dsh-connect-workbuddy 4.8.1 → 4.9.0

package/lib/client.js

@@ -690,7 +690,8 @@ window.__ModuleLoader__.load({
 			const slot = {
 				enabled: preferences.enabled,
 				targetModelId: preferences.targetModelId,
-				memberAccountIds: preferences.memberAccountIds
+				memberAccountIds: preferences.memberAccountIds,
+				orderAccountIds: preferences.orderAccountIds
 			};
 			if (preferences.probeInputTokens !== void 0) slot["probeInputTokens"] = preferences.probeInputTokens;
 			const next = nextRegionPool(scope.getSnapshot().value, region, slot)[region];
@@ -704,10 +705,73 @@ window.__ModuleLoader__.load({
 				if (!Array.isArray(stored) || stored.length !== preferences.memberAccountIds.length) return false;
 				const wanted = new Set(preferences.memberAccountIds);
 				if (!stored.every((id) => typeof id === "string" && wanted.has(id))) return false;
+				const storedOrder = pool["orderAccountIds"];
+				if (!Array.isArray(storedOrder) || storedOrder.length !== preferences.orderAccountIds.length) return false;
+				if (!storedOrder.every((id, index) => id === preferences.orderAccountIds[index])) return false;
 				return true;
 			});
 		}
 		//#endregion
+		//#region src/client/manual-order.ts
+		/**
+		* Manual priority order, shared by every surface that lists member accounts.
+		*
+		* The defect this exists to prevent: the pool card sorts its rows by
+		* `orderAccountIds` while the composer credits panel listed the same accounts
+		* in whatever order the Host returned. Two views of one pool, disagreeing — the
+		* user sorts the pool, opens the credit panel, and sees a different order, so
+		* neither list looks authoritative. A user cannot tell which one is "the" order,
+		* and the manual sorting feature looks broken even though it saved correctly.
+		*
+		* So the order lives here, once, and both lists call it. The alternative —
+		* each component sorting however it likes — is exactly what drifted.
+		*/
+		/**
+		* The saved manual order out of a settings snapshot, or an empty array.
+		*
+		* Reads defensively: the snapshot is Host-supplied JSON, so `regions` may be
+		* absent (a profile that never used this feature), `pool` may be absent, and
+		* `orderAccountIds` may be anything at all. Every shape that is not a list of
+		* strings means "no manual order", which is also an older profile's spelling —
+		* never a crash.
+		*/
+		function readOrderAccountIds(value, region) {
+			if (region === void 0) return [];
+			const regions = value?.regions;
+			if (typeof regions !== "object" || regions === null) return [];
+			const slot = regions[region];
+			if (typeof slot !== "object" || slot === null) return [];
+			const order = slot.pool;
+			if (typeof order !== "object" || order === null) return [];
+			const ids = order.orderAccountIds;
+			if (!Array.isArray(ids)) return [];
+			return ids.filter((id) => typeof id === "string");
+		}
+		/**
+		* Reorder `accounts` to follow `orderIds`, leaving unordered accounts in place
+		* AFTER the ordered ones, and preserving their original relative order.
+		*
+		* Returns a new array; never mutates the input, because the caller's array is
+		* usually a state value that must not change identity behind React's back.
+		*
+		* Ids in `orderIds` that no longer name an account are simply ignored: the pool
+		* can drop a member while an order still mentions it, and that must degrade to
+		* "that position is empty" rather than hide a real account.
+		*/
+		function applyManualOrder(accounts, orderIds) {
+			if (orderIds.length === 0) return [...accounts];
+			const rank = /* @__PURE__ */ new Map();
+			orderIds.forEach((id, index) => {
+				if (!rank.has(id)) rank.set(id, index);
+			});
+			const ordered = [];
+			const rest = [];
+			for (const account of accounts) if (rank.has(account.id)) ordered.push(account);
+			else rest.push(account);
+			ordered.sort((left, right) => (rank.get(left.id) ?? 0) - (rank.get(right.id) ?? 0));
+			return [...ordered, ...rest];
+		}
+		//#endregion
 		//#region src/client/exclusion-text.ts
 		/** The exclusion label for one account, or undefined when it is usable. */
 		function exclusionText(t, excludedBy) {
@@ -724,6 +788,449 @@ window.__ModuleLoader__.load({
 			}
 		}
 		//#endregion
+		//#region src/account-pool.ts
+		/**
+		* How long an account stays out of the pool when the upstream stated no time.
+		*
+		* A conservative FALLBACK, not a measurement: it applies whenever a failed
+		* outcome carries no `retryAtMs`, which is every rate limit that came without a
+		* reset sentence AND every transient failure (a transport error, a 5xx). In both
+		* cases "when can I use this again" has no honest answer.
+		*
+		* The two failure directions it avoids: keeping the account in the pool would
+		* re-bill it immediately and re-trip the same limit; dropping it FOREVER would
+		* discard a working account over an event that said nothing about it. A short,
+		* stated cooldown is the least-wrong of the two — and it is what lets the pool
+		* heal itself, since nothing else re-probes an excluded member.
+		*/
+		const POOL_UNKNOWN_COOLDOWN_MS = 18e5;
+		/**
+		* Whether one account can be billed at `nowMs`.
+		*
+		* Returns the exclusion reason, or undefined when the account is a candidate.
+		* The order matters and is NOT arbitrary:
+		*
+		* - A `credential-rejected` account is excluded regardless of any cooldown: its
+		*   token is not accepted, so waiting cannot help and the user must re-auth.
+		* - A limited, unreachable or failed outcome is checked against its stated (or
+		*   fallback) cooldown, so an account whose limit has already reset — or whose
+		*   gateway blipped once — is back in the pool without needing another test
+		*   first.
+		* - An `ok` measurement, and no measurement at all, are both candidates. The
+		*   latter matters: a freshly discovered account has never been tested and must
+		*   not be invisible.
+		*
+		* WHY TRANSIENT OUTCOMES GET A COOLDOWN. They are not statements about the
+		* ACCOUNT. A transport failure can be a DNS blip, and — before the shim learned
+		* to skip reporting an aborted request — it was routinely the user closing the
+		* panel mid-flight. A 5xx is the gateway's afternoon, not this account's health.
+		* Excluding them permanently meant one transient event idled a perfectly good
+		* account until the user happened to press "test" again, and with every member
+		* so idled the pool had no candidate at all: failover then had nowhere to go and
+		* the raw upstream error was reported as-is. The cooldown is what makes the pool
+		* RECOVER instead of staying broken.
+		*
+		* `not-found` and `credential-rejected` deliberately get none: one describes a
+		* model the region no longer offers (a catalog fact, not a transient one) and
+		* the other needs the user to sign in again. Neither is fixed by waiting, and
+		* pretending otherwise would re-bill a token the upstream has already refused.
+		*
+		* Each unusable outcome keeps its OWN value rather than being folded into
+		* `credential-rejected`. The fold made one row state two contradictory things —
+		* the name column said "被拒绝" (sign in again) while the probe column, reading
+		* the same measurement, said "连不上上游——这是网络问题，不是模型问题" — and it
+		* told a user whose upstream had merely blipped that their sign-in was bad.
+		* (That label has since been made cause-NEUTRAL: it used to assert "not the
+		* model" for a bucket that also holds gateway 5xx and request timeouts, where
+		* the claim is simply unfounded. The recorded `message` now carries the cause.)
+		* The distinctions are already computed upstream in `outcomeOfFailure`
+		* (`src/probe.ts:290-299`); this only stops discarding them.
+		*/
+		function exclusionOf(probe, nowMs) {
+			if (probe === void 0) return void 0;
+			switch (probe.outcome) {
+				case "ok": return;
+				case "credential-rejected": return "credential-rejected";
+				case "not-found": return "not-found";
+				case "unavailable": return retryDue(probe, nowMs) ? void 0 : "unavailable";
+				case "failed": return retryDue(probe, nowMs) ? void 0 : "failed";
+				case "rate-limited": return retryDue(probe, nowMs) ? void 0 : "rate-limited";
+				case "model-busy": return retryDue(probe, nowMs, 12e4) ? void 0 : "model-busy";
+				case "out-of-credit": return retryDue(probe, nowMs) ? void 0 : "out-of-credit";
+				case "policy-rejected": return;
+				default: return "unusable";
+			}
+		}
+		/**
+		* Whether an account's cooldown has elapsed (or was never stated).
+		*
+		* The fallback is the ONLY thing a transient outcome relies on: `cooldownOf`
+		* attaches `retryAtMs` for a rate limit or a drained quota, never for a
+		* transport failure, so `atMs + POOL_UNKNOWN_COOLDOWN_MS` is what brings those
+		* back. That is deliberate — the alternative is a permanent exclusion decided by
+		* an event that said nothing about the account.
+		*
+		* `fallbackMs` lets one outcome carry a SHORTER clock than the generic one: the
+		* model-scoped throttle is upstream's own "about a minute", and applying the
+		* half-hour account fallback to it is issue #56. It is a parameter rather than a
+		* second function so every outcome keeps sharing one definition of "due".
+		*/
+		function retryDue(probe, nowMs, fallbackMs = POOL_UNKNOWN_COOLDOWN_MS) {
+			return nowMs >= (probe.retryAtMs ?? probe.atMs + fallbackMs);
+		}
+		/**
+		* 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/remaining.ts
+		const MINUTE_MS$1 = 6e4;
+		const HOUR_MS$1 = 60 * MINUTE_MS$1;
+		const DAY_MS$1 = 24 * HOUR_MS$1;
+		/**
+		* How far out hours stop being the useful unit.
+		*
+		* Below this, hours; at or above it, days. The cut is at TWO days rather than
+		* one so that 30 hours reads as "约 30 小时后" instead of rounding to "约 1 天后",
+		* which would understate it by six hours.
+		*/
+		const DAYS_AT_MS = 2 * DAY_MS$1;
+		/**
+		* A short "约 N 分钟后 / 约 N 小时后 / 约 N 天后", or `''` once the moment passed.
+		*
+		* The empty string is the contract callers depend on: an elapsed cooldown means
+		* the account is already back, so appending "in 0 minutes" would assert the
+		* opposite of the state the card is showing. Callers append this only when it is
+		* non-empty.
+		*
+		* Rounding is deliberately coarse — "约 1 小时后" for 69 minutes is what a reader
+		* wants, and a precision that changes every minute would be noise rather than
+		* information. The absolute instant sits right beside it for anyone who needs it.
+		*/
+		function remainingText(t, untilMs, nowMs) {
+			const left = untilMs - nowMs;
+			if (left <= 0) return "";
+			if (left < MINUTE_MS$1) return t("row.remainingImminent");
+			if (left < HOUR_MS$1) return t("row.remainingMinutes", { count: Math.round(left / MINUTE_MS$1) });
+			if (left < DAYS_AT_MS) return t("row.remainingHours", { count: Math.round(left / HOUR_MS$1) });
+			return t("row.remainingDays", { count: Math.round(left / DAY_MS$1) });
+		}
+		//#endregion
+		//#region src/client/account-state.ts
+		/** 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 "model-busy": return t("row.poolExcludedModelBusy");
+				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");
+			}
+		}
+		/**
+		* `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 formatShortClock(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));
+		}
+		/**
+		* The "why can't this serve, and until when" sentence for one account.
+		*
+		* Returns `undefined` when there is nothing to say — an account with no
+		* measurement and no exclusion is simply unknown, and inventing "可用" for it
+		* would be a claim nobody made.
+		*
+		* The retry wording has three states, matching the card's three:
+		*  - a stated instant        → "被限流 · 10/19 01:32 之后可再用"
+		*  - no instant but a timed   → "被限流 · 未提供恢复时间"
+		*    exclusion
+		*  - any other outcome        → the bare outcome ("连不上上游")
+		*
+		* That third case is deliberate: "未提供恢复时间" beside a credential rejection
+		* would imply waiting helps, when the only fix is signing in again.
+		*/
+		function availabilityLine(t, account, nowMs = Date.now()) {
+			const probe = account.probe;
+			if (probe !== void 0) {
+				if (probe.retryAtMs !== void 0) {
+					const left = remainingText(t, probe.retryAtMs, nowMs);
+					const at = t("row.poolRetryAt", { at: formatShortClock(probe.retryAtMs) });
+					return `${outcomeText(t, probe.outcome)} · ${at}${left === "" ? "" : ` · ${left}`}`;
+				}
+				if (probe.outcome === "rate-limited" || probe.outcome === "model-busy" || probe.outcome === "out-of-credit") return `${outcomeText(t, probe.outcome)} · ${t("row.poolRetryUnknown")}`;
+				return outcomeText(t, probe.outcome);
+			}
+			if (account.excludedBy !== void 0) return exclusionLabel(t, account.excludedBy);
+		}
+		/**
+		* The SHORT form of the same fact: why the account cannot serve, and how long
+		* until it can — without the absolute instant.
+		*
+		* This exists because the composer's balance panel prints one line per account
+		* and the absolute date made every limited row read like a log entry
+		* ("被限流 · 10/19, 01:32 之后可再用 · 约 6 小时后") beside a number the row is
+		* actually about. The panel keeps the reason and the wait; the pool card keeps
+		* the full sentence from {@link availabilityLine}, which is the one place a
+		* reader can afford the exact instant.
+		*
+		* It is a sibling rather than a parameter so the two surfaces cannot half-adopt
+		* a flag: the card has no way to reach this function, and the panel has no way
+		* to lose the wait.
+		*/
+		function availabilityMark(t, account, nowMs = Date.now()) {
+			const probe = account.probe;
+			if (probe !== void 0) {
+				if (probe.retryAtMs !== void 0) {
+					const left = remainingText(t, probe.retryAtMs, nowMs);
+					return left === "" ? outcomeText(t, probe.outcome) : `${outcomeText(t, probe.outcome)} · ${left}`;
+				}
+				if (probe.outcome === "rate-limited" || probe.outcome === "model-busy" || probe.outcome === "out-of-credit") return `${outcomeText(t, probe.outcome)} · ${t("row.poolRetryUnknown")}`;
+				return outcomeText(t, probe.outcome);
+			}
+			if (account.excludedBy !== void 0) return exclusionLabel(t, account.excludedBy);
+		}
+		/**
+		* The exclusion's own label, for the case where no probe backs it.
+		*
+		* Kept private: callers that have a probe must go through `availabilityLine` or
+		* `availabilityMark`, so neither surface can invent its own vocabulary for the
+		* same measurement.
+		*/
+		function exclusionLabel(t, excludedBy) {
+			switch (excludedBy) {
+				case "rate-limited": return t("row.poolExcludedRateLimited");
+				case "model-busy": return t("row.poolExcludedModelBusy");
+				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 t("row.poolExcludedUnusable");
+			}
+		}
+		/**
+		* The dot's state as a class suffix, so CSS can colour it without inline styles.
+		*
+		* `error` is separate from `warn` because the advice differs: one means "wait",
+		* the other means "do something".
+		*/
+		function stateTone(account) {
+			if (account.excludedBy !== void 0) return account.excludedBy === "rate-limited" || account.excludedBy === "model-busy" || account.excludedBy === "unavailable" ? "warn" : "error";
+			if (account.probe === void 0) return "unknown";
+			return outcomeOk(account.probe.outcome) ? "ok" : "warn";
+		}
+		/**
+		* The tone as a CSS colour variable.
+		*
+		* Derived from `stateTone` rather than repeating its branches: an inlined copy
+		* would be a second definition of the rule, free to drift the first time one is
+		* edited. The pool table draws a dot from a computed colour, so it needs a value
+		* rather than a class name.
+		*/
+		function stateColor(account) {
+			switch (stateTone(account)) {
+				case "ok": return "var(--dsw-alias-state-success-primary, #22a06b)";
+				case "warn": return "var(--dsw-alias-state-warn-primary, #f59e0b)";
+				case "error": return "var(--dsw-alias-state-error-primary, #ef4444)";
+				default: return "var(--dsw-alias-label-dimmed, #9aa0a6)";
+			}
+		}
+		/**
+		* Read one line of the test batch's stream as a test row.
+		*
+		* The stream is `{ action, modelId }`, then one `{ row }` per account, then
+		* `{ done: true }` — or `{ reason, error }` when the batch itself broke. Only the
+		* row shape is recognized here; the rest is the caller's business.
+		*
+		* Every field is validated rather than trusted. This parses a wire the panel did
+		* not write, and a half-shaped row reaching the component's state would render
+		* as a measurement nobody took — worse than ignoring the line, because the
+		* subsequent re-read is what would have quietly corrected it.
+		*/
+		function testRowOf(line) {
+			const raw = line["row"];
+			if (typeof raw !== "object" || raw === null) return void 0;
+			const row = raw;
+			const accountId = row["accountId"];
+			const name = row["accountName"];
+			const rawResult = row["result"];
+			if (typeof accountId !== "string" || accountId === "") return void 0;
+			if (typeof rawResult !== "object" || rawResult === null) return void 0;
+			const result = probeResultOf(rawResult);
+			if (result === void 0) return void 0;
+			return {
+				accountId,
+				accountName: typeof name === "string" && name !== "" ? name : accountId,
+				result
+			};
+		}
+		/** The probe result inside a test row, when it is complete enough to render. */
+		function probeResultOf(raw) {
+			const outcome = raw["outcome"];
+			const modelId = raw["modelId"];
+			if (typeof outcome !== "string" || !isProbeOutcome(outcome)) return void 0;
+			if (typeof modelId !== "string") return void 0;
+			const elapsedMs = raw["elapsedMs"];
+			const status = raw["status"];
+			const message = raw["message"];
+			const retryAtMs = raw["retryAtMs"];
+			const retrySource = raw["retrySource"];
+			return {
+				modelId,
+				outcome,
+				...typeof elapsedMs === "number" ? { elapsedMs } : {},
+				...typeof status === "number" ? { status } : {},
+				...typeof message === "string" ? { message } : {},
+				...typeof retryAtMs === "number" ? { retryAtMs } : {},
+				...isRetrySource(retrySource) ? { retrySource } : {}
+			};
+		}
+		/** The outcome vocabulary, as a value — the type alone cannot be tested against a wire. */
+		const PROBE_OUTCOMES = [
+			"ok",
+			"rate-limited",
+			"model-busy",
+			"out-of-credit",
+			"credential-rejected",
+			"policy-rejected",
+			"unavailable",
+			"not-found",
+			"failed"
+		];
+		function isProbeOutcome(value) {
+			return PROBE_OUTCOMES.includes(value);
+		}
+		function isRetrySource(value) {
+			return value === "retry-after" || value === "upstream-message" || value === "quota-refresh" || value === "upstream-tips";
+		}
+		/**
+		* Fold ONE streamed test row into the usage document the panel is rendering.
+		*
+		* Why fold at all, when the batch is followed by a re-read: the batch is SERIAL
+		* and a stuck member can take seconds, so a panel that changes nothing until the
+		* LAST account answers is exactly the dead-looking button the streamed batch was
+		* built to avoid. Folding each row as it lands makes the row change the moment
+		* its measurement exists; the re-read afterwards then replaces the fold with the
+		* same facts, this time from the Host's own store.
+		*
+		* The exclusion is RE-DERIVED here rather than left as it was: it is derived
+		* state (`exclusionOf`), so copying the previous one forward would keep a
+		* just-measured-good account red until the re-read — and would keep a
+		* just-measured-limited one green, which is the more expensive error.
+		*/
+		function withTestRow(usage, row, nowMs) {
+			if (!("pool" in usage) || usage.pool === void 0) return usage;
+			const pool = usage.pool;
+			const index = indexOfTestedAccount(pool.accounts, row);
+			if (index === void 0) return usage;
+			const measured = pool.accounts[index];
+			if (measured === void 0) return usage;
+			const { excludedBy: _previous, ...account } = measured;
+			const probe = {
+				outcome: row.result.outcome,
+				atMs: nowMs,
+				source: "test-batch",
+				modelId: row.result.modelId,
+				...row.result.retryAtMs === void 0 ? {} : { retryAtMs: row.result.retryAtMs },
+				...row.result.message === void 0 ? {} : { message: row.result.message }
+			};
+			const excludedBy = exclusionOf(probe, nowMs);
+			const folded = {
+				...account,
+				probe,
+				...excludedBy === void 0 ? {} : { excludedBy }
+			};
+			const accounts = pool.accounts.map((candidate, at) => at === index ? folded : candidate);
+			return {
+				...usage,
+				pool: {
+					...pool,
+					accounts
+				}
+			};
+		}
+		/**
+		* Which listed account a test row measured, or `undefined` when it measured none
+		* of them.
+		*
+		* Matched by ID first. The NAME is only a fallback for a row whose id this
+		* document no longer lists, and only when exactly one listed account carries it:
+		* two accounts sharing a name must never have one measurement written onto both.
+		*/
+		function indexOfTestedAccount(accounts, row) {
+			const byId = accounts.findIndex((account) => account.accountId === row.accountId);
+			if (byId >= 0) return byId;
+			const matches = accounts.flatMap((account, at) => account.accountName === row.accountName ? [at] : []);
+			return matches.length === 1 ? matches[0] : void 0;
+		}
+		//#endregion
 		//#region src/client/credit-format.ts
 		/**
 		* How a credit balance is written on screen.
@@ -936,9 +1443,9 @@ window.__ModuleLoader__.load({
 		}
 		//#endregion
 		//#region src/client/probe-age.ts
-		const MINUTE_MS$1 = 6e4;
-		const HOUR_MS$1 = 60 * MINUTE_MS$1;
-		const DAY_MS$1 = 24 * HOUR_MS$1;
+		const MINUTE_MS = 6e4;
+		const HOUR_MS = 60 * MINUTE_MS;
+		const DAY_MS = 24 * HOUR_MS;
 		/**
 		* How long ago a measurement was taken, coarsely: "刚刚", "N 分钟前",
 		* "N 小时前", "N 天前".
@@ -954,10 +1461,10 @@ window.__ModuleLoader__.load({
 		*/
 		function probeAgeText(t, atMs, nowMs) {
 			const age = nowMs - atMs;
-			if (age < MINUTE_MS$1) return t("row.poolProbeJustNow");
-			if (age < HOUR_MS$1) return t("row.poolProbeMinutesAgo", { count: Math.round(age / MINUTE_MS$1) });
-			if (age < 2 * DAY_MS$1) return t("row.poolProbeHoursAgo", { count: Math.round(age / HOUR_MS$1) });
-			return t("row.poolProbeDaysAgo", { count: Math.round(age / DAY_MS$1) });
+			if (age < MINUTE_MS) return t("row.poolProbeJustNow");
+			if (age < HOUR_MS) return t("row.poolProbeMinutesAgo", { count: Math.round(age / MINUTE_MS) });
+			if (age < 2 * DAY_MS) return t("row.poolProbeHoursAgo", { count: Math.round(age / HOUR_MS) });
+			return t("row.poolProbeDaysAgo", { count: Math.round(age / DAY_MS) });
 		}
 		//#endregion
 		//#region src/probe.ts
@@ -993,88 +1500,6 @@ window.__ModuleLoader__.load({
 		new RegExp(`将在?\\s*${RESET_STAMP}[\\s\\S]*?重置`, "u");
 		new RegExp(`(?:reset|resets|refresh|refreshes)\\s+(?:at|on)\\s+${RESET_STAMP}`, "iu");
 		//#endregion
-		//#region src/client/remaining.ts
-		const MINUTE_MS = 6e4;
-		const HOUR_MS = 60 * MINUTE_MS;
-		const DAY_MS = 24 * HOUR_MS;
-		/**
-		* How far out hours stop being the useful unit.
-		*
-		* Below this, hours; at or above it, days. The cut is at TWO days rather than
-		* one so that 30 hours reads as "约 30 小时后" instead of rounding to "约 1 天后",
-		* which would understate it by six hours.
-		*/
-		const DAYS_AT_MS = 2 * DAY_MS;
-		/**
-		* A short "约 N 分钟后 / 约 N 小时后 / 约 N 天后", or `''` once the moment passed.
-		*
-		* The empty string is the contract callers depend on: an elapsed cooldown means
-		* the account is already back, so appending "in 0 minutes" would assert the
-		* opposite of the state the card is showing. Callers append this only when it is
-		* non-empty.
-		*
-		* Rounding is deliberately coarse — "约 1 小时后" for 69 minutes is what a reader
-		* wants, and a precision that changes every minute would be noise rather than
-		* information. The absolute instant sits right beside it for anyone who needs it.
-		*/
-		function remainingText(t, untilMs, nowMs) {
-			const left = untilMs - nowMs;
-			if (left <= 0) return "";
-			if (left < MINUTE_MS) return t("row.remainingImminent");
-			if (left < HOUR_MS) return t("row.remainingMinutes", { count: Math.round(left / MINUTE_MS) });
-			if (left < DAYS_AT_MS) return t("row.remainingHours", { count: Math.round(left / HOUR_MS) });
-			return t("row.remainingDays", { count: Math.round(left / DAY_MS) });
-		}
-		//#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.
@@ -1339,47 +1764,19 @@ window.__ModuleLoader__.load({
 			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 "model-busy": return t("row.poolExcludedModelBusy");
-				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 formatCredits(value);
-		}
 		/**
-		* `MM/DD, HH:mm` on a 24-hour clock.
+		* Whether two id lists are equal IN ORDER.
 		*
-		* `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.
+		* Unlike `sameIds`, position matters: manual priority is order-sensitive, so a
+		* swapped pair is a real change and must light up "unsaved changes". A set
+		* comparison here would treat reordering as a no-op and drop the user's sort.
 		*/
-		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 sameOrder(left, right) {
+			if (left.length !== right.length) return false;
+			return left.every((id, index) => id === right[index]);
+		}
+		function formatNumber$1(value) {
+			return formatCredits(value);
 		}
 		function formatClock$1(value) {
 			return new Intl.DateTimeFormat(void 0, {
@@ -1389,12 +1786,6 @@ window.__ModuleLoader__.load({
 				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 === "model-busy" || 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 pool section.
 		*
@@ -1414,6 +1805,7 @@ window.__ModuleLoader__.load({
 				setLog(logStore.get(region) ?? []);
 			}, [region]);
 			const [draftRegion, setDraftRegion] = (0, react.useState)(void 0);
+			const [orderRulesOpen, setOrderRulesOpen] = (0, react.useState)(false);
 			const mounted = (0, react.useRef)(true);
 			(0, react.useEffect)(() => {
 				mounted.current = true;
@@ -1425,7 +1817,8 @@ window.__ModuleLoader__.load({
 				enabled: pool?.enabled ?? false,
 				targetModelId: pool?.targetModelId || pool?.staleTargetModelId || "",
 				probeInputTokens: pool?.probeInputTokens ?? 0,
-				memberAccountIds: pool?.memberAccountIds ?? []
+				memberAccountIds: pool?.memberAccountIds ?? [],
+				orderAccountIds: pool?.orderAccountIds ?? []
 			};
 			const active = draftRegion === region && draft !== null ? draft : saved;
 			/**
@@ -1446,7 +1839,7 @@ window.__ModuleLoader__.load({
 			* the pending edit.
 			*/
 			const poolRunning = saved.enabled;
-			const dirty = draftRegion === region && draft !== null && (draft.enabled !== saved.enabled || draft.targetModelId !== saved.targetModelId || draft.probeInputTokens !== saved.probeInputTokens || !sameIds(draft.memberAccountIds, saved.memberAccountIds));
+			const dirty = draftRegion === region && draft !== null && (draft.enabled !== saved.enabled || draft.targetModelId !== saved.targetModelId || draft.probeInputTokens !== saved.probeInputTokens || !sameIds(draft.memberAccountIds, saved.memberAccountIds) || !sameOrder(draft.orderAccountIds, saved.orderAccountIds));
 			/**
 			* Membership that actually resolves to a local sign-in — what a batch runs on.
 			*
@@ -1460,6 +1853,13 @@ window.__ModuleLoader__.load({
 			* the field.
 			*/
 			const listedIds = new Set((pool?.accounts ?? []).map((account) => account.accountId));
+			const orderIds = (() => {
+				const members = active.memberAccountIds.filter((id) => listedIds.has(id));
+				const explicit = active.orderAccountIds.filter((id) => members.includes(id));
+				const rest = members.filter((id) => !explicit.includes(id));
+				return [...explicit, ...rest];
+			})();
+			const orderIsManual = active.orderAccountIds.some((id) => active.memberAccountIds.includes(id));
 			const effectiveMembers = effectiveMemberIds({
 				savedEffective: pool?.effectiveMemberAccountIds ?? [],
 				draftMembers: active.memberAccountIds,
@@ -1607,6 +2007,36 @@ window.__ModuleLoader__.load({
 					};
 				});
 			}, [editDraft]);
+			/**
+			* Move one member one step up (`-1`) or down (`+1`) in the manual priority.
+			*
+			* The FIRST click is "the user starts sorting manually": it persists the WHOLE
+			* currently-visible order into the draft, not just the one swapped pair. A
+			* click that wrote only the moved id would leave the other rows unsorted (and
+			* `orderIsManual` false), so the draft and the tables they power stay in sync.
+			* `delta` is restricted to ±1 — a single swap per click — which is what makes
+			* the first/last rows' extra buttons (rather than fields) correct.
+			*/
+			const moveMember = (0, react.useCallback)((accountId, delta) => {
+				editDraft((current) => {
+					const listed = new Set((pool?.accounts ?? []).map((account) => account.accountId));
+					const members = current.memberAccountIds.filter((id) => listed.has(id));
+					const explicit = current.orderAccountIds.filter((id) => members.includes(id));
+					const rest = members.filter((id) => !explicit.includes(id));
+					const visible = [...explicit, ...rest];
+					const index = visible.indexOf(accountId);
+					if (index < 0) return current;
+					const to = index + delta;
+					if (to < 0 || to >= visible.length) return current;
+					const next = [...visible];
+					next.splice(index, 1);
+					next.splice(to, 0, accountId);
+					return {
+						...current,
+						orderAccountIds: next
+					};
+				});
+			}, [editDraft, pool]);
 			/** Check every listed account, or none of them. */
 			const selectAll = (0, react.useCallback)((next) => {
 				editDraft((current) => ({
@@ -1915,23 +2345,50 @@ window.__ModuleLoader__.load({
 				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${pool.checkinSupported ? " dsm-workbuddy-pool-table-checkin" : ""}` }, (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")), pool.checkinSupported ? (0, react.createElement)("span", null, t("row.poolColumnCheckin")) : null, (0, react.createElement)("span", null)), ...pool.accounts.map((account) => renderAccountRow({
-				t,
-				account,
-				checked: active.memberAccountIds.includes(account.accountId),
-				canEdit: canEditPool,
-				checkinSupported: pool.checkinSupported,
-				onToggle: (next) => toggleMember(account.accountId, next),
-				busy: rowBusyAccountId !== void 0,
-				testDisabled: pool.targetModelSource === "none" || pool.targetModelSource === "stale",
-				targetHint: pool.targetModelSource === "none" ? t("row.poolTargetNone") : pool.targetModelSource === "stale" ? t("row.poolTargetStale", { model: pool.staleTargetModelId ?? "" }) : void 0,
-				onTest: () => {
-					runRowTest(account.accountId);
-				},
-				onRemove: () => {
-					runRowRemove(account.accountId, account.accountName);
-				}
-			}))), effectiveMembers.length === 0 ? (0, react.createElement)("p", {
+			}, t("row.poolSelectNone")))), (0, react.createElement)("details", {
+				className: "dsm-workbuddy-pool-order-rules",
+				open: orderRulesOpen,
+				onToggle: (event) => setOrderRulesOpen(event.currentTarget.open)
+			}, (0, react.createElement)("summary", { className: "dsm-workbuddy-pool-order-rules-summary" }, t("row.poolOrderRulesTitle")), (0, react.createElement)("div", { className: "dsm-workbuddy-pool-order-rules-body" }, (0, react.createElement)("p", { className: "dsm-workbuddy-pool-note" }, t("row.poolOrderRulesIntro")), (0, react.createElement)("ol", { className: "dsm-workbuddy-pool-order-rules-list" }, ...ORDER_RULE_KEYS.map((key) => (0, react.createElement)("li", { key }, t(key)))), (0, react.createElement)("p", { className: "dsm-workbuddy-pool-order-rules-why" }, t("row.poolOrderWhy")), (0, react.createElement)("p", { className: "dsm-workbuddy-pool-note" }, t("row.poolOrderBadgeNote")))), (0, react.createElement)("div", { className: `dsm-workbuddy-pool-table${pool.checkinSupported ? " dsm-workbuddy-pool-table-checkin" : ""}` }, (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")), pool.checkinSupported ? (0, react.createElement)("span", null, t("row.poolColumnCheckin")) : null, (0, react.createElement)("span", null)), ...(() => {
+				const ordered = sortAccountsByOrder(pool.accounts, orderIds);
+				let memberSeen = 0;
+				let memberTotal = 0;
+				for (const account of ordered) if (active.memberAccountIds.includes(account.accountId)) memberTotal += 1;
+				return ordered.map((account) => {
+					const isMember = active.memberAccountIds.includes(account.accountId);
+					const left = isMember ? memberSeen : -1;
+					const right = isMember ? memberTotal - 1 - memberSeen : -1;
+					if (isMember) memberSeen += 1;
+					return renderAccountRow({
+						t,
+						account,
+						checked: isMember,
+						canEdit: canEditPool,
+						checkinSupported: pool.checkinSupported,
+						onToggle: (next) => toggleMember(account.accountId, next),
+						busy: rowBusyAccountId !== void 0,
+						testDisabled: pool.targetModelSource === "none" || pool.targetModelSource === "stale",
+						targetHint: pool.targetModelSource === "none" ? t("row.poolTargetNone") : pool.targetModelSource === "stale" ? t("row.poolTargetStale", { model: pool.staleTargetModelId ?? "" }) : void 0,
+						onTest: () => {
+							runRowTest(account.accountId);
+						},
+						onRemove: () => {
+							runRowRemove(account.accountId, account.accountName);
+						},
+						orderIndex: isMember && orderIsManual ? left + 1 : void 0,
+						orderIsManual,
+						moveEnabled: pool.enabled === true && isMember && canEditPool,
+						onMoveUp: () => {
+							moveMember(account.accountId, -1);
+						},
+						onMoveDown: () => {
+							moveMember(account.accountId, 1);
+						},
+						moveUpDisabled: left <= 0,
+						moveDownDisabled: right <= 0
+					});
+				});
+			})()), effectiveMembers.length === 0 ? (0, react.createElement)("p", {
 				className: "dsm-workbuddy-pool-warn",
 				role: "status"
 			}, `${t("row.poolNoneSelected")} ${t("row.poolNoneSelectedHint")}`) : null, ghostMembers$1.length === 0 ? null : (0, react.createElement)("div", { className: "dsm-workbuddy-pool-ghosts" }, (0, react.createElement)("p", {
@@ -1997,12 +2454,11 @@ window.__ModuleLoader__.load({
 		}
 		/** One account's row. */
 		function renderAccountRow(input) {
-			const { t, account, checked, canEdit, checkinSupported, onToggle, busy, testDisabled, targetHint, onTest, onRemove } = input;
+			const { t, account, checked, canEdit, checkinSupported, onToggle, busy, testDisabled, targetHint, onTest, onRemove, orderIndex, orderIsManual, moveEnabled, onMoveUp, onMoveDown, moveUpDisabled, moveDownDisabled } = input;
 			const name = account.accountName === "" ? t("row.accountUnnamed") : account.accountName;
 			const excluded = exclusionText(t, account.excludedBy);
 			const probe = account.probe;
-			const outcomeLine = 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 === "model-busy" || probe.outcome === "out-of-credit" ? `${outcomeText(t, probe.outcome)} · ${t("row.poolRetryUnknown")}` : outcomeText(t, probe.outcome);
-			const remaining = probe?.retryAtMs === void 0 ? "" : remainingText(t, probe.retryAtMs, Date.now());
+			const outcomeLine = availabilityLine(t, account) ?? t("row.poolNeverTested");
 			const reason = probe === void 0 ? void 0 : inlineProbeReason(probe.outcome, probe.message);
 			const age = probe === void 0 ? void 0 : probeAgeText(t, probe.atMs, Date.now());
 			const probeLabel = probe === void 0 ? void 0 : probe.source === void 0 ? {
@@ -2015,11 +2471,7 @@ window.__ModuleLoader__.load({
 				text: t("row.poolProbeSourceTest"),
 				className: "dsm-workbuddy-pool-prov-tag"
 			};
-			const probeLine = [
-				outcomeLine,
-				remaining,
-				reason
-			].filter((part) => part !== void 0 && part !== "").join(" · ");
+			const probeLine = [outcomeLine, reason].filter((part) => part !== void 0 && part !== "").join(" · ");
 			return (0, react.createElement)("div", {
 				className: `dsm-workbuddy-pool-row${account.current ? " dsm-workbuddy-pool-row-current" : ""}`,
 				key: account.accountId
@@ -2032,7 +2484,27 @@ window.__ModuleLoader__.load({
 			})), (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), account.current ? (0, react.createElement)("span", { className: "dsm-workbuddy-pool-current-tag" }, t("row.poolCurrentBadge")) : null, (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", {
+			}), (0, react.createElement)("span", { className: "dsm-workbuddy-pool-account-name" }, (0, react.createElement)("b", null, name), checked ? (0, react.createElement)("span", { className: "dsm-workbuddy-pool-order" }, orderIsManual ? (0, react.createElement)("span", {
+				className: "dsm-workbuddy-pool-rank",
+				title: t("row.poolRankManualTitle")
+			}, t("row.poolRankLabel", { rank: orderIndex ?? 0 })) : (0, react.createElement)("span", {
+				className: "dsm-workbuddy-pool-rank dsm-workbuddy-pool-rank-auto",
+				title: t("row.poolRankAutoTitle")
+			}, t("row.poolRankAuto")), moveEnabled ? (0, react.createElement)("span", { className: "dsm-workbuddy-pool-move" }, (0, react.createElement)("button", {
+				type: "button",
+				className: "dsm-workbuddy-pool-move-btn",
+				title: t("row.poolMoveUpTitle"),
+				"aria-label": t("row.poolMoveUpAria", { accountName: name }),
+				disabled: moveUpDisabled,
+				onClick: onMoveUp
+			}, "↑"), (0, react.createElement)("button", {
+				type: "button",
+				className: "dsm-workbuddy-pool-move-btn",
+				title: t("row.poolMoveDownTitle"),
+				"aria-label": t("row.poolMoveDownAria", { accountName: name }),
+				disabled: moveDownDisabled,
+				onClick: onMoveDown
+			}, "↓")) : null) : null, account.current ? (0, react.createElement)("span", { className: "dsm-workbuddy-pool-current-tag" }, t("row.poolCurrentBadge")) : null, (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: formatShortClock(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: formatShortClock(account.nearestExpiryMs) }))), (0, react.createElement)("span", {
 				className: "dsm-workbuddy-pool-probe",
 				...probe?.message === void 0 ? {} : { title: probe.message }
 			}, (0, react.createElement)("span", { className: "dsm-workbuddy-pool-probe-main" }, probeLine), probeLabel === void 0 && age === void 0 ? null : (0, react.createElement)("span", { className: "dsm-workbuddy-pool-probe-prov" }, probeLabel === void 0 ? null : (0, react.createElement)("span", { className: probeLabel.className }, probeLabel.text), probeLabel === void 0 || age === void 0 ? null : (0, react.createElement)("span", { className: "dsm-workbuddy-pool-prov-sep" }, "·"), age === void 0 ? null : (0, react.createElement)("span", { className: "dsm-workbuddy-pool-prov-age" }, age), probe === void 0 ? null : (0, react.createElement)("span", { className: "dsm-workbuddy-pool-prov-model" }, probe.modelId === void 0 ? t("row.poolProbeModelUnknown") : t("row.poolProbeModel", { model: probe.modelId })))), checkinSupported ? (0, react.createElement)("span", { className: "dsm-workbuddy-pool-checkin" }, account.checkedInToday === void 0 ? (0, react.createElement)("span", {
@@ -2134,6 +2606,61 @@ window.__ModuleLoader__.load({
 				key: `${entry.atMs}-${index}`
 			}, (0, react.createElement)("span", { className: "dsm-workbuddy-pool-log-time" }, formatClock$1(entry.atMs)), (0, react.createElement)("span", { className: `dsm-workbuddy-pool-log-text dsm-workbuddy-pool-log-${entry.tone}` }, entry.text)))));
 		}
+		/**
+		* Sort accounts by the manual priority order, without losing stability.
+		*
+		* Helpers/rows are rendered in this order so a click on ↑/↓ reorders the row
+		* immediately (client-side), before any save + host round-trip. Ids in `orderIds`
+		* that are not actually members are skipped; members not listed fall back to the
+		* END in their original relative order.
+		*
+		* The sort is STABLE: two ids with the same priority rank keep their original
+		* array order. A `rank` lookup returns `orderIds.length` as the sentinel for
+		* "not ordered", which is larger than any real rank, so unlisted members sort
+		* after every listed one. An EMPTY `orderIds` short-circuits: the input order is
+		* already the answer, and we avoid building the rank map / comparator for the
+		* common (never-sorted) case.
+		*
+		* TWO subtleties that a naive rank comparator gets wrong, both of which would
+		* make the table visibly wrong:
+		*
+		* - DUPLICATE ids keep the FIRST occurrence's rank (`if (!rank.has(id))`).
+		*   Overwriting instead would let a stray duplicate silently push the account
+		*   it names to the duplicate's later position, so the row would drift away
+		*   from the badge that claims to describe it.
+		* - The sort key is the PAIR (rank, original index), not rank alone. Ranks are
+		*   unique per id, but the `Infinity` fallback is shared by every unlisted
+		*   account, and `Array.prototype.sort` is NOT guaranteed stable across engines
+		*   for arbitrary inputs; relying on it would let the unlisted tail reshuffle
+		*   between renders. Breaking the tie on the original index makes the result a
+		*   pure function of the input, which is what stops the table from jittering
+		*   when the same snapshot arrives twice.
+		*/
+		/**
+		* The ordering rules, in EXACTLY the comparator's priority order.
+		*
+		* Kept as one table rather than inline literals so the order is a single thing
+		* a reader can compare against `src/account-pool.ts` — the rule text and the
+		* code must never drift, and a flat list makes that diff trivial. Typed as
+		* `WorkBuddySettingsKey` so a renamed or removed locale key is a compile error
+		* instead of a raw key rendered to the user.
+		*/
+		const ORDER_RULE_KEYS = [
+			"row.poolOrderRuleUsable",
+			"row.poolOrderRuleExpiring",
+			"row.poolOrderRuleManual",
+			"row.poolOrderRuleNearestExpiry",
+			"row.poolOrderRuleExpiringAmount",
+			"row.poolOrderRuleTotal",
+			"row.poolOrderRuleFreshness",
+			"row.poolOrderRuleId"
+		];
+		function sortAccountsByOrder(accounts, orderIds) {
+			return applyManualOrder(accounts.map((account) => ({
+				id: account.accountId,
+				account
+			})), orderIds).map((entry) => entry.account);
+		}
 		//#endregion
 		//#region src/client/OAuthSignIn.tsx
 		/**
@@ -3343,7 +3870,48 @@ window.__ModuleLoader__.load({
 /* Declared AFTER the blanket span rule so it wins: the badge must not inherit
    the muted 11px tertiary treatment the membership line uses. */
 .dsm-workbuddy-pool-account-name .dsm-workbuddy-pool-current-tag{align-self:flex-start;margin-top:2px;padding:1px 6px;border-radius:999px;background:rgba(86,134,254,.16);color:var(--dsw-alias-brand-primary,#5686fe);font-size:11px;font-weight:600;line-height:16px;white-space:nowrap}
+/* Manual-priority chrome (order badge + up/down arrows). The rank badge is a SPAN,
+   not a button: it only DESCRIBES the current order and must not read as a
+   control (nor join the row's button list). The solid vs dashed distinction is
+   load-bearing — a numeric rank must NOT appear when the credit policy still
+   decides the order, so the -auto modifier is the dashed/grey state. */
+.dsm-workbuddy-pool-account-name .dsm-workbuddy-pool-order{display:flex;align-items:center;gap:6px;margin-top:2px;flex-wrap:wrap}
+.dsm-workbuddy-pool-account-name .dsm-workbuddy-pool-rank{display:inline-flex;align-items:center;border-radius:999px;border:1px solid rgba(86,134,254,.32);background:rgba(86,134,254,.12);color:var(--dsw-alias-brand-primary,#5686fe);font-size:11px;font-weight:600;line-height:16px;padding:1px 6px;white-space:nowrap;cursor:default;font-variant-numeric:tabular-nums}
+.dsm-workbuddy-pool-account-name .dsm-workbuddy-pool-rank-auto{border:1px dashed var(--dsw-alias-border-l1,#2c2d31);background:var(--dsw-alias-bg-layer-3,#2a2c33);color:var(--dsw-alias-label-secondary,#c6c9d0)}
+.dsm-workbuddy-pool-account-name .dsm-workbuddy-pool-move{display:inline-flex;align-items:center;gap:2px}
+.dsm-workbuddy-pool-account-name .dsm-workbuddy-pool-move-btn{width:18px;height:18px;padding:0;display:inline-flex;align-items:center;justify-content:center;border-radius:6px;border:1px solid var(--dsw-alias-border-l1,#2c2d31);background:var(--dsw-alias-bg-layer-3,#2a2c33);color:var(--dsw-alias-label-secondary,#c6c9d0);font-size:11px;line-height:1;cursor:pointer}
+.dsm-workbuddy-pool-account-name .dsm-workbuddy-pool-move-btn:disabled{opacity:.4;cursor:default}
+/* Hover/focus must change BOTH halves of the contrast pair.
+   The rule this replaces recoloured only the glyph — to
+   --dsw-alias-label-primary (#e6e6e6) — and left the background as it was. In
+   the LIGHT theme that token is near-WHITE, so on hover the arrow painted
+   white-on-light and vanished under the cursor (reported as "the up arrow
+   disappears when I hover"). Recolouring text without also repainting its
+   backdrop is unsafe whenever the two come from independent tokens, so this
+   sets an explicit tinted background and keeps the glyph on the brand colour,
+   which is legible in both themes. The outline is a third, theme-independent
+   affordance so the target is findable even if a token is remapped. */
+.dsm-workbuddy-pool-account-name .dsm-workbuddy-pool-move-btn:not(:disabled):hover,
+.dsm-workbuddy-pool-account-name .dsm-workbuddy-pool-move-btn:not(:disabled):focus-visible{background:rgba(86,134,254,.16);border-color:rgba(86,134,254,.55);color:var(--dsw-alias-brand-primary,#5686fe);outline:2px solid rgba(86,134,254,.45);outline-offset:1px}
 .dsm-workbuddy-pool-excluded{color:var(--dsw-alias-state-warn-primary,#f59e0b)}
+/* The ordering-rule disclosure, placed directly above the member table.
+   A native <details>: the marker is left to the browser so the control keeps
+   its built-in keyboard and screen-reader behaviour. The summary is a full-width
+   row because a 12px grey label on its own is a small click target, and this is
+   the one place a confused user is meant to click. */
+.dsm-workbuddy-pool-order-rules{border:1px solid var(--dsw-alias-border-l1,#2c2d31);border-radius:10px;background:var(--dsw-alias-bg-layer-2,#232529);margin:0 0 10px;overflow:hidden}
+.dsm-workbuddy-pool-order-rules-summary{padding:8px 12px;cursor:pointer;user-select:none;color:var(--dsw-alias-label-secondary,#c6c9d0);font-size:12px;font-weight:600;line-height:18px}
+.dsm-workbuddy-pool-order-rules-summary:hover{color:var(--dsw-alias-label-primary,#e6e6e6)}
+.dsm-workbuddy-pool-order-rules-summary:focus-visible{outline:2px solid rgba(86,134,254,.55);outline-offset:-2px}
+.dsm-workbuddy-pool-order-rules-body{display:flex;flex-direction:column;gap:8px;padding:0 12px 12px;border-top:1px solid var(--dsw-alias-border-l1,#2c2d31);padding-top:10px}
+/* The rules already carry their own "1." … "8." inside the sentence, so the <ol>
+   is semantic only. Suppressing the marker keeps a single number on screen
+   instead of "1. 1. …". */
+.dsm-workbuddy-pool-order-rules-list{margin:0;padding:0;list-style:none;display:flex;flex-direction:column;gap:6px;font-size:12px;line-height:18px;color:var(--dsw-alias-label-secondary,#c6c9d0)}
+.dsm-workbuddy-pool-order-rules-list li{padding-left:2px}
+/* The "why expiring credits win" note is the sentence users push back on, so
+   it is tinted rather than buried in the same grey as the eight rules. */
+.dsm-workbuddy-pool-order-rules-why{margin:0;padding:8px 10px;border-radius:8px;border-left:3px solid var(--dsw-alias-state-warn-primary,#f59e0b);background:rgba(245,158,11,.10);font-size:12px;line-height:18px;color:var(--dsw-alias-label-secondary,#c6c9d0)}
 .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)}
@@ -3623,11 +4191,24 @@ window.__ModuleLoader__.load({
    instead of the name. */
 .dsm-workbuddy-composer-panel-who{display:flex;flex-direction:column;min-width:0;gap:1px}
 .dsm-workbuddy-composer-panel-name{overflow:hidden;text-overflow:ellipsis}
-/* Why the account cannot serve right now ("被限流"), in the warn colour the pool
-   table uses for the same fact — so one measurement reads the same on both. */
+/* The second line under the name: TWO facts, two tones.
+   .dsm-workbuddy-composer-panel-mark-current -- "当前选用", green: it says which
+     account is serving this tab, which is not a problem and must not be painted
+     like one. The owner asked for exactly this ("框出来的，当前选用用绿色的字").
+   .dsm-workbuddy-composer-panel-mark-reason -- why it cannot serve ("被限流"),
+     in the warn colour the pool table uses for the same fact, so one
+     measurement reads the same on both surfaces.
+   The two are siblings in a flex line and the separator between them is drawn
+   here, not in the text: rendered text stays exactly "当前选用 · 被限流 · 约 6
+   小时后" for anything that reads the DOM as a string. */
 .dsm-workbuddy-composer-panel-mark{
+  display:flex;flex-wrap:wrap;align-items:baseline;
   font-size:11px;line-height:15px;
-  color:var(--dsw-alias-state-warn-primary,#f59e0b);
+}
+.dsm-workbuddy-composer-panel-mark-current{color:var(--dsw-alias-state-success-primary,#22a06b)}
+.dsm-workbuddy-composer-panel-mark-reason{color:var(--dsw-alias-state-warn-primary,#f59e0b)}
+.dsm-workbuddy-composer-panel-mark-current+.dsm-workbuddy-composer-panel-mark-reason::before{
+  content:" · ";color:var(--dsw-alias-label-dimmed,rgba(127,127,127,.6));
 }
 /* Hover belongs to the switch, not the row: the number cell is not clickable,
    so lighting it up would promise an action it cannot perform. */
@@ -3642,9 +4223,21 @@ window.__ModuleLoader__.load({
   flex:none;width:7px;height:7px;border-radius:50%;
   background:var(--dsw-alias-label-dimmed,rgba(127,127,127,.5));
 }
-.dsm-workbuddy-composer-panel-table tr.dsm-workbuddy-composer-panel-row-current .dsm-workbuddy-composer-panel-dot{
-  background:var(--dsw-state-success,#22a06b);
-}
+/* Availability, matching the pool table's dot EXACTLY (see
+   account-state.ts, stateTone, which is the one place the rule lives).
+   Three states, and colour answers only the first question: can this account
+   serve the next message? The second question -- which account is serving this
+   tab -- is answered in words on the row ("current"), so the colour is free to
+   stay honest about usability. Green for usable (selected or not), red for a
+   refusal of any kind (a stated rate limit included: amber used to sit here and
+   read as "mostly fine"), and the neutral grey above for an account nobody has
+   measured yet, which is neither.
+   NOTE: no backticks in this comment. The whole stylesheet is a template
+   literal, and a stray backtick silently closes it (the file then fails to
+   parse with a misleading "Expected a semicolon"). */
+.dsm-workbuddy-composer-panel-dot-ok{background:var(--dsw-alias-state-success-primary,#22a06b)}
+.dsm-workbuddy-composer-panel-dot-error{background:var(--dsw-alias-state-error-primary,#ef4444)}
+.dsm-workbuddy-composer-panel-dot-unknown{background:var(--dsw-alias-label-dimmed,rgba(127,127,127,.5))}
 .dsm-workbuddy-composer-panel-foot{
   display:flex;justify-content:space-between;gap:8px;
   margin-top:9px;padding-top:7px;
@@ -5454,6 +6047,57 @@ window.__ModuleLoader__.load({
 				minute: "2-digit"
 			});
 		}
+		/**
+		* The dot's classes, one per tone.
+		*
+		* Written out in full instead of `\`…-dot-${tone}\`` on purpose: the panel's
+		* CSS-contract test harvests class names from this file with
+		* /dsm-workbuddy-composer-[a-z-]+/ and a template literal would contribute a
+		* dangling "…-dot-" prefix that no rule defines.
+		*/
+		const DOT_CLASS = {
+			ok: "dsm-workbuddy-composer-panel-dot dsm-workbuddy-composer-panel-dot-ok",
+			error: "dsm-workbuddy-composer-panel-dot dsm-workbuddy-composer-panel-dot-error",
+			unknown: "dsm-workbuddy-composer-panel-dot dsm-workbuddy-composer-panel-dot-unknown"
+		};
+		/**
+		* The dot class for one row: green when the account can serve, red when it cannot.
+		*
+		* The rule the owner settled on, after three rounds of this: colour answers
+		* "can it be used", and the row's second line answers "is it the one I am
+		* using". Those two questions used to share one channel — an earlier revision
+		* painted green only on the selected account, which made every usable row grey
+		* and the list read as one live row among dead ones ("这样无法知道当前用的是什么"):
+		* true about selection, false about usability, and the panel is opened mainly to
+		* ask the second question.
+		*
+		* So green is now the ordinary state of a usable account, selected or not, and
+		* "当前选用" is printed under the name of the selected one. Red carries the
+		* refusal — including a stated rate limit, which used to be amber; amber read as
+		* "mostly fine", and an account that cannot answer this message is not fine.
+		*
+		* Grey is reserved for an account nobody has measured yet. Painting it green
+		* would assert a health nobody checked, and red would assert a failure nobody
+		* saw; the absence of a reading is its own state.
+		*/
+		function dotClass(account) {
+			const tone = stateTone(account);
+			if (tone === "ok") return DOT_CLASS.ok;
+			if (tone === "warn" || tone === "error") return DOT_CLASS.error;
+			return DOT_CLASS.unknown;
+		}
+		/**
+		* The row's second line, from the facts that belong in it.
+		*
+		* Two independent ones: whether this is the account serving the tab, and — when
+		* it cannot serve — why, with the wait but never the absolute instant. Joined
+		* with the same separator the rest of this panel uses, and dropped entirely when
+		* there is nothing to say, so a plain usable row stays one line tall.
+		*/
+		function detailLine(...parts) {
+			const kept = parts.filter((part) => part !== void 0 && part !== "");
+			return kept.length === 0 ? void 0 : kept.join(" · ");
+		}
 		function ComposerCredits(props) {
 			const { t, provider, region, settingsScope } = props;
 			if (t === void 0) throw new Error("Composer credits readout requires its translation function");
@@ -5462,11 +6106,24 @@ window.__ModuleLoader__.load({
 			const [usage, setUsage] = (0, react.useState)(void 0);
 			const [accountCredits, setAccountCredits] = (0, react.useState)(void 0);
 			const [busy, setBusy] = (0, react.useState)(false);
+			/**
+			* A test batch is running.
+			*
+			* Separate from `busy`, which tracks a credits READ: the two take wildly
+			* different times (one round trip against one probe per account, serial with
+			* a gap), and sharing a flag would either freeze the readout for a minute or
+			* let a press be swallowed as "already refreshing".
+			*/
+			const [testing, setTesting] = (0, react.useState)(false);
+			/** The batch's failure, in the user's language; `failed` is for reads. */
+			const [testError, setTestError] = (0, react.useState)(void 0);
 			const [switchingId, setSwitchingId] = (0, react.useState)(void 0);
 			const [failed, setFailed] = (0, react.useState)(false);
 			const [lastRefresh, setLastRefresh] = (0, react.useState)(void 0);
 			const [open, setOpen] = (0, react.useState)(false);
 			const inFlight = (0, react.useRef)(false);
+			/** A batch is running; guards a second press that lands before `setTesting`. */
+			const testingRef = (0, react.useRef)(false);
 			/** Account-table reads in flight; see `fetchAccountCredits`. */
 			const accountsInFlight = (0, react.useRef)(0);
 			/** Which account-table read is the newest; see `fetchAccountCredits`. */
@@ -5654,26 +6311,85 @@ window.__ModuleLoader__.load({
 				}
 			};
 			/**
-			* One manual refresh, of both things the panel shows.
+			* The header button: test EVERY account in this region, then re-read what the
+			* batch changed.
 			*
-			* It used to call `fetchUsage` alone, so pressing 刷新 on the account table
-			* refreshed the trigger's balance and left every ROW exactly as it was —
-			* including its 被限流 / 模型繁忙 mark. The button sits inside the table's own
-			* header, so the user reads it as "refresh this table"; a control that
-			* refreshes something else is worse than no control, and it is one of the
-			* reasons the panel could keep claiming a state the card had already moved
-			* past.
+			* It used to be a plain refresh. The owner asked for the other thing this
+			* panel's readers actually want — the same "一键测试所有账号" the pool card
+			* runs (`src/account-pool-run.ts testAllAccounts`, one account at a time with
+			* a gap, because hitting the whole pool at once is how the upstream's volume
+			* limit gets tripped).
 			*
-			* Both reads run concurrently rather than in sequence: neither depends on the
-			* other, and awaiting the usage document first would delay the table by one
-			* round trip for no benefit. `refreshUsage` resolves rather than throws on
-			* failure (it records `failed` itself), so the table's read is never skipped
-			* because the other half went wrong.
+			* Two reasons the batch, not a read, is the right control HERE. A mark in this
+			* table is a MEASUREMENT (`被限流 · 约 6 小时后` is a probe result), and
+			* re-reading the usage document cannot improve a stale measurement — only
+			* running it again can. And the rows are the pool's members, so the question
+			* "which of these can serve?" is answered by testing them, not by asking the
+			* credits endpoint again.
+			*
+			* The re-read afterwards is not a courtesy: the probes live in the USAGE
+			* document (`usage.pool.accounts[].probe`), so the dots and marks only move
+			* once that document is fetched again. Without it the button would leave the
+			* table showing the state it just measured away.
+			*
+			* The batch answers NDJSON (one line per account, streamed) on a current Host
+			* and one document on an older one, so both shapes are read; the stream is
+			* drained even after unmount, because dropping the reader leaves the Host
+			* writing into a socket nobody reads.
 			*/
-			const refresh = (0, react.useCallback)(async () => {
-				setFailed(false);
-				await Promise.all([fetchUsage(), fetchAccountCredits(void 0, true)]);
-			}, [fetchUsage, fetchAccountCredits]);
+			const testEveryAccount = (0, react.useCallback)(async () => {
+				if (activeRegion === void 0 || testingRef.current) return;
+				testingRef.current = true;
+				if (mounted.current) {
+					setTesting(true);
+					setTestError(void 0);
+					setFailed(false);
+				}
+				try {
+					const response = await fetch(withWorkBuddyRegionAndAction(WORKBUDDY_POOL_PATH, activeRegion, "test"), {
+						method: "POST",
+						headers: { accept: "application/json" },
+						credentials: "same-origin"
+					});
+					let failure;
+					if ((response.headers.get("content-type") ?? "").includes("ndjson")) {
+						if (!response.ok) failure = poolFailureText(t, { status: response.status });
+						else await readNdjson(response.body, (line) => {
+							const row = testRowOf(line);
+							if (row !== void 0) {
+								if (mounted.current) setUsage((previous) => previous === void 0 ? previous : withTestRow(previous, row, Date.now()));
+								return;
+							}
+							const reason = line["reason"];
+							if (typeof reason !== "string") return;
+							failure = poolFailureText(t, {
+								status: 200,
+								reason,
+								error: typeof line["error"] === "string" ? line["error"] : void 0
+							});
+						});
+					} else {
+						const body = await response.json().catch(() => void 0);
+						if (!response.ok) failure = poolFailureText(t, {
+							status: response.status,
+							reason: body?.reason,
+							error: body?.error
+						});
+					}
+					if (mounted.current && failure !== void 0) setTestError(failure);
+				} catch {
+					if (mounted.current) setTestError(t("composer.testFailed"));
+				} finally {
+					testingRef.current = false;
+					if (mounted.current) setTesting(false);
+					await Promise.all([fetchUsage(), fetchAccountCredits(void 0, true)]);
+				}
+			}, [
+				activeRegion,
+				fetchUsage,
+				fetchAccountCredits,
+				t
+			]);
 			if (owned === void 0) return null;
 			/**
 			* The Host's own answer for this region, when the document carries one.
@@ -5717,6 +6433,9 @@ window.__ModuleLoader__.load({
 				};
 			});
 			const canSwitch = settingsScope !== void 0 && settingsScope.getSnapshot().writable === true;
+			const poolOrder = usage?.status === "signed-in" ? usage.pool?.orderAccountIds : void 0;
+			const orderedRows = applyManualOrder(rows, poolOrder !== void 0 && poolOrder.length > 0 ? poolOrder : settingsScope === void 0 ? [] : readOrderAccountIds(settingsScope.getSnapshot().value, activeRegion));
+			const poolById = new Map((usage?.status === "signed-in" ? usage.pool?.accounts ?? [] : []).map((account) => [account.accountId, account]));
 			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("span", {
 				ref: rootRef,
 				className: "dsm-workbuddy-composer-credits",
@@ -5752,11 +6471,12 @@ window.__ModuleLoader__.load({
 							}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
 								type: "button",
 								className: "dsm-workbuddy-composer-panel-refresh",
-								disabled: busy || switchingId !== void 0,
+								disabled: busy || testing || switchingId !== void 0,
+								title: t("composer.testAllHint"),
 								onClick: () => {
-									refresh();
+									testEveryAccount();
 								},
-								children: busy ? t("composer.refreshing") : t("composer.refresh")
+								children: testing ? t("composer.testing") : t("composer.testAll")
 							})]
 						}),
 						signedOut ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
@@ -5774,13 +6494,25 @@ window.__ModuleLoader__.load({
 								scope: "col",
 								className: "dsm-workbuddy-composer-panel-num",
 								children: t("composer.credits")
-							})] }) }), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("tbody", { children: rows.map((row) => {
+							})] }) }), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("tbody", { children: orderedRows.map((row) => {
 								const current = row.id === selectedId;
-								const excluded = exclusionText(t, row.excludedBy);
+								const poolRow = poolById.get(row.id);
+								const live = poolRow === void 0 ? current : poolRow.current;
+								const availability = poolRow ?? {
+									excludedBy: row.excludedBy,
+									probe: void 0
+								};
+								const usable = stateTone(availability) === "ok";
+								const currentMark = live ? t("composer.current") : void 0;
+								const reasonMark = usable ? void 0 : availabilityMark(t, availability);
+								const spoken = detailLine(live ? t("composer.current") : void 0, usable ? void 0 : availabilityLine(t, availability));
+								const whoLabel = spoken === void 0 ? row.accountName : `${row.accountName} — ${spoken}`;
 								return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("tr", {
 									className: current ? "dsm-workbuddy-composer-panel-row-current" : void 0,
+									title: spoken,
 									children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("th", {
 										scope: "row",
+										"aria-label": whoLabel,
 										children: /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("button", {
 											type: "button",
 											className: "dsm-workbuddy-composer-panel-switch",
@@ -5790,16 +6522,22 @@ window.__ModuleLoader__.load({
 												switchTo(row.id);
 											},
 											children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
-												className: "dsm-workbuddy-composer-panel-dot",
+												className: dotClass(availability),
 												"aria-hidden": "true"
 											}), /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("span", {
 												className: "dsm-workbuddy-composer-panel-who",
 												children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
 													className: "dsm-workbuddy-composer-panel-name",
 													children: row.accountName
-												}), excluded === void 0 ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+												}), currentMark === void 0 && reasonMark === void 0 ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("span", {
 													className: "dsm-workbuddy-composer-panel-mark",
-													children: excluded
+													children: [currentMark === void 0 ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+														className: "dsm-workbuddy-composer-panel-mark-current",
+														children: currentMark
+													}), reasonMark === void 0 ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+														className: "dsm-workbuddy-composer-panel-mark-reason",
+														children: reasonMark
+													})]
 												})]
 											})]
 										})
@@ -5822,7 +6560,12 @@ window.__ModuleLoader__.load({
 							className: "dsm-workbuddy-composer-panel-error",
 							role: "status",
 							children: t("composer.refreshFailed")
-						}) : null
+						}) : null,
+						testError === void 0 ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+							className: "dsm-workbuddy-composer-panel-error",
+							role: "status",
+							children: testError
+						})
 					]
 				}), document.body)]
 			});
@@ -6277,6 +7020,19 @@ window.__ModuleLoader__.load({
 			"row.poolSelectAll": "Select all",
 			"row.poolSelectNone": "Clear all",
 			"row.poolSelectedCount": "{count} of {total} selected",
+			"row.poolOrderRulesTitle": "How this pool chooses an account",
+			"row.poolOrderRulesIntro": "The pool always picks the first account that can actually be billed right now. The rules below are checked in order — the first one that separates two accounts decides; later rules only break ties.",
+			"row.poolOrderRuleUsable": "1. Can it be billed right now? Accounts that are rate-limited, out of credit, credential-rejected, or failing are moved to the back until their cooldown ends. This outranks everything, including your own order below.",
+			"row.poolOrderRuleExpiring": "2. Does it have credits expiring within 3 days? Yes goes first. This also outranks your manual order — see the note below.",
+			"row.poolOrderRuleManual": "3. Your manual order. The position you set with the ↑ / ↓ arrows. Accounts you never ordered are placed after every ordered one.",
+			"row.poolOrderRuleNearestExpiry": "4. Which expiry comes first? Between accounts that both have credits expiring, the one losing them sooner goes first.",
+			"row.poolOrderRuleExpiringAmount": "5. How many are expiring? Between those same accounts, the one with more at stake goes first. With nothing expiring this is equivalent to comparing totals.",
+			"row.poolOrderRuleTotal": "6. Total credits. The account holding more goes first, so a nearly-drained account is kept in reserve.",
+			"row.poolOrderRuleFreshness": "7. Freshness of the sign-in. The more recently issued credential wins a draw.",
+			"row.poolOrderRuleId": "8. Account id. A final tie-break, so the same pool always produces the same order.",
+			"row.poolOrderWhy": "Why expiring credits outrank your manual order: expiring credits are money about to disappear, while a manual order may be stale or set by accident. If the manual order won, one mis-drag could let credits lapse unused. So an account with credits expiring within 3 days always goes ahead of one without, even if you dragged it to the bottom.",
+			"row.poolOrderBadgeNote": "The badge shows the position you SAVED, not the live ranking. An account can read \"No. 2\" while being benched for a rate limit — the number is your saved preference, and the pool skips accounts it cannot bill right now.",
+			"row.poolOrderRulesToggle": "Show the full ordering rule",
 			"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} pool member(s) are no longer signed in on this machine, so they are not counted and not used: {names}. Remove any you no longer need below.",
@@ -6289,6 +7045,14 @@ window.__ModuleLoader__.load({
 			"row.poolCurrentHeader": "In use: {account}",
 			"row.poolNotMember": "Not in pool",
 			"row.poolUnsavedMembers": "Selection changed — save to apply",
+			"row.poolRankLabel": "No. {rank}",
+			"row.poolRankManualTitle": "You placed this account at position {rank} in the pool manually.",
+			"row.poolRankAuto": "Auto",
+			"row.poolRankAutoTitle": "Not manually sorted yet: the pool spends expiring credits first, then picks accounts by remaining balance. Use ↑/↓ to set your own order.",
+			"row.poolMoveUpTitle": "Move account up in this pool's order",
+			"row.poolMoveDownTitle": "Move account down in this pool's order",
+			"row.poolMoveUpAria": "Move {accountName} up in this pool's order",
+			"row.poolMoveDownAria": "Move {accountName} down in this pool's order",
 			"row.poolRowTest": "Test",
 			"row.poolRowRemove": "Remove",
 			"row.poolRowRemoveHint": "Remove this account from the list. The WorkBuddy desktop app is not signed out — it keeps its own sign-in. Removing only hides the account here; 「Detect accounts again」 brings it back.",
@@ -6317,10 +7081,13 @@ window.__ModuleLoader__.load({
 			"composer.account": "Account",
 			"composer.credits": "Credits",
 			"composer.switchTo": "Switch to {account}",
+			"composer.current": "In use",
 			"composer.noAccounts": "No account in this region",
 			"composer.signedOut": "Not signed in",
-			"composer.refresh": "Refresh credits",
-			"composer.refreshing": "Refreshing credits…",
+			"composer.testAll": "Test all",
+			"composer.testing": "Testing…",
+			"composer.testAllHint": "Test every account in this region, one at a time",
+			"composer.testFailed": "Could not test the accounts",
 			"composer.refreshFailed": "Could not refresh credits",
 			"composer.lastRefresh": "Last refreshed",
 			"composer.panelTitle": "WorkBuddy credits",
@@ -6565,6 +7332,19 @@ window.__ModuleLoader__.load({
 			"row.poolSelectAll": "全选",
 			"row.poolSelectNone": "全不选",
 			"row.poolSelectedCount": "已选 {count} / {total}",
+			"row.poolOrderRulesTitle": "本池如何挑选账号",
+			"row.poolOrderRulesIntro": "池子总是先挑「现在确实能扣费的」账号。下面这些规则按顺序逐条比较，第一条分出胜负就停止，后面的只在平局时才看。",
+			"row.poolOrderRuleUsable": "1. 现在能扣费吗？被限流、积分耗尽、凭证被拒或调用失败的账号会被挪到后面，直到冷却结束。这一条优先级最高，压过下面的手动顺序。",
+			"row.poolOrderRuleExpiring": "2. 有 3 天内会过期的积分吗？有就排前面。这一条同样压过手动顺序，原因见下方说明。",
+			"row.poolOrderRuleManual": "3. 你排的手动顺序。就是用 ↑ / ↓ 设定的位置。没有手动排过的账号，会排在所有已排序账号之后。",
+			"row.poolOrderRuleNearestExpiry": "4. 谁先过期？两个都有临期积分时，先到期的排前面。",
+			"row.poolOrderRuleExpiringAmount": "5. 过期多少？同样是两个都有临期积分时，临期数额大的排前面。没有临期积分时，这一步等同于比较总积分。",
+			"row.poolOrderRuleTotal": "6. 总积分。积分多的排前面，接近耗尽的号先留着备用。",
+			"row.poolOrderRuleFreshness": "7. 登录凭证新旧。凭证签发更晚的赢下平局。",
+			"row.poolOrderRuleId": "8. 账号 id。最终兜底，保证同样的池子每次排出来的顺序都一样。",
+			"row.poolOrderWhy": "为什么临期积分压过手动顺序：临期积分是马上要过期的钱，而手动顺序可能已经过时、也可能是手滑拖错了。如果让手动顺序赢，一次误拖就足以让积分白白过期。所以有 3 天内到期积分的账号，永远排在没有的账号前面 —— 哪怕你把它拖到了最后一位。",
+			"row.poolOrderBadgeNote": "徽标显示的是你「保存」的位置，不是此刻的实际排序。一个账号可能写着「第 2 位」却因为被限流而暂时不被选中 —— 那个数字代表你的偏好，池子会跳过当下无法扣费的账号。",
+			"row.poolOrderRulesToggle": "查看完整排序规则",
 			"row.poolNoneSelected": "这个池里还没有勾选任何账号。",
 			"row.poolNoneSelectedHint": "请在上方勾选至少一个账号并保存。在此之前两个按钮都不可用 —— 空池没有可执行的对象。",
 			"row.poolGhostMembers": "有 {count} 个已选入本池的账号在本机已不再登录，因此不计入、也不会被使用：{names}。不需要的可在下方逐个移除。",
@@ -6577,6 +7357,14 @@ window.__ModuleLoader__.load({
 			"row.poolCurrentHeader": "当前使用：{account}",
 			"row.poolNotMember": "未入池",
 			"row.poolUnsavedMembers": "勾选已改动 —— 保存后生效",
+			"row.poolRankLabel": "第 {rank} 位",
+			"row.poolRankManualTitle": "你在本池中手动把该账号排在第 {rank} 位。",
+			"row.poolRankAuto": "自动排序",
+			"row.poolRankAutoTitle": "还没有手动排序：池会先花临期积分，再按余额多寡选号。用 ↑/↓ 自己指定顺序。",
+			"row.poolMoveUpTitle": "在本池顺序中上移该账号",
+			"row.poolMoveDownTitle": "在本池顺序中下移该账号",
+			"row.poolMoveUpAria": "在本池顺序中上移 {accountName}",
+			"row.poolMoveDownAria": "在本池顺序中下移 {accountName}",
 			"row.poolRowTest": "测试",
 			"row.poolRowRemove": "删除",
 			"row.poolRowRemoveHint": "把这个账号从列表中移除。桌面 App 不会被退出登录——它保留自己的登录状态。移除只是暂时隐藏，点「重新检测账号」即可找回。",
@@ -6605,10 +7393,13 @@ window.__ModuleLoader__.load({
 			"composer.account": "账号",
 			"composer.credits": "积分",
 			"composer.switchTo": "切换到 {account}",
+			"composer.current": "当前选用",
 			"composer.noAccounts": "该区域暂无账号",
 			"composer.signedOut": "未登录",
-			"composer.refresh": "刷新积分",
-			"composer.refreshing": "正在刷新积分…",
+			"composer.testAll": "一键测试",
+			"composer.testing": "正在测试…",
+			"composer.testAllHint": "逐个测试本区所有账号（一次一个，避免触发上游限流）",
+			"composer.testFailed": "测试失败",
 			"composer.refreshFailed": "积分刷新失败",
 			"composer.lastRefresh": "最近刷新",
 			"composer.panelTitle": "WorkBuddy 积分",