sintbot 1.0.16 → 1.3.0

package/src/platform/wecomcli.js

@@ -1,128 +0,0 @@
-// 企业微信官方命令行工具的薄封装:以机器人身份 HTTP 直连发消息 / 传素材 / 拉历史 / 搜人。
-//
-// 为什么走它而不是 daemon 的长连接:同一个机器人只许一条长连接,子进程(基础技能 `sbot wecom`、生图 worker、
-// 接管链接 `--send`)再开一条就把 daemon 踢下线;工具是 HTTP 直连,不占那条连接。三处调用方此前各写一份
-// exec 包装(cmdWecom 里那份还有个 `u.userid` 的未定义变量,单聊发送一跑就炸)⇒ 收成一处。
-//
-// ⚠ 两套 id 空间:daemon 从长连接拿到的单聊 chatId 是明文 userid,工具只认它自己那套(woA2… 形态);
-//    群 id(wr 开头)两边一致。所以不是群的目标先搜人换算,且只认精确且唯一的命中 —— 模糊命中会发到别人那里。
-const { execFile } = require('node:child_process')
-const fs = require('node:fs')
-const path = require('node:path')
-
-// 群历史只能查近 7 天,而 begin_time 恰好 7 天前会被拒(850016,真机踩到:主机钟与服务端钟差几秒就越界)⇒ 一律取 6 天
-const HISTORY_DAYS = 6
-
-// 工具要的「YYYY-MM-DD HH:MM:SS」字面量按**北京时间**解释(服务端在国内),与主机时区无关 —— 生产机是美东,按本机
-// 格式化等于把窗口整体错开 12 小时:当天的消息全查不到、还一声不响(10-10 真机踩到,此前文档写的「本机时区」是错的)
-function fmtBeijing(d) {
-  const parts = Object.fromEntries(new Intl.DateTimeFormat('en-CA', { timeZone: 'Asia/Shanghai', hourCycle: 'h23', year: 'numeric', month: '2-digit', day: '2-digit', hour: '2-digit', minute: '2-digit', second: '2-digit' }).formatToParts(d).map((x) => [x.type, x.value]))
-  return `${parts.year}-${parts.month}-${parts.day} ${parts.hour}:${parts.minute}:${parts.second}`
-}
-
-function createWecomCli({ bin = 'wecom-cli', exec = execFile, timeoutMs = 60_000 } = {}) {
-  // 调工具:JSON 回包里固定带两段安全提示字段,剥掉;{error:{code,message}} ⇒ 抛;退出码 0 但不是 JSON 也不能当成功
-  // opts.cwd:工具只许把下载的文件写进**它自己的 cwd**(或 /private/tmp)—— 真机 10-12:`--output-dir ~/.sbot/wecom-inbox` 被拒
-  //   「目标路径超出可访问范围(允许范围: <cwd>, /private/tmp)」。所以取媒体时把 cwd 设成目标目录、`--output-dir .`
-  const run = (args, opts = {}) => new Promise((resolve, reject) => {
-    exec(bin, args, { timeout: timeoutMs, maxBuffer: 8 << 20, ...(opts.cwd ? { cwd: opts.cwd } : {}) }, (err, stdout, stderr) => {
-      if (err && err.code === 'ENOENT') return reject(Object.assign(new Error('企业微信命令行工具未安装(doctor 的 wecom.cli 行)'), { code: 'ENOENT' }))
-      let j = null
-      try { j = JSON.parse(String(stdout || '').trim() || '{}') } catch { /* 非 JSON 输出按下面处理 */ }
-      if (j && j.error) {
-        // 两个要翻成人话的码(10-12 调研):850003 = 工具的能力授权(每 7 天一续)过期,要创建者点续期链接;853006 = 企业规模门控
-        // (>10 人企业官方尚未开放 chat.* 与 message send,不是配置错)。原码与续期链接挂在 Error 上给日志 / 告警用
-        const code = j.error.code, help = j.error.help_message || j.help_message || ''
-        const msg = String(code) === '850003' ? '工具的能力授权已过期(每 7 天一续),请机器人创建者点续期链接' + (help ? ':' + String(help).slice(0, 200) : '')
-          : String(code) === '853006' ? '企业规模门控:企业超过 10 人时官方尚未开放这项能力(不是配置错)'
-          : `${j.error.message || code || '失败'}`
-        return reject(Object.assign(new Error(msg), { code, help }))
-      }
-      if (err && !j) return reject(new Error(String(stderr || err.message || '').trim().slice(0, 300)))
-      if (!j) return reject(new Error('工具没有返回可读的结果:' + String(stdout || stderr || '').trim().slice(0, 200)))
-      if (!opts.keepContext) { delete j.security_notice; delete j.extra_identity_context }
-      resolve(j)
-    })
-  })
-
-  // 搜人:只认精确命中(userid 相等或关键词命中),模糊到别人头上就是张冠李戴
-  const findUser = async (userId) => {
-    const r = await run(['contact', 'users', 'search', '--keywords', userId])
-    return (r.users || []).filter((x) => x && (x.userid === userId || (x.matched_keywords || []).includes(userId)))
-  }
-
-  // 目标会话换算成工具认的 id:群原样;单聊搜人,精确且唯一才发
-  const chatIdForCli = async (chatId) => {
-    if (/^wr/.test(chatId)) return chatId
-    const hits = await findUser(chatId)
-    if (hits.length !== 1 || !hits[0].userid) throw new Error(hits.length ? '单聊对象不唯一,发不了' : '找不到这个单聊对象的账号,发不了')
-    return hits[0].userid
-  }
-
-  // 工具的 send 子命令按 --msg-type 取同名 JSON 参数(--markdown / --image / --file);success:false 也算失败
-  const sendBody = async (chatId, msgType, payload) => {
-    const r = await run(['message', 'aibot', 'send', '--chat-id', await chatIdForCli(chatId), '--msg-type', msgType, '--' + msgType, JSON.stringify(payload)])
-    if (r.success === false) throw new Error(r.message || '发送被拒')
-    return r
-  }
-
-  const upload = async (kind, absPath) => {
-    const up = await run(['media', 'upload', '--type', kind, '--file-path', absPath])
-    if (!up.media_id) throw new Error('上传没有返回素材 id')
-    return up.media_id
-  }
-
-
-  // 机器人自己是谁:官方工具的隐藏服务 `identity whoami`(--help 不列,schema list 能看到;10-12 调研 + 真机)—— 平台所有
-  // 其他地方(长连接协议 / 其余接口)都没有机器人名,这是唯一的正路。回包是一段文本:
-  //   机器人身份:\n名字:SintBot\nID:aib…\n授权真人用户身份:\n名字:张三\nID:wo…
-  // 解析成 { bot:{name,id}, user:{name,id} };老版工具没这条服务 ⇒ 抛(调用方退回扫群历史里的 @)
-  const whoami = async () => {
-    const j = await run(['identity', 'whoami'], { keepContext: true })
-    const t = String(j.extra_identity_context || '')
-    const pick = (head) => { const m = new RegExp(head + '[:：]\\s*名字[:：]\\s*([^\\n]*?)\\s*\\n\\s*ID[:：]\\s*(\\S+)').exec(t); return m ? { name: m[1].trim(), id: m[2].trim() } : null }
-    const bot = pick('机器人身份'), user = pick('授权真人用户身份')
-    if (!bot || !bot.name) throw new Error('身份接口没有返回机器人名')
-    return { bot, user }
-  }
-
-  return {
-    run,
-    whoami,
-    findUser,
-    chatIdForCli,
-    sendMarkdown: (chatId, content) => sendBody(chatId, 'markdown', { content }),
-    sendImage: async (chatId, absPath) => sendBody(chatId, 'image', { media_id: await upload('image', absPath) }),
-    sendFile: async (chatId, absPath) => sendBody(chatId, 'file', { media_id: await upload('file', absPath) }),
-    // 群历史(近 N 天,只有群;真机上含不 @ 机器人的人类发言、带 userid 与 user_name,不含机器人自己发的)
-    history: async (chatId, { days = HISTORY_DAYS, now = () => new Date() } = {}) => {
-      const end = now(), begin = new Date(end.getTime() - days * 86400_000)
-      const r = await run(['chat', 'messages', 'list', '--chat-id', chatId, '--begin-time', fmtBeijing(begin), '--end-time', fmtBeijing(end)])
-      return r.messages || []
-    },
-    // 取群历史里某条消息的媒体(图片 / 文件 / 视频):历史列表只给 media_id 不给内容,要再调一次这个接口。
-    // 工具的回包有两种形态(schema 写明):内容长或含非 UTF-8 字节 ⇒ 框架落盘到 --output-dir,JSON 里给 file_path;
-    // 内容短 ⇒ 直接给 content 字串。两种都归一成 { path, name, type }:文件一定在本机磁盘上,调用方只管搬与改名。
-    // 真机 10-12:落盘形态 = `file_path` 绝对路径 + 原始文件名(`企业微信截图_….png`,带扩展名)+ 0600;相对路径也兜(按 outDir 解析)。
-    fetchMedia: async (mediaId, outDir) => {
-      if (!mediaId) throw new Error('缺少媒体 id')
-      fs.mkdirSync(outDir, { recursive: true, mode: 0o700 }) // cwd 必须先存在,否则 spawn 直接 ENOENT
-      const r = await run(['message', 'files', 'get', '--media-id', String(mediaId), '--output-dir', '.'], { cwd: outDir })
-      const it = (r && r.media_item) || {}
-      const name = it.file_name ? String(it.file_name) : null
-      if (it.file_path) return { path: path.resolve(outDir, String(it.file_path)), name, type: it.media_type || null }
-      if (typeof it.content === 'string') {
-        // 短内容直接在 JSON 里(小文本文件那类):自己落盘,文件名只认安全字符
-        fs.mkdirSync(outDir, { recursive: true, mode: 0o700 })
-        let base = (name || '').replace(/[^\w.-]+/g, '_').slice(0, 80)
-        if (!base || /^\.+$/.test(base)) base = `msg_media_${String(mediaId).replace(/[^\w-]+/g, '_').slice(-12)}` // 远端给的文件名洗完只剩「.」「..」之类 ⇒ 用 media_id 兜底
-        const p = path.join(outDir, base)
-        fs.writeFileSync(p, it.content, { mode: 0o600 })
-        return { path: p, name, type: it.media_type || null }
-      }
-      throw new Error('取媒体没有返回文件内容')
-    },
-  }
-}
-
-module.exports = { createWecomCli, HISTORY_DAYS, fmtBeijing }

