lark-relay 0.4.4 → 0.4.6

package/lib/cot.js

@@ -1,377 +0,0 @@
-'use strict'
-
-// cot display:消息上挂载「思考过程」,事件流对齐 AG-UI 协议。
-// 三步流:POST 建 COT 消息 → PUT 攒批写事件(可反复)→ RUN_FINISHED 自动完结。
-// 接口细节与实测边界见 docs/cot-message-api.md
-//
-// **COT 只承载过程,结论必须单独发一条普通消息** —— 接口的设计前提,不是我们的选择。
-// 故本类没有 card.finalize(result) 那种「把结论写进载体」的能力。
-//
-// ⚠️ content 是**字符串化的 JSON**(双层编码),_encode 统一处理
-// ⚠️ RUN_FINISHED / RUN_ERROR 后再写事件被硬拒("COT already in terminal state"),
-//   故 finalize 之后必须闭嘴 —— 用 this.done 守
-const larkcli = require('./larkcli')
-const { stripToJson, errText, tail } = larkcli
-
-const BATCH_MS = Number(process.env.LR_COT_BATCH_MS || 1000)
-const MAX_EVENTS = 50 // 接口硬上限:events[] 每次 1~50 条
-// 单条 content 上限是**序列化后 4096 字节**,不是字符(文档写「字符」)。
-// 中文每字 3 字节 → 按字符截会稳定超限,且一条超长会让同批全部事件被拒
-const MAX_CONTENT_BYTES = 4096
-
-// say 映射到哪类事件。**实测两者渲染完全一致**,故按事件量取舍:
-// text 每段 3 个事件,reasoning 每段 5 个(多一对外包裹)。
-// 留开关是因为渲染一致不保证永远一致
-const SAY_AS = process.env.LR_COT_SAY_AS === 'reasoning' ? 'reasoning' : 'text'
-
-// claude 工具名 → COT 内置 icon 枚举。
-// 实测 9 个枚举全部有专属图标(search 🔍 / bash </> / read 📖 / write ✏️ / doc 📄 /
-// calendar 📅 / task ☑️ / meeting 📹 / default ●)。文档外的值多数回落成 default 的圆点,
-// 少数(shell/edit/web)生效但只是已有图标的别名 —— 没有新增表达力且无兼容承诺,不用
-const ICONS = {
-  Bash: 'bash',
-  BashOutput: 'bash',
-  Read: 'read',
-  NotebookRead: 'read',
-  Edit: 'write',
-  Write: 'write',
-  NotebookEdit: 'write',
-  Grep: 'search',
-  Glob: 'search',
-  WebSearch: 'search',
-  WebFetch: 'search',
-  Task: 'task',
-  TodoWrite: 'task',
-}
-
-// MCP 工具名(mcp__<server>__<action>)按名字猜 —— 它们在 dispatch 场景很常见,
-// 一律给 default 的圆点等于没信息。命名约定不保证,故只在猜中时用。
-// **顺序即优先级**:域名词(doc/task/calendar)比动词更能说明工具属于哪个域,故排在前
-const MCP_HINTS = [
-  [/meeting|minutes|\bvc\b/, 'meeting'],
-  [/calendar|schedule/, 'calendar'],
-  [/task|todo/, 'task'],
-  [/doc|sheet|base|wiki|file/, 'doc'],
-  [/write|create|update|edit|send|post|delete/, 'write'],
-  [/read|get|fetch|view/, 'read'],
-  [/search|find|query|list/, 'search'],
-]
-
-function iconFor(tool) {
-  if (ICONS[tool]) return ICONS[tool]
-  const s = String(tool).toLowerCase()
-  if (s.startsWith('mcp__')) {
-    for (const [re, icon] of MCP_HINTS) if (re.test(s)) return icon
-  }
-  return 'default'
-}
-
-// 按 UTF-8 字节截断,且不切坏字符(码点边界对齐)。
-// 不能按码点数截 —— 上限是字节,中文每字 3 字节(见 MAX_CONTENT_BYTES)
-function clipBytes(s, maxBytes) {
-  const str = String(s)
-  if (Buffer.byteLength(str, 'utf8') <= maxBytes) return str
-  const ell = '…'
-  const ellBytes = Buffer.byteLength(ell, 'utf8')
-  // 连省略号都装不下 → 返回空串。否则 '' + '…' 会**超过** maxBytes,
-  // 破坏「返回值 ≤ maxBytes」这个契约(本函数是导出的)
-  if (maxBytes < ellBytes) return ''
-  const budget = maxBytes - ellBytes
-  // Buffer 直切会把多字节字符切成半个 → 用码点逐个累加,天然对齐边界。
-  // 逐码点而非逐 UTF-16 单元:emoji 等代理对不能拆
-  let bytes = 0
-  let out = ''
-  for (const ch of str) {
-    const b = Buffer.byteLength(ch, 'utf8')
-    if (bytes + b > budget) break
-    out += ch
-    bytes += b
-  }
-  return out + ell
-}
-
-class CotSession {
-  constructor({ profile, chatId, lastMsg, replyInThread }) {
-    this.profile = profile
-    this.chatId = chatId
-    this.lastMsg = lastMsg
-    this.replyInThread = replyInThread
-    this.cotId = null
-    this.messageId = null
-    this.done = false // 已写 RUN_FINISHED/RUN_ERROR;之后写入必被拒
-    this.seq = 0 // 只用来生成本地唯一的 messageId/toolCallId,**从不发给服务端**
-    this.pending = [] // 待发事件队列
-    this.lastStamp = 0 // 事件 timestamp 的单调下界(见 _stamp)
-    this.pendingSay = null // 延迟一段的 say(见 onSay);结论不能进过程区
-    this.timer = null
-    // 串行队列:PUT 必须按写入顺序到达,晚发先到会让 delta 乱序拼接成错乱文本
-    this.q = Promise.resolve()
-  }
-
-  _enqueue(fn) {
-    this.q = this.q.then(fn, fn)
-    return this.q
-  }
-
-  // 步骤 ①:建 COT 消息 → {cot_id, message_id}。两者后续都要带。
-  // origin_message_id 让 COT 挂在触发它的那条用户消息上。
-  async create() {
-    const data = { receive_id: this.chatId }
-    if (this.lastMsg && this.lastMsg !== '-') data.origin_message_id = this.lastMsg
-    if (this.replyInThread) data.reply_in_thread = true
-    const { stdout } = await larkcli.run([
-      '--profile', this.profile, 'api', 'POST', '/open-apis/im/v1/message_cot',
-      '--params', JSON.stringify({ receive_id_type: 'chat_id' }),
-      '--as', 'bot', '--data', JSON.stringify(data),
-    ])
-    const j = JSON.parse(stripToJson(stdout))
-    this.cotId = j?.data?.cot_id || null
-    this.messageId = j?.data?.message_id || null
-    if (!this.cotId || !this.messageId) return null
-    // RUN_STARTED 立刻发,让消息一出现就是「在跑」而不是空壳
-    this._push(['RUN_STARTED', { runId: this.cotId, threadId: this.cotId }])
-    await this.flush()
-    return this.cotId
-  }
-
-  // 编码单条事件:content 序列化 + 超 4096 字节时截断自由文本字段。
-  // 返回事件对象,null = 截不下来只能丢弃(整批被服务端拒比丢一条更糟)
-  _encode(eventType, content) {
-    let s = JSON.stringify(content)
-    if (Buffer.byteLength(s, 'utf8') > MAX_CONTENT_BYTES) {
-      // 超长只可能来自 delta/title/message 这类自由文本
-      const key = ['delta', 'title', 'message'].find((k) => typeof content[k] === 'string')
-      if (!key) return null // 没有可截的字段 → 丢这条,过程事件不值得冒整批失败
-      // JSON 转义会膨胀(换行 2 字节、控制字符 6 字节),故截完再验、按实测比例收敛。
-      // 别用固定系数退让 —— 0.8 退 8 次才到 0.17,覆盖不了 6 倍膨胀(ANSI 日志会撞上)
-      const overhead = Buffer.byteLength(JSON.stringify({ ...content, [key]: '' }), 'utf8')
-      let budget = MAX_CONTENT_BYTES - overhead
-      for (let i = 0; i < 8 && budget > 0; i++) {
-        const clipped = { ...content, [key]: clipBytes(content[key], budget) }
-        s = JSON.stringify(clipped)
-        const actual = Buffer.byteLength(s, 'utf8')
-        if (actual <= MAX_CONTENT_BYTES) break
-        // 按本轮实测膨胀率反推能装多少,留 2% 余量
-        const ratio = (MAX_CONTENT_BYTES - overhead) / (actual - overhead)
-        const next = Math.floor(budget * ratio * 0.98)
-        budget = next < budget ? next : budget - 1 // 保证严格递减,不会死循环
-      }
-      // 截不下来就丢;配对的 START/END 由 _push 的成组语义一起丢,不留空气泡
-      if (Buffer.byteLength(s, 'utf8') > MAX_CONTENT_BYTES) return null
-    }
-    return { event_type: eventType, content: s, timestamp: String(this._stamp()) }
-  }
-
-  // 事件 timestamp 必须**严格单调递增**。
-  // 实测(2026-08-20):同一批 8 个 delta 用相同 timestamp 时,客户端渲染成
-  // 「3 2 6 8 7 5 4 1」—— 不是反转而是完全打乱,说明它按 timestamp 排序且排序不稳定。
-  // 而一段 say 的 START/CONTENT/END 是同步生成的,Date.now() 必然相同 → 文字错乱。
-  // 墙上时间只作下界,计数器保证单调(同 paths.js 的 stamp,时钟回拨也不倒退)
-  _stamp() {
-    const now = Date.now()
-    this.lastStamp = now > this.lastStamp ? now : this.lastStamp + 1
-    return this.lastStamp
-  }
-
-  // 成组入队:**同一组事件保证同批发出**。
-  // 一段 say 是 3 件套(reasoning 档 5 件)、一次工具调用是 2 件套 —— 若被切批拆散,
-  // 前半批失败就会让客户端收到没有 START 的孤立 CONTENT/END(渲染行为未验证)。
-  // 组内任一条因超长被丢 → 整组丢,不留「有气泡无内容」
-  _push(...events) {
-    if (this.done) return
-    const encoded = []
-    for (const [type, content] of events) {
-      const e = this._encode(type, content)
-      if (!e) return // 组内有一条编码不出来 → 整组不发
-      encoded.push(e)
-    }
-    // 装不下整组就先把已攒的发走,让这一组完整落进下一批 —— 这是「不跨批」的实现
-    if (this.pending.length && this.pending.length + encoded.length > MAX_EVENTS) this.flush()
-    this.pending.push(...encoded)
-    if (this.pending.length >= MAX_EVENTS) {
-      this.flush()
-    } else if (!this.timer) {
-      this.timer = setTimeout(() => this.flush(), BATCH_MS)
-      if (this.timer.unref) this.timer.unref() // 别让攒批定时器吊住进程退出
-    }
-  }
-
-  // 等队列排空后返回 v,且**吞掉 rejection** —— flush/update 返回的就是 this.q,
-  // 而它们被 fire-and-forget 调用,裸传 rejected 的 q 会终结常驻进程
-  _settled(v) {
-    return this.q.then(
-      () => v,
-      () => v,
-    )
-  }
-
-  // 步骤 ②:PUT 写事件。返回 bool —— **调用方靠它判断是否要兜底**
-  // (RUN_FINISHED 写失败则 COT 永久卡在「在跑」)。
-  // 整个 fn 体裹 try:flush() 绝不能抛(理由同 _settled);连日志的 EPIPE 也要吞
-  flush() {
-    if (this.timer) {
-      clearTimeout(this.timer)
-      this.timer = null
-    }
-    // 已封口:pending 里的事件注定被拒,清掉省下每批一次的失败请求 + 日志
-    if (this.done) {
-      this.pending = []
-      return this._settled(false)
-    }
-    // cotId 为 null 时**不清空 pending** —— create 还没成功,事件要活到它成功
-    if (!this.pending.length || !this.cotId) return this._settled(true)
-    const batch = this.pending
-    this.pending = []
-    return this._enqueue(async () => {
-      let ok = true
-      try {
-        // 切片非冗余:create 之前攒的事件可远超 50 条(那时 flush 提前返回且不清空)。
-        // 切点不会落在一段 say 中间 —— _push 的成组语义保证
-        for (let i = 0; i < batch.length; i += MAX_EVENTS) {
-          const events = batch.slice(i, i + MAX_EVENTS)
-          try {
-            await larkcli.run([
-              '--profile', this.profile, 'api', 'PUT', '/open-apis/im/v1/message_cot',
-              '--as', 'bot',
-              '--data', JSON.stringify({
-                events, message_id: this.messageId, cot_id: this.cotId,
-              }),
-            ])
-          } catch (err) {
-            ok = false
-            const t = tail(errText(err), 200)
-            process.stderr.write(`cot: 写事件失败(${events.length} 条)→ ${t}\n`)
-            // terminal state 之后的写入全是徒劳,直接封口
-            if (/terminal state/.test(t)) this.done = true
-            break // 一片失败,后续片多半同因,别刷屏
-          }
-        }
-      } catch {
-        ok = false // 含 stderr.write 抛 EPIPE 这类极端情况
-      }
-      return ok
-    })
-  }
-
-  // 中间文本。每段一个独立 messageId —— 同 id 的多条 CONTENT 会被客户端拼成一段,
-  // 而两次 say 之间通常隔着工具调用,拼起来读不通。
-  //
-  // **延迟一段**:最后一段 say 就是结论,它会作为独立消息再发一次 ——
-  // 也写进过程区群里就看到两遍。故压着最新一段,onFinal 时丢弃。
-  // 用「延迟一段」而非内容比较 —— 最稳
-  onSay(text) {
-    this._flushPending()
-    this.pendingSay = text
-  }
-
-  _flushPending() {
-    if (this.pendingSay === null) return
-    const text = this.pendingSay
-    this.pendingSay = null
-    const id = `say-${++this.seq}`
-    if (SAY_AS === 'text') {
-      this._push(
-        ['TEXT_MESSAGE_START', { messageId: id, role: 'assistant' }],
-        ['TEXT_MESSAGE_CONTENT', { messageId: id, delta: String(text) }],
-        ['TEXT_MESSAGE_END', { messageId: id }],
-      )
-    } else {
-      this._push(
-        ['REASONING_START', { messageId: id }],
-        ['REASONING_MESSAGE_START', { messageId: id }],
-        ['REASONING_MESSAGE_CONTENT', { messageId: id, delta: String(text) }],
-        ['REASONING_MESSAGE_END', { messageId: id }],
-        ['REASONING_END', { messageId: id }],
-      )
-    }
-  }
-
-  // 工具调用。**不写 TOOL_CALL_RESULT**:输出动辄几千字符且可能含不宜进群的仓库内容,
-  // 与 card 档只显示工具名+参数摘要一致。text 形如 "Bash: ls -la"(claude.js 拼的)
-  onTool(text) {
-    // 工具调用到来 = 前面那段 say 不是结论,可以放行了
-    this._flushPending()
-    const s = String(text)
-    const tool = s.split(':', 1)[0].trim()
-    const id = `tool-${++this.seq}`
-    this._push(
-      [
-        'TOOL_CALL_START',
-        {
-          toolCallId: id,
-          icon: iconFor(tool),
-          title: s,
-          toolCallName: tool || 'tool',
-        },
-      ],
-      ['TOOL_CALL_END', { toolCallId: id }],
-    )
-  }
-
-  // 手里那段 pending(= 结论)直接丢弃,不放行 —— 它会作为独立消息发出,
-  // 写进过程区就成了群里的第二遍
-  onFinal() {
-    this.pendingSay = null
-  }
-
-  // 步骤 ③:RUN_FINISHED 自动完结 —— **但只在写入成功时**。写失败(500/频控/抖动)
-  // 那条终结事件就没到服务端,COT 永久卡在「在跑」→ 靠 complete 兜底(幂等,不守 done)。
-  // rc != 0 走 RUN_ERROR + 无条件 complete:RUN_ERROR 是否自动流转未验证,补一刀不亏
-  async finalize({ rc = 0, error = '' } = {}) {
-    if (!this.cotId || this.done) return false
-    if (rc === 0) {
-      this._push(['RUN_FINISHED', { runId: this.cotId, threadId: this.cotId }])
-      const ok = await this.flush()
-      this.done = true
-      if (!ok) await this.complete('done') // 它和最多 49 条事件同批,该批被拒就一起没了
-      return true
-    }
-    // rc != 0:没有「结论」这回事,压着的那段 say 是仅有的线索,放行
-    this._flushPending()
-    this._push([
-      'RUN_ERROR',
-      {
-        runId: this.cotId,
-        threadId: this.cotId,
-        message: clipBytes(error || `rc=${rc}`, 500),
-        code: String(rc),
-      },
-    ])
-    await this.flush()
-    this.done = true
-    await this.complete('error')
-    return true
-  }
-
-  // 手动关写入态。正常路径不需要(RUN_FINISHED 已流转),
-  // 留给异常中断 —— 不调的话 COT 会一直显示「在跑」
-  async complete(reason = 'done') {
-    if (!this.cotId) return false
-    return this._enqueue(async () => {
-      try {
-        await larkcli.run([
-          '--profile', this.profile, 'api', 'POST',
-          `/open-apis/im/v1/message_cot/complete/${this.cotId}`,
-          '--params', JSON.stringify({ message_id: this.messageId, reason }),
-          '--as', 'bot',
-        ])
-        return true
-      } catch {
-        return false
-      }
-    })
-  }
-
-  // 兜「从没 finalize 成功」的情况:超时被 SIGTERM、异常中断 ——
-  // 不调 complete 的话 COT 会一直显示「在跑」
-  async stop() {
-    if (this.done || !this.cotId) return
-    // 从没 finalize 就走到这里 = 异常中断,压着的那段不是结论 → 放行
-    this._flushPending()
-    await this.flush()
-    await this.complete('timeout')
-    this.done = true
-  }
-}
-
-module.exports = { CotSession, iconFor, clipBytes, SAY_AS, MAX_EVENTS, MAX_CONTENT_BYTES }

