dsh-connect-workbuddy 2.3.0 → 2.3.1

package/CHANGELOG.md

@@ -1,5 +1,57 @@
 # Changelog
 
+## 2.3.1 (2026-09-29)
+
+### Features
+
+#### 模型「测试」改为真实体积：揭穿「测试通过、实际被限」
+
+**上游的 6004 限流按请求体积触发**，而此前的探针只发 `max_tokens: 1` + `ping`（约 18 token）——它永远够不到那条线。于是出现一个自相矛盾的现象：**卡片测出来模型可用，真实会话却每次都 429**。这不是探针算错，而是它**问的问题太轻**。
+
+真机量化（2026-09-29，同一账号、同一模型，只改输入体积）：
+
+| 输入 | 上游计到的 prompt_tokens | 结果 |
+| --- | --- | --- |
+| ~10 | 38 | ok |
+| ~1,000 | 1,138 | ok |
+| ~10,000 | 11,138 | ok |
+| ~18,000 | 20,018 | ok |
+| **~25,000** | **25,023** | ok |
+| ~30,000（干净账号只发这一次） | ~32k | **429 / 6004** |
+
+- **阈值在 20k 与 30k 之间，单次大请求即触发**（不是累计），且**每个账号各有自己的重置时间**（实测同一时刻两个账号分别报 `22:20:33` 与 `00:32:51`）。
+- **为什么这是用户会踩到的**：插件向 DSH 宣称的上下文窗口最高 200K（`web-status.ts` 把 1M 的模型按默认预算压到 200K），DSH 因此要到 20 万 token 才压缩——**远超上游 ~20–30k 的节流线**。长会话里请求一路涨过阈值，之后每一次都失败，而小探针始终显示可用。
+- **改动**：**只保留一种测试**，即每个模型行上的「测试」按钮，它现在发一条 **~25k 输入 token** 的真实体积请求。真机验证：请求体 112,713 B，上游计到 `prompt_tokens: 25023`。
+- **删掉了两样东西**：① 原先的最小探针（`probeRequestBody` 的 `ping` 版本、`heavy` 开关、`PROBE_USER_PROMPT`）；② 模型区顶部的**「测试已勾选」批量按钮**。后者不是排版调整而是成本决定——每次探测都真花钱（实测 `credit` 约 0.02～0.72），一次覆盖整个已勾选列表就是一次不可控支出。路由相应改为**只接受 1 个模型**（多于 1 个直接 400）：卡片只发这一个形状，多模型请求不是卡片发的，拒绝它正是防止陈旧 bundle 或手写客户端把按钮变成消费循环的那道闸。
+- **实测代价**：一次「测试」报 `credit` 0.02（健康账号、25k 输入）；被限流时立即 429 并给出重置时间。此前的最小探针是 0～0.01。
+
+### Bug Fixes
+
+#### 「上游未给出何时恢复」是错的：恢复时间一直在响应体里
+
+2.3.0 的模型测试上线后，真实使用暴露了一个要命的偏差：**探针说模型可用、用户点「测试」也看到通过，但真正发请求却被限流**；而被限流的那一行显示的是「上游未给出何时恢复」——**上游其实说了，就在响应体里**。
+
+- **根因**：`cooldownOf()` 只读两个来源——`Retry-After` 响应头、以及积分耗尽时的月度刷新点。而本服务的 429 **根本没有 `Retry-After` 头**，重置时间写在响应体的 `msg` 文本里。实测抓到的原文（2026-09-29，逐字）：
+
+  ```json
+  {"code":6004,"msg":"您的使用量已超出频率限制，将在 2026-09-30 02:30:30 UTC+8 重置，您也可以切换其他模型继续使用。"}
+  ```
+
+  2.3.0 的注释写「上游不提供限流元数据」，这个结论**是从响应头单独得出的**——就响应头而言是对的，作为结论是错的。
+- **为什么「测试通过、实际被限」不是探针的错**：探针与真实请求的判定本来就一致。用真实凭据实测，同一模型用**四种请求形态**（`max_tokens:1` + `ping`、`max_tokens:2000` + 长 prompt、以及两者交叉）全部返回**同一个 429**；13 个模型里只有 `deepseek-v4.1-flash` 被限，其余 12 个（含默认的 `glm-5.3-flash` 一类）全部 `ok`。所以「测试通过」看到的是**别的模型**，而被限的那个恰好是配置里用着的。限流由账户/模型维度的配额决定，与请求大小无关——这也回答了「加大请求能不能测出来」：不能。
+- **修法**：新增 `parseUpstreamResetAt()`，从失败响应体解析 `将在 <时间> UTC<偏移> 重置`；`cooldownOf()` 增加第三个来源 `upstream-message`（优先级：响应头 > 响应体 > 月度刷新点）。`probeModel()` 把 body 传给它。
+- **时区必须按偏移量算，不能被本机时区左右**：`2026-09-30 02:30:30 UTC+8` 是 UTC 的 `2026-09-29T18:30:30Z`。直接 `Date.parse` 会**按本地时区**解读——在 UTC+8 的机器上恰好正确，换台机器就静默错一个偏移量。因此用 `Date.UTC` 组装后减去声明的偏移，实测 UTC / Asia/Shanghai / America/New_York 三种 `TZ` 下输出一致。
+- **宁可不说，也不说错**：无法解析时返回 `undefined`，卡片继续如实显示「上游未给出何时恢复」。`Date.UTC` 会把 13 月、32 日**静默归一化**成另一个真实时刻，所以解析后逐字段回验，不合法就丢弃；`UTC+99` 这类越界偏移同样拒绝。这些都配了用例。
+- **守卫与变异验证**：`tests/probe.spec.ts`（28 → 38 例）覆盖：真机原文端到端（经 `probeModel`）、响应头优先于响应体、`T` 分隔符与 `UTC+0800` 紧凑写法、负偏移、四种「不该解析出时间」的形态、三种非法日期、越界偏移。**变异验证**：把偏移量那一步去掉（当成 UTC 算）→ **6 例变红**。
+- 文案无需改动：`row.probeRateLimitedAt`（`✗ 被限流 · {at} 之后可再用`）本就存在，此前只是永远走不到。
+
+### Tests
+
+- `tests/probe.spec.ts`（28 → 42 例）：探测请求体**恒为真实体积**且随目标常量缩放；`parseUpstreamResetAt` 的真机原文、`T` 分隔符、`UTC+0800` 紧凑写法、负偏移、越界偏移、三种非法日期、四种「不该解析出时间」的形态；`cooldownOf` 三级来源的优先级（响应头 > 响应体 > 月度刷新点）。
+- `tests/web-status.spec.ts`（49 → 50 例）：路由**只接受单个模型**，多模型请求 400。
+- **变异验证**：把偏移量换算去掉（当成 UTC 算）→ **6 例变红**；去掉单模型强制 → 对应用例变红。
+- 全量：**449 例全绿**（2.3.0 为 434 例），typecheck 与 build 通过。
+
 ## 2.3.0 (2026-09-29)
 
 ### Features
@@ -25,6 +77,8 @@
 | 积分耗尽，无月周期包 | `✗ 积分不足 · 上游未给出何时恢复` | 无 |
 | 401/403 凭据被拒 | `✗ WorkBuddy 拒绝了这个账号的 token——请重新登录或换一个账号` | — |
 
+> ⚠️ **本节的第 2 条来源此后有更正（见 Unreleased）**：本节写「上游不提供这个数据」，那是**只看响应头**得出的结论——响应头里确实没有，但上游把重置时间写在**响应体**里（`将在 … UTC+8 重置`）。「上游未给时间」那一行因此在真实 429 上从不该出现。解析与实测见 Unreleased 的 Bug Fixes 一节。
+
 限流**不会**去借月周期包的刷新时间：那会让用户为几秒的限流去等几周。这个区分由 `cooldownOf` 强制，并有专门用例钉住。
 
 **为何每个探测请求都必须以 system 消息开头**：国际网关（`www.workbuddy.ai`）对 `[{role:'user'}]` 一律返回 HTTP 400 / 业务码 `11128`（`first message is not system prompt`）。按国内版那样只发一条 user 消息，会把**整个国际版误报成全部不可用**。实测加上 system 消息后立即 200，故探测请求始终带一条 system 消息。
@@ -38,7 +92,7 @@
 
 ### Tests
 
