dsh-whale-widget 0.2.9 → 0.3.0

package/lib/index.js

@@ -1,52 +1,397 @@
 import fs from 'node:fs'
 import os from 'node:os'
 import path from 'node:path'
+import dns from 'node:dns'
 import { fileURLToPath } from 'node:url'
 
+// Node 的 fetch(undici) 可能优先 IPv6：个别域名(如 open.bigmodel.cn)有 AAAA 记录但本机 IPv6 不通，
+// 会直接报 "fetch failed"（curl 会自动回退 IPv4，所以看起来正常）。统一改为 IPv4 优先。
+try { dns.setDefaultResultOrder('ipv4first') } catch (err) {}
+
 // Package root: lib/index.js -> package root. Keeps the bundle relocatable
 // when installed as a normal DSH npm plugin (node_modules or a local link).
 const PACKAGE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..')
 
-// DSH home: used for the widget size/usage memory files, since node_modules may
+// DSH home: used for the widget memory/role/audio files, since node_modules may
 // be read-only or cleaned on update.
 const DSH_HOME = process.env.DSH_HOME || path.join(os.homedir(), '.dsh')
 
-// Whale image: package-relative first, legacy absolute paths as fallback.
+// Whale image: package-relative first (ship DSniang1/DSniang02.png in assets/),
+// legacy absolute paths as fallback.
 const IMAGE_CANDIDATES = [
   path.join(PACKAGE_ROOT, 'assets', 'DSniang1.png'),
   path.join(PACKAGE_ROOT, 'assets', 'DSniang02.png'),
-  'D:/TestBox/deepseek/DSniang1.png',
-  'D:/TestBox/deepseek/DSniang02.png',
-  'D:/TestBox/deepseek/skin/DSniang02.png',
 ]
+// 自定义角色图片存放目录（第一个可写的会被使用；roles.json 存角色元数据）
+const ROLE_DIR_CANDIDATES = [
+  path.join(DSH_HOME, 'whale-roles'),
+  path.join(DSH_HOME, 'profiles', 'web', 'whale-roles'),
+]
+const ROLE_INDEX_NAME = 'roles.json'
+const ROLE_DEFAULT_ID = 'default'
+// 自定义音频片段存放目录（每个片段一个 <id>.wav + audio.json 索引）
+const AUDIO_DIR_CANDIDATES = [
+  path.join(DSH_HOME, 'whale-audio'),
+  path.join(DSH_HOME, 'profiles', 'web', 'whale-audio'),
+]
+const AUDIO_INDEX_NAME = 'audio.json'
+// 内置预设音效组（不可删、不可改），对应 assets 里的 Ya/D 系列
+const PRESET_GROUPS = {
+  duck: { id: 'duck', name: '小黄鸭', press: 'ya1', release: 'ya2', preset: true },
+  fx1: { id: 'fx1', name: '音效1', press: 'd1', release: 'd2', preset: true },
+}
+// 内置预设片段（不可删）：传统 4 个映射到 SOUND_SETS 的 mp3，exp_orb / end_a 映射到随包发布的 wav。
+// mime 必须与文件字节一致（音频路由按它下发 Content-Type，不匹配会导致解码/听感异常）。
+const PRESET_FRAGMENTS = {
+  ya1: { id: 'ya1', name: '小黄鸭·按下', preset: true, mime: 'audio/mpeg' },
+  ya2: { id: 'ya2', name: '小黄鸭·松开', preset: true, mime: 'audio/mpeg' },
+  d1: { id: 'd1', name: '音效1·按下', preset: true, mime: 'audio/mpeg' },
+  d2: { id: 'd2', name: '音效1·松开', preset: true, mime: 'audio/mpeg' },
+  // 任务结束音的内置默认音效(随包资源,用户库缺失时回退内置文件)
+  exp_orb: { id: 'exp_orb', name: 'Minecraft·经验球', preset: true, mime: 'audio/wav' },
+  // 任务结束音 A(随包资源):原为用户音效库里的自导入片段，现作为内置预设随包发布。
+  // 显示名与用户库里同名片段一致时，前端下拉按显示名去重（内置与前端的同名条目只出现一条）。
+  end_a: { id: 'end_a', name: 'A', preset: true, mime: 'audio/wav' },
+}
+// 内置片段的音频文件：包内 assets 优先，开发环境回退到 skin 目录
+const BUILTIN_FRAGMENT_FILES = {
+  exp_orb: [
+    path.join(PACKAGE_ROOT, 'assets', 'minecraft-exp-orb.wav'),
+  ],
+  // 任务结束音 A：随包发布 assets/task-end-a.wav（1.81s / 48kHz / 立体声 / 16bit PCM）
+  end_a: [
+    path.join(PACKAGE_ROOT, 'assets', 'task-end-a.wav'),
+  ],
+}
+// —— 自定义 API 模型（v655）：非 DeepSeek 厂商的余额 / 用量 / 提醒 ——
+// 注册表落在 $DSH_HOME/.dshw-api.json；密钥走 DSH 官方凭据（ctx.credentials），本文件不存明文。
+const API_FILE_CANDIDATES = [
+  path.join(DSH_HOME, '.dshw-api.json'),
+  path.join(DSH_HOME, 'profiles', 'web', '.dshw-api.json'),
+]
+const API_BUILTIN_ID = 'deepseek'
+// 内置厂商模板：balance 描述「怎么取余额」。json 路径支持 a.b[0].c；scale 为取值后的乘数。
+// 余额接口已按官方文档 / 社区参考核对（DeepSeek、OpenRouter、Kimi、阶跃、Novita、OpenAI 兼容中转站）；
+// 硅基流动的余额接口已官方下线（410），故改为「无余额接口 + /v1/models 探活」；
+// 火山方舟同理（余额/用量属火山引擎 AK/SK 签名的 OpenAPI）。其余厂商可选用 custom 手填 URL 与字段路径。
+// 厂商模板下拉的排序键（v726）：英文名直接用；中文名取首字的拼音，让中英文按 A→Z **混排**。
+// 为什么不用 localeCompare：ICU 默认把汉字排到拉丁字母之后，中文厂商会被整段甩到列表末尾。
+// 新增中文厂商时在下面补一行（键 = 厂商名首字）。
+const TPL_PINYIN_INITIAL = { 阿: 'a', 百: 'bai', 本: 'ben', 硅: 'gui', 火: 'huo', 阶: 'jie', 魔: 'mo', 腾: 'teng', 讯: 'xun', 智: 'zhi', 自: 'zi' }
+function tplSortKey(name) {
+  const s = String(name || '').trim()
+  if (!s) return ''
+  const py = TPL_PINYIN_INITIAL[s.slice(0, 1)]
+  return py || s.toLowerCase()
+}
+const API_TEMPLATES = {
+  deepseek: {
+    name: 'DeepSeek', currency: 'CNY', keyRef: 'DEEPSEEK_API_KEY', builtin: true,
+    balance: { url: 'https://api.deepseek.com/user/balance', auth: 'Bearer {key}', json: { remaining: 'balance_infos[0].total_balance' } },
+  },
+  openrouter: {
+    name: 'OpenRouter', currency: 'USD', keyRef: 'OPENROUTER_API_KEY',
+    balance: { url: 'https://openrouter.ai/api/v1/credits', auth: 'Bearer {key}', json: { total: 'data.total_credits', used: 'data.total_usage' } },
+  },
+  siliconflow_cn: {
+    name: '硅基流动（CN）', currency: 'CNY', keyRef: 'SILICONFLOW_API_KEY', noBalanceApi: true,
+    // ⚠️ 官方已下线余额接口（不是"暂时故障"）——2026-08-11 更新公告《【接口服务调整】/user/info 接口将停止服务》：
+    //   「/user/info 已无法适配平台用户账户体系，该 API 将于 2026-08-14 正式停止服务，届时接口将不再可用」，
+    //   并称「后续将适时提供账户层面的替代 API，新接口上线后将在本页面另行通知」。
+    //   截至 2026-09-14，公告页最新条目（2026.09.09）**仍未见替代 API**；CN 文档「平台系列」也只剩「获取用户模型列表」。
+    //   v724 路由实测：/v1 下未知路径 404、而 /v1/user/info 仍返 401（鉴权层）→ 路由没被摘掉，但按公告已不可用。
+    //   → 日后官方恢复或上线替代接口：把 url 与 json 字段路径填回来即可（模板只是默认值，用户可覆盖）。
+    apiNote: '官方已下线 /user/info 余额接口（2026-08-14 起停止服务；公告称后续会提供替代 API，暂未上线）→ 余额显示「—」，今日已用按会话事件估算；「测试连通性」用 /v1/models 验证 key',
+    matchIds: ['siliconflow', 'Qwen', 'deepseek-ai'],
+    balance: { url: '', auth: 'Bearer {key}', json: { remaining: '' } },
+    probeUrl: 'https://api.siliconflow.cn/v1/models',
+  },
+  siliconflow_en: {
+    name: '硅基流动（EN）', currency: 'USD', keyRef: 'SILICONFLOW_API_KEY', noBalanceApi: true,
+    // 同国内站：余额接口已停止服务。注意国际站文档 docs.siliconflow.com 至今仍挂着 Retrieve user info 页
+    //（文档未同步），不能据此认为接口可用 —— 以国内官方公告为准。
+    apiNote: '同国内站：/user/info 余额接口已停止服务（国际站文档尚未同步）→ 余额「—」，今日已用按会话事件估算',
+    matchIds: ['siliconflow', 'Qwen', 'deepseek-ai'],
+    balance: { url: '', auth: 'Bearer {key}', json: { remaining: '' } },
+    probeUrl: 'https://api.siliconflow.com/v1/models',
+  },
+  moonshot: {
+    // 大陆站：api.moonshot.cn，余额为人民币（充值 + 代金券合计）。v724 实测：200 且字段命中 ✓
+    name: 'Kimi / Moonshot（CN）', currency: 'CNY', keyRef: 'MOONSHOT_API_KEY', matchIds: ['moonshot', 'kimi'],
+    balance: { url: 'https://api.moonshot.cn/v1/users/me/balance', auth: 'Bearer {key}', json: { remaining: 'data.available_balance' } },
+    probeUrl: 'https://api.moonshot.cn/v1/models',
+  },
+  moonshot_intl: {
+    // 国际站是独立账号体系（key 不通用），余额按美元计
+    name: 'Kimi / Moonshot（国际）', currency: 'USD', keyRef: 'MOONSHOT_INTL_API_KEY',
+    balance: { url: 'https://api.moonshot.ai/v1/users/me/balance', auth: 'Bearer {key}', json: { remaining: 'data.available_balance' } },
+    probeUrl: 'https://api.moonshot.ai/v1/models',
+  },
+  stepfun: {
+    name: '阶跃星辰 StepFun', currency: 'CNY', keyRef: 'STEPFUN_API_KEY', matchIds: ['stepfun', 'step-'],
+    balance: { url: 'https://api.stepfun.com/v1/accounts', auth: 'Bearer {key}', json: { remaining: 'balance' } },
+  },
+  novita: {
+    name: 'Novita AI', currency: 'USD', keyRef: 'NOVITA_API_KEY', matchIds: ['novita'],
+    balance: { url: 'https://api.novita.ai/v3/user/balance', auth: 'Bearer {key}', json: { remaining: 'availableBalance', scale: 0.0001 } },
+  },
+  volcengine_ark: {
+    name: '火山方舟 Ark', currency: 'CNY', keyRef: 'ARK_API_KEY', noBalanceApi: true,
+    // 方舟没有「用 API key 查余额」的接口（余额/用量属于火山引擎 AK/SK 签名的 OpenAPI）。
+    // v724 实测：/api/v3/models → 200（探活可用）；/api/v3/balance → 404（无余额接口，确认）。
+    apiNote: '余额/用量需火山引擎 AK/SK 签名的 OpenAPI（或控制台）→ 余额「—」，今日已用按会话事件估算；探活用 /api/v3/models（实测可用）',
+    matchIds: ['doubao', 'ep-'],
+    balance: { url: '', auth: 'Bearer {key}', json: { remaining: '' } },
+    probeUrl: 'https://ark.cn-beijing.volces.com/api/v3/models',
+  },
+  // —— 订阅额度（Coding Plan）模板：kind='quota'，语义是"窗口用量% + 重置时间"，不是钱 ——
+  // 注意：这些接口只对「订阅套餐」账号有效。买 Token 包（资源包）的账号查不到额度
+  // （智谱会返回「当前用户不存在coding plan」），那种情况用模型菜单里的
+  // 「额度（订阅/资源包）」按会话 token 自动统计。
+  zhipu_glm_coding: {
+    name: '智谱 GLM Coding Plan（订阅）', currency: 'CNY', keyRef: 'ZHIPU_API_KEY', kind: 'quota',
+    quota: {
+      url: 'https://open.bigmodel.cn/api/monitor/usage/quota/limit',
+      auth: '{key}', // 智谱此接口不带 Bearer
+      json: { percent: 'data.limits[0].TOKENS_LIMIT.percentage', resetAt: 'data.limits[0].nextResetTime', level: 'data.level' },
+    },
+    probeUrl: 'https://open.bigmodel.cn/api/monitor/usage/quota/limit',
+  },
+  kimi_coding: {
+    name: 'Kimi Coding（订阅）', currency: 'CNY', keyRef: 'KIMI_CODING_KEY', kind: 'quota',
+    quota: {
+      url: 'https://api.kimi.com/coding/v1/usages',
+      auth: 'Bearer {key}',
+      json: { remain: 'usage.remaining', total: 'usage.limit', resetAt: 'usage.resetTime' },
+    },
+    probeUrl: 'https://api.kimi.com/coding/v1/usages',
+  },
+  minimax_coding: {
+    name: 'MiniMax Coding（订阅）', currency: 'CNY', keyRef: 'MINIMAX_API_KEY', kind: 'quota',
+    quota: {
+      url: 'https://api.minimaxi.com/v1/api/openplatform/coding_plan/remains',
+      auth: 'Bearer {key}',
+      json: {
+        remainPct: 'model_remains[0].current_interval_remaining_percent',
+        weeklyRemainPct: 'model_remains[0].current_weekly_remaining_percent',
+        resetAtMs: 'model_remains[0].end_time',
+      },
+    },
+    probeUrl: 'https://api.minimaxi.com/v1/api/openplatform/coding_plan/remains',
+  },
+  openai_compat: {
+    name: 'OpenAI 兼容中转站', currency: 'USD', keyRef: 'CUSTOM_API_KEY', needsBaseUrl: true,
+    // OneAPI / New API 一类网关的经典账单接口：额度(美元) + 已用(美分)
+    balance: {
+      url: '{base}/v1/dashboard/billing/subscription', auth: 'Bearer {key}', json: { total: 'hard_limit_usd' },
+      usage: { url: '{base}/v1/dashboard/billing/usage', auth: 'Bearer {key}', json: { used: 'total_usage', scale: 0.01 } },
+    },
+  },
+  custom: {
+    name: '自定义 HTTP', currency: 'CNY', keyRef: 'CUSTOM_API_KEY',
+    balance: { url: '', auth: 'Bearer {key}', json: { remaining: '' } },
+  },
+  // —— Codex 模式（第一期：本地会话统计）——
+  // 不查余额、不联网、不用凭据：直接读 ~/.codex/sessions 的 rollout-*.jsonl 统计 token。
+  // 好处：能覆盖「不在 DSH 里跑」的 Codex 使用；坏处：只有 token，没有金额（费用另由余额/额度口径处理）。
+  codex: {
+    name: 'Codex（本地会话）', currency: 'CNY', keyRef: '', kind: 'codex',
+    balance: { url: '', auth: '', json: { remaining: '' } },
+  },
+  // ================= v724：补齐「官方没有用 API key 查余额的接口」的常用厂商 =================
+  // 作用：① 选完自动填好 凭据名 / 币种 / 事件匹配(matchIds) / 探活地址 ②「测试连通性」可验证 key
+  // ③ 余额显示「—」，今日已用按本机会话事件估算（noBalanceApi + apiNote 会显示在面板提示里）。
+  // 说明：probeUrl 一律用各家的 OpenAI 兼容 /v1/models（官方文档形态，能否通过取决于 key 权限）。
+  openai: {
+    name: 'OpenAI', currency: 'USD', keyRef: 'OPENAI_API_KEY', noBalanceApi: true,
+    apiNote: '官方已下线 billing 余额接口，没有「用 API key 查余额」的公开接口（只能看控制台）→ 余额「—」，今日已用按会话事件估算',
+    matchIds: ['gpt', 'o1-', 'o3-', 'o4-', 'chatgpt'],
+    probeUrl: 'https://api.openai.com/v1/models',
+    balance: { url: '', auth: 'Bearer {key}', json: { remaining: '' } },
+  },
+  anthropic: {
+    name: 'Anthropic Claude', currency: 'USD', keyRef: 'ANTHROPIC_API_KEY', noBalanceApi: true,
+    apiNote: '官方无余额接口；用量要走 Admin API（需 admin key）或控制台。注意其探活需要 x-api-key + anthropic-version 两个请求头，本挂件暂不支持 → 不提供探活',
+    matchIds: ['claude'],
+    balance: { url: '', auth: 'Bearer {key}', json: { remaining: '' } },
+  },
+  gemini: {
+    name: 'Google Gemini', currency: 'USD', keyRef: 'GEMINI_API_KEY', noBalanceApi: true,
+    apiNote: '官方无余额接口（配额只在 AI Studio / Cloud 控制台）→ 余额「—」，今日已用按会话事件估算；探活用 ?key= 形式',
+    matchIds: ['gemini'],
+    probeUrl: 'https://generativelanguage.googleapis.com/v1beta/models?key={key}',
+    balance: { url: '', auth: '', json: { remaining: '' } },
+  },
+  xai: {
+    name: 'xAI Grok', currency: 'USD', keyRef: 'XAI_API_KEY', noBalanceApi: true,
+    apiNote: '官方无公开的余额查询接口（额度在 console.x.ai）→ 余额「—」，今日已用按会话事件估算',
+    matchIds: ['grok'],
+    probeUrl: 'https://api.x.ai/v1/models',
+    balance: { url: '', auth: 'Bearer {key}', json: { remaining: '' } },
+  },
+  groq: {
+    name: 'Groq', currency: 'USD', keyRef: 'GROQ_API_KEY', noBalanceApi: true,
+    apiNote: '官方无余额接口（免费额度/速率在控制台看）→ 余额「—」，今日已用按会话事件估算',
+    matchIds: ['llama', 'mixtral', 'qwen', 'deepseek', 'gemma', 'whisper'],
+    probeUrl: 'https://api.groq.com/openai/v1/models',
+    balance: { url: '', auth: 'Bearer {key}', json: { remaining: '' } },
+  },
+  mistral: {
+    name: 'Mistral AI', currency: 'USD', keyRef: 'MISTRAL_API_KEY', noBalanceApi: true,
+    apiNote: '官方无余额接口 → 余额「—」，今日已用按会话事件估算',
+    matchIds: ['mistral', 'codestral', 'magistral', 'pixtral', 'ministral'],
+    probeUrl: 'https://api.mistral.ai/v1/models',
+    balance: { url: '', auth: 'Bearer {key}', json: { remaining: '' } },
+  },
+  together: {
+    name: 'Together AI', currency: 'USD', keyRef: 'TOGETHER_API_KEY', noBalanceApi: true,
+    apiNote: '官方无余额接口 → 余额「—」，今日已用按会话事件估算',
+    matchIds: ['meta-llama', 'Qwen', 'deepseek', 'mistralai', 'nvidia'],
+    probeUrl: 'https://api.together.xyz/v1/models',
+    balance: { url: '', auth: 'Bearer {key}', json: { remaining: '' } },
+  },
+  fireworks: {
+    name: 'Fireworks AI', currency: 'USD', keyRef: 'FIREWORKS_API_KEY', noBalanceApi: true,
+    apiNote: '官方无余额接口 → 余额「—」，今日已用按会话事件估算',
+    matchIds: ['accounts/fireworks', 'llama-v3', 'qwen'],
+    probeUrl: 'https://api.fireworks.ai/inference/v1/models',
+    balance: { url: '', auth: 'Bearer {key}', json: { remaining: '' } },
+  },
+  deepinfra: {
+    name: 'DeepInfra', currency: 'USD', keyRef: 'DEEPINFRA_API_KEY', noBalanceApi: true,
+    apiNote: '官方无余额接口 → 余额「—」，今日已用按会话事件估算',
+    matchIds: ['meta-llama', 'Qwen', 'deepseek'],
+    probeUrl: 'https://api.deepinfra.com/v1/openai/models',
+    balance: { url: '', auth: 'Bearer {key}', json: { remaining: '' } },
+  },
+  cerebras: {
+    name: 'Cerebras', currency: 'USD', keyRef: 'CEREBRAS_API_KEY', noBalanceApi: true,
+    apiNote: '官方无余额接口 → 余额「—」，今日已用按会话事件估算',
+    matchIds: ['llama', 'qwen'],
+    probeUrl: 'https://api.cerebras.ai/v1/models',
+    balance: { url: '', auth: 'Bearer {key}', json: { remaining: '' } },
+  },
+  dashscope: {
+    name: '阿里云百炼（通义千问）', currency: 'CNY', keyRef: 'DASHSCOPE_API_KEY', noBalanceApi: true,
+    apiNote: '云厂商：余额/账单要走阿里云 AK/SK 的 OpenAPI（或控制台），API key 查不到 → 余额「—」，今日已用按会话事件估算',
+    matchIds: ['qwen', 'qwq', 'qvq'],
+    probeUrl: 'https://dashscope.aliyuncs.com/compatible-mode/v1/models',
+    balance: { url: '', auth: 'Bearer {key}', json: { remaining: '' } },
+  },
+  qianfan: {
+    name: '百度千帆（文心）', currency: 'CNY', keyRef: 'QIANFAN_API_KEY', noBalanceApi: true,
+    apiNote: '云厂商：余额/账单要走百度云 AK/SK（或控制台），API key 查不到 → 余额「—」，今日已用按会话事件估算',
+    matchIds: ['ernie'],
+    probeUrl: 'https://qianfan.baidubce.com/v2/models',
+    balance: { url: '', auth: 'Bearer {key}', json: { remaining: '' } },
+  },
+  hunyuan: {
+    name: '腾讯混元', currency: 'CNY', keyRef: 'HUNYUAN_API_KEY', noBalanceApi: true,
+    apiNote: '云厂商：余额/账单要走腾讯云 SecretId/Key（或控制台），API key 查不到 → 余额「—」，今日已用按会话事件估算',
+    matchIds: ['hunyuan'],
+    probeUrl: 'https://api.hunyuan.cloud.tencent.com/v1/models',
+    balance: { url: '', auth: 'Bearer {key}', json: { remaining: '' } },
+  },
+  spark: {
+    name: '讯飞星火', currency: 'CNY', keyRef: 'SPARK_API_KEY', noBalanceApi: true,
+    apiNote: '官方无余额接口（额度在控制台）→ 余额「—」，今日已用按会话事件估算',
+    matchIds: ['spark', 'generalv', '4.0ultra'],
+    probeUrl: 'https://spark-api-open.xf-yun.com/v1/models',
+    balance: { url: '', auth: 'Bearer {key}', json: { remaining: '' } },
+  },
+  modelscope: {
+    name: '魔搭 ModelScope', currency: 'CNY', keyRef: 'MODELSCOPE_API_KEY', noBalanceApi: true,
+    apiNote: '官方无余额接口 → 余额「—」，今日已用按会话事件估算',
+    matchIds: ['Qwen', 'deepseek', 'MiniMax', 'glm'],
+    probeUrl: 'https://api-inference.modelscope.cn/v1/models',
+    balance: { url: '', auth: 'Bearer {key}', json: { remaining: '' } },
+  },
+  ollama: {
+    name: '本地模型（Ollama / LM Studio）', currency: 'CNY', keyRef: '', noBalanceApi: true, needsBaseUrl: true,
+    apiNote: '本地推理没有余额概念 → 余额「—」；填好 Base URL（如 http://127.0.0.1:11434/v1）后按会话事件统计 token',
+    matchIds: ['llama', 'qwen', 'gemma', 'deepseek', 'mistral', 'phi'],
+    probeUrl: '{base}/v1/models',
+    balance: { url: '', auth: '', json: { remaining: '' } },
+  },
+  zhipu_glm_coding_intl: {
+    name: '智谱 GLM Coding Plan（国际 z.ai）', currency: 'USD', keyRef: 'ZHIPU_INTL_API_KEY', kind: 'quota',
+    quota: {
+      url: 'https://api.z.ai/api/monitor/usage/quota/limit',
+      auth: '{key}', // 与国内站一样不带 Bearer
+      json: { percent: 'data.limits[0].TOKENS_LIMIT.percentage', resetAt: 'data.limits[0].nextResetTime', level: 'data.level' },
+    },
+    probeUrl: 'https://api.z.ai/api/monitor/usage/quota/limit',
+  },
+  minimax_coding_intl: {
+    name: 'MiniMax Coding（国际）', currency: 'USD', keyRef: 'MINIMAX_INTL_API_KEY', kind: 'quota',
+    quota: {
+      url: 'https://api.minimax.io/v1/api/openplatform/coding_plan/remains',
+      auth: 'Bearer {key}',
+      json: {
+        remainPct: 'model_remains[0].current_interval_remaining_percent',
+        weeklyRemainPct: 'model_remains[0].current_weekly_remaining_percent',
+        resetAtMs: 'model_remains[0].end_time',
+      },
+    },
+    probeUrl: 'https://api.minimax.io/v1/api/openplatform/coding_plan/remains',
+  },
+}
 
 // Size memory file: prefer writable DSH home locations, then legacy fallbacks.
 const SIZE_FILE_CANDIDATES = [
   path.join(DSH_HOME, '.dshw-size.json'),
   path.join(DSH_HOME, 'profiles', 'web', '.dshw-size.json'),
-  'D:/TestBox/deepseek/.dshw-size.json',
-  'D:/TestBox/deepseek/skin/.dshw-size.json',
 ]
-
 // Usage ledger file (小鲸鱼记账 mode): same policy as the size file.
 const USAGE_FILE_CANDIDATES = [
   path.join(DSH_HOME, '.dshw-usage.json'),
   path.join(DSH_HOME, 'profiles', 'web', '.dshw-usage.json'),
-  'D:/TestBox/deepseek/.dshw-usage.json',
-  'D:/TestBox/deepseek/skin/.dshw-usage.json',
 ]