package/lib/dispatch.js

@@ -1,276 +0,0 @@
-'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 { sendCard } = require('./card')
-const { CotSession } = require('./cot')
-const { reply } = require('./reply')
-
-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, mode } = 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 派生:work 模式按 thread_id 隔离(话题即边界,不滚动,epoch 恒 0);
-    // chat 模式按 (群, epoch),空闲超 idle_gap 就开新世代
-    let uuid
-    let epoch = 0
-    if (mode.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}`)
-    }
-
-    // 过程展示:work 模式挂 COT 消息。建不起来就静默降级(结论照发)
-    let cot = null
-    if (mode.cot) {
-      cot = new CotSession({ profile, chatId, lastMsg, replyInThread: mode.thread })
-      try {
-        if (!(await cot.create())) throw new Error('建 COT 消息失败')
-      } catch (err) {
-        process.stderr.write(`cot: ${err.message},本轮无过程展示\n`)
-        cot = null
-      }
-    }
-
-    const res = await claude.runClaude({
-      cwd,
-      prompt: claude.PROMPTS[mode.prompt](batch),
-      uuid,
-      instructions: insPath,
-      addDirs,
-      allowedTools: cfg.allowed || 'Read Edit Write Bash',
-      model: cfg.model,
-      timeoutSec: Number(cfg.timeout) || 1800,
-      stream: !!cot,
-      onEvent: cot
-        ? (kind, text) => {
-            if (kind === 'say') cot.onSay(text)
-            else if (kind === 'tool') cot.onTool(text)
-            else if (kind === 'final') cot.onFinal()
-          }
-        : null,
-    })
-
-    // 兜底文案分两套:要发回群的(deliver != none)面向群里的人写,
-    // agent 模式的 final 只进台账,不该出现「稍后重试或换个说法」这种对人说的话
-    let final = (res.final || '').trim()
-    if (!final) {
-      const errTail = String(res.err).replace(/\n/g, ' ').slice(-300)
-      if (mode.deliver === 'none') {
-        final = res.rc === 0 ? '(本轮无自述)' : `(异常 rc=${res.rc}) ${errTail}`
-      } else {
-        final =
-          res.rc === 0
-            ? '(完成,但没拿到最终结论)'
-            : `⚠️ 处理超时或异常(rc=${res.rc})。稍后重试或换个说法。\n\n错误:${errTail}`
-      }
-    }
-
-    // 收尾必须包 try/catch:handleGroup 外层只有 try/finally(无 catch),
-    // 收尾一抛就会跳过下面的结论投递 + ledgerAppend,而 take 游标已推
-    // → 结论既不进群也不进台账,这批消息永不重来
-    if (cot) {
-      try {
-        await cot.finalize({ rc: res.rc, error: res.err })
-        await cot.stop()
-      } catch (err) {
-        process.stderr.write(`cot: 收尾异常(不影响结论)→ ${err.stack || err}\n`)
-      }
-    }
-
-    // 结论投递:card = 卡片(markdown 渲染、不受 3500 字符分片限制),失败降级纯文本;
-    // text = 纯文本;none = **引擎不发**,agent 模式下模型已自己发过了,
-    // final 只是它的一句自述(进台账供回溯)
-    if (mode.deliver !== 'none') {
-      const sent = mode.deliver === 'card'
-        ? await sendCard(final, { profile, chatId, replyTo: lastMsg, inThread: mode.thread })
-        : false
-      if (!sent) await reply(profile, chatId, lastMsg, final, { inThread: mode.thread })
-    }
-
-    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 || []
-  // work=话题内一问一答要跟手 → 1s;chat=群里多行需求 → 15s 让人打完
-  const debounceMs = (Number(cfg.debounce) || t.mode.debounce) * 1000
-
-  process.stderr.write(
-    `dispatch ${task}: app=${cfg.app} ${chats.length} 群 mode=${t.modeName} ` +
-      `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 (;;) {
-    let res
-    try {
-      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,
-      })
-    } catch (err) {
-      // 取批阶段的异常绝不能让进程退出:Restart=on-failure 会变成每 5s 崩一次,
-      // 而卡住的那条消息永远在队首 → 任务彻底停摆且看不出原因
-      process.stderr.write(`dispatch: ${task} 取批失败,15s 后重试 → ${err.stack || err}\n`)
-      if (opts.once) return 1
-      await new Promise((r) => setTimeout(r, 15_000))
-      continue
-    }
-
-    if (res.events.length) {
-      // 一个防抖窗口会吐同群多话题的消息,只按 chat_id 分组会**串话题**
-      const groups = groupByChatThread(res.events)
-      for (let i = 0; i < groups.length; i++) {
-        // 收到停止信号后不再开新一轮 claude:单元 TimeoutStopSec=30,
-        // 而一轮最长 1800s → 会被 SIGKILL,卡片停在占位符、结论不回群。
-        // 游标此时也没推(take 的 abort 分支只在有批次时推),故剩余组下次重新取到
-        if (stopping) {
-          process.stderr.write(
-            `dispatch: ${task} 正在停止,剩余 ${groups.length - i} 组留到下次\n`,
-          )
-          break
-        }
-        try {
-          await handleGroup(t, groups[i])
-        } catch (err) {
-          process.stderr.write(`dispatch: ${task} 处理组失败 ${err.stack || err}\n`)
-        }
-      }
-    } else if (opts.once) {
-      process.stderr.write(`dispatch: 没等到消息(${res.reason})\n`)
-      return res.reason === 'timeout' ? 4 : 0 // 与 take 对齐:4 = 等超时,0 = 正常
-    }
-
-    if (opts.once || stopping) return 0
-  }
-}
-
-module.exports = { run, cmdList, handleGroup }