@mzzsfy/dsh-usage-panel 0.4.5 → 0.6.0

package/README.md

@@ -40,8 +40,8 @@ dsh plugin --profile web add @mzzsfy/dsh-usage-panel
 
 ## 定期查询与趋势(v2)
 
-- 定期查询:时间驱动调度——每账号按读数档位定档,含 5 小时窗口的账号每 10 分钟查询一次(= 短窗口快照粒度),其余账号每小时一次(= 长窗口快照粒度);上次尝试查询时刻随配置持久化,宿主重启后调度无缝衔接。定时轮询为软依赖:宿主 timer 服务不可用时仅停用自动轮询,面板显示降级提示,手动查询与全部配置能力不受影响
-- 失败退避:单账号失败按指数退避(基期 = 账号档位间隔,×2 封顶 8 倍),成功即恢复;失败账号按短档节奏(10 分钟)调度重试,退避指数压制实际频率,避免一次瞬时失败造成短窗序列长时间空洞。退避与档位到点独立叠加,二者皆过才发起查询。面板打开触发的自动查询同样受退避约束,手动刷新不受限
+- 定期查询:时间驱动调度——全账号统一每 10 分钟查询一次(余额阈值等通知最长延迟约 10 分钟);上次尝试查询时刻随配置持久化,宿主重启后调度无缝衔接。定时轮询为软依赖:宿主 timer 服务不可用时仅停用自动轮询,面板显示降级提示,手动查询与全部配置能力不受影响
+- 失败退避:单账号失败按指数退避(基期 = 统一查询间隔,×2 封顶 8 倍),成功即恢复。退避与到点判定独立叠加,二者皆过才发起查询。面板打开触发的自动查询同样受退避约束,手动刷新不受限
 - 历史快照:按序列分档落盘 `history.json`(5 小时滚动 → 10 分钟粒度留 7 天;7 天 / 月 / 余额 → 小时粒度留 30 天),档内去重,超期修剪,硬点数上限兜底;删除账号时其历史序列同步清理
 - 趋势视图:悬浮账号卡片弹出 sparkline(自绘 SVG),短 / 长窗口独立成图,绝对值 / 差值双视角;「详情」对话框可切时间范围(长窗口 / 月 / 余额:近 7 天 / 30 天 / 全部;5 小时短窗口仅近 7 天 / 全部),含区间摘要与明细表
 - 历史文件解析失败时自动备份为 `history.json.bak` 并暂停写入(防空数据覆盖);`history.json` 被移除或恢复为可解析内容后自动恢复写入,`.bak` 是损坏前的最后数据,删除前请确认不再需要。`accounts.json` 同构守卫:损坏时备份为 `accounts.json.bak` 并拒绝一切写入(防账号 Key 被空配置覆盖),恢复后解除
@@ -73,7 +73,7 @@ usage-panel:
     balanceThreshold: null        # 余额阈值,null 为不启用
     resetNotice: true             # 窗口重置时通知上一窗口峰值
     toast: true                   # 页内 toast 通道
