@eddyskywalker/dsh-chatgpt-subscription 0.10.11 → 0.10.13

package/lib/index.js

@@ -2,13 +2,13 @@ import { createRequire } from "node:module";
 import z from "@deepseek-ai/schemastery";
 import * as LlmModule from "@deepseek-ai/dsh-llm";
 import { HarnessError, LlmAdapter, LlmError, LlmError as LlmError$1, ProviderRequestId, ReasoningEffortId, attributionHeaders, resolveRetryPolicy } from "@deepseek-ai/dsh-llm";
+import fs, { chmod, lstat, mkdir, open, readFile, rename, stat, unlink } from "node:fs/promises";
 import path, { basename, dirname, join, relative, resolve } from "node:path";
 import os, { homedir } from "node:os";
 import { createHash, randomBytes, randomUUID } from "node:crypto";
 import { isDeepStrictEqual } from "node:util";
 import { execSync, spawn } from "node:child_process";
-import fsPromises, { chmod, lstat, mkdir, open, readFile, rename, stat, unlink } from "node:fs/promises";
-import fs, { appendFileSync, constants, copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, rmSync, statSync, utimesSync, writeFileSync } from "node:fs";
+import fs$1, { appendFileSync, constants, copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, rmSync, statSync, utimesSync, writeFileSync } from "node:fs";
 import http, { createServer } from "node:http";
 import { WebError } from "@deepseek-ai/dsh-web";
 import { lookup } from "node:dns/promises";
@@ -60,7 +60,23 @@ const OAUTH_CALLBACK_HOST = "localhost";
 const OAUTH_CALLBACK_PORT = 1455;
 const OAUTH_REDIRECT_URI = `http://${OAUTH_CALLBACK_HOST}:${OAUTH_CALLBACK_PORT}/auth/callback`;
 const OAUTH_SCOPE = "openid profile email offline_access";
-const OAUTH_ORIGINATOR = "opencode";
+/**
+* The single `originator` this line presents to the Codex backend on every
+* request, and the one OAuth sends during sign-in.
+*
+* This used to be three different values - `opencode` for chat and sign-in,
+* `pi` for the image and search endpoints - which was an archaeological record
+* of when each endpoint was reverse-engineered, not a decision. The Codex
+* backend keys behaviour off this value (`codex_cli_rs` is what the official
+* CLI sends) and treats it as one client identity, so splitting it across three
+* files meant three unrelated failure signatures for one account. Both spellings
+* are known-good against the backend; `opencode` is kept because it is the value
+* the OAuth flow has always presented, and changing the sign-in originator is a
+* different risk from changing the request originator.
+*/
+const CODEX_ORIGINATOR = "opencode";
+/** OAuth presents the same identity the request path does (see above). */
+const OAUTH_ORIGINATOR = CODEX_ORIGINATOR;
 const TOKEN_REFRESH_MARGIN_MS = 6e4;
 const ROUTE_PREFIX$4 = "/api/dsh-chatgpt-subscription";
 const PLUGIN_VERSION = "0.1.0-alpha.0";
@@ -70,9 +86,18 @@ const CODEX_RESPONSES_URL = `${CODEX_API_BASE}/responses`;
 const CODEX_IMAGE_GENERATION_URL = `${CODEX_API_BASE}/images/generations`;
 const CODEX_SEARCH_URL = `${CODEX_API_BASE}/alpha/search`;
 const CODEX_USAGE_URL = "https://chatgpt.com/backend-api/wham/usage";
+const CODEX_MODELS_URL = `${CODEX_API_BASE}/models?client_version=0.99.0`;
+/**
+* Beta gate the Codex backend expects on every responses request.
+*
+* The subscription backend is served under a beta flag, not as stable API:
+* without this header the endpoint is a different (and, on older builds,
+* rejected) surface. Kept as a single constant so the value is reviewable in
+* one place with the rest of the wire contract in `wire-auth.ts`.
+*/
+const CODEX_OPENAI_BETA = "responses=experimental";
 const CODEX_RESET_CREDITS_URL = "https://chatgpt.com/backend-api/wham/rate-limit-reset-credits";
 const CODEX_RESET_CREDITS_CONSUME_URL = `${CODEX_RESET_CREDITS_URL}/consume`;
-const CODEX_ORIGINATOR = "opencode";
 const CODEX_IMAGE_TOOL_NAME = "codex_image_generate";
 const CODEX_IMAGE_MODEL = "gpt-image-2";
 const CODEX_SEARCH_PROVIDER_ID = "codex-subscription";
@@ -227,6 +252,9 @@ function reasoningEffortsForModel(model) {
 	if (profile === "gpt-6") return GPT_6_REASONING_EFFORTS;
 	return profile === "gpt-5.6" ? GPT_56_REASONING_EFFORTS : STANDARD_REASONING_EFFORTS;
 }
+function isCodexReasoningEffort(value) {
+	return typeof value === "string" && GPT_56_REASONING_EFFORTS.some((effort) => effort === value);
+}
 function isCodexModelId(model) {
 	return typeof model === "string" && CODEX_MODEL_CATALOG.some((entry) => entry.id === model);
 }
