dsh-router-core 0.3.2 → 0.3.3

package/src/router/usage-store.ts

@@ -5,14 +5,21 @@
  * 落盘**而不是 SQLite：dsh-router 现有持久化全是 JSON（supplier-config.json /
  * keys.json），不为一个看板引入数据库依赖。
  *
- * 两条查询路径（照 9router `getUsageStats` 的 `useDailySummary` 分叉）：
- *   - `today` / `24h` → 走**明细环**（滚动窗口，天桶是自然日，对不上）
- *   - `7d` / `30d`   → 走**天桶**（长期精确，不受明细环容量限制）
+ * 统计口径（不再走明细环 —— 见下面「天花板」）：
+ *   - `today`      → 走**天桶**（今天这一桶就是答案，天然精确）
+ *   - `24h`        → 走**小时桶**（滚动窗口，天桶是自然日，对不上）
+ *   - `7d` / `30d` → 走**天桶**（长期精确）
  *
  * 天花板（JSON 的代价，刻意接受）：
- *   - 明细环只留最近 `RING_CAP` 条。超量时 today/24h 会**少算**（天桶不会，
- *     所以 7d/30d 永远准）。要彻底准就把明细也落盘成按小时的桶，届时
- *     `chart()` 的小时桶直接读它即可，接口不用变。
+ *   - 明细环 `recent[]` 只留最近 `RING_CAP` 条，**只服务「最近请求列表」**，
+ *     不参与任何统计。历史上 today/24h 直接扫它，单日超 500 条就被静默截断，
+ *     于是出现「今日 500 / 7 天 1621」这种自相矛盾的数字——现在不会了。
+ *   - **小时桶只从新数据开始累积**：升级前落的盘没有小时粒度，而明细环只剩
+ *     最近 500 条、回溯不回去，所以那段历史的**天内分布是永久缺失的**。
+ *     影响面：①`24h` 遇到「小时粒度不齐」的自然日 → 整桶计入（宁可多算，
+ *     也不显示一个比「今日」还小的荒唐数字）；②`today`/`24h` 的小时柱状图
+ *     那几格是空的（不编数据）。天桶口径（today/7d/30d）完全不受影响，
+ *     新数据立刻就有小时粒度，隔天起图表全正常。
  *   - 天桶保留 30 天（9router 有 SQLite 不 prune，JSON 撑不住，得自己限）
  *   - 落盘防抖 2s：进程被 kill 最多丢 2s 的计数。看板不是账本，可接受；
  *     要严格就改成立即写，代价是每个请求一次磁盘写。
@@ -52,6 +59,21 @@ interface Entry {
   lastTs: number
 }
 
