mslxdff 0.1.123 → 0.1.124

package/package.json

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

package/src/cli/commands/workbuddy.js

@@ -13,6 +13,59 @@ export async function handleWorkbuddy(args) {
     child.on("close", (code) => process.exit(code ?? 0));
     child.on("error", (err) => { console.error(`workbuddy checkin failed: ${err.message}`); process.exit(1); });
     await new Promise(() => {});
+  } else if (sub === "growth" || sub === "earn" || sub === "tasks") {
+    const asJson = args.includes("--json") || args.includes("-json");
+    const ci = args.indexOf("--codes");
+    const codes = ci >= 0 && args[ci + 1] ? String(args[ci + 1]).split(",").filter(Boolean) : undefined;
+    const ai = args.indexOf("--account");
+    const prefix = ai >= 0 && args[ai + 1] ? String(args[ai + 1]) : "";
+    let items = await loadWorkbuddyAccounts();
+    if (prefix) items = items.filter((it) => String(it.uid).startsWith(prefix));
+    if (!items.length) { console.log("no workbuddy accounts — run node workbuddy-token-auto.js"); process.exit(0); }
+    await refreshExpiringAccounts(items);
+    const { runGrowthAll } = await import("../../providers/workbuddy/growth.js");
+    if (!asJson) console.log(`workbuddy growth (${items.length} account(s), serial):`);
+    const res = await runGrowthAll({
+      accounts: items.map((it) => ({ uid: it.uid, at: it.key, domain: it.domain, enterpriseId: it.enterpriseId })),
+      codes,
+      onAccount: (row) => {
+        if (asJson) return;
+        const u = String(row.uid).slice(0, 8);
+        if (!row.ok && row.error) { console.log(`  [${u}] 失败: ${row.error}`); return; }
+        for (const t of row.tasks) {
+          if (t.skipped) console.log(`  [${u}] ${t.task_code} 跳过(${t.skipped})`);
+          else console.log(`  [${u}] ${t.task_code} 触发 ${t.fired}/${t.times} → ${t.status || "?"}${t.credit ? ` +${t.credit}` : ""}`);
+        }
+        console.log(`  [${u}] 合计 +${row.credit} 积分 / +${row.energy} 能量`);
+      },
+    });
+    if (asJson) console.log(JSON.stringify(res, null, 2));
+    else console.log(`总计 +${res.creditTotal} 积分`);
+    process.exit(0);
+  } else if (sub === "travel" || sub === "cat" || sub === "cat-travel") {
+    const asJson = args.includes("--json") || args.includes("-json");
+    const ai = args.indexOf("--account");
+    const prefix = ai >= 0 && args[ai + 1] ? String(args[ai + 1]) : "";
+    let items = await loadWorkbuddyAccounts();
+    if (prefix) items = items.filter((it) => String(it.uid).startsWith(prefix));
+    if (!items.length) { console.log("no workbuddy accounts — run node workbuddy-token-auto.js"); process.exit(0); }
+    await refreshExpiringAccounts(items);
+    const { runCatTravel } = await import("../../providers/workbuddy/cat-travel.js");
+    if (!asJson) console.log(`workbuddy cat-travel (${items.length} account(s)):`);
+    const rows = [];
+    for (const it of items) {
+      const u = String(it.uid).slice(0, 8);
+      const r = await runCatTravel({
+        uid: it.uid, at: it.key, domain: it.domain, enterpriseId: it.enterpriseId,
+        onStep: asJson ? null : (s) => console.log(`  [${u}] ${s.step} ${s.ok ? "✓" : "✗"} ${s.message}${s.reward ? ` (+${s.reward})` : ""}`),
+      });
+      if (!asJson) console.log(`  [${u}] ${r.summary}`);
+      rows.push({ uid: it.uid, outcome: r.outcome, credits: r.credits, ok: r.ok, steps: r.steps });
+    }
+    const total = rows.reduce((s, r) => s + (r.credits || 0), 0);
+    if (asJson) console.log(JSON.stringify({ results: rows, credits: total }, null, 2));
+    else console.log(`总计 +${total} 积分`);
+    process.exit(0);
   } else if (sub === "balance" || sub === "balances" || sub === "credit" || sub === "credits") {
     const asJson = args.includes("--json") || args.includes("-json");
     const { loadProviderConfigs } = await import("../../state.js");
@@ -85,7 +138,59 @@ export async function handleWorkbuddy(args) {
     console.log(`removed workbuddy ${uid} (now ${auths.length} account(s))`);
     process.exit(0);
   } else {
-    console.error("usage: mslxdff -workbuddy checkin | balance [--json] | list | remove <uid>");
+    console.error("usage: mslxdff -workbuddy checkin | growth [--codes a,b] [--account <uid>] | travel | balance [--json] | list | remove <uid>");
     process.exit(1);
   }
 }
