dsh-connect-trae 3.10.1 → 3.10.2

package/CHANGELOG.md

@@ -1,5 +1,40 @@
 # Changelog
 
+## 3.10.2 (2026-10-19)
+
+> 设置页的账号列表**先出、积分后补**。打开卡片原本要等**一整份**用量文档组装完才画第一笔：那份文档的
+> 尾巴上挂着「逐账号读上游余额」和「逐账号读签到状态」，每个账号一次网络往返，单次超时 30 秒、没有重试，
+> 上游一慢就层层等待——这正是兄弟插件 dsh-connect-workbuddy 的 issue #77（实测 30–60 秒才看到账号）。
+> Trae 这边同一份文档里 `poolMembersOf` 甚至被调了 **4 次**（`members`、`effectiveMemberAccountIds`、
+> `memberNames`、`otherAccounts` 各一次），签到那条路还要再触发一次，所以同样的机器上比 workbuddy 更慢。
+> 本版把首屏与「测量」拆开：首屏只用本机已存的东西，测量结果随后补上。
+
+### 修复
+
+- **账号列表不再等上游余额**。`GET /usage?region=…&detail=fast` 返回一份只用本机状态的「首屏文档」：
+  `store.current()` 读已存凭据（不做网络刷新）、账号行来自新增的 `localMembers`（就是请求路径本来就在用的
+  `localPoolMembers`，零上游调用）、签到状态来自本进程已测过的缓存。**实测 0 次上游请求**，本机 1.3 秒的
+  完整文档变成毫秒级首屏。
+- **卡片分两笔画**：先请求 `detail=fast` 上屏，再请求完整文档补齐积分/签到/模型探测结果。首屏文档**永不
+  覆盖**已经在屏的完整文档——否则每次轮询都会把积分闪回「—」。
+- **首屏之前不再谎称「未登录」**。旧代码在 `statusByRegion` 里预置了一份 `signed-out` 占位文档并直接渲染，
+  于是整段等待时间里已登录的用户看到的是「去登录」引导；现在状态表初始为空，未拿到任何文档时显示新增的
+  「正在加载账号…」，真正的 `signed-out` 文档到了才显示登录引导。
+- **完整文档故意保持不变**：`detail` 缺省、或值不是精确的 `fast`（比如大小写写错、拼成 `fastest`）时一律
+  退回完整文档——宁可慢一会儿，也不能给出一份更空的卡片。
+- Host 侧配套：`TraePoolDeps` 新增可选 `localMembers` / `cachedCheckinState`，`src/index.ts` 里分别接到
+  `localPoolMembers` 与新增的签到状态缓存（`CHECKIN_CACHE_MS = 10 * 60_000`）。老版本 Host 没有这两个
+  dep 时，首屏文档**省略** pool 段而不是回头去付那次昂贵读取。
+
+### 测试
+
+- 新增 `tests/issue77-fast-first-paint.spec.ts`（11 例）：首屏文档的上游调用数为 0、用的是 `current()`
+  而不是 `resolve()`、缺 dep 时省略 pool 段、`detail` 缺省/拼错一律退回完整文档。
+- 新增 `tests/issue77-card-first-paint.spec.tsx`（3 例）：完整文档还在路上时账号行已经上屏、未拿到任何
+  文档时显示「正在加载账号」而不是「未登录」引导、迟到的首屏文档不会覆盖已在屏的完整文档。
+- 全仓 **902** 例通过，0 skipped。
+
+
 ## 3.10.1 (2026-10-19)
 
 > 「一键签到所有账号」下线。Trae 限制**每台设备每天只能签到一次**：本机任一账号签过之后，这个按钮

package/lib/client.js

