@yxzpro/agent-acta 2.14.4

package/page/topbar.js

@@ -0,0 +1,61 @@
+// 顶栏（R25 批 2 从 agent-acta-page.html 搬出的第一个组件）。
+// 契约见 page/shared.js 头部的「R25 组件文件契约」；Vue 的 API 一律写全名，不解构。
+//
+// 数据进出（搬的时候逐个对过）：
+//   · 这里只是**显示 + 发命令**：liveText / idleText / scanning / scanMs / idleExitMs 全是根的 SSE
+//     与 /api/settings 回写出来的状态（改前就在根里，改后还在根里）—— 组件不持有其中任何一个，
+//     否则一份真相变两份，多标签页对齐（settings 事件）就会写不到真正驱动连接的那份上。
+//   · 三个命令走 emit：set-scan / set-idle 都是 POST /api/settings + ElMessage，launch-client 是 POST /api/client，
+//     这些都要用根的 getJSON（404 点亮版本红条那段逻辑只有一份），所以处理函数留在根。
+//   · 品牌区（logo + AgentActa）纯静态，跟着搬家。
+window.AACTA = window.AACTA || {};
+AACTA.Topbar = {
+  name: 'aa-topbar',
+  template: `
+  <header class="topbar">
+    <div class="brand"><span class="logo">A</span>AgentActa</div>
+    <div class="top-right">
+      <!-- 唤出桌面悬浮卡片：卡片被 ✕ 关掉后壳可能还活着（被面板窗吊着），命令行之外给页面一个入口。
+           服务端 POST /api/client → runClient()（幂等）：壳在就聚焦/重建卡片，不在就拉起新壳。 -->
+      <el-button size="small" plain :loading="clientLaunching" title="打开桌面悬浮卡片（右上角常驻的小窗/水球）" @click="$emit('launch-client')">悬浮卡片</el-button>
+      <el-dropdown trigger="click" placement="bottom-end" @command="v => $emit('set-idle', v)">
+        <span class="live-tag idle" :class="{idleOn: idleExitMs > 0}" :title="'页面全关且没有新日志持续这么久后，服务自己退出（下次开会话会被 hook 自动拉起）。当前：' + idleText">
+          <span class="dot"></span>{{ idleText }}<el-icon class="caret"><arrow-down></arrow-down></el-icon>
+        </span>
+        <template #dropdown>
+          <el-dropdown-menu>
+            <el-dropdown-item v-for="o in idleOptions" :key="o.v" :command="o.v" :class="{picked: idleExitMs === o.v}">{{ o.label }}</el-dropdown-item>
+          </el-dropdown-menu>
+        </template>
+      </el-dropdown>
+      <el-dropdown trigger="click" placement="bottom-end" @command="v => $emit('set-scan', v)">
+        <span class="live-tag" :class="{on: live && !paused && !scanning, scan: live && scanning, paused: live && paused && !scanning}"
+          :title="scanning ? '正在扫描各 agent 的日志目录，扫完自动进入实时更新' : (paused ? '已暂停定时扫描，点此选择刷新频率' : '点此调整刷新频率')">
+          <span class="dot"></span>{{ liveText }}<el-icon class="caret"><arrow-down></arrow-down></el-icon>
+        </span>
+        <template #dropdown>
+          <el-dropdown-menu>
+            <el-dropdown-item v-for="o in scanOptions" :key="o.v" :command="o.v" :class="{picked: scanMs === o.v}">{{ o.label }}</el-dropdown-item>
+          </el-dropdown-menu>
+        </template>
+      </el-dropdown>
+    </div>
+  </header>`,
+  props: {
+    clientLaunching: Boolean,
+    live: Boolean,
+    paused: Boolean,
+    // null = 没在扫；{ done, total, agent } = 正在扫。模板只读它做 class 与 title，不写
+    scanning: { type: Object, default: null },
+    scanMs: { type: Number, default: 0 },
+    scanOptions: { type: Array, default: () => [] },
+    liveText: { type: String, default: '' },
+    idleExitMs: { type: Number, default: 0 },
+    idleOptions: { type: Array, default: () => [] },
+    idleText: { type: String, default: '' },
+  },
+  emits: ['launch-client', 'set-idle', 'set-scan'],
+  setup() {
+    return {};
+  }
+};

package/parsers/atomcode.mjs

