magicrew-auth 0.3.8 → 0.3.14

package/src/inspect.mjs

@@ -0,0 +1,191 @@
+// 体检 —— 「首任务做了没」「邀请奖励到没到账」
+//
+// ═══════════════════════════════════════════════════════════════════════
+// 为什么需要它
+// ═══════════════════════════════════════════════════════════════════════
+//
+// 邀请奖励不是「注册即得」。官方前端 locale 的原文是：
+//
+//   被邀请人完成首个任务或对话后，即可获得 {{points}} 积分奖励。
+//
+// 于是每次拉新都卡在同一个问题上：**小号到底算不算「完成」了？钱到没到？**
+// 手工去网页翻「免费积分计划」里那张表很麻烦，尤其号一多。
+//
+// 所以给 magpie 的登录方式列表里挂一条「体检」：点一下，把所有账号的
+// 首任务状态、邀请人数、奖励明细一次列出来。不输入、不改任何状态。
+//
+// ⚠ 判据不是猜的：`first_ai_work` 与邀请奖励用的是同一套「产品内完成过」
+//   判定。实测同一个号通过 magpie 调模型、真扣了积分，`first_ai_work`
+//   仍然是 PENDING，邀请奖励也一分不发 —— 见 CHANGELOG 0.3.9。
+
+import { readFileSync } from "node:fs"
+import { homedir } from "node:os"
+import { join } from "node:path"
+import {
+  SITES,
+  fetchWho,
+  fetchPoints,
+  fetchOnboardingTasks,
+  fetchOwnInviteCode,
+  fetchInviteRewards,
+} from "./api.mjs"
+
+/** magpie 的凭据库；zcode 插件也是直接读它来枚举多账号的 */
+function authStorePath(home = homedir()) {
+  return join(home, ".config", "magpie", "plugin-auth.json")
+}
+
+/**
+ * 枚举本机已登录的全部 magicrew 账号。
+ *
+ * 键名形如 `magicrew`、`magicrew-intl`、`magicrew#4rm3fp`、`magicrew-intl#z983c8`，
+ * 所以按 `magicrew-intl` 前缀判站点，剩下的都算国内站。
+ *
+ * @returns {Array<{id,siteId,site,jwt,org,accountId}>}
+ */
+export function listAccounts({ home = homedir() } = {}) {
+  let raw
+  try {
+    raw = JSON.parse(readFileSync(authStorePath(home), "utf8"))
+  } catch {
+    return []
+  }
+  const out = []
+  for (const [id, e] of Object.entries(raw)) {
+    // 宿主里的键名是 `magicrew` / `magicrew#4rm3fp` / `magicrew-intl` / `magicrew-intl#z983c8`
+    // ⚠ 别写成 /^magicrew(#|$)/ —— 那样 `magicrew-intl*` 全部匹配不上，
+    //   国际站会显示「还没有登录任何账号」（踩过）
+    if (!/^magicrew(-intl)?(#|$)/.test(id)) continue
+    if (typeof e?.jwt !== "string" || !e.jwt) continue
+    const siteId = id.startsWith("magicrew-intl") ? "intl" : "cn"
+    out.push({
+      id,
+      siteId,
+      site: SITES[siteId],
+      jwt: e.jwt,
+      org: String(e.org ?? ""),
+      accountId: String(e.accountId ?? id),
+    })
+  }
+  return out
+}
+
+/**
+ * 查一个账号的四件事。任一接口挂了不影响其它项 —— 体检要尽量给出全貌，
+ * 不能因为「积分读不到」就整份报告作废。
+ */
+export async function inspectOne(a) {
+  const host = a.site.host
+  const r = { ...a, errors: [], points: null, who: null, firstTask: null, invite: null, rewards: null }
+
+  const guard = async (name, p) => {
+    try {
+      return await p
+    } catch (e) {
+      r.errors.push(`${name}：${e?.message ?? e}`)
+      return null
+    }
+  }
+
+  // 五个请求并发：串行要等五轮，太慢；guard 已保证单个失败不拖垮整份报告
+  const [points, who, tasks, invite, rewards] = await Promise.all([
+    guard("积分", fetchPoints(a.jwt, a.org, host)),
+    guard("账号名", fetchWho(a.jwt, a.org, host)),
+    guard("首任务", fetchOnboardingTasks(a.jwt, a.org, host)),
+    guard("邀请码", fetchOwnInviteCode(a.jwt, a.org, host)),
+    guard("邀请奖励", fetchInviteRewards(a.jwt, a.org, host)),
+  ])
+
+  r.points = points
+  r.who = who
+  r.invite = invite
+  r.rewards = rewards
+
+  if (tasks) {
+    const t = tasks.find((x) => x.code === "first_ai_work")
+    r.firstTask = t
+      ? {
+          done: t.status === "COMPLETED" || t.rewardStatus === "GRANTED",
+          points: t.points,
+          at: t.completedAt,
+        }
+      : { done: null, points: 0, at: null } // null = 本站没有这项任务（国际站恒如此）
+  }
+
+  return r
+}
+
+/** 一个账号一段，纯文本 —— magpie 那边是当错误信息弹出来的，不做富文本 */
+export function formatOne(r) {
+  const tag = r.siteId === "intl" ? "国际站" : "国内站"
+  // 昵称/手机号好认；取不到才退回组织码（那是一串随机字母数字，认不出是谁）
+  const who = r.who?.name || r.org || r.accountId
+  const L = []
+  L.push(`【${tag}】${who}  (${r.org})`)
+
+  if (r.points) L.push(`  积分 ${r.points.total}`)
+  else L.push("  积分 读取失败")
+
+  if (r.firstTask === null) {
+    L.push("  首任务 读取失败")
+  } else if (r.firstTask.done === null) {
+    L.push(`  首任务 —（本站没有新手福利，无需完成）`)
+  } else if (r.firstTask.done) {
+    // completed_at 是 UTC 带时区的 ISO；本地化再显示，否则会差 8 小时
+    let at = ""
+    if (r.firstTask.at) {
+      try {
+        at = " " + new Date(r.firstTask.at).toLocaleString("zh-CN", { hour12: false })
+      } catch {}
+    }
+    L.push(`  首任务 ✅ 已完成${at}`)
+  } else {
+    L.push(`  首任务 ⏳ 未完成${r.firstTask.points ? `（完成可得 ${r.firstTask.points} 分）` : ""}`)
+    L.push("         ↳ 需在网页/客户端里真跑完一次对话或任务，通过 magpie 调模型不算")
+  }
+
+  if (r.invite) {
+    const n = r.invite.count
+    const earned = r.rewards ? r.rewards.earned : 0
+    L.push(`  邀请码 ${r.invite.code} · 已邀 ${n} 人 · 已到账 ${earned} 分`)
+  } else {
+    L.push("  邀请码 读取失败")
+  }
+
+  if (r.rewards) {
+    if (!r.rewards.list.length) {
+      L.push(`  奖励记录 0 条${r.invite?.count ? "  ← 有人用了你的码，但还没「完成首任务」，所以没发" : ""}`)
+    } else {
+      for (const x of r.rewards.list) {
+        const who = x.invitedUserId ? ` 邀请 ${x.invitedUserId.slice(0, 14)}…` : ""
+        L.push(`    · ${x.description} +${x.points} · ${x.statusText}${who}`)
+      }
+    }
+  }
+
+  if (r.errors.length) L.push(`  ⚠ ${r.errors.join("；")}`)
+  return L.join("\n")
+}
+
+/**
+ * 全量体检，返回可直接展示的整份报告。
+ *
+ * @param {{siteId?: "cn"|"intl"}} opts 传了就只查该站点（两个 provider 各挂一条，
+ *   点哪个就只看哪个站，跟「一个包两个供应商、互不聚合」保持一致）
+ */
+export async function buildReport({ siteId } = {}) {
+  const all = listAccounts()
+  const accounts = siteId ? all.filter((a) => a.siteId === siteId) : all
+  if (!accounts.length) {
+    const where = siteId === "intl" ? "国际站 MagiCrew " : siteId === "cn" ? "国内站 超级麦吉 " : ""
+    return where
+      ? `${where}还没有登录任何账号，先添加一个再来体检。`
+      : "还没有登录任何超级麦吉 / MagiCrew 账号，先添加一个再来体检。"
+  }
+  const rows = []
+  // 串行：一批号同时打四五个请求容易撞限流，慢一点但结果可信
+  for (const a of accounts) rows.push(await inspectOne(a))
+  return [`体检（${accounts.length} 个账号）`, ...rows.map(formatOne)].join("\n\n")
+}
+
+export { authStorePath }

package/src/store.mjs

@@ -217,6 +217,109 @@ function noteOrg(siteId, org) {
   } catch {}
 }
 
+// ═══ 「首次 AI 工作 / 首个对话」的一次性标记 ═════════════════════════
+//
+// 这件事对每个账号**只该做一次**。目的只有一个：满足服务端
+// 「被邀请人完成首个任务或对话后，邀请人才能拿到积分」那条判定。
+// 邀请奖励只发一次，所以补一次就够，再发纯属白烧积分。
+//
+// 早前的闸门写错了 —— 按「今天发过没有」记日期，于是：
+//
+//   ① 服务端结算慢（几十秒到几分钟）、或者任务状态压根不翻 COMPLETED 时，
+//      第二天签到又看到 PENDING，再发一条。一个号天天烧钱。
+//   ② 只按「有没有项目」判：项目建了但消息没发出去，会被当成「已用过」
+//      而永远不补；反过来项目没建成，每次进来都重试。
+//
+// 现在的规则：
+//   · 发送成功 → 写 `status: "sent"`，**此后再也不发**（换天、重登、重启都一样）
+//   · 真去发了但失败 → 记 attempts，最多 MAX_AUTOCHAT_ATTEMPTS 次，到顶写
+//     `gave-up` 也不再发（别让一个永远失败的号每次签到都撞一遍）
+//   · 「还没有工作台/项目」不算失败 —— 那是账号没就绪，不计数，下次再来
+//   · 老文件里的 `"YYYY-MM-DD"` 字符串按「已发过」读，升级后不会重发
+//
+// 文件：~/.cache/magpie/magicrew-autochat-<siteId>.json
+//   { [org]: { at: "ISO", status: "sent" | "failed" | "gave-up", attempts: n, reason?: "…" } }
+
+const MAX_AUTOCHAT_ATTEMPTS = 3
+
+function autochatPath(siteId) {
+  return join(cacheDir(), `magicrew-autochat-${siteId}.json`)
+}
+
+/**
+ * 读整张表。老格式（值为 `"YYYY-MM-DD"` 字符串）归一成 `{ at, status: "sent" }`,
+ * 这样升级后的第一次读就把历史账号认成「已经补过」。
+ */
+export function readAutoChat(siteId) {
+  try {
+    const v = JSON.parse(readFileSync(autochatPath(siteId), "utf8"))
+    if (!v || typeof v !== "object") return {}
+    const out = {}
+    for (const [org, e] of Object.entries(v)) {
+      if (typeof e === "string") out[org] = { at: e, status: "sent", attempts: 1, legacy: true }
+      else if (e && typeof e === "object") out[org] = e
+    }
+    return out
+  } catch {
+    return {}
+  }
+}
+
+/** 这个账号的那一笔，没有就 null */
+export function readAutoChatEntry(siteId, org) {
+  return readAutoChat(siteId)[org] ?? null
+}
+
+/** 已经补过（或已放弃）→ 一次都不再发。换天也不会。 */
+export function isAutoChatSettled(siteId, org) {
+  const e = readAutoChatEntry(siteId, org)
+  return !!e && (e.status === "sent" || e.status === "gave-up")
+}
+
+function writeAutoChat(siteId, org, entry) {
+  try {
+    const m = readAutoChat(siteId)
+    m[org] = entry
+    // 只留最近 200 个账号，文件别无限涨
+    const keys = Object.keys(m)
+    if (keys.length > 200) for (const k of keys.slice(0, keys.length - 200)) delete m[k]
+    const f = autochatPath(siteId)
+    mkdirSync(dirname(f), { recursive: true })
+    writeFileSync(f, JSON.stringify(m))
+  } catch {}
+}
+
+/** 消息确实发出去了 —— 从此这个账号不再补。只在**发送成功**后调用。 */
+export function noteAutoChat(siteId, org, extra = {}) {
+  const prev = readAutoChatEntry(siteId, org)
+  writeAutoChat(siteId, org, {
+    at: new Date().toISOString(),
+    status: "sent",
+    attempts: (Number(prev?.attempts) || 0) + 1,
+    ...extra,
+  })
+}
+
+/**
+ * 真去发了但没成 —— 记一次尝试，留给下一次。
+ *
+ * @returns {{attempts:number, givenUp:boolean}}
+ */
+export function noteAutoChatFailure(siteId, org, reason) {
+  const prev = readAutoChatEntry(siteId, org)
+  const attempts = (Number(prev?.attempts) || 0) + 1
+  const givenUp = attempts >= MAX_AUTOCHAT_ATTEMPTS
+  writeAutoChat(siteId, org, {
+    at: new Date().toISOString(),
+    status: givenUp ? "gave-up" : "failed",
+    attempts,
+    reason: String(reason ?? "").slice(0, 200),
+  })
+  return { attempts, givenUp }
+}
+
+export { MAX_AUTOCHAT_ATTEMPTS }
+
 export {
   AUTHOR_INVITE,
   cacheDir,

package/src/tasks.mjs

@@ -20,7 +20,13 @@
 //
 // 每天跑一次，两步都做，任一步失败不影响另一步。
 
-import { fetchPoints, claimLoginGift, fetchOnboardingTasks, completeOnboardingTask } from "./api.mjs"
+import { fetchPoints, claimLoginGift, fetchOnboardingTasks, completeOnboardingTask, fetchFirstWorkspaceId, fetchProjectTopics } from "./api.mjs"
+import { isAutoChatSettled, noteAutoChat, noteAutoChatFailure } from "./store.mjs"
+
+/** 站点 id —— 去重标记按站点分文件存 */
+function siteIdOf(host) {
+  return host.includes("magicrew") ? "magicrew-intl" : "magicrew"
+}
 
 /** 已知不支持手动完成的任务，别再白试 */
 const NOT_MANUALLY_COMPLETABLE = new Set(["first_ai_work"])
@@ -74,8 +80,24 @@ export async function runCheckin(auth) {
     failed = true
     parts.push(`新手任务读取失败：${tasksErr?.message ?? tasksErr}`)
   } else if (!tasks.length) {
-    // ⚠ 空列表 ≠ 已完成。国际站这个接口对未登记账号恒返回空数组。
-    parts.push("本站无新手福利任务")
+    // 国际站：onboarding 接口恒返回空数组，没有「新手福利」这套任务。
+    // 但**邀请奖励的判据是一样的** —— 官方 locale 原文「被邀请人完成首个任务
+    // 或对话后，即可获得 {{points}} 积分奖励」，而国际站没有任务清单，
+    // 所以那条判据在这边就等于「发过一条消息」。
+    //
+    // 实测（2026-10-28）：新号发一条消息后，邀请人立刻 +200。
+    //
+    // 怎么判断「要不要发」：看这个账号有没有工作台项目 ——
+    //   一个项目都没有 = 从没发过消息 → 建项目 + 发一条
+    //   已经有项目     = 用过 → 跳过（别每天签到都发，白烧积分）
+    const r = await autoFirstChat(h)
+    if (r.ok) {
+      claimedAnything = true
+      parts.push(`首对话：已自动完成（${r.topicName}，模型 ${r.model}）`)
+    } else if (!r.settled) {
+      // settled = 这个账号早就补过了（一次性任务）—— 不必每天在签到消息里复述
+      parts.push(`首对话：${r.reason}`)
+    }
   } else {
     const pending = tasks.filter((t) => t.status !== "COMPLETED" && t.rewardStatus !== "GRANTED")
 
@@ -87,8 +109,20 @@ export async function runCheckin(auth) {
       const taskFailed = []
 
       for (const t of pending) {
-        if (NOT_MANUALLY_COMPLETABLE.has(t.code)) {
-          skipped.push(`${t.title}（${t.points} 分，要真跑一次 AI 任务）`)
+        // 「完成第一次 AI 工作」是唯一 PUT 不掉的：服务端认死必须是产品内
+        // 真的跑完过一次对话（PUT 回 9303）。所以改成**替它发一条消息** ——
+        // 走 chat-task 的纯协议通道，不开浏览器。
+        // 这也是邀请奖励的触发条件：被邀请人完成首个任务后，邀请人才拿到分。
+        if (t.code === "first_ai_work") {
+          const r = await autoFirstWork(h)
+          if (r.ok) {
+            claimed.push({ code: t.code, title: t.title, points: t.points })
+            if (r.pending) parts.push("首任务：消息已发出，等结算")
+          } else if (r.settled) {
+            // 这个账号早就补过了（一次性任务）—— 安静跳过，不必每天复述
+          } else {
+            skipped.push(`${t.title}（${t.points} 分）：${r.reason}`)
+          }
           continue
         }
         try {
@@ -134,4 +168,159 @@ export async function runCheckin(auth) {
   }
 }
 
+/**
+ * 替账号完成「第一次 AI 工作」：建个话题、发一条消息、等结算。
+ *
+ * 为什么不能 PUT：`PUT /onboarding/tasks/first_ai_work/completion` 回 9303
+ * 「该新人引导任务不支持手动完成」—— 服务端只认产品内真的有一次对话。
+ *
+ * 为什么不用浏览器：消息走 Socket.IO，协议已经摸清（见 chat-task.mjs），
+ * 纯 Node 发得出去，比拉一个 Chrome 再点输入框可靠得多。
+ *
+ * @returns {{ok:boolean, pending?:boolean, reason?:string}}
+ */
+async function autoFirstWork(h) {
+  const siteId = siteIdOf(h.host)
+
+  // 闸门：这个账号**曾经**补过就不再发 —— 不是「今天发过没有」。
+  // 邀请奖励只发一次，补第二遍纯属白烧积分（见 store.mjs 那节注释）。
+  if (isAutoChatSettled(siteId, h.org)) {
+    return { ok: false, settled: true, reason: "首任务此前已补过（一次性任务）" }
+  }
+
+  try {
+    const wsId = await fetchFirstWorkspaceId(h.jwt, h.org, h.host).catch(() => "")
+    if (!wsId) {
+      // 账号还没进过工作台 —— 不算失败、也不计数：只读接口，下次签到再来
+      return { ok: false, reason: "这个账号还没有工作台 —— 先在网页里进一次工作台" }
+    }
+
+    // 重模块按需加载：WebSocket 那套挂了不该拖累整个签到
+    const { runChatTask } = await import("./chat-task.mjs")
+    const r = await runChatTask({
+      jwt: h.jwt,
+      org: h.org,
+      host: h.host,
+      workspaceId: wsId,
+    })
+    if (!r.ok) {
+      // 真去发了但没成 —— 计数，到上限就放弃，别让一个永远失败的号每次签到撞一遍
+      const f = noteAutoChatFailure(siteId, h.org, r.reason || "发送失败")
+      const why = r.reason || "发送失败"
+      return { ok: false, reason: f.givenUp ? `${why}（已试 ${f.attempts} 次，不再重试）` : why }
+    }
+
+    // 消息确实发出去了 —— 立刻写**一次性**标记。之后不管结算成不成功、换不换天、
+    // 重不重登，都不会再发第二条：这件事判的是「有没有过」，不是「今天有没有」。
+    noteAutoChat(siteId, h.org, { topicId: r.topicId || undefined, model: r.model || undefined })
+
+    // 顺手等一会儿结算，让签到消息报得准。拿不到也无所谓 —— 标记已经写了，
+    // 下次签到看到 PENDING 只会安静跳过，不会再发消息。
+    for (let i = 0; i < 12; i++) {
+      await new Promise((res) => setTimeout(res, 5000))
+      const list = await fetchOnboardingTasks(h.jwt, h.org, h.host).catch(() => null)
+      if (!list) continue
+      const fw = list.find((x) => x.code === "first_ai_work")
+      if (fw && (fw.status === "COMPLETED" || fw.rewardStatus === "GRANTED")) {
+        return { ok: true }
+      }
+    }
+    return { ok: true, pending: true }
+  } catch (e) {
+    const why = String(e?.message ?? e)
+    const f = noteAutoChatFailure(siteId, h.org, why)
+    return { ok: false, reason: f.givenUp ? `${why}（已试 ${f.attempts} 次，不再重试）` : why }
+  }
+}
+
+/**
+ * 国际站的「首个对话」：没有任务清单可依，只能看它用没用过。
+ *
+ * 判据是**有没有话题**，不是有没有工作台项目 —— 项目在打开工作台时就会
+ * 自动建，「建了项目、一句话没说」的新号很常见，而那种号正是需要补一条的。
+ * 话题才是「真的发过消息」的证据。
+ *
+ * @returns {{ok?:boolean, settled?:boolean, reason?:string, topicName?:string, model?:string}}
+ */
+async function autoFirstChat(h) {
+  const siteId = siteIdOf(h.host)
+  // 同一道闸门：一次性。换天、重登、重启都不会再发。
+  if (isAutoChatSettled(siteId, h.org)) {
+    return { settled: true, reason: "首对话此前已补过（一次性任务）" }
+  }
+
+  try {
+    const wsId = await fetchFirstWorkspaceId(h.jwt, h.org, h.host).catch(() => "")
+    if (!wsId) return { reason: "这个账号还没有工作区，先在网页里进一次" }
+
+    const { findProjectId, runChatTask } = await import("./chat-task.mjs")
+    const pid = await findProjectId(h.jwt, h.org, h.host, wsId).catch(() => "")
+    if (pid) {
+      let topics
+      try {
+        topics = await fetchProjectTopics(h.jwt, h.org, pid, h.host)
+      } catch (e) {
+        // 查不到判据就**这次不发**：宁可漏一轮（下次登录 / 签到还会来），
+        // 也不要把「接口抖了一下」当成「没说过话」白花一次积分。
+        // 不落标记、不计数 —— 这不是失败，是没拿到判据。
+        return { reason: `话题清单查不到（${String(e?.message ?? e)}），这次不发` }
+      }
+      if (topics.length > 0) {
+        // 有话题 = 真的发过消息 → 落一次性标记，以后连查都不查
+        noteAutoChat(siteId, h.org, { reason: `已有 ${topics.length} 个话题，视为用过` })
+        return { settled: true, reason: `此前已用过（已有 ${topics.length} 个话题）` }
+      }
+      // 有项目、没话题：项目多半是打开工作台时自动建的，一句话没说 —— 往下补。
+    }
+
+    const r = await runChatTask({ jwt: h.jwt, org: h.org, host: h.host, workspaceId: wsId })
+    if (!r.ok) {
+      const f = noteAutoChatFailure(siteId, h.org, r.reason || "发送失败")
+      const why = r.reason || "发送失败"
+      return { reason: f.givenUp ? `${why}（已试 ${f.attempts} 次，不再重试）` : why }
+    }
+
+    // 发出去了才写一次性标记；失败的一直不写，留给下一次
+    noteAutoChat(siteId, h.org, { topicId: r.topicId || undefined, model: r.model || undefined })
+    return { ok: true, topicName: r.topicName, model: r.model }
+  } catch (e) {
+    const why = String(e?.message ?? e)
+    const f = noteAutoChatFailure(siteId, h.org, why)
+    return { reason: f.givenUp ? `${why}（已试 ${f.attempts} 次，不再重试）` : why }
+  }
+}
+
+/**
+ * 账号刚加进来时的一次性补完 —— 登录成功后调用，和签到共用同一道闸门。
+ *
+ * 为什么单独开一个入口：主人的要求是「一个账号加入的时候做一次」，
+ * 而不是「每天签到都做」。登录那一刻就是「加入」，做完就永久标记，
+ * 之后无论重登多少次、签到多少天，都不会再发第二条消息。
+ *
+ * 调用方**不要 await** —— 建项目 + 发消息 + 兜底等结算最坏要一分钟，
+ * 登录必须立刻返回。失败也不用管：下一个签到日 checkin 会接着做（同一道闸门）。
+ *
+ * @param {{jwt:string, org:string, host:string}} h
+ */
+export async function ensureFirstTaskOnce(h) {
+  const siteId = siteIdOf(h.host)
+  if (isAutoChatSettled(siteId, h.org)) return { settled: true }
+
+  // 国内站：有任务清单。清单里没有 first_ai_work、或者已经完成 → 什么都不用做
+  const tasks = await fetchOnboardingTasks(h.jwt, h.org, h.host).catch(() => null)
+  if (Array.isArray(tasks) && tasks.length) {
+    const fw = tasks.find((t) => t.code === "first_ai_work")
+    if (!fw) return { skipped: true, reason: "本站没有这项任务" }
+    if (fw.status === "COMPLETED" || fw.rewardStatus === "GRANTED") {
+      // 服务端已经认过了 —— 落标记，以后不查了
+      noteAutoChat(siteId, h.org, { reason: "服务端已标记完成" })
+      return { skipped: true, reason: "已完成" }
+    }
+    return autoFirstWork(h)
+  }
+
+  // 国际站：没有任务清单 → 看有没有话题（不是有没有项目）
+  return autoFirstChat(h)
+}
+
 export { NOT_MANUALLY_COMPLETABLE }