magicrew-auth 0.3.8 → 0.3.13

package/src/model-context.mjs

@@ -1,100 +1,100 @@
-// 模型上下文窗口 —— 向 magpie 自己的模型库查
-//
-// ═══ 为什么不能自己填一个值 ═══════════════════════════════════════════
-//
-// magicrew 的两个模型接口**都不返回上下文窗口**：
-//   GET /api/v1/flows/models  → value / label / vision / tags / configs
-//   GET /v1/models            → id / object / created_at / owner_by
-//
-// 早前这里一律填 256_000 当保守值，后果是反的：
-// `pi-ai detected context overflow for model "magicrew/deepseek-v4.1-flash"`
-// —— agent 拿 256K 判断"放不下了"，而实际窗口是 1M，白砍掉四分之三。
-//
-// magpie 自己有一份模型库（`~/.cache/magpie/models.json`，按厂商分组，
-// 每条带 `limit.context`），它本来就随 magpie 更新。**向它查，不要自己编。**
-//
-// 查不到才退回保守值 —— 宁可保守，不要给出超过真实窗口的数（那会让 agent
-// 以为还有余量，请求超了上游才报错）。
-
-import { readFileSync } from "node:fs"
-import { homedir } from "node:os"
-import { join } from "node:path"
-
-/**
- * 查不到时的兜底：**1M**。
- *
- * 优先级从高到低：
- *   ① 用户在 magpie GUI 里手选的（「上下文窗口」那一行）—— magpie 直接用它，插件的值只是默认
- *   ② 本文件从 magpie 模型库查到的真实值（models.dev 数据）
- *   ③ 这个兜底
- *
- * ⚠ 兜底故意给大的：给 1M 而实际只有 128K 时，上游会在超限时报错，用户看得到；
- *   给 256K 而实际有 1M 时，agent 会主动拒绝一段本可以处理的对话 —— 那是静默的能力损失，
- *   比报错更难查（`pi-ai detected context overflow` 就是这么来的）。
- */
-const FALLBACK_CONTEXT = 1_048_576
-
-let cache = null
-let cacheAt = 0
-
-/** models.json 5-6MB，读一次缓存住；10 分钟内不重复读 */
-const CACHE_MS = 10 * 60_000
-
-function loadLibrary() {
-  if (cache && Date.now() - cacheAt < CACHE_MS) return cache
-  const idx = new Map()
-  try {
-    const raw = readFileSync(join(homedir(), ".cache", "magpie", "models.json"), "utf8")
-    const walk = (o) => {
-      if (Array.isArray(o)) {
-        for (const v of o) walk(v)
-        return
-      }
-      if (!o || typeof o !== "object") return
-      const id = typeof o.id === "string" ? o.id : ""
-      const ctx = o.limit?.context ?? o.context_length ?? o.context_window
-      if (id && Number(ctx) > 0) {
-        idx.set(id.toLowerCase(), Number(ctx))
-        // 同一个模型可能挂在多个厂商下（deepseek-ai/x、Pro/deepseek-ai/x …），
-        // 只保留最大值 —— 那才是它真能收的
-        const tail = id.toLowerCase().split("/").pop()
-        if (tail) {
-          const prev = idx.get(`~${tail}`) || 0
-          if (Number(ctx) > prev) idx.set(`~${tail}`, Number(ctx))
-        }
-      }
-      for (const v of Object.values(o)) walk(v)
-    }
-    walk(JSON.parse(raw))
-  } catch {}
-  cache = idx
-  cacheAt = Date.now()
-  return idx
-}
-
-/**
- * 这个模型的上下文窗口。
- * @param {string} modelId  插件侧的模型 id，如 `deepseek-v4.1-flash`
- * @returns {number} 字节按 token 计；查不到给保守值
- */
-export function contextOf(modelId) {
-  const id = String(modelId || "").toLowerCase()
-  if (!id) return FALLBACK_CONTEXT
-  const idx = loadLibrary()
-
-  // ① 全名命中（插件 id 恰好等于库里的 id）
-  if (idx.has(id)) return idx.get(id)
-
-  // ② 尾段命中：库里的 `deepseek-ai/deepseek-v4.1-flash` ↔ 我们的 `deepseek-v4.1-flash`
-  if (idx.has(`~${id}`)) return idx.get(`~${id}`)
-
-  // ③ 同一个模型挂在不同厂商前缀下，取最大的那个（真能收的容量）
-  let best = 0
-  for (const [k, v] of idx) {
-    if (k.startsWith("~")) continue
-    if (k.endsWith(`/${id}`) && v > best) best = v
-  }
-  return best || FALLBACK_CONTEXT
-}
-
-export const _internal = { FALLBACK_CONTEXT, loadLibrary }
+// 模型上下文窗口 —— 向 magpie 自己的模型库查
+//
+// ═══ 为什么不能自己填一个值 ═══════════════════════════════════════════
+//
+// magicrew 的两个模型接口**都不返回上下文窗口**：
+//   GET /api/v1/flows/models  → value / label / vision / tags / configs
+//   GET /v1/models            → id / object / created_at / owner_by
+//
+// 早前这里一律填 256_000 当保守值，后果是反的：
+// `pi-ai detected context overflow for model "magicrew/deepseek-v4.1-flash"`
+// —— agent 拿 256K 判断"放不下了"，而实际窗口是 1M，白砍掉四分之三。
+//
+// magpie 自己有一份模型库（`~/.cache/magpie/models.json`，按厂商分组，
+// 每条带 `limit.context`），它本来就随 magpie 更新。**向它查，不要自己编。**
+//
+// 查不到才退回保守值 —— 宁可保守，不要给出超过真实窗口的数（那会让 agent
+// 以为还有余量，请求超了上游才报错）。
+
+import { readFileSync } from "node:fs"
+import { homedir } from "node:os"
+import { join } from "node:path"
+
+/**
+ * 查不到时的兜底：**1M**。
+ *
+ * 优先级从高到低：
+ *   ① 用户在 magpie GUI 里手选的（「上下文窗口」那一行）—— magpie 直接用它，插件的值只是默认
+ *   ② 本文件从 magpie 模型库查到的真实值（models.dev 数据）
+ *   ③ 这个兜底
+ *
+ * ⚠ 兜底故意给大的：给 1M 而实际只有 128K 时，上游会在超限时报错，用户看得到；
+ *   给 256K 而实际有 1M 时，agent 会主动拒绝一段本可以处理的对话 —— 那是静默的能力损失，
+ *   比报错更难查（`pi-ai detected context overflow` 就是这么来的）。
+ */
+const FALLBACK_CONTEXT = 1_048_576
+
+let cache = null
+let cacheAt = 0
+
+/** models.json 5-6MB，读一次缓存住；10 分钟内不重复读 */
+const CACHE_MS = 10 * 60_000
+
+function loadLibrary() {
+  if (cache && Date.now() - cacheAt < CACHE_MS) return cache
+  const idx = new Map()
+  try {
+    const raw = readFileSync(join(homedir(), ".cache", "magpie", "models.json"), "utf8")
+    const walk = (o) => {
+      if (Array.isArray(o)) {
+        for (const v of o) walk(v)
+        return
+      }
+      if (!o || typeof o !== "object") return
+      const id = typeof o.id === "string" ? o.id : ""
+      const ctx = o.limit?.context ?? o.context_length ?? o.context_window
+      if (id && Number(ctx) > 0) {
+        idx.set(id.toLowerCase(), Number(ctx))
+        // 同一个模型可能挂在多个厂商下（deepseek-ai/x、Pro/deepseek-ai/x …），
+        // 只保留最大值 —— 那才是它真能收的
+        const tail = id.toLowerCase().split("/").pop()
+        if (tail) {
+          const prev = idx.get(`~${tail}`) || 0
+          if (Number(ctx) > prev) idx.set(`~${tail}`, Number(ctx))
+        }
+      }
+      for (const v of Object.values(o)) walk(v)
+    }
+    walk(JSON.parse(raw))
+  } catch {}
+  cache = idx
+  cacheAt = Date.now()
+  return idx
+}
+
+/**
+ * 这个模型的上下文窗口。
+ * @param {string} modelId  插件侧的模型 id，如 `deepseek-v4.1-flash`
+ * @returns {number} 字节按 token 计；查不到给保守值
+ */
+export function contextOf(modelId) {
+  const id = String(modelId || "").toLowerCase()
+  if (!id) return FALLBACK_CONTEXT
+  const idx = loadLibrary()
+
+  // ① 全名命中（插件 id 恰好等于库里的 id）
+  if (idx.has(id)) return idx.get(id)
+
+  // ② 尾段命中：库里的 `deepseek-ai/deepseek-v4.1-flash` ↔ 我们的 `deepseek-v4.1-flash`
+  if (idx.has(`~${id}`)) return idx.get(`~${id}`)
+
+  // ③ 同一个模型挂在不同厂商前缀下，取最大的那个（真能收的容量）
+  let best = 0
+  for (const [k, v] of idx) {
+    if (k.startsWith("~")) continue
+    if (k.endsWith(`/${id}`) && v > best) best = v
+  }
+  return best || FALLBACK_CONTEXT
+}
+
+export const _internal = { FALLBACK_CONTEXT, loadLibrary }

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 } 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,147 @@ 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 existing = await findProjectId(h.jwt, h.org, h.host, wsId).catch(() => "")
+    if (existing) {
+      // 已有项目 = 早就说过话。直接落一次性标记，省得以后每次登录都查一遍。
+      noteAutoChat(siteId, h.org, { reason: "已有工作台项目，视为用过" })
+      return { settled: true, reason: "此前已用过（已有工作台项目）" }
+    }
+
+    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 }