@@ -136,6 +136,22 @@ window.__ModuleLoader__.load({
 		function withTraeTransferAction(path, panel, action) {
 			return `${path}?${TRAE_REGION_PARAM}=${panel}&action=${action}`;
 		}
+		/** Query parameter asking for a thinner first-paint document (issue #77). */
+		const TRAE_DETAIL_PARAM = "detail";
+		/** The only recognised `detail` value: local state only, no upstream read. */
+		const TRAE_DETAIL_FAST = "fast";
+		/**
+		* Address one panel's usage route asking for the FAST document, e.g.
+		* `/plugins/dsh-connect-trae/usage?region=cn&detail=fast`.
+		*
+		* Kept beside {@link withTraeRegion} for the same reason as
+		* {@link withTraeTransferAction}: the region is already a parameter, so a caller
+		* appending `&detail=` by hand is one typo away from a request that silently
+		* asks for the wrong document.
+		*/
+		function withTraeRegionFastDetail(path, panel) {
+			return `${withTraeRegion(path, panel)}&${TRAE_DETAIL_PARAM}=${TRAE_DETAIL_FAST}`;
+		}
 		/**
 		* Peel ONE `{get(): T}` live reference, the shape DSH 0.1.7 delivers a
 		* volatile-marked settings field as (see {@link unwrapVolatileDeep}).
@@ -3037,21 +3053,18 @@ window.__ModuleLoader__.load({
 			const [open, setOpen] = (0, react.useState)(view === "page");
 			/** The region whose tab is on screen; each tab is its own provider stack. */
 			const [activeRegion, setActiveRegion] = (0, react.useState)("cn");
-			/** Last-known usage per region, so tab dots survive tab switches. */
-			const [statusByRegion, setStatusByRegion] = (0, react.useState)({
-				cn: {
-					status: "signed-out",
-					accounts: []
-				},
-				enterprise: {
-					status: "signed-out",
-					accounts: []
-				},
-				ai: {
-					status: "signed-out",
-					accounts: []
-				}
-			});
+			/**
+			* Last-known usage per region, so tab dots survive tab switches.
+			*
+			* A region is ABSENT until something has been read for it (issue #77). It used
+			* to be seeded with a signed-out document, which meant the whole wait for the
+			* first paint rendered as "not signed in — sign in again / scan for accounts"
+			* to a user who was perfectly signed in. The difference between "nothing known
+			* yet" and "known to be signed out" is the difference between a loading line
+			* and a wrong instruction, so the map starts empty and the render below says
+			* which one it is.
+			*/
+			const [statusByRegion, setStatusByRegion] = (0, react.useState)({});
 			const [busy, setBusy] = (0, react.useState)(false);
 			/**
 			* Availability verdicts from the one-click test, per region, keyed by model
@@ -3324,10 +3337,54 @@ window.__ModuleLoader__.load({
 					return;
 				}
 			}, [t]);
+			/**
+			* Paint the fast document (issue #77).
+			*
+			* The full document above cannot answer before the Host has read every member's
+			* balance — one upstream round-trip per account, and this panel's pool assembly
+			* happens to walk the membership more than once. That is the wait the issue
+			* reports: tens of seconds in which the card used to show nothing at all.
+			*
+			* The fast document is built from local state only (no upstream read at all), so
+			* it answers in milliseconds and carries everything needed to DRAW: the bound
+			* account, its expiry, the model list and the pool rows. The live figures it
+			* omits (credits, check-in column) are exactly the values that need the round
+			* trip, and the card already renders their absence as `—` / unknown.
+			*
+			* Deliberately separate from {@link refreshUsage} rather than a parameter of it:
+			* a first paint never writes an error state (a slow upstream is not the user's
+			* problem until the full document says so), and it must never downgrade a region
+			* that has already been painted in full.
+			*/
+			const refreshUsageFast = (0, react.useCallback)(async (region, signal) => {
+				try {
+					const response = await fetch(withTraeRegionFastDetail(TRAE_USAGE_PATH, region), {
+						headers: { accept: "application/json" },
+						credentials: "same-origin",
+						...signal === void 0 ? {} : { signal }
+					});
+					if (!response.ok) return;
+					const usage = await response.json().catch(() => void 0);
+					if (usage === void 0) return;
+					if (!mounted.current || signal?.aborted === true) return;
+					setStatusByRegion((prev) => {
+						const previous = prev[region];
+						if (previous !== void 0 && previous.status === "signed-in") return prev;
+						return {
+							...prev,
+							[region]: usage
+						};
+					});
+				} catch {}
+			}, []);
 			(0, react.useEffect)(() => {
 				if (!open || !activeRegionOn) return;
 				const controller = new AbortController();
-				refreshUsage(activeRegion, controller.signal);
+				(async () => {
+					await refreshUsageFast(activeRegion, controller.signal);
+					if (controller.signal.aborted) return;
+					refreshUsage(activeRegion, controller.signal);
+				})();
 				return () => {
 					controller.abort();
 				};
@@ -3335,9 +3392,19 @@ window.__ModuleLoader__.load({
 				open,
 				activeRegion,
 				activeRegionOn,
-				refreshUsage
+				refreshUsage,
+				refreshUsageFast
 			]);
-			const status = statusByRegion[activeRegion] ?? {
+			/**
+			* The document actually on screen for this region, and whether one has arrived.
+			*
+			* `loaded === undefined` is the only state that may render the loading line: a
+			* signed-out document is a real answer (the user must sign in), never a stand-in
+			* for "still fetching".
+			*/
+			const loaded = statusByRegion[activeRegion];
+			const loading = loaded === void 0;
+			const status = loaded ?? {
 				status: "signed-out",
 				accounts: []
 			};
@@ -4023,7 +4090,7 @@ window.__ModuleLoader__.load({
 					children: view.label
 				});
 			};
-			const label = status.status === "signed-in" ? t("row.signedIn", { accountName: status.accountName }) : status.status === "error" ? t("row.requestFailed") : t("row.signedOut");
+			const label = loading ? t("row.accountsLoading") : status.status === "signed-in" ? t("row.signedIn", { accountName: status.accountName }) : status.status === "error" ? t("row.requestFailed") : t("row.signedOut");
 			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("li", {
 				className: `dsm-plugin-card${open ? " dsm-plugin-card-open" : ""}`,
 				children: [
@@ -4658,7 +4725,12 @@ window.__ModuleLoader__.load({
 										]
 									})
 								] }) : null,
-								status.status === "signed-out" ? /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+								status.status === "signed-out" && loading ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(react_jsx_runtime.Fragment, { children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+									className: "dsm-trae-usage-text",
+									role: "status",
+									children: t("row.accountsLoading")
+								}) }) : null,
+								status.status === "signed-out" && !loading ? /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
 									className: "dsm-trae-usage-text",
 									children: status.message ?? t("row.signedOutHint")
 								}), status.searched && status.searched.length > 0 ? /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("details", {
@@ -5472,6 +5544,7 @@ window.__ModuleLoader__.load({
 			"row.transferNoToken": "no token, will be skipped",
 			"row.accountsRescan": "Detect accounts again",
 			"row.accountsScanning": "Detecting…",
+			"row.accountsLoading": "Loading your accounts…",
 			"row.accountsNone": "This region reports no usable account.",
 			"row.accountCurrentBadge": "in use",
 			"row.accountSwitch": "Switch",
@@ -5793,6 +5866,7 @@ window.__ModuleLoader__.load({
 			"row.transferNoToken": "无 Token，将被跳过",
 			"row.accountsRescan": "重新检测账号",
 			"row.accountsScanning": "正在检测…",
+			"row.accountsLoading": "正在加载账号…",
 			"row.accountsNone": "该区域没有可列出的账号。",
 			"row.accountCurrentBadge": "当前使用",
 			"row.accountSwitch": "切换",

package/lib/index.d.ts

@@ -3459,6 +3459,31 @@ interface TraePoolDeps {
    * Only the status document's own assembly and an explicit batch call it.
    */
   members(panel: TraePanel): Promise<readonly TraePoolMember[]>;
+  /**
+   * One panel's pool membership from LOCAL state only — the first-paint source
+   * (issue #77).
+   *
+   * Cheap by contract in the strongest sense: no upstream read at all, so the
+   * account table can be painted before any billing endpoint answers. A member
+   * whose credit total has never been measured carries no `credits`, which the
+   * card already renders as `—` rather than as a wrong figure; the follow-up
+   * full document fills the real numbers in.
+   *
+   * A Host built without it degrades to omitting the pool block from a
+   * first-paint document rather than paying {@link members} there — the card
+   * then shows its single-account view for one refresh cycle.
+   */
+  localMembers?(panel: TraePanel): Promise<readonly TraePoolMember[]>;
+  /**
+   * The panel's saved member names, from a local scan only.
+   *
+   * The first-paint counterpart of {@link memberNames}. The full document builds
+   * these by walking {@link members} (which reads every balance), which is a
+   * second full membership pass for a map of names; the fast document must not
+   * pay that, and it does not need to: the saved-list rows it renders are the
+   * ones {@link localMembers} already names.
+   */
+  localMemberNames?(panel: TraePanel): Promise<Record<string, string>>;
   /**
    * The checked ids that still resolve to a local sign-in, from a local scan only.
    * The batch route's empty-pool guard runs this on every request, so it must not
@@ -3482,6 +3507,16 @@ interface TraePoolDeps {
    * TODAY because this machine already spent its claim on another account.
    */
   checkinState?(panel: TraePanel): Promise<Record<string, TraePoolCheckinState>>;
+  /**
+   * Today's check-in state from the cells already measured this process — the
+   * first-paint counterpart (issue #77) of {@link checkinState}.
+   *
+   * Synchronous by contract: it reads the Host's measurement cache and nothing
+   * else, so it must never start a request. A Host without it degrades to an
+   * unknown check-in column in the first paint, which the card already renders
+   * as unknown; the full document fills the column in.
+   */
+  cachedCheckinState?(panel: TraePanel): Readonly<Record<string, TraePoolCheckinState>>;
   /** Run the check-in batch. Persists nothing to settings; drops its own caches. */
   checkin?(panel: TraePanel): Promise<readonly TraePoolCheckinRow[]>;
   /** Run the model-availability batch and persist its measurements. */
@@ -3500,6 +3535,19 @@ interface TraePoolCheckinState {
   /** Whether this account is offered the reward at all; false renders `disabled`. */
   enabled?: boolean;
 }
+/**
+ * Which usage document a request asked for (issue #77).
+ *
+ * `full` is the document every earlier caller has always received: live credit
+ * figures, fresh check-in state, the ranked pool. `fast` is the same document
+ * built from LOCAL state only — no upstream read at all — so the card can paint
+ * the account table immediately and then upgrade it with the full document.
+ *
+ * The distinction lives in ONE optional query parameter (`detail`) so an old
+ * caller, a hand-written curl and a browser refresh all keep working: an absent
+ * or unrecognised value is `full`.
+ */
+type TraeStatusDetail = 'full' | 'fast';
 /**
  * Assemble one region's card document. `panel` is the tab the card is on; the
  * panel-scoped store already answers with only that region's accounts, so the
@@ -3507,7 +3555,9 @@ interface TraePoolCheckinState {
  * Sign-in state is read-only; credit is a live billing answer whose failure
  * degrades to `creditsError` rather than failing the whole document.
  */
-declare function traeWebUsage(deps: TraeUsageRouteOptions, panel: TraePanel): Promise<TraeWebUsage>;
+declare function traeWebUsage(deps: TraeUsageRouteOptions, panel: TraePanel, options?: {
+  detail?: TraeStatusDetail;
+}): Promise<TraeWebUsage>;
 /** Mount the GET usage route on an optional webServer context. */
 declare function registerTraeUsageRoute(ctx: Context$1, deps: TraeUsageRouteOptions): void;
 //#endregion

package/lib/index.js

@@ -1089,6 +1089,23 @@ function regionOfTraeStatusUrl(url) {
 	if (value === null || value === "") return "cn";
 	return TRAE_PANELS.includes(value) ? value : void 0;
 }
+/** Query parameter asking for a thinner first-paint document (issue #77). */
+const TRAE_DETAIL_PARAM = "detail";
+/** The only recognised `detail` value: local state only, no upstream read. */
+const TRAE_DETAIL_FAST = "fast";
+/**
+* Whether a request URL asks for the fast document.
+*
+* Only the exact value counts — a typo (`fastest`, `FAST`) degrades to the FULL
+* document, because a thinner panel is a worse failure than a slower one: the
+* caller that made the mistake is asking about an optimisation, so the safe
+* answer is the truthful one.
+*/
+function fastDetailOf(url) {
+	const at = url.indexOf("?");
+	if (at === -1) return false;
+	return new URLSearchParams(url.slice(at + 1)).get(TRAE_DETAIL_PARAM) === TRAE_DETAIL_FAST;
+}
 /**
 * Peel ONE `{get(): T}` live reference, the shape DSH 0.1.7 delivers a
 * volatile-marked settings field as (see {@link unwrapVolatileDeep}).
@@ -6856,7 +6873,8 @@ function toCheckin(status) {
 * Sign-in state is read-only; credit is a live billing answer whose failure
 * degrades to `creditsError` rather than failing the whole document.
 */
-async function traeWebUsage(deps, panel) {
+async function traeWebUsage(deps, panel, options = {}) {
+	const fast = options.detail === "fast";
 	const store = deps.store(panel);
 	const enabled = deps.regionEnabled(panel);
 	/**
@@ -6887,7 +6905,8 @@ async function traeWebUsage(deps, panel) {
 	}
 	let credential;
 	try {
-		credential = await store.resolve();
+		credential = fast ? await store.current() : await store.resolve();
+		if (credential === void 0) credential = await store.resolve();
 	} catch (error) {
 		return {
 			status: "signed-out",
@@ -6916,7 +6935,16 @@ async function traeWebUsage(deps, panel) {
 		enabledModelIds: [...deps.enabledModelIds(panel)],
 		...deps.rawDiagnostic === void 0 ? {} : { rawChat: deps.rawDiagnostic(panel) }
 	};
-	const poolSection = await poolSectionOf(deps, panel);
+	if (fast) {
+		const poolSection = await poolSectionOf(deps, panel, true);
+		return {
+			status: "signed-in",
+			...account,
+			...poolSection,
+			...panel === "enterprise" ? { creditsUnavailable: "enterprise" } : {}
+		};
+	}
+	const poolSection = await poolSectionOf(deps, panel, false);
 	const client = deps.client(panel);
 	if (regionOfPanel(panel) === "ai") try {
 		const payStatus = await client.payStatus();
@@ -7009,10 +7037,10 @@ async function creditAlternatives(deps, panel, accounts) {
 * BOUND account, which `traeWebUsage` reports as `status: error` before the pool
 * is even assembled.
 */
-async function poolSectionOf(deps, panel) {
+async function poolSectionOf(deps, panel, fast = false) {
 	if (deps.pool === void 0) return {};
 	try {
-		const pool = await traeWebPool(deps, panel);
+		const pool = await traeWebPool(deps, panel, fast);
 		return pool === void 0 ? {} : { pool };
 	} catch {
 		return {};
@@ -7030,20 +7058,35 @@ async function poolSectionOf(deps, panel) {
 * Every per-row read is failure-tolerant on purpose: one account whose balance
 * read throws must not remove the other members from the table.
 */
-async function traeWebPool(deps, panel) {
+async function traeWebPool(deps, panel, fast = false) {
 	const pool = deps.pool;
 	if (pool === void 0) return void 0;
 	const preferences = pool.preferences(panel);
-	const members = await pool.members(panel);
+	const members = fast ? await pool.localMembers?.(panel) : await pool.members(panel);
+	if (members === void 0) return void 0;
 	const nowMs = Date.now();
 	const ranked = rankPool(members, nowMs);
 	const target = resolveTargetModel(pool.catalog?.(panel) ?? [], preferences.targetModelId);
 	const byId = new Map(members.map((member) => [member.account.id, member]));
 	const excludedById = new Map(ranked.flatMap((row) => row.excludedBy === void 0 ? [] : [[row.account.id, row.excludedBy]]));
 	const rankedIds = new Set(ranked.map((row) => row.account.id));
-	const others = (await pool.otherAccounts?.(panel) ?? []).filter((account) => !rankedIds.has(account.id));
-	const checkinState = await pool.checkinState?.(panel).catch(() => ({})) ?? {};
-	const memberNames = await pool.memberNames?.(panel).catch(() => ({})) ?? {};
+	/**
+	* ISSUE #77: every dep below is shaped so the first paint can avoid the
+	* upstream. `otherAccounts`, `memberNames` and `checkinState` are all derived
+	* from a FULL membership pass on this Host (one balance read per account), and
+	* three of them in a row is most of the reported wait. The fast document
+	* answers the same questions from the roster it already has:
+	*
+	* - `otherAccounts`: the local roster minus the members already ranked. The
+	*   saved-but-unreachable ghosts are added below from `preferences` anyway, so
+	*   nothing a row is built from goes missing.
+	* - `memberNames`: only consulted for ghosts, whose rows the fast document
+	*   carries from `localMemberNames` when the Host offers it.
+	* - `checkinState`: the measurement cache, read synchronously.
+	*/
+	const others = fast ? members.filter((member) => !rankedIds.has(member.account.id)).map((member) => member.account) : (await pool.otherAccounts?.(panel) ?? []).filter((account) => !rankedIds.has(account.id));
+	const checkinState = fast ? { ...pool.cachedCheckinState?.(panel) ?? {} } : await pool.checkinState?.(panel).catch(() => ({})) ?? {};
+	const memberNames = fast ? await pool.localMemberNames?.(panel).catch(() => ({})) ?? {} : await pool.memberNames?.(panel).catch(() => ({})) ?? {};
 	const currentAccountId = await pool.currentAccountId?.(panel).catch(() => void 0);
 	/**
 	* A row per listed account, members first.
@@ -7239,8 +7282,9 @@ function registerTraeUsageRoute(ctx, deps) {
 				}
 				const panel = requestRegion(req, res);
 				if (panel === void 0) return;
+				const detail = fastDetailOf(req.url ?? "") ? "fast" : "full";
 				try {
-					json(res, 200, await traeWebUsage(deps, panel));
+					json(res, 200, await traeWebUsage(deps, panel, { detail }));
 				} catch (error) {
 					json(res, 500, { error: safeMessage(error) });
 				}
@@ -8543,6 +8587,15 @@ const Config = z.object({
 /** Every region, in card tab order. */
 const REGION_KEYS = ["cn", "ai"];
 /**
+* How long a measured check-in state stays usable (issue #77).
+*
+* The upstream rewards ONE check-in per device per day, so a figure measured
+* minutes ago cannot have changed; re-reading it is a pure upstream round-trip.
+* Ten minutes matches the sibling plugin's cache and is comfortably shorter than
+* a day, so a genuine second check-in still shows up on the next poll after it.
+*/
+const CHECKIN_CACHE_MS = 6e5;
+/**
 * What ONE failed real request means for the account that served it (issue #44).
 *
 * The shim only reports account-scoped kinds here, so this table never has to
@@ -8992,6 +9045,24 @@ function apply(ctx, config) {
 		enterprise: /* @__PURE__ */ new Map(),
 		ai: /* @__PURE__ */ new Map()
 	};
+	/**
+	* Today's check-in state per account, measured by the LAST full read.
+	*
+	* Issue #77: the check-in column used to be an upstream call per account with
+	* no memory at all, so every open of the card paid for every member twice (the
+	* pool's own membership pass plus one `checkinStatus()` each). The first-paint
+	* document may not wait for any of that, and re-measuring what was measured
+	* minutes ago buys nothing: a check-in happens at most once per device per day.
+	*
+	* Entries older than {@link CHECKIN_CACHE_MS} are treated as absent rather than
+	* as stale truth, so a document never claims "already checked in" off yesterday's
+	* measurement. A cold cache means "not read", which the card renders as unknown.
+	*/
+	const checkinStateCache = {
+		cn: {},
+		enterprise: {},
+		ai: {}
+	};
 	const poolCreditsOfAccount = async (panel, accountId) => {
 		const credits = await stacks[panel].creditsOfAccount(accountId);
 		if (credits === void 0) return void 0;
@@ -9067,6 +9138,24 @@ function apply(ctx, config) {
 		}));
 	};
 	/**
+	* Today's check-in state from the cells already measured — the first-paint read
+	* (issue #77).
+	*
+	* Synchronous and local by contract: it never starts a request, so the card's
+	* first paint cannot be held by the upstream. Only FRESH cells are returned; an
+	* expired entry is dropped rather than reported, because "checked in" from four
+	* hours ago is a claim about a day that may already be over.
+	*/
+	function cachedCheckinStateOf(panel) {
+		const nowMs = Date.now();
+		const state = {};
+		for (const [accountId, entry] of Object.entries(checkinStateCache[panel])) {
+			if (nowMs - entry.atMs >= CHECKIN_CACHE_MS) continue;
+			state[accountId] = entry.state;
+		}
+		return state;
+	}
+	/**
 	* Pool members from LOCAL state only: the store's logins, the saved probes and
 	* the cached credit totals. No upstream call, so it is safe on the request
 	* path (see {@link poolCreditCache} for why the cache exists).
@@ -9291,7 +9380,8 @@ function apply(ctx, config) {
 			checkinSupported: (stored) => regionOfPanel(stored) === "cn",
 			checkin: async (stored) => checkinAllAccounts(await poolTargetsOf(stored), probeDeps()),
 			checkinState: async (stored) => {
-				const state = {};
+				const state = cachedCheckinStateOf(stored);
+				const nowMs = Date.now();
 				for (const target of await poolTargetsOf(stored)) {
 					const credential = await stacks[stored].store.resolveCredentialOf(target.accountId);
 					if (credential === void 0) continue;
@@ -9301,15 +9391,21 @@ function apply(ctx, config) {
 					});
 					try {
 						const status = await client.checkinStatus();
-						state[target.accountId] = {
+						const measured = {
 							checkedIn: status.checkedIn,
 							deviceCheckedIn: status.didCheckedIn,
 							enabled: status.enabled
 						};
+						state[target.accountId] = measured;
+						checkinStateCache[stored][target.accountId] = {
+							state: measured,
+							atMs: nowMs
+						};
 					} catch {}
 				}
 				return state;
 			},
+			cachedCheckinState: (stored) => cachedCheckinStateOf(stored),
 			test: async (stored, modelId, onRow) => {
 				await warmWireMap(stored);
 				const probeInputTokens = probeInputTokensOf(stored);
@@ -9409,6 +9505,12 @@ function apply(ctx, config) {
 		pool: {
 			preferences: (panel) => poolPreferencesOf(panel),
 			members: (panel) => poolMembersOf(panel),
+			localMembers: (panel) => localPoolMembers(panel),
+			localMemberNames: async (panel) => {
+				const names = {};
+				for (const member of await localPoolMembers(panel)) names[member.account.id] = member.account.accountName;
+				return names;
+			},
 			effectiveMemberAccountIds: async (panel) => {
 				return effectiveMembersOf(poolPreferencesOf(panel).memberAccountIds ?? [], new Set((await poolMembersOf(panel)).map((member) => member.account.id)));
 			},
@@ -9423,6 +9525,7 @@ function apply(ctx, config) {
 			checkinSupported: (panel) => regionOfPanel(panel) === "cn",
 			checkin: (panel) => poolDepsOf(panel).checkin?.(panel) ?? Promise.resolve([]),
 			checkinState: (panel) => poolDepsOf(panel).checkinState?.(panel) ?? Promise.resolve({}),
+			cachedCheckinState: (panel) => cachedCheckinStateOf(panel),
 			test: (panel, modelId, onRow) => poolDepsOf(panel).test?.(panel, modelId, onRow) ?? Promise.resolve([]),
 			testOne: (panel, accountId) => poolDepsOf(panel).testOne?.(panel, accountId) ?? Promise.resolve(void 0),
 			removeOne: (panel, accountId) => poolDepsOf(panel).removeOne?.(panel, accountId) ?? Promise.resolve(false)

package/package.json

@@ -2,7 +2,7 @@
   "name": "dsh-connect-trae",
   "displayName": "DSH Connect Trae",
   "description": "把本机登录的 Trae 模型接入 DeepSeek Harness：国内版与国际版双供应商并行，提供用量/积分概览与每日签到领取。",
-  "version": "3.10.1",
+  "version": "3.10.2",
   "author": "dingminhua",
   "copyright": "Copyright (c) 2026 LaoDing",
   "license": "MIT",