+
+// 账号加载（state 优先，缺则扫 auths/workbuddy-*.json），供 growth/travel 使用。
+async function loadWorkbuddyAccounts() {
+  const { loadProviderConfigs } = await import("../../state.js");
+  const cfg = loadProviderConfigs().workbuddy || {};
+  const auths = Array.isArray(cfg.auths) ? cfg.auths : [];
+  const keys = Array.isArray(cfg.keys) ? cfg.keys : [];
+  const items = auths.map((a, i) => ({
+    uid: a.uid, domain: a.domain || "www.codebuddy.cn", enterpriseId: a.enterpriseId || "",
+    key: keys[i] || "", auth: a,
+  })).filter((it) => it.uid && it.key);
+  if (items.length) return items;
+  try {
+    const { readdirSync, readFileSync, existsSync } = await import("node:fs");
+    const { join } = await import("node:path");
+    const { resolveAuthDir } = await import("../../providers/workbuddy/account-store.js");
+    const dir = resolveAuthDir();
+    if (existsSync(dir)) {
+      for (const f of readdirSync(dir).filter((x) => x.startsWith("workbuddy-") && x.endsWith(".json"))) {
+        try {
+          const j = JSON.parse(readFileSync(join(dir, f), "utf8"));
+          if (j?.account?.uid && j?.auth?.accessToken) {
+            const domain = j.auth.domain || "www.codebuddy.cn";
+            items.push({
+              uid: j.account.uid, domain, enterpriseId: j.account.enterpriseId || "",
+              key: j.auth.accessToken,
+              auth: { uid: j.account.uid, domain, enterpriseId: j.account.enterpriseId || "", refreshToken: j.auth.refreshToken || "" },
+            });
+          }
+        } catch {}
+      }
+    }
+  } catch {}
+  return items;
+}
+
+// 临期 token 续期（<1h），refresh 结果经 store 回写 state 与 auths 文件。
+async function refreshExpiringAccounts(items) {
+  const { compatFetch } = await import("../../compat.js");
+  const { createAuthService, decodeJwtExp } = await import("../../providers/workbuddy/auth.js");
+  const keys = items.map((it) => it.key);
+  const authList = items.map((it) => it.auth);
+  const svc = createAuthService({ fetchImpl: compatFetch, store: { keys, authList } });
+  await Promise.all(authList.map(async (auth, i) => {
+    try {
+      const exp = decodeJwtExp(keys[i]);
+      if (exp && exp - Date.now() / 1000 < 3600) await svc.refreshTokenFor(keys[i], auth);
+    } catch {}
+  }));
+  items.forEach((it, i) => { it.key = keys[i]; });
+  return items;
+}

package/src/providers/workbuddy/cat-travel.js