@@ -0,0 +1,321 @@
+// ---------------- atomcode 解析器（sessions/<hash>/*.meta + *.jsonl） ----------------
+// 从 agent-acta-server.mjs 拆出（纯搬家，逻辑零改动）。导出：
+//   expandMeta      —— .meta 轮次 → 条目（scanAtomcodeDir 与分片首扫共用）
+//   scanAtomcodeDir —— 一个 hash 会话目录：*.jsonl 逐行增量（轮时间戳/预览）+ *.meta 全量
+//   atomcodeDirs    —— hash 会话目录列表
+//   atomcodeEntryContent —— 单轮详情（重读 .jsonl 取正文/工具；逐次调用来自 datalog）
+//   datalogCalls / datalogDir —— 逐次 LLM 调用明细（数据源，atomcodeEntryContent 内部调用）
+import fs from 'node:fs';
+import path from 'node:path';
+import { HOME, files, addEntry, modelList, markKind, listDirCached, isDir, trunc, readCompleteLines } from './shared.mjs';
+
+export function sumModel(ts, key) { return (ts.model_usage || []).reduce((a, m) => a + (m.tokens?.[key] || 0), 0); }
+
+// ---------------- atomcode datalog（config.toml 的 [datalog]：逐次 LLM 调用明细） ----------------
+// atomcode 的「逐次请求」明细**不在** sessions/ 里：`.meta` 的 `turn_stats[].model_usage` 是
+// **轮 × 模型**的聚合（一轮里跑 80 次调用也只留一行），拆不开。真正的逐次记录在 `config.toml`
+// 的 `[datalog]` 段指向的独立目录里：每个 turn 一对
+//   `<时间戳>-<会话uuid>-t<轮号>-p<pid>-i<实例>.{md,jsonl}`
+// `.md` 里每个 round 一段 `### Turn N`，带**真实**的 `_[tokens: prompt=…+completion=…, cache=…tok]_`。
+//
+// 三个必须守住的约束：
+//  1. **只读 .md**。本机实测那目录 16GB，其中 11GB 是 .jsonl（完整请求体），.md 只有 85MB。
+//  2. **只取数字**。.md 里有原始 prompt、推理全文、工具出入参——一个字节都不往这里带。
+//  3. **拿不到不算错**。datalog 默认关闭（`enabled=false` 时目录根本不存在），用户没开就返回空数组。
+//     旧命名（`2026-05-26_15-57-41.md`，名字里没有 uuid）挂不到具体某一轮上，只能放弃——
+//     本机 3233 轮里能精确对上的 1013 轮，所以 UI 必须容忍「有的轮有明细、有的没有」。
+
+// config.toml 里 [datalog] 的 dir，30s 缓存。**必须读配置**：本机就落在 E: 盘（不在 ~/.atomcode 下），
+// 硬猜默认路径在这台机器上会一条都读不到。没有 config.toml / 解析不了 → 退回默认位置试一下。
+let dlCfg = { at: 0, dir: null };
+export function datalogDir() {
+  if (dlCfg.dir !== null && Date.now() - dlCfg.at < 30000) return dlCfg.dir || null;
+  const home = path.join(HOME, '.atomcode');
+  const fallback = path.join(home, 'datalog');
+  let dir = fallback;
+  try {
+    const text = fs.readFileSync(path.join(home, 'config.toml'), 'utf8');
+    let inSec = false, enabled = null, raw = '';
+    for (const line0 of text.split('\n')) {
+      const line = line0.trim();
+      if (line.startsWith('[')) { inSec = line.replace(/\s/g, '') === '[datalog]'; continue; }
+      if (!inSec || line.startsWith('#')) continue;
+      const m = line.match(/^([A-Za-z_][\w.-]*)\s*=\s*(.*)$/);
+      if (!m) continue;
+      let v = m[2];
+      if (v[0] === '"' || v[0] === "'") { const q = v[0], e = v.indexOf(q, 1); v = e > 0 ? v.slice(1, e) : v.slice(1); }
+      else { const h = v.indexOf('#'); if (h >= 0) v = v.slice(0, h); v = v.trim(); }
+      if (m[1] === 'enabled') enabled = v !== 'false';
+      if (m[1] === 'dir') raw = v;
+    }
+    if (enabled === false) { dlCfg = { at: Date.now(), dir: '' }; return null; }   // 显式关掉 → 不读
+    if (raw) {
+      // 支持 ~ 与绝对路径；相对路径按 cwd 解析（这里没有可靠的 cwd）→ 不猜，退回默认位置
+      if (raw === '~') dir = HOME;
+      else if (/^[~][\\/]/.test(raw)) dir = path.join(HOME, raw.slice(2));
+      else if (path.isAbsolute(raw)) dir = raw;
+    }
+  } catch { /* 没有 config.toml：按默认位置试 */ }
+  try { if (!fs.statSync(dir).isDirectory()) dir = ''; } catch { dir = ''; }
+  dlCfg = { at: Date.now(), dir };
+  return dir || null;
+}
+
+// uuid#轮号 → .md 路径。uuid 全局唯一，不用拿项目名/hash 去拼（省掉一套命名清洗的坑）。
+// 目录里 2600+ 文件、6 个子目录，readdir 一遍很便宜，30s 重建一次足够。
+let dlIdx = { at: 0, dir: '', map: null };
+function datalogIndex(dir) {
+  if (dlIdx.map && dlIdx.dir === dir && Date.now() - dlIdx.at < 30000) return dlIdx.map;
+  const map = new Map();
+  try {
+    for (const proj of fs.readdirSync(dir)) {
+      const dp = path.join(dir, proj);
+      let st; try { st = fs.statSync(dp); } catch { continue; }
+      if (!st.isDirectory()) continue;
+      for (const f of fs.readdirSync(dp)) {
+        const m = f.match(/-([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})-t(\d+)-[^\\/]*\.md$/i);
+        if (m) map.set(m[1].toLowerCase() + '#' + m[2], path.join(dp, f));
+      }
+    }
+  } catch { /* 目录半路消失就当没有 */ }
+  dlIdx = { at: Date.now(), dir, map };
+  return map;
+}
+
+// 把一份 .md 解析成逐轮调用。两个坑都踩过，记下来：
+//
+//  1. **别拿 ``` 配对来跳过代码块**。真这么写了，结果某些 md 里围栏行数是**奇数**（实测一份
+//     139 行，全都在列 0），状态机一旦错位就把后半份文件整个吞掉——那次的症状是「54 轮只解析出
+//     44 轮」。源文件的围栏本来就不保证平衡，靠它做区间划分就是用不可靠的输入去当边界。
+//  2. 工具结果里**可能逐字回显** `### Turn N` 和整行 tokens（这个面板自己就在读别的日志，这不是
+//     假想）。所以表头必须序号连续才认；账行要求行首恰好缩进两格、整行严丝合缝；而且一轮里若
+//     出现多行，**以最后一行为准**——真账行总是打在这一轮全部工具调用之后，回声在它前面，会被盖掉。
+function parseDatalogMd(text) {
+  let model = '';
+  const rounds = [];
+  let cur = null, last = 0;
+  for (const line of text.split('\n')) {
+    if (!model && line.startsWith('**env:**')) { const m = line.match(/model=([^,\s]+)/); if (m) model = m[1]; continue; }
+    const h = line.match(/^### Turn (\d+)\s*$/);
+    if (h) {
+      const n = Number(h[1]);
+      if (n === last + 1) { cur = { n, prompt: null, completion: 0, cache: 0, dur: null }; rounds.push(cur); last = n; }
+      continue;   // 不连续的表头 = 正文里的回声，当没看见（保留 cur，别把这一轮的账丢了）
+    }
+    if (!cur) continue;
+    const t = line.match(/^ {2}_\[tokens: prompt=(\d+)\+completion=(\d+), cache=(\d+)tok([^\]]*)\]_\s*$/);
+    if (t) {
+      cur.prompt = +t[1]; cur.completion = +t[2]; cur.cache = +t[3];
+      // v5.1.0 起这一行会多带本轮的请求耗时（on_request→on_model_response 计时）。字段是本机
+      // 5.0.9 还产不出来的东西，所以**尾段留成通配**再捞 `dur=Nms`：格式换了位置也认，
+      // 没有就是没有（对 5.1.0 之前的全部旧文件实测零影响）。
+      const d = t[4].match(/dur=(\d+)ms/);
+      if (d) cur.dur = +d[1];
+    }
+  }
+  return { model, rounds: rounds.filter(r => r.prompt != null) };
+}
+
+// 同一份 .md 会随会话进行不断变长，而 live 的条目每个扫描周期都会被重新取一次详情——
+// 用 {mtime,size} 当版本号挡住重复解析（statSync 比重读+解析一个几 MB 的 md 便宜得多）。
+const dlCache = new Map();
+export function datalogCalls(src, fallbackModel) {
+  const dir = datalogDir();
+  if (!dir) return [];
+  const base = path.basename(src.file);
+  const uuid = (base.endsWith('.jsonl') ? base.slice(0, -6) : base).toLowerCase();
+  const f = datalogIndex(dir).get(uuid + '#' + src.turn);
+  if (!f) return [];
+  let calls, key;
+  try {
+    const st = fs.statSync(f);
+    key = st.mtimeMs + ':' + st.size;
+    const hit = dlCache.get(f);
+    if (hit && hit.key === key) return hit.calls;
+    const { model, rounds } = parseDatalogMd(fs.readFileSync(f, 'utf8'));
+    const mdl = model || fallbackModel || '';
+    calls = rounds.map(r => ({
+      model: mdl,
+      // 口径对齐卡片：datalog 的 prompt **含**缓存，面板的 tin 是**不含**缓存的输入。
+      // 对过账：Σ(prompt − cache) == .meta 的 model_usage.input，896/896 精确相等。
+      tin: Math.max(0, r.prompt - r.cache), tout: r.completion, tcache: r.cache,
+      // 本轮请求耗时。5.1.0 之前 datalog 不记（旧命名格式那个 _(3.9s)_ 是**工具**耗时，别混进来），
+      // 拿不到就是 0 → 页面 fmtDur 渲染成 —，宁可留空也不编一个数出来
+      dur: r.dur != null ? r.dur : 0,
+    }));
+  } catch { return []; }
+  if (dlCache.size > 64) dlCache.clear();
+  dlCache.set(f, { key, calls });
+  return calls;
+}
+
+// ---------------- 条目生成 ----------------
+export function expandMeta(agent, metaPath, base, jsonlRef, data) {
+  const jsonlPath = jsonlRef ? jsonlRef[0] : metaPath.slice(0, -5) + '.jsonl';
+  const jdata = jsonlRef ? files.get(jsonlRef[0])?.data : null;
+  const turnTs = jdata?.turnTs || {};
+  const preview = jdata?.preview || {};
+  const md5ish = metaPath.replace(/[\\/:]/g, '~');
+  for (const t of data.turns) {
+    // 确定性 id：meta 每轮都会变、会重扫，自增 id 会导致同一轮重复灌入（曾放大到 67 份）
+    const id = 'a#' + md5ish + '#' + t.turn_id;
+    // I16 / D1：`time` 一律取**轮起点**，与全项目口径一致（claude / dsh / zcode / codex 全取起点）。
+    //   以前写的是 `turnTs[t.turn_id]`，而 jsonl 的 `ts` 是**轮结束**时刻（对账 ts − started_at
+    //   ≈ duration_ms，本机 773 条样本平均偏差 15ms 证实）⇒ atomcode 是唯一一家取终点的，
+    //   卡片/会话页显示的时间戳整体偏一个轮长、按天分桶也跟着偏。
+    //   jsonl 里**同时**有 started_at（起点）与 ts（终点）：优先取 started_at，拿不到才退 ts − dur
+    //   （dur = meta 的 duration_ms，本身就是「终点−起点」），两者都拿不到才算时间未知。
+    // I16 / D2：拿不到时间时**不再沉默回落 updated_at**。那会让同一会话几十轮全塌成同一时刻
+    //   （本机 2391/3492 轮 = 68.5% 是这么来的），页面看上去「这些轮同时发生」，而真相是「不知道」。
+    //   改成落 `timeUnknown: true` + time=0 —— 页面按「时间未知」如实标注并把它排到最后，
+    //   不拿会话更新时刻冒充轮时间。这是前置闸那条「排除时间未知的轮」的落点。
+    const end = Number(turnTs[t.turn_id]);
+    const start = Number(jdata?.turnStart?.[t.turn_id]);
+    const dur = Number(t.dur) || 0;
+    let time = 0, unknown = false;
+    if (start > 0) time = start;
+    else if (end > 0) time = Math.max(0, end - dur);
+    else unknown = true;
+    addEntry(id, {
+      agent, project: data.project || '(未知项目)', session: data.name || base,
+      time, dur: t.dur, status: t.errored ? 'error' : 'ok',
+      // 时间未知的轮如实标注：页面据此不拿它做时间轴/拓扑排序，也不并进按天分桶的假位置。
+      timeUnknown: unknown ? true : undefined,
+      // total 与别家口径统一：轮内各次调用的累加（meta 的 model_usage 本来就是按轮累加的）。
+      // ⚠️ 不能再用 meta.total_tokens 当 total —— 实测它 = **末轮 prompt+completion**（986 个样本 985 个精确相等），
+      // 语义是「这一轮结束时的上下文占用」，跟 tin/tout/tcache（各轮累加）不是一个量纲。
+      // 拿它当合计的话卡片上会出现「合计 269160 < 输入 431208」这种算不通的数。
+      tin: t.tin, tout: t.tout, tcache: t.tcache, total: t.tin + t.tout + t.tcache,
+      // ctx 是窗口**容量**，ctxUsed 是结束时**实际占用**，页面那根进度条要的是后者（见页面 ctxUsed）
+      ctx: t.ctx, ctxUsed: t.ctxUsed,
+      // round_count 就是轮内 LLM 调用次数（拿 datalog 的逐轮块数对过：1015 轮里 896 轮精确相等，
+      // 少数差 1 是被打断没跑完的那轮）——以前写死 null 让「N 次 LLM」徽章一直不显示，数字其实一直在手上
+      rounds: t.rounds, tools: t.tools, calls: t.rounds,
+      toolNames: (jdata?.toolNames || {})[t.turn_id] || {},
+      models: t.models, preview: preview[t.turn_id] || '',
+    }, { file: jsonlPath, turn: Number(t.turn_id), kind: 'atomcode' });
+  }
+}
+
+// ---------------- 扫描 ----------------
+export function scanAtomcodeDir(agent, names, dir) {
+  const metas = [], jsonls = new Map();
+  for (const n of names) {
+    const fp = path.join(dir, n);
+    let fst; try { fst = fs.statSync(fp); } catch { continue; }
+    if (!fst.isFile()) continue;
+    if (n.endsWith('.meta')) metas.push([fp, fst]);
+    else if (n.endsWith('.jsonl')) jsonls.set(n.slice(0, -6), [fp, fst]);
+  }
+  for (const [base, [fp, fst]] of jsonls) {
+    const key = fp, m = fst.mtimeMs, s = fst.size;
+    const prev = files.get(key);
+    if (prev && prev.m === m && prev.s === s) continue;
+    const off = prev?.off || 0;
+    let data = prev?.data || { turnTs: {}, turnStart: {}, preview: {}, toolNames: {} };
+    if (s <= off) continue;
+    try {
+      // 只推进到最后一个完整行，避免半截行被吞（旧版 off=size+shift 每次追加丢一条）
+      const rd = readCompleteLines(fp, off, s);
+      if (!rd) { files.set(key, { agent, kind: 'jsonl', m, s, off, data }); continue; }
+      const newOff = rd.newOff;
+      for (const line of rd.lines) {
+        // I16 / D1：`ts` 是**轮结束**时刻、`started_at` 才是**轮起点**（全项目口径取起点）。
+        // 两个都收下来，emit 时优先用 started_at（见 expandMeta），拿不到才退 `ts − duration_ms`。
+        // 老 state 没有 turnStart ⇒ 缺这一位时回落仍成立，不会把已有的轮时间弄丢。
+        const tm = line.match(/"turn_id":(\d+)/), tsm = line.match(/"ts":(\d+)/), sam = line.match(/"started_at":(\d+)/);
+        if (!tm || (!tsm && !sam)) continue;
+        const tid = tm[1];
+        if (tsm && !data.turnTs[tid]) data.turnTs[tid] = Number(tsm[1]);
+        if (!data.turnStart) data.turnStart = {};
+        if (sam && !data.turnStart[tid]) data.turnStart[tid] = Number(sam[1]);
+        if (!data.preview[tid]) {
+          const um = line.match(/"user":"((?:[^"\\]|\\.)*)"/);
+          if (um) data.preview[tid] = um[1].replace(/\\n/g, ' ').replace(/\\"/g, '"').replace(/\\u[\dA-Fa-f]{4}/g, '·').slice(0, 200);
+        }
+        // 工具名去重计数（卡片「调用」旁的问号悬浮层数据源）：jsonl 每行的 tools[] 带逐个 name。
+        // 用 JSON.parse 而不是正则：tools 的 args 字符串里可能含 ] 等字符，正则会断在半路
+        // （实测一轮 7 个 edit_file 只数出 1 个）。解析失败的行宁可丢掉也不数错。
+        try {
+          const j = JSON.parse(line);
+          if (Array.isArray(j.tools) && j.tools.length) {
+            if (!data.toolNames[tid]) data.toolNames[tid] = {};
+            const tn = data.toolNames[tid];
+            for (const tl of j.tools) { const n = tl && tl.name; if (n) tn[n] = (tn[n] || 0) + 1; }
+          }
+        } catch {}
+      }
+      files.set(key, { agent, kind: 'jsonl', m, s, off: newOff, data });
+      markKind('jsonl');
+    } catch {}
+  }
+  for (const [fp, fst] of metas) {
+    const base = path.basename(fp).slice(0, -5);
+    const key = fp, m = fst.mtimeMs, s = fst.size;
+    const prev = files.get(key);
+    if (prev && prev.m === m && prev.s === s) continue;
+    let data = null;
+    try {
+      const j = JSON.parse(fs.readFileSync(fp, 'utf8'));
+      data = {
+        project: j.working_dir || '', name: j.name || '', created: j.created_at || 0, updated: j.updated_at || 0,
+        turns: (j.turn_stats || []).map(t => ({
+          // total_tokens 不是「本轮用了多少 token」，是**末轮 prompt+completion**＝结束时的上下文占用，
+          // 所以挂在 ctxUsed 上（页面用它画上下文进度条），别当 token 合计用
+          turn_id: t.turn_id, dur: t.duration_ms || 0, ctxUsed: t.total_tokens || 0,
+          tin: sumModel(t, 'input'), tout: sumModel(t, 'output'), tcache: sumModel(t, 'cached_input'),
+          ctx: t.ctx_window || 0, rounds: t.round_count || 0, tools: t.tool_call_count || 0,
+          errored: !!t.errored, models: modelList((t.model_usage || []).map(x => x.model_id)),
+        })),
+      };
+    } catch { continue; }
+    files.set(key, { agent, kind: 'meta', m, s, off: 0, data });
+    expandMeta(agent, fp, base, jsonls.get(base), data);
+  }
+}
+
+// hash 会话目录列表（原逻辑：列不出目录、或子项不是目录都跳过）
+export function atomcodeDirs(root) {
+  const hashes = listDirCached(root);
+  if (!hashes) return [];
+  const out = [];
+  for (const hash of hashes) { const d = path.join(root, hash); if (isDir(d)) out.push(d); }
+  return out;
+}
+
+// 详情：重读 sessions 的 .jsonl 按 turn_id 过滤取正文/工具，逐次调用明细来自 datalog（见上）。
+// entry 是扫描侧产出的条目（models / calls）——只作兜底用，从参数传入，避免这里反向去查全局表。
+export function atomcodeEntryContent(src, full, entry) {
+  const fstate = files.get(src.file);
+  const version = fstate ? fstate.m + ':' + (fstate.off || 0) : null;
+  let out = null;
+  const lines = fs.readFileSync(src.file, 'utf8').split('\n');
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    let j; try { j = JSON.parse(line); } catch { continue; }
+    if (j.turn_id !== src.turn) continue;
+    if (!out) out = { user: '', assistant: '', tools: [] };
+    if (j.user && !out.user) out.user = String(j.user);
+    // 一轮多 round：assistant 逐行累加（原为覆盖，中间输出会丢）
+    if (j.assistant) out.assistant = out.assistant ? out.assistant + '\n\n---\n\n' + j.assistant : String(j.assistant);
+    for (const tl of j.tools || []) {
+      const fi = {}, fo = {};
+      out.tools.push({ name: tl.name, input: trunc(tl.args, full, fi), inputTrunc: !!fi.t, output: trunc(tl.result, full, fo), outputTrunc: !!fo.t, error: !!tl.is_error });
+    }
+  }
+  if (!out) out = { user: '', assistant: '', tools: [] };
+  // 逐次 LLM 调用明细来自 datalog（sessions 里没有这个粒度），没有就空数组 → 页面那块不渲染。
+  // 注意：sessions 的 .jsonl 可能是 0 字节（实测有这种会话），此时上面循环啥也没读到，
+  // 但 datalog 照旧能给明细，所以 calls 必须挂在「读不到正文」这个分支之外。
+  out.calls = datalogCalls(src, (entry?.models || [])[0]);
+  // 卡片上写着「N 次 LLM」却一条明细都拿不出来时，得说清为什么——不然看着像坏了。
+  // 两种情况分开写：开关/目录压根没开（用户能去开），和这一轮恰好没落盘（只能等）。
+  if (!out.calls.length) {
+    const rc = entry?.calls || 0;
+    if (rc > 0) out.callsNote = datalogDir()
+      ? `这一轮没有 datalog 记录（${rc} 次调用只剩轮级汇总）`
+      : 'datalog 未开启（默认关闭），拿不到逐次明细';
+  }
+  out.v = version;
+  return out;
+}

package/parsers/buddy.mjs

@@ -0,0 +1,272 @@
+// ---------------- buddy jsonl（codebuddy / workbuddy：<base>/projects/<slug>/<sessionId>.jsonl） ----------------
+// 从 agent-acta-server.mjs 拆出（纯搬家，逻辑零改动）。导出 scanBuddy / buddyEntryContent
+// 与口径函数（buddyUserText / buddyCall / buddyPreview —— 详情与扫描共用同一套）。
+//
+// 与 claude 同族的逐行 jsonl，但记录类型不同：
+//   {"type":"message","role":"user"|"assistant"} 开轮/正文
+//   {"type":"function_call"} / {"type":"function_call_result"}（callId 配对）/ {"type":"reasoning"}
+//   {"type":"turn-metrics","durationMs","tokenDelta"} 一轮收尾 → 精确耗时
+//   {"type":"ai-title","aiTitle"} 会话标题
+// 两个必须知道的格式坑：
+//   1) 用户真实输入常被包在 <system-reminder>（IDE 注入）里，真正的 prompt 在 <user_query> 中
+//      （workbuddy 几乎全是这种），codebuddy 多数是裸文本 —— 先取 user_query，再剥 system-reminder 段。
+//   2) token 用量挂在「每次 LLM 调用」的记录上，既可能在 message:assistant 也可能在 function_call，
+//      按 providerData.messageId 去重累加（实测累加值 == turn-metrics.tokenDelta，可互相校验）；
+//      且 usage.input_tokens 含缓存命中，要减去 cache_read_input_tokens 才与 claude 口径一致。
+//   3) 同一条用户消息会被源重写一次（jsonl 只追加 → 两行、`id` 相同，第二行把同一段话包进
+//      <user_query>），两边时间戳与抽取正文一致 —— 开轮按 `id` 去重（扫描/详情同一判据），
+//      否则一张卡变两张（本机 149 份会话实测 7 对）。
+import fs from 'node:fs';
+import path from 'node:path';
+import { files, entries, addEntry, markKind, listDirCached, isDir, trunc, readCompleteLines } from './shared.mjs';
+
+export const BUDDY_SKIP_RE = /^(<command-name>|<local-command|<system-reminder|<cb_summary>)/;
+
+export function buddyUserText(content) {
+  const blocks = Array.isArray(content) ? content : [];
+  const raw = blocks.map(b => (typeof b === 'string' ? b : String(b?.text || ''))).join('\n');
+  if (!raw.trim()) return '';
+  const q = /<user_query>([\s\S]*?)<\/user_query>/.exec(raw);
+  if (q && q[1].trim()) return q[1].replace(/\s+/g, ' ').trim();
+  const rest = raw.replace(/<system-reminder[\s\S]*?<\/system-reminder>/g, '').trim();
+  if (!rest || BUDDY_SKIP_RE.test(rest)) return ''; // 纯注入/命令消息不开新轮（与详情同口径）
+  return rest;
+}
+
+export function buddyUsage(j) {
+  const u = j.message?.usage || j.providerData?.usage;
+  const raw = j.providerData?.rawUsage;
+  if (!u && !raw) return null;
+  const inAll = u?.input_tokens ?? raw?.prompt_tokens ?? 0;
+  // 两处都有可能带缓存命中数，取大者（口径：input_tokens 含缓存）
+  const cache = Math.max(u?.cache_read_input_tokens || 0, raw?.prompt_tokens_details?.cached_tokens || 0);
+  const tout = u?.output_tokens ?? raw?.completion_tokens ?? 0;
+  return { tin: Math.max(0, inAll - cache), tout, tcache: cache };
+}
+
+// 一条 LLM 调用的用量（调用可能是 assistant 文本，也可能是 function_call，共用一个 messageId）
+export function buddyCall(j) {
+  const pd = j.providerData || {};
+  return { mid: pd.messageId || j.id || null, model: pd.requestModelName || pd.model || '', usage: buddyUsage(j) };
+}
+
+// 预览文案：后台任务通知 / 队友消息 / 压缩摘要同样会开轮（它们确实在烧 token），但预览要把 XML 标签换成看得懂的字
+export function buddyPreview(t) {
+  const tn = /<task-notification>([\s\S]*?)<\/task-notification>/.exec(t);
+  if (tn) {
+    const s = /<summary>([\s\S]*?)<\/summary>/.exec(tn[1]);
+    return ('[后台任务] ' + (s ? s[1] : tn[1])).replace(/\s+/g, ' ').trim();
+  }
+  const tm = /<teammate-message[^>]*>([\s\S]*?)<\/teammate-message>/.exec(t);
+  if (tm) return ('[队友消息] ' + tm[1].replace(/<[^>]*>/g, ' ')).replace(/\s+/g, ' ').trim();
+  if (/^<(cb_summary|conversation_history_summary)>/.test(t)) return ('[历史摘要] ' + t.replace(/<\/?[a-z_]+>/g, ' ')).replace(/\s+/g, ' ').trim();
+  return t.replace(/\s+/g, ' ').trim();
+}
+
+export function buddyIdBase(fp) { return 'b#' + fp.replace(/[\\/:]/g, '~') + '#'; }
+
+function emitBuddyTurns(agent, fp, slug, data, fromIdx) {
+  const idBase = buddyIdBase(fp);
+  for (let i = fromIdx; i < data.turns.length; i++) {
+    const t = data.turns[i];
+    addEntry(idBase + t.idx, {
+      agent, project: data.cwd || slug, session: data.sessionId || path.basename(fp, '.jsonl'),
+      time: t.time, dur: t.dur || Math.max(0, t.lastTs - t.time), status: t.err ? 'error' : 'ok',
+      tin: t.tin, tout: t.tout, tcache: t.tcache, total: t.tin + t.tout + t.tcache,
+      ctx: 0, rounds: t.calls, tools: t.tools, calls: t.calls, // 同 claude：rounds=calls=轮内 LLM 调用数
+      models: t.models, preview: t.preview, name: data.title || null, // name=会话标题（无模型信息时前端用它兜底）
+      finished: !!t.finished, aborted: !!t.aborted, toolNames: t.toolNames || {},
+    }, { file: fp, turn: t.idx, kind: 'buddyjsonl' });
+  }
+}
+
+export function scanBuddy(agent, root, onlyFile) { // onlyFile 见 scanClaude 的说明
+  const slugs = listDirCached(root);
+  if (!slugs) return;
+  const onlyDir = onlyFile ? path.dirname(onlyFile) : null; // 同 scanClaude：排在 isDir 之前，省掉 slug 数 × 文件数次 stat
+  for (const slug of slugs) {
+    const dir = path.join(root, slug);
+    if (onlyDir && dir !== onlyDir) continue;
+    if (!isDir(dir)) continue;
+    const names = listDirCached(dir);
+    if (!names) continue;
+    for (const n of names) {
+      if (!n.endsWith('.jsonl')) continue;
+      const fp = path.join(dir, n);
+      if (onlyFile && fp !== onlyFile) continue;
+      let fst; try { fst = fs.statSync(fp); } catch { continue; }
+      const key = fp, m = fst.mtimeMs, s = fst.size;
+      const prev = files.get(key);
+      if (prev && prev.m === m && prev.s === s) {
+        // 重启后 entries 为空但 files 状态被恢复：从状态直接重建条目，不重扫文件
+        if (prev.data?.turns?.length && !entries.has(buddyIdBase(fp) + (prev.data.turns.length - 1))) emitBuddyTurns(agent, fp, slug, prev.data, 0);
+        continue;
+      }
+      const off = prev?.off || 0;
+      const data = prev?.data || { cwd: '', title: '', sessionId: '', turns: [], emitted: 0, uids: [] };
+      if (s <= off) { files.set(key, { agent, kind: 'buddyjsonl', m, s, off, data }); markKind('buddyjsonl'); continue; }
+      try {
+        const rd = readCompleteLines(fp, off, s);
+        if (!rd) { files.set(key, { agent, kind: 'buddyjsonl', m, s, off, data }); markKind('buddyjsonl'); continue; } // 尚无完整行
+        const newOff = rd.newOff;
+        for (const line of rd.lines) {
+          if (!line.trim()) continue;
+          let j; try { j = JSON.parse(line); } catch { continue; }
+          if (j.cwd && !data.cwd) data.cwd = j.cwd;
+          if (j.sessionId) data.sessionId = j.sessionId;
+          if (j.type === 'ai-title' && j.aiTitle) data.title = String(j.aiTitle).slice(0, 60);
+          if (j.type === 'message' && j.role === 'user') {
+            const t0 = buddyUserText(j.content);
+            if (!t0) continue;
+            // 同一条用户消息会被源**原地重写**一次（jsonl 只追加，故落盘两行、`id` 相同）：
+            // 先一行裸文本、紧跟一行把同一段话包进 <user_query>（实测 149 份会话共 7 对，
+            // 两边的时间戳与抽取后的正文完全一致）。不去重就一张卡变两张。
+            const umsg = j.id || null;
+            if (umsg) {
+              if (data.uids.includes(umsg)) continue;
+              data.uids.push(umsg);
+            }
+            const ts = j.timestamp || 0;
+            if (data.turns.length) data.turns[data.turns.length - 1].finished = true;
+            data.turns.push({
+              idx: data.turns.length, time: ts, lastTs: ts, dur: 0,
+              tin: 0, tout: 0, tcache: 0, tools: 0, calls: 0, mids: [], models: [], err: false,
+              preview: buddyPreview(t0).slice(0, 300), toolNames: {}, finished: false, aborted: false,
+            });
+            continue;
+          }
+          const cur = data.turns[data.turns.length - 1];
+          if (!cur) continue;
+          if (j.type === 'turn-metrics') {
+            // 一轮收尾：durationMs 是从本轮开始到此刻的真实耗时（比相邻时间戳推算准）
+            cur.dur = j.durationMs || 0;
+            cur.finished = true;
+          } else if (j.type === 'function_call') {
+            cur.tools++;
+            const nm = typeof j.name === 'string' && j.name ? j.name : (typeof j.toolName === 'string' && j.toolName ? j.toolName : '?');
+            cur.toolNames[nm] = (cur.toolNames[nm] || 0) + 1;
+          } else if (j.type !== 'message' && j.type !== 'function_call_result') {
+            continue;
+          }
+          const c = buddyCall(j);
+          if (c.mid && cur.mids.includes(c.mid)) {
+            // 同一次 LLM 调用的多条记录（正文 + 工具调用）已计过用量
+          } else if (c.usage) {
+            cur.mids.push(c.mid);
+            cur.calls++;
+            cur.tin += c.usage.tin; cur.tout += c.usage.tout; cur.tcache += c.usage.tcache;
+          }
+          if (c.model && !cur.models.includes(c.model)) cur.models.push(c.model);
+          if (j.status === 'error' || j.status === 'failed') cur.err = true;
+          if (j.timestamp) cur.lastTs = Math.max(cur.lastTs, j.timestamp);
+        }
+        files.set(key, { agent, kind: 'buddyjsonl', m, s, off: newOff, data });
+        markKind('buddyjsonl');
+        // 从最后一个已发轮起重发（进行中的轮会被原地更新）
+        emitBuddyTurns(agent, fp, slug, data, Math.max(0, data.emitted - 1));
+        data.emitted = data.turns.length;
+      } catch {}
+    }
+  }
+}
+
+// 详情：重读 jsonl 按 src.turn 过滤。开轮判定与用量去重都走扫描侧同一套函数
+// （buddyUserText / buddyCall，同一条 messageId 只算一次），两边口径对齐。
+export function buddyEntryContent(src, full) {
+  const fstate = files.get(src.file);
+  const version = fstate ? fstate.m + ':' + (fstate.off || 0) : null;
+  const lines = fs.readFileSync(src.file, 'utf8').split('\n');
+  let turnIdx = -1, prevTs = 0;
+  const out = { user: '', assistant: '', tools: [], calls: [], v: version };
+  const texts = [];
+  const byMid = new Set();   // 同一次 LLM 调用的多条记录只算一次用量
+  const byCallId = new Map(); // function_call_result 按 callId 精确回填（并行调用不错位）
+  // 正文和用量常常**不在同一条记录上**：纯工具调用那几次的用量挂在 function_call 那条，
+  // 正文挂在 message/assistant 那条，两边靠 providerData.messageId 关联。
+  // 实测 20 份会话：313 个带正文的 mid，只有 102 个的正文与用量同条。
+  // 所以整篇读完再按 mid 回填，别在读到正文的那一刻就往上挂（那时还不知道它属于哪次调用）。
+  const callByMid = new Map();  // mid -> 这一行明细
+  const textByMid = new Map();  // mid -> 这次调用自己产出的正文
+  const toolsByMid = new Map(); // mid -> 这次调用发起了哪些工具（同一次响应并行调几个就有几条记录）
+  const seenUser = new Set();   // 同 id 的用户消息是源自己重写的第二条，扫描侧不开轮，这里也不能数
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    let j; try { j = JSON.parse(line); } catch { continue; }
+    if (j.type === 'message' && j.role === 'user') {
+      const t0 = buddyUserText(j.content);
+      if (!t0) continue; // 与 scanBuddy 同口径跳过注入/命令消息
+      if (j.id) {
+        if (seenUser.has(j.id)) continue;
+        seenUser.add(j.id);
+      }
+      turnIdx++;
+      if (turnIdx > src.turn) break;
+      if (turnIdx === src.turn) { out.user = t0; prevTs = j.timestamp || 0; }
+      continue;
+    }
+    if (turnIdx !== src.turn) continue;
+    const ts = j.timestamp || 0;
+    if (j.type === 'message' && j.role === 'assistant') {
+      // 与 scanBuddy 同一口径：只在「带用量的记录」上按 messageId 去重计一次
+      const c = buddyCall(j);
+      if (c.usage && !(c.mid && byMid.has(c.mid))) {
+        if (c.mid) byMid.add(c.mid);
+        const call = { model: c.model, tin: c.usage.tin, tout: c.usage.tout, tcache: c.usage.tcache, dur: ts && prevTs ? Math.max(0, ts - prevTs) : 0 };
+        out.calls.push(call);
+        if (c.mid) callByMid.set(c.mid, call);
+      }
+      for (const b of (Array.isArray(j.content) ? j.content : [])) {
+        if (!b || b.type !== 'output_text' || !b.text) continue;
+        const seg = String(b.text);
+        texts.push(seg);
+        // 正文记在当前记录自己的 mid 上（与上面记调用用的是同一个 messageId）
+        if (c.mid) textByMid.set(c.mid, textByMid.has(c.mid) ? textByMid.get(c.mid) + '\n' + seg : seg);
+      }
+    } else if (j.type === 'function_call') {
+      const c = buddyCall(j);
+      if (c.usage && !(c.mid && byMid.has(c.mid))) {
+        if (c.mid) byMid.add(c.mid);
+        const call = { model: c.model, tin: c.usage.tin, tout: c.usage.tout, tcache: c.usage.tcache, dur: ts && prevTs ? Math.max(0, ts - prevTs) : 0 };
+        out.calls.push(call);
+        if (c.mid) callByMid.set(c.mid, call);
+      }
+      const fi = {};
+      const tool = {
+        name: j.name || '?', tid: j.callId || null, ts,
+        input: trunc(j.arguments ?? '', full, fi), inputTrunc: !!fi.t,   // 过 toText（trunc 内），别在这里 String() 掉对象
+        output: '', error: null,
+      };
+      out.tools.push(tool);
+      if (tool.tid) byCallId.set(tool.tid, tool);
+      if (c.mid) {
+        const arr = toolsByMid.get(c.mid);
+        if (arr) arr.push(tool.name); else toolsByMid.set(c.mid, [tool.name]);
+      }
+    } else if (j.type === 'function_call_result') {
+      // callId 精确配对；无 id 时退回第一个空 output（旧格式）
+      const t = (j.callId && byCallId.get(j.callId)) || out.tools.find(x => !x.output);
+      if (t) {
+        const o = j.output;
+        const fo = {};
+        t.output = trunc(o, full, fo);   // 同 claude：内容块/对象的拆解统一交给 toText()
+        t.outputTrunc = !!fo.t;
+        if (j.status && j.status !== 'completed') t.error = j.status;
+        if (ts && t.ts) t.dur = Math.max(0, ts - t.ts); // 工具自身耗时：调用 → 结果
+      }
+    } else {
+      continue;
+    }
+    if (ts) prevTs = ts;
+  }
+  for (const [mid, call] of callByMid) {
+    const seg = textByMid.get(mid);
+    if (seg) {
+      const ft = {};
+      call.text = trunc(seg, full, ft); call.textTrunc = !!ft.t;
+    }
+    const tl = toolsByMid.get(mid);
+    if (tl && tl.length) call.tools = tl;
+  }
+  out.assistant = texts.join('\n');
+  return out;
+}