事件解码器：全站唯一的"事件 → 人话"翻译层

UI 重构的地基。现有的 describe()（RunPanel.tsx:392）是工程师视角——
db_query__warehouse({"sql":...}) 是函数调用语法、1234+567 tok · $0.0021 是账单、
exit=0 · microvm 是退出码，而且 25 个事件类型里一半直接 return '' 没翻译。

做成独立模块而不是散在各页面，是因为画布时间线、助手栏、运行页要读同一个
故事。两套翻译的话同一次运行在不同地方讲得不一样，用户没法判断哪个是真的。

## 三条原则

- **不回写事件**：run 终态时对全部已落库事件算 manifest_hash，事后增删改会
  对不上。翻译只在前端内存里发生。
- **成对事件合并成一行**：tool.start + tool.end 是同一件事的两个时刻，拆两行
  等于把"查询数据"和"查完了"当成两件事。按 call_id 配对（并发调同名工具时
  按名字会错位），独立 Tool 节点没有 call_id 则回退到名字。
- **节点是天然的分组单位**：一个图节点内部可能有好几轮模型和工具调用，
  它们属于同一个步骤——这正是"简要思考节点"该有的结构。

## 用真实事件调出来的五个坑

从库里导出 5 类真实运行（带查询/带审批/带出具/失败/带思考）当 fixture，
构造的样本永远不会长成那样：

- **审批重复三次**。human.requested 没有 interrupt_id、run.interrupted 才有，
  两个 key 算不到一起；而审批恢复后 LangGraph 重放节点又发一遍 human.requested。
  改用两者共有的 node_id|mode|title 做键，三条收敛成一条。
- **节点重放让同名节点出现两次**。node.started 第二次来时复用原来那条。
- **"继续执行"说两遍**。run.resumed 和 run.started(resumed=true) 是同一件事。
- **标题退化成裸 id**。没起过名字的节点 label 等于 id（后端兜底），"in"/"h"/"out"
  对用户毫无意义——退到节点类型的中文名。
- **空 preview 当详情显示**。{} 不是详情，是噪音。

## 刻意不做的

- 不显示 token 数和美元：那是账单视角，不是"它干了什么"
- 不依赖 canvas/nodeDefs：解码器是纯翻译层，画布只是消费者之一。
  16 行的类型名映射重复得起，反向依赖会让运行页被迫加载整套节点定义
- 未知事件不静默吞掉：宁可显示一条原始的，也比让人觉得"什么都没发生"好

## 验证

scripts/check-decode.mjs 用真实 fixture 跑 21 条断言（转译借 vite dev server，
测的就是应用实际运行的那份）。守的是"审批只出现一次""没有裸 id""没有事件名
泄漏到标题"这类会悄悄退化的性质。

scripts/check-decode.mjs