@@ -0,0 +1,125 @@
+import { compatFetch } from "../../compat.js";
+import { growthRequest } from "./growth-api.js";
+import { fireGrowthEvent } from "./growth.js";
+// WorkBuddy 猫猫旅行（/activity/growth/buddy/*，无 /v2 前缀）：
+// 同意协议 → 首次领养（+300）→ 派出 → 到站领奖。
+// 领养门槛「first_buddy task not completed yet」= 需至少一次对话，
+// 用一次 chat_request_send 事件（免费模型、成本 0）即可解锁。
+
+const BUDDY_GATE_MARKER = "first_buddy task not completed yet";
+const DEFAULT_LOCATION_ID = 4;
+
+// sleep 必须保活事件循环（CLI 场景 unref 会让 Node 提前退出，见 growth.js 同注）。
+const defaultSleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+export async function runCatTravel({
+  uid, at, domain, enterpriseId,
+  locationId = DEFAULT_LOCATION_ID,
+  fetchImpl = compatFetch, sleepFn = defaultSleep,
+  gaps = {}, onStep = null,
+} = {}) {
+  const g = { pollMs: 1500, ...gaps };
+  const api = { uid, at, domain, enterpriseId, fetchImpl };
+  const steps = [];
+  let credits = 0;
+  const add = (step, ok, message, reward = 0, skipped = false) => {
+    credits += reward;
+    const s = { step, ok, skipped, reward, message };
+    steps.push(s);
+    try { onStep?.(s); } catch {}
+  };
+  const done = (ok, outcome, summary) => ({ ok, outcome, credits, steps, summary });
+
+  // 1) 猫档案：data.buddy 为 null 即未领养
+  const info = await growthRequest({ ...api, method: "GET", path: "/activity/growth/buddy/info" });
+  if (!info.ok) {
+    add("info", false, `查询猫档案失败：${info.msg || info.status}`);
+    return done(false, "error", "查询猫档案失败");
+  }
+  const buddy = info.data?.buddy || null;
+
+  // 2) 无猫：协议 → 领养（门槛未达标时自动补一次对话再试）
+  if (!buddy) {
+    const agr = await growthRequest({ ...api, method: "POST", path: "/activity/growth/buddy/agreement", body: { agree: true } });
+    if (!agr.ok) {
+      add("agreement", false, `同意协议失败：${agr.msg || agr.status}`);
+      return done(false, "error", "同意协议失败");
+    }
+    add("agreement", true, "已同意活动协议");
+
+    let first = await growthRequest({ ...api, method: "POST", path: "/activity/growth/buddy/first" });
+    if (!first.ok && first.status === 400 && String(first.msg || "").toLowerCase().includes(BUDDY_GATE_MARKER)) {
+      const fr = await fireGrowthEvent(api, { eventCodes: ["chat_request_send"] });
+      if (fr.ok) {
+        add("gate", true, "领养门槛未达标，已补一次对话解锁");
+        await sleepFn(g.pollMs);
+        first = await growthRequest({ ...api, method: "POST", path: "/activity/growth/buddy/first" });
+      } else {
+        add("gate", false, `门槛补齐失败：${fr.msg || fr.status}`, 0, true);
+      }
+    }
+    if (first.ok) {
+      const data = first.data || {};
+      const got = Number(data.credit || 0);
+      const reward = got > 0 ? got : 300;
+      const energy = Number(data.energy || 0);
+      let msg = `领养成功，已发放 ${reward} 积分`;
+      if (energy) msg += ` + ${energy} 能量`;
+      const badge = data.badge?.name;
+      if (badge) msg += `，解锁徽章「${badge}」`;
+      add("adopt", true, msg, reward);
+      return done(true, "adopted", msg);
+    }
+    if (first.status === 400 && String(first.msg || "").toLowerCase().includes(BUDDY_GATE_MARKER)) {
+      add("adopt", true, "本次无法领养：对话门槛未达标", 0, true);
+      return done(true, "gate_blocked", "本次无法领养（对话门槛未达标）");
+    }
+    add("adopt", false, `领养失败：${first.msg || first.status}`);
+    return done(false, "error", "领养失败");
+  }
+  add("adopt", true, `已有猫：${buddy.name || buddy.id}`, 0, true);
+
+  // 3) 旅行状态
+  const st = await growthRequest({ ...api, method: "GET", path: "/activity/growth/buddy/travel/status" });
+  if (!st.ok) {
+    add("status", false, `查询旅行状态失败：${st.msg || st.status}`);
+    return done(false, "error", "查询旅行状态失败");
+  }
+  const state = String(st.data?.state || "");
+  const recordId = Number(st.data?.record_id || 0);
+
+  // 4) 到站领奖 / 空闲派出
+  if (state === "arrived") {
+    if (recordId <= 0) {
+      add("claim", false, "已到站但缺少 record_id，无法领奖");
+      return done(false, "error", "领奖失败（缺少 record_id）");
+    }
+    const cl = await growthRequest({ ...api, method: "POST", path: "/activity/growth/buddy/travel/claim", body: { record_id: recordId } });
+    if (!cl.ok) {
+      add("claim", false, `领奖失败：${cl.msg || cl.status}`);
+      return done(false, "error", "领奖失败");
+    }
+    const reward = Number(cl.data?.reward_credit || 0);
+    add("claim", true, `领奖成功，获得 ${reward} 积分`, reward);
+    return done(true, reward > 0 ? "travel_claimed" : "travel_none", reward > 0 ? `完成，共获得 ${reward} 积分` : "完成，本次无新增积分");
+  }
+  if (state === "idle") {
+    if (st.data?.daily_limit_reached) {
+      add("depart", true, "今日已派出过，明日可再次派出", 0, true);
+      return done(true, "travel_none", "今日已派出过");
+    }
+    const dp = await growthRequest({ ...api, method: "POST", path: "/activity/growth/buddy/travel/depart", body: { location_id: locationId } });
+    if (!dp.ok) {
+      add("depart", false, `派出失败：${dp.msg || dp.status}`);
+      return done(false, "error", "派出失败");
+    }
+    add("depart", true, "已派出猫咪旅行，到站后可领奖");
+    return done(true, "departed", "已派出猫咪旅行，到站后可领奖");
+  }
+  if (state === "traveling") {
+    add("depart", true, `猫咪正在旅行中（record=${recordId}）`, 0, true);
+    return done(true, "traveling", "猫咪正在旅行中，到站后可领奖");
+  }
+  add("status", true, `未知旅行状态 ${state}，未执行动作`, 0, true);
+  return done(true, "unknown", `未知旅行状态 ${state}`);
+}

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