@@ -270,28 +298,40 @@ function resolveCodexFallbackModel(model) {
 //#region src/host/model-catalog.ts
 const PROVIDER_ID$6 = CODEX_CHATGPT_PROVIDER_ID;
 const PROVIDER_NAME$6 = "Codex（ChatGPT 订阅）";
-function listCodexModels(preferences) {
+function listCodexModels(preferences, live) {
 	const status = preferences?.status();
 	if (status?.enabled === false) return [];
-	const visible = new Set(status?.visibleModelIds ?? CODEX_MODEL_CATALOG.map((entry) => entry.id));
-	return CODEX_MODEL_CATALOG.filter((entry) => visible.has(entry.id)).map((entry) => ({
+	const source = live !== void 0 && live.length > 0 ? live.map((entry) => ({
+		id: entry.id,
+		name: entry.name,
+		inputModalities: entry.inputModalities
+	})) : CODEX_MODEL_CATALOG.map((entry) => ({
+		id: entry.id,
+		name: entry.name,
+		inputModalities: entry.inputModalities
+	}));
+	const visible = new Set(status?.visibleModelIds ?? source.map((entry) => entry.id));
+	return source.filter((entry) => visible.has(entry.id)).map((entry) => ({
 		provider: PROVIDER_ID$6,
 		id: entry.id,
 		name: entry.name,
 		inputModalities: [...entry.inputModalities]
 	}));
 }
-function resolveCodexModel(model, preferences) {
+function resolveCodexModel(model, preferences, live) {
 	const entry = resolveCodexCatalogEntry(model);
+	const liveEntry = live?.find((candidate) => candidate.id === model);
 	const configuredContextWindow = (preferences?.status())?.contextWindowOverrides[model];
-	const efforts = reasoningEffortsForModel(model);
-	const defaultEffort = efforts.includes(entry.defaultReasoningEffort) ? entry.defaultReasoningEffort : efforts[0];
+	const listedEfforts = liveEntry?.reasoningEfforts?.filter(isCodexReasoningEffort);
+	const efforts = listedEfforts !== void 0 && listedEfforts.length > 0 ? listedEfforts : reasoningEffortsForModel(model);
+	const statedDefault = liveEntry?.defaultReasoningEffort ?? entry.defaultReasoningEffort;
+	const defaultEffort = isCodexReasoningEffort(statedDefault) && efforts.includes(statedDefault) ? statedDefault : efforts[0];
 	return {
 		provider: PROVIDER_ID$6,
 		id: model,
-		name: entry.id === model ? entry.name : model,
-		inputModalities: [...entry.inputModalities],
-		context: { contextWindow: configuredContextWindow ?? entry.contextWindow },
+		name: liveEntry?.name ?? (entry.id === model ? entry.name : model),
+		inputModalities: [...liveEntry?.inputModalities ?? entry.inputModalities],
+		context: { contextWindow: configuredContextWindow ?? liveEntry?.contextWindow ?? entry.contextWindow },
 		defaultMaxTokens: codexModelMaxTokens(model),
 		reasoning: {
 			efforts: efforts.map((effort) => ({
@@ -324,10 +364,12 @@ const RETRY_POLICY$5 = resolveRetryPolicy({
 var CodexChatGptAdapter = class extends LlmAdapter {
 	client;
 	preferences;
-	constructor(client, preferences) {
+	loadCatalog;
+	constructor(client, preferences, loadCatalog) {
 		super();
 		this.client = client;
 		this.preferences = preferences;
+		this.loadCatalog = loadCatalog;
 	}
 	providerInfo(provider) {
 		return {
@@ -340,10 +382,21 @@ var CodexChatGptAdapter = class extends LlmAdapter {
 	}
 	imageRequestPricing(_provider, _model) {}
 	async listModels() {
-		return listCodexModels(this.preferences);
+		return listCodexModels(this.preferences, await this.catalog());
 	}
 	async resolveModel(_provider, model, signal) {
-		return resolveCodexModel(model, this.preferences);
+		return resolveCodexModel(model, this.preferences, await this.catalog(signal));
+	}
+	/**
+	* The live listing, or undefined when this line has no way to fetch one.
+	*
+	* Never throws: a listing failure must not become a failed picker or a
+	* rejected model resolution. `loadCodexCatalog` already answers with the
+	* shipped table on failure, so the catch here only covers a throwing loader.
+	*/
+	async catalog(signal) {
+		if (this.loadCatalog === void 0) return void 0;
+		return this.loadCatalog({ signal }).catch(() => void 0);
 	}
 	async prepareCall(provider, model, signal) {
 		return {
@@ -367,6 +420,347 @@ function dshHomeDir() {
 	return process.env.DSH_HOME?.trim() || path.join(os.homedir(), ".dsh");
 }
 //#endregion
+//#region src/host/common/catalog-snapshot.ts
+/**
+* Persistent snapshot for one provider's live model catalog.
+*
+* The in-memory catalog caches keep a process alive between requests, but they
+* start cold: on the first call after a restart (or a plugin reinstall) the
+* picker and the settings page both wait on the upstream listing before they
+* can render anything, and an unreachable endpoint turns that wait into the
+* full discovery timeout — "the model server is unavailable" on a fresh
+* install. The catalog is not fast-moving data, so the last successful listing
+* is persisted to `<DSH_HOME>/storages/` and rehydrated into the in-memory
+* cache on first use. A snapshot the caller can read is therefore available
+* from the very first call, with no network in the path.
+*
+* Writes are best-effort: persistence is an optimization, never a capability.
+* A read-only home or a locked file must not fail the fetch that produced the
+* snapshot.
+*/
+/** File name of the persisted snapshot for one catalog. */
+function catalogSnapshotPath(name) {
+	return path.join(dshHomeDir(), "storages", `${name}-catalog.json`);
+}
+/**
+* Snapshot name for one catalog *and* one credential scope.
+*
+* A persisted snapshot answers before any credential is read — that is the whole
+* point of it — so the file itself has to carry the scope it was fetched under.
+* Otherwise the first call after a restart, for any account, is answered by
+* whatever listing some other scope happened to persist last: a Kimi listing
+* fetched for the mainland-cn endpoint would answer a global caller with models
+* and context windows that region does not serve, and a Command Code listing
+* fetched against one API environment would answer the other.
+*
+* The scope is part of the file name rather than of the payload because a caller
+* that cannot name the account — the harness resolves this catalog with no token
+* at all — still has to find the snapshot its own scope owns.
+*
+* Everything outside `[a-z0-9]` is folded to `_`, so no scope can escape the
+* `storages` directory.
+*/
+function catalogSnapshotName(base, scope) {
+	const normalized = scope.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+	return normalized === "" ? base : `${base}-${normalized}`;
+}
+/**
+* Read the persisted snapshot for one catalog.
+*
+* Shape errors and unreadable files both return `undefined` — the caller keeps
+* its in-memory state, and the next successful fetch overwrites the file.
+*/
+async function readCatalogSnapshot(name, parseModels) {
+	try {
+		const content = await fs.readFile(catalogSnapshotPath(name), "utf8");
+		const parsed = JSON.parse(content);
+		if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return void 0;
+		const record = parsed;
+		const fetchedAt = record.fetchedAt;
+		if (typeof fetchedAt !== "number" || !Number.isFinite(fetchedAt) || fetchedAt <= 0) return void 0;
+		const models = parseModels(record.models);
+		if (models === void 0 || models.length === 0) return void 0;
+		return {
+			fetchedAt,
+			models
+		};
+	} catch {
+		return;
+	}
+}
+/**
+* Snapshot writes still in flight.
+*
+* Callers fire-and-forget these writes, so nothing in production ever awaits
+* one. A test that deletes its private `storages` directory between cases
+* cannot know when that is safe, and a write that lands after the delete
+* recreates the file the next case asserts is absent — which is how a stale
+* listing leaked into a later test and failed it on CI. Registering each write
+* gives {@link flushCatalogSnapshots} a deterministic point to wait on.
+*/
+const pendingSnapshotWrites = /* @__PURE__ */ new Set();
+/** Persist one snapshot; a failure is logged nowhere and never thrown. */
+function writeCatalogSnapshot(name, models, fetchedAt) {
+	const write = (async () => {
+		try {
+			const filePath = catalogSnapshotPath(name);
+			await fs.mkdir(path.dirname(filePath), { recursive: true });
+			const tmp = `${filePath}.tmp.${Date.now()}`;
+			await fs.writeFile(tmp, JSON.stringify({
+				fetchedAt,
+				models
+			}, null, 2), "utf8");
+			await fs.rename(tmp, filePath);
+		} catch {}
+	})();
+	pendingSnapshotWrites.add(write);
+	write.finally(() => {
+		pendingSnapshotWrites.delete(write);
+	});
+	return write;
+}
+/**
+* Warm an in-memory cache from the persisted snapshot when it is fresher than
+* what the cache currently holds. Called lazily on the first cache miss of a
+* process, so a restart serves the previous listing without waiting on the
+* network.
+*
+* @returns the snapshot's `fetchedAt`, or `0` when no usable snapshot exists —
+*   the caller then fetches as before.
+*/
+async function rehydrateCatalogCache(name, parseModels, accept, currentFetchedAt) {
+	const snapshot = await readCatalogSnapshot(name, parseModels);
+	if (snapshot === void 0 || snapshot.fetchedAt <= currentFetchedAt) return 0;
+	accept(snapshot.fetchedAt, snapshot.models);
+	return snapshot.fetchedAt;
+}
+//#endregion
+//#region src/host/wire-auth.ts
+/**
+* Turn-state header the Codex backend hands back on a responses response.
+*
+* The official CLI reads it and echoes it on the next request of the same
+* conversation; the backend uses it to resume instead of re-ingesting the
+* whole history. It is opaque, short-lived and account-scoped, so it is
+* threaded through rather than computed (see `responses-client.ts`).
+*/
+const CODEX_TURN_STATE_HEADER = "x-codex-turn-state";
+function codexHeaders(credentials, sessionId, options = {}) {
+	const dshAgent = attributionHeaders()["user-agent"] ?? "dsh/unknown";
+	return {
+		authorization: `Bearer ${credentials.accessToken}`,
+		...credentials.accountId ? { "chatgpt-account-id": credentials.accountId } : {},
+		"openai-beta": CODEX_OPENAI_BETA,
+		originator: CODEX_ORIGINATOR,
+		"user-agent": `dsh-chatgpt-subscription/${PLUGIN_VERSION} (${dshAgent})`,
+		...sessionId ? { "session-id": sessionId } : {},
+		...options.turnState ? { [CODEX_TURN_STATE_HEADER]: options.turnState } : {}
+	};
+}
+function stableSessionId(value) {
+	const source = value === void 0 || value === "" ? randomUUID() : value;
+	return `dsh-${createHash("sha256").update(source).digest("hex").slice(0, 32)}`;
+}
+function retryAfterMs$1(headers) {
+	const raw = headers.get("retry-after");
+	if (raw === null) return void 0;
+	const seconds = Number(raw);
+	if (Number.isFinite(seconds) && seconds >= 0) return Math.min(seconds * 1e3, 10 * 6e4);
+	const timestamp = Date.parse(raw);
+	if (!Number.isFinite(timestamp)) return void 0;
+	return Math.min(Math.max(0, timestamp - Date.now()), 10 * 6e4);
+}
+//#endregion
+//#region src/host/codex-catalog.ts
+/** How long a live listing is reused before the server is asked again. */
+const CATALOG_TTL_MS = 15 * 6e4;
+/**
+* Snapshot scope.
+*
+* The Codex listing is account-scoped (each plan sees its own models), so the
+* persisted snapshot is filed under the account it was fetched for. Without the
+* scope a rehydrated listing from one account would answer another's picker.
+*/
+const SNAPSHOT_SCOPE = "chatgpt-codex";
+let catalogCache$2 = null;
+const catalogInFlight$3 = /* @__PURE__ */ new Map();
+let snapshotRehydrated = null;
+/**
+* The listing currently held, or undefined before the first load.
+*
+* Callers that need a catalog with no credential read the shipped table
+* directly; returning it here under a different entry type would force every
+* one of them to convert it.
+*/
+function getCachedCatalog() {
+	return catalogCache$2?.models;
+}
+/**
+* Read the models this subscription can call.
+*
+* The shipped table in `shared/model-catalog.ts` stays the floor: it is what
+* answers a picker before the first sign-in, and what a failed listing falls
+* back to. The subscription listing is the authority once one is available,
+* because only the backend knows which models a plan currently serves and at
+* what context window — the reason subscription-only models exist at all.
+*
+* Single-flighted per account, because the harness resolves every model of every
+* provider when it builds the picker; without that, one picker build is one
+* round trip per model.
+*/
+function loadCodexCatalog(credentials, options = {}) {
+	const key = accountKeyFor$1(credentials);
+	if (options.force !== true) {
+		const cached = catalogCache$2;
+		if (cached !== null && cached.key === key && Date.now() - cached.at < CATALOG_TTL_MS) return Promise.resolve(cached.models);
+	}
+	const pending = catalogInFlight$3.get(key);
+	if (pending !== void 0) return pending;
+	const run = performCatalogLoad$1(credentials, options).then((models) => {
+		catalogInFlight$3.delete(key);
+		return models;
+	}, (error) => {
+		catalogInFlight$3.delete(key);
+		throw error;
+	});
+	catalogInFlight$3.set(key, run);
+	return run;
+}
+async function performCatalogLoad$1(credentials, options) {
+	const key = accountKeyFor$1(credentials);
+	const fetchFn = options.fetchFn ?? fetch;
+	snapshotRehydrated ??= rehydrateSnapshot(key);
+	await snapshotRehydrated;
+	const cached = catalogCache$2;
+	if (cached !== null && cached.key === key && Date.now() - cached.at < CATALOG_TTL_MS) return cached.models;
+	let models;
+	let live = false;
+	try {
+		const response = await fetchFn(CODEX_MODELS_URL, {
+			method: "GET",
+			headers: {
+				...codexHeaders(credentials),
+				accept: "application/json"
+			},
+			signal: options.signal
+		});
+		if (!response.ok) throw new Error(`Codex model listing failed (${response.status}).`);
+		const listing = parseListing(await response.json().catch(() => void 0));
+		if (listing.length === 0) throw new Error("Codex model listing named no models this line understands.");
+		models = listing;
+		live = true;
+		writeCatalogSnapshot(catalogSnapshotName(SNAPSHOT_SCOPE, key), [...models], Date.now());
+	} catch {
+		models = getCachedCatalog() ?? [];
+		live = false;
+	}
+	catalogCache$2 = {
+		at: Date.now(),
+		models,
+		key,
+		live
+	};
+	return models;
+}
+/**
+* Seed the in-memory cache from the last persisted listing.
+*
+* Best effort by construction: a missing or malformed snapshot leaves the cache
+* cold, and the caller then simply makes the network call.
+*/
+async function rehydrateSnapshot(key) {
+	const snapshot = await readCatalogSnapshot(catalogSnapshotName(SNAPSHOT_SCOPE, key), (value) => Array.isArray(value) ? value.flatMap((item) => parseListingEntry$1(item)) : void 0).catch(() => void 0);
+	if (snapshot === void 0 || snapshot.models.length === 0) return;
+	if (catalogCache$2 !== null) return;
+	catalogCache$2 = {
+		at: snapshot.fetchedAt,
+		models: snapshot.models,
+		key,
+		live: true
+	};
+}
+/**
+* Read the listing payload.
+*
+* The documented shape is `{ models: [...] }`, but a bare array is accepted too
+* so a backend that flattens the envelope does not read as an empty catalog.
+*/
+function parseListing(payload) {
+	const record = asRecord$10(payload);
+	const models = Array.isArray(payload) ? payload : record?.models;
+	if (!Array.isArray(models)) return [];
+	return models.flatMap((item) => parseListingEntry$1(item));
+}
+/**
+* One listing entry.
+*
+* Only fields the backend actually documents are read. A model id this line has
+* never heard of still produces an entry, because the listing is the authority
+* on what the account may call — but every capability it does not state falls
+* back to a conservative answer rather than to a guess.
+*/
+function parseListingEntry$1(value) {
+	const record = asRecord$10(value);
+	if (record === void 0) return [];
+	const id = asString$14(record.slug) ?? asString$14(record.id);
+	if (id === void 0) return [];
+	const contextWindow = asNumber$4(record.context_window) ?? asNumber$4(record.contextWindow);
+	const modalities = parseModalities(record.input_modalities);
+	const efforts = parseEfforts(record.supported_reasoning_levels);
+	const fallback = CODEX_MODEL_CATALOG.find((entry) => entry.id === id);
+	return [{
+		id,
+		name: asString$14(record.display_name) ?? asString$14(record.displayName) ?? fallback?.name ?? id,
+		contextWindow: contextWindow !== void 0 && contextWindow > 0 ? contextWindow : null,
+		inputModalities: modalities ?? (fallback ? [...fallback.inputModalities] : ["text"]),
+		...efforts !== null ? { reasoningEfforts: efforts } : {},
+		defaultReasoningEffort: asString$14(record.default_reasoning_level) ?? fallback?.defaultReasoningEffort ?? null
+	}];
+}
+function parseModalities(value) {
+	if (!Array.isArray(value)) return null;
+	const out = [];
+	for (const item of value) {
+		const name = asString$14(item);
+		if (name === "text" || name === "image") out.push(name);
+	}
+	return out.length > 0 ? out : null;
+}
+/**
+* Reasoning levels the listing states, in the order it stated them.
+*
+* The backend writes each level as `{ "effort": "high" }`; a bare string is
+* accepted too, since that is the other spelling seen in the wild.
+*/
+function parseEfforts(value) {
+	if (!Array.isArray(value)) return null;
+	const out = [];
+	for (const item of value) {
+		const effort = asString$14(item) ?? asString$14(asRecord$10(item)?.effort);
+		if (effort !== void 0 && !out.includes(effort)) out.push(effort);
+	}
+	return out.length > 0 ? out : null;
+}
+/**
+* Cache identity for one credential.
+*
+* The account id is the entitlement boundary: two accounts of the same user can
+* see different listings, and a pool rotates between them, so the key has to
+* follow the account rather than the person.
+*/
+function accountKeyFor$1(credentials) {
+	return credentials.accountId || "default";
+}
+function asRecord$10(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function asString$14(value) {
+	return typeof value === "string" && value !== "" ? value : void 0;
+}
+function asNumber$4(value) {
+	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+//#endregion
 //#region src/host/common/credential-read-cache.ts
 /**
 * Identity a file-backed credential store reports when nothing is stored.
@@ -905,6 +1299,16 @@ function poolCredentialAccount$1(filePath) {
 	return createHash("sha256").update(path.resolve(filePath)).digest("hex");
 }
 const poolOperations = /* @__PURE__ */ new Map();
+const poolIdentityRevisions = /* @__PURE__ */ new Map();
+const poolRefreshes = /* @__PURE__ */ new Map();
+/**
+* A selected row was deleted, or became unusable, while a caller awaited it.
+*
+* Distinct from every other credential error because a MODEL REQUEST can still
+* be served by another account: routing excludes the row and tries the next
+* one, while a caller that named the account still gets the plain refusal.
+*/
+var PoolAccountUnavailableError = class extends LlmError {};
 /**
 * The shared multi-account pool: encrypted storage, eligibility filtering,
 * rotation strategy, 429 cooldowns and per-account auth failures.
@@ -926,11 +1330,14 @@ var AccountPoolCore = class {
 	* can therefore invalidate on identity change without paying a credential read
 	* to discover it.
 	*/
-	identityRevision = 0;
+	/** Pool-file identity of this instance: locks, revisions and flights key on it. */
+	operationKey;
 	constructor(hooks) {
 		this.hooks = hooks;
 		this.filePath = hooks.poolFile;
 		this.backend = hooks.backend ?? createPoolBackend(hooks);
+		const resolved = path.resolve(this.filePath);
+		this.operationKey = process.platform === "win32" ? resolved.toLowerCase() : resolved;
 	}
 	/**
 	* A cheap, in-memory revision of the pool's serving identity.
@@ -946,15 +1353,21 @@ var AccountPoolCore = class {
 	* would report one account's usage under another account's name.
 	*/
 	currentIdentityRevision() {
-		return this.identityRevision;
+		return poolIdentityRevisions.get(this.operationKey) ?? 0;
 	}
 	/** Human description of where this pool's credentials live. */
 	path() {
 		if (process.platform === "win32") return `${this.filePath}.dpapi`;
 		return `${process.platform === "darwin" ? "Keychain" : "Secret Service"}: ${this.hooks.keychainService}/${poolCredentialAccount$1(this.filePath)}`;
 	}
+	/**
+	* Queue one storage transaction for this pool file.
+	*
+	* NOT reentrant: a transaction must use {@link loadPoolData} and
+	* {@link updatePool} rather than calling the public read/write methods.
+	*/
 	serialize(operation) {
-		const key = path.resolve(this.filePath);
+		const key = this.operationKey;
 		const result = (poolOperations.get(key) || Promise.resolve()).then(operation);
 		const settled = result.then(() => void 0, () => void 0);
 		poolOperations.set(key, settled);
@@ -978,31 +1391,74 @@ var AccountPoolCore = class {
 	* getter write to disk.
 	*/
 	read() {
-		return this.serialize(async () => {
-			let current = null;
-			try {
-				current = await this.backend.load();
-			} catch {}
-			if (current !== null && Array.isArray(current.accounts) && current.accounts.length > 0) return current;
-			try {
-				const legacy = await this.hooks.legacyAccount?.();
-				if (legacy) return {
-					version: 1,
-					activeAccountId: legacy.id,
-					rotationStrategy: current?.rotationStrategy || "sequential",
-					accounts: [legacy]
-				};
-			} catch {}
-			return current || {
+		return this.serialize(() => this.loadPoolData());
+	}
+	/**
+	* Load the pool without holding the file lock.
+	*
+	* Providers override this to maintain their own in-memory indexes, so every
+	* load — including one inside {@link updatePool} — refreshes them.
+	*/
+	async loadPoolData() {
+		let current = null;
+		try {
+			current = await this.backend.load();
+		} catch {}
+		if (current !== null && Array.isArray(current.accounts) && current.accounts.length > 0) return current;
+		try {
+			const legacy = await this.hooks.legacyAccount?.();
+			if (legacy) return {
 				version: 1,
-				rotationStrategy: "sequential",
-				accounts: []
+				activeAccountId: legacy.id,
+				rotationStrategy: current?.rotationStrategy || "sequential",
+				accounts: [legacy]
 			};
-		});
+		} catch {}
+		return current || {
+			version: 1,
+			rotationStrategy: "sequential",
+			accounts: []
+		};
+	}
+	async persistPoolData(data) {
+		poolIdentityRevisions.set(this.operationKey, this.currentIdentityRevision() + 1);
+		await this.saveVerified(data);
 	}
+	/**
+	* Replace the whole document (initialization, import), NOT a read-modify-write.
+	* Prefer {@link updatePool} for mutations so the draft is read under the lock.
+	*/
 	write(data) {
-		this.identityRevision += 1;
-		return this.serialize(() => this.saveVerified(this.hooks.parsePoolData(data)));
+		return this.serialize(() => this.persistPoolData(data));
+	}
+	/**
+	* Read the LATEST document, mutate it and persist it as one file transaction.
+	*
+	* This is the whole fix for the read-modify-write race: the old shape read a
+	* snapshot, awaited (a token refresh, a settings write, an encrypted round
+	* trip) and then wrote that whole stale snapshot back, erasing whatever landed
+	* in between — including another account's freshly rotated token.
+	*
+	* The callback runs under the file lock, so it must not call read, write or
+	* updatePool (the lock is not reentrant) and must not do network I/O.
+	* Provider-local stores belong in `afterCommit`, which runs only once the
+	* pool write is verified, and must not re-enter the pool either.
+	*/
+	updatePool(mutate, afterCommit) {
+		return this.serialize(async () => {
+			const data = await this.loadPoolData();
+			const before = structuredClone(data);
+			const result = await mutate(data);
+			if (!isDeepStrictEqual(before, data)) {
+				await this.persistPoolData(data);
+				await afterCommit?.(data, result).catch(() => void 0);
+				for (const account of data.accounts) if (!isDeepStrictEqual(before.accounts.find((entry) => entry.id === account.id)?.credentials, account.credentials)) await this.hooks.credentialsCommitted?.(account).catch(() => void 0);
+				const previousPrimary = before.accounts.find((account) => account.isPrimary);
+				const primary = data.accounts.find((account) => account.isPrimary);
+				if (previousPrimary?.id !== primary?.id || !isDeepStrictEqual(previousPrimary?.credentials, primary?.credentials)) await this.hooks.mirrorPrimary?.(primary?.credentials ?? null).catch(() => void 0);
+			}
+			return result;
+		});
 	}
 	/** Public summaries, with cooldowns that already expired reported as absent. */
 	async listAccounts() {
@@ -1031,8 +1487,17 @@ var AccountPoolCore = class {
 		return this.hooks.extendSummary ? this.hooks.extendSummary(account, summary, now) : summary;
 	}
 	/** Add or re-authorize one account; an existing dedupe key updates in place. */
-	async addAccount(credentials, alias) {
-		const data = await this.read();
+	addAccount(credentials, alias) {
+		return this.updatePool((data) => this.addAccountToPool(data, credentials, alias));
+	}
+	/**
+	* Add or re-authorize inside an existing transaction.
+	*
+	* Capacity, dedupe and the primary decision are all taken against the live
+	* document, so two simultaneous sign-ins cannot each pass a check the other
+	* has already invalidated.
+	*/
+	addAccountToPool(data, credentials, alias) {
 		const key = this.hooks.dedupeKey?.(credentials);
 		const existingIndex = key === void 0 ? -1 : data.accounts.findIndex((account) => this.hooks.dedupeKey?.(account.credentials) === key);
 		const maxAccounts = this.hooks.maxAccounts ?? 20;
@@ -1058,77 +1523,79 @@ var AccountPoolCore = class {
 		if (existingIndex >= 0) data.accounts[existingIndex] = account;
 		else data.accounts.push(account);
 		if (!data.activeAccountId || account.isPrimary) data.activeAccountId = account.id;
-		await this.write(data);
-		if (account.isPrimary) this.hooks.mirrorPrimary?.(credentials).catch(() => void 0);
 		return account;
 	}
-	async setPrimary(accountId) {
-		const data = await this.read();
-		for (const account of data.accounts) account.isPrimary = account.id === accountId;
-		const primary = data.accounts.find((account) => account.isPrimary);
-		if (primary) {
-			data.activeAccountId = primary.id;
-			this.hooks.mirrorPrimary?.(primary.credentials).catch(() => void 0);
-		}
-		await this.write(data);
+	setPrimary(accountId) {
+		return this.updatePool((data) => {
+			for (const account of data.accounts) account.isPrimary = account.id === accountId;
+			const primary = data.accounts.find((account) => account.isPrimary);
+			if (primary) data.activeAccountId = primary.id;
+		});
 	}
 	/**
 	* Persist a refreshed credential for one account.
 	*
+	* `expected` makes this a conditional write: when the stored credential is
+	* no longer the one the caller started from, something newer won the race (a
+	* re-login, a rotation committed while this call was in flight) and the
+	* latest row is returned WITHOUT being overwritten. A deleted account is
+	* never brought back.
+	*
 	* Used by a forced refresh (a 401 mid-request) rather than by the rotating
-	* getEffectiveAccount path, which already writes back what it refreshed.
+	* getEffectiveAccount path, which refreshes through its own single-flight.
 	*/
-	async updateAccountCredentials(accountId, credentials) {
-		const data = await this.read();
-		const target = data.accounts.find((account) => account.id === accountId);
-		if (target === void 0) return void 0;
-		target.credentials = credentials;
-		await this.write(data);
-		if (target.isPrimary) this.hooks.mirrorPrimary?.(credentials).catch(() => void 0);
-		return target;
+	updateAccountCredentials(accountId, credentials, expected) {
+		return this.updatePool((data) => {
+			const target = data.accounts.find((account) => account.id === accountId);
+			if (target && (expected === void 0 || isDeepStrictEqual(target.credentials, expected))) target.credentials = credentials;
+			return target;
+		});
 	}
-	async setAlias(accountId, alias) {
-		const data = await this.read();
-		const target = data.accounts.find((account) => account.id === accountId);
-		if (target && alias.trim()) {
-			target.alias = alias.trim();
-			await this.write(data);
-		}
+	setAlias(accountId, alias) {
+		return this.updatePool((data) => {
+			const target = data.accounts.find((account) => account.id === accountId);
+			if (target && alias.trim()) target.alias = alias.trim();
+		});
 	}
-	async deleteAccount(accountId) {
-		const data = await this.read();
+	deleteAccount(accountId) {
+		return this.updatePool((data) => this.deleteAccountFromPool(data, accountId));
+	}
+	/**
+	* Remove one account inside a transaction.
+	*
+	* Provider refusal rules (a snapshot this plugin does not own, a desktop
+	* account it may only hide) belong in an override of this, so the check and
+	* the removal cannot be separated by a concurrent change.
+	*/
+	deleteAccountFromPool(data, accountId) {
 		const wasPrimary = data.accounts.find((account) => account.id === accountId)?.isPrimary;
 		data.accounts = data.accounts.filter((account) => account.id !== accountId);
-		if (wasPrimary && data.accounts.length > 0) {
-			data.accounts[0].isPrimary = true;
-			this.hooks.mirrorPrimary?.(data.accounts[0].credentials).catch(() => void 0);
-		} else if (data.accounts.length === 0) this.hooks.mirrorPrimary?.(null).catch(() => void 0);
+		if (wasPrimary && data.accounts.length > 0) data.accounts[0].isPrimary = true;
 		if (data.activeAccountId === accountId) data.activeAccountId = data.accounts.find((account) => account.isPrimary)?.id ?? data.accounts[0]?.id;
-		await this.write(data);
 	}
-	async setStrategy(strategy) {
-		const data = await this.read();
-		data.rotationStrategy = strategy;
-		await this.write(data);
+	setStrategy(strategy) {
+		return this.updatePool((data) => {
+			data.rotationStrategy = strategy;
+		});
 	}
 	/** Cool one account down after an upstream 429. */
-	async markCooldown(accountId, durationMs, reason) {
-		const data = await this.read();
-		const target = data.accounts.find((account) => account.id === accountId);
-		if (target) {
-			target.cooldownUntil = Date.now() + Math.max(MIN_COOLDOWN_MS, durationMs);
-			target.cooldownReason = reason;
-			await this.write(data);
-		}
+	markCooldown(accountId, durationMs, reason) {
+		return this.updatePool((data) => {
+			const target = data.accounts.find((account) => account.id === accountId);
+			if (target) {
+				target.cooldownUntil = Date.now() + Math.max(MIN_COOLDOWN_MS, durationMs);
+				target.cooldownReason = reason;
+			}
+		});
 	}
-	async clearCooldown(accountId) {
-		const data = await this.read();
-		const target = data.accounts.find((account) => account.id === accountId);
-		if (target) {
-			target.cooldownUntil = void 0;
-			target.cooldownReason = void 0;
-			await this.write(data);
-		}
+	clearCooldown(accountId) {
+		return this.updatePool((data) => {
+			const target = data.accounts.find((account) => account.id === accountId);
+			if (target) {
+				target.cooldownUntil = void 0;
+				target.cooldownReason = void 0;
+			}
+		});
 	}
 	/**
 	* Record that an account can no longer authenticate.
@@ -1136,23 +1603,23 @@ var AccountPoolCore = class {
 	* The account stays in the pool: signing in again is what restores it, and a
 	* deleted account would take the user's alias and ordering with it.
 	*/
-	async markAuthFailed(accountId, reason, status = "expired") {
-		const data = await this.read();
-		const target = data.accounts.find((account) => account.id === accountId);
-		if (target) {
-			target.authStatus = status;
-			target.authFailedReason = reason;
-			await this.write(data);
-		}
+	markAuthFailed(accountId, reason, status = "expired") {
+		return this.updatePool((data) => {
+			const target = data.accounts.find((account) => account.id === accountId);
+			if (target) {
+				target.authStatus = status;
+				target.authFailedReason = reason;
+			}
+		});
 	}
-	async clearAuthFailed(accountId) {
-		const data = await this.read();
-		const target = data.accounts.find((account) => account.id === accountId);
-		if (target) {
-			target.authStatus = void 0;
-			target.authFailedReason = void 0;
-			await this.write(data);
-		}
+	clearAuthFailed(accountId) {
+		return this.updatePool((data) => {
+			const target = data.accounts.find((account) => account.id === accountId);
+			if (target) {
+				target.authStatus = void 0;
+				target.authFailedReason = void 0;
+			}
+		});
 	}
 	/** Whether an account may serve a request right now. */
 	isEligible(account, now, triedAccountIds) {
@@ -1192,24 +1659,16 @@ var AccountPoolCore = class {
 	*
 	* @param fetchFn - fetch used if the credential is close to expiry.
 	*/
-	async getCredentialAccount(fetchFn = fetch) {
+	async getCredentialAccount(fetchFn = fetch, forceRefresh = false) {
 		const data = await this.read();
 		if (data.accounts.length === 0) throw new Error(this.hooks.emptyMessage ?? `未登录 ${this.hooks.displayName} 账号，请先在设置页添加账号。`);
-		const now = Date.now();
 		const usable = data.accounts.filter((account) => this.isCredentialUsable(account));
 		if (usable.length === 0) throw new LlmError(`全部 ${data.accounts.length} 个 ${this.hooks.displayName} 账号均需要重新登录。`, "AUTH", { status: 401 });
 		const selected = this.selectAccount(usable, data);
-		if (this.shouldRefreshCredential(selected, now) && this.hooks.refresh) {
-			const refreshed = await this.hooks.refresh(selected.credentials, fetchFn);
-			await this.updateAccountCredentials(selected.id, refreshed);
-			return {
-				account: selected,
-				credentials: refreshed
-			};
-		}
+		const account = await this.freshAccount(selected, fetchFn, forceRefresh);
 		return {
-			account: selected,
-			credentials: selected.credentials
+			account,
+			credentials: account.credentials
 		};
 	}
 	/**
@@ -1244,8 +1703,8 @@ var AccountPoolCore = class {
 	* looks unexpired, and only the service's own refusal says so. Renewing it is
 	* what separates that from a credential that genuinely needs a new sign-in.
 	*/
-	async renewCredential(accountId, fetchFn = fetch) {
-		return this.credentialFor(accountId, fetchFn, true);
+	async renewCredential(accountId, fetchFn = fetch, expected) {
+		return this.credentialFor(accountId, fetchFn, true, expected);
 	}
 	/**
 	* Resolve, and if needed renew, one account's credential.
@@ -1255,29 +1714,106 @@ var AccountPoolCore = class {
 	* not name an account (the catalog loader) still has to present the
 	* credential that is actually in play.
 	*/
-	async credentialFor(accountId, fetchFn, force) {
+	async credentialFor(accountId, fetchFn, force, expected) {
 		const data = await this.read();
 		const target = accountId === void 0 ? data.accounts.find((account) => account.id === data.activeAccountId) ?? data.accounts.find((account) => account.isPrimary) ?? data.accounts[0] : data.accounts.find((account) => account.id === accountId);
 		if (target === void 0) throw new LlmError(this.hooks.emptyMessage ?? `未登录 ${this.hooks.displayName} 账号，请先在设置页添加账号。`, "AUTH");
 		if (!this.isCredentialUsable(target)) throw new LlmError(`${this.hooks.displayName} 账号的凭据已被拒绝，需要重新登录。`, "AUTH", { status: 401 });
-		if (!force && (!this.shouldRefreshCredential(target, Date.now()) || !this.hooks.refresh)) return target.credentials;
-		if (!this.hooks.refresh) return target.credentials;
+		if (expected !== void 0 && !isDeepStrictEqual(expected, target.credentials)) return target.credentials;
+		return (await this.freshAccount(target, fetchFn, force)).credentials;
+	}
+	/**
+	* Return one account's current row, refreshing it at most once per generation.
+	*
+	* Shared by every entry point — routing, auxiliary tools, the settings card
+	* and forced renewals — across all instances of the pool file, because a
+	* rotating refresh token may be spent once: two parallel exchanges both fail,
+	* and the losing one gets recorded as a dead sign-in.
+	*
+	* Reading the current generation and registering/joining its flight happen in
+	* one short transaction, so a commit cannot slip between the two decisions.
+	* The network call is fired AFTER the lock is released, and the plan returned
+	* from the lock is a plain value: awaiting a flight while holding the lock
+	* would deadlock that flight's own commit.
+	*/
+	async freshAccount(target, fetchFn, force = false) {
+		let launch;
+		const plan = await this.serialize(async () => {
+			const current = (await this.loadPoolData()).accounts.find((account) => account.id === target.id);
+			if (current === void 0 || !this.isCredentialUsable(current)) throw new PoolAccountUnavailableError(this.hooks.emptyMessage ?? "未登录 " + this.hooks.displayName + " 账号，请先在设置页添加账号。", "AUTH");
+			if (!isDeepStrictEqual(current.credentials, target.credentials)) return { account: current };
+			if (!this.hooks.refresh || !force && !this.shouldRefreshCredential(current, Date.now())) return { account: current };
+			const key = JSON.stringify([this.operationKey, current.id]);
+			const pending = poolRefreshes.get(key);
+			if (pending !== void 0 && isDeepStrictEqual(pending.credentials, current.credentials)) return { result: pending.result };
+			const result = new Promise((resolve, reject) => {
+				launch = () => {
+					this.refreshAccount(current, fetchFn).then(resolve, reject);
+				};
+			});
+			const flight = {
+				credentials: structuredClone(current.credentials),
+				result
+			};
+			poolRefreshes.set(key, flight);
+			const release = () => {
+				if (poolRefreshes.get(key) === flight) poolRefreshes.delete(key);
+			};
+			result.then(release, release);
+			return { result };
+		});
+		launch?.();
+		return plan.result ?? plan.account;
+	}
+	/**
+	* Refresh one account: network outside the lock, then a conditional commit.
+	*
+	* Every write-back is checked against the credential the refresh started from,
+	* which is what keeps a late response from restoring a spent token over a
+	* re-login, and keeps a deleted account from coming back.
+	*/
+	async refreshAccount(target, fetchFn) {
+		const expected = structuredClone(target.credentials);
 		const live = await this.hooks.liveCredentialsFor?.(target).catch(() => null);
 		if (live !== null && live !== void 0 && live.advanced) {
-			target.credentials = live.credentials;
-			await this.write(data).catch(() => void 0);
-			return live.credentials;
+			const account = await this.updateAccountCredentials(target.id, live.credentials, expected).catch(() => ({
+				...target,
+				credentials: live.credentials
+			}));
+			this.assertUsableAccount(account);
+			return account;
 		}
 		let refreshed;
 		try {
 			refreshed = await this.hooks.refresh(target.credentials, fetchFn);
 		} catch (error) {
 			const status = this.hooks.refreshFailureStatus?.(error);
-			if (status !== void 0) await this.markAuthFailed(target.id, error instanceof Error ? error.message : String(error), status).catch(() => void 0);
+			let superseded;
+			await this.updatePool((data) => {
+				const current = data.accounts.find((account) => account.id === target.id);
+				if (current === void 0) return;
+				if (!isDeepStrictEqual(current.credentials, expected)) {
+					superseded = current;
+					return;
+				}
+				if (status !== void 0) {
+					current.authStatus = status;
+					current.authFailedReason = error instanceof Error ? error.message : String(error);
+				}
+			}).catch(() => void 0);
+			if (superseded !== void 0) {
+				this.assertUsableAccount(superseded);
+				return superseded;
+			}
 			throw error;
 		}
-		await this.updateAccountCredentials(target.id, refreshed);
-		return refreshed;
+		const account = await this.updateAccountCredentials(target.id, refreshed, expected);
+		this.assertUsableAccount(account);
+		return account;
+	}
+	assertUsableAccount(account) {
+		if (account === void 0) throw new PoolAccountUnavailableError(this.hooks.emptyMessage ?? "未登录 " + this.hooks.displayName + " 账号，请先在设置页添加账号。", "AUTH");
+		if (!this.isCredentialUsable(account)) throw new PoolAccountUnavailableError(this.hooks.displayName + " 账号的凭据已被拒绝，需要重新登录。", "AUTH", { status: 401 });
 	}
 	/** Whether one account's credential must be refreshed before it is handed out. */
 	shouldRefreshCredential(account, now) {
@@ -1321,37 +1857,34 @@ var AccountPoolCore = class {
 	* @param fetchFn - fetch used by the provider's token refresh.
 	* @throws LlmError with `RATE_LIMIT` when every account is cooling down.
 	*/
-	async getEffectiveAccount(excludeIds, fetchFn = fetch) {
+	async getEffectiveAccount(excludeIds, fetchFn = fetch, forceRefresh = false) {
 		const data = await this.read();
 		if (data.accounts.length === 0) throw new Error(this.hooks.emptyMessage ?? `未登录 ${this.hooks.displayName} 账号，请先在设置页添加账号。`);
 		const now = Date.now();
 		const eligible = data.accounts.filter((account) => this.isEligible(account, now, excludeIds));
 		if (eligible.length === 0) throw this.allUnavailableError(data, now);
 		const selected = this.selectAccount(eligible, data);
-		if (this.shouldRefreshCredential(selected, now) && this.hooks.refresh) {
-			let refreshed;
-			try {
-				refreshed = await this.hooks.refresh(selected.credentials, fetchFn);
-			} catch (error) {
-				const status = this.hooks.refreshFailureStatus?.(error);
-				if (status === void 0) throw error;
-				await this.markAuthFailed(selected.id, error instanceof Error ? error.message : String(error), status);
-				const nextExclude = new Set(excludeIds ?? []);
-				nextExclude.add(selected.id);
-				if (await this.hasAnotherAvailableAccount(nextExclude)) return this.getEffectiveAccount(nextExclude, fetchFn);
-				throw error;
-			}
-			selected.credentials = refreshed;
-			const index = data.accounts.findIndex((account) => account.id === selected.id);
-			if (index >= 0) data.accounts[index] = selected;
-			if (selected.isPrimary) this.hooks.mirrorPrimary?.(refreshed).catch(() => void 0);
-		}
-		selected.lastUsedAt = now;
-		data.activeAccountId = selected.id;
-		await this.write(data).catch(() => void 0);
+		let refreshed;
+		try {
+			refreshed = await this.freshAccount(selected, fetchFn, forceRefresh);
+		} catch (error) {
+			if (this.hooks.refreshFailureStatus?.(error) === void 0 && !(error instanceof PoolAccountUnavailableError)) throw error;
+			const nextExclude = new Set(excludeIds ?? []);
+			nextExclude.add(selected.id);
+			if (await this.hasAnotherAvailableAccount(nextExclude)) return this.getEffectiveAccount(nextExclude, fetchFn, forceRefresh);
+			throw error;
+		}
+		const account = await this.updatePool((current) => {
+			const latest = current.accounts.find((entry) => entry.id === refreshed.id);
+			if (latest === void 0 || !isDeepStrictEqual(latest.credentials, refreshed.credentials)) return latest;
+			latest.lastUsedAt = now;
+			if (current.activeAccountId === data.activeAccountId) current.activeAccountId = latest.id;
+			return latest;
+		}).catch(() => refreshed);
+		this.assertUsableAccount(account);
 		return {
-			account: selected,
-			credentials: selected.credentials
+			account,
+			credentials: account.credentials
 		};
 	}
 };
@@ -1724,8 +2257,7 @@ var OAuthService = class {
 	async refresh() {
 		this.assertAvailable();
 		if (this.pool !== null) {
-			const { account, credentials } = await this.pool.getEffectiveAccount(void 0, this.fetchFn);
-			await this.refreshAccount(credentials).then((refreshed) => this.pool.updateAccountCredentials(account.id, refreshed));
+			await this.pool.getEffectiveAccount(void 0, this.fetchFn, true);
 			return this.status();
 		}
 		const stored = await this.loadAuthenticated();
@@ -1787,18 +2319,8 @@ var OAuthService = class {
 	*/
 	async credentials(forceRefresh = false, access = {}) {
 		if (this.pool !== null) {
-			if (access.purpose === "tool") {
-				const { account, credentials } = await this.pool.getCredentialAccount(this.fetchFn);
-				if (!forceRefresh) return credentials;
-				const refreshed = await this.refreshAccount(credentials, this.fetchFn);
-				await this.pool.updateAccountCredentials(account.id, refreshed);
-				return refreshed;
-			}
-			const { account, credentials } = await this.pool.getEffectiveAccount(void 0, this.fetchFn);
-			if (!forceRefresh) return credentials;
-			const refreshed = await this.refreshAccount(credentials, this.fetchFn);
-			await this.pool.updateAccountCredentials(account.id, refreshed);
-			return refreshed;
+			if (access.purpose === "tool") return (await this.pool.getCredentialAccount(this.fetchFn, forceRefresh)).credentials;
+			return (await this.pool.getEffectiveAccount(void 0, this.fetchFn, forceRefresh)).credentials;
 		}
 		const stored = await this.loadAuthenticated();
 		if (forceRefresh || stored.expiresAt - this.now() <= 6e4) return this.refreshCredentials(stored);
@@ -2251,11 +2773,8 @@ var CodexAccountPool = class extends AccountPoolCore {
 	async refreshAccountNow(accountId) {
 		const account = (await this.read()).accounts.find((entry) => entry.id === accountId);
 		if (account === void 0) throw new Error("ChatGPT 账号已不在号池中");
-		const refresher = this.refresherRef.current;
-		if (refresher === void 0) throw new Error("ChatGPT 凭据刷新服务尚未就绪");
-		const refreshed = await refresher.refreshAccount(account.credentials);
-		await this.updateAccountCredentials(accountId, refreshed);
-		return refreshed;
+		if (this.refresherRef.current === void 0) throw new Error("ChatGPT 凭据刷新服务尚未就绪");
+		return this.renewCredential(accountId, fetch, account.credentials);
 	}
 	/** The single-credential store this pool mirrors its primary account into. */
 	mirrorStore() {
@@ -2627,31 +3146,6 @@ function normalizeGenerateOptions(options) {
 	};
 }
 //#endregion
-//#region src/host/wire-auth.ts
-function codexHeaders(credentials, sessionId) {
-	const dshAgent = attributionHeaders()["user-agent"] ?? "dsh/unknown";
-	return {
-		authorization: `Bearer ${credentials.accessToken}`,
-		...credentials.accountId ? { "chatgpt-account-id": credentials.accountId } : {},
-		originator: CODEX_ORIGINATOR,
-		"user-agent": `dsh-chatgpt-subscription/${PLUGIN_VERSION} (${dshAgent})`,
-		...sessionId ? { "session-id": sessionId } : {}
-	};
-}
-function stableSessionId(value) {
-	const source = value === void 0 || value === "" ? randomUUID() : value;
-	return `dsh-${createHash("sha256").update(source).digest("hex").slice(0, 32)}`;
-}
-function retryAfterMs$1(headers) {
-	const raw = headers.get("retry-after");
-	if (raw === null) return void 0;
-	const seconds = Number(raw);
-	if (Number.isFinite(seconds) && seconds >= 0) return Math.min(seconds * 1e3, 10 * 6e4);
-	const timestamp = Date.parse(raw);
-	if (!Number.isFinite(timestamp)) return void 0;
-	return Math.min(Math.max(0, timestamp - Date.now()), 10 * 6e4);
-}
-//#endregion
 //#region src/host/codex-images.ts
 const PNG_SIGNATURE = [
 	137,
@@ -2805,7 +3299,6 @@ function requestImage(fetchFn, credentials, prompt, turnId, signal) {
 		method: "POST",
 		headers: {
 			...codexHeaders(credentials),
-			originator: "pi",
 			accept: "application/json",
 			"content-type": "application/json",
 			"x-codex-image-turn-id": turnId
@@ -2905,7 +3398,6 @@ function sendSearch(fetchFn, credentials, query, model, id, signal) {
 		method: "POST",
 		headers: {
 			...codexHeaders(credentials),
-			originator: "pi",
 			accept: "application/json",
 			"content-type": "application/json"
 		},
@@ -3058,8 +3550,8 @@ function parseEnvProxy(env = process.env, options = {}) {
 	try {
 		const dshHome = env.DSH_HOME || path.join(os.homedir(), ".dsh");
 		const envFile = options.envFile ?? path.join(dshHome, ".env");
-		if (fs.existsSync(envFile)) {
-			const match = fs.readFileSync(envFile, "utf8").match(/^(?:export\s+)?(?:HTTPS_PROXY|https_proxy|HTTP_PROXY|http_proxy|ALL_PROXY|all_proxy)\s*=\s*["']?([^"'\r\n]+)["']?/m);
+		if (fs$1.existsSync(envFile)) {
+			const match = fs$1.readFileSync(envFile, "utf8").match(/^(?:export\s+)?(?:HTTPS_PROXY|https_proxy|HTTP_PROXY|http_proxy|ALL_PROXY|all_proxy)\s*=\s*["']?([^"'\r\n]+)["']?/m);
 			if (match && match[1]?.trim()) return normalizeProxyUrl(match[1].trim());
 		}
 	} catch {}
@@ -3680,7 +4172,7 @@ var FileCredentialStore$2 = class {
 	}
 	async removeLegacy() {
 		try {
-			await fsPromises.unlink(this.filePath);
+			await fs.unlink(this.filePath);
 		} catch (error) {
 			if (error.code !== "ENOENT") throw new Error("Antigravity legacy credential removal failed");
 		}
@@ -3699,11 +4191,11 @@ var FileCredentialStore$2 = class {
 			}
 			let legacy;
 			try {
-				const stats = await fsPromises.lstat(this.filePath);
+				const stats = await fs.lstat(this.filePath);
 				if (!stats.isFile() || stats.isSymbolicLink()) throw new Error("Invalid credential file");
 				if (process.getuid && stats.uid !== process.getuid()) throw new Error("Invalid credential owner");
-				if (process.platform !== "win32") await fsPromises.chmod(this.filePath, 384);
-				legacy = await fsPromises.readFile(this.filePath, "utf8");
+				if (process.platform !== "win32") await fs.chmod(this.filePath, 384);
+				legacy = await fs.readFile(this.filePath, "utf8");
 			} catch (error) {
 				if (error.code === "ENOENT") return null;
 				throw new Error("Antigravity legacy credential read failed");
@@ -3738,7 +4230,7 @@ var FileModelSettingsStore$2 = class {
 	}
 	async read() {
 		try {
-			const content = await fsPromises.readFile(this.filePath, "utf8");
+			const content = await fs.readFile(this.filePath, "utf8");
 			const parsed = JSON.parse(content);
 			if (typeof parsed === "object" && parsed !== null) {
 				const record = parsed;
@@ -3764,10 +4256,10 @@ var FileModelSettingsStore$2 = class {
 		};
 	}
 	async write(settings) {
-		await fsPromises.mkdir(path.dirname(this.filePath), { recursive: true });
+		await fs.mkdir(path.dirname(this.filePath), { recursive: true });
 		const tmp = `${this.filePath}.tmp.${Date.now()}`;
-		await fsPromises.writeFile(tmp, JSON.stringify(settings, null, 2), "utf8");
-		await fsPromises.rename(tmp, this.filePath);
+		await fs.writeFile(tmp, JSON.stringify(settings, null, 2), "utf8");
+		await fs.rename(tmp, this.filePath);
 	}
 	async updateSettings(patch) {
 		const current = await this.read();
@@ -3893,7 +4385,7 @@ var FilePreferencesStore = class {
 	async readDocument() {
 		let parsed;
 		try {
-			parsed = JSON.parse(await fsPromises.readFile(this.filePath, "utf8"));
+			parsed = JSON.parse(await fs.readFile(this.filePath, "utf8"));
 		} catch {
 			return;
 		}
@@ -3914,17 +4406,17 @@ var FilePreferencesStore = class {
 		for (const listener of [...this.listeners]) listener(next, prev);
 	}
 	async write(value) {
-		await fsPromises.mkdir(path.dirname(this.filePath), { recursive: true });
+		await fs.mkdir(path.dirname(this.filePath), { recursive: true });
 		writeSequence += 1;
 		const tmp = `${this.filePath}.tmp.${process.pid}.${writeSequence}`;
 		try {
-			await fsPromises.writeFile(tmp, JSON.stringify(value, null, 2), {
+			await fs.writeFile(tmp, JSON.stringify(value, null, 2), {
 				encoding: "utf8",
 				mode: 384
 			});
-			await fsPromises.rename(tmp, this.filePath);
+			await fs.rename(tmp, this.filePath);
 		} finally {
-			await fsPromises.unlink(tmp).catch(() => void 0);
+			await fs.unlink(tmp).catch(() => void 0);
 		}
 	}
 };
@@ -3989,7 +4481,7 @@ const LEGACY_DOCUMENTS = ["settings.yaml", "settings.yaml.imported"];
 */
 async function readLegacyPreferences(homeDir = dshHomeDir$2()) {
 	for (const name of LEGACY_DOCUMENTS) {
-		const document = await fsPromises.readFile(path.join(homeDir, name), "utf8").catch(() => void 0);
+		const document = await fs.readFile(path.join(homeDir, name), "utf8").catch(() => void 0);
 		if (document === void 0) continue;
 		const section = sectionOf(document, PREFERENCES_NAMESPACE);
 		if (section !== void 0 && Object.keys(section).length > 0) return section;
@@ -4297,7 +4789,7 @@ function normalizeReplayCallIds(items, normalizeCallId) {
 		call_id: normalizeCallId(item.call_id)
 	} : item);
 }
-async function buildResponsesPayload(options, attachments, localRawImages = {}, outputVerbosity = null, fastMode = false, reasoningSummary = null) {
+async function buildResponsesPayload(options, attachments, localRawImages = {}, outputVerbosity = null, fastMode = false, reasoningSummary = null, promptCacheKey) {
 	const sandboxRetryTools = recentSandboxRetryToolNames(options.messages);
 	const resolveLocalRawImages = supportsImageInput(options);
 	const normalizeCallId = createCallIdNormalizer();
@@ -4365,7 +4857,8 @@ async function buildResponsesPayload(options, attachments, localRawImages = {},
 		input,
 		stream: true,
 		store: false,
-		include: ["reasoning.encrypted_content"]
+		include: ["reasoning.encrypted_content"],
+		...promptCacheKey ? { prompt_cache_key: promptCacheKey } : {}
 	};
 	const instructions = [...instructionParts, localRawImageInstruction(localImageStats)].filter((value) => Boolean(value));
 	if (instructions.length > 0) payload.instructions = instructions.join("\n\n");
@@ -4381,6 +4874,8 @@ async function buildResponsesPayload(options, attachments, localRawImages = {},
 	}
 	if (outputVerbosity !== null) payload.text = { verbosity: outputVerbosity };
 	if (fastMode) payload.service_tier = "priority";
+	const modelMaxTokens = codexModelMaxTokens(options.model);
+	payload.max_output_tokens = options.maxTokens === void 0 ? modelMaxTokens : Math.min(options.maxTokens, modelMaxTokens);
 	if (options.reasoningEffort !== void 0) {
 		const effort = codexWireReasoningEffort(options.model, options.reasoningEffort);
 		payload.reasoning = codexModelSupportsReasoningSummary(options.model) ? {
@@ -4698,6 +5193,8 @@ const MAX_VISIBLE_REASONING_CHARS = 12e3;
 const DEFAULT_POOL_COOLDOWN_MS = 15 * 6e4;
 const REASONING_DELTA_FLUSH_CHARS = 768;
 const REASONING_TRUNCATED_NOTICE = "\n\n[Reasoning summary truncated to keep the DSH web UI responsive.]";
+/** Cap on conversations whose turn state is remembered at once. */
+const MAX_TRACKED_TURN_STATES = 200;
 var ResponsesClient = class {
 	oauth;
 	attachments;
@@ -4707,6 +5204,16 @@ var ResponsesClient = class {
 	fastMode;
 	reasoningSummary;
 	accountPool;
+	/**
+	* Opaque backend turn state, keyed by conversation session id.
+	*
+	* The Codex backend hands `x-codex-turn-state` back on each response and
+	* expects it on the next request of the same conversation, which lets it
+	* resume the turn instead of re-ingesting the whole history. The value is
+	* short-lived and account-scoped, so it is stored per session and simply
+	* dropped when the backend stops sending it — never a correctness input.
+	*/
+	turnStates = /* @__PURE__ */ new Map();
 	constructor(oauth, attachments, options = {}) {
 		this.oauth = oauth;
 		this.attachments = attachments;
@@ -4727,7 +5234,7 @@ var ResponsesClient = class {
 		let attemptOptions = options;
 		let response;
 		while (true) {
-			const payload = await buildResponsesPayload(attemptOptions, this.attachments, this.localRawImages, this.outputVerbosity(), this.fastMode(), this.reasoningSummary());
+			const payload = await buildResponsesPayload(attemptOptions, this.attachments, this.localRawImages, this.outputVerbosity(), this.fastMode(), this.reasoningSummary(), promptCacheKeyFor(sessionId));
 			try {
 				response = await this.send(payload, sessionId, options.signal);
 				break;
@@ -4762,9 +5269,36 @@ var ResponsesClient = class {
 			response = await this.request(payload, credentials, sessionId, signal);
 		}
 		if (!response.ok) throw await responseError(response);
+		this.rememberTurnState(response, sessionId);
 		return response;
 	}
 	/**
+	* Record the turn state a response carried, for the next turn of this session.
+	*
+	* A response that carries none clears any stored value: a backend that stops
+	* sending the header has stopped honouring it, and replaying a stale value
+	* would be guessing. An empty header is treated the same as absent.
+	*/
+	rememberTurnState(response, sessionId) {
+		const next = response.headers.get(CODEX_TURN_STATE_HEADER)?.trim();
+		if (next === void 0 || next === "") this.turnStates.delete(sessionId);
+		else this.storeTurnState(sessionId, next);
+	}
+	/**
+	* Bounded store: a long-lived host serves many sessions, and nothing here ever
+	* signals that a session ended, so the map is capped and evicts the oldest
+	* entry. The value is an optimization, so a miss only costs a full resend.
+	*/
+	storeTurnState(sessionId, value) {
+		this.turnStates.delete(sessionId);
+		this.turnStates.set(sessionId, value);
+		while (this.turnStates.size > MAX_TRACKED_TURN_STATES) {
+			const oldest = this.turnStates.keys().next();
+			if (oldest.done === true) break;
+			this.turnStates.delete(oldest.value);
+		}
+	}
+	/**
 	* Send one payload with account rotation.
 	*
 	* The pool picks the account — skipping cooling, quota-exhausted and failed
@@ -4806,6 +5340,7 @@ var ResponsesClient = class {
 				});
 			}
 			if (!response.ok) throw await responseError(response);
+			this.rememberTurnState(response, sessionId);
 			return response;
 		}
 	}
@@ -4814,7 +5349,7 @@ var ResponsesClient = class {
 			return await this.fetchFn(CODEX_RESPONSES_URL, {
 				method: "POST",
 				headers: {
-					...codexHeaders(credentials, sessionId),
+					...codexHeaders(credentials, sessionId, { turnState: this.turnStates.get(sessionId) }),
 					"content-type": "application/json",
 					accept: "text/event-stream"
 				},
@@ -4827,6 +5362,17 @@ var ResponsesClient = class {
 		}
 	}
 };
+/**
+* Prompt cache key for one conversation.
+*
+* The backend keys its prefix cache on this string, so it must be stable for a
+* conversation and distinct between conversations — otherwise one session would
+* be served another session's cached prefix. The session id is already a hashed
+* opaque string, so it is reused directly rather than hashed again.
+*/
+function promptCacheKeyFor(sessionId) {
+	return sessionId;
+}
 async function* parseResponsesStream(response, signal, hiddenSandboxControls = /* @__PURE__ */ new Set()) {
 	if (response.body === null) throw new LlmError("Codex returned no response stream.", "PROVIDER_ERROR");
 	const reader = response.body.getReader();
@@ -5818,7 +6364,7 @@ function registerRoutes(ctx, oauth, usage, preferences, proxyManager, searchSwit
 					"Content-Type": "application/javascript; charset=utf-8",
 					"Cache-Control": "public, max-age=86400"
 				});
-				fs.createReadStream(mermaidPath).pipe(response);
+				fs$1.createReadStream(mermaidPath).pipe(response);
 			} catch {
 				response.writeHead(404, { "Content-Type": "text/plain" });
 				response.end("Not found");
@@ -9384,7 +9930,7 @@ var FileCredentialStore$1 = class {
 	}
 	async removeLegacy() {
 		try {
-			await fsPromises.unlink(this.filePath);
+			await fs.unlink(this.filePath);
 		} catch (error) {
 			if (error.code !== "ENOENT") throw new Error("Command Code legacy credential removal failed");
 		}
@@ -9403,11 +9949,11 @@ var FileCredentialStore$1 = class {
 			}
 			let legacy;
 			try {
-				const stats = await fsPromises.lstat(this.filePath);
+				const stats = await fs.lstat(this.filePath);
 				if (!stats.isFile() || stats.isSymbolicLink()) throw new Error("Invalid credential file");
 				if (process.getuid && stats.uid !== process.getuid()) throw new Error("Invalid credential owner");
-				if (process.platform !== "win32") await fsPromises.chmod(this.filePath, 384);
-				legacy = await fsPromises.readFile(this.filePath, "utf8");
+				if (process.platform !== "win32") await fs.chmod(this.filePath, 384);
+				legacy = await fs.readFile(this.filePath, "utf8");
 			} catch (error) {
 				if (error.code === "ENOENT") return null;
 				throw new Error("Command Code legacy credential read failed");
@@ -9443,7 +9989,7 @@ var FileModelSettingsStore$1 = class {
 	}
 	async read() {
 		try {
-			const content = await fsPromises.readFile(this.filePath, "utf8");
+			const content = await fs.readFile(this.filePath, "utf8");
 			const parsed = JSON.parse(content);
 			if (typeof parsed === "object" && parsed !== null) {
 				const record = parsed;
@@ -9469,10 +10015,10 @@ var FileModelSettingsStore$1 = class {
 		};
 	}
 	async write(settings) {
-		await fsPromises.mkdir(path.dirname(this.filePath), { recursive: true });
+		await fs.mkdir(path.dirname(this.filePath), { recursive: true });
 		const tmp = `${this.filePath}.tmp.${Date.now()}`;
-		await fsPromises.writeFile(tmp, JSON.stringify(settings, null, 2), "utf8");
-		await fsPromises.rename(tmp, this.filePath);
+		await fs.writeFile(tmp, JSON.stringify(settings, null, 2), "utf8");
+		await fs.rename(tmp, this.filePath);
 	}
 	async updateSettings(patch) {
 		const current = await this.read();
@@ -9571,121 +10117,6 @@ function commandCodePlanLabel(planId) {
 	return resolveCommandCodePlan(planId)?.name ?? planId;
 }
 //#endregion
-//#region src/host/common/catalog-snapshot.ts
-/**
-* Persistent snapshot for one provider's live model catalog.
-*
-* The in-memory catalog caches keep a process alive between requests, but they
-* start cold: on the first call after a restart (or a plugin reinstall) the
-* picker and the settings page both wait on the upstream listing before they
-* can render anything, and an unreachable endpoint turns that wait into the
-* full discovery timeout — "the model server is unavailable" on a fresh
-* install. The catalog is not fast-moving data, so the last successful listing
-* is persisted to `<DSH_HOME>/storages/` and rehydrated into the in-memory
-* cache on first use. A snapshot the caller can read is therefore available
-* from the very first call, with no network in the path.
-*
-* Writes are best-effort: persistence is an optimization, never a capability.
-* A read-only home or a locked file must not fail the fetch that produced the
-* snapshot.
-*/
-/** File name of the persisted snapshot for one catalog. */
-function catalogSnapshotPath(name) {
-	return path.join(dshHomeDir(), "storages", `${name}-catalog.json`);
-}
-/**
-* Snapshot name for one catalog *and* one credential scope.
-*
-* A persisted snapshot answers before any credential is read — that is the whole
-* point of it — so the file itself has to carry the scope it was fetched under.
-* Otherwise the first call after a restart, for any account, is answered by
-* whatever listing some other scope happened to persist last: a Kimi listing
-* fetched for the mainland-cn endpoint would answer a global caller with models
-* and context windows that region does not serve, and a Command Code listing
-* fetched against one API environment would answer the other.
-*
-* The scope is part of the file name rather than of the payload because a caller
-* that cannot name the account — the harness resolves this catalog with no token
-* at all — still has to find the snapshot its own scope owns.
-*
-* Everything outside `[a-z0-9]` is folded to `_`, so no scope can escape the
-* `storages` directory.
-*/
-function catalogSnapshotName(base, scope) {
-	const normalized = scope.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
-	return normalized === "" ? base : `${base}-${normalized}`;
-}
-/**
-* Read the persisted snapshot for one catalog.
-*
-* Shape errors and unreadable files both return `undefined` — the caller keeps
-* its in-memory state, and the next successful fetch overwrites the file.
-*/
-async function readCatalogSnapshot(name, parseModels) {
-	try {
-		const content = await fsPromises.readFile(catalogSnapshotPath(name), "utf8");
-		const parsed = JSON.parse(content);
-		if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return void 0;
-		const record = parsed;
-		const fetchedAt = record.fetchedAt;
-		if (typeof fetchedAt !== "number" || !Number.isFinite(fetchedAt) || fetchedAt <= 0) return void 0;
-		const models = parseModels(record.models);
-		if (models === void 0 || models.length === 0) return void 0;
-		return {
-			fetchedAt,
-			models
-		};
-	} catch {
-		return;
-	}
-}
-/**
-* Snapshot writes still in flight.
-*
-* Callers fire-and-forget these writes, so nothing in production ever awaits
-* one. A test that deletes its private `storages` directory between cases
-* cannot know when that is safe, and a write that lands after the delete
-* recreates the file the next case asserts is absent — which is how a stale
-* listing leaked into a later test and failed it on CI. Registering each write
-* gives {@link flushCatalogSnapshots} a deterministic point to wait on.
-*/
-const pendingSnapshotWrites = /* @__PURE__ */ new Set();
-/** Persist one snapshot; a failure is logged nowhere and never thrown. */
-function writeCatalogSnapshot(name, models, fetchedAt) {
-	const write = (async () => {
-		try {
-			const filePath = catalogSnapshotPath(name);
-			await fsPromises.mkdir(path.dirname(filePath), { recursive: true });
-			const tmp = `${filePath}.tmp.${Date.now()}`;
-			await fsPromises.writeFile(tmp, JSON.stringify({
-				fetchedAt,
-				models
-			}, null, 2), "utf8");
-			await fsPromises.rename(tmp, filePath);
-		} catch {}
-	})();
-	pendingSnapshotWrites.add(write);
-	write.finally(() => {
-		pendingSnapshotWrites.delete(write);
-	});
-	return write;
-}
-/**
-* Warm an in-memory cache from the persisted snapshot when it is fresher than
-* what the cache currently holds. Called lazily on the first cache miss of a
-* process, so a restart serves the previous listing without waiting on the
-* network.
-*
-* @returns the snapshot's `fetchedAt`, or `0` when no usable snapshot exists —
-*   the caller then fetches as before.
-*/
-async function rehydrateCatalogCache(name, parseModels, accept, currentFetchedAt) {
-	const snapshot = await readCatalogSnapshot(name, parseModels);
-	if (snapshot === void 0 || snapshot.fetchedAt <= currentFetchedAt) return 0;
-	accept(snapshot.fetchedAt, snapshot.models);
-	return snapshot.fetchedAt;
-}
-//#endregion
 //#region src/host/command-code/client.ts
 const CLI_VERSION = "1.0.0";
 /**
@@ -12955,6 +13386,10 @@ function maxOutputTokensFor$3(modelId, contextWindow) {
 	const capped = (contextWindow ?? kimiCodeModelDef(modelId)?.contextWindow ?? 262144) - CONTEXT_HEADROOM_TOKENS$1;
 	return Math.max(declared, capped);
 }
+/** Whether a stored preference names a tier this line can send. */
+function isKimiCacheTtl(value) {
+	return value === "5m" || value === "1h";
+}
 /**
 * Reduce the requested output cap so prompt + output fit the window.
 *
@@ -13004,7 +13439,8 @@ function registerKimiCodePreferenceStore(settings, fallbackStore = new FileModel
 			enabledModelIds: [...DEFAULT_ENABLED_MODEL_IDS$3],
 			catalogModels: [],
 			contextWindowOverrides: {},
-			defaultReasoningEffort: null
+			defaultReasoningEffort: null,
+			cacheTtl: null
 		};
 		fallbackStore.read().then((stored) => {
 			snapshot = stored;
@@ -13021,7 +13457,12 @@ function registerKimiCodePreferenceStore(settings, fallbackStore = new FileModel
 		enabled: z.boolean().default(true),
 		enabledModelIds: z.array(z.string()).default([...DEFAULT_ENABLED_MODEL_IDS$3]),
 		contextWindowOverrides: z.dict(z.number()).default({}),
-		defaultReasoningEffort: z.union([...KIMI_CODE_REASONING_EFFORTS.map((effort) => z.const(effort)), z.const(null)]).default(null)
+		defaultReasoningEffort: z.union([...KIMI_CODE_REASONING_EFFORTS.map((effort) => z.const(effort)), z.const(null)]).default(null),
+		cacheTtl: z.union([
+			z.const("5m"),
+			z.const("1h"),
+			z.const(null)
+		]).default(null)
 	}));
 	return {
 		status: () => {
@@ -13031,7 +13472,8 @@ function registerKimiCodePreferenceStore(settings, fallbackStore = new FileModel
 				enabledModelIds: value.enabledModelIds,
 				catalogModels: [],
 				contextWindowOverrides: value.contextWindowOverrides,
-				defaultReasoningEffort: value.defaultReasoningEffort
+				defaultReasoningEffort: value.defaultReasoningEffort,
+				cacheTtl: isKimiCacheTtl(value.cacheTtl) ? value.cacheTtl : null
 			};
 		},
 		update: async (patch) => {
@@ -13040,7 +13482,8 @@ function registerKimiCodePreferenceStore(settings, fallbackStore = new FileModel
 				enabled: patch.enabled !== void 0 ? patch.enabled : current.enabled !== false,
 				enabledModelIds: patch.enabledModelIds ?? current.enabledModelIds,
 				contextWindowOverrides: patch.contextWindowOverrides ? mergeContextWindowOverrides(current.contextWindowOverrides, patch.contextWindowOverrides) : current.contextWindowOverrides,
-				defaultReasoningEffort: patch.defaultReasoningEffort !== void 0 ? patch.defaultReasoningEffort : current.defaultReasoningEffort
+				defaultReasoningEffort: patch.defaultReasoningEffort !== void 0 ? patch.defaultReasoningEffort : current.defaultReasoningEffort,
+				cacheTtl: patch.cacheTtl !== void 0 ? patch.cacheTtl : current.cacheTtl
 			};
 			await scope.update(normalized);
 			fallbackStore.updateSettings(patch).catch(() => void 0);
@@ -13162,7 +13605,7 @@ var FileCredentialStore$3 = class {
 	}
 	async removeLegacy() {
 		try {
-			await fsPromises.unlink(this.filePath);
+			await fs.unlink(this.filePath);
 		} catch (error) {
 			if (error.code !== "ENOENT") throw new Error("Kimi Code legacy credential removal failed");
 		}
@@ -13181,11 +13624,11 @@ var FileCredentialStore$3 = class {
 			}
 			let legacy;
 			try {
-				const stats = await fsPromises.lstat(this.filePath);
+				const stats = await fs.lstat(this.filePath);
 				if (!stats.isFile() || stats.isSymbolicLink()) throw new Error("Invalid credential file");
 				if (process.getuid && stats.uid !== process.getuid()) throw new Error("Invalid credential owner");
-				if (process.platform !== "win32") await fsPromises.chmod(this.filePath, 384);
-				legacy = await fsPromises.readFile(this.filePath, "utf8");
+				if (process.platform !== "win32") await fs.chmod(this.filePath, 384);
+				legacy = await fs.readFile(this.filePath, "utf8");
 			} catch (error) {
 				if (error.code === "ENOENT") return null;
 				throw new Error("Kimi Code legacy credential read failed");
@@ -13221,7 +13664,7 @@ var FileModelSettingsStore$3 = class {
 	}
 	async read() {
 		try {
-			const content = await fsPromises.readFile(this.filePath, "utf8");
+			const content = await fs.readFile(this.filePath, "utf8");
 			const parsed = JSON.parse(content);
 			if (typeof parsed === "object" && parsed !== null) {
 				const record = parsed;
@@ -13234,7 +13677,8 @@ var FileModelSettingsStore$3 = class {
 					enabledModelIds,
 					catalogModels,
 					contextWindowOverrides,
-					defaultReasoningEffort
+					defaultReasoningEffort,
+					cacheTtl: isKimiCacheTtl(record.cacheTtl) ? record.cacheTtl : null
 				};
 			}
 		} catch {}
@@ -13243,14 +13687,15 @@ var FileModelSettingsStore$3 = class {
 			enabledModelIds: [...DEFAULT_ENABLED_MODEL_IDS$3],
 			catalogModels: [],
 			contextWindowOverrides: {},
-			defaultReasoningEffort: null
+			defaultReasoningEffort: null,
+			cacheTtl: null
 		};
 	}
 	async write(settings) {
-		await fsPromises.mkdir(path.dirname(this.filePath), { recursive: true });
+		await fs.mkdir(path.dirname(this.filePath), { recursive: true });
 		const tmp = `${this.filePath}.tmp.${Date.now()}`;
-		await fsPromises.writeFile(tmp, JSON.stringify(settings, null, 2), "utf8");
-		await fsPromises.rename(tmp, this.filePath);
+		await fs.writeFile(tmp, JSON.stringify(settings, null, 2), "utf8");
+		await fs.rename(tmp, this.filePath);
 	}
 	async updateSettings(patch) {
 		const current = await this.read();
@@ -13259,7 +13704,8 @@ var FileModelSettingsStore$3 = class {
 			...patch.enabled !== void 0 ? { enabled: patch.enabled } : {},
 			...patch.enabledModelIds !== void 0 ? { enabledModelIds: patch.enabledModelIds } : {},
 			...patch.contextWindowOverrides !== void 0 ? { contextWindowOverrides: mergeContextWindowOverrides(current.contextWindowOverrides, patch.contextWindowOverrides) } : {},
-			...patch.defaultReasoningEffort !== void 0 ? { defaultReasoningEffort: patch.defaultReasoningEffort } : {}
+			...patch.defaultReasoningEffort !== void 0 ? { defaultReasoningEffort: patch.defaultReasoningEffort } : {},
+			...patch.cacheTtl !== void 0 && patch.cacheTtl !== null ? { cacheTtl: isKimiCacheTtl(patch.cacheTtl) ? patch.cacheTtl : current.cacheTtl } : patch.cacheTtl === null ? { cacheTtl: null } : {}
 		};
 		await this.write(next);
 		return next;
@@ -13289,7 +13735,7 @@ async function resolveRegion(env = process.env) {
 		return pinned.includes(".ai") ? "global" : "mainland-cn";
 	}
 	try {
-		const marker = (await fsPromises.readFile(regionMarkerPath(), "utf8")).trim();
+		const marker = (await fs.readFile(regionMarkerPath(), "utf8")).trim();
 		if (isRegion$4(marker)) return marker;
 	} catch {}
 	return "mainland-cn";
@@ -13298,8 +13744,8 @@ async function resolveRegion(env = process.env) {
 async function persistRegion(region) {
 	try {
 		const file = regionMarkerPath();
-		await fsPromises.mkdir(path.dirname(file), { recursive: true });
-		await fsPromises.writeFile(file, region, "utf8");
+		await fs.mkdir(path.dirname(file), { recursive: true });
+		await fs.writeFile(file, region, "utf8");
 	} catch {}
 }
 //#endregion
@@ -13401,13 +13847,13 @@ function deviceModel() {
 async function getDeviceId() {
 	const file = deviceIdPath();
 	try {
-		const existing = (await fsPromises.readFile(file, "utf8")).trim();
+		const existing = (await fs.readFile(file, "utf8")).trim();
 		if (existing !== "") return existing;
 	} catch {}
 	const created = randomUUID();
 	try {
-		await fsPromises.mkdir(path.dirname(file), { recursive: true });
-		await fsPromises.writeFile(file, created, {
+		await fs.mkdir(path.dirname(file), { recursive: true });
+		await fs.writeFile(file, created, {
 			encoding: "utf8",
 			mode: 384
 		});
@@ -15223,6 +15669,39 @@ function imageBlockToInline$2(block, images) {
 		data: resolved.data
 	} : void 0;
 }
+/**
+* Media a single request build may carry.
+*
+* Passed as one object so adding a media kind never grows a positional
+* signature the existing callers already bind.
+*/
+/**
+* The cache field for the Anthropic-compatible wire.
+*
+* TOP LEVEL, not per block: the service documents that a `cache_control` inside
+* a message is ignored, and omitting the field means "read a 5m entry but do
+* not write one" — which is why this is only attached when the caller asked
+* for a tier.
+*/
+function kimiAnthropicCacheControl(ttl) {
+	return { cache_control: {
+		type: "ephemeral",
+		ttl
+	} };
+}
+/**
+* The cache field for the OpenAI-compatible wire.
+*
+* `mode: 'implicit'` is the only mode the service supports — it identifies the
+* prefix itself, so this is not a request to break the cache but a request to
+* write it at a chosen TTL.
+*/
+function kimiOpenAICacheOptions(ttl) {
+	return { prompt_cache_options: {
+		mode: "implicit",
+		ttl
+	} };
+}
 function textOf$3(content) {
 	if (typeof content === "string") return sanitizeText$3(content);
 	if (!Array.isArray(content)) return "";
@@ -15758,6 +16237,7 @@ function buildOpenAIRequest(options, images = NO_RESOLVED_IMAGES$3, preserveThin
 		stream: true,
 		stream_options: { include_usage: true },
 		max_completion_tokens: maxTokens,
+		...media.cacheTtl === null || media.cacheTtl === void 0 ? {} : kimiOpenAICacheOptions(media.cacheTtl),
 		...stopSequences(options.stop).length > 0 ? { stop: stopSequences(options.stop) } : {},
 		...options.tools && options.tools.length > 0 ? {
 			tools: options.tools.map((tool) => ({
@@ -15891,7 +16371,8 @@ function mergeAnthropicMessages$1(entries) {
 	return merged;
 }
 /** Build one `/v1/messages` body. */
-function buildAnthropicRequest(options, images = NO_RESOLVED_IMAGES$3, _media = {}) {
+function buildAnthropicRequest(options, images = NO_RESOLVED_IMAGES$3, media = {}) {
+	const cacheTtl = media.cacheTtl ?? null;
 	const carriers = options.messages.filter((message) => message.role === "system" && messageToolsOf(message) !== void 0);
 	const unsentDeclarations = carriers.reduce((total, message) => total + (messageToolsOf(message)?.length ?? 0), 0);
 	const carrierText = carriers.map((message) => textOf$3(message.content)).filter((text) => text !== "");
@@ -15922,6 +16403,7 @@ function buildAnthropicRequest(options, images = NO_RESOLVED_IMAGES$3, _media =
 		model: options.model,
 		max_tokens: maxTokens,
 		messages: mergeAnthropicMessages$1(entries),
+		...cacheTtl === null || cacheTtl === void 0 ? {} : kimiAnthropicCacheControl(cacheTtl),
 		...system === void 0 ? {} : { system },
 		...options.temperature === void 0 || budget !== void 0 ? {} : { temperature: options.temperature },
 		...options.stop && options.stop.length > 0 ? { stop_sequences: options.stop } : {},
@@ -16724,12 +17206,13 @@ var KimiCodeAdapter = class extends LlmAdapter {
 		const entry = catalog.find((model) => model.id === options.model);
 		const requestOptions = offloadOldestRequestVideos(offloadOldestRequestImages$2(normalizeGenerateOptions(options)));
 		const [images, videos] = await Promise.all([resolveRequestImages$2(requestOptions, this.options.attachments, signal), resolveRequestVideos(requestOptions, this.options.videos, signal)]);
+		const settings = await this.settings();
 		const media = {
 			videos,
 			videoAccepted: inputModalitiesForEntry(options.model, catalog).includes("video"),
-			messageTools: dynamicToolsForEntry(options.model, catalog)
+			messageTools: dynamicToolsForEntry(options.model, catalog),
+			cacheTtl: settings.cacheTtl
 		};
-		const settings = await this.settings();
 		const contextWindow = this.contextWindowFor(options.model, entry, settings.contextWindowOverrides);
 		const requestedMax = options.maxTokens ?? maxOutputTokensFor$3(options.model, contextWindow);
 		const body = assertRequestBodyFits$1(buildRequest({
@@ -17108,6 +17591,7 @@ async function getKimiCodeWebStatus(store, modelSettings, preferences, options =
 		models,
 		contextWindowOverrides: settings.contextWindowOverrides,
 		defaultReasoningEffort: settings.defaultReasoningEffort,
+		cacheTtl: settings.cacheTtl,
 		loginRegion: region,
 		serving: readOption$3(options.serving, true),
 		conflict: readOption$3(options.conflict, null)
@@ -17333,6 +17817,10 @@ function registerKimiCodeRoutes(ctx, store, modelSettings, preferences, options
 						const effort = body.defaultReasoningEffort;
 						if (effort === null || isKimiCodeEffort(effort)) patch.defaultReasoningEffort = effort;
 					}
+					if (body.cacheTtl !== void 0) {
+						const ttl = body.cacheTtl;
+						if (ttl === null || isKimiCacheTtl(ttl)) patch.cacheTtl = ttl;
+					}
 					if (preferences) await preferences.update(patch);
 					else await modelSettings.updateSettings(patch);
 					if (patch.enabledModelIds !== void 0 || patch.enabled !== void 0) ctx.emit?.("llm/adapters-updated");
@@ -17542,15 +18030,15 @@ async function saveVideo(input) {
 	const digest = createHash("sha256").update(input.data).digest("hex");
 	const attachmentId = `sha256:${digest}`;
 	const dir = videoStoreDir();
-	await fsPromises.mkdir(dir, {
+	await fs.mkdir(dir, {
 		recursive: true,
 		mode: 448
 	});
 	const target = path.join(dir, digest + extensionFor(input.declaredType));
-	if (!await fsPromises.stat(target).then(() => true).catch(() => false)) {
+	if (!await fs.stat(target).then(() => true).catch(() => false)) {
 		const tmp = `${target}.tmp.${process.pid}.${Date.now()}`;
-		await fsPromises.writeFile(tmp, input.data);
-		await fsPromises.rename(tmp, target);
+		await fs.writeFile(tmp, input.data);
+		await fs.rename(tmp, target);
 	}
 	pruneVideoStore().catch(() => void 0);
 	return {
@@ -17580,14 +18068,14 @@ async function pruneVideoStore(budgetBytes = VIDEO_STORE_BUDGET_BYTES) {
 	const dir = videoStoreDir();
 	let entries;
 	try {
-		const names = await fsPromises.readdir(dir);
+		const names = await fs.readdir(dir);
 		entries = [];
 		for (const name of names) {
 			if (name.includes(".tmp.")) {
-				await fsPromises.rm(path.join(dir, name), { force: true }).catch(() => void 0);
+				await fs.rm(path.join(dir, name), { force: true }).catch(() => void 0);
 				continue;
 			}
-			const stats = await fsPromises.stat(path.join(dir, name)).catch(() => void 0);
+			const stats = await fs.stat(path.join(dir, name)).catch(() => void 0);
 			if (stats === void 0 || !stats.isFile()) continue;
 			entries.push({
 				path: path.join(dir, name),
@@ -17604,7 +18092,7 @@ async function pruneVideoStore(budgetBytes = VIDEO_STORE_BUDGET_BYTES) {
 	let removed = 0;
 	for (const entry of entries) {
 		if (total <= budgetBytes) break;
-		await fsPromises.rm(entry.path, { force: true }).catch(() => void 0);
+		await fs.rm(entry.path, { force: true }).catch(() => void 0);
 		total -= entry.size;
 		removed += 1;
 	}
@@ -17628,7 +18116,7 @@ async function readVideoBytes(ref) {
 	if (stored === void 0) throw new VideoIngestError("video reference is not one this store issued", "VIDEO_REFERENCE_INVALID");
 	let data;
 	try {
-		data = await fsPromises.readFile(stored);
+		data = await fs.readFile(stored);
 	} catch {
 		throw new VideoIngestError("stored video is missing; attach it again", "VIDEO_MISSING");
 	}
@@ -17689,14 +18177,14 @@ function humanBytes(bytes) {
 /** Read one local file, refusing anything that is not a regular file. */
 async function readLocalFile(input) {
 	if (!path.isAbsolute(input)) throw new HarnessError(`video path must be absolute: ${input}`, "KIMI_VIDEO_PATH_NOT_ABSOLUTE");
-	const stats = await fsPromises.stat(input).catch(() => void 0);
+	const stats = await fs.stat(input).catch(() => void 0);
 	if (stats === void 0) throw new HarnessError(`video file not found: ${input}`, "KIMI_VIDEO_NOT_FOUND");
 	if (!stats.isFile()) throw new HarnessError(`video path is not a regular file: ${input}`, "KIMI_VIDEO_NOT_A_FILE");
 	if (stats.size > 31457280) throw new HarnessError(`video is ${humanBytes(stats.size)}, above the ${humanBytes(MAX_VIDEO_FILE_BYTES)} limit this route sends`, "KIMI_VIDEO_TOO_LARGE");
 	const type = mediaTypeForPath(input);
 	if (type === void 0) throw new HarnessError(`unsupported video extension "${path.extname(input)}"; supported: .mp4 .m4v .webm .mov .avi .mpeg .mpg .flv .wmv .3gp`, "KIMI_VIDEO_TYPE_UNSUPPORTED");
 	return {
-		data: await fsPromises.readFile(input),
+		data: await fs.readFile(input),
 		name: path.basename(input),
 		type
 	};
@@ -19177,16 +19665,16 @@ function credentialNeedsRefresh(credentials, now = Date.now()) {
 * leaves the destination untouched.
 */
 async function writeFileAtomic(filePath, contents) {
-	await fsPromises.mkdir(path.dirname(filePath), { recursive: true });
+	await fs.mkdir(path.dirname(filePath), { recursive: true });
 	const temporary = filePath + ".dsh-tmp-" + process.pid + "-" + Date.now();
 	try {
-		await fsPromises.writeFile(temporary, contents, {
+		await fs.writeFile(temporary, contents, {
 			encoding: "utf8",
 			mode: 384
 		});
-		await fsPromises.rename(temporary, filePath);
+		await fs.rename(temporary, filePath);
 	} catch (error) {
-		await fsPromises.rm(temporary, { force: true }).catch(() => void 0);
+		await fs.rm(temporary, { force: true }).catch(() => void 0);
 		throw new Error("MiniMax Code credential write failed; the previous file was left untouched (" + (error instanceof Error ? error.message : String(error)) + ")");
 	}
 }
@@ -19396,7 +19884,7 @@ async function readNativeDocument(region) {
 	const filePath = authJsonPath(region);
 	let raw;
 	try {
-		raw = await fsPromises.readFile(filePath, "utf8");
+		raw = await fs.readFile(filePath, "utf8");
 	} catch {
 		return null;
 	}
@@ -19433,7 +19921,7 @@ async function syncAuthState(region, options) {
 	const filePath = authStateJsonPath(region);
 	let parsed;
 	try {
-		parsed = JSON.parse(await fsPromises.readFile(filePath, "utf8"));
+		parsed = JSON.parse(await fs.readFile(filePath, "utf8"));
 	} catch {
 		return;
 	}
@@ -19481,7 +19969,7 @@ var MinimaxCodeCredentialStore = class {
 	async readPluginFile() {
 		let raw;
 		try {
-			raw = await fsPromises.readFile(pluginCredentialPath(), "utf8");
+			raw = await fs.readFile(pluginCredentialPath(), "utf8");
 		} catch {
 			return null;
 		}
@@ -19623,7 +20111,7 @@ var MinimaxCodeCredentialStore = class {
 	*/
 	delete() {
 		return serialize(pluginCredentialPath(), async () => {
-			await fsPromises.rm(pluginCredentialPath(), { force: true });
+			await fs.rm(pluginCredentialPath(), { force: true });
 			recentRead = null;
 		});
 	}
@@ -19722,17 +20210,17 @@ var MinimaxCodeModelSettingsStore = class {
 	}
 	async read() {
 		try {
-			return parseMinimaxCodeModelSettings(JSON.parse(await fsPromises.readFile(this.filePath, "utf8")));
+			return parseMinimaxCodeModelSettings(JSON.parse(await fs.readFile(this.filePath, "utf8")));
 		} catch {
 			return defaultMinimaxCodeSettings();
 		}
 	}
 	async write(settings) {
-		await fsPromises.mkdir(path.dirname(this.filePath), { recursive: true });
+		await fs.mkdir(path.dirname(this.filePath), { recursive: true });
 		const temporary = this.filePath + ".tmp." + Date.now();
-		await fsPromises.writeFile(temporary, JSON.stringify(settings, null, 2) + "\n", "utf8");
-		await fsPromises.rename(temporary, this.filePath);
-		if (!isDeepStrictEqual(parseMinimaxCodeModelSettings(JSON.parse(await fsPromises.readFile(this.filePath, "utf8"))), settings)) throw new Error("MiniMax Code model settings write failed; the stored selection does not match what was written");
+		await fs.writeFile(temporary, JSON.stringify(settings, null, 2) + "\n", "utf8");
+		await fs.rename(temporary, this.filePath);
+		if (!isDeepStrictEqual(parseMinimaxCodeModelSettings(JSON.parse(await fs.readFile(this.filePath, "utf8"))), settings)) throw new Error("MiniMax Code model settings write failed; the stored selection does not match what was written");
 	}
 	/**
 	* Read-modify-write under the same per-path lock the credential writes use.
@@ -21552,23 +22040,30 @@ var MinimaxCodeAccountPool = class extends AccountPoolCore {
 	* because that one genuinely needs a sign-in.
 	*/
 	async healStaleAuthFailures(current) {
-		const data = current ?? await this.read();
-		if (!data.accounts.some(isMarkedFailed)) return false;
+		const failedAccounts = (current ?? await this.read()).accounts.filter(isMarkedFailed);
+		if (failedAccounts.length === 0) return false;
+		const targets = new Map(failedAccounts.map((account) => [account.id, {
+			credentials: account.credentials,
+			authStatus: account.authStatus
+		}]));
 		const live = await this.store.read().catch(() => null);
 		if (live === null) return false;
-		let changed = false;
-		for (const account of data.accounts) {
-			if (account.authStatus === void 0 || account.authStatus === "ok") continue;
-			if (!minimaxCodeSameCredentialSession(live, account.credentials)) continue;
-			if (!minimaxCodeCredentialAdvancedPast(live, account.credentials)) continue;
-			account.authStatus = void 0;
-			account.authFailedReason = void 0;
-			account.credentials = live;
-			changed = true;
-		}
-		if (!changed) return false;
-		await this.write(data).catch(() => void 0);
-		return true;
+		return await this.updatePool((draft) => {
+			let changed = false;
+			for (const account of draft.accounts) {
+				const expected = targets.get(account.id);
+				if (!expected) continue;
+				if (account.authStatus !== expected.authStatus) continue;
+				if (!isDeepStrictEqual(account.credentials, expected.credentials)) continue;
+				if (!minimaxCodeSameCredentialSession(live, account.credentials)) continue;
+				if (!minimaxCodeCredentialAdvancedPast(live, account.credentials)) continue;
+				account.authStatus = void 0;
+				account.authFailedReason = void 0;
+				account.credentials = live;
+				changed = true;
+			}
+			return changed;
+		});
 	}
 	/**
 	* Pick the account for the next request.
@@ -21582,7 +22077,13 @@ var MinimaxCodeAccountPool = class extends AccountPoolCore {
 		const effective = await this.getEffectiveAccount(excludeIds, fetchFn);
 		const live = await this.liveNativeCredential(effective.account);
 		if (live === null) return effective;
-		if (live.accessToken !== effective.credentials.accessToken) await this.updateAccountCredentials(effective.account.id, live).catch(() => void 0);
+		if (live.accessToken !== effective.credentials.accessToken) {
+			const updated = await this.updateAccountCredentials(effective.account.id, live, effective.credentials).catch(() => void 0);
+			if (updated) return {
+				account: updated,
+				credentials: updated.credentials
+			};
+		}
 		return {
 			account: effective.account,
 			credentials: live
@@ -21644,7 +22145,7 @@ var MinimaxCodeAccountPool = class extends AccountPoolCore {
 		return this.addAccount(credentials, alias);
 	}
 	/**
-	* Delete one account.
+	* Remove one account inside a transaction.
 	*
 	* An account whose credential is the desktop app's own \`auth.json\` is refused:
 	* this plugin does not own that file, and removing the account would either
@@ -21652,9 +22153,9 @@ var MinimaxCodeAccountPool = class extends AccountPoolCore {
 	* file — sign the user out of MiniMax Code itself. Signing out there is the
 	* supported way to end it, and the card is told so by \`removable: false\`.
 	*/
-	async deleteAccount(accountId) {
-		if ((await this.read()).accounts.find((account) => account.id === accountId)?.source === "minimax-native") throw new Error("该账号来自 MiniMax Code 桌面端（~/.minimax/auth），本插件只能读取和续期，不能删除。请在 MiniMax Code 应用中退出登录。");
-		await super.deleteAccount(accountId);
+	deleteAccountFromPool(data, accountId) {
+		if (data.accounts.find((account) => account.id === accountId)?.source === "minimax-native") throw new Error("该账号来自 MiniMax Code 桌面端（~/.minimax/auth），本插件只能读取和续期，不能删除。请在 MiniMax Code 应用中退出登录。");
+		super.deleteAccountFromPool(data, accountId);
 	}
 	/** The credential store this pool mirrors its primary account into. */
 	mirrorStore() {
@@ -23434,7 +23935,7 @@ function isCanonicalFile(name) {
 async function scanCredentials(dir = codeBuddyAuthDir()) {
 	let names;
 	try {
-		names = await fsPromises.readdir(dir);
+		names = await fs.readdir(dir);
 	} catch (error) {
 		if (error.code === "ENOENT") return [];
 		throw new Error(`WorkBuddy credential directory could not be read: ${dir}`);
@@ -23444,9 +23945,9 @@ async function scanCredentials(dir = codeBuddyAuthDir()) {
 		if (!name.endsWith(".info")) continue;
 		const file = path.join(dir, name);
 		try {
-			const stats = await fsPromises.stat(file);
+			const stats = await fs.stat(file);
 			if (!stats.isFile()) continue;
-			const raw = await fsPromises.readFile(file, "utf8");
+			const raw = await fs.readFile(file, "utf8");
 			found.push(parseCredentialFile(JSON.parse(raw), file, stats.mtimeMs));
 		} catch {
 			continue;
@@ -23583,7 +24084,7 @@ var FileCredentialStore$4 = class {
 	async isStillCurrent(credentials) {
 		if (credentials.source === "managed") return true;
 		try {
-			return (await fsPromises.stat(credentials.sourceFile)).mtimeMs === credentials.sourceMtimeMs;
+			return (await fs.stat(credentials.sourceFile)).mtimeMs === credentials.sourceMtimeMs;
 		} catch {
 			return false;
 		}
@@ -23623,9 +24124,9 @@ var FileCredentialStore$4 = class {
 	*/
 	async readDesktopFile(filePath) {
 		try {
-			const stats = await fsPromises.stat(filePath);
+			const stats = await fs.stat(filePath);
 			if (!stats.isFile()) return null;
-			const raw = await fsPromises.readFile(filePath, "utf8");
+			const raw = await fs.readFile(filePath, "utf8");
 			return parseCredentialFile(JSON.parse(raw), filePath, stats.mtimeMs);
 		} catch {
 			return null;
@@ -23684,25 +24185,25 @@ var FileCredentialStore$4 = class {
 	*/
 	async writeBack(credentials) {
 		try {
-			const raw = await fsPromises.readFile(credentials.sourceFile, "utf8");
+			const raw = await fs.readFile(credentials.sourceFile, "utf8");
 			const parsed = JSON.parse(raw);
 			if (!isRecord$11(parsed) || !isRecord$11(parsed.auth)) return;
 			parsed.auth.accessToken = credentials.accessToken;
 			if (credentials.refreshToken !== "") parsed.auth.refreshToken = credentials.refreshToken;
 			parsed.auth.expiresAt = credentials.expiresAt;
 			parsed.auth.lastRefreshTime = Date.now();
-			const sourceMode = process.platform === "win32" ? void 0 : (await fsPromises.stat(credentials.sourceFile)).mode & 511;
+			const sourceMode = process.platform === "win32" ? void 0 : (await fs.stat(credentials.sourceFile)).mode & 511;
 			const tmp = `${credentials.sourceFile}.tmp.${process.pid}`;
 			try {
-				await fsPromises.writeFile(tmp, JSON.stringify(parsed, null, 2), {
+				await fs.writeFile(tmp, JSON.stringify(parsed, null, 2), {
 					encoding: "utf8",
 					...sourceMode === void 0 ? {} : { mode: sourceMode }
 				});
-				await fsPromises.rename(tmp, credentials.sourceFile);
+				await fs.rename(tmp, credentials.sourceFile);
 			} finally {
-				await fsPromises.unlink(tmp).catch(() => void 0);
+				await fs.unlink(tmp).catch(() => void 0);
 			}
-			credentials.sourceMtimeMs = (await fsPromises.stat(credentials.sourceFile)).mtimeMs;
+			credentials.sourceMtimeMs = (await fs.stat(credentials.sourceFile)).mtimeMs;
 		} catch {}
 	}
 };
@@ -23717,7 +24218,7 @@ var FileModelSettingsStore$4 = class {
 	}
 	async read() {
 		try {
-			const content = await fsPromises.readFile(this.filePath, "utf8");
+			const content = await fs.readFile(this.filePath, "utf8");
 			const parsed = JSON.parse(content);
 			if (isRecord$11(parsed)) {
 				const enabledModelIds = Array.isArray(parsed.enabledModelIds) ? parsed.enabledModelIds.filter((id) => typeof id === "string") : [...DEFAULT_ENABLED_MODEL_IDS$1];
@@ -23745,10 +24246,10 @@ var FileModelSettingsStore$4 = class {
 		};
 	}
 	async write(settings) {
-		await fsPromises.mkdir(path.dirname(this.filePath), { recursive: true });
+		await fs.mkdir(path.dirname(this.filePath), { recursive: true });
 		const tmp = `${this.filePath}.tmp.${Date.now()}`;
-		await fsPromises.writeFile(tmp, JSON.stringify(settings, null, 2), "utf8");
-		await fsPromises.rename(tmp, this.filePath);
+		await fs.writeFile(tmp, JSON.stringify(settings, null, 2), "utf8");
+		await fs.rename(tmp, this.filePath);
 	}
 	async updateSettings(patch) {
 		const current = await this.read();
@@ -26157,15 +26658,15 @@ var WorkBuddyAccountPool = class extends AccountPoolCore {
 		this.options_selection = options.selection;
 	}
 	/**
-	* Read the pool, refreshing the legacy-key index on the way.
+	* Load the pool, refreshing the legacy-key index on the way.
 	*
-	* Every routing decision goes through this method before it consults the
-	* settings selection, so building the index here is what keeps a pin written
-	* before the identity fix resolvable when {@link resolveSelectionId} is asked
-	* for it.
+	* Every routing decision and mutation goes through this method before it
+	* consults the settings selection, so building the index here is what keeps
+	* a pin written before the identity fix resolvable when
+	* {@link resolveSelectionId} is asked for it.
 	*/
-	async read() {
-		const data = await super.read();
+	async loadPoolData() {
+		const data = await super.loadPoolData();
 		this.legacyIds.clear();
 		for (const account of data.accounts) for (const alias of workBuddyAccountIdAliases(account.credentials)) if (alias !== account.id) this.legacyIds.set(alias, account.id);
 		return data;
@@ -26185,20 +26686,34 @@ var WorkBuddyAccountPool = class extends AccountPoolCore {
 	*/
 	async syncDesktopAccounts() {
 		const discovered = await this.store.discoverDesktopCredentials();
-		if (discovered.length > 0) {
-			const data = await this.read();
-			const known = new Set(data.accounts.map((account) => workBuddyAccountId(account.credentials)));
-			const seen = /* @__PURE__ */ new Set();
-			for (const credentials of discovered) {
-				const id = workBuddyAccountId(credentials);
-				if (known.has(id) || seen.has(id)) continue;
-				seen.add(id);
-				await this.addAccount({
-					...credentials,
-					source: "desktop"
-				});
+		const candidates = [];
+		const seen = /* @__PURE__ */ new Set();
+		for (const raw of discovered) {
+			const credentials = withResolvedIdentity({
+				...raw,
+				source: "desktop"
+			});
+			const id = workBuddyAccountId(credentials);
+			if (seen.has(id)) continue;
+			seen.add(id);
+			candidates.push(credentials);
+		}
+		if (candidates.length > 0) await this.updatePool((data) => {
+			const existingKeys = /* @__PURE__ */ new Set();
+			for (const account of data.accounts) {
+				existingKeys.add(account.id);
+				const key = this.hooks.dedupeKey?.(account.credentials);
+				if (key !== void 0) existingKeys.add(key);
 			}
-		}
+			for (const credentials of candidates) {
+				const key = this.hooks.dedupeKey?.(credentials);
+				const id = this.hooks.accountId?.(credentials);
+				if (key !== void 0 && existingKeys.has(key) || id !== void 0 && existingKeys.has(id)) continue;
+				this.addAccountToPool(data, credentials);
+				if (key !== void 0) existingKeys.add(key);
+				if (id !== void 0) existingKeys.add(id);
+			}
+		});
 		return this.listAccounts();
 	}
 	/**
@@ -26214,7 +26729,13 @@ var WorkBuddyAccountPool = class extends AccountPoolCore {
 		const live = await this.store.readDesktopFile(effective.account.sourceFile);
 		if (live === null) return effective;
 		if (isExpired(live)) return effective;
-		if (live.accessToken !== effective.credentials.accessToken) await this.updateAccountCredentials(effective.account.id, live).catch(() => void 0);
+		if (live.accessToken !== effective.credentials.accessToken) {
+			const updated = await this.updateAccountCredentials(effective.account.id, live, effective.credentials).catch(() => void 0);
+			if (updated) return {
+				account: updated,
+				credentials: updated.credentials
+			};
+		}
 		return {
 			account: effective.account,
 			credentials: live
@@ -26251,15 +26772,15 @@ var WorkBuddyAccountPool = class extends AccountPoolCore {
 		return super.addAccount(withResolvedIdentity(credentials), alias);
 	}
 	/**
-	* Delete one account.
+	* Remove one account inside a transaction.
 	*
 	* A desktop account is refused: the plugin does not own that credential file,
 	* so removing it from the pool would strand the IDE's session while telling
 	* the user their account was deleted. Hiding is the supported action there.
 	*/
-	async deleteAccount(accountId) {
-		if ((await this.read()).accounts.find((account) => account.id === accountId)?.source === "desktop") throw new Error("桌面账号由 CodeBuddy 客户端所有，只能隐藏，不能删除。");
-		await super.deleteAccount(accountId);
+	deleteAccountFromPool(data, accountId) {
+		if (data.accounts.find((account) => account.id === accountId)?.source === "desktop") throw new Error("桌面账号由 CodeBuddy 客户端所有，只能隐藏，不能删除。");
+		super.deleteAccountFromPool(data, accountId);
 	}
 };
 //#endregion
@@ -26352,6 +26873,25 @@ const CLAUDE_CODE_BETA = "claude-code-20250219";
 /** Lets thinking blocks interleave with tool use across a multi-turn loop. */
 const INTERLEAVED_THINKING_BETA = "interleaved-thinking-2025-05-14";
 /**
+* Licenses the extended one-hour prompt-cache TTL.
+*
+* `cache_control: { type: 'ephemeral', ttl: '1h' }` is NOT accepted without this
+* beta: the one-hour tier is a separate licensed capability, and a body that
+* asks for it without the marker is refused the same way `block_binding` is.
+*/
+const EXTENDED_CACHE_TTL_BETA = "extended-cache-ttl-2025-04-11";
+/** A cache marker for one tier. Absent `ttl` means the five-minute default. */
+function cacheControlFor(ttl) {
+	return {
+		type: "ephemeral",
+		ttl
+	};
+}
+/** Whether a stored preference names a tier this line can send. */
+function isClaudeCacheTtl$1(value) {
+	return value === "5m" || value === "1h";
+}
+/**
 * Licenses `thinking.block_binding` in a request body.
 *
 * The field is not optional to license: the vendor documents that a body
@@ -27320,6 +27860,7 @@ function defaultClaudeSettings() {
 		enabledModelIds: [...DEFAULT_ENABLED_MODEL_IDS],
 		contextWindowOverrides: {},
 		defaultReasoningEffort: null,
+		cacheTtl: null,
 		selectedAccountId: null
 	};
 }
@@ -27555,12 +28096,14 @@ function parseClaudeModelSettings(value) {
 		for (const [model, window] of Object.entries(record.contextWindowOverrides)) if (typeof window === "number" && Number.isFinite(window) && window > 0) contextWindowOverrides[model] = window;
 	}
 	const defaultReasoningEffort = nonEmptyString$3(record.defaultReasoningEffort) ?? null;
+	const cacheTtl = isClaudeCacheTtl$1(record.cacheTtl) ? record.cacheTtl : null;
 	const selectedAccountId = nonEmptyString$3(record.selectedAccountId) ?? null;
 	return {
 		enabled: record.enabled !== false,
 		enabledModelIds,
 		contextWindowOverrides,
 		defaultReasoningEffort,
+		cacheTtl,
 		selectedAccountId
 	};
 }
@@ -27571,6 +28114,7 @@ function mergeClaudeSettings(current, patch) {
 		enabledModelIds: patch.enabledModelIds !== void 0 ? [...patch.enabledModelIds] : current.enabledModelIds,
 		contextWindowOverrides: patch.contextWindowOverrides !== void 0 ? mergeContextWindowOverrides(current.contextWindowOverrides, patch.contextWindowOverrides) : current.contextWindowOverrides,
 		defaultReasoningEffort: patch.defaultReasoningEffort !== void 0 ? patch.defaultReasoningEffort : current.defaultReasoningEffort,
+		cacheTtl: patch.cacheTtl !== void 0 ? patch.cacheTtl : current.cacheTtl,
 		selectedAccountId: patch.selectedAccountId !== void 0 ? patch.selectedAccountId : current.selectedAccountId
 	};
 }
@@ -27643,7 +28187,7 @@ var FileCredentialStore = class {
 	}
 	async removeLegacy() {
 		try {
-			await fsPromises.unlink(this.filePath);
+			await fs.unlink(this.filePath);
 		} catch (error) {
 			if (error.code !== "ENOENT") throw new Error("Claude legacy credential removal failed");
 		}
@@ -27664,11 +28208,11 @@ var FileCredentialStore = class {
 		}
 		let legacy;
 		try {
-			const stats = await fsPromises.lstat(this.filePath);
+			const stats = await fs.lstat(this.filePath);
 			if (!stats.isFile() || stats.isSymbolicLink()) throw new Error("Invalid credential file");
 			if (process.getuid && stats.uid !== process.getuid()) throw new Error("Invalid credential owner");
-			if (process.platform !== "win32") await fsPromises.chmod(this.filePath, 384);
-			legacy = await fsPromises.readFile(this.filePath, "utf8");
+			if (process.platform !== "win32") await fs.chmod(this.filePath, 384);
+			legacy = await fs.readFile(this.filePath, "utf8");
 		} catch (error) {
 			if (error.code === "ENOENT") return null;
 			throw new Error("Claude legacy credential read failed");
@@ -27776,17 +28320,17 @@ var FileModelSettingsStore = class {
 	}
 	async read() {
 		try {
-			const content = await fsPromises.readFile(this.filePath, "utf8");
+			const content = await fs.readFile(this.filePath, "utf8");
 			return parseClaudeModelSettings(JSON.parse(content));
 		} catch {
 			return defaultClaudeSettings();
 		}
 	}
 	async write(settings) {
-		await fsPromises.mkdir(path.dirname(this.filePath), { recursive: true });
+		await fs.mkdir(path.dirname(this.filePath), { recursive: true });
 		const tmp = this.filePath + ".tmp." + Date.now();
-		await fsPromises.writeFile(tmp, JSON.stringify(settings, null, 2), "utf8");
-		await fsPromises.rename(tmp, this.filePath);
+		await fs.writeFile(tmp, JSON.stringify(settings, null, 2), "utf8");
+		await fs.rename(tmp, this.filePath);
 	}
 	/**
 	* Read-modify-write under the same per-path lock the credentials use.
@@ -27828,6 +28372,11 @@ function registerClaudePreferenceStore(settings, fallbackStore = new FileModelSe
 		enabledModelIds: z.array(z.string()).default([...DEFAULT_ENABLED_MODEL_IDS]),
 		contextWindowOverrides: z.dict(z.number()).default({}),
 		defaultReasoningEffort: z.union([z.string(), z.const(null)]).default(null),
+		cacheTtl: z.union([
+			z.const("5m"),
+			z.const("1h"),
+			z.const(null)
+		]).default(null),
 		selectedAccountId: z.union([z.string(), z.const(null)]).default(null)
 	}));
 	return {
@@ -27838,6 +28387,7 @@ function registerClaudePreferenceStore(settings, fallbackStore = new FileModelSe
 				enabledModelIds: value.enabledModelIds,
 				contextWindowOverrides: value.contextWindowOverrides,
 				defaultReasoningEffort: value.defaultReasoningEffort,
+				cacheTtl: isClaudeCacheTtl$1(value.cacheTtl) ? value.cacheTtl : null,
 				selectedAccountId: value.selectedAccountId ?? null
 			};
 		},
@@ -28033,6 +28583,7 @@ function claudeBetas(options = {}) {
 	betas.push(OAUTH_BETA);
 	if (options.thinking === true) betas.push(INTERLEAVED_THINKING_BETA);
 	if (options.thinkingBinding === true) betas.push(THINKING_BINDING_CONTROLS_BETA);
+	if (options.cacheTtl === "1h") betas.push(EXTENDED_CACHE_TTL_BETA);
 	return betas;
 }
 /** The `User-Agent` value this line reports for one surface. */
@@ -29630,7 +30181,7 @@ function leadingSystemText(options) {
 *
 * @param cacheControl - false is the opt-OUT; the default requests caching.
 */
-function buildClaudeSystemBlocks(options, cacheControl = true) {
+function buildClaudeSystemBlocks(options, cacheControl = true, ttl = "5m") {
 	const blocks = [{
 		type: "text",
 		text: CLAUDE_CODE_IDENTITY_TEXT
@@ -29642,7 +30193,7 @@ function buildClaudeSystemBlocks(options, cacheControl = true) {
 	});
 	if (cacheControl) {
 		const last = blocks[blocks.length - 1];
-		last.cache_control = { type: "ephemeral" };
+		last.cache_control = cacheControlFor(ttl);
 	}
 	return blocks;
 }
@@ -29680,13 +30231,14 @@ function lastCacheableUserBlock(messages) {
 *   and has not been handed to a caller yet.
 * @returns the number of breakpoints written.
 */
-function markClaudeCacheBreakpoints(body) {
+function markClaudeCacheBreakpoints(body, ttl = "5m") {
 	let marked = 0;
+	const marker = cacheControlFor(ttl);
 	const system = body.system;
 	if (Array.isArray(system)) {
 		const last = system[system.length - 1];
 		if (last !== void 0) {
-			last.cache_control = { type: "ephemeral" };
+			last.cache_control = { ...marker };
 			marked += 1;
 		}
 	}
@@ -29694,7 +30246,7 @@ function markClaudeCacheBreakpoints(body) {
 	if (Array.isArray(messages)) {
 		const target = lastCacheableUserBlock(messages);
 		if (target !== void 0) {
-			target.cache_control = { type: "ephemeral" };
+			target.cache_control = { ...marker };
 			marked += 1;
 		}
 	}
@@ -29702,7 +30254,7 @@ function markClaudeCacheBreakpoints(body) {
 	if (Array.isArray(tools) && tools.length > 0) {
 		const last = tools[tools.length - 1];
 		if (last !== void 0) {
-			last.cache_control = { type: "ephemeral" };
+			last.cache_control = { ...marker };
 			marked += 1;
 		}
 	}
@@ -29936,11 +30488,12 @@ function buildClaudeRequestBody(options, images = NO_RESOLVED_IMAGES, request =
 	const thinkingEnabled = thinking !== void 0 && thinking.type !== "disabled";
 	const temperatureAllowed = claudeModelSupportsTemperature(options.model) && !thinkingEnabled;
 	const caching = request.cacheControl !== false;
+	const cacheTtl = request.cacheTtl ?? "5m";
 	const body = {
 		model: options.model,
 		max_tokens: maxTokens,
 		stream: true,
-		system: buildClaudeSystemBlocks(options, caching),
+		system: buildClaudeSystemBlocks(options, caching, cacheTtl),
 		messages: mergeClaudeMessages(entries),
 		...options.tools !== void 0 && options.tools.length > 0 ? { tools: options.tools.map((tool) => wireTool(tool, names)) } : {},
 		...thinking === void 0 ? {} : { thinking },
@@ -29948,7 +30501,7 @@ function buildClaudeRequestBody(options, images = NO_RESOLVED_IMAGES, request =
 		...temperatureAllowed && options.temperature !== void 0 ? { temperature: options.temperature } : {},
 		...options.stop !== void 0 && options.stop.length > 0 ? { stop_sequences: [...options.stop] } : {}
 	};
-	if (caching) markClaudeCacheBreakpoints(body);
+	if (caching) markClaudeCacheBreakpoints(body, cacheTtl);
 	return body;
 }
 /**
@@ -31730,7 +32283,7 @@ var ClaudeAccountTokenStore = class {
 		await this.store.saveAccount(credentials, { internalId: this.internalId });
 	}
 };
-var ClaudeAdapter = class extends LlmAdapter {
+var ClaudeAdapter = class ClaudeAdapter extends LlmAdapter {
 	store;
 	modelSettings;
 	preferences;
@@ -31912,10 +32465,25 @@ var ClaudeAdapter = class extends LlmAdapter {
 	* driven by {@link shouldRotateAccount}, which bypasses the pool ENTIRELY when
 	* no credentials were resolved for it.
 	*/
-	async attemptRequest(credentials, requestOptions, images, toolNames, thinking, signal, fetchFn) {
+	/**
+	* The prompt-cache tier this line requests.
+	*
+	* A stored value wins; nothing stored falls back to the tier the OFFICIAL
+	* client uses for a subscription's main conversation, so a user comparing
+	* this plugin with Claude Code sees the same cache lifetime rather than half
+	* of it.
+	*
+	* @param settings - the document the caller already read for this turn.
+	*/
+	static cacheTtlFor(settings) {
+		return settings?.cacheTtl ?? "1h";
+	}
+	async attemptRequest(credentials, requestOptions, images, toolNames, thinking, settings, signal, fetchFn) {
+		const cacheTtl = ClaudeAdapter.cacheTtlFor(settings);
 		const payload = buildClaudeRequestBody(requestOptions, images, {
 			toolNames,
-			cacheControl: true
+			cacheControl: true,
+			cacheTtl
 		});
 		try {
 			return await fetchFn("https://api.anthropic.com/v1/messages?beta=true", {
@@ -31924,6 +32492,7 @@ var ClaudeAdapter = class extends LlmAdapter {
 					model: requestOptions.model,
 					thinking,
 					thinkingBinding: claudeBodyBindsThinking(payload),
+					cacheTtl,
 					method: "POST"
 				}),
 				body: JSON.stringify(payload),
@@ -31942,6 +32511,7 @@ var ClaudeAdapter = class extends LlmAdapter {
 		assertClaudeCliVersionMeetsFloor(requestOptions.model, await this.catalogForRequest());
 		const effort = requestOptions.reasoningEffort === void 0 || requestOptions.reasoningEffort === null ? void 0 : String(requestOptions.reasoningEffort);
 		const thinking = claudeRequestThinks(requestOptions.model, effort);
+		const settings = await this.settings().catch(() => null);
 		const pool = this.accountPool;
 		const tried = /* @__PURE__ */ new Set();
 		let response;
@@ -31961,7 +32531,7 @@ var ClaudeAdapter = class extends LlmAdapter {
 		let outputStarted = false;
 		while (true) {
 			const { credentials, accountId } = await this.resolveCredential(pool, tried, fetchFn, signal);
-			response = await this.attemptRequest(credentials, requestOptions, images, toolNames, thinking, signal, fetchFn);
+			response = await this.attemptRequest(credentials, requestOptions, images, toolNames, thinking, settings, signal, fetchFn);
 			if (response.ok) break;
 			const detail = (await response.text().catch(() => "")).slice(0, 2e3);
 			const failure = classifyFailure(response.status, detail, response.headers);
@@ -32577,7 +33147,7 @@ function isAdoptedCredentialExpired(credential, now = Date.now()) {
 * caller in the process, so with a pool it would hand the second account the
 * first account's freshly rotated credential — and, through the adapter above,
 * write it into the second account's record. The pool therefore keeps its OWN
-* single-flight, per account (see the inFlight map), which preserves the property
+* single-flight, per pool file and account, which preserves the property
 * the frozen module wanted (one rotation per expiry, no two callers spending the
 * same rotating token) without the cross-account contamination.
 *
@@ -32963,7 +33533,6 @@ var ClaudeAccountPool = class extends AccountPoolCore {
 	* marked expired immediately after a refresh that in fact succeeded. Keyed by
 	* the record's id — never by a token — so it cannot mix two accounts up.
 	*/
-	inFlight = /* @__PURE__ */ new Map();
 	constructor(options = {}) {
 		const store = options.store ?? new FileCredentialStore();
 		const refreshSeam = options.refreshCredentials ?? ((credentials, fetchFn) => refreshClaudeCredential(credentials, fetchFn));
@@ -33010,6 +33579,10 @@ var ClaudeAccountPool = class extends AccountPoolCore {
 				if (record === void 0) return null;
 				return poolAccountForRecord(record, true);
 			},
+			credentialsCommitted: async (account) => {
+				if (isAdoptedPoolCredential(account.credentials)) return;
+				await store.saveAccount(account.credentials, { internalId: account.id });
+			},
 			mirrorPrimary: async (credentials) => {
 				if (credentials === null) {
 					await store.delete();
@@ -33071,8 +33644,8 @@ var ClaudeAccountPool = class extends AccountPoolCore {
 	* {@link recordIdsFor} reads is kept in step with the rows that actually exist.
 	* See the recordIds field for why entries are not pruned.
 	*/
-	async read() {
-		const data = await super.read();
+	async loadPoolData() {
+		const data = await super.loadPoolData();
 		for (const account of data.accounts) this.indexAccount(account);
 		return data;
 	}
@@ -33085,10 +33658,27 @@ var ClaudeAccountPool = class extends AccountPoolCore {
 	* 'one account, one key' section.
 	*/
 	async addAccount(credentials, alias) {
-		const data = await this.read();
+		return this.updatePool((data) => this.addManagedAccount(data, credentials, alias)).catch((error) => {
+			this.recordIds.clear();
+			throw error;
+		});
+	}
+	async addManagedAccount(data, credentials, alias) {
 		if (isAdoptedPoolCredential(credentials)) return this.addAdoptedAccount(credentials, data, alias);
+		parseClaudeCredentials(credentials);
 		const knownId = await this.recordIdFor(credentials);
-		const record = await this.store.saveAccount(credentials);
+		const document = await this.store.read();
+		const keys = identityKeysFor(credentials);
+		const stored = document?.accounts.find((record) => record.identityKeys.some((key) => keys.includes(key)));
+		const record = stored === void 0 ? {
+			internalId: data.accounts.find((account) => account.id === knownId)?.adopted === false ? knownId ?? createInternalId() : createInternalId(),
+			identityKeys: keys,
+			credentials
+		} : {
+			...stored,
+			identityKeys: mergeIdentityKeys(stored.identityKeys, keys),
+			credentials
+		};
 		this.indexRecord(record);
 		if (knownId !== void 0 && knownId !== record.internalId) {
 			const row = data.accounts.find((account) => account.id === knownId);
@@ -33100,10 +33690,9 @@ var ClaudeAccountPool = class extends AccountPoolCore {
 				delete row.sourcePath;
 				row.identityKeys = mergeIdentityKeys(row.identityKeys, record.identityKeys);
 				if (data.activeAccountId === knownId) data.activeAccountId = record.internalId;
-				await this.write(data);
 			}
 		}
-		return super.addAccount(credentials, alias);
+		return this.addAccountToPool(data, credentials, alias);
 	}
 	/**
 	* Add, or re-import, one borrowed Claude Code snapshot.
@@ -33132,9 +33721,7 @@ var ClaudeAccountPool = class extends AccountPoolCore {
 		const candidateId = byIdentity ?? this.recordIds.get(sourceKey);
 		const existing = candidateId === void 0 ? void 0 : data.accounts.find((account) => account.id === candidateId);
 		if (existing !== void 0 && existing.adopted !== true) {
-			const before = existing.identityKeys.length;
 			existing.identityKeys = mergeIdentityKeys(existing.identityKeys, identityKeysFor(credentials));
-			if (existing.identityKeys.length !== before) await this.write(data);
 			return existing;
 		}
 		if (candidateId === void 0) {
@@ -33145,7 +33732,7 @@ var ClaudeAccountPool = class extends AccountPoolCore {
 			this.recordIds.set(sourceKey, candidateId);
 			this.indexCredential(credentials, candidateId);
 		}
-		return super.addAccount(credentials, alias);
+		return this.addAccountToPool(data, credentials, alias);
 	}
 	/**
 	* Merge two rows that are one account.
@@ -33168,7 +33755,21 @@ var ClaudeAccountPool = class extends AccountPoolCore {
 	*/
 	async mergeAccounts(keepAccountId, dropAccountId) {
 		if (keepAccountId === dropAccountId) throw new Error("A Claude pool merge needs two different accounts.");
-		const data = await this.read();
+		let originals;
+		return await this.updatePool(async (data) => {
+			const keep = data.accounts.find((account) => account.id === keepAccountId);
+			const drop = data.accounts.find((account) => account.id === dropAccountId);
+			if (keep === void 0 || drop === void 0) throw new Error("The Claude pool merge addressed an account the pool does not have.");
+			originals = {
+				keep,
+				drop
+			};
+			return this.mergeAccountsInPool(data, keepAccountId, dropAccountId);
+		}, async (_data, result) => {
+			if (originals !== void 0) await this.reconcileMergedDocument(originals.keep, originals.drop, result);
+		});
+	}
+	async mergeAccountsInPool(data, keepAccountId, dropAccountId) {
 		const keep = data.accounts.find((account) => account.id === keepAccountId);
 		const drop = data.accounts.find((account) => account.id === dropAccountId);
 		if (keep === void 0 || drop === void 0) throw new Error("The Claude pool merge addressed an account the pool does not have.");
@@ -33217,9 +33818,6 @@ var ClaudeAccountPool = class extends AccountPoolCore {
 		data.accounts[index] = merged;
 		data.accounts = data.accounts.filter((account) => account.id !== dropAccountId);
 		if (data.activeAccountId === dropAccountId) data.activeAccountId = merged.id;
-		await this.write(data);
-		if (merged.isPrimary) this.hooks.mirrorPrimary?.(merged.credentials).catch(() => void 0);
-		await this.reconcileMergedDocument(keep, drop, merged);
 		return merged;
 	}
 	/**
@@ -33259,10 +33857,12 @@ var ClaudeAccountPool = class extends AccountPoolCore {
 	* neither path.
 	*/
 	async removeImportedAccount(accountId) {
-		const target = (await this.read()).accounts.find((account) => account.id === accountId);
-		if (target === void 0) return;
-		if (target.adopted !== true) throw new Error("That account was signed in through this plugin; delete it instead of removing an import.");
-		await super.deleteAccount(accountId);
+		return this.updatePool((data) => {
+			const target = data.accounts.find((account) => account.id === accountId);
+			if (target === void 0) return;
+			if (target.adopted !== true) throw new Error("That account was signed in through this plugin; delete it instead of removing an import.");
+			super.deleteAccountFromPool(data, accountId);
+		});
 	}
 	/**
 	* Delete one plugin-owned account.
@@ -33275,9 +33875,12 @@ var ClaudeAccountPool = class extends AccountPoolCore {
 	* back a credential the user just deleted.
 	*/
 	async deleteAccount(accountId) {
-		if ((await this.read()).accounts.find((account) => account.id === accountId)?.adopted === true) throw new Error("The sign-in imported from Claude Code is not an account this plugin owns; remove the import instead.");
-		await super.deleteAccount(accountId);
-		await this.store.deleteAccount(accountId);
+		return this.updatePool((data) => {
+			if (data.accounts.find((account) => account.id === accountId)?.adopted === true) throw new Error("The sign-in imported from Claude Code is not an account this plugin owns; remove the import instead.");
+			super.deleteAccountFromPool(data, accountId);
+		}, async () => {
+			await this.store.deleteAccount(accountId);
+		});
 	}
 	/**
 	* The immutable id of the record that owns a credential, or nothing.
@@ -33357,44 +33960,7 @@ var ClaudeAccountPool = class extends AccountPoolCore {
 	*/
 	refreshCredentials(credentials, fetchFn) {
 		if (isAdoptedPoolCredential(credentials)) return Promise.reject(new ClaudeAdoptedCredentialError(adoptedCredentialExpired(credentials) ? ADOPTED_CREDENTIAL_EXPIRED_HINT : ADOPTED_NEVER_REFRESHED_MESSAGE));
-		return this.singleFlightRefresh(credentials, fetchFn);
-	}
-	/**
-	* The per-account single-flight, resolving the account's id first.
-	*
-	* Separated from the hook above only because resolving the id consults the
-	* credential document, and a hook cannot await: the guard stays synchronous so
-	* it can never be skipped by a caller that forgets to wait.
-	*/
-	async singleFlightRefresh(credentials, fetchFn) {
-		const key = await this.recordIdFor(credentials);
-		if (key !== void 0) {
-			const shared = this.inFlight.get(key);
-			if (shared !== void 0) return shared;
-		}
-		const pending = this.performRefresh(credentials, fetchFn);
-		if (key !== void 0) {
-			this.inFlight.set(key, pending);
-			pending.then(() => void 0, () => void 0).then(() => {
-				if (this.inFlight.get(key) === pending) this.inFlight.delete(key);
-			});
-		}
-		return pending;
-	}
-	/**
-	* Rotate one managed credential and keep the credential document in step.
-	*
-	* The document write is what stops the pre-pool projection from handing out a
-	* token the rotation has already spent. Its failure is swallowed on purpose:
-	* the credential WAS refreshed, the pool's own record holds it, and a mirror
-	* that could not be written must not fail a request that can still be served —
-	* the same rule the core applies to its own bookkeeping writes.
-	*/
-	async performRefresh(credentials, fetchFn) {
-		const recordId = await this.recordIdFor(credentials);
-		const refreshed = await this.refreshSeam(credentials, fetchFn);
-		if (recordId !== void 0) await new ClaudeCredentialStoreAdapter(this.store, recordId).write(refreshed).catch(() => void 0);
-		return refreshed;
+		return this.refreshSeam(credentials, fetchFn);
 	}
 };
 //#endregion
@@ -33435,6 +34001,16 @@ const CLAUDE_REASONING_EFFORTS = [
 function isClaudeReasoningEffort(value) {
 	return typeof value === "string" && CLAUDE_REASONING_EFFORTS.includes(value);
 }
+/**
+* Whether a posted value names a tier this route can send.
+*
+* Membership is checked at the wire boundary for the same reason effort levels
+* are: the one-hour tier is a LICENSED capability, so a value that reached the
+* body without the matching beta would be refused by the service.
+*/
+function isClaudeCacheTtl(value) {
+	return value === "5m" || value === "1h";
+}
 //#endregion
 //#region src/host/claude/routes.ts
 /** Ceiling on one request body. Identical to every sibling line's. */
@@ -33626,6 +34202,7 @@ async function getClaudeWebStatus(store, modelSettings, preferences, options = {
 		models,
 		contextWindowOverrides: settings.contextWindowOverrides,
 		defaultReasoningEffort: settings.defaultReasoningEffort,
+		cacheTtl: settings.cacheTtl,
 		selectedAccountId: settings.selectedAccountId,
 		accounts: poolAccounts.map((summary) => summary),
 		rotationStrategy: poolData?.rotationStrategy ?? "sequential",
@@ -33904,6 +34481,10 @@ function registerClaudeRoutes(ctx, store, modelSettings, preferences, options =
 						const effort = body.defaultReasoningEffort;
 						if (effort === null || isClaudeReasoningEffort(effort)) patch.defaultReasoningEffort = effort;
 					}
+					if (body.cacheTtl !== void 0) {
+						const ttl = body.cacheTtl;
+						if (ttl === null || isClaudeCacheTtl(ttl)) patch.cacheTtl = ttl;
+					}
 					if (body.selectedAccountId !== void 0) {
 						const selected = body.selectedAccountId;
 						if (selected !== null && typeof selected !== "string") return sendJson(response, 400, {
@@ -34439,7 +35020,7 @@ var WorkBuddyCheckinService = class {
 		if (this.loaded) return;
 		this.loaded = true;
 		try {
-			const parsed = JSON.parse(await fsPromises.readFile(this.statePath, "utf8"));
+			const parsed = JSON.parse(await fs.readFile(this.statePath, "utf8"));
 			if (isRecord$2(parsed)) {
 				const lastRunAt = asCount$1(parsed.lastRunAt);
 				if (lastRunAt !== void 0) this.lastRunAt = lastRunAt;
@@ -34452,15 +35033,15 @@ var WorkBuddyCheckinService = class {
 	}
 	async save() {
 		try {
-			await fsPromises.mkdir(path.dirname(this.statePath), { recursive: true });
+			await fs.mkdir(path.dirname(this.statePath), { recursive: true });
 			const tmp = `${this.statePath}.tmp.${process.pid}`;
 			const document = {
 				version: 2,
 				lastRunAt: this.lastRunAt,
 				accounts: this.state
 			};
-			await fsPromises.writeFile(tmp, JSON.stringify(document, null, 2), "utf8");
-			await fsPromises.rename(tmp, this.statePath);
+			await fs.writeFile(tmp, JSON.stringify(document, null, 2), "utf8");
+			await fs.rename(tmp, this.statePath);
 		} catch {}
 	}
 	async post(url, headers) {
@@ -35108,7 +35689,7 @@ var MinimaxCodeCheckinService = class {
 		if (this.loaded) return;
 		this.loaded = true;
 		try {
-			const parsed = JSON.parse(await fsPromises.readFile(this.statePath, "utf8"));
+			const parsed = JSON.parse(await fs.readFile(this.statePath, "utf8"));
 			if (isRecord(parsed)) {
 				const lastRunAt = asCount(parsed.lastRunAt);
 				if (lastRunAt !== void 0) this.lastRunAt = lastRunAt;
@@ -35127,7 +35708,7 @@ var MinimaxCodeCheckinService = class {
 	}
 	async save() {
 		try {
-			await fsPromises.mkdir(path.dirname(this.statePath), { recursive: true });
+			await fs.mkdir(path.dirname(this.statePath), { recursive: true });
 			const tmp = `${this.statePath}.tmp.${process.pid}`;
 			const document = {
 				version: 1,
@@ -35135,8 +35716,8 @@ var MinimaxCodeCheckinService = class {
 				accounts: this.state,
 				identities: this.identities
 			};
-			await fsPromises.writeFile(tmp, JSON.stringify(document, null, 2), "utf8");
-			await fsPromises.rename(tmp, this.statePath);
+			await fs.writeFile(tmp, JSON.stringify(document, null, 2), "utf8");
+			await fs.rename(tmp, this.statePath);
 		} catch {}
 	}
 };
@@ -37112,9 +37693,9 @@ function appendWindow(current, addition, limit) {
 /**
 * Install the reasoning-collapse guard on a Context.
 *
-* The guard is inert unless the host exposes the `llm/stream` seam, so a
-* harness without it keeps the built-in behaviour instead of failing this
-* plugin's load.
+* The guard is inert unless the host exposes the event bus, so a harness
+* without it keeps the built-in behaviour instead of failing this plugin's
+* load.
 *
 * Resuming needs the live Agent for `cancel` and `steer`, and no supported
 * generation hands the agent to `llm/stream`. `agent/created` reports it on
@@ -37124,19 +37705,19 @@ function appendWindow(current, addition, limit) {
 *
 * @param ctx - plugin context.
 * @param options - see {@link GuardOptions}; validated fail-loud.
-* @returns a disposer, or undefined when the seam is unavailable.
+* @returns a disposer removing both listeners, or undefined when the host
+* exposes no event bus.
 */
 function installReasoningCollapseGuard(ctx, options = {}) {
 	const resolved = resolveGuardOptions(options);
-	const runtime = ctx.llm;
-	if (runtime === void 0 || typeof runtime.stream !== "function") return void 0;
-	const original = runtime.stream;
+	if (typeof ctx.on !== "function") return void 0;
 	const watched = new Set(resolved.includeModels);
 	const breakers = /* @__PURE__ */ new WeakMap();
 	let currentAgent;
-	const releaseAgent = typeof ctx.on === "function" ? ctx.on("agent/created", ({ agent }) => {
-		currentAgent = agent;
-	}) : void 0;
+	const releaseAgent = ctx.on("agent/created", (payload) => {
+		currentAgent = payload.agent;
+	});
+	const releaseStream = ctx.on("llm/stream", guardStream, { global: true });
 	function breakerFor(key) {
 		let state = breakers.get(key);
 		if (state === void 0) {
@@ -37174,7 +37755,7 @@ function installReasoningCollapseGuard(ctx, options = {}) {
 			agent.steer?.(createResumeMessage(text));
 		});
 	}
-	runtime.stream = function reasoningCollapseGuardStream(request, next) {
+	function guardStream(request, next) {
 		const state = breakerFor(request.signal ?? STATIC_KEY);
 		if (state.exhausted || !watchedModel(request.model)) return next();
 		async function* guarded() {
@@ -37196,9 +37777,9 @@ function installReasoningCollapseGuard(ctx, options = {}) {
 			}
 		}
 		return guarded();
-	};
+	}
 	return () => {
-		runtime.stream = original;
+		releaseListener(releaseStream);
 		releaseListener(releaseAgent);
 	};
 }
@@ -37290,7 +37871,7 @@ function apply(ctx, pluginConfig = {}) {
 		ctx.effect(() => {
 			const dispose = installReasoningCollapseGuard(ctx, guardOptions);
 			if (dispose === void 0) {
-				ctx.logger.warn("[dsh-chatgpt-subscription] reasoning-collapse guard skipped: this harness exposes no llm/stream seam");
+				ctx.logger.warn("[dsh-chatgpt-subscription] reasoning-collapse guard skipped: this harness exposes no event bus");
 				return () => void 0;
 			}
 			return dispose;
@@ -37528,7 +38109,10 @@ function apply(ctx, pluginConfig = {}) {
 			outputVerbosity: () => preferences.status().outputVerbosity,
 			fastMode: () => preferences.status().fastMode,
 			reasoningSummary: () => preferences.status().reasoningSummary
-		}), preferences);
+		}), preferences, (options) => oauth.credentials(void 0, { purpose: "tool" }).then((credentials) => loadCodexCatalog(credentials, {
+			fetchFn: proxyFetch,
+			signal: options?.signal
+		})).catch(() => []));
 		const searchSwitcher = new SearchProviderSwitcher(ctx.loader);
 		const applyWebProviders = (current = preferences.status()) => {
 			const pluginFetch = proxyManager.resolveActiveProxyUrl() !== null;