-
-// Sound assets: package-relative first (ship Ya1/Ya2/D1/D2.mp3 in assets/ for
-// sounds out of the box), legacy paths as fallback.
+// 每轮消耗 seq 持久化文件：避免插件热重载后 seq 归零导致页面把新轮次误判为旧轮次吞掉
+const TURN_FILE_CANDIDATES = [
+  path.join(DSH_HOME, '.dshw-turn.json'),
+  path.join(DSH_HOME, 'profiles', 'web', '.dshw-turn.json'),
+]
+// Sound assets: package-relative first (ship Ya1/Ya2/D1/D2.mp3 in assets/),
+// legacy absolute paths as fallback.
+const BUBBLE_FILE_CANDIDATES = [
+  // v728：发布版会删掉开发机路径（§9.4），所以这里必须有 $DSH_HOME 兜底 ——
+  // 否则清完这个数组会变成空的：泡泡配置读不了也存不了（自定义泡泡整体失效）。
+  path.join(DSH_HOME, '.dshw-bubble.json'),
+  path.join(DSH_HOME, 'profiles', 'web', '.dshw-bubble.json'),
+]
+// 泡泡图库(独立于角色图库):图片文件目录 + 索引
+const BUBBLE_IMG_DIR_CANDIDATES = [
+  // v728：同理必须有 $DSH_HOME 兜底 —— pickBubbleImgDir() 遍历失败还会取 [0]，
+  // 空数组会让图库上传直接报错。
+  path.join(DSH_HOME, 'whale-bubble-imgs'),
+  path.join(DSH_HOME, 'profiles', 'web', 'whale-bubble-imgs'),
+]
+const BUBBLE_IMG_INDEX_NAME = 'bubble-imgs.json'
+// 内置默认泡泡图(语义 id → assets 文件):面板常驻可选;全新安装无用户图库时
+// bubble-img.png 从内置清单回退加载。文件同时位于 package assets/ 与开发回退目录。
+const DEFAULT_BUBBLE_IMGS = [
+  { id: 'bimg_petpet', name: 'petpet', file: 'bubble-petpet.gif', format: 'gif' },
+  { id: 'bimg_money1', name: 'money1', file: 'bubble-money1.gif', format: 'gif' },
+]
+function bubbleImgFileCandidates(file) {
+  return [
+    path.join(PACKAGE_ROOT, 'assets', file),
+  ]
+}
+function loadBuiltinBubbleImgBytes(def) {
+  if (!def || !def.file) return null
+  for (const p of bubbleImgFileCandidates(def.file)) {
+    try {
+      const bytes = fs.readFileSync(p)
+      if (bytes && bytes.length > 0) return bytes
+    } catch (err) {}
+  }
+  return null
+}
 const SOUND_SETS = {
-  duck: {
-    press: [path.join(PACKAGE_ROOT, 'assets', 'Ya1.mp3'), 'D:/TestBox/deepseek/skin/Ya1.mp3'],
-    release: [path.join(PACKAGE_ROOT, 'assets', 'Ya2.mp3'), 'D:/TestBox/deepseek/skin/Ya2.mp3'],
-  },
-  fx1: {
-    press: [path.join(PACKAGE_ROOT, 'assets', 'D1.mp3'), 'D:/TestBox/deepseek/skin/D1.mp3'],
-    release: [path.join(PACKAGE_ROOT, 'assets', 'D2.mp3'), 'D:/TestBox/deepseek/skin/D2.mp3'],
-  },
+  duck: { press: [path.join(PACKAGE_ROOT, 'assets', 'Ya1.mp3')], release: [path.join(PACKAGE_ROOT, 'assets', 'Ya2.mp3')] },
+  fx1: { press: [path.join(PACKAGE_ROOT, 'assets', 'D1.mp3')], release: [path.join(PACKAGE_ROOT, 'assets', 'D2.mp3')] },
 }
 function soundSetFromUrl(url) {
   try {
@@ -59,29 +404,47 @@ const BALANCE_URL = 'https://api.deepseek.com/user/balance'
 const BALANCE_TTL_MS = 25000
 const RUA_GIF_CANDIDATES = [
   path.join(PACKAGE_ROOT, 'assets', 'rua.gif'),
-  'D:/TestBox/deepseek/skin/rua.gif',
-  'D:/TestBox/deepseek/rua.gif',
 ]
 // DeepSeek CNY prices per million tokens: [空闲时段价, 高峰时段价].
 // 高峰时段：工作日 9:00–12:00 和 14:00–18:00（北京时间）；2026-08-23 起周末全天谷价。
-// Adjust here if DeepSeek changes pricing.
+// 价格来源：官方 https://api-docs.deepseek.com/zh-cn/quick_start/pricing
+// 2026-09-10 起 Flash 系列降价：缓存命中 0.05→0.02、未命中 1.5→1、输出 4.5→4（高峰=空闲×2）。
+// 2026-09-14 复核：价格数字与上表一致,无需改动。
 const PEAK_HOURS = [
   [9, 12],
   [14, 18],
 ]
-const BASE_PRICE = { hit: [0.05, 0.1], miss: [1.5, 3.0], out: [4.5, 9.0] }
-// deepseek-v4-pro 为 flash 的 3 倍价（官方 2026-08-17 生效）；vision-exp 与 flash 同价
+// Flash（正式模型名 deepseek-flash = DeepSeek-V4.1-Flash）
+const BASE_PRICE = { hit: [0.02, 0.04], miss: [1, 2], out: [4, 8] }
+// Pro 为 Flash 的 3 倍价（官方 2026-08-17 生效）。官方 2026-09-14 公告：V4 Pro 继续提供 API 服务、
+// 计费方式保持不变——此前"9/14 12:00 起 pro 请求路由到 V4.1 Flash 并按 Flash 价计费"的安排已取消，
+// 因此这里不做按日期的降级切换。
 const PRO_PRICE = { hit: [0.15, 0.3], miss: [4.5, 9.0], out: [13.5, 27.0] }
 const PRICING = {
-  'deepseek-v4-flash-vision-exp': BASE_PRICE,
-  'deepseek-v4-flash': BASE_PRICE,
+  'deepseek-flash': BASE_PRICE,
+  'deepseek-v4-flash-vision-exp': BASE_PRICE, // 旧名已下线,请求由 V4.1-Flash 提供,按 Flash 价计费
+  'deepseek-v4-flash': BASE_PRICE, // 同上
   'deepseek-v4-pro': PRO_PRICE,
-  'deepseek-chat': BASE_PRICE,
-  'deepseek-reasoner': BASE_PRICE,
   _default: BASE_PRICE,
 }
+// 用户自定义单价（自定义 API 模型面板里填的「元/百万 token」），按 matchIds 子串匹配，优先于内置价目表
+let CUSTOM_PRICES = {}
+// 自定义单价的币种/汇率（与 CUSTOM_PRICES 同键）：单价若按美元填写，记账时按用户填的汇率换算成人民币
+let CUSTOM_PRICE_META = {}
+function customPriceMetaFor(model) {
+  const m = String(model || '').toLowerCase()
+  // 按键长降序：最长命中优先，避免短关键字（如 pro）误伤别的模型
+  for (const key of Object.keys(CUSTOM_PRICE_META).sort((a, b) => b.length - a.length)) {
+    if (key && m.indexOf(key) !== -1) return CUSTOM_PRICE_META[key]
+  }
+  return null
+}
 function priceFor(model) {
   const m = String(model || '').toLowerCase()
+  // 自定义单价同样按键长降序匹配（与 customPriceMetaFor 保持一致）
+  for (const key of Object.keys(CUSTOM_PRICES).sort((a, b) => b.length - a.length)) {
+    if (key && m.indexOf(key) !== -1) return CUSTOM_PRICES[key]
+  }
   for (const key of Object.keys(PRICING)) {
     if (key === '_default') continue
     if (m.indexOf(key) !== -1) return PRICING[key]
@@ -113,1327 +476,114 @@ const JSON_HEADERS = {
   'Cache-Control': 'no-store',
 }
 
-const WIDGET_JS = `(function () {
-if (window.__dshWhaleWidget) return
-window.__dshWhaleWidget = true
-
-var MIN_SCALE = 0.6
-var MAX_SCALE = 2.5
-var STEP = 0.1
-var CLICK_SQ = 9
-var REFRESH_MS = 60000
-var CHANGE_MS = 900
-var ANIM_MS = 700
-var BUBBLE_MS = 5000
-var FETCH_TIMEOUT_MS = 25000
-var BALANCE_URL = '/dsh-whale/balance.json'
-var SIZE_URL = '/dsh-whale/size.json'
-var IMG_URL = '/dsh-whale/image.png?v=2'
-var GIF_URL = '/dsh-whale/rua.gif'
-
-var css = [
-  '.dshwv-root{position:fixed;right:0;bottom:0;--dshw-scale:1;--dshw-base:clamp(122px,calc(min(250px,min(100vw,100vh) * 0.28) * var(--dshw-scale)),625px);width:var(--dshw-base);height:var(--dshw-base);pointer-events:none;user-select:none;-webkit-user-select:none;z-index:9999;font-family:inherit;transition:left .16s ease,top .16s ease,transform .3s ease}',
-  '.dshwv-root.dshwv-left{transform:scaleX(-1)}',
-  '.dshwv-root.dshwv-dragging{cursor:grabbing;transition:none}',
-  '.dshwv-body{position:absolute;left:0;top:0;width:100%;height:100%;transform-origin:50% 100%;transition:transform .22s cubic-bezier(.34,1.56,.64,1)}',
-  '.dshwv-img{position:absolute;right:0;bottom:0;width:59.45%;height:59.45%;display:block;pointer-events:none;-webkit-user-drag:none;user-select:none}',
-  '.dshwv-bubble{position:absolute;left:0;top:0;width:100%;aspect-ratio:1026/700;pointer-events:none;z-index:1;--dshw-u:calc(var(--dshw-base) / 1026)}',
-  '.dshwv-bubble svg{display:block;width:100%;height:100%;pointer-events:none}',
-  '.dshwv-bubble svg path,.dshwv-bubble svg ellipse{pointer-events:none;cursor:pointer}',
-  '.dshwv-bubble.dshwv-bubble-open svg path,.dshwv-bubble.dshwv-bubble-open svg ellipse{pointer-events:visiblePainted}',
-  '.dshwv-bubble .dshwv-bshape,.dshwv-bubble .dshwv-b1,.dshwv-bubble .dshwv-b2{opacity:0;transform:scale(.7);transform-box:fill-box;transform-origin:50% 50%;transition:opacity .2s ease,transform .2s ease}',
-  '.dshwv-bubble.dshwv-bubble-open .dshwv-bshape,.dshwv-bubble.dshwv-bubble-open .dshwv-b1,.dshwv-bubble.dshwv-bubble-open .dshwv-b2{opacity:1;transform:none}',
-  '.dshwv-gif{position:absolute;left:44.25%;top:38%;transform:translate(-50%,-50%);max-width:calc(var(--dshw-u) * 560);max-height:calc(var(--dshw-u) * 400);display:none;opacity:0;transition:opacity .2s ease;pointer-events:none;-webkit-user-drag:none;user-select:none;object-fit:contain}',
-  '.dshwv-root.dshwv-left .dshwv-gif{transform:translate(-50%,-50%) scaleX(-1)}',
-  '.dshwv-bubble.dshwv-bubble-open .dshwv-gif{opacity:1}',
-  '.dshwv-bubble.dshwv-bubble-open .dshwv-b2{transition-delay:0s}',
-  '.dshwv-bubble.dshwv-bubble-open .dshwv-b1{transition-delay:.13s}',
-  '.dshwv-bubble.dshwv-bubble-open .dshwv-bshape{transition-delay:.26s}',
-  '.dshwv-bubble .dshwv-bshape{transition-delay:.1s}',
-  '.dshwv-bubble .dshwv-b1{transition-delay:.2s}',
-  '.dshwv-bubble .dshwv-b2{transition-delay:.3s}',
-  '.dshwv-text{position:absolute;left:44.25%;top:38%;transform:translate(-50%,-50%);text-align:center;color:#536ba9;line-height:1.15;white-space:nowrap;pointer-events:none;opacity:0;transition:opacity .16s ease,transform .3s ease}',
-  '.dshwv-bubble.dshwv-bubble-open .dshwv-text{opacity:1;transition:opacity .16s ease .36s,transform .3s ease}',
-  '.dshwv-root.dshwv-left .dshwv-text{transform:translate(-50%,-50%) scaleX(-1)}',
-  '.dshwv-label{font-size:calc(var(--dshw-u) * 66);font-weight:600;letter-spacing:.06em}',
-  '.dshwv-amount{font-size:calc(var(--dshw-u) * 128);font-weight:800;line-height:1.05}',
-  '.dshwv-period{font-size:calc(var(--dshw-u) * 104);font-weight:800;line-height:1.05}',
-  '.dshwv-wrap{white-space:normal;max-width:calc(var(--dshw-u) * 560);line-height:1.2}',
-  '.dshwv-hint{font-size:calc(var(--dshw-u) * 56);color:#9fb0d9;letter-spacing:.02em;margin-top:calc(var(--dshw-u) * 9);min-height:calc(var(--dshw-u) * 64);line-height:1.15}',
-  '.dshwv-menu-btn{position:absolute;top:calc(40.55% + 4px);right:4px;width:26px;height:26px;border:none;border-radius:6px;background:rgba(32,49,112,.85);cursor:pointer;pointer-events:auto;display:flex;flex-direction:column;align-items:center;justify-content:center;gap:4px;padding:0;z-index:2;opacity:0;transition:opacity .15s ease}',
-  '.dshwv-menu-btn.dshwv-menu-btn-visible{opacity:1}',
-  '.dshwv-menu-btn span{display:block;width:14px;height:2px;background:#fff;border-radius:1px}',
-  '.dshwv-menu-btn:hover{background:#203170}',
-  '.dshwv-menu{position:fixed;min-width:196px;background:rgba(255,255,255,.92);border:1px solid rgba(32,49,112,.35);border-radius:10px;padding:10px 12px;opacity:0;transform:scale(.92) translateY(-4px);transform-origin:top right;transition:opacity .18s ease,transform .2s cubic-bezier(.34,1.56,.64,1);pointer-events:none;z-index:10000;box-shadow:0 6px 18px rgba(0,0,0,.18);color-scheme:light}',
-  '.dshwv-menu.dshwv-menu-open{opacity:1;transform:scale(1) translateY(0);pointer-events:auto}',
-  '.dshwv-menu-row{display:flex;align-items:center;gap:8px;margin:5px 0;color:#203170;font-size:12px;white-space:nowrap}',
-  '.dshwv-range{flex:1;min-width:0;accent-color:#203170}',
-  '.dshwv-number{width:44px;border:1px solid rgba(32,49,112,.4);border-radius:6px;padding:2px 4px;font-size:12px;color:#203170;background:#fff;box-sizing:border-box}',
-  '.dshwv-number:disabled{opacity:.4;background:rgba(32,49,112,.06);cursor:not-allowed}',
-  '.dshwv-sound{flex:1;border:1px solid rgba(32,49,112,.4);border-radius:6px;background:rgba(32,49,112,.08);color:#203170;font-size:12px;padding:3px 0;cursor:pointer}',
-  '.dshwv-sound:hover{background:rgba(32,49,112,.16)}',
-  '.dshwv-check{width:16px;height:16px;accent-color:#203170;cursor:pointer;flex:0 0 auto}',
-  '.dshwv-menu-sep{height:1px;background:rgba(32,49,112,.25);margin:6px 0}',
-  '.dshwv-volpct{width:44px;text-align:right;color:#203170;font-size:12px}'
-].join('\\n')
-
-var styleEl = document.createElement('style')
-styleEl.textContent = css
-document.head.appendChild(styleEl)
-
-var root = document.createElement('div')
-root.className = 'dshwv-root'
-
-var img = document.createElement('img')
-img.className = 'dshwv-img'
-img.src = IMG_URL
-img.alt = 'DeepSeek 余额'
-img.draggable = false
-
-var menuBtn = document.createElement('button')
-menuBtn.type = 'button'
-menuBtn.className = 'dshwv-menu-btn'
-menuBtn.title = '菜单'
-menuBtn.innerHTML = '<span></span><span></span><span></span>'
-menuBtn.addEventListener('click', function (e) { e.stopPropagation(); toggleMenu() })
-
-var menuBox = document.createElement('div')
-menuBox.className = 'dshwv-menu'
-function menuLabel(text) {
-  var s = document.createElement('span')
-  s.textContent = text
-  return s
-}
-function menuRow() {
-  var r = document.createElement('div')
-  r.className = 'dshwv-menu-row'
-  return r
-}
-var scaleInput = document.createElement('input')
-scaleInput.type = 'range'
-scaleInput.min = String(MIN_SCALE)
-scaleInput.max = String(MAX_SCALE)
-scaleInput.step = '0.1'
-scaleInput.className = 'dshwv-range'
-scaleInput.value = '1.5'
-var scaleNumber = document.createElement('input')
-scaleNumber.type = 'number'
-scaleNumber.min = '1'
-scaleNumber.max = '20'
-scaleNumber.step = '1'
-scaleNumber.className = 'dshwv-number'
-scaleNumber.value = '10'
-scaleInput.addEventListener('pointerdown', function () { root.style.transition = 'none' })
-scaleInput.addEventListener('input', function () { setScale(scaleInput.value) })
-scaleInput.addEventListener('change', function () { root.style.transition = '' })
-scaleNumber.addEventListener('focus', function () { root.style.transition = 'none' })
-scaleNumber.addEventListener('blur', function () { root.style.transition = '' })
-scaleNumber.addEventListener('input', function () {
-  var v = Math.round(Number(scaleNumber.value))
-  var s = MIN_SCALE + Math.max(0, Math.min(20, v) - 1) * (MAX_SCALE - MIN_SCALE) / 19
-  setScale(s)
-})
-scaleNumber.addEventListener('change', function () {
-  var v = Math.round(Number(scaleNumber.value))
-  var s = MIN_SCALE + Math.max(0, Math.min(20, v) - 1) * (MAX_SCALE - MIN_SCALE) / 19
-  setScale(s)
-  root.style.transition = ''
-})
-var soundSelect = document.createElement('select')
-soundSelect.className = 'dshwv-sound'
-function soundOpt(value, label) {
-  var o = document.createElement('option')
-  o.value = value
-  o.textContent = label
-  return o
-}
-soundSelect.appendChild(soundOpt('duck', '小黄鸭'))
-soundSelect.appendChild(soundOpt('fx1', '音效1'))
-soundSelect.addEventListener('change', function () { setSoundSet(soundSelect.value) })
-var usageSelect = document.createElement('select')
-usageSelect.className = 'dshwv-sound'
-usageSelect.appendChild(soundOpt('ledger', '小鲸鱼记账 (推荐)'))
-usageSelect.appendChild(soundOpt('token', '实时·令牌 (用法：去问dsh)'))
-usageSelect.addEventListener('change', function () { setUsageMode(usageSelect.value) })
-var peakSelect = document.createElement('select')
-peakSelect.className = 'dshwv-sound'
-peakSelect.appendChild(soundOpt('default', '默认'))
-peakSelect.appendChild(soundOpt('liangwen', '梁文峰谷'))
-peakSelect.appendChild(soundOpt('qiangqiang', '!?强强?!'))
-peakSelect.addEventListener('change', function () { setPeakMode(peakSelect.value) })
-var bubbleToggle = document.createElement('input')
-bubbleToggle.type = 'checkbox'
-bubbleToggle.className = 'dshwv-check'
-bubbleToggle.checked = true
-bubbleToggle.title = '开启/关闭思考气泡'
-bubbleToggle.addEventListener('change', function () { setBubbleOn(bubbleToggle.checked) })
-var turnCostToggle = document.createElement('input')
-turnCostToggle.type = 'checkbox'
-turnCostToggle.className = 'dshwv-check'
-turnCostToggle.checked = true
-turnCostToggle.title = '每轮对话结束后自动显示本轮消耗金额'
-turnCostToggle.addEventListener('change', function () { setTurnCostOn(turnCostToggle.checked) })
-var turnCostCloseInput = document.createElement('input')
-turnCostCloseInput.type = 'number'
-turnCostCloseInput.min = '0'
-turnCostCloseInput.step = '1'
-turnCostCloseInput.className = 'dshwv-number'
-turnCostCloseInput.value = '5'
-turnCostCloseInput.disabled = false // 跟随「每轮消耗提示」开关
-turnCostCloseInput.title = '填 0 表示不自动关闭，需手动点击关闭'
-turnCostCloseInput.addEventListener('input', function () { setTurnCostClose(turnCostCloseInput.value) })
-turnCostCloseInput.addEventListener('change', function () { setTurnCostClose(turnCostCloseInput.value) })
-var scrollGapToggle = document.createElement('input')
-scrollGapToggle.type = 'checkbox'
-scrollGapToggle.className = 'dshwv-check'
-scrollGapToggle.checked = false
-scrollGapToggle.title = '开启后挂件右侧按设定像素避开滚动条；关闭则贴边（盖住滚动条）'
-scrollGapToggle.addEventListener('change', function () { setScrollGapOn(scrollGapToggle.checked) })
-var scrollGapInput = document.createElement('input')
-scrollGapInput.type = 'number'
-scrollGapInput.min = '0'
-scrollGapInput.step = '1'
-scrollGapInput.className = 'dshwv-number'
-scrollGapInput.value = '17'
-scrollGapInput.disabled = true // 默认避让关 → 宽度不可修改，勾选后启用
-scrollGapInput.title = '避让滚动条的像素宽度，填 0 表示贴边'
-scrollGapInput.addEventListener('input', function () { setScrollGapPx(scrollGapInput.value) })
-scrollGapInput.addEventListener('change', function () { setScrollGapPx(scrollGapInput.value) })
-var row1 = menuRow()
-row1.appendChild(menuLabel('大小'))
-row1.appendChild(scaleInput)
-row1.appendChild(scaleNumber)
-var row2 = menuRow()
-row2.appendChild(menuLabel('音效'))
-row2.appendChild(soundSelect)
-var volInput = document.createElement('input')
-volInput.type = 'range'
-volInput.min = '0'
-volInput.max = '1'
-volInput.step = '0.05'
-volInput.className = 'dshwv-range'
-volInput.value = '0.9'
-var volPct = document.createElement('span')
-volPct.className = 'dshwv-volpct'
-volPct.textContent = '90%'
-volInput.addEventListener('input', function () { setVol(volInput.value) })
-var row3 = menuRow()
-row3.appendChild(menuLabel('音量'))
-row3.appendChild(volInput)
-row3.appendChild(volPct)
-var row4 = menuRow()
-row4.appendChild(menuLabel('用量'))
-row4.appendChild(usageSelect)
-var row5 = menuRow()
-row5.appendChild(menuLabel('峰谷'))
-row5.appendChild(peakSelect)
-var row6 = menuRow()
-row6.appendChild(menuLabel('气泡'))
-row6.appendChild(bubbleToggle)
-var menuSep1 = document.createElement('div')
-menuSep1.className = 'dshwv-menu-sep'
-var row7 = menuRow()
-row7.appendChild(menuLabel('每轮消耗提示'))
-row7.appendChild(turnCostToggle)
-row7.appendChild(menuLabel('自动关闭'))
-row7.appendChild(turnCostCloseInput)
-row7.appendChild(menuLabel('秒'))
-var row9 = menuRow()
-row9.appendChild(menuLabel('避让滚动条'))
-row9.appendChild(scrollGapToggle)
-row9.appendChild(menuLabel('宽度'))
-row9.appendChild(scrollGapInput)
-row9.appendChild(menuLabel('px'))
-menuBox.appendChild(row1)
-menuBox.appendChild(row2)
-menuBox.appendChild(row3)
-menuBox.appendChild(row4)
-menuBox.appendChild(row5)
-menuBox.appendChild(row6)
-menuBox.appendChild(row7)
-menuBox.appendChild(menuSep1)
-menuBox.appendChild(row9)
-
-var textBox = document.createElement('div')
-textBox.className = 'dshwv-text'
-var labelEl = document.createElement('div')
-labelEl.className = 'dshwv-label'
-labelEl.textContent = 'DeepSeek 余额'
-var amountEl = document.createElement('div')
-amountEl.className = 'dshwv-amount'
-var hintEl = document.createElement('div')
-hintEl.className = 'dshwv-hint'
-textBox.appendChild(labelEl)
-textBox.appendChild(amountEl)
-textBox.appendChild(hintEl)
-
-var bubbleBox = document.createElement('div')
-bubbleBox.className = 'dshwv-bubble'
-bubbleBox.innerHTML = '<svg viewBox="0 0 1026 700" preserveAspectRatio="xMidYMid meet" xmlns="http://www.w3.org/2000/svg">' +
-  '<path class="dshwv-bshape" fill="#FFFFFF" stroke="#203170" stroke-width="18" stroke-linejoin="round" stroke-linecap="round" d="M 827 248 A 373 232 0 1 0 81 246 A 373 232 0 0 0 301 465 A 57 32 10 0 0 413 484 A 373 232 0 0 0 827 248 Z"/>' +
-  '<ellipse class="dshwv-b1" cx="352" cy="561" rx="37.5" ry="26" fill="#FFFFFF" stroke="#203170" stroke-width="18"/>' +
-  '<ellipse class="dshwv-b2" cx="442" cy="646" rx="24.5" ry="18" fill="#FFFFFF" stroke="#203170" stroke-width="18"/>' +
-  '</svg>'
-var gifEl = document.createElement('img')
-gifEl.className = 'dshwv-gif'
-gifEl.src = GIF_URL
-gifEl.alt = ''
-gifEl.draggable = false
-bubbleBox.appendChild(gifEl)
-var gifFailed = false
-gifEl.onerror = function () { gifFailed = true }
-bubbleBox.appendChild(textBox)
-bubbleBox.addEventListener('click', function (e) {
-  e.stopPropagation()
-  if (!bubbleShown) return
-  if (costBubbleActive) {
-    // 消耗金额泡泡：点击关闭（确认）
-    hideCostBubble()
-    return
-  }
-  if (bubbleRandomActive) {
-    // 再次点击：关闭
-    hideBubble()
-  } else {
-    // 首次点击：切到随机台词段，并重置自动关闭计时——
-    // 保证第二段台词有完整停留时间（否则第 4 秒点击只看到 0.5 秒）
-    bubbleRandomActive = true
-    bubbleRandomLines = pickRandomLines()
-    swapBubbleContent(function () { applyBubbleLines(bubbleRandomLines) })
-    if (bubbleTimer) { clearTimeout(bubbleTimer); bubbleTimer = null }
-    bubbleTimer = setTimeout(hideBubble, BUBBLE_MS)
-  }
-})
-
-var body = document.createElement('div')
-body.className = 'dshwv-body'
-body.appendChild(img)
-body.appendChild(bubbleBox)
-root.appendChild(body)
-root.appendChild(menuBtn)
-document.body.appendChild(root)
-document.body.appendChild(menuBox)
-
-// Position model: the widget is ALWAYS expressed in left/top px (so edge snaps
-// animate smoothly via the CSS transition on both sides — switching to
-// right/auto cannot transition and flashes). The anchor info (h/v + offsets)
-// lives in state and is used by settle() to recompute coordinates on window
-// resize and size changes, keeping the widget glued to its anchored edge.
-var state = {
-  scale: 1.5,
-  h: 'right',
-  hOff: 0,
-  v: 'bottom',
-  vOff: 0,
-  left: 0,
-  top: 0,
-  balance: null,
-  currency: null,
-  todayUsage: null,
-  isPeak: false,
-  status: 'loading',
-  message: ''
-}
-var busy = false
-var settleTimer = null
-var animDelayTimer = null
-var drag = null
-var shown = null
-var animId = null
-var bubbleShown = false
-var bubbleTimer = null
-var bubbleRandomActive = false
-var bubbleRandomLines = null
-var BUBBLE_STYLE_CLASS = { A: 'dshwv-label', B: 'dshwv-amount', P: 'dshwv-period', C: 'dshwv-hint' }
-function pickOne(arr) { return arr[Math.floor(Math.random() * arr.length)] }
-function singleCenter(style, text, color, wrap) { return [null, { t: text, s: style, c: color || '', w: !!wrap }, null] }
-function buildGroup1() {
-  var peak = !!state.isPeak
-  var offText = '空闲时段'
-  var peakText = '高峰时段'
-  if (peakMode === 'liangwen') {
-    offText = '梁文谷'
-    peakText = '梁文峰'
-  } else if (peakMode === 'qiangqiang') {
-    offText = '!?谷谷?!'
-    peakText = '!?峰峰?!'
-  }
-  return [
-    { t: '当前时间段为:', s: 'A', c: '' },
-    { t: peak ? peakText : offText, s: 'P', c: peak ? '#e0433f' : '#2fa24c' },
-    { t: '今日已用 ' + fmt(state.todayUsage, state.currency), s: 'C', c: '' },
-  ]
-}
-var RANDOM_GROUPS = [
-  { w: 45, lines: buildGroup1 },
-  { w: 7, lines: function () { return singleCenter('B', pickOne(['好模型... ↓', '好女孩...↓'])) } },
-  { w: 7, lines: function () { return singleCenter('A', pickOne(['不知道用户有什么用，先赶走吧~', '我...我...我也要挣钱吗？', '我去吃饭啦，测完叫我', '压力一只蓝色大肥鱼？！', 'DeepSleep...', '坏了...用户彻底怒了！']), '', true) } },
-  { w: 10, lines: function () { return { gif: true } } },
-  { w: 3, lines: function () { return singleCenter('A', pickOne(['你目录里的dsh是什么...大烧货吗...?', '恭喜你实现token自由！token全跑了！', '真当我是便宜货啊...']), '', true) } },
-  { w: 1, lines: function () { return singleCenter('B', '哦鲸鲸... ') } },
+// 浏览器端挂件代码已拆分为独立文件 whale-widget.js(与本文件同目录),
+// 不再内嵌模板字面量:可直接 node --check / IDE 高亮,改 widget 后硬刷新页面即生效(无需重启 DSH)。
+// 每次请求按 mtime 判断是否需要重读,避免常驻缓存导致改了不生效。
+const WIDGET_FILE_CANDIDATES = [
+  path.join(path.dirname(fileURLToPath(import.meta.url)), 'whale-widget.js'),
+  path.join(PACKAGE_ROOT, 'whale-widget.js'),
+  path.join(PACKAGE_ROOT, 'assets', 'whale-widget.js'),
 ]
-function pickRandomLines() {
-  var total = 0
-  for (var i = 0; i < RANDOM_GROUPS.length; i++) total += RANDOM_GROUPS[i].w
-  var r = Math.random() * total
-  for (var i = 0; i < RANDOM_GROUPS.length; i++) {
-    r -= RANDOM_GROUPS[i].w
-    if (r < 0) return RANDOM_GROUPS[i].lines()
-  }
-  return RANDOM_GROUPS[RANDOM_GROUPS.length - 1].lines()
-}
-function applyBubbleLines(lines) {
-  if (lines && lines.gif) {
-    // gif 台词组：只显示 gif，隐藏三行文字（display 必须显式覆盖 CSS 的 none）
-    if (gifFailed) {
-      // gif 加载失败/路由缺失：降级为文字台词，避免空白白色气泡
-      lines = singleCenter('A', pickOne(['gif 加载失败了...', '今天没有动图给你看~', '呜呜 动图不见了...']), '', true)
-    } else {
-      if (gifFadeTimer) { clearTimeout(gifFadeTimer); gifFadeTimer = null }
-      gifEl.style.display = 'block'
-      gifEl.style.opacity = ''
-      labelEl.style.display = 'none'
-      amountEl.style.display = 'none'
-      hintEl.style.display = 'none'
-      return
-    }
-  }
-  if (gifFadeTimer) { clearTimeout(gifFadeTimer); gifFadeTimer = null }
-  gifEl.style.display = 'none'
-  gifEl.style.opacity = ''
-  var els = [labelEl, amountEl, hintEl]
-  for (var i = 0; i < 3; i++) {
-    var el = els[i]
-    var ln = lines && lines[i]
-    if (ln) {
-      el.style.display = ''
-      el.className = (BUBBLE_STYLE_CLASS[ln.s] || 'dshwv-label') + (ln.w ? ' dshwv-wrap' : '')
-      el.textContent = ln.t
-      el.style.color = ln.c || ''
-    } else {
-      el.style.display = 'none'
-      el.textContent = ''
-      el.style.color = ''
-    }
-  }
-}
-var bubbleSwapTimer = null
-var hintFadeTimer = null
-var gifFadeTimer = null
-var lastHintText = null
-function setHint(text) {
-  // 首次/恢复（lastHintText===null）时直接写文本，不做淡出淡入——否则
-  // 气泡打开或按压重开时会先淡出再淡入，造成「消失一下又出现」。
-  // 只有气泡打开期间的内容变化（加载中→今日已用）才走动画。
-  if (text === lastHintText) return
-  var first = lastHintText === null
-  lastHintText = text
-  if (first || !bubbleShown) {
-    hintEl.textContent = text
-    return
-  }
-  hintEl.style.transition = 'opacity .18s ease'
-  hintEl.style.opacity = '0'
-  hintFadeTimer = setTimeout(function () {
-    hintFadeTimer = null
-    hintEl.textContent = text
-    hintEl.style.opacity = '1'
-    setTimeout(function () {
-      hintEl.style.transition = ''
-      hintEl.style.opacity = ''
-    }, 220)
-  }, 190)
-}
-function swapBubbleContent(applyFn) {
-  if (bubbleSwapTimer) { clearTimeout(bubbleSwapTimer); bubbleSwapTimer = null }
-  textBox.style.transition = 'opacity .18s ease'
-  textBox.style.opacity = '0'
-  bubbleSwapTimer = setTimeout(function () {
-    bubbleSwapTimer = null
-    applyFn()
-    textBox.style.opacity = '1'
-    setTimeout(function () {
-      textBox.style.transition = ''
-      textBox.style.opacity = ''
-    }, 220)
-  }, 190)
-}
-function restoreBubbleLines() {
-  if (bubbleSwapTimer) { clearTimeout(bubbleSwapTimer); bubbleSwapTimer = null }
-  if (hintFadeTimer) { clearTimeout(hintFadeTimer); hintFadeTimer = null }
-  if (gifFadeTimer) { clearTimeout(gifFadeTimer); gifFadeTimer = null }
-  lastHintText = null
-  textBox.style.transition = ''
-  textBox.style.opacity = ''
-  gifEl.style.display = 'none'
-  gifEl.style.opacity = ''
-  labelEl.style.display = ''
-  labelEl.className = 'dshwv-label'
-  labelEl.textContent = 'DeepSeek 余额'
-  labelEl.style.color = ''
-  amountEl.style.display = ''
-  amountEl.className = 'dshwv-amount'
-  amountEl.style.color = ''
-  hintEl.style.display = ''
-  hintEl.className = 'dshwv-hint'
-  hintEl.style.color = ''
-  render()
-}
-function showBubble() {
-  if (!bubbleOn) return
-  // 消耗金额泡泡显示期间，余额变动不再弹出普通泡泡
-  if (costBubbleActive) return
-  if (bubbleTimer) { clearTimeout(bubbleTimer); bubbleTimer = null }
-  if (gifFadeTimer) { clearTimeout(gifFadeTimer); gifFadeTimer = null }
-  bubbleShown = true
-  bubbleRandomActive = false
-  restoreBubbleLines()
-  bubbleBox.classList.add('dshwv-bubble-open')
-  // 默认展示当前内容；点击气泡切到随机台词段；总时长 5 秒自动关闭
-  bubbleTimer = setTimeout(hideBubble, BUBBLE_MS)
-}
-function hideBubble() {
-  if (bubbleTimer) { clearTimeout(bubbleTimer); bubbleTimer = null }
-  if (bubbleSwapTimer) { clearTimeout(bubbleSwapTimer); bubbleSwapTimer = null }
-  if (hintFadeTimer) { clearTimeout(hintFadeTimer); hintFadeTimer = null }
-  textBox.style.transition = ''
-  textBox.style.opacity = ''
-  hintEl.style.transition = ''
-  hintEl.style.opacity = ''
-  bubbleRandomActive = false
-  bubbleRandomLines = null
-  bubbleShown = false
-  // 只销毁 gif 显示；三行文字保持现状让气泡自然淡出——不能在关闭瞬间
-  // 恢复成余额内容（否则随机台词界面会闪现余额）。文字恢复交给下次
-  // showBubble() 的 restoreBubbleLines()（那时气泡隐藏，恢复过程不可见）。
-  bubbleBox.classList.remove('dshwv-bubble-open')
-  // gif 靠 CSS opacity 过渡淡出；display:none 会跳过过渡，须等淡出完成再隐藏
-  gifFadeTimer = setTimeout(function () {
-    gifFadeTimer = null
-    gifEl.style.display = 'none'
-  }, 240)
-}
-
-// —— 每轮对话消耗金额泡泡 ——
-var costBubbleTimer = null
-function showCostBubble(amount) {
-  if (!bubbleOn || !turnCostOn) return
-  if (costBubbleTimer) { clearTimeout(costBubbleTimer); costBubbleTimer = null }
-  if (bubbleTimer) { clearTimeout(bubbleTimer); bubbleTimer = null }
-  if (gifFadeTimer) { clearTimeout(gifFadeTimer); gifFadeTimer = null }
-  // 取消进行中的余额数字滚动与延迟计时器，避免竞态覆盖成本金额
-  if (animId) { cancelAnimationFrame(animId); animId = null }
-  if (animDelayTimer) { clearTimeout(animDelayTimer); animDelayTimer = null }
-  if (settleTimer) { clearTimeout(settleTimer); settleTimer = null }
-  costBubbleActive = true
-  bubbleRandomActive = false
-  bubbleShown = true
-  lastHintText = null
-  // 样式：第一行 A（标签），第二行 B（红色金额），居中两行
-  gifEl.style.display = 'none'
-  gifEl.style.opacity = ''
-  labelEl.style.display = ''
-  labelEl.className = 'dshwv-label'
-  labelEl.textContent = '上一轮对话消耗:'
-  labelEl.style.color = ''
-  amountEl.style.display = ''
-  amountEl.className = 'dshwv-amount'
-  amountEl.textContent = '¥ ' + (isFinite(amount) ? Number(amount).toFixed(2) : '--')
-  amountEl.style.color = '#e0433f'
-  hintEl.style.display = 'none'
-  hintEl.textContent = ''
-  hintEl.style.color = ''
-  textBox.style.transition = ''
-  textBox.style.opacity = ''
-  bubbleBox.classList.add('dshwv-bubble-open')
-  if (turnCostCloseMs > 0) {
-    costBubbleTimer = setTimeout(hideCostBubble, turnCostCloseMs)
-  }
-}
-function hideCostBubble() {
-  if (costBubbleTimer) { clearTimeout(costBubbleTimer); costBubbleTimer = null }
-  costBubbleActive = false
-  hideBubble()
-}
-
-function clamp(v, lo, hi) { return v < lo ? lo : (v > hi ? hi : v) }
-function viewport() {
-  return {
-    w: window.innerWidth || document.documentElement.clientWidth || 1280,
-    h: window.innerHeight || document.documentElement.clientHeight || 800
-  }
-}
-function rightGap() {
-  // 开关关闭：贴边（不避让滚动条）
-  if (!scrollGapOn) return 0
-  // 开启：用用户填写的像素；填 0 也贴边
-  return scrollGapPx > 0 ? scrollGapPx : 0
-}
-function fmt(balance, currency) {
-  var num = Number(balance)
-  var fixed = isFinite(num) ? num.toFixed(2) : '--'
-  return currency === 'CNY' ? '¥ ' + fixed : fixed + ' ' + currency
-}
-function animateAmount(from, to, currency, duration) {
-  // 消耗金额泡泡显示期间，余额数字滚动不触碰金额行
-  if (costBubbleActive) return
-  if (animId) cancelAnimationFrame(animId)
-  if (from === null || !isFinite(from)) from = to
-  if (from === to) {
-    shown = to
-    amountEl.textContent = fmt(to, currency)
-    return
-  }
-  var startTime = null
-  function step(ts) {
-    // 帧级保护：成本泡泡出现后立即停止滚动，避免后续帧把余额写进金额行
-    if (costBubbleActive) {
-      animId = null
-      return
-    }
-    if (startTime === null) startTime = ts
-    var t = Math.min(1, (ts - startTime) / duration)
-    var eased = 1 - Math.pow(1 - t, 3)
-    var val = from + (to - from) * eased
-    amountEl.textContent = fmt(val, currency)
-    if (t < 1) {
-      animId = requestAnimationFrame(step)
-    } else {
-      animId = null
-      shown = to
-      amountEl.textContent = fmt(to, currency)
-    }
-  }
-  animId = requestAnimationFrame(step)
-}
-function render() {
-  // 消耗金额泡泡显示期间，余额渲染不覆盖其内容（金额行/标题行/提示行）
-  if (costBubbleActive) return
-  var amount, hint
-  if (state.status === 'error') {
-    amount = shown !== null ? fmt(shown, state.currency) : '--'
-    hint = state.message ? state.message.slice(0, 14) : '获取失败 · 点击重试'
-  } else if (state.balance === null) {
-    amount = shown !== null ? fmt(shown, state.currency) : '…'
-    hint = '加载中…'
-  } else {
-    amount = shown !== null ? fmt(shown, state.currency) : fmt(state.balance, state.currency)
-    hint = '今日已用 ' + (state.todayUsage !== null && state.todayUsage !== undefined ? fmt(state.todayUsage, state.currency) : '--')
-  }
-  amountEl.textContent = amount
-  if (bubbleRandomActive && bubbleRandomLines) {
-    applyBubbleLines(bubbleRandomLines)
-  } else {
-    setHint(hint)
-  }
-}
-function express() {
-  root.style.right = 'auto'
-  root.style.bottom = 'auto'
-  root.style.left = state.left + 'px'
-  root.style.top = state.top + 'px'
-  root.classList.toggle('dshwv-left', state.h === 'left')
-}
-function settle() {
-  var vp = viewport()
-  var w = root.offsetWidth || root.getBoundingClientRect().width || 0
-  var h = root.offsetHeight || root.getBoundingClientRect().height || 0
-  if (drag && drag.active) {
-    // mid-drag resize: keep the pointer-follow position, just clamp into view
-    state.left = clamp(state.left, 0, Math.max(0, vp.w - w - rightGap()))
-    state.top = clamp(state.top, 0, Math.max(0, vp.h - h))
-    express()
-    return
-  }
-  if (state.h === 'right') {
-    state.left = Math.max(0, vp.w - w - state.hOff - rightGap())
-  } else if (state.h === 'left') {
-    state.left = state.hOff
-  } else {
-    state.left = clamp(state.left, 0, Math.max(0, vp.w - w - rightGap()))
-  }  if (state.v === 'bottom') {
-    state.top = Math.max(0, vp.h - h - state.vOff)
-  } else if (state.v === 'top') {
-    state.top = state.vOff
-  } else {
-    state.top = clamp(state.top, 0, Math.max(0, vp.h - h))
-  }
-  express()
-}
-function refresh(manual) {
-  if (busy) return
-  busy = true
-  if (animDelayTimer) { clearTimeout(animDelayTimer); animDelayTimer = null }
-  if (manual || state.balance === null) { state.status = 'loading'; render() }
-  var ctrl = null
-  var timer = null
-  try {
-    ctrl = new AbortController()
-    timer = setTimeout(function () { try { ctrl.abort() } catch (err) {} }, FETCH_TIMEOUT_MS)
-  } catch (err) {}
-  fetch(BALANCE_URL, { cache: 'no-store', signal: ctrl ? ctrl.signal : undefined })
-    .then(function (r) { return r.json() })
-    .then(function (data) {
-      if (data && data.ok) {
-        var nb = Number(data.totalBalance)
-        var nc = String(data.currency || 'CNY')
-        var changed = state.balance !== null && (nb !== state.balance || nc !== state.currency)
-        var currencyChanged = state.currency !== null && nc !== state.currency
-        state.balance = nb
-        state.currency = nc
-        state.message = ''
-        state.todayUsage = data.todayUsage !== undefined ? data.todayUsage : null
-        state.isPeak = !!data.isPeak
-        if (changed && !currencyChanged) {
-          if (!manual) {
-            showBubble()
-            state.status = 'changing'
-            // balance-change bubble: wait 0.3s after it floats out, then roll the number
-            if (animDelayTimer) clearTimeout(animDelayTimer)
-            animDelayTimer = setTimeout(function () {
-              animDelayTimer = null
-              animateAmount(shown, nb, nc, ANIM_MS)
-            }, 300)
-            if (settleTimer) clearTimeout(settleTimer)
-            settleTimer = setTimeout(function () {
-              settleTimer = null
-              if (state.status === 'changing') { state.status = 'ok'; render() }
-            }, CHANGE_MS + 300)
-          } else {
-            animateAmount(shown, nb, nc, ANIM_MS)
-            state.status = 'ok'
-            render()
-          }
-        } else {
-          if (animId === null) shown = nb
-          state.status = 'ok'
-          render()
-        }
-      } else {
-        state.status = 'error'
-        state.message = (data && data.error) ? String(data.error) : '获取失败'
-        render()
-      }
-    })
-    .catch(function () {
-      state.status = 'error'
-      state.message = '获取失败'
-      render()
-    })
-    .finally(function () {
-      busy = false
-      if (timer) clearTimeout(timer)
-    })
-}
-var soundOn = true
-var soundVol = 0.9
-var soundSet = 'duck'
-var usageMode = 'ledger'
-var peakMode = 'default'
-var bubbleOn = true
-var turnCostOn = true
-var turnCostCloseMs = 5000
-var costBubbleActive = false
-var scrollGapOn = false
-var scrollGapPx = 17
-function saveConfig() {
-  try {
-    fetch(SIZE_URL, { method: 'PUT', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ scale: state.scale, sound: soundOn, vol: soundVol, soundSet: soundSet, usageMode: usageMode, peakMode: peakMode, bubbleOn: bubbleOn, turnCostOn: turnCostOn, turnCostCloseMs: turnCostCloseMs, scrollGapOn: scrollGapOn, scrollGapPx: scrollGapPx }) })
-    // 锚点位置记忆：记录相对边框的离边距离，窗口 resize 后保持（localStorage）。
-    // v:2 = 净距离格式（剥离避让距离），v:1 旧格式含避让距离，恢复时废弃旧格式。
-    var vp = viewport()
-    var w = root.offsetWidth || root.getBoundingClientRect().width || 0
-    var h = root.offsetHeight || root.getBoundingClientRect().height || 0
-    var leftDist = state.left
-    var rightDist = vp.w - state.left - w
-    var topDist = state.top
-    var bottomDist = vp.h - state.top - h
-    var hAnchor = leftDist <= rightDist ? 'left' : 'right'
-    var hDistRaw = Math.round(Math.min(leftDist, rightDist))
-    var hDist = hAnchor === 'right' && scrollGapOn ? Math.max(0, hDistRaw - rightGap()) : hDistRaw
-    localStorage.setItem('dshw-pos', JSON.stringify({
-      v: 2,
-      hAnchor: hAnchor,
-      hDist: hDist,
-      vAnchor: topDist <= bottomDist ? 'top' : 'bottom',
-      vDist: Math.round(Math.min(topDist, bottomDist))
-    }))
-  } catch (err) {}
-}
-function setUsageMode(v) {
-  usageMode = v === 'token' ? 'token' : 'ledger'
-  usageSelect.value = usageMode
-  saveConfig()
-  refresh(false)
-}
-function setPeakMode(v) {
-  peakMode = v === 'liangwen' || v === 'qiangqiang' ? v : 'default'
-  peakSelect.value = peakMode
-  saveConfig()
-}
-function setBubbleOn(v) {
-  bubbleOn = !!v
-  bubbleToggle.checked = bubbleOn
-  saveConfig()
-  // 必须走 hideCostBubble：残留的 costBubbleActive 会让 render()/showBubble() 永久早退
-  if (!bubbleOn) hideCostBubble()
-}
-function setTurnCostOn(v) {
-  turnCostOn = !!v
-  turnCostToggle.checked = turnCostOn
-  turnCostCloseInput.disabled = !turnCostOn
-  saveConfig()
-  if (!turnCostOn) hideCostBubble()
-}
-function setTurnCostClose(v) {
-  if (!turnCostOn) return
-  var n = Math.max(0, Math.round(Number(v) || 0))
-  turnCostCloseMs = n * 1000
-  turnCostCloseInput.value = String(n)
-  saveConfig()
-}
-function setScrollGapOn(v) {
-  scrollGapOn = !!v
-  scrollGapToggle.checked = scrollGapOn
-  scrollGapInput.disabled = !scrollGapOn
-  saveConfig()
-  settle()
-}
-function setScrollGapPx(v) {
-  if (!scrollGapOn) return
-  var n = Math.max(0, Math.round(Number(v) || 0))
-  scrollGapPx = n
-  scrollGapInput.value = String(n)
-  saveConfig()
-  settle()
-}
-function scaleToDisplay(s) {
-  return Math.round((s - MIN_SCALE) / ((MAX_SCALE - MIN_SCALE) / 19)) + 1
-}
-function setScale(v) {
-  var next = Math.round(Math.min(MAX_SCALE, Math.max(MIN_SCALE, Number(v))) * 10) / 10
-  // 缩放测量需要 left/top 立即到位：临时禁用过渡（滚轮/数字框路径没有
-  // 滑块 pointerdown 的 transition:none，否则 r2 测的是过渡起点导致错锚点）
-  var prevTrans = root.style.transition
-  root.style.transition = 'none'
-  var rect = root.getBoundingClientRect()
-  // fixed point: the whale's corner — bottom-right when unflipped, bottom-left
-  // when flipped. Growing extends the widget up-left / up-right from that
-  // corner; shrinking pulls it back toward the corner. The whale always hugs
-  // its corner while scaling.
-  var fx = state.h === 'left' ? rect.left : rect.right
-  var fy = rect.bottom
-  state.scale = next
-  root.style.setProperty('--dshw-scale', String(next))
-  scaleInput.value = String(next)
-  scaleNumber.value = String(scaleToDisplay(next))
-  saveConfig()
-  // keep the corner fixed while resizing; the position correction applies
-  // instantly because the caller disables the transition for the whole drag
-  var r2 = root.getBoundingClientRect()
-  var vp = viewport()
-  if (state.h === 'left') {
-    state.left = Math.min(Math.max(fx, 0), Math.max(0, vp.w - r2.width))
-  } else {
-    state.left = Math.min(Math.max(fx - r2.width, 0), Math.max(0, vp.w - r2.width))
-  }
-  state.top = Math.min(Math.max(fy - r2.height, 0), Math.max(0, vp.h - r2.height))
-  express()
-  // 恢复过渡必须延迟到下一帧：本帧 left/top 已在 none 下设置并提交，
-  // 立即恢复会让浏览器对「刚改过的 left/top」重新评估并播放过渡动画
-  // （翻转时叠加 transform .3s 更明显，表现为抽搐）。
-  requestAnimationFrame(function () {
-    root.style.transition = prevTrans
-  })
-}
-function setVol(v) {
-  var next = Math.round(Math.min(1, Math.max(0, Number(v))) * 100) / 100
-  soundVol = next
-  soundOn = next > 0
-  volInput.value = String(next)
-  volPct.textContent = Math.round(next * 100) + '%'
-  try {
-    if (pressAudio) pressAudio.volume = next
-    if (releaseAudio) releaseAudio.volume = next
-  } catch (err) {}
-  saveConfig()
-}
-function setSoundSet(v) {
-  soundSet = v === 'fx1' ? 'fx1' : 'duck'
-  soundSelect.value = soundSet
-  applySoundSet()
-  saveConfig()
-}
-var SQUISH = 'scaleY(0.88) scaleX(1.05)'
-var pressAudio = null
-var releaseAudio = null
-var pressing = false
-var pressEnded = false
-var releasePlayed = false
-var releaseTimer = null
-function applySoundSet() {
-  try {
-    pressAudio = new Audio('/dsh-whale/sound/press.mp3?set=' + soundSet)
-    pressAudio.preload = 'auto'
-    pressAudio.volume = soundVol
-    releaseAudio = new Audio('/dsh-whale/sound/release.mp3?set=' + soundSet)
-    releaseAudio.preload = 'auto'
-    releaseAudio.volume = soundVol
-  } catch (err) {}
-}
-function playPress() {
-  if (!pressAudio || !soundOn) return
-  try {
-    if (releaseTimer) { clearTimeout(releaseTimer); releaseTimer = null }
-    if (releaseAudio) {
-      releaseAudio.pause()
-      releaseAudio.currentTime = 0
-    }
-    pressEnded = false
-    releasePlayed = false
-    pressAudio.onended = function () {
-      pressEnded = true
-      // fallback (duration unknown): click → Ya2 right after Ya1 ends
-      if (!pressing && !releasePlayed) playRelease()
-      // hold: still pressed → wait for pressUp()
-    }
-    pressAudio.currentTime = 0
-    var p = pressAudio.play()
-    if (p && typeof p.catch === 'function') p.catch(function () {})
-  } catch (err) {}
-}
-function playRelease() {
-  if (releasePlayed || !releaseAudio || !soundOn) return
-  releasePlayed = true
-  try {
-    releaseAudio.currentTime = 0
-    var p = releaseAudio.play()
-    if (p && typeof p.catch === 'function') p.catch(function () {})
-  } catch (err) {}
-}
-function pressDown() {
-  body.style.transform = SQUISH
-  pressing = true
-  playPress()
-}
-function pressUp() {
-  body.style.transform = 'scaleY(1) scaleX(1)'
-  pressing = false
-  if (pressEnded) {
-    // hold (or released after Ya1 finished) → Ya2 now
-    playRelease()
-    return
-  }
-  // click: start Ya2 in the last 100ms of Ya1's playback
-  var durKnown = false
-  var remainMs = 0
-  try {
-    var dur = pressAudio ? pressAudio.duration : 0
-    if (isFinite(dur) && dur > 0) {
-      durKnown = true
-      remainMs = (dur - pressAudio.currentTime) * 1000
-    }
-  } catch (err) {}
-  if (durKnown) {
-    releaseTimer = setTimeout(function () {
-      releaseTimer = null
-      playRelease()
-    }, Math.max(0, remainMs - 100))
-  }
-  // duration unknown → pressAudio.onended fallback plays Ya2 after Ya1 ends
-}
-var menuOpen = false
-function toggleMenu() {
-  menuOpen = !menuOpen
-  if (menuOpen) positionMenu()
-  menuBox.classList.toggle('dshwv-menu-open', menuOpen)
-  if (menuOpen) menuBtn.classList.add('dshwv-menu-btn-visible')
-}
-function closeMenu() {
-  menuOpen = false
-  menuBox.classList.remove('dshwv-menu-open')
-  root.style.transition = ''
-  snapCheck()
-}
-function snapCheck() {
-  var rect = root.getBoundingClientRect()
-  var vp = viewport()
-  var w = rect.width, h = rect.height
-  var left = rect.left, top = rect.top
-  var centerX = left + w / 2
-  var centerY = top + h / 2
-  var moved = false
-  if (centerX < vp.w / 4) {
-    state.h = 'left'
-    state.hOff = 0
-    left = 0
-    moved = true
-  } else if (centerX > vp.w * 3 / 4) {
-    state.h = 'right'
-    state.hOff = 0
-    left = vp.w - w - rightGap()
-    moved = true
-  } else {
-    state.h = null
-    state.hOff = left
-  }
-  if (centerY < vp.h / 4) {
-    state.v = 'top'
-    state.vOff = 0
-    top = 0
-    moved = true
-  } else {
-    state.v = 'bottom'
-    state.vOff = Math.max(0, vp.h - top - h)
-  }
-  if (moved) {
-    state.left = left
-    state.top = top
-    settle()
+let widgetJsCache = null // { text, mtimeMs }
+function loadWidgetJs() {
+  for (const p of WIDGET_FILE_CANDIDATES) {
+    try {
+      const st = fs.statSync(p)
+      if (widgetJsCache && widgetJsCache.mtimeMs === st.mtimeMs) return widgetJsCache.text
+      const text = fs.readFileSync(p, 'utf8')
+      widgetJsCache = { text, mtimeMs: st.mtimeMs }
+      return text
+    } catch (err) {}
   }
-}
-function positionMenu() {
-  try {
-    var r = root.getBoundingClientRect()
-    var b = menuBtn.getBoundingClientRect()
-    var vp = viewport()
-    var onLeft = r.left + r.width / 2 < vp.w / 2
-    // the menu appears ABOVE the button, anchored to its side:
-    // right side → menu bottom-right aligns with the button's top-right;
-    // left side → menu bottom-left aligns with the button's top-left
-    if (onLeft) {
-      menuBox.style.left = b.left + 'px'
-      menuBox.style.right = 'auto'
-      menuBox.style.transformOrigin = 'bottom left'
-    } else {
-      menuBox.style.right = (vp.w - b.right) + 'px'
-      menuBox.style.left = 'auto'
-      menuBox.style.transformOrigin = 'bottom right'
-    }
-    menuBox.style.bottom = (vp.h - b.top) + 'px'
-    menuBox.style.top = 'auto'
-  } catch (err) {}
+  return widgetJsCache ? widgetJsCache.text : ''
 }
 
-var hitCanvas = null
-var hitReady = false
-function setupHitTest() {
-  try {
-    hitCanvas = document.createElement('canvas')
-    hitCanvas.width = 610
-    hitCanvas.height = 610
-    var probe = new Image()
-    probe.onload = function () {
-      try {
-        // 拉伸到 610×610 与 isWhaleHit 的坐标映射对齐；不指定尺寸会按原图大小绘制，
-        // 回退到非 610×610 素材（如 DSniang02.png）时命中区域会错位
-        hitCanvas.getContext('2d').drawImage(probe, 0, 0, 610, 610)
-        hitReady = true
-      } catch (err) {}
-    }
-    probe.onerror = function () {}
-    probe.src = IMG_URL
-  } catch (err) {}
-}
-function isWhaleHit(e) {
-  if (!hitCanvas || !hitReady) return true
-  try {
-    var r = img.getBoundingClientRect()
-    if (!r || r.width <= 0 || r.height <= 0) return false
-    var lx = (e.clientX - r.left) / r.width * 610
-    var ly = (e.clientY - r.top) / r.height * 610
-    if (lx < 0 || ly < 0 || lx >= 610 || ly >= 610) return false
-    if (state.h === 'left') lx = 610 - lx
-    var data = hitCanvas.getContext('2d').getImageData(Math.floor(lx), Math.floor(ly), 1, 1).data
-    return data[3] > 10
-  } catch (err) {
-    return true
-  }
-}
-function onDocPointerDown(e) {
-  if (e.target && e.target.closest) {
-    if (e.target.closest('.dshwv-bubble') || e.target.closest('.dshwv-menu') || e.target.closest('.dshwv-menu-btn')) return
-  }
-  if (menuOpen) {
-    closeMenu()
-    return
-  }
-  if (e.button !== 0 && e.pointerType === 'mouse') return
-  if (!isWhaleHit(e)) return
-  try { e.preventDefault(); e.stopPropagation() } catch (err) {}
-  var vp = viewport()
-  var rect = root.getBoundingClientRect()
-  drag = { active: true, startX: e.clientX, startY: e.clientY, origLeft: rect.left, origTop: rect.top, w: rect.width, h: rect.height, moved: false, vp: vp }
-  root.classList.add('dshwv-dragging')
-  pressDown()
-  setWidgetCursor('grabbing')
-  document.addEventListener('pointermove', onDocPointerMove, true)
-  document.addEventListener('pointerup', onDocPointerUp, true)
-  document.addEventListener('pointercancel', onDocPointerCancel, true)
-}
-function onDocPointerMove(e) {
-  if (!drag || !drag.active) return
-  var dx = e.clientX - drag.startX
-  var dy = e.clientY - drag.startY
-  if (dx * dx + dy * dy >= CLICK_SQ) drag.moved = true
-  // Keep the pre-drag flip orientation while dragging (state.h/v stay as they
-  // were); on release endDrag() recomputes the anchors and settle() flips the
-  // class with a smooth transition instead of reverting instantly.
-  state.left = clamp(drag.origLeft + dx, 0, Math.max(0, drag.vp.w - drag.w))
-  state.top = clamp(drag.origTop + dy, 0, Math.max(0, drag.vp.h - drag.h))
-  express()
-}
-function onDocPointerUp(e) {
-  // 拦截鲸鱼区域内的 pointerup：防止下方元素（如文件行）监听 pointerup 穿透误触发
-  try { if (isWhaleHit(e)) { e.preventDefault(); e.stopPropagation() } } catch (err) {}
-  endDrag(e, true)
-}
-function onDocPointerCancel(e) { endDrag(e, false) }
-function onDocClickStopper(e) {
-  // 只在鲸鱼命中区域拦截 click（保持透明区 pass-through）。
-  // 持久注册（不随 endDrag 移除）——click 在 pointerup 之后派发，
-  // 若在 endDrag 移除会导致 click 穿透到下方元素（如误打开文件）。
-  if (!isWhaleHit(e)) return
-  try { e.preventDefault(); e.stopPropagation() } catch (err) {}
-}
-document.addEventListener('pointerdown', onDocPointerDown, true)
-document.addEventListener('click', onDocClickStopper, true)
-
-var widgetCursor = ''
-function setWidgetCursor(v) {
-  if (v !== widgetCursor) {
-    widgetCursor = v
-    try { document.body.style.cursor = v } catch (err) {}
-  }
-}
-function onDocPointerMoveCursor(e) {
-  if (drag && drag.active) { setWidgetCursor('grabbing'); return }
-  var el = null
-  try { el = document.elementFromPoint(e.clientX, e.clientY) } catch (err) {}
-  if (el && el.closest && (el.closest('.dshwv-bubble') || el.closest('.dshwv-menu') || el.closest('.dshwv-menu-btn'))) {
-    setWidgetCursor('')
-    menuBtn.classList.add('dshwv-menu-btn-visible')
-    return
-  }
-  var over = isWhaleHit(e)
-  setWidgetCursor(over ? 'grab' : '')
-  menuBtn.classList.toggle('dshwv-menu-btn-visible', over || menuOpen)
-}
-document.addEventListener('pointermove', onDocPointerMoveCursor, true)
-
-function endDrag(e, clickAllowed) {
-  if (!drag || !drag.active) return
-  drag.active = false
-  document.removeEventListener('pointermove', onDocPointerMove, true)
-  document.removeEventListener('pointerup', onDocPointerUp, true)
-  document.removeEventListener('pointercancel', onDocPointerCancel, true)
-  pressUp()
-  root.classList.remove('dshwv-dragging')
-  setWidgetCursor(isWhaleHit(e) ? 'grab' : '')
-  if (clickAllowed && !drag.moved) { showBubble(); refresh(true); return }
-  var dx = e.clientX - drag.startX
-  var dy = e.clientY - drag.startY
-  var left = clamp(drag.origLeft + dx, 0, Math.max(0, drag.vp.w - drag.w))
-  var top = clamp(drag.origTop + dy, 0, Math.max(0, drag.vp.h - drag.h))
-  var centerX = left + drag.w / 2
-  var centerY = top + drag.h / 2
-  if (centerX < drag.vp.w / 4) {
-    state.h = 'left'
-    state.hOff = 0
-  } else if (centerX > drag.vp.w * 3 / 4) {
-    state.h = 'right'
-    state.hOff = 0
-  } else {
-    state.h = null
-    state.hOff = left
-  }
-  if (centerY < drag.vp.h / 4) {
-    state.v = 'top'
-    state.vOff = 0
-  } else if (centerY > drag.vp.h * 3 / 4) {
-    state.v = 'bottom'
-    state.vOff = 0
-  } else {
-    state.v = null
-    state.vOff = top
-  }
-  state.left = left
-  state.top = top
-  settle()
-  // 拖拽结束立即保存锚点位置（否则刷新/关闭后位置回退到上次改菜单时）
-  saveConfig()
-}
-// 窗口尺寸变化时：自由位置的鲸鱼按相对边框锚点重算（保持离边距离，窗口恢复原状即回原位）；
-// 贴边吸附的鲸鱼走 settle()（保持贴边）
-function applyAnchorPos() {
-  try {
-    var a = JSON.parse(localStorage.getItem('dshw-pos') || 'null')
-    if (!a || a.v !== 2 || (a.hAnchor !== 'left' && a.hAnchor !== 'right') || typeof a.hDist !== 'number' ||
-        (a.vAnchor !== 'top' && a.vAnchor !== 'bottom') || typeof a.vDist !== 'number') return false
-    var vp = viewport()
-    var w = root.offsetWidth || root.getBoundingClientRect().width || 0
-    var h = root.offsetHeight || root.getBoundingClientRect().height || 0
-    // 与加载恢复一致：锚点存净距离，右锚点按当前避让开关叠加
-    var effectiveRightDist = a.hAnchor === 'right' ? a.hDist + (scrollGapOn ? rightGap() : 0) : a.hDist
-    var l = a.hAnchor === 'left' ? a.hDist : vp.w - effectiveRightDist - w
-    var t = a.vAnchor === 'top' ? a.vDist : vp.h - a.vDist - h
-    state.left = clamp(l, 0, Math.max(0, vp.w - w))
-    state.top = clamp(t, 0, Math.max(0, vp.h - h))
-    state.h = a.hAnchor
-    state.hOff = 0
-    state.v = a.vAnchor
-    state.vOff = 0
-    express()
-    return true
-  } catch (err) { return false }
-}
-window.addEventListener('resize', function () {
-  if (state.h === null && state.v === null && applyAnchorPos()) return
-  settle()
-})
-
-var rect0 = root.getBoundingClientRect()
-state.left = rect0.left
-state.top = rect0.top
-express()
-render()
-applySoundSet()
-setupHitTest()
-fetch(SIZE_URL, { cache: 'no-store' })
-  .then(function (r) { return r.json() })
-  .then(function (d) {
-    if (d && typeof d.scale === 'number' && d.scale >= MIN_SCALE - 0.1 && d.scale <= MAX_SCALE + 0.1) {
-      state.scale = d.scale
-      root.style.setProperty('--dshw-scale', String(d.scale))
-      scaleInput.value = String(d.scale)
-      scaleNumber.value = String(scaleToDisplay(d.scale))
-      settle()
-    }
-    if (d && typeof d.vol === 'number') {
-      soundVol = d.vol
-      soundOn = soundVol > 0
-      volInput.value = String(soundVol)
-      volPct.textContent = Math.round(soundVol * 100) + '%'
+export default {
+  name: 'whale-balance-widget',
+  inject: ['webServer', 'credentials', 'connection'],
+  apply(ctx) {
+    // —— 浏览器信任栅栏（对应 issue #92）——
+    // dsh 的 connection 服务提供 requestRejection(req)：Host/Origin 被伪造（DNS 重绑定）
+    // 或未认证的请求必须被拒。官方插件（如 dsh-host-open-in-app）在自定义路由里都会先调用；
+    // 本插件所有 /dsh-whale/* 路由同样必须走一遍，否则接口可被任意网页读写。
+    function rejected(req, res) {
       try {
-        if (pressAudio) pressAudio.volume = soundVol
-        if (releaseAudio) releaseAudio.volume = soundVol
-      } catch (err) {}
-    }
-    if (d && typeof d.soundSet === 'string') {
-      soundSet = d.soundSet === 'fx1' ? 'fx1' : 'duck'
-      soundSelect.value = soundSet
-      applySoundSet()
-    }
-    if (d && typeof d.usageMode === 'string') {
-      usageMode = d.usageMode === 'token' ? 'token' : 'ledger'
-      usageSelect.value = usageMode
-    }
-    if (d && typeof d.peakMode === 'string') {
-      peakMode = d.peakMode === 'liangwen' || d.peakMode === 'qiangqiang' ? d.peakMode : 'default'
-      peakSelect.value = peakMode
-    }
-    if (d && typeof d.bubbleOn === 'boolean') {
-      bubbleOn = d.bubbleOn
-      bubbleToggle.checked = bubbleOn
-    }
-    if (d && typeof d.turnCostOn === 'boolean') {
-      turnCostOn = d.turnCostOn
-      turnCostToggle.checked = turnCostOn
-      turnCostCloseInput.disabled = !turnCostOn
-    }
-    if (d && typeof d.turnCostCloseMs === 'number') {
-      turnCostCloseMs = d.turnCostCloseMs > 0 ? d.turnCostCloseMs : 0
-      turnCostCloseInput.value = String(Math.round(turnCostCloseMs / 1000))
-    }
-    if (d && typeof d.scrollGapOn === 'boolean') {
-      scrollGapOn = d.scrollGapOn
-      scrollGapToggle.checked = scrollGapOn
-      scrollGapInput.disabled = !scrollGapOn
-    }
-    if (d && typeof d.scrollGapPx === 'number') {
-      scrollGapPx = d.scrollGapPx > 0 ? Math.round(d.scrollGapPx) : 0
-      scrollGapInput.value = String(scrollGapPx)
-    }
-    // 相对边框恢复（localStorage 锚点）：窗口变化后保持离边距离。
-    // 仅认 v:2 净距离格式；旧格式（含避让距离）废弃，挂件保持默认右下角吸附。
-    // 恢复时还原吸附状态（hAnchor/vAnchor → state.h/v），避免挂件变自由位置
-    // 导致避让调节不实时（settle 自由分支只 clamp 不重算位置）。
-    try {
-      var a = JSON.parse(localStorage.getItem('dshw-pos') || 'null')
-      if (a && a.v === 2 && (a.hAnchor === 'left' || a.hAnchor === 'right') && typeof a.hDist === 'number' &&
-          (a.vAnchor === 'top' || a.vAnchor === 'bottom') && typeof a.vDist === 'number') {
-        var vpA = viewport()
-        var wA = root.offsetWidth || root.getBoundingClientRect().width || 0
-        var hA = root.offsetHeight || root.getBoundingClientRect().height || 0
-        // 锚点存的是净距离：右锚点按当前避让开关叠加避让距离
-        var effectiveRightDist = a.hAnchor === 'right' ? a.hDist + (scrollGapOn ? rightGap() : 0) : a.hDist
-        var lA = a.hAnchor === 'left' ? a.hDist : vpA.w - effectiveRightDist - wA
-        var tA = a.vAnchor === 'top' ? a.vDist : vpA.h - a.vDist - hA
-        state.left = clamp(lA, 0, Math.max(0, vpA.w - wA))
-        state.top = clamp(tA, 0, Math.max(0, vpA.h - hA))
-        // 按锚点还原吸附状态（贴边锚点 → 吸附；自由位锚点 → 自由）
-        state.h = a.hAnchor
-        state.hOff = 0
-        state.v = a.vAnchor
-        state.vOff = 0
-        settle()
-      }
-    } catch (err) {}
-    refresh(false)
-  })
-  .catch(function () { refresh(false) })
-setInterval(function () { refresh(false) }, REFRESH_MS)
-
-// —— 每轮对话消耗检测：轮询 last-turn.json，出现新 seq 时弹消耗金额泡泡 ——
-var LAST_TURN_URL = '/dsh-whale/last-turn.json'
-var lastCostSeq = 0
-var lastCostAligned = false
-function pollLastTurn() {
-  try {
-    fetch(LAST_TURN_URL, { cache: 'no-store' })
-      .then(function (r) { return r.json() })
-      .then(function (d) {
-        if (!d || !d.ok || typeof d.seq !== 'number') return
-        if (!lastCostAligned) {
-          // 首次拿到数据：只对齐 seq，不弹旧轮次
-          lastCostSeq = d.seq
-          lastCostAligned = true
-          return
-        }
-        if (d.seq > lastCostSeq) {
-          lastCostSeq = d.seq
-          if (d.turn !== null && d.amount !== null) {
-            showCostBubble(Number(d.amount))
+        const conn = ctx.get('connection') || ctx.connection
+        if (!conn || typeof conn.requestRejection !== 'function') {
+          // fail-open：此刻栅栏不可用（connection 服务缺失）。inject 已声明该服务，正常不会走到这里；
+          // 打一条 warn 便于发现"栅栏实际失效"，而不是静默放行
+          if (!rejected.warned) {
+            rejected.warned = true
+            try { console.warn('[whale-balance] 信任栅栏不可用：connection 服务缺失，自定义路由将放行处理') } catch (err) {}
           }
+          return false
         }
+        const code = conn.requestRejection(req)
+        if (code === undefined || code === null || code === false) return false
+        res.statusCode = typeof code === 'number' ? code : 403
+        res.end()
+        return true
+      } catch (err) { return false }
+    }
+    // 统一注册入口：所有路由自动套上信任栅栏
+    function registerRoute(route) {
+      const inner = route && route.handler
+      const wrapped = Object.assign({}, route, {
+        handler: async (req, res) => {
+          if (rejected(req, res)) return
+          return inner(req, res)
+        },
       })
-      .catch(function () {})
-  } catch (err) {}
-}
-setInterval(pollLastTurn, 1000)
-})()`
-
-
-const name = 'whale-balance-widget'
-const inject = ['webServer', 'credentials']
-
-function apply(ctx) {
+      return ctx.webServer.register(wrapped)
+    }
     let imageBytes = null
     let balanceCache = null
     let balanceInFlight = null
     let gifBytes = null
     // 每轮对话消耗统计：按 (session.id, turn) 分桶聚合，完成后写入 lastTurn。
     // 用 Map 分桶避免主会话与子代理（spawn/fork）并行时串账。
-    let turnAggs = new Map() // sessionId -> { turn, cost, tokens, lastTs }
+    let turnAggs = new Map() // sessionId -> { turn, cost, tokens, byModel, byModelTokens, lastTs }
     let lastTurn = null // { turn, amount, tokens, ts }
     let lastTurnSeq = 0
     const disposers = []
 
+    // 持久化 seq：热重载/重启后 seq 继续递增，前端不会把新轮次误判为旧轮次
+    function readTurnSeq() {
+      for (const p of TURN_FILE_CANDIDATES) {
+        try {
+          const parsed = JSON.parse(fs.readFileSync(p, 'utf8'))
+          if (parsed && typeof parsed.seq === 'number' && parsed.seq >= 0) return parsed.seq
+        } catch (err) {}
+      }
+      return 0
+    }
+    function writeTurnSeq(seq) {
+      const body = JSON.stringify({ seq, updatedAt: new Date().toISOString() })
+      for (const p of TURN_FILE_CANDIDATES) {
+        try { fs.writeFileSync(p, body, 'utf8'); return } catch (err) {}
+      }
+    }
+    lastTurnSeq = readTurnSeq()
+
     function finalizeTurn(sessionId) {
       const agg = turnAggs.get(sessionId)
       if (agg && agg.cost > 0) {
         lastTurn = { turn: agg.turn, amount: agg.cost, tokens: agg.tokens, ts: agg.lastTs }
         lastTurnSeq++
+        writeTurnSeq(lastTurnSeq)
+        // 按模型拆分写入用量事件(模型明细的唯一来源)
+        const byModel = agg.byModel || {}
+        const byModelTokens = agg.byModelTokens || {}
+        const modelNames = Object.keys(byModel)
+        if (modelNames.length) {
+          for (const mname of modelNames) {
+            appendUsageEvent({ ts: agg.lastTs, model: mname, cost: byModel[mname], tokens: byModelTokens[mname] || 0 })
+            // 自定义模型：按 matchIds 归属到注册表里的模型（余额差不可用时作为该模型的今日已用兜底）
+            apiAttributeEvent(mname, byModel[mname], byModelTokens[mname] || 0)
+          }
+        } else {
+          appendUsageEvent({ ts: agg.lastTs, model: '未知', cost: agg.cost, tokens: agg.tokens })
+        }
       }
       turnAggs.delete(sessionId)
     }
@@ -1455,19 +605,38 @@ function apply(ctx) {
         let agg = turnAggs.get(sessionId)
         if (!agg || agg.turn !== turn) {
           if (agg) finalizeTurn(sessionId)
-          agg = { turn, cost: 0, tokens: 0, lastTs: Date.now() }
+          agg = { turn, cost: 0, tokens: 0, byModel: {}, byModelTokens: {}, lastTs: Date.now() }
           turnAggs.set(sessionId, agg)
         }
         const input = Number(usage.inputTokens) || 0
         const cache = Number(usage.cacheReadTokens) || 0
         const output = Number(usage.outputTokens) || 0
         const reasoning = Number(usage.reasoningTokens) || 0
-        agg.tokens += input + cache + output + reasoning
-        // 定价换算（CNY/百万 token；缓存命中=输入价，其余按各自档位）
+        // 口径修正（issue #89 / PR #83）：dsh 保证 reasoningTokens ⊆ outputTokens
+        // （见 dsh-token-meter 的校验 reasoningTokens > outputTokens 即判非法），
+        // 所以 reasoning 不能再单独累加 —— 否则输出侧按输出价被重复计费（实测偏高约一倍）。
+        // 兜底：万一某 provider 上报的 reasoning 不是 output 的子集（reasoning > output），
+        // 就把差额补回计费输出，避免另一种口径下少算
+        const outputBilled = reasoning > output ? output + reasoning : output
+        const toks = input + cache + outputBilled
+        agg.tokens += toks
+        // 定价换算（CNY/百万 token；缓存命中=输入价，其余按各自档位），并按模型拆分
         const model = d.message && d.message.source ? d.message.source.model : ''
+        // 每轮结算前刷新一次自定义单价（10 秒节流），让自定义 API 模型用用户填的价格计费
+        try { refreshCustomPrices() } catch (err) {}
         const p = priceFor(model)
         const off = isPeakTime(Math.floor(Date.now() / 1000)) ? 1 : 0
-        agg.cost += (cache / 1e6) * p.hit[off] + (input / 1e6) * p.miss[off] + ((output + reasoning) / 1e6) * p.out[off]
+        let costMsg = (cache / 1e6) * p.hit[off] + (input / 1e6) * p.miss[off] + (outputBilled / 1e6) * p.out[off]
+        // 自定义单价若按美元填写，按用户填的汇率换算成人民币（账本统一按 CNY 记账）
+        try {
+          const meta = customPriceMetaFor(model)
+          if (meta && meta.cur === 'USD' && Number(meta.rate) > 0) costMsg = costMsg * Number(meta.rate)
+        } catch (err) {}
+        agg.cost += costMsg
+        if (model) {
+          agg.byModel[model] = (agg.byModel[model] || 0) + costMsg
+          agg.byModelTokens[model] = (agg.byModelTokens[model] || 0) + toks
+        }
         agg.lastTs = Date.now()
       } catch (err) {}
     }
@@ -1576,65 +745,6 @@ function apply(ctx) {
       }
     }
 
-    async function fetchUsage() {
-      let cred
-      try {
-        cred = await ctx.credentials.resolve('DEEPSEEK_PLATFORM_TOKEN')
-      } catch (err) {
-        return { error: 'platform cred resolve failed' }
-      }
-      if (!cred) return { error: 'no platform token' }
-      const token = String(cred.value).replace(/^Bearer\s+/i, '')
-      try {
-        const now = new Date()
-        const tz = -now.getTimezoneOffset() * 60
-        const start = Math.floor(new Date(now.getFullYear(), now.getMonth(), now.getDate()).getTime() / 1000)
-        const end = start + 86400
-        const url = 'https://platform.deepseek.com/api/v0/usage/by_api_key/amount?start=' + start + '&end=' + end + '&tz=' + tz
-        const res = await fetch(url, {
-          headers: { Authorization: 'Bearer ' + token },
-          signal: AbortSignal.timeout(15000),
-        })
-        if (!res.ok) return { error: 'http ' + res.status }
-        const data = await res.json()
-        const u = computeTodayUsage(data)
-        if (u && isFinite(u.amount)) return { amount: u.amount, tokens: u.tokens }
-        return { error: 'no usage' }
-      } catch (err) {
-        return { error: String((err && err.message) || err) }
-      }
-    }
-
-    function computeTodayUsage(data) {
-      // data.data.biz_data.series[]: [{model, buckets:[{time, usage:{RESPONSE_TOKEN, PROMPT_CACHE_HIT_TOKEN, PROMPT_CACHE_MISS_TOKEN}}]}]
-      let d = data
-      if (d && d.data && d.data.biz_data && Array.isArray(d.data.biz_data.series)) d = d.data.biz_data
-      else if (d && d.data && Array.isArray(d.data.series)) d = d.data
-      const series = Array.isArray(d.series) ? d.series : null
-      if (!series || series.length === 0) return null
-      let cost = 0
-      let tokens = 0
-      let found = false
-      for (const s of series) {
-        if (!s || typeof s !== 'object') continue
-        const p = priceFor(s.model)
-        const buckets = Array.isArray(s.buckets) ? s.buckets : []
-        for (const b of buckets) {
-          const u = b && b.usage
-          if (!u || typeof u !== 'object') continue
-          const hit = Number(u.PROMPT_CACHE_HIT_TOKEN) || 0
-          const miss = Number(u.PROMPT_CACHE_MISS_TOKEN) || 0
-          const out = Number(u.RESPONSE_TOKEN) || 0
-          if (hit + miss + out === 0) continue
-          found = true
-          tokens += hit + miss + out
-          const pi = isPeakTime(b.time) ? 1 : 0
-          cost += (hit / 1e6) * p.hit[pi] + (miss / 1e6) * p.miss[pi] + (out / 1e6) * p.out[pi]
-        }
-      }
-      return found ? { amount: cost, tokens: tokens } : null
-    }
-
     function todayKey() {
       const d = new Date()
       const p = (n) => String(n).padStart(2, '0')
@@ -1659,82 +769,1235 @@ function apply(ctx) {
       }
       return false
     }
-    // 记账模式：每次观测到余额后，用余额正差值累计当天用量（跨天自动归零并归档）。
-    // 币种感知：观测币种与上次不同时只重置基准、不记差值——数值跳变来自币种
-    // 切换而非真实消费（[0] 选币时代 CNY/USD 随机切换曾记出巨额假账，见 #13）。
-    function recordLedgerUsage(currentBalance, currency) {
-      const t = todayKey()
-      let led = readUsageLedger()
-      const cur = String(currency || '')
-      const currencyChanged =
-        typeof led.lastCurrency === 'string' && led.lastCurrency !== '' &&
-        cur !== '' && led.lastCurrency !== cur
-      if (led.date !== t) {
-        if (led.date && typeof led.todayUsage === 'number') {
-          led.history = led.history || {}
-          led.history[led.date] = led.todayUsage
+    // —— 账本保留策略（v700）：events 保留 90 天或最多 2 万条；history 保留 365 天；
+    //    超期部分归档到 .dshw-usage-archive.json（不丢历史，只是移出主账本，避免账本无限膨胀）——
+    function usageArchivePath() {
+      for (const p of USAGE_FILE_CANDIDATES) {
+        try {
+          fs.accessSync(path.dirname(p), fs.constants.W_OK)
+          return path.join(path.dirname(p), '.dshw-usage-archive.json')
+        } catch (err) {}
+      }
+      return path.join(DSH_HOME, '.dshw-usage-archive.json')
+    }
+    function readUsageArchive() {
+      try {
+        const j = JSON.parse(fs.readFileSync(usageArchivePath(), 'utf8'))
+        if (j && typeof j === 'object') return j
+      } catch (err) {}
+      return { version: 1, events: [], history: {} }
+    }
+    // 返回 true 表示账本被裁剪过（调用方随后写盘即可）
+    function pruneLedgerUsage(led) {
+      try {
+        const ev = Array.isArray(led.events) ? led.events : []
+        const hist = (led.history && typeof led.history === 'object') ? led.history : {}
+        const dateCut90 = dayAdd(todayKey(), -90)
+        const dateCut365 = dayAdd(todayKey(), -365)
+        const keepEv = []
+        const dropEv = []
+        for (const e of ev) {
+          const day = String((e && e.day) || '')
+          if (day && day < dateCut90) dropEv.push(e)
+          else keepEv.push(e)
         }
-        led.date = t
-        led.lastBalance = currentBalance
-        led.lastCurrency = cur
-        led.todayUsage = 0
-      } else if (currencyChanged) {
-        // 币种切换：只换基准，不把差值记成消费
-        led.lastBalance = currentBalance
-        led.lastCurrency = cur
-      } else {
-        const prev = typeof led.lastBalance === 'number' ? led.lastBalance : currentBalance
-        if (typeof prev === 'number' && typeof currentBalance === 'number' && currentBalance < prev) {
-          led.todayUsage = (typeof led.todayUsage === 'number' ? led.todayUsage : 0) + (prev - currentBalance)
+        if (keepEv.length > 20000) {
+          const extra = keepEv.length - 20000
+          for (const e of keepEv.splice(0, extra)) dropEv.push(e)
         }
-        led.lastBalance = currentBalance
-        led.lastCurrency = cur
-      }
-      const keys = Object.keys(led.history || {}).sort()
-      while (keys.length > 30) {
-        delete led.history[keys.shift()]
-      }
-      writeUsageLedger(led)
-      return led
+        const dropHist = {}
+        let histDropped = 0
+        for (const day of Object.keys(hist)) {
+          if (String(day) < dateCut365) {
+            dropHist[day] = hist[day]
+            delete hist[day]
+            histDropped++
+          }
+        }
+        if (!dropEv.length && !histDropped) return false
+        const ar = readUsageArchive()
+        ar.events = Array.isArray(ar.events) ? ar.events : []
+        for (const e of dropEv) ar.events.push(e)
+        if (ar.events.length > 200000) ar.events.splice(0, ar.events.length - 200000)
+        ar.history = Object.assign({}, ar.history || {}, dropHist)
+        ar.updatedAt = new Date().toISOString()
+        ar.note = '小鲸鱼记账归档：events 超 90 天或超 2 万条、history 超 365 天的部分'
+        try { fs.writeFileSync(usageArchivePath(), JSON.stringify(ar), 'utf8') } catch (err) { return false }
+        led.events = keepEv
+        led.history = hist
+        return true
+      } catch (err) { return false }
     }
-    function normalizeUsageMode(m) {
-      return m === 'token' ? 'token' : 'ledger'
+    function dayKeyOfDate(d) {
+      const p = (n) => String(n).padStart(2, '0')
+      return d.getFullYear() + '-' + p(d.getMonth() + 1) + '-' + p(d.getDate())
     }
-
-    async function getBalancePayload() {
-      const payload = await fetchBalance()
-      if (!payload.ok) return payload
-      // 无论哪种模式，都先把余额观测记入账本（自动累积「鲸鱼记账」数据）
-      const led = recordLedgerUsage(Number(payload.totalBalance), payload.currency)
-      const cfg = readSizeConfig() || {}
-      const mode = normalizeUsageMode(cfg.usageMode)
-      const full = { ...payload }
-      full.isPeak = isPeakTime(Math.floor(Date.now() / 1000))
-      if (mode === 'ledger') {
-        full.todayUsage = led.todayUsage
-        full.usageMode = 'ledger'
-        return full
+    function dayKeyFromTs(ts) { return dayKeyOfDate(new Date(Number(ts))) }
+    function dayAdd(baseDayStr, delta) {
+      const d = new Date(baseDayStr + 'T00:00:00')
+      d.setDate(d.getDate() + delta)
+      return dayKeyOfDate(d)
+    }
+    function round2(x) { return Math.round((Number(x) || 0) * 100) / 100 }
+    // 每轮结算后追加一条用量事件(模型明细/7天/全部记录的来源;上限 8000 条)
+    function appendUsageEvent(ev) {
+      const led = readUsageLedger()
+      led.events = Array.isArray(led.events) ? led.events : []
+      led.events.push({
+        ts: Number(ev.ts) || Date.now(),
+        day: dayKeyFromTs(ev.ts),
+        model: String(ev.model || '未知'),
+        cost: round2(ev.cost),
+        tokens: Math.round(Number(ev.tokens) || 0),
+      })
+      // 保留策略：events 90 天 / 最多 2 万条（超期或超量归档到 .dshw-usage-archive.json）
+      pruneLedgerUsage(led)
+      writeUsageLedger(led)
+    }
+    // 供面板/窗口使用的汇总:今日(按模型降序)、近7天、7天合计、全部记录
+    function usageRecordsPayload() {
+      const led = readUsageLedger()
+      const events = Array.isArray(led.events) ? led.events : []
+      const history = led.history && typeof led.history === 'object' ? led.history : {}
+      const today = dayKeyFromTs(Date.now())
+      function sumEv(d) { let s = 0; for (const e of events) if (e.day === d) s += Number(e.cost) || 0; return s }
+      // 当日真实消费 = 零点起始余额 − 当前余额(官方按真实扣款计,事件漏记时用它兜底)
+      function realDelta() {
+        if (typeof led.dayStart === 'number' && typeof led.lastBalance === 'number') {
+          const d = led.dayStart - led.lastBalance
+          if (d > 0) return d
+        }
+        return 0
       }
-      // token：尝试平台令牌实时计算
-      let cred = null
-      try {
-        cred = await ctx.credentials.resolve('DEEPSEEK_PLATFORM_TOKEN')
-      } catch (err) {}
-      if (cred) {
-        const u = await fetchUsage()
-        if (u && u.amount !== undefined) {
-          full.todayUsage = u.amount
-          full.usageMode = 'token'
-          return full
+      // 单日合计:事件合计优先,其次历史归档值;今天以真实余额差为准——
+      // 官方账单按真实扣款计,事件计价可能出现系统性偏高(如重复/口径差异),
+      // 而余额差(零点余额−当前余额)与官网几乎一致,故今日不再与事件取大。
+      function totalDay(d) {
+        if (d === today) {
+          const dd = realDelta()
+          if (dd > 0) return round2(dd)
+          // 余额差不可用(充值/退款/无基准)时退回事件/历史
+          let v = sumEv(d)
+          const h = history[d]
+          if (typeof h === 'number' && h > v) v = h
+          return round2(v)
         }
+        let v = sumEv(d)
+        const h = history[d]
+        if (typeof h === 'number' && h > v) v = h
+        return round2(v)
       }
-      // 无令牌或令牌失败：回落记账模式
-      full.todayUsage = led.todayUsage
-      full.usageMode = 'ledger'
-      return full
-    }
-
-    function getBalance() {
+      function modelsFor(d) {
+        const map = {}
+        for (const e of events) {
+          if (e.day !== d) continue
+          const k = e.model || '未知'
+          map[k] = (map[k] || 0) + (Number(e.cost) || 0)
+        }
+        const names = Object.keys(map).sort((a, b) => map[b] - map[a])
+        const tot = totalDay(d)
+        const evSum = names.reduce((s, k) => s + map[k], 0)
+        const arr = names.map((k) => ({ model: k, cost: map[k] }))
+        // 今天:模型明细需与合计一致——
+        // 事件合计 > 余额差(事件偏高)时按比例压缩到合计;
+        // 事件合计 < 合计(事件漏记/余额差兜底)时补一行「未入明细」。
+        if (d === today && evSum > 0.0001 && evSum > tot + 0.004) {
+          const k = tot / evSum
+          for (const it of arr) it.cost = round2(it.cost * k)
+          const now = arr.reduce((s, it) => s + it.cost, 0)
+          const diff = round2(tot - now)
+          if (Math.abs(diff) > 0.004) {
+            if (diff > 0) arr[0].cost = round2(arr[0].cost + diff)
+            else arr[0].cost = round2(Math.max(0, arr[0].cost + diff))
+          }
+        }
+        arr.forEach((it) => { it.cost = round2(it.cost) })
+        // 今天若有“未入明细”的真实消费(事件漏记部分),补一行使合计对得上
+        if (d === today) {
+          const gap = tot - evSum
+          if (gap > 0.004) arr.push({ model: '(未入明细)', cost: round2(gap) })
+        }
+        arr.sort((a, b) => b.cost - a.cost)
+        return arr
+      }
+      const days7 = []
+      let total7 = 0
+      // 今天在最上,往后退 6 天
+      for (let i = 0; i <= 6; i++) {
+        const d = dayAdd(today, -i)
+        const t = totalDay(d)
+        total7 += t
+        days7.push({ date: d, total: round2(t), models: modelsFor(d) })
+      }
+      const daySet = {}
+      Object.keys(history).forEach((d) => { if (/^\d{4}-\d{2}-\d{2}$/.test(d)) daySet[d] = 1 })
+      events.forEach((e) => { if (/^\d{4}-\d{2}-\d{2}$/.test(e.day)) daySet[e.day] = 1 })
+      const allDays = Object.keys(daySet).sort().reverse().map((d) => ({ date: d, total: totalDay(d), models: modelsFor(d) }))
+      const latestEvents = events.slice().sort((a, b) => b.ts - a.ts).slice(0, 500)
+      return {
+        ok: true,
+        today: { total: totalDay(today), models: modelsFor(today) },
+        days7: days7,
+        total7: round2(total7),
+        all: { days: allDays, events: latestEvents },
+        settings: readUsageSettings(),
+      }
+    }
+    // 用量相关设置(任务结束音 / 余额预警 / 今日预算)存于用量账本 settings
+    function usageSettingsDefaults() {
+      return {
+        // 任务结束音：默认关闭，但默认已选中内置的 Minecraft·经验球（exp_orb），打开即用
+        taskEnd: { on: false, sel: 'frag:exp_orb' },
+        // 默认固化自开发环境当前 usage.json 设置(全新安装即此体验)
+        // ⚠️ 这里的 alert / budget / turnCost 内容与前端 whale-widget.js 的
+        //    usageRemindDefaultLines() / usageTurnCostDefaultLines() **必须逐字段一致**
+        //    (host = 新用户默认内容；前端 = 编辑器里「恢复默认」的目标内容)。改一处必须同步另一处。
+        alert: {
+          on: true, below: 5,
+          msg: '余额预警:当前余额已低于设定值 {below}',
+          lines: [
+            { type: 'text', text: '老大~你的DS余额', size: 5, bold: true },
+            { type: 'text', text: '已经不足', size: 5, bold: true, row: 2 },
+            { type: 'text', text: '¥{below}', size: 5, bold: true, rgb: 'rouge', color: '', bgRgb: '', bg: '', row: 2 },
+            { type: 'text', text: '啦~', size: 5, bold: true, row: 2 },
+            { type: 'image', imgId: 'bimg_money1', size: 6, imgScale: 0.4 },
+            { type: 'link', text: '>> 喂 点 米 <<', url: 'https://platform.deepseek.com/top_up', size: 1, color: '#ffffff', rgb: '', bgRgb: 'indigo', bg: '', bold: true, ul: false },
+          ],
+          autoClose: false, ttlSec: 6,
+        },
+        budget: {
+          on: true, amount: 10,
+          msg: '今日已用已达预算 ¥{amount}',
+          lines: [
+            { type: 'text', text: '老大，今天花销已经超过', size: 6, bold: true, row: 1 },
+            { type: 'text', text: '¥{amount}', size: 7, bold: true, row: 1, rgb: 'rouge', color: '', italic: false, bgRgb: '', bg: '' },
+            { type: 'text', text: '啦，再花要变成穷光蛋啦...', size: 6, bold: true, row: 1 },
+          ],
+          autoClose: false, ttlSec: 6,
+        },
+        // 每轮消耗提示内容(自定义提示窗口):与预警/预算同一套模块化内容,{cost} = 本轮消耗金额。
+        // 内容 = 冻结的当前生效快照(与前端 usageTurnCostDefaultLines() 一致)；
+        // 开关/自动关闭秒数仍存 .dshw-size.json(不迁移),这里只放内容。
+        turnCost: {
+          lines: [
+            { type: 'text', text: '上一轮对话消耗:', size: 8, bold: true },
+            { type: 'text', text: '¥ {cost}', size: 24, bold: true, color: '#e0433f' },
+            { type: 'today', size: 2, tpl: '今日已用 {expense_ds}', bold: false, rgb: '', color: '#ffffff', bgRgb: 'indigo', bg: '' },
+          ],
+        },
+      }
+    }
+    function readUsageSettings() {
+      const led = readUsageLedger()
+      const d = usageSettingsDefaults()
+      const s = led && led.settings && typeof led.settings === 'object' ? led.settings : {}
+      if (s.taskEnd && typeof s.taskEnd === 'object') d.taskEnd = Object.assign({}, d.taskEnd, s.taskEnd)
+      if (s.alert && typeof s.alert === 'object') d.alert = Object.assign({}, d.alert, s.alert)
+      if (s.budget && typeof s.budget === 'object') d.budget = Object.assign({}, d.budget, s.budget)
+      if (s.turnCost && typeof s.turnCost === 'object') d.turnCost = Object.assign({}, d.turnCost, s.turnCost)
+      // 每个模型各自的提醒/预算：内置 DeepSeek 沿用顶层 alert/budget（旧配置零迁移）
+      const byModel = s.models && typeof s.models === 'object' ? s.models : {}
+      // 手动额度默认值：资源包/订阅制厂商没有额度接口时，总量与已用由用户在面板里手填
+      const qDef = () => ({ on: false, mode: 'auto', total: 0, unit: 'tokens', used: 0, reset: 'none', baseAt: 0 })
+      d.models = { [API_BUILTIN_ID]: { alert: d.alert, budget: d.budget, quota: Object.assign(qDef(), (byModel[API_BUILTIN_ID] && byModel[API_BUILTIN_ID].quota) || {}) } }
+      for (const m of readApiRegistry().models) {
+        if (!m || !m.id || m.id === API_BUILTIN_ID) continue
+        const st = byModel[m.id] && typeof byModel[m.id] === 'object' ? byModel[m.id] : {}
+        d.models[m.id] = {
+          alert: Object.assign({}, usageSettingsDefaults().alert, st.alert || {}),
+          budget: Object.assign({}, usageSettingsDefaults().budget, st.budget || {}),
+          quota: Object.assign(qDef(), st.quota || {}),
+        }
+      }
+      return d
+    }
+    function writeUsageSettings(patch) {
+      const led = readUsageLedger()
+      led.settings = led.settings && typeof led.settings === 'object' ? led.settings : {}
+      const p = patch || {}
+      if (p.taskEnd && typeof p.taskEnd === 'object') led.settings.taskEnd = Object.assign({}, led.settings.taskEnd || {}, p.taskEnd)
+      if (p.alert && typeof p.alert === 'object') led.settings.alert = Object.assign({}, led.settings.alert || {}, p.alert)
+      if (p.budget && typeof p.budget === 'object') led.settings.budget = Object.assign({}, led.settings.budget || {}, p.budget)
+      // 每轮消耗提示内容(自定义提示窗口)
+      if (p.turnCost && typeof p.turnCost === 'object') led.settings.turnCost = Object.assign({}, led.settings.turnCost || {}, p.turnCost)
+      // 按模型保存提醒/预算：{ modelId, alert?, budget? }
+      if (p.modelSettings && p.modelSettings.id) {
+        const mid = String(p.modelSettings.id)
+        led.settings.models = led.settings.models && typeof led.settings.models === 'object' ? led.settings.models : {}
+        const cur = led.settings.models[mid] && typeof led.settings.models[mid] === 'object' ? led.settings.models[mid] : {}
+        if (p.modelSettings.alert && typeof p.modelSettings.alert === 'object') cur.alert = Object.assign({}, cur.alert || {}, p.modelSettings.alert)
+        if (p.modelSettings.budget && typeof p.modelSettings.budget === 'object') cur.budget = Object.assign({}, cur.budget || {}, p.modelSettings.budget)
+        // 手动额度：整体覆盖（总量/单位/已用/重置周期/统计模式/开关）
+        if (p.modelSettings.quota && typeof p.modelSettings.quota === 'object') {
+          const q = Object.assign({}, p.modelSettings.quota)
+          const wantReset = !!q.resetBase
+          delete q.resetBase
+          // 「重置基准」：把累计 token 的基准点设为当前值 → 已用从 0 重新计
+          if (wantReset) {
+            const u = apiUsageRaw(mid)
+            q.baseAt = Number(u && u.tokensTotal) || 0
+          }
+          cur.quota = Object.assign({}, cur.quota || {}, q)
+        }
+        led.settings.models[mid] = cur
+        // 内置 DeepSeek：同步回写顶层字段，旧读取方（泡泡提醒）不受影响
+        if (mid === API_BUILTIN_ID) {
+          if (cur.alert) led.settings.alert = cur.alert
+          if (cur.budget) led.settings.budget = cur.budget
+        }
+      }
+      if (!writeUsageLedger(led)) return { ok: false, error: '保存失败' }
+      return { ok: true, settings: readUsageSettings() }
+    }
+    // ===== Codex 本地会话统计（Codex 适配 · 第一期）=====
+    // 数据源：$CODEX_HOME/sessions/YYYY/MM/DD/rollout-*.jsonl 与 archived_sessions/*.jsonl（明文 JSONL）
+    //   每行：{ type, timestamp, ordinal, payload }
+    //   逐轮用量：type=token_count 的 payload.info.last_token_usage / total_token_usage
+    //   模型归属：type=turn_context 的 payload.model
+    // 口径：优先用「累计量的差值」（total_token_usage 单调递增，天然免疫一次轮次多条 token_count 的重复），
+    //       用量拆分按该事件的 last_token_usage 比例缩放；累计缺失时退回 last_token_usage。
+    // 缓存：$DSH_HOME/.dshw-codex.json（只存各文件聚合与 size/mtime，不存任何凭据，也不写 ~/.codex）
+    function codexHome() {
+      const env = String(process.env.CODEX_HOME || '').trim()
+      for (const c of [env, path.join(os.homedir(), '.codex')]) {
+        try { if (c && fs.existsSync(c)) return c } catch (err) {}
+      }
+      return ''
+    }
+    function readCodexCache() {
+      try {
+        const j = JSON.parse(fs.readFileSync(path.join(DSH_HOME, '.dshw-codex.json'), 'utf8'))
+        if (j && j.files && typeof j.files === 'object') return j
+      } catch (err) {}
+      return { version: 1, files: {} }
+    }
+    function writeCodexCache(c) {
+      try { fs.writeFileSync(path.join(DSH_HOME, '.dshw-codex.json'), JSON.stringify(c), 'utf8'); return true } catch (err) { return false }
+    }
+    function listCodexSessionFiles(root) {
+      const out = []
+      const walk = (dir, depth) => {
+        if (depth > 6) return
+        let ents = []
+        try { ents = fs.readdirSync(dir, { withFileTypes: true }) } catch (err) { return }
+        for (const e of ents) {
+          const p = path.join(dir, e.name)
+          if (e.isDirectory()) walk(p, depth + 1)
+          else if (/^rollout-.*\.jsonl$/i.test(e.name)) out.push(p)
+        }
+      }
+      walk(path.join(root, 'sessions'), 0)
+      walk(path.join(root, 'archived_sessions'), 0)
+      return out
+    }
+    // 解析单个会话文件 → { day: { model: {in,cached,cwrite,out,reason,total,turns} } }
+    function parseCodexFile(file) {
+      const days = {}
+      let model = 'codex'
+      let prevTotal = null
+      let lastRl = null, rlTs = 0
+      let text = ''
+      try { text = fs.readFileSync(file, 'utf8') } catch (err) { return { days, rl: null, rlTs: 0 } }
+      const bump = (day, mk, v) => {
+        days[day] = days[day] || {}
+        const cur = days[day][mk] || { in: 0, cached: 0, cwrite: 0, out: 0, reason: 0, total: 0, turns: 0 }
+        cur.in += v.in; cur.cached += v.cached; cur.cwrite += v.cwrite
+        cur.out += v.out; cur.reason += v.reason; cur.total += v.total; cur.turns += v.turns
+        days[day][mk] = cur
+      }
+      for (const line of text.split('\n')) {
+        if (!line || line.charCodeAt(0) !== 123) continue // 只处理 '{' 开头的行
+        let o = null
+        try { o = JSON.parse(line) } catch (err) { continue }
+        const p = o && o.payload
+        if (!p) continue
+        if (o.type === 'turn_context') {
+          if (p.model) model = String(p.model)
+          continue
+        }
+        if (o.type !== 'event_msg' || p.type !== 'token_count') continue
+        const info = p.info
+        if (!info || typeof info !== 'object') continue
+        const last = info.last_token_usage || null
+        const tot = info.total_token_usage || null
+        const ts = Date.parse(String(o.timestamp || '')) || 0
+        if (!ts) continue
+        const day = dayKeyFromTs(ts)
+        // 该次增量
+        let delta = null
+        const totAll = tot ? Number(tot.total_tokens) || 0 : 0
+        if (totAll > 0) {
+          if (prevTotal === null || totAll < prevTotal) delta = totAll
+          else delta = totAll - prevTotal
+          prevTotal = totAll
+        }
+        if (delta === null || delta <= 0) {
+          if (!last) continue
+          delta = Number(last.total_tokens) || 0
+        }
+        if (delta <= 0) continue
+        // 拆分：按 last_token_usage 的比例缩放到 delta
+        const lTotal = last ? Number(last.total_tokens) || 0 : 0
+        const k = (lTotal > 0 && last) ? delta / lTotal : 0
+        const v = last && k > 0
+          ? {
+            in: Math.round((Number(last.input_tokens) || 0) * k),
+            cached: Math.round((Number(last.cached_input_tokens) || 0) * k),
+            cwrite: Math.round((Number(last.cache_write_input_tokens) || 0) * k),
+            out: Math.round((Number(last.output_tokens) || 0) * k),
+            reason: Math.round((Number(last.reasoning_output_tokens) || 0) * k),
+          }
+          : { in: 0, cached: 0, cwrite: 0, out: 0, reason: 0 }
+        bump(day, model, { in: v.in, cached: v.cached, cwrite: v.cwrite, out: v.out, reason: v.reason, total: delta, turns: 1 })
+        // 订阅窗口快照：Codex 在 token_count 事件里带 rate_limits（ChatGPT 订阅 provider 才有值，
+        // DeepSeek 这类 API-key provider 是 null）。保留最新的非空快照，供第二期展示。
+        const rl = p.rate_limits
+        if (rl && typeof rl === 'object' && (rl.primary || rl.secondary || rl.plan_type || rl.credits)) {
+          if (ts >= rlTs) { lastRl = rl; rlTs = ts }
+        }
+      }
+      return { days, rl: lastRl, rlTs }
+    }
+    // rate_limits 字段名在不同 Codex 版本里不一致 → 多候选键容错，换算成「已用% + 重置时间戳」
+    function normalizeCodexWindow(w) {
+      if (!w || typeof w !== 'object') return null
+      const pick = (keys) => {
+        for (const k of keys) {
+          const raw = w[k]
+          if (raw === null || raw === undefined || raw === '') continue
+          const n = Number(raw)
+          if (isFinite(n)) return n
+        }
+        return null
+      }
+      let usedPct = pick(['used_percent', 'usedPercent', 'percent', 'used_pct', 'usage_percent', 'usagePercent'])
+      const remainPct = pick(['remaining_percent', 'remainingPercent', 'left_percent', 'remaining_pct'])
+      if (usedPct === null && remainPct !== null) usedPct = Math.max(0, 100 - remainPct)
+      let resetAt = null
+      const secs = pick(['resets_in_seconds', 'resetsInSeconds', 'reset_after_seconds', 'reset_in_seconds', 'seconds_until_reset'])
+      if (secs !== null && secs >= 0) resetAt = Date.now() + secs * 1000
+      else {
+        const abs = w.resets_at || w.reset_at || w.reset_time || w.next_reset || w.resetAt || w.nextResetTime
+        if (typeof abs === 'number' && isFinite(abs)) resetAt = abs < 1e12 ? abs * 1000 : abs
+        else if (typeof abs === 'string' && abs) { const t = Date.parse(abs); if (isFinite(t)) resetAt = t }
+      }
+      const windowMinutes = pick(['window_minutes', 'windowMinutes', 'window', 'period_minutes'])
+      const label = String(w.limit_name || w.name || w.label || w.window_name || '')
+      if (usedPct === null && resetAt === null) return null
+      return { usedPct, resetAt, windowMinutes, label }
+    }
+    function normalizeCodexRateLimits(rl) {
+      if (!rl || typeof rl !== 'object') return null
+      const primary = normalizeCodexWindow(rl.primary)
+      const secondary = normalizeCodexWindow(rl.secondary)
+      if (!primary && !secondary) return null
+      return {
+        primary, secondary,
+        planType: rl.plan_type ? String(rl.plan_type) : '',
+        limitName: rl.limit_name ? String(rl.limit_name) : (rl.limit_id ? String(rl.limit_id) : ''),
+        reached: rl.rate_limit_reached_type ? String(rl.rate_limit_reached_type) : '',
+      }
+    }
+    // 汇总（带增量缓存：只有变化的文件才重新解析）
+    function codexSummary() {
+      const home = codexHome()
+      if (!home) return { ok: false, error: '未找到 Codex 目录（$CODEX_HOME 或 ~/.codex）' }
+      const cache = readCodexCache()
+      const files = listCodexSessionFiles(home)
+      const keep = {}
+      let changed = 0
+      for (const f of files) {
+        let st = null
+        try { st = fs.statSync(f) } catch (err) { continue }
+        const prev = cache.files[f]
+        if (prev && prev.size === st.size && prev.mtimeMs === st.mtimeMs && prev.days) { keep[f] = prev; continue }
+        const parsed = parseCodexFile(f)
+        keep[f] = { size: st.size, mtimeMs: st.mtimeMs, days: parsed.days, rl: parsed.rl || null, rlTs: parsed.rlTs || 0 }
+        changed++
+      }
+      if (changed > 0 || Object.keys(cache.files).length !== Object.keys(keep).length) {
+        writeCodexCache({ version: 1, files: keep, builtAt: Date.now() })
+      }
+      const today = dayKeyFromTs(Date.now())
+      const month = today.slice(0, 7)
+      const byDay = {}
+      const byModel = {}
+      let totalTokens = 0, todayTokens = 0, monthTokens = 0, outTokens = 0, reasonTokens = 0, cachedTokens = 0
+      let bestRl = null, bestRlTs = -1
+      for (const f of Object.keys(keep)) {
+        if (keep[f].rl && (keep[f].rlTs || 0) >= bestRlTs) { bestRl = keep[f].rl; bestRlTs = keep[f].rlTs || 0 }
+        const days = keep[f].days || {}
+        for (const d of Object.keys(days)) {
+          const day0 = byDay[d] || (byDay[d] = { tokens: 0, turns: 0, models: {} })
+          for (const m of Object.keys(days[d])) {
+            const v = days[d][m] || {}
+            day0.tokens += Number(v.total) || 0
+            day0.turns += Number(v.turns) || 0
+            day0.models[m] = (day0.models[m] || 0) + (Number(v.total) || 0)
+            const bm = byModel[m] || (byModel[m] = { tokens: 0, out: 0, reason: 0, cached: 0, turns: 0 })
+            bm.tokens += Number(v.total) || 0
+            bm.out += Number(v.out) || 0
+            bm.reason += Number(v.reason) || 0
+            bm.cached += Number(v.cached) || 0
+            bm.turns += Number(v.turns) || 0
+            totalTokens += Number(v.total) || 0
+            outTokens += Number(v.out) || 0
+            reasonTokens += Number(v.reason) || 0
+            cachedTokens += Number(v.cached) || 0
+            if (d === today) todayTokens += Number(v.total) || 0
+            if (d.slice(0, 7) === month) monthTokens += Number(v.total) || 0
+          }
+        }
+      }
+      const days7 = []
+      for (let i = 0; i < 7; i++) {
+        const d = dayAdd(today, -i)
+        days7.push({ date: d, tokens: (byDay[d] && byDay[d].tokens) || 0, turns: (byDay[d] && byDay[d].turns) || 0 })
+      }
+      return {
+        ok: true, home, sessions: files.length, changed,
+        todayTokens, monthTokens, totalTokens,
+        outTokens, reasonTokens, cachedTokens,
+        days7, byModel,
+        // 第二期：订阅窗口（5h / 周）。仅当日志里带着带值的 rate_limits（ChatGPT 订阅 provider）时才有内容
+        rateLimits: bestRl,
+        windows: normalizeCodexRateLimits(bestRl),
+        rateLimitsTs: bestRlTs > 0 ? bestRlTs : 0,
+      }
+    }
+    // codexSummary 的短 TTL 记忆：payload 循环 + 额度计算 + 探活会在同一次请求里反复问同一份数据，
+    // 每次都同步 stat/读文件会白白阻塞事件循环（会话文件可能有几十 MB）
+    let codexMemo = null, codexMemoAt = 0
+    function codexSummaryCached() {
+      const now = Date.now()
+      if (codexMemo && now - codexMemoAt < 5000) return codexMemo
+      codexMemo = codexSummary()
+      codexMemoAt = now
+      return codexMemo
+    }
+    // 后台预热：codexSummary 首次要同步读全部 rollout 日志（可能几十 MB），
+    // 放在请求路径里会阻塞事件循环。这里在插件启动后预热一次，并每 5 分钟刷新一次缓存，
+    // 请求进来时通常直接命中 codexSummaryCached 的 5 秒记忆。
+    try {
+      setTimeout(function () { try { codexSummaryCached() } catch (err) {} }, 1500)
+      setInterval(function () { try { codexSummaryCached() } catch (err) {} }, 5 * 60 * 1000)
+    } catch (err) {}
+    // ===== 自定义 API 模型注册表（v655）=====
+    // 文件：$DSH_HOME/.dshw-api.json → { version, models:[…], usage:{ [id]:{day,dayStart,lastBalance,delta,eventCost} } }
+    // 密钥不落此文件：写入 DSH 官方凭据（ctx.credentials.set），读取走 credentials.resolve(keyRef)。
+    function defaultApiRegistry() { return { version: 1, models: [], usage: {} } }
+    function readApiRegistry() {
+      for (const p of API_FILE_CANDIDATES) {
+        try {
+          const parsed = JSON.parse(fs.readFileSync(p, 'utf8'))
+          if (parsed && Array.isArray(parsed.models)) {
+            if (!parsed.usage || typeof parsed.usage !== 'object') parsed.usage = {}
+            return parsed
+          }
+        } catch (err) {}
+      }
+      return defaultApiRegistry()
+    }
+    function writeApiRegistry(reg) {
+      const body = JSON.stringify(reg, null, 2)
+      for (const p of API_FILE_CANDIDATES) {
+        try { fs.writeFileSync(p, body, 'utf8'); return true } catch (err) {}
+      }
+      return false
+    }
+    function apiTemplateOf(provider) {
+      return API_TEMPLATES[String(provider || '')] || null
+    }
+    // 内置 DeepSeek 永远存在（不进注册表文件），其余来自注册表
+    function apiBuiltinModel() {
+      const t = API_TEMPLATES.deepseek
+      return { id: API_BUILTIN_ID, name: t.name, provider: 'deepseek', currency: t.currency, keyRef: t.keyRef, builtin: true, matchIds: ['deepseek'] }
+    }
+    function apiAllModels() {
+      const custom = readApiRegistry().models.filter((m) => m && m.id && m.id !== API_BUILTIN_ID)
+      return [apiBuiltinModel()].concat(custom)
+    }
+    function apiModelById(id) {
+      if (String(id || '') === API_BUILTIN_ID) return apiBuiltinModel()
+      return readApiRegistry().models.find((m) => m && m.id === id) || null
+    }
+    // JSON 取值：支持 a.b[0].c
+    function pickJsonPath(obj, pathStr) {
+      try {
+        const parts = String(pathStr || '').replace(/\[(\d+)\]/g, '.$1').split('.').filter((x) => x.length > 0)
+        let cur = obj
+        for (const p of parts) {
+          if (cur === null || cur === undefined) return undefined
+          cur = cur[p]
+        }
+        return cur
+      } catch (err) { return undefined }
+    }
+    function apiNum(v, scale) {
+      const n = Number(v)
+      if (!isFinite(n)) return null
+      const s = isFinite(Number(scale)) && Number(scale) > 0 ? Number(scale) : 1
+      return n * s
+    }
+    // v724 非空合并：over 里的空串 / undefined / null **不覆盖** base。
+    // 为什么需要：新建模型时表单里没填的字段会存成空串，若直接 Object.assign，
+    // 空串会把模板自带的接口地址 / 字段路径"盖掉"，余额就永远查不到（会报「未配置余额接口地址」）。
+    function mergeNonEmpty(base, over) {
+      const out = Object.assign({}, base || {})
+      const o = over && typeof over === 'object' ? over : {}
+      for (const k of Object.keys(o)) {
+        const v = o[k]
+        if (v === undefined || v === null || v === '') continue
+        if (v && typeof v === 'object' && !Array.isArray(v)) { out[k] = mergeNonEmpty(out[k], v); continue }
+        out[k] = v
+      }
+      return out
+    }
+    // v724 递归去空：写注册表时用。让"没填的字段"根本不存在 → 模板默认值继续生效（配合 mergeNonEmpty）
+    function stripEmptyDeep(o) {
+      if (Array.isArray(o)) return o
+      if (!o || typeof o !== 'object') return o
+      const out = {}
+      for (const k of Object.keys(o)) {
+        const v = stripEmptyDeep(o[k])
+        if (v === undefined || v === null || v === '') continue
+        if (v && typeof v === 'object' && !Array.isArray(v) && !Object.keys(v).length) continue
+        out[k] = v
+      }
+      return out
+    }
+    async function apiFetchJson(url, auth, key) {
+      const headers = {}
+      const a = String(auth == null ? 'Bearer {key}' : auth)
+      if (a) headers.Authorization = a.replace('{key}', key)
+      // v724：URL 里也支持 {key}（如 Gemini 的 ?key=… 形式；auth 传空串时不带 Authorization 头）
+      const u = String(url).replace('{key}', key)
+      const res = await fetch(u, { headers, signal: AbortSignal.timeout(15000) })
+      if (!res.ok) throw new Error('HTTP ' + res.status)
+      return await res.json()
+    }
+    // 测试连通性：优先模板的 probeUrl（如方舟 /api/v3/models），否则用余额接口/Base URL
+    // 从响应体里提炼「业务层错误」：有些接口（如智谱额度）key 不对也返回 HTTP 200，
+    // 真正的问题在 body 的 code/msg（例如「当前用户不存在coding plan」），必须报出来
+    function apiBusinessError(data) {
+      if (!data || typeof data !== 'object') return ''
+      if (data.success === false || data.ok === false) {
+        return String(data.msg || data.message || data.error || 'success=false').slice(0, 120)
+      }
+      const code = Number(data.code)
+      if (isFinite(code) && code !== 0 && code !== 200 && data.msg) return String(data.msg).slice(0, 120)
+      if (typeof data.error === 'string' && data.error) return data.error.slice(0, 120)
+      if (data.error && typeof data.error === 'object' && data.error.message) return String(data.error.message).slice(0, 120)
+      return ''
+    }
+    async function apiProbeModel(model) {
+      if (!model) return { ok: false, error: '模型不存在' }
+      const tpl = apiTemplateOf(model.provider) || {}
+      if (model.id === API_BUILTIN_ID) {
+        const r = await fetchBalance()
+        return r.ok ? { ok: true, detail: '余额 ' + r.totalBalance + ' ' + (r.currency || 'CNY') } : { ok: false, error: r.error || r.code }
+      }
+      // Codex 模式：本地会话统计即「探活结果」，不需要网络与密钥
+      if (tpl.kind === 'codex') {
+        const cs = codexSummaryCached()
+        const f = (n) => (n >= 100000000 ? (n / 100000000).toFixed(2) + '亿' : (n >= 10000 ? (n / 10000).toFixed(1).replace(/\.0$/, '') + '万' : String(Math.round(Number(n) || 0))))
+        if (cs && cs.ok) {
+          return { ok: true, detail: 'Codex 本地会话：今日 ' + f(cs.todayTokens) + ' · 本月 ' + f(cs.monthTokens) + ' · 累计 ' + f(cs.totalTokens) + ' tokens（' + cs.sessions + ' 个会话文件）' }
+        }
+        return { ok: false, error: (cs && cs.error) || '未找到 Codex 会话目录' }
+      }
+      let key = ''
+      try {
+        const cred = await ctx.credentials.resolve(model.keyRef || tpl.keyRef || '')
+        key = cred && cred.value ? String(cred.value) : ''
+      } catch (err) { key = '' }
+      if (!key) return { ok: false, error: '未配置 ' + (model.keyRef || tpl.keyRef || 'API key') }
+      const b = mergeNonEmpty(tpl.balance, model.balance) // v724：模型侧空串不再覆盖模板
+      const base = String(model.baseUrl || '').replace(/\/+$/, '')
+      const url = String(tpl.probeUrl || b.url || (base ? base + '/v1/models' : '')).replace('{base}', base)
+      if (!url) return { ok: false, error: '没有可测试的接口（请填余额接口或 Base URL）' }
+      try {
+        const data = await apiFetchJson(url, b.auth, key)
+        const bizErr = apiBusinessError(data)
+        if (bizErr) return { ok: false, error: '测试失败: ' + bizErr }
+        let detail = 'HTTP 200'
+        if (data && Array.isArray(data.data)) detail = '可用模型 ' + data.data.length + ' 个'
+        else if (data && data.data && Array.isArray(data.data.models)) detail = '可用模型 ' + data.data.models.length + ' 个'
+        return { ok: true, detail: detail }
+      } catch (err) {
+        return { ok: false, error: '测试失败: ' + String((err && err.message) || err).slice(0, 140) }
+      }
+    }
+    // 订阅额度（Coding Plan）解析：各厂商字段不同，统一归一成「已用% + 重置时间 + 档位」
+    //   zhipu:    data.limits[0].TOKENS_LIMIT.percentage（已用%）+ nextResetTime
+    //   kimi:     usage.remaining / usage.limit（剩余/总量）
+    //   minimax:  model_remains[0].current_interval_remaining_percent（剩余%）+ end_time(ms)
+    async function fetchModelQuota(model) {
+      if (!model) return { ok: false, error: '模型不存在' }
+      const tpl = apiTemplateOf(model.provider) || {}
+      const q = tpl.quota
+      if (!q || !q.url) return { ok: false, code: 'NO_QUOTA', error: '该厂商没有订阅额度接口' }
+      let key = ''
+      try {
+        const cred = await ctx.credentials.resolve(model.keyRef || tpl.keyRef || '')
+        key = cred && cred.value ? String(cred.value) : ''
+      } catch (err) { key = '' }
+      if (!key) return { ok: false, code: 'NO_KEY', error: '未配置 ' + (model.keyRef || tpl.keyRef || 'API key') }
+      const base = String(model.baseUrl || '').replace(/\/+$/, '')
+      const url = String(q.url).replace('{base}', base)
+      try {
+        const data = await apiFetchJson(url, q.auth, key)
+        const bizErr = apiBusinessError(data)
+        if (bizErr) return { ok: false, code: 'BIZ', error: bizErr }
+        const j = q.json || {}
+        const num = (v) => { const n = Number(v); return isFinite(n) ? n : null }
+        let usedPct = null, remainPct = null, resetAt = null, level = '', weeklyUsedPct = null
+        if (j.percent) { const p = num(pickJsonPath(data, j.percent)); if (p !== null) usedPct = p }
+        if (j.remainPct) {
+          const p = num(pickJsonPath(data, j.remainPct))
+          if (p !== null) { remainPct = p; if (usedPct === null) usedPct = Math.max(0, 100 - p) }
+        }
+        if (j.weeklyRemainPct) {
+          const p = num(pickJsonPath(data, j.weeklyRemainPct))
+          if (p !== null) weeklyUsedPct = Math.max(0, 100 - p)
+        }
+        if (j.remain && j.total) {
+          const r0 = num(pickJsonPath(data, j.remain))
+          const t0 = num(pickJsonPath(data, j.total))
+          if (r0 !== null && t0) {
+            remainPct = Math.max(0, Math.min(100, r0 / t0 * 100))
+            usedPct = Math.max(0, 100 - remainPct)
+          }
+        }
+        if (j.resetAt) resetAt = pickJsonPath(data, j.resetAt)
+        if (j.resetAtMs) { const ms = num(pickJsonPath(data, j.resetAtMs)); if (ms !== null) resetAt = ms }
+        if (j.level) level = String(pickJsonPath(data, j.level) || '')
+        if (usedPct === null && remainPct === null && !resetAt) {
+          return { ok: false, code: 'PARSE', error: '额度接口返回无法解析（字段路径不匹配）' }
+        }
+        return { ok: true, usedPct, remainPct, resetAt, level, weeklyUsedPct }
+      } catch (err) {
+        return { ok: false, code: 'HTTP', error: '额度接口请求失败: ' + String((err && err.message) || err).slice(0, 140) }
+      }
+    }
+    // 厂商回报「账号没有该订阅套餐」（如智谱的「当前用户不存在coding plan」）：
+    // 对没订阅的用户这行没意义，标记 hide 让前端不显示（真正的网络/密钥错误不隐藏）
+    function apiPlanNoPlan(msg) {
+      const s = String(msg || '').toLowerCase()
+      if (!s) return false
+      return s.indexOf('coding plan') >= 0 || s.indexOf('不存在') >= 0 || s.indexOf('未订阅') >= 0 ||
+        s.indexOf('not subscribed') >= 0 || s.indexOf('no plan') >= 0 || s.indexOf('no active') >= 0 ||
+        s.indexOf('subscription') >= 0
+    }
+    // 取某模型余额：DeepSeek 复用既有官方链路；其余按模板/自定义描述请求并解析
+    async function fetchModelBalance(model) {
+      if (!model) return { ok: false, code: 'NO_MODEL', error: '模型不存在' }
+      if (model.id === API_BUILTIN_ID) {
+        const r = await fetchBalance()
+        if (!r.ok) return r
+        return { ok: true, remaining: Number(r.totalBalance), currency: r.currency || 'CNY' }
+      }
+      const tpl = apiTemplateOf(model.provider) || {}
+      const b = mergeNonEmpty(tpl.balance, model.balance) // v724：模型侧空串不再覆盖模板
+      if (!b.url) return { ok: false, code: 'NO_URL', error: '未配置余额接口地址' }
+      let key = ''
+      try {
+        const cred = await ctx.credentials.resolve(model.keyRef || tpl.keyRef || '')
+        key = cred && cred.value ? String(cred.value) : ''
+      } catch (err) { key = '' }
+      if (!key) return { ok: false, code: 'NO_KEY', error: '未配置 ' + (model.keyRef || tpl.keyRef || 'API key') }
+      const base = String(model.baseUrl || '').replace(/\/+$/, '')
+      const url = String(b.url).replace('{base}', base)
+      try {
+        const data = await apiFetchJson(url, b.auth, key)
+        const j = b.json || {}
+        let remaining = null
+        let total = null
+        let used = 0
+        if (j.remaining) { const v = apiNum(pickJsonPath(data, j.remaining), j.scale); if (v !== null) remaining = v }
+        if (j.total) { const v = apiNum(pickJsonPath(data, j.total), j.scale); if (v !== null) total = v }
+        if (j.used) { const v = apiNum(pickJsonPath(data, j.used), j.scale); if (v !== null) used += v }
+        if (b.usage && b.usage.url) {
+          const u = b.usage
+          const d2 = await apiFetchJson(String(u.url).replace('{base}', base), u.auth || b.auth, key)
+          const j2 = u.json || {}
+          if (j2.used) { const v = apiNum(pickJsonPath(d2, j2.used), j2.scale); if (v !== null) used += v }
+        }
+        if (remaining === null && total !== null) remaining = total - used
+        if (remaining === null) return { ok: false, code: 'SHAPE', error: '接口返回里没找到配置的字段（检查 JSON 路径）' }
+        return { ok: true, remaining, total, used, currency: model.currency || tpl.currency || 'CNY' }
+      } catch (err) {
+        return { ok: false, code: 'HTTP', error: '余额接口请求失败: ' + String((err && err.message) || err).slice(0, 160) }
+      }
+    }
+    // 逐模型记录的骨架：跨天只重置「当日」字段，累计量（tokensTotal/tokensMonth）保留
+    function apiUsageNewDay(cur, day, dayKey) {
+      const prev = cur && typeof cur === 'object' ? cur : {}
+      const mk = String(dayKey || '').slice(0, 7)
+      return {
+        day: day, dayStart: null, lastBalance: null, delta: 0, eventCost: 0, eventTokens: 0, currency: '',
+        tokensTotal: Number(prev.tokensTotal) || 0,
+        month: mk,
+        tokensMonth: prev.month === mk ? (Number(prev.tokensMonth) || 0) : 0,
+      }
+    }
+    // 逐模型余额差记账（与 DeepSeek 账本同口径：当天首次观测为基准，之后累加下降额）
+    function apiRecordBalance(id, remaining) {
+      try {
+        const reg = readApiRegistry()
+        reg.usage = reg.usage && typeof reg.usage === 'object' ? reg.usage : {}
+        const day = todayKey()
+        let cur = reg.usage[id]
+        if (!cur || cur.day !== day) cur = apiUsageNewDay(cur, day, todayKey())
+        if (typeof remaining === 'number' && isFinite(remaining)) {
+          if (cur.dayStart === null || cur.dayStart === undefined) cur.dayStart = remaining
+          if (typeof cur.lastBalance === 'number' && remaining < cur.lastBalance - 0.000001) cur.delta = round2(cur.delta + (cur.lastBalance - remaining))
+          cur.lastBalance = remaining
+        }
+        reg.usage[id] = cur
+        writeApiRegistry(reg)
+        return cur
+      } catch (err) { return null }
+    }
+    // 今日已用：来源可能是「余额差」（厂商币种）或「会话事件金额」（已按自定义单价折算成人民币）。
+    // 两种来源币种不同 → 返回值必须带上 currency，前端显示与阈值比较都按它走，
+    // 否则 USD 单价的模型会把人民币数额渲染成 $、或拿两种单位直接比大小。
+    function apiTodayUsage(id, modelCurrency) {
+      const mcur = String(modelCurrency || 'CNY').toUpperCase() || 'CNY'
+      try {
+        const reg = readApiRegistry()
+        const cur = reg.usage && reg.usage[id]
+        if (!cur || cur.day !== todayKey()) return { amount: 0, source: 'none', currency: mcur }
+        if (typeof cur.delta === 'number' && cur.delta > 0.004) return { amount: round2(cur.delta), source: 'balance', currency: mcur }
+        return { amount: round2(Number(cur.eventCost) || 0), source: 'events', currency: 'CNY' }
+      } catch (err) { return { amount: 0, source: 'none', currency: mcur } }
+    }
+    function apiUsageRaw(id) {
+      try {
+        const reg = readApiRegistry()
+        return (reg.usage && reg.usage[id]) || null
+      } catch (err) { return null }
+    }
+    // 额度「已用」：自动模式用会话 token 统计（不重置=累计-基准，每日=今日，每月=本月）
+    function apiQuotaAutoUsed(id, q) {
+      const u = apiUsageRaw(id) || {}
+      const reset = (q && q.reset) || 'none'
+      // 单位是「金额（元）」时自动统计意义不成立：自动累计的是 token，不是钱。
+      // 这里直接回退成手动值（q.used），避免把 token 数当金额显示；界面上也约束为只能手动填写。
+      if (q && q.unit === 'money' && (q.mode === 'auto' || q.mode === 'codex')) {
+        return Math.round(Number(q.used) || 0)
+      }
+      // Codex 模式：已用 = Codex 本地会话统计的 token（按重置口径取今日/本月/累计）
+      if (q && q.mode === 'codex') {
+        const cs = codexSummaryCached()
+        const base = Number(q.used) || 0
+        if (!cs || !cs.ok) return base
+        if (reset === 'daily') return Math.round(Number(cs.todayTokens) || 0)
+        if (reset === 'monthly') return Math.round(Number(cs.monthTokens) || 0)
+        const baseAt = Number(q.baseAt) || 0
+        return Math.round(base + Math.max(0, (Number(cs.totalTokens) || 0) - baseAt))
+      }
+      if (reset === 'daily') return Math.round(Number(u.eventTokens) || 0)
+      if (reset === 'monthly') return Math.round(Number(u.tokensMonth) || 0)
+      const total = Number(u.tokensTotal) || 0
+      const baseAt = Number(q && q.baseAt) || 0
+      // used 在自动模式下表示「起始已用」（装机前已经用掉的部分）
+      return Math.round((Number(q && q.used) || 0) + Math.max(0, total - baseAt))
+    }
+    // 会话事件归属：把某模型的 token 花费累加到注册表里匹配的模型（matchIds 子串匹配）
+    function apiAttributeEvent(modelName, cost, tokens) {
+      try {
+        const name = String(modelName || '').toLowerCase()
+        if (!name) return false
+        const reg = readApiRegistry()
+        let hit = null
+        for (const m of reg.models) {
+          if (!m || !m.id) continue
+          const ids = Array.isArray(m.matchIds) && m.matchIds.length ? m.matchIds : [m.name, m.id]
+          for (const s of ids) {
+            const k = String(s || '').toLowerCase().trim()
+            if (k && name.indexOf(k) >= 0) { hit = m; break }
+          }
+          if (hit) break
+        }
+        if (!hit) return false
+        reg.usage = reg.usage && typeof reg.usage === 'object' ? reg.usage : {}
+        const day = todayKey()
+        let cur = reg.usage[hit.id]
+        if (!cur || cur.day !== day) cur = apiUsageNewDay(cur, day, todayKey())
+        cur.eventCost = round2((Number(cur.eventCost) || 0) + (Number(cost) || 0))
+        cur.eventTokens = (Number(cur.eventTokens) || 0) + (Number(tokens) || 0)
+        // 累计量：额度（资源包/订阅）按它算已用；跨天不清零
+        const tk = Number(tokens) || 0
+        cur.tokensTotal = (Number(cur.tokensTotal) || 0) + tk
+        const mk = todayKey().slice(0, 7)
+        if (cur.month !== mk) { cur.month = mk; cur.tokensMonth = 0 }
+        cur.tokensMonth = (Number(cur.tokensMonth) || 0) + tk
+        reg.usage[hit.id] = cur
+        writeApiRegistry(reg)
+        return true
+      } catch (err) { return false }
+    }
+    // 删除模型：注册表 + 逐模型设置 + 所有泡泡里引用该模型的模块（含并列 A/B 与模块库）
+    function apiDeleteModel(id) {
+      const mid = String(id || '')
+      if (!mid || mid === API_BUILTIN_ID) return { ok: false, error: '内置模型不可删除' }
+      const reg = readApiRegistry()
+      reg.models = reg.models.filter((m) => !(m && m.id === mid))
+      if (reg.usage) delete reg.usage[mid]
+      writeApiRegistry(reg)
+      // 删除模型后同样失效单价缓存（它可能带着自定义单价）
+      customPriceAt = 0
+      let removed = 0
+      try {
+        const led = readUsageLedger()
+        if (led.settings && led.settings.models && led.settings.models[mid]) {
+          delete led.settings.models[mid]
+          writeUsageLedger(led)
+        }
+      } catch (err) {}
+      try {
+        const cfg = loadBubbleConfig()
+        let changed = false
+        const stripItem = (obj) => {
+          if (!obj || typeof obj !== 'object') return
+          if (Array.isArray(obj.modules)) {
+            const before = obj.modules.length
+            obj.modules = obj.modules.filter((m) => !(m && m.modelId === mid))
+            removed += before - obj.modules.length
+            if (obj.modules.length !== before) changed = true
+          }
+          if (Array.isArray(obj.options)) {
+            for (const o of obj.options) if (o && o.item) stripItem(o.item)
+          }
+        }
+        // 泡泡步骤（含并列 A/B）
+        if (Array.isArray(cfg.items)) for (const it of cfg.items) stripItem(it)
+        // 模块库条目形态为 {id,name,module}
+        if (Array.isArray(cfg.lib)) {
+          for (let i = cfg.lib.length - 1; i >= 0; i--) {
+            const lb = cfg.lib[i]
+            if (lb && lb.module && lb.module.modelId === mid) { cfg.lib.splice(i, 1); changed = true; removed++; continue }
+            if (lb && lb.module) stripItem(lb.module)
+          }
+        }
+        if (changed) writeBubbleConfig(cfg)
+      } catch (err) {}
+      return { ok: true, removedModules: removed }
+    }
+    // 新增/更新模型；密钥（keyValue）若提供则写入 DSH 官方凭据
+    // 自定义单价表刷新：把每个自定义 API 模型的 matchIds → 价格表映射进来，供 module 级 priceFor 使用
+    // （priceFor 在模块作用域，读不到插件内的注册表，所以这里把结果写进 CUSTOM_PRICES）
+    let customPriceAt = 0
+    function refreshCustomPrices() {
+      const now = Date.now()
+      if (now - customPriceAt < 10000) return
+      customPriceAt = now
+      try {
+        const map = {}
+        const metaMap = {}
+        for (const m of readApiRegistry().models) {
+          // 内置模型（DeepSeek）跳过：它有自己的峰谷价表，不能被自定义单价覆盖
+          if (!m || m.id === API_BUILTIN_ID) continue
+          const pr = m && m.price
+          if (!pr) continue
+          const hit = Number(pr.hit), miss = Number(pr.miss), out = Number(pr.out)
+          const ok = (v) => (isFinite(v) ? v : 0)
+          if (!isFinite(hit) && !isFinite(miss) && !isFinite(out)) continue
+          const table = { hit: [ok(hit), ok(hit)], miss: [ok(miss), ok(miss)], out: [ok(out), ok(out)] }
+          const meta = { cur: String(pr.cur || 'CNY').toUpperCase(), rate: isFinite(Number(pr.rate)) ? Number(pr.rate) : 0 }
+          const ids = Array.isArray(m.matchIds) && m.matchIds.length ? m.matchIds : [m.name, m.id]
+          for (const s of ids) {
+            const k = String(s || '').toLowerCase().trim()
+            // 关键字过短（< 3 字符，如 pro/flash）极易误伤其它模型，直接忽略
+            if (k && k.length >= 3) { map[k] = table; metaMap[k] = meta }
+          }
+        }
+        CUSTOM_PRICES = map
+        CUSTOM_PRICE_META = metaMap
+      } catch (err) {}
+    }
+    async function apiSaveModel(input) {
+      const p = input || {}
+      const tpl = apiTemplateOf(p.provider)
+      if (!tpl) return { ok: false, error: '未知的厂商模板' }
+      const name = String(p.name || '').trim().slice(0, 30) || tpl.name
+      const keyRef = String(p.keyRef || tpl.keyRef || '').trim().slice(0, 64) || tpl.keyRef
+      const id = p.id ? String(p.id) : ('api_' + Date.now().toString(36) + '_' + Math.random().toString(36).slice(2, 7))
+      const reg = readApiRegistry()
+      let model = reg.models.find((m) => m && m.id === id)
+      if (!model) {
+        model = { id, createdAt: Date.now() }
+        reg.models.push(model)
+      }
+      model.name = name
+      model.provider = p.provider
+      model.currency = String(p.currency || tpl.currency || 'CNY').toUpperCase().slice(0, 8)
+      model.keyRef = keyRef
+      if (p.baseUrl !== undefined) model.baseUrl = String(p.baseUrl || '').slice(0, 300)
+      if (p.balance && typeof p.balance === 'object') {
+        // v724：空字段不写入（stripEmptyDeep）→ 模板默认值继续生效；
+        // 全部为空时直接删掉 model.balance，等于"完全用模板"
+        const balIn = stripEmptyDeep({
+          url: String(p.balance.url || '').slice(0, 500),
+          auth: String(p.balance.auth || '').slice(0, 200),
+          json: {
+            remaining: String((p.balance.json && p.balance.json.remaining) || '').slice(0, 200),
+            total: String((p.balance.json && p.balance.json.total) || '').slice(0, 200),
+            used: String((p.balance.json && p.balance.json.used) || '').slice(0, 200),
+            scale: isFinite(Number(p.balance.json && p.balance.json.scale)) ? Number(p.balance.json.scale) : undefined,
+          },
+        })
+        if (balIn && Object.keys(balIn).length) model.balance = balIn
+        else delete model.balance
+        if (p.balance.usage && p.balance.usage.url) {
+          model.balance = model.balance || {}
+          model.balance.usage = stripEmptyDeep({
+            url: String(p.balance.usage.url).slice(0, 500),
+            auth: String(p.balance.usage.auth == null ? '' : p.balance.usage.auth).slice(0, 200),
+            json: { used: String((p.balance.usage.json && p.balance.usage.json.used) || '').slice(0, 200), scale: isFinite(Number(p.balance.usage.json && p.balance.usage.json.scale)) ? Number(p.balance.usage.json.scale) : undefined },
+          })
+        }
+      }
+      // 会话事件归属：默认用「模型名」和「id」做子串匹配，用户可另填
+      // 自定义单价（元/百万 token）：缓存命中 / 未命中输入 / 输出。留空则沿用内置价目表
+      if (p.price && typeof p.price === 'object') {
+        const num = (v) => {
+          const s = String(v === undefined || v === null ? '' : v).trim()
+          if (s === '') return undefined
+          return isFinite(Number(s)) ? Number(s) : undefined
+        }
+        const pr = { hit: num(p.price.hit), miss: num(p.price.miss), out: num(p.price.out) }
+        const cur0 = String(p.price.cur || '').trim().toUpperCase().slice(0, 8)
+        const rate0 = num(p.price.rate)
+        const anyPrice = pr.hit !== undefined || pr.miss !== undefined || pr.out !== undefined
+        // 校验（为什么：不校验的话，负数/超大值会算出荒谬金额；USD 缺汇率会被静默当人民币记账）
+        const inRange = (v, max) => v === undefined || (v >= 0 && v <= max)
+        if (!inRange(pr.hit, 1000000) || !inRange(pr.miss, 1000000) || !inRange(pr.out, 1000000)) {
+          return { ok: false, error: '单价必须是 0–1000000 之间的数字（单位：币种/百万 token）' }
+        }
+        if (rate0 !== undefined && !(rate0 > 0 && rate0 <= 1000)) {
+          return { ok: false, error: '汇率必须是 0–1000 之间的正数（元/USD）' }
+        }
+        if (anyPrice && cur0 === 'USD' && !(rate0 > 0)) {
+          return { ok: false, error: '单价币种为美元时必须填写汇率（元/USD）' }
+        }
+        if (cur0) pr.cur = cur0
+        if (rate0 !== undefined) pr.rate = rate0
+        if (pr.hit === undefined && pr.miss === undefined && pr.out === undefined) delete model.price
+        else model.price = pr
+      } else if (p.price === null) {
+        delete model.price
+      }
+      writeApiRegistry(reg)
+      // 改完单价立即失效缓存：否则 refreshCustomPrices 的 10 秒节流会让新价最坏 10 秒后才生效
+      customPriceAt = 0
+      let keySaved = false
+      if (p.keyValue !== undefined && String(p.keyValue).length) {
+        try {
+          await ctx.credentials.set(keyRef, String(p.keyValue))
+          keySaved = true
+        } catch (err) {}
+      }
+      return { ok: true, id, keySaved }
+    }
+    // 列表（含实时余额与各模型提醒/预算）：余额并发取，失败只影响该项
+    async function apiModelsPayload() {
+      const models = apiAllModels()
+      const settings = readUsageSettings()
+      const out = []
+      let codexStats = null // Codex 本地会话统计（机器级，多个 codex 模型共享，算一次）
+      for (const m of models) {
+        let entry = {
+          id: m.id, name: m.name, provider: m.provider, currency: m.currency,
+          keyRef: m.keyRef, builtin: !!m.builtin, baseUrl: m.baseUrl || '',
+          matchIds: m.matchIds || [], settings: settings.models && settings.models[m.id] ? settings.models[m.id] : null,
+          price: m.price || null,
+          // 手动额度（订阅/资源包）：总量、单位、已用、重置周期；前端据此显示额度模块
+          quota: (settings.models && settings.models[m.id] && settings.models[m.id].quota)
+            ? Object.assign({}, settings.models[m.id].quota) : null,
+          balance: null, todayUsage: null, todayUsageCurrency: null, usageSource: 'none', error: null,
+        }
+        // 自动模式的「已用」由 host 按会话 token 统计（前端不自己算）
+        if (entry.quota) {
+          entry.quota.autoUsed = apiQuotaAutoUsed(m.id, entry.quota)
+          entry.quota.autoToday = Math.round(Number((apiUsageRaw(m.id) || {}).eventTokens) || 0)
+        }
+        // 把「接口描述」（url/请求头/字段）单独下发，供前端面板回填；
+        // entry.balance 是数值，不能当描述用（否则面板保存会用空值覆盖描述）
+        const tplE = apiTemplateOf(m.provider) || {}
+        entry.balanceDesc = mergeNonEmpty(tplE.balance, m.balance) // v724：空串不覆盖模板
+        if (m.id === API_BUILTIN_ID) {
+          entry.balanceMode = 'api'
+          entry.hasBalanceApi = true
+          try {
+            const cred = await ctx.credentials.resolve(m.keyRef || 'DEEPSEEK_API_KEY')
+            entry.hasKey = !!(cred && cred.value)
+          } catch (err) {}
+          try {
+            const p = await getBalance()
+            if (p && p.ok) {
+              entry.balance = Number(p.totalBalance)
+              entry.todayUsage = ledgerTodayTotal(readUsageLedger())
+              entry.todayUsageCurrency = 'CNY' // 内置 DeepSeek 走账本，一律人民币
+              entry.usageSource = 'ledger'
+            } else if (p) entry.error = p.error || p.code || '余额获取失败'
+          } catch (err) { entry.error = String((err && err.message) || err) }
+        } else {
+          let hasKey = false
+          try {
+            const cred = await ctx.credentials.resolve(m.keyRef || '')
+            hasKey = !!(cred && cred.value)
+          } catch (err) {}
+          entry.hasKey = hasKey
+          // 该模型实际生效的余额描述：模板默认 + 用户覆盖
+          const tplM = apiTemplateOf(m.provider) || {}
+          const balDesc = Object.assign({}, tplM.balance || {}, m.balance || {})
+          const hasBalanceApi = !!String(balDesc.url || '').trim()
+          entry.hasBalanceApi = hasBalanceApi
+          entry.probeUrl = String(tplM.probeUrl || '')
+          // 订阅额度（kind='quota' 的模板，如智谱/Kimi/MiniMax Coding）：前端据此显示额度行与模块
+          entry.planSupport = !!tplM.quota
+          // Codex 模式：不查余额、不需要密钥，直接给本地会话统计（今日/本月/累计/近7天）
+          if (tplM.kind === 'codex') {
+            if (!codexStats) codexStats = codexSummaryCached()
+            entry.codex = codexStats
+            entry.hasKey = true
+            entry.error = codexStats && codexStats.ok ? null : ((codexStats && codexStats.error) || '未找到 Codex 会话目录')
+          }
+          // 没有余额接口的厂商（如火山方舟）：余额显示「—」，只用会话事件估算
+          entry.balanceMode = hasBalanceApi ? 'api' : 'events'
+          if (hasBalanceApi && hasKey) {
+            const r = await fetchModelBalance(m)
+            if (r && r.ok) {
+              entry.balance = r.remaining
+              if (r.currency) entry.currency = r.currency
+              apiRecordBalance(m.id, r.remaining)
+              const u = apiTodayUsage(m.id, entry.currency || m.currency)
+              entry.todayUsage = u.amount
+              entry.usageSource = u.source
+              entry.todayUsageCurrency = u.currency
+            } else if (r) {
+              entry.error = r.error || r.code || '余额获取失败'
+            }
+          } else if (!hasBalanceApi) {
+            entry.error = null // 无余额接口不算错误
+          } else {
+            entry.error = '未配置 ' + (m.keyRef || 'API key')
+          }
+          // 订阅额度：有额度接口 + 有 key 才请求；失败只影响 plan 字段
+          if (tplM.quota && hasKey) {
+            try {
+              entry.plan = await fetchModelQuota(m)
+              if (entry.plan && !entry.plan.ok && apiPlanNoPlan(entry.plan.error)) entry.plan.hide = true
+            } catch (err) { entry.plan = { ok: false, error: String((err && err.message) || err) } }
+          }
+          if (entry.todayUsage === null) {
+            const u2 = apiTodayUsage(m.id, entry.currency || m.currency)
+            entry.todayUsage = u2.amount
+            entry.usageSource = u2.source
+            entry.todayUsageCurrency = u2.currency
+          }
+        }
+        out.push(entry)
+      }
+      return {
+        ok: true,
+        builtinId: API_BUILTIN_ID,
+        // v724：把模板的接口描述也下发（B 方案：前端选模板后直接回填这些字段）
+        templates: Object.keys(API_TEMPLATES).map((k) => ({
+          id: k, name: API_TEMPLATES[k].name, currency: API_TEMPLATES[k].currency,
+          keyRef: API_TEMPLATES[k].keyRef, builtin: !!API_TEMPLATES[k].builtin,
+          needsBaseUrl: !!API_TEMPLATES[k].needsBaseUrl,
+          hasBalance: !!String((API_TEMPLATES[k].balance || {}).url || '').trim(),
+          probeUrl: String(API_TEMPLATES[k].probeUrl || ''),
+          kind: String(API_TEMPLATES[k].kind || 'balance'),
+          balance: API_TEMPLATES[k].balance ? JSON.parse(JSON.stringify(API_TEMPLATES[k].balance)) : null,
+          quota: API_TEMPLATES[k].quota ? JSON.parse(JSON.stringify(API_TEMPLATES[k].quota)) : null,
+          matchIds: Array.isArray(API_TEMPLATES[k].matchIds) ? API_TEMPLATES[k].matchIds.slice(0, 12) : [],
+          noBalanceApi: !!API_TEMPLATES[k].noBalanceApi,
+          apiNote: String(API_TEMPLATES[k].apiNote || ''),
+          sortKey: tplSortKey(API_TEMPLATES[k].name), // v726：下拉排序键（前端按它排）
+        })),
+        models: out,
+      }
+    }
+
+    // 记账：跨天时以当天第一次观测到的余额为“当日零点起始余额 dayStart”；
+    // 当天内每次观测都滚动刷新 lastBalance,不再因“今天已有事件”而提前返回——
+    // 事件明细可能因会话中断/重启漏记,真实余额差(dayStart−lastBalance)始终可算。
+    // 归档以真实余额差为准(与官网一致,事件计价偏高时不被带高);余额差不可用时才用事件。
+    function recordLedgerUsage(currentBalance) {
+      const t = todayKey()
+      let led = readUsageLedger()
+      const events = Array.isArray(led.events) ? led.events : []
+      function sumEv(d) { let s = 0; for (const e of events) if (e.day === d) s += Number(e.cost) || 0; return s }
+      if (led.date !== t) {
+        // 跨天:归档旧日真实合计(优先当日余额差;不可用/为0时退事件与历史),并重置当天基准
+        const oldDay = led.date
+        if (oldDay) {
+          led.history = led.history || {}
+          let oldTotal = 0
+          if (typeof led.dayStart === 'number' && typeof led.lastBalance === 'number' && led.lastBalance < led.dayStart) {
+            oldTotal = Math.max(oldTotal, led.dayStart - led.lastBalance)
+          }
+          oldTotal = Math.max(oldTotal, sumEv(oldDay))
+          if (typeof led.todayUsage === 'number') oldTotal = Math.max(oldTotal, led.todayUsage)
+          led.history[oldDay] = round2(oldTotal)
+        }
+        led.date = t
+        led.dayStart = currentBalance
+        led.todayUsage = 0
+        led.lastBalance = currentBalance
+      } else {
+        // 兼容旧账本:当天尚无 dayStart 时,把已冻结的 lastBalance 视为当天起始余额
+        if (typeof led.dayStart !== 'number' && typeof led.lastBalance === 'number') {
+          led.dayStart = led.lastBalance
+        }
+        led.lastBalance = currentBalance
+      }
+      // 归档/裁剪统一由 pruneLedgerUsage 负责（history 保留 365 天，events 90 天/2 万条）
+      pruneLedgerUsage(led)
+      writeUsageLedger(led)
+      return led
+    }
+    function normalizeUsageMode() {
+      return 'ledger' // 小鲸鱼记账为唯一记账方式
+    }
+    // 今日已用:以“当日真实余额差(零点起始余额−当前余额)”为准——
+    // 官方账单按真实扣款计,事件计价可能出现系统性偏高(14.49 vs 余额差 13.91 vs 官网 13.88),
+    // 余额差与官网几乎一致;事件合计仅在余额差不可用(充值/退款/无基准)时作兜底。
+    function ledgerTodayTotal(led) {
+      const events = Array.isArray(led.events) ? led.events : []
+      const t = dayKeyFromTs(Date.now())
+      let s = 0
+      for (const e of events) if (e.day === t) s += Number(e.cost) || 0
+      if (typeof led.dayStart === 'number' && typeof led.lastBalance === 'number') {
+        const d = led.dayStart - led.lastBalance
+        if (d > 0.004) return round2(d)
+      }
+      return round2(s)
+    }
+
+    async function getBalancePayload() {
+      const payload = await fetchBalance()
+      if (!payload.ok) {
+        // 余额接口失败（含限流 429）时仍附上今日已用：事件优先，其次账本余额差
+        const led = readUsageLedger()
+        return { ...payload, todayUsage: ledgerTodayTotal(led), usageMode: 'ledger' }
+      }
+      recordLedgerUsage(Number(payload.totalBalance))
+      // 必须在写入后重读账本:否则 todayUsage 会按“上一轮 lastBalance”计算,
+      // 造成泡泡与用量记录(后者直接读文件)数值不一致(如 4.99 vs 5.05)
+      const led = readUsageLedger()
+      const full = { ...payload }
+      full.isPeak = isPeakTime(Math.floor(Date.now() / 1000))
+      full.todayUsage = ledgerTodayTotal(led)
+      full.usageMode = 'ledger'
+      return full
+    }
+
+    function getBalance() {
       const now = Date.now()
       if (balanceCache && now - balanceCache.at < BALANCE_TTL_MS) {
         return Promise.resolve(balanceCache.payload)
@@ -1773,7 +2036,7 @@ function apply(ctx) {
               scale: parsed.scale,
               sound: parsed.sound !== false,
               vol: typeof parsed.vol === 'number' ? parsed.vol : 0.9,
-              soundSet: parsed.soundSet === 'fx1' ? 'fx1' : 'duck',
+              soundSet: typeof parsed.soundSet === 'string' && parsed.soundSet ? parsed.soundSet : 'duck',
               usageMode: normalizeUsageMode(parsed.usageMode),
               peakMode: parsed.peakMode === 'liangwen' || parsed.peakMode === 'qiangqiang' ? parsed.peakMode : 'default',
               bubbleOn: parsed.bubbleOn !== false,
@@ -1781,6 +2044,7 @@ function apply(ctx) {
               turnCostCloseMs: typeof parsed.turnCostCloseMs === 'number' ? parsed.turnCostCloseMs : 5000,
               scrollGapOn: parsed.scrollGapOn === true,
               scrollGapPx: typeof parsed.scrollGapPx === 'number' ? Math.round(parsed.scrollGapPx) : 17,
+              menuBtnHide: parsed.menuBtnHide === true,
             }
           }
         } catch (err) {}
@@ -1788,7 +2052,7 @@ function apply(ctx) {
       return null
     }
 
-    function writeSizeConfig(scale, sound, vol, soundSet, usageMode, peakMode, bubbleOn, turnCostOn, turnCostCloseMs, scrollGapOn, scrollGapPx) {
+    function writeSizeConfig(scale, sound, vol, soundSet, usageMode, peakMode, bubbleOn, turnCostOn, turnCostCloseMs, scrollGapOn, scrollGapPx, menuBtnHide) {
       const um = normalizeUsageMode(usageMode)
       const pm = peakMode === 'liangwen' || peakMode === 'qiangqiang' ? peakMode : 'default'
       const bo = bubbleOn !== false
@@ -1796,11 +2060,12 @@ function apply(ctx) {
       const tcc = typeof turnCostCloseMs === 'number' ? (turnCostCloseMs > 0 ? turnCostCloseMs : 0) : 5000
       const sgo = scrollGapOn === true
       const sgp = typeof scrollGapPx === 'number' && scrollGapPx > 0 ? Math.round(scrollGapPx) : 0
+      const mbh = menuBtnHide === true
       const body = JSON.stringify({
         scale: scale,
         sound: sound !== false,
         vol: typeof vol === 'number' ? vol : 0.9,
-        soundSet: soundSet === 'fx1' ? 'fx1' : 'duck',
+        soundSet: typeof soundSet === 'string' && soundSet ? soundSet : 'duck',
         usageMode: um,
         peakMode: pm,
         bubbleOn: bo,
@@ -1808,6 +2073,7 @@ function apply(ctx) {
         turnCostCloseMs: tcc,
         scrollGapOn: sgo,
         scrollGapPx: sgp,
+        menuBtnHide: mbh,
         updatedAt: new Date().toISOString(),
       })
       for (const p of SIZE_FILE_CANDIDATES) {
@@ -1818,7 +2084,7 @@ function apply(ctx) {
             scale: scale,
             sound: sound !== false,
             vol: typeof vol === 'number' ? vol : 0.9,
-            soundSet: soundSet === 'fx1' ? 'fx1' : 'duck',
+            soundSet: typeof soundSet === 'string' && soundSet ? soundSet : 'duck',
             usageMode: um,
             peakMode: pm,
             bubbleOn: bo,
@@ -1826,6 +2092,7 @@ function apply(ctx) {
             turnCostCloseMs: tcc,
             scrollGapOn: sgo,
             scrollGapPx: sgp,
+            menuBtnHide: mbh,
           }
         } catch (err) {}
       }
@@ -1850,7 +2117,282 @@ function apply(ctx) {
       })
     }
 
-    disposers.push(ctx.webServer.register({
+    function readBodyMax(req, maxBytes) {
+      return new Promise((resolve, reject) => {
+        const chunks = []
+        let size = 0
+        req.on('data', (c) => {
+          size += c.length
+          if (size > maxBytes) {
+            reject(new Error('body too large'))
+            req.destroy()
+            return
+          }
+          chunks.push(c)
+        })
+        req.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')))
+        req.on('error', reject)
+      })
+    }
+
+    // —— 自定义角色存储：whale-roles/ 目录，每个角色一个 <id>.png + roles.json 索引 ——
+    function pickRoleDir() {
+      for (const p of ROLE_DIR_CANDIDATES) {
+        try {
+          fs.mkdirSync(p, { recursive: true })
+          fs.accessSync(p, fs.constants.W_OK)
+          return p
+        } catch (err) {}
+      }
+      return ROLE_DIR_CANDIDATES[0]
+    }
+
+    function defaultRolesIndex() {
+      return {
+        version: 1,
+        roles: [
+          // 默认小鲸鱼初始置顶；pinnedAt=1 作为基线，任何新置顶（Date.now()）都会排在它上面
+          { id: ROLE_DEFAULT_ID, name: '小鲸鱼', pinnedAt: 1, createdAt: 0 },
+        ],
+      }
+    }
+
+    function readRolesIndex() {
+      const dir = pickRoleDir()
+      try {
+        const parsed = JSON.parse(fs.readFileSync(path.join(dir, ROLE_INDEX_NAME), 'utf8'))
+        if (parsed && Array.isArray(parsed.roles)) {
+          if (!parsed.roles.some((r) => r && r.id === ROLE_DEFAULT_ID)) {
+            parsed.roles.unshift(defaultRolesIndex().roles[0])
+          }
+          return parsed
+        }
+      } catch (err) {}
+      return defaultRolesIndex()
+    }
+
+    function writeRolesIndex(index) {
+      const dir = pickRoleDir()
+      try {
+        fs.writeFileSync(path.join(dir, ROLE_INDEX_NAME), JSON.stringify(index, null, 2), 'utf8')
+        return true
+      } catch (err) {
+        return false
+      }
+    }
+
+    // 排序：置顶的在前（pinnedAt 大者先，即最新置顶在最上面），未置顶按创建时间倒序
+    function sortRoles(roles) {
+      return roles.slice().sort((a, b) => {
+        const ap = a.pinnedAt && a.pinnedAt > 0 ? a.pinnedAt : 0
+        const bp = b.pinnedAt && b.pinnedAt > 0 ? b.pinnedAt : 0
+        if (ap && bp) return bp - ap
+        if (ap) return -1
+        if (bp) return 1
+        return (b.createdAt || 0) - (a.createdAt || 0)
+      })
+    }
+
+    function rolesPayload() {
+      const index = readRolesIndex()
+      return {
+        ok: true,
+        roles: sortRoles(index.roles).map((r) => ({
+          id: r.id,
+          name: String(r.name || r.id),
+          url: r.id === ROLE_DEFAULT_ID ? '/dsh-whale/image.png' : '/dsh-whale/role-image.png?id=' + encodeURIComponent(r.id),
+          pinned: !!(r.pinnedAt && r.pinnedAt > 0),
+          pinnedAt: r.pinnedAt || null,
+          createdAt: r.createdAt || null,
+          // format: 'png' | 'gif' | 'apng'（旧角色无 format 字段 → png）
+          format: r.format === 'gif' || r.format === 'apng' ? r.format : 'png',
+        })),
+      }
+    }
+
+    // 角色文件按格式映射扩展名：gif→.gif，apng/png→.png（APNG 文件仍是 PNG 容器）
+    function roleFileExt(format) {
+      return format === 'gif' ? 'gif' : 'png'
+    }
+
+    function roleFilePath(id, format) {
+      if (typeof id !== 'string' || !/^[A-Za-z0-9_-]{1,64}$/.test(id) || id === ROLE_DEFAULT_ID) return null
+      return path.join(pickRoleDir(), id + '.' + roleFileExt(format))
+    }
+
+    function roleImagePath(id) {
+      // 查找角色元数据确定扩展名；找不到默认 png
+      const { role } = roleIndexFind(id)
+      const format = role && (role.format === 'gif' || role.format === 'apng') ? role.format : 'png'
+      const p = roleFilePath(id, format)
+      return p
+    }
+
+    function roleIdFromUrl(url) {
+      try {
+        const q = String(url || '').split('?')[1] || ''
+        const m = /(?:^|&)id=([^&]+)/.exec(q)
+        return m ? decodeURIComponent(m[1]) : ''
+      } catch (err) { return '' }
+    }
+
+    function roleIndexFind(id) {
+      const index = readRolesIndex()
+      const role = index.roles.find((r) => r && r.id === id)
+      return { index, role }
+    }
+
+    // —— 自定义音频：whale-audio/ 目录，片段 <id>.wav + audio.json 索引 ——
+    function pickAudioDir() {
+      for (const p of AUDIO_DIR_CANDIDATES) {
+        try {
+          fs.mkdirSync(p, { recursive: true })
+          fs.accessSync(p, fs.constants.W_OK)
+          return p
+        } catch (err) {}
+      }
+      return AUDIO_DIR_CANDIDATES[0]
+    }
+
+    function defaultAudioIndex() {
+      return { version: 1, groups: [], fragments: [] }
+    }
+
+    function readAudioIndex() {
+      const dir = pickAudioDir()
+      try {
+        const parsed = JSON.parse(fs.readFileSync(path.join(dir, AUDIO_INDEX_NAME), 'utf8'))
+        if (parsed && Array.isArray(parsed.groups) && Array.isArray(parsed.fragments)) {
+          return parsed
+        }
+      } catch (err) {}
+      return defaultAudioIndex()
+    }
+
+    function writeAudioIndex(index) {
+      const dir = pickAudioDir()
+      try {
+        fs.writeFileSync(path.join(dir, AUDIO_INDEX_NAME), JSON.stringify(index, null, 2), 'utf8')
+        return true
+      } catch (err) {
+        return false
+      }
+    }
+
+    // 自定义片段 id -> 文件路径；预设片段无文件
+    function audioFragmentPath(id) {
+      if (typeof id !== 'string' || !/^[A-Za-z0-9_-]{1,64}$/.test(id)) return null
+      if (PRESET_FRAGMENTS[id]) return null
+      return path.join(pickAudioDir(), id + '.wav')
+    }
+
+    function audioIdFromUrl(url) {
+      try {
+        const q = String(url || '').split('?')[1] || ''
+        const m = /(?:^|&)id=([^&]+)/.exec(q)
+        return m ? decodeURIComponent(m[1]) : ''
+      } catch (err) { return '' }
+    }
+
+    // 片段列表：预设片段 + 用户自定义片段
+    function audioFragmentsPayload() {
+      const index = readAudioIndex()
+      const presets = Object.keys(PRESET_FRAGMENTS).map((k) => ({
+        id: k,
+        name: PRESET_FRAGMENTS[k].name,
+        preset: true,
+      }))
+      const custom = index.fragments.map((f) => ({
+        id: f.id,
+        name: String(f.name || f.id),
+        preset: false,
+        createdAt: f.createdAt || null,
+      }))
+      return presets.concat(custom)
+    }
+
+    // 音效组列表：预设组 + 用户自定义组（置顶优先，组内按创建时间倒序）
+    function audioGroupsPayload() {
+      const index = readAudioIndex()
+      // 排序：置顶的自定义组最前，其次预设组，最后未置顶的自定义组（按创建时间倒序）
+      const customs = index.groups.slice().map((g) => ({
+        id: g.id,
+        name: String(g.name || g.id),
+        press: typeof g.press === 'string' ? g.press : null,
+        release: typeof g.release === 'string' ? g.release : null,
+        preset: false,
+        pinned: !!(g.pinnedAt && g.pinnedAt > 0),
+        pinnedAt: g.pinnedAt || null,
+        createdAt: g.createdAt || 0,
+      }))
+      const pinned = customs.filter((g) => g.pinned).sort((a, b) => b.pinnedAt - a.pinnedAt)
+      const unpinned = customs.filter((g) => !g.pinned).sort((a, b) => b.createdAt - a.createdAt)
+      const presets = Object.keys(PRESET_GROUPS).map((k) => {
+        const g = PRESET_GROUPS[k]
+        return { id: g.id, name: g.name, press: g.press, release: g.release, preset: true, pinned: false, pinnedAt: null, createdAt: 0 }
+      })
+      return pinned.concat(presets, unpinned)
+    }
+
+    function audioPayload() {
+      return {
+        ok: true,
+        groups: audioGroupsPayload(),
+        fragments: audioFragmentsPayload(),
+      }
+    }
+
+    // 取片段音频字节：内置随包片段 → 预设(SOUND_SETS) → 自定义 whale-audio/<id>.wav
+    function loadAudioFragmentBytes(fragId) {
+      if (BUILTIN_FRAGMENT_FILES[fragId]) {
+        return loadSound(BUILTIN_FRAGMENT_FILES[fragId])
+      }
+      if (PRESET_FRAGMENTS[fragId]) {
+        // 预设片段映射到对应音效文件：ya1->duck.press, ya2->duck.release, d1->fx1.press, d2->fx1.release
+        const map = { ya1: ['duck', 'press'], ya2: ['duck', 'release'], d1: ['fx1', 'press'], d2: ['fx1', 'release'] }
+        const [setName, slot] = map[fragId]
+        const set = SOUND_SETS[setName]
+        if (!set) return null
+        return loadSound(set[slot])
+      }
+      const p = audioFragmentPath(fragId)
+      if (!p) return null
+      try {
+        const bytes = fs.readFileSync(p)
+        if (bytes && bytes.length > 0) return bytes
+      } catch (err) {}
+      return null
+    }
+
+    // 组内实际使用的片段：若自定义组引用的片段被删，回退到预设
+    // 返回 '' 表示该槽显式留空（该事件静音），调用方应据此不发音频
+    function groupFragmentId(groupId, slot) {
+      const custom = readAudioIndex().groups.find((g) => g && g.id === groupId)
+      if (custom) {
+        const fid = custom[slot]
+        if (fid === '') return ''
+        if (fid) {
+          if (PRESET_FRAGMENTS[fid]) return fid
+          if (customFragExists(fid)) return fid
+        }
+        // 无字段/引用失效 → 回退预设：新组无引用时用 duck
+        return slot === 'press' ? PRESET_GROUPS.duck.press : PRESET_GROUPS.duck.release
+      }
+      const preset = PRESET_GROUPS[groupId]
+      if (preset) return preset[slot]
+      return slot === 'press' ? PRESET_GROUPS.duck.press : PRESET_GROUPS.duck.release
+    }
+
+    function customFragExists(id) {
+      try {
+        const p = audioFragmentPath(id)
+        if (!p) return false
+        const st = fs.statSync(p)
+        return st.isFile()
+      } catch (err) { return false }
+    }
+
+    disposers.push(registerRoute({
       kind: 'exact',
       path: '/dsh-whale/image.png',
       handler: (req, res) => {
@@ -1869,7 +2411,7 @@ function apply(ctx) {
       },
     }))
 
-    disposers.push(ctx.webServer.register({
+    disposers.push(registerRoute({
       kind: 'exact',
       path: '/dsh-whale/rua.gif',
       handler: (req, res) => {
@@ -1888,7 +2430,7 @@ function apply(ctx) {
       },
     }))
 
-    disposers.push(ctx.webServer.register({
+    disposers.push(registerRoute({
       kind: 'exact',
       path: '/dsh-whale/balance.json',
       handler: async (req, res) => {
@@ -1903,7 +2445,7 @@ function apply(ctx) {
       },
     }))
 
-    disposers.push(ctx.webServer.register({
+    disposers.push(registerRoute({
       kind: 'exact',
       path: '/dsh-whale/last-turn.json',
       handler: (req, res) => {
@@ -1916,7 +2458,7 @@ function apply(ctx) {
       },
     }))
 
-    disposers.push(ctx.webServer.register({
+    disposers.push(registerRoute({
       kind: 'exact',
       path: '/dsh-whale/size.json',
       handler: async (req, res) => {
@@ -1937,7 +2479,7 @@ function apply(ctx) {
                 balanceCache = null
               }
             }
-            const result = writeSizeConfig(scale, parsed.sound !== false, parsed.vol, parsed.soundSet, parsed.usageMode, parsed.peakMode, parsed.bubbleOn, parsed.turnCostOn, parsed.turnCostCloseMs, parsed.scrollGapOn, parsed.scrollGapPx)
+            const result = writeSizeConfig(scale, parsed.sound !== false, parsed.vol, parsed.soundSet, parsed.usageMode, parsed.peakMode, parsed.bubbleOn, parsed.turnCostOn, parsed.turnCostCloseMs, parsed.scrollGapOn, parsed.scrollGapPx, parsed.menuBtnHide)
             res.writeHead(result.ok ? 200 : 500, JSON_HEADERS)
             res.end(JSON.stringify(result))
           } catch (err) {
@@ -1951,6 +2493,391 @@ function apply(ctx) {
       },
     }))
 
+    disposers.push(registerRoute({
+      kind: 'exact',
+      path: '/dsh-whale/usage-records.json',
+      handler: async (req, res) => {
+        try {
+          // 与余额路由同源:请求到来时若持有较新的余额缓存(≤70s,覆盖两次 60s 轮询间隙),
+          // 先用它刷新账本 lastBalance 再算汇总,保证“今日合计”与泡泡“今日已用”读同一份数据;
+          // 缓存太旧(挂件长时间未开)则跳过,避免把过期余额写回账本。
+          try {
+            if (balanceCache && balanceCache.payload && balanceCache.payload.ok &&
+                isFinite(Number(balanceCache.payload.totalBalance)) &&
+                Date.now() - balanceCache.at <= 70000) {
+              recordLedgerUsage(Number(balanceCache.payload.totalBalance))
+            }
+          } catch (err) {}
+          res.writeHead(200, JSON_HEADERS)
+          res.end(JSON.stringify(usageRecordsPayload()))
+        } catch (err) {
+          res.writeHead(200, JSON_HEADERS)
+          res.end(JSON.stringify({ ok: false, error: String((err && err.message) || err) }))
+        }
+      },
+    }))
+    // 用量设置(任务结束音/余额预警/今日预算)
+    disposers.push(registerRoute({
+      kind: 'exact',
+      path: '/dsh-whale/usage-settings.json',
+      handler: async (req, res) => {
+        try {
+          if (req.method === 'PUT' || req.method === 'POST') {
+            const body = await readBody(req)
+            const parsed = JSON.parse(body || '{}')
+            if (!parsed || typeof parsed !== 'object') throw new Error('bad body')
+            const result = writeUsageSettings(parsed)
+            res.writeHead(result.ok ? 200 : 400, JSON_HEADERS)
+            res.end(JSON.stringify(result))
+            return
+          }
+          res.writeHead(200, JSON_HEADERS)
+          res.end(JSON.stringify({ ok: true, settings: readUsageSettings() }))
+        } catch (err) {
+          res.writeHead(400, JSON_HEADERS)
+          res.end(JSON.stringify({ ok: false, error: String((err && err.message) || err) }))
+        }
+      },
+    }))
+
+    // 自定义 API 模型：GET 列表（含实时余额/今日已用/各模型提醒预算）
+    // POST {action: save|delete|set-key|delete-key|model-settings}
+    disposers.push(registerRoute({
+      kind: 'exact',
+      path: '/dsh-whale/api-models.json',
+      handler: async (req, res) => {
+        try {
+          if (req.method === 'PUT' || req.method === 'POST') {
+            const body = await readBody(req)
+            const parsed = JSON.parse(body || '{}')
+            const action = String((parsed && parsed.action) || 'save')
+            if (action === 'delete') {
+              const r = apiDeleteModel(parsed.id)
+              const list = await apiModelsPayload()
+              res.writeHead(r.ok ? 200 : 400, JSON_HEADERS)
+              res.end(JSON.stringify(Object.assign({}, r, { models: list.models })))
+              return
+            }
+            if (action === 'probe') {
+              // 只做只读连通性测试（如方舟 /api/v3/models），不消耗 token
+              const m0 = apiModelById(parsed.id)
+              const pr = await apiProbeModel(m0)
+              res.writeHead(200, JSON_HEADERS)
+              res.end(JSON.stringify(pr))
+              return
+            }
+            if (action === 'set-key' || action === 'delete-key') {
+              const ref = String(parsed.keyRef || '').trim()
+              if (!ref) throw new Error('bad keyRef')
+              const svc = ctx.credentials
+              if (action === 'set-key') {
+                await svc.set(ref, String(parsed.keyValue || ''))
+              } else if (typeof svc.unset === 'function') {
+                // 普通密钥存在凭据文档的 refs 段：必须用 unset 才能真正删除
+                // （deleteRecord 只处理 records 段的结构化记录，对 refs 会静默返回）
+                await svc.unset(ref)
+              } else {
+                await svc.deleteRecord(ref)
+              }
+              res.writeHead(200, JSON_HEADERS)
+              res.end(JSON.stringify({ ok: true }))
+              return
+            }
+            if (action === 'model-settings') {
+              const r = writeUsageSettings({ modelSettings: { id: String(parsed.id || ''), alert: parsed.alert, budget: parsed.budget, quota: parsed.quota } })
+              res.writeHead(r.ok ? 200 : 400, JSON_HEADERS)
+              res.end(JSON.stringify(r))
+              return
+            }
+            // 注意：keyValue 在提交体上（不在 model 里），必须合并进去，
+            // 否则前端面板里填的 API key 会被丢弃（密钥永远存不进去）
+            const r = await apiSaveModel(Object.assign({}, parsed.model || parsed, { keyValue: parsed.keyValue }))
+            const list2 = await apiModelsPayload()
+            res.writeHead(r.ok ? 200 : 400, JSON_HEADERS)
+            res.end(JSON.stringify(Object.assign({}, r, { models: list2.models })))
+            return
+          }
+          const payload = await apiModelsPayload()
+          res.writeHead(200, JSON_HEADERS)
+          res.end(JSON.stringify(payload))
+        } catch (err) {
+          res.writeHead(400, JSON_HEADERS)
+          res.end(JSON.stringify({ ok: false, error: String((err && err.message) || err).slice(0, 200) }))
+        }
+      },
+    }))
+
+    disposers.push(registerRoute({
+      kind: 'exact',
+      path: '/dsh-whale/roles.json',
+      handler: async (req, res) => {
+        if (req.method === 'POST' || req.method === 'PUT') {
+          try {
+            // 放宽到 30MB：支持最大 20MB 的 GIF（base64 膨胀约 1.33 倍）
+            const body = await readBodyMax(req, 30 * 1024 * 1024)
+            const parsed = JSON.parse(body)
+            const name = String(parsed.name || '').trim().slice(0, 20) || '新角色'
+            const image = String(parsed.image || '')
+            const m = /^data:image\/(png|jpeg|webp|gif);base64,([A-Za-z0-9+/=]+)$/.exec(image)
+            if (!m) {
+              res.writeHead(400, JSON_HEADERS)
+              res.end(JSON.stringify({ ok: false, error: 'invalid image data' }))
+              return
+            }
+            const buf = Buffer.from(m[2], 'base64')
+            if (buf.length < 8 || buf.length > 20 * 1024 * 1024) {
+              res.writeHead(400, JSON_HEADERS)
+              res.end(JSON.stringify({ ok: false, error: 'image too large' }))
+              return
+            }
+            // format：客户端显式告知 gif/apng（APNG 的 dataURL 是 image/png，需客户端区分）；
+            // 未显式给时按 dataURL 的 MIME 推断（gif→gif，其余 png）
+            const declared = parsed.format === 'gif' ? 'gif' : (parsed.format === 'apng' ? 'apng' : null)
+            const fmt = declared || (m[1] === 'gif' ? 'gif' : 'png')
+            const id = 'role_' + Date.now().toString(36) + '_' + Math.random().toString(36).slice(2, 8)
+            const dir = pickRoleDir()
+            fs.writeFileSync(path.join(dir, id + '.' + roleFileExt(fmt)), buf)
+            const index = readRolesIndex()
+            index.roles.push({ id, name, format: fmt, pinnedAt: null, createdAt: Date.now() })
+            writeRolesIndex(index)
+            res.writeHead(200, JSON_HEADERS)
+            res.end(JSON.stringify(rolesPayload()))
+          } catch (err) {
+            res.writeHead(400, JSON_HEADERS)
+            res.end(JSON.stringify({ ok: false, error: String((err && err.message) || err).slice(0, 200) }))
+          }
+          return
+        }
+        res.writeHead(200, JSON_HEADERS)
+        res.end(JSON.stringify(rolesPayload()))
+      },
+    }))
+
+    disposers.push(registerRoute({
+      kind: 'exact',
+      path: '/dsh-whale/role-pin.json',
+      handler: async (req, res) => {
+        try {
+          const body = await readBodyMax(req, 8192)
+          const parsed = JSON.parse(body)
+          const id = String(parsed.id || '')
+          const { index, role } = roleIndexFind(id)
+          if (!role) {
+            res.writeHead(404, JSON_HEADERS)
+            res.end(JSON.stringify({ ok: false, error: 'role not found' }))
+            return
+          }
+          role.pinnedAt = parsed.pinned === true ? Date.now() : null
+          writeRolesIndex(index)
+          res.writeHead(200, JSON_HEADERS)
+          res.end(JSON.stringify(rolesPayload()))
+        } catch (err) {
+          res.writeHead(400, JSON_HEADERS)
+          res.end(JSON.stringify({ ok: false, error: String((err && err.message) || err).slice(0, 200) }))
+        }
+      },
+    }))
+
+    disposers.push(registerRoute({
+      kind: 'exact',
+      path: '/dsh-whale/role-delete.json',
+      handler: async (req, res) => {
+        try {
+          const body = await readBodyMax(req, 8192)
+          const parsed = JSON.parse(body)
+          const id = String(parsed.id || '')
+          if (id === ROLE_DEFAULT_ID) {
+            res.writeHead(400, JSON_HEADERS)
+            res.end(JSON.stringify({ ok: false, error: 'cannot delete default role' }))
+            return
+          }
+          const { index, role } = roleIndexFind(id)
+          if (!role) {
+            res.writeHead(404, JSON_HEADERS)
+            res.end(JSON.stringify({ ok: false, error: 'role not found' }))
+            return
+          }
+          // 先按角色 format 确定文件路径（必须在从索引移除之前，否则查不到 format 默认成 png，删不掉 .gif）
+          const fmt = role.format === 'gif' || role.format === 'apng' ? role.format : 'png'
+          const p = roleFilePath(id, fmt)
+          index.roles = index.roles.filter((r) => r.id !== id)
+          writeRolesIndex(index)
+          if (p) { try { fs.unlinkSync(p) } catch (err) {} }
+          res.writeHead(200, JSON_HEADERS)
+          res.end(JSON.stringify(rolesPayload()))
+        } catch (err) {
+          res.writeHead(400, JSON_HEADERS)
+          res.end(JSON.stringify({ ok: false, error: String((err && err.message) || err).slice(0, 200) }))
+        }
+      },
+    }))
+
+    disposers.push(registerRoute({
+      kind: 'exact',
+      path: '/dsh-whale/role-image.png',
+      handler: (req, res) => {
+        try {
+          const id = roleIdFromUrl(req.url)
+          const p = roleImagePath(id)
+          if (!p) throw new Error('bad role id')
+          const bytes = fs.readFileSync(p)
+          // 按角色格式返回对应 MIME：gif 动图 → image/gif；png/apng 都是 PNG 容器 → image/png
+          const { role } = roleIndexFind(id)
+          const mime = role && role.format === 'gif' ? 'image/gif' : 'image/png'
+          res.writeHead(200, {
+            'Content-Type': mime,
+            'Cache-Control': 'no-store',
+            'Content-Length': String(bytes.length),
+          })
+          res.end(bytes)
+        } catch (err) {
+          res.writeHead(404, { 'Content-Type': 'text/plain; charset=utf-8' })
+          res.end('role image unavailable')
+        }
+      },
+    }))
+
+    disposers.push(registerRoute({
+      kind: 'exact',
+      path: '/dsh-whale/audio.json',
+      handler: async (req, res) => {
+        if (req.method === 'POST' || req.method === 'PUT') {
+          try {
+            const body = await readBodyMax(req, 8 * 1024 * 1024)
+            const parsed = JSON.parse(body)
+            const action = parsed.action
+            const index = readAudioIndex()
+            if (action === 'upload-fragment') {
+              const name = String(parsed.name || '').trim().slice(0, 40) || '未命名音频'
+              const audio = String(parsed.audio || '')
+              const m = /^data:audio\/wav;base64,([A-Za-z0-9+/=]+)$/.exec(audio)
+              if (!m) {
+                res.writeHead(400, JSON_HEADERS)
+                res.end(JSON.stringify({ ok: false, error: 'invalid wav data' }))
+                return
+              }
+              const buf = Buffer.from(m[1], 'base64')
+              if (buf.length < 44 || buf.length > 8 * 1024 * 1024) {
+                res.writeHead(400, JSON_HEADERS)
+                res.end(JSON.stringify({ ok: false, error: 'audio too large' }))
+                return
+              }
+              const id = 'audio_' + Date.now().toString(36) + '_' + Math.random().toString(36).slice(2, 8)
+              fs.writeFileSync(path.join(pickAudioDir(), id + '.wav'), buf)
+              index.fragments.push({ id, name, createdAt: Date.now() })
+              writeAudioIndex(index)
+              res.writeHead(200, JSON_HEADERS)
+              res.end(JSON.stringify({ ok: true, id, fragments: audioFragmentsPayload() }))
+              return
+            }
+            if (action === 'save-group') {
+              const id = String(parsed.id || '')
+              const name = String(parsed.name || '').trim().slice(0, 20) || '未命名音效组'
+              const press = String(parsed.press ?? '')
+              const release = String(parsed.release ?? '')
+              // 校验引用片段存在（预设或自定义）；空字符串=该槽留空(该事件静音)，允许保存
+              const frags = audioFragmentsPayload().map((f) => f.id)
+              const validPress = press === '' ? '' : (frags.includes(press) ? press : PRESET_GROUPS.duck.press)
+              const validRelease = release === '' ? '' : (frags.includes(release) ? release : PRESET_GROUPS.duck.release)
+              if (id && index.groups.some((g) => g.id === id)) {
+                const g = index.groups.find((x) => x.id === id)
+                g.name = name
+                g.press = validPress
+                g.release = validRelease
+              } else {
+                const gid = 'group_' + Date.now().toString(36) + '_' + Math.random().toString(36).slice(2, 8)
+                index.groups.push({ id: gid, name, press: validPress, release: validRelease, pinnedAt: null, createdAt: Date.now() })
+              }
+              writeAudioIndex(index)
+              res.writeHead(200, JSON_HEADERS)
+              res.end(JSON.stringify({ ok: true, groups: audioGroupsPayload() }))
+              return
+            }
+            if (action === 'delete-group') {
+              const id = String(parsed.id || '')
+              if (PRESET_GROUPS[id]) {
+                res.writeHead(400, JSON_HEADERS)
+                res.end(JSON.stringify({ ok: false, error: 'cannot delete preset group' }))
+                return
+              }
+              index.groups = index.groups.filter((g) => g.id !== id)
+              writeAudioIndex(index)
+              res.writeHead(200, JSON_HEADERS)
+              res.end(JSON.stringify({ ok: true, groups: audioGroupsPayload() }))
+              return
+            }
+            if (action === 'delete-fragment') {
+              const id = String(parsed.id || '')
+              if (PRESET_FRAGMENTS[id]) {
+                res.writeHead(400, JSON_HEADERS)
+                res.end(JSON.stringify({ ok: false, error: 'cannot delete preset fragment' }))
+                return
+              }
+              index.fragments = index.fragments.filter((f) => f.id !== id)
+              writeAudioIndex(index)
+              const p = audioFragmentPath(id)
+              if (p) { try { fs.unlinkSync(p) } catch (err) {} }
+              res.writeHead(200, JSON_HEADERS)
+              res.end(JSON.stringify({ ok: true, fragments: audioFragmentsPayload(), groups: audioGroupsPayload() }))
+              return
+            }
+            if (action === 'pin-group') {
+              const id = String(parsed.id || '')
+              const g = index.groups.find((x) => x.id === id)
+              if (!g) {
+                res.writeHead(404, JSON_HEADERS)
+                res.end(JSON.stringify({ ok: false, error: 'group not found' }))
+                return
+              }
+              g.pinnedAt = parsed.pinned === true ? Date.now() : null
+              writeAudioIndex(index)
+              res.writeHead(200, JSON_HEADERS)
+              res.end(JSON.stringify({ ok: true, groups: audioGroupsPayload() }))
+              return
+            }
+            res.writeHead(400, JSON_HEADERS)
+            res.end(JSON.stringify({ ok: false, error: 'unknown action' }))
+          } catch (err) {
+            res.writeHead(400, JSON_HEADERS)
+            res.end(JSON.stringify({ ok: false, error: String((err && err.message) || err).slice(0, 200) }))
+          }
+          return
+        }
+        res.writeHead(200, JSON_HEADERS)
+        res.end(JSON.stringify(audioPayload()))
+      },
+    }))
+
+    disposers.push(registerRoute({
+      kind: 'exact',
+      path: '/dsh-whale/audio-fragment.wav',
+      handler: (req, res) => {
+        try {
+          const id = audioIdFromUrl(req.url)
+          const bytes = loadAudioFragmentBytes(id)
+          if (!bytes) throw new Error('bad fragment id')
+          // 预设/内置片段可能是 mp3 也可能是 wav —— Content-Type 必须与字节匹配，
+          // 否则浏览器解码路径/加载行为异常（MIME 与字节不符会导致听感差异）
+          const mime = fragmentMime(id)
+          res.writeHead(200, {
+            'Content-Type': mime,
+            'Cache-Control': 'no-store',
+            'Content-Length': String(bytes.length),
+          })
+          res.end(bytes)
+        } catch (err) {
+          res.writeHead(404, { 'Content-Type': 'text/plain; charset=utf-8' })
+          res.end('audio fragment unavailable')
+        }
+      },
+    }))
+
+    // 片段字节对应的 MIME：内置/预设片段按声明，自定义片段一律 wav
+    function fragmentMime(fragId) {
+      const f = PRESET_FRAGMENTS[fragId]
+      return (f && f.mime) || 'audio/wav'
+    }
+
     function loadSound(candidates) {
       for (const p of candidates) {
         try {
@@ -1976,25 +2903,271 @@ function apply(ctx) {
       res.end(bytes)
     }
 
-    disposers.push(ctx.webServer.register({
+    disposers.push(registerRoute({
       kind: 'exact',
       path: '/dsh-whale/sound/press.mp3',
       handler: (req, res) => {
         const set = SOUND_SETS[soundSetFromUrl(req.url)] || SOUND_SETS.duck
+        // 自定义音效组：set 为组 id 时按组内 press 片段取音频
+        const setName = soundSetFromUrl(req.url)
+        if (setName && !SOUND_SETS[setName]) {
+          const fragId = groupFragmentId(setName, 'press')
+          if (fragId === '') { res.writeHead(204); res.end(); return } // 留空槽：该事件静音
+          const bytes = loadAudioFragmentBytes(fragId)
+          if (bytes) {
+            res.writeHead(200, {
+              'Content-Type': fragmentMime(fragId),
+              'Cache-Control': 'no-store',
+              'Content-Length': String(bytes.length),
+            })
+            res.end(bytes)
+            return
+          }
+        }
         serveSound(req, res, set.press)
       },
     }))
 
-    disposers.push(ctx.webServer.register({
+    disposers.push(registerRoute({
       kind: 'exact',
       path: '/dsh-whale/sound/release.mp3',
       handler: (req, res) => {
         const set = SOUND_SETS[soundSetFromUrl(req.url)] || SOUND_SETS.duck
+        const setName = soundSetFromUrl(req.url)
+        if (setName && !SOUND_SETS[setName]) {
+          const fragId = groupFragmentId(setName, 'release')
+          if (fragId === '') { res.writeHead(204); res.end(); return } // 留空槽：该事件静音
+          const bytes = loadAudioFragmentBytes(fragId)
+          if (bytes) {
+            res.writeHead(200, {
+              'Content-Type': fragmentMime(fragId),
+              'Cache-Control': 'no-store',
+              'Content-Length': String(bytes.length),
+            })
+            res.end(bytes)
+            return
+          }
+        }
         serveSound(req, res, set.release)
       },
     }))
 
-    disposers.push(ctx.webServer.register({
+    function pickBubbleImgDir() {
+      for (const p of BUBBLE_IMG_DIR_CANDIDATES) {
+        try {
+          fs.mkdirSync(p, { recursive: true })
+          fs.accessSync(p, fs.constants.W_OK)
+          return p
+        } catch (err) {}
+      }
+      return BUBBLE_IMG_DIR_CANDIDATES[0]
+    }
+    function defaultBubbleImgIndex() {
+      return { version: 1, images: [] }
+    }
+    function readBubbleImgIndex() {
+      try {
+        const parsed = JSON.parse(fs.readFileSync(path.join(pickBubbleImgDir(), BUBBLE_IMG_INDEX_NAME), 'utf8'))
+        if (parsed && Array.isArray(parsed.images)) return parsed
+      } catch (err) {}
+      return defaultBubbleImgIndex()
+    }
+    function writeBubbleImgIndex(index) {
+      try {
+        fs.writeFileSync(path.join(pickBubbleImgDir(), BUBBLE_IMG_INDEX_NAME), JSON.stringify(index, null, 2), 'utf8')
+        return true
+      } catch (err) {
+        return false
+      }
+    }
+    function bubbleImgPayload() {
+      const index = readBubbleImgIndex()
+      // 内置默认图常驻(先列出,不占 createdAt 排序;用户图库含同 id 时不重复)
+      const seen = {}
+      index.images.forEach((im) => { seen[im.id] = 1 })
+      const builtins = DEFAULT_BUBBLE_IMGS.filter((d) => !seen[d.id]).map((d) => ({
+        id: d.id,
+        name: String(d.name || d.id),
+        format: d.format === 'gif' ? 'gif' : 'png',
+        url: '/dsh-whale/bubble-img.png?id=' + encodeURIComponent(d.id),
+        createdAt: null,
+        builtin: true,
+      }))
+      return {
+        ok: true,
+        images: builtins.concat(index.images.slice().sort((a, b) => (b.createdAt || 0) - (a.createdAt || 0)).map((im) => ({
+          id: im.id,
+          name: String(im.name || im.id),
+          format: im.format === 'gif' ? 'gif' : 'png',
+          url: '/dsh-whale/bubble-img.png?id=' + encodeURIComponent(im.id),
+          createdAt: im.createdAt || null,
+        }))),
+      }
+    }
+    function bubbleImgIdFromUrl(url) {
+      try {
+        const q = String(url || '').split('?')[1] || ''
+        const m = /(?:^|&)id=([^&]+)/.exec(q)
+        return m ? decodeURIComponent(m[1]) : ''
+      } catch (err) { return '' }
+    }
+    function loadBubbleConfig() {
+      for (const p of BUBBLE_FILE_CANDIDATES) {
+        try {
+          const parsed = JSON.parse(fs.readFileSync(p, 'utf8'))
+          if (parsed && parsed.v === 1) return parsed
+        } catch (err) {}
+      }
+      return null
+    }
+    function writeBubbleConfig(cfg) {
+      const body = JSON.stringify(cfg, null, 2)
+      for (const p of BUBBLE_FILE_CANDIDATES) {
+        try { fs.writeFileSync(p, body, 'utf8'); return true } catch (err) {}
+      }
+      return false
+    }
+
+    disposers.push(registerRoute({
+      kind: 'exact',
+      path: '/dsh-whale/bubble.json',
+      handler: async (req, res) => {
+        try {
+          if (req.method === 'POST' || req.method === 'PUT') {
+            const body = await readBodyMax(req, 512 * 1024)
+            const parsed = JSON.parse(body)
+            if (!parsed || typeof parsed !== 'object' || !Array.isArray(parsed.items) || !Array.isArray(parsed.lib)) {
+              res.writeHead(400, JSON_HEADERS)
+              res.end(JSON.stringify({ ok: false, error: 'invalid bubble config' }))
+              return
+            }
+            // v727：tapAdvance =「点按角色推进泡泡队列」（只存布尔值，不放行其它字段）
+            const cfg = { v: 1, items: parsed.items, lib: parsed.lib, tapAdvance: parsed.tapAdvance === true }
+            writeBubbleConfig(cfg)
+            res.writeHead(200, JSON_HEADERS)
+            res.end(JSON.stringify({ ok: true, config: cfg }))
+            return
+          }
+          const cfg = loadBubbleConfig()
+          res.writeHead(200, JSON_HEADERS)
+          res.end(JSON.stringify({ ok: true, config: cfg }))
+        } catch (err) {
+          res.writeHead(400, JSON_HEADERS)
+          res.end(JSON.stringify({ ok: false, error: String((err && err.message) || err).slice(0, 200) }))
+        }
+      },
+    }))
+
+    disposers.push(registerRoute({
+      kind: 'exact',
+      path: '/dsh-whale/bubble-imgs.json',
+      handler: (req, res) => {
+        res.writeHead(200, JSON_HEADERS)
+        res.end(JSON.stringify(bubbleImgPayload()))
+      },
+    }))
+
+    disposers.push(registerRoute({
+      kind: 'exact',
+      path: '/dsh-whale/bubble-img-upload.json',
+      handler: async (req, res) => {
+        try {
+          const body = await readBodyMax(req, 10 * 1024 * 1024)
+          const parsed = JSON.parse(body)
+          const action = parsed && parsed.action
+          const index = readBubbleImgIndex()
+          if (action === 'upload') {
+            const name = String(parsed.name || '').trim().slice(0, 40) || ''
+            const data = String(parsed.data || '')
+            const m = /^data:image\/(png|gif);base64,([A-Za-z0-9+/=]+)$/.exec(data)
+            if (!m) {
+              res.writeHead(400, JSON_HEADERS)
+              res.end(JSON.stringify({ ok: false, error: 'invalid image data' }))
+              return
+            }
+            const format = m[1] === 'gif' ? 'gif' : 'png'
+            const buf = Buffer.from(m[2], 'base64')
+            if (buf.length < 64 || buf.length > 8 * 1024 * 1024) {
+              res.writeHead(400, JSON_HEADERS)
+              res.end(JSON.stringify({ ok: false, error: 'image too large' }))
+              return
+            }
+            const id = 'bimg_' + Date.now().toString(36) + '_' + Math.random().toString(36).slice(2, 8)
+            fs.writeFileSync(path.join(pickBubbleImgDir(), id + '.' + format), buf)
+            index.images.push({ id, name, format, createdAt: Date.now() })
+            writeBubbleImgIndex(index)
+            res.writeHead(200, JSON_HEADERS)
+            res.end(JSON.stringify(bubbleImgPayload()))
+            return
+          }
+          if (action === 'delete') {
+            const id = String(parsed.id || '')
+            const img = index.images.find((x) => x.id === id)
+            if (!img) {
+              res.writeHead(404, JSON_HEADERS)
+              res.end(JSON.stringify({ ok: false, error: 'image not found' }))
+              return
+            }
+            index.images = index.images.filter((x) => x.id !== id)
+            writeBubbleImgIndex(index)
+            const ext = img.format === 'gif' ? 'gif' : 'png'
+            try { fs.unlinkSync(path.join(pickBubbleImgDir(), id + '.' + ext)) } catch (err) {}
+            res.writeHead(200, JSON_HEADERS)
+            res.end(JSON.stringify(bubbleImgPayload()))
+            return
+          }
+          res.writeHead(400, JSON_HEADERS)
+          res.end(JSON.stringify({ ok: false, error: 'unknown action' }))
+        } catch (err) {
+          res.writeHead(400, JSON_HEADERS)
+          res.end(JSON.stringify({ ok: false, error: String((err && err.message) || err).slice(0, 200) }))
+        }
+      },
+    }))
+
+    disposers.push(registerRoute({
+      kind: 'exact',
+      path: '/dsh-whale/bubble-img.png',
+      handler: (req, res) => {
+        try {
+          const id = bubbleImgIdFromUrl(req.url)
+          // 1) 用户图库优先
+          const index = readBubbleImgIndex()
+          const img = index.images.find((x) => x.id === id)
+          if (img) {
+            const ext = img.format === 'gif' ? 'gif' : 'png'
+            const bytes = fs.readFileSync(path.join(pickBubbleImgDir(), id + '.' + ext))
+            res.writeHead(200, {
+              'Content-Type': img.format === 'gif' ? 'image/gif' : 'image/png',
+              'Cache-Control': 'no-store',
+              'Content-Length': String(bytes.length),
+            })
+            res.end(bytes)
+            return
+          }
+          // 2) 内置默认图回退(全新安装无用户图库时,泡泡序列引用的语义 id 也能出图)
+          const def = DEFAULT_BUBBLE_IMGS.find((x) => x.id === id)
+          if (def) {
+            const bytes = loadBuiltinBubbleImgBytes(def)
+            if (bytes) {
+              res.writeHead(200, {
+                'Content-Type': def.format === 'gif' ? 'image/gif' : 'image/png',
+                'Cache-Control': 'no-store',
+                'Content-Length': String(bytes.length),
+              })
+              res.end(bytes)
+              return
+            }
+          }
+          throw new Error('bad image id')
+        } catch (err) {
+          res.writeHead(404, { 'Content-Type': 'text/plain; charset=utf-8' })
+          res.end('bubble image unavailable')
+        }
+      },
+    }))
+
+          disposers.push(registerRoute({
       kind: 'exact',
       path: '/dsh-whale/widget.js',
       handler: (req, res) => {
@@ -2002,7 +3175,7 @@ function apply(ctx) {
           'Content-Type': 'application/javascript; charset=utf-8',
           'Cache-Control': 'no-store',
         })
-        res.end(WIDGET_JS)
+        res.end(loadWidgetJs())
       },
     }))
 
@@ -2018,6 +3191,5 @@ function apply(ctx) {
         try { d() } catch (err) {}
       }
     })
+  },
 }
-
-export { name, inject, apply }