mslxdff 0.1.225 → 0.1.227

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