+/** 小时桶（today/24h 的统计口径，下标 = 本地小时 0..23）。 */
+interface HourBucket {
+  requests: number
+  ok: number
+  failed: number
+  promptTokens: number
+  completionTokens: number
+  cachedTokens: number
+  durationMs: number
+  ttfbMs: number
+  ttfbCount: number
+  estimatedInputs: number
+  estimatedOutputs: number
+}
+
 /** 一天一桶。 */
 interface DayBucket {
   requests: number
@@ -67,6 +89,8 @@ interface DayBucket {
   /** 输入是估算的请求数（面板据此提示「部分数据为估算」）。 */
   estimatedInputs: number
   estimatedOutputs: number
+  /** 24 个小时桶，定长（天桶本身才 1.5KB，加这个可忽略）。 */
+  hours: HourBucket[]
   bySupplier: Record<string, Entry>
   byModel: Record<string, Entry>
   byRequested: Record<string, Entry>
@@ -80,13 +104,30 @@ interface UsageFile {
 
 export type Period = 'today' | '24h' | '7d' | '30d'
 
-/** 明细环容量：够 today/24h 看，又不至于让 JSON 无限长。 */
+/** 明细环容量：只喂「最近请求列表」，跟统计口径无关了。 */
 const RING_CAP = 500
+/** 一天几格（小时桶定长；要更细的精度就把这个值放大）。 */
+const HOURS = 24
 /** 天桶保留天数。 */
 const KEEP_DAYS = 30
 /** 落盘防抖。 */
 const SAVE_DEBOUNCE_MS = 2000
 
+/** 小时格：一个整点 + 它落在哪个自然日 + 那天的数据/该小时桶（无数据则 undefined）。 */
+interface HourSlot {
+  dayKey: string
+  start: number
+  day: DayBucket | undefined
+  b: HourBucket | undefined
+}
+
+const emptyHour = (): HourBucket => ({
+  requests: 0, ok: 0, failed: 0,
+  promptTokens: 0, completionTokens: 0, cachedTokens: 0,
+  durationMs: 0, ttfbMs: 0, ttfbCount: 0,
+  estimatedInputs: 0, estimatedOutputs: 0,
+})
+
 const emptyDay = (): DayBucket => ({
   requests: 0,
   ok: 0,
@@ -99,6 +140,7 @@ const emptyDay = (): DayBucket => ({
   ttfbCount: 0,
   estimatedInputs: 0,
   estimatedOutputs: 0,
+  hours: Array.from({ length: HOURS }, () => emptyHour()),
   bySupplier: {},
   byModel: {},
   byRequested: {},
@@ -174,6 +216,23 @@ export class UsageStore {
     if (rec.inputEstimated) day.estimatedInputs += 1
     if (rec.outputEstimated) day.estimatedOutputs += 1
 
+    const h = day.hours[new Date(ts).getHours()]
+    if (h !== undefined) {
+      h.requests += 1
+      if (rec.ok) h.ok += 1
+      else h.failed += 1
+      h.promptTokens += promptTokens
+      h.completionTokens += completionTokens
+      h.cachedTokens += rec.cachedTokens
+      h.durationMs += rec.durationMs
+      if (rec.ttfbMs > 0) {
+        h.ttfbMs += rec.ttfbMs
+        h.ttfbCount += 1
+      }
+      if (rec.inputEstimated) h.estimatedInputs += 1
+      if (rec.outputEstimated) h.estimatedOutputs += 1
+    }
+
     this.bump(day.bySupplier, rec.supplier, rec)
     this.bump(day.byModel, rec.model, rec)
     this.bump(day.byRequested, rec.requested, rec)
@@ -198,26 +257,80 @@ export class UsageStore {
     map[key] = e
   }
 
-  /** 窗口内的明细（today/24h 路径）。 */
-  private inWindow(period: Period, now: number): UsageRecord[] {
-    const cutoff = period === 'today' ? new Date(now).setHours(0, 0, 0, 0) : now - 86400000
-    return this.recent.filter((r) => r.ts >= cutoff)
+  /**
+   * 从 `first` 起的 24 个小时格：每格带整点时间戳、所属自然日、那天的数据。
+   *
+   * `today` 传今天 00:00，`24h` 传「当前整点往前 23 格」。
+   * 跨天一律靠 `localDateKey(start)` 现算，不用「减 N 小时」去猜天数：
+   * 本地时区（尤其 DST）下小时偏移和自然日不是一回事，算错就漏一整天。
+   */
+  private hourSlots(first: number): HourSlot[] {
+    const out: HourSlot[] = []
+    for (let i = 0; i < HOURS; i += 1) {
+      const start = first + i * 3600000
+      const dayKey = localDateKey(start)
+      const day = this.days.get(dayKey)
+      out.push({ dayKey, start, day, b: day?.hours[new Date(start).getHours()] })
+    }
+    return out
+  }
+
+  /** 今天的小时格起点（自然日零点）。 */
+  private static dayStartOf(now: number): number {
+    return new Date(now).setHours(0, 0, 0, 0)
+  }
+
+  /** 24h 滚动窗口的小时格起点（当前整点往前 23 格）。 */
+  private static rollingStartOf(now: number): number {
+    const c = new Date(now)
+    c.setMinutes(0, 0, 0)
+    return c.getTime() - (HOURS - 1) * 3600000
+  }
+
+  /**
+   * 一整天的小时桶是否齐（各格之和 >= 天桶计数）。
+   *
+   * 不齐 = 这天是升级前落的盘（没有小时粒度）→ 24h 窗口踩到它就只能整桶计入。
+   * 宁可多算窗口外那截，也不能报一个比「今日」还小的数。
+   */
+  private static hoursComplete(d: DayBucket): boolean {
+    return d.hours.reduce((n, h) => n + h.requests, 0) >= d.requests
   }
 
   /** 汇总 + Top 榜。 */
   stats(period: Period, now = Date.now()): StatsResult {
-    // today/24h 走明细环（滚动窗口）；7d/30d 走天桶
-    if (period === 'today' || period === '24h') {
-      const rows = this.inWindow(period, now)
+    // today 走天桶（今天这一桶就是答案）；24h 走小时桶；7d/30d 走天桶
+    if (period === 'today') {
+      const d = this.days.get(localDateKey(now))
+      const acc = emptyAcc()
+      if (d === undefined) return finish(acc, {}, {}, {}, this.lifetime)
+      addDay(acc, d)
+      // 天桶的维度表就是 today 的 Top 榜，不用另算
+      return finish(acc, d.bySupplier, d.byModel, d.byRequested, this.lifetime)
+    }
+
+    if (period === '24h') {
+      const slots = this.hourSlots(UsageStore.rollingStartOf(now))
       const acc = emptyAcc()
       const bySupplier: Record<string, Entry> = {}
       const byModel: Record<string, Entry> = {}
       const byRequested: Record<string, Entry> = {}
-      for (const rec of rows) {
-        addRec(acc, rec)
-        bumpInto(bySupplier, rec.supplier, rec)
-        bumpInto(byModel, rec.model, rec)
-        bumpInto(byRequested, rec.requested, rec)
+      for (const key of new Set(slots.map((s) => s.dayKey))) {
+        const d = this.days.get(key)
+        if (d === undefined) continue
+        if (UsageStore.hoursComplete(d)) {
+          // 小时粒度齐：只算窗口内踩到的格
+          for (const s of slots) {
+            if (s.dayKey === key && s.b !== undefined) addHour(acc, s.b)
+          }
+        } else {
+          // 老数据（升级前落的盘）：整桶计入，宁可多算也不漏算
+          addDay(acc, d)
+        }
+        // Top 榜只能走天桶的维度表（小时桶不拆维度）
+        mergeInto(bySupplier, d.bySupplier)
+        mergeInto(byModel, d.byModel)
+        mergeInto(byRequested, d.byRequested)
       }
       return finish(acc, bySupplier, byModel, byRequested, this.lifetime)
     }
@@ -230,17 +343,7 @@ export class UsageStore {
     for (let i = days - 1; i >= 0; i -= 1) {
       const d = this.days.get(localDateKey(now - i * 86400000))
       if (d === undefined) continue
-      acc.requests += d.requests
-      acc.ok += d.ok
-      acc.failed += d.failed
-      acc.promptTokens += d.promptTokens
-      acc.completionTokens += d.completionTokens
-      acc.cachedTokens += d.cachedTokens
-      acc.durationMs += d.durationMs
-      acc.ttfbMs += d.ttfbMs
-      acc.ttfbCount += d.ttfbCount
-      acc.estimatedInputs += d.estimatedInputs
-      acc.estimatedOutputs += d.estimatedOutputs
+      addDay(acc, d)
       mergeInto(bySupplier, d.bySupplier)
       mergeInto(byModel, d.byModel)
       mergeInto(byRequested, d.byRequested)
@@ -248,26 +351,16 @@ export class UsageStore {
     return finish(acc, bySupplier, byModel, byRequested, this.lifetime)
   }
 
-  /** 柱状图数据：today/24h = 24 个小时桶（走明细环），7d/30d = 天桶。 */
+  /** 柱状图数据：today/24h = 24 个小时桶，7d/30d = 天桶。 */
   chart(period: Period, now = Date.now()): ChartBucket[] {
     if (period === 'today' || period === '24h') {
-      const rows = this.inWindow(period, now)
-      const start = period === 'today'
-        ? Math.floor(new Date(now).setHours(0, 0, 0, 0) / 3600000) * 3600000
-        : Math.floor((now - 23 * 3600000) / 3600000) * 3600000
-      const buckets: ChartBucket[] = Array.from({ length: 24 }, (_, i) => ({
-        label: `${String(new Date(start + i * 3600000).getHours()).padStart(2, '0')}:00`,
-        requests: 0,
-        tokens: 0,
+      const p = (n: number): string => String(n).padStart(2, '0')
+      const first = period === 'today' ? UsageStore.dayStartOf(now) : UsageStore.rollingStartOf(now)
+      return this.hourSlots(first).map((s) => ({
+        label: `${p(new Date(s.start).getHours())}:00`,
+        requests: s.b?.requests ?? 0,
+        tokens: (s.b?.promptTokens ?? 0) + (s.b?.completionTokens ?? 0),
       }))
-      for (const rec of rows) {
-        const idx = Math.floor((rec.ts - start) / 3600000)
-        const b = buckets[idx]
-        if (b === undefined) continue
-        b.requests += 1
-        b.tokens += rec.promptTokens + rec.completionTokens
-      }
-      return buckets
     }
     const days = period === '7d' ? 7 : 30
     const out: ChartBucket[] = []
@@ -320,8 +413,14 @@ export class UsageStore {
       this.days = new Map(Object.entries(f.days ?? {}))
       this.recent = Array.isArray(f.recent) ? f.recent.slice(0, RING_CAP) : []
       this.lifetime = typeof f.lifetime === 'number' ? f.lifetime : 0
-      // 逐字段兜底：旧文件缺后加的字段（ttfb*/estimated*）不能让整个桶变 NaN
-      for (const [k, d] of this.days) this.days.set(k, { ...emptyDay(), ...d })
+      // 逐字段兜底：旧文件缺后加的字段（ttfb*/estimated*/hours）不能让整个桶变 NaN。
+      // hours 额外修长度/补空：老文件没有它，且 spread 会整段覆盖成短数组或带洞。
+      for (const [k, d] of this.days) {
+        const day: DayBucket = { ...emptyDay(), ...d }
+        const hours = Array.from({ length: HOURS }, (_, i) => ({ ...emptyHour(), ...d.hours?.[i] }))
+        day.hours = hours
+        this.days.set(k, day)
+      }
     } catch {
       // 首次运行/文件损坏：从空开始，不阻断启动
     }
@@ -411,33 +510,34 @@ const emptyAcc = (): Acc => ({
   estimatedInputs: 0, estimatedOutputs: 0,
 })
 
-function addRec(acc: Acc, rec: UsageRecord): void {
-  acc.requests += 1
-  if (rec.ok) acc.ok += 1
-  else acc.failed += 1
-  acc.promptTokens += rec.promptTokens
-  acc.completionTokens += rec.completionTokens
-  acc.cachedTokens += rec.cachedTokens
-  acc.durationMs += rec.durationMs
-  if (rec.ttfbMs > 0) {
-    acc.ttfbMs += rec.ttfbMs
-    acc.ttfbCount += 1
-  }
-  if (rec.inputEstimated) acc.estimatedInputs += 1
-  if (rec.outputEstimated) acc.estimatedOutputs += 1
+/** 天桶累加（today / 7d / 30d 路径，以及 24h 的「老数据整桶兜底」）。 */
+function addDay(acc: Acc, d: DayBucket): void {
+  acc.requests += d.requests
+  acc.ok += d.ok
+  acc.failed += d.failed
+  acc.promptTokens += d.promptTokens
+  acc.completionTokens += d.completionTokens
+  acc.cachedTokens += d.cachedTokens
+  acc.durationMs += d.durationMs
+  acc.ttfbMs += d.ttfbMs
+  acc.ttfbCount += d.ttfbCount
+  acc.estimatedInputs += d.estimatedInputs
+  acc.estimatedOutputs += d.estimatedOutputs
 }
 
-function bumpInto(map: Record<string, Entry>, key: string, rec: UsageRecord): void {
-  if (key === '') return
-  const e = map[key] ?? emptyEntry()
-  e.requests += 1
-  if (rec.ok) e.ok += 1
-  else e.failed += 1
-  e.promptTokens += rec.promptTokens
-  e.completionTokens += rec.completionTokens
-  e.cachedTokens += rec.cachedTokens
-  e.lastTs = Math.max(e.lastTs, rec.ts)
-  map[key] = e
+/** 小时桶累加（24h 路径）。 */
+function addHour(acc: Acc, h: HourBucket): void {
+  acc.requests += h.requests
+  acc.ok += h.ok
+  acc.failed += h.failed
+  acc.promptTokens += h.promptTokens
+  acc.completionTokens += h.completionTokens
+  acc.cachedTokens += h.cachedTokens
+  acc.durationMs += h.durationMs
+  acc.ttfbMs += h.ttfbMs
+  acc.ttfbCount += h.ttfbCount
+  acc.estimatedInputs += h.estimatedInputs
+  acc.estimatedOutputs += h.estimatedOutputs
 }
 
 function finish(

package/src/router/usage.test.ts

@@ -288,6 +288,121 @@ test('周期：7d/30d 走天桶，明细环撑爆也不影响', () => {
   assert.equal(s.recentList(1000).length, 500) // 明细环只留 500
 })
 
+test('周期：today/24h 走小时桶，明细环撑爆也不影响（回归：今日曾被截断成 500）', () => {
+  const s = new UsageStore('')
+  const now = Date.now()
+  // 塞 600 条（> RING_CAP 500），全在今天
+  for (let i = 0; i < 600; i += 1) rec(s, { ts: now })
+  assert.equal(s.stats('today', now).requests, 600, 'today 必须精确，不能受明细环容量限制')
+  assert.equal(s.stats('24h', now).requests, 600)
+  assert.equal(s.stats('7d', now).requests, 600)
+  assert.equal(s.stats('30d', now).requests, 600)
+  assert.equal(s.recentList(1000).length, 500, '明细环仍然只留 500（它只服务最近列表）')
+})
+
+test('周期：today 精确，不会把昨天算进来', () => {
+  const s = new UsageStore('')
+  // 基准取正午：两头都留够余量，免得真实挂钟一过 23 点测试就翻车（踩过）
+  const base = new Date()
+  base.setHours(12, 0, 0, 0)
+  const now = base.getTime()
+  const dayStart = new Date(now).setHours(0, 0, 0, 0)
+
+  // 昨天 22:00 一批、今天 08/09 点各一批 —— 每批都逼近 RING_CAP
+  for (let i = 0; i < 300; i += 1) rec(s, { ts: dayStart - 2 * 3600000 })
+  for (let i = 0; i < 300; i += 1) rec(s, { ts: dayStart + 8 * 3600000 })
+  for (let i = 0; i < 300; i += 1) rec(s, { ts: dayStart + 9 * 3600000 })
+
+  assert.equal(s.stats('today', now).requests, 600, 'today 只算今天')
+  assert.equal(s.stats('7d', now).requests, 900)
+  // 24h 从今天 12:00 往前滚：昨天 22:00 那批距今 14 小时，还在窗口内
+  assert.equal(s.stats('24h', now).requests, 900)
+})
+
+test('图表：today 的小时桶按整点归位，不再靠明细环', () => {
+  const s = new UsageStore('')
+  const base = new Date()
+  base.setHours(12, 0, 0, 0)
+  const now = base.getTime()
+  const dayStart = new Date(now).setHours(0, 0, 0, 0)
+
+  for (let i = 0; i < 600; i += 1) rec(s, { ts: dayStart + 9 * 3600000 + 1000 }) // 今天 09:00 那格
+
+  const ch = s.chart('today', now)
+  assert.equal(ch.length, 24)
+  assert.equal(ch[9]?.requests, 600, '全落 09:00 那格')
+  assert.equal(ch[9]?.tokens, 600 * 15)
+  assert.equal(ch[10]?.requests, 0)
+  assert.equal(ch.reduce((n, b) => n + b.requests, 0), 600, '各格之和 = today 总数')
+})
+
+test('落盘：旧文件没有 hours 字段也能读（没有迁移，补空即可）', () => {
+  const dir = `${process.env.TMPDIR ?? '/tmp'}/dshr-usage-${Math.random().toString(36).slice(2)}`
+  mkdirSync(dir, { recursive: true })
+  const fp = `${dir}/state.json`
+  // 手写一份「老格式」：天桶没有 hours（升级前落盘的就是这样）
+  writeFileSync(
+    `${dir}/usage.json`,
+    JSON.stringify({
+      days: { [localDateKey(Date.now())]: { requests: 3, ok: 3, failed: 0, bySupplier: {} } },
+      recent: [],
+      lifetime: 3,
+    }),
+  )
+  const s = new UsageStore(fp)
+  // 天桶口径照常：老数据一天都不会丢
+  assert.equal(s.stats('7d').requests, 3)
+  assert.equal(s.stats('today').requests, 3, 'today 走天桶，老数据照读')
+  // 小时粒度是永久缺失的（明细环回溯不回去）→ 24h 整桶兜底，不编数据
+  assert.equal(s.stats('24h').requests, 3, '小时桶不齐 → 整桶计入，不报比 today 更小的数')
+  assert.equal(s.chart('today').length, 24, '图表格子数不变')
+  assert.equal(s.chart('today').reduce((n, b) => n + b.requests, 0), 0, '没有小时粒度就不瞎填')
+  // 新请求照常累加，补上的 hours 立刻生效
+  rec(s, { ts: Date.now() })
+  assert.equal(s.stats('today').requests, 4)
+  assert.equal(s.chart('today').reduce((n, b) => n + b.requests, 0), 1)
+})
+
+test('周期：24h 跨天时，小时粒度齐的走小时格、不齐的整桶兜底', () => {
+  const dir = `${process.env.TMPDIR ?? '/tmp'}/dshr-usage-${Math.random().toString(36).slice(2)}`
+  mkdirSync(dir, { recursive: true })
+  const fp = `${dir}/state.json`
+  // 时钟固定当天 12:00，不用 Date.now()：24h 是当前整点往前 23 格，
+  // 真实时钟在 23 点时窗口起点正好是今天 00:00，昨天整桶落在窗口外，
+  // 这条用例就会从 700 变成 300 —— 测试挂不挂取决于跑的时刻，不能接受。
+  const now = new Date().setHours(12, 30, 0, 0)
+  const dayStart = new Date(now).setHours(0, 0, 0, 0)
+  const yesterdayKey = localDateKey(dayStart - 12 * 3600000)
+
+  // 昨天是「老数据」：天桶有 400 条但没有小时粒度
+  writeFileSync(
+    `${dir}/usage.json`,
+    JSON.stringify({
+      days: {
+        [yesterdayKey]: { requests: 400, ok: 400, failed: 0, bySupplier: {}, byModel: {}, byRequested: {} },
+      },
+      recent: [],
+      lifetime: 400,
+    }),
+  )
+  const s = new UsageStore(fp)
+  // 今天补 300 条（有小时粒度），全在当前小时，一定落在 24h 窗口内
+  for (let i = 0; i < 300; i += 1) rec(s, { ts: now })
+
+  assert.equal(s.stats('today', now).requests, 300, 'today 只算今天')
+  // 窗口含昨天 12:00 之后那截 → 但昨天没小时粒度，只能整桶（400）计入
+  const d24 = s.stats('24h', now).requests
+  assert.ok(d24 >= 300, '24h 绝不能小于 today')
+  assert.ok(d24 <= 700, '24h 也绝不能超总数')
+  assert.equal(d24, 700, '昨天整桶 400 + 今天 300')
+
+  // 反面对照：时钟移到 23 点，窗口不再含昨天，昨天那桶必须整桶退出
+  // （不是被算一半，也不是漏掉今天的 300）。锁死「整桶进/整桶出」。
+  const late = new Date().setHours(23, 30, 0, 0)
+  assert.equal(s.stats('24h', late).requests, 300, '窗口不含昨天时只剩今天')
+  assert.equal(s.stats('today', late).requests, 300, 'today 不受影响')
+})
+
 test('Top 榜：按请求数降序，且三个维度各自聚合', () => {
   const s = new UsageStore('')
   rec(s, { supplier: 'a', model: 'm1', requested: 'combo-x' })

package/src/shared.ts

@@ -60,6 +60,8 @@ export interface RouterCheckinResponse {
   succeeded: number
   /** 今日已签到的链接数（幂等成功）。 */
   already: number
+  /** 失败/未开放的链接数。 */
+  failed: number
   results?: Array<{ uid: string; ok: boolean; status?: string; message?: string }>
 }
 

package/src/suppliers/loader.ts

@@ -98,7 +98,8 @@ export function wrapModule(instance: SupplierModule, env: SupplierEnv, source: s
 
   // 账号池由核心持有（选号/冷却/禁用/错误累计），插件不参与。
   // 挂在 supplier 上：status() 叠加状态与 Router 的 chat 循环共用同一实例。
-  const pool = new AccountPool()
+  // 冷却键带 supplierId（跨供应商同名模型不串），故构造时注入本供应商 id。
+  const pool = new AccountPool(instance.id)
 
   const supplier: Supplier = {
     id: instance.id,

package/src/suppliers/registry.test.ts

@@ -4,7 +4,10 @@
  * 锁定的契约：checkinNow 是**单账号**能力，遍历所有链接 + 汇总是核心的活：
  *   - 禁用链接不签（不动它）
  *   - 某个链接抛错 → 记成 error，不带垮其它链接
- *   - succeeded / already 按 status 统计，ok = 有任一成功或今日已签
+ *   - succeeded / already / failed 按 status 统计
+ *   - **ok = 全部链接都成功（含已签）**；有任一失败 → HTTP 400 + ok:false，
+ *     让面板把失败如实亮出来（2026-09-02 修正：旧口径「有任一成功就算 ok」
+ *     会把部分失败吞成整体成功，UI 谎报「签到完成」）
  */
 import test from 'node:test'
 import assert from 'node:assert/strict'
@@ -84,6 +87,7 @@ interface CheckinPayload {
   total: number
   succeeded: number
   already: number
+  failed: number
   results?: CheckinResult[]
   error?: string
 }
@@ -120,20 +124,36 @@ test('签到：禁用链接照样签（禁用由插件自己判定，核心不
   assert.equal(body.results?.[0]?.status, 'disabled')
 })
 
-test('签到：单链接抛错记成 error，其余照签', async () => {
+test('签到：单链接抛错记成 error 不连坐；有失败 → 400 不算整体成功', async () => {
   const { status, body } = await postCheckin(
     fixture([{ uid: 'a' }, { uid: 'b' }], async (uid) => {
       if (uid === 'a') throw new Error('boom')
       return { ok: true, status: 'ok' }
     }),
   )
-  assert.equal(status, 200)
+  // 有任一失败整体就不是 ok（否则 UI 会谎报「签到完成」）——a 的错照记，不连坐 b
+  assert.equal(status, 400)
+  assert.equal(body.ok, false)
   assert.equal(body.succeeded, 1)
+  assert.equal(body.failed, 1)
   assert.equal(body.results?.[0]?.status, 'error')
   assert.equal(body.results?.[0]?.message, 'boom')
   assert.equal(body.results?.[1]?.status, 'ok')
 })
 
+test('签到：全部成功（含 already）才算整体 ok', async () => {
+  const { status, body } = await postCheckin(
+    fixture([{ uid: 'a' }, { uid: 'b' }], async (uid) =>
+      uid === 'a' ? { ok: true, status: 'ok', message: '+200' } : { ok: true, status: 'already', message: '今日已签到' },
+    ),
+  )
+  assert.equal(status, 200)
+  assert.equal(body.ok, true)
+  assert.equal(body.succeeded, 1)
+  assert.equal(body.already, 1)
+  assert.equal(body.failed, 0)
+})
+
 test('签到：今日已签（already）算成功，不计入 succeeded', async () => {
   const { status, body } = await postCheckin(
     fixture([{ uid: 'a' }], async () => ({ ok: true, status: 'already', message: '今日已签到' })),

package/src/suppliers/registry.ts

@@ -375,8 +375,13 @@ export function supplierRoutes(base: string, loaded: LoadedSupplier, store: Supp
         }
         const succeeded = results.filter((r) => r.status === 'ok').length
         const already = results.filter((r) => r.status === 'already').length
-        const payload = { ok: succeeded + already > 0, total: uids.length, succeeded, already, results }
-        writeJson(res, payload.ok ? 200 : 400, payload)
+        // 全部链接都成功（含已签）才算整体成功；有任一失败 → ok:false + HTTP 400，
+        // 让面板把失败如实亮出来。别学旧逻辑「有成功就算 ok」——部分失败被
+        // 当成整体成功，UI 会谎报「签到完成」（2026-09-02 实测踩到）。
+        const failed = results.length - succeeded - already
+        const ok = failed === 0 && results.length > 0
+        const payload = { ok, total: uids.length, succeeded, already, failed, results }
+        writeJson(res, ok ? 200 : 400, payload)
       },
     })
   }