@@ -0,0 +1,67 @@
+import { compatFetch, timeoutSignal } from "../../compat.js";
+// WorkBuddy growth 域（/activity/growth/* 与 /v2/activity/growth/*）底层请求。
+// 双域容灾与签到同款；业务失败结构化返回（ok:false + code/msg），不抛异常。
+// 注意：领奖路径 /activity/growth/tasks/{code}/claim 无 /v2 前缀（上游实测形态）。
+
+export const GROWTH_BASES = [
+  "https://copilot.tencent.com",
+  "https://www.codebuddy.cn",
+];
+
+export function growthHeaders({ 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 async function growthRequest({
+  uid, at, domain, enterpriseId,
+  method = "GET", path, body,
+  fetchImpl = compatFetch, timeoutMs = 15000,
+} = {}) {
+  const headers = growthHeaders({ 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,
+    };
+    if (out.ok) return out;
+    if (res.status === 401 || res.status === 403) return { ...out, needRefresh: true };
+    last = out;
+  }
+  return last || { ok: false, status: 0, code: null, msg: "无可用域", data: {} };
+}

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

@@ -0,0 +1,63 @@
+// WorkBuddy 成长任务策略表：哪些任务可自动完成 / 用什么事件 / 何时只能人工。
+// 来源：workbuddy2api admin/growth_plans.py 的逐条实测结论（1131 事件枚举 + 客户端机制证据）。
+// 未登记任务默认 MANUAL——宁可漏做，不盲发请求污染上游日志。
+
+export const PLAN_LEVELS = { AUTO: "auto", MULTI: "multi", MANUAL: "manual", SKIP: "skip" };
+export const MAX_TIMES = 10;
+
+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,
+  };
+}
+
+export const TASK_PLANS = {
+  // —— 上游实测可自动 ——
+  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"),
+};
+
+const DEFAULT_PLAN = plan("", PLAN_LEVELS.MANUAL, [], "未登记的任务类型，需人工确认");
+
+export function planFor(code) {
+  return TASK_PLANS[code] || DEFAULT_PLAN;
+}
+
+export function classifyTask(task = {}) {
+  const code = task.task_code || "";
+  const p = planFor(code);
+  let level = p.level;
+  const reward = Number(task.reward_credit || 0);
+  if (reward <= 0 && level !== PLAN_LEVELS.SKIP) level = PLAN_LEVELS.SKIP;
+  const prog = task.progress || {};
+  const target = Number(prog.target);
+  const current = Number(prog.current || 0);
+  const rawNeed = Number.isInteger(target) && target > current ? target - current : 1;
+  return {
+    ...task,
+    level,
+    actionable: (level === PLAN_LEVELS.AUTO || level === PLAN_LEVELS.MULTI) && p.eventCodes.length > 0,
+    strategy: p.reason,
+    model: p.model,
+    need_times: Math.max(1, Math.min(rawNeed, MAX_TIMES)),
+  };
+}

