dsh-connect-workbuddy 2.3.1 → 3.0.0

package/lib/client.js

@@ -37,6 +37,25 @@ window.__ModuleLoader__.load({
 		* browser half.
 		*/
 		const WORKBUDDY_PROBE_PATH = "/plugins/dsh-connect-workbuddy/probe";
+		/**
+		* Plugin-owned account-pool endpoint: one batch action per call.
+		*
+		* `?action=checkin` claims the daily reward for every account of a region;
+		* `?action=test` probes every account against the region's target model. Both
+		* are POST and loopback-only because both cost something real — check-in writes
+		* to the user's account, a probe spends credits.
+		*
+		* Deliberately ONE endpoint rather than two: the two actions share every
+		* guard (method, origin, region, pool-enabled) and differ only in the work, so
+		* splitting them would duplicate the guards and invite them to drift apart.
+		*/
+		const WORKBUDDY_POOL_PATH = "/plugins/dsh-connect-workbuddy/pool";
+		/** Query parameter selecting which pool batch action a request means. */
+		const WORKBUDDY_POOL_ACTION_PARAM = "action";
+		/** Address one region's pool endpoint with an action. */
+		function withWorkBuddyRegionAndAction(path, region, action) {
+			return `${withWorkBuddyRegion(path, region)}&${WORKBUDDY_POOL_ACTION_PARAM}=${action}`;
+		}
 		/** Query parameter naming the region a card request addresses. */
 		const WORKBUDDY_REGION_PARAM = "region";
 		/** Every region, in card tab order. */
@@ -113,6 +132,33 @@ window.__ModuleLoader__.load({
 		* value is always the `regions` map, i.e. exactly what `settingsScope.set(
 		* 'regions', ...)` needs.
 		*/
+		/**
+		* Build the next `regions` settings value for a MODEL-LIST save.
+		*
+		* The model save replaces a region slot wholesale, so the merge has to start
+		* from the EXISTING slot rather than from a fresh object: the pool's
+		* preferences live in that same slot, and a save that omitted them would delete
+		* settings the user configured elsewhere in the card. Every writer that owns
+		* only part of a slot goes through a helper like this one.
+		*/
+		function nextRegionModels(value, region, models) {
+			return nextRegionSlots(regionsMapOf(value), region, {
+				...regionSlotOf(value, region),
+				...models
+			});
+		}
+		/**
+		* Build the next `regions` settings value for a POOL-PREFERENCES save.
+		*
+		* Same reasoning as {@link nextRegionModels}: the pool is one field of a slot
+		* that also holds the model list, so the merge starts from the existing slot.
+		*/
+		function nextRegionPool(value, region, pool) {
+			return nextRegionSlots(regionsMapOf(value), region, {
+				...regionSlotOf(value, region),
+				pool
+			});
+		}
 		function nextRegionEnabled(value, region, enabled) {
 			return nextRegionSlots(regionsMapOf(value), region, {
 				...regionSlotOf(value, region),
@@ -371,8 +417,9 @@ window.__ModuleLoader__.load({
 		* @throws {WorkBuddySettingsWriteError} when the catalog does not read back.
 		*/
 		async function writeRegionModels(scope, region, payload) {
+			const next = nextRegionModels(scope.getSnapshot().value, region, payload)[region];
 			const written = payload.lastCatalog.map((model) => model.id);
-			await writeField(scope, "regions", region, payload, (readBack) => {
+			await writeField(scope, "regions", region, next, (readBack) => {
 				const stored = readBack?.lastCatalog?.map((model) => model.id);
 				return stored !== void 0 && stored.length === written.length && stored.every((id, index) => id === written[index]);
 			});
@@ -409,6 +456,1001 @@ window.__ModuleLoader__.load({
 				return stored !== null && stored !== void 0 && stored["enabled"] === enabled;
 			});
 		}
+		/**
+		* Write one region's account-pool PREFERENCES, verifying they landed.
+		*
+		* Routed through {@link writeField} like every other settings write, so it gets
+		* the same Host-endpoint-first path and the same landed check. The card treats
+		* a resolved write as "the draft is now safe to discard", so a write that
+		* silently did nothing would throw away the user's edits while reporting
+		* success — unrecoverable, since the draft is the only copy.
+		*
+		* The COMPLETE region slot is passed in by the caller for the same reason
+		* {@link writeRegionEnabled} does it: the pool lives INSIDE the region slot
+		* alongside `lastCatalog`/`enabledModelIds`, so writing only the pool field
+		* would drop the model list.
+		*
+		* Deliberately does NOT carry the pool's measured facts. Those are written by
+		* the Host to its own file; keeping them out of settings is what stops a save
+		* from rolling back a test result the timer had just recorded.
+		*
+		* @param scope - the bound settings scope for this plugin's namespace.
+		* @param region - the region whose pool preferences are written.
+		* @param preferences - the four preference fields, as the user set them.
+		* @param slot - the region's COMPLETE next slot (caller owns the merge).
+		* @throws {WorkBuddySettingsWriteError} when neither writer persists the value.
+		*/
+		async function writePoolPreferences(scope, region, preferences) {
+			const next = nextRegionPool(scope.getSnapshot().value, region, preferences)[region];
+			await writeField(scope, "regions", region, next, (readBack) => {
+				const pool = readBack?.pool;
+				if (pool === void 0 || pool === null) return false;
+				if (pool["enabled"] !== preferences.enabled || pool["rotateByCredits"] !== preferences.rotateByCredits || pool["autoTestIntervalMinutes"] !== preferences.autoTestIntervalMinutes || pool["targetModelId"] !== preferences.targetModelId) return false;
+				const stored = pool["memberAccountIds"];
+				if (!Array.isArray(stored) || stored.length !== preferences.memberAccountIds.length) return false;
+				const wanted = new Set(preferences.memberAccountIds);
+				return stored.every((id) => typeof id === "string" && wanted.has(id));
+			});
+		}
+		//#endregion
+		//#region src/account-pool.ts
+		/**
+		* The checked ids that still resolve to a local sign-in, in the caller's order.
+		*
+		* This is THE definition of "effective members", and it exists because the same
+		* predicate was written five separate times: the status document
+		* (`web-status.ts`), the batch route's empty-pool guard, the Host dependency the
+		* card reads, `poolMemberAccounts` and the browser helper. Five copies of one
+		* rule is this project's single most productive bug shape ("fixed one end,
+		* missed the other"), so the rule now has one home and every site delegates to
+		* it.
+		*
+		* ORDER IS THE CALLER'S, and comes from `orderedIds`: the answer preserves the
+		* order of THAT argument. Callers pass whichever list's order they want to show
+		* — the saved list for the user's own order, the store's roster for the account
+		* table's. Neither is silently reshuffled by the filter. (The first parameter was
+		* once named `saved`, which read as "this must be the saved list" even though
+		* `web-status.ts` legitimately passes the roster for store order; the name was
+		* the trap, so it now describes the ROLE instead of the source.)
+		*
+		* Pure, so it is unit-testable without a store, and it never mutates its input.
+		*/
+		function effectiveMembersOf(orderedIds, listedIds) {
+			return orderedIds.filter((id) => listedIds.has(id));
+		}
+		/**
+		* A latest-wins guard for one region's asynchronous work.
+		*
+		* Exists because `applyRotation` awaits (it fetches credits per member), so two
+		* overlapping calls can interleave: a slow call that read "rotation is ON" can
+		* resume AFTER a newer call cleared the override for "rotation is OFF" and write
+		* the stale account back — leaving the card showing the pool switched off while
+		* a rotated account is still billed.
+		*
+		* `begin()` claims a new generation and returns a probe; the caller must check
+		* it after EVERY await and bail when it reports stale. Extracted as a pure
+		* factory rather than inlined so the rule is unit-testable: an inlined token is
+		* only observable by reproducing a real interleaving, which is slow and easy to
+		* get subtly wrong (a harness that never actually overlaps passes either way).
+		*/
+		function createLatestWins() {
+			const generations = {};
+			return { begin(key) {
+				const generation = (generations[key] ?? 0) + 1;
+				generations[key] = generation;
+				return () => generations[key] !== generation;
+			} };
+		}
+		//#endregion
+		//#region src/client/pool-state.ts
+		/**
+		* Pure decision helpers for the account pool's card section.
+		*
+		* 参考：`src/account-pool.ts` 的做法——把「判定规则」从组件里抽出来，让规则本身
+		*   可被单测直接钉住，而不是只能通过渲染整棵组件树间接观察。
+		* 改动：新增本模块，收纳三组此前内联在 `AccountPool.tsx` 里的判定。抽出它们的
+		*   直接原因是**独立验证发现 H-1/H-2 两个最高危修复没有任何自动化回归测试**：
+		*   内联在组件里就只能靠真实渲染验证，而渲染测试既慢又容易被隔离问题骗过。
+		*
+		* 本模块不 import React、不碰网络，纯函数、全函数。
+		*
+		* @module dsh-connect-workbuddy/client/pool-state
+		*/
+		/**
+		* Whether rotation currently owns the region's billing choice, and whether the
+		* user has drafted turning it off.
+		*
+		* `locked` reads the COMMITTED preferences, never the draft. The Host decides
+		* who is billed from the saved config, so a draft-based lock let one click of
+		* "turn off rotation" re-enable the manual dropdown and hide the conflict
+		* notice while the Host kept rotating — the user then picked an account, the
+		* card showed it as current, and a different account was billed. That is
+		* exactly the failure the lock exists to prevent.
+		*
+		* `unlockPending` is the honest intermediate state: the draft says "stop
+		* rotating" but the Host has not been told yet, so the lock still applies and
+		* the UI must say so rather than looking broken.
+		*/
+		function rotationLockState(saved, active) {
+			const locked = saved.enabled && saved.rotateByCredits;
+			return {
+				locked,
+				unlockPending: locked && !(active.enabled && active.rotateByCredits)
+			};
+		}
+		/**
+		* The base a draft edit starts from.
+		*
+		* Resolved at EDIT time rather than captured when the callback was built. The
+		* defect this fixes: the callback's dependency list named individual scalar
+		* fields, so a field added later (`memberAccountIds`) was missing from it and
+		* the callback kept a STALE base — checking one account then silently dropped
+		* another that had been saved in between.
+		*
+		* `previous` is the draft already in state; it only applies to the region it
+		* was made on, because the two pools are independent and one region's unsaved
+		* edits must never seed the other's.
+		*/
+		function draftBaseFor(previous, previousRegion, region, saved) {
+			return previous !== null && previousRegion === region ? previous : saved;
+		}
+		/**
+		* Membership that resolves to a real local sign-in — what a batch runs on.
+		*
+		* The HOST computes this and sends it; this helper only chooses which answer to
+		* trust. Counting the raw saved list is what let the UI claim "已选 1 / 共 1"
+		* and enable both buttons while the batch ran on ZERO accounts and reported
+		* success, so:
+		*
+		*   - while the draft is CLEAN, the Host's answer is authoritative (it reflects
+		*     what would actually run, including sign-ins that have since disappeared);
+		*   - while the draft is DIRTY, it must be derived from the edited list, since
+		*     the Host's answer describes the SAVED state and would ignore the edit the
+		*     user is looking at.
+		*/
+		function effectiveMemberIds(input) {
+			if (!input.dirty) return [...input.savedEffective];
+			return effectiveMembersOf(input.draftMembers, input.listedIds);
+		}
+		/**
+		* Saved member ids with no matching sign-in.
+		*
+		* Surfaced rather than silently ignored: the ids remain in the user's saved
+		* list (a login can come back), so the card has to explain why the pool behaves
+		* as though they were absent.
+		*/
+		function ghostMemberIds(draftMembers, listedIds) {
+			return draftMembers.filter((id) => !listedIds.has(id));
+		}
+		/**
+		* How many accounts a batch will really touch, as the log announces it.
+		*
+		* Mirrors the HOST's own resolution exactly — `effective ?? saved` in the pool
+		* route — because the number in the activity log must describe what the Host
+		* runs, not what the card happens to display. Two wrong answers are possible and
+		* both were live at different times:
+		*
+		*   - counting the raw SAVED list overstates it, so a ghost-only pool logged
+		*     "checking in 1 account(s)" and was then refused with 409 having touched
+		*     nothing;
+		*   - counting the DRAFT-derived set announces unsaved edits the Host will not
+		*     run (it reads the committed config).
+		*
+		* `savedEffective` is `undefined` only for a Host too old to send it, where the
+		* saved list is the best available answer — the same fallback the route uses.
+		*/
+		function announcedBatchCount(input) {
+			return (input.savedEffective ?? input.savedMembers).length;
+		}
+		const POOL_INTERVAL_MAX = 1440;
+		/**
+		* Localize a pool route failure from its structured cause.
+		*
+		* Lives here, not in `AccountPool.tsx`, because the card's module graph pulls
+		* DSH's browser packages and there is no jsdom in this project — a rule left
+		* inside the component cannot be tested at all. That is not hypothetical: the
+		* independent verification deleted this function's `no-live-members` branch AND
+		* both locale copies of its copy, and the whole 618-test suite still passed.
+		* Extracting it is what lets `tests/pool-state.spec.ts` pin every branch.
+		*
+		* Returns undefined for an unknown cause so the caller can fall back to the
+		* Host's own words — a new cause added upstream must still be visible rather
+		* than swallowed into a generic message.
+		*
+		* `detail` is the Host's raw `error` text, used only where the sentence has a
+		* slot for it (`pool-failed`). It is NOT the primary path: echoing English
+		* developer prose into a Chinese UI was the defect this function exists to
+		* prevent, and only the cases with no structured cause fall back to it.
+		*/
+		function poolErrorText(t, reason, detail) {
+			switch (reason) {
+				case "pool-disabled": return t("row.poolErrDisabled");
+				case "no-members": return t("row.poolErrNoMembers");
+				case "no-live-members": return t("row.poolErrNoLiveMembers");
+				case "no-free-model": return t("row.poolErrNoFreeModel");
+				case "target-model-stale": return t("row.poolErrStaleModel");
+				case "pool-unavailable": return t("row.poolErrUnavailable");
+				case "pool-failed": return t("row.poolErrFailed", { message: detail ?? "" });
+				default: return;
+			}
+		}
+		/**
+		* The message to show for a failed pool request, from every signal available.
+		*
+		* The three-tier rule, in order, and why each tier exists:
+		*
+		*  1. the STRUCTURED cause, localized — the Host's `error` is an English
+		*     developer sentence, and echoing it put untranslated prose in a Chinese UI;
+		*  2. the Host's raw text, for a cause this build does not know — still more
+		*     informative than a generic message, and it keeps a new upstream cause
+		*     visible rather than swallowed;
+		*  3. a message keyed on the STATUS — every pool exit that carries no reason
+		*     (405/403/400 and the generic 500) otherwise reached the user as bare
+		*     English like `HTTP 405`.
+		*
+		* Extracted from the card for the same reason as {@link poolErrorText}: a rule
+		* inside the browser-only `.tsx` cannot be tested, and the status tier in
+		* particular had no guard at all — reverting it to `` `HTTP ${status}` `` left
+		* the entire suite green.
+		*/
+		function poolFailureText(t, input) {
+			return poolErrorText(t, input.reason, input.error) ?? input.error ?? t("row.poolErrHttp", { status: String(input.status) });
+		}
+		/**
+		* Parse an in-progress interval edit.
+		*
+		* Returns `undefined` while the text is not yet a plain non-negative integer —
+		* empty, `-`, `12e`, `1.5` — so the caller can leave EXACTLY what the user typed
+		* on screen instead of rewriting the control from a parsed number.
+		*
+		* That rewriting was the defect this replaces: the field clamped on every
+		* keystroke and wrote the clamped result back into a controlled `value`, so
+		* typing `120` produced `520` (each keystroke's clamped `5` was rendered, and the
+		* next digit appended to it) and clearing the field immediately snapped it to
+		* `5`. The user's original request was "设置一个时间间隔自动测试" — a field that
+		* cannot be typed into is that requirement unmet, not a cosmetic wart.
+		*/
+		function parseIntervalInput(raw) {
+			const trimmed = raw.trim();
+			if (!/^[0-9]+$/.test(trimmed)) return void 0;
+			const parsed = Number(trimmed);
+			if (!Number.isFinite(parsed)) return void 0;
+			return Math.min(POOL_INTERVAL_MAX, Math.max(5, Math.round(parsed)));
+		}
+		/**
+		* One keystroke in the interval field: what to DISPLAY, and what to commit.
+		*
+		* `text` is ALWAYS the raw keystroke, never a re-serialized number — that
+		* distinction is the whole defect. A field whose displayed value is derived from
+		* the parsed-and-clamped number cannot be typed into: each keystroke's clamped
+		* `5` is rendered, and the next digit appends to it (`120` → `520`).
+		*
+		* `commit` is the clamped number to fold into the draft, or `undefined` while the
+		* text is not yet a plain integer (so the draft is left alone until the entry is
+		* meaningful). Splitting the two makes the invariant unit-testable without a DOM,
+		* which this project has no way to render.
+		*/
+		function intervalEditOnInput(raw) {
+			return {
+				text: raw,
+				commit: parseIntervalInput(raw)
+			};
+		}
+		/**
+		* Pool MEMBERS that can serve right now.
+		*
+		* Judged over members only. Using the whole account table made the "no usable
+		* account" warning unreachable: unchecked rows are listed for the user to opt
+		* into and never carry `excludedBy`, so any unchecked sign-in kept the count
+		* above zero — exactly when every member was limited and the explanation was
+		* most needed.
+		*/
+		function usableMemberIds(accounts, effectiveMembers, draftMembers) {
+			const wanted = /* @__PURE__ */ new Set([...effectiveMembers, ...draftMembers]);
+			return accounts.filter((account) => wanted.has(account.accountId) && account.excludedBy === void 0).map((account) => account.accountId);
+		}
+		//#endregion
+		//#region src/client/AccountPool.tsx
+		/**
+		* The account pool's card section.
+		*
+		* 参考：`WorkBuddyCard.tsx` 的既有写法 —— 草稿态 + dirty 标记 + 「保存/放弃」、
+		*   60 秒轮询、`writeField` 验证写入，全部沿用；样式类名继续用
+		*   `dsm-workbuddy-*` 前缀，好让这一块与卡片其余部分共用同一套外观语言。
+		* 改动：把「账号池」这一整块独立成模块。原因是它有三条别的区块没有的规则，
+		*   放在卡片里会被淹没：
+		*
+		*   1. **两项互斥。** 自动轮换开启时，上方卡片原有的手动账号下拉必须停用 ——
+		*      否则会出现"下拉显示 A、实际计费 B"。本模块通过 `onRotationChange`
+		*      把这个状态交回卡片，由卡片去禁用那个下拉。
+		*   2. **两种状态、两套写入。** 四项偏好走草稿 + 保存（保存成功才丢弃草稿）；
+		*      测试结果与轮换是**运行时事实**，由 Host 自动落盘，绝不经这个保存按钮。
+		*      把它们混在一起，一次「保存」就会用旧草稿覆盖刚测出的结果。
+		*   3. **免费模型可能不存在。** 国内版静态目录不带倍率，所以「自动挑免费模型」
+		*      在国内版首次刷新前会挑到空。此时**不回退到收费模型**，而是如实说明并
+		*      停用测试按钮。
+		*
+		* @module dsh-connect-workbuddy/client/AccountPool
+		*/
+		/** How many activity lines are kept; the oldest are dropped. */
+		const LOG_LIMIT = 60;
+		/**
+		* Activity logs, kept per region OUTSIDE the component.
+		*
+		* The card unmounts its whole body when collapsed (`WorkBuddyCard.tsx:832`
+		* renders it only while `open`), and again whenever a poll briefly leaves the
+		* region unsigned-in. Component state therefore lost the entire log on every
+		* collapse, and — because the rotation bookkeeping reset with it — wrote a
+		* PHANTOM "switched from — to X" record on the next open. Holding both here
+		* keeps the history across remounts and across tab switches.
+		*/
+		const logStore = /* @__PURE__ */ new Map();
+		const rotationMemory = /* @__PURE__ */ new Map();
+		/**
+		* Whether two id sets are equal, ignoring order.
+		*
+		* The membership compare must not depend on click order: re-selecting the same
+		* accounts in a different sequence is not an edit, and treating it as one would
+		* light up "unsaved changes" for a no-op.
+		*/
+		function sameIds(left, right) {
+			if (left.length !== right.length) return false;
+			const wanted = new Set(right);
+			return left.every((id) => wanted.has(id));
+		}
+		/** Whether a probe outcome means the model answered. */
+		function outcomeOk(outcome) {
+			return outcome === "ok";
+		}
+		/** A short, localizable label for one probe outcome. */
+		function outcomeText(t, outcome) {
+			switch (outcome) {
+				case "ok": return t("row.probeOk");
+				case "rate-limited": return t("row.poolExcludedRateLimited");
+				case "out-of-credit": return t("row.poolExcludedOutOfCredit");
+				case "credential-rejected": return t("row.probeCredentialRejected");
+				case "not-found": return t("row.probeNotFound");
+				case "unavailable": return t("row.probeUnavailable");
+				default: return t("row.probeFailed");
+			}
+		}
+		function formatNumber$1(value) {
+			return new Intl.NumberFormat(void 0, { maximumFractionDigits: 0 }).format(value);
+		}
+		/**
+		* `MM/DD, HH:mm` on a 24-hour clock.
+		*
+		* `hourCycle: 'h23'` is REQUIRED, not decorative: without it `Intl` follows the
+		* browser locale's preference, and en-US renders `09/30, 01:23 PM`. A wall-clock
+		* glued to "AM/PM" reads as 12-hour no matter what the surrounding UI assumes,
+		* and it is the one thing a Chinese user cannot scan past — the card otherwise
+		* speaks 24-hour everywhere (see `formatClock`).
+		*
+		* `h23` rather than `hour12: false`, because the latter maps to `h24` in some
+		* engines and would print midnight as `24:00`. `h23` pins 00–23 exactly, which
+		* is also the cycle DSH's own timestamps use.
+		*/
+		function formatShort(value) {
+			return new Intl.DateTimeFormat(void 0, {
+				month: "2-digit",
+				day: "2-digit",
+				hour: "2-digit",
+				minute: "2-digit",
+				hourCycle: "h23"
+			}).format(new Date(value));
+		}
+		function formatClock(value) {
+			return new Intl.DateTimeFormat(void 0, {
+				hour: "2-digit",
+				minute: "2-digit",
+				second: "2-digit",
+				hourCycle: "h23"
+			}).format(new Date(value));
+		}
+		/** A dot colour for one account's state. */
+		function stateColor(account) {
+			if (account.excludedBy !== void 0) return account.excludedBy === "rate-limited" || account.excludedBy === "unavailable" ? "var(--dsw-alias-state-warn-primary, #f59e0b)" : "var(--dsw-alias-state-error-primary, #ef4444)";
+			if (account.probe === void 0) return "var(--dsw-alias-label-dimmed, #9aa0a6)";
+			return outcomeOk(account.probe.outcome) ? "var(--dsw-alias-state-success-primary, #22a06b)" : "var(--dsw-alias-state-warn-primary, #f59e0b)";
+		}
+		/** The exclusion label for one account, or undefined when it is usable. */
+		function exclusionText(t, account) {
+			switch (account.excludedBy) {
+				case "rate-limited": return t("row.poolExcludedRateLimited");
+				case "out-of-credit": return t("row.poolExcludedOutOfCredit");
+				case "credential-rejected": return t("row.poolExcludedRejected");
+				case "not-found": return t("row.probeNotFound");
+				case "unavailable": return t("row.probeUnavailable");
+				case "failed": return t("row.probeFailed");
+				case "unusable": return t("row.poolExcludedUnusable");
+				default: return;
+			}
+		}
+		/**
+		* The pool section.
+		*
+		* Renders nothing when the Host reports no pool state at all: an older Host
+		* built without this feature should show an unmodified card, not an empty
+		* section implying the feature exists.
+		*/
+		function AccountPool(props) {
+			const { t, region, pool, settingsScope, siblingBusy, onBusyChange, onSaved, onRefresh, onRotationChange } = props;
+			const [draft, setDraft] = (0, react.useState)(null);
+			const [saving, setSaving] = (0, react.useState)(false);
+			const [saveError, setSaveError] = (0, react.useState)(void 0);
+			const [busy, setBusy] = (0, react.useState)(void 0);
+			const [actionError, setActionError] = (0, react.useState)(void 0);
+			const [log, setLog] = (0, react.useState)(() => logStore.get(region) ?? []);
+			(0, react.useEffect)(() => {
+				setLog(logStore.get(region) ?? []);
+				setIntervalText(void 0);
+			}, [region]);
+			const [draftRegion, setDraftRegion] = (0, react.useState)(void 0);
+			/**
+			* The interval field's raw text while it is being typed.
+			*
+			* `undefined` means "not editing" and the control renders the committed
+			* number. Keeping the in-progress string here is what makes the field
+			* typeable: clamping on every keystroke and writing the result straight back
+			* into the controlled `value` turned `120` into `520` and made an empty field
+			* snap to `5`. See `parseIntervalInput`.
+			*/
+			const [intervalText, setIntervalText] = (0, react.useState)(void 0);
+			const mounted = (0, react.useRef)(true);
+			(0, react.useEffect)(() => {
+				mounted.current = true;
+				return () => {
+					mounted.current = false;
+				};
+			}, []);
+			const saved = {
+				enabled: pool?.enabled ?? false,
+				rotateByCredits: pool?.rotateByCredits ?? false,
+				autoTestIntervalMinutes: pool?.autoTestIntervalMinutes ?? 30,
+				targetModelId: pool?.targetModelId || pool?.staleTargetModelId || "",
+				memberAccountIds: pool?.memberAccountIds ?? []
+			};
+			const active = draftRegion === region && draft !== null ? draft : saved;
+			const dirty = draftRegion === region && draft !== null && (draft.enabled !== saved.enabled || draft.rotateByCredits !== saved.rotateByCredits || draft.autoTestIntervalMinutes !== saved.autoTestIntervalMinutes || draft.targetModelId !== saved.targetModelId || !sameIds(draft.memberAccountIds, saved.memberAccountIds));
+			const current = pool?.accounts.find((account) => account.current);
+			/**
+			* Membership that actually resolves to a local sign-in — what a batch runs on.
+			*
+			* The HOST computes this and sends it, so the card cannot drift from the
+			* batch's real behaviour. Counting the raw saved list is what let the UI
+			* claim "已选 1 / 共 1" and enable both buttons while the batch ran on ZERO
+			* accounts and reported success.
+			*
+			* Derived locally as a FALLBACK for the case where the user has edited the
+			* draft (the Host's answer describes the SAVED state) or an older Host omits
+			* the field.
+			*/
+			const listedIds = new Set((pool?.accounts ?? []).map((account) => account.accountId));
+			const effectiveMembers = effectiveMemberIds({
+				savedEffective: pool?.effectiveMemberAccountIds ?? [],
+				draftMembers: active.memberAccountIds,
+				listedIds,
+				dirty
+			});
+			/** Saved ids with no matching sign-in; surfaced rather than silently ignored. */
+			const ghostMembers = ghostMemberIds(active.memberAccountIds, listedIds);
+			/**
+			* Pool MEMBERS that can serve right now.
+			*
+			* Judged over members only. Using the whole account table made the "no usable
+			* account" warning unreachable: unchecked rows are listed for the user to opt
+			* into and never carry `excludedBy`, so any unchecked sign-in kept the count
+			* above zero — exactly when every member was limited and the explanation was
+			* most needed.
+			*/
+			const usableMemberSet = new Set(usableMemberIds(pool?.accounts ?? [], effectiveMembers, active.memberAccountIds));
+			const usable = (pool?.accounts ?? []).filter((account) => usableMemberSet.has(account.accountId));
+			/**
+			* Whether rotation currently owns this region's choice — read from the
+			* COMMITTED preferences, not the draft.
+			*
+			* The distinction is the whole point. The Host decides who is billed from the
+			* saved config, so a draft-based lock let one click of "turn off rotation"
+			* re-enable the manual dropdown and hide the conflict notice while the Host
+			* kept rotating — the user then picked an account, the card showed it as
+			* current, and a different account was billed. That is exactly the failure
+			* the lock exists to prevent.
+			*
+			* Reading the committed value means the dropdown stays disabled until the
+			* change is SAVED, which is honest: until then the Host really is still
+			* rotating. The conflict notice says so and offers to save.
+			*/
+			const { locked: rotationLocked, unlockPending: rotationUnlockPending } = rotationLockState(saved, active);
+			const canEditPool = settingsScope !== void 0;
+			(0, react.useEffect)(() => {
+				onRotationChange?.(rotationLocked);
+				return () => {
+					onRotationChange?.(false);
+				};
+			}, [onRotationChange, rotationLocked]);
+			(0, react.useEffect)(() => {
+				onBusyChange?.(saving);
+				return () => {
+					onBusyChange?.(false);
+				};
+			}, [onBusyChange, saving]);
+			const appendLog = (0, react.useCallback)((text, tone) => {
+				setLog((previous) => {
+					const next = [{
+						atMs: Date.now(),
+						text,
+						tone
+					}, ...previous].slice(0, LOG_LIMIT);
+					logStore.set(region, next);
+					return next;
+				});
+			}, [region]);
+			/**
+			* Record a rotation the HOST performed.
+			*
+			* Rotation can happen on a timer with no card interaction, so the browser
+			* cannot infer it — the Host reports which account it moved to and this logs
+			* the transition. Without it "every switch is recorded" was a promise the UI
+			* had no way to keep.
+			*/
+			/**
+			* Record rotation transitions the HOST performed.
+			*
+			* Rotation can happen on a timer with no card interaction, so the browser
+			* cannot infer it — the Host reports which account it moved to and this logs
+			* the change.
+			*
+			* Three defects are fixed here, all from keeping one `useRef` for a value
+			* that is per-region and long-lived:
+			*
+			*   1. **No phantom first record.** The ref used to start `undefined`, so the
+			*      first rotation the card ever SAW was reported as a fresh switch ("from
+			*      — to X") even when it had happened long before. The first observation
+			*      now PRIMES the ref instead of logging.
+			*   2. **Per-region state.** The card keeps ONE component instance across
+			*      tabs and only swaps the `region` prop, so a shared ref explained one
+			*      region's rotation with another region's account list — producing
+			*      records for switches that never happened. State is keyed by region.
+			*   3. **The stop event is logged.** Rotation ending (`undefined`) used to
+			*      return early AND leave the ref set, so "rotation stopped, back to your
+			*      own account" never appeared, and rotating to the SAME account again
+			*      was silently skipped.
+			*/
+			const rotatedTo = pool?.rotatedToAccountId;
+			(0, react.useEffect)(() => {
+				const memory = rotationMemory.get(region) ?? {
+					last: void 0,
+					primed: false
+				};
+				const previous = memory.last;
+				if (!memory.primed) {
+					rotationMemory.set(region, {
+						last: rotatedTo,
+						primed: true
+					});
+					return;
+				}
+				if (rotatedTo === previous) return;
+				if (rotatedTo === void 0) {
+					rotationMemory.set(region, {
+						last: void 0,
+						primed: true
+					});
+					if (previous !== void 0) appendLog(t("row.poolLogRotationStopped", { from: nameOf(previous, pool) || t("row.accountUnnamed") }), "info");
+					return;
+				}
+				rotationMemory.set(region, {
+					last: rotatedTo,
+					primed: true
+				});
+				appendLog(t("row.poolLogRotated", {
+					from: previous === void 0 ? "—" : nameOf(previous, pool) || t("row.accountUnnamed"),
+					to: nameOf(rotatedTo, pool) || t("row.accountUnnamed")
+				}), "info");
+			}, [
+				appendLog,
+				pool,
+				region,
+				rotatedTo,
+				t
+			]);
+			/**
+			* The latest saved preferences, for callbacks that must not capture a stale
+			* copy.
+			*
+			* `saved` is rebuilt on every render, so putting it in a `useCallback` dep
+			* list would rebuild the callback every render (making the memo pointless),
+			* while listing individual fields by hand is exactly what caused the
+			* data-loss defect this ref fixes: a field added later
+			* (`memberAccountIds`) was missing from the list, so the callback kept a
+			* stale base and checking one account silently dropped another.
+			*
+			* A ref gives both properties at once — a STABLE callback identity and a
+			* base read at call time. It is synced in a LAYOUT effect, which flushes
+			* synchronously after commit and BEFORE the browser paints: a user event
+			* cannot be processed before a frame is painted, so by the time any click
+			* reaches `editDraft` the ref is current. (A plain `useEffect` would leave a
+			* window between paint and its flush; a render-phase write would be unsafe
+			* under concurrent rendering, where a discarded pass could leave the ref
+			* holding values from a tree that never committed.)
+			*
+			* Seeded with the initial value so the very first interaction, before any
+			* effect has run, still reads real preferences.
+			*/
+			const savedRef = (0, react.useRef)(saved);
+			(0, react.useLayoutEffect)(() => {
+				savedRef.current = saved;
+			});
+			/** Read by `editDraft` so it can refuse edits mid-save without rebuilding. */
+			const savingRef = (0, react.useRef)(saving);
+			(0, react.useLayoutEffect)(() => {
+				savingRef.current = saving;
+			});
+			const editDraft = (0, react.useCallback)((edit) => {
+				if (savingRef.current) return;
+				setDraftRegion(region);
+				setDraft((previous) => {
+					return edit(draftBaseFor(previous, draftRegion, region, savedRef.current));
+				});
+			}, [draftRegion, region]);
+			const discard = (0, react.useCallback)(() => {
+				setDraft(null);
+				setDraftRegion(void 0);
+				setIntervalText(void 0);
+				setSaveError(void 0);
+			}, []);
+			/** Save the four preferences through the plugin's VERIFIED write path. */
+			const save = (0, react.useCallback)(async () => {
+				if (settingsScope === void 0 || !dirty || draft === null) return;
+				setSaving(true);
+				setSaveError(void 0);
+				let committed = false;
+				try {
+					await writePoolPreferences(settingsScope, region, draft);
+					if (await onSaved?.() === false) {
+						if (mounted.current) setSaveError(t("row.poolSavedStaleRefresh"));
+						return;
+					}
+					committed = true;
+				} catch (error) {
+					if (mounted.current) setSaveError(error instanceof Error ? error.message : t("row.requestFailed"));
+				} finally {
+					if (committed) discard();
+					if (mounted.current) setSaving(false);
+				}
+			}, [
+				dirty,
+				discard,
+				draft,
+				onSaved,
+				region,
+				settingsScope,
+				t
+			]);
+			/** Check or uncheck one account in this pool. */
+			const toggleMember = (0, react.useCallback)((accountId, next) => {
+				editDraft((current) => {
+					const set = new Set(current.memberAccountIds);
+					if (next) set.add(accountId);
+					else set.delete(accountId);
+					return {
+						...current,
+						memberAccountIds: [...set]
+					};
+				});
+			}, [editDraft]);
+			/** Check every listed account, or none of them. */
+			const selectAll = (0, react.useCallback)((next) => {
+				editDraft((current) => ({
+					...current,
+					memberAccountIds: next ? (pool?.accounts ?? []).map((account) => account.accountId) : []
+				}));
+			}, [editDraft, pool]);
+			/**
+			* The interval control's two halves, kept apart so the field is typeable.
+			*
+			* `onIntervalInput` records what the user typed and only folds a VALID value
+			* into the draft; `onIntervalCommit` (blur / Enter) forces the text back to
+			* the committed number, clamping an out-of-range or non-numeric entry exactly
+			* once, after the user is done. Committing on every keystroke is what made
+			* `120` land as `520`.
+			*/
+			const onIntervalInput = (0, react.useCallback)((raw) => {
+				const { text, commit } = intervalEditOnInput(raw);
+				setIntervalText(text);
+				if (commit === void 0) return;
+				editDraft((current) => ({
+					...current,
+					autoTestIntervalMinutes: commit
+				}));
+			}, [editDraft]);
+			const onIntervalCommit = (0, react.useCallback)(() => {
+				setIntervalText(void 0);
+			}, []);
+			/** Run one batch action against the Host. */
+			const runAction = (0, react.useCallback)(async (action) => {
+				setBusy(action);
+				setActionError(void 0);
+				const memberCount = announcedBatchCount({
+					savedEffective: pool?.effectiveMemberAccountIds,
+					savedMembers: pool?.memberAccountIds ?? []
+				});
+				appendLog(action === "checkin" ? t("row.poolLogCheckinStart", { count: memberCount }) : t("row.poolLogTestStart", {
+					count: memberCount,
+					model: pool?.targetModelId ?? ""
+				}), "info");
+				try {
+					const response = await fetch(withWorkBuddyRegionAndAction(WORKBUDDY_POOL_PATH, region, action), {
+						method: "POST",
+						headers: { accept: "application/json" },
+						credentials: "same-origin"
+					});
+					const body = await response.json().catch(() => void 0);
+					if (!response.ok) throw new Error(poolFailureText(t, {
+						status: response.status,
+						reason: body?.reason,
+						error: body?.error
+					}));
+					if (!mounted.current) return;
+					if (action === "checkin") {
+						for (const row of body?.rows ?? []) if (row.status === "claimed") appendLog(t("row.poolLogCheckinClaimed", {
+							accountName: row.accountName === "" ? t("row.accountUnnamed") : row.accountName,
+							credit: String(row.credit ?? 0)
+						}), "ok");
+						else if (row.status === "already") appendLog(t("row.poolLogCheckinAlready", { accountName: row.accountName === "" ? t("row.accountUnnamed") : row.accountName }), "info");
+						else appendLog(t("row.poolLogCheckinFailed", {
+							accountName: row.accountName === "" ? t("row.accountUnnamed") : row.accountName,
+							message: row.message ?? t("row.requestFailed")
+						}), "error");
+						appendLog(t("row.poolLogCheckinDone"), "ok");
+					} else {
+						for (const row of body?.rows ?? []) {
+							const outcome = row?.result?.outcome;
+							if (outcome === void 0) {
+								appendLog(t("row.poolLogTestRowMalformed", { accountName: row?.accountName === "" || row?.accountName === void 0 ? t("row.accountUnnamed") : row.accountName }), "warn");
+								continue;
+							}
+							appendLog(t("row.poolLogTestRow", {
+								accountName: row.accountName === "" ? t("row.accountUnnamed") : row.accountName,
+								outcome: outcomeText(t, outcome)
+							}), outcomeOk(outcome) ? "ok" : "warn");
+						}
+						appendLog(t("row.poolLogTestDone"), "ok");
+					}
+					onRefresh?.();
+				} catch (error) {
+					const message = error instanceof Error ? error.message : t("row.requestFailed");
+					if (mounted.current) {
+						setActionError(message);
+						appendLog(t("row.poolLogBatchFailed", { message }), "error");
+					}
+				} finally {
+					if (mounted.current) setBusy(void 0);
+				}
+			}, [
+				appendLog,
+				onRefresh,
+				pool,
+				region,
+				t
+			]);
+			if (pool === void 0) return null;
+			/**
+			* Where the target model came from.
+			*
+			* Rendered under the buttons. This was computed and then never used, so the
+			* card never explained its own target — which is the entire reason
+			* `targetModelSource` is sent by the Host.
+			*/
+			const targetLabel = pool.targetModelSource === "preferred" ? t("row.poolTargetPreferred", { model: pool.targetModelId ?? "" }) : pool.targetModelSource === "free" ? t("row.poolTargetFree", { model: pool.targetModelId ?? "" }) : pool.targetModelSource === "stale" ? t("row.poolTargetStale", { model: pool.staleTargetModelId ?? "" }) : t("row.poolTargetNone");
+			return (0, react.createElement)("section", { className: "dsm-workbuddy-pool" }, (0, react.createElement)("div", { className: "dsm-workbuddy-pool-head" }, (0, react.createElement)("div", null, (0, react.createElement)("h3", { className: "dsm-workbuddy-pool-title" }, t("row.poolTitle")), (0, react.createElement)("p", { className: "dsm-workbuddy-pool-summary" }, t("row.poolSummary", {
+				count: effectiveMembers.length,
+				model: pool.targetModelId ?? (pool.targetModelSource === "stale" ? t("row.poolTargetStaleShort") : pool.targetModelSource === "none" ? t("row.poolTargetNoneShort") : t("row.poolTargetAuto"))
+			}))), rotationLocked && current !== void 0 ? (0, react.createElement)("span", { className: "dsm-workbuddy-pool-badge" }, t("row.poolRotating")) : null), (0, react.createElement)("div", { className: "dsm-workbuddy-pool-actions" }, (0, react.createElement)("button", {
+				type: "button",
+				className: "dsm-btn dsm-btn-primary",
+				disabled: busy !== void 0 || !active.enabled || effectiveMembers.length === 0,
+				onClick: () => {
+					runAction("checkin");
+				}
+			}, busy === "checkin" ? t("row.poolCheckingIn") : t("row.poolCheckinAll")), (0, react.createElement)("button", {
+				type: "button",
+				className: "dsm-btn dsm-btn-outline",
+				disabled: busy !== void 0 || !active.enabled || effectiveMembers.length === 0 || pool.targetModelSource === "none" || pool.targetModelSource === "stale",
+				title: pool.targetModelSource === "none" ? t("row.poolTargetNone") : pool.targetModelSource === "stale" ? t("row.poolTargetStale", { model: pool.staleTargetModelId ?? "" }) : void 0,
+				onClick: () => {
+					runAction("test");
+				}
+			}, busy === "test" ? t("row.poolTesting") : t("row.poolTestAll")), busy === void 0 ? null : (0, react.createElement)("span", { className: "dsm-workbuddy-pool-hint" }, t("row.poolBusyHint"))), (0, react.createElement)("p", { className: "dsm-workbuddy-pool-note" }, targetLabel), !active.enabled ? (0, react.createElement)("p", { className: "dsm-workbuddy-pool-note" }, t("row.poolEnabledHint")) : null, rotationLocked && usable.length === 0 ? (0, react.createElement)("p", {
+				className: "dsm-workbuddy-pool-warn",
+				role: "status"
+			}, `${t("row.poolNoCandidate")} ${t("row.poolNoCandidateHint")}`) : null, (0, react.createElement)("div", { className: "dsm-workbuddy-pool-members" }, (0, react.createElement)("div", { className: "dsm-workbuddy-pool-members-head" }, (0, react.createElement)("div", null, (0, react.createElement)("h4", { className: "dsm-workbuddy-pool-members-title" }, t("row.poolMembersTitle")), (0, react.createElement)("p", { className: "dsm-workbuddy-pool-note" }, t("row.poolMembersHint"))), (0, react.createElement)("div", { className: "dsm-workbuddy-pool-members-actions" }, (0, react.createElement)("span", { className: "dsm-workbuddy-pool-hint" }, t("row.poolSelectedCount", {
+				count: effectiveMembers.length,
+				total: pool.accounts.length
+			})), (0, react.createElement)("button", {
+				type: "button",
+				className: "dsm-btn dsm-btn-outline dsm-workbuddy-pool-small-btn",
+				disabled: pool.accounts.length === 0 || !canEditPool,
+				onClick: () => selectAll(true)
+			}, t("row.poolSelectAll")), (0, react.createElement)("button", {
+				type: "button",
+				className: "dsm-btn dsm-btn-outline dsm-workbuddy-pool-small-btn",
+				disabled: effectiveMembers.length === 0 || !canEditPool,
+				onClick: () => selectAll(false)
+			}, t("row.poolSelectNone")))), (0, react.createElement)("div", { className: "dsm-workbuddy-pool-table" }, (0, react.createElement)("div", { className: "dsm-workbuddy-pool-row dsm-workbuddy-pool-row-head" }, (0, react.createElement)("span", null, t("row.poolColumnAccount")), (0, react.createElement)("span", null, t("row.poolColumnCredits")), (0, react.createElement)("span", null, t("row.poolColumnProbe")), (0, react.createElement)("span", null, t("row.poolColumnCheckin"))), ...pool.accounts.map((account) => renderAccountRow({
+				t,
+				account,
+				checked: active.memberAccountIds.includes(account.accountId),
+				canEdit: canEditPool,
+				onToggle: (next) => toggleMember(account.accountId, next)
+			}))), effectiveMembers.length === 0 ? (0, react.createElement)("p", {
+				className: "dsm-workbuddy-pool-warn",
+				role: "status"
+			}, `${t("row.poolNoneSelected")} ${t("row.poolNoneSelectedHint")}`) : null, ghostMembers.length === 0 ? null : (0, react.createElement)("p", {
+				className: "dsm-workbuddy-pool-warn",
+				role: "status"
+			}, t("row.poolGhostMembers", { count: ghostMembers.length })), dirty && !sameIds(active.memberAccountIds, saved.memberAccountIds) ? (0, react.createElement)("p", { className: "dsm-workbuddy-pool-dirty" }, t("row.poolUnsavedMembers")) : null), pool.targetModelSource === "none" ? (0, react.createElement)("p", {
+				className: "dsm-workbuddy-pool-warn",
+				role: "status"
+			}, `${t("row.poolTargetNone")} ${t("row.poolTargetNoneHint")}`) : null, pool.targetModelSource === "stale" ? (0, react.createElement)("div", { className: "dsm-workbuddy-pool-conflict" }, (0, react.createElement)("span", { className: "dsm-workbuddy-pool-conflict-main" }, (0, react.createElement)("b", null, t("row.poolTargetStale", { model: pool.staleTargetModelId ?? "" })), (0, react.createElement)("span", null, t("row.poolTargetStaleHint"))), (0, react.createElement)("button", {
+				type: "button",
+				className: "dsm-btn dsm-btn-outline",
+				disabled: !canEditPool,
+				onClick: () => {
+					editDraft((current) => ({
+						...current,
+						targetModelId: ""
+					}));
+				}
+			}, t("row.poolTargetStaleClear"))) : null, actionError === void 0 ? null : (0, react.createElement)("p", {
+				className: "dsm-workbuddy-pool-error",
+				role: "alert"
+			}, actionError), renderSettings({
+				t,
+				pool,
+				active,
+				dirty,
+				saving,
+				siblingBusy: siblingBusy === true,
+				rotationLocked,
+				rotationUnlockPending,
+				saveError,
+				settingsScope,
+				intervalText,
+				onIntervalInput,
+				onIntervalCommit,
+				onEdit: editDraft,
+				onSave: () => {
+					save();
+				},
+				onDiscard: discard,
+				onUnlock: () => {
+					editDraft((current) => ({
+						...current,
+						rotateByCredits: false
+					}));
+				},
+				appendLog
+			}), (0, react.createElement)("p", { className: "dsm-workbuddy-pool-note" }, t("row.poolRegionNote")), renderLog({
+				t,
+				log,
+				busy: busy !== void 0,
+				onClear: () => {
+					logStore.set(region, []);
+					setLog([]);
+				}
+			}));
+		}
+		/** An account's display name by id, or undefined when it is not listed. */
+		function nameOf(accountId, pool) {
+			const account = pool?.accounts.find((entry) => entry.accountId === accountId);
+			return account === void 0 ? void 0 : account.accountName;
+		}
+		/** One account's row. */
+		function renderAccountRow(input) {
+			const { t, account, checked, canEdit, onToggle } = input;
+			const name = account.accountName === "" ? t("row.accountUnnamed") : account.accountName;
+			const excluded = exclusionText(t, account);
+			const probe = account.probe;
+			const probeLine = probe === void 0 ? t("row.poolNeverTested") : probe.retryAtMs !== void 0 ? `${outcomeText(t, probe.outcome)} · ${t("row.poolRetryAt", { at: formatShort(probe.retryAtMs) })}` : probe.outcome === "rate-limited" || probe.outcome === "out-of-credit" ? `${outcomeText(t, probe.outcome)} · ${t("row.poolRetryUnknown")}` : outcomeText(t, probe.outcome);
+			return (0, react.createElement)("div", {
+				className: `dsm-workbuddy-pool-row${account.current ? " dsm-workbuddy-pool-row-current" : ""}`,
+				key: account.accountId
+			}, (0, react.createElement)("span", { className: "dsm-workbuddy-pool-account" }, (0, react.createElement)("label", { className: "dsm-workbuddy-pool-check" }, (0, react.createElement)("input", {
+				type: "checkbox",
+				checked,
+				disabled: !canEdit,
+				"aria-label": t("row.poolSelectAria", { accountName: name }),
+				onChange: (event) => onToggle(event.currentTarget.checked)
+			})), (0, react.createElement)("span", {
+				className: "dsm-workbuddy-usage-dot",
+				style: { background: stateColor(account) }
+			}), (0, react.createElement)("span", { className: "dsm-workbuddy-pool-account-name" }, (0, react.createElement)("b", null, name), (0, react.createElement)("span", { className: checked ? "dsm-workbuddy-pool-member" : "dsm-workbuddy-pool-not-member" }, checked ? t("row.poolMember") : t("row.poolNotMember")), excluded === void 0 ? probe === void 0 ? null : (0, react.createElement)("span", null, t("row.poolTestedAt", { at: formatShort(probe.atMs) })) : (0, react.createElement)("span", { className: "dsm-workbuddy-pool-excluded" }, excluded))), (0, react.createElement)("span", { className: "dsm-workbuddy-pool-credits" }, account.credits === void 0 ? (0, react.createElement)("span", null, "—") : (0, react.createElement)("b", null, formatNumber$1(account.credits)), account.expiringSoon !== void 0 && account.expiringSoon > 0 ? (0, react.createElement)("span", { className: "dsm-workbuddy-pool-soon" }, t("row.poolCreditSoon", { count: formatNumber$1(account.expiringSoon) })) : account.nearestExpiryMs === void 0 ? null : (0, react.createElement)("span", { className: "dsm-workbuddy-pool-soon-plain" }, t("row.poolCreditNearest", { at: formatShort(account.nearestExpiryMs) }))), (0, react.createElement)("span", { className: "dsm-workbuddy-pool-probe" }, probeLine), (0, react.createElement)("span", { className: "dsm-workbuddy-pool-checkin" }, account.checkedInToday === void 0 ? (0, react.createElement)("span", {
+				className: "dsm-workbuddy-pool-unknown",
+				title: t("row.poolNeverTested")
+			}, t("row.poolCheckinUnknown")) : account.checkedInToday ? (0, react.createElement)("span", { className: "dsm-workbuddy-pool-checked" }, t("row.poolCheckedIn")) : t("row.poolNotCheckedIn")));
+		}
+		/** The preference editor plus its save/discard actions. */
+		function renderSettings(input) {
+			const { t, pool, active, dirty, saving, siblingBusy, rotationLocked, rotationUnlockPending, saveError, settingsScope, intervalText, onEdit, onSave, onDiscard, onUnlock, onIntervalInput, onIntervalCommit } = input;
+			const canEdit = settingsScope !== void 0;
+			const toggle = (label, hint, checked, onChange, disabled = false) => (0, react.createElement)("div", { className: "dsm-workbuddy-pool-set" }, (0, react.createElement)("span", { className: "dsm-workbuddy-pool-set-copy" }, (0, react.createElement)("b", null, label), (0, react.createElement)("span", null, hint)), (0, react.createElement)("span", { className: "dsm-workbuddy-pool-set-ctl" }, (0, react.createElement)("label", { className: "sw" }, (0, react.createElement)("input", {
+				type: "checkbox",
+				checked,
+				disabled: disabled || !canEdit,
+				onChange: (event) => onChange(event.currentTarget.checked)
+			}), (0, react.createElement)("span", { className: "sw-track" }))));
+			return (0, react.createElement)("div", { className: "dsm-workbuddy-pool-settings-wrap" }, (0, react.createElement)("div", { className: "dsm-workbuddy-pool-head" }, (0, react.createElement)("h3", { className: "dsm-workbuddy-pool-title" }, t("row.poolSettingsTitle")), dirty ? (0, react.createElement)("span", { className: "dsm-workbuddy-pool-dirty" }, t("row.poolDirty")) : null), (0, react.createElement)("p", { className: "dsm-workbuddy-pool-note" }, t("row.poolSettingsHint")), (0, react.createElement)("div", { className: "dsm-workbuddy-pool-settings" }, toggle(t("row.poolEnabled"), t("row.poolEnabledHint"), active.enabled, (next) => onEdit((current) => ({
+				...current,
+				enabled: next
+			}))), toggle(t("row.poolRotate"), t("row.poolRotateHint"), active.rotateByCredits, (next) => onEdit((current) => ({
+				...current,
+				rotateByCredits: next
+			})), !active.enabled), (0, react.createElement)("div", { className: "dsm-workbuddy-pool-set" }, (0, react.createElement)("span", { className: "dsm-workbuddy-pool-set-copy" }, (0, react.createElement)("b", null, t("row.poolInterval")), (0, react.createElement)("span", null, t("row.poolIntervalHint"))), (0, react.createElement)("span", { className: "dsm-workbuddy-pool-set-ctl" }, (0, react.createElement)("input", {
+				className: "dsm-workbuddy-pool-num",
+				type: "number",
+				min: 5,
+				max: POOL_INTERVAL_MAX,
+				step: 5,
+				value: intervalText ?? String(active.autoTestIntervalMinutes),
+				disabled: !active.enabled || !canEdit,
+				onChange: (event) => {
+					onIntervalInput(event.currentTarget.value);
+				},
+				onBlur: () => onIntervalCommit(),
+				onKeyDown: (event) => {
+					if (event.key === "Enter") onIntervalCommit();
+				}
+			}), (0, react.createElement)("span", { className: "dsm-workbuddy-pool-hint" }, t("row.poolIntervalUnit")))), (0, react.createElement)("div", { className: "dsm-workbuddy-pool-set" }, (0, react.createElement)("span", { className: "dsm-workbuddy-pool-set-copy" }, (0, react.createElement)("b", null, t("row.poolTargetLabel")), (0, react.createElement)("span", null, t("row.poolTargetHint"))), (0, react.createElement)("span", { className: "dsm-workbuddy-pool-set-ctl" }, (0, react.createElement)("select", {
+				className: "dsm-workbuddy-pool-select",
+				value: active.targetModelId,
+				disabled: !active.enabled || !canEdit,
+				onChange: (event) => {
+					const value = event.currentTarget.value;
+					onEdit((current) => ({
+						...current,
+						targetModelId: value
+					}));
+				}
+			}, (0, react.createElement)("option", { value: "" }, t("row.poolTargetAutoOption")), active.targetModelId !== "" && !(pool.catalog ?? []).some((m) => m.id === active.targetModelId) ? (0, react.createElement)("option", {
+				value: active.targetModelId,
+				disabled: true
+			}, t("row.poolTargetStaleOption", { model: active.targetModelId })) : null, ...(pool.catalog ?? []).map((model) => (0, react.createElement)("option", {
+				value: model.id,
+				key: model.id
+			}, model.creditMultiplier === void 0 ? model.name : `${model.name} (x${model.creditMultiplier.toFixed(2)})`)))))), (0, react.createElement)("div", { className: "dsm-workbuddy-pool-save-bar" }, (0, react.createElement)("button", {
+				type: "button",
+				className: "dsm-btn dsm-btn-primary",
+				disabled: !dirty || saving || siblingBusy || !canEdit,
+				onClick: onSave
+			}, saving ? t("row.poolSaving") : t("row.poolSaved")), (0, react.createElement)("button", {
+				type: "button",
+				className: "dsm-btn dsm-btn-outline",
+				disabled: !dirty || saving || siblingBusy,
+				onClick: onDiscard
+			}, t("row.poolDiscard")), (0, react.createElement)("span", { className: "dsm-workbuddy-pool-hint" }, dirty ? t("row.poolSaveDirty") : t("row.poolSaveIdle"))), saveError === void 0 ? null : (0, react.createElement)("p", {
+				className: "dsm-workbuddy-pool-error",
+				role: "alert"
+			}, t("row.poolSaveFailed", { message: saveError })), rotationLocked ? (0, react.createElement)("div", { className: "dsm-workbuddy-pool-conflict" }, (0, react.createElement)("span", { className: "dsm-workbuddy-pool-conflict-main" }, (0, react.createElement)("b", null, t("row.poolManualLocked")), (0, react.createElement)("span", null, t("row.poolManualLockedHint"))), rotationUnlockPending ? (0, react.createElement)("span", { className: "dsm-workbuddy-pool-pending" }, t("row.poolUnlockPending")) : null, (0, react.createElement)("button", {
+				type: "button",
+				className: "dsm-btn dsm-btn-outline",
+				disabled: !canEdit || rotationUnlockPending,
+				onClick: onUnlock
+			}, rotationUnlockPending ? t("row.poolUnlockSaved") : t("row.poolManualUnlock"))) : null);
+		}
+		/** The activity log. */
+		function renderLog(input) {
+			const { t, log, busy, onClear } = input;
+			return (0, react.createElement)("div", { className: "dsm-workbuddy-pool-log" }, (0, react.createElement)("div", { className: "dsm-workbuddy-pool-log-head" }, (0, react.createElement)("span", null, t("row.poolLogTitle")), log.length === 0 ? null : (0, react.createElement)("button", {
+				type: "button",
+				className: "dsm-btn dsm-btn-outline dsm-workbuddy-pool-log-clear",
+				disabled: busy === true,
+				onClick: onClear
+			}, t("row.poolLogClear"))), log.length === 0 ? (0, react.createElement)("div", { className: "dsm-workbuddy-pool-log-empty" }, t("row.poolLogEmpty")) : (0, react.createElement)("div", { className: "dsm-workbuddy-pool-log-body" }, ...log.map((entry, index) => (0, react.createElement)("div", {
+				className: "dsm-workbuddy-pool-log-row",
+				key: `${entry.atMs}-${index}`
+			}, (0, react.createElement)("span", { className: "dsm-workbuddy-pool-log-time" }, formatClock(entry.atMs)), (0, react.createElement)("span", { className: `dsm-workbuddy-pool-log-text dsm-workbuddy-pool-log-${entry.tone}` }, entry.text)))));
+		}
 		//#endregion
 		//#region src/native-modality.ts
 		/**
@@ -618,6 +1660,86 @@ window.__ModuleLoader__.load({
 .dsm-workbuddy-usage-cheer-star{font-size:12px;line-height:1;display:inline-flex}
 .dsm-workbuddy-usage-cheer:hover{color:var(--dsw-alias-label-primary,#e6e6e6)}
 .dsm-workbuddy-usage-cheer:focus-visible{outline:2px solid var(--dsw-alias-brand-primary,#5686fe);outline-offset:2px}
+
+/* ---- Account pool ---- */
+.dsm-workbuddy-pool{display:flex;flex-direction:column;gap:12px;margin:0;padding:16px 0 4px;border-top:1px solid var(--dsw-alias-border-l2,#36373b)}
+.dsm-workbuddy-pool-head{display:flex;align-items:flex-start;justify-content:space-between;gap:12px;flex-wrap:wrap}
+.dsm-workbuddy-pool-title{margin:0;font-size:15px;font-weight:600;color:var(--dsw-alias-label-primary,#e6e6e6)}
+.dsm-workbuddy-pool-summary{margin:2px 0 0;font-size:12px;line-height:18px;color:var(--dsw-alias-label-tertiary,#999)}
+.dsm-workbuddy-pool-badge{flex:none;padding:2px 9px;border-radius:999px;font-size:12px;line-height:18px;font-weight:500;color:var(--dsw-alias-brand-primary,#5686fe);background:rgba(86,134,254,.12);border:1px solid rgba(86,134,254,.32)}
+.dsm-workbuddy-pool-actions{display:flex;gap:8px;flex-wrap:wrap;align-items:center}
+.dsm-workbuddy-pool-hint{font-size:12px;line-height:18px;color:var(--dsw-alias-label-tertiary,#999)}
+.dsm-workbuddy-pool-note{margin:0;font-size:12px;line-height:17px;color:var(--dsw-alias-label-tertiary,#999)}
+.dsm-workbuddy-pool-warn{margin:0;padding:9px 11px;border-radius:9px;font-size:12px;line-height:17px;color:var(--dsw-alias-state-warn-primary,#f59e0b);background:rgba(245,158,11,.09);border:1px solid rgba(245,158,11,.3)}
+.dsm-workbuddy-pool-error{margin:0;font-size:12px;line-height:17px;color:var(--dsw-alias-state-error-primary,#ef4444);white-space:pre-line}
+.dsm-workbuddy-pool-table{border:1px solid var(--dsw-alias-border-l2,#3a3d45);border-radius:12px;overflow:hidden;background:var(--dsw-alias-bg-layer-2,#24262c)}
+.dsm-workbuddy-pool-row{display:grid;grid-template-columns:1.6fr 1fr 1.3fr .9fr;gap:10px;align-items:center;padding:10px 14px;border-top:1px solid var(--dsw-alias-border-l1,#2c2d31);font-size:13px;color:var(--dsw-alias-label-secondary,#c6c9d0)}
+.dsm-workbuddy-pool-row:first-child{border-top:0}
+.dsm-workbuddy-pool-row-head{padding:8px 14px;background:var(--dsw-alias-bg-layer-3,#2a2c33);color:var(--dsw-alias-label-tertiary,#999);font-size:11px;font-weight:600;letter-spacing:.02em;text-transform:uppercase}
+.dsm-workbuddy-pool-row-current{background:rgba(86,134,254,.07)}
+.dsm-workbuddy-pool-account{display:flex;align-items:center;gap:8px;min-width:0}
+.dsm-workbuddy-pool-account-name{display:flex;flex-direction:column;gap:1px;min-width:0}
+.dsm-workbuddy-pool-account-name b{font-weight:500;color:var(--dsw-alias-label-primary,#e6e6e6);overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.dsm-workbuddy-pool-account-name span{font-size:11px;line-height:16px;color:var(--dsw-alias-label-tertiary,#999)}
+.dsm-workbuddy-pool-excluded{color:var(--dsw-alias-state-warn-primary,#f59e0b)}
+.dsm-workbuddy-pool-credits{display:flex;flex-direction:column;gap:1px;min-width:0;font-variant-numeric:tabular-nums}
+.dsm-workbuddy-pool-credits b{color:var(--dsw-alias-label-primary,#e6e6e6);font-weight:600}
+.dsm-workbuddy-pool-soon{font-size:11px;line-height:16px;color:var(--dsw-alias-state-warn-primary,#f59e0b)}
+.dsm-workbuddy-pool-soon-plain{font-size:11px;line-height:16px;color:var(--dsw-alias-label-tertiary,#999)}
+.dsm-workbuddy-pool-probe,.dsm-workbuddy-pool-checkin{font-size:12px;line-height:17px;color:var(--dsw-alias-label-tertiary,#999);min-width:0;overflow-wrap:anywhere}
+.dsm-workbuddy-pool-members{display:flex;flex-direction:column;gap:10px}
+.dsm-workbuddy-pool-members-head{display:flex;align-items:flex-start;justify-content:space-between;gap:12px;flex-wrap:wrap}
+.dsm-workbuddy-pool-members-title{margin:0 0 3px;font-size:13px;font-weight:600;color:var(--dsw-alias-label-primary,#e6e6e6)}
+.dsm-workbuddy-pool-members-actions{display:flex;align-items:center;gap:8px;flex-wrap:wrap}
+.dsm-workbuddy-pool-small-btn{padding:3px 10px;font-size:12px}
+.dsm-workbuddy-pool-check{display:inline-flex;align-items:center;flex:none;cursor:pointer}
+.dsm-workbuddy-pool-check input{margin:0;cursor:pointer;accent-color:var(--dsw-alias-brand-primary,#5686fe)}
+.dsm-workbuddy-pool-check input:disabled{cursor:default;opacity:.5}
+.dsm-workbuddy-pool-checked{color:var(--dsw-alias-state-success-primary,#22a06b)}
+.dsm-workbuddy-pool-unknown{color:var(--dsw-alias-label-dimmed,#9aa0a6)}
+.dsm-workbuddy-pool-member{color:var(--dsw-alias-brand-primary,#5686fe)}
+.dsm-workbuddy-pool-not-member{color:var(--dsw-alias-label-dimmed,#9aa0a6)}
+.dsm-workbuddy-pool-settings-wrap{display:flex;flex-direction:column;gap:10px}
+.dsm-workbuddy-pool-dirty{font-size:12px;line-height:18px;font-weight:500;color:var(--dsw-alias-state-warn-primary,#f59e0b)}
+.dsm-workbuddy-pool-settings{display:flex;flex-direction:column;gap:1px;border:1px solid var(--dsw-alias-border-l2,#3a3d45);border-radius:12px;overflow:hidden;background:var(--dsw-alias-bg-layer-2,#24262c)}
+.dsm-workbuddy-pool-set{display:flex;align-items:flex-start;justify-content:space-between;gap:16px;padding:12px 14px;border-top:1px solid var(--dsw-alias-border-l1,#2c2d31)}
+.dsm-workbuddy-pool-set:first-child{border-top:0}
+.dsm-workbuddy-pool-set-copy{display:flex;flex-direction:column;gap:3px;min-width:0;flex:1}
+.dsm-workbuddy-pool-set-copy b{font-size:13px;font-weight:500;color:var(--dsw-alias-label-primary,#e6e6e6)}
+.dsm-workbuddy-pool-set-copy span{font-size:12px;line-height:18px;color:var(--dsw-alias-label-tertiary,#999)}
+.dsm-workbuddy-pool-set-ctl{flex:none;display:flex;align-items:center;gap:8px}
+.dsm-workbuddy-pool-num{width:74px;padding:6px 10px;border:1px solid var(--dsw-alias-border-l2,#3a3d45);border-radius:8px;background:var(--dsw-alias-bg-layer-3,#2a2c33);color:var(--dsw-alias-label-primary,#e6e6e6);font:inherit;font-size:13px;text-align:center;font-variant-numeric:tabular-nums}
+.dsm-workbuddy-pool-select{max-width:260px;padding:6px 10px;border:1px solid var(--dsw-alias-border-l2,#3a3d45);border-radius:8px;background:var(--dsw-alias-bg-layer-3,#2a2c33);color:var(--dsw-alias-label-primary,#e6e6e6);font:inherit;font-size:13px;cursor:pointer}
+.dsm-workbuddy-pool-select:disabled,.dsm-workbuddy-pool-num:disabled{opacity:.5;cursor:default}
+.dsm-workbuddy-pool-save-bar{display:flex;align-items:center;gap:9px;flex-wrap:wrap}
+.dsm-workbuddy-pool-conflict{display:flex;align-items:flex-start;justify-content:space-between;gap:12px;flex-wrap:wrap;padding:11px 13px;border-radius:10px;background:rgba(245,158,11,.08);border:1px solid var(--dsw-alias-state-warn-primary,#f59e0b)}
+.dsm-workbuddy-pool-pending{flex:none;align-self:center;font-size:12px;line-height:17px;color:var(--dsw-alias-state-warn-primary,#f59e0b)}
+.dsm-workbuddy-pool-conflict-main{display:flex;flex-direction:column;gap:2px;min-width:0;flex:1}
+.dsm-workbuddy-pool-conflict-main b{font-size:12px;font-weight:600;color:var(--dsw-alias-state-warn-primary,#f59e0b)}
+.dsm-workbuddy-pool-conflict-main span{font-size:12px;line-height:17px;color:var(--dsw-alias-label-secondary,#c6c9d0)}
+.dsm-workbuddy-pool-log{border:1px solid var(--dsw-alias-border-l2,#3a3d45);border-radius:12px;overflow:hidden;background:var(--dsw-alias-bg-layer-2,#24262c)}
+.dsm-workbuddy-pool-log-head{display:flex;align-items:center;justify-content:space-between;padding:9px 14px;background:var(--dsw-alias-bg-layer-3,#2a2c33);border-bottom:1px solid var(--dsw-alias-border-l1,#2c2d31);font-size:12px;font-weight:600;color:var(--dsw-alias-label-secondary,#c6c9d0)}
+.dsm-workbuddy-pool-log-clear{padding:2px 10px;font-size:12px}
+.dsm-workbuddy-pool-log-body{max-height:186px;overflow-y:auto}
+.dsm-workbuddy-pool-log-row{display:flex;gap:10px;padding:7px 14px;border-top:1px solid var(--dsw-alias-border-l1,#2c2d31);font-size:12px;line-height:18px}
+.dsm-workbuddy-pool-log-row:first-child{border-top:0}
+.dsm-workbuddy-pool-log-time{flex:none;color:var(--dsw-alias-label-tertiary,#999);font-family:ui-monospace,SFMono-Regular,Menlo,monospace}
+.dsm-workbuddy-pool-log-text{min-width:0;overflow-wrap:anywhere}
+.dsm-workbuddy-pool-log-ok{color:var(--dsw-alias-state-success-primary,#22a06b)}
+.dsm-workbuddy-pool-log-warn{color:var(--dsw-alias-state-warn-primary,#f59e0b)}
+.dsm-workbuddy-pool-log-error{color:var(--dsw-alias-state-error-primary,#ef4444)}
+.dsm-workbuddy-pool-log-info{color:var(--dsw-alias-label-secondary,#c6c9d0)}
+.dsm-workbuddy-pool-log-empty{padding:14px;font-size:12px;color:var(--dsw-alias-label-tertiary,#999)}
+@media (max-width:760px){.dsm-workbuddy-pool-row{grid-template-columns:1fr 1fr;row-gap:6px}.dsm-workbuddy-pool-select{max-width:180px}}
+/* Pool switch, namespaced under .dsm-workbuddy-pool so it cannot collide with host styles. */
+.dsm-workbuddy-pool .sw{position:relative;display:inline-block;width:38px;height:22px;flex:none;cursor:pointer}
+.dsm-workbuddy-pool .sw input{position:absolute;opacity:0;width:0;height:0}
+.dsm-workbuddy-pool .sw-track{position:absolute;inset:0;border-radius:999px;background:var(--dsw-alias-border-l2,#3a3d45);transition:background .18s}
+.dsm-workbuddy-pool .sw-track::after{content:"";position:absolute;top:3px;left:3px;width:16px;height:16px;border-radius:50%;background:#fff;transition:transform .18s;box-shadow:0 1px 3px rgba(0,0,0,.3)}
+.dsm-workbuddy-pool .sw input:checked+.sw-track{background:var(--dsw-alias-brand-primary,#5686fe)}
+.dsm-workbuddy-pool .sw input:checked+.sw-track::after{transform:translateX(16px)}
+.dsm-workbuddy-pool .sw input:disabled+.sw-track{opacity:.4}
+.dsm-workbuddy-pool .sw input:disabled{cursor:default}
 `;
 		//#endregion
 		//#region src/client/searched-paths.ts
@@ -866,16 +1988,25 @@ window.__ModuleLoader__.load({
 				month: "2-digit",
 				day: "2-digit",
 				hour: "2-digit",
-				minute: "2-digit"
+				minute: "2-digit",
+				hourCycle: "h23"
 			}).format(new Date(value));
 		}
-		/** Compact package-date rendering with time, e.g. 08/25 14:44. */
+		/**
+		* Compact package-date rendering with time, e.g. `08/25 14:44`.
+		*
+		* `hourCycle: 'h23'` is what makes that example TRUE. Without it `Intl` defers
+		* to the browser locale, and en-US produced `08/25, 02:44 PM` — 12-hour, with a
+		* comma the template never asked for. `h23` (not `hour12: false`) keeps midnight
+		* at `00:00` instead of `24:00`, and matches DSH's own clock cycle.
+		*/
 		function formatDate(value) {
 			return new Intl.DateTimeFormat(void 0, {
 				month: "2-digit",
 				day: "2-digit",
 				hour: "2-digit",
-				minute: "2-digit"
+				minute: "2-digit",
+				hourCycle: "h23"
 			}).format(new Date(value));
 		}
 		function formatCapacity(value, unknown) {
@@ -970,6 +2101,22 @@ window.__ModuleLoader__.load({
 			/** Save failure surfaced next to the buttons; cleared by the next attempt. */
 			const [saveError, setSaveError] = (0, react.useState)(void 0);
 			const [switchingAccount, setSwitchingAccount] = (0, react.useState)(false);
+			/**
+			* Whether the account pool's rotation currently owns this region's choice.
+			*
+			* Reported up by the pool section. While true, the manual account dropdown is
+			* disabled: both would write the same slot, and letting them disagree is how
+			* the card ends up showing one account while another is billed. The pool
+			* shows the reason and an inline way to switch rotation off.
+			*/
+			const [poolRotationLocked, setPoolRotationLocked] = (0, react.useState)(false);
+			/**
+			* Whether the account pool's save is in flight. Both sections write into one
+			* region slot and the Host merges per-region, so two concurrent saves can
+			* interleave on a stale base and revert each other while both report success
+			* — the two save buttons are serialized to make that impossible.
+			*/
+			const [poolBusy, setPoolBusy] = (0, react.useState)(false);
 			/** A refused account write (silently unpersisted settings on a locked file). */
 			const [accountError, setAccountError] = (0, react.useState)(void 0);
 			const [checkingIn, setCheckingIn] = (0, react.useState)(false);
@@ -998,7 +2145,37 @@ window.__ModuleLoader__.load({
 			(0, react.useEffect)(() => settingsScope?.subscribe(() => {
 				setSettingsRevision((value) => value + 1);
 			}), [settingsScope]);
+			/**
+			* Per-region latest-wins guard for the usage fetch.
+			*
+			* Two refreshes can overlap — the 60s poll, a save, a batch action, the
+			* account re-scan — and they are plain `fetch`es with no ordering guarantee.
+			* Without a guard the SLOWER response wins, so a snapshot taken before a
+			* check-in could land after one taken after it and overwrite the newer
+			* credits. The guard makes "the last request started" the one that is applied,
+			* whatever order the responses arrive in.
+			*
+			* Keyed by region, not global: the card deliberately fetches BOTH regions at
+			* once (`for (const region of WORKBUDDY_REGIONS)` below), so a single shared
+			* counter would make each of those two calls cancel the other and leave one
+			* tab permanently stale.
+			*
+			* The rule itself is the tested `createLatestWins` factory, not a second
+			* implementation written here.
+			*
+			* `begin()` returns a probe that reports **stale**: `true` once a newer call
+			* has claimed the same region (see `src/account-pool.ts`). So the variable is
+			* named `stale` and the bail-out is `if (stale())` — the same polarity as the
+			* Host's rotation guard in `src/index.ts`. Naming it `fresh` and writing
+			* `if (!fresh())` inverts the poll: every response that is NOT superseded —
+			* i.e. every response in the single-fetch case — gets discarded, and the card
+			* renders its placeholder forever. That defect shipped once; the polarity is
+			* now pinned by a rendered assertion rather than by the spelling of the
+			* identifier.
+			*/
+			const usageGuard = (0, react.useRef)(createLatestWins());
 			const refreshUsage = (0, react.useCallback)(async (region, signal) => {
+				const stale = usageGuard.current.begin(region);
 				try {
 					const response = await fetch(withWorkBuddyRegion(WORKBUDDY_USAGE_PATH, region), {
 						headers: { accept: "application/json" },
@@ -1008,19 +2185,34 @@ window.__ModuleLoader__.load({
 					const value = await response.json().catch(() => void 0);
 					if (!response.ok) throw new Error(`HTTP ${response.status}`);
 					const usage = value;
+					if (stale()) return void 0;
 					if (mounted.current && signal?.aborted !== true) setStatusByRegion((prev) => ({
 						...prev,
 						[region]: usage
 					}));
 					return usage;
 				} catch (error) {
-					if (mounted.current && signal?.aborted !== true) setStatusByRegion((prev) => ({
-						...prev,
-						[region]: {
-							status: "error",
-							message: error instanceof Error ? error.message : t("row.requestFailed")
-						}
-					}));
+					if (stale()) return void 0;
+					if (mounted.current && signal?.aborted !== true) {
+						const message = error instanceof Error ? error.message : t("row.requestFailed");
+						setStatusByRegion((prev) => {
+							const previous = prev[region];
+							if (previous !== void 0 && previous.status === "signed-in") return {
+								...prev,
+								[region]: {
+									...previous,
+									refreshError: message
+								}
+							};
+							return {
+								...prev,
+								[region]: {
+									status: "error",
+									message
+								}
+							};
+						});
+					}
 					return;
 				}
 			}, [t]);
@@ -1203,6 +2395,7 @@ window.__ModuleLoader__.load({
 					if (mounted.current) setStatusByRegion((prev) => ({
 						...prev,
 						[activeRegion]: {
+							...prev[activeRegion],
 							status: "error",
 							message: error instanceof Error ? error.message : t("row.requestFailed")
 						}
@@ -1454,7 +2647,7 @@ window.__ModuleLoader__.load({
 											children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("input", {
 												type: "checkbox",
 												checked: regionOnState,
-												disabled: togglingRegion === region || !canWrite,
+												disabled: togglingRegion === region || !canWrite || saving || poolBusy,
 												"aria-label": t("row.tabSwitchAria", { region: region === "cn" ? t("row.tabCn") : t("row.tabGlobal") }),
 												onChange: (event) => {
 													toggleRegion(region, event.target.checked);
@@ -1518,7 +2711,7 @@ window.__ModuleLoader__.load({
 										children: /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("select", {
 											className: "dsm-workbuddy-usage-select",
 											value: status.accounts.find((account) => account.selected)?.id ?? "",
-											disabled: switchingAccount || !canWrite,
+											disabled: switchingAccount || !canWrite || poolRotationLocked,
 											onChange: (event) => {
 												switchAccount(event.currentTarget.value);
 											},
@@ -1640,6 +2833,11 @@ window.__ModuleLoader__.load({
 									className: "dsm-workbuddy-usage-error",
 									children: t("row.creditsError", { message: status.creditsError })
 								}),
+								status.refreshError === void 0 ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+									className: "dsm-workbuddy-usage-error",
+									role: "alert",
+									children: t("row.requestFailedHint", { message: status.refreshError })
+								}),
 								/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("section", {
 									className: "dsm-workbuddy-models",
 									"aria-label": t("row.modelsTitle"),
@@ -1801,13 +2999,13 @@ window.__ModuleLoader__.load({
 													children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
 														type: "button",
 														className: "dsm-btn dsm-btn-outline",
-														disabled: !dirty || saving,
+														disabled: !dirty || saving || poolBusy || togglingRegion !== void 0,
 														onClick: discardModels,
 														children: t("row.discard")
 													}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
 														type: "button",
 														className: "dsm-btn dsm-btn-primary",
-														disabled: !dirty || saving || activeEnabledIds.size === 0,
+														disabled: !dirty || saving || poolBusy || togglingRegion !== void 0 || activeEnabledIds.size === 0,
 														onClick: () => {
 															saveModels();
 														},
@@ -1817,6 +3015,19 @@ window.__ModuleLoader__.load({
 											]
 										})
 									]
+								}),
+								/* @__PURE__ */ (0, react_jsx_runtime.jsx)(AccountPool, {
+									t,
+									region: activeRegion,
+									...status.pool === void 0 ? {} : { pool: status.pool },
+									...settingsScope === void 0 ? {} : { settingsScope },
+									siblingBusy: saving || togglingRegion !== void 0,
+									onBusyChange: setPoolBusy,
+									onSaved: async () => await refreshUsage(activeRegion) !== void 0,
+									onRefresh: () => {
+										refreshUsage(activeRegion);
+									},
+									onRotationChange: setPoolRotationLocked
 								})
 							] }) : null,
 							status.status === "signed-out" ? /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
@@ -1883,6 +3094,15 @@ window.__ModuleLoader__.load({
 			"row.credentialRejectedRelogin": "No other local sign-in exists to switch to. Sign in again in the WorkBuddy desktop app.",
 			"row.credentialRejectedChoose": "Other local sign-ins exist but none of them answered the upstream just now. Try switching to one above; if none works, sign in again in the desktop app.",
 			"row.requestFailed": "Request failed",
+			"row.requestFailedHint": "Refresh failed — showing the last loaded data: {message}",
+			"row.poolErrUnavailable": "The account pool is not available in this build (or its batch route is missing). Restart the app; if it persists, the plugin needs reinstalling.",
+			"row.poolErrFailed": "The batch failed on the host side: {message}",
+			"row.poolErrHttp": "The batch was refused (HTTP {status}). Check the plugin is up to date and try again.",
+			"row.poolErrDisabled": "The account pool is switched off for this region. Turn it on and save before running a batch.",
+			"row.poolErrNoMembers": "No account is checked into this pool — the batch had nothing to run. Check at least one account and save.",
+			"row.poolErrNoLiveMembers": "Every account checked into this pool has lost its local sign-in, so the batch had nothing to run. Sign in again in the WorkBuddy desktop app, or save to drop them.",
+			"row.poolErrNoFreeModel": "This region has no zero-multiplier model to test with. Refresh the model catalog, or pick a target model yourself.",
+			"row.poolErrStaleModel": "The target model is no longer offered by this region. Pick another, or switch back to automatic.",
 			"row.creditsTotalLabel": "Total remaining credits",
 			"row.creditsMonthlyRemain": "Remaining {remain} / {size} · Refreshes {at}",
 			"row.checkinClaim": "Check in",
@@ -1938,7 +3158,98 @@ window.__ModuleLoader__.load({
 			"row.probeFailed": "✗ Test failed",
 			"row.probeFailedStatus": "✗ Test failed (HTTP {status})",
 			"row.probeError": "Could not run the test: {message}",
-			"row.cheer": "Star on GitHub"
+			"row.cheer": "Star on GitHub",
+			"row.poolTitle": "Account pool",
+			"row.poolSummary": "{count} account(s) in this region · target model {model}",
+			"row.poolNoCandidate": "No account in this pool can be used right now.",
+			"row.poolNoCandidateHint": "Every account is rate-limited, out of credits, rejected, unreachable, or in a state this build cannot use. Re-check the accounts, or sign in again in the desktop app.",
+			"row.poolRotating": "Auto-rotating",
+			"row.poolCheckinAll": "Check in all accounts",
+			"row.poolCheckingIn": "Checking in…",
+			"row.poolTestAll": "Test all accounts",
+			"row.poolTesting": "Testing…",
+			"row.poolBusyHint": "Running one account at a time…",
+			"row.poolTargetAuto": "Auto",
+			"row.poolTargetStaleShort": "target model unavailable",
+			"row.poolTargetNoneShort": "no free model",
+			"row.poolTargetFree": "Auto-picked free model: {model}",
+			"row.poolTargetPreferred": "Your chosen model: {model}",
+			"row.poolTargetNone": "This region has no zero-multiplier model yet.",
+			"row.poolTargetStale": "The target model you saved is no longer offered: {model}",
+			"row.poolTargetStaleHint": "The region's catalog changed and no longer lists this model, so testing is off rather than running against a model the upstream may not accept. Pick another target, or switch back to automatic.",
+			"row.poolTargetStaleClear": "Switch back to automatic",
+			"row.poolTargetStaleOption": "{model} (no longer offered)",
+			"row.poolTargetNoneHint": "The domestic catalog only reveals its multipliers after a model refresh. Rather than quietly spending credits on a paid model, testing stays off until one appears — refresh the models, or pick a target model yourself.",
+			"row.poolColumnAccount": "Account",
+			"row.poolColumnCredits": "Credits",
+			"row.poolColumnProbe": "Target model",
+			"row.poolColumnCheckin": "Check-in",
+			"row.poolNeverTested": "Not tested yet",
+			"row.poolTestedAt": "Tested {at}",
+			"row.poolCheckedIn": "Checked in",
+			"row.poolNotCheckedIn": "Not checked in",
+			"row.poolCheckinUnknown": "—",
+			"row.poolCreditSoon": "{count} expiring within 3 days",
+			"row.poolCreditNearest": "Nearest package expires {at}",
+			"row.poolExcludedRateLimited": "Rate limited",
+			"row.poolExcludedOutOfCredit": "Out of credits",
+			"row.poolExcludedRejected": "Rejected",
+			"row.poolExcludedUnusable": "Unusable",
+			"row.poolRetryAt": "Back after {at}",
+			"row.poolRetryUnknown": "The upstream gave no time for when this frees up",
+			"row.poolSettingsTitle": "Account pool settings",
+			"row.poolSettingsHint": "These four are preferences: they take effect when you save (same as the model list). Test results and rotation are written automatically and are not affected by this button.",
+			"row.poolEnabled": "Enable the account pool",
+			"row.poolEnabledHint": "While off, the plugin behaves exactly as before: it follows the account you selected and never reorders accounts.",
+			"row.poolRotate": "Rotate by credits",
+			"row.poolRotateHint": "Let the plugin pick the billing account by availability, then credits, then expiry (ties fall back to credential freshness and account id). Turning this on disables manual selection until you save; every switch is recorded.",
+			"row.poolInterval": "Automatic test interval",
+			"row.poolIntervalHint": "Minutes between automatic tests of this region's accounts. Runs only while BOTH the pool and this region's provider are enabled; switching either off stops the timer.",
+			"row.poolIntervalUnit": "minutes",
+			"row.poolTargetLabel": "Target test model",
+			"row.poolTargetHint": "Auto (default) picks a zero-multiplier model from this region's catalog, preferring the largest context window. The two regions can pick different models. A manual choice always wins.",
+			"row.poolTargetAutoOption": "Auto — pick a free model",
+			"row.poolSaved": "Save",
+			"row.poolSaving": "Saving…",
+			"row.poolSaveFailed": "Could not save: {message}",
+			"row.poolSavedStaleRefresh": "Saved, but the panel could not re-read it. The value is stored; the next refresh will show it.",
+			"row.poolDiscard": "Discard changes",
+			"row.poolDirty": "● Unsaved changes",
+			"row.poolSaveIdle": "Change any setting above to save it.",
+			"row.poolSaveDirty": "You have unsaved changes — saving writes them to this region.",
+			"row.poolManualLocked": "Manual selection is disabled: this region is rotating automatically",
+			"row.poolManualLockedHint": "The plugin picks the account by availability, then credits, then expiry, so you cannot pin one manually. The dropdown above is disabled to avoid showing one account while another is billed.",
+			"row.poolManualUnlock": "Turn off rotation",
+			"row.poolUnlockPending": "Save to apply — until then the plugin is still rotating.",
+			"row.poolUnlockSaved": "Rotation off — save to unlock",
+			"row.poolLogTitle": "Activity",
+			"row.poolLogClear": "Clear",
+			"row.poolLogEmpty": "Nothing yet. Check-ins, tests, and account switches are recorded here.",
+			"row.poolLogCheckinStart": "Checking in {count} account(s), one at a time",
+			"row.poolLogCheckinClaimed": "{accountName}: checked in (+{credit})",
+			"row.poolLogCheckinAlready": "{accountName}: already checked in today — skipped",
+			"row.poolLogCheckinFailed": "{accountName}: check-in failed — {message}",
+			"row.poolLogCheckinDone": "Check-in finished",
+			"row.poolLogBatchFailed": "Batch failed — nothing ran: {message}",
+			"row.poolLogTestStart": "Testing {count} account(s) against {model}",
+			"row.poolLogTestRow": "{accountName}: {outcome}",
+			"row.poolLogTestDone": "Test finished; the pool was re-ranked",
+			"row.poolLogTestRowMalformed": "{accountName}: the host returned no result for this account",
+			"row.poolLogRotated": "Switched billing from {from} to {to}",
+			"row.poolLogRotationStopped": "Rotation stopped — back to {from}",
+			"row.poolRegionNote": "The domestic and international pools are fully independent: accounts, switches, intervals, and target models never affect each other.",
+			"row.poolMembersTitle": "Accounts in this pool",
+			"row.poolMembersHint": "Only checked accounts are checked in, tested, and used for rotation. Nothing is selected by default — check the ones you want, then save.",
+			"row.poolSelectAll": "Select all",
+			"row.poolSelectNone": "Clear all",
+			"row.poolSelectedCount": "{count} of {total} selected",
+			"row.poolNoneSelected": "No account is checked into this pool.",
+			"row.poolNoneSelectedHint": "Check at least one account above and save. Until then both buttons stay disabled, because a pool with no members has nothing to run on.",
+			"row.poolGhostMembers": "{count} saved account(s) are no longer signed in on this machine, so they are not counted and not used. Save again to drop them.",
+			"row.poolSelectAria": "Include {accountName} in this region's account pool",
+			"row.poolMember": "In pool",
+			"row.poolNotMember": "Not in pool",
+			"row.poolUnsavedMembers": "Selection changed — save to apply"
 		};
 		const zh = {
 			"row.title": "接入使用 WorkBuddy 积分与模型（dsh-connect-workbuddy）",
@@ -1975,6 +3286,15 @@ window.__ModuleLoader__.load({
 			"row.credentialRejectedRelogin": "本机没有其他账号可切换。请在 WorkBuddy 桌面端重新登录。",
 			"row.credentialRejectedChoose": "本机还有其他账号，但刚才都没能通过上游校验。可以在上方切换一个试试；如果都不行，请在桌面端重新登录。",
 			"row.requestFailed": "请求失败",
+			"row.requestFailedHint": "刷新失败——下方为上次加载的数据：{message}",
+			"row.poolErrUnavailable": "本版本没有可用的账号池（或其批量接口缺失）。请重启应用；若仍不行，插件可能需要重新安装。",
+			"row.poolErrFailed": "批量操作在宿主侧失败：{message}",
+			"row.poolErrHttp": "批量操作被拒绝（HTTP {status}）。请确认插件是最新版本后重试。",
+			"row.poolErrDisabled": "本区域的账号池是关闭的。请先启用并保存，再执行批量操作。",
+			"row.poolErrNoMembers": "本池没有勾选任何账号，批量操作没有可执行对象。请至少勾选一个账号并保存。",
+			"row.poolErrNoLiveMembers": "本池勾选的账号在本机都已不再登录，批量操作没有可执行对象。请在 WorkBuddy 桌面端重新登录，或保存以移除它们。",
+			"row.poolErrNoFreeModel": "本区域没有可用的免费（倍率为 0）模型。请先刷新模型目录，或自己指定一个目标模型。",
+			"row.poolErrStaleModel": "目标模型已不在本区域目录中。请改选一个，或切回自动。",
 			"row.creditsTotalLabel": "总剩余积分",
 			"row.creditsMonthlyRemain": "剩余 {remain} / {size} · {at} 刷新",
 			"row.checkinClaim": "立即签到",
@@ -2030,7 +3350,98 @@ window.__ModuleLoader__.load({
 			"row.probeFailed": "✗ 测试失败",
 			"row.probeFailedStatus": "✗ 测试失败（HTTP {status}）",
 			"row.probeError": "无法执行测试：{message}",
-			"row.cheer": "鼓励一下"
+			"row.cheer": "鼓励一下",
+			"row.poolTitle": "账号池",
+			"row.poolSummary": "本区域 {count} 个账号 · 目标模型 {model}",
+			"row.poolNoCandidate": "账号池里目前没有可用的账号。",
+			"row.poolNoCandidateHint": "每个账号要么被限流、要么积分耗尽、要么被上游拒绝、要么连不上上游，或处于本版本无法使用的状态。请重新检测账号，或在桌面端重新登录。",
+			"row.poolRotating": "自动轮换中",
+			"row.poolCheckinAll": "一键签到所有账号",
+			"row.poolCheckingIn": "签到中…",
+			"row.poolTestAll": "一键测试所有账号",
+			"row.poolTesting": "测试中…",
+			"row.poolBusyHint": "正在逐个账号执行…",
+			"row.poolTargetAuto": "自动",
+			"row.poolTargetStaleShort": "目标模型已失效",
+			"row.poolTargetNoneShort": "无免费模型",
+			"row.poolTargetFree": "自动选中的免费模型：{model}",
+			"row.poolTargetPreferred": "你指定的模型：{model}",
+			"row.poolTargetNone": "本区域暂时没有倍率为 0 的免费模型。",
+			"row.poolTargetStale": "你保存的目标模型已不在目录中：{model}",
+			"row.poolTargetStaleHint": "本区域的模型目录已变化，不再包含这个模型，因此测试被停用——而不是拿一个上游可能不接受的模型去跑。请改选一个目标模型，或切回自动。",
+			"row.poolTargetStaleClear": "切回自动",
+			"row.poolTargetStaleOption": "{model}（已下架）",
+			"row.poolTargetNoneHint": "国内版的倍率要等模型目录刷新后才会出现。为了不让你在不知情的情况下花掉积分，插件**不会**自动改用收费模型——请先刷新模型目录，或自己指定一个目标模型。",
+			"row.poolColumnAccount": "账号",
+			"row.poolColumnCredits": "积分",
+			"row.poolColumnProbe": "目标模型",
+			"row.poolColumnCheckin": "签到",
+			"row.poolNeverTested": "尚未测试",
+			"row.poolTestedAt": "测试于 {at}",
+			"row.poolCheckedIn": "已签到",
+			"row.poolNotCheckedIn": "未签到",
+			"row.poolCheckinUnknown": "—",
+			"row.poolCreditSoon": "{count} 积分 3 天内过期",
+			"row.poolCreditNearest": "最近积分包 {at} 过期",
+			"row.poolExcludedRateLimited": "被限流",
+			"row.poolExcludedOutOfCredit": "积分耗尽",
+			"row.poolExcludedRejected": "被拒绝",
+			"row.poolExcludedUnusable": "不可用",
+			"row.poolRetryAt": "{at} 之后可再用",
+			"row.poolRetryUnknown": "上游未给出何时恢复",
+			"row.poolSettingsTitle": "账号池设置",
+			"row.poolSettingsHint": "下面四项是偏好设置：点保存才生效（与「模型管理」一致）。测试结果与轮换记录由插件自动写入，不受这个保存按钮影响。",
+			"row.poolEnabled": "启用账号池",
+			"row.poolEnabledHint": "关闭时插件行为与从前完全一致：跟随你选择的账号，绝不按积分重排。",
+			"row.poolRotate": "按积分自动轮换",
+			"row.poolRotateHint": "允许插件按「可用性 → 积分 → 可用时间」自动选择计费账号（并列时依次比凭据新鲜度与账号 id）。开启后需保存才停用手动选择；每次切换都会留下记录。",
+			"row.poolInterval": "自动测试间隔",
+			"row.poolIntervalHint": "每隔多少分钟自动测试本区域账号。需要「账号池」与本区域的供应商都启用；任一关闭即停止定时器。",
+			"row.poolIntervalUnit": "分钟",
+			"row.poolTargetLabel": "目标测试模型",
+			"row.poolTargetHint": "「自动」（默认）会从本区域目录里挑一个倍率为 0 的免费模型，多个候选取上下文窗口最大的。国内版与国际版可能挑到不同的模型。手动指定优先于自动。",
+			"row.poolTargetAutoOption": "自动 —— 挑一个免费模型",
+			"row.poolSaved": "保存",
+			"row.poolSaving": "保存中…",
+			"row.poolSaveFailed": "保存失败：{message}",
+			"row.poolSavedStaleRefresh": "已保存，但面板未能重新读取。设置已写入；下次刷新后会显示。",
+			"row.poolDiscard": "放弃修改",
+			"row.poolDirty": "● 有未保存的修改",
+			"row.poolSaveIdle": "修改任一设置后即可保存。",
+			"row.poolSaveDirty": "有未保存的修改 —— 保存后写入本区域配置。",
+			"row.poolManualLocked": "手动选择已停用：本区域正在自动轮换",
+			"row.poolManualLockedHint": "插件按「可用性 → 积分 → 可用时间」自动选择账号，因此不能手动指定。上面的下拉已置灰，避免出现\"显示 A 却计费 B\"。",
+			"row.poolManualUnlock": "关闭自动轮换",
+			"row.poolUnlockPending": "保存后生效 —— 在那之前插件仍在轮换。",
+			"row.poolUnlockSaved": "已关闭轮换 —— 保存后解锁",
+			"row.poolLogTitle": "活动记录",
+			"row.poolLogClear": "清空",
+			"row.poolLogEmpty": "尚无活动。签到、测试与账号切换都会记录在这里。",
+			"row.poolLogCheckinStart": "开始签到 {count} 个账号（逐个执行）",
+			"row.poolLogCheckinClaimed": "{accountName}：签到成功 +{credit}",
+			"row.poolLogCheckinAlready": "{accountName}：今日已签到，跳过",
+			"row.poolLogCheckinFailed": "{accountName}：签到失败 —— {message}",
+			"row.poolLogCheckinDone": "签到完成",
+			"row.poolLogBatchFailed": "批量操作失败 —— 没有执行：{message}",
+			"row.poolLogTestStart": "开始测试 {count} 个账号 × {model}",
+			"row.poolLogTestRow": "{accountName}：{outcome}",
+			"row.poolLogTestDone": "测试完成，已重新计算候选账号",
+			"row.poolLogTestRowMalformed": "{accountName}：Host 未返回该账号的结果",
+			"row.poolLogRotated": "计费账号已从 {from} 切换到 {to}",
+			"row.poolLogRotationStopped": "轮换已停止 —— 回到 {from}",
+			"row.poolRegionNote": "国内版与国际版是完全独立的两个账号池：账号、开关、间隔、目标模型互不影响。",
+			"row.poolMembersTitle": "本池包含的账号",
+			"row.poolMembersHint": "只有勾选的账号才会被签到、测试和轮换。默认一个都不勾 —— 请勾选你要的账号，然后保存。",
+			"row.poolSelectAll": "全选",
+			"row.poolSelectNone": "全不选",
+			"row.poolSelectedCount": "已选 {count} / {total}",
+			"row.poolNoneSelected": "这个池里还没有勾选任何账号。",
+			"row.poolNoneSelectedHint": "请在上方勾选至少一个账号并保存。在此之前两个按钮都不可用 —— 空池没有可执行的对象。",
+			"row.poolGhostMembers": "有 {count} 个已保存的账号在本机已不再登录，因此不计入、也不会被使用。再保存一次即可移除它们。",
+			"row.poolSelectAria": "把 {accountName} 加入本区域的账号池",
+			"row.poolMember": "已在池中",
+			"row.poolNotMember": "未入池",
+			"row.poolUnsavedMembers": "勾选已改动 —— 保存后生效"
 		};
 		//#endregion
 		//#region src/client/index.tsx