lark-relay 0.4.5 → 0.4.7

package/lib/help.js

@@ -52,20 +52,26 @@ function takeHelp(apps) {
 
 const COLLECT_HELP = `把全部 lark-cli profile 的事件收下来,原子落盘。零参数、零配置。
 
-  lark-relay collect                    # 前台跑(调试)
+  lark-relay-collect                    # 前台跑(调试)
   常驻:Linux 用 systemd,macOS 用 launchd(单元模板见仓库 systemd//launchd 目录)
 
+独立可执行文件而非 \`lark-relay\` 的子命令 —— 它是常驻服务,服务管理器展示的是
+可执行文件名,与 launchd label(com.adaex.lark-relay-collect)、systemd 单元名同名才认得出。
+
 app 列表实时读 \`lark-cli profile list\`,新增 profile 自动纳入,无需改配置。
 每 app 一个子进程;某个挂了单独重启,不影响其他。
 tokenStatus 为 expired 的 profile 自动跳过并 warn(永久失败,重试是死循环)。
 用户重新 login 后下次启动自动纳入。
 
 为什么必须常驻:lark 事件是流式的,进程不在的时刻消息永久丢失(实测:消息发出
-8s 后才起 consumer,收到 0 条)。collect 独立常驻,才能让 take/dispatch 侧
-崩了、claude 跑 30 分钟、会话关几小时,都不丢消息。
+8s 后才起 consumer,收到 0 条)。collect 独立常驻,才能让 take 侧
+崩了、AI 跑 30 分钟、会话关几小时,都不丢消息。
 
-装完先 \`lark-relay status\` 确认 -- collect 行应为 running;不在跑看
-服务日志(Linux \`journalctl -u lark-relay-collect\`;macOS \`log show --predicate 'process == "lark-relay"'\`)。
+装完先 \`lark-relay status\` 确认 -- collect 行应为 running;不在跑看服务日志:
+  Linux   journalctl -u lark-relay-collect
+  macOS   tail -f ~/.lark-relay/logs/collect.err.log
+          (launchd 把 stderr 直写该文件,**不进统一日志**,log show 查不到)
+          日志行带 ISO 时间戳;超 16MB 自动轮转,旧的在 .1/.2/.3
 
 落盘:~/.lark-relay/store/<app>/<YYYY-MM-DD>/<纳秒>_<pid>_<seq>.json
 回收由 collect 进程内每小时自查一次,删超期的整个日期目录(不另起 gc 单元/timer)。
@@ -73,81 +79,33 @@ tokenStatus 为 expired 的 profile 自动跳过并 warn(永久失败,重试是
 参数
   --exclude <apps>  排除指定 profile(逗号分隔)
   --retain N        store 保留天数(默认 3)
-  --ledger-retain N ledger 保留天数(默认 90)`
+
+环境变量
+  LARK_RELAY_LOG_MAX_MB  单个日志文件上限(默认 16),超了轮转
+  LARK_RELAY_LOG_KEEP    保留几代旧日志(默认 3)`
 
 const STATUS_HELP = `一眼看清全局:谁在跑、积压多少、游标在哪。
 
   lark-relay status              # 概览
   lark-relay status --json       # 机器可读
 
-排障入口:某消费者「落后」很多 -> 它的 take/dispatch 没在跑或卡住;
+排障入口:某消费者「落后」很多 -> 它的 take 没在跑或卡住;
 「无消费者」= 白采,可考虑 --exclude。
-collect 行不是 running -> 看服务日志(systemd journal 或 launchd 统一日志),
+collect 行不是 running -> 看服务日志(Linux journalctl;
+macOS \`tail -f ~/.lark-relay/logs/collect.err.log\` -- 不进统一日志),
 collect 停摆的每一秒都在丢消息。`
 
-const DISPATCH_HELP = `常驻:等消息 -> 唤起 claude 干活 -> 结果回群。无人在场也跑。
-
-  lark-relay dispatch --list          # 列出所有 dispatch 任务及状态
-  lark-relay dispatch <task> --once   # 前台跑一轮(调试,不进常驻服务)
-  常驻:Linux 用 systemd,macOS 用 launchd(单元模板见仓库 systemd//launchd 目录)
+const GUIDE = `lark-relay -- Lark 事件中继站。两件事:收下来 / 我来取。
 
---list 输出:任务名 / app / 群数 / 常驻服务是否 active / 上次 ledger 时间
-
-任务发现:扫 $LR_ROOT/*/dispatch.yaml -- 有文件即是任务,无需注册表。
-LR_ROOT 在单元里指定(唯一的目录绑定,与代码无关)。
-
-dispatch.yaml(4 必填 + 3 可选)
-  app: <profile 名>
-  chats: [oc_xxx]
-  dirs: [/path/to/repo]            # 首个 = 主工作目录
-  instructions: ./instructions.md  # 职责/边界,--append-system-prompt-file 注入
-  filter: '.mentions[]?.id == "ou_xxx"'   # 可选
-  # mode: work        默认;work | chat | agent(见下)
-  # model: <名称>      默认走终端同一套默认路由
-
-mode 三个场景(一个键定死全部行为,不用拼组合)
-  work   处理工作:话题内回复 + 过程挂 COT 消息 + 结论发卡片
-         + 按 thread_id 隔离 session + 防抖 1s(一问一答要跟手)
-         COT 要求客户端 PC >= 7.70 / 移动 >= 7.74;老客户端那条过程消息显示为
-         「Completed」(不崩),结论卡片不受影响
-  chat   简单问答:直发群里 + 纯文本 + 按(群, epoch)隔离 session
-         + 防抖 15s(等人打完多行)
-  agent  模型自己当运营者:引擎只拉起它 + 传消息 + 记台账,**一条消息都不发**。
-         发不发 / 回哪条 / 用哪个 bot 身份 / 文字还是表情,全由模型按
-         instructions 决定(它有 Bash + lark-cli)。适合「多数轮该沉默」的
-         群运营 -- work/chat 会逼模型每轮都产出一段发回群的话
+\`lark-relay-collect\` 把事件收下来落盘(常驻服务),\`lark-relay take\` 在你需要时取走一批。
+两者分离是硬需求:消费侧崩了、AI 跑 30 分钟、会话关几小时,采集都不能停 --
+停摆的每一秒都在丢消息。所以采集是独立的可执行文件,不是本命令的子命令。
 
-最佳实践
-  · 边界写 instructions,别指望 --add-dir 目录的 CLAUDE.md(启动不加载)
-  · 改完 yaml 先 --once 跑一轮验证,再 enable
-  · 高风险发布仍建议人工执行
-
-退出码(--once)
-  0  跑了一轮,或没等到消息但正常结束
-  1  取批异常(看 stderr)
-  2  任务不存在或配置错
-  4  等消息超时(5min 没消息)`
-
-const GUIDE = `lark-relay -- Lark 事件中继站。三个命令:收下来 / 我来取 / 派给别人。
-
-先判场景(两者不可混用)
-┌──────────┬────────────────────────┬────────────────────────┐
-│          │ 在场取用 take          │ 托管派活 dispatch      │
-├──────────┼────────────────────────┼────────────────────────┤
-│ 长命的   │ AI 会话(人设、上下文) │ 消息(等在队列里)     │
-│ 短命的   │ 消息(来一批处理一批)  │ AI(每轮新起,跑完就没)│
-│ 谁等谁   │ AI 等消息              │ 消息等 AI              │
-│ 控制权   │ AI 手里                │ 服务手里               │
-│ 谁能干   │ 任何 agent             │ 需内置唤起知识         │
-│ 配置     │ 纯参数,无文件         │ dispatch.yaml          │
-└──────────┴────────────────────────┴────────────────────────┘
-
-你(AI)在会话里盯群 -> take。无人在场也要干活 -> dispatch。
-
-前置:collect 必须在跑
+前置:采集必须在跑
   lark-relay status        # collect 行应为 running
   进程不在的时刻消息永久丢失,不是延迟送达。
-  不在跑 -> 起常驻服务(Linux systemd / macOS launchd,模板见仓库;或 \`lark-relay collect\` 前台调试)
+  不在跑 -> 起常驻服务(Linux systemd / macOS launchd,模板见仓库;
+           或 \`lark-relay-collect\` 前台调试)
 
 take 三步(照做)
   1. 查群 ID   lark-cli --profile <app> im +chat-search --as user --query "<群名>"
@@ -159,11 +117,6 @@ take 三步(照做)
   一批处理完再起一个。不要自己写 while 循环 -- 进程退出会通知你。
   退出码:0=有一批,4=超时没消息(正常,再起一个),2=参数错,3=游标被占用。
 
-建 dispatch 任务
-  1. 在任务目录写 dispatch.yaml(\`lark-relay dispatch --help\` 有模板)
-  2. lark-relay dispatch <task> --once     # 前台验一轮
-  3. 起常驻服务(Linux systemd / macOS launchd,模板见仓库)
-
 常见错误
   · 拿不到消息 -> 九成是 bot 不在群。验 bot 必须 --as user,
     bot 不在群时用 bot 身份查不到,「查询失败」不能推断「不在群」
@@ -176,4 +129,4 @@ take 三步(照做)
 
 各命令详情:lark-relay <命令> --help`
 
-module.exports = { takeHelp, COLLECT_HELP, STATUS_HELP, DISPATCH_HELP, GUIDE }
+module.exports = { takeHelp, COLLECT_HELP, STATUS_HELP, GUIDE }

package/lib/lock.js

@@ -1,10 +1,7 @@
 'use strict'
 
-// 两种锁,语义不同,别混:
-// - 消费者锁(非阻塞):同一 --name 不该有两个 take/dispatch 在跑,抢不到直接退出并说清楚。
-//   否则两个进程互相推游标,批次会被撕成两半。
-// - (任务,群)锁(阻塞 -w 1800):dispatch 每群串行。并发会写坏 append-only ledger,
-//   且同群两轮 claude 会互相打断。超时视为「别人正在干」,静默跳过。
+// 消费者锁(非阻塞):同一 --name 不该有两个 take 在跑,抢不到直接退出并说清楚。
+// 否则两个进程互相推游标,批次会被撕成两半。
 const fs = require('fs')
 const path = require('path')
 const { paths, ensureDir } = require('./paths')
@@ -72,19 +69,6 @@ function acquireExclusive(key) {
   return { ok: false, file: dir, holder: readPid(pidFile) }
 }
 
-// 阻塞版:等到拿到锁或超时。dispatch 每(任务,群)一把。
-async function acquireBlocking(key, timeoutMs = 1800_000, pollMs = 500) {
-  const deadline = Date.now() + timeoutMs
-  for (;;) {
-    const lock = acquireExclusive(key)
-    if (lock.ok) return lock
-    if (Date.now() >= deadline) {
-      return { ok: false, file: lock.file, holder: lock.holder, timedOut: true }
-    }
-    await new Promise((r) => setTimeout(r, pollMs))
-  }
-}
-
 function mkHandle(dir, pidFile, me) {
   let released = false
   const release = () => {
@@ -130,4 +114,4 @@ function sanitize(s) {
   return String(s).replace(/[^A-Za-z0-9._-]/g, '_')
 }
 
-module.exports = { acquireExclusive, acquireBlocking }
+module.exports = { acquireExclusive }

package/lib/log.js

@@ -0,0 +1,164 @@
+'use strict'
+
+// 常驻日志:时间戳前缀 + 按大小轮转。**只给 collect 这类常驻服务用**,
+// CLI 的用户可见输出(take 的 NDJSON 载荷、status --json)绝不能过这里 --
+// 加前缀会破坏下游解析契约。
+//
+// 为什么需要:Linux 有 journald 免费给时间戳和轮转,macOS 的 launchd 只有
+// StandardErrorPath 直写文件 -- 无时间戳、无轮转、无分级。而本项目的核心排查
+// 问题恰是「**什么时候**断线、断了多久、那个窗口丢了几条」,时间戳是唯一依据。
+const fs = require('fs')
+const path = require('path')
+const { paths } = require('./paths')
+
+// 激活判据:stderr 是普通文件 = launchd 直写场景。
+// 实测 fs.fstatSync(2):pipe -> isFile=false/isFIFO=true;重定向到文件 -> isFile=true。
+// 这一个判据同时分开了三种场景:
+//   launchd 直写文件  -> 要时间戳、要轮转(本模块接管)
+//   systemd journald  -> 不要(journald 自带时间戳,加了会重复;socket 不是 file)
+//   前台调试 tty/pipe -> 不要(人眼看,时间戳是噪音)
+// 所以不需要按平台分支,也不需要环境变量开关 -- 判据天然对齐。
+function stderrIsFile() {
+  try {
+    return fs.fstatSync(2).isFile()
+  } catch {
+    return false
+  }
+}
+
+// 轮转阈值。默认 16MB。
+// ⚠️ 下界只防 0/负数/NaN,不能写 Math.max(1, MB) —— 那会把 0.001 这种
+// 小阈值抬成 1MB,测试就没法用小文件验轮转(踩过:930 字节都没触发)
+function envBytes() {
+  const mb = Number(process.env.LARK_RELAY_LOG_MAX_MB)
+  const v = Number.isFinite(mb) && mb > 0 ? mb : 16
+  return Math.max(1024, Math.round(v * 1024 * 1024))
+}
+const MAX_BYTES = envBytes()
+// 保留代数。⚠️ 必须 >1:实测只留 1 代时,高频写入会让第二次轮转覆盖第一次的 .1,
+// 中间整段永久丢失 -- 那正是加时间戳要回溯的东西,不能自拆台脚。
+const KEEP = (() => {
+  const n = Number(process.env.LARK_RELAY_LOG_KEEP)
+  return Number.isInteger(n) && n >= 1 ? n : 3
+})()
+
+let fd = null
+let target = null
+let size = 0
+let active = false
+
+// 拿 stderr 指向的真实路径。
+// ⚠️ 不能用 realpathSync('/dev/fd/2') —— macOS 实测**不解引用**,原样返回
+// '/dev/fd/2'(Linux 才解得开)。lsof 能拿到,但为写日志 spawn 外部进程太重。
+//
+// 正解:日志路径是我们自己在 plist 里定的约定路径,直接用它,再用 dev/ino
+// 核对「它确实就是 fd 2 指向的那个文件」-- 校验通过才接管,不匹配就退回直写。
+// 这样既不 spawn,也不会在别人自定义了 StandardErrorPath 时写错对象。
+//
+// LARK_RELAY_LOG_FILE 是显式指定的逃生舱(也是测试入口):给了就直接用,
+// 跳过 dev/ino 校验 -- 调用方明确知道自己要写哪儿。
+function resolveTarget() {
+  if (process.env.LARK_RELAY_LOG_FILE) return process.env.LARK_RELAY_LOG_FILE
+  const guess = path.join(paths.root, 'logs', 'collect.err.log')
+  try {
+    const a = fs.fstatSync(2)
+    const b = fs.statSync(guess)
+    if (a.dev === b.dev && a.ino === b.ino) return guess
+  } catch {}
+  return null
+}
+
+function open() {
+  fd = fs.openSync(target, 'a')
+  try {
+    size = fs.fstatSync(fd).size
+  } catch {
+    size = 0
+  }
+}
+
+// 轮转:KEEP=3 时 .2 -> .3、.1 -> .2、当前 -> .1,然后重开。
+// 必须由本进程 reopen -- launchd 持有 fd 2,外部 rename(newsyslog)后
+// 进程仍写旧 inode,日志看着「停了」。newsyslog 要配 SIGHUP 且是系统级配置,
+// 与「服务不绑代码目录」不自洽,故不用。
+function rotate() {
+  try {
+    if (fd !== null) fs.closeSync(fd)
+  } catch {}
+  // 先把带编号的整体后移(从大到小,避免覆盖),最旧的一代自然被 rename 挤掉。
+  // ⚠️ 编号档位是 .1 ~ .KEEP,循环必须到 1 为止(曾写成把当前文件直接
+  // rename 成 .2,导致 .1 永不存在 —— 实测文件跳号)
+  for (let i = KEEP - 1; i >= 1; i--) {
+    try {
+      if (fs.existsSync(`${target}.${i}`)) fs.renameSync(`${target}.${i}`, `${target}.${i + 1}`)
+    } catch {}
+  }
+  // 当前文件永远进 .1
+  try {
+    if (fs.existsSync(target)) fs.renameSync(target, `${target}.1`)
+  } catch {}
+  open()
+}
+
+function stamp() {
+  return new Date().toISOString()
+}
+
+function writeRaw(s) {
+  if (fd === null) return process.stderr.write(s)
+  const buf = Buffer.from(s)
+  if (size + buf.length > MAX_BYTES) rotate()
+  try {
+    fs.writeSync(fd, buf)
+    size += buf.length
+  } catch {
+    // 写失败不能让常驻进程崩 -- 日志是辅助,采集是本职
+    try {
+      process.stderr.write(s)
+    } catch {}
+  }
+}
+
+// 逐行加前缀。⚠️ 必须按 \n 拆分,不能只在整块前面拼一个时间戳:
+// 调用方存在单次 write 输出多行的情况(启动横幅 3 行、子进程转发的多行诊断),
+// 只给首行加前缀会让后续行无法归属到时间点,轮转/grep 时尤其致命。
+function logLine(text) {
+  const s = String(text)
+  if (!active) return void process.stderr.write(s.endsWith('\n') ? s : `${s}\n`)
+  const body = s.endsWith('\n') ? s.slice(0, -1) : s
+  const ts = stamp()
+  let out = ''
+  for (const line of body.split('\n')) out += `${ts} ${line}\n`
+  writeRaw(out)
+}
+
+// 常驻入口调一次。非 launchd 场景是 no-op,logLine 退化成裸 stderr 直写。
+function init() {
+  if (active) return active
+  // 显式指定优先于场景探测 -- 调用方明确要写文件时不该被 isFile 判据挡住
+  if (!process.env.LARK_RELAY_LOG_FILE && !stderrIsFile()) return false
+  target = resolveTarget()
+  if (!target) return false
+  try {
+    fs.mkdirSync(path.dirname(target), { recursive: true })
+    open()
+    active = true
+  } catch {
+    fd = null
+    active = false
+  }
+  return active
+}
+
+// 测试用:重置模块态。生产代码不该调
+function _reset() {
+  try {
+    if (fd !== null) fs.closeSync(fd)
+  } catch {}
+  fd = null
+  target = null
+  size = 0
+  active = false
+}
+
+module.exports = { init, logLine, stderrIsFile, _reset }

package/lib/paths.js

@@ -11,7 +11,6 @@ const paths = {
   root: ROOT,
   store: path.join(ROOT, 'store'),
   cursors: path.join(ROOT, 'cursors'),
-  ledger: path.join(ROOT, 'ledger'),
   run: path.join(ROOT, 'run'),
 
   appDay(app, day) {
@@ -23,9 +22,6 @@ const paths = {
   cursor(name, app) {
     return path.join(ROOT, 'cursors', name, app)
   },
-  ledgerFile(task, chat) {
-    return path.join(ROOT, 'ledger', `${task}__${chat}.ndjson`)
-  },
 }
 
 function ensureDir(dir) {

package/lib/status.js

@@ -7,7 +7,6 @@ const { execFileSync } = require('child_process')
 const store = require('./store')
 const { paths } = require('./paths')
 const larkcli = require('./larkcli')
-const { listTasks } = require('./tasks')
 
 function ago(ms) {
   if (!ms) return '—'
@@ -41,9 +40,8 @@ function unitMainPid(unit) {
 
 // 服务管理器按平台分治:Linux systemd / macOS launchd。
 // 单元名/label 是部署约定,与 systemd 单元、launchd plist 同源;
-// LR_COLLECT_LABEL / LR_DISPATCH_LABEL_PREFIX 是改名部署的逃生舱。
+// LR_COLLECT_LABEL 是改名部署的逃生舱。
 const COLLECT_LABEL = process.env.LR_COLLECT_LABEL || 'com.adaex.lark-relay-collect'
-const DISPATCH_LABEL_PREFIX = process.env.LR_DISPATCH_LABEL_PREFIX || 'com.adaex.lark-relay-dispatch'
 
 function launchctlState(label) {
   try {
@@ -53,21 +51,25 @@ function launchctlState(label) {
       encoding: 'utf8',
       stdio: ['ignore', 'pipe', 'ignore'],
     })
-    const state = (out.match(/^\s*state\s*=\s*(\S+)/m) || [])[1]
+    // ⚠️ 取值必须到行尾再 trim,不能用 (\S+) —— launchd 对已加载但没在跑的服务
+    // 输出 `state = not running`,(\S+) 只吃到 "not",status 会显示成
+    // 「collect ○ not」。而「collect 没在跑」正是最要命的状态,偏偏这时不可读
+    //
+    // 只把 running 归一成 active(供上层判活),其余保留 launchd 原话不映射成
+    // systemd 的 inactive —— 用户接着要跑 `launchctl print`,看到的就是
+    // `not running`,术语一致比跨平台统一更有用
+    const state = (out.match(/^\s*state\s*=\s*(.+)$/m) || [])[1]
     const pid = Number((out.match(/^\s*pid\s*=\s*(\d+)/m) || [])[1]) || null
-    return { state: state === 'running' ? 'active' : state || 'inactive', pid }
+    const s = (state || '').trim()
+    return { state: s === 'running' ? 'active' : s || 'inactive', pid }
   } catch {
     return { state: 'inactive', pid: null }
   }
 }
 
-// kind: 'collect' | 'dispatch';dispatch 带任务名。
-function serviceState(kind, name) {
-  if (process.platform === 'darwin') {
-    const label = kind === 'collect' ? COLLECT_LABEL : `${DISPATCH_LABEL_PREFIX}.${name}`
-    return launchctlState(label)
-  }
-  const unit = kind === 'collect' ? 'lark-relay-collect.service' : `lark-relay-dispatch@${name}.service`
+function serviceState() {
+  if (process.platform === 'darwin') return launchctlState(COLLECT_LABEL)
+  const unit = 'lark-relay-collect.service'
   return { state: unitState(unit), pid: unitMainPid(unit) }
 }
 
@@ -113,7 +115,7 @@ function lagOf(app, cursor) {
 }
 
 async function buildStatus() {
-  const { state, pid } = serviceState('collect')
+  const { state, pid } = serviceState()
 
   let profiles = []
   try {
@@ -145,25 +147,7 @@ async function buildStatus() {
     rows.push({ app, today: store.countToday(app), latestMs, consumers: cs })
   }
 
-  const tasks = []
-  for (const t of listTasks()) {
-    let lastLedgerMs = null
-    for (const chat of t.config.chats || []) {
-      try {
-        const st = fs.statSync(paths.ledgerFile(t.name, chat))
-        if (!lastLedgerMs || st.mtimeMs > lastLedgerMs) lastLedgerMs = st.mtimeMs
-      } catch {}
-    }
-    tasks.push({
-      name: t.name,
-      app: t.config.app,
-      chats: (t.config.chats || []).length,
-      state: serviceState('dispatch', t.name).state,
-      lastLedgerMs,
-    })
-  }
-
-  return { collect: { state, pid, usable, expired, hint: collectHint() }, apps: rows, tasks }
+  return { collect: { state, pid, usable, expired, hint: collectHint() }, apps: rows }
 }
 
 function formatStatus(s) {
@@ -201,16 +185,6 @@ function formatStatus(s) {
     out.push(`${w(r.app, 8)}${w(r.today, 10)}${w(ago(r.latestMs), 13)}${cs}`)
   }
 
-  if (s.tasks.length) {
-    out.push('')
-    out.push('dispatch 任务')
-    for (const t of s.tasks) {
-      const d = t.state === 'active' ? '●' : '○'
-      out.push(
-        `${w(t.name, 9)}${d} ${w(t.state, 9)}${w(`${t.chats} 群`, 7)}上次派活 ${ago(t.lastLedgerMs)}`,
-      )
-    }
-  }
   return out.join('\n')
 }
 

package/lib/store.js

@@ -27,7 +27,7 @@ function writeEvent(app, obj, seq) {
 
 // 排序键:stamp → pid → seq,数值比较(不靠字典序,避免位宽变化时错序)
 // ⚠️ 必须容忍非法文件名:任何手工放进 store 的 .json(notes.json / 备份 / README.json)
-// 都会进到这里。曾用 BigInt 裸解析 → SyntaxError 让 take/status/dispatch 全线崩溃
+// 都会进到这里。曾用 BigInt 裸解析 → SyntaxError 让 take/status 全线崩溃
 // (且需目录里 ≥2 个文件才触发,因为单元素 sort 不调比较器 —— 攒够两个突然全崩)
 const NAME_RE = /^(\d+)_(\d+)_(\d+)$/
 
@@ -175,28 +175,6 @@ function gcStore(retainDays) {
   return removed
 }
 
-// ledger 是 ~/.lark-relay/ 里唯一不能重建的东西,按天回收(默认 90 天)
-function gcLedger(retainDays) {
-  const cutoff = Date.now() - retainDays * 86400 * 1000
-  const removed = []
-  let names
-  try {
-    names = fs.readdirSync(paths.ledger)
-  } catch {
-    return removed
-  }
-  for (const name of names) {
-    const file = path.join(paths.ledger, name)
-    try {
-      if (fs.statSync(file).mtimeMs < cutoff) {
-        fs.rmSync(file, { force: true })
-        removed.push(name)
-      }
-    } catch {}
-  }
-  return removed
-}
-
 module.exports = {
   writeEvent,
   scanWindow,
@@ -212,5 +190,4 @@ module.exports = {
   latestEntry,
   listApps,
   gcStore,
-  gcLedger,
 }

package/lib/take.js

@@ -77,8 +77,8 @@ async function takeBatch(opts) {
 
   for (;;) {
     // abort(SIGTERM/SIGINT)时必须和正常返回一样落盘 —— 否则批次已吐给调用方
-    // (AI 已看到、dispatch 已跑完 claude 并回群),游标却没推、dedup 没落盘,
-    // 重启后同一批会**重跑一遍**(实测:重复回群 + ledger 两行)
+    // (AI 已看到、可能已回群),游标却没推、dedup 没落盘,
+    // 重启后同一批会**重跑一遍**(实测:重复回群)
     if (signal && signal.aborted) {
       if (batch.length && commit) store.writeCursor(name, app, commit)
       dedup.flush()

package/lib/utf8.js

@@ -0,0 +1,15 @@
+'use strict'
+
+// UTF-8 兜底:systemd / launchd 环境都无 LANG -> C locale。虽然 Node 的字符串处理
+// 不像 bash 那样按字节切片,但子进程(lark-cli)会继承 locale,中文仍会被切坏。
+//
+// 两个 bin(lark-relay / lark-relay-collect)都要,故抽成模块 —— 复制两份会漂移。
+// 必须在任何 spawn 之前执行,所以两个入口都在最顶上 require 它。
+function ensureUtf8(env = process.env) {
+  if (!/utf-?8/i.test(env.LC_ALL || env.LC_CTYPE || env.LANG || '')) {
+    env.LANG = 'C.UTF-8'
+    env.LC_ALL = 'C.UTF-8'
+  }
+}
+
+module.exports = { ensureUtf8 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "lark-relay",
-  "version": "0.4.5",
-  "description": "Lark event relay: collect events to disk, take a batch when you need it, or dispatch work to an AI agent.",
+  "version": "0.4.7",
+  "description": "Lark event relay: collect events to disk, take a batch when you need it.",
   "keywords": [
     "lark",
     "feishu",
@@ -17,7 +17,8 @@
     "node": ">=18"
   },
   "bin": {
-    "lark-relay": "bin/lark-relay.js"
+    "lark-relay": "bin/lark-relay.js",
+    "lark-relay-collect": "bin/lark-relay-collect.js"
   },
   "files": [
     "bin",

package/lib/card.js

@@ -1,76 +0,0 @@
-'use strict'
-
-// 结论卡片:一条非流式 interactive 消息。
-// work 模式用它发最终结论 —— 过程由 COT 消息承担(lib/cot.js),这里只放结论。
-//
-// 比纯文本好在:markdown 正常渲染、不受 reply 的 3500 字符分片限制。
-// **不需要 card 实体**:直接 msg_type=interactive 一步发出(实测),
-// cardkit 那套「建实体 → 拿 card_id → 流式 PUT → 关流式」只有流式打字机才需要
-const larkcli = require('./larkcli')
-const { errText, tail } = larkcli
-
-// 飞书卡片按标题字号渲染 #,窄卡片里过大突兀 → ATX 标题降级为加粗。
-// 必须状态机跳过 ``` 代码块:块内的 `# 注释`(shell/python)绝不能被误降级
-function mdfix(text) {
-  const out = []
-  let inCode = false
-  for (const line of String(text).split('\n')) {
-    if (/^[ \t]*```/.test(line)) {
-      inCode = !inCode
-      out.push(line)
-      continue
-    }
-    if (!inCode) {
-      const m = line.match(/^#+[ \t]+(.*)$/)
-      if (m) {
-        out.push(m[1] === '' ? line : `**${m[1]}**`)
-        continue
-      }
-    }
-    out.push(line)
-  }
-  return out.join('\n')
-}
-
-function buildCard(text) {
-  return {
-    schema: '2.0',
-    config: {},
-    body: { elements: [{ tag: 'markdown', content: mdfix(text) }] },
-  }
-}
-
-/**
- * 发一张结论卡片。失败返回 false —— 调用方必须降级发纯文本,保证结论必达。
- * @param {object} opts {profile, chatId, replyTo, inThread}
- */
-async function sendCard(text, { profile, chatId, replyTo, inThread } = {}) {
-  const content = JSON.stringify(buildCard(text))
-  const args = replyTo && replyTo !== '-'
-    ? [
-        '--profile', profile, 'api', 'POST',
-        `/open-apis/im/v1/messages/${replyTo}/reply`,
-        '--as', 'bot',
-        '--data', JSON.stringify({
-          msg_type: 'interactive',
-          content,
-          ...(inThread ? { reply_in_thread: true } : {}),
-        }),
-      ]
-    : [
-        '--profile', profile, 'im', '+messages-send',
-        '--params', JSON.stringify({ receive_id_type: 'chat_id' }),
-        '--data', JSON.stringify({ receive_id: chatId, msg_type: 'interactive', content }),
-        '--as', 'bot',
-      ]
-  try {
-    const { stdout } = await larkcli.run(args)
-    if (/"ok":\s*true/.test(stdout)) return true
-    process.stderr.write(`card: 未 ok chat=${chatId} → ${tail(stdout)}\n`)
-  } catch (err) {
-    process.stderr.write(`card: 发送失败 chat=${chatId} → ${tail(errText(err))}\n`)
-  }
-  return false
-}
-
-module.exports = { sendCard, mdfix, buildCard }