package/src/providers/workbuddy/growth.js

@@ -0,0 +1,181 @@
+import { compatFetch, timeoutSignal, uuid } from "../../compat.js";
+import { GROWTH_BASES, growthHeaders, growthRequest } from "./growth-api.js";
+import { PLAN_LEVELS, MAX_TIMES, planFor, classifyTask } from "./growth-plans.js";
+// WorkBuddy 成长计划任务：拉列表 → 参与(accept) → 触发(growthEvent) → 领奖(claim)。
+// 机制（上游实测）：进度由请求体 extra_vars.growthEvent 驱动；未 accept 不累计；
+// completed ≠ claimed（要另调领奖）。串行 + 节流是硬要求，同账号禁并行。
+// 策略表（哪些任务可自动 / 用什么事件）见 growth-plans.js。
+
+export { PLAN_LEVELS, MAX_TIMES, TASK_PLANS, planFor, classifyTask } from "./growth-plans.js";
+
+// 注意：sleep 必须保活事件循环（不能 unref）——CLI 场景下 unref 的定时器
+// 会让 Node 在等待期间判定 event loop 空而提前退出（exit 13 unsettled await）。
+const defaultSleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+export async function waitFor(fn, { timeoutMs = 8000, intervalMs = 500, sleepFn = defaultSleep } = {}) {
+  const deadline = Date.now() + timeoutMs;
+  for (;;) {
+    let v = false;
+    try { v = await fn(); } catch {}
+    if (v) return true;
+    if (Date.now() >= deadline) return false;
+    await sleepFn(intervalMs);
+  }
+}
+
+export async function growthTasks(api = {}) {
+  const r = await growthRequest({ ...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] } });
+}
+
+export async function growthClaim(api = {}, code) {
+  return growthRequest({ ...api, method: "POST", path: `/activity/growth/tasks/${code}/claim` });
+}
+
+// 通过带 growthEvent 的模型请求触发进度：正常 200 + 免费模型 + max_tokens=1（成本 0）。
+// 读首块即主动断开，不等待全文。
+export async function fireGrowthEvent(api = {}, { eventCodes = [], model, eventId, timeoutMs = 60000 } = {}) {
+  const { uid, at, domain, enterpriseId, fetchImpl = compatFetch } = api;
+  const id = eventId || uuid();
+  const body = {
+    model: model || process.env.MSLXDFF_WORKBUDDY_GROWTH_MODEL || "hy3",
+    stream: true,
+    max_tokens: 1,
+    messages: [{ role: "user", content: "hi" }],
+    extra_vars: { growthEvent: JSON.stringify(eventCodes.map((c) => ({ eventCode: c, id }))) },
+  };
+  let last = { ok: false, status: 0 };
+  for (const base of GROWTH_BASES) {
+    let res;
+    try {
+      res = await fetchImpl(`${base}/v2/chat/completions`, {
+        method: "POST",
+        headers: growthHeaders({ at, uid, domain, enterpriseId }),
+        body: JSON.stringify(body),
+        signal: timeoutSignal(timeoutMs),
+      });
+    } catch (e) {
+      last = { ok: false, status: 0, msg: String(e?.message || e).slice(0, 200) };
+      continue;
+    }
+    try {
+      const reader = res.body?.getReader?.();
+      if (reader) { await reader.read(); await reader.cancel?.(); }
+    } catch {}
+    if (res.status === 200) return { ok: true, status: 200 };
+    last = { ok: false, status: res.status, msg: `HTTP ${res.status}` };
+  }
+  return last;
+}
+
+// 单账号闭环：拉列表 → 逐任务(accept→等落库→触发×N→等复查) → 统一领奖。
+export async function runGrowthAccount({
+  uid, at, domain, enterpriseId,
+  codes, model,
+  fetchImpl = compatFetch, sleepFn = defaultSleep,
+  gaps = {}, onStep = null,
+} = {}) {
+  const g = { eventMs: 1200, accountMs: 1000, pollMs: 500, acceptTimeoutMs: 8000, verifyTimeoutMs: 8000, ...gaps };
+  const api = { uid, at, domain, enterpriseId, fetchImpl };
+  const step = (e) => { try { onStep?.(e); } catch {} };
+  const out = { uid, ok: true, tasks: [], credit: 0, energy: 0 };
+
+  const listed = await growthTasks(api);
+  if (!listed.ok) { out.ok = false; out.error = listed.msg || "拉取任务列表失败"; return out; }
+  const byCode = new Map(listed.tasks.map((t) => [t.task_code, t]));
+  const wanted = Array.isArray(codes) && codes.length ? codes : listed.tasks.map((t) => t.task_code);
+
+  const latestOf = async (code) => {
+    const r = await growthTasks(api);
+    return r.ok ? r.tasks.find((t) => t.task_code === code) : undefined;
+  };
+
+  for (const code of wanted) {
+    const raw = byCode.get(code);
+    if (!raw) { out.tasks.push({ task_code: code, ok: false, skipped: "任务不存在" }); continue; }
+    const info = classifyTask(raw);
+    if (info.accept_status === "claimed") {
+      out.tasks.push({ task_code: code, title: info.title, ok: true, skipped: "已领取", status: "claimed" });
+      step({ phase: "task", task_code: code, skipped: "已领取" });
+      continue;
+    }
+    if (!info.actionable) {
+      out.tasks.push({ task_code: code, title: info.title, ok: false, skipped: info.strategy || "需人工完成", level: info.level });
+      step({ phase: "task", task_code: code, skipped: info.strategy });
+      continue;
+    }
+    if (info.accept_status === "not_accepted") {
+      const ar = await growthAccept(api, [code]);
+      step({ phase: "accept", task_code: code, ok: ar.ok, msg: ar.msg });
+      if (ar.ok) {
+        await waitFor(async () => {
+          const t = await latestOf(code);
+          return !!t && !!t.accept_status && t.accept_status !== "not_accepted";
+        }, { timeoutMs: g.acceptTimeoutMs, intervalMs: g.pollMs, sleepFn });
+      }
+    }
+    let fired = 0;
+    for (let i = 0; i < info.need_times; i++) {
+      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);
+    }
+    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 });
+    const latest = (await latestOf(code)) || info;
+    const item = {
+      task_code: code,
+      title: latest.title || info.title || code,
+      ok: fired > 0,
+      fired,
+      times: info.need_times,
+      status: latest.accept_status,
+      progress: `${latest.progress?.current ?? 0}/${latest.progress?.target ?? "?"}`,
+    };
+    out.tasks.push(item);
+    step({ phase: "task", ...item });
+  }
+
+  const done = (await growthTasks(api)).tasks.filter((t) => t.accept_status === "completed");
+  for (const t of done) {
+    const cr = await growthClaim(api, t.task_code);
+    const credit = Number(cr.data?.credit || 0);
+    const energy = Number(cr.data?.energy || 0);
+    if (cr.ok) {
+      out.credit += credit;
+      out.energy += energy;
+      const item = out.tasks.find((x) => x.task_code === t.task_code);
+      if (item) { item.status = "claimed"; item.credit = credit; item.energy = energy; item.ok = true; }
+    }
+    step({ phase: "claim", task_code: t.task_code, ok: cr.ok, credit, energy, msg: cr.msg });
+    await sleepFn(g.eventMs);
+  }
+  if (out.tasks.length && out.tasks.every((t) => !t.ok)) out.ok = false;
+  return out;
+}
+
+// 多账号串行（账号间 1s 节流；单账号异常不挡后续）。
+export async function runGrowthAll({ accounts = [], onAccount, ...opts } = {}) {
+  const results = [];
+  let creditTotal = 0;
+  for (const a of accounts) {
+    let row;
+    try { row = await runGrowthAccount({ ...opts, ...a }); }
+    catch (e) { row = { uid: a.uid, ok: false, tasks: [], credit: 0, energy: 0, error: String(e?.message || e).slice(0, 200) }; }
+    results.push(row);
+    creditTotal += row.credit || 0;
+    try { onAccount?.(row); } catch {}
+    await (opts.sleepFn || defaultSleep)(opts.gaps?.accountMs ?? 1000);
+  }
+  return { ok: results.some((r) => r.ok), results, creditTotal };
+}