-    webhookUrl: ''                # 凭据,留空禁用;面板只写不回显
+    webhookUrl: ''                # webhook 目标 URL,留空禁用;面板原文回显
     imTargets: []                 # dsh-im 投递目标 [{botId, targetId}]
 ```
 
@@ -88,7 +88,7 @@ usage-panel:
 ### 通知接口
 
 - `GET /api/usage-panel/notifications`:通知投影长轮询;`cursor` 缺省=首拉立即返回全量,`cursor` 等于当前版本时挂起至事件或超时,落后或超前(宿主重启版本回退)立即返回全量,客户端以响应 version 重置游标自愈;响应 `{units, version}`
-- `GET|POST /api/usage-panel/notify-config`:全局通知规则;`webhookUrl` 属凭据任何响应不回传原文,仅 `webhookConfigured` 标志
+- `GET|POST /api/usage-panel/notify-config`:全局通知规则;`webhookUrl` 原文随响应回显
 - `POST /api/usage-panel/test-webhook` / `POST /api/usage-panel/test-im`:测试投递,返回真实结果
 - `GET /api/usage-panel/im-targets?botId=`:列出 dsh-im 该 bot 已保存投递目标
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mzzsfy/dsh-usage-panel",
   "description": "多平台 LLM 账号余额与额度面板:支持 DeepSeek/OpenRouter/Kimi/智谱/MiniMax/NewApi 及自定义端点,自动定期查询,趋势图与历史快照,用量/余额阈值与窗口重置多通道通知",
-  "version": "0.4.5",
+  "version": "0.6.0",
   "type": "module",
   "main": "src/index.js",
   "exports": {

package/src/client.js

@@ -992,6 +992,7 @@ function NotifyConfigCard() {
       .then((res) => {
         if (!alive) return
         setConfig(res && res.notify ? res.notify : {})
+        setWebhookUrl(res && res.notify && typeof res.notify.webhookUrl === 'string' ? res.notify.webhookUrl : '')
         setImAvailable(res ? res.imAvailable === true : false)
       })
       .catch((err) => { if (alive) setError('读取通知配置失败:' + (err && err.message ? err.message : String(err))) })
@@ -1097,6 +1098,9 @@ function NotifyConfigCard() {
   }
   const targets = Array.isArray(config.imTargets) ? config.imTargets : []
   const boundBots = imBoundBotIds(targets)
+  // 已配置态与测试/保存分流均由 webhookUrl 派生;草稿编辑中不被其他 patch 回执重置
+  const savedWebhookUrl = typeof config.webhookUrl === 'string' ? config.webhookUrl.trim() : ''
+  const webhookDirty = webhookUrl.trim() !== savedWebhookUrl
   // 通知配置一次即久,默认折叠:summary 摘要行常显状态,展开才是完整配置
   return h('details', { className: 'up-card up-fold' },
     h('summary', { className: 'up-fold__summary' },
@@ -1104,7 +1108,7 @@ function NotifyConfigCard() {
       h('span', { className: 'up-dot' + (config.enabled === true ? '' : ' up-dot--off') }),
       h('span', { className: 'up-meta' }, config.enabled === true ? '已启用' : '已关闭'),
       targets.length > 0 ? h('span', { className: 'up-meta' }, targets.length + ' 个 IM 目标') : null,
-      config.webhookConfigured === true ? h('span', { className: 'up-meta' }, 'webhook 已配置') : null,
+      savedWebhookUrl.length > 0 ? h('span', { className: 'up-meta' }, 'webhook 已配置') : null,
     ),
     h('div', { className: 'up-card__row' },
       h(Switch, {
@@ -1156,29 +1160,37 @@ function NotifyConfigCard() {
         onChange: (checked) => patch({ toast: checked }),
       }),
       h('div', { className: 'up-card__row' },
-        h('span', { className: 'up-field__label', title: 'host 直发的 Slack 兼容 JSON 通知;填新地址保存后自动发送测试' }, 'Webhook'),
-        config.webhookConfigured === true ? h('span', { className: 'up-dot', title: '已配置' }) : null,
+        h('span', { className: 'up-field__label', title: 'host 直发的 Slack 兼容 JSON 通知;URL 原文回显,改动保存后自动发送测试' }, 'Webhook'),
+        savedWebhookUrl.length > 0 ? h('span', { className: 'up-dot', title: '已配置' }) : null,
         h('span', { className: 'up-field' },
           h('input', {
-            type: 'password', style: { width: '260px' },
+            type: 'text', style: { width: '260px' },
             value: webhookUrl,
             onChange: (e) => setWebhookUrl(e.target.value),
-            placeholder: config.webhookConfigured === true ? '已配置,留空保持不变' : 'https://hooks.example.com/…',
+            placeholder: 'https://hooks.example.com/…',
           })),
         h('button', {
           className: 'up-btn',
           onClick: () => {
-            if (webhookUrl.trim().length === 0) {
-              if (config.webhookConfigured !== true) { notify('请先填写 webhook URL', 'error'); return }
+            if (!webhookDirty) {
+              if (savedWebhookUrl.length === 0) { notify('请先填写 webhook URL', 'error'); return }
               testWebhook()
               return
             }
-            const part = { webhookUrl: webhookUrl.trim() }
-            api('/api/usage-panel/notify-config', { method: 'POST', body: JSON.stringify(part) })
-              .then((res) => { apply(res); setWebhookUrl(''); testWebhook() })
+            // 草稿与已保存值不同即保存(含清空=禁用);清空保存后通道关闭,不再自动测试误导报错
+            const disabling = webhookUrl.trim().length === 0
+            api('/api/usage-panel/notify-config', { method: 'POST', body: JSON.stringify({ webhookUrl: webhookUrl.trim() }) })
+              .then((res) => {
+                if (res && res.notify) {
+                  setConfig(res.notify)
+                  setWebhookUrl(typeof res.notify.webhookUrl === 'string' ? res.notify.webhookUrl : '')
+                }
+                notify(disabling ? 'webhook 已禁用' : '通知配置已保存', 'ok')
+                if (!disabling) testWebhook()
+              })
               .catch(fail)
           },
-        }, webhookUrl.trim().length > 0 ? '保存并测试' : '测试'),
+        }, webhookDirty ? '保存并测试' : '测试'),
       ),
       // IM 通道:目标来自 dsh-im 已保存目录,勾选即自动保存;新建与平台测试在 dsh-im 设置页完成
       imAvailable ? null : h('span', { className: 'up-meta' }, 'dsh-im 未安装,IM 通道不可用'),

package/src/index.js

@@ -16,7 +16,7 @@ import {
 } from './parsers.mjs'
 import { readingToSnapshots, appendPoint, buildMonthSequence, newSequenceStore } from './history.mjs'
 import { createHistoryStore } from './historyStore.mjs'
-import { createBackoff, isShortWindowTier, tierIntervalSec, lastQuerySecOf, isDue, runLimited } from './poller.mjs'
+import { createBackoff, lastQuerySecOf, isDue, runLimited, POLL_INTERVAL_SEC } from './poller.mjs'
 import {
   DEFAULT_QUOTA_THRESHOLD_PCT,
   WEBHOOK_TIMEOUT_MS,
@@ -51,7 +51,6 @@ const HISTORY_FILE = join(DATA_DIR, 'history.json')
 const BAK_SUFFIX = '.bak'
 const ACCOUNTS_BROKEN_MESSAGE = '账号配置文件已损坏已备份,已暂停写入以防数据丢失'
 const TICK_SEC = 30
-const SHORT_SUFFIX = '5h'
 
 const NAMESPACE = 'usage-panel'
 
@@ -334,9 +333,8 @@ export function apply(ctx) {
   let accountsBroken = false
   let historyStore = createHistoryStore({ file: HISTORY_FILE })
   let history = newSequenceStore()
-  // 账号级档位退避状态:基期随读数档位翻转重建;调度到点由 last.queriedAt + 档位间隔另行判定
-  const pollState = new Map()
-  // 通知投影(client 轮询展示)与事件序号
+  // 账号级退避状态:每账号失败计数独立,只管退避不管调度;调度到点由 last.queriedAt + 统一间隔另行判定
+  const pollState = new Map()  // 通知投影(client 轮询展示)与事件序号
   const projection = createProjection({})
   let notifySeq = 0
 
@@ -367,37 +365,28 @@ export function apply(ctx) {
     return persistHistory()
   }
 
-  // 账号级退避状态:基期 = 账号档位间隔(读数档位翻转时重建),只管退避不管调度
+  // 账号级退避状态:基期 = 统一查询间隔,每账号失败计数独立,只管退避不管调度
   function pollEntry(account) {
-    const baseSec = tierIntervalSec(hasShortWindow(account))
     const existing = pollState.get(account.id)
-    if (existing && existing.baseSec === baseSec) return existing
-    const state = { baseSec, backoff: createBackoff({ baseSec }) }
-    pollState.set(account.id, state)
-    return state
-  }
-
-  function hasShortWindow(account) {
-    return isShortWindowTier(
-      account.last,
-      account.last !== null && account.last.reading !== null &&
-        readingToSnapshots(account.last.reading).some((snap) => snap.suffix === SHORT_SUFFIX),
-    )
+    if (existing) return existing
+    const backoff = createBackoff({ baseSec: POLL_INTERVAL_SEC })
+    pollState.set(account.id, backoff)
+    return backoff
   }
 
   function runQuery(account) {
     const queriedAt = Date.now()
     return queryAccount(account).then((result) => {
-      const state = pollEntry(account)
+      const backoff = pollEntry(account)
       if (result.ok) {
-        state.backoff.onSuccess()
+        backoff.onSuccess()
         // 先评估后落盘:阈值穿越事件不因落盘失败丢失;落盘失败仅弃本轮快照
         evaluateAndDispatch(account, queriedAt)
         return recordSnapshots(account, account.last.reading, queriedAt)
           .catch(() => {})
           .then(() => result)
       }
-      state.backoff.onFailure(Math.floor(queriedAt / 1000))
+      backoff.onFailure(Math.floor(queriedAt / 1000))
       return result
     })
   }
@@ -538,7 +527,7 @@ export function apply(ctx) {
           const account = current.accounts.find((item) => item.id === id)
           requireOk(account !== undefined, '账号不存在: ' + id)
           // 面板打开触发的自动查询受退避约束,避免绕过退避轰炸上游;手动刷新不受限
-          if (auto && pollEntry(account).backoff.isBlocked(Math.floor(Date.now() / 1000))) {
+          if (auto && pollEntry(account).isBlocked(Math.floor(Date.now() / 1000))) {
             sendJson(res, 200, { ok: false, skipped: true, account: redactAccount(account) })
             return
           }
@@ -730,7 +719,7 @@ export function apply(ctx) {
   )
 
   // 定期轮询:固定短 tick,时间驱动调度——上次尝试查询时刻(account.last.queriedAt,
-  // 成功失败均记、随配置持久化)距今超过账号档位间隔即到点;退避独立叠加,二者皆过才查。
+  // 成功失败均记、随配置持久化)距今超过统一查询间隔即到点;退避独立叠加,二者皆过才查。
   // 旧 round 分频形态已废:round 仅查询时递增使余额类账号死锁停摆,短窗账号每 tick 必查
   // 使间隔设置失效。
   // timer 软依赖经嵌套 inject 等待:服务激活才武装轮询,缺失则自动轮询停用,
@@ -748,11 +737,11 @@ export function apply(ctx) {
       if (!current) return
       const nowSec = Math.floor(Date.now() / 1000)
       const due = current.accounts.filter((account) => {
-        if (pollEntry(account).backoff.isBlocked(nowSec)) return false
+        if (pollEntry(account).isBlocked(nowSec)) return false
         return isDue({
           lastQuerySec: lastQuerySecOf(account.last),
           nowSec,
-          intervalSec: tierIntervalSec(hasShortWindow(account)),
+          intervalSec: POLL_INTERVAL_SEC,
         })
       })
       if (due.length === 0) return

package/src/notify.mjs

@@ -405,7 +405,7 @@ export function resolvedNotifySettings(raw) {
   }
 }
 
-// 面板可见配置:webhookUrl 属凭据不出主机,仅回是否已配置。
+// 面板可见配置:webhookUrl 原文随响应回显,面板所见即所存。
 export function publicNotify(resolved) {
   return {
     enabled: resolved.enabled,
@@ -414,7 +414,7 @@ export function publicNotify(resolved) {
     resetNotice: resolved.resetNotice,
     toast: resolved.toast,
     imTargets: resolved.imTargets,
-    webhookConfigured: resolved.webhookUrl.trim().length > 0,
+    webhookUrl: resolved.webhookUrl,
   }
 }
 

package/src/poller.mjs

@@ -1,15 +1,15 @@
-// 轮询纯逻辑层:时间驱动调度 / 失败指数退避 / 档位间隔。无 IO,host 半区与单测共用。
+// 轮询纯逻辑层:时间驱动调度 / 失败指数退避 / 统一查询间隔。无 IO,host 半区与单测共用。
 // 历史教训:旧 round 分频形态(round 仅在查询时递增)构成死锁——余额类账号首查后
 // round 恒 1 永不再查;短窗账号每 tick 必查使用户间隔设置完全失效。改为时间驱动:
-// 上次尝试查询时刻(成功失败均记)+ 档位间隔判定到点,退避独立叠加。
+// 上次尝试查询时刻(成功失败均记)+ 统一间隔判定到点,退避独立叠加。
+// 旧档位间隔(短窗 10 分钟/余额 1 小时)已统一为单一间隔:通知及时性要求余额类
+// 账号同节奏,两档常量相等后档位机制退化为恒同值死路径,整体移除。
 
 export const BACKOFF_CAP_MULTIPLE = 8
-// 短窗口档(5h 序列)查询间隔 = 序列快照粒度(history.mjs GRANULARITY_MS['10m'])
-export const SHORT_TIER_INTERVAL_SEC = 10 * 60
-// 长窗口档(日/月/余额序列)查询间隔 = 序列快照粒度(history.mjs GRANULARITY_MS['1h'])
-export const LONG_TIER_INTERVAL_SEC = 60 * 60
+// 全账号统一查询间隔
+export const POLL_INTERVAL_SEC = 10 * 60
 
-// 失败退避状态机:基期 = 账号档位间隔,×2 封顶;成功即恢复。
+// 失败退避状态机:基期 = 统一查询间隔,×2 封顶;成功即恢复。
 export function createBackoff({ baseSec }) {
   let failures = 0
   let nextRetryAt = null
@@ -32,19 +32,6 @@ export function createBackoff({ baseSec }) {
   }
 }
 
-// 短窗口档账号判定:从未查询成功(含最近一次失败)或最近成功读数含短窗序列。
-// 失败归短档:保持 10 分钟调度节奏与 600s 退避基期,避免一次瞬时失败把含 5h
-// 窗口的账号塌缩到 1 小时档,造成短窗序列长时间空洞;轰炸由退避指数压制。
-export function isShortWindowTier(last, readingHasShort) {
-  if (last === null) return true
-  return last.ok !== true || readingHasShort
-}
-
-// 账号档位间隔:含短窗口序列走短档,否则长档。
-export function tierIntervalSec(hasShortWindow) {
-  return hasShortWindow ? SHORT_TIER_INTERVAL_SEC : LONG_TIER_INTERVAL_SEC
-}
-
 // 上次尝试查询时刻(秒):queriedAt 毫秒历元;缺失/非法(旧数据)回 null 视为立即到点。
 export function lastQuerySecOf(last) {
   const queriedAt = last !== null && typeof last === 'object' ? last.queriedAt : undefined

package/test/notify.route.test.mjs

@@ -176,22 +176,22 @@ test('评估接线: custom 账号 extract 规则驱动 balance 读数全链路(
   }
 })
 
-test('notify-config: GET 不回显 webhookUrl 原文, 仅回是否已配置', async () => {
+test('notify-config: GET 回显 webhookUrl 原文', async () => {
   // Given 已配置 webhook 的 settings
   const { ctx, routes } = makeCtx({ settingsValue: { notify: { enabled: true, webhookUrl: 'https://hooks.example.com/private' } } })
   apply(ctx)
   // When 读取通知配置
   const res = await call(routes, '/api/usage-panel/notify-config', makeReq('GET'))
-  // Then 原文不出主机
+  // Then 原文随响应回显, webhookConfigured 已移除
   assert.equal(res.status, 200)
-  assert.equal(res.payload.notify.webhookUrl, undefined)
-  assert.equal(res.payload.notify.webhookConfigured, true)
+  assert.equal(res.payload.notify.webhookUrl, 'https://hooks.example.com/private')
+  assert.equal('webhookConfigured' in res.payload.notify, false)
   assert.equal(res.payload.imAvailable, false)
 })
 
 test('notify-config: 非法补丁 400, 合法补丁合并生效', async () => {
-  // Given 合法 ctx
-  const { ctx, routes } = makeCtx({ settingsValue: { notify: { enabled: true } } })
+  // Given 合法 ctx,已配置 webhook
+  const { ctx, routes } = makeCtx({ settingsValue: { notify: { enabled: true, webhookUrl: 'https://hooks.example.com/keep' } } })
   apply(ctx)
   // When 提交越界阈值
   const bad = await call(routes, '/api/usage-panel/notify-config', makeReq('POST', { quotaThresholdPct: 0 }))
@@ -199,12 +199,13 @@ test('notify-config: 非法补丁 400, 合法补丁合并生效', async () => {
   assert.equal(bad.status, 400)
   // When 提交合法补丁(仅改阈值与余额阈值)
   const good = await call(routes, '/api/usage-panel/notify-config', makeReq('POST', { quotaThresholdPct: 80, balanceThreshold: 20 }))
-  // Then 生效且未提供的键保持原值
+  // Then 生效且未提供的键保持原值(部分补丁不得清掉已存 webhook)
   assert.equal(good.status, 200)
   const view = await call(routes, '/api/usage-panel/notify-config', makeReq('GET'))
   assert.equal(view.payload.notify.quotaThresholdPct, 80)
   assert.equal(view.payload.notify.balanceThreshold, 20)
   assert.equal(view.payload.notify.enabled, true)
+  assert.equal(view.payload.notify.webhookUrl, 'https://hooks.example.com/keep')
 })
 
 test('test-webhook: 返回真实投递结果而非谎报成功', async () => {

package/test/notify.test.mjs

@@ -418,14 +418,14 @@ test('读侧归一: 残缺配置回退默认值', () => {
   assert.equal(resolved.webhookUrl, '')
 })
 
-test('凭据脱敏: publicNotify 不回显 webhookUrl 原文, 仅回是否已配置', () => {
+test('面板回显: publicNotify 返回 webhookUrl 原文', () => {
   // Given 已配置 webhook 的归一配置
   const resolved = resolvedNotifySettings({ webhookUrl: 'https://hooks.example.com/private' })
   // When 转面板可见形态
   const view = publicNotify(resolved)
-  // Then 原文不出主机, webhookConfigured 为 true
-  assert.equal(view.webhookUrl, undefined)
-  assert.equal(view.webhookConfigured, true)
+  // Then 原文随响应回显, webhookConfigured 已移除
+  assert.equal(view.webhookUrl, 'https://hooks.example.com/private')
+  assert.equal('webhookConfigured' in view, false)
   assert.equal(view.toast, true)
 })
 

package/test/poller.test.mjs

@@ -1,17 +1,16 @@
-// 轮询纯逻辑 BDD:时间驱动调度 / 失败退避 / 档位间隔。无外部依赖,定时器由调用方注入。
+// 轮询纯逻辑 BDD:时间驱动调度 / 失败退避 / 统一查询间隔。无外部依赖,定时器由调用方注入。
 // 历史:round 分频形态(shouldQueryThisRound/longWindowDivisor)已被时间驱动取代——
 // round 仅查询时递增使余额类账号死锁停摆,短窗账号每 tick 必查使用户间隔失效。
+// 档位间隔(短档 10 分钟/长档 1 小时)已被统一间隔取代——通知及时性要求余额类账号
+// 与短窗账号同节奏,两档常量相等后档位机制退化为恒同值死路径,整体移除。
 import { test } from 'node:test'
 import assert from 'node:assert/strict'
 import {
   BACKOFF_CAP_MULTIPLE,
-  SHORT_TIER_INTERVAL_SEC,
-  LONG_TIER_INTERVAL_SEC,
+  POLL_INTERVAL_SEC,
   createBackoff,
-  tierIntervalSec,
   lastQuerySecOf,
   isDue,
-  isShortWindowTier,
   runLimited,
 } from '../src/poller.mjs'
 
@@ -45,11 +44,8 @@ test('场景: 退避期间被跳过,到期放行', () => {
   assert.equal(backoff.isBlocked(600), false)
 })
 
-test('场景: 档位间隔 = 序列快照粒度(短档 10 分钟,长档 1 小时)', () => {
-  assert.equal(SHORT_TIER_INTERVAL_SEC, 10 * 60)
-  assert.equal(LONG_TIER_INTERVAL_SEC, 60 * 60)
-  assert.equal(tierIntervalSec(true), SHORT_TIER_INTERVAL_SEC)
-  assert.equal(tierIntervalSec(false), LONG_TIER_INTERVAL_SEC)
+test('场景: 统一查询间隔 10 分钟,余额类账号与短窗账号同节奏', () => {
+  assert.equal(POLL_INTERVAL_SEC, 10 * 60)
 })
 
 test('场景: 上次尝试查询时刻换算,缺失或非法回 null 视为立即到点', () => {
@@ -65,29 +61,19 @@ test('场景: 时间驱动到点判定', () => {
   assert.equal(isDue({ lastQuerySec: null, nowSec: 1000, intervalSec: 600 }), true, '从未查询立即到点')
   assert.equal(isDue({ lastQuerySec: 500, nowSec: 1099, intervalSec: 600 }), false, '未满间隔')
   assert.equal(isDue({ lastQuerySec: 500, nowSec: 1100, intervalSec: 600 }), true, '恰满间隔到点')
-  assert.equal(isDue({ lastQuerySec: 0, nowSec: LONG_TIER_INTERVAL_SEC, intervalSec: LONG_TIER_INTERVAL_SEC }), true)
+  assert.equal(isDue({ lastQuerySec: 0, nowSec: POLL_INTERVAL_SEC, intervalSec: POLL_INTERVAL_SEC }), true)
 })
 
 test('场景: 退避与到点独立叠加,双过才查(时序推演锁定)', () => {
-  // 短窗账号失败:退避基期 = 档间隔 600;首次失败后 600s 内到点亦被退避压住
-  const backoff = createBackoff({ baseSec: SHORT_TIER_INTERVAL_SEC })
+  // 失败:退避基期 = 统一间隔;首次失败后一个周期内到点亦被退避压住
+  const backoff = createBackoff({ baseSec: POLL_INTERVAL_SEC })
   backoff.onFailure(1000)
   const dueAt = (lastQuerySec, nowSec) =>
-    !backoff.isBlocked(nowSec) && isDue({ lastQuerySec, nowSec, intervalSec: SHORT_TIER_INTERVAL_SEC })
+    !backoff.isBlocked(nowSec) && isDue({ lastQuerySec, nowSec, intervalSec: POLL_INTERVAL_SEC })
   assert.equal(dueAt(400, 1500), false, '退避未过(到 1600 才解),尽管 1000 已到点')
   assert.equal(dueAt(400, 1600), true, '退避与到点双过')
 })
 
-test('场景: 短窗口档判定,从未成功(含最近失败)按短档,失败不塌缩到长档', () => {
-  const readingHasShort = true
-  assert.equal(isShortWindowTier(null, readingHasShort), true, 'last 为空视为短窗口档')
-  assert.equal(isShortWindowTier(null, false), true, 'last 为空即使无短窗口读数也首轮即查')
-  assert.equal(isShortWindowTier({ ok: true, reading: {} }, readingHasShort), true)
-  assert.equal(isShortWindowTier({ ok: true, reading: {} }, false), false, '成功且仅长窗口按长档')
-  assert.equal(isShortWindowTier({ ok: false, reading: null }, readingHasShort), true, '失败不塌缩:含短窗账号保持短档节奏')
-  assert.equal(isShortWindowTier({ ok: false, reading: null }, false), true, '失败的长窗账号也归短档:10 分钟节奏 + 退避压制重试')
-})
-
 test('场景: 受限并发执行——全项被处理,慢任务不阻塞其他 worker', async () => {
   // Given 6 项任务,并发 2:每个任务挂起直到放行;并发内慢任务(后放行)只占 1 个 worker 位
   const processed = []