mslxdff 0.1.194 → 0.1.199

package/docs/cli_help_mini.md

@@ -78,6 +78,7 @@
 | zcode 接入 | `-provider zcode login [--bigmodel]` | ZCode（智谱官方编程工作台）免费额度授权：打印 chat.z.ai 授权链接→浏览器登录→CLI 轮询（`oauth/cli/init`→`poll`）拿 JWT，落盘 `auths/zcode-<uid>.json`+state 并把内置目录（`GLM-5.3`/`GLM-5.3-Flash`/`GLM-5.2`/`GLM-5-Turbo`）并入 allowlist；`zcode/<modelId>` 前缀路由（Anthropic 网关，恒上游 stream，**免验证码**）；`--bigmodel` 切 bigmodel.cn；恒 local-only 不借出 |
 | zcode 额度 | `-provider zcode quota [--json]` | 查 ZCode 套餐名/状态/有效期 + 各模型余量（`billing/balance` 分组表格）；空套餐给领取指引、401 给重登指引 |
 | raccoon 接入 | `-provider raccoon login` | Raccoon（商汤小浣熊）扫码登录：生成 `qrcode_code`→终端二维码 + `login/mp?code=` 链接→**用微信「扫一扫」扫**并确认（浏览器直接打开链接会 404，站点 SPA 无该路由）→轮询拿 token，落盘 `auths/raccoon-<uid>.json`+state（`keys` 一律以文档为准，续期后自愈）并把兜底 6 模型并入 allowlist；`raccoon/<modelId>` 前缀路由（**OpenAI 兼容网关**，**免验证码**）；多号自动轮换：请求内撞积分不足/限流就当场换下一个号，**暂不支持手动指定用哪个号**；积分不足长冷 1h、限流短冷 30s；恒 local-only 不借出 |
+| raccoon 密码登录 | `-provider raccoon login --password` | Raccoon **手机号+密码登录**（多号免扫码）：走 IAM 明文端点（`/api/iam/v1/auth/login/password/phone`，**不用**官方那条要加密手机号的 web 端点）；TTY 下密码**关回显**（逐键 `*`），非 TTY 须 `--password=<密码>`；默认 `--nation 86`；失败给人话（「手机号或密码不正确」），回执回显手机号但**打码**、**不回显密码**；落盘/确认/领奖与扫码登录完全同路 |
 | raccoon 积分 | `-provider raccoon quota [--json]` / `checkin` | 逐号查积分五分项 / 领「桌面端登录奖励」——**这家没有每日签到**：每日 300 与注册礼包 3000 由服务端自动发（无端点，每日 300 当天 23:59:59 清零），唯一要领的登录奖励 3000 是**每号一次性**且 `login` 时已自动领掉，`checkin` 只是补领兜底；判据只认账单、不认上游 `code:0`（重复领会虚回成功）；未登录给 login 指引；daemon 每日 09:00 兜底扫描未领过的号（`MSLXDFF_RACCOON_CHECKIN=0` 关，`_CHECKIN_HOUR` 改点） |
 | WorkBuddy 成长任务 | `-workbuddy growth [--json]` / `-wb growth` | 成长任务全自动（拉列表→参与→触发→领奖，串行 1.2s/1s，已领幂等跳过）；可自动 `chat_5`/`automation_1`/`skill_1`/`Model_chat_GLM5.2`，需客户端任务标 MANUAL 不发包；daemon 每日 09:30 自动（`MSLXDFF_WORKBUDDY_GROWTH=0` 关，`_GROWTH_HOUR`/`_GROWTH_MODEL` 可配） |
 | WorkBuddy 猫猫旅行 | `-workbuddy travel [--json]` / `-wb travel` | 无猫自动同意协议+领养（+300，门槛未达自动补一次对话解锁）；到站领奖 / 空闲派出（location 4）/ 旅行中跳过 |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mslxdff",
