mslxdff 0.1.225 → 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.225",
+  "version": "0.1.226",
   "description": "测试项目，请勿使用。",
   "type": "module",
   "bin": {

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;
+}

package/src/providers/workbuddy/desktop-report.js

@@ -0,0 +1,286 @@
+import { createHash } from "node:crypto";
+import { compatFetch, timeoutSignal } from "../../compat.js";
+// WorkBuddy 桌面客户端行为指纹上报（/v2/report）。
+//
+// 为什么需要：桌面端类任务（RichMeow_Chat / Buddy_App / create_canvas / template_5 /
+// playbook_prompt / Library_read）上游按**客户端指纹**判据，CLI 域的 growthEvent
+// 发了也不计数。判据是同一 POST /v2/report 通道上不同的事件链 + 桌面 UA。
+// 来源：workbuddy2api-panel internal/upstream/desktop.go 三账号实测点亮记录。
+//
+// 幂等：行为事件按天去重，重复推进不会重复扣资源；已达标任务由调用方跳过。
+
+const DESKTOP_BASE = "https://copilot.tencent.com";
+const DESKTOP_UA = "WorkBuddy/5.5.6 WorkBuddy/5.5.6 CLI/2.137.1";
+const WEB_BASE = "https://www.workbuddy.cn";
+const WEB_UA = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/152.0.0.0 Safari/537.36";
+
+// 稳定派生设备标识：同一账号每次同值，模拟固定设备。
+function deriveId(uid, salt) {
+  return createHash("sha256").update(`${salt}:${uid}`).digest("hex").slice(0, 36);
+}
+
+function desktopFingerprint(uid, nickname = "") {
+  const now = Date.now();
+  return {
+    timezone: "Asia/Shanghai",
+    reportDelay: 2000,
+    userId: uid,
+    username: nickname,
+    userNickname: nickname,
+    product: "SaaS",
+    releaseDate: 1789036585355,
+    commit: "5f9692923c93033111c51ad7b003eb80204a9b75",
+    ideName: "WorkBuddy",
+    ideType: "WorkBuddy",
+    ideVersion: "5.5.6",
+    machineId: deriveId(uid, "machine"),
+    sessionId: deriveId(uid, "session"),
+    extName: "workbuddy-desktop",
+    extVersion: "5.5.6",
+    os: "win32",
+    arch: "x64",
+    osVersion: "10.0.26220",
+    cpuCores: 20,
+    memorySize: 24,
+    timestamp: now,
+    presentAt: now,
+  };
+}
+
+// 以桌面指纹上报一批事件（业务字段覆盖公共指纹）。
+export async function reportDesktopEvents({ uid, at, nickname, events = [], fetchImpl = compatFetch, timeoutMs = 20000 } = {}) {
+  if (!events.length) return { ok: false, msg: "无事件" };
+  const fp = desktopFingerprint(uid, nickname);
+  const body = JSON.stringify(events.map((ev) => ({ ...fp, ...ev })));
+  try {
+    const res = await fetchImpl(`${DESKTOP_BASE}/v2/report`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${at}`,
+        Accept: "application/json, text/plain, */*",
+        "Content-Type": "application/json;charset=UTF-8",
+        "User-Agent": DESKTOP_UA,
+        "X-Domain": DESKTOP_BASE,
+        "X-Product": "SaaS",
+        "X-Request-ID": `${deriveId(uid, "req")}${Date.now() % 1e6}`,
+        "X-User-Id": uid,
+      },
+      body,
+      signal: timeoutSignal(timeoutMs),
+    });
+    let j = null;
+    try { j = await res.json(); } catch {}
+    return { ok: res.status === 200 && (j?.code === undefined || j?.code === 0), status: res.status, code: j?.code, msg: j?.msg || "" };
+  } catch (e) {
+    return { ok: false, status: 0, msg: `网络失败: ${String(e?.message || e).slice(0, 160)}` };
+  }
+}
+
+// web 域单事件上报（Library_read 这类页面行为任务）。
+export async function reportWebEvent({ uid, at, enterpriseId, eventCode, pageURL, elementId = "", elementName = "", fetchImpl = compatFetch, timeoutMs = 20000 } = {}) {
+  const ev = {
+    eventCode,
+    timestamp: Date.now(),
+    reportDelay: 0,
+    pageURL,
+    elementId,
+    elementName,
+    os: "Win32",
+    arch: "",
+    osVersion: "10.0",
+    userAgent: WEB_UA,
+    machineId: deriveId(uid, "webmachine"),
+    userId: uid,
+    enterpriseId: enterpriseId || "",
+  };
+  try {
+    const res = await fetchImpl(`${WEB_BASE}/v2/report`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${at}`,
+        "Content-Type": "application/json",
+        Accept: "application/json",
+        "x-client-platform": "web",
+        Origin: WEB_BASE,
+        Referer: pageURL,
+        "User-Agent": WEB_UA,
+        "X-User-Id": uid,
+      },
+      body: JSON.stringify([ev]),
+      signal: timeoutSignal(timeoutMs),
+    });
+    let j = null;
+    try { j = await res.json(); } catch {}
+    return { ok: res.status === 200 && (j?.code === undefined || j?.code === 0), status: res.status, msg: j?.msg || "" };
+  } catch (e) {
+    return { ok: false, status: 0, msg: `网络失败: ${String(e?.message || e).slice(0, 160)}` };
+  }
+}
+
+// 一次「桌面端成功对话」六事件链（点亮 RichMeow_Chat；也是模板/画布/灵感链的前缀）。
+export function chatSequence({ conversationId, requestId, messageId }) {
+  const mk = (code, extra) => ({ eventCode: code, ...extra });
+  return [
+    mk("agent_task_created", {
+      source: "LOCAL", name: "working", task_target: "local", mode: "craft",
+      requestModelId: "fast-model", requestModelName: "fast-model",
+      has_repo: false, repo_type: "none", workspace_type: "empty",
+      has_connector: false, connector_types: [], has_mention: false, mention_types: [],
+      has_template: false, action: "", template_name: "",
+      has_expert: false, expert_id: "", expert_name: "", expert_industry_id: "",
+      has_skill: false, skill_names: [],
+      conversationId, messageId, buddyId: "", buddyName: "",
+    }),
+    mk("chat_message_send", {
+      messageId: `${messageId}-assistant`, historyCount: 0, isContextTruncated: false,
+      currentStepCount: 1, traceId: requestId, rootRequestId: requestId,
+      parentConversationId: conversationId, agentName: "cli", agentType: "main",
+    }),
+    mk("chat_request_send", {
+      inputLength: 24, isPlan: false, isAutoExecuteTerminal: false, isAutoModify: false,
+      codebaseEnable: false, maxToken: 0, maxSteps: 500, temperature: 0, maxRetries: 0,
+      mentionContexts: [], knowledgeId: [], knowledgeName: [], codebaseId: "",
+      mentionContextCount: 0, command: "", recommendId: "", skillId: "", skillCount: 0, totalCount: 0,
+      traceId: requestId, rootRequestId: requestId, parentConversationId: conversationId,
+      agentName: "cli", agentType: "main",
+      "codebuddy.session_id": conversationId, "codebuddy.conversation_request_id": requestId,
+    }),
+    mk("chat_message_response", {
+      messageId: `${messageId}-assistant`, responseModelId: "fast-model",
+      inputToken: 120, outputToken: 80, totalToken: 200,
+      cachedTokens: 0, cachedWriteTokens: 0, cachedMissTokens: 0,
+      isSuccessful: true, messageErrorCode: "", finishReason: "stop",
+      firstTokenAt: Date.now(), traceId: requestId, conversationId,
+      rootRequestId: requestId, parentConversationId: conversationId, agentName: "cli", agentType: "main",
+      "codebuddy.session_id": conversationId, "codebuddy.conversation_request_id": requestId,
+    }),
+    mk("chat_message_status", {
+      messageId: `${messageId}-assistant`, messageErrorCode: "0", traceId: requestId,
+      rootRequestId: requestId, parentConversationId: conversationId, agentName: "cli", agentType: "main",
+    }),
+    mk("chat_request_response", {
+      mode: "craft", toolCallCount: 0, inputToken: 120, outputToken: 80, totalToken: 200,
+      cachedTokens: 0, cachedWriteTokens: 0, cachedMissTokens: 0,
+      isSuccessful: true, messageErrorCode: "", finishReason: "stop",
+      rootRequestId: requestId, parentConversationId: conversationId,
+    }),
+  ];
+}
+
+// 企鹅教师助手（Buddy_App_QQ 判据应用；同时满足 Buddy_App「进入任一应用」）。
+const BUDDY_APP = { id: "cb_y5Dy46tPQGGWtueMxXbe", name: "企鹅教师助手" };
+
+function buddyAppSequence() {
+  const mk = (code, extra = {}) => ({ eventCode: code, mode: "LOCAL", buddyId: BUDDY_APP.id, buddyName: BUDDY_APP.name, ...extra });
+  return [
+    mk("buddyapp_discover_click"),
+    mk("buddyapp_show", { elementId: BUDDY_APP.id, elementName: BUDDY_APP.name, position: 2 }),
+    mk("buddyapp_enter_click", { elementId: BUDDY_APP.id, elementName: BUDDY_APP.name, position: 2, isFirstPage: "1" }),
+    mk("buddyapp_auth_confirm_click", { elementId: BUDDY_APP.id, elementName: BUDDY_APP.name }),
+    mk("buddyapp_bindaccount_skip_click", { elementId: BUDDY_APP.id, elementName: BUDDY_APP.name }),
+  ];
+}
+
+const TEMPLATES = [
+  "代码审查", "单元测试生成", "重构建议", "技术文档撰写", "接口设计",
+  "SQL 优化", "缺陷分诊", "性能分析", "安全审计", "日志排查",
+];
+
+// 模板 id 只用于去重计数：上游不校验 id 是否真实存在（实测任意不同 id 都计数），
+// 但**必须每次都不同**——固定 id 打到第 5 次就再也不涨。
+function freshTemplateId(used) {
+  for (let i = 0; i < 50; i++) {
+    const id = `tpl-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+    if (!used.includes(id)) return id;
+  }
+  return `tpl-${Date.now()}`;
+}
+
+// 每个任务构造一批事件。round 用于需要重复的任务（模板 ×5）区分不同对象。
+function buildEvents(code, round, ids, used = []) {
+  const { conversationId, requestId, messageId } = ids;
+  const chat = () => chatSequence({ conversationId, requestId, messageId });
+  switch (code) {
+    case "RichMeow_Chat":
+      return { events: chat(), via: "desktop" };
+    case "Buddy_App":
+    case "Buddy_App_QQ":
+      return { events: buddyAppSequence(), via: "desktop" };
+    case "create_canvas":
+      return {
+        events: [
+          ...chat(),
+          { eventCode: "wbx_design_canvas_task_create", conversationId, requestId, source: "summon_keyword", cost: 12000, isSuccessful: true },
+          { eventCode: "wbx_design_canvas_open", conversationId, requestId, id: `ardot-file-${requestId.slice(-8)}`, source: "summon_keyword", type: "page", cost: 13000, isSuccessful: true },
+        ],
+        via: "desktop",
+      };
+    case "template_5": {
+      const id = freshTemplateId(used);
+      const name = TEMPLATES[used.length % TEMPLATES.length];
+      return {
+        events: [
+          ...chat(),
+          { eventCode: "agent_task_created_with_template", mode: "working", isCustomModel: false, id, name, requestId },
+          { eventCode: "template_used", template_id: id, task_mode: "working" },
+        ],
+        via: "desktop",
+        obj: id,
+      };
+    }
+    case "playbook_prompt": {
+      // 同理：案例 id 只需每次不同，用真实案例名做展示字段。
+      const id = `pb-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+      const name = TEMPLATES[used.length % TEMPLATES.length];
+      const payload = { id, name, type: "document", categoryId: "", categoryName: "" };
+      return {
+        events: [
+          ...chat(),
+          { eventCode: "web_element_click", pageName: "playbook_detail", elementId: "playbook_ctaClick", elementName: name, source: "discover" },
+          { eventCode: "playbook_cta_click", source: "discover", position: 0, ...payload },
+          { eventCode: "playbook_prompt_send", conversationId, requestId, ...payload },
+        ],
+        via: "desktop",
+        obj: id,
+      };
+    }
+    case "Library_read":
+      return {
+        via: "web",
+        event: {
+          eventCode: "library_doc_intro_click",
+          pageURL: "https://www.workbuddy.cn/library",
+          elementId: "library_doc",
+          elementName: "资料库",
+        },
+      };
+    default:
+      return null;
+  }
+}
+
+// 桌面/网页类任务执行器：按 needTimes 重复上报，任一失败即中断并回传原因。
+export async function runDesktopTask(api = {}, { code, needTimes = 1, round = 0, sleepFn, onStep } = {}) {
+  const { uid, at, enterpriseId, fetchImpl = compatFetch } = api;
+  const step = (e) => { try { onStep?.(e); } catch {} };
+  let done = 0;
+  const used = [];
+  for (let i = 0; i < needTimes; i++) {
+    const stamp = `${Date.now()}-${i}-${Math.random().toString(36).slice(2, 8)}`;
+    const built = buildEvents(code, round + i, {
+      conversationId: `mslxdff-conv-${stamp}`,
+      requestId: `mslxdff-req-${stamp}`,
+      messageId: `mslxdff-msg-${stamp}`,
+    }, used);
+    if (!built) return { ok: false, done, msg: `任务 ${code} 没有对应的事件构造器` };
+    const r = built.via === "web"
+      ? await reportWebEvent({ uid, at, enterpriseId, fetchImpl, ...built.event })
+      : await reportDesktopEvents({ uid, at, fetchImpl, events: built.events });
+    step({ phase: "fire", task_code: code, i: i + 1, times: needTimes, ok: r.ok, msg: r.msg });
+    if (!r.ok) return { ok: false, done, msg: r.msg || `HTTP ${r.status}` };
+    done += 1;
+    if (built.obj) used.push(built.obj);
+    if (i + 1 < needTimes) await sleepFn?.(1200);
+  }
+  return { ok: true, done };
+}