package/src/platform/wecomgate.js

@@ -1,108 +0,0 @@
-// 企业微信「不 @ 也回复」的第二道门:**便宜模型门控**(纯逻辑,依赖全注入,可单测)。
-//
-// 第一道门是规则(wecompoll.js:点名 / 跟进窗口),零 token 但只认死规矩 —— 「刚才那个报表再发一份」这种明显在对机器人
-// 说话却没点名、也过了跟进窗口的消息,规则只能放过。这里补第二道:规则判不了的消息,拿最近几句群聊 + 这一句去问一个
-// **便宜的模型**「机器人该不该接这句」,它说 YES 才喂真正的 agent。问一次只花十几到一百多 token、不带会话、不起 CLI
-// (走 provider 的 HTTP 端点,见 src/agent/askonce.js),与喂一轮 agent(几万到几十万 token 上下文)差三个数量级。
-//
-// 边界与保险:
-//   · 宁漏不误:问不通(超时 / 网络 / 回包看不懂)一律当 NO —— 漏答一句不要紧(人再 @ 一次就行),误答是打扰。
-//   · 不值一问的不问:太短(≤ 1 个字)、只有表情 / 标点、纯链接,直接 NO,省掉子请求。
-//   · 限速:每个群每分钟最多问 maxPerMin 次(默认 6),超出的当 NO 并记一次日志 —— 群里刷屏时别把门控自己刷成一笔开销。
-//   · 判定模型看到的是**去身份的文字**(昵称 + 正文),不给 userid、不给机器路径;正文截断到 MAX_TEXT 字。
-// 操作者没配 gatekeeper 时整个模块不参与(wecompoll 的 gate 为 null),行为与 v0.11.110 完全一致。
-
-const MAX_TEXT = 400       // 候选正文 / 每条上下文最多保留的字数(门控只看大意,长文截了不影响判定)
-const MAX_RECENT = 8       // 给判定模型看的最近几句
-const DEFAULT_PER_MIN = 6
-
-// 「不值一问」:太短 / 只有表情标点 / 只有链接 ⇒ 不问直接 NO
-function trivial(text) {
-  const t = String(text || '').trim()
-  if (t.length <= 1) return true
-  if (/^https?:\/\/\S+$/i.test(t)) return true
-  // 剥掉所有字母数字与 CJK 后若什么都不剩 ⇒ 只有表情 / 标点
-  const core = t.replace(/[\p{L}\p{N}]/gu, '')
-  return core.length === t.length
-}
-
-const clip = (s) => { const t = String(s || '').replace(/\s+/g, ' ').trim(); return t.length > MAX_TEXT ? t.slice(0, MAX_TEXT - 1) + '…' : t }
-
-// 判定提示词:system 定规则,user 给上下文与候选句。只要求输出 YES / NO,方便任何模型、任何语言习惯都能答对。
-function buildGatePrompt({ botName = '', recent = [], candidate = {} } = {}) {
-  const name = botName || '机器人'
-  const system = [
-    `你是群聊里一个助手机器人「${name}」的「要不要接话」判定器。群成员刚发了一条消息,没有 @ 机器人、也没叫它的名字。`,
-    `只有当这条消息明显是在对机器人说话、或在请求机器人能做的事(查资料、看代码改代码、生成图片、读文件、回答问题、继续刚才机器人在做的任务)时,回答 YES。`,
-    `消息末尾的「[附图片]」「[附文件 …]」表示这条消息带着附件:带附件并在问「这是什么 / 看看这个 / 帮我处理」之类的,是在让机器人看,回答 YES。`,
-    `成员之间的闲聊、对某个人说的话、表情、简短的附和(「好」「收到」「哈哈」)、与机器人无关的通知,一律回答 NO。拿不准就 NO。`,
-    `只输出 YES 或 NO,不要解释。`,
-  ].join('\n')
-  const ctx = (recent || []).slice(-MAX_RECENT).map((m) => `- ${m.sender || '成员'}${m.bot ? '(机器人)' : ''}:${clip(m.text)}`)
-  const user = [
-    ctx.length ? '最近的群消息(旧→新):' : '(这个群最近没有别的消息)',
-    ...ctx,
-    `候选消息 —— ${candidate.sender || '成员'}:「${clip(candidate.text)}」`,
-    '机器人要不要接这一句?',
-  ].join('\n')
-  return { system, user }
-}
-
-// 回包 → true / false / null(看不懂)。只认开头:YES / NO / 是 / 否;前面允许少量空白与标点
-function parseVerdict(text) {
-  const t = String(text || '').trim().replace(/^[\s"'`*「」【】()()\[\]]+/, '')
-  if (/^yes\b/i.test(t) || /^是/.test(t) || /^要/.test(t)) return true
-  if (/^no\b/i.test(t) || /^否/.test(t) || /^不/.test(t)) return false
-  return null
-}
-
-/**
- * @param {object} o
- *   ask        — async ({system, user}) => string  问一次便宜模型(由接线层按 provider 配置实现;抛 = 问不通)
- *   botName    — 机器人名(提示词里用;可给函数,现读配置)
- *   maxPerMin  — 每群每分钟最多问几次(默认 6;0 = 不限)
- *   now / log  — 注入时钟 / 日志
- * 返回 gate(chatId, { text, sender, recent }) => Promise<boolean>
- */
-function createGatekeeper({ ask, botName = '', maxPerMin = DEFAULT_PER_MIN, now = () => Date.now(), log = () => {} } = {}) {
-  if (typeof ask !== 'function') throw new Error('gatekeeper: ask required')
-  const asked = new Map()   // chatId → [时刻…](最近一分钟)
-  const stats = { asked: 0, yes: 0, no: 0, failed: 0, skipped: 0, throttled: 0 }
-  let failStreak = 0
-
-  const underLimit = (chatId) => {
-    if (!(maxPerMin > 0)) return true
-    const t = now()
-    const arr = (asked.get(chatId) || []).filter((x) => t - x < 60_000)
-    if (arr.length >= maxPerMin) { asked.set(chatId, arr); return false }
-    arr.push(t); asked.set(chatId, arr)
-    return true
-  }
-
-  async function gate(chatId, { text, sender, recent } = {}) {
-    if (trivial(text)) { stats.skipped++; return false }
-    if (!underLimit(chatId)) {
-      stats.throttled++
-      if (stats.throttled === 1 || stats.throttled % 50 === 0) log(`企业微信门控限速(…${String(chatId).slice(-8)}):一分钟内超过 ${maxPerMin} 条,多出的不问直接不答(累计 ${stats.throttled})`)
-      return false
-    }
-    stats.asked++
-    let raw
-    try { raw = await ask(buildGatePrompt({ botName: typeof botName === 'function' ? botName() : botName, recent, candidate: { text, sender } })) } catch (e) {
-      stats.failed++; failStreak++
-      if (failStreak <= 3 || failStreak % 30 === 0) log(`企业微信门控问不通(第 ${failStreak} 次,当作不答): ` + String((e && e.message) || e).slice(0, 160))
-      return false
-    }
-    failStreak = 0
-    const v = parseVerdict(raw)
-    if (v === null) { stats.failed++; log('企业微信门控回答看不懂(当作不答): ' + String(raw).slice(0, 60)); return false }
-    if (v) stats.yes++; else stats.no++
-    // 每次判定一行日志:NO 路径不然看不见(真机 11:44 一条带图的问句被判 NO,翻日志只看到「门控生效」,查不出判了什么);问过的才记,已经限速
-    log(`企业微信门控 ${v ? 'YES' : 'NO'}(…${String(chatId).slice(-8)}):${String(text).replace(/\s+/g, ' ').slice(0, 40)}`)
-    return v
-  }
-
-  return Object.assign(gate, { stats: () => ({ ...stats }) })
-}
-
-module.exports = { createGatekeeper, buildGatePrompt, parseVerdict, trivial, MAX_RECENT, DEFAULT_PER_MIN }

package/src/platform/wecomname.js

@@ -1,43 +0,0 @@
-// 企业微信机器人的名字从哪来:平台没有「取机器人信息」的接口(长连接命令集 / 官方命令行工具都没有),但群成员 @ 它时
-// 消息正文里就带着「@SintBot」—— 而长连接只推 @ 机器人的消息,所以每条群消息里必有它的名字。这里只做纯逻辑:
-//   mentionsOf(text)    正文里的 @ 名字列表(名字到空白 / 全角标点为止;两个人名连着 @ 时各算各的)
-//   guessBotName(msgs)  一批群历史消息里出现最多的那个 @ 名字 ⇒ 机器人名(群里被 @ 最多的就是它;别人也会被 @,但没它多)
-// 守护进程收到 @ 消息时现学现用(wecom.js),控制台「刷新身份」扫近几天群历史统计后落进配置(server.js)。
-// 手填框去掉了:填错一个字,剥 @ 和点名判断就全失效,而对不对只有群里知道。
-
-const MENTION_RE = /@([^\s@,，。!！?？:：;；、()()\[\]【】]+)/g
-
-// 零宽字符(U+200B~200D / 2060 / FEFF)不在 JS 的 \s 里,手机端粘贴夹带时会学成「SintBot\u200b」这种名字 —— 与剥 @ 那边(wecom.js ZERO_WIDTH_RE)同口径,入口先去掉
-const ZERO_WIDTH_RE = /[\u200b-\u200d\u2060\ufeff]/g
-function mentionsOf(text) {
-  const out = []
-  const s = String(text || '').replace(ZERO_WIDTH_RE, '')
-  let m
-  while ((m = MENTION_RE.exec(s))) { const n = m[1].trim(); if (n) out.push(n) }
-  return out
-}
-
-// 一条历史消息的所有文字片段(text / 图文混排里的 text 项;两套字段名都认)
-function textsOf(m) {
-  if (!m) return []
-  if (m.msg_type === 'text') return [String((m.text && m.text.content) || '')]
-  if (m.msg_type === 'mixed') return ((m.mixed && (m.mixed.items || m.mixed.msg_item)) || []).filter((it) => it && it.msg_type === 'text').map((it) => String((it.text && it.text.content) || ''))
-  return []
-}
-
-// 返回 { name, count, total }:total = 含 @ 的消息数;name = null 表示一条 @ 都没见到
-function guessBotName(msgs) {
-  const counts = new Map()
-  let total = 0
-  for (const m of msgs || []) {
-    const names = new Set(textsOf(m).flatMap(mentionsOf))
-    if (!names.size) continue
-    total++
-    for (const n of names) counts.set(n, (counts.get(n) || 0) + 1)
-  }
-  let best = null, bestN = 0
-  for (const [n, c] of counts) if (c > bestN) { best = n; bestN = c }
-  return { name: best, count: bestN, total }
-}
-
-module.exports = { mentionsOf, guessBotName, textsOf }

package/src/platform/wecompoll.js

@@ -1,241 +0,0 @@
-// 企业微信「不 @ 也回复」:轮询群历史补入站(纯逻辑,依赖全注入,可单测)。
-//
-// 为什么要它:长连接只推 @ 机器人的消息(平台边界,10-10 真机实证),而官方命令行工具能拉近 7 天群历史、含不 @ 的
-// 人类发言。所以「不 @ 也回复」= 每隔 intervalMs 拉一次已绑群的历史,把新出现的人类消息喂给引擎;回复走主动推送。
-// 轮询本身零 token(HTTP 调用,不经模型);**真正烧 token 的是喂模型** —— 一条就是一轮、带整段会话上下文。
-// 所以这里有一道**规则门控**(零 token),只放行两类:
-//   ① 消息里点了机器人的名(botName / keywords 里任一,如「机器人」「助手」);
-//   ② 跟进窗口内:机器人在这个群上一次被 @ 或上一次开口之后 followMs 内的消息(「@ 一次开了头,接下来几句不用再 @」)。
-// 其余只留在历史里不喂(agent 要上下文时自己 history)。followMs = 0 ⇒ 不设窗口,全部都喂(明知烧 token 的 operator 自己选)。
-// 第二道门「便宜模型门控」(规则不放行的再问一个便宜 provider 该不该接)由 wecomgate.js 实现、经 gate 选项注入;没配就只有规则这一道。
-//
-// 去重两道:① 与长连接已投递的 @ 消息去重(同一群、剥 @ 后正文相同、时间差 ≤ DUP_WINDOW_MS)—— 否则每条 @ 消息会被答两遍;
-//          ② 同一秒内的重叠:水位按 send_time 字面量(秒级)推进,边界那一秒的消息靠 (send_time|userid|content) 键去重。
-// 启动第一轮只建基线不投递(否则把近 7 天的旧消息全灌进去)。
-
-const DUP_WINDOW_MS = 3 * 60_000
-
-// 工具给的 send_time 是北京时间字面量「YYYY-MM-DD HH:MM:SS」⇒ 毫秒
-function parseBeijing(s) {
-  const m = /^(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})$/.exec(String(s || '').trim())
-  if (!m) return NaN
-  return Date.UTC(+m[1], +m[2] - 1, +m[3], +m[4] - 8, +m[5], +m[6])
-}
-
-// 历史消息 → 片段:{ type:'text', text } | { type:'media', kind:'image'|'file'|'video', mediaId, name }。
-// 历史列表里的媒体只有 media_id(内容要另调取媒体接口),所以这里只拆不下载 —— 下不下载由 pollChat 按门控结果决定:
-// 门控不放行的消息根本不喂,也就不必为它起一次子进程去取图。语音有转写就当文字(不下载音频)。
-function messageParts(m) {
-  if (!m) return []
-  const media = (kind, obj) => ({ type: 'media', kind, mediaId: (obj && obj.media_id) || null, name: (obj && obj.file_name) || null })
-  switch (m.msg_type) {
-    case 'text': return [{ type: 'text', text: String((m.text && m.text.content) || '') }]
-    // ⚠ 历史接口的图文混排是 `mixed.items`(schema MixedContent.items,真机 10-12 一条带字的图就这样被拆成空、静默略过),
-    //    长连接回调那边是 `mixed.msg_item` —— 两套字段名,两个都认
-    case 'mixed': return ((m.mixed && (m.mixed.items || m.mixed.msg_item)) || []).map((it) => it && it.msg_type === 'text' ? { type: 'text', text: String((it.text && it.text.content) || '') } : (it && it.msg_type === 'image' ? media('image', it.image) : null)).filter(Boolean)
-    case 'image': return [media('image', m.image)]
-    case 'file': return [media('file', m.file)]
-    case 'voice': return [{ type: 'text', text: String((m.voice && m.voice.content) || '') ? '(语音转文字)' + m.voice.content : '[语音]' }]
-    case 'video': return [media('video', m.video)]
-    default: return []
-  }
-}
-const mediaLabel = (kind) => (kind === 'image' ? '图片' : kind === 'video' ? '视频' : '文件')
-// 片段 → 一行正文(媒体给占位标记):去重键与日志用;喂引擎的正文由 pollChat 另拼(媒体换成本机路径标记)
-function messageText(m) {
-  return messageParts(m).map((p) => p.type === 'text' ? p.text : `[${mediaLabel(p.kind)}${p.name ? ' ' + p.name : ''}]`).filter(Boolean).join(' ')
-}
-// 只取文字片段(去重与点名判定用:长连接那边记的是剥 @ 后的纯文字,不含媒体标记 —— 只发一张图 @ 机器人时两边都是空串才对得上)
-const plainText = (m) => messageParts(m).filter((p) => p.type === 'text').map((p) => p.text).filter(Boolean).join(' ')
-// 本机路径标记,与长连接入站那条(wecom.js mediaMark)同一形状 —— 清单只教了一种写法
-const defaultMark = (kind, p) => `[${mediaLabel(kind)} path=${p}]`
-
-function createHistoryPoll({
-  chats = () => [],            // () => 要轮询的群 id 列表(每 tick 现读,跟随配置热重载)
-  list,                        // (chatId) => Promise<messages[]>(工具的 chat messages list)
-  deliver,                     // (msg) => void 把一条人类消息喂给引擎(InboundMessage 形状)
-  wasDelivered = () => false,  // (chatId, text, tMs, {userId,userName}) => bool 长连接是否已投递过这条(去重 @ 消息;text = 剥 @ 后的纯文字,不含媒体标记;meta 让适配器把账号 ↔ 姓名对上)
-  stripMention = (t) => t,     // 剥正文里的 @机器人
-  fetchMedia = null,           // async ({kind, mediaId, name}, base) => 本机路径;null = 不下载,媒体只给「[图片]」占位(没装命令行工具时)
-  mark = defaultMark,          // (kind, path) => 正文里的本机路径标记(与长连接入站同形)
-  gate = null,                 // 第二道门(便宜模型门控,wecomgate.js):async (chatId, {text, sender, recent}) => bool;规则不放行时才问;null = 没配
-  now = () => Date.now(), setTimer = setTimeout, clearTimer = clearTimeout,
-  intervalMs = 20_000, followMs = 5 * 60_000,
-  // 分档间隔(两车道,v0.11.115):intervalMs 是「温」档(配置里的 pollSec);热 = 跟进窗口内(刚被 @ / 刚开口 / 刚喂过),
-  // 冷 = 这个群 idleMs 内没有任何人类发言;授权 / 规模门控类错误(850003 / 853006)整体暂停 pauseMs 再试 —— 刷也刷不出来,只会刷出告警
-  hotMs = 8_000, coldMs = 0, idleMs = 10 * 60_000, pauseMs = 30 * 60_000,
-  botName = '', keywords = ['机器人', '助手'],
-  log = () => {},
-} = {}) {
-  const state = new Map()   // chatId → { last: send_time 字面量, keys: Set }
-  const followUntil = new Map() // chatId → 跟进窗口截止(ms)
-  const nextAt = new Map()      // chatId → 下次该拉的时刻(ms);没记录 = 立刻
-  const lastHumanAt = new Map() // chatId → 历史里最后一条人类消息的时刻(ms),喂没喂都记 —— 分档用
-  let pausedUntil = 0           // 授权类错误 ⇒ 整体暂停到这个时刻
-  const coldOf = () => (coldMs > 0 ? coldMs : Math.max(6 * intervalMs, 120_000))
-  const hotOf = () => Math.min(hotMs, intervalMs)
-  // 这个群现在该多久拉一次:热 / 温 / 冷
-  const tierMs = (chatId) => {
-    const t = now()
-    if ((followUntil.get(chatId) || 0) > t) return hotOf()
-    const lh = lastHumanAt.get(chatId)
-    if (lh == null || !(t - lh >= idleMs)) return intervalMs // 没见过 = 温
-    return coldOf()
-  }
-  const tierName = (chatId) => { const ms = tierMs(chatId); return ms === hotOf() && (followUntil.get(chatId) || 0) > now() ? 'hot' : ms === intervalMs ? 'warm' : 'cold' }
-  const recent = new Map()  // chatId → [{sender, text}] 最近几句(只给第二道门当上下文;喂没喂都记,机器人自己的话读不到 —— 历史里没有)
-  const RECENT_KEEP = 8
-  const remember = (chatId, sender, text) => { const arr = recent.get(chatId) || []; arr.push({ sender, text }); if (arr.length > RECENT_KEEP) arr.shift(); recent.set(chatId, arr) }
-  let timer = null, stopped = true, failStreak = 0
-  // botName / keywords 可以是函数(现读配置,控制台改了热生效);每次判定现算名单,几个字符串的开销可忽略
-  const names = () => { const b = typeof botName === 'function' ? botName() : botName; let k = typeof keywords === 'function' ? keywords() : keywords; if (!Array.isArray(k)) k = ['机器人', '助手']; return [b, ...k].map((x) => String(x || '').trim().toLowerCase()).filter(Boolean) }
-
-  const mentioned = (text) => { const t = String(text || '').toLowerCase(); return names().some((n) => t.includes(n)) }
-  // 规则门控:点名 ⇒ 喂;跟进窗口内 ⇒ 喂;followMs 为 0 ⇒ 全喂
-  const shouldFeed = (chatId, text, tMs) => {
-    if (followMs === 0) return true
-    if (mentioned(text)) return true
-    return tMs <= (followUntil.get(chatId) || 0)
-  }
-
-  async function pollChat(chatId) {
-    let msgs
-    try { msgs = await list(chatId) } catch (e) {
-      failStreak++
-      if (failStreak <= 3 || failStreak % 30 === 0) log(`企业微信群历史轮询失败(…${String(chatId).slice(-8)},第 ${failStreak} 次): ` + String((e && e.message) || e).slice(0, 160))
-      if (e && e.code === 'ENOENT') { stop(); log('企业微信命令行工具未安装,「不 @ 也回复」已停') }
-      // 850003 = 工具能力授权过期(创建者点链接续期)· 853006 = 企业规模门控(官方未开放):都不是刷能刷出来的,整体歇 pauseMs 再试
-      else if (e && /^(850003|853006)$/.test(String(e.code))) { pausedUntil = now() + pauseMs; log(`企业微信「不 @ 也回复」暂停 ${Math.round(pauseMs / 60_000)} 分钟(${e.code}:${e.code === '853006' || e.code === 853006 ? '企业规模门控,官方未对本企业开放读群历史' : '工具能力授权过期,要创建者续期'})`) }
-      return
-    }
-    failStreak = 0
-    const st = state.get(chatId)
-    const sorted = (msgs || []).filter((m) => m && m.send_time).sort((a, b) => String(a.send_time).localeCompare(String(b.send_time)))
-    if (sorted.length) { const lt = parseBeijing(String(sorted[sorted.length - 1].send_time)); if (Number.isFinite(lt)) lastHumanAt.set(chatId, lt) }
-    if (!st) { // 第一轮:只建基线
-      const last = sorted.length ? String(sorted[sorted.length - 1].send_time) : ''
-      state.set(chatId, { last, keys: new Set(sorted.filter((m) => String(m.send_time) === last).map(keyOf)) })
-      return
-    }
-    const fed = [] // 本轮放行的消息:攒成一批投递(一轮答完),不是每条各起一轮
-    for (const m of sorted) {
-      const t = String(m.send_time)
-      if (t < st.last) continue
-      const k = keyOf(m)
-      if (st.keys.has(k)) continue
-      if (t > st.last) { st.last = t; st.keys = new Set() }
-      st.keys.add(k)
-      const parts = messageParts(m)
-      const plain = stripMention(plainText(m)).replace(/\s+/g, ' ').trim()
-      const medias = parts.filter((p) => p.type === 'media')
-      if (!plain && !medias.length) continue
-      const tMs = parseBeijing(t)
-      // 去重与门控都按纯文字判:长连接那边记的也是纯文字(只发一张图 @ 机器人 ⇒ 两边都是空串,才对得上;拿带「[图片]」的串去比永远对不上 = 同一张图答两遍)
-      const sender = String(m.user_name || m.userid || '')
-      if (wasDelivered(chatId, plain, tMs, { userId: String(m.userid || ''), userName: String(m.user_name || '') })) { remember(chatId, sender, plain || messageText(m)); continue } // 长连接已投递的 @ 消息(上下文照记,纯图记成占位;meta 给适配器桥接姓名)
-      // 第一道门(规则,零 token)不放行 ⇒ 有第二道门(便宜模型)就问它;它说不要、或没配 ⇒ 不喂。
-      // 先 remember 再问:给门控看的上下文不含这一句本身(它在「候选消息」里单独给)
-      const ctx = (recent.get(chatId) || []).slice()
-      remember(chatId, sender, plain || messageText(m))
-      if (!shouldFeed(chatId, plain, tMs)) {
-        if (!gate || !plain) continue // 纯媒体没有文字可判,不问
-        // 候选句要带上附件提示:门控看不到图,「这是什么界面」配一张图是在问机器人,光看文字像闲聊(真机 11:44 判成了 NO)
-        const hint = medias.length ? ' ' + medias.map((md) => `[附${mediaLabel(md.kind)}${md.name ? ' ' + md.name : ''}]`).join(' ') : ''
-        let ok = false
-        try { ok = await gate(chatId, { text: plain + hint, sender, recent: ctx }) } catch (e) { log('企业微信门控异常(当作不答): ' + (e && e.message)) }
-        if (!ok) continue
-      }
-      // 门控放行了才去取媒体(每个媒体一次子进程):取到给本机路径标记,取不到给一句能看懂的失败标记 —— agent 至少知道「这里有张图我没拿到」
-      const marks = []
-      const stamp = t.replace(/\D/g, '')
-      for (let i = 0; i < medias.length; i++) {
-        const md = medias[i]
-        if (!fetchMedia || !md.mediaId) { marks.push(`[${mediaLabel(md.kind)}${md.name ? ' ' + md.name : ''}]`); continue }
-        try { marks.push(mark(md.kind, await fetchMedia(md, `poll-${stamp}-${hash(k)}-${i + 1}`))) }
-        // ⚠ 失败标记不带错误原话:原话里有命令行工具名 / 机器路径(ENOENT 的完整路径、工具 usage),agent 会顺手复述给群成员;它只需要知道「这张图没拿到」
-        catch (e) { log(`企业微信群历史媒体下载失败(${md.kind}): ` + String((e && e.message) || e).slice(0, 160)); marks.push(`[${mediaLabel(md.kind)} 下载失败]`) }
-      }
-      const text = [plain, ...marks].filter(Boolean).join('\n')
-      // label = 给推送引用行用的原话:纯文字,媒体只给「[图片 a.png]」这种不带本机路径的标记(用户面零路径)
-      fed.push({ userId: String(m.userid || ''), sender, text, label: plain || messageText(m), stamp, k, tMs: Number.isFinite(tMs) ? tMs : now(), hhmm: t.slice(11, 16) })
-    }
-    if (!fed.length) return
-    // 攒批:同一轮拉到的多条放行消息合成一条投递 —— 引擎按一轮处理,回复一次。多条时每行带「[时分 发送者]」,
-    // 代表(msgId / 时间 / 发送者)取末条,与引擎出队合并的口径一致;推送回复要引用的也是末条。
-    const last = fed[fed.length - 1]
-    const body = fed.length === 1 ? last.text : fed.map((f) => `[${f.hhmm} ${f.sender}] ${f.text}`).join('\n')
-    try {
-      deliver({
-        chatId,
-        userId: last.userId,
-        senderName: last.sender,
-        text: body,
-        msgId: `poll:${chatId}:${last.stamp}:${hash(last.k)}`,
-        createTimeMs: last.tMs,
-        // 没有 req_id ⇒ 回复走主动推送、没有流式;quote 给适配器在推送开头引用原话(推送不会自动引用,群里分不清在回谁)
-        // 攒批时引用行要让群里看出「这一条回了好几句」:more = 末条之前还有几条;senders = 几个人在说
-        replyCtx: { chatId, chatType: 'group', quote: { sender: last.sender, text: String(last.label || '').slice(0, 40), more: fed.length - 1, senders: new Set(fed.map((f) => f.sender)).size } },
-        polled: true,
-        batchOf: fed.length,
-      })
-    } catch (e) { log('企业微信轮询投递异常: ' + (e && e.message)) }
-    bump(chatId, now() + hotOf()) // 喂过 ⇒ 下次拉取按热档提前(跟进窗口由机器人开口时开,这里不开 —— 门控口径不变)
-  }
-
-  const chatIds = () => { try { return (chats() || []).filter((id) => /^wr/.test(String(id))) } catch { return [] } }
-  // 一个定时器,到点扫一遍:只拉到期的群,拉完按各自档位记下次;定时器定在最早到期的那个群。
-  // 手动调 tick()(测试 / 排障)= 不看档位全拉一遍;定时器走 tick(false) 只拉到期的
-  // ⚠ 不可重入:一轮 tick 里 await 着门控 / 媒体下载时,kick / noteActivity 会重定定时器 —— 若放任第二个 tick 并发跑同一个群,
-  //   两份 pollChat 会乱序投递(后一份先投了更新的消息,前一份随后投的旧消息被引擎水位线当陈旧丢掉 = 静默吞消息)。
-  //   跑着时只记「要再来一次」,末尾 arm 时 nextAt 已被 bump 改过,自然算出立即到期。
-  let running = false
-  async function tick(force = true) {
-    if (stopped || running) return
-    running = true
-    timer = null
-    try {
-      const ids = chatIds()
-      const t0 = now()
-      for (const id of ids) {
-        if (!force && pausedUntil > now()) break // 撞到授权 / 门控类错误:别让剩下的群各起一次子进程撞同一个错
-        if (!force && (nextAt.get(id) || 0) > t0) continue
-        try { await pollChat(id) } catch (e) { log('企业微信轮询异常(跳过本群本轮): ' + (e && e.message)) } // 串行:一次一个子进程,别把工具打爆;任何意外抛出都不许杀掉整条轮询
-        // 本轮内有人 bump 过(喂过 ⇒ 热档、答完补拉)就保留那个更早的时刻;否则按档位记下次。cur > t0 区分「新 bump」与触发本次的旧到期值
-        const cur = nextAt.get(id); const planned = now() + tierMs(id)
-        nextAt.set(id, cur != null && cur > t0 && cur < planned ? cur : planned)
-      }
-      if (pausedUntil > now()) for (const id of ids) nextAt.set(id, Math.max(nextAt.get(id) || 0, pausedUntil))
-    } finally { running = false }
-    arm()
-  }
-  function arm(ids = chatIds()) {
-    if (stopped || running) return // 跑着时不设定时器:tick 末尾会按最新的 nextAt 重定
-    if (timer) { clearTimer(timer); timer = null }
-    const t = now()
-    let due = Infinity
-    for (const id of ids) due = Math.min(due, nextAt.has(id) ? nextAt.get(id) : t)
-    if (!Number.isFinite(due)) due = t + intervalMs // 一个群都没绑:按温档再看(配置热重载可能加群)
-    timer = setTimer(() => tick(false), Math.max(0, due - t))
-  }
-  // 把某个群的下次拉取提前到 at(只提前不推后),并重定定时器
-  function bump(chatId, at) { if (!chatId || stopped) return; const cur = nextAt.get(chatId); if (cur == null || at < cur) nextAt.set(chatId, at); arm() }
-
-  function start() {
-    if (!(intervalMs > 0)) return false
-    stopped = false
-    timer = setTimer(() => tick(false), 0)
-    return true
-  }
-  function stop() { stopped = true; if (timer) { clearTimer(timer); timer = null } }
-  // 机器人在这个群被 @ 了 / 开口了 / 喂过了 ⇒ 开(续)跟进窗口,并切到热档(下次拉取提前到 hotMs 内)
-  function noteActivity(chatId) { if (!chatId) return; if (followMs > 0) followUntil.set(chatId, now() + followMs); bump(chatId, now() + hotOf()) }
-  // 补拉:delayMs 后就拉这个群一次(机器人刚答完,跟进句通常紧跟其后)
-  function kick(chatId, delayMs = 0) { bump(chatId, now() + Math.max(0, delayMs)) }
-
-  return { start, stop, tick, noteActivity, kick, shouldFeed, tierName, _state: state, _nextAt: nextAt }
-}
-
-const keyOf = (m) => `${m.send_time}|${m.userid || ''}|${messageText(m)}`
-function hash(s) { let h = 0; for (let i = 0; i < s.length; i++) h = (h * 31 + s.charCodeAt(i)) | 0; return (h >>> 0).toString(36) }
-
-module.exports = { createHistoryPoll, parseBeijing, messageText, messageParts, plainText, DUP_WINDOW_MS }