-  "version": "0.1.194",
+  "version": "0.1.199",
   "description": "测试项目，请勿使用。",
   "type": "module",
   "bin": {

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

@@ -60,13 +60,15 @@ export async function runSerialTrial(ctx, deps = {}) {
   }
 
   let lastErr = viaRouteLastErr;
-  // 指定 free 模型的同池互备：order 里带了兄弟模型，但只有**额度类**失败才许继续换。
-  // 参数错/5xx/空转等仍按"显式指定即报错"的旧口径收场，别把客户端自己的错伪装成换模型成功。
-  const canFailover = (err) => canFallback && (!poolFallback || isPoolSwitchWorthy(err ?? lastErr));
+  // BUG-42 同池互备判据：poolWorthy 记「本模型直连时被上游判过额度/终局」，接力揉的 502 冲不掉它（详见 ADR-0061）。
+  let poolWorthy = false;
+  const canFailover = (err) =>
+    canFallback && (!poolFallback || isPoolSwitchWorthy(err ?? lastErr) || poolWorthy);
   // 请求级空轮等待累计（跨候选）：阶梯是「每发候选」各算的，不设顶就会 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;
@@ -154,11 +156,11 @@ export async function runSerialTrial(ctx, deps = {}) {
         upBody = upRaw.replace(/\s+/g, " ").slice(0, 400);
         const upMsg = upBody || `upstream ${upRes.status}`;
         lastErr = { model, upstream: upRes, status: upRes.status, message: upMsg };
-        // 终局判决短路（判据与现网取证见 terminal-verdict.js）：上游把「这个模型你别想用」——免费层身份
-        // 闸门 / 模型 id 不存在——写死在错误里时，换组员撞的是同一堵墙（实测组员回同一条 FreeTierError），
-        // 接力只会把 6s 的真相拖成 70s 的 502 "peers failed"。逃生阀 MSLXDFF_TERMINAL_SHORTCIRCUIT=0。
+        // 终局判决短路（判据与现网取证见 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) });

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

@@ -19,12 +19,16 @@
 // 防上游把同一判决挪到 400/404 就失明。
 const FREE_TIER_PATTERNS = [
   /FreeTierError/i,
-  // 额度耗尽（具名判决）。裸 "Rate limit exceeded" 不在此列——那可能只是这一发撞上限流，换号换节点
-  // 就恢复；只有上游**具名**说"你的免费额度用完了"才是对同源组员同样成立的判决。
-  // 实测（errors.log，2026-10-16）：muse-spark / ll-alpha 的 429 体是
-  // `{"error":{"type":"FreeUsageLimitError","message":"Rate limit exceeded..."}}`，旧判据漏掉它
-  // ⇒ 白跑组员接力 70s 才回错。escape hatch 同 MSLXDFF_TERMINAL_SHORTCIRCUIT=0。
-  /FreeUsageLimitError/i,
+  // ⚠ `FreeUsageLimitError` 曾列在此（BUG-8 于 2026-10-16 加入）**现已移除**（2026-10-17 纠正）：
+  // 它是**限额/限流**判决，不是身份闸门。三条独立实证都证明「换出口/换组员就恢复」⇒ 属可接力：
+  //   ① 本仓自测记录（warp-pool/verdict.js:9-10）：同一身份连发 3 次 429 FreeUsageLimitError，
+  //      **身份一换、同一个请求立刻 200**（限额按出口 IP 计）；
+  //   ② warp-pool 的决策表（verdict.js:62）对 429 FreeUsage 明写「强制换出口、跳过冷却」；
+  //   ③ v6 池（v6pool-claim-rotate.test.js:140）同样据它换源地址。
+  // 更根本：ADR-0058 §2 本就把「401/402/**429**/5xx」明列为**可恢复、接力照常**；本文件头 :9-11 也是
+  // 同一口径。BUG-8 把 429 的具名文案判成终局，偏离了本模块自己写下的边界 —— 现网代价是
+  // 组员额度还在、仍被 `peersSkipped:true` 一刀跳过（2026-10-18 events.log 满屏实证）。
+  // 改由 TRANSIENT_MARKERS 显式排除（不依赖 message 里偶然出现的 "rate limit"）。
   // 具名资格判决：上游明说「你没订阅这个模型套餐」。它比 free 层判决更硬——免费层判决还可能随
   // 上游口径变化，套餐缺失则是**换号换节点都不会变**的判决，属本判据射程内却曾被漏判。
   // 实测（errors.log，2026-10-17 两次逐字相同，cline/cline-pass/deepseek-v4.1-flash）：
@@ -56,6 +60,11 @@ const MODEL_GONE_PATTERNS = [
 // 反向护栏：形状像终局但语义是「这个号/这一发不行」，换号换节点可能就好——绝不终局。
 // 只认明确凭据/限流语义词，不收裸 `token`：`max_tokens` 之类的参数报错会被它误判成可接力。
 const TRANSIENT_MARKERS = [
+  // 限额/限流具名判决 ⇒ **可恢复**（换出口换组员就恢复，见 FREE_TIER_PATTERNS 上方三条实证）。
+  // 显式列出而非指望 message 里的 "rate limit" 字样：上游改文案时这层不能跟着失明
+  // （`FreeUsageLimitError` 的类名比它的 message 稳定得多）。
+  // GoUsageLimitError 与它同族（warp-pool/verdict.js:25 把两者并列），同样按出口计、同样可换。
+  /FreeUsageLimitError|GoUsageLimitError/i,
   /security_reject/i,
   /安全校验拒绝/,
   /isQueued/i,

package/src/cli/commands/provider/index.js

@@ -47,6 +47,7 @@ export async function handleProvider(args) {
     console.error("            mslxdff -provider zcode login [--bigmodel]       ZCode 授权（智谱免费额度，Start/Coding Plan）");
     console.error("            mslxdff -provider zcode quota [--json]          查看套餐/余量（未登录给重登指引）");
     console.error("            mslxdff -provider raccoon login                   Raccoon（商汤小浣熊）扫码登录（终端二维码，免验证码）");
+    console.error("            mslxdff -provider raccoon login --password        Raccoon 手机号+密码登录（多号免扫码；密码输入不回显）");
     console.error("            mslxdff -provider raccoon quota|checkin [--json]   查积分余额 / 领每日登录积分");
     console.error("            mslxdff -provider traework login|checkin|quota [--json]  SOLO 国内号：登录 / 每日签到领积分 / 查签到与积分额度（quota 只读，不烧配额）");
     console.error("            mslxdff -provider openrouter clear                remove all keys");

package/src/cli/commands/provider/raccoon-login.js

@@ -9,6 +9,7 @@ import { compatFetch } from "../../../compat.js";
 import {
   buildQrUrl,
   cancelQrSession,
+  confirmRaccoonSession,
   createQrSession,
   fetchRaccoonUserInfo,
   pollQrLogin,
@@ -26,6 +27,15 @@ const RELOGIN_HINT = "   （可重试：mslxdff -provider raccoon login）";
 export async function handleRaccoonLogin(id, sub, rest = [], deps = {}) {
   const pid = normalizeProviderId(id) || String(id || "").toLowerCase();
   if (pid !== "raccoon") return false;
+  // `login --password` 走手机号+密码（多账号免扫码）；无该旗标仍是扫码。分派必须在
+  // LOGIN_SUBS 判定之前，且只在此处转交 —— 扫码路径本身零改动。
+  if (LOGIN_SUBS.has(sub) && rest.some((x) => {
+    const s = String(x);
+    return s === "--password" || s.startsWith("--password=") || s === "-p" || s === "--phone" || s.startsWith("--phone=");
+  })) {
+    const { handleRaccoonPasswordLogin } = await import("./raccoon-password.js");
+    return handleRaccoonPasswordLogin(id, sub, rest, deps);
+  }
   if (!LOGIN_SUBS.has(sub)) return false;
 
   const fetchImpl = deps.fetchImpl || compatFetch;
@@ -92,7 +102,29 @@ export async function handleRaccoonLogin(id, sub, rest = [], deps = {}) {
     return true;
   }
 
-  const credential = out.credential;
+  return await finishRaccoonLogin({ credential: out.credential, fetchImpl, deps, log });
+}
+
+/**
+ * 登录成功后的收尾四步（**扫码与密码两条路共用，单一源**）：
+ * confirm 会话 → 取用户信息 → 落盘 + 补 allowlist → 领一次性登录奖励 → 打印回执。
+ *
+ * 抽出来的理由不只是省行数：这四步的顺序有硬约束（必须先 confirm 才能用 token；领奖必须在
+ * access_token 刚签发的窗口内），任何一条路径自己重写一遍都会漏掉其中一步且难以察觉。
+ *
+ * @param {object} a
+ * @param {object} a.credential 已签发的凭据（两种登录方式同形）
+ * @param {Function} a.fetchImpl
+ * @param {object} a.deps 与原 CLI 依赖注入同形（dir/file/deviceId/saveAccount/claimReward/skipReward/env）
+ * @param {Function} a.log
+ * @param {string} [a.methodNote] 登录方式说明行（如密码登录标注手机号），纯展示
+ * @returns {Promise<boolean>} 恒 true（表示「已处理」，交还 CLI 派发链）
+ */
+export async function finishRaccoonLogin({ credential, fetchImpl, deps = {}, log, methodNote = "" }) {
+  // 新登录的会话是「未确认」状态：不先 POST /iam/confirm，此后所有业务端点（含下面的领奖励、
+  // 以及 daemon 的 chat）都会撞 `400 code 200901 iam_confirm_required`。登录时当场确认一次，
+  // 让落盘的凭据从一开始就是可用的；确认失败不阻断（chat.js 有懒重试兜底），只在末尾如实提示。
+  const confirmed = await confirmRaccoonSession(credential, { fetchImpl });
   const info = await fetchRaccoonUserInfo(credential, { fetchImpl });
   const uid = resolveRaccoonUid({
     userId: info.userId,
@@ -129,7 +161,9 @@ export async function handleRaccoonLogin(id, sub, rest = [], deps = {}) {
 
   log("");
   log(`✅ 登录成功！uid=${uid}  昵称=${info.name || "(空)"}  token=${raccoonTokenFingerprint(credential.access_token)}…`);
+  if (methodNote) log(methodNote);
   log(`   凭据: ${saved.file}`);
+  if (!confirmed) log("   ⚠ 会话确认（iam/confirm）暂未成功 —— 不影响使用（调用时会自动重试确认），若持续报错请重跑 login");
   if (allow.added.length) log(`   allowlist 已补齐 ${allow.added.length} 个模型：${allow.added.join(", ")}`);
   if (reward) {
     const line = {

package/src/cli/commands/provider/raccoon-password.js

@@ -0,0 +1,162 @@
+// mslxdff -provider raccoon login --password —— 手机号 + 密码登录（多账号免扫码）。
+//
+// 为什么需要它：扫码登录一次只能加一个号，且要手机在手边；密码登录可以在同一个终端里
+// 连着把多个号加完（脚本化也行），是「批量补号」的正路。
+//
+// 安全：密码**只经手本进程内存**，绝不落盘、绝不打印、绝不进 argv（除非用户显式 `--password=xxx`，
+// 那种情况会在回执里提示一次「密码已进 shell 历史」）。落盘的是 token，与扫码登录同一条路。
+import { compatFetch } from "../../../compat.js";
+import { loginRaccoonWithPassword, normalizePhone } from "../../../providers/raccoon/password-login.js";
+import { finishRaccoonLogin } from "./raccoon-login.js";
+
+const RELOGIN_HINT = "   （可重试：mslxdff -provider raccoon login --password）";
+
+/**
+ * 从 rest 里取 `--key=value` 或 `--key value` 两种写法。
+ * **裸旗标（无值）返回 undefined**，不是空串 —— 这样 `?? deps.x` 才能正常回落，
+ * 否则 `"" ?? deps.x` 恒取空串，把「只写了 --password 想让程序询问」误判成「显式给了空密码」。
+ */
+function flagValue(rest, ...names) {
+  for (let i = 0; i < rest.length; i++) {
+    const cur = String(rest[i]);
+    for (const name of names) {
+      if (cur === name) {
+        const next = rest[i + 1];
+        return typeof next === "string" && next.length > 0 && !next.startsWith("-") ? next : undefined;
+      }
+      if (cur.startsWith(`${name}=`)) {
+        const v = cur.slice(name.length + 1);
+        return v.length > 0 ? v : undefined;
+      }
+    }
+  }
+  return undefined;
+}
+
+/**
+ * TTY 隐藏输入：**不碰 readline**（它会自己接管 stdin 的原始模式，与我们抢同一份字节），
+ * 直接开 raw mode 逐字符读，每个键回显一个 `*` 给出「确实收到了」的可见反馈。
+ * 非 TTY 返回 null（由调用方转成「必须用 flag」的指引，绝不从管道偷读）。
+ */
+async function promptHidden(label) {
+  if (!process.stdin.isTTY || !process.stdout.isTTY) return null;
+  return await new Promise((resolve) => {
+    const wasRaw = Boolean(process.stdin.isRaw);
+    let buf = "";
+    const done = (value) => {
+      process.stdin.removeListener("data", onData);
+      try { process.stdin.setRawMode(wasRaw); } catch {}
+      process.stdin.pause();
+      process.stdout.write("\n");
+      resolve(value);
+    };
+    const onData = (chunk) => {
+      for (const ch of String(chunk)) {
+        if (ch === "\r" || ch === "\n") return done(buf);
+        if (ch === "\u0003") return done(null); // Ctrl-C
+        if (ch === "\u007f" || ch === "\b") { // 退格
+          if (buf.length > 0) { buf = buf.slice(0, -1); process.stdout.write("\b \b"); }
+          continue;
+        }
+        if (ch < " ") continue; // 忽略其余控制字符
+        buf += ch;
+        process.stdout.write("*");
+      }
+    };
+    process.stdout.write(label);
+    try { process.stdin.setRawMode(true); } catch {}
+    process.stdin.resume();
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", onData);
+  });
+}
+
+async function promptVisible(label) {
+  if (!process.stdin.isTTY || !process.stdout.isTTY) return null;
+  const { createInterface } = await import("../../../readline-compat.js");
+  const rl = createInterface({ input: process.stdin, output: process.stdout, terminal: true });
+  try {
+    return await rl.question(label);
+  } finally {
+    rl.close();
+  }
+}
+
+export async function handleRaccoonPasswordLogin(id, sub, rest = [], deps = {}) {
+  const fetchImpl = deps.fetchImpl || compatFetch;
+  const log = deps.log || ((m) => console.log(m));
+  const exit = deps.exit || ((code) => process.exit(code));
+
+  log("=".repeat(60));
+  log("  Raccoon 登录（商汤小浣熊 · 手机号 + 密码）");
+  log("=".repeat(60));
+  log("");
+
+  let phone = flagValue(rest, "--phone") ?? deps.phone;
+  // `--password` 既是「模式开关」也可携带值：`--password`（裸）→ 交互询问，`--password=xxx` → 直接用。
+  let password = flagValue(rest, "--password", "-p") ?? deps.password;
+  const nationCode = flagValue(rest, "--nation", "--nation-code", "--area") || deps.nationCode || "86";
+
+  if (!phone) {
+    const asked = await promptVisible("  手机号: ");
+    if (asked === null) {
+      log("❌ 非交互环境（非 TTY）无法询问手机号 —— 请用 --phone 传入");
+      log(RELOGIN_HINT);
+      exit(1);
+      return true;
+    }
+    phone = asked;
+  }
+  const cleanPhone = normalizePhone(phone);
+  if (!cleanPhone) {
+    log("❌ 手机号不能为空（只填数字即可）");
+    log(RELOGIN_HINT);
+    exit(1);
+    return true;
+  }
+
+  if (!password) {
+    const asked = await promptHidden("  密码（输入不回显）: ");
+    if (asked === null) {
+      log("❌ 非交互环境（非 TTY）无法安全询问密码 —— 请用 --password 传入");
+      log(RELOGIN_HINT);
+      exit(1);
+      return true;
+    }
+    password = asked;
+  }
+
+  if (String(password || "").length === 0) {
+    log("❌ 密码不能为空");
+    log(RELOGIN_HINT);
+    exit(1);
+    return true;
+  }
+
+  log("🔐 正在登录…");
+  let credential;
+  try {
+    credential = await loginRaccoonWithPassword(
+      { phone: cleanPhone, password, nationCode },
+      { fetchImpl, env: deps.env },
+    );
+  } catch (error) {
+    log("");
+    log(`❌ 登录失败：${error?.message ?? error}`);
+    log(RELOGIN_HINT);
+    exit(1);
+    return true;
+  }
+
+  // 密码已用完，立刻从本进程的作用域里抹掉（降内存残留；不是安全边界，是习惯）
+  password = undefined;
+
+  const masked = cleanPhone.length > 4 ? `${"*".repeat(cleanPhone.length - 4)}${cleanPhone.slice(-4)}` : cleanPhone;
+  return await finishRaccoonLogin({
+    credential,
+    fetchImpl,
+    deps,
+    log,
+    methodNote: `   登录方式: 密码登录（手机号 ${masked}）`,
+  });
+}

package/src/providers/raccoon/chat.js

@@ -11,6 +11,7 @@ import {
 } from "./const.js";
 import { effortFromBody } from "../../thinking-effort.js";
 import { RACCOON_CHAT_ACCEPT, raccoonAuthHeaders } from "./headers.js";
+import { confirmRaccoonSession } from "./login.js";
 import {
   aggregateRaccoonSse,
   classifyRaccoonFailure,
@@ -18,6 +19,9 @@ import {
   raccoonErrorResponse,
 } from "./sse.js";
 
+/** 上游「新会话未确认」闸门码（2026-10-18 取证）：先 POST /iam/confirm 再重试。 */
+const IAM_CONFIRM_REQUIRED = 200901;
+
 /** 首帧窥探上限：超过这个字节数还没形成完整 SSE 帧就不再等（避免慢首包把请求卡住）。 */
 const PEEK_MAX_BYTES = 8192;
 
@@ -144,21 +148,33 @@ export async function forwardRaccoonChat({
   const wireBody = buildRaccoonWireBody(body, { effort, env });
   const modelId = wireBody.model;
 
-  let res;
-  try {
-    res = await fetchImpl(raccoonChatUrl(), {
-      method: "POST",
-      headers: raccoonAuthHeaders(credential, { accept: RACCOON_CHAT_ACCEPT, env }),
-      body: JSON.stringify(wireBody),
-      signal: timeoutSignal(timeoutMs),
-    });
-  } catch (e) {
-    return raccoonErrorResponse({ kind: "server", message: String(e?.message || e).slice(0, 160) });
+  // ⚠ 新会话未确认闸门（2026-10-18 上游改版，与扫码签发同批）：新登录的 token 属于「未确认会话」，
+  //   任何业务端点都先回 `400 {code:200901 iam_confirm_required}`，必须先 POST /iam/confirm 确认一次才放行。
+  //   桌面端旧 token 早已确认故无感 —— 这正是「同一家、旧号能用、新登的号全 400、重登也没用」的根因。
+  //   官方前端做法是「撞 200901 → confirm → 重试原请求」，此处对齐：至多重试一次，防打旋。
+  let res = null;
+  let failPayload = null;
+  for (let attempt = 0; attempt < 2; attempt++) {
+    try {
+      res = await fetchImpl(raccoonChatUrl(), {
+        method: "POST",
+        headers: raccoonAuthHeaders(credential, { accept: RACCOON_CHAT_ACCEPT, env }),
+        body: JSON.stringify(wireBody),
+        signal: timeoutSignal(timeoutMs),
+      });
+    } catch (e) {
+      return raccoonErrorResponse({ kind: "server", message: String(e?.message || e).slice(0, 160) });
+    }
+    if (res.ok) break;
+    failPayload = await res.json().catch(() => null);
+    if (attempt === 0 && res.status === 400 && Number(failPayload?.code) === IAM_CONFIRM_REQUIRED) {
+      if (await confirmRaccoonSession(credential, { fetchImpl, env })) continue; // 确认成功 → 重试一次
+    }
+    break;
   }
 
   if (!res.ok) {
-    const payload = await res.json().catch(() => null);
-    return raccoonErrorResponse({ ...classifyRaccoonFailure(res.status, payload), model: modelId });
+    return raccoonErrorResponse({ ...classifyRaccoonFailure(res.status, failPayload), model: modelId });
   }
 
   // 业务错误惯例：HTTP 200 + JSON 信封（code 非 0）→ 同样按错误分类，不谎报成功

package/src/providers/raccoon/const.js

@@ -23,6 +23,14 @@ export const RACCOON_IAM_PREFIX = "/api/iam/v1";
 export const raccoonModelCatalogUrl = () => `${RACCOON_ORIGIN}${RACCOON_LLM_PREFIX}/model_catalog`;
 export const raccoonChatUrl = () => `${RACCOON_ORIGIN}${RACCOON_LLM_PREFIX}/chat/completions`;
 export const raccoonRefreshUrl = () => `${RACCOON_ORIGIN}${RACCOON_AUTH_PREFIX}/refresh`;
+/**
+ * IAM 会话确认端点（2026-10-18 故障取证 + 官方前端 c6.js 实证）。
+ * 上游把网页/IAM 登录的会话划入「先确认再放行」：新登录的 token 打业务端点回
+ * `400 {"code":200901,"message":"iam_confirm_required"}`，先带 Bearer POST 本端点
+ * （body `{}` 即可）确认会话后业务端点恢复 200。官方前端的处理同样是
+ * 「撞 200901 → confirm(true) → 重试原请求」。
+ */
+export const raccoonIamConfirmUrl = () => `${RACCOON_ORIGIN}${RACCOON_AUTH_PREFIX}/iam/confirm`;
 export const raccoonUserInfoUrl = () => `${RACCOON_ORIGIN}${RACCOON_AUTH_PREFIX}/user_info`;
 export const raccoonBalanceUrl = () => `${RACCOON_ORIGIN}${RACCOON_POINTS_PREFIX}/balance`;
 export const raccoonBillsUrl = (limit = 50) =>
@@ -36,6 +44,31 @@ export const raccoonQrPollUrl = () => `${RACCOON_ORIGIN}${RACCOON_IAM_PREFIX}/au
 /** 取消二维码（PUT，body `{ qrcode_code, status: "canceled" }`）——过期/离开页面时礼貌回收。 */
 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`
+ * ⚠ 密码只在此处作为请求体出现，**绝不落盘、绝不进日志**。
+ */
+export const raccoonPasswordLoginUrl = () => `${RACCOON_ORIGIN}${RACCOON_IAM_PREFIX}/auth/login/password/phone`;
+
+/**
+ * 密码登录失败码 → 人话。命中即抛「可操作」的错误，未命中一律透出上游 message。
+ * 表里只放**实测见过**的码，不臆造（上游加了新码就走 default 兜底）。
+ */
+export const RACCOON_PASSWORD_ERRORS = {
+  AUTH_ACCOUNT_OR_PASSWORD_INVALID: "手机号或密码不正确",
+  AUTH_ACCOUNT_NOT_FOUND: "该手机号未注册过小浣熊（先去官网注册，或改用扫码登录）",
+  AUTH_ACCOUNT_LOCKED: "账号已被锁定，请到官网处理后再试",
+  COMMON_INVALID_ARGUMENT: "登录参数不完整（需要 国家码 + 手机号 + 密码）",
+};
+
 /**
  * 扫码登录深链接：终端编成二维码，**必须用微信「扫一扫」**打开确认。
  * code 与 scan_path 都由 `POST /auth/mp/qrcode` 下发（scan_path 实测为 `/login/mp`），

package/src/providers/raccoon/credits.js

@@ -14,6 +14,7 @@ import {
   raccoonLoginGrantUrl,
 } from "./const.js";
 import { raccoonAuthHeaders } from "./headers.js";
+import { confirmRaccoonSession } from "./login.js";
 import { parseRaccoonEnvelope, raccoonEnvelopeText } from "./envelope.js";
 
 const num = (v) => {
@@ -22,20 +23,33 @@ const num = (v) => {
   return undefined;
 };
 
+/** 上游「新会话未确认」闸门码：先 POST /iam/confirm 再重试一次（与 chat.js 同款兜底）。 */
+const IAM_CONFIRM_REQUIRED = 200901;
+
 async function request(url, { credential, fetchImpl = fetch, env = process.env, method = "GET", body, timeoutMs = RACCOON_REQUEST_TIMEOUT_MS } = {}) {
-  const res = await fetchImpl(url, {
-    method,
-    headers: raccoonAuthHeaders(credential, { env }),
-    ...(body === undefined ? {} : { body: JSON.stringify(body) }),
-    signal: AbortSignal.timeout(timeoutMs),
-  });
-  let parsed;
-  try {
-    parsed = await res.json();
-  } catch {
-    throw new Error(`raccoon: 响应不是 JSON（HTTP ${res.status}）`);
+  const once = async () => {
+    const res = await fetchImpl(url, {
+      method,
+      headers: raccoonAuthHeaders(credential, { env }),
+      ...(body === undefined ? {} : { body: JSON.stringify(body) }),
+      signal: AbortSignal.timeout(timeoutMs),
+    });
+    let parsed;
+    try {
+      parsed = await res.json();
+    } catch {
+      throw new Error(`raccoon: 响应不是 JSON（HTTP ${res.status}）`);
+    }
+    return { res, envelope: parseRaccoonEnvelope(parsed, res.status) };
+  };
+  let { res, envelope } = await once();
+  // 未确认会话闸门：确认一次后重试（老号 / CLI 直连都可能撞上，登录时已确认的号不会走到这）
+  if (res.status === 400 && Number(envelope.code) === IAM_CONFIRM_REQUIRED) {
+    if (await confirmRaccoonSession(credential, { fetchImpl, env })) {
+      ({ res, envelope } = await once());
+    }
   }
-  return parseRaccoonEnvelope(parsed, res.status);
+  return envelope;
 }
 
 /** 余额五分项（缺项即省略，合计优先取上游的 available_points）。 */

package/src/providers/raccoon/login.js

@@ -8,6 +8,7 @@ import {
   RACCOON_LOGIN_POLL_INTERVAL_MS,
   RACCOON_LOGIN_TIMEOUT_MS,
   RACCOON_REQUEST_TIMEOUT_MS,
+  raccoonIamConfirmUrl,
   raccoonQrCancelUrl,
   raccoonQrCreateUrl,
   raccoonQrPageUrl,
@@ -224,6 +225,35 @@ export async function refreshRaccoonCredential(credential, opts = {}) {
   };
 }
 
+/**
+ * IAM 会话确认（POST /api/web/auth/v1/iam/confirm，body `{}`，带 Bearer）。
+ *
+ * 2026-10-18 故障取证：上游新登录的会话未确认前，业务端点一律回
+ * `400 {"code":200901,"message":"iam_confirm_required"}`（桌面端旧会话早已确认，
+ * 所以官方 App 无感）。官方前端（c6.js）的处理是「撞 200901 → confirm → 重试原请求」，
+ * 我们对齐同款：chat.js 兜底重试 + 登录成功后主动确认一次。
+ * 返回是否确认成功；任何失败都吞掉返回 false（由调用方的懒重试兜底，绝不阻断主流程）。
+ */
+export async function confirmRaccoonSession(credential, { fetchImpl = fetch, env = process.env, timeoutMs = RACCOON_REQUEST_TIMEOUT_MS } = {}) {
+  try {
+    const res = await fetchImpl(raccoonIamConfirmUrl(), {
+      method: "POST",
+      headers: raccoonAuthHeaders(credential, { env }),
+      body: "{}",
+      signal: AbortSignal.timeout(timeoutMs),
+    });
+    let parsed = null;
+    try {
+      parsed = await res.json();
+    } catch {
+      parsed = null;
+    }
+    return res.ok && isRaccoonOk(parseRaccoonEnvelope(parsed, res.status));
+  } catch {
+    return false;
+  }
+}
+
 /** 取用户信息（uid/昵称/手机号/office_identity）；任何失败都返回空对象，不阻断登录。 */
 export async function fetchRaccoonUserInfo(credential, opts = {}) {
   const { fetchImpl = fetch, env = process.env, timeoutMs = RACCOON_REQUEST_TIMEOUT_MS } = opts;

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

@@ -0,0 +1,87 @@
+// raccoon 密码登录（手机号 + 密码）—— 多账号自动化添加的捷径（免扫码）。
+// 契约与「为什么不用官方前端那条加密端点」见 const.js 的 raccoonPasswordLoginUrl 注释。
+//
+// ⚠ 安全红线：密码**只作为请求体出现一次**。本模块不落盘、不打印、不记日志；
+//   抛出的错误里也绝不带上请求体原文（上游 message 是它自己的文案，安全）。
+import {
+  RACCOON_PASSWORD_ERRORS,
+  RACCOON_REQUEST_TIMEOUT_MS,
+  raccoonPasswordLoginUrl,
+} from "./const.js";
+import { raccoonAnonymousHeaders } from "./headers.js";
+import { isRaccoonOk, parseRaccoonEnvelope, raccoonEnvelopeText } from "./envelope.js";
+import { decodeJwtExpMs } from "./auth.js";
+
+/** nation_code 归一：接受 `"86"` / `"+86"` / `86`，统一成不带加号的数字串。 */
+export function normalizeNationCode(raw) {
+  const s = String(raw ?? "").trim().replace(/^\+/, "");
+  return /^\d{1,4}$/.test(s) ? s : "";
+}
+
+/** 手机号归一：只留数字（去空格、连字符、括号）。空结果由调用方判错。 */
+export function normalizePhone(raw) {
+  return String(raw ?? "").replace(/[^\d]/g, "");
+}
+
+/** 上游登录失败 → 人话 Error。命中码表用它，否则透出上游 message（绝不带请求体）。 */
+function passwordLoginError(envelope, status) {
+  const key = String(envelope?.code ?? "");
+  const friendly = RACCOON_PASSWORD_ERRORS[key];
+  const err = new Error(`raccoon: 密码登录失败：${friendly || raccoonEnvelopeText(envelope, `HTTP ${status}`)}`);
+  err.code = envelope?.code;
+  err.status = status;
+  return err;
+}
+
+/**
+ * 手机号 + 密码 → credential（与扫码登录**同一形状**，可直接喂 saveRaccoonAccount）。
+ *
+ * 返回 `{ access_token, refresh_token, expires_at?, office_identity? }`；
+ * 失败抛「可操作」的错误（码表命中给人话，未命中透出上游文案）。
+ * 本地校验先于出网：手机号/密码为空当场报错，不白跑一次请求。
+ */
+export async function loginRaccoonWithPassword({ phone, password, nationCode = "86" } = {}, {
+  fetchImpl = fetch,
+  env = process.env,
+  timeoutMs = RACCOON_REQUEST_TIMEOUT_MS,
+} = {}) {
+  const nc = normalizeNationCode(nationCode);
+  const ph = normalizePhone(phone);
+  if (!nc) throw new Error("raccoon: 国家码不合法（用 86 这类数字，或 +86）");
+  if (!ph) throw new Error("raccoon: 手机号不能为空");
+  if (String(password ?? "").length === 0) throw new Error("raccoon: 密码不能为空");
+
+  let res;
+  try {
+    res = await fetchImpl(raccoonPasswordLoginUrl(), {
+      method: "POST",
+      headers: raccoonAnonymousHeaders({ env }),
+      body: JSON.stringify({ nation_code: nc, phone: ph, password: String(password) }),
+      signal: AbortSignal.timeout(timeoutMs),
+    });
+  } catch (error) {
+    throw new Error(`raccoon: 密码登录请求失败：${error?.message ?? error}`);
+  }
+
+  let parsed;
+  try {
+    parsed = await res.json();
+  } catch {
+    throw new Error(`raccoon: 密码登录响应不是 JSON（HTTP ${res.status}）`);
+  }
+  const envelope = parseRaccoonEnvelope(parsed, res.status);
+  if (!isRaccoonOk(envelope)) throw passwordLoginError(envelope, res.status);
+
+  const data = envelope.data ?? {};
+  const accessToken = typeof data.access_token === "string" ? data.access_token : "";
+  if (!accessToken) throw new Error("raccoon: 密码登录响应缺少 access_token");
+  const refreshToken = typeof data.refresh_token === "string" ? data.refresh_token : "";
+  const officeIdentity = typeof data.office_identity === "string" ? data.office_identity : "";
+  const expMs = decodeJwtExpMs(accessToken);
+  return {
+    access_token: accessToken,
+    refresh_token: refreshToken,
+    ...(expMs === undefined ? {} : { expires_at: String(expMs) }),
+    ...(officeIdentity ? { office_identity: officeIdentity } : {}),
+  };
+}

package/src/providers/workbuddy/auth.js

@@ -27,6 +27,32 @@ export function isInsufficientStatus(status, bodyText, cached) {
   return false;
 }
 
+// 频率限制：上游「这个号这一秒用量超了」——该换号顶，但**不是**这个号没额度了。
+// 与 isInsufficientStatus 严格分开：后者命中会被 chat.js 把该号余额标 0（永久跳过），
+// 而腾讯 workbuddy 的 6004 是「使用量已超出频率限制，将在 <时间> 重置」+ 中文措辞，
+// 既不含任何英文字样也没有额度码——历史上正是这里不认，导致 429 原样吐给客户端、从不换号。
+// Note: 为什么 6004 必须走独立判定而不是并入 insufficient — 见 .agents/notes/implemented/bug-fix/2026-10-18-workbuddy-6004-rate-limit-rotate.md
+export function isRateLimitedStatus(status, bodyText) {
+  if (status !== 429) return false;
+  const t = String(bodyText || "");
+  if (/"code"\s*:\s*6004\b/.test(t)) return true;
+  const lower = t.toLowerCase();
+  if (lower.includes("frequency limit") || lower.includes("rate limit") || lower.includes("too many requests")) return true;
+  if (t.includes("频率限制") || t.includes("请求过于频繁") || t.includes("使用量已超出")) return true;
+  return false;
+}
+
+// 上游 msg 里的重置时刻（"将在 2026-10-18 21:14:48 UTC+8 重置"）→ 建议冷却毫秒数；
+// 解析不出返回 0，调用方退回到固定冷却档，绝不因此把号判死。
+export function parseRateLimitResetMs(bodyText, clock = Date.now) {
+  const m = String(bodyText || "").match(/(\d{4}-\d{2}-\d{2})[ T](\d{2}:\d{2}:\d{2})\s*(?:UTC\+8)?\s*重置/);
+  if (!m) return 0;
+  const at = Date.parse(`${m[1]}T${m[2]}+08:00`);
+  if (!Number.isFinite(at)) return 0;
+  const ms = at - clock();
+  return ms > 0 ? ms : 0;
+}
+
 export function isAuthError(status, bodyText) {
   if (status === 401 || status === 403) return true;
   const t = String(bodyText || "").toLowerCase();
@@ -35,7 +61,6 @@ export function isAuthError(status, bodyText) {
   if (status === 400 && t.includes("token")) return true;
   return false;
 }
-
 export function createAuthService({
   baseUrl,
   fetchImpl,

package/src/providers/workbuddy/chat.js

@@ -1,5 +1,5 @@
 import { joinUrl } from "../base.js";
-import { isAuthError, isInsufficientStatus } from "./auth.js";
+import { isAuthError, isInsufficientStatus, isRateLimitedStatus, parseRateLimitResetMs } from "./auth.js";
 import { appendRotationLog as defaultAppend } from "./rotation-log.js";
 import { createTransport } from "../../transport/index.js";
 import { dispatcherFetch } from "../../upstream-engine/sdk/attempt.js";
@@ -232,7 +232,23 @@ export function createChatService({
           lastErr = failErr(`workbuddy insufficient for ${uid}: ${txt.slice(0, 120)}`, t0, clock);
           continue;
         }
-        res = rewrapBody(res, txt);
+        // 频率限制（腾讯 code 6004）：这个号撞了限流，但**额度还在**（total 可能还有几千点）。
+        // 必须换下一个号顶，且绝不能 setBalance(total:0) —— 那会把好号永久跳过，
+        // 是「429 原样吐回客户端、从不换号」在 2026-10-17 实锤的那条老路。
+        // Note: 6004 的判据与冷却分档 — 见 .agents/notes/implemented/bug-fix/2026-10-18-workbuddy-6004-rate-limit-rotate.md
+        if (isRateLimitedStatus(res.status, txt)) {
+          const resetMs = parseRateLimitResetMs(txt, clock);
+          // 冷却时长取「上游给的重置时刻」与固定下限的较大者；解析不出就只按固定档，
+          // 且**封顶 10 分钟**：6004 的重置时间可能远在数小时后，照抄会把号冻到下班。
+          const coolMs = Math.min(Math.max(resetMs || 0, cooldownMs), 10 * 60_000);
+          try { activeRing.onError(key, coolMs); } catch {}
+          doLog({ uid, model: _modelVal, totalMs: Math.round(nowMs(clock) - t0), balanceHit: false, error: `rate-limited(${coolMs}ms) ${txt.slice(0, 120)}` });
+          lastErr = failErr(`workbuddy rate limited for ${uid}: ${txt.slice(0, 120)}`, t0, clock);
+          if (activeRing.available() > 0) continue;
+          res = rewrapBody(res, txt);
+        } else {
+          res = rewrapBody(res, txt);
+        }
       }
       if (res.status === 401 || res.status === 403 || res.status === 429 || res.status >= 500) try { activeRing.onError(key); } catch {}
       res = withUidHeader(res, uid);

package/src/providers/workbuddy/index.js

@@ -213,5 +213,5 @@ export function createWorkbuddyProvider({
 }
 
 // re-export submodules for tests that import directly
-export { decodeJwtExp, isAuthError, isInsufficientStatus } from "./auth.js";
+export { decodeJwtExp, isAuthError, isInsufficientStatus, isRateLimitedStatus, parseRateLimitResetMs } from "./auth.js";
 export { createBalanceCache } from "./balance.js";