package/src/runtime/bootstrap.js

@@ -24,4 +24,9 @@ export async function startDaemonMain(VERSION) {
   void setupWorkbuddyCheckin({ bus, logs }).catch((e) => {
     try { logs.appendEvent({ ts: Date.now(), type: "workbuddy-checkin-setup-failed", error: String(e?.message || e).slice(0, 200) }); } catch {}
   });
+
+  const { setupWorkbuddyGrowth } = await import("./workbuddy-growth.js");
+  void setupWorkbuddyGrowth({ bus, logs }).catch((e) => {
+    try { logs.appendEvent({ ts: Date.now(), type: "workbuddy-growth-setup-failed", error: String(e?.message || e).slice(0, 200) }); } catch {}
+  });
 }

package/src/runtime/workbuddy-checkin.js

@@ -20,17 +20,17 @@ export function todayKey(d = new Date()) {
 }
 
 // 到下一次计划点的毫秒数（今天未到点→今天，已过→明天同时）。
-export function nextRunDelayMs(now = new Date(), hour = 9) {
+export function nextRunDelayMs(now = new Date(), hour = 9, minute = 0) {
   const next = new Date(now);
-  next.setHours(hour, 0, 0, 0);
+  next.setHours(hour, minute, 0, 0);
   if (next.getTime() <= now.getTime()) next.setDate(next.getDate() + 1);
   return next.getTime() - now.getTime();
 }
 
 // 启动补签：已过今日计划点、且（从没签过 或 上次不是今天）。
-export function shouldCatchUp({ lastDate, now = new Date(), hour = 9 } = {}) {
+export function shouldCatchUp({ lastDate, now = new Date(), hour = 9, minute = 0 } = {}) {
   const point = new Date(now);
-  point.setHours(hour, 0, 0, 0);
+  point.setHours(hour, minute, 0, 0);
   if (now.getTime() < point.getTime()) return false;
   return !lastDate || lastDate !== todayKey(now);
 }

package/src/runtime/workbuddy-growth.js

@@ -0,0 +1,133 @@
+import { compatFetch } from "../compat.js";
+import { todayKey, nextRunDelayMs, shouldCatchUp } from "./workbuddy-checkin.js";
+// daemon 内置 WorkBuddy 成长任务 + 猫猫旅行每日自动（A 方案）：
+// 多账号串行（任务间 1.2s、账号间 1s 节流）+ 启动补跑 + 每日定时（默认 09:30，与 09:00 签到错峰）。
+// 开关：MSLXDFF_WORKBUDDY_GROWTH=0 关闭（默认开）；时间：MSLXDFF_WORKBUDDY_GROWTH_HOUR（默认 9）。
+// 幂等：已 claimed 的任务跳过；结果落 state.workbuddyGrowth 防重复补跑。
+
+export const GROWTH_MINUTE = 30;
+
+export function isGrowthEnabled(env = process.env) {
+  const v = String(env.MSLXDFF_WORKBUDDY_GROWTH ?? "1").trim().toLowerCase();
+  return !["0", "false", "off", "no"].includes(v);
+}
+
+export function getGrowthHour(env = process.env) {
+  const h = Number(env.MSLXDFF_WORKBUDDY_GROWTH_HOUR);
+  return Number.isInteger(h) && h >= 0 && h <= 23 ? h : 9;
+}
+
+export function nextGrowthDelayMs(now = new Date(), hour = 9, minute = GROWTH_MINUTE) {
+  return nextRunDelayMs(now, hour, minute);
+}
+
+export function shouldGrowthCatchUp({ lastDate, now = new Date(), hour = 9, minute = GROWTH_MINUTE } = {}) {
+  return shouldCatchUp({ lastDate, now, hour, minute });
+}
+
+const sleep = (ms) => new Promise((r) => { const t = setTimeout(r, ms); if (typeof t.unref === "function") t.unref(); });
+
+export async function setupWorkbuddyGrowth({ bus, logs } = {}) {
+  function emit(type, data = {}) {
+    const entry = { ts: Date.now(), type, ...data };
+    try { bus?.emit(entry); } catch {}
+    try { logs?.appendEvent?.(entry); } catch {}
+    console.log(`[workbuddy-growth] ${type} ${JSON.stringify(data)}`.slice(0, 500));
+  }
+  if (!isGrowthEnabled()) {
+    console.log("[workbuddy-growth] disabled (set MSLXDFF_WORKBUDDY_GROWTH=1 to enable)");
+    emit("workbuddy-growth-disabled");
+    return { enabled: false };
+  }
+  const hour = getGrowthHour();
+  console.log(`[workbuddy-growth] enabled: daily ${String(hour).padStart(2, "0")}:${GROWTH_MINUTE} local, multi-account serial`);
+  emit("workbuddy-growth-enabled", { hour, minute: GROWTH_MINUTE });
+
+  const stateMod = await import("../state.js");
+  const { runGrowthAll } = await import("../providers/workbuddy/growth.js");
+  const { runCatTravel } = await import("../providers/workbuddy/cat-travel.js");
+  const { createAuthService, decodeJwtExp } = await import("../providers/workbuddy/auth.js");
+
+  let running = false;
+  async function loadAccounts() {
+    const cfg = stateMod.loadProviderConfigs().workbuddy || {};
+    const keys = [...(Array.isArray(cfg.keys) ? cfg.keys : [])];
+    const authList = [...(Array.isArray(cfg.auths) ? cfg.auths : [])];
+    if (!keys.length) return null;
+    // 先给临期 token 续期（与签到调度同款：refresh 结果经 store 回写 state 与 auths 文件）
+    const authService = createAuthService({ fetchImpl: compatFetch, store: { keys, authList } });
+    await Promise.all(authList.map(async (auth, i) => {
+      try {
+        const exp = decodeJwtExp(keys[i]);
+        if (exp && exp - Date.now() / 1000 < 3600) await authService.refreshTokenFor(keys[i], auth);
+      } catch {}
+    }));
+    return authList
+      .map((a, i) => ({ uid: a.uid, at: keys[i], domain: a.domain, enterpriseId: a.enterpriseId }))
+      .filter((a) => a.uid && a.at);
+  }
+
+  async function runOnce(reason) {
+    if (running) return { skipped: "already-running" };
+    running = true;
+    try {
+      const accounts = await loadAccounts();
+      if (!accounts?.length) {
+        emit("workbuddy-growth-no-accounts", { reason });
+        return { ok: false, reason: "no-accounts" };
+      }
+      const growthRes = await runGrowthAll({
+        accounts,
+        onAccount: (row) => emit("workbuddy-growth-account", {
+          uid: String(row.uid).slice(0, 8), ok: row.ok, credit: row.credit,
+          tasks: row.tasks.filter((t) => t.ok && !t.skipped).length, reason,
+        }),
+      });
+      const travel = [];
+      for (const a of accounts) {
+        try {
+          const r = await runCatTravel({ uid: a.uid, at: a.at, domain: a.domain, enterpriseId: a.enterpriseId });
+          travel.push({ uid: a.uid, outcome: r.outcome, credits: r.credits, summary: r.summary });
+          emit("workbuddy-growth-travel", { uid: String(a.uid).slice(0, 8), outcome: r.outcome, credits: r.credits, reason });
+        } catch (e) {
+          travel.push({ uid: a.uid, outcome: "error", credits: 0, summary: String(e?.message || e).slice(0, 120) });
+        }
+        await sleep(1000);
+      }
+      const date = todayKey();
+      const creditTotal = growthRes.creditTotal + travel.reduce((s, r) => s + (r.credits || 0), 0);
+      try {
+        stateMod.writeStateImmediate(stateMod.defaultStateFile(), {
+          workbuddyGrowth: {
+            date, at: Date.now(), ok: growthRes.ok, credit: creditTotal, accounts: accounts.length,
+            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 };
+    } 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) };
+    } finally {
+      running = false;
+    }
+  }
+
+  // 启动补跑：昨天没跑且已过今天计划点，60s 后跑（等网络/上游就绪）
+  try {
+    const lastDate = stateMod.readState(stateMod.defaultStateFile())?.workbuddyGrowth?.date || "";
+    if (shouldGrowthCatchUp({ lastDate, hour })) {
+      setTimeout(() => { runOnce("catch-up").catch(() => {}); }, 60_000).unref?.();
+      console.log(`[workbuddy-growth] catch-up scheduled (last=${lastDate || "never"})`);
+    }
+  } catch {}
+  function arm() {
+    const delay = nextGrowthDelayMs(new Date(), hour);
+    setTimeout(() => {
+      runOnce("daily").catch(() => {}).finally(arm);
+    }, delay).unref?.();
+  }
+  arm();
+  return { enabled: true, hour, minute: GROWTH_MINUTE, runOnce };
+}