-- `tests/probe.spec.ts`（新增，28 例）：请求体必带 system 首条且 `max_tokens: 1` / `stream:true`；`Retry-After` 的秒数与 HTTP-date 两形态、以及 0 / 负数 / 过期时间不被当作冷却；`cooldownOf` 的四种组合（含**限流绝不编造时间**、**限流不借月周期刷新时间**）；七类失败分类；成功流不被截断影响；**抛出异常不逃逸**；失败正文脱敏。
+- `tests/probe.spec.ts`（新增，28 例；此后在 Unreleased 增至 38 例）：请求体必带 system 首条且 `max_tokens: 1` / `stream:true`；`Retry-After` 的秒数与 HTTP-date 两形态、以及 0 / 负数 / 过期时间不被当作冷却；`cooldownOf` 的四种组合（含**限流绝不编造时间**、**限流不借月周期刷新时间**）；七类失败分类；成功流不被截断影响；**抛出异常不逃逸**；失败正文脱敏。
 - `tests/web-status.spec.ts`（+10 例）：逐模型串行调用（并发变异会红）、region 透传、空列表 / 非数组 / 超限批量一律 400、无能力时 503、非回环来源 403、非 POST 405、未知 region 400、抛错转 500 且不泄露 token。
 - **变异验证**（5 处，逐一实测变红）：给限流编造固定倒计时 → 3 例红；删掉 system 首条消息 → 2 例红；让限流借用月周期刷新时间 → 1 例红；把串行批改为并发扇出 → 1 例红；其余对照组全绿。
 

package/README.en.md

@@ -25,7 +25,9 @@ A [DeepSeek Harness (DSH)](https://github.com/deepseek-ai/deepseek-harness) bund
 - **Tabbed settings card** — the card's top carries a "Domestic / Global" tab bar; each tab holds its own account picker, credits overview, and model management. Account, directory, selection, and unsaved drafts are fully isolated per tab — switching accounts or refreshing models on one tab never touches the other side's runtime catalog or sessions.
 - **Switch either provider off on its own** — each tab carries an on/off checkbox (both checked by default). Unchecking one **withdraws that provider from DSH's model picker entirely** (it is not merely a hidden tab): its adapter route and its "Settings → Models" directory entry are both pulled, and startup no longer sends pointless requests for it. Account, credits, directory, and selection are all kept, and re-checking restores everything. The typical use is "I have no use for the international side" — switch it off and keep the picker clean. Note: a session that had already selected a model from the switched-off provider will report `NO_ADAPTER` on its next call; the card states this plainly on the switched-off tab instead of failing silently.
 - **Model management** — refresh the full catalog from upstream and enable or disable each model individually; refresh is a draft operation that only takes effect on save. Upstream also reports credit multiplier, context/output limits, and reasoning efforts; **image input is decided by a vendor-verified table**: a refresh pre-checks only models the vendor's own documentation calls natively multimodal, leaves documented text-only models unchecked, and treats anything without a vendor source as unverified and unchecked rather than guessing. Upstream's `supportsImages` is a *platform* declaration, not the model's capability, so it does not drive that decision at all. You can still tick any box by hand, and your selection is kept locally.
-- **Model availability testing, including cooldown recovery times** — working out when a limited model frees up used to mean guessing through repeated failures. Now every model row has a **Test** button and the models header has **Test selected**: each chosen model gets one minimal request (`max_tokens: 1`), and you get a direct answer for whether it works right now and, if not, when it comes back. Measured cost is negligible: the response reports `credit` between 0 and 0.01, and one probe left the balance unchanged (933 → 933), against 0.79x and up for a real reply; each probe took 0.8–3.4s. **On "when can I use this again", the upstream does not provide that data**: measured responses carry no `Retry-After` and no `X-RateLimit-*`, and 12 rapid requests to the same model all succeeded. So the plugin **never invents a countdown** — it shows a time only for the two cases where the upstream actually states one (a `Retry-After` header, or the monthly quota's refresh point when the quota is exhausted) and says plainly that no time was given otherwise. A rate limit deliberately does **not** borrow the monthly refresh time, which would tell you to wait weeks for a limit that clears in seconds. Probes run in the Host, so **the credential never reaches the page**, and results are not written to settings — your saved selection is untouched.
+- **Model availability testing, including cooldown recovery times** — working out when a limited model frees up used to mean guessing through repeated failures. Now every model row has a **Test** button that gives you a direct answer for whether the model works right now and, if not, when it comes back. **It sends a real-volume request (about 25k input tokens)**, rather than "ping it and see if it answers" — because the upstream throttles on request **SIZE** (measured: about 20k tokens pass, about 30k are refused), so a small request looks fine while every request in a long conversation may be refused. That is exactly where "the test passes but I am limited" came from. **Where the recovery time comes from**: the upstream's 429 carries **no** `Retry-After` header (and no `X-RateLimit-*`), but it writes the reset time into the response **body** — `{"code":6004,"msg":"…将在 2026-09-30 02:30:30 UTC+8 重置…"}`. The plugin parses that time and converts it using the UTC offset the message states, so the result does not depend on your machine's timezone; the card then shows “✗ Rate limited · usable again after 2026/9/30 02:30:30”. When none of the sources states a time, the plugin **never invents a countdown** and says plainly that no time was given. A rate limit deliberately does **not** borrow the monthly refresh time, which would tell you to wait weeks for a limit that clears in seconds. Probes run in the Host, so **the credential never reaches the page**, and results are not written to settings — your saved selection is untouched.
+
+  **Two things to know.** ① **It really does spend credits** — one measured probe reported `credit` 0.02 (a refused one 429s and costs almost nothing). So testing is **manual and per-model only**: there is deliberately no “Test selected” batch button, because sweeping the whole list from one click is an uncontrolled spend — and the Host enforces the same rule, **accepting a single model only** and refusing multi-model requests. ② The upstream advertises a 1M context yet throttles far below it, and the plugin advertises up to 200K to DSH, so DSH compacts very late — hitting the throttle in a long session follows directly from that.
 - **Local account switching** — discovers the multiple sign-in credentials WorkBuddy's desktop app leaves behind and lets you switch per region. Tokens are never written to DSH settings.
 - **Actionable advice when a credential is refused** — when the upstream rejects the selected account's token, the plugin actually **probes** the other local sign-ins: if one still answers, it tells you to switch to it (with a one-click switch) instead of vaguely asking you to sign in again — re-authenticating fixes nothing while you are pinned to a revoked backup. Only when there is genuinely no other local account does it ask you to sign in again.
 - **Read-only credits overview** — remaining credit aggregated per package, plus each model's credit multiplier. Queries consume no credits.

package/README.md

@@ -31,7 +31,9 @@
 - **插件卡片 tab 切换** —— 设置卡片顶部为「国内版 / 国际版」两个 tab，各含独立的账号选择、积分概览与模型管理；每个 tab 的账号、目录、勾选与未保存草稿完全隔离——在一个 tab 里切账号或刷新模型，不会触碰另一边的运行时目录与会话。
 - **可单独关闭任一版本供应商** —— 每个 tab 右侧有一个勾选框（默认都勾选）。**取消勾选即把该供应商从 DSH 模型选择器里彻底撤掉**（不是只藏起 tab）：它的路由与「设置 → 模型」页的目录条目一并摘除，启动时也不再为它发无用请求。账号、积分、目录与勾选**全部保留**，重新勾选即完整恢复。典型用法是「我根本用不到国际版」——关掉它，让选择器干净。注意：若某会话此前选中的正是被关闭供应商的模型，该会话再调用会报 `NO_ADAPTER`，卡片会在关闭态的 tab 上明确提示这一点，不会静默失败。
 - **模型管理** —— 从上游刷新完整模型目录，逐项勾选启用或禁用；刷新是草稿操作，点保存才生效。上游同时给出积分倍率、上下文/输出上限与推理档位；**图片输入按厂商核验表判定**：刷新时只有厂商文档明确写为原生多模态的模型才自动勾选，文档写明纯文本的不勾，**没有厂商资料的一律按「未核实」不猜**（上游的 `supportsImages` 是平台侧声明，不等于模型能看图，不参与判定）。用户仍可随时手动勾选，勾选状态保存在本地。
-- **模型可用性测试（含冷却恢复时间）** —— 限量模型的冷却时间过去只能靠反复试错去猜。现在每个模型行有一个「测试」按钮，模型区顶部有「测试已勾选」，对勾选的模型**各发一条最小请求**（`max_tokens: 1`），直接告诉你它此刻能否使用、不能用时何时恢复。实测代价可忽略：`credit` 报 0～0.01，单次探测前后余额不变（933 → 933），而正常一次回答是 0.79x 起；单次耗时 0.8～3.4s。**关于「多久之后可以再次使用」，上游并不提供这个数据**：实测响应头里没有 `Retry-After`、也没有 `X-RateLimit-*`，对同一模型连续快速打 12 次全部成功。因此插件**不编造倒计时**，只在两种上游真的给出时间的情形下显示时间——`Retry-After` 头，或积分耗尽时该区域月周期包的刷新点；两者都没有时如实显示「上游未给出何时恢复」。限流**不会**去借月周期包的刷新时间（那会让人为几秒的限流去等几周）。探测在后台发起，**凭据不会传到页面**；结果不写入设置，也不改变你已保存的勾选。
+- **模型可用性测试（含冷却恢复时间）** —— 限量模型的冷却时间过去只能靠反复试错去猜。现在每个模型行有一个「测试」按钮，直接告诉你它此刻能否使用、不能用时何时恢复。**它发的是一条真实体积的请求（约 25k 输入 token）**，而不是「发个 ping 看通不通」——因为上游的限流**按请求体积触发**（实测约 20k 能过、约 30k 被拒），小请求看着正常、长对话里却可能每次都被拒，那正是「测试通过、实际被限」的来源。**恢复时间的来源**：上游的 429 **不带** `Retry-After` 响应头（也没有 `X-RateLimit-*`），但它把重置时间写在**响应体**里——`{"code":6004,"msg":"…将在 2026-09-30 02:30:30 UTC+8 重置…"}`。插件从响应体解析该时间（并按其声明的 UTC 偏移换算，不受你本机时区影响），因此卡片能直接显示「✗ 被限流 · 2026/9/30 02:30:30 之后可再用」。三处来源都没说时，插件**不编造倒计时**，如实显示「上游未给出何时恢复」。限流**不会**去借月周期包的刷新时间（那会让人为几秒的限流去等几周）。探测在后台发起，**凭据不会传到页面**；结果不写入设置，也不改变你已保存的勾选。
+
+  **两点需要知道**：① **它真的花钱**——实测一次报 `credit` 0.02（被限流时直接 429，几乎不花）。因此**只能按单个模型手工点**，没有「测试已勾选」这类批量按钮：一次覆盖整个列表就是一次不可控支出（服务端也据此**只接受单个模型**，多模型请求会被拒）。② 上游虽宣称 1M 上下文，但节流线远低于此；插件向 DSH 宣称的窗口最高 200K，所以 DSH 很晚才压缩对话——长会话撞限流是这条机制的直接结果。
 - **本机账号切换** —— 自动发现 WorkBuddy 桌面端留下的多个登录凭据，可按区域切换账号；Token 不写入 DSH 设置。
 - **凭据失效时给出可执行的建议** —— 上游拒绝当前账号的 token 时，插件会**实际探测**本机其他账号：若有账号仍然可用，就直接告诉你「切换到它即可」（并附一键切换），而不是笼统地让你重新登录——被钉在一个作废的旧备份上时，重新登录并不能解决问题。只有本机确实没有别的账号可切换时，才会提示重新登录。
 - **只读积分概览** —— 按套餐聚合展示剩余积分，并列出每个模型的积分倍率。查询不消耗积分。

package/lib/bin.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { O as workbuddyOwnAuthPath, T as legacyWorkbuddyOwnAuthPath, W as findWorkbuddyAppExecutable, _ as WorkBuddyCredentialStore, a as readHostHeartbeat, b as defaultDesktopAuthCandidates, c as WORKBUDDY_CONNECT_VERSION, g as WORKBUDDY_AUTH_FILE_ENV, j as WorkBuddyUpstreamClient, l as FALLBACK_WORKBUDDY_MODELS, o as workbuddyHostHeartbeatPath, r as isHeartbeatProcessAlive, u as FALLBACK_WORKBUDDY_MODELS_GLOBAL, x as defaultDesktopAuthDirs, z as WORKBUDDY_APP_EXECUTABLE_ENV } from "./host-heartbeat-Uh8JCXqk.js";
+import { O as workbuddyOwnAuthPath, T as legacyWorkbuddyOwnAuthPath, W as findWorkbuddyAppExecutable, _ as WorkBuddyCredentialStore, a as readHostHeartbeat, b as defaultDesktopAuthCandidates, c as WORKBUDDY_CONNECT_VERSION, g as WORKBUDDY_AUTH_FILE_ENV, j as WorkBuddyUpstreamClient, l as FALLBACK_WORKBUDDY_MODELS, o as workbuddyHostHeartbeatPath, r as isHeartbeatProcessAlive, u as FALLBACK_WORKBUDDY_MODELS_GLOBAL, x as defaultDesktopAuthDirs, z as WORKBUDDY_APP_EXECUTABLE_ENV } from "./host-heartbeat-CDZRWbFv.js";
 import { realpathSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 //#region src/bin.ts

package/lib/client.js

@@ -891,14 +891,14 @@ window.__ModuleLoader__.load({
 		* The sentence a probe result gets, and how it should be coloured.
 		*
 		* The cooldown wording is the part that had to be got right. The upstream names
-		* a "use again" time in exactly two situations — a `Retry-After` header, or an
-		* exhausted monthly quota whose refresh point it declares — and its 200s and
-		* 429s carry NO rate-limit metadata at all (measured: no `Retry-After`, no
-		* `X-RateLimit-*`, and 12 rapid requests to one model all succeeded). So a
-		* limited result WITHOUT a stated time must say that plainly. Substituting a
-		* locally invented countdown would be the single most misleading thing this
-		* feature could do: it would look like an upstream answer while being a guess,
-		* and the user would wait for a moment that means nothing.
+		* a "use again" time in three situations: a `Retry-After` header, the reset
+		* sentence it writes into its own failure BODY (where this service actually
+		* puts it — its 429s carry no rate-limit header at all), or an exhausted
+		* monthly quota whose refresh point it declares. So a limited result WITHOUT
+		* any stated time must say that plainly. Substituting a locally invented
+		* countdown would be the single most misleading thing this feature could do: it
+		* would look like an upstream answer while being a guess, and the user would
+		* wait for a moment that means nothing.
 		*/
 		function probeResultView(result, t) {
 			switch (result.outcome) {
@@ -1233,8 +1233,6 @@ window.__ModuleLoader__.load({
 			* A bound scope is therefore all that is required to accept an edit.
 			*/
 			const canWrite = settingsScope !== void 0;
-			/** Whether any row's probe is in flight, so the batch button reflects it. */
-			const anyProbing = Object.keys(probing).length > 0;
 			const editDraft = (edit) => {
 				setDrafts((prev) => ({
 					...prev,
@@ -1654,18 +1652,9 @@ window.__ModuleLoader__.load({
 											}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
 												className: "dsm-workbuddy-models-summary",
 												children: t("row.modelsSummary", { count: activeEnabledIds.size })
-											})] }), /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+											})] }), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
 												className: "dsm-workbuddy-models-head-actions",
-												children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
-													type: "button",
-													className: "dsm-btn dsm-btn-outline",
-													disabled: activeEnabledIds.size === 0 || anyProbing,
-													title: t("row.probeAllHint"),
-													onClick: () => {
-														probeModels([...activeEnabledIds]);
-													},
-													children: anyProbing ? t("row.probing") : t("row.probeAll")
-												}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+												children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
 													type: "button",
 													className: "dsm-btn dsm-btn-outline",
 													disabled: busy,
@@ -1673,7 +1662,7 @@ window.__ModuleLoader__.load({
 														refreshModels();
 													},
 													children: busy ? t("row.modelsRefreshing") : t("row.modelsRefresh")
-												})]
+												})
 											})]
 										}),
 										probeError === void 0 ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
