mslxdff 0.1.224 → 0.1.226

package/docs/cli_help_mini.md

@@ -80,7 +80,10 @@
 | 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 **手机号+密码登录**（多号免扫码）：走官方同款 `POST /api/web/auth/v1/login_with_password`，**phone/password 须 AES-128-CFB 加密**（key 硬编码于前端，见 `crypto.js`；发明文会报「手机号或密码不正确」）；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 growth [--json]` / `-wb growth` | 成长任务全自动（拉列表→参与→触发→领奖，串行 1.2s/1s，已领幂等跳过）；三种触发通道分派——`growthEvent` 对话（`chat_5`/`automation_1`/`skill_1`/`Model_chat_GLM5.2`）、桌面指纹事件链（`RichMeow_Chat`/`Buddy_App`/`Buddy_App_QQ`/`create_canvas`/`template_5`/`playbook_prompt`）、专家真实对话回执（`expert_5`/`Expert_team_use_3`）；**任务列表与领奖只在 `www.workbuddy.cn` 命中**，accept 前上游不下发 target 须 accept 后重读；仍 MANUAL 的 5 项（`Library_read`/`Expert_lighthouse`/`Hp_Appearance`/`WorkBuddy_Valorant`/`wb_wechat_oa_subscribe_task`）只认客户端真实行为，不空烧对话；daemon 每日 09:30 自动（`MSLXDFF_WORKBUDDY_GROWTH=0` 关，`_GROWTH_HOUR`/`_GROWTH_MODEL` 可配） |
+| WorkBuddy 积分盘点 | `-provider workbuddy quota [--json]` / `credits` / `balance` | **只读**逐号列未领任务（含积分/进度/状态）、连登天数、可兑档位、抽奖次数、未领合计；不发任何写请求 |
+| WorkBuddy 补领 | `-provider workbuddy checkin [--json]` / `claim` | 补领闭环：活跃上报点亮连登 → 兑换 7/14/28 档位 → 抽完全部次数 → 成长任务全量（含桌面/专家通道）；输出到账项数/积分/跳过项/未计分告警 |
+| WorkBuddy 连登 | daemon 每日随成长排程 | **签到不点亮连登**——`streak.days` 只认 `/v2/report` 的 `chat_request_send` 事件；不发则 7/14/28 档位积分与抽奖次数永远拿不到（2026-10-20 实测签到成功但 streak 恒 0） |
 | WorkBuddy 猫猫旅行 | `-workbuddy travel [--json]` / `-wb travel` | 无猫自动同意协议+领养（+300，门槛未达自动补一次对话解锁）；到站领奖 / 空闲派出（location 4）/ 旅行中跳过 |
 | WorkBuddy 余额 | `-workbuddy balance [--json]` / `-wb balance` | 查多号余额（`total/dailyPacks/nextExpire`，TTL 5min） |
 | WorkBuddy 列表 | `-workbuddy list` / `-wb list` | 列账号（`uid/domain/enterpriseId`） |

package/package.json

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

package/src/chat-pipeline/context-forward.js

@@ -0,0 +1,55 @@
+// 转发阶段的上下文闸门编排（从 serial-trial.js 拆出，控单文件 ≤20KB 硬门）。
+//
+// 分工：context-guard.js 做纯判决（估算 token、比上限），本文件做**编排**——把「组员/宽带转发」
+// 整段包起来，闸门一触发就收场，不再落到后面的换路逻辑。
+//
+// 为什么必须在这里停：闸门拦下**不是**上游失败。同一份大上下文换个目标（组员→宽带成员）照样撑爆，
+// 只会白烧另一台机器的额度。故直接以标准 `context_length_exceeded` 收场，让客户端压缩后重试。
+import { json } from "../routes/helpers.js";
+
+/** 闸门产出的失败（finishContextGuard 与各 handler 共用同一个标记）。 */
+export function isContextGuardErr(e) {
+  return Boolean(e && typeof e === "object" && e.contextGuard);
+}
+
+/**
+ * 收场：未 flush 时回标准错误体（客户端据 code 触发压缩）；已 flush（流式已开始）交给既有出口写 in-band 帧。
+ */
+export async function finishContextGuard({
+  res, body, lastErr, order, handlerCtx, evt, logCall, logError, mark, perf0, stages, done,
+  requested, useAuto, model, exhaustedLocal,
+}) {
+  const g = lastErr?.contextGuard || {};
+  evt("context-guard", {
+    reqId: handlerCtx.reqId, model, estimated: g.estimated, limit: g.limit, over: g.over,
+    action: "stop-forwarding",
+  });
+  try { logError(model, 400, lastErr.message); } catch {}
+  if (!res?.headersSent) {
+    return json(res, 400, {
+      error: { type: "invalid_request_error", code: "context_length_exceeded", message: lastErr.message },
+    });
+  }
+  await exhaustedLocal({
+    res, body, lastErr, order,
+    handlerCtx: { ...handlerCtx, model, reqId: handlerCtx.reqId },
+    evt, logCall, mark, perf0, stages, done, requested, useAuto,
+  });
+  return { done: true };
+}
+
+/**
+ * 跑一段转发并在闸门触发时立即收场。
+ * @param {Function} run 真正发起转发的函数（应返回 {handled, lastErr}）
+ * @param {object} ctx 收场所需的上下文（res/body/order/handlerCtx/evt/...）
+ * @returns {Promise<{done:boolean, lastErr?:object}>}
+ */
+export async function forwardOrGuard(run, ctx) {
+  const r = await run();
+  if (r?.handled) return { done: true };
+  if (isContextGuardErr(r?.lastErr)) {
+    await finishContextGuard({ ...ctx, lastErr: r.lastErr });
+    return { done: true };
+  }
+  return { done: false, lastErr: r?.lastErr };
+}

package/src/chat-pipeline/context-guard.js

@@ -0,0 +1,101 @@
+// 转发前上下文预检：本地额度用完要转给组员时，先把「上下文会不会撑爆对方」判掉。
+//
+// 为什么需要（用户定的口径）：各家 free 模型的上下文窗口各不相同、大多在 200k 以下，而网关**没有**
+// 一个可靠的上游窗口数据源 —— 靠模型自报会拿到 1M 这类不实的值（见 context-lookup 的 L4 兜底）。
+// 于是本地出口还有额度时一切正常（本地模型窗口往往更大），一旦额度用完转给组员，同一份大上下文
+// 在对方那里直接 `400 context_length_exceeded`。现网实证：errors.log 里 376 条超限，其中 274 条
+// 来自 broadband（组员执行）、93 条来自 messages、仅 9 条 chat；模型集中在 deepseek-v4.1-flash-free(323)。
+//
+// 设计取舍：**不猜每个模型的确切窗口**，只设一个保守的统一上限（默认 200k）。超了就**不转发**，
+// 让客户端按标准 `context_length_exceeded` 触发自己的压缩流程 —— 这正是「在转发之前触发压缩」。
+// 宁可让客户端多压一次，也不要把一个大上下文白转给组员、烧掉对方额度再撞墙。
+//
+// 与 count-tokens 的关系：估算公式**同源**（../text-tokens.js），不另造第二个读数来源（ADR-0055）。
+// 但计量对象不同：那边是 Anthropic 请求体（system/messages blocks），这边是**已翻译好的 chat body**
+// （messages 数组 + tools），是真正要发给上游的那份，所以单独走一遍计数。
+
+import { createTokenCounter } from "../text-tokens.js";
+
+// 统一保守窗口。取值依据：现网 free 层主流 200k，且错误集中在 -free 模型。
+// 未自报窗口的模型按这个值对外宣称（见 context-lookup 的 L4）；转发前也按它判。
+export const DEFAULT_FORWARD_MAX_CONTEXT_TOKENS = 200_000;
+
+/** 读取转发前上限；`0`/负数 = 关闭预检（退回旧行为：无脑转发）。非法值按默认。 */
+export function forwardMaxContextTokens(env = process.env) {
+  const raw = String(env.MSLXDFF_FORWARD_MAX_CONTEXT_TOKENS ?? "").trim();
+  if (raw === "") return DEFAULT_FORWARD_MAX_CONTEXT_TOKENS;
+  const n = Number(raw);
+  if (!Number.isFinite(n)) return DEFAULT_FORWARD_MAX_CONTEXT_TOKENS;
+  if (n <= 0) return 0;
+  const f = Math.floor(n);
+  // (0,1) 会被 floor 成 0 —— 那等于悄悄关掉闸门，按非法值回默认（同 context-lookup 的取舍）
+  return f > 0 ? f : DEFAULT_FORWARD_MAX_CONTEXT_TOKENS;
+}
+
+// 单条消息的文本面（role 名与 tool_call 参数也算：它们同样占上游上下文）
+function addMessage(counter, m) {
+  if (!m || typeof m !== "object") return;
+  const c = m.content;
+  if (typeof c === "string") counter.add(c);
+  else if (Array.isArray(c)) {
+    for (const p of c) {
+      if (!p || typeof p !== "object") continue;
+      if (typeof p.text === "string") counter.add(p.text);
+      else if (p.type === "image") counter.add("x".repeat(4000)); // 图片按固定面值近似（不吃字符但占真实上下文）
+    }
+  } else if (c != null) counter.add(String(c));
+  if (Array.isArray(m.tool_calls)) {
+    for (const tc of m.tool_calls) {
+      counter.add(String(tc?.function?.name || ""));
+      counter.add(String(tc?.function?.arguments || ""));
+    }
+  }
+}
+
+/**
+ * 估算**已翻译的 chat body** 的输入 token 数。
+ * 逐段喂进同一个计数器再一次性套公式（与 text-tokens 的累计口径一致：逐段各套会乘上「非空至少 1」下限）。
+ */
+export function estimateChatBodyTokens(body = {}) {
+  const counter = createTokenCounter();
+  const messages = Array.isArray(body?.messages) ? body.messages : [];
+  for (const m of messages) addMessage(counter, m);
+  if (Array.isArray(body?.tools) && body.tools.length) {
+    try { counter.add(JSON.stringify(body.tools)); } catch { /* 循环引用等异常：不计工具面 */ }
+  }
+  // tools 的 JSON 里已含 name/description/schema；system 已在 messages 首条里
+  return counter.tokens();
+}
+
+// 同一次请求的 body 对象会在多个出站口被反复判（via-route → peer → broadband），
+// 而大上下文扫描是 O(字符数)。按对象身份缓存，保证「每请求只算一次」（同 ADR-0055 决策 4 的口径）。
+const estimateCache = new WeakMap();
+
+function estimateOnce(body) {
+  if (!body || typeof body !== "object") return estimateChatBodyTokens(body);
+  const hit = estimateCache.get(body);
+  if (hit !== undefined) return hit;
+  const n = estimateChatBodyTokens(body);
+  estimateCache.set(body, n);
+  return n;
+}
+
+/**
+ * 转发前判决。返回 null = 放行；否则给出超限信息（调用方据此短路，**不转发**）。
+ * @param {object} body 已翻译的 chat body
+ * @param {{limit?:number}} opts limit 缺省读 env
+ * @returns {{estimated:number, limit:number, over:number}|null}
+ */
+export function overForwardLimit(body, opts = {}) {
+  const limit = opts.limit === undefined ? forwardMaxContextTokens() : Number(opts.limit) || 0;
+  if (!limit || limit <= 0) return null;
+  const estimated = estimateOnce(body);
+  if (estimated <= limit) return null;
+  return { estimated, limit, over: estimated - limit };
+}
+
+/** 给客户端看的文案：必须含 `context_length_exceeded` 语义，客户端据此触发压缩。 */
+export function contextGuardMessage({ estimated, limit } = {}) {
+  return `context_length_exceeded: 请求约 ${estimated ?? "?"} tokens，超过网关注入的转发上限 ${limit ?? "?"}；`
+    + "本地节点额度已用尽，为避免把同一份上下文转发给组员后再次超限，请先运行 /compact 压缩上下文再重试。";
+}

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

@@ -14,6 +14,7 @@ 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 } from "./terminal-verdict.js";
+import { forwardOrGuard } from "./context-forward.js";
 
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 
@@ -253,21 +254,24 @@ export async function runSerialTrial(ctx, deps = {}) {
       }
       break;
     }
+    // 转发闸门（详见 context-forward.js）：被拦即收场，不许换路重试——同一份大上下文换个目标照样撑爆。
+    const gc = { res, body, order, handlerCtx, evt, logCall, logError, mark, perf0, stages, done, requested, useAuto, model, exhaustedLocal };
     if (canForwardPeers) {
       if (!shouldUseGroupForModel(model)) {
         evt("group-skip", { reqId, model, reason: `${groupSkipReason(model)} (peer)` });
       } else {
-        const pr = await peerRelay({ model, body, lastErr, requested, useAuto, lockModel, auto, peers, handlerCtx, evt, logCall, mark, perf0, attemptStartMs: performance.now(), stages, startedAt, plugins, res });
-        if (pr.handled) return { done: true };
-        if (pr.lastErr) lastErr = pr.lastErr;
+        const fr = await forwardOrGuard(() => peerRelay({ model, body, lastErr, requested, useAuto, lockModel, auto, peers, handlerCtx, evt, logCall, mark, perf0, attemptStartMs: performance.now(), stages, startedAt, plugins, res }), gc);
+        if (fr.done) return fr;
+        lastErr = fr.lastErr ?? lastErr;
       }
     }
     if (groups) {
       if (!shouldUseGroupForModel(model)) {
         evt("group-skip", { reqId, model, reason: `${groupSkipReason(model)} (broadband)` });
       } else {
-        const br = await broadbandRelay({ model, body, hops, lastErr, requested, useAuto, lockModel, auto, groups, token, bus, logs, handlerCtx, evt, mark, perf0, attemptStartMs: performance.now(), stages, res, startedAt, plugins });
-        if (br.handled) return { done: true };
+        const fr = await forwardOrGuard(() => broadbandRelay({ model, body, hops, lastErr, requested, useAuto, lockModel, auto, groups, token, bus, logs, handlerCtx, evt, mark, perf0, attemptStartMs: performance.now(), stages, res, startedAt, plugins }), gc);
+        if (fr.done) return fr;
+        lastErr = fr.lastErr ?? lastErr;
       }
     }
     if (canFailover()) { evt("fallback", { reqId, from: model, to: order[idx + 1] ?? null, reason: lastErr?.message || `upstream ${lastErr?.status ?? 502}` }); continue; }

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

@@ -76,6 +76,8 @@ export async function handleProvider(args) {
   if (await handleClineLogin(id, sub)) return true;
   const { handleWorkbuddyLogin } = await import("./workbuddy-login.js");
   if (await handleWorkbuddyLogin(id, sub, rest)) return true;
+  const { handleWorkbuddyQuota } = await import("./workbuddy-quota.js");
+  if (await handleWorkbuddyQuota(id, sub, rest)) return true;
   const { handleCodeartsLogin } = await import("./codearts-login.js");
   if (await handleCodeartsLogin(id, sub, rest)) return true;
   const { handleTraeworkLogin } = await import("./traework-login.js");

package/src/cli/commands/provider/workbuddy-quota.js

@@ -0,0 +1,154 @@
+// mslxdff -provider workbuddy quota|checkin —— 查还漏领多少积分 / 手动补领
+//
+// 子命令：
+//   quota|credits|balance [--json]  只读：逐号列出未领任务、连登天数、可兑换档位、抽奖次数
+//   checkin|claim                   补领：连登兑换 + 抽奖 + 成长任务闭环（含桌面/专家类）
+//
+// ⚠ 只读口径（2026-10-20 实测）：
+//   - 签到每天成功（code 0）**不等于**连登点亮；连登只认 /v2/report 的
+//     chat_request_send 事件，所以「签到 OK + 连登 0 天」是常态，不是异常。
+//   - 任务列表与领奖只在 www.workbuddy.cn 命中（web 成长中心口径）。
+import { normalizeProviderId } from "../../../providers/model-id.js";
+import { compatFetch } from "../../../compat.js";
+
+const QUOTA_SUBS = new Set(["quota", "credits", "balance"]);
+const CLAIM_SUBS = new Set(["checkin", "claim", "signin"]);
+
+async function loadCreds() {
+  const { loadProviderConfig, loadProviderKeys } = await import("../../../state.js");
+  const cfg = loadProviderConfig("workbuddy") || {};
+  const keys = loadProviderKeys("workbuddy") || [];
+  const authList = Array.isArray(cfg.auths) ? cfg.auths : [];
+  const out = [];
+  for (let i = 0; i < Math.max(keys.length, authList.length); i++) {
+    const a = authList[i] || {};
+    const at = keys[i] || "";
+    if (!a.uid || !at) continue;
+    out.push({ uid: a.uid, at, domain: a.domain, enterpriseId: a.enterpriseId || "" });
+  }
+  return out;
+}
+
+const short = (uid) => String(uid).slice(0, 8);
+
+export async function handleWorkbuddyQuota(id, sub, rest = [], deps = {}) {
+  const pid = normalizeProviderId(id) || String(id || "").toLowerCase();
+  if (pid !== "workbuddy") return false;
+  const s = String(sub || "").toLowerCase();
+  const isClaim = CLAIM_SUBS.has(s);
+  if (!isClaim && !QUOTA_SUBS.has(s)) return false;
+
+  const log = deps.log || ((m) => console.log(m));
+  const exit = deps.exit || ((code) => process.exit(code));
+  const json = rest.includes("--json") || rest.includes("-json");
+  const fetchImpl = deps.fetchImpl || compatFetch;
+  const accounts = await loadCreds();
+  if (!accounts.length) {
+    if (json) log(JSON.stringify({ error: "not_logged_in", hint: "mslxdff -provider workbuddy login" }));
+    else {
+      log("未登录：还没有 workbuddy 账号");
+      log("  先运行: mslxdff -provider workbuddy login");
+    }
+    exit(1);
+    return true;
+  }
+
+  const { growthTasks, runGrowthAccount } = await import("../../../providers/workbuddy/growth.js");
+  const { growthStreak, lotteryChances, reportChatActivity, runStreakBonus } = await import("../../../providers/workbuddy/activity.js");
+
+  const rows = [];
+  for (const a of accounts) {
+    const row = { uid: a.uid, ok: true };
+    try {
+      if (isClaim) {
+        const rep = await reportChatActivity({ ...a, fetchImpl });
+        const sb = await runStreakBonus({ ...a, fetchImpl });
+        const g = await runGrowthAccount({ ...a, fetchImpl });
+        row.activity = rep.ok;
+        row.streak = { days: sb.days, redeemed: sb.redeemed, drawn: sb.drawn, credit: sb.credit, errors: sb.errors };
+        const claimed = g.tasks.filter((t) => t.status === "claimed");
+        row.growth = {
+          credit: g.credit, energy: g.energy,
+          claimed: claimed.map((t) => t.task_code),
+          ignored: g.tasks.filter((t) => t.fired > 0 && !["claimed", "completed"].includes(String(t.status || ""))).map((t) => t.task_code),
+          skipped: g.tasks.filter((t) => t.skipped).length,
+          error: g.error,
+        };
+        row.ok = rep.ok || g.ok;
+      } else {
+        const listed = await growthTasks({ ...a, fetchImpl });
+        const tasks = listed.tasks || [];
+        const pending = tasks.filter((t) => t.accept_status !== "claimed");
+        row.tasksError = listed.ok ? null : listed.msg || "拉取失败";
+        row.pending = pending.map((t) => ({
+          code: t.task_code,
+          credit: Number(t.reward_credit || 0),
+          energy: Number(t.reward_energy || 0),
+          status: t.accept_status,
+          progress: `${t.progress?.current ?? t.current ?? 0}/${t.progress?.target ?? t.target ?? 0}`,
+        }));
+        row.pendingCredit = row.pending.reduce((n, t) => n + t.credit, 0);
+        row.claimed = tasks.filter((t) => t.accept_status === "claimed").length;
+        const st = await growthStreak({ ...a, fetchImpl });
+        row.streak = { days: st.days, tiers: st.tiers, cards: st.cards, error: st.ok ? undefined : st.msg };
+        const lot = await lotteryChances({ ...a, fetchImpl });
+        row.chances = lot.chances;
+        row.ok = !!listed.ok;
+      }
+    } catch (e) {
+      row.ok = false;
+      row.error = String(e?.message || e).slice(0, 160);
+    }
+    rows.push(row);
+  }
+
+  const failed = rows.filter((r) => !r.ok).length;
+
+  if (json) {
+    log(JSON.stringify({ provider: "workbuddy", mode: isClaim ? "claim" : "quota", accounts: rows, ok: rows.length - failed, total: rows.length }));
+    exit(failed === rows.length ? 1 : 0);
+    return true;
+  }
+
+  if (isClaim) {
+    log(`workbuddy 补领 · 共 ${rows.length} 个号`);
+    for (const r of rows) {
+      log(`  [${short(r.uid)}]`);
+      if (r.error) { log(`    ❌ ${r.error}`); continue; }
+      log(`    活跃上报: ${r.activity ? "✓ 已点亮连登" : "✗ 失败"}`);
+      const s = r.streak || {};
+      const tiers = (s.redeemed || []).map((x) => `${x.tier}(+${x.credit}c)`).join(" ") || "-";
+      log(`    连登: ${s.days ?? "?"} 天 · 兑换 ${tiers} · 抽奖 ${s.drawn ?? 0} 次 · +${s.credit ?? 0} 分`);
+      if (s.errors?.length) log(`    ⚠ ${s.errors.join("；")}`);
+      const g = r.growth || {};
+      log(`    成长任务: 到账 ${g.claimed?.length ?? 0} 项 · +${g.credit ?? 0} 分 · 跳过 ${g.skipped ?? 0} 项`);
+      if (g.claimed?.length) log(`      已领: ${g.claimed.join(", ")}`);
+      if (g.ignored?.length) log(`      ⚠ 上报未计分（该任务只认客户端真实行为）: ${g.ignored.join(", ")}`);
+      if (g.error) log(`    ⚠ ${g.error}`);
+    }
+    log("");
+    log("  复核: mslxdff -provider workbuddy quota");
+    exit(failed === rows.length ? 1 : 0);
+    return true;
+  }
+
+  log(`workbuddy 已领 / 未领 · 共 ${rows.length} 个号`);
+  let totalPending = 0;
+  for (const r of rows) {
+    if (r.error) { log(`  [${short(r.uid)}] ❌ ${r.error}`); continue; }
+    totalPending += r.pendingCredit || 0;
+    const st = r.streak || {};
+    const unlocked = (st.tiers || []).filter((t) => !["locked", "claimed"].includes(t.status));
+    log(`  [${short(r.uid)}] 已领 ${r.claimed} 项 · 未领 ${r.pending.length} 项 合计 ${r.pendingCredit} 分`);
+    log(`      连登 ${st.days} 天${st.cards ? ` · 补签卡 ${st.cards}` : ""} · 可兑档位 ${unlocked.map((t) => t.tier).join(",") || "无"} · 抽奖次数 ${r.chances}`);
+    for (const t of r.pending) {
+      log(`      · ${t.code.padEnd(28)} +${String(t.credit).padEnd(4)} c  ${t.status} ${t.progress}`);
+    }
+    if (r.tasksError) log(`      ⚠ 任务列表拉取失败：${r.tasksError}`);
+  }
+  log("");
+  log(`  未领合计 ${totalPending} 分（不含连登档位与抽奖）`);
+  log("  补领: mslxdff -provider workbuddy checkin");
+  exit(failed === rows.length ? 1 : 0);
+  return true;
+}

package/src/providers/workbuddy/activity.js

@@ -0,0 +1,204 @@
+import { randomUUID } from "node:crypto";
+import { compatFetch, timeoutSignal } from "../../compat.js";
+import { growthRequest } from "./growth-api.js";
+// WorkBuddy 每日活跃上报 + 连登管家（兑换档位 + 抽奖）。
+//
+// 为什么不靠签到：实测（2026-10-20，本机三号）签到每天成功（code 0）但
+// GET /activity/growth/streak 的 days 恒为 0 —— 连登只认 /v2/report 的
+// chat_request_send 事件，签到不点亮。连登档位 7/14/28 天的积分、补签卡、
+// 抽奖次数全部拿不到，属于「不报错但持续漏领」。
+//
+// 上报形状照抄客户端（字段宁全勿简，防上游加严）；userId 必填，缺失服务端
+// 200 但静默丢弃。每号每天 1 次即可（按天去重，重复上报无额外收益）。
+
+const REPORT_BASES = ["https://www.codebuddy.cn", "https://copilot.tencent.com"];
+
+function reportHeaders({ at, uid, domain, enterpriseId }) {
+  return {
+    Authorization: `Bearer ${at}`,
+    "Content-Type": "application/json",
+    Accept: "application/json",
+    "X-User-Id": uid,
+    "X-Domain": domain || "www.codebuddy.cn",
+    "X-Product": "SaaS",
+    "User-Agent": "CLI/2.115.0 WorkBuddy/2.115.0",
+    Origin: "https://www.codebuddy.cn",
+    Referer: "https://www.codebuddy.cn/",
+    ...(enterpriseId ? { "X-Enterprise-Id": enterpriseId } : {}),
+  };
+}
+
+export function chatActivityEvent({ uid, conversationId, requestId, model = "deepseek-v4-flash", modelName = "DeepSeek V4 Flash" }) {
+  const now = Date.now();
+  return {
+    eventCode: "chat_request_send",
+    timestamp: now,
+    reportDelay: 0,
+    mode: "craft",
+    conversationId,
+    requestId,
+    inputLength: 12,
+    requestModelId: model,
+    requestModelName: modelName,
+    isPlan: false,
+    isAutoExecuteTerminal: false,
+    isAutoModify: false,
+    codebaseEnable: false,
+    maxToken: 0,
+    maxSteps: 0,
+    temperature: 0,
+    maxRetries: 0,
+    mentionContexts: [],
+    knowledgeId: [],
+    knowledgeName: [],
+    codebaseId: "",
+    mentionContextCount: 0,
+    command: "",
+    expertId: "",
+    recommendId: "",
+    skillId: "",
+    skillCount: 0,
+    totalCount: 0,
+    fileUri: "",
+    presentAt: now,
+    traceId: "",
+    rootRequestId: requestId,
+    parentConversationId: conversationId,
+    agentName: "default",
+    agentType: "conversation",
+    userId: uid,
+  };
+}
+
+// 一条对话活跃上报：点亮当日连登 + 解锁 first_buddy（领养前置）。双域容灾，不抛异常。
+export async function reportChatActivity({ uid, at, domain, enterpriseId, conversationId, requestId, model, modelName, fetchImpl = compatFetch, timeoutMs = 15000 } = {}) {
+  if (!uid || !at) return { ok: false, msg: "缺少 uid / accessToken" };
+  const conv = conversationId || `mslxdff-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  const req = requestId || conv;
+  const body = JSON.stringify([chatActivityEvent({ uid, conversationId: conv, requestId: req, model, modelName })]);
+  let last = { ok: false, msg: "无可用域" };
+  for (const base of REPORT_BASES) {
+    let res;
+    try {
+      res = await fetchImpl(`${base}/v2/report`, {
+        method: "POST",
+        headers: reportHeaders({ at, uid, domain, enterpriseId }),
+        body,
+        signal: timeoutSignal(timeoutMs),
+      });
+    } catch (e) {
+      last = { ok: false, status: 0, msg: `网络失败: ${String(e?.message || e).slice(0, 160)}` };
+      continue;
+    }
+    let j = null;
+    try { j = await res.json(); } catch {}
+    const out = { ok: res.status === 200 && j?.code === 0, status: res.status, code: j?.code, msg: j?.msg || "", base };
+    if (out.ok) return out;
+    // 401/403 是登录态问题，换域也没用
+    if (res.status === 401 || res.status === 403) return { ...out, needRefresh: true };
+    last = out;
+  }
+  return last;
+}
+
+const TIER_KEYS = ["tier_7d", "tier_14d", "tier_28d"];
+
+// 连登完整状态（days / 档位 / 补签卡）。
+export async function growthStreak(api = {}) {
+  const r = await growthRequest({ ...api, method: "GET", path: "/activity/growth/streak" });
+  if (!r.ok) return { ok: false, msg: r.msg || `HTTP ${r.status}`, days: 0, tiers: [], cards: 0 };
+  const data = r.data || {};
+  const rs = data.redemption_status || {};
+  const tiers = TIER_KEYS
+    .map((k) => ({ tier: k.slice(5), status: rs[`${k}_status`] || "", days: Number(rs[`${k}_count`] || 0) }))
+    .filter((t) => t.status);
+  return {
+    ok: true,
+    days: Number(data.streak?.days || 0),
+    monthTotalDays: Number(data.streak?.month_total_days || 0),
+    nextTier: data.streak?.next_tier || "",
+    nextTierRemaining: Number(data.streak?.next_tier_remaining || 0),
+    tiers,
+    cards: Number(data.makeup_cards?.balance || 0),
+    rewards: Array.isArray(rs.tiers) ? rs.tiers : [],
+  };
+}
+
+// 兑换一个已解锁档位（tier: "7d"|"14d"|"28d"）；未解锁上游 403，调用方按 status 跳过即可。
+export async function redeemStreakTier(api = {}, tier) {
+  const r = await growthRequest({
+    ...api,
+    method: "POST",
+    path: "/activity/growth/redeem",
+    body: { tier, client_token: randomUUID() },
+  });
+  return { ok: r.ok, status: r.status, code: r.code, msg: r.msg || "", data: r.data || {} };
+}
+
+export async function lotteryChances(api = {}) {
+  const r = await growthRequest({ ...api, method: "GET", path: "/activity/growth/lottery/summary" });
+  if (!r.ok) return { ok: false, chances: 0, enabled: false, msg: r.msg || `HTTP ${r.status}` };
+  return { ok: true, chances: Number(r.data?.chances || 0), enabled: r.data?.module?.enabled !== false };
+}
+
+export async function lotteryDraw(api = {}) {
+  const r = await growthRequest({
+    ...api,
+    method: "POST",
+    path: "/activity/growth/lottery/draw",
+    body: { client_token: randomUUID() },
+  });
+  return { ok: r.ok, status: r.status, msg: r.msg || "", prize: r.data || null };
+}
+
+// 连登管家闭环：兑换所有已解锁未领取的档位 → 抽完全部次数。幂等，未解锁静默跳过。
+export async function runStreakBonus({ uid, at, domain, enterpriseId, fetchImpl = compatFetch, onStep = null, maxDraws = 20 } = {}) {
+  const api = { uid, at, domain, enterpriseId, fetchImpl };
+  const step = (e) => { try { onStep?.(e); } catch {} };
+  const out = { uid, redeemed: [], drawn: 0, credit: 0, energy: 0, prizes: [], errors: [] };
+
+  const st = await growthStreak(api);
+  if (!st.ok) {
+    out.errors.push(`读连登状态失败：${st.msg}`);
+    return out;
+  }
+  out.days = st.days;
+
+  for (const t of st.tiers) {
+    // locked = 天数不够；claimed = 已领过。其余状态视为可兑换。
+    if (!["locked", "claimed"].includes(String(t.status))) {
+      const r = await redeemStreakTier(api, t.tier);
+      if (r.ok) {
+        const credit = Number(r.data?.credit || 0);
+        const energy = Number(r.data?.energy || 0);
+        out.credit += credit;
+        out.energy += energy;
+        out.redeemed.push({ tier: t.tier, credit, energy });
+        step({ phase: "redeem", ok: true, tier: t.tier, credit, energy });
+      } else {
+        out.errors.push(`兑换 ${t.tier} 失败：${r.msg || `HTTP ${r.status}`}`);
+        step({ phase: "redeem", ok: false, tier: t.tier, msg: r.msg });
+      }
+    }
+  }
+
+  // 每轮重读次数（兑换与抽奖都可能再发次数），抽到 0 或达上限为止。
+  for (;;) {
+    if (out.drawn >= maxDraws) break;
+    const left = (await lotteryChances(api)).chances;
+    if (left <= 0) break;
+    const r = await lotteryDraw(api);
+    if (!r.ok) {
+      out.errors.push(`抽奖失败：${r.msg || `HTTP ${r.status}`}`);
+      step({ phase: "draw", ok: false, msg: r.msg });
+      break;
+    }
+    out.drawn += 1;
+    const name = r.prize?.prize_name || r.prize?.name || r.prize?.title || "";
+    const credit = Number(r.prize?.credit || 0);
+    out.credit += credit;
+    out.prizes.push({ name, credit });
+    step({ phase: "draw", ok: true, remaining: left - 1, prize: name, credit });
+  }
+  return out;
+}