lark-relay 0.0.0 → 0.1.0

package/lib/claude.js

@@ -0,0 +1,207 @@
+'use strict'
+
+// 唤起 headless claude。session 确定性派生,不落配置、不需人填。
+const crypto = require('crypto')
+const fs = require('fs')
+const os = require('os')
+const path = require('path')
+const { spawn } = require('child_process')
+
+// 模型分发交给 dotfiles 里的 claude() 函数 —— 它有白名单校验,是单一事实源。
+// 旧架构存的是内部函数名(route: cc-48,实测早已不存在),改存模型名后
+// 新增后端零改动,写错也会被分发器 exit 2 挡住。
+const CC_RC = process.env.LR_CC_RC || path.join(os.homedir(), 'space/dotfiles/rc.d/claude.sh')
+
+// sha1(task|scope) 前 32 位切成 8-4-4-4-12
+function deriveUuid(task, scope) {
+  const h = crypto.createHash('sha1').update(`${task}|${scope}`).digest('hex')
+  return `${h.slice(0, 8)}-${h.slice(8, 12)}-${h.slice(12, 16)}-${h.slice(16, 20)}-${h.slice(20, 32)}`
+}
+
+// Claude Code 按 cwd 分目录存 session:/ 和 . 都换成 -
+function encCwd(cwd) {
+  return String(cwd).replace(/[/.]/g, '-')
+}
+
+function sessionFile(cwd, uuid) {
+  return path.join(os.homedir(), '.claude', 'projects', encCwd(cwd), `${uuid}.jsonl`)
+}
+
+// 会话世代号:超过 idleGap 没动静就开新会话。thread 模式不调用(话题即边界,恒 0)。
+function sessionEpoch(stateDir, task, chatId, idleGap) {
+  const dir = path.join(stateDir, 'state')
+  fs.mkdirSync(dir, { recursive: true })
+  const file = path.join(dir, `${task}__${chatId}.tsv`)
+  const now = Math.floor(Date.now() / 1000)
+  let epoch = 0
+  try {
+    const [lastStr, epStr] = fs.readFileSync(file, 'utf8').trim().split('\t')
+    const last = Number(lastStr) || 0
+    epoch = Number(epStr) || 0
+    if (idleGap > 0 && now - last > idleGap) epoch += 1
+  } catch {}
+  fs.writeFileSync(file, `${now}\t${epoch}\n`)
+  return epoch
+}
+
+const PROMPT_TEMPLATE = (batch) =>
+  `下面是飞书群里最新一批消息。请把它们当作针对本仓库(当前工作目录)的任务来处理:定位/分析/修复/测试。处理完后,你的最终回复会被原样发回该群,请直接面向群里的人简洁说明你做了什么、发现了什么、需要什么确认。
+
+===== 群消息 =====
+${batch}
+===== 结束 =====`
+
+/**
+ * 起一轮 headless claude。
+ * @returns {Promise<{rc:number, final:string, err:string}>}
+ */
+function runClaude(opts) {
+  const {
+    cwd,
+    prompt,
+    uuid,
+    instructions,
+    addDirs = [],
+    allowedTools = 'Read Edit Write Bash',
+    model,
+    timeoutSec = 1800,
+    stream = false,
+    onEvent,
+  } = opts
+
+  const resume = fs.existsSync(sessionFile(cwd, uuid))
+  const args = ['-p', prompt]
+  // 首次用 --session-id 建、之后用 --resume 续,判据就是 jsonl 是否存在
+  args.push(resume ? '--resume' : '--session-id', uuid)
+  args.push('--add-dir', cwd) // 主工作目录自己也加一次
+  args.push('--setting-sources', 'user,project,local') // 含 project 才加载主目录 CLAUDE.md
+  args.push('--permission-mode', 'acceptEdits')
+  args.push('--allowedTools', allowedTools)
+  for (const d of addDirs) args.push('--add-dir', d)
+  // 职责/边界必须走这里:CLAUDE.md 只自动加载主工作目录+父链,
+  // --add-dir 的目录启动不加载,AGENTS.md 也不被当 memory
+  if (instructions && fs.existsSync(instructions)) {
+    args.push('--append-system-prompt-file', instructions)
+  }
+  args.push('--output-format', stream ? 'stream-json' : 'json')
+  if (stream) args.push('--verbose')
+
+  // 经 bash -lc source claude.sh 后调 claude() —— 模型分发与白名单校验都在那里
+  const quoted = args.map(shellQuote).join(' ')
+  const modelArg = model ? `--model ${shellQuote(model)} ` : ''
+  const script =
+    `set -o pipefail\n` +
+    `if ! source ${shellQuote(CC_RC)} 2>/dev/null; then\n` +
+    `  echo "cc: 无法 source ${CC_RC}" >&2; exit 3\n` +
+    `fi\n` +
+    `claude ${modelArg}${quoted}\n`
+
+  return new Promise((resolve) => {
+    const child = spawn('bash', ['-lc', script], {
+      cwd,
+      env: {
+        ...process.env,
+        LANG: 'C.UTF-8',
+        LC_ALL: 'C.UTF-8',
+        // headless 里 Bash 工具层单命令超时 10min(非整体超时)
+        BASH_MAX_TIMEOUT_MS: process.env.BASH_MAX_TIMEOUT_MS || '600000',
+      },
+      stdio: ['ignore', 'pipe', 'pipe'],
+    })
+
+    let out = ''
+    let err = ''
+    let done = false
+    // 挂钟超时兜底:包住整轮
+    const timer = setTimeout(() => {
+      if (!done) {
+        err += `\n[timeout ${timeoutSec}s]`
+        child.kill('SIGTERM')
+        setTimeout(() => child.kill('SIGKILL'), 5000)
+      }
+    }, timeoutSec * 1000)
+
+    if (stream) {
+      let buf = ''
+      child.stdout.on('data', (d) => {
+        buf += d.toString()
+        const lines = buf.split('\n')
+        buf = lines.pop()
+        for (const line of lines) handleStreamLine(line, onEvent, (t) => (out = t))
+      })
+      child.stdout.on('end', () => {
+        if (buf.trim()) handleStreamLine(buf, onEvent, (t) => (out = t))
+      })
+    } else {
+      child.stdout.on('data', (d) => (out += d.toString()))
+    }
+    child.stderr.on('data', (d) => (err += d.toString()))
+
+    child.on('close', (code) => {
+      done = true
+      clearTimeout(timer)
+      let final = ''
+      if (stream) {
+        final = out
+      } else {
+        try {
+          final = JSON.parse(stripToJson(out))?.result || ''
+        } catch {
+          final = out.trim()
+        }
+      }
+      resolve({ rc: code === null ? 124 : code, final, err })
+    })
+    child.on('error', (e) => {
+      done = true
+      clearTimeout(timer)
+      resolve({ rc: 1, final: '', err: String(e.message) })
+    })
+  })
+}
+
+// stream-json 事件 → say / tool / final
+function handleStreamLine(line, onEvent, setFinal) {
+  const s = line.trim()
+  if (!s || s[0] !== '{') return
+  let j
+  try {
+    j = JSON.parse(s)
+  } catch {
+    return
+  }
+  if (j.type === 'assistant') {
+    for (const c of j.message?.content || []) {
+      if (c.type === 'text' && c.text) onEvent?.('say', c.text)
+      else if (c.type === 'tool_use') {
+        const detail =
+          c.input?.command ?? c.input?.file_path ?? c.input?.pattern ?? c.input?.description ?? ''
+        const str = String(detail)
+        onEvent?.('tool', `${c.name}: ${str.length > 300 ? `${str.slice(0, 300)}…` : str}`)
+      }
+    }
+  } else if (j.type === 'result') {
+    const r = j.result || ''
+    setFinal(r)
+    onEvent?.('final', r)
+  }
+}
+
+function stripToJson(s) {
+  const i = String(s).indexOf('{')
+  return i === -1 ? '{}' : String(s).slice(i)
+}
+
+function shellQuote(s) {
+  return `'${String(s).replace(/'/g, `'\\''`)}'`
+}
+
+module.exports = {
+  runClaude,
+  deriveUuid,
+  sessionEpoch,
+  sessionFile,
+  encCwd,
+  PROMPT_TEMPLATE,
+  CC_RC,
+}

package/lib/collect.js

@@ -0,0 +1,167 @@
+'use strict'
+
+// collect:底座。全部 profile 各起一个 consume → 读 stdout NDJSON → 原子落盘。
+// 零参数、零配置 —— app 列表实时读 `lark-cli profile list`。
+//
+// 为什么必须独立常驻:lark 事件是流式的,进程不在的时刻消息永久丢失
+// (实测:消息发出 8s 后才起 consumer,收到 0 条)。collect 独立常驻,
+// 才能让 take/dispatch 侧崩了、claude 跑 30 分钟、会话关几小时,都不丢消息。
+const readline = require('readline')
+const larkcli = require('./larkcli')
+const store = require('./store')
+const { paths, ensureDir } = require('./paths')
+
+const EVENT_KEY = process.env.LARK_RELAY_EVENT_KEY || 'im.message.receive_v1'
+const GC_INTERVAL_MS = 3600_000
+
+class AppCollector {
+  constructor(app, opts) {
+    this.app = app
+    this.opts = opts
+    this.seq = 0
+    this.received = 0
+    this.child = null
+    this.stopped = false
+    this.backoffMs = 1000
+    this.restarts = 0
+  }
+
+  start() {
+    if (this.stopped) return
+    const child = larkcli.spawnConsume(this.app, EVENT_KEY, ['--as', 'bot', '--timeout', '0'])
+    this.child = child
+
+    // stdin 是管道且我们永不写、永不关 —— unbounded consume 把 stdin EOF 当退出信号。
+    // 关掉或给 /dev/null 会让它立刻退出,变成疯狂重启循环(实测踩过)。
+    // 只在 stop() 里显式 SIGTERM 结束它。
+    if (child.stdin) child.stdin.on('error', () => {})
+
+    const rl = readline.createInterface({ input: child.stdout, crlfDelay: Infinity })
+    rl.on('line', (line) => {
+      const s = line.trim()
+      if (!s || s[0] !== '{') return
+      let obj
+      try {
+        obj = JSON.parse(s)
+      } catch {
+        process.stderr.write(`[${this.app}] warn: 非 JSON 行,已跳过\n`)
+        return
+      }
+      try {
+        store.writeEvent(this.app, obj, this.seq++)
+        this.received++
+        // 收到第一条就说明这个 app 通了,重置退避
+        this.backoffMs = 1000
+      } catch (err) {
+        process.stderr.write(`[${this.app}] error: 落盘失败 ${err.message}\n`)
+      }
+    })
+
+    // 不加 --quiet:它会隐藏事件丢失。stderr 的 ready/exit/drop 诊断进 journald
+    child.stderr.on('data', (buf) => {
+      const text = buf.toString().trimEnd()
+      if (text) process.stderr.write(`[${this.app}] ${text}\n`)
+    })
+
+    child.on('exit', (code, signal) => {
+      this.child = null
+      if (this.stopped) return
+      this.restarts++
+      const why = signal ? `signal ${signal}` : `code ${code}`
+      process.stderr.write(
+        `[${this.app}] consume 退出(${why}),${Math.round(this.backoffMs / 1000)}s 后重启\n`,
+      )
+      // 每 app 一个子进程;某个挂了单独重启,不影响其他
+      setTimeout(() => this.start(), this.backoffMs)
+      this.backoffMs = Math.min(this.backoffMs * 2, 60_000)
+    })
+
+    child.on('error', (err) => {
+      process.stderr.write(`[${this.app}] spawn 失败:${err.message}\n`)
+    })
+  }
+
+  stop() {
+    this.stopped = true
+    // 优雅停止:SIGTERM。禁 SIGKILL —— 否则漏卸载服务端订阅
+    if (this.child) this.child.kill('SIGTERM')
+  }
+}
+
+async function runCollect(opts) {
+  ensureDir(paths.store)
+  ensureDir(paths.cursors)
+  ensureDir(paths.ledger)
+
+  const exclude = new Set(opts.exclude || [])
+  const profiles = await larkcli.listProfiles()
+
+  const chosen = []
+  const skipped = []
+  for (const p of profiles) {
+    if (exclude.has(p.name)) {
+      skipped.push(`${p.name} [excluded]`)
+      continue
+    }
+    // expired = 授权过期,not-authed = 从未 login。两者都永久失败,重试是死循环。
+    // 用户重新 login 后下次启动自动纳入。
+    if (!p.usable) {
+      skipped.push(`${p.name} [${p.reason}]`)
+      continue
+    }
+    chosen.push(p)
+  }
+
+  if (skipped.length) {
+    process.stderr.write(`warn: 跳过 ${skipped.join(' ')}\n`)
+  }
+  if (!chosen.length) {
+    process.stderr.write('error: 没有可用 profile。先 `lark-cli auth login`\n')
+    return 1
+  }
+
+  process.stderr.write(
+    `lark-relay collect: ${chosen.length}/${profiles.length} profiles → ${paths.store}\n` +
+      `  ${chosen.map((p) => p.name).join(' ')}\n` +
+      `  event_key=${EVENT_KEY} store 保留 ${opts.retain}天 ledger 保留 ${opts.ledgerRetain}天\n`,
+  )
+
+  const collectors = chosen.map((p) => new AppCollector(p.name, opts))
+  for (const c of collectors) c.start()
+
+  // gc 在本进程内每小时自查:回收逻辑就是「删超期日期目录」一句话,
+  // 另起 gc 命令 + systemd timer 是为一行逻辑加两个部署件。
+  const gcTimer = setInterval(() => {
+    try {
+      const s = store.gcStore(opts.retain)
+      const l = store.gcLedger(opts.ledgerRetain)
+      if (s.length || l.length) {
+        process.stderr.write(`gc: 删 store ${s.length} 个日期目录, ledger ${l.length} 个文件\n`)
+      }
+    } catch (err) {
+      process.stderr.write(`gc: 失败 ${err.message}\n`)
+    }
+  }, GC_INTERVAL_MS)
+  // 启动时先跑一次,别等一小时
+  try {
+    store.gcStore(opts.retain)
+    store.gcLedger(opts.ledgerRetain)
+  } catch {}
+
+  return await new Promise((resolve) => {
+    let shuttingDown = false
+    const shutdown = (sig) => {
+      if (shuttingDown) return
+      shuttingDown = true
+      process.stderr.write(`收到 ${sig},停止 ${collectors.length} 个 consumer\n`)
+      clearInterval(gcTimer)
+      for (const c of collectors) c.stop()
+      // 给子进程时间卸载服务端订阅
+      setTimeout(() => resolve(0), 3000)
+    }
+    process.on('SIGTERM', () => shutdown('SIGTERM'))
+    process.on('SIGINT', () => shutdown('SIGINT'))
+  })
+}
+
+module.exports = { runCollect, EVENT_KEY }

package/lib/dedup.js

@@ -0,0 +1,69 @@
+'use strict'
+
+// 两层去重:cursor 管进度,message_id 管幂等。
+// 为什么还要第二层:collect 重启或 bus 重投时同一条消息可能二次落盘,
+// 此时它是**新文件**(新纳秒前缀),游标拦不住 —— 只有 message_id 能拦。
+// 为什么不用 event_id:同一条消息在不同 consumer 上 event_id 可复用/变化,
+// 实测不可作幂等键(旧架构 docs/architecture.md 已记此坑)。
+const fs = require('fs')
+const path = require('path')
+const { paths, ensureDir } = require('./paths')
+
+const TTL_MS = 6 * 3600 * 1000
+
+class Dedup {
+  constructor(name, app) {
+    this.file = path.join(paths.cursors, name, `${app}.seen.json`)
+    this.map = new Map()
+    this.dirty = false
+    this._load()
+  }
+
+  _load() {
+    let raw
+    try {
+      raw = fs.readFileSync(this.file, 'utf8')
+    } catch {
+      return
+    }
+    let obj
+    try {
+      obj = JSON.parse(raw)
+    } catch {
+      return // 坏文件:当空处理,最多多放行一条重复
+    }
+    const cutoff = Date.now() - TTL_MS
+    for (const [id, ts] of Object.entries(obj)) {
+      if (typeof ts === 'number' && ts >= cutoff) this.map.set(id, ts)
+    }
+  }
+
+  has(id) {
+    if (!id) return false
+    return this.map.has(id)
+  }
+
+  add(id) {
+    if (!id) return
+    this.map.set(id, Date.now())
+    this.dirty = true
+  }
+
+  flush() {
+    if (!this.dirty) return
+    const cutoff = Date.now() - TTL_MS
+    const obj = {}
+    for (const [id, ts] of this.map) {
+      if (ts >= cutoff) obj[id] = ts
+    }
+    ensureDir(path.dirname(this.file))
+    const tmp = `${this.file}.tmp`
+    try {
+      fs.writeFileSync(tmp, JSON.stringify(obj))
+      fs.renameSync(tmp, this.file)
+      this.dirty = false
+    } catch {}
+  }
+}
+
+module.exports = { Dedup, TTL_MS }

package/lib/dispatch.js

@@ -0,0 +1,241 @@
+'use strict'
+
+// dispatch:常驻循环 = take + 唤起 claude。无人在场也跑。
+// **内部就是调 take** —— 保证两场景不实现分叉(旧架构三份 wrapper 各自演化出
+// 253 行就是分叉的教训)。
+const fs = require('fs')
+const path = require('path')
+const { execFileSync } = require('child_process')
+const { loadTask, listTasks, lrRoot } = require('./tasks')
+const { takeBatch } = require('./take')
+const { groupByChatThread, renderText } = require('./render')
+const { acquireBlocking } = require('./lock')
+const { paths, ensureDir } = require('./paths')
+const store = require('./store')
+const claude = require('./claude')
+const { CardSession } = require('./card')
+const { reply } = require('./reply')
+const larkcli = require('./larkcli')
+
+function cmdList() {
+  const tasks = listTasks()
+  if (!tasks.length) {
+    process.stdout.write(
+      `没有 dispatch 任务。LR_ROOT=${lrRoot()}\n` +
+        `建任务:在 $LR_ROOT/<任务名>/dispatch.yaml 写配置(模板见 lark-relay dispatch --help)\n`,
+    )
+    return 0
+  }
+  const rows = [['任务', 'app', '群数', '单元', '上次派活']]
+  for (const t of tasks) {
+    const unit = `lark-relay-dispatch@${t.name}.service`
+    let state = 'inactive'
+    try {
+      state = execFileSync('systemctl', ['is-active', unit], { encoding: 'utf8' }).trim()
+    } catch (err) {
+      state = (err.stdout || '').trim() || 'inactive'
+    }
+    let last = '—'
+    for (const chat of t.config.chats || []) {
+      try {
+        const st = fs.statSync(paths.ledgerFile(t.name, chat))
+        const m = Math.round((Date.now() - st.mtimeMs) / 60000)
+        last = m < 60 ? `${m}m ago` : `${Math.round(m / 60)}h ago`
+      } catch {}
+    }
+    rows.push([
+      t.name,
+      String(t.config.app || '?'),
+      String((t.config.chats || []).length),
+      state,
+      last,
+    ])
+    if (t.errs.length) rows.push([`  ⚠ ${t.errs.join('; ')}`, '', '', '', ''])
+  }
+  const wid = [0, 1, 2, 3, 4].map((i) => Math.max(...rows.map((r) => (r[i] || '').length)))
+  for (const r of rows) {
+    process.stdout.write(r.map((c, i) => String(c || '').padEnd(wid[i] + 2)).join('').trimEnd() + '\n')
+  }
+  return 0
+}
+
+// ledger:dispatch 每轮追加一条,四个字段。session 会因空闲滚动/过期丢上下文,
+// 结论不能丢,供跨会话回溯。
+function ledgerAppend(task, chatId, epoch, trigger, result) {
+  try {
+    ensureDir(paths.ledger)
+    const line = JSON.stringify({
+      ts: new Date().toISOString(),
+      epoch: Number(epoch) || 0,
+      trigger: String(trigger).slice(0, 500),
+      result: String(result).slice(0, 4000),
+    })
+    fs.appendFileSync(paths.ledgerFile(task, chatId), `${line}\n`)
+  } catch {}
+}
+
+// 处理一个 (chat_id, thread_id) 组:派一轮活
+async function handleGroup(t, group, opts = {}) {
+  const { name: task, taskDir, insPath, dirs, session, display } = t
+  const cfg = t.config
+  const profile = cfg.app
+  const chatId = group.chatId
+  const threadId = group.threadId
+  const events = group.events
+
+  const cwd = dirs[0] || taskDir
+  const addDirs = dirs.slice(1)
+  const batch = renderText(events)
+  const lastMsg = events[events.length - 1]?.message_id || '-'
+
+  // 每(任务,群)一把锁串行:并发会写坏 append-only ledger、错算 epoch,
+  // 且同群两轮 claude 会互相打断。粒度是群而非话题 —— session 与 epoch 状态按群竞争。
+  const lock = await acquireBlocking(`dispatch-${task}__${chatId}`, 1800_000)
+  if (!lock.ok) {
+    process.stderr.write(`dispatch: ${task}/${chatId} 获取锁超时,跳过本批\n`)
+    return 0
+  }
+
+  try {
+    // session 派生:thread 模式按 thread_id 隔离(话题即边界,不滚动,epoch 恒 0);
+    // 否则按 (群, epoch),空闲超 idle_gap 就开新世代
+    let uuid
+    let epoch = 0
+    if (session === 'thread' && threadId) {
+      uuid = claude.deriveUuid(task, `${chatId}|thread:${threadId}`)
+    } else {
+      epoch = claude.sessionEpoch(paths.root, task, chatId, Number(cfg.idle_gap) || 86400)
+      uuid = claude.deriveUuid(task, `${chatId}|${epoch}`)
+    }
+
+    const replyInThread = session === 'thread'
+    const useCard = display === 'card'
+    let card = null
+
+    if (useCard) {
+      card = new CardSession({ profile, chatId, lastMsg, replyInThread })
+      try {
+        if (!(await card.create())) throw new Error('建卡片实体失败')
+        if (!(await card.post())) throw new Error('发卡片消息失败')
+      } catch (err) {
+        process.stderr.write(`card: ${err.message},回退 final\n`)
+        card = null
+      }
+    }
+
+    const res = await claude.runClaude({
+      cwd,
+      prompt: claude.PROMPT_TEMPLATE(batch),
+      uuid,
+      instructions: insPath,
+      addDirs,
+      allowedTools: cfg.allowed || 'Read Edit Write Bash',
+      model: cfg.model,
+      timeoutSec: Number(cfg.timeout) || 1800,
+      stream: !!card,
+      onEvent: card
+        ? (kind, text) => {
+            if (kind === 'say') card.onSay(text)
+            else if (kind === 'tool') card.onTool(text)
+            else if (kind === 'final') card.onFinal()
+            if (kind !== 'final') card.update(card.acc)
+          }
+        : null,
+    })
+
+    let final = (res.final || '').trim()
+    if (!final) {
+      final =
+        res.rc === 0
+          ? '(完成,但没拿到最终结论)'
+          : `⚠️ 处理超时或异常(rc=${res.rc})。稍后重试或换个说法。\n\n错误:${String(res.err)
+              .replace(/\n/g, ' ')
+              .slice(-300)}`
+    }
+
+    if (card) {
+      // 全卡 PUT 失败必须降级发纯文本,保证结论必达
+      const ok = await card.finalize(final)
+      if (!ok) await reply(profile, chatId, lastMsg, final, { inThread: replyInThread })
+      await card.stop()
+    } else {
+      await reply(profile, chatId, lastMsg, final, { inThread: replyInThread })
+    }
+
+    ledgerAppend(task, chatId, epoch, batch, final)
+    process.stderr.write(
+      `dispatch: ${task}/${chatId}${threadId ? `/${threadId}` : ''} 完成 rc=${res.rc} ` +
+        `${events.length} 条 → ${final.length} 字符\n`,
+    )
+    return res.rc === 0 ? 0 : 1
+  } finally {
+    lock.release()
+  }
+}
+
+async function run(task, opts = {}) {
+  const t = loadTask(task)
+  if (!t) {
+    process.stderr.write(
+      `找不到任务 ${task}:${path.join(lrRoot(), task, 'dispatch.yaml')} 不存在\n` +
+        `LR_ROOT=${lrRoot()};看现有任务:lark-relay dispatch --list\n`,
+    )
+    return 2
+  }
+  if (t.errs.length) {
+    process.stderr.write(`任务 ${task} 配置有问题:\n  ${t.errs.join('\n  ')}\n`)
+    return 2
+  }
+
+  const cfg = t.config
+  const chats = cfg.chats || []
+  // thread=话题回复,交互式一问一答要跟手 → 1s;否则群任务多行需求 → 15s 让人打完
+  const debounceMs = (Number(cfg.debounce) || (t.session === 'thread' ? 1 : 15)) * 1000
+
+  process.stderr.write(
+    `dispatch ${task}: app=${cfg.app} ${chats.length} 群 session=${t.session} ` +
+      `display=${t.display} model=${cfg.model || '(默认路由)'} 防抖 ${debounceMs / 1000}s\n`,
+  )
+
+  const consumer = `dispatch-${task}`
+  if (store.readCursor(consumer, cfg.app) === null) store.seedCursorNow(consumer, cfg.app)
+
+  const ac = new AbortController()
+  let stopping = false
+  const onSig = () => {
+    stopping = true
+    ac.abort()
+  }
+  process.on('SIGTERM', onSig)
+  process.on('SIGINT', onSig)
+
+  for (;;) {
+    const res = await takeBatch({
+      app: cfg.app,
+      chats,
+      name: consumer,
+      filter: cfg.filter,
+      debounceMs,
+      maxWaitMs: 75_000,
+      timeoutMs: opts.once ? 300_000 : 12 * 3600 * 1000,
+      signal: ac.signal,
+    })
+
+    if (res.events.length) {
+      // 一个防抖窗口会吐同群多话题的消息,只按 chat_id 分组会**串话题**
+      for (const g of groupByChatThread(res.events)) {
+        try {
+          await handleGroup(t, g)
+        } catch (err) {
+          process.stderr.write(`dispatch: ${task} 处理组失败 ${err.stack || err}\n`)
+        }
+      }
+    } else if (opts.once) {
+      process.stderr.write(`dispatch: 没等到消息(${res.reason})\n`)
+    }
+
+    if (opts.once || stopping) return 0
+  }
+}
+
+module.exports = { run, cmdList, ledgerAppend, handleGroup }