@@ -1746,15 +1735,18 @@ window.__ModuleLoader__.load({
 																	}
 																}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", { children: formatCapacity(model.nativeContextWindow, t("row.modelUnknown")) })] })]
 															}),
-															/* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
-																type: "button",
-																className: "dsm-btn dsm-btn-outline dsm-workbuddy-model-probe",
-																disabled: probing[model.id] === true || status.status !== "signed-in",
-																title: t("row.probeHint"),
-																onClick: () => {
-																	probeModels([model.id]);
-																},
-																children: probing[model.id] === true ? t("row.probing") : t("row.probe")
+															/* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+																className: "dsm-workbuddy-model-actions-buttons",
+																children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+																	type: "button",
+																	className: "dsm-btn dsm-btn-outline dsm-workbuddy-model-probe",
+																	disabled: probing[model.id] === true || status.status !== "signed-in",
+																	title: t("row.probeHint"),
+																	onClick: () => {
+																		probeModels([model.id]);
+																	},
+																	children: probing[model.id] === true ? t("row.probing") : t("row.probe")
+																})
 															})
 														]
 													}),
@@ -1933,9 +1925,7 @@ window.__ModuleLoader__.load({
 			"row.modelCapabilityPending": "Only capabilities advertised by WorkBuddy are shown.",
 			"row.probe": "Test",
 			"row.probing": "Testing…",
-			"row.probeAll": "Test selected",
-			"row.probeAllHint": "Send one minimal request (1 output token) to each enabled model and report which ones answer right now. Measured cost: 0 to 0.01 credits per model, against 0.79+ for a real reply.",
-			"row.probeHint": "Send one minimal request to this model to check it answers right now.",
+			"row.probeHint": "Send a real-volume request (~25k input tokens) to this model and report whether it answers right now. The upstream rate limit fires on request SIZE — measured: about 20k tokens pass, about 30k are refused — so a small request can look fine while every long-conversation request is refused. This is why every test costs real credits (about 0.7) and runs one model at a time.",
 			"row.probeOk": "✓ Usable",
 			"row.probeOkMs": "✓ Usable ({ms})",
 			"row.probeRateLimitedUnknown": "✗ Rate limited · the upstream gave no time for when it frees up",
@@ -2027,9 +2017,7 @@ window.__ModuleLoader__.load({
 			"row.modelCapabilityPending": "仅展示 WorkBuddy 接口明确公布的模型能力。",
 			"row.probe": "测试",
 			"row.probing": "测试中…",
-			"row.probeAll": "测试已勾选",
-			"row.probeAllHint": "对每个已勾选的模型各发一条最小请求（只出 1 个 token），报告哪个现在真的能用。实测每个模型消耗 0～0.01 积分，而正常一次回答是 0.79 起。",
-			"row.probeHint": "对该模型发一条最小请求，检查它现在能不能用。",
+			"row.probeHint": "对该模型发一条**真实体积**的请求（约 25k 输入 token），报告它现在能不能用。上游的限流按**请求体积**触发——实测约 20k 能过、约 30k 被拒——所以小请求看着正常、长对话里却可能每次都被拒。这也是为什么每次测试都会消耗真实积分（约 0.7），且一次只测一个模型。",
 			"row.probeOk": "✓ 可用",
 			"row.probeOkMs": "✓ 可用（{ms}）",
 			"row.probeRateLimitedUnknown": "✗ 被限流 · 上游未给出何时恢复",

package/lib/{host-heartbeat-Uh8JCXqk.js → host-heartbeat-CDZRWbFv.js}

@@ -2258,7 +2258,7 @@ var WorkBuddyCatalog = class {
 //#endregion
 //#region src/version.ts
 /** The npm package version this build was produced from. */
