lark-relay 0.1.1 → 0.2.0

package/lib/card.js

@@ -1,6 +1,6 @@
 'use strict'
 
-// card display:CardKit 流式打字机,单卡原地更新。ai-pmo 在用的模式。
+// card display:CardKit 流式打字机,单卡原地更新。
 // 五步流:建卡实体 → 发引用消息 → 流式 PUT body → 收尾全卡重构 → 关流式定格。
 //
 // ⚠️ 两处双层编码(踩过):
@@ -64,17 +64,30 @@ class CardSession {
     this.replyInThread = replyInThread
     this.cardId = null
     this.messageId = null
-    this.seq = 0 // int32 从 1 起,卡片更新串行无并发
+    this.seq = 0 // int32 从 1 起
     this.lastPutAt = 0
     this.acc = ''
     this.proc = ''
     this.pendingSay = null
+    // 串行队列:所有卡片写操作排队执行。
+    // ⚠️ onEvent 里的 update() 是 fire-and-forget(不 await),若并发发出,
+    // 晚发的可能先到 → 服务端拒较小 sequence;更糟的是 in-flight 的 update
+    // (seq 小、body 大所以慢)在 finalize/stop 之后才到达 →
+    // **卡片从最终结论退回中间过程文本并定格在那里**(流式已关,不会再刷新)。
+    // 实测到达顺序曾是 finalize(2) → stop(3) → update(1)
+    this.q = Promise.resolve()
   }
 
   next() {
     return ++this.seq
   }
 
