mslxdff 0.1.200 → 0.1.207

package/src/chat-pipeline/serial-trial.js

@@ -13,7 +13,7 @@ import { shouldUseGroupForModel, isHardLocalOnly, isKeyProviderDirectOnly } from
 import { summarizeRequest, upstreamEcho } from "../model-trace.js";
 import { isEmptyTurnError } from "../routes/chat/relay-pipeline.js";
 import { emptyRetryCfg, emptyRaiseCap, withRaisedMaxTokens, withOutputFloor, emptyNudgeCfg, withEmptyNudge, computeNextDelay, emptyTurnBudgetMs, emptyTurnMinRaiseTo } from "./empty-turn.js";
-import { classifyTerminalUpstream, readVerdictText, terminalShortcircuitOff, isPoolSwitchWorthy } from "./terminal-verdict.js";
+import { classifyTerminalUpstream, readVerdictText, terminalShortcircuitOff } from "./terminal-verdict.js";
 
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 
@@ -39,7 +39,7 @@ export async function runSerialTrial(ctx, deps = {}) {
   } = deps;
   const {
     order, reqId, requested, body, hops, useAuto, lockModel, plugins,
-    auto, upstream, peers, groups, bus, token, canFallback, canForwardPeers, poolFallback,
+    auto, upstream, peers, groups, bus, token, canFallback, canForwardPeers,
     perf0, stages, mark, evt, logCall, logError, done, handlerCtx,
     res, startedAt, logs,
   } = ctx;
@@ -60,15 +60,13 @@ export async function runSerialTrial(ctx, deps = {}) {
   }
 
   let lastErr = viaRouteLastErr;
-  // BUG-42 同池互备判据：poolWorthy 记「本模型直连时被上游判过额度/终局」，接力揉的 502 冲不掉它（详见 ADR-0061）。
-  let poolWorthy = false;
-  const canFailover = (err) =>
-    canFallback && (!poolFallback || isPoolSwitchWorthy(err ?? lastErr) || poolWorthy);
+  // 指定模型只走单候选（order=[requested]），组员/组长接力在同模型内进行；候选间不换模型。
+  // canFallback 仅对 auto 的多候选生效。poolFallback/"同池互备"已移除：指定模型绝不漂移到别的模型。
+  const canFailover = () => canFallback;
   // 请求级空轮等待累计（跨候选）：阶梯是「每发候选」各算的，不设顶就会 N×(2+8+30) 把客户端吊在门外
   let requestWaitedMs = 0;
   candidate: for (let idx = 0; idx < order.length; idx++) {
     const model = order[idx];
-    poolWorthy = false; // 每候选独立记账：上一发 429 不代表这一发也 429
     handlerCtx.model = model;
     handlerCtx.orderLen = order.length;
     handlerCtx.idx = idx;
@@ -159,8 +157,6 @@ export async function runSerialTrial(ctx, deps = {}) {
         // 终局判决短路（判据与现网取证见 terminal-verdict.js）
         const verdict = classifyTerminalUpstream(upRes.status, upRaw);
         const terminalOn = verdict.terminal && !terminalShortcircuitOff();
-        // BUG-42 记账点：本机直连时上游判过额度/终局 ⇒ 换兄弟有账可依（接力冲不掉，详见 ADR-0061）
-        if (isPoolSwitchWorthy({ status: upRes.status, terminal: verdict.terminal })) poolWorthy = true;
         // 一行话把「判决」与「原文」一起落 errors.log（不分两行：同一发失败在 errors.log 里只该有一条）
         logError(model, upRes.status, `upstream ${upRes.status}${upBody ? ` body=${upBody.slice(0, 300)}` : ""}${terminalOn ? ` · 终局判决 ${verdict.kind}（跳过组员接力）` : ""}`);
         evt("upstream-error", { reqId, model, status: upRes.status, message: upMsg.slice(0, 300), timing: upRes._t ?? null, ...upstreamEcho(upRes) });
@@ -274,7 +270,7 @@ export async function runSerialTrial(ctx, deps = {}) {
         if (br.handled) return { done: true };
       }
     }
-    if (canFailover(lastErr)) { evt("fallback", { reqId, from: model, to: order[idx + 1] ?? null, pool: poolFallback || undefined, reason: lastErr?.message || `upstream ${lastErr?.status ?? 502}` }); continue; }
+    if (canFailover()) { evt("fallback", { reqId, from: model, to: order[idx + 1] ?? null, reason: lastErr?.message || `upstream ${lastErr?.status ?? 502}` }); continue; }
     await exhaustedLocal({ res, body, lastErr, order, handlerCtx: { ...handlerCtx, model, reqId }, evt, logCall, mark, perf0, stages, done, requested, useAuto });
     return { done: true };
   }

package/src/chat-pipeline/terminal-verdict.js

