dsh-llm-codebuddy-power 1.0.0 → 1.3.0

package/lib/cli-login.js

@@ -354,7 +354,7 @@ async function writeJsonAtomic(path, value) {
 * (`$DSH_HOME/data/plugins/llm-codebuddy-power/`,通过 harness 所用的同一个
 * `@deepseek-ai/dsh-home-paths` 解析),而不放在插件包内,因此重装不会让
 * 用户退出登录。写入经 [atomic-file.ts](./atomic-file.ts) 做原子替换并按路径串行化:
-* 多个账号的令牌刷新、设置页的增删与 CLI 的调用都在改同一份文件,不串行化时
+* 多个账号的令牌刷新、配置页的增删与 CLI 的调用都在改同一份文件,不串行化时
 * 两个并发写入会各自基于自己读到的旧内容覆盖对方。残缺文件会让用户手里只有
 * 一份读不出的凭据,还无法与“从未登录过”区分开。
 *
@@ -429,9 +429,8 @@ function trimEmptyAccountFields(account) {
 * 把解析出的 JSON 归一化为账号集合。
 *
 * 同时接受当前形态与仅有一个账号的旧形态(顶层 `auth` + `account`):旧文件
-* 迁移成单元素列表,并让那个账号成为默认账号,于是升级不会改变用户下一次
-* 请求用的是谁。`defaultUid` 与 `lastUid` 指向已不存在的账号时丢弃——它们只是
-* 指针,留着会让“有没有默认账号”与实际情况相反。
+* 迁移成单元素列表,于是升级不会改变用户下一次请求用的是谁。`lastUid` 指向已不
+* 存在的账号时丢弃 —— 它只是个指针,留着会让兜底落到一个用不了的账号上。
 * @param parsed - 解析出的 JSON 值。
 * @returns 归一化后的账号集合。
 */
@@ -447,22 +446,17 @@ function normalizeStorage(parsed) {
 			if (typeof value !== "string") return void 0;
 			return accounts.some((a) => a.account.uid === value) ? value : void 0;
 		};
-		const defaultUid = pick(record.defaultUid);
 		const lastUid = pick(record.lastUid);
 		return {
 			accounts,
-			...defaultUid === void 0 ? {} : { defaultUid },
 			...lastUid === void 0 ? {} : { lastUid }
 		};
 	}
 	if (!isAccountEntry(record)) return emptyStorage();
-	return {
-		accounts: [{
-			auth: record.auth,
-			account: trimEmptyAccountFields(record.account)
-		}],
-		defaultUid: record.account.uid
-	};
+	return { accounts: [{
+		auth: record.auth,
+		account: trimEmptyAccountFields(record.account)
+	}] };
 }
 /**
 * 读取已存储的账号集合。
@@ -502,55 +496,37 @@ async function updateStorage(change) {
 * 插入一个账号,或替换同 uid 账号的凭据。
 *
 * 同 uid 视为重新登录同一个账号:令牌被替换而不是追加成第二个条目,否则
-* 设置页会出现两个同名徽章,退出其中一个还会留下另一个。
+* 配置页会出现两个同名徽章,退出其中一个还会留下另一个。
 * @param entry - 刚登录得到的账号。
 */
 async function upsertAccount(entry) {
 	await updateStorage((current) => {
 		const uid = entry.account.uid;
 		const accounts = current.accounts.some((a) => a.account.uid === uid) ? current.accounts.map((a) => a.account.uid === uid ? entry : a) : [...current.accounts, entry];
-		const defaultUid = current.defaultUid ?? (current.accounts.length === 0 ? uid : void 0);
+		const lastUid = current.lastUid ?? (current.accounts.length === 0 ? uid : void 0);
 		return {
 			accounts,
-			...defaultUid === void 0 ? {} : { defaultUid },
-			...current.lastUid === void 0 ? {} : { lastUid: current.lastUid }
+			...lastUid === void 0 ? {} : { lastUid }
 		};
 	});
 }
 /**
-* 移除若干账号,并清掉指向它们的默认账号与“最后一次手动切换”的账号。
+* 移除若干账号,并清掉指向它们的“最后一次手动切换”的账号。
 * @param uids - 要移除的账号 uid。
 */
 async function removeAccounts(uids) {
 	const removed = new Set(uids);
 	await updateStorage((current) => {
 		const accounts = current.accounts.filter((a) => !removed.has(a.account.uid));
-		const gone = (uid) => uid !== void 0 && removed.has(uid) ? void 0 : uid;
-		const defaultUid = gone(current.defaultUid);
-		const lastUid = gone(current.lastUid);
+		const lastUid = current.lastUid !== void 0 && removed.has(current.lastUid) ? void 0 : current.lastUid;
 		return {
 			accounts,
-			...defaultUid === void 0 ? {} : { defaultUid },
 			...lastUid === void 0 ? {} : { lastUid }
 		};
 	});
 }
 /**
-* 指定或取消默认账号。
-* @param uid - 默认账号的 uid;传 `undefined` 取消默认账号。
-*/
-async function setDefaultAccount(uid) {
-	await updateStorage((current) => {
-		const next = {
-			accounts: current.accounts,
-			...current.lastUid === void 0 ? {} : { lastUid: current.lastUid }
-		};
-		if (uid !== void 0 && current.accounts.some((a) => a.account.uid === uid)) next.defaultUid = uid;
-		return next;
-	});
-}
-/**
-* 记下最后一次被手动切换到的账号(没有默认账号时作为兜底)。
+* 记下最后一次被手动切换到的账号,作为未选用账号的会话的兜底。
 * @param uid - 被切换到的账号 uid。
 */
 async function setLastAccount(uid) {
@@ -800,16 +776,19 @@ function normalizeResetTime(raw) {
 	return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`;
 }
 /**
-* 判断某个套餐显示名是否表示一次性赠送额度。
+* 判断某个计量窗口是否是一次性赠送额度。
 *
-* CodeBuddy 的个人计量面把推荐/裂变额度命名为“裂变包”,未来任何促销都可能
-* 带有“赠送”;其他一切(试用/可续期主套餐、企业行)都视为主池。显示名是
-* 计量面暴露的唯一区分依据,因此两种写法都会被匹配。
-* @param name - 窗口的显示名。
-* @returns 赠送套餐名返回 true。
+* 依据是子产品编码:{@link CODEBUDDY_GIFT_SUB_PRODUCT_CODE} 由全部赠送活动共用,
+* 而可续期主套餐用另一个编码。套餐显示名不能独立作依据 —— 两类赠送活动的
+* `PackageCode` 不同、显示名也不同,只有一类名字里带“裂变”,另一类叫“拉新权益包”,
+* 按名匹配会把后者错算进主池。显示名与子产品名因此只作兜底,供未来换了子产品编码
+* 却仍在名字里沿用“裂变/赠送”字样的赠送活动使用。
+* @param resource - `Accounts` 数组里的一项。
+* @returns 赠送窗口返回 true。
 */
-function isGiftName(name) {
-	return /裂变|赠送/.test(name);
+function isGiftResource(resource) {
+	if (string(resource, "SubProductCode") === "sp_tcaca_codebuddyide_bonus_pack") return true;
+	return /裂变|赠送/.test(string(resource, "PackageName") ?? "") || /裂变|赠送/.test(string(resource, "SubProductName") ?? "");
 }
 /**
 * 把有可用容量的窗口聚合成一个池(used/limit 求和)。
@@ -838,13 +817,13 @@ function liveGiftWindows(windows) {
 /**
 * 构建个人快照的主池/赠送池划分,以及提示框的赠送明细(最早过期的有效赠送
 * 在前,最多 5 个)。
-* @param windows - 已解析的窗口。
+* @param windows - 已解析的窗口,各自带 {@link UsageWindow.gift} 归属。
 * @returns 该划分,仅当对应池有可用 limit 时才包含 `main`/`gift`。
 */
 function splitPools(windows) {
 	const mainWindows = [];
 	const giftWindows = [];
-	for (const window of windows) if (isGiftName(window.name)) giftWindows.push(window);
+	for (const window of windows) if (window.gift) giftWindows.push(window);
 	else mainWindows.push(window);
 	const main = poolOf(mainWindows);
 	const live = liveGiftWindows(giftWindows);
@@ -883,14 +862,17 @@ function personalUsage(accounts) {
 		const name = string(resource, "PackageName") ?? string(resource, "PackageCode") ?? string(resource, "ResourceId") ?? `resource_${index}`;
 		const rawReset = string(resource, "CycleEndTime");
 		const resetsAt = rawReset === void 0 ? void 0 : normalizeResetTime(rawReset);
+		const gift = isGiftResource(resource);
 		if (limit <= 0) return {
 			name,
+			gift,
 			...resetsAt === void 0 ? {} : { resetsAt }
 		};
 		return {
 			name,
 			used,
 			limit,
+			gift,
 			...resetsAt === void 0 ? {} : { resetsAt }
 		};
 	});
@@ -920,6 +902,7 @@ function enterpriseUsage(data) {
 		name: "enterprise",
 		used,
 		limit,
+		gift: false,
 		...reset === void 0 ? {} : { resetsAt: reset }
 	};
 	const main = poolOf([window]);
@@ -1113,10 +1096,14 @@ function isAccountRef(value) {
 /**
 * 文件读出的记录是否合法。
 *
-* `accounts` 与 `credit` 同为必填:一条记录说不出这一轮用的是哪个账号,悬停提示就会
-* 缺一行,那与"没有这条记录"没有区别,因此不完整即整条丢弃。引用还必须能在同一份
-* 文件的账号表里解析到 —— 一个悬空引用渲染不出账号,与缺字段是同一种残缺。
-* 插件尚未发布,磁盘上不存在按旧格式写下的文件,故不保留渐进读取。
+* `credit` 与 `accounts` 同为必填:一条记录说不出这一轮扣了多少、用的是哪个账号,
+* 就答不了它存在的唯一问题,与"没有这条记录"没有区别,因此不完整即整条丢弃。引用
+* 还必须能在同一份文件的账号表里解析到 —— 一个悬空引用渲染不出账号,与缺字段是同
+* 一种残缺。
+*
+* `requestId` 则允许缺失:它是后加的字段,已发布的旧版本写下的记录没有它。那些轮次
+* 照常显示积分,只是拿不出请求 id,因此不值得为它丢掉整轮积分。存在时必须是字符串,
+* 否则是损坏内容而不是旧格式。
 * @param value - 文件里的一条轮次记录。
 * @param table - 同一份文件的账号表。
 * @returns 该记录是否可用。
@@ -1124,7 +1111,7 @@ function isAccountRef(value) {
 function isCreditRecord(value, table) {
 	if (typeof value !== "object" || value === null) return false;
 	const record = value;
-	return typeof record.credit === "number" && Number.isFinite(record.credit) && Array.isArray(record.accounts) && record.accounts.length > 0 && record.accounts.every((key) => typeof key === "string" && isAccountRef(table[key]));
+	return typeof record.credit === "number" && Number.isFinite(record.credit) && Array.isArray(record.accounts) && record.accounts.length > 0 && record.accounts.every((key) => typeof key === "string" && isAccountRef(table[key])) && (record.requestId === void 0 || typeof record.requestId === "string");
 }
 /**
 * 读取一个会话的信息。
@@ -1212,7 +1199,8 @@ async function updateSessionInfo(sessionId, change) {
 * 并发调用会互相取到对方的刷新结果,其中一个的 token 永远停留过期。
 *
 * 账号由会话决定:某个会话显式选了账号就用它,否则顺延到派生它的会话(子代理、
-* fork)、默认账号、最后一次手动切换的账号,最后落到列表第一个。目录与计量快照
+* fork),再落到账号级兜底(最后一次手动切换的账号,其次是列表第一个)。会话在
+* 第一次真正发请求时把解析到的账号固定下来,此后不再跟随兜底。目录与计量快照
 * 也按账号分别缓存,因为不同账号的可用模型与额度本就可以不同。
 *
 * @module dsh-llm-codebuddy-power/session
@@ -1257,7 +1245,8 @@ function resolveCreditRecord(record, table) {
 	}
 	return {
 		credit: record.credit,
-		accounts
+		accounts,
+		...record.requestId === void 0 ? {} : { requestId: record.requestId }
 	};
 }
 /**
@@ -1327,7 +1316,7 @@ var CodeBuddySession = class {
 	*
 	* 集合只由**带会话身份的**读取填充(聊天请求、模型面板),并供拿不到会话身份的
 	* 调用方({@link knownModel}、`listModels`)查询:那些调用方无法知道该用哪个账号
-	* 的目录,主动读取只能落在默认账号上 —— 而当前会话用的可能正是另一个账号。
+	* 的目录,主动读取只能落在账号级兜底上 —— 而当前会话用的可能正是另一个账号。
 	*/
 	knownCatalog = /* @__PURE__ */ new Map();
 	/** 按账号 uid 单飞的目录读取。 */
@@ -1444,12 +1433,14 @@ var CodeBuddySession = class {
 		const existing = track.credits.get(turn);
 		const accounts = existing?.accounts ?? [];
 		const known = accounts.some((entry) => entry.uid === account.uid);
+		const requestId = existing?.requestId ?? track.turnRequestId;
 		const merged = {
 			credit: (existing?.credit ?? 0) + credit,
 			accounts: known ? accounts : [...accounts, {
 				nickname: account.nickname,
 				uid: account.uid
-			}]
+			}],
+			requestId
 		};
 		track.credits.set(turn, merged);
 		updateSessionInfo(sessionId, (info) => {
@@ -1469,7 +1460,8 @@ var CodeBuddySession = class {
 					...info.credits,
 					[String(turn)]: {
 						credit: merged.credit,
-						accounts: keys
+						accounts: keys,
+						...merged.requestId === void 0 ? {} : { requestId: merged.requestId }
 					}
 				}
 			};
@@ -1518,7 +1510,7 @@ var CodeBuddySession = class {
 	/**
 	* 由当前缓存的各账号目录重建合并目录。
 	*
-	* 账号退出后的处理必须是"重建"而不是"清空":清空会让官方列表塌回默认账号,
+	* 账号退出后的处理必须是"重建"而不是"清空":清空会让官方列表塌回账号级兜底,
 	* 而其余仍登录账号的目录本来就在手上 —— 继续并着才是"退出后重新合并当前已有的
 	* 列表"。重建同时确定性地解决同 id 的归属:只剩下仍在的账号参与竞争。
 	*/
@@ -1554,7 +1546,7 @@ var CodeBuddySession = class {
 	* 或每记一次“最后切换的账号”都会被当成账号变更,从而丢掉按账号缓存的计量快照并
 	* 广播一次模型变更 —— 那些都不是账号增删。真的增删时才会丢弃已退出账号的缓存并
 	* 重建合并目录:退出一个账号后官方列表应当继续并着其余账号已读到的目录,而不是
-	* 塌回默认账号一个。
+	* 塌回账号级兜底那一个。
 	*/
 	async refreshIfChanged() {
 		const storageKey = await storageFreshness();
@@ -1576,8 +1568,9 @@ var CodeBuddySession = class {
 	* 该会话自身及其派生祖先显式选用的账号,由近及远。读取某个会话的信息可能要碰盘,
 	* 因此本方法是异步的。
 	*
-	* 走到祖先是因为子代理与 fork 出来的会话在界面上没有自己的账号按钮:它们若不
-	* 沿用父会话,就会静默改用默认账号,把一次派发记到另一个账号头上。
+	* 走到祖先是因为子代理与 fork 出来的会话在**固定之前**还没有自己的账号:子代理
+	* 界面上从来就没有账号按钮,若不沿用父会话就会静默改用账号级兜底,把一次派发记到
+	* 另一个账号头上;fork 有自己的按钮,但它在被切换之前也应当跟着父会话走。
 	*/
 	async accountChain(sessionId) {
 		const chain = [];
@@ -1594,17 +1587,39 @@ var CodeBuddySession = class {
 	/**
 	* 该会话此刻生效的账号 uid。
 	*
-	* 顺序:会话(或其派生祖先)显式选用的账号 → 默认账号 → 最后一次手动切换的
-	* 账号 → 列表第一个。指向已退出账号的选择会被跳过,而不是当成“没有账号”;
-	* 全部落空时返回 `undefined`,调用方据此报未登录。
+	* 顺序:会话(或其派生祖先)显式选用的账号 → 最后一次手动切换的账号 → 列表第一个。
+	* 指向已退出账号的选择会被跳过,而不是当成“没有账号”;全部落空时返回
+	* `undefined`,调用方据此报未登录。
 	*/
 	async accountUidFor(sessionId) {
 		if (sessionId !== void 0) {
 			for (const uid of await this.accountChain(sessionId)) if (this.accountEntry(uid) !== void 0) return uid;
 		}
-		for (const fallback of [this.storage?.defaultUid, this.storage?.lastUid]) if (this.accountEntry(fallback) !== void 0) return fallback;
+		const last = this.storage?.lastUid;
+		if (this.accountEntry(last) !== void 0) return last;
 		return this.storage?.accounts[0]?.account.uid;
 	}
+	/**
+	* 把该会话此刻解析到的账号写进它自己的文件,使它从此不再跟随账号级兜底。
+	*
+	* 已有选择就不再动它。那有两种可能,而两种都不该被覆盖:早已固定的会话重写只是
+	* 同一份事实的重复落盘;而记录指向一个已退出账号时,读取侧按"没有选择"处理它,
+	* 磁盘上的记录则只增不删 —— 覆盖掉它会让该账号重新登录后不再回到这个会话。
+	* @param sessionId - dsh 会话身份。
+	* @param uid - 本次请求实际使用的账号 uid。
+	*/
+	async pinAccount(sessionId, uid) {
+		const info = await this.infoOf(sessionId);
+		if (info.uid !== void 0) return;
+		await updateSessionInfo(sessionId, (current) => current.uid === void 0 ? {
+			...current,
+			uid
+		} : current);
+		this.infos.set(sessionId, {
+			...info,
+			uid
+		});
+	}
 	identityOf(entry) {
 		return {
 			accessToken: entry.auth.accessToken,
@@ -1633,13 +1648,21 @@ var CodeBuddySession = class {
 	}
 	/**
 	* 已存账号条目,在首次使用、失效之后以及文件被外部改动时从磁盘读取。
-	* @param sessionId - 用哪个会话的账号;会话未选用时按默认账号解析。
+	*
+	* 解析出的账号在返回前固定进该会话自己的文件,因此"这个会话用哪个账号"只在它
+	* 第一次真正发请求时从全局兜底取一次;此后用户别处切换账号不会再改变它。固定
+	* 挂在这里而不是账号解析处(见 {@link accountUidFor}),是因为本方法只被
+	* {@link requestIdentity} 调用,即只有真实请求经过 —— 界面上打开一个空会话所
+	* 触发的用量与目录读取不会落下任何记录。
+	* @param sessionId - 用哪个会话的账号;会话未选用时按账号级兜底解析。
 	* @throws NotLoggedInError 未存有任何凭据时。
 	*/
 	async require(sessionId) {
 		await this.refreshIfChanged();
-		const entry = this.accountEntry(await this.accountUidFor(sessionId));
+		const uid = await this.accountUidFor(sessionId);
+		const entry = this.accountEntry(uid);
 		if (entry === void 0) throw new NotLoggedInError("CodeBuddy is not signed in. Run `dsh plugin --profile web codebuddy-power` to sign in through your browser; no API key is required.");
+		if (sessionId !== void 0 && uid !== void 0) await this.pinAccount(sessionId, uid);
 		return entry;
 	}
 	/**
@@ -1699,7 +1722,7 @@ var CodeBuddySession = class {
 	* 两者在**同一次**身份解析中一起给出:分开解析会有两次账号选择,而账号是每次请求
 	* 解析的(用户可在同一步里切换),两次解析可能落到不同账号上 —— 那样记进这一轮的
 	* 账号名就与实际发出去的请求不符。缩写由落盘侧按同一规则算出,故此处给出完整账号。
-	* @param sessionId - 请求所属的会话;决定用哪个账号,缺省时用默认账号。
+	* @param sessionId - 请求所属的会话;决定用哪个账号,缺省时按账号级兜底。
 	* @returns 身份请求头与发起该请求的账号。
 	*/
 	async requestIdentity(sessionId) {
@@ -1721,19 +1744,16 @@ var CodeBuddySession = class {
 		return (this.storage?.accounts.length ?? 0) > 0;
 	}
 	/**
-	* 已存账号及其默认账号,供设置页与会话切换按钮展示。
-	* @returns 账号列表(顺序与磁盘一致)与默认账号 uid;未登录时列表为空。
+	* 已存账号,供配置页与会话切换按钮展示。
+	* @returns 账号列表(顺序与磁盘一致);未登录时列表为空。
 	*/
 	async accountList() {
 		await this.refreshIfChanged();
-		return {
-			accounts: (this.storage?.accounts ?? []).map(accountInfo),
-			...this.storage?.defaultUid === void 0 ? {} : { defaultUid: this.storage.defaultUid }
-		};
+		return (this.storage?.accounts ?? []).map(accountInfo);
 	}
 	/**
 	* 某会话此刻生效的账号 uid。
-	* @param sessionId - dsh 会话身份;缺省时用默认账号。
+	* @param sessionId - dsh 会话身份;缺省时按账号级兜底。
 	* @returns 账号 uid;一个账号也没有时为 `undefined`。
 	*/
 	async activeUid(sessionId) {
@@ -1742,6 +1762,10 @@ var CodeBuddySession = class {
 	}
 	/**
 	* 把某会话的账号切换为指定账号,并把它记为最后一次手动切换的账号。
+	*
+	* 该会话已有持久记录才写它自己的文件;一个还从未落过盘的新会话只更新账号级的
+	* `lastUid` —— 它可能永远不会被发过第一条消息,为它建文件会在磁盘上留下无人
+	* 认领的残留文件。这类会话在真正发请求时由 {@link require} 固定下来。
 	* @param sessionId - dsh 会话身份。
 	* @param uid - 要使用的账号 uid。
 	* @returns 该 uid 是已存账号时为 true;否则不做任何改动并返回 false。
@@ -1749,7 +1773,9 @@ var CodeBuddySession = class {
 	async activate(sessionId, uid) {
 		await this.refreshIfChanged();
 		if (this.accountEntry(uid) === void 0) return false;
+		await setLastAccount(uid);
 		const info = await this.infoOf(sessionId);
+		if (info.uid === void 0 && Object.keys(info.credits).length === 0) return true;
 		await updateSessionInfo(sessionId, (current) => ({
 			...current,
 			uid
@@ -1758,13 +1784,12 @@ var CodeBuddySession = class {
 			...info,
 			uid
 		});
-		await setLastAccount(uid);
 		return true;
 	}
 	/**
 	* CodeBuddy 模型目录,短暂缓存,并在并发读取者之间共享。
 	* @param signal - 底层读取的可选取消信号。
-	* @param sessionId - 用哪个会话的账号;缺省时用默认账号。
+	* @param sessionId - 用哪个会话的账号;缺省时按账号级兜底解析。
 	* @returns 目录中的模型,按服务自身的顺序。
 	*/
 	async models(signal, sessionId) {
@@ -1774,7 +1799,7 @@ var CodeBuddySession = class {
 	* 目录及其推广与档位,在同一个 TTL 下按账号一起缓存,并按账号单飞,使列表与
 	* 面板富化共享同一次读取。
 	* @param signal - 底层读取的可选取消信号。
-	* @param sessionId - 用哪个会话的账号;缺省时用默认账号。
+	* @param sessionId - 用哪个会话的账号;缺省时按账号级兜底解析。
 	* @returns 模型、推广与档位。
 	*/
 	async catalogData(signal, sessionId) {
@@ -1820,7 +1845,7 @@ var CodeBuddySession = class {
 	* 从各账号已读到的目录的并集里查一个模型,**不发起任何请求**。
 	*
 	* 供拿不到会话身份的调用方使用(适配器的 `resolveModel`):它无法知道该用哪个
-	* 账号的目录,主动读取只能落在默认账号上,而当前会话用的可能正是另一个账号 ——
+	* 账号的目录,主动读取只能落在账号级兜底上,而当前会话用的可能正是另一个账号 ——
 	* 那会把一个账号独有的模型解析成保守的默认能力(上下文窗口、输出上限、图片输入
 	* 全部按最保守处理)。并集由带会话身份的读取填充,因此这个查询零成本、也不改变
 	* "谁在读目录"这件事。
@@ -1845,7 +1870,7 @@ var CodeBuddySession = class {
 	* 目录及其推广/档位;读不到时返回空值 —— 供面板使用的
 	* {@link catalogData} 建议性读取孪生体。
 	* @param signal - 可选取消信号。
-	* @param sessionId - 用哪个会话的账号;缺省时用默认账号。
+	* @param sessionId - 用哪个会话的账号;缺省时按账号级兜底解析。
 	* @returns 目录与活动,或空列表。
 	*/
 	async catalogDataOrEmpty(signal, sessionId) {
@@ -1869,10 +1894,10 @@ var CodeBuddySession = class {
 	/**
 	* 目录;读不到时返回空列表。
 	*
-	* 列出模型是设置页上的浏览动作,所以失败必须降级为“没有可显示的内容”,
+	* 列出模型是配置页上的浏览动作,所以失败必须降级为“没有可显示的内容”,
 	* 而不是让页面崩掉。请求路径直接使用 {@link models} 并保留真实失败。
 	* @param signal - 可选取消信号。
-	* @param sessionId - 用哪个会话的账号;缺省时用默认账号。
+	* @param sessionId - 用哪个会话的账号;缺省时按账号级兜底解析。
 	* @returns 目录,或空列表。
 	*/
 	async modelsOrEmpty(signal, sessionId) {
@@ -1893,7 +1918,7 @@ var CodeBuddySession = class {
 	* 其他每种失败(传输、解析、刷新过期)都在一条警告之后解析为
 	* `undefined`。身份通过与聊天请求相同的按账号单飞刷新解析,所以并发的计量
 	* 读取绝不会消耗两次刷新 token。
-	* @param sessionId - 用哪个会话的账号;缺省时用默认账号。
+	* @param sessionId - 用哪个会话的账号;缺省时按账号级兜底解析。
 	* @param signal - 可选取消信号。
 	* @returns 该快照;未存有任何凭据或计量平面不可达时为 `undefined`。
 	*/
@@ -1936,8 +1961,7 @@ var CodeBuddySession = class {
 *
 * 用法:
 *   codebuddy-power                     登录并追加账号
-*   codebuddy-power --status            列出全部账号与默认账号
-*   codebuddy-power --default <账号>    把某个账号设为默认
+*   codebuddy-power --status            列出全部账号
 *   codebuddy-power --logout <账号>     退出一个账号
 *   codebuddy-power --logout --all      退出全部账号
 *   codebuddy-power --no-open           只打印 URL,不打开浏览器
@@ -1967,10 +1991,9 @@ function lookupAccount(accounts, spec) {
 	if (byNickname.length > 1) return { failure: `The nickname "${spec}" matches ${byNickname.length} accounts; use a uid or an index instead.` };
 	return { failure: `No stored account matches "${spec}". Run --status to list them.` };
 }
-/** 打印全部账号,标出默认账号,再列出默认账号可用的模型。 */
+/** 打印全部账号,再列出兜底账号可用的模型。 */
 async function status() {
-	const stored = await loadStorage();
-	const accounts = stored.accounts;
+	const accounts = (await loadStorage()).accounts;
 	if (accounts.length === 0) {
 		console.log("Not signed in. Run `dsh plugin --profile web codebuddy-power` to sign in through your browser.");
 		return 1;
@@ -1978,8 +2001,7 @@ async function status() {
 	console.log(`Accounts (${accounts.length}):`);
 	accounts.forEach((account, index) => {
 		const enterprise = account.account.enterpriseName === void 0 ? "" : `  [${account.account.enterpriseName}]`;
-		const isDefault = account.account.uid === stored.defaultUid ? "  (default)" : "";
-		console.log(`  ${index + 1}. ${account.account.nickname}${enterprise}  (uid ${account.account.uid})${isDefault}`);
+		console.log(`  ${index + 1}. ${account.account.nickname}${enterprise}  (uid ${account.account.uid})`);
 	});
 	console.log(`Credential: ${getStoragePath()}`);
 	const models = await new CodeBuddySession().modelsOrEmpty();
@@ -2001,17 +2023,6 @@ async function status() {
 	}
 	return 0;
 }
-/** 设置默认账号。 */
-async function setDefault(spec) {
-	const found = lookupAccount((await loadStorage()).accounts, spec);
-	if ("failure" in found) {
-		console.error(found.failure);
-		return 1;
-	}
-	await setDefaultAccount(found.entry.account.uid);
-	console.log(`Default account is now ${found.entry.account.nickname} (uid ${found.entry.account.uid}).`);
-	return 0;
-}
 /** 退出一个账号,或 `--all` 时退出全部。 */
 async function logout(spec, all) {
 	const stored = await loadStorage();
@@ -2050,18 +2061,10 @@ async function main() {
 		return at === -1 ? void 0 : argv[at + 1];
 	};
 	if (args.has("--help") || args.has("-h")) {
-		console.log("Usage: dsh plugin --profile web codebuddy-power [--status | --default <account> | --logout <account> | --logout --all | --no-open]");
+		console.log("Usage: dsh plugin --profile web codebuddy-power [--status | --logout <account> | --logout --all | --no-open]");
 		return 0;
 	}
 	if (args.has("--status")) return status();
-	if (args.has("--default")) {
-		const spec = valueOf("--default");
-		if (spec === void 0) {
-			console.error("--default needs an account (uid, index, or nickname).");
-			return 1;
-		}
-		return setDefault(spec);
-	}
 	if (args.has("--logout")) return logout(valueOf("--logout"), args.has("--all"));
 	const controller = new AbortController();
 	const onSignal = () => {