+  // 把卡片写操作排进串行队列。seq 在**真正执行时**才取,保证发出顺序 == seq 顺序
+  _enqueue(fn) {
+    this.q = this.q.then(fn, fn)
+    return this.q
+  }
+
   // 步骤 ①:建卡片实体 → card_id。data 是**字符串**(双层编码)
   async create() {
     const body = JSON.stringify({ type: 'card_json', data: JSON.stringify(initCard()) })
@@ -115,71 +128,81 @@ class CardSession {
 
   // 步骤 ③:流式期单 body 元素全量替换(打字机)。
   // 全量替换故本地要维护累积串;单次失败可容忍(下次 PUT 是全量,自愈)。
-  async update(text) {
-    const now = Date.now()
-    if (now - this.lastPutAt < THROTTLE_MS) return // 仅防频控,不为攒批
-    this.lastPutAt = now
-    const content = mdfix(text || '🔧 正在查阅…')
-    try {
-      await larkcli.run([
-        '--profile', this.profile, 'api', 'PUT',
-        `/open-apis/cardkit/v1/cards/${this.cardId}/elements/body/content`,
-        '--as', 'bot',
-        '--data', JSON.stringify({ content, sequence: this.next() }),
-      ])
-    } catch {}
+  // 走串行队列:调用方 fire-and-forget 也不会乱序
+  update(text) {
+    return this._enqueue(async () => {
+      const now = Date.now()
+      if (now - this.lastPutAt < THROTTLE_MS) return // 仅防频控,不为攒批
+      this.lastPutAt = now
+      const content = mdfix(text || '🔧 正在查阅…')
+      try {
+        await larkcli.run([
+          '--profile', this.profile, 'api', 'PUT',
+          `/open-apis/cardkit/v1/cards/${this.cardId}/elements/body/content`,
+          '--as', 'bot',
+          '--data', JSON.stringify({ content, sequence: this.next() }),
+        ])
+      } catch {}
+    })
   }
 
-  // 步骤 ④:收尾全卡重构。注意外层键是 card(内含 {type,data}),不是 ③ 的 content
-  async finalize(result) {
-    const elements = []
-    if (this.proc.trim()) {
-      elements.push({
-        tag: 'collapsible_panel',
-        expanded: false,
-        header: { title: { tag: 'markdown', content: '💭 思考与执行过程(点击展开)' } },
-        elements: [{ tag: 'markdown', content: mdfix(this.proc) }],
+  // 步骤 ④:收尾全卡重构。注意外层键是 card(内含 {type,data}),不是 ③ 的 content。
+  // 排在队尾执行 —— 必须等所有 in-flight update 落地,否则会被它们覆盖
+  finalize(result) {
+    return this._enqueue(async () => {
+      const elements = []
+      if (this.proc.trim()) {
+        elements.push({
+          tag: 'collapsible_panel',
+          expanded: false,
+          header: { title: { tag: 'markdown', content: '💭 思考与执行过程(点击展开)' } },
+          elements: [{ tag: 'markdown', content: mdfix(this.proc) }],
+        })
+        elements.push({ tag: 'hr' })
+      }
+      // 无过程内容时只放结论,不放空面板
+      elements.push({ tag: 'markdown', content: mdfix(result) })
+      const card = {
+        schema: '2.0',
+        config: { streaming_mode: false },
+        body: { elements },
+      }
+      const body = JSON.stringify({
+        card: { type: 'card_json', data: JSON.stringify(card) },
+        sequence: this.next(),
       })
-      elements.push({ tag: 'hr' })
-    }
-    // 无过程内容时只放结论,不放空面板
-    elements.push({ tag: 'markdown', content: mdfix(result) })
-    const card = {
-      schema: '2.0',
-      config: { streaming_mode: false },
-      body: { elements },
-    }
-    const body = JSON.stringify({
-      card: { type: 'card_json', data: JSON.stringify(card) },
-      sequence: this.next(),
+      try {
+        const { stdout } = await larkcli.run([
+          '--profile', this.profile, 'api', 'PUT',
+          `/open-apis/cardkit/v1/cards/${this.cardId}`,
+          '--as', 'bot', '--data', body,
+        ])
+        return /"ok":\s*true/.test(stdout)
+      } catch (err) {
+        const tail = String(err.stdout || err.stderr || err.message)
+          .replace(/\n/g, ' ')
+          .slice(0, 200)
+        process.stderr.write(`card: 收尾全卡更新失败 → ${tail}\n`)
+        return false
+      }
     })
-    try {
-      const { stdout } = await larkcli.run([
-        '--profile', this.profile, 'api', 'PUT',
-        `/open-apis/cardkit/v1/cards/${this.cardId}`,
-        '--as', 'bot', '--data', body,
-      ])
-      return /"ok":\s*true/.test(stdout)
-    } catch (err) {
-      const tail = String(err.stdout || err.stderr || err.message).replace(/\n/g, ' ').slice(0, 200)
-      process.stderr.write(`card: 收尾全卡更新失败 → ${tail}\n`)
-      return false
-    }
   }
 
   // 步骤 ⑤:关流式定格。settings 的值是**字符串化的 JSON**(双层转义)
-  async stop() {
-    try {
-      await larkcli.run([
-        '--profile', this.profile, 'api', 'PATCH',
-        `/open-apis/cardkit/v1/cards/${this.cardId}/settings`,
-        '--as', 'bot',
-        '--data', JSON.stringify({
-          settings: JSON.stringify({ config: { streaming_mode: false } }),
-          sequence: this.next(),
-        }),
-      ])
-    } catch {}
+  stop() {
+    return this._enqueue(async () => {
+      try {
+        await larkcli.run([
+          '--profile', this.profile, 'api', 'PATCH',
+          `/open-apis/cardkit/v1/cards/${this.cardId}/settings`,
+          '--as', 'bot',
+          '--data', JSON.stringify({
+            settings: JSON.stringify({ config: { streaming_mode: false } }),
+            sequence: this.next(),
+          }),
+        ])
+      } catch {}
+    })
   }
 
   // 流式事件三种 kind。pendingSay 延迟一段:每轮最后一段 say 就是最终结论

package/lib/claude.js

@@ -7,10 +7,12 @@ 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')
+// 模型分发交给一个 shell 函数 `claude()` —— 由它做白名单校验与后端路由,
+// 是模型名的单一事实源。包不自己维护模型清单(那样新增后端要改两处)。
+//
+// LR_CC_RC 指向定义了 `claude()` 的 rc 文件。默认值只是个约定俗成的位置,
+// 部署时按实际环境设置:Environment=LR_CC_RC=%h/path/to/claude.sh
+const CC_RC = process.env.LR_CC_RC || path.join(os.homedir(), '.claude-route.sh')
 
 // sha1(task|scope) 前 32 位切成 8-4-4-4-12
 function deriveUuid(task, scope) {
@@ -86,15 +88,23 @@ function runClaude(opts) {
   args.push('--output-format', stream ? 'stream-json' : 'json')
   if (stream) args.push('--verbose')
 
-  // 经 bash -lc source claude.sh 后调 claude() —— 模型分发与白名单校验都在那里
+  // 经 bash -lc source <rc> 后调 claude() —— 模型分发与白名单校验都在那里。
+  // rc 不存在时**不当致命错误**:降级到 PATH 里的 claude,只在指定了 --model 时才必须有 rc
+  // (否则 --model 传给原生 claude 会是另一套语义)。
+  // ⚠️ CC_RC 必须 shellQuote:曾直接内插进双引号里的 echo,
+  // LR_CC_RC='/x$(命令)' 会被执行(实测)。所有插进 script 的值一律走 shellQuote
   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`
+  const rcQ = shellQuote(CC_RC)
+  const script = model
+    ? `set -o pipefail\n` +
+      `if ! source ${rcQ} 2>/dev/null; then\n` +
+      `  printf '%s\\n' "cc: 指定了 --model 但 source 失败,设 LR_CC_RC 指向定义 claude() 的文件" >&2\n` +
+      `  exit 3\n` +
+      `fi\n` +
+      `claude --model ${shellQuote(model)} ${quoted}\n`
+    : `set -o pipefail\n` +
+      `source ${rcQ} 2>/dev/null || true\n` +
+      `claude ${quoted}\n`
 
   return new Promise((resolve) => {
     const child = spawn('bash', ['-lc', script], {

package/lib/collect.js

@@ -24,6 +24,7 @@ class AppCollector {
     this.stopped = false
     this.backoffMs = 1000
     this.restarts = 0
+    this.healthyTimer = null
   }
 
   start() {
@@ -50,39 +51,55 @@ class AppCollector {
       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`)
       }
     })
 
+    // 退避重置的判据是「子进程活够久」而非「收到消息」:
+    // 某 app 长期没消息但连接正常时,退避会一路顶到 60s 上限再也不降,
+    // 占空比掉到 50% 以下 —— 而那段时间的消息是永久丢的
+    this.healthyTimer = setTimeout(() => {
+      this.backoffMs = 1000
+    }, 30_000)
+
     // 不加 --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) => {
+    // spawn 失败(lark-cli 被卸载 / 升级中途 / PATH 变化)只发 error+close,**没有 exit**。
+    // 把重启逻辑挂在 close 上,否则该 app 会永久停摆而主进程看着还 active
+    let restarted = false
+    const scheduleRestart = (why) => {
+      if (restarted || this.stopped) return
+      restarted = true
+      clearTimeout(this.healthyTimer)
       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`,
+        `[${this.app}] consume 退出(${why}),${Math.round(this.backoffMs / 1000)}s 后重启 ` +
+          `—— 这段时间该 app 的消息会永久丢失\n`,
       )
       // 每 app 一个子进程;某个挂了单独重启,不影响其他
       setTimeout(() => this.start(), this.backoffMs)
       this.backoffMs = Math.min(this.backoffMs * 2, 60_000)
+    }
+
+    child.on('close', (code, signal) => {
+      scheduleRestart(signal ? `signal ${signal}` : `code ${code}`)
     })
 
     child.on('error', (err) => {
       process.stderr.write(`[${this.app}] spawn 失败:${err.message}\n`)
+      scheduleRestart(`spawn error ${err.code || err.message}`)
     })
   }
 
   stop() {
     this.stopped = true
+    clearTimeout(this.healthyTimer)
     // 优雅停止:SIGTERM。禁 SIGKILL —— 否则漏卸载服务端订阅
     if (this.child) this.child.kill('SIGTERM')
   }
@@ -94,7 +111,20 @@ async function runCollect(opts) {
   ensureDir(paths.ledger)
 
   const exclude = new Set(opts.exclude || [])
-  const profiles = await larkcli.listProfiles()
+  let profiles
+  try {
+    profiles = await larkcli.listProfiles()
+  } catch (err) {
+    const e = new Error(
+      `读不到 lark-cli profile 列表:${(err.message || '').split('\n')[0]}\n` +
+        `collect 依赖 lark-cli 提供认证与事件总线。检查:\n` +
+        `  which ${larkcli.CLI}          # 装了吗、在 PATH 里吗\n` +
+        `  ${larkcli.CLI} profile list   # 能跑吗\n` +
+        `systemd 单元里 PATH 要用 fnm default alias 的稳定路径,不能用会话级的 multishell 路径`,
+    )
+    e.userFacing = true
+    throw e
+  }
 
   const chosen = []
   const skipped = []

package/lib/dispatch.js

@@ -210,28 +210,49 @@ async function run(task, opts = {}) {
   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,
-    })
+    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 分组会**串话题**
-      for (const g of groupByChatThread(res.events)) {
+      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, g)
+          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

package/lib/filter.js

@@ -37,11 +37,16 @@ function applyFilter(events, expr) {
       maxBuffer: 64 * 1024 * 1024,
     })
   } catch (err) {
-    const e = new Error(
-      `--filter 表达式求值失败:${expr}\n${(err.stderr || err.message || '').trim()}`,
+    // 保守放行 + warn,不抛 —— 抛出去会让 dispatch 崩溃循环:
+    // 表达式对某类事件报错(如 `.mentions[].id` 遇到没有 mentions 的消息)时,
+    // 那条消息永远卡在队首,游标推不动,systemd 每 5s 重启一次,该任务彻底停摆。
+    // 放行的代价是模型多看几条本该滤掉的消息,远小于停摆
+    process.stderr.write(
+      `warn: --filter 求值失败,本批不过滤(${events.length} 条放行)。表达式:${expr}\n` +
+        `      ${(err.stderr || err.message || '').trim().split('\n')[0]}\n` +
+        `      提示:字段可能不存在,用 ? 和 // 兜底,如 '(.mentions // []) | any(.id == "ou_xxx")'\n`,
     )
-    e.userFacing = true
-    throw e
+    return events
   }
   const verdicts = out.split('\n').filter((l) => l.length > 0)
   // 求值行数应与事件数一致;不一致说明表达式产出多值,保守放行全部并 warn

package/lib/larkcli.js

@@ -135,7 +135,7 @@ async function sendCard(profile, chatId, card, opts = {}) {
   return JSON.parse(stdout)
 }
 
-// reply 返回体的 thread_id 是 null,要 messages-mget 才拿得到(lark-runner 实测)。
+// reply 返回体的 thread_id 是 null,要单独查消息详情才拿得到(实测)。
 async function getMessageThreadId(profile, messageId) {
   try {
     const { stdout } = await run([

package/lib/lock.js

@@ -1,43 +1,75 @@
 'use strict'
 
 // 两种锁,语义不同,别混:
-// - 消费者锁(非阻塞):同一 --name 不该有两个 take 在跑,抢不到直接退出并说清楚。
+// - 消费者锁(非阻塞):同一 --name 不该有两个 take/dispatch 在跑,抢不到直接退出并说清楚。
 //   否则两个进程互相推游标,批次会被撕成两半。
 // - (任务,群)锁(阻塞 -w 1800):dispatch 每群串行。并发会写坏 append-only ledger,
-//   且同群两轮 claude 会互相打断。超时视为「别人正在干」,静默跳过(exit 0)。
+//   且同群两轮 claude 会互相打断。超时视为「别人正在干」,静默跳过。
 const fs = require('fs')
 const path = require('path')
 const { paths, ensureDir } = require('./paths')
 
-// 用 O_CREAT|O_EXCL 的 pidfile 做非阻塞互斥 —— 不引 flock 依赖,跨平台。
-// 持有者死了(pid 不存在)则夺锁,避免崩溃后永久锁死。
+// 互斥原语:**把「已写好 pid 的目录」原子 rename 到锁位置**。
+// rename 到一个已存在的非空目录会失败(ENOTEMPTY/EEXIST),这就是原子的 test-and-set,
+// 且锁一出现就带着 pid —— 没有任何中间态。
+//
+// ⚠️ 走过的弯路(都实测复现了多重持锁,别退回去):
+// ① pidfile + O_EXCL + 「删陈旧锁再重试」:两个进程可以都 rmSync 成功(force 不报错)
+//    再都 openSync 成功 → 同时持锁(12 进程抢锁 40% 复现)
+// ② 写临时文件 + rename 覆盖 + 回读确认:输家的 rename 可能落在赢家回读之后
+// ③ mkdir 目录 + 之后再写 pid:mkdir 与写 pid 之间有窗口 —— 别的进程看到空锁目录、
+//    读不到 pid,就把它当陈旧锁夺走(实测 12 进程里最多 4 个同时持锁)
 function acquireExclusive(key) {
-  const file = path.join(ensureDir(paths.run), `${sanitize(key)}.pid`)
-  for (let attempt = 0; attempt < 2; attempt++) {
+  const safe = sanitize(key)
+  const runDir = ensureDir(paths.run)
+  const dir = path.join(runDir, `${safe}.lock`)
+  const pidFile = path.join(dir, 'pid')
+  const me = String(process.pid)
+
+  for (let attempt = 0; attempt < 5; attempt++) {
+    // 备好一个「完整的锁」:目录 + 里面的 pid
+    const staging = path.join(runDir, `.${safe}.${process.pid}.${attempt}.staging`)
     try {
-      const fd = fs.openSync(file, 'wx')
-      fs.writeSync(fd, String(process.pid))
-      fs.closeSync(fd)
-      const release = () => {
-        try {
-          if (fs.readFileSync(file, 'utf8').trim() === String(process.pid)) fs.rmSync(file, { force: true })
-        } catch {}
-      }
-      process.once('exit', release)
-      return { ok: true, file, release }
+      fs.rmSync(staging, { recursive: true, force: true })
+      fs.mkdirSync(staging, { recursive: true })
+      fs.writeFileSync(path.join(staging, 'pid'), me)
     } catch (err) {
-      if (err.code !== 'EEXIST') throw err
-      const holder = readPid(file)
-      if (holder && holder !== process.pid && alive(holder)) {
-        return { ok: false, file, holder }
-      }
-      // 陈旧锁:持有者已死,清掉重试一次
+      cleanup(staging)
+      throw err
+    }
+
+    // 原子上位:目标不存在才成功
+    try {
+      fs.renameSync(staging, dir)
+      return mkHandle(dir, pidFile, me)
+    } catch (err) {
+      cleanup(staging)
+      if (!['ENOTEMPTY', 'EEXIST', 'EISDIR', 'ENOTDIR'].includes(err.code)) throw err
+    }
+
+    // 锁已被占。看持有者还活着吗
+    const holder = readPid(pidFile)
+    if (holder === process.pid) return mkHandle(dir, pidFile, me) // 自己已持有,复用
+    if (holder && alive(holder)) return { ok: false, file: dir, holder }
+
+    // 陈旧锁:整体 rename 挪走(原子,只有一个进程能挪成功),确认是死锁后删掉再重试。
+    // 不能直接 rm —— 删和建之间别人可能刚上位,会把活锁删掉
+    const claim = `${dir}.steal.${process.pid}.${attempt}`
+    try {
+      fs.renameSync(dir, claim)
+    } catch {
+      continue // 没抢到搬运权,重新判定
+    }
+    const stolen = readPid(path.join(claim, 'pid'))
+    if (stolen && stolen !== process.pid && alive(stolen)) {
       try {
-        fs.rmSync(file, { force: true })
+        fs.renameSync(claim, dir) // 误抢了活锁,原样放回
       } catch {}
+      return { ok: false, file: dir, holder: stolen }
     }
+    cleanup(claim)
   }
-  return { ok: false, file, holder: readPid(file) }
+  return { ok: false, file: dir, holder: readPid(pidFile) }
 }
 
 // 阻塞版:等到拿到锁或超时。dispatch 每(任务,群)一把。
@@ -46,11 +78,36 @@ async function acquireBlocking(key, timeoutMs = 1800_000, pollMs = 500) {
   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 }
+    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 = () => {
+    if (released) return
+    released = true
+    try {
+      // 只删自己的锁 —— 别删掉夺锁者的
+      if (fs.readFileSync(pidFile, 'utf8').trim() === me) {
+        fs.rmSync(dir, { recursive: true, force: true })
+      }
+    } catch {}
+  }
+  // 注:SIGKILL 不会跑 exit 钩子 → 留下陈旧锁,靠上面的死进程检测清理
+  process.once('exit', release)
+  return { ok: true, file: dir, release }
+}
+
+function cleanup(p) {
+  try {
+    fs.rmSync(p, { recursive: true, force: true })
+  } catch {}
+}
+
 function readPid(file) {
   try {
     const n = Number(fs.readFileSync(file, 'utf8').trim())

package/lib/paths.js

@@ -33,14 +33,20 @@ function ensureDir(dir) {
   return dir
 }
 
-// 事件文件名 <纳秒>_<pid>_<seq>.json —— 纳秒前缀让字典序 == 时间序,
-// pid+seq 保证同一纳秒内多进程/多事件不撞名。
+// 事件文件名 <stamp>_<pid>_<seq>.json —— stamp 前缀让字典序 == 写入序,
+// pid+seq 保证同一 stamp 内多进程/多事件不撞名。
+//
+// ⚠️ stamp 必须**严格单调递增**,否则消费侧游标会跨过后写的小 stamp 事件 → 永久丢消息。
+// 曾用 `Date.now()*1e6 + hrtime%1e6`:毫秒边界与 hrtime 整毫秒边界有固定相位差,
+// 同一毫秒内落在回绕点两侧的事件,后写的 stamp 反而更小 —— 实测 30 万次里 257 次倒退,
+// 端到端丢 0.28%。且 NTP step / 时钟回拨会让整体变小 → 之后全部事件都在游标之前 → 100% 全丢。
+// 现在:墙上时间只作下界,内部计数器保证单调,时钟回拨也只会让 stamp 走平不会倒退。
+let lastStamp = 0n
+
 function eventFilename(seq) {
-  const ns = process.hrtime.bigint()
   const wall = BigInt(Date.now()) * 1000000n
-  // 用墙上时间做高位(跨进程可比),hrtime 低位补足单调性
-  const stamp = wall + (ns % 1000000n)
-  return `${stamp}_${process.pid}_${seq}.json`
+  lastStamp = wall > lastStamp ? wall : lastStamp + 1n
+  return `${lastStamp}_${process.pid}_${seq}.json`
 }
 
 // 本地日期 YYYY-MM-DD。按天分目录,gc 整目录删。

package/lib/store.js

@@ -7,6 +7,10 @@ const fs = require('fs')
 const path = require('path')
 const { paths, ensureDir, eventFilename, dayKey, dayKeyOffset } = require('./paths')
 
+// scan 窗口天数。必须 >= store 保留天数,否则「保留着却扫不到」= 静默丢消息。
+// 只扫窗口内是为了避免全目录排序(旧架构每轮全扫 4467 个文件)
+const SCAN_DAYS = Number(process.env.LARK_RELAY_SCAN_DAYS || 4)
+
 // 原子落盘:同目录 写 .tmp → rename。
 // 这是 partial write 的正解 —— lark-cli --output-dir 先建 0 字节再填充,
 // 游标可能跨过半成品导致事件永久丢失。
@@ -21,15 +25,22 @@ function writeEvent(app, obj, seq) {
   return { day, name, file: dest }
 }
 
-// 排序键:纳秒 → pid → seq,数值比较(不靠字典序,避免位宽变化时错序)
+// 排序键:stamp → pid → seq,数值比较(不靠字典序,避免位宽变化时错序)
+// ⚠️ 必须容忍非法文件名:任何手工放进 store 的 .json(notes.json / 备份 / README.json)
+// 都会进到这里。曾用 BigInt 裸解析 → SyntaxError 让 take/status/dispatch 全线崩溃
+// (且需目录里 ≥2 个文件才触发,因为单元素 sort 不调比较器 —— 攒够两个突然全崩)
+const NAME_RE = /^(\d+)_(\d+)_(\d+)$/
+
 function parseKey(name) {
   const base = name.endsWith('.json') ? name.slice(0, -5) : name
-  const parts = base.split('_')
-  return {
-    stamp: BigInt(parts[0] || 0),
-    pid: Number(parts[1] || 0),
-    seq: Number(parts[2] || 0),
-  }
+  const m = NAME_RE.exec(base)
+  if (!m) return { stamp: 0n, pid: 0, seq: 0, valid: false }
+  return { stamp: BigInt(m[1]), pid: Number(m[2]), seq: Number(m[3]), valid: true }
+}
+
+// 合法事件文件名判据。scanWindow 用它过滤掉杂项文件,不让它们参与排序/消费
+function isEventName(name) {
+  return name.endsWith('.json') && NAME_RE.test(name.slice(0, -5))
 }
 
 function cmpName(a, b) {
@@ -57,8 +68,10 @@ function afterCursor(entry, cursor) {
   return cmpName(entry.name, cName) > 0
 }
 
-// 只扫今天 + 昨天 —— 避免全目录排序(旧架构每轮全扫 4467 个文件)
-function scanWindow(app, days = 2) {
+// 只扫今天 + 昨天…… 的窗口跟随 retain,避免「保留 3 天却只扫 2 天」:
+// 消费者停机超过 1 天后,盘上还在的事件会永久扫不到(游标停在更早的日期,
+// 而窗口已经不覆盖它 → 静默丢失)。实测:游标停在 D-2、第三天启动即复现
+function scanWindow(app, days = SCAN_DAYS) {
   const out = []
   for (let i = 0; i < days; i++) {
     const day = dayKeyOffset(-i)
@@ -70,8 +83,7 @@ function scanWindow(app, days = 2) {
       continue
     }
     for (const name of names) {
-      if (!name.endsWith('.json')) continue // 跳过 .tmp
-      if (name.startsWith('.')) continue
+      if (!isEventName(name)) continue // 跳过 .tmp、隐藏文件、手工放进来的杂项 .json
       out.push({ app, day, name, file: path.join(dir, name) })
     }
   }
@@ -119,7 +131,7 @@ function seedCursorNow(name, app) {
 function countToday(app) {
   const dir = paths.appDay(app, dayKey())
   try {
-    return fs.readdirSync(dir).filter((n) => n.endsWith('.json')).length
+    return fs.readdirSync(dir).filter(isEventName).length // 不把杂项 .json 算成事件
   } catch {
     return 0
   }

package/lib/take.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lark-relay",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Lark event relay: collect events to disk, take a batch when you need it, or dispatch work to an AI agent.",
   "keywords": [
     "lark",