-const WORKBUDDY_CONNECT_VERSION = "2.3.0";
+const WORKBUDDY_CONNECT_VERSION = "2.3.1";
 //#endregion
 //#region src/host-heartbeat.ts
 /**

package/lib/index.d.ts

@@ -1195,23 +1195,48 @@ declare const WORKBUDDY_CONNECT_VERSION: string;
  * would report every global model as broken.
  */
 declare const PROBE_SYSTEM_PROMPT = "You are a connectivity check. Reply with a single word.";
-/** The one-word user turn; the smallest thing a chat endpoint accepts. */
-declare const PROBE_USER_PROMPT = "ping";
 /**
- * Output cap for a probe. One token is enough to prove the model answers, and
- * keeps the cost negligible: live measurements of `max_tokens: 1` probes
- * reported `credit` between 0 and 0.01, and one such probe left the credit
- * balance unchanged (933 → 933). For scale, a model on that roster bills 0.79+
- * per real reply. The point of the feature is to learn whether a model works
- * while spending as close to nothing as the service allows.
+ * Output cap for a probe. One token is enough to prove the model answers.
+ *
+ * The probe's cost comes from its INPUT, not its output (see
+ * {@link PROBE_INPUT_TOKENS}), so paying for a long completion would add money
+ * without adding signal.
  */
 declare const PROBE_MAX_TOKENS = 1;
+/**
+ * How much input a probe sends, in tokens.
+ *
+ * This is the whole point of the probe, and it is NOT a free choice. The
+ * upstream's rate limit (business code 6004) fires on request SIZE, measured on
+ * 2026-09-29 by varying only the input against one account and one model:
+ *
+ *   | input     | prompt_tokens the upstream counted | result |
+ *   | ---       | ---                                | ---    |
+ *   | ~10       | 38                                 | ok     |
+ *   | ~1,000    | 1,138                              | ok     |
+ *   | ~10,000   | 11,138                             | ok     |
+ *   | ~18,000   | 20,018                             | ok     |
+ *   | ~25,000   | 25,023                             | ok     |
+ *   | ~30,000   | ~32k                               | **429 / 6004** |
+ *
+ * So the threshold sits between 20k and 30k, a SINGLE large request is enough to
+ * trip it (it is not a running total), and each account reports its own reset
+ * time (two accounts at the same moment: `22:20:33` and `00:32:51`).
+ *
+ * A probe that sent a handful of tokens answered "usable" while every real
+ * request in a long conversation was refused — the probe was asking too small a
+ * question. 25k is sized to be a realistic long-conversation payload.
+ */
+declare const PROBE_INPUT_TOKENS = 25000;
 /**
  * Build the request body for one probe.
  *
  * `stream` is forced because the upstream rejects non-streaming chat requests;
  * `prepareChatBody` enforces that too, but sending it explicitly keeps this
  * function's output valid on its own.
+ *
+ * Measured on the built artifact: 112,713 bytes of body, and the upstream
+ * counted `prompt_tokens: 25023` at a cost of `credit: 0.72`.
  */
 declare function probeRequestBody(modelId: string): string;
 /**
@@ -1242,7 +1267,7 @@ interface WorkBuddyProbeResult {
   /** A time the upstream named, in ms. Absent when it named none. */
   retryAtMs?: number;
   /** Where a supplied `retryAtMs` came from, so the card can say so. */
-  retrySource?: 'retry-after' | 'quota-refresh';
+  retrySource?: 'retry-after' | 'upstream-message' | 'quota-refresh';
 }
 /**
  * Parse a `Retry-After` header value into an absolute time.
@@ -1258,24 +1283,29 @@ declare function parseRetryAfter(value: string | null, nowMs: number): number |
 /**
  * The cooldown the upstream stated, if it stated one.
  *
- * Two sources, in order of authority:
+ * Three sources, in order of authority:
  *
  * 1. `Retry-After` on the failure response. This is the upstream naming a time
  *    for THIS request, so it wins.
- * 2. The region's monthly quota refresh point, but ONLY for an out-of-credit
+ * 2. The reset time the upstream writes into its own failure body (see
+ *    {@link parseUpstreamResetAt}). This is the case that actually fires on
+ *    this service: a 429 from the Chinese gateway carries code 6004 and a
+ *    `将在 … 重置` sentence, with no `Retry-After` header at all.
+ * 3. The region's monthly quota refresh point, but ONLY for an out-of-credit
  *    outcome. A quota that resets at a known time is the one case where "when
  *    can I use this again" has a real answer even without a header — and it is
  *    the answer for the most common real limit on this service.
  *
- * A `rate-limited` outcome with neither source returns `{}`, which the card
- * renders as "the upstream did not say when". That is the honest answer: the
- * live probes found no rate-limit metadata in any response at all, so inventing
- * a number here would be pure fiction.
+ * A limited outcome with none of the three returns `{}`, which the card renders
+ * as "the upstream did not say when". That remains the honest answer for a
+ * genuinely timeless failure; inventing a number here would be pure fiction.
  */
 declare function cooldownOf(input: {
   outcome: WorkBuddyProbeOutcome;
   retryAfter: string | null;
   nowMs: number;
+  /** The upstream's own failure text, where a reset sentence may live. */
+  body?: string;
   /** The region's next monthly quota refresh, when the upstream declares one. */
   quotaRefreshAtMs?: number;
 }): Pick<WorkBuddyProbeResult, 'retryAtMs' | 'retrySource'>;
