dsh-workbuddy-xdpool 1.7.7 → 1.7.9

package/CHANGELOG.md

@@ -4,6 +4,113 @@
 
 版本号遵循 [语义化版本](https://semver.org/lang/zh-CN/)。
 
+## 1.7.9 — 一个对话只用一个账号，新对话才换人
+
+> 有人反馈：除了「优先模式」，换别的模式都会掉命中率、掉速度。这个观察是对的，而且原因不在你的网络——在账号切换本身。所以这次加了一种新模式，专门解决这件事。
+
+### 为什么换个模式就会掉命中率
+
+上游的 prompt 缓存是按**账号**隔离的，不是按你这个人。
+
+所以「轮换模式」和「均衡模式」每发一条消息都可能换一个账号，对上游来说就是换了一个租户——**整段对话的缓存全部作废，从第一个字重新算**。命中率当然掉，首字延迟当然涨。
+
+而「优先模式」把这一切都押在一个账号上：缓存稳了，速度好了，代价是这个账号的额度会被你一个人用完。
+
+一句话：以前你只能在「额度分摊」和「缓存命中」之间选一个。
+
+### 新增「每对话固定」模式
+
+现在可以两个都要。
+
+规则很简单：**一个对话从头到尾只用一个账号；你新开一个对话，才轮到下一个账号。**
+
+- 同一个对话的每一轮都打同一个账号 → 上游缓存一直是热的 → 命中率和速度都是优先模式的水平。
+- 新对话按顺序铺到下一个账号 → 额度还是分散在几个账号上，不会只烧一个。
+
+卡片上「账号使用方式」里多了一个「每对话固定（推荐）」，点一下就能切。
+
+**默认值仍然是「优先模式」，没有偷偷改你的设置。** 想试新模式，自己点一下；不满意，再点回来。
+
+### 账号被限流或被你关掉，会自动换绑
+
+绑定不是死契。如果这个对话的账号：
+
+- 被上游限流了（只针对当前模型，别的模型照用），
+- 被你在卡片上关掉了，
+- 或者积分到了你设的保留线，
+
+那么这个对话下一轮会自动换到一个能用的账号，并且**以后就固定在新的那个账号上**——不会每轮都重新挑，也不会因为一个账号打盹就让整个对话报错。
+
+### 四种模式怎么选
+
+- **每对话固定**：多个对话同时用，既想省额度又想保住命中率。推荐先试这个。
+- **优先模式**：就一个对话，或者只有一个账号额度够用。缓存最稳。
+- **轮换模式**：不在乎速度，只想让几个账号的积分严格平均地掉。
+- **均衡模式**：随机抽，闲置越久的账号越容易被选中；比轮换更不容易被一个不健康的账号拖住。
+
+### 已知边界
+
+- 绑定只存在内存里，重启 DSH 后就忘了。影响很小：重启只是让每个对话重新认一次账号，之后照样固定。
+- 绑定按**对话的第一条用户消息**区分。两个对话如果第一句话一字不差，会被当成同一个对话、共用账号。这种情况很少见，共用了也没有坏处，只是共享一份缓存。
+- 最多记住 200 个对话的绑定，超了会淘汰最久没用过的那个。被淘汰的对话下一轮重新绑定一次，仅此一次，行为不受影响。
+
+## 1.7.8 — 说清楚卡片在哪儿、以及我们支持到哪个版本
+
+> 这次没有功能问题，全在「声明」上：一处把你引到不存在的路径，一处让你以为装错了版本。
+
+### README 的入口路径是 0.1.x 时代的，0.2.0 上按它找不到
+
+README 一直写着「设置 → 插件 → DSH WorkBuddy XD Pool」。**0.2.0 起没有这条二层路径了。**
+
+实际位置是：**打开设置面板 → 顶部平级标签里的「XD Pool」**（排在 `通用设置 / 模型 / 内置插件 / Agent 预设` 后面）。开设置面板的方式是**侧边栏左下角的齿轮**，或快捷键 `Ctrl+Alt+,`。
+
+已把 README 三处改掉，并且**补上了开面板的方法**——只写「切到 XD Pool」而不说怎么开设置，等于没写。老路径保留一句「0.1.x 时代叫这个」，方便升级上来的人理解自己的习惯为什么突然不灵了。
+
+### `engines.dsh` 写着 `<0.2.0`，可它在 0.2.0 上跑得好好的
+
+这个声明的问题不在于"保守"，而在于**它会把人带偏**：任何人按 `engines` 做兼容判断，第一反应都是"这插件不支持 0.2.0"，然后往错误的方向排查。反馈里就有一位因此走了一大圈。
+
+现在放宽到 `<0.3.0`，并且**把三个 host peer 依赖（`dsh-llm` / `dsh-llm-pi-ai` / `dsh-settings`）一起对齐**——它们约束的是同一批宿主包，只改一个反而制造新的不一致。
+
+放宽不等于"什么都接受"：上界仍然卡在 `<0.3.0`，**没测过的大版本不该被默认声称支持**。
+
+### 导航图标匹配不上时，现在会说话
+
+`installNavIcon()` 靠选择器找设置面板里那一行。**找不到时它完全静默** —— 表现就是"图标没出来"，没有任何线索。这次排查里它不是故障点，但它是最贵的一环：**看起来什么都没发生**。
+
+现在连续匹配失败会 `console.warn` 一次，带上选择器、期望的标签、以及**当前导航里实际有什么**：
+
+```
+[dsh-workbuddy-xdpool] the settings nav row could not be found, so the icon was not applied.
+selector="[role=\"dialog\"] nav button" expectedLabel="XD Pool" rowsPresent=["通用设置","模型",...]
+This is cosmetic only — the card itself still works. Please report this line…
+```
+
+**不是每次都喊**：设置面板没打开时找不到是**正常的**（那一行压根不在 DOM 里），每次都喊只会让人学会忽略它。所以只在"面板开着、却连续 N 次找不到"时才报一次，且每轮只报一次。
+
+### 关于那份"0.2.0 删了 slots 服务"的报告
+
+反馈者**自己撤回了**那个结论，我更正一下：**不成立**。
+
+他后来实测到：`__DSH_BOOT__.entries` 含本插件、`importErrors` 为空、客户端 fiber 状态是 ACTIVE、卡片 DOM 完整渲染、`installNavIcon` 正常生效。而且**把 `dsh.client.inject` 改掉再测，行为完全一致** —— 所以那两个包的声明**不会阻断加载，不需要改**。
+
+他复盘出的两个方法论坑，我认为值得原样记下来，因为它们非常容易重犯：
+- 只用正则扫「谁 `provide("name")` 了服务」，漏掉别的声明写法，就宣布服务被删了 —— **典型的假阴性**；
+- 在**会话页**（设置面板没开）dump DOM 搜插件节点，0 命中当成故障证据 —— 而 `settings.section` **只在面板打开时才进 DOM**，0 命中是必然的。
+
+`slots` 和 `settings.section` 在 0.2.0 里都健在，渲染方是 `dsh-client-ui-settings-general` 的 `renderSlot("settings.section", …)`。
+
+### 验证
+
+- 类型检查全绿，测试 **332 项全绿**（+7）。
+- 新增 `tests/compatibility-declaration.test.ts`：`engines.dsh` 必须容纳 0.2.x、**上界仍要卡住没测过的大版本**、三个 host peer 与 `engines.dsh` 保持一致、README **不得再把老路径当指引**（但允许作为历史说明出现）、必须写出开设置面板的方法。
+- **反向验证**：把 `engines` 退回 `<0.2.0` → 2 项变红；把 README 退回老路径 → 1 项变红。
+- 本机核对宿主代码：`renderSlot("settings.section", { close }, { only: active })` 确为**平级渲染**，插件注册 `order: 440`（排最后），与反馈的实测描述一致。
+
+### 一点说明
+
+我本机是 DSH Desktop 2.0.15（内核 0.1.7-rc.2），**不是 0.2.0-rc.2**，所以我**没法在本地复现 0.2.0 的渲染行为**。本次改动依据的是反馈者提供的实测数据，外加我对本机宿主代码里 `renderSlot` 调用的核对。放宽 `engines` 这个结论我是采信的，但没有在 0.2.0 上亲手验过。
+
 ## 1.7.7 — 别再让你为了一个「等一会儿」去重新登录
 
 > 报错说「API 密钥无效」，于是你跑去重新登录 —— 但密钥根本没问题，只是那个模型暂时限流了。

package/README.md

@@ -19,7 +19,7 @@
 
 ## 先看几张图
 
-**插件配置卡片（设置 → 插件 → DSH WorkBuddy XD Pool）**
+**插件配置卡片（设置 → 「XD Pool」一节）**
 
 ![WorkBuddy 池设置卡片：国内版 / 国际版切换栏、池健康状态、账号面板、积分包与合计、每账号每日签到、积分自动化面板、模型管理](assets/settings-card.png)
 
@@ -42,6 +42,7 @@
 - **零配置**：装上、打开，就完事了。WorkBuddy 桌面 App 里每个登过的账号都会被自动发现并入池，不需要在插件里录任何东西。
 
 - **自动容错换号**：池子记着每个账号的限流状态。某个号触发 429 就冷却它，后面的请求自动落到下一个健康的号上；冷却结束自动恢复。所有号都在冷却时，请求才排队等待。
+- **四种账号分配方式**：`priority` 先用完一个号；`round-robin` 按顺序轮换；`balanced` 随机抽、偏向闲置久的；`sticky` 让**一个对话只用一个账号，新对话才换下一个**——上游缓存按账号隔离，中途换号等于把整段对话的缓存作废，`sticky` 就是为这件事准备的。卡片上点一下即可切换，默认仍是 `priority`。
 
 - **池健康一眼看清**：卡片显示「几个账号 / 几个在冷却」「下一个会轮到谁」，以及每个账号的令牌有效期和冷却倒计时。
 
@@ -83,9 +84,13 @@
 
 ## 安装
 
-前置条件：装好 WorkBuddy 桌面 App 并登录（插件复用它存在本机的登录状态）。多账号 = 在桌面 App 里换着登几次，每次登录都会被自动吸进池里。已针对 DSH Desktop host `0.1.2` 适配。
+前置条件：装好 WorkBuddy 桌面 App 并登录（插件复用它存在本机的登录状态）。多账号 = 在桌面 App 里换着登几次，每次登录都会被自动吸进池里。
 
-> 兼容 host `0.1.1-rc.2` / `0.1.2` 系列：安装设置节时会按 host 能力自动选择 `settings.installSection`（0.1.2-rc.1+）或更早的自由函数写法。
+> 兼容 host `0.1.1-rc.2` 起的整个 0.1.x 系列，以及 `0.2.0-rc.2`。安装设置节时会按 host 能力自动选择 `settings.installSection`（0.1.2-rc.1+）或更早的自由函数写法；卡片在 0.2.0 上作为设置面板里一个**平级标签页**渲染。
+
+> **卡片在哪儿打开**：DSH 设置面板本身。开法是**侧边栏左下角的齿轮**，或者快捷键 `Ctrl+Alt+,`。
+> 面板顶部是平级标签：`通用设置 / 模型 / 内置插件 / Agent 预设 / XD Pool` —— 本插件就是最后那个 **XD Pool**。
+> （0.1.x 时代它叫「设置 → 插件 → DSH WorkBuddy XD Pool」，0.2.0 起改成了平级标签，按老路径找不到。）
 
 **方式一：从 npm 安装（推荐）**
 
@@ -129,7 +134,7 @@ pnpm typecheck:client   # 客户端类型检查
 
 > 注意：`pnpm install` 要用 pnpm 11（`npx pnpm@11`），必要时加 `--config.confirmModulesPurge=false --config.minimumReleaseAge=0`——pnpm 11 默认的 `minimumReleaseAge` 供应链年龄策略会拦下刚发布的 rc 包。
 
-装完以后：模型选择器里会出现 **WorkBuddy XD Pool** 分组；设置 → 插件 → **DSH WorkBuddy XD Pool** 能看池健康、各账号的令牌 / 积分 / 签到 / 冷却状态，还有「重新检测账号」「清除所有冷却」按钮和每个账号的签到按钮。
+装完以后：模型选择器里会出现 **WorkBuddy XD Pool** 分组；打开设置面板（左下角齿轮或 `Ctrl+Alt+,`）切到 **XD Pool** 一栏，能看池健康、各账号的令牌 / 积分 / 签到 / 冷却状态，还有「重新检测账号」「清除所有冷却」按钮和每个账号的签到按钮。
 
 Web / TUI profile 也能用（`--profile web` / `--profile dsh-tui`）。
 
@@ -172,12 +177,16 @@ dsh plugin --profile desktop exec dsh-workbuddy-xdpool remove myKey
 | --- | --- | --- |
 | `authFile` | 覆盖 WorkBuddy 桌面 auth 文件路径（跨平台自动探测出问题时用，等同于 `WORKBUDDY_AUTH_FILE`） | 自动探测 |
 | `cooldownMs` | 单账号 429 冷却时长（毫秒） | `60000` |
+| `distribution` | 账号分配方式：`sticky`（每对话固定一个账号，新对话换下一个）/ `priority`（先用完一个）/ `round-robin`（按顺序轮换）/ `balanced`（随机，偏向闲置久的） | `priority` |
+
+> 上游 prompt 缓存按账号隔离，所以对话中途换号会把缓存整段作废。想让多账号同时分摊额度又不想掉命中率，用 `sticky`。
 
 也可以直接写进 `~/.dsh/settings.yaml`：
 
 ```yaml
 workbuddy-xdpool:
   cooldownMs: 120000
+  distribution: sticky
 ```
 
 ## 架构

package/lib/bin.js

@@ -2612,6 +2612,13 @@ function candidateAuthDirs(env = process.env) {
 	return dirs;
 }
 /**
+* How many conversation→account bindings `sticky` mode remembers.
+*
+* Only a memory bound: evicting the oldest binding costs one re-pick on that
+* conversation's next turn, it never loses an account or a request.
+*/
+const STICKY_AFFINITY_LIMIT = 200;
+/**
 * Read-only pool of every discovered WorkBuddy account, with rate-limit
 * cooldown and round-robin failover.
 */
@@ -2660,6 +2667,15 @@ var WorkBuddyAccountPool = class {
 	distribution;
 	/** Cursor for round-robin mode; unused under priority distribution. */
 	cursor = 0;
+	/**
+	* `sticky` mode: conversation key → account id.
+	*
+	* A conversation that keeps the same account also keeps that account's
+	* upstream prompt cache warm — the cache is per tenant, so rotating accounts
+	* mid-conversation pays full prompt cost on every turn. Insertion order is
+	* the LRU order: re-binding deletes then re-inserts.
+	*/
+	affinity = /* @__PURE__ */ new Map();
 	lastScanAtMs = 0;
 	preferredId;
 	/**
@@ -2918,6 +2934,45 @@ var WorkBuddyAccountPool = class {
 		this.cursor = (index + 1) % pool.length;
 		return account;
 	}
+	/** Remember which account a conversation is bound to, keeping LRU order. */
+	bindAffinity(conversationKey, accountId) {
+		this.affinity.delete(conversationKey);
+		this.affinity.set(conversationKey, accountId);
+		while (this.affinity.size > STICKY_AFFINITY_LIMIT) {
+			const oldest = this.affinity.keys().next().value;
+			if (oldest === void 0) break;
+			this.affinity.delete(oldest);
+		}
+	}
+	/**
+	* `sticky`: the account this conversation already used, when it can still
+	* serve the model being asked for.
+	*
+	* Returns `undefined` both when there is no binding and when the binding is
+	* no longer eligible (cooling for this model, disabled, out of credits) — the
+	* caller then rebinds, which is what makes a rate-limited conversation hop to
+	* a fresh account instead of failing.
+	*/
+	affinityAccount(pool, conversationKey) {
+		if (conversationKey === void 0 || conversationKey === "") return void 0;
+		const boundId = this.affinity.get(conversationKey);
+		if (boundId === void 0) return void 0;
+		const bound = pool.find((account) => account.id === boundId);
+		if (bound === void 0) {
+			this.affinity.delete(conversationKey);
+			return;
+		}
+		this.bindAffinity(conversationKey, boundId);
+		return bound;
+	}
+	/** Bindings currently remembered; exposed for tests and diagnostics. */
+	affinitySize() {
+		return this.affinity.size;
+	}
+	/** Forget every conversation binding (tests, and a settings change). */
+	clearAffinity() {
+		this.affinity.clear();
+	}
 	/**
 	* Priority mode: weighted random over the eligible accounts.
 	*
@@ -2956,15 +3011,20 @@ var WorkBuddyAccountPool = class {
 	*   it resumes straight away.
 	* - **round-robin**: consecutive requests rotate through the pool so spend
 	*   spreads evenly across every account.
+	* - **sticky**: one account per conversation, and a new conversation moves to
+	*   the next account in order. Keeps the upstream prompt cache warm within a
+	*   conversation while still spreading spend across conversations.
 	*
-	* In both modes an explicit user selection (`prefer`) heads the list, a
+	* In every mode an explicit user selection (`prefer`) heads the list, a
 	* cooling account is skipped for that model only, and an unrecognised setting
 	* falls back to priority.
 	*
 	* Scans on first use, and rescans when every known account is cooling down: a
 	* fresh desktop login is the usual way out of an exhausted pool.
+	*
+	* `conversationKey` is only consulted under `sticky`; other modes ignore it.
 	*/
-	async acquire(modelId, region) {
+	async acquire(modelId, region, conversationKey) {
 		if (this.accounts.length === 0) await this.scan();
 		let pool = this.available(Date.now(), modelId, region);
 		if (pool.length === 0) {
@@ -2979,8 +3039,16 @@ var WorkBuddyAccountPool = class {
 				return preferred;
 			}
 		}
-		const account = this.distribution === "round-robin" ? this.pickRoundRobin(pool) : this.distribution === "balanced" ? this.pickByWeight(pool) : pool[0];
+		if (this.distribution === "sticky") {
+			const bound = this.affinityAccount(pool, conversationKey);
+			if (bound !== void 0) {
+				await this.ensureFresh(bound);
+				return bound;
+			}
+		}
+		const account = this.distribution === "round-robin" || this.distribution === "sticky" ? this.pickRoundRobin(pool) : this.distribution === "balanced" ? this.pickByWeight(pool) : pool[0];
 		if (account === void 0) return void 0;
+		if (this.distribution === "sticky" && conversationKey !== void 0 && conversationKey !== "") this.bindAffinity(conversationKey, account.id);
 		await this.ensureFresh(account);
 		return account;
 	}
@@ -5080,8 +5148,9 @@ z.object({
 	distribution: asVolatile(z.union([
 		"priority",
 		"round-robin",
-		"balanced"
-	]).default("priority").description("How requests are spread: priority (drain one), round-robin (in order), or balanced (idle-weighted random)")),
+		"balanced",
+		"sticky"
+	]).default("priority").description("How requests are spread: priority (drain one), round-robin (in order), balanced (idle-weighted random), or sticky (one account per conversation, new conversations rotate)")),
 	disabledAccountIds: asVolatile(z.array(z.string()).default([]).description("Account ids excluded from the pool (empty = every discovered account participates)")),
 	creditReserves: asVolatile(z.dict(z.number().step(1).min(0)).default({}).description("Per-account credit floor: stop using an account once its balance reaches this value")),
 	enabledModelIds: asVolatile(z.array(z.string()).default([]).description("Legacy shared model-id list; used by a region that has no per-region selection yet")),

package/lib/client.js

@@ -1304,13 +1304,14 @@ window.__ModuleLoader__.load({
 										}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
 											className: "dsm-workbuddy-xdpool-dist-options",
 											children: [
+												"sticky",
 												"priority",
 												"balanced",
 												"round-robin"
 											].map((option) => {
 												const active = (status.distribution ?? "priority") === option;
-												const label = option === "priority" ? t?.("row.distPriority") ?? "Priority" : option === "balanced" ? t?.("row.distBalanced") ?? "Balanced" : t?.("row.distRoundRobin") ?? "Round-robin";
-												const hint = option === "priority" ? t?.("row.distPriorityHint") ?? "" : option === "balanced" ? t?.("row.distBalancedHint") ?? "" : t?.("row.distRoundRobinHint") ?? "";
+												const label = option === "sticky" ? t?.("row.distSticky") ?? "Per conversation" : option === "priority" ? t?.("row.distPriority") ?? "Priority" : option === "balanced" ? t?.("row.distBalanced") ?? "Balanced" : t?.("row.distRoundRobin") ?? "Round-robin";
+												const hint = option === "sticky" ? t?.("row.distStickyHint") ?? "" : option === "priority" ? t?.("row.distPriorityHint") ?? "" : option === "balanced" ? t?.("row.distBalancedHint") ?? "" : t?.("row.distRoundRobinHint") ?? "";
 												return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("button", {
 													type: "button",
 													role: "radio",
@@ -2282,6 +2283,8 @@ window.__ModuleLoader__.load({
 			"row.distRoundRobinHint": "Take turns in order, spreading the spend evenly",
 			"row.distBalanced": "Balanced",
 			"row.distBalancedHint": "Draw at random, favouring the account idle longest",
+			"row.distSticky": "Per conversation",
+			"row.distStickyHint": "One account per chat, new chats take the next account — keeps the prompt cache warm",
 			"row.resetCooldowns": "Clear all cooldowns",
 			"row.resetCooldownsBusy": "Clearing…",
 			"row.resetCooldownsDone": "Cooldowns cleared",
@@ -2434,6 +2437,8 @@ window.__ModuleLoader__.load({
 			"row.distRoundRobinHint": "按顺序轮流使用，积分均匀分摊",
 			"row.distBalanced": "均衡模式",
 			"row.distBalancedHint": "随机抽取，闲置越久的账号被选中概率越高",
+			"row.distSticky": "每对话固定（推荐）",
+			"row.distStickyHint": "一个对话只用一个账号，新对话自动换下一个账号——保住上游缓存，命中率和速度都更好",
 			"row.resetCooldowns": "清除所有冷却",
 			"row.resetCooldownsBusy": "正在清除…",
 			"row.resetCooldownsDone": "冷却已清除",
@@ -2536,6 +2541,15 @@ window.__ModuleLoader__.load({
 		*/
 		const NAV_ROW_SELECTOR = "[role=\"dialog\"] nav button";
 		/**
+		* How many consecutive in-dialog passes may miss the nav row before the
+		* diagnostic fires.
+		*
+		* Above 1 because a single miss is routine — the shell can re-render between
+		* our mutation callback and the query. Small enough that a genuinely broken
+		* selector is reported within a frame or two of opening the settings panel.
+		*/
+		const NAV_ICON_MISS_THRESHOLD = 3;
+		/**
 		* Draw this page's own glyph in its Settings nav row.
 		*
 		* The `settings.section` contract carries no icon: the shell decides the glyph
@@ -2576,13 +2590,46 @@ window.__ModuleLoader__.load({
 				document.head.appendChild(tag);
 				let disposed = false;
 				let scheduled = false;
+				/**
+				* Consecutive passes that found no matching row.
+				*
+				* A miss is NORMAL most of the time: the settings dialog is closed, so its
+				* nav is not in the DOM at all, and the icon stays unapplied by design.
+				* Warning on the first miss would fire constantly and train everyone to
+				* ignore it.
+				*
+				* What is worth reporting is a PERSISTENT miss while the dialog IS open —
+				* that means the shell's nav markup changed and the selector no longer
+				* matches, which is exactly the failure that looks like "nothing happened"
+				* and cost hours to find. So the threshold is a burst of misses, and the
+				* warning is emitted once per burst rather than once per mutation.
+				*/
+				let missStreak = 0;
+				let warned = false;
 				const sync = () => {
 					scheduled = false;
 					if (disposed) return;
 					const wanted = String(resolveLabel() ?? "").trim();
 					if (wanted === "") return;
-					for (const row of document.querySelectorAll(NAV_ROW_SELECTOR)) if (String(row.textContent ?? "").trim() === wanted) row.setAttribute(NAV_ICON_MARKER, "");
-					else row.removeAttribute(NAV_ICON_MARKER);
+					let matched = 0;
+					for (const row of document.querySelectorAll(NAV_ROW_SELECTOR)) if (String(row.textContent ?? "").trim() === wanted) {
+						row.setAttribute(NAV_ICON_MARKER, "");
+						matched += 1;
+					} else row.removeAttribute(NAV_ICON_MARKER);
+					if (matched > 0) {
+						missStreak = 0;
+						warned = false;
+						return;
+					}
+					if (document.querySelector(NAV_ROW_SELECTOR) === null) {
+						missStreak = 0;
+						return;
+					}
+					missStreak += 1;
+					if (missStreak < NAV_ICON_MISS_THRESHOLD || warned) return;
+					warned = true;
+					const present = [...document.querySelectorAll(NAV_ROW_SELECTOR)].map((row) => String(row.textContent ?? "").trim()).filter((text) => text !== "");
+					console.warn(`[dsh-workbuddy-xdpool] the settings nav row could not be found, so the icon was not applied. selector=${JSON.stringify(NAV_ROW_SELECTOR)} expectedLabel=${JSON.stringify(wanted)} rowsPresent=${JSON.stringify(present)}. This is cosmetic only — the card itself still works. Please report this line so the selector can be updated.`);
 				};
 				const schedule = () => {
 					if (scheduled || disposed) return;

package/lib/index.d.ts

@@ -831,7 +831,7 @@ export declare function workbuddyAccountId(credential: Pick<WorkBuddyCredential,
 /** Every directory the pool should scan, in probe order. */
 export declare function candidateAuthDirs(env?: NodeJS.ProcessEnv): string[];
 /** How the pool chooses which account serves the next request. */
-type AccountDistribution = 'priority' | 'round-robin' | 'balanced';
+type AccountDistribution = 'priority' | 'round-robin' | 'balanced' | 'sticky';
 interface AccountPoolOptions {
   /** Logger for discovery and rotation events. */
   logger?: {
@@ -858,6 +858,9 @@ interface AccountPoolOptions {
    *   queue the moment its window resets.
    * - `round-robin`: consecutive requests rotate through the pool so the
    *   spend spreads evenly.
+   * - `sticky`: one account per conversation, and a new conversation moves to
+   *   the next account in order. Keeps the upstream prompt cache warm inside a
+   *   conversation while still spreading spend across conversations.
    */
   distribution?: AccountDistribution;
 }
@@ -884,6 +887,15 @@ export declare class WorkBuddyAccountPool {
   private distribution;
   /** Cursor for round-robin mode; unused under priority distribution. */
   private cursor;
+  /**
+   * `sticky` mode: conversation key → account id.
+   *
+   * A conversation that keeps the same account also keeps that account's
+   * upstream prompt cache warm — the cache is per tenant, so rotating accounts
+   * mid-conversation pays full prompt cost on every turn. Insertion order is
+   * the LRU order: re-binding deletes then re-inserts.
+   */
+  private readonly affinity;
   private lastScanAtMs;
   private preferredId;
   /**
@@ -1010,6 +1022,22 @@ export declare class WorkBuddyAccountPool {
   };
   /** Round-robin: the legacy cursor walk, kept for the distribution that asks for it. */
   private pickRoundRobin;
+  /** Remember which account a conversation is bound to, keeping LRU order. */
+  private bindAffinity;
+  /**
+   * `sticky`: the account this conversation already used, when it can still
+   * serve the model being asked for.
+   *
+   * Returns `undefined` both when there is no binding and when the binding is
+   * no longer eligible (cooling for this model, disabled, out of credits) — the
+   * caller then rebinds, which is what makes a rate-limited conversation hop to
+   * a fresh account instead of failing.
+   */
+  private affinityAccount;
+  /** Bindings currently remembered; exposed for tests and diagnostics. */
+  affinitySize(): number;
+  /** Forget every conversation binding (tests, and a settings change). */
+  clearAffinity(): void;
   /**
    * Priority mode: weighted random over the eligible accounts.
    *
@@ -1036,15 +1064,20 @@ export declare class WorkBuddyAccountPool {
    *   it resumes straight away.
    * - **round-robin**: consecutive requests rotate through the pool so spend
    *   spreads evenly across every account.
+   * - **sticky**: one account per conversation, and a new conversation moves to
+   *   the next account in order. Keeps the upstream prompt cache warm within a
+   *   conversation while still spreading spend across conversations.
    *
-   * In both modes an explicit user selection (`prefer`) heads the list, a
+   * In every mode an explicit user selection (`prefer`) heads the list, a
    * cooling account is skipped for that model only, and an unrecognised setting
    * falls back to priority.
    *
    * Scans on first use, and rescans when every known account is cooling down: a
    * fresh desktop login is the usual way out of an exhausted pool.
+   *
+   * `conversationKey` is only consulted under `sticky`; other modes ignore it.
    */
-  acquire(modelId?: string, region?: WorkBuddyRegion): Promise<WorkBuddyAccount | undefined>;
+  acquire(modelId?: string, region?: WorkBuddyRegion, conversationKey?: string): Promise<WorkBuddyAccount | undefined>;
   /** Pin the account the plugin card should prefer; tokens stay out of settings. */
   /** How the pool currently spreads requests. Shown on the card. */
   currentDistribution(): AccountDistribution;
@@ -1513,7 +1546,7 @@ interface PoolWebAutomationEarnings {
  */
 type PoolRegion = 'cn' | 'global';
 /** How the pool spreads requests across its accounts. */
-type PoolDistribution = 'priority' | 'round-robin' | 'balanced';
+type PoolDistribution = 'priority' | 'round-robin' | 'balanced' | 'sticky';
 /**
  * The schedule every automation job falls back to.
  *
@@ -2480,10 +2513,15 @@ export interface Config {
    * - `balanced` draws at random, weighting whichever account has been idle
    *   longest. Spend still spreads, but without a fixed order, so one unhealthy
    *   account cannot pin the pool to itself.
+   * - `sticky` gives each conversation one account and moves the next new
+   *   conversation to the next account in order. Rotating accounts inside a
+   *   conversation throws away the upstream prompt cache (it is per tenant), so
+   *   this keeps the cache warm while still spreading spend across
+   *   conversations.
    *
    * Absent reads as `priority`.
    */
-  distribution?: 'priority' | 'round-robin' | 'balanced';
+  distribution?: 'priority' | 'round-robin' | 'balanced' | 'sticky';
   /**
    * Account ids switched off on the card. A disabled account is never picked
    * to serve a request, but it stays in the pool and on the card so it can be

package/lib/index.js

@@ -2720,6 +2720,13 @@ function candidateAuthDirs(env = process.env) {
 	return dirs;
 }
 /**
+* How many conversation→account bindings `sticky` mode remembers.
+*
+* Only a memory bound: evicting the oldest binding costs one re-pick on that
+* conversation's next turn, it never loses an account or a request.
+*/
+const STICKY_AFFINITY_LIMIT = 200;
+/**
 * Read-only pool of every discovered WorkBuddy account, with rate-limit
 * cooldown and round-robin failover.
 */
@@ -2768,6 +2775,15 @@ var WorkBuddyAccountPool = class {
 	distribution;
 	/** Cursor for round-robin mode; unused under priority distribution. */
 	cursor = 0;
+	/**
+	* `sticky` mode: conversation key → account id.
+	*
+	* A conversation that keeps the same account also keeps that account's
+	* upstream prompt cache warm — the cache is per tenant, so rotating accounts
+	* mid-conversation pays full prompt cost on every turn. Insertion order is
+	* the LRU order: re-binding deletes then re-inserts.
+	*/
+	affinity = /* @__PURE__ */ new Map();
 	lastScanAtMs = 0;
 	preferredId;
 	/**
@@ -3026,6 +3042,45 @@ var WorkBuddyAccountPool = class {
 		this.cursor = (index + 1) % pool.length;
 		return account;
 	}
+	/** Remember which account a conversation is bound to, keeping LRU order. */
+	bindAffinity(conversationKey, accountId) {
+		this.affinity.delete(conversationKey);
+		this.affinity.set(conversationKey, accountId);
+		while (this.affinity.size > STICKY_AFFINITY_LIMIT) {
+			const oldest = this.affinity.keys().next().value;
+			if (oldest === void 0) break;
+			this.affinity.delete(oldest);
+		}
+	}
+	/**
+	* `sticky`: the account this conversation already used, when it can still
+	* serve the model being asked for.
+	*
+	* Returns `undefined` both when there is no binding and when the binding is
+	* no longer eligible (cooling for this model, disabled, out of credits) — the
+	* caller then rebinds, which is what makes a rate-limited conversation hop to
+	* a fresh account instead of failing.
+	*/
+	affinityAccount(pool, conversationKey) {
+		if (conversationKey === void 0 || conversationKey === "") return void 0;
+		const boundId = this.affinity.get(conversationKey);
+		if (boundId === void 0) return void 0;
+		const bound = pool.find((account) => account.id === boundId);
+		if (bound === void 0) {
+			this.affinity.delete(conversationKey);
+			return;
+		}
+		this.bindAffinity(conversationKey, boundId);
+		return bound;
+	}
+	/** Bindings currently remembered; exposed for tests and diagnostics. */
+	affinitySize() {
+		return this.affinity.size;
+	}
+	/** Forget every conversation binding (tests, and a settings change). */
+	clearAffinity() {
+		this.affinity.clear();
+	}
 	/**
 	* Priority mode: weighted random over the eligible accounts.
 	*
@@ -3064,15 +3119,20 @@ var WorkBuddyAccountPool = class {
 	*   it resumes straight away.
 	* - **round-robin**: consecutive requests rotate through the pool so spend
 	*   spreads evenly across every account.
+	* - **sticky**: one account per conversation, and a new conversation moves to
+	*   the next account in order. Keeps the upstream prompt cache warm within a
+	*   conversation while still spreading spend across conversations.
 	*
-	* In both modes an explicit user selection (`prefer`) heads the list, a
+	* In every mode an explicit user selection (`prefer`) heads the list, a
 	* cooling account is skipped for that model only, and an unrecognised setting
 	* falls back to priority.
 	*
 	* Scans on first use, and rescans when every known account is cooling down: a
 	* fresh desktop login is the usual way out of an exhausted pool.
+	*
+	* `conversationKey` is only consulted under `sticky`; other modes ignore it.
 	*/
-	async acquire(modelId, region) {
+	async acquire(modelId, region, conversationKey) {
 		if (this.accounts.length === 0) await this.scan();
 		let pool = this.available(Date.now(), modelId, region);
 		if (pool.length === 0) {
@@ -3087,8 +3147,16 @@ var WorkBuddyAccountPool = class {
 				return preferred;
 			}
 		}
-		const account = this.distribution === "round-robin" ? this.pickRoundRobin(pool) : this.distribution === "balanced" ? this.pickByWeight(pool) : pool[0];
+		if (this.distribution === "sticky") {
+			const bound = this.affinityAccount(pool, conversationKey);
+			if (bound !== void 0) {
+				await this.ensureFresh(bound);
+				return bound;
+			}
+		}
+		const account = this.distribution === "round-robin" || this.distribution === "sticky" ? this.pickRoundRobin(pool) : this.distribution === "balanced" ? this.pickByWeight(pool) : pool[0];
 		if (account === void 0) return void 0;
+		if (this.distribution === "sticky" && conversationKey !== void 0 && conversationKey !== "") this.bindAffinity(conversationKey, account.id);
 		await this.ensureFresh(account);
 		return account;
 	}
@@ -5646,6 +5714,34 @@ function requestShape(raw) {
 		return "body was not parseable JSON";
 	}
 }
+/**
+* Stable identity of the conversation a request belongs to, for `sticky`.
+*
+* The FIRST user message is the key: it is the one part of the body that does
+* not change as the history grows, so every turn of a conversation hashes the
+* same way while a new chat (with a different opening message) hashes
+* differently. Hashing rather than storing the text keeps conversation content
+* out of the pool's memory.
+*
+* Two conversations that open with the exact same message share an account —
+* rare, and harmless: it only means they share one account's prompt cache.
+*/
+function conversationKeyOf(raw) {
+	try {
+		const parsed = JSON.parse(raw);
+		if (!Array.isArray(parsed.messages)) return void 0;
+		for (const entry of parsed.messages) {
+			if (typeof entry !== "object" || entry === null) continue;
+			const message = entry;
+			if (message["role"] !== "user") continue;
+			const content = typeof message["content"] === "string" ? message["content"] : JSON.stringify(message["content"] ?? "");
+			return createHash("sha256").update(content).digest("hex").slice(0, 32);
+		}
+		return;
+	} catch {
+		return;
+	}
+}
 function readBody(req) {
 	return new Promise((resolve, reject) => {
 		const chunks = [];
@@ -5775,6 +5871,7 @@ function createWorkBuddyShim(options) {
 		const prepared = client.prepareChatBody(raw);
 		const controller = new AbortController();
 		req.on("close", () => controller.abort());
+		const conversationKey = conversationKeyOf(raw);
 		let modelId;
 		try {
 			const parsed = JSON.parse(raw);
@@ -5786,7 +5883,7 @@ function createWorkBuddyShim(options) {
 		let last;
 		for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
 			if (controller.signal.aborted) return;
-			const account = await pool.acquire(modelId, region);
+			const account = await pool.acquire(modelId, region, conversationKey);
 			if (account === void 0) {
 				const why = pool.unavailableReason(modelId, region);
 				if (why.reason === "cooling") {
@@ -7112,8 +7209,9 @@ const Config = z.object({
 	distribution: asVolatile(z.union([
 		"priority",
 		"round-robin",
-		"balanced"
-	]).default("priority").description("How requests are spread: priority (drain one), round-robin (in order), or balanced (idle-weighted random)")),
+		"balanced",
+		"sticky"
+	]).default("priority").description("How requests are spread: priority (drain one), round-robin (in order), balanced (idle-weighted random), or sticky (one account per conversation, new conversations rotate)")),
 	disabledAccountIds: asVolatile(z.array(z.string()).default([]).description("Account ids excluded from the pool (empty = every discovered account participates)")),
 	creditReserves: asVolatile(z.dict(z.number().step(1).min(0)).default({}).description("Per-account credit floor: stop using an account once its balance reaches this value")),
 	enabledModelIds: asVolatile(z.array(z.string()).default([]).description("Legacy shared model-id list; used by a region that has no per-region selection yet")),

package/package.json

@@ -2,7 +2,7 @@
   "name": "dsh-workbuddy-xdpool",
   "displayName": "DSH WorkBuddy XD Pool",
   "description": "Merge every locally signed-in WorkBuddy account into DeepSeek Harness as one auto-failing-over model pool (multi-account rotation, live credits, daily check-in and model catalog).",
-  "version": "1.7.7",
+  "version": "1.7.9",
   "license": "MIT",
   "author": "XDTrees",
   "homepage": "https://github.com/XDTrees/dsh-workbuddy-xdpool#readme",
@@ -25,7 +25,7 @@
   "type": "module",
   "engines": {
     "node": "^22.19.0 || >=24.0.0",
-    "dsh": ">=0.1.5-rc.1 <0.2.0"
+    "dsh": ">=0.1.5-rc.1 <0.3.0"
   },
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -99,9 +99,9 @@
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.1-rc.1",
-    "@deepseek-ai/dsh-llm": ">=0.1.1-rc.1 <0.2.0",
-    "@deepseek-ai/dsh-llm-pi-ai": ">=0.1.1-rc.1 <0.2.0",
-    "@deepseek-ai/dsh-settings": ">=0.1.1-rc.1 <0.2.0",
+    "@deepseek-ai/dsh-llm": ">=0.1.1-rc.1 <0.3.0",
+    "@deepseek-ai/dsh-llm-pi-ai": ">=0.1.1-rc.1 <0.3.0",
+    "@deepseek-ai/dsh-settings": ">=0.1.1-rc.1 <0.3.0",
     "@deepseek-ai/schemastery": "^3.18.1",
     "@earendil-works/pi-ai": ">=0.82.1"
   },