dsh-xdpool 2.5.0 → 2.6.0

package/lib/bin.js

@@ -1,6 +1,6 @@
 import { createDecipheriv, createHash, randomUUID } from "node:crypto";
 import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, writeFileSync } from "node:fs";
-import { copyFile, mkdir, readFile, readdir, rename, rm, writeFile, writeFile as writeFile$1 } from "node:fs/promises";
+import { chmod, copyFile, mkdir, readFile, readdir, rename, rm, writeFile, writeFile as writeFile$1 } from "node:fs/promises";
 import { homedir, platform } from "node:os";
 import { basename, dirname, join, resolve } from "node:path";
 import { execFile, execFileSync } from "node:child_process";
@@ -108,24 +108,53 @@ function isAbortError(error) {
 }
 /** Cap on the reassembled compaction reply, guarding against a runaway stream. */
 const COMPLETION_TEXT_LIMIT = 65536;
-/** Insufficient-credit markers, ASCII lowercase plus the original Chinese. */
+/**
+* Insufficient-credit markers, ASCII lowercase plus the original Chinese.
+*
+* The PLURAL forms are listed separately on purpose: this table is matched with
+* `includes`, so `'credits exhausted'.includes('credit exhausted')` is false.
+* The gateway's own 14018 message is `Credits exhausted.` — plural — which
+* therefore matched nothing, fell through to `soft_rate`, and cooled the account
+* and rotated instead of parking it. A rate-limit cooldown on a drained account
+* means every model on it keeps being retried and keeps failing (#from the
+* connect-workbuddy cross-check).
+*/
 const HARD_CREDIT_MARKERS = [
 	"insufficient credit",
+	"insufficient credits",
 	"no credit",
+	"no credits",
 	"credit exhausted",
+	"credits exhausted",
+	"credit exhausted.",
 	"out of credit",
+	"out of credits",
 	"quota exceeded",
 	"quota exhaust",
+	"quota exhausted",
 	"payment required",
 	"credit not enough",
+	"credits not enough",
 	"not enough credit",
+	"not enough credits",
 	"积分不足",
 	"额度不足",
 	"余额不足",
 	"积分用完",
 	"额度用尽",
-	"没有积分"
+	"没有积分",
+	"额度耗尽",
+	"积分耗尽"
 ];