@@ -1314,9 +1344,9 @@ interface WorkBuddyProbeClient {
  * Run one probe for one model and reduce it to the card's row.
  *
  * The successful path drains the SSE stream purely to read the `credit` figure
- * the upstream reports, then discards the rest: the probe's question is "did
- * this model answer", and `max_tokens: 1` means there is nothing else in the
- * stream worth keeping.
+ * the upstream reports, then discards the rest: the question is whether this
+ * model answers a real-sized request, and `max_tokens: 1` means there is nothing
+ * else in the stream worth keeping.
  *
  * Never throws. A probe is a diagnostic the user asked for, so every failure is
  * a RESULT — one dead model must not abort the batch and hide the other rows.
@@ -1653,15 +1683,15 @@ interface WorkBuddyWebProbeResult {
    * A time the upstream named for using this model again, in ms.
    *
    * ABSENT means the upstream named none, and the card must say exactly that.
-   * The live probes that shaped this feature found no rate-limit metadata in
-   * any response — no `Retry-After`, no `X-RateLimit-*` — so a client-invented
-   * countdown here would be fiction. Only two sources ever fill this:
-   * a real `Retry-After`, or (for an exhausted quota) the region's own quota
-   * refresh point, which the upstream does declare.
+   * A client-invented countdown here would be fiction. Three sources fill it:
+   * a real `Retry-After` header; the reset sentence the upstream writes into
+   * its own failure BODY (`将在 … UTC+8 重置`, which is where this service
+   * actually puts it — its 429s carry no rate-limit header at all); or, for an
+   * exhausted quota, the region's own quota refresh point.
    */
   retryAtMs?: number;
-  /** Which of those two sources supplied {@link retryAtMs}. */
-  retrySource?: 'retry-after' | 'quota-refresh';
+  /** Which of those three sources supplied {@link retryAtMs}. */
+  retrySource?: 'retry-after' | 'upstream-message' | 'quota-refresh';
 }
 /**
  * Deep copy of a settings value with every `{get(): T}` live reference replaced
@@ -1731,14 +1761,19 @@ interface WorkBuddyStatusRouteOptions {
    */
   regionEnabled(region: WorkBuddyRegion): boolean;
   /**
-   * Send one minimal request to each named model of a region and report what
+   * Send one real-volume request to each named model of a region and report what
    * came back.
    *
    * Optional: it is the only dependency the card's test button needs, so a Host
    * built without it (or a route mounted for a status-only consumer) simply
    * answers 503 and the button reports that instead of failing the card.
+   *
+   * Every request costs real credits (measured `credit: 0.72` for one probe), so
+   * the card drives this ONE model per click and never as a batch.
    */
-  probeModels?(region: WorkBuddyRegion, modelIds: readonly string[], signal?: AbortSignal): Promise<readonly WorkBuddyWebProbeResult[]>;
+  probeModels?(region: WorkBuddyRegion, modelIds: readonly string[], options?: {
+    signal?: AbortSignal;
+  }): Promise<readonly WorkBuddyWebProbeResult[]>;
   /**
    * The region's next monthly quota refresh, when the upstream declares one.
    *
@@ -1976,4 +2011,4 @@ declare function legacyAttributionRegion(value: Config, accountsFor: (region: Wo
  */
 declare function apply(ctx: Context, config: Config): void;
 //#endregion
-export { CREDENTIAL_REJECTED_CODE, Config, ENCRYPTED_CREDENTIAL_CODE, FALLBACK_WORKBUDDY_MODELS, FALLBACK_WORKBUDDY_MODELS_GLOBAL, NATIVE_MODALITY_BY_MODEL_ID, PROBE_MAX_TOKENS, PROBE_SYSTEM_PROMPT, PROBE_USER_PROMPT, type UpstreamErrorKind, WORKBUDDY_ACCOUNTS_REFRESH_PATH, WORKBUDDY_APP_EXECUTABLE_ENV, WORKBUDDY_AUTH_FILENAME, WORKBUDDY_AUTH_FILE_ENV, WORKBUDDY_CHECKIN_PATH, WORKBUDDY_CONNECT_VERSION, WORKBUDDY_GLOBAL_PROVIDER, WORKBUDDY_HOST_HEARTBEAT_FILENAME, WORKBUDDY_MODELS_REFRESH_PATH, WORKBUDDY_PROBE_PATH, WORKBUDDY_PROVIDER, WORKBUDDY_PROVIDERS, WORKBUDDY_PROVIDER_DISPLAY_NAMES, WORKBUDDY_REGIONS, WORKBUDDY_REGION_PARAM, WORKBUDDY_SETTINGS_NS, WORKBUDDY_STREAM_IDLE_TIMEOUT_MS, WORKBUDDY_USAGE_PATH, type WorkBuddyAccountChoice, type WorkBuddyAdapter, type WorkBuddyAuthStatus, type WorkBuddyCandidateFailure, WorkBuddyCatalog, type WorkBuddyChatResult, type WorkBuddyCredential, type WorkBuddyCredentialRecovery, WorkBuddyCredentialRejectedError, WorkBuddyCredentialStore, type WorkBuddyCreditPackage, type WorkBuddyCredits, WorkBuddyEncryptedCredentialError, type WorkBuddyEncryptedField, type WorkBuddyHostHeartbeat, type WorkBuddyModelInfo, type WorkBuddyNativeModality, type WorkBuddyProbeClient, type WorkBuddyProbeOutcome, type WorkBuddyProbeResult, type WorkBuddyProbeStore, type WorkBuddyReasoning, type WorkBuddyRecoveryCandidate, type WorkBuddyRefreshOutcome, WorkBuddyRegionState, type WorkBuddyShim, type WorkBuddyStatusRouteOptions, type WorkBuddyStoreOptions, WorkBuddyUpstreamClient, type WorkBuddyUpstreamModel, type WorkBuddyUsabilityProbeOptions, apply, asVolatile, authFileName, classifyUpstreamError, clearAtRestKeyCache, clearHostHeartbeat, cooldownOf, createAccountUsabilityProbe, createWorkBuddyAdapter, createWorkBuddyShim, creditOfStream, defaultDesktopAuthCandidates, defaultDesktopAuthDirs, defaultDesktopAuthPath, deriveAtRestKey, deriveAtRestKeyId, deriveCatalog, fallbackModelsFor, fetchAtRestKeyPayload, findWorkbuddyAppExecutable, hasEncryptedCredentialFields, imageDefaultFor, inject, isCredentialRejectedError, isEncryptedCredentialError, isEncryptedFieldWrapper, isHeartbeatProcessAlive, isWorkbuddyBundle, legacyAttributionRegion, legacyWorkbuddyOwnAuthPath, macosBundleExecutable, macosNestedAppBundles, name, nativeModalityOf, nextRegionEnabled, nextRegionSlots, openEncryptedField, outcomeOfFailure, parseCreditMultiplier, parseReasoning, parseRetryAfter, parseUpstreamModel, parseWorkBuddyAuth, prepareChatBody, probeModel, probeRequestBody, probeSucceeded, processStartTimeMs, readAtRestKey, readHostHeartbeat, regionCleared, regionEnabled, regionEnabledOf, regionOf, regionOfProvider, regionOfStatusUrl, regionStateOf, registerWorkBuddyStatusRoute, resolveCredentialRecovery, selectAccountFor, settingsNamespaceOf, toPersistedWorkBuddyModel, unwrapVolatileDeep, withWorkBuddyRegion, workBuddyDisplayName, workBuddyModelInput, workBuddyThinkingLevelMap, workBuddyWebStatus, workbuddyAccountId, workbuddyAppExecutableCandidates, workbuddyHostHeartbeatPath, workbuddyOwnAuthPath, writeHostHeartbeat };
+export { CREDENTIAL_REJECTED_CODE, Config, ENCRYPTED_CREDENTIAL_CODE, FALLBACK_WORKBUDDY_MODELS, FALLBACK_WORKBUDDY_MODELS_GLOBAL, NATIVE_MODALITY_BY_MODEL_ID, PROBE_INPUT_TOKENS, PROBE_MAX_TOKENS, PROBE_SYSTEM_PROMPT, type UpstreamErrorKind, WORKBUDDY_ACCOUNTS_REFRESH_PATH, WORKBUDDY_APP_EXECUTABLE_ENV, WORKBUDDY_AUTH_FILENAME, WORKBUDDY_AUTH_FILE_ENV, WORKBUDDY_CHECKIN_PATH, WORKBUDDY_CONNECT_VERSION, WORKBUDDY_GLOBAL_PROVIDER, WORKBUDDY_HOST_HEARTBEAT_FILENAME, WORKBUDDY_MODELS_REFRESH_PATH, WORKBUDDY_PROBE_PATH, WORKBUDDY_PROVIDER, WORKBUDDY_PROVIDERS, WORKBUDDY_PROVIDER_DISPLAY_NAMES, WORKBUDDY_REGIONS, WORKBUDDY_REGION_PARAM, WORKBUDDY_SETTINGS_NS, WORKBUDDY_STREAM_IDLE_TIMEOUT_MS, WORKBUDDY_USAGE_PATH, type WorkBuddyAccountChoice, type WorkBuddyAdapter, type WorkBuddyAuthStatus, type WorkBuddyCandidateFailure, WorkBuddyCatalog, type WorkBuddyChatResult, type WorkBuddyCredential, type WorkBuddyCredentialRecovery, WorkBuddyCredentialRejectedError, WorkBuddyCredentialStore, type WorkBuddyCreditPackage, type WorkBuddyCredits, WorkBuddyEncryptedCredentialError, type WorkBuddyEncryptedField, type WorkBuddyHostHeartbeat, type WorkBuddyModelInfo, type WorkBuddyNativeModality, type WorkBuddyProbeClient, type WorkBuddyProbeOutcome, type WorkBuddyProbeResult, type WorkBuddyProbeStore, type WorkBuddyReasoning, type WorkBuddyRecoveryCandidate, type WorkBuddyRefreshOutcome, WorkBuddyRegionState, type WorkBuddyShim, type WorkBuddyStatusRouteOptions, type WorkBuddyStoreOptions, WorkBuddyUpstreamClient, type WorkBuddyUpstreamModel, type WorkBuddyUsabilityProbeOptions, apply, asVolatile, authFileName, classifyUpstreamError, clearAtRestKeyCache, clearHostHeartbeat, cooldownOf, createAccountUsabilityProbe, createWorkBuddyAdapter, createWorkBuddyShim, creditOfStream, defaultDesktopAuthCandidates, defaultDesktopAuthDirs, defaultDesktopAuthPath, deriveAtRestKey, deriveAtRestKeyId, deriveCatalog, fallbackModelsFor, fetchAtRestKeyPayload, findWorkbuddyAppExecutable, hasEncryptedCredentialFields, imageDefaultFor, inject, isCredentialRejectedError, isEncryptedCredentialError, isEncryptedFieldWrapper, isHeartbeatProcessAlive, isWorkbuddyBundle, legacyAttributionRegion, legacyWorkbuddyOwnAuthPath, macosBundleExecutable, macosNestedAppBundles, name, nativeModalityOf, nextRegionEnabled, nextRegionSlots, openEncryptedField, outcomeOfFailure, parseCreditMultiplier, parseReasoning, parseRetryAfter, parseUpstreamModel, parseWorkBuddyAuth, prepareChatBody, probeModel, probeRequestBody, probeSucceeded, processStartTimeMs, readAtRestKey, readHostHeartbeat, regionCleared, regionEnabled, regionEnabledOf, regionOf, regionOfProvider, regionOfStatusUrl, regionStateOf, registerWorkBuddyStatusRoute, resolveCredentialRecovery, selectAccountFor, settingsNamespaceOf, toPersistedWorkBuddyModel, unwrapVolatileDeep, withWorkBuddyRegion, workBuddyDisplayName, workBuddyModelInput, workBuddyThinkingLevelMap, workBuddyWebStatus, workbuddyAccountId, workbuddyAppExecutableCandidates, workbuddyHostHeartbeatPath, workbuddyOwnAuthPath, writeHostHeartbeat };

package/lib/index.js

@@ -1,4 +1,4 @@
-import { A as WorkBuddyCredentialRejectedError, B as clearAtRestKeyCache, C as hasEncryptedCredentialFields, D as workbuddyAccountId, E as parseWorkBuddyAuth, F as parseReasoning, G as isEncryptedFieldWrapper, H as deriveAtRestKeyId, I as parseUpstreamModel, J as macosNestedAppBundles, K as isWorkbuddyBundle, L as prepareChatBody, M as classifyUpstreamError, N as isCredentialRejectedError, O as workbuddyOwnAuthPath, P as parseCreditMultiplier, R as regionOf, S as defaultDesktopAuthPath, T as legacyWorkbuddyOwnAuthPath, U as fetchAtRestKeyPayload, V as deriveAtRestKey, W as findWorkbuddyAppExecutable, X as readAtRestKey, Y as openEncryptedField, Z as workbuddyAppExecutableCandidates, _ as WorkBuddyCredentialStore, a as readHostHeartbeat, b as defaultDesktopAuthCandidates, c as WORKBUDDY_CONNECT_VERSION, d as WorkBuddyCatalog, f as deriveCatalog, g as WORKBUDDY_AUTH_FILE_ENV, h as WORKBUDDY_AUTH_FILENAME, i as processStartTimeMs, j as WorkBuddyUpstreamClient, k as CREDENTIAL_REJECTED_CODE, l as FALLBACK_WORKBUDDY_MODELS, m as ENCRYPTED_CREDENTIAL_CODE, n as clearHostHeartbeat, o as workbuddyHostHeartbeatPath, p as fallbackModelsFor, q as macosBundleExecutable, r as isHeartbeatProcessAlive, s as writeHostHeartbeat, t as WORKBUDDY_HOST_HEARTBEAT_FILENAME, u as FALLBACK_WORKBUDDY_MODELS_GLOBAL, v as WorkBuddyEncryptedCredentialError, w as isEncryptedCredentialError, x as defaultDesktopAuthDirs, y as authFileName, z as WORKBUDDY_APP_EXECUTABLE_ENV } from "./host-heartbeat-Uh8JCXqk.js";
+import { A as WorkBuddyCredentialRejectedError, B as clearAtRestKeyCache, C as hasEncryptedCredentialFields, D as workbuddyAccountId, E as parseWorkBuddyAuth, F as parseReasoning, G as isEncryptedFieldWrapper, H as deriveAtRestKeyId, I as parseUpstreamModel, J as macosNestedAppBundles, K as isWorkbuddyBundle, L as prepareChatBody, M as classifyUpstreamError, N as isCredentialRejectedError, O as workbuddyOwnAuthPath, P as parseCreditMultiplier, R as regionOf, S as defaultDesktopAuthPath, T as legacyWorkbuddyOwnAuthPath, U as fetchAtRestKeyPayload, V as deriveAtRestKey, W as findWorkbuddyAppExecutable, X as readAtRestKey, Y as openEncryptedField, Z as workbuddyAppExecutableCandidates, _ as WorkBuddyCredentialStore, a as readHostHeartbeat, b as defaultDesktopAuthCandidates, c as WORKBUDDY_CONNECT_VERSION, d as WorkBuddyCatalog, f as deriveCatalog, g as WORKBUDDY_AUTH_FILE_ENV, h as WORKBUDDY_AUTH_FILENAME, i as processStartTimeMs, j as WorkBuddyUpstreamClient, k as CREDENTIAL_REJECTED_CODE, l as FALLBACK_WORKBUDDY_MODELS, m as ENCRYPTED_CREDENTIAL_CODE, n as clearHostHeartbeat, o as workbuddyHostHeartbeatPath, p as fallbackModelsFor, q as macosBundleExecutable, r as isHeartbeatProcessAlive, s as writeHostHeartbeat, t as WORKBUDDY_HOST_HEARTBEAT_FILENAME, u as FALLBACK_WORKBUDDY_MODELS_GLOBAL, v as WorkBuddyEncryptedCredentialError, w as isEncryptedCredentialError, x as defaultDesktopAuthDirs, y as authFileName, z as WORKBUDDY_APP_EXECUTABLE_ENV } from "./host-heartbeat-CDZRWbFv.js";
 import z from "@deepseek-ai/schemastery";
 import { randomBytes, timingSafeEqual } from "node:crypto";
 import { createProvider } from "@earendil-works/pi-ai";
@@ -501,25 +501,63 @@ function createWorkBuddyShim(options) {
 * would report every global model as broken.
 */
 const PROBE_SYSTEM_PROMPT = "You are a connectivity check. Reply with a single word.";
-/** The one-word user turn; the smallest thing a chat endpoint accepts. */
-const PROBE_USER_PROMPT = "ping";
 /**
-* Output cap for a probe. One token is enough to prove the model answers, and
-* keeps the cost negligible: live measurements of `max_tokens: 1` probes
-* reported `credit` between 0 and 0.01, and one such probe left the credit
-* balance unchanged (933 → 933). For scale, a model on that roster bills 0.79+
-* per real reply. The point of the feature is to learn whether a model works
-* while spending as close to nothing as the service allows.
+* Output cap for a probe. One token is enough to prove the model answers.
+*
+* The probe's cost comes from its INPUT, not its output (see
+* {@link PROBE_INPUT_TOKENS}), so paying for a long completion would add money
+* without adding signal.
 */
 const PROBE_MAX_TOKENS = 1;
 /**
+* How much input a probe sends, in tokens.
+*
+* This is the whole point of the probe, and it is NOT a free choice. The
+* upstream's rate limit (business code 6004) fires on request SIZE, measured on
+* 2026-09-29 by varying only the input against one account and one model:
+*
+*   | input     | prompt_tokens the upstream counted | result |
+*   | ---       | ---                                | ---    |
+*   | ~10       | 38                                 | ok     |
+*   | ~1,000    | 1,138                              | ok     |
+*   | ~10,000   | 11,138                             | ok     |
+*   | ~18,000   | 20,018                             | ok     |
+*   | ~25,000   | 25,023                             | ok     |
+*   | ~30,000   | ~32k                               | **429 / 6004** |
+*
+* So the threshold sits between 20k and 30k, a SINGLE large request is enough to
+* trip it (it is not a running total), and each account reports its own reset
+* time (two accounts at the same moment: `22:20:33` and `00:32:51`).
+*
+* A probe that sent a handful of tokens answered "usable" while every real
+* request in a long conversation was refused — the probe was asking too small a
+* question. 25k is sized to be a realistic long-conversation payload.
+*/
+const PROBE_INPUT_TOKENS = 25e3;
+/**
+* Characters per token for the filler text, measured.
+*
+* Filling with a fixed English sentence, the upstream counted about 4.5
+* characters per token. An estimate rather than a bundled tokenizer: the body
+* only needs to be the right SIZE CLASS, and the target has ample margin over
+* the measured threshold, so estimate error cannot change the verdict.
+*/
+const CHARS_PER_TOKEN = 4.5;
+/** Neutral filler; carries no user content, only volume. */
+const FILLER_LINE = "The quick brown fox jumps over the lazy dog. ";
+/**
 * Build the request body for one probe.
 *
 * `stream` is forced because the upstream rejects non-streaming chat requests;
 * `prepareChatBody` enforces that too, but sending it explicitly keeps this
 * function's output valid on its own.
+*
+* Measured on the built artifact: 112,713 bytes of body, and the upstream
+* counted `prompt_tokens: 25023` at a cost of `credit: 0.72`.
 */
 function probeRequestBody(modelId) {
+	const targetChars = Math.ceil(PROBE_INPUT_TOKENS * CHARS_PER_TOKEN);
+	const filler = FILLER_LINE.repeat(Math.ceil(targetChars / 45));
 	return JSON.stringify({
 		model: modelId,
 		messages: [{
@@ -527,7 +565,7 @@ function probeRequestBody(modelId) {
 			content: PROBE_SYSTEM_PROMPT
 		}, {
 			role: "user",
-			content: PROBE_USER_PROMPT
+			content: `${filler}Reply with a single word.`
 		}],
 		max_tokens: 1,
 		stream: true
@@ -558,21 +596,71 @@ function parseRetryAfter(value, nowMs) {
 	return parsed;
 }
 /**
+* The upstream's reset sentence, as its Chinese gateway writes it.
+*
+* Measured on a live 429 (code 6004), verbatim:
+*
+*   `您的使用量已超出频率限制，将在 2026-09-30 02:30:30 UTC+8 重置，您也可以切换其他模型继续使用。`
+*
+* The two halves are captured separately because the second one is the whole
+* reason this parser exists: the upstream DOES name a time, and the plugin was
+* showing "the upstream gave no time" while the answer was sitting right there
+* in the body. The earlier note in this module ("the upstream provides no
+* rate-limit metadata") was drawn from the RESPONSE HEADERS alone — true as far
+* as it went, and wrong as a conclusion, because the time is in the body text.
+*
+* Deliberately loose about the surrounding wording (`[\s\S]*?` on both sides)
+* and strict about the parts that must not be guessed: the keyword 重置, the
+* timestamp shape, and an explicit UTC offset. A message that merely mentions
+* 重置 without a parsable offset yields no time, which is the honest answer.
+*/
+const UPSTREAM_RESET_PATTERN = /将在?\s*(\d{4})-(\d{2})-(\d{2})[ T](\d{2}):(\d{2}):(\d{2})\s*UTC\s*([+-])(\d{1,2})(?::?(\d{2}))?[\s\S]*?重置/u;
+/**
+* Parse the reset time out of an upstream failure message.
+*
+* Returns epoch ms, or undefined when the message names no parsable time — the
+* caller must then say "the upstream gave no time", never invent one.
+*
+* THE OFFSET IS HONOURED, NOT ASSUMED. `2026-09-30 02:30:30 UTC+8` is 18:30:30
+* UTC the previous day, and `Date.parse` on the bare string would read it as
+* LOCAL time — on a machine set to UTC+8 that happens to be right, and on any
+* other machine it is silently wrong by the offset. So the components are
+* assembled with `Date.UTC` and the stated offset subtracted, which is correct
+* on every host regardless of its own zone.
+*
+* A whole-second resolution is what the upstream prints; sub-second precision
+* would be fiction in the other direction.
+*/
+function parseUpstreamResetAt(message) {
+	const match = UPSTREAM_RESET_PATTERN.exec(message);
+	if (match === null) return void 0;
+	const [, year, month, day, hour, minute, second, sign, offsetHours, offsetMinutes] = match;
+	const offsetTotalMinutes = (sign === "-" ? -1 : 1) * (Number(offsetHours) * 60 + Number(offsetMinutes ?? "0"));
+	const utcMs = Date.UTC(Number(year), Number(month) - 1, Number(day), Number(hour), Number(minute), Number(second));
+	const parsed = new Date(utcMs);
+	if (parsed.getUTCFullYear() !== Number(year) || parsed.getUTCMonth() !== Number(month) - 1 || parsed.getUTCDate() !== Number(day) || parsed.getUTCHours() !== Number(hour) || parsed.getUTCMinutes() !== Number(minute) || parsed.getUTCSeconds() !== Number(second)) return;
+	if (Math.abs(offsetTotalMinutes) > 840) return void 0;
+	return utcMs - offsetTotalMinutes * 6e4;
+}
+/**
 * The cooldown the upstream stated, if it stated one.
 *
-* Two sources, in order of authority:
+* Three sources, in order of authority:
 *
 * 1. `Retry-After` on the failure response. This is the upstream naming a time
 *    for THIS request, so it wins.
-* 2. The region's monthly quota refresh point, but ONLY for an out-of-credit
+* 2. The reset time the upstream writes into its own failure body (see
+*    {@link parseUpstreamResetAt}). This is the case that actually fires on
+*    this service: a 429 from the Chinese gateway carries code 6004 and a
+*    `将在 … 重置` sentence, with no `Retry-After` header at all.
+* 3. The region's monthly quota refresh point, but ONLY for an out-of-credit
 *    outcome. A quota that resets at a known time is the one case where "when
 *    can I use this again" has a real answer even without a header — and it is
 *    the answer for the most common real limit on this service.
 *
-* A `rate-limited` outcome with neither source returns `{}`, which the card
-* renders as "the upstream did not say when". That is the honest answer: the
-* live probes found no rate-limit metadata in any response at all, so inventing
-* a number here would be pure fiction.
+* A limited outcome with none of the three returns `{}`, which the card renders
+* as "the upstream did not say when". That remains the honest answer for a
+* genuinely timeless failure; inventing a number here would be pure fiction.
 */
 function cooldownOf(input) {
 	const fromHeader = parseRetryAfter(input.retryAfter, input.nowMs);
@@ -580,6 +668,11 @@ function cooldownOf(input) {
 		retryAtMs: fromHeader,
 		retrySource: "retry-after"
 	};
+	const fromBody = input.body === void 0 ? void 0 : parseUpstreamResetAt(input.body);
+	if (fromBody !== void 0) return {
+		retryAtMs: fromBody,
+		retrySource: "upstream-message"
+	};
 	if (input.outcome === "out-of-credit" && input.quotaRefreshAtMs !== void 0) return {
 		retryAtMs: input.quotaRefreshAtMs,
 		retrySource: "quota-refresh"
@@ -640,9 +733,9 @@ function redact(text) {
 * Run one probe for one model and reduce it to the card's row.
 *
 * The successful path drains the SSE stream purely to read the `credit` figure
-* the upstream reports, then discards the rest: the probe's question is "did
-* this model answer", and `max_tokens: 1` means there is nothing else in the
-* stream worth keeping.
+* the upstream reports, then discards the rest: the question is whether this
+* model answers a real-sized request, and `max_tokens: 1` means there is nothing
+* else in the stream worth keeping.
 *
 * Never throws. A probe is a diagnostic the user asked for, so every failure is
 * a RESULT — one dead model must not abort the batch and hide the other rows.
@@ -691,6 +784,7 @@ async function probeModel(input) {
 			outcome,
 			retryAfter: answer.retryAfter,
 			nowMs: input.nowMs,
+			body,
 			...input.quotaRefreshAtMs === void 0 ? {} : { quotaRefreshAtMs: input.quotaRefreshAtMs }
 		})
 	};
@@ -897,14 +991,6 @@ function json(res, status, body) {
 	});
 	res.end(payload);
 }
-/**
-* Cap on how many models one probe request may name.
-*
-* A probe is a real (if tiny) request against a metered service, and the batch
-* runs sequentially, so an unbounded list would let one click hold the route for
-* minutes. The card never sends more than the models on its own screen.
-*/
-const PROBE_BATCH_LIMIT = 64;
 /** Request-body cap for the probe route: model ids only, never content. */
 const PROBE_BODY_LIMIT = 65536;
 /**
@@ -1218,7 +1304,7 @@ function registerWorkBuddyStatusRoute(ctx, deps) {
 					const body = await readJsonBody(req);
 					const modelIds = Array.isArray(body.modelIds) ? body.modelIds.filter((id) => typeof id === "string" && id !== "") : [];
 					if (modelIds.length === 0) return json(res, 400, { error: "modelIds must be a non-empty array of strings" });
-					if (modelIds.length > PROBE_BATCH_LIMIT) return json(res, 400, { error: `at most ${String(PROBE_BATCH_LIMIT)} models per probe` });
+					if (modelIds.length > 1) return json(res, 400, { error: "a probe accepts exactly one model" });
 					const results = [];
 					for (const modelId of modelIds) results.push(...await deps.probeModels(region, [modelId]));
 					json(res, 200, { results });
@@ -1687,7 +1773,7 @@ function apply(ctx, config) {
 		* out-of-credit result. Every other limited outcome has no time anywhere, and
 		* the probe reports exactly that instead of inventing one.
 		*/
-		async probeModels(region, modelIds, signal) {
+		async probeModels(region, modelIds, options) {
 			let credential;
 			try {
 				credential = await stacks[region].store.resolve();
@@ -1706,7 +1792,7 @@ function apply(ctx, config) {
 				modelId,
 				nowMs: Date.now(),
 				...quotaRefreshAtMs === void 0 ? {} : { quotaRefreshAtMs },
-				...signal === void 0 ? {} : { signal }
+				...options?.signal === void 0 ? {} : { signal: options.signal }
 			}));
 			return results;
 		},
@@ -1847,4 +1933,4 @@ function apply(ctx, config) {
 	});
 }
 //#endregion
-export { CREDENTIAL_REJECTED_CODE, Config, ENCRYPTED_CREDENTIAL_CODE, FALLBACK_WORKBUDDY_MODELS, FALLBACK_WORKBUDDY_MODELS_GLOBAL, NATIVE_MODALITY_BY_MODEL_ID, PROBE_MAX_TOKENS, PROBE_SYSTEM_PROMPT, PROBE_USER_PROMPT, WORKBUDDY_ACCOUNTS_REFRESH_PATH, WORKBUDDY_APP_EXECUTABLE_ENV, WORKBUDDY_AUTH_FILENAME, WORKBUDDY_AUTH_FILE_ENV, WORKBUDDY_CHECKIN_PATH, WORKBUDDY_CONNECT_VERSION, WORKBUDDY_GLOBAL_PROVIDER, WORKBUDDY_HOST_HEARTBEAT_FILENAME, WORKBUDDY_MODELS_REFRESH_PATH, WORKBUDDY_PROBE_PATH, WORKBUDDY_PROVIDER, WORKBUDDY_PROVIDERS, WORKBUDDY_PROVIDER_DISPLAY_NAMES, WORKBUDDY_REGIONS, WORKBUDDY_REGION_PARAM, WORKBUDDY_SETTINGS_NS, WORKBUDDY_STREAM_IDLE_TIMEOUT_MS, WORKBUDDY_USAGE_PATH, WorkBuddyCatalog, WorkBuddyCredentialRejectedError, WorkBuddyCredentialStore, WorkBuddyEncryptedCredentialError, WorkBuddyUpstreamClient, apply, asVolatile, authFileName, classifyUpstreamError, clearAtRestKeyCache, clearHostHeartbeat, cooldownOf, createAccountUsabilityProbe, createWorkBuddyAdapter, createWorkBuddyShim, creditOfStream, defaultDesktopAuthCandidates, defaultDesktopAuthDirs, defaultDesktopAuthPath, deriveAtRestKey, deriveAtRestKeyId, deriveCatalog, fallbackModelsFor, fetchAtRestKeyPayload, findWorkbuddyAppExecutable, hasEncryptedCredentialFields, imageDefaultFor, inject, isCredentialRejectedError, isEncryptedCredentialError, isEncryptedFieldWrapper, isHeartbeatProcessAlive, isWorkbuddyBundle, legacyAttributionRegion, legacyWorkbuddyOwnAuthPath, macosBundleExecutable, macosNestedAppBundles, name, nativeModalityOf, nextRegionEnabled, nextRegionSlots, openEncryptedField, outcomeOfFailure, parseCreditMultiplier, parseReasoning, parseRetryAfter, parseUpstreamModel, parseWorkBuddyAuth, prepareChatBody, probeModel, probeRequestBody, probeSucceeded, processStartTimeMs, readAtRestKey, readHostHeartbeat, regionCleared, regionEnabled, regionEnabledOf, regionOf, regionOfProvider, regionOfStatusUrl, regionStateOf, registerWorkBuddyStatusRoute, resolveCredentialRecovery, selectAccountFor, settingsNamespaceOf, toPersistedWorkBuddyModel, unwrapVolatileDeep, withWorkBuddyRegion, workBuddyDisplayName, workBuddyModelInput, workBuddyThinkingLevelMap, workBuddyWebStatus, workbuddyAccountId, workbuddyAppExecutableCandidates, workbuddyHostHeartbeatPath, workbuddyOwnAuthPath, writeHostHeartbeat };
+export { CREDENTIAL_REJECTED_CODE, Config, ENCRYPTED_CREDENTIAL_CODE, FALLBACK_WORKBUDDY_MODELS, FALLBACK_WORKBUDDY_MODELS_GLOBAL, NATIVE_MODALITY_BY_MODEL_ID, PROBE_INPUT_TOKENS, PROBE_MAX_TOKENS, PROBE_SYSTEM_PROMPT, WORKBUDDY_ACCOUNTS_REFRESH_PATH, WORKBUDDY_APP_EXECUTABLE_ENV, WORKBUDDY_AUTH_FILENAME, WORKBUDDY_AUTH_FILE_ENV, WORKBUDDY_CHECKIN_PATH, WORKBUDDY_CONNECT_VERSION, WORKBUDDY_GLOBAL_PROVIDER, WORKBUDDY_HOST_HEARTBEAT_FILENAME, WORKBUDDY_MODELS_REFRESH_PATH, WORKBUDDY_PROBE_PATH, WORKBUDDY_PROVIDER, WORKBUDDY_PROVIDERS, WORKBUDDY_PROVIDER_DISPLAY_NAMES, WORKBUDDY_REGIONS, WORKBUDDY_REGION_PARAM, WORKBUDDY_SETTINGS_NS, WORKBUDDY_STREAM_IDLE_TIMEOUT_MS, WORKBUDDY_USAGE_PATH, WorkBuddyCatalog, WorkBuddyCredentialRejectedError, WorkBuddyCredentialStore, WorkBuddyEncryptedCredentialError, WorkBuddyUpstreamClient, apply, asVolatile, authFileName, classifyUpstreamError, clearAtRestKeyCache, clearHostHeartbeat, cooldownOf, createAccountUsabilityProbe, createWorkBuddyAdapter, createWorkBuddyShim, creditOfStream, defaultDesktopAuthCandidates, defaultDesktopAuthDirs, defaultDesktopAuthPath, deriveAtRestKey, deriveAtRestKeyId, deriveCatalog, fallbackModelsFor, fetchAtRestKeyPayload, findWorkbuddyAppExecutable, hasEncryptedCredentialFields, imageDefaultFor, inject, isCredentialRejectedError, isEncryptedCredentialError, isEncryptedFieldWrapper, isHeartbeatProcessAlive, isWorkbuddyBundle, legacyAttributionRegion, legacyWorkbuddyOwnAuthPath, macosBundleExecutable, macosNestedAppBundles, name, nativeModalityOf, nextRegionEnabled, nextRegionSlots, openEncryptedField, outcomeOfFailure, parseCreditMultiplier, parseReasoning, parseRetryAfter, parseUpstreamModel, parseWorkBuddyAuth, prepareChatBody, probeModel, probeRequestBody, probeSucceeded, processStartTimeMs, readAtRestKey, readHostHeartbeat, regionCleared, regionEnabled, regionEnabledOf, regionOf, regionOfProvider, regionOfStatusUrl, regionStateOf, registerWorkBuddyStatusRoute, resolveCredentialRecovery, selectAccountFor, settingsNamespaceOf, toPersistedWorkBuddyModel, unwrapVolatileDeep, withWorkBuddyRegion, workBuddyDisplayName, workBuddyModelInput, workBuddyThinkingLevelMap, workBuddyWebStatus, workbuddyAccountId, workbuddyAppExecutableCandidates, workbuddyHostHeartbeatPath, workbuddyOwnAuthPath, writeHostHeartbeat };

package/package.json

@@ -2,7 +2,7 @@
   "name": "dsh-connect-workbuddy",
   "displayName": "DSH Connect WorkBuddy",
   "description": "把本机登录的 WorkBuddy 模型接入 DeepSeek Harness，并提供只读的积分概览与模型管理。",
-  "version": "2.3.0",
+  "version": "2.3.1",
   "author": "dingminhua",
   "copyright": "Copyright (c) 2026 LaoDing",
   "license": "MIT",