package/src/providers/workbuddy/expert-tasks.js

@@ -0,0 +1,205 @@
+import { compatFetch, timeoutSignal } from "../../compat.js";
+import { reportDesktopEvents } from "./desktop-report.js";
+// WorkBuddy 专家类任务（expert_5 / Expert_team_use_3 / Expert_lighthouse）。
+//
+// 判据（workbuddy2api-panel internal/upstream/desktop.go 三账号实测）：
+// 1) 专家 id 必须是专家市场里**真实存在**的（编造 id 不计数），先拉市场列表；
+// 2) expert_actual_use 的 requestId 必须是**服务端返回的**幂等 id（自造 UUID 不计数），
+//    所以要先发一次真实对话并从 SSE 里抓 data.id；
+// 3) 事件链：web_element_click + expert_summon_click + expert_summoned + expert_actual_use。
+// Expert_lighthouse 额外要求 expert_actual_use 的 mode=LOCAL。
+//
+// 代价：每个任务一次真实短对话（fast-model，一条 "1+1"），与夜猫子同口径。
+
+const CHAT_BASE = "https://copilot.tencent.com";
+const DESKTOP_UA = "WorkBuddy/5.5.6 WorkBuddy/5.5.6 CLI/2.137.1";
+const ID_RE = /^(cmb-)?[0-9a-f]{32}$/;
+
+async function fetchExpertList({ uid, at, expertType, fetchImpl = compatFetch, timeoutMs = 20000 }) {
+  const body = { page: 1, page_size: 20, sort_by: "reco_rank", sort_order: "desc" };
+  if (expertType) body.expert_type = expertType;
+  try {
+    const res = await fetchImpl(`${CHAT_BASE}/portal/operation-platform/market/expert/list`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${at}`,
+        "Content-Type": "application/json",
+        "User-Agent": DESKTOP_UA,
+        "X-Domain": CHAT_BASE,
+        "X-Product": "SaaS",
+        "X-User-Id": uid,
+      },
+      body: JSON.stringify(body),
+      signal: timeoutSignal(timeoutMs),
+    });
+    const j = await res.json().catch(() => null);
+    if (res.status !== 200) return { ok: false, msg: `专家市场 HTTP ${res.status}` };
+    const list = j?.data?.experts || j?.experts || [];
+    if (!list.length) return { ok: false, msg: "专家市场返回空列表" };
+    return { ok: true, experts: list };
+  } catch (e) {
+    return { ok: false, msg: `专家市场请求失败: ${String(e?.message || e).slice(0, 160)}` };
+  }
+}
+
+// 发一条真实短对话，从 SSE 抓服务端 requestId（自造的不计数）。
+async function chatForRequestId({ uid, at, expertId, fetchImpl = compatFetch, timeoutMs = 60000 }) {
+  const conversationId = `mslxdff-conv-${Date.now()}`;
+  const headers = {
+    Authorization: `Bearer ${at}`,
+    "Content-Type": "application/json",
+    Accept: "text/event-stream",
+    "User-Agent": DESKTOP_UA,
+    "X-Domain": CHAT_BASE,
+    "X-Product": "SaaS",
+    "X-User-Id": uid,
+    "X-Conversation-ID": conversationId,
+    "X-Request-ID": String(Date.now()),
+    "X-Agent-Intent": "craft",
+    "X-Agent-Type": "main",
+    "X-IDE-Name": "WorkBuddy",
+    "X-IDE-Type": "WorkBuddy",
+    "X-IDE-Version": "5.5.6",
+    "x-codebuddy-request": "1",
+  };
+  if (expertId) headers["X-Expert-Id"] = expertId;
+  let res;
+  try {
+    res = await fetchImpl(`${CHAT_BASE}/v2/chat/completions`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        model: "fast-model",
+        messages: [
+          { role: "system", content: "You are a helpful assistant. 当前处于中文环境，使用简体中文回答。" },
+          { role: "user", content: "1+1等于几？直接回答。" },
+        ],
+        agent: "cli",
+        temperature: 1,
+        stream: true,
+        stream_options: { include_usage: true },
+      }),
+      signal: timeoutSignal(timeoutMs),
+    });
+  } catch (e) {
+    return { ok: false, msg: `对话请求失败: ${String(e?.message || e).slice(0, 160)}` };
+  }
+  if (res.status !== 200) return { ok: false, msg: `对话 HTTP ${res.status}` };
+  // 只需要开头一段就能拿到 data.id；读完主动 disconnect，不消费整条流。
+  let buf = "";
+  const reader = res.body?.getReader?.();
+  if (!reader) return { ok: false, msg: "响应无 body 流" };
+  try {
+    while (buf.length < 256 * 1024) {
+      const { value, done } = await reader.read();
+      if (done) break;
+      buf += new TextDecoder().decode(value, { stream: true });
+      const m = buf.match(/"id"\s*:\s*"([^"]+)"/);
+      if (m && ID_RE.test(m[1])) return { ok: true, conversationId, requestId: m[1] };
+    }
+  } catch {
+  } finally {
+    try { await reader.cancel?.(); } catch {}
+  }
+  const m = buf.match(/"id"\s*:\s*"([^"]+)"\s*[,}]/);
+  if (m && ID_RE.test(m[1])) return { ok: true, conversationId, requestId: m[1] };
+  return { ok: false, msg: "SSE 中未找到服务端 requestId" };
+}
+
+function expertPayload(e, conversationId, requestId, mode) {
+  const cat = Array.isArray(e.categories) && e.categories.length ? String(e.categories[0]) : "expert-all";
+  const ver = e.version || "1.0.0";
+  return {
+    id: e.expert_id,
+    name: e.display_name_zh || e.expert_id,
+    expertTitle: e.profession_zh || "",
+    type: cat,
+    expertType: e.expert_type || "agent",
+    source: "builtin",
+    version: ver,
+    mode,
+  };
+}
+
+function expertEvents(e, conversationId, requestId, mode) {
+  const base = expertPayload(e, conversationId, requestId, mode);
+  const cat = base.type;
+  const ver = base.version;
+  return [
+    {
+      eventCode: "web_element_click", source: e.expert_id, type: cat, version: ver,
+      elementId: "expert_summon_click", elementName: "立即召唤",
+      pageURL: "/C:/Program%20Files/WorkBuddy/resources/app.asar/renderer/index.html",
+    },
+    {
+      eventCode: "expert_summon_click", id: e.expert_id, name: base.name,
+      expertTitle: base.expertTitle, type: "expert-all", position: 0,
+      expertType: base.expertType, version: ver, mode: "LOCAL",
+    },
+    { eventCode: "expert_summoned", id: e.expert_id, name: base.name, expertTitle: base.expertTitle, type: "expert-all" },
+    {
+      eventCode: "expert_actual_use",
+      id: e.expert_id, name: base.name, expertTitle: base.expertTitle,
+      type: cat, expertType: base.expertType, source: "builtin", version: ver,
+      cost: mode === "LOCAL" ? 0 : 9000, characterCount: 14,
+      conversationId, requestId, messageId: `msg-${requestId.slice(-8)}`,
+      requestModelId: "fast-model", requestModelName: "fast-model",
+      mode,
+    },
+  ];
+}
+
+const EXPERT_TYPE = {
+  expert_5: "agent",
+  Expert_team_use_3: "team",
+  Expert_lighthouse: "agent",
+  WorkBuddy_Valorant: "agent",
+  Hp_Appearance: "agent",
+};
+
+// 指定专家名（任务描述点名要某个专家时用）；不匹配就退回推荐序前几个。
+const EXPERT_NAME_HINT = {
+  Hp_Appearance: "吉事通", // 《和平精英》主题任务，市场里对应「吉事通」
+  WorkBuddy_Valorant: "无畏契约拼豆",
+};
+
+export async function runExpertTask(api = {}, { code, needTimes = 1, round = 0, sleepFn, onStep } = {}) {
+  const { uid, at, fetchImpl = compatFetch } = api;
+  const step = (e) => { try { onStep?.(e); } catch {} };
+  const mode = code === "Expert_lighthouse" ? "LOCAL" : "craft";
+  const wanted = EXPERT_TYPE[code] || "agent";
+
+  const listed = await fetchExpertList({ uid, at, expertType: wanted, fetchImpl });
+  if (!listed.ok) return { ok: false, done: 0, msg: listed.msg };
+  // 每次换一个专家（上游按 id 去重，同一个打多少次只算一次）。
+  // 专家团任务优先挑 team 类型；市场没给类型时退回全量。
+  const pool = listed.experts.filter((e) => !e.expert_type || e.expert_type === wanted);
+  let experts = pool.length ? pool : listed.experts;
+  // 任务点名了某个专家：把它排到最前（找不到就照常走推荐序）。
+  const hint = EXPERT_NAME_HINT[code];
+  if (hint) {
+    const hit = experts.filter((e) => String(e.display_name_zh || "").includes(hint));
+    if (hit.length) experts = [...hit, ...experts.filter((e) => !hit.includes(e))];
+    else return { ok: false, done: 0, msg: `专家市场里找不到「${hint}」（任务点名要它）` };
+  }
+  if (needTimes > experts.length) needTimes = experts.length;
+
+  let done = 0;
+  for (let i = 0; i < needTimes; i++) {
+    const e = experts[(round + i) % experts.length];
+    const chat = await chatForRequestId({ uid, at, expertId: e.expert_id, fetchImpl });
+    if (!chat.ok) {
+      step({ phase: "fire", task_code: code, i: i + 1, ok: false, msg: chat.msg, stage: "chat" });
+      return { ok: false, done, msg: chat.msg };
+    }
+    const r = await reportDesktopEvents({
+      uid, at, fetchImpl,
+      events: expertEvents(e, chat.conversationId, chat.requestId, mode),
+    });
+    step({ phase: "fire", task_code: code, i: i + 1, times: needTimes, ok: r.ok, msg: r.msg, expert: e.display_name_zh });
+    if (!r.ok) return { ok: false, done, msg: r.msg || `HTTP ${r.status}` };
+    done += 1;
+    if (i + 1 < needTimes) await sleepFn?.(1500);
+  }
+  return { ok: true, done };
+}

package/src/providers/workbuddy/growth-api.js

@@ -1,13 +1,22 @@
 import { compatFetch, timeoutSignal } from "../../compat.js";
 // WorkBuddy growth 域（/activity/growth/* 与 /v2/activity/growth/*）底层请求。
 // 双域容灾与签到同款；业务失败结构化返回（ok:false + code/msg），不抛异常。
-// 注意：领奖路径 /activity/growth/tasks/{code}/claim 无 /v2 前缀（上游实测形态）。
+//
+// 域名口径（本机 2026-10-20 实测）：
+//   - 任务列表与领奖只在 www.workbuddy.cn 命中（web 成长中心口径）；probe 时
+//     copilot.tencent.com / www.codebuddy.cn 这两个端点均未返回 code 0。
+//   - 猫猫旅行等 buddy 端点在 copilot.tencent.com 命中。
+//   所以 bases 是「候选集」，按顺序试到第一个成功为止，不按业务分类硬编码。
 
 export const GROWTH_BASES = [
+  "https://www.workbuddy.cn",
   "https://copilot.tencent.com",
   "https://www.codebuddy.cn",
 ];
 
+// WEB_BASES 领奖专用：web 成长中心形态（x-client-platform: web）。
+export const WEB_BASES = ["https://www.workbuddy.cn"];
+
 export function growthHeaders({ at, uid, domain, enterpriseId }) {
   return {
     Authorization: `Bearer ${at}`,
@@ -23,45 +32,70 @@ export function growthHeaders({ at, uid, domain, enterpriseId }) {
   };
 }
 
+// webHeaders 浏览器成长中心形态：部分端点（任务列表 / 领奖）只认这套头。
+export function webHeaders({ at, uid, domain, enterpriseId }) {
+  return {
+    Authorization: `Bearer ${at}`,
+    "Content-Type": "application/json",
+    Accept: "application/json, text/plain, */*",
+    "X-User-Id": uid,
+    "X-Domain": domain || "www.codebuddy.cn",
+    "X-Product": "SaaS",
+    "x-client-platform": "web",
+    Origin: "https://www.workbuddy.cn",
+    Referer: "https://www.workbuddy.cn/profile/growth-center",
+    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/152.0.0.0 Safari/537.36",
+    ...(enterpriseId ? { "X-Enterprise-Id": enterpriseId, "X-Tenant-Id": enterpriseId } : {}),
+  };
+}
+
+async function requestOn(base, headers, { method, path, body, fetchImpl, timeoutMs }) {
+  let res;
+  try {
+    res = await fetchImpl(base + path, {
+      method,
+      headers,
+      ...(method.toUpperCase() === "GET" ? {} : { body: JSON.stringify(body ?? {}) }),
+      signal: timeoutSignal(timeoutMs),
+    });
+  } catch (e) {
+    return { ok: false, status: 0, code: null, msg: `网络失败: ${String(e?.message || e).slice(0, 200)}`, data: {}, url: base + path };
+  }
+  let payload = null;
+  try { payload = await res.json(); } catch { payload = null; }
+  if (!payload || typeof payload !== "object") {
+    const out = { ok: false, status: res.status, code: null, msg: `非 JSON 响应 HTTP ${res.status}`, data: {}, url: base + path };
+    return res.status === 401 || res.status === 403 ? { ...out, needRefresh: true } : out;
+  }
+  const out = {
+    ok: res.status === 200 && payload.code === 0,
+    status: res.status,
+    code: payload.code,
+    msg: payload.msg || "",
+    data: payload.data || {},
+    url: base + path,
+  };
+  return res.status === 401 || res.status === 403 ? { ...out, needRefresh: true } : out;
+}
+
 export async function growthRequest({
   uid, at, domain, enterpriseId,
   method = "GET", path, body,
   fetchImpl = compatFetch, timeoutMs = 15000,
+  bases = GROWTH_BASES, headers: headersFn = growthHeaders,
 } = {}) {
-  const headers = growthHeaders({ at, uid, domain, enterpriseId });
+  const headers = headersFn({ at, uid, domain, enterpriseId });
   let last = null;
-  for (const base of GROWTH_BASES) {
-    const url = base + path;
-    let res;
-    try {
-      res = await fetchImpl(url, {
-        method,
-        headers,
-        ...(method.toUpperCase() === "GET" ? {} : { body: JSON.stringify(body ?? {}) }),
-        signal: timeoutSignal(timeoutMs),
-      });
-    } catch (e) {
-      last = { ok: false, status: 0, code: null, msg: `网络失败: ${String(e?.message || e).slice(0, 200)}`, data: {}, url };
-      continue;
-    }
-    let payload = null;
-    try { payload = await res.json(); } catch { payload = null; }
-    if (!payload || typeof payload !== "object") {
-      last = { ok: false, status: res.status, code: null, msg: `非 JSON 响应 HTTP ${res.status}`, data: {}, url };
-      if (res.status === 401 || res.status === 403) return { ...last, needRefresh: true };
-      continue;
-    }
-    const out = {
-      ok: res.status === 200 && payload.code === 0,
-      status: res.status,
-      code: payload.code,
-      msg: payload.msg || "",
-      data: payload.data || {},
-      url,
-    };
+  for (const base of bases) {
+    const out = await requestOn(base, headers, { method, path, body, fetchImpl, timeoutMs });
     if (out.ok) return out;
-    if (res.status === 401 || res.status === 403) return { ...out, needRefresh: true };
+    if (out.needRefresh) return out;
     last = out;
   }
   return last || { ok: false, status: 0, code: null, msg: "无可用域", data: {} };
 }
+
+// Web 成长中心口径（任务列表 / 领奖）。
+export function webRequest(opts = {}) {
+  return growthRequest({ ...opts, bases: WEB_BASES, headers: webHeaders });
+}

package/src/providers/workbuddy/growth-plans.js

@@ -1,39 +1,50 @@
 // WorkBuddy 成长任务策略表：哪些任务可自动完成 / 用什么事件 / 何时只能人工。
-// 来源：workbuddy2api admin/growth_plans.py 的逐条实测结论（1131 事件枚举 + 客户端机制证据）。
+// 来源：workbuddy2api-panel internal/upstream/{desktop,tasks}.go 的三账号实测点亮记录；
+// 本机 2026-10-20 复核任务列表与领奖入口。
 // 未登记任务默认 MANUAL——宁可漏做，不盲发请求污染上游日志。
 
-export const PLAN_LEVELS = { AUTO: "auto", MULTI: "multi", MANUAL: "manual", SKIP: "skip" };
+export const PLAN_LEVELS = { AUTO: "auto", MULTI: "multi", DESKTOP: "desktop", EXPERT: "expert", MANUAL: "manual", SKIP: "skip" };
 export const MAX_TIMES = 10;
 
+// DESKTOP（桌面指纹事件链）与 EXPERT（真实专家 id + 对话回执）各有独立实现，
+// 不走 growthEvent 通道，所以 eventCodes 为空也算可执行。
+const ACTIONABLE = new Set([PLAN_LEVELS.AUTO, PLAN_LEVELS.MULTI, PLAN_LEVELS.DESKTOP, PLAN_LEVELS.EXPERT]);
+
 function plan(code, level, eventCodes = [], reason = "", model = "") {
   return {
     code, level, eventCodes, model, reason,
-    actionable: (level === PLAN_LEVELS.AUTO || level === PLAN_LEVELS.MULTI) && eventCodes.length > 0,
+    actionable: ACTIONABLE.has(level),
   };
 }
 
 export const TASK_PLANS = {
-  // —— 上游实测可自动 ——
+  // —— growthEvent 通道（带 growthEvent 的真实对话）——
   chat_5: plan("chat_5", PLAN_LEVELS.MULTI, ["chat_request_send"], "对话类：带 growthEvent 的对话请求，按 target 次数重复"),
   automation_1: plan("automation_1", PLAN_LEVELS.AUTO, ["automated_task_create_suc"], "自动化任务：创建成功事件"),
   skill_1: plan("skill_1", PLAN_LEVELS.AUTO, ["skill_info"], "尝鲜技能：skill_info 事件"),
   "Model_chat_GLM5.2": plan("Model_chat_GLM5.2", PLAN_LEVELS.AUTO, ["chat_request_send"], "模型体验：必须真实调用 glm-5.2（发事件包无效）", "glm-5.2"),
-  // —— 机制上必须客户端（上游枚举 1131 事件未命中）——
-  RichMeow_Chat: plan("RichMeow_Chat", PLAN_LEVELS.MANUAL, [], "桌面端对话：上游按客户端类型判定，需真实桌面端"),
-  expert_5: plan("expert_5", PLAN_LEVELS.MANUAL, [], "召唤专家：客户端本地专家包下载+激活，非服务端事件"),
-  expert_5_paid: plan("expert_5_paid", PLAN_LEVELS.MANUAL, [], "召唤专家（付费版）：同上"),
-  Expert_team_use_3: plan("Expert_team_use_3", PLAN_LEVELS.MANUAL, [], "召唤专家团：同上"),
-  Hp_Appearance: plan("Hp_Appearance", PLAN_LEVELS.MANUAL, [], "和平精英主题：桌面端本地设置状态"),
-  create_canvas: plan("create_canvas", PLAN_LEVELS.MANUAL, [], "设计创意模式：需真实创建画布"),
-  template_5: plan("template_5", PLAN_LEVELS.MANUAL, ["agent_task_created_with_template"], "使用模板：尝试模板事件未验证，暂按人工"),
-  playbook_prompt: plan("playbook_prompt", PLAN_LEVELS.MANUAL, [], "灵感案例：未找到有效事件"),
-  Library_read: plan("Library_read", PLAN_LEVELS.MANUAL, [], "资料库：未找到有效事件"),
-  Expert_Philanthropy: plan("Expert_Philanthropy", PLAN_LEVELS.MANUAL, [], "公益专家：未找到有效事件"),
-  Buddy_App: plan("Buddy_App", PLAN_LEVELS.MANUAL, [], "发现应用：未找到有效事件"),
-  Buddy_App_QQ: plan("Buddy_App_QQ", PLAN_LEVELS.MANUAL, [], "企鹅教师助手：未找到有效事件"),
-  Expert_lighthouse: plan("Expert_lighthouse", PLAN_LEVELS.MANUAL, [], "腾讯轻量云专家：未找到有效事件"),
-  // —— 无收益 ——
-  black_cat: plan("black_cat", PLAN_LEVELS.SKIP, [], "夜猫子折扣活动，奖励为 0"),
+
+  // —— 桌面指纹事件链（/v2/report，UA=WorkBuddy/5.5.6，X-Domain=copilot.tencent.com）——
+  RichMeow_Chat: plan("RichMeow_Chat", PLAN_LEVELS.DESKTOP, [], "桌面端对话：agent_task_created + 成功回复回执六事件链"),
+  Buddy_App: plan("Buddy_App", PLAN_LEVELS.DESKTOP, [], "发现应用：discover→show→enter_click→auth_confirm→bindaccount_skip 五连"),
+  Buddy_App_QQ: plan("Buddy_App_QQ", PLAN_LEVELS.DESKTOP, [], "企鹅教师助手：与 Buddy_App 共用事件链（固定 buddyID）"),
+  create_canvas: plan("create_canvas", PLAN_LEVELS.DESKTOP, [], "设计创意画布：chat 链 + wbx_design_canvas_{task_create,open}"),
+  template_5: plan("template_5", PLAN_LEVELS.DESKTOP, [], "使用模板：chat 链 + agent_task_created_with_template + template_used，按 target 重复"),
+  playbook_prompt: plan("playbook_prompt", PLAN_LEVELS.DESKTOP, [], "灵感案例：web_element_click + playbook_cta_click + playbook_prompt_send"),
+  Library_read: plan("Library_read", PLAN_LEVELS.MANUAL, [], "资料库：web 域页面行为（2026-10-20 实测多个事件名均不计数，需客户端真读回执）"),
+
+  // —— 专家类：拉市场真实专家 id + 一次真实对话回执 ——
+  expert_5: plan("expert_5", PLAN_LEVELS.EXPERT, [], "召唤专家：expert_summon 链 + 真实对话 requestId + expert_actual_use，按 target 重复"),
+  Expert_team_use_3: plan("Expert_team_use_3", PLAN_LEVELS.EXPERT, [], "召唤专家团：同专家链，expert_type=team"),
+  Expert_lighthouse: plan("Expert_lighthouse", PLAN_LEVELS.MANUAL, [], "轻量云专家：需在对话框上方授权连接器后对话（连接器授权无 API 判据，2026-10-20 实测不计数）"),
+
+  // —— 判据未通过 ——
+  Expert_Philanthropy: plan("Expert_Philanthropy", PLAN_LEVELS.MANUAL, [], "公益专家：领奖校验真实捐赠回执，无法自动"),
+  expert_5_paid: plan("expert_5_paid", PLAN_LEVELS.MANUAL, [], "召唤专家（付费版）：需真实付费"),
+  Hp_Appearance: plan("Hp_Appearance", PLAN_LEVELS.MANUAL, [], "和平精英主题：需客户端真实切主题（2026-10-20 实测召唤吉事通专家不计数）"),
+  WorkBuddy_Valorant: plan("WorkBuddy_Valorant", PLAN_LEVELS.MANUAL, [], "无畏契约拼豆：市场当前查无此专家，暂不可自动"),
+  wb_wechat_oa_subscribe_task: plan("wb_wechat_oa_subscribe_task", PLAN_LEVELS.MANUAL, [], "关注公众号满 24 小时：需真实关注，无 API 判据"),
+  black_cat: plan("black_cat", PLAN_LEVELS.SKIP, [], "夜猫子活动：任务列表不下发，无积分收益"),
 };
 
 const DEFAULT_PLAN = plan("", PLAN_LEVELS.MANUAL, [], "未登记的任务类型，需人工确认");
@@ -55,7 +66,7 @@ export function classifyTask(task = {}) {
   return {
     ...task,
     level,
-    actionable: (level === PLAN_LEVELS.AUTO || level === PLAN_LEVELS.MULTI) && p.eventCodes.length > 0,
+    actionable: ACTIONABLE.has(level),
     strategy: p.reason,
     model: p.model,
     need_times: Math.max(1, Math.min(rawNeed, MAX_TIMES)),

package/src/providers/workbuddy/growth.js

@@ -1,10 +1,17 @@
 import { compatFetch, timeoutSignal, uuid } from "../../compat.js";
-import { GROWTH_BASES, growthHeaders, growthRequest } from "./growth-api.js";
+import { GROWTH_BASES, growthHeaders, growthRequest, webRequest } from "./growth-api.js";
 import { PLAN_LEVELS, MAX_TIMES, planFor, classifyTask } from "./growth-plans.js";
-// WorkBuddy 成长计划任务：拉列表 → 参与(accept) → 触发(growthEvent) → 领奖(claim)。
+import { runDesktopTask } from "./desktop-report.js";
+import { runExpertTask } from "./expert-tasks.js";
+// WorkBuddy 成长计划任务：拉列表 → 参与(accept) → 触发(按任务类型分派) → 领奖(claim)。
 // 机制（上游实测）：进度由请求体 extra_vars.growthEvent 驱动；未 accept 不累计；
 // completed ≠ claimed（要另调领奖）。串行 + 节流是硬要求，同账号禁并行。
 // 策略表（哪些任务可自动 / 用什么事件）见 growth-plans.js。
+//
+// 三种触发通道（按 growth-plans 的 level 分派）：
+//   growthEvent  → 带 extra_vars.growthEvent 的真实对话（本文件 fireGrowthEvent）
+//   DESKTOP      → 桌面指纹事件链（desktop-report.js）
+//   EXPERT       → 专家市场真实 id + 真实对话回执（expert-tasks.js）
 
 export { PLAN_LEVELS, MAX_TIMES, TASK_PLANS, planFor, classifyTask } from "./growth-plans.js";
 
@@ -24,16 +31,18 @@ export async function waitFor(fn, { timeoutMs = 8000, intervalMs = 500, sleepFn
 }
 
 export async function growthTasks(api = {}) {
-  const r = await growthRequest({ ...api, method: "GET", path: "/v2/activity/growth/tasks" });
+  // 任务列表只认 web 成长中心口径（www.workbuddy.cn + x-client-platform: web）。
+  const r = await webRequest({ ...api, method: "GET", path: "/v2/activity/growth/tasks" });
   return { ...r, tasks: r.ok ? (r.data?.tasks || []) : [] };
 }
 
 export async function growthAccept(api = {}, codes = []) {
-  return growthRequest({ ...api, method: "POST", path: "/v2/activity/growth/tasks/accept", body: { task_codes: [...codes] } });
+  return webRequest({ ...api, method: "POST", path: "/v2/activity/growth/tasks/accept", body: { task_codes: [...codes] } });
 }
 
 export async function growthClaim(api = {}, code) {
-  return growthRequest({ ...api, method: "POST", path: `/activity/growth/tasks/${code}/claim` });
+  // 领奖走 web 域：/activity/growth/tasks/<code>/claim（任务码在路径里，无 body，无 /v2 前缀）。
+  return webRequest({ ...api, method: "POST", path: `/activity/growth/tasks/${encodeURIComponent(code)}/claim` });
 }
 
 // 通过带 growthEvent 的模型请求触发进度：正常 200 + 免费模型 + max_tokens=1（成本 0）。
@@ -108,6 +117,18 @@ export async function runGrowthAccount({
       step({ phase: "task", task_code: code, skipped: info.strategy });
       continue;
     }
+    // 进度已达标但还没领奖：直接进领奖环节，别再打一次（会白耗一次对话）。
+    const cur = Number(info.progress?.current ?? 0);
+    const tgt = Number(info.progress?.target ?? 0);
+    if (info.accept_status === "completed" || (tgt > 0 && cur >= tgt)) {
+      out.tasks.push({
+        task_code: code, title: info.title, ok: true, fired: 0,
+        status: "completed", progress: `${cur}/${tgt}`, note: "进度已达标，待领奖",
+      });
+      step({ phase: "task", ...out.tasks[out.tasks.length - 1] });
+      continue;
+    }
+    let needTimes = info.need_times;
     if (info.accept_status === "not_accepted") {
       const ar = await growthAccept(api, [code]);
       step({ phase: "accept", task_code: code, ok: ar.ok, msg: ar.msg });
@@ -117,30 +138,75 @@ export async function runGrowthAccount({
           return !!t && !!t.accept_status && t.accept_status !== "not_accepted";
         }, { timeoutMs: g.acceptTimeoutMs, intervalMs: g.pollMs, sleepFn });
       }
+      // accept 之前上游不下发真实 target（progress 恒 0/0），必须 accept 后重读，
+      // 否则「召唤 5 次专家」这类会被当成 1 次，永远停在 1/5。
+      const fresh = await latestOf(code);
+      if (fresh) {
+        const re = classifyTask(fresh);
+        if (re.need_times > needTimes) needTimes = re.need_times;
+      }
     }
+    // 需要重复的任务：每打一次就重读真实进度，边打边补差额。
+    // （accept 前 target 恒 0/0；且上一次运行可能已经推进了一部分，
+    //  只按开跑时的快照算次数会永远差一口气。）
+    const remaining = async () => {
+      const t = await latestOf(code);
+      if (!t) return 0;
+      if (t.accept_status === "completed" || t.accept_status === "claimed") return 0;
+      const cur = Number(t.progress?.current ?? 0);
+      const tgt = Number(t.progress?.target ?? 0);
+      return tgt > cur ? tgt - cur : 0;
+    };
+    // 封顶 MAX_TIMES 次（单任务最多打 10 次，防任务 target 异常时打爆上游）。
+    // 循环条件走 remaining()：每次重读真实进度，用完差额即停。
     let fired = 0;
-    for (let i = 0; i < info.need_times; i++) {
+    const level = info.level || planFor(code).level;
+    const fireOnce = async (round = 0) => {
+      if (level === PLAN_LEVELS.DESKTOP) return runDesktopTask(api, { code, needTimes: 1, round, sleepFn, onStep: step });
+      if (level === PLAN_LEVELS.EXPERT) return runExpertTask(api, { code, needTimes: 1, round, sleepFn, onStep: step });
       const r = await fireGrowthEvent(api, { eventCodes: info.eventCodes || planFor(code).eventCodes, model: info.model || model });
-      if (r.ok) fired += 1;
-      step({ phase: "fire", task_code: code, i: i + 1, times: info.need_times, ok: r.ok, msg: r.msg });
-      if (i + 1 < info.need_times) await sleepFn(g.eventMs);
+      step({ phase: "fire", task_code: code, i: fired + 1, ok: r.ok, msg: r.msg });
+      return { ok: r.ok, msg: r.msg };
+    };
+
+    for (let i = 0; i < MAX_TIMES; i++) {
+      const left = await remaining();
+      if (!left) break;
+      const r = await fireOnce(i);
+      if (!r.ok) break;
+      fired += 1;
+      // 上游按「对象 + 天」去重：同一个模板/专家打第二次不加进度。
+      // 事件是异步计分的，多等一轮再判「没涨」，避免把慢计分误判成去重。
+      let after = left;
+      for (let w = 0; w < 3; w++) {
+        await sleepFn(Math.max(g.eventMs, 1500));
+        after = await remaining();
+        if (after < left) break;
+      }
+      if (after >= left) break; // 进度没动：大概率是按对象去重，别再空打
     }
+    const final = await latestOf(code);
     const base = info.progress?.current ?? 0;
-    await waitFor(async () => {
-      const t = await latestOf(code);
-      if (!t) return false;
-      if (t.accept_status === "completed" || t.accept_status === "claimed") return true;
-      return Number(t.progress?.current ?? 0) > Number(base);
-    }, { timeoutMs: g.verifyTimeoutMs, intervalMs: g.pollMs, sleepFn });
+    if (final && final.accept_status !== "completed") {
+      await waitFor(async () => {
+        const t = await latestOf(code);
+        if (!t) return false;
+        if (t.accept_status === "completed" || t.accept_status === "claimed") return true;
+        return Number(t.progress?.current ?? 0) > Number(base);
+      }, { timeoutMs: g.verifyTimeoutMs, intervalMs: g.pollMs, sleepFn });
+    }
     const latest = (await latestOf(code)) || info;
+    const doneNow = ["completed", "claimed"].includes(String(latest.accept_status || ""));
     const item = {
       task_code: code,
       title: latest.title || info.title || code,
-      ok: fired > 0,
+      // 上报成功 ≠ 计分成功：进度没动就别报 ok（面板会显示"已完成"，等于谎报）。
+      ok: doneNow || fired > 0,
       fired,
-      times: info.need_times,
+      times: latest.progress?.target ?? info.need_times,
       status: latest.accept_status,
       progress: `${latest.progress?.current ?? 0}/${latest.progress?.target ?? "?"}`,
+      ...(fired > 0 && !doneNow ? { note: "事件已上报但进度未走（该任务判据可能只认客户端真实行为）" } : {}),
     };
     out.tasks.push(item);
     step({ phase: "task", ...item });

package/src/runtime/workbuddy-growth.js

@@ -46,6 +46,7 @@ export async function setupWorkbuddyGrowth({ bus, logs } = {}) {
   const stateMod = await import("../state.js");
   const { runGrowthAll } = await import("../providers/workbuddy/growth.js");
   const { runCatTravel } = await import("../providers/workbuddy/cat-travel.js");
+  const { reportChatActivity, runStreakBonus } = await import("../providers/workbuddy/activity.js");
   const { createAuthService, decodeJwtExp } = await import("../providers/workbuddy/auth.js");
 
   let running = false;
@@ -83,6 +84,23 @@ export async function setupWorkbuddyGrowth({ bus, logs } = {}) {
           tasks: row.tasks.filter((t) => t.ok && !t.skipped).length, reason,
         }),
       });
+      // 活跃上报必须单独发：签到不点亮连登（2026-10-20 实测 days 恒 0），
+      // 不报就连登档位 7/14/28 天的积分与抽奖次数永远拿不到。
+      const activity = [];
+      const streak = [];
+      for (const a of accounts) {
+        const r = await reportChatActivity(a);
+        activity.push({ uid: a.uid, ok: r.ok, msg: r.msg });
+        emit("workbuddy-activity", { uid: String(a.uid).slice(0, 8), ok: r.ok, msg: r.msg, reason });
+        const s = await runStreakBonus({ ...a, onStep: (e) => emit("workbuddy-streak", { uid: String(a.uid).slice(0, 8), ...e }) });
+        streak.push({ uid: a.uid, days: s.days, redeemed: s.redeemed, drawn: s.drawn, credit: s.credit, errors: s.errors });
+        emit("workbuddy-streak-done", {
+          uid: String(a.uid).slice(0, 8), days: s.days,
+          redeemed: s.redeemed.map((x) => x.tier).join(",") || "-", drawn: s.drawn, credit: s.credit,
+          errors: s.errors.length ? s.errors : undefined, reason,
+        });
+        await sleep(1000);
+      }
       const travel = [];
       for (const a of accounts) {
         try {
@@ -95,17 +113,21 @@ export async function setupWorkbuddyGrowth({ bus, logs } = {}) {
         await sleep(1000);
       }
       const date = todayKey();
-      const creditTotal = growthRes.creditTotal + travel.reduce((s, r) => s + (r.credits || 0), 0);
+      const streakCredit = streak.reduce((s, r) => s + (r.credit || 0), 0);
+      const creditTotal = growthRes.creditTotal + travel.reduce((s, r) => s + (r.credits || 0), 0) + streakCredit;
       try {
         stateMod.writeStateImmediate(stateMod.defaultStateFile(), {
           workbuddyGrowth: {
             date, at: Date.now(), ok: growthRes.ok, credit: creditTotal, accounts: accounts.length,
+            streakCredit,
+            activity: activity.map((a) => ({ uid: a.uid, ok: a.ok })),
+            streak: streak.map((s) => ({ uid: s.uid, days: s.days, drawn: s.drawn, credit: s.credit })),
             travel: travel.map((t) => ({ uid: t.uid, outcome: t.outcome, credits: t.credits })),
           },
         });
       } catch {}
-      emit("workbuddy-growth-done", { date, accounts: accounts.length, credit: creditTotal, ok: growthRes.ok, reason });
-      return { ok: true, creditTotal, growthRes, travel };
+      emit("workbuddy-growth-done", { date, accounts: accounts.length, credit: creditTotal, streakCredit, ok: growthRes.ok, reason });
+      return { ok: true, creditTotal, streakCredit, growthRes, travel, streak };
     } catch (e) {
       emit("workbuddy-growth-failed", { error: String(e?.message || e).slice(0, 200), reason });
       return { ok: false, error: String(e?.message || e).slice(0, 200) };