@@ -0,0 +1,116 @@
+// 事件解码器的回归检查。
+//
+// 用**真实运行**导出的事件跑（fixtures.json 取自 data/agentlab.db），不是构造的样本：
+// 这里要守的恰恰是真实事件的脏细节——审批会重放、成对事件字段不齐、
+// 空 preview、节点没起过名字。构造的样本永远不会长成那样。
+//
+// 转译借 vite dev server（它 serve 的就是应用实际运行的那份），所以跑之前
+// 前端得起着：./scripts/dev.sh
+import { readFileSync } from 'node:fs'
+
+const WEB = process.env.AGENTLAB_WEB ?? 'http://localhost:5273'
+const root = new URL('..', import.meta.url).pathname
+const fixtures = JSON.parse(
+  readFileSync(`${root}frontend/src/run/__tests__/fixtures.json`, 'utf8'))
+
+const res = await fetch(`${WEB}/src/run/decode.ts?t=${Date.now()}`)
+if (!res.ok) {
+  console.error(`✗ 拿不到转译结果（${WEB}）——前端没起？先跑 ./scripts/dev.sh`)
+  process.exit(1)
+}
+const mod = await import(
+  'data:text/javascript;base64,' + Buffer.from(await res.text()).toString('base64'))
+
+let failed = 0
+const check = (name, cond, detail = '') => {
+  console.log(`  ${cond ? '✓' : '✗'} ${name}${detail ? ` — ${detail}` : ''}`)
+  if (!cond) failed++
+}
+const flatten = (steps) =>
+  steps.flatMap((s) => [s, ...(s.children ? flatten(s.children) : [])])
+
+console.log('=== 数据库查询 ===')
+{
+  const steps = mod.decodeRun(fixtures.db)
+  const all = flatten(steps)
+  const q = all.find((s) => s.kind === 'query')
+  check('查询步骤说人话，不是 db_query__warehouse(...)',
+    !!q && q.title.includes('查询数据') && !q.title.includes('db_query__'), q?.title)
+  check('SQL 原文留在详情里可展开', !!q?.detail?.includes('SELECT'))
+  check('工具调用挂在节点下，不是平铺',
+    steps.some((s) => s.kind === 'node' && s.children?.some((c) => c.kind === 'query')))
+}
+
+console.log('\n=== 人工审批（含重放）===')
+{
+  const steps = mod.decodeRun(fixtures.human)
+  const all = flatten(steps)
+  // 一次审批会产生 human.requested ×2（重放）+ run.interrupted，界面上只该有一条
+  check('"等你确认"只出现一次',
+    all.filter((s) => s.kind === 'human' && s.title.includes('确认')).length === 1,
+    `${all.filter((s) => s.kind === 'human' && s.title.includes('确认')).length} 条`)
+  check('"继续执行"只出现一次',
+    steps.filter((s) => s.title === '继续执行').length === 1,
+    `${steps.filter((s) => s.title === '继续执行').length} 条`)
+  // 节点重放不该让同一个节点在时间线上出现两遍
+  const nodeIds = steps.filter((s) => s.kind === 'node').map((s) => s.nodeId)
+  check('节点不因重放而重复', new Set(nodeIds).size === nodeIds.length,
+    nodeIds.join(','))
+  check('审批结果有交代', all.some((s) => s.title.includes('放行') || s.title.includes('驳回')))
+}
+
+console.log('\n=== 出具判定 ===')
+{
+  const steps = mod.decodeRun(fixtures.issue)
+  check('出具档位翻译成中文', steps.some((s) => s.kind === 'issuance' && s.title.includes('出具')),
+    steps.find((s) => s.kind === 'issuance')?.title)
+}
+
+console.log('\n=== 失败运行 ===')
+{
+  const steps = mod.decodeRun(fixtures.failed)
+  const all = flatten(steps)
+  const errs = all.filter((s) => s.level === 'error')
+  check('错误只说一遍（节点失败与 run.failed 是同一件事）',
+    new Set(errs.map((s) => s.detail ?? s.title)).size === errs.length,
+    `${errs.length} 条错误`)
+  check('开头那条不会一直转圈',
+    !steps.some((s) => s.kind === 'lifecycle' && s.status === 'running'))
+}
+
+console.log('\n=== 通用规则 ===')
+{
+  const all = Object.values(fixtures).flatMap((evts) => flatten(mod.decodeRun(evts)))
+  check('没有裸节点 id 当标题',
+    !all.some((s) => s.kind === 'node' && /^(in|out|h|m|t\d|n\d)$/.test(s.title)),
+    all.filter((s) => s.kind === 'node' && /^(in|out|h|m)$/.test(s.title)).map(s=>s.title).join(','))
+  check('没有空详情', !all.some((s) => s.detail === '{}' || s.detail === ''))
+  check('没有原始事件名泄漏到标题',
+    !all.some((s) => /^(node|run|llm|tool)\./.test(s.title)),
+    all.filter((s) => /^(node|run|llm|tool)\./.test(s.title)).map(s=>s.title).join(','))
+  check('耗时是人类单位', all.filter((s) => s.meta).every((s) => /(\d+ms|\d+\.\d+s|\d+m\d+s|\d+ 行)/.test(s.meta)))
+}
+
+console.log('\n=== Copilot 操作流 ===')
+{
+  const ops = [
+    { op: 'heartbeat', phase: 'planning', elapsed_ms: 3000 },
+    { op: 'heartbeat', phase: 'planning', elapsed_ms: 6000 },
+    { op: 'thinking', delta: '用户要查销量。' },
+    { op: 'thinking', delta: '先看表结构。' },
+    { op: 'plan', summary: '三步：取数→汇总→出具' },
+    { op: 'add_node', node: { id: 'q', type: 'tool', data: { label: '取数' } } },
+    { op: 'add_edge', edge: { source: 'a', target: 'q' } },
+    { op: 'done', explanation: '完成' },
+  ]
+  const steps = mod.decodeCopilot(ops)
+  check('心跳不堆行', steps.filter((s) => s.kind === 'lifecycle' && s.status === 'running').length === 1)
+  check('连续思考并成一条', steps.filter((s) => s.kind === 'think').length === 1,
+    `${steps.filter((s) => s.kind === 'think').length} 条`)
+  check('思考全文保留在详情', steps.find((s) => s.kind === 'think')?.detail?.includes('先看表结构'))
+  check('连线不单独成行', !steps.some((s) => s.title.includes('edge')))
+  check('节点用标签不用 id', steps.some((s) => s.kind === 'node' && s.title === '取数'))
+}
+
+console.log(failed ? `\n✗ ${failed} 项未通过` : '\n✓ 解码器全部通过')
+process.exit(failed ? 1 : 0)