+/**
+* Business codes that mean "this account cannot pay", independent of wording.
+*
+* `14018` is the gateway's credits-exhausted code; the number survived several
+* rewordings of the sentence around it, so matching it is steadier than matching
+* prose. Read from the body rather than from the HTTP status because the gateway
+* answers these inside a 200 or a 4xx envelope.
+*/
+const HARD_CREDIT_CODES = ["14018", "14003"];
 /** Session-invalidation markers that mean "this credential is dead; use another".
 *  Kept alongside the HTTP-status rule in `classifyUpstreamError`: the status is
 *  enough for a direct 401/403, but some failures arrive wrapped in a 200
@@ -370,7 +399,10 @@ const CHAT_IDENTITY_HEADERS = Object.freeze({
 const BANNED_SYSTEM_PHRASES = Object.freeze([
 	[/powered by DeepSeek Harness/gi, "running on DeepSeek Harness"],
 	[/DeepSeek Harness Web GUI/gi, "DeepSeek Harness web interface"],
-	[/Relative paths resolve from the workspace root/gi, "Relative paths are resolved against the workspace root"]
+	[/Relative paths resolve from the workspace root/gi, "Relative paths are resolved against the workspace root"],
+	[/You are a coding agent running in the Codex CLI, a terminal-based coding assistant/gi, "You are a coding agent running in this environment, a terminal-based coding assistant"],
+	[/You are a coding agent running in the Codex CLI/gi, "You are a coding agent running in this environment"],
+	[/Codex CLI is an open source project led by OpenAI/gi, "This coding agent is an open source project"]
 ]);
 /**
 * Rewrite fingerprinted system/assistant content, leaving everything else
@@ -676,6 +708,7 @@ function classifyUpstreamError(status, body) {
 	if (status === 402) return "hard_credit";
 	if (status === 401 || status === 403) return "session_dead";
 	const lower = body.toLowerCase();
+	for (const code of HARD_CREDIT_CODES) if (body.includes(`"code":${code}`) || body.includes(`"code": ${code}`) || body.includes(`"code":"${code}"`)) return "hard_credit";
 	for (const marker of HARD_CREDIT_MARKERS) if (lower.includes(marker.toLowerCase()) || body.includes(marker)) return "hard_credit";
 	for (const marker of SESSION_DEAD_MARKERS) if (body.includes(marker)) return "session_dead";
 	if (status === 429) return "soft_rate";
@@ -993,7 +1026,8 @@ function parseTask(value) {
 		status: typeof raw["status"] === "string" ? raw["status"] : "",
 		claimable: !claimed && target > 0 && current >= target,
 		claimed,
-		locked: raw["locked"] === true
+		locked: raw["locked"] === true,
+		jumpUrl: typeof raw["jump_url"] === "string" ? raw["jump_url"] : ""
 	};
 }
 var WorkBuddyUpstreamClient = class {
@@ -2095,6 +2129,92 @@ var WorkBuddyUpstreamClient = class {
 	}
 };
 //#endregion
+//#region src/file-perms.ts
+/**
+* Write a file that holds credentials, without leaving it world-readable.
+*
+* Every credential this plugin keeps on disk — the durable account list, the
+* ignore list, any mirrored balance — travelled through a plain `writeFile` with
+* the process umask as the only protection. On a POSIX host that typically means
+* `0644`: readable by every other user on the machine, and these files carry
+* `accessToken` / `refreshToken` verbatim.
+*
+* Two rules, and the order matters:
+*
+* 1. **Create, don't patch.** `mode` on `writeFile` only applies when the file is
+*    created. The atomic-write pattern already writes a fresh temp file and
+*    renames it over the target, so the temp is created with `0600` and the
+*    rename carries that permission to the destination. Chmod'ing afterwards
+*    would also work but leaves a window where the file exists with the old
+*    mode.
+* 2. **Still chmod best-effort.** A file written by an older version already
+*    exists with `0644`; the rename replaces the inode, so rule 1 covers it —
+*    but a host that keeps the target in place (or a future caller that writes
+*    directly) would not be covered, and `chmod` is cheap.
+*
+* WINDOWS: `mode` is ignored by Node on win32, and there is no ACL equivalent in
+* the standard library. The honest statement is what actually protects these
+* files there: they live under the user's own profile (%USERPROFILE%, %LOCALAPPDATA%),
+* whose inherited ACL excludes other standard users by default. Calling `icacls`
+* per write would spawn a process on every balance update to re-apply a
+* protection the parent directory already provides, so this module does not. A
+* profile relocated to a shared directory is outside what this code can detect —
+* the README says where the files live so the user can check.
+*
+* @module dsh-xdpool/file-perms
+*/
+/** Owner-only, for a file that holds a secret. */
+const SECRET_FILE_MODE = 384;
+/** Owner-only, for the directory that holds them. */
+const SECRET_DIR_MODE = 448;
+/**
+* True on a platform where POSIX modes are meaningful.
+*
+* Computed through a `typeof process` guard rather than read straight off the
+* global: this module is host-only in intent, but `store.ts` imports it and the
+* browser bundle imports `store.ts` for its row types, so the module body DOES
+* get bundled for the browser. A bare `process.platform` there throws
+* `ReferenceError: process is not defined` at first render — and it is the kind
+* of failure that only shows up in the packaged app.
+*/
+const POSIX = typeof process === "undefined" ? false : process.platform !== "win32";
+/**
+* Create the directory a secret lives in, owner-only.
+*
+* `recursive` so a fresh install works, and the mode applies to every directory
+* this call creates. An existing directory keeps its mode — `mkdir` does not
+* change what is already there — so `chmod` runs too, best-effort: tightening a
+* directory that a previous version created permissively is exactly the case
+* worth fixing, and a failure is not worth aborting a save over.
+*/
+async function ensureSecretDir(dir) {
+	await mkdir(dir, {
+		recursive: true,
+		...POSIX ? { mode: SECRET_DIR_MODE } : {}
+	});
+	if (!POSIX) return;
+	try {
+		await chmod(dir, SECRET_DIR_MODE);
+	} catch {}
+}
+/**
+* Write `contents` to `path` with owner-only permissions.
+*
+* Not atomic on its own — callers that need the crash-safe temp+rename dance keep
+* doing it and just route the temp write through here, which is why the mode is
+* applied at creation: the rename then carries it to the final file.
+*/
+async function writeSecretFile(path, contents) {
+	await writeFile$1(path, contents, POSIX ? {
+		encoding: "utf8",
+		mode: SECRET_FILE_MODE
+	} : "utf8");
+	if (!POSIX) return;
+	try {
+		await chmod(path, SECRET_FILE_MODE);
+	} catch {}
+}
+//#endregion
 //#region src/ignored.ts
 /**
 * The permanent ignore list: accounts the user has thrown out of the pool.
@@ -2195,9 +2315,9 @@ async function writeIgnoredAccounts(accounts, path = ignoredIdsPath()) {
 		version: 1,
 		accounts
 	}, null, 2);
-	await mkdir(dirname(path), { recursive: true });
+	await ensureSecretDir(dirname(path));
 	const temp = `${path}.tmp`;
-	await writeFile$1(temp, `${payload}\n`, "utf8");
+	await writeSecretFile(temp, `${payload}\n`);
 	await rename(temp, path);
 }
 /**
@@ -2323,9 +2443,9 @@ async function saveStoredAccounts(path, accounts) {
 		version: 1,
 		accounts: stored
 	}, null, 2) + "\n";
-	await mkdir(join(path, ".."), { recursive: true });
+	await ensureSecretDir(join(path, ".."));
 	const tmp = `${path}.tmp`;
-	await writeFile$1(tmp, document, "utf8");
+	await writeSecretFile(tmp, document);
 	await rename(tmp, path);
 }
 //#endregion
@@ -3089,16 +3209,20 @@ function parseWorkBuddyAuth(text, sourcePath, decrypt) {
 	const refreshExpiresAtMs = typeof auth["refreshExpiresAt"] === "number" ? expiryToMs(auth["refreshExpiresAt"]) : void 0;
 	if (refreshExpiresAtMs !== void 0 && refreshExpiresAtMs > 0 && refreshExpiresAtMs < Date.now()) return;
 	const lastRefreshAtMs = typeof auth["lastRefreshTime"] === "number" ? expiryToMs(auth["lastRefreshTime"]) : void 0;
+	const nickname = optionalString(decryptableString(identity["nickname"], decrypt).value);
+	const uin = optionalString(identity["uin"]);
+	const uid = optionalString(identity["uid"]);
+	const enterpriseId = optionalString(identity["enterpriseId"]);
 	return {
 		accessToken,
 		refreshToken: decryptableString(auth["refreshToken"], decrypt).value,
 		expiresAtMs: typeof auth["expiresAt"] === "number" ? expiryToMs(auth["expiresAt"]) : 0,
 		...refreshExpiresAtMs === void 0 ? {} : { refreshExpiresAtMs },
 		...lastRefreshAtMs === void 0 ? {} : { lastRefreshAtMs },
-		...optionalString(decryptableString(identity["nickname"], decrypt).value) === void 0 ? {} : { nickname: optionalString(decryptableString(identity["nickname"], decrypt).value) },
-		...optionalString(identity["uin"]) === void 0 ? {} : { uin: optionalString(identity["uin"]) },
-		...optionalString(identity["uid"]) === void 0 ? {} : { uid: optionalString(identity["uid"]) },
-		...optionalString(identity["enterpriseId"]) === void 0 ? {} : { enterpriseId: optionalString(identity["enterpriseId"]) },
+		...nickname === void 0 ? {} : { nickname },
+		...uin === void 0 ? {} : { uin },
+		...uid === void 0 ? {} : { uid },
+		...enterpriseId === void 0 ? {} : { enterpriseId },
 		domain: typeof auth["domain"] === "string" ? auth["domain"] : "",
 		sourcePath
 	};
@@ -3443,6 +3567,16 @@ var WorkBuddyAccountPool = class {
 	*/
 	disabledIds = /* @__PURE__ */ new Set();
 	/**
+	* The account ids the store held after the last successful write.
+	*
+	* Read back on the next scan to say WHICH accounts left, not just how many.
+	* The list is written wholesale, so a scan that does not find an account
+	* deletes it — and that account's credential is then unrecoverable without a
+	* fresh sign-in (#117). `undefined` until the first write, so the first scan
+	* never reports every account as "leave".
+	*/
+	lastPersistedIds;
+	/**
 	* Account ids the user threw out of the pool for good.
 	*
 	* Enforced BEFORE the credential is parsed: `scan()` skips a file whose
@@ -3519,6 +3653,11 @@ var WorkBuddyAccountPool = class {
 	* A function rather than a list because that pool is mounted asynchronously
 	* and can be re-read on demand; `undefined` means "no such source", which is
 	* the state every test and every pre-mount startup is in.
+	*
+	* The `| undefined` is explicit because `applyExternalSource` CLEARS the field by
+	* assigning `undefined` — under `exactOptionalPropertyTypes` a bare `?:` means
+	* "may be absent, never undefined", which made that documented clearing action
+	* a type error.
 	*/
 	externalSource;
 	constructor(options = {}) {
@@ -3624,9 +3763,10 @@ var WorkBuddyAccountPool = class {
 		}
 		const byId = /* @__PURE__ */ new Map();
 		for (const account of this.accounts) byId.set(account.id, account);
-		if (this.persistent && this.accounts.length === 0) {
+		if (this.persistent) {
 			const stored = await loadStoredAccounts(this.storePath);
 			for (const entry of stored) {
+				if (this.ignoredIds.size > 0 && this.ignoredIds.has(entry.id)) continue;
 				if (byId.has(entry.id)) continue;
 				byId.set(entry.id, {
 					id: entry.id,
@@ -3676,7 +3816,10 @@ var WorkBuddyAccountPool = class {
 		this.accounts = ordered;
 		this.lastScanAtMs = Date.now();
 		if (this.persistent) try {
+			const leaving = this.lastPersistedIds === void 0 ? [] : [...this.lastPersistedIds].filter((id) => !this.accounts.some((account) => account.id === id));
+			if (leaving.length > 0) this.logger?.warn?.(`dsh-xdpool: ${String(leaving.length)} account(s) are no longer in the pool after a rescan and were removed from the store: ${leaving.join(", ")}. Their credentials are gone unless they are signed in again.`);
 			await saveStoredAccounts(this.storePath, this.accounts);
+			this.lastPersistedIds = new Set(this.accounts.map((account) => account.id));
 		} catch (error) {
 			this.logger?.warn?.("dsh-xdpool: could not persist the account store", error);
 		}
@@ -3696,11 +3839,11 @@ var WorkBuddyAccountPool = class {
 	* model id the legacy account-wide check applies (callers that cannot name a
 	* model, e.g. CLI diagnostics).
 	*/
-	available(now, modelId, region) {
+	available(now, modelId, region, reserveExempt) {
 		return this.accounts.filter((account) => {
 			if (this.disabledIds.has(account.id)) return false;
 			const reserve = this.creditReserves.get(account.id);
-			if (reserve !== void 0 && reserve > 0) {
+			if (!reserveExempt?.has(account.id) && reserve !== void 0 && reserve > 0) {
 				const balance = this.creditBalances.get(account.id);
 				if (balance !== void 0 && balance <= reserve) return false;
 			}
@@ -3724,7 +3867,7 @@ var WorkBuddyAccountPool = class {
 	* Counts are over the region's accounts, since a provider only ever sees its
 	* own gateway.
 	*/
-	unavailableReason(modelId, region) {
+	unavailableReason(modelId, region, reserveExempt) {
 		const now = Date.now();
 		const inRegion = this.accounts.filter((account) => region === void 0 || regionOf(account.credential.domain) === region);
 		if (inRegion.length === 0) return {
@@ -3737,6 +3880,29 @@ var WorkBuddyAccountPool = class {
 		let cooling = 0;
 		let disabled = 0;
 		let dead = 0;
+		/**
+		* Accounts that survived every OTHER filter and are held back only by their
+		* credit floor.
+		*
+		* Counted rather than returned on the first hit. The old `return` fired the
+		* moment it met one reserved account, so a single account parked under its
+		* floor reported `reserve` for the whole gateway — even while four other
+		* accounts were healthy and had just been tried. The caller turns
+		* `reason === 'reserve'` into a 402 telling the user to lower the reserve,
+		* which pointed at a setting that was not the problem (#98: a five-account
+		* pool reported `reserve_floor` because of one account that had sat below
+		* its floor for weeks, while the actual state was "the rest are cooling").
+		*/
+		let reserved = 0;
+		/**
+		* Accounts that reached the end of the walk unblocked.
+		*
+		* Non-zero means the pool still has somewhere to send a request, so a
+		* reserve is NOT what this answer is about: editing a number cannot fix a
+		* request that some other account is already able to serve, and saying
+		* otherwise sends the reader to the wrong setting.
+		*/
+		let usable = 0;
 		for (const account of inRegion) {
 			if (this.disabledIds.has(account.id)) {
 				disabled += 1;
@@ -3752,16 +3918,14 @@ var WorkBuddyAccountPool = class {
 				continue;
 			}
 			const reserve = this.creditReserves.get(account.id);
-			if (reserve !== void 0 && reserve > 0) {
+			if (!reserveExempt?.has(account.id) && reserve !== void 0 && reserve > 0) {
 				const balance = this.creditBalances.get(account.id);
-				if (balance !== void 0 && balance <= reserve) return {
-					total: inRegion.length,
-					cooling,
-					disabled,
-					dead,
-					reason: "reserve"
-				};
+				if (balance !== void 0 && balance <= reserve) {
+					reserved += 1;
+					continue;
+				}
 			}
+			usable += 1;
 		}
 		if (dead > 0) return {
 			total: inRegion.length,
@@ -3784,6 +3948,13 @@ var WorkBuddyAccountPool = class {
 			dead,
 			reason: "disabled"
 		};
+		if (usable === 0 && reserved > 0) return {
+			total: inRegion.length,
+			cooling,
+			disabled,
+			dead,
+			reason: "reserve"
+		};
 		return {
 			total: inRegion.length,
 			cooling,
@@ -3960,16 +4131,18 @@ var WorkBuddyAccountPool = class {
 	* Scans on first use, and rescans when every known account is cooling down: a
 	* fresh desktop login is the usual way out of an exhausted pool.
 	*
+	* `reserveExempt` is host-only: account ids whose own credentials freshly
+	* confirmed a zero-credit model. It never bypasses disabled, dead credentials, cooldowns or region.
 	* `conversationKey` is only consulted under `sticky`; other modes ignore it.
 	*/
-	async acquire(modelId, region, conversationKey) {
+	async acquire(modelId, region, conversationKey, reserveExempt) {
 		if (this.accounts.length === 0) await this.scan();
 		const maxTries = this.accounts.length + 1;
 		for (let attempt = 0; attempt < maxTries; attempt += 1) {
-			let pool = this.available(Date.now(), modelId, region);
+			let pool = this.available(Date.now(), modelId, region, reserveExempt);
 			if (pool.length === 0 && attempt === 0) {
 				await this.scan();
-				pool = this.available(Date.now(), modelId, region);
+				pool = this.available(Date.now(), modelId, region, reserveExempt);
 			}
 			if (pool.length === 0) return void 0;
 			if (this.preferredAccountId !== void 0) {
@@ -4162,6 +4335,43 @@ var WorkBuddyAccountPool = class {
 		return this.accounts.filter((account) => (account.credentialDeadUntilMs ?? 0) > now);
 	}
 	/**
+	* Try to bring benched accounts back WITHOUT waiting out the cooldown.
+	*
+	* The cooldown is a guess about how long a problem lasts, and the guess is
+	* usually wrong in one direction or the other: a token revoked by a password
+	* change stays dead for the full window even after the user signs in again in
+	* some other client, and a transient upstream hiccup benches a perfectly good
+	* account for half an hour.
+	*
+	* So instead of only waiting, ask. For each benched account, one cheap
+	* authenticated read: if it answers, the credential works and the account goes
+	* back into rotation immediately. Nothing about the failure is trusted — only a
+	* successful call clears it — and a probe that fails keeps the original
+	* cooldown untouched (probing must never EXTEND a bench, or a broken endpoint
+	* would keep every account locked out for as long as it stayed broken).
+	*
+	* `probe` is injected rather than imported so this class stays free of the
+	* upstream client: the pool knows about accounts, not about HTTP.
+	*
+	* Returns the accounts it revived, for logging and for the run summary.
+	*/
+	async reviveBenched(probe) {
+		const benched = this.deadCredentials();
+		if (benched.length === 0) return [];
+		const revived = [];
+		for (const account of benched) {
+			try {
+				await probe(account.credential);
+			} catch {
+				continue;
+			}
+			this.clearCredentialDead(account.id);
+			revived.push(account);
+			this.logger?.info?.(`dsh-xdpool: ${account.label} answered a probe; back in rotation without waiting out the cooldown`);
+		}
+		return revived;
+	}
+	/**
 	* Refresh the account's access token when it is within the margin (or already
 	* expired), in-flight de-duped per account. A failed refresh keeps the
 	* existing token when it has not yet expired, so an unreachable refresh
@@ -4308,8 +4518,23 @@ ${new Date(until).toISOString()}
 * (`kimi-k3-1`). A stale fallback is worse than a short one — it looks
 * authoritative while being wrong.
 *
-* `multiplier: 0` is the gateways' own spelling of "free" (`credits: "x0.00"`),
-* which is what turns on the free badge.
+* NO PRICES AND NO PROMO BADGES HERE. This table is what the picker shows when
+* the startup fetch fails, and a multiplier captured months ago is a price the
+* user will budget against while it is quietly wrong. Two specific harms:
+*
+*   - `multiplier: 0` renders the "free" badge, so a model that was free at
+*     capture time keeps claiming to be free after the promotion ends;
+*   - a non-zero multiplier renders next to the model, so a stale figure reads
+*     as the current rate.
+*
+* `undefined` is the honest state: the card prints no rate and no badge, which
+* is exactly true — this build does not know the price. The live fetch fills
+* both in within a second of a working startup, and `catalogSource` already
+* tells the card to say the list is the built-in one.
+*
+* Windows, output ceilings and the `craft` capability tag stay: those are
+* properties of the model, not of a campaign, and they are what makes the list
+* usable offline at all.
 */
 const FALLBACK_WORKBUDDY_MODELS = [
 	{
@@ -4326,8 +4551,7 @@ const FALLBACK_WORKBUDDY_MODELS = [
 		contextWindow: 96e4,
 		maxOutputTokens: 64e3,
 		supportsImages: true,
-		multiplier: .29,
-		tags: ["craft", "badge:夜间免费:#FF0000"]
+		tags: ["craft"]
 	},
 	{
 		id: "hy3",
@@ -4335,40 +4559,35 @@ const FALLBACK_WORKBUDDY_MODELS = [
 		contextWindow: 192e3,
 		maxOutputTokens: 64e3,
 		supportsImages: true,
-		multiplier: 0,
-		tags: ["craft", "badge:限时免费:#FF0000"]
+		tags: ["craft"]
 	},
 	{
 		id: "hy3-x",
 		name: "Hy3",
 		contextWindow: 192e3,
 		maxOutputTokens: 64e3,
-		supportsImages: true,
-		multiplier: .05
+		supportsImages: true
 	},
 	{
 		id: "space-bunny",
 		name: "Space-Bunny",
 		contextWindow: 1e6,
 		maxOutputTokens: 64e3,
-		supportsImages: true,
-		multiplier: .08
+		supportsImages: true
 	},
 	{
 		id: "deepseek-v4.1-flash",
 		name: "Deepseek-V4.1-Flash",
 		contextWindow: 1e6,
 		maxOutputTokens: 128e3,
-		supportsImages: true,
-		multiplier: .11
+		supportsImages: true
 	},
 	{
 		id: "deepseek-v4-pro",
 		name: "Deepseek-V4-Pro",
 		contextWindow: 1e6,
 		maxOutputTokens: 128e3,
-		supportsImages: true,
-		multiplier: .51
+		supportsImages: true
 	},
 	{
 		id: "deepseek-v4-flash",
@@ -4382,16 +4601,14 @@ const FALLBACK_WORKBUDDY_MODELS = [
 		name: "GLM-5.3",
 		contextWindow: 1e6,
 		maxOutputTokens: 64e3,
-		supportsImages: true,
-		multiplier: .79
+		supportsImages: true
 	},
 	{
 		id: "glm-5.3-flash",
 		name: "GLM-5.3-Flash",
 		contextWindow: 1e6,
 		maxOutputTokens: 131072,
-		supportsImages: true,
-		multiplier: .06
+		supportsImages: true
 	},
 	{
 		id: "glm-5.2",
@@ -4399,64 +4616,56 @@ const FALLBACK_WORKBUDDY_MODELS = [
 		contextWindow: 1e6,
 		maxOutputTokens: 64e3,
 		supportsImages: true,
-		multiplier: .79,
-		tags: ["craft", "badge:夜间折扣:#1E90FF"]
+		tags: ["craft"]
 	},
 	{
 		id: "glm-5.1",
 		name: "GLM-5.1",
 		contextWindow: 2e5,
 		maxOutputTokens: 48e3,
-		supportsImages: false,
-		multiplier: .79
+		supportsImages: false
 	},
 	{
 		id: "glm-5v-turbo",
 		name: "GLM-5v-Turbo",
 		contextWindow: 2e5,
 		maxOutputTokens: 64e3,
-		supportsImages: true,
-		multiplier: .71
+		supportsImages: true
 	},
 	{
 		id: "kimi-k3-1",
 		name: "Kimi-K3",
 		contextWindow: 1e6,
 		maxOutputTokens: 32e3,
-		supportsImages: true,
-		multiplier: 1.62
+		supportsImages: true
 	},
 	{
 		id: "kimi-k2.8-preview",
 		name: "Kimi-K2.8-Preview",
 		contextWindow: 1e6,
 		maxOutputTokens: 64e3,
-		supportsImages: true,
-		multiplier: .77
+		supportsImages: true
 	},
 	{
 		id: "kimi-k2.7",
 		name: "Kimi-K2.7-Code",
 		contextWindow: 256e3,
 		maxOutputTokens: 32e3,
-		supportsImages: true,
-		multiplier: .57
+		supportsImages: true
 	},
 	{
 		id: "kimi-k2.6",
 		name: "Kimi-K2.6",
 		contextWindow: 256e3,
 		maxOutputTokens: 32e3,
-		supportsImages: true,
-		multiplier: .52
+		supportsImages: true
 	},
 	{
 		id: "minimax-m3",
 		name: "MiniMax-M3",
 		contextWindow: 512e3,
 		maxOutputTokens: 64e3,
-		supportsImages: true,
-		multiplier: .25
+		supportsImages: true
 	}
 ];
 /**
@@ -4529,11 +4738,24 @@ var WorkBuddyCatalog = class {
 	}
 	/**
 	* The models DSH should actually offer, after applying the user's selection:
-	* disabled models are dropped, an explicit image list overrides the upstream
-	* capability flag, and a per-model budget caps the advertised window.
+	* disabled models are dropped, an explicit image list decides image support,
+	* and a per-model budget caps the advertised window.
 	*
 	* An absent `enabledModelIds` means "everything" — a fresh install with no
 	* saved selection must not present an empty picker.
+	*
+	* IMAGE SUPPORT IS THE USER'S SET, NOT AN OR. The upstream flag is `true` for
+	* essentially every model of this vendor (measured: 15 of 16 on CN, 23 of 23
+	* on international), so `supportsImages || imageSet.has(id)` could only ever
+	* turn the flag ON — un-ticking the box in the card changed nothing, and the
+	* adapter kept advertising `['text','image']`. The checkbox existed and did
+	* not work, which is worse than not offering it.
+	*
+	* So when the user HAS saved an image selection, that set is the answer, in
+	* both directions. When they have not (undefined — a fresh install, or a
+	* config written before this fix), the upstream capability stands: silently
+	* disabling image input for everyone who never touched the switch would be a
+	* regression, and the absent case is exactly "no opinion".
 	*/
 	visible() {
 		const enabled = this.selection.enabledModelIds;
@@ -4543,7 +4765,7 @@ var WorkBuddyCatalog = class {
 		const budgets = this.selection.contextBudgets;
 		return this.models.filter((model) => allow === void 0 || allow.has(model.id)).map((model) => {
 			const next = { ...model };
-			if (imageSet !== void 0) next.supportsImages = next.supportsImages || imageSet.has(model.id);
+			if (imageSet !== void 0) next.supportsImages = imageSet.has(model.id);
 			const budget = budgets?.[model.id];
 			if (budget !== void 0 && budget > 0 && budget < next.contextWindow) next.contextWindow = budget;
 			return next;
@@ -4648,8 +4870,13 @@ function catalogFromUpstream(models, region = "cn") {
 	if (models.length === 0) return fallbackModelsFor(region);
 	return models.map(toModelInfo);
 }
-//#endregion
-//#region src/status-paths.ts
+Object.freeze([
+	"priority",
+	"round-robin",
+	"balanced",
+	"sticky",
+	"expiry"
+]);
 /**
 * The schedule every automation job falls back to.
 *
@@ -9608,6 +9835,24 @@ const PROVIDERS = Object.freeze([
 		"website": "https://openai.com/",
 		"local": false,
 		"source": "fcc"
+	},
+	{
+		"id": "custom_openai",
+		"name": "Custom OpenAI-compatible",
+		"category": "apikey",
+		"auth": {
+			"kind": "apiKey",
+			"env": "CUSTOM_OPENAI_API_KEY",
+			"url": null
+		},
+		"baseUrl": "",
+		"format": "openai-chat",
+		"models": [],
+		"notes": "Any OpenAI-compatible endpoint — vLLM, LiteLLM, one-api, LM Studio, a self-hosted gateway. Paste the base URL (ending in /v1) and the key on this card, then press Fetch models.",
+		"website": null,
+		"local": false,
+		"baseUrlOverrideEnv": "CUSTOM_OPENAI_BASE_URL",
+		"custom": true
 	}
 ].map((entry) => Object.freeze({
 	...entry,
@@ -9967,6 +10212,71 @@ function appearanceChain(themeKey = APPEARANCE_THEME_KEY) {
 	};
 }
 /**
+* Pull the `expertId` out of a task's `jump_url`.
+*
+* The "体验XX专家" tasks (#98) name an expert that is NOT in the marketplace
+* listing — the reporter翻遍了 marketExpertList in both `agent` and `team`
+* types and got zero hits — so the only place the id appears is the deeplink
+* embedded in the task itself:
+*
+*   https://www.workbuddy.cn/work/launch/?deeplink=workbuddy%3A%2F%2Fexperts%3FexpertId%3Dex_GDl31WahyIH0&buddy_type=workbuddy
+*
+* The deeplink is percent-encoded, and it has to be: the `?` and `&` inside it
+* would otherwise end the outer query. So the parse is two steps — decode the
+* `deeplink` parameter, then read `expertId` off the scheme it decodes to — and
+* NOT a regex over the whole URL, which would also match the outer `expertId`
+* spelling in a future URL shape and silently pick the wrong one.
+*
+* Returns undefined for the tasks whose deeplink carries no id at all
+* (`WorkBuddy_Valorant` points at `workbuddy://expert` with no query), which is
+* the honest answer: those need a different source and are not guessed here.
+*/
+function expertIdFromJumpUrl(jumpUrl) {
+	if (jumpUrl === "") return void 0;
+	/** Read `expertId` off any URL-ish string, decoded or not. */
+	const readId = (value) => {
+		let query = value;
+		try {
+			const parsed = new URL(value);
+			query = parsed.search === "" ? value : parsed.search;
+		} catch {
+			query = value;
+		}
+		const marker = query.indexOf("expertId=");
+		if (marker === -1) return void 0;
+		const rest = query.slice(marker + 9);
+		const end = rest.search(/[&#]/u);
+		const id = (end === -1 ? rest : rest.slice(0, end)).trim();
+		return id === "" ? void 0 : id;
+	};
+	let source = jumpUrl;
+	try {
+		const raw = new URL(jumpUrl).searchParams.get("deeplink");
+		if (raw !== null && raw !== "") source = raw;
+	} catch {
+		source = jumpUrl;
+	}
+	return readId(source);
+}
+/**
+* Build a summon record for an expert the marketplace does not list.
+*
+* Everything the chains need beyond the id is cosmetic — the scorer keys on
+* `expertId` — so the title from the task is reused as the display name rather
+* than inventing one. `version` is left empty, which every consumer already
+* defaults to `1.0.0`.
+*/
+function expertFromTask(expertId, title) {
+	return {
+		expertId,
+		expertType: "agent",
+		displayName: title,
+		profession: title,
+		version: "",
+		categories: []
+	};
+}
+/**
 * The three "summon an expert" events (`expert_summon_click` and friends).
 *
 * Paid before the conversation, in the order the app emits them.
@@ -10080,7 +10390,12 @@ const EVENT_CHAIN_BUILDERS = {
 	skill_1: true,
 	expert_5: true,
 	Expert_team_use_3: true,
-	Expert_lighthouse: true
+	Expert_lighthouse: true,
+	expert_use_maidehao: true,
+	expert_use_douyinyin: true,
+	expert_use_shangjia_xuanchuan: true,
+	expert_use_bowangwang: true,
+	WorkBuddy_Valorant: true
 };
 const AUTOMATION_TICK_MS = 6e4;
 const JOB_KINDS = [
@@ -10195,10 +10510,35 @@ function slotKey(date, timeZone = AUTOMATION_TIME_ZONE) {
 	const { hour } = zonedParts(date, timeZone);
 	return `${dayKey(date, timeZone)}T${hour}`;
 }
-/** Whether this account may be used: not switched off, not cooling. */
-function eligible(account, now) {
+/**
+* Which account classes each job may touch.
+*
+* This replaced a single `global → false`, which was right about the growth
+* system and wrong as a blanket: it excluded a global account from EVERY job,
+* including the ones that are idempotent, cheap, and pay credits regardless of
+* region. The blanket also made the rule unfalsifiable — "global does nothing"
+* cannot be checked, whereas "the checkin job tries global accounts and here is
+* what came back" can.
+*
+* So the scope is per job, and the default for a job that is not named is `cn`:
+* a new job must opt in explicitly rather than inherit an accident.
+*/
+const JOB_REGION_SCOPE = {
+	report: ["cn"],
+	tasks: ["cn"],
+	streak: ["cn"],
+	travel: ["cn"],
+	compensation: ["cn"],
+	checkin: ["cn", "global"]
+};
+/** Whether `job` may run against `region`; unnamed jobs stay CN. */
+function jobAllowsRegion(job, region) {
+	return (JOB_REGION_SCOPE[job] ?? ["cn"]).includes(region);
+}
+/** Whether this account may be used for a job: not cooling, and right region. */
+function eligible(account, now, job) {
 	if (account.cooldownUntilMs > now) return false;
-	if (regionOf(account.credential.domain) === "global") return false;
+	if (job !== void 0 && !jobAllowsRegion(job, regionOf(account.credential.domain))) return false;
 	return true;
 }
 const sleep = (ms) => new Promise((resolve) => {
@@ -10269,6 +10609,16 @@ var WorkBuddyScheduler = class {
 	/** Host hooks that persist the ledger across restarts. */
 	loadEarnings;
 	saveEarningsFn;
+	/**
+	* The most recent ledger write that may still be in flight.
+	*
+	* `persistEarnings` is synchronous from its callers' point of view, but the
+	* host's settings write is not: it is an async document update. Keeping the
+	* promise here is what lets {@link flushEarnings} wait for the write that
+	* matters — the last one before a restart — without making every counter
+	* update await disk.
+	*/
+	pendingEarningsWrite = Promise.resolve();
 	constructor(pool, client, options = {}) {
 		this.pool = pool;
 		this.client = client;
@@ -10305,6 +10655,18 @@ var WorkBuddyScheduler = class {
 		this.saveEarningsFn = save;
 	}
 	/**
+	* Wait for the ledger write that is (or was last) in flight.
+	*
+	* Called at the END of a task pass, right after the last claim, so the rewards
+	* that were just collected are on disk before a restart can lose them. It is
+	* deliberately NOT awaited on every counter bump: the settings document write
+	* is the slow part, and paying it per account would slow the pass for no
+	* benefit while the process is still alive.
+	*/
+	async flushEarnings() {
+		await this.pendingEarningsWrite;
+	}
+	/**
 	* Fold a previously persisted ledger back in, when it belongs to today.
 	*
 	* Used after the settings document becomes readable, which happens after
@@ -10574,7 +10936,7 @@ var WorkBuddyScheduler = class {
 			compensationCredit: (existing?.compensationCredit ?? 0) + compensationCredit,
 			date: today
 		});
-		this.persistEarnings();
+		this.pendingEarningsWrite = this.persistEarnings();
 	}
 	/** Clear the per-account counters when the local day changes. */
 	rollEarnings(today) {
@@ -10590,9 +10952,18 @@ var WorkBuddyScheduler = class {
 	* Best effort on purpose: a failed save must never abort a run that has
 	* already collected rewards, and the in-memory ledger keeps serving the card
 	* for the rest of the session either way.
+	*
+	* The returned promise settles when the write has landed (or failed). Callers
+	* that are about to END a run await it: reported in #98, a task pass that
+	* claimed 21 tasks had its process restarted before the volatile settings
+	* write reached disk, so `automationEarnings` still read `credit: 0` while
+	* the upstream had really paid out. Fire-and-forget is fine for a counter the
+	* card will re-read in this process; it is not fine for the last write before
+	* exit.
 	*/
 	persistEarnings() {
-		if (this.saveEarningsFn === void 0) return;
+		const save = this.saveEarningsFn;
+		if (save === void 0) return Promise.resolve();
 		const accounts = {};
 		for (const [id, entry] of this.earnings) accounts[id] = entry;
 		const ledger = {
@@ -10600,12 +10971,14 @@ var WorkBuddyScheduler = class {
 			accounts
 		};
 		try {
-			const saved = this.saveEarningsFn(ledger);
-			if (saved !== void 0 && typeof saved.then === "function") saved.then(void 0, (error) => {
+			const saved = save(ledger);
+			if (saved !== void 0 && typeof saved.then === "function") return Promise.resolve(saved).then(void 0, (error) => {
 				this.logger.warn?.("dsh-xdpool: could not persist automation earnings:", error);
 			});
+			return Promise.resolve();
 		} catch (error) {
 			this.logger.warn?.("dsh-xdpool: could not persist automation earnings:", error);
+			return Promise.resolve();
 		}
 	}
 	/**
@@ -10632,8 +11005,22 @@ var WorkBuddyScheduler = class {
 		let energy = 0;
 		let claimed = 0;
 		const detail = [];
+		/**
+		* Every item this run considered, with a status attached.
+		*
+		* `detail` stays as the human-readable log line; this is the same work in a
+		* shape the card can GROUP and COUNT, so "3 tasks unclaimed — locked" is
+		* distinguishable from "0 tasks, everything already collected".
+		*/
+		const items = [];
 		let progressNote;
-		const accounts = this.accountsInOrder();
+		try {
+			const revived = await this.pool.reviveBenched((credential) => this.client.fetchCredits(credential));
+			for (const account of revived) detail.push(`复活 ${account.label}`);
+		} catch (error) {
+			this.logger.warn?.("automation: could not probe benched accounts:", error);
+		}
+		const accounts = this.accountsInOrder(kind);
 		if (kind === "tasks") await this.sendEventChains(accounts);
 		for (let index = 0; index < accounts.length; index++) {
 			if (this.stopped) break;
@@ -10641,12 +11028,22 @@ var WorkBuddyScheduler = class {
 			if (account === void 0) continue;
 			try {
 				switch (kind) {
-					case "checkin":
+					case "checkin": {
+						let alreadyDone = false;
+						try {
+							alreadyDone = (await this.client.fetchCheckinStatus(account.credential)).todayCheckedIn === true;
+						} catch (error) {
+							this.logger.warn?.(`automation checkin ${account.label}: status read failed, claiming anyway:`, error);
+						}
+						if (alreadyDone) {
+							this.logger.info?.(`automation checkin ${account.label}: already done today (read, not claimed)`);
+							break;
+						}
 						try {
 							const claim = await this.client.claimDailyCheckin(account.credential);
 							this.recordEarnings(account.id, today, { checkinCredit: claim.credit });
 							if (claim.credit > 0) {
-								if (claim.credit > 0) detail.push(`签到 +${claim.credit}`);
+								detail.push(`签到 +${claim.credit}`);
 								this.logger.info?.(`automation checkin ${account.label}: +${claim.credit} credit`);
 							}
 						} catch (error) {
@@ -10654,6 +11051,7 @@ var WorkBuddyScheduler = class {
 							this.logger.info?.(`automation checkin ${account.label}: already done today`);
 						}
 						break;
+					}
 					case "report": {
 						const days = await this.reportOne(account);
 						this.logger.info?.(`automation report ${account.label}: streak days=${days}`);
@@ -10665,6 +11063,7 @@ var WorkBuddyScheduler = class {
 						energy += result.energy;
 						claimed += result.claimed;
 						detail.push(...result.titles);
+						items.push(...result.items);
 						this.claimableSeen += result.claimableCount;
 						this.recordEarnings(account.id, today, {
 							credit: result.credit,
@@ -10712,8 +11111,11 @@ var WorkBuddyScheduler = class {
 		state.claimed = claimed;
 		state.message = this.summarise(kind, ok, failed, claimed, credit, energy);
 		state.detail = detail;
-		state.progress = progressNote;
+		state.items = items;
+		if (progressNote === void 0) delete state.progress;
+		else state.progress = progressNote;
 		this.logger.info?.(`automation ${accountWord}: ${state.message}`);
+		if (kind === "tasks" || kind === "checkin" || kind === "streak" || kind === "travel" || kind === "compensation") await this.flushEarnings();
 	}
 	/** Compose the one-line summary shown on the card. */
 	summarise(kind, ok, failed, claimed, credit, energy) {
@@ -10725,12 +11127,16 @@ var WorkBuddyScheduler = class {
 	*
 	* Disabled accounts are excluded here rather than filtered by the caller so a
 	* card switch takes effect on the next pass without any event plumbing.
+	*
+	* `job` narrows the set by region scope: the growth jobs are CN-only while
+	* check-in runs on both gateways, so eligibility cannot be decided without
+	* knowing which job is about to run.
 	*/
-	accountsInOrder() {
+	accountsInOrder(job) {
 		const now = Date.now();
 		return this.pool.list().filter((account) => {
 			if (this.pool.isDisabled(account.id)) return false;
-			return eligible(account, now);
+			return eligible(account, now, job);
 		});
 	}
 	/**
@@ -10836,10 +11242,88 @@ var WorkBuddyScheduler = class {
 			case "expert_5": return this.expertChains(credential, "agent", task);
 			case "Expert_team_use_3": return this.expertChains(credential, "team", task);
 			case "Expert_lighthouse": return this.lighthouseChains(credential);
+			case "expert_use_maidehao":
+			case "expert_use_douyinyin":
+			case "expert_use_shangjia_xuanchuan":
+			case "expert_use_bowangwang":
+			case "WorkBuddy_Valorant": return this.taskExpertChains(credential, task);
 			default: return [];
 		}
 	}
 	/**
+	* Summon-and-use one expert NAMED BY THE TASK.
+	*
+	* Structurally `expertChains` minus the marketplace: the expert id is read
+	* from the task's deeplink instead of by browsing `marketExpertList`, because
+	* this family's experts are not listed there at all (#98 measured 500 entries
+	* across both `agent` and `team`, zero hits).
+	*
+	* Returns `[]` — not a throw — when the task carries no usable id: the caller
+	* logs "could not be built" only for exceptions, and a task shape this code
+	* does not understand is information, not a fault.
+	*/
+	/**
+	* Find the expert a task is about, by matching its title against the
+	* marketplace.
+	*
+	* The marketplace listing is ~500 entries across `agent` and `team`, and this
+	* only runs for a task whose deeplink carried no id — at most a handful per
+	* run — so the cost is acceptable. It is not cached because a freshly
+	* published expert must become findable without a restart.
+	*
+	* Matching rules, all of them strict on purpose:
+	*   - the task's title must appear IN the expert's name or profession, or the
+	*     expert's display name must appear in the title (both directions, since
+	*     the board and the marketplace word things differently);
+	*   - comparison ignores case, whitespace and the punctuation vendors sprinkle
+	*     through names;
+	*   - several matches means NO answer. Summoning the wrong agent scores 0, so a
+	*     guess costs an upstream call and still fails — worse than declining.
+	*/
+	async expertIdByKeyword(credential, task) {
+		const normalise = (value) => value.toLowerCase().replace(/[\s_\-·:：,，.。()（）【】[\]「」]/gu, "");
+		const wanted = normalise(task.title);
+		if (wanted === "") return void 0;
+		let candidates;
+		try {
+			const [agents, teams] = await Promise.all([this.client.marketExpertList(credential, "agent"), this.client.marketExpertList(credential, "team")]);
+			candidates = [...agents, ...teams];
+		} catch (error) {
+			this.logger.warn?.(`automation events ${task.taskCode}: marketplace lookup failed:`, error);
+			return;
+		}
+		const matches = candidates.filter((candidate) => {
+			const name = normalise(candidate.displayName ?? "");
+			const profession = normalise(candidate.profession ?? "");
+			if (name === "" && profession === "") return false;
+			return name !== "" && (name.includes(wanted) || wanted.includes(name)) || profession !== "" && (profession.includes(wanted) || wanted.includes(profession));
+		});
+		if (matches.length !== 1) {
+			if (matches.length > 1) this.logger.info?.(`automation events ${task.taskCode}: ${String(matches.length)} marketplace experts match "${task.title}", not guessing`);
+			return;
+		}
+		const found = matches[0];
+		if (found === void 0) return void 0;
+		this.logger.info?.(`automation events ${task.taskCode}: resolved expertId ${found.expertId} by keyword "${task.title}"`);
+		return found.expertId;
+	}
+	async taskExpertChains(credential, task) {
+		const expertId = expertIdFromJumpUrl(task.jumpUrl) ?? await this.expertIdByKeyword(credential, task);
+		if (expertId === void 0) {
+			this.logger.warn?.(`automation events ${task.taskCode}: no expertId in jump_url and no marketplace match, skipping`);
+			return [];
+		}
+		const expert = expertFromTask(expertId, task.title);
+		await this.client.reportDesktopEvents(credential, expertSummonEvents(expert));
+		if (this.delayMs > 0 && !this.stopped) await sleep(this.delayMs);
+		const chat = await this.client.openConversation(credential, expert.expertId);
+		if (chat === void 0) throw new Error(`${task.taskCode}: no server conversation`);
+		return [{
+			transport: "desktop",
+			events: [...expertChatEvents(expert, chat.conversationId, chat.requestId), expertActualUseEvent(expert, chat.conversationId, chat.requestId)]
+		}];
+	}
+	/**
 	* The summon-and-use chains for the expert tasks.
 	*
 	* Two steps per expert, and both are load-bearing: the summon events alone are
@@ -10911,21 +11395,41 @@ var WorkBuddyScheduler = class {
 		const credential = account.credential;
 		const open = (await this.client.listTasks(credential)).filter((task) => task.acceptStatus === "not_accepted" && !task.locked).map((task) => task.taskCode);
 		if (open.length > 0) await this.client.acceptTasks(credential, open);
-		const claimable = (await this.client.listTasks(credential)).filter((task) => task.claimable && !task.locked);
+		const refreshed = await this.client.listTasks(credential);
+		const claimable = refreshed.filter((task) => task.claimable && !task.locked);
 		let credit = 0;
 		let energy = 0;
 		let claimed = 0;
 		const titles = [];
+		const items = [];
+		for (const task of refreshed) if (task.locked === true || task.claimable !== true) items.push({
+			title: task.title === "" ? task.taskCode : task.title,
+			status: "skipped",
+			note: task.locked === true ? "locked" : task.acceptStatus === "not_accepted" ? "not accepted" : "not scored yet"
+		});
 		for (const task of claimable) {
 			if (this.stopped) break;
 			const reward = await this.client.claimTaskReward(credential, task.taskCode);
 			credit += reward.credit;
 			energy += reward.energy;
+			const label = task.title === "" ? task.taskCode : task.title;
 			if (reward.credit > 0 || reward.energy > 0) {
 				claimed++;
 				titles.push(task.title);
+				items.push({
+					title: label,
+					status: "claimed",
+					...reward.credit > 0 ? { credit: reward.credit } : {},
+					...reward.energy > 0 ? { energy: reward.energy } : {}
+				});
 				this.logger.info?.(`automation claim ${account.label}: ${task.title} +${reward.credit}c +${reward.energy}e`);
-			} else this.logger.info?.(`automation claim ${account.label}: ${task.taskCode} already claimed`);
+			} else {
+				items.push({
+					title: label,
+					status: "already"
+				});
+				this.logger.info?.(`automation claim ${account.label}: ${task.taskCode} already claimed`);
+			}
 			if (this.delayMs > 0 && !this.stopped) await sleep(this.delayMs);
 		}
 		return {
@@ -10933,7 +11437,8 @@ var WorkBuddyScheduler = class {
 			credit,
 			energy,
 			claimableCount: claimable.length,
-			titles
+			titles,
+			items
 		};
 	}
 	/**
@@ -11075,6 +11580,7 @@ Object.freeze({
 	"kimi_code": "Kimi Code 订阅，模型 id 取自 9router 的 kimi 注册表",
 	"lightning": "Lightning AI 的 Model APIs 网关",
 	"llamacpp": "本地服务器，模型列表取决于用户已加载的模型",
+	"custom_openai": "自定义 OpenAI 兼容端点：vLLM / LiteLLM / one-api / 自建网关，填 base URL 和 key 后拉取模型",
 	"llm7": "default/fast/pro 别名被固定，只留流式工具模型",
 	"lmstudio": "本地服务器，模型列表取决于用户已加载的模型",
 	"minimax": "推理内容从正文流中单独拆出，语音与图像 id 已剔除",
@@ -11220,7 +11726,7 @@ async function readPreferredId(path = preferredIdPath()) {
 * free of documents that describe the absence of a decision.
 */
 async function writePreferredId(accountId, path = preferredIdPath()) {
-	await mkdir(dirname(path), { recursive: true });
+	await ensureSecretDir(dirname(path));
 	if (accountId === void 0) {
 		await rm(path, { force: true });
 		return;
@@ -11230,7 +11736,7 @@ async function writePreferredId(accountId, path = preferredIdPath()) {
 		accountId: accountId.trim()
 	}, null, 2);
 	const temp = `${path}.tmp`;
-	await writeFile$1(temp, `${payload}\n`, "utf8");
+	await writeSecretFile(temp, `${payload}\n`);
 	await rename(temp, path);
 }
 fileURLToPath(new URL("..", import.meta.url));
@@ -11307,7 +11813,18 @@ z.object({
 	modelSelectionGlobal: asVolatile(modelSelectionSchema.description("Model selection for the international gateway")),
 	automation: asVolatile(automationSchema.description("Daily points automation (activity report, task claiming, check-in)")),
 	automationEarnings: asVolatile(z.any().description("Automation earnings ledger (written by the scheduler)")),
-	sidebarRow: asVolatile(z.boolean().default(true).description("Show the XD Pool entry in the left sidebar (the Settings page keeps working either way)"))
+	sidebarRow: asVolatile(z.boolean().default(true).description("Show the XD Pool entry in the left sidebar (the Settings page keeps working either way)")),
+	/**
+	* The 免密 free lane (`free:` models).
+	*
+	* OFF unless set, and it is the only lane that works that way. It is a shared
+	* third-party endpoint with no credential of its own, so there is nothing for
+	* a user to "configure" — it simply appears in the picker or does not. On by
+	* default it added a group nobody asked for that the aggregate switch does not
+	* govern (it is not an aggregate provider), leaving no way to remove it
+	* without editing a file. Reported as "关不掉，应该默认是关闭的".
+	*/
+	freeLane: asVolatile(z.boolean().default(false).description("Offer the shared 免密 free models (the \"XD Pool · 免费模型\" group). Off by default: it is a third-party endpoint with no key of your own."))
 });
 /** Assemble the runtime objects without registering anything. */
 /**