@@ -33,8 +33,7 @@ const FREE_TIER_PATTERNS = [
   // 上游口径变化，套餐缺失则是**换号换节点都不会变**的判决，属本判据射程内却曾被漏判。
   // 实测（errors.log，2026-10-17 两次逐字相同，cline/cline-pass/deepseek-v4.1-flash）：
   // `{"error":{"code":"ENTITLEMENT_ERROR","message":"Error 403: the user is not subscribed to required model plan"}}`
-  // ⇒ 旧版 classifyTerminalUpstream 返回 {terminal:false}，照跑组员接力，且 isPoolSwitchWorthy 也返回 false
-  //   （终局为假 ⇒ 同池互备路径一并关闭），指定 free 模型的调用方只能吃 403 收场。
+  // ⇒ 旧版 classifyTerminalUpstream 返回 {terminal:false}，被误当普通 403 照跑组员接力收场。
   // 文案兜底另收一条：防上游改 code 名后只保留人类可读的 message。
   /ENTITLEMENT_ERROR/i,
   /not subscribed to required model plan/i,
@@ -131,17 +130,3 @@ export function terminalShortcircuitOff(env = process.env) {
   const s = String(raw).trim().toLowerCase();
   return s === "0" || s === "false" || s === "off" || s === "no";
 }
-
-/**
- * 「这一发失败值得换个同池模型再试」vs「换了也一样」的分界（BUG-7 的收窄口径）。
- * 只有额度/判决类失败才允许指定 free 模型横向切同池兄弟：
- *  - 429：免费池的限流几乎都是额度维度，换个模型常能立刻出字；
- *  - terminal（具名额度判决 / 模型 id 不存在）：换兄弟模型可能命中另一个可用 id。
- * 参数错（400）、上游 5xx、fetch 异常一律**不**横向切——那会把「客户端自己发错了」伪装成换模型成功，
- * 也白烧别的模型额度。
- */
-export function isPoolSwitchWorthy(lastErr) {
-  if (!lastErr) return false;
-  if (lastErr.terminal) return true;
-  return Number(lastErr.status) === 429;
-}

package/src/cli/commands/stats.js

@@ -72,7 +72,7 @@ function renderTable(headers, rows, aligns = []) {
 }
 
 function tokenRow(id, r) {
-  return [id, r.requests, fmtTok(r.promptTokens), fmtTok(r.completionTokens), reasoningCell(r), fmtTok(r.totalTokens)];
+  return [id, r.requests, fmtTok(r.promptTokens), fmtTok(r.completionTokens), cacheCell(r), reasoningCell(r), fmtTok(r.totalTokens)];
 }
 
 // 思考列的四态渲染：~ 只跟估算/混合来源；none（未知）显示 —，绝不显示成 0 冒充「不思考」
@@ -82,6 +82,14 @@ function reasoningCell(r) {
   return r.reasoningSource === "estimated" || r.reasoningSource === "mixed" ? `${text}~` : text;
 }
 
+// 缓存命中列：`N (p%)` = 上游上报的缓存读 token ÷ 窗口输入总数（上游 prompt_tokens 含命中）。
+// 窗口内没有任何命中读数（cacheRows=0）显示 —：不拿 0 冒充「这个模型没缓存」。
+function cacheCell(r) {
+  if (!r.cacheRows || !(r.cacheReadTokens > 0)) return "—";
+  const tokens = fmtTok(r.cacheReadTokens);
+  return r.cacheHitRate == null ? tokens : `${tokens} (${(r.cacheHitRate * 100).toFixed(1)}%)`;
+}
+
 function performanceRow(id, r) {
   const samples = Number(r.streamRequests) || 0;
   const ttfb = samples > 0 ? fmtMs(r.avgTtfbMs) : "—"; // 无流式样本时不拿空样本算出的均值糊人
@@ -106,7 +114,7 @@ export function renderStats(report, { hours = null, model = null } = {}) {
   lines.push(`成功请求：${totals.requests} 次 · 模型：${models.length} 个`);
   lines.push("");
   lines.push("Token 用量");
-  lines.push(renderTable(["模型", "请求", "输入", "输出", "思考", "合计"], tokenRows, ["left", right, right, right, right, right]));
+  lines.push(renderTable(["模型", "请求", "输入", "输出", "缓存命中", "思考", "合计"], tokenRows, ["left", right, right, right, right, right, right]));
   lines.push("");
   lines.push("响应性能");
   lines.push(renderTable(["模型", "首字", "总耗时", "速度", "首字样本"], performanceRows, ["left", right, right, right, right]));
@@ -115,6 +123,7 @@ export function renderStats(report, { hours = null, model = null } = {}) {
   lines.push("思考：数值后带 ~ = 按思考字符÷4 估算（上游未上报）；— = 未上报且无可估内容；0 = 上游明确上报本轮无思考。");
   lines.push("首字样本：n/N = 有首字样本数/流式请求数，N=0 时首字显示 —（样本太少的均值不可当全量真值）。");
   lines.push("速度 = 输出 tokens ÷ 生成耗时（总耗时−首字），按窗口加权；只统计成功请求。");
+  lines.push("缓存命中：N (p%) = 上游上报的缓存读 token ÷ 窗口输入总数（上游输入总数含命中）；— = 窗口内没有命中读数（上游未报或确无命中）。");
   lines.push("口径差异：-status / -model stats 的首字仍取自 state 的终生 EMA（按转发入口量），与本表**不同源**。");
   lines.push("范围：只含经 8989 网关的成功请求；不含失败请求和 -chat 直连。");
   const keepDays = usageKeepDays();

package/src/cli/policy.js

@@ -99,11 +99,11 @@ export function slowCooldownMs() {
 }
 export function peerCooldownMs() {
   const n = Number(process.env.MSLXDFF_PEER_COOLDOWN_MS);
-  return Number.isInteger(n) && n > 0 ? n : 30_000;
+  return Number.isInteger(n) && n > 0 ? n : 10_000;
 }
 export function peerLimitCooldownMs() {
   const n = Number(process.env.MSLXDFF_PEER_LIMIT_COOLDOWN_MS);
-  return Number.isInteger(n) && n > 0 ? n : 5 * 60_000;
+  return Number.isInteger(n) && n > 0 ? n : 10 * 60_000;
 }
 export function peerHeatMs() {
   const n = Number(process.env.MSLXDFF_PEER_HEAT_MS);

package/src/metrics.js

@@ -1,4 +1,5 @@
 import { normalizeFullId, toFullId } from "./providers/model-id.js";
+import { cacheReadTokens, cacheWriteTokens } from "./usage/cache-fields.js";
 
 export { normalizeFullId, toFullId };
 
@@ -33,7 +34,15 @@ export function extractUsageFromJson(parsed) {
   // reasoning_tokens 透传
   const rt = u.completion_tokens_details?.reasoning_tokens ?? u.reasoning_tokens;
   if (Number.isFinite(Number(rt))) out.reasoning_tokens = Number(rt);
-  return Object.keys(out).length ? out : null;
+  // 「什么都没报」的判据只看原有三个核心字段：只有缓存字段的空包仍算未报（保持原语义）
+  if (!Object.keys(out).length) return null;
+  // 缓存读数：候选链单一来源 = usage/cache-fields.js（与 /v1/messages 的 usage 翻译同源）。
+  // 命中只在上游真报 >0 时落字段；写入字段存在即落（显式 0 也算已报）——「未知」与「0」必须可区分。
+  const cr = cacheReadTokens(u);
+  if (cr > 0) out.cache_read_input_tokens = cr;
+  const cw = cacheWriteTokens(u);
+  if (cw != null) out.cache_creation_input_tokens = cw;
+  return out;
 }
 
 export function extractUsageFromSseText(sseText) {

package/src/peers.js

@@ -1,7 +1,10 @@
 import { loadPeers, savePeers, loadPeerErrors, savePeerErrors, loadPeerStats, savePeerStats } from "./state.js";
 
-export const DEFAULT_PEER_COOLDOWN_MS = 30_000;
-export const DEFAULT_PEER_LIMIT_COOLDOWN_MS = 5 * 60_000;
+// 组员失败冷却分级（2026-10-18 用户拍板）：
+// 非额度失败（502/5xx/超时，可能几秒就恢复）→ 短冷却 10s，到点自动重新纳入候选、继续挨个重试；
+// 额度类（连续 2 次 429）→ 长冷却 10min（额度当天不会因快重试恢复，反复撞只会白烧配额）。
+export const DEFAULT_PEER_COOLDOWN_MS = 10_000;
+export const DEFAULT_PEER_LIMIT_COOLDOWN_MS = 10 * 60_000;
 export const DEFAULT_PEER_HEAT_MS = 5 * 60_000;
 export const DEFAULT_MAX_HOPS = 3;
 export const DEFAULT_BROADBAND_STALE_MS = 90_000;

package/src/providers/raccoon/const.js

@@ -45,27 +45,42 @@ export const raccoonQrPollUrl = () => `${RACCOON_ORIGIN}${RACCOON_IAM_PREFIX}/au
 export const raccoonQrCancelUrl = () => `${RACCOON_ORIGIN}${RACCOON_IAM_PREFIX}/auth/mp/qrcode`;
 
 /**
- * 密码登录（手机号 + 密码）。**同一 IAM 族的明文端点**。
- * ⚠ 官方前端（app.asar module 726xx → `loginWithPassword`）打的是旧 web 通道
- *   `POST /api/web/auth/v1/login_with_password`，但那条**要求手机号加密**：
- *   明文发送回 `400 100003 params_encryted_error: param phone encrypted error`。
- *   本机实测 IAM 同族端点收**明文**三字段并直通业务校验（错密码回
- *   `401 AUTH_ACCOUNT_OR_PASSWORD_INVALID`），故走这条 —— 不需要复刻官方加密公钥。
- * body 契约（实测逐条确认）：`{ nation_code: "86", phone, password }`
- *   · nation_code 必须是**字符串**（数字 86 与 `+86` 中的数字形式被判 body invalid；`"+86"` 字符串可用）
- *   · 缺 nation_code / 空 phone / 空 password → `400 COMMON_INVALID_ARGUMENT`
+ * 密码登录（手机号 + 密码）—— **走官方前端同款 web 端点，参数须 AES 加密**。
+ *
+ * 端点选择（2026-10-18 真实账号实测三选一）：
+ *   `POST /api/web/auth/v1/login_with_password`（官方前端 `loginWithPassword` 同款）
+ *     → 200 `{code:0, data:{access_token, refresh_token}}` ✅ 与 refresh/chat/credits 同族，且给 refresh_token
+ *   `POST /api/iam/v1/auth/login/password/phone`
+ *     → 200 `{code:"OK", data:{access_token, token_type, expires_at}}` —— **无 refresh_token**，
+ *       token 一过期就得重新输密码，对多号长期使用是硬伤，故弃用。
+ * 两处都要求 phone/password **加密**（算法与 key 见 `crypto.js`）；明文一律回
+ * `AUTH_ACCOUNT_OR_PASSWORD_INVALID`（用「密码错」的口径掩盖「格式错」，极难自查）。
+ *
+ * body 契约：`{ nation_code: "86", phone: <加密>, password: <加密> }`
+ *   · nation_code 是**明文数字字符串**（数字 86 被判 body invalid）
+ *   · phone / password 各自 Base64(IV ‖ AES-128-CFB 密文) —— 见 crypto.js
  * ⚠ 密码只在此处作为请求体出现，**绝不落盘、绝不进日志**。
  */
-export const raccoonPasswordLoginUrl = () => `${RACCOON_ORIGIN}${RACCOON_IAM_PREFIX}/auth/login/password/phone`;
+export const raccoonPasswordLoginUrl = () => `${RACCOON_ORIGIN}${RACCOON_AUTH_PREFIX}/login_with_password`;
+
+/**
+ * 登录参数加密 key（AES-128-CFB）。**上游公开常量**，打包在任意客户端里（app.asar 原文）。
+ * 照抄它只为对齐协议；传输保密性来自 HTTPS，不来自这个 key。
+ */
+export const RACCOON_PASSWORD_ENC_KEY = "senseraccoon2023";
 
 /**
  * 密码登录失败码 → 人话。命中即抛「可操作」的错误，未命中一律透出上游 message。
- * 表里只放**实测见过**的码，不臆造（上游加了新码就走 default 兜底）。
+ * 表里只放**本机实测见过**的码，不臆造（上游加了新码就走 default 兜底透出原文）。
+ *   200004                          —— web 通道（本项目所用）实测：错误密码回
+ *                                      `{code:200004,message:"phone_or_password_verify_error"}`；
+ *                                      该 message 是英文码不是人话，必须靠本表翻译。
+ *   AUTH_ACCOUNT_OR_PASSWORD_INVALID —— IAM 通道同义码（本项目已不用该端点，保留以防回退）。
+ *   COMMON_INVALID_ARGUMENT          —— 缺 nation_code/空字段实测（IAM 通道）。
  */
 export const RACCOON_PASSWORD_ERRORS = {
+  200004: "手机号或密码不正确",
   AUTH_ACCOUNT_OR_PASSWORD_INVALID: "手机号或密码不正确",
-  AUTH_ACCOUNT_NOT_FOUND: "该手机号未注册过小浣熊（先去官网注册，或改用扫码登录）",
-  AUTH_ACCOUNT_LOCKED: "账号已被锁定，请到官网处理后再试",
   COMMON_INVALID_ARGUMENT: "登录参数不完整（需要 国家码 + 手机号 + 密码）",
 };
 

package/src/providers/raccoon/credits.js

@@ -126,7 +126,7 @@ async function readBills(opts) {
 /**
  * 领取「桌面端登录奖励」（每号一次性）。返回三种非抛错结果之一：
  * - `{ claimed: true,  points }`  本次真到账（账单里出现了登录奖励那笔）
- * - `{ claimed: false, alreadyClaimed: true, points }`  历史已领，**且不会去碰写端点**
+ * - `{ claimed: false, alreadyClaimed: true, points }`  历史已领（账单查到，或上游回 `granted:false`）
  * - `{ claimed: false, phantom: true,  points: 0 }`  上游回了 code:0 但账单没有这笔 —— 虚回，如实报未到账
  * - `{ claimed: false, unverified: true, points: 0 }`  账单查不动，无法确认到账（不猜、不谎报）
  * grant 请求本身失败（业务码非 0）且账单也查不到已领 → 抛错（如实透出）。
@@ -145,7 +145,17 @@ export async function claimRaccoonLoginReward({ credential, fetchImpl = fetch, e
     envelope = { code: -1, message: error?.message ?? String(error), status: 0, data: undefined };
   }
 
-  // 无论上游怎么说，一律回账单复查 —— 这是唯一可信的到账凭据。
+  // 上游用 `data.granted` 直接回答「这次到底发没发」—— 这是比账单更权威的判据，优先采信。
+  // `granted === false` ⇒ 本号此前已发过（一次性礼包），**不是「未到账」**。
+  // 为什么不能只靠账单：重度使用的号（如 daemon 正在跑的那个）账单会被「对话消耗」刷满，
+  //   分页窗口里根本翻不到那条陈年 reward_grant —— 此时只信账单就会把「早就领过」
+  //   误报成「上游回执成功但账单查不到 → 未到账」（实测踩到，教训）。
+  // 官方前端同款判据：granted 为真才弹「积分已到账」，为假就静默（见 app.asar grantDesktopLoginPoints 调用点）。
+  if (envelope?.code === 0 && envelope.data?.granted === false) {
+    return { claimed: false, alreadyClaimed: true, points: RACCOON_LOGIN_REWARD_POINTS };
+  }
+
+  // 未给 granted 判据（如上游老版本/测试桩）时回退账单复查 —— 到账凭据仍以账单为准。
   const after = await readBills(opts);
   const landed = after === undefined ? undefined : findLoginRewardInBills(after);
   if (landed) {

package/src/providers/raccoon/crypto.js

@@ -0,0 +1,43 @@
+// raccoon 登录参数加密（手机号 / 密码）—— 单一源。
+//
+// 取证（2026-10-18：app.asar webpack module 68284 原文 + 本机真实账号实测）：
+//   官方登录页拿到输入后先调 `U.yv()` 再拼 body，而 `yv` 的真身就是这段：
+//     function c(e, t = "senseraccoon2023") {
+//       const a = CryptoJS.enc.Utf8.parse(t);
+//       const i = CryptoJS.lib.WordArray.random(16);                    // 随机 IV
+//       const r = CryptoJS.AES.encrypt(e, a, { iv: i, mode: CFB, padding: NoPadding });
+//       return i.concat(r.ciphertext).toString(CryptoJS.enc.Base64);
+//     }
+//   即 **key 与模式都硬编码在前端**：AES-128-CFB、key = "senseraccoon2023"、无 padding，
+//   输出 Base64(IV(16 字节) ‖ 密文)。手机号与密码走的是同一个函数 —— 两个字段都要加密。
+//
+// 为什么必须加密（否则极难自查）：明文发送时服务端解得空串再去比对，一律回
+// `AUTH_ACCOUNT_OR_PASSWORD_INVALID`（"手机号或密码不正确"）—— 用「密码错」的口径
+// 掩盖了「格式错」。本机用真实账号取证：明文 → 401；按本算法加密 → 200。
+// 且只加密手机号、密码留明文也是 401，可证**两个字段都加密**。
+//
+// ⚠ 这个 key 是**上游公开常量**（打包进任意客户端），不是本项目的机密；照抄它只为对齐协议，
+//   不代表传输具备保密性 —— 真正的保护来自 HTTPS，以及本项目「密码不落盘/不打印」的纪律。
+import { createCipheriv, randomBytes } from "node:crypto";
+import { RACCOON_PASSWORD_ENC_KEY } from "./const.js";
+
+const IV_BYTES = 16;
+
+/**
+ * 加密单个登录字段（手机号或密码）→ Base64(IV ‖ AES-128-CFB 密文)。
+ *
+ * 与上游前端**逐位对齐**：同 key、同模式（CFB128，对齐 CryptoJS 的 `mode.CFB`）、
+ * 同 padding（NoPadding —— CFB 是流模式，密文长度恒等于明文长度）、同拼接顺序。
+ * 每次调用生成新的随机 IV（上游亦然）：同一输入两次调用密文不同，这是正确行为。
+ */
+export function raccoonEncryptField(plain, keyStr = RACCOON_PASSWORD_ENC_KEY) {
+  const key = Buffer.from(String(keyStr ?? ""), "utf8");
+  if (key.length !== 16) throw new Error("raccoon: 登录加密 key 必须是 16 字节（AES-128）");
+  const iv = randomBytes(IV_BYTES);
+  const cipher = createCipheriv("aes-128-cfb", key, iv);
+  const body = Buffer.concat([
+    cipher.update(Buffer.from(String(plain ?? ""), "utf8")),
+    cipher.final(),
+  ]);
+  return Buffer.concat([iv, body]).toString("base64");
+}

package/src/providers/raccoon/password-login.js

@@ -1,7 +1,8 @@
 // raccoon 密码登录（手机号 + 密码）—— 多账号自动化添加的捷径（免扫码）。
-// 契约与「为什么不用官方前端那条加密端点」见 const.js 的 raccoonPasswordLoginUrl 注释。
+// 契约、端点选择理由与「为什么必须加密」见 const.js 的 raccoonPasswordLoginUrl 注释；
+// 加密算法与 key 见 crypto.js（单一源）。
 //
-// ⚠ 安全红线：密码**只作为请求体出现一次**。本模块不落盘、不打印、不记日志；
+// ⚠ 安全红线：密码**只作为请求体出现一次**（且出站前已被加密）。本模块不落盘、不打印、不记日志；
 //   抛出的错误里也绝不带上请求体原文（上游 message 是它自己的文案，安全）。
 import {
   RACCOON_PASSWORD_ERRORS,
@@ -11,6 +12,7 @@ import {
 import { raccoonAnonymousHeaders } from "./headers.js";
 import { isRaccoonOk, parseRaccoonEnvelope, raccoonEnvelopeText } from "./envelope.js";
 import { decodeJwtExpMs } from "./auth.js";
+import { raccoonEncryptField } from "./crypto.js";
 
 /** nation_code 归一：接受 `"86"` / `"+86"` / `86`，统一成不带加号的数字串。 */
 export function normalizeNationCode(raw) {
@@ -39,6 +41,9 @@ function passwordLoginError(envelope, status) {
  * 返回 `{ access_token, refresh_token, expires_at?, office_identity? }`；
  * 失败抛「可操作」的错误（码表命中给人话，未命中透出上游文案）。
  * 本地校验先于出网：手机号/密码为空当场报错，不白跑一次请求。
+ *
+ * ⚠ 出站前 phone/password 都经 `raccoonEncryptField` 加密（上游契约，见 const.js）——
+ *   发明文只会换来一句「手机号或密码不正确」，把格式错误伪装成密码错误。
  */
 export async function loginRaccoonWithPassword({ phone, password, nationCode = "86" } = {}, {
   fetchImpl = fetch,
@@ -51,12 +56,20 @@ export async function loginRaccoonWithPassword({ phone, password, nationCode = "
   if (!ph) throw new Error("raccoon: 手机号不能为空");
   if (String(password ?? "").length === 0) throw new Error("raccoon: 密码不能为空");
 
+  // 未知错误码时透出上游 message 而非裸码 —— 上游新旧通道对同一错误的形态不同：
+  // 新 IAM 把 message 放顶层（AUTH_ACCOUNT_OR_PASSWORD_INVALID），旧 web 只有 message/details。
+  const body = {
+    nation_code: nc,
+    phone: raccoonEncryptField(ph),
+    password: raccoonEncryptField(String(password)),
+  };
+
   let res;
   try {
     res = await fetchImpl(raccoonPasswordLoginUrl(), {
       method: "POST",
       headers: raccoonAnonymousHeaders({ env }),
-      body: JSON.stringify({ nation_code: nc, phone: ph, password: String(password) }),
+      body: JSON.stringify(body),
       signal: AbortSignal.timeout(timeoutMs),
     });
   } catch (error) {
@@ -70,6 +83,8 @@ export async function loginRaccoonWithPassword({ phone, password, nationCode = "
     throw new Error(`raccoon: 密码登录响应不是 JSON（HTTP ${res.status}）`);
   }
   const envelope = parseRaccoonEnvelope(parsed, res.status);
+  // 上游把错误码同时塞在 `code` 与 `message`：web 通道 `{code:"AUTH_...",message:"AUTH_..."}`
+  // 时 message 是裸码，不能当人话用 —— 故这里把 code 也纳入，让码表能命中。
   if (!isRaccoonOk(envelope)) throw passwordLoginError(envelope, res.status);
 
   const data = envelope.data ?? {};

package/src/routes/helpers.js

@@ -44,13 +44,23 @@ export function notFound(res) {
   return json(res, 404, { error: "Not Found" });
 }
 
+// 入站请求体读取：**必须先收齐字节再一次性 decode**。
+//
+// 不要写成 `let data = ""; req.on("data", c => data += c)`：`c` 是 Buffer，`+=` 会按**每个 TCP 块**
+// 各自隐式 `toString("utf8")` —— 多字节字符（绝大多数汉字/emoji）被切在块中间时，两半各自解成
+// `U+FFFD`「�」。切块位置随网络随机 ⇒ **同一份请求体不同轮次坏的位置不同**，而这份 body 会原样
+// 转发给上游：从坏点起的字节前缀每轮都变，上游的前缀缓存从那里起永远命中不了。
+// 实测（2026-10-18，raccoon 会话 talk/full 语料）：同一会话相邻两轮的同一条历史消息里
+// 「个」↔「�」来回跳（成 U+FFFD），首差异落在历史 21%–43% 处；命中一次的对照实验里
+// 同前缀两连发 cache_read=384/429，说明上游缓存本来是好的、是被我们这份坏字节废掉的。
 export function readBody(req) {
   return new Promise((resolve, reject) => {
-    let data = "";
-    req.on("data", (c) => (data += c));
+    const chunks = [];
+    req.on("data", (c) => chunks.push(Buffer.isBuffer(c) ? c : Buffer.from(String(c), "utf8")));
     req.on("end", () => {
       try {
-        resolve(data ? JSON.parse(data) : {});
+        const text = Buffer.concat(chunks).toString("utf8");
+        resolve(text ? JSON.parse(text) : {});
       } catch (err) {
         reject(err);
       }

package/src/routes/messages-route.js

@@ -23,6 +23,7 @@ import {
 } from "../anthropic/translate.js";
 import { estimateTokens } from "../anthropic/count-tokens.js";
 import { sseToChatJson } from "../anthropic/sse-aggregate.js";
+import { claudeSessionId } from "../anthropic/session-id.js";
 import {
   detectSearchRequest,
   runWebSearch,
@@ -308,6 +309,15 @@ export async function messagesHandler(ctx) {
   }));
   const pipeline = createChatPipeline(ctx);
   const fakeReq = withBody(req, chatBody);
+  // 会话身份（照抄 cc-switch session.rs:107-231）：Claude Code 把会话 id 放在**请求体 metadata**里
+  // （metadata.user_id 的 JSON session_id / 旧 `_session_` 后缀 / metadata.session_id），只读 header 会漏，
+  // 上游的缓存亲和与粘性路由就拿不到稳定 key ⇒ 每轮换 key。这里补进既有的 x-session-id 通道
+  // （chat-pipeline 已消费该头；不改管线，只影响 /v1/messages）。
+  const sid = claudeSessionId(req.headers, body);
+  if (sid) {
+    fakeReq.headers = { ...fakeReq.headers, "x-session-id": fakeReq.headers?.["x-session-id"] || sid.sessionId };
+    alog("session", JSON.stringify({ source: sid.source, id: sid.sessionId.slice(0, 12) }));
+  }
   // ADR-0055：请求侧 token 估算 thunk（路由层也 memoize，与决策 4「每请求至多算一次」对齐；
   // translator 内部还有一层 memoize，双保险）。
   let estCache;
@@ -336,11 +346,11 @@ export async function messagesHandler(ctx) {
       }
       // 上游偶发非 chat 形状（无 choices）：包成单 text 块，绝不 500（照 responses-route.js 先例）
       if (!Array.isArray(chatJson.choices)) {
-        const r = chatJsonToAnthropic({ choices: [{ message: { content: String(text).slice(0, 8000) } }] }, chatBody.model, { estInput });
+        const r = chatJsonToAnthropic({ choices: [{ message: { content: String(text).slice(0, 8000) } }] }, chatBody.model, { estInput, thinking: emitThinking() });
         alog("done-nonchat", JSON.stringify({ ms: Date.now() - t0, bytes: text.length }));
         return json(res, 200, r);
       }
-      const out = chatJsonToAnthropic(chatJson, chatBody.model, { estInput });
+      const out = chatJsonToAnthropic(chatJson, chatBody.model, { estInput, thinking: emitThinking() });
       alog("done-json", JSON.stringify({ ms: Date.now() - t0, status, blocks: out.content.length, stop: out.stop_reason, usage: out.usage }));
       return json(res, 200, out);
     }

package/src/routes/peers.js

@@ -5,7 +5,6 @@ import { runHook } from "../plugins.js";
 import { buildShareKeysHeader, SHARE_KEYS_HEADER } from "../providers/share-keys.js";
 import { compatFetch, timeoutSignal, getUndici } from "../compat.js";
 
-const PEER_TIMEOUT_MS = 30_000;
 // peer 阶段总预算：三批候选（ordered / orderedByLastError / coolingByLastError）共享同一个
 // 截止时间，而不是每批各吃满一次等头超时。实测最坏路径是三批串行各 30s（≈90s），
 // 客户端表现为"随机转圈"；预算到点即停，把余下时间还给本地兜底。
@@ -21,6 +20,15 @@ import { summarizeRequest } from "../model-trace.js";
 const PEER_BODY_TIMEOUT_MS = 120_000;
 export { PEER_BODY_TIMEOUT_MS };
 
+// undici dispatcher 的「收到响应头」时限（headersTimeout）。**必须与 bodyTimeout 同档**：组员节点
+// 自己也压着响应头等首块（ADR-0043 首块前不 flush），undici 层若是 30s，连接会在组建还没吐头时被
+// 掐成 `fetch failed (UND_ERR_HEADERS_TIMEOUT)` —— 实测三个组员全部精确卡 ~30620ms abort，组网
+// 兜底退化成「每次白等 30s」（BUG-1 的 dispatcher 层残留：当时只改了应用层 abort 定时器，漏了这行）。
+// 提到 120s 不会让请求真的挂 120s：真正的闸门是应用层 peer 阶段总预算（peerStageCtx，缺省 45s），
+// 到点即 abort；undici 只做最后兜底，与本文件 PEER_BODY_TIMEOUT_MS / forwardToPeer 的等待上限同口径。
+const PEER_HEADERS_TIMEOUT_MS = PEER_BODY_TIMEOUT_MS;
+export { PEER_HEADERS_TIMEOUT_MS };
+
 function peerConnectTimeoutMs() {
   const n = Number(process.env.MSLXDFF_PEER_CONNECT_TIMEOUT_MS);
   return Number.isInteger(n) && n > 0 ? n : DEFAULT_PEER_CONNECT_TIMEOUT_MS;
@@ -52,14 +60,14 @@ export function peerStageCtx(ctx = {}) {
 // 连接级超时（DNS + TCP/TLS 握手）：黑洞节点（端口挂起）必须快速失败，
 // 不能占用 30s 的响应超时（曾把一次请求拖到 92s）。仅 undici 可用时生效。
 let peerDispatcher = null;
-function getPeerDispatcher() {
+export function getPeerDispatcher() {
   if (peerDispatcher) return peerDispatcher;
   const { Agent } = getUndici();
   if (!Agent) return null;
   try {
     peerDispatcher = new Agent({
       connect: { timeout: peerConnectTimeoutMs() },
-      headersTimeout: PEER_TIMEOUT_MS,
+      headersTimeout: PEER_HEADERS_TIMEOUT_MS,
       bodyTimeout: PEER_BODY_TIMEOUT_MS,
       keepAliveTimeout: 30_000,
       keepAliveMaxTimeout: 60_000,
@@ -68,6 +76,28 @@ function getPeerDispatcher() {
   return peerDispatcher;
 }
 
+/**
+ * 保热：用**组员转发同一条连接池**（getPeerDispatcher）打 GET /health，把 (本机→组员) 的连接
+ * 保持在温热、且**正是 chat 会复用的那条 socket**（裸 fetch 的全局池热的是另一条，等于白热）。
+ * /health 无鉴权、无副作用、零额度。绝不抛；返回 {ok}。
+ */
+export async function warmPeerHealth(url, { timeoutMs = 5000 } = {}) {
+  const base = String(url || "").replace(/\/+$/, "");
+  if (!base) return { ok: false, error: "no url" };
+  const dispatcher = getPeerDispatcher();
+  try {
+    const res = await compatFetch(`${base}/health`, {
+      headers: { Accept: "application/json" },
+      signal: timeoutSignal(timeoutMs),
+      ...(dispatcher ? { dispatcher } : {}),
+    });
+    try { if (res.body) await res.text().catch(() => {}); } catch {}
+    return { ok: Boolean(res?.ok), status: res?.status };
+  } catch (e) {
+    return { ok: false, error: errMsg(e) };
+  }
+}
+
 // 跨 caller 中继必须剥离 reasoning 加密态：encrypted_content 由上游按 caller（出口）签发，
 // 换个节点转发会被拒（400 "reasoning encrypted_content was not issued to this caller"）。
 // 明文 reasoning_content 保留（不绑定 caller，thinking 模式需要）。

package/src/runtime/bootstrap.js

@@ -37,6 +37,14 @@ export async function startDaemonMain(VERSION) {
   startGroupSync({ peers: ctx.peers, groups: ctx.groups, logs });
   startBroadband({ token: ctx.token, upstream: ctx.upstream });
 
+  // 保热心跳：每 ≤120s 经 **chat 同池**访问每个组员(/health) + 每个 picks 供应商(preheat)，
+  // 防「久未使用 → 首发 fetch failed / 上游冷启动」（现网 2026-10-18 16:16 三组员同时 fetch failed）。
+  {
+    const { startKeepWarm } = await import("./keep-warm.js");
+    const { loadModelPicks } = await import("../state.js");
+    startKeepWarm({ peers: ctx.peers, providers: ctx.providers, upstream: ctx.upstream, logs, loadModelPicks: () => loadModelPicks({}) });
+  }
+
   const { setupAutoUpdate } = await import("./auto-update.js");
   setupAutoUpdate({ VERSION, bus, logs });