diff --git a/plugins/avatasia/mmc-trajectory/README.md b/plugins/avatasia/mmc-trajectory/README.md
index 81a7ce7..3bf43db 100644
--- a/plugins/avatasia/mmc-trajectory/README.md
+++ b/plugins/avatasia/mmc-trajectory/README.md
@@ -6,6 +6,8 @@ Browse the model trajectory of a MiniMax Code conversation: messages, reasoning,
 
 Author: [avatasia](https://github.com/avatasia) · Version: `1.0.0`
 
+Before changing the page, read [docs/LAYERS.md](docs/LAYERS.md): which functional layer a control belongs to, what it may read, and the four questions to answer before implementing a new one. It exists because this page's filter logic grew one feature at a time, and the defects that produced are all traceable to that.
+
 ## Install and use
 
 Copy this entire directory into your active MiniMax Code data directory, including the hidden `.minimax-plugin` directory. By default, `<dataDir>` is the `.minimax` directory in your home folder (`~/.minimax`), so plugins go in `~/.minimax/plugins/`. If you have configured a different data directory, use that directory instead:
diff --git a/plugins/avatasia/mmc-trajectory/README.zh-CN.md b/plugins/avatasia/mmc-trajectory/README.zh-CN.md
index bb26af5..927d87d 100644
--- a/plugins/avatasia/mmc-trajectory/README.zh-CN.md
+++ b/plugins/avatasia/mmc-trajectory/README.zh-CN.md
@@ -6,6 +6,8 @@
 
 作者：[avatasia](https://github.com/avatasia) · 版本：`1.0.0`
 
+改动这个页面前，先读 [docs/LAYERS.md](docs/LAYERS.md)：一个控件属于哪一层、能读什么、以及实现新功能之前必须先答的四个问题。它存在的原因是这个页面的筛选逻辑是一次加一个功能长出来的，产出的缺陷都能追溯到这一点。
+
 ## 安装与使用
 
 把整个目录（含隐藏的 `.minimax-plugin`）复制到你的 MiniMax Code 活跃数据目录下。默认情况下 `<dataDir>` 是家目录下的 `.minimax`（即 `~/.minimax`），所以插件放在 `~/.minimax/plugins/`。如果你配置过其它数据目录，请用那个目录：
diff --git a/plugins/avatasia/mmc-trajectory/docs/LAYERS.md b/plugins/avatasia/mmc-trajectory/docs/LAYERS.md
new file mode 100644
index 0000000..17531a2
--- /dev/null
+++ b/plugins/avatasia/mmc-trajectory/docs/LAYERS.md
@@ -0,0 +1,486 @@
+# 前端分层：这个页面的功能类型 → 层 → 归属
+
+这份文档对应的是一类**已经付出过代价**的错误，不是风格偏好。下面每一条「代价」都能在本仓库里指到具体代码或具体缺陷。
+
+## 0. 要解决什么
+
+症状是「功能不断堆叠，联动时出现异常」。拆开看是两件事：
+
+1. **堆叠**：新控件被放到「离它作用对象最近的地方」，而不是「离它所属的层最近的地方」。于是同一层的控件散落在页面的两处。
+2. **联动异常**：没有分层的共享模型，每加一个跨控件的能力，就只能在各个渲染函数里手写互斥分支。分支之间必然互相看不见对方在做什么。
+
+第 2 点是重点。上一轮修的三处异常轴缺陷——合计指向另一个选择、`重置` 在多选下自称已是默认、单选说「已叠加 4 条规则」——**没有一处是算错**，三处都是「两个筛选器各自推理自己」的症状。它们的共同根因只有一个：筛选这件事在这个页面里没有一层。
+
+---
+
+## 1. 现状：实际的结构（不是设计意图）
+
+按文档顺序，逐层对照。**这一节描述现状，不是方案**；方案在第 3 节。
+
+| 文档位置 | DOM | 控件 | 写的 state | 它回答的问题 |
+| --- | --- | --- | --- | --- |
+| 1 | `header.page-header` | 跟随最新、刷新 | `followLatest` | 跟不跟 |
+| 2 | `#error-bar` `#stale-bar` | — | `hardError` `stale` | 出错了吗 |
+| 3 | `form.toolbar#toolbar` row1 | 会话、上下文代、搜索 | `sessionId` `generation` `query` | **看哪段数据** + **看哪些记录** |
+| 3 | `form.toolbar#toolbar` row2 | 时间区间 + 4 个快捷 + 更新到最新 + 清空区间 | `rangeFrom` `rangeTo` `rangeCutoff` | **看哪些记录** |
+| 4 | `section.kpi-section` | 5 张 KPI 卡 | —（只读） | 整场会话的统计 |
+| 5 | `div.filter-sticky` | 类型轴 | `kinds` | **看哪些记录** |
+| 5 | `div.filter-sticky` | 异常轴 + 多选 + 提示行 | `anomalyRules` `multiAnomaly` `anomalyLast` | **看哪些记录** |
+| 6 | `section.overview` | 总览轴切换、拖拽刷选、清除区间 | `actualDuration` `overviewSelection` `overviewViewport` | 同一批记录的图形投影 |
+| 7 | `main.columns` → `panel` 轨迹 | 窗口控制（最新 200 / 全部 / 向上加载） | `limit` `allRecords` | 渲染多少 |
+| 7 | `main.columns` → `panel` 检视 | 四个 tab | `activeTab` `selectedId` | 这一条记录长什么样 |
+
+**「看哪些记录」这一件事，现在住在文档位置的 3、5 两处**，中间隔着整块 KPI 区。
+
+---
+
+## 2. 已经付过的代价
+
+### D1 — ~~同一层的控件被劈成两半~~ **设计如此，不是缺陷**
+
+**这一条撤回。** 它曾经被写成需要偿还的结构债，理由是「看哪些记录」这一个职责住在文档位置 3（`form.toolbar`）和位置 5（`.filter-sticky`）两处、中间隔着 KPI 区。
+
+**这个判断是错的。** 查询条件是一个**聚合**，不是一个控件：前端 UI 与最终请求参数本来就该拆开，两块甚至更多块 UI 各拼一部分参数是正常形态（是否 MVVM 与此无关）。要求它们在文档里连续，是把「层要连续」当成了设计洁癖，而它不是——KPI 区答的是「这场会话一共发生了什么」，筛选区答的是「我现在看其中哪些」，两者本来就不必挨着。
+
+当时提的搬动方案（把搜索框和时间区间移进 sticky 筛选带）也被否决：**窄屏上 sticky 会占满视口，可用区域反而更小。** 搜索框尤其如此。
+
+所以这一条留在这里，是为了让下一个读到这里的人知道**这条路已经走过、结论是不动**，而不是把它当成待办。
+
+真正该盯的不是控件在文档里的位置，而是**位置变了之后由谁负责重算**——见 D9。
+
+### D2 — 同一份 state 里，有两句互相矛盾的设计声明
+
+```js
+// kinds
+// The type chips are the only filter, so this array is the only definition of what is on
+// screen.
+
+// rangeFrom
+// This is the one filter the KPI follows. The type chips and the search box narrow
+// what is *drawn*; a range answers a different question …
+```
+
+两句话都对，各自描述的是一个**更早的**页面。合起来，这个对象对「筛选是什么」给出了两种互不兼容的模型。这不是笔误，是堆叠留下的沉积：**没有一层来裁决哪句话作废。**
+
+`README.md` 其实已经把这件事说对了一半——它写的是「the only filter **over kinds**」，并明确说明时间区间与异常筛选是横跨类型、且不改写 `kinds`。带限定词的那句现在仍然成立；代码注释里**没有限定词**的那句不成立。分层不是要推翻 README 的模型，是给它一个归属：**层不新增字段，只是命名谁拥有它们。**
+
+### D3 — 汇总层用了筛选层的视觉语言
+
+`kpiStats()` 只跟时间区间（`hasTimeRange() ? scopedStats() : payload.stats`），不跟类型轴、不跟搜索、不跟异常轴——即 KPI 讲的是「这一段时间里的整场会话」，而它的卡片和筛选控件共用同一套视觉语言、同一个滚动流里的相邻位置。读者无法从视觉上知道这两者口径不同。
+
+### D4 — 跨层回写没有声明
+
+全页唯一一条「从下往上写」的数据流是总览条的区间刷选 → `rangeFrom/rangeTo`，以及它自带的「清除区间」「更新到最新」。它写的是 L2 的字段，但持有者是 L3 的控件，而且 `overviewSelection` 另存了一份区间。没有声明，于是每次动它都要重新推演谁该刷新。
+
+### D5 — 一个字段多个写者
+
+`state.kinds` 4 处写入、`state.anomalyRules` 4 处、`multiAnomaly` 3 处、`query` 3 处、`limit` 3 处。互斥不变量只能靠一个协调函数 `resetBaseFilters()` 去维持，而协调函数本身就是「没有共享模型」的产物。
+
+### D6 — 控件的位置和它写入的层不是一回事
+
+窗口控制（`显示最新 200 / 显示全部 / 向上加载`）在**列表面板里**，但它写的是「渲染多少」这一层的事，不改筛选结果。同类还有总览条：它既是投影，又持有写入筛选的控件。位置即归属的直觉在这里已经不成立，而文档里没有一处声明它。
+
+### D7 — 函数名跨层
+
+`applyFilterScope()` 的名字说的是 L2（筛选作用域），函数体第一行却是 `if (!dom.kpiScope) return;` —— 它写的是 L4 的口径行。真正的作用域处理（异常模式下把 `[data-filter-scope]` 标 inert）在 `syncAnomalyMode()` 里。
+
+一个以 L2 命名、只写 L4 的函数，会让下一次读代码的人把口径声明当成筛选行为的一部分。这不是笔误级的问题：它是 D4 的同一个根因——**跨层关系没有被声明，于是命名先替它做了个假声明。**
+
+### D8 — L6 读的是「整场会话」，不是「表里有什么」 **已修**
+
+L6 检视面板该读 L5（列表），实际读的是 L0：`selectedRecord()` 和 `revealSelection()` 扫的是 `state.flat`——未经筛选的整场会话；而 L5 的行是拿 `visibleEntries()` 建的。两边对「选中」的定义不是同一个。
+
+读者看到的是：选中一条记录 → 点「工具失败」→ 账本从 61 条变成「已显示 2 条」，检视面板纹丝不动仍显示原来那条，而且**表里没有任何一行带选中标记**。页面内部没有任何一处自相矛盾——只是面板在描述一个屏幕上看不到的东西。
+
+更糟的是能点的按钮也一起撒谎：`复制 JSON`、`交给 AI 分析这条` 读的是同一个旧记录。
+
+唯一能回收 `state.selectedId` 的地方是 `applyPayload()`，而且只在**数据签名变化**时。本地改筛选一次都不走那里，所以没有任何一条筛选轴能救它。
+
+**修法**：判定权收进 `revealSelection(entries)` 一个函数，参数就是 L5 即将拿去建行的那个数组；调用点收进 `renderLedger()`——所有会改变「表里有什么」的路径的**唯一出口**（9 处直接调它，其中就包括类型轴本身）。`selectedRecord()` 降级成纯查找，它的 5 个读者（面板 / 复制 / 交接 / 交接按钮 / …）不再各自重新回答「什么算选中」。守卫：`tests/verify-selection.mjs` + `tests/mutate-selection.py`。
+
+### D9 — 钉住偏移的重算责任只挂在一根线上 **已修**
+
+四个 sticky 层的偏移由 3 个 CSS 变量串起来，唯一写手 `syncStickyOffsets()` 的唯一调用点是 `render()` 末尾。而 `renderLedger()` 被 9 处**直接**调用绕过 `render()`（类型轴、搜索、总览刷选、加载更早、窗口模式、选中行…）。今天这 9 处恰好都不改 band 高度所以看不出来——**不变量靠约定撑着，不靠结构**：再加一个条件时照这个写法走，就会静默错位。
+
+同时没有任何 resize 挂钩（无 `resize` 监听、无 `ResizeObserver`）。而稳定会话下每次轮询都是 304，`render()` 根本不跑（304 分支只在 `state.loading` 时才 render）——窗口一变窄、类型行换行、band 长高，**永远没人重测**。
+
+**修法**：测量收进 `renderLedger()` 出口（与 D8 同一个出口），`render()` 里不再重复调；补 `resize` 挂钩，按 `requestAnimationFrame` 合并成一帧一次（每次测量读 3 个 `offsetHeight`，会强制布局，拖窗口时逐事件测量就是布局抖动）。守卫：`tests/verify-sticky.mjs` 新增 5 条断言 + `tests/mutate-sticky.py` 新增 7 条变异。
+
+> 顺带说明 D1 与 D9 的关系：D1 说的「层被劈开」是**位置**问题，结论是不动；D9 说的是**位置变了之后由谁重算**，这才是真问题。两者不要混。
+
+### D10 — 每轮轮询把整个 lineage 重读重解析一遍 **已修**
+
+这一条不在前端，在 L0。`handleTrajectory()` 命中 `trajectoryCache` 时直接短路返回（好）；**未命中时**那个循环（`server.mjs:1881-1919`）对 lineage 上**每一个** generation 文件做 `readHead()` 全量读 + `parseMessagesJsonl()` 全量解析，然后重建全部 row。
+
+而 `trajectoryCacheKey()` 把每一代的 `byteLength` 拼进了键，所以**只要会话还在追加，键就变，就必然 miss**——缓存是全有或全无的。
+
+本机实测（会话 `mvs_2fd90165…`，23 代）：
+
+| | |
+| --- | --- |
+| 每轮读入的源字节 | `payload.session.sizeBytes` = **99,986,501** |
+| 其中冻结的 snapshot（22 个） | 99,889 KB = **99.90%** |
+| 只有 `messages.jsonl` 在长 | 97,526 字节 = **0.10%** |
+| 重建耗时 | **1,138 ms**（拟合 31 ms/MB） |
+| 占 2,500 ms 轮询间隔 | **46%** |
+
+同一份数据在三个层各自独立地表现出同一个比例：**服务端输入 99.90% 冗余、线上字节 99.99% 冗余（5 分钟 1.31 GB 换 118,875 字节真实新增，放大 11,006×）、页面解析 ~99.99% 冗余**。会话在忙碌时每 3–6 秒变一次，而轮询每 2.5 秒问一次——所以**几乎每次轮询都撞上全量重发**。
+
+**曾被考虑并否决的两条**：
+
+- **响应开 gzip**（36.0 MB → 7.8 MB，4.6×）。实测**净亏损**：同机 loopback、同样 `await response.json()`，裸传 201 ms vs gzip 268 ms，页面反而慢 67 ms；服务端每个 cacheKey 还要多付 458 ms deflate，浏览器付 80 ms inflate。**本机不是带宽瓶颈，压缩换不来东西。**
+- **缓存每代的序列化片段**（用字符串而非对象图，内存友好）。**不成立**：`buildTrajectoryPayload()` 里 `turn.index = turns.length + 1` 是**全局序号**，且同一个 `turnId` 会跨代出现（`turnById` 复用该 turn 并继续追加记录）。所以每一代既不能独立缓存也不能独立拼接。
+
+**修法**（四问）：
+
+1. **归层** — L0，服务端。第二个缓存，与 `trajectoryCache` **并列而非替代**：整场缓存在命中时仍直接短路，新缓存只在整场 miss 后才被读写。**互斥由控制流保证**，不靠约定。
+2. **关联** — 新缓存按**单文件**粒度，键与整场缓存不同，两者互不写入对方的键。不新增任何前端 state，不改任何页面行为。
+3. **布局** — `start()` 闭包内、`trajectoryCache` 旁边。**不做模块级 Map**（跨 `start()` 泄漏）。自带按**字节预算**的 LRU，默认 256 MB。
+4. **口径** — **不改变任何对外承诺的数字**。唯一要守的不变量：**缓存命中必须产出与冷读逐字节相同的 body**。守卫 `tests/verify-parsed-rows.mjs` 断言这一点。
+
+**缓存键的三个正确性前提**（任一条错了，缓存就会供出陈旧数据——这是它唯一不能出的错）：
+
+- **键用 `filePath` 而不是 `fileName`。** `messages.jsonl` **不是唯一的**，每个会话都有一个；只用文件名，两个会话的同名文件可能撞车。
+- **键用 `stat` 的 `size` + `mtimeMs`，不用 catalog 里的 `byteLength`。** 代码自己在 `server.mjs:1889-1894` 注释了那个值是快照、会过期，而且 active 文件每轮都在它之外继续增长。
+- **键含 `limit`。** `readHead` 会按 `limit` 截断，截断与否是读出来的事实的一部分，缓存值里带着 `truncated` 判定。
+
+**共享带来的写入风险**：`rows` 跨请求共享同一批对象。已逐个查过下游——`redactStructure()` 构造新对象（`out = {}`）而不原地改，`record = { ...base }` 也是新建，`splitRawRecords` 改的是新建的 record。唯一写缓存对象的是 `row[ROW_GENERATION] = link.generation`，而同一 `filePath` 恒定映射同一 generation，幂等。
+
+**内存代价（实测，不是估计）**：`JSON.parse` 保留率实测 **1.36×**（34.3 MB 文本 → 46.7 MB 堆），且这是**下限**——payload 已被 `splitRawRecords` 剥掉消息正文，真实的 rows 图更大。外推到 95.4 MB 源文件是 **130–290 MB 常驻**。所以上界必须显式：换掉的是每 2.5 s 约 350 MB 的分配 churn，换来一次性常驻。**预算按字节而非条数**，因为条数与体积无关（一条可能是 40 字节也可能是 40 MB）。
+
+> 真正把这件事做干净的是增量协议（`?since=`，服务端只发新增尾部）。它连这 130–290 MB 都不需要，而且额外消掉那 139 ms 的 `JSON.stringify` 和页面的 200 ms 传输+解析。**按代缓存胜在不动协议**，性能上它被增量协议严格支配。这一条留作后续。
+
+### D11 — 为「量一下大小」把整场消息体序列化一遍，然后扔掉 **已修**
+
+D10 修完之后实测发现重建时间没动，于是回头查 D10 的成本拆分，发现 D10 里写错了一个数。实测（真实 22 个冻结文件）：
+
+```
+冷读（读 + 解析全部）  306 ms      ← 不是我在 D10 里写的 ~1,000 ms
+命中缓存                 2 ms
+解析吞吐              311 MB/s
+```
+
+**更正 D10**：读+解析约 306 ms，不是约 1,000 ms。当时那个数是用「1,138 − 139（stringify）」减出来的，把没有查过的 `buildTrajectoryPayload` 和 `buildRawPayload` 一起算进了「读+解析」里。按代缓存的真实收益是**约 300 ms，占一轮重建的约 21%**，不是 3.5×。常驻堆实测 **116 MB**（95.3 MB 源文件 × 1.22×），低于当时 130–290 MB 的外推。
+
+> 顺带修了 D10 自己发的代码里的一个缺陷：预算代理写成 3×，于是 95.3 MB × 3 = 286 MB 计费压过 256 MB 预算，LRU 把放得下的条目也赶走了。实测保留率 1.22×，代理改为 2×。**预算的好坏完全取决于这个数**。
+
+剩下的 ~1,100 ms 在下游，其中最大的一块是个纯浪费：
+
+`buildRawPayload(message, redact)` 对**每一条记录**执行 `JSON.stringify(message)`——18,337 次、合计约 100 MB——只为回答两个问题：序列化后是否超过 `MAX_RAW_BYTES`（65536），以及是否含 `.minimax` 需要脱敏。**那个字符串用完就扔**：`splitRawRecords()` 在最终序列化之前把 `raw` 从每条记录上摘掉（`server.mjs:1954` 的注释自己写着「from here on the body carries no message bodies at all」），而 `raw.value` 真正带走的其实是**原消息对象**，不是这个字符串。
+
+于是每一轮重建都要把 100 MB 消息体完整序列化一遍、量一下、再扔。而 `raw` 只有打开某条记录的原文页、复制、交接时才读得到——18,337 条里几乎从不读。
+
+**修法**（四问）：
+
+1. **归层** — L0 服务端。`raw` 的计算从「构建 payload 时」移到「`/raw` 被请求时」。不新增任何 state,不改筛选/渲染层。
+2. **关联** — `raw` 与 bulk payload 的关系不变(它本来就不在 bulk 里)。变的是**判定「过大」的时机**:从构建时移到请求时,两者必须在同一处写,不能一个函数判、另一个函数用。
+3. **布局** — bulk payload 仍然不带 `raw`;`/raw` 仍然按 record index 服务。**新增的只是一个定位符**:每条记录记下它来自 `rows` 的第几条,由 `splitRawRecords()` 摘进缓存项,`/raw` 用它回到那一条消息。`handleRaw()` 再调用 `buildRawPayload()`——一次只算一条。
+4. **口径** — **`rawOmitted` 从 bulk payload 迁到 `/raw` 响应**。这是本项目第一次做**契约级**的口径变更,所以逐个读点列在这里,并在 `tests/verify-raw-lazy.mjs` 里逐个加断言:
+
+| # | 位置 | 现在读 | 改后读 |
+| --- | --- | --- | --- |
+| 1 | `index.html:2867` 交接元信息 | `record.rawOmitted` | `rawText === null`（交接本来就先取 `rawSourceFor`，`copySelected` 同样） |
+| 2 | `index.html:5989` `rawSourceFor` | `record.rawOmitted` → 短路 `null` | 无条件取 `/raw`，省略由服务端给出 |
+| 3 | `index.html:5998-5999` 原文页提示 | `record.rawOmitted` | `/raw` 的 `omitted` |
+| 4 | `index.html:6007-6008` 原文页内容 | `record.rawOmitted` → `—` | 同上 |
+| 5 | `index.html:6059` `copySelected` | `source === null` → `stringify(record)` | 不变（`rawSourceFor` 仍可能返回 `null`） |
+
+**5 个读点里没有一个在台账行上**——全部在「打开这条记录」的路径上。所以这条口径不需要在列表里出现,只需要在读者真的去读的时候给出同一句话。
+
+**读者可见的变化只有一处**:原文页对「过大」的记录会多发一次 `/raw` 请求(之前是零次)。这是一条用户主动打开才走的路径,用一次请求换每轮轮询少序列化 100 MB,是划算的。
+
+**正文里不再有 `rawOmitted` 字段**,18,337 条记录每条少一个键。
+
+### D12 — 「显示全部」把两万行塞进一次同步循环，页面当场冻住 **已修**
+
+**归层** L5 的建行路径。写的是 L5 的 `state` 吗？不是——它一个字段都不写，只建 DOM。真正要守的是 **D8 的出口不变**：`renderLedger()` 仍然是唯一出口。
+
+**关联** 与 `updateWindowBar()` 从属：进度必须**经过**它输出，不能自己碰那个 count 节点，否则 D8 的「一个写手」当场破掉（见 R1）。
+
+**布局** 不新增容器。建行循环拆批，仍按原来的 `section.turn-group` 逐轮追加，`.row-list` 结构一字未改——所以 `client-check.mjs` 里从 `renderLedger()` 里读压缩带路由的那条断言不用改。进度显示在已有的窗口条上，不另起一个面板。
+
+**口径** **不变**。「显示全部」仍然是全部。这条下面专门有一节说明为什么不把它变小。
+
+**实测（本机，会话 150 轮 / 18,924 条记录 / 视口 735×900）**：
+
+```
+分批建行（25 轮/帧）总耗时      3,956 ms
+  每批建行 JS   中位 141 ms / 最大 151 ms
+  帧间（浏览器对整篇文档的 layout+ paint）  ≈ 617 ms/帧
+```
+
+关键结论是：**卡的不是建行 JS，是每帧对整篇两万行文档做的 layout**。六批 JS 加起来约 870 ms，剩下的 3,086 ms 是 5 个帧间隙。所以单纯把批调小**治不了**——批越小，帧次数越多，对不断变长的文档重复 layout 的总代价越高。
+
+**实测并否决的替代方案：`content-visibility: auto`**。它直接掐掉那 3,086 ms：
+
+```
+同一套分批 + .turn-group { content-visibility: auto; contain-intrinsic-size: auto 900px }
+  总耗时 979 ms   （3,956 → 979，4.0×）
+  每批最大 151 ms → 161 ms 的 layout 也一并消失
+```
+
+行数一致（18,845 vs 18,864，差值是两次测量之间会话自己长的 19 条），所以 4 倍是真的。**CSS 常量版没有采用**，理由是一个数对不上一张表：
+
+```
+150 个轮组的真实高度   p25 1,011 px   中位 2,667 px   p75 6,627 px   最大 29,754 px
+```
+
+跨度 **11 倍**。`contain-intrinsic-size` 只能填一个数：填 900（我最初拍的值）会让初始文档高度只有真实值的 **20%**，滚动条比实际短 5 倍，滚下去页面还会一边滚一边长；填任何一个单一值都是拿「滚动条说谎」换速度——正是这份文件反复禁止的那类交易（「凡是宽度由数据决定的列，宽度必须从实测推导」）。`auto` 关键字只让浏览器**记住**已渲染过的尺寸，救不了从未渲染过的那 148 个。
+
+**没有采用，也写在这里**，因为下一次有人量到这 4 倍时会再问一遍。
+
+> **2026-10-12 实测更正：上面这条否决只对「CSS 常量」成立。**
+> 11 倍是**轮组之间**的跨度；组内高度完全由 (行数, 压缩带数) 决定。实测（152 组 / 19,315 条 / 视口 735×900 / dpr 2）：
+>
+> | 量 | n | min | 中位 | max |
+> | --- | --- | --- | --- | --- |
+> | 普通行 `.row-list > li` | 19,292 | 36 | 36 | **36** |
+> | 轮头 `.turn-head` | 152 | 39 | 39 | **39** |
+> | 压缩带 `li.compaction-cell` | 23 | 38 | 38 | **38** |
+> | 轮组自身 chrome | 152 | 0 | 0 | 12 |
+>
+> 普通行 **min = max = 36 px**，19,292 条一条不差：摘要列是 nowrap + ellipsis，**它根本不换行**，所以「行高随内容变化」这个担心从一开始就不成立。
+>
+> ```
+> 预测总高  694,512(行) + 883(带) + 5,928(头) = 701,323
+> 真实总高                                    701,660
+> 误差                                          0.048%
+> ```
+>
+> 填一个 CSS 常量 → 误差是那 11 倍；**逐组按 (行数, 压缩带数) 在建行那一刻算** → 误差 0.05%。两者不是同一件事。
+>
+> **逐组推导版已实现并实测，但未采用——有一个没能定位的滚动回归。** 做法：`.turn-group` 的 `content-visibility: auto` 由账本上的一个 class 打开，class 只在第一批建完、并且从**真实 DOM** 量出行高 / 带高 / 头高之后才加上（写死的常量就是「猜别人屏幕」，所以不写死）；此后每个轮组在建行那一刻按 (行数, 压缩带数) 算自己的 `contain-intrinsic-size`。
+>
+> 实测（同机，152 组 / 19,374 行 / 视口 735×900 / dpr 2）：
+>
+> ```
+> 总建行时间     782 ms      （分批无跳过 3,956 ms → 5.1×；CSS 常量版 979 ms）
+> 自标定高度     head 39.40 · row 36 · band 38.40
+> 带尺寸的轮组   152 / 152
+> 预测文档高     705,230      真实 705,529      误差 −0.04%
+> 文档实际高     705,627（滚到底部后，`auto` 已记住已渲染轮组的真实尺寸）
+> ```
+>
+> **已验证**：滚到 705,627 px 的文档底部，行正常渲染且有真实几何；深层记录（第 27 轮 #2129）可点，检视正确填出「第 27 轮 · #2129 · 工具结果」。
+>
+> **2026-10-12 归因完成：那次跳转不是回归，是既有缺陷 D14，逐组推导版的唯一阻塞已解除。**
+>
+> 先做的是控制实验——在**已发布代码**（无 `content-visibility`、无探针）上跑同一条路径：显示全部 → 滚到第 29 轮 → 点一行 → 等轮询。视口同样跳回第 1 轮，检视面板仍正确显示 `#2780 · 第 29 轮`。所以它与 `content-visibility` 无关。
+>
+> 下面是给 `renderLedger()` 的捕获点与 `restoreRowAnchor()` 打的点（19,626 行 / 155 轮 / 文档高 716,000 px / 视口 841×900）：
+>
+> ```
+> cap  ySave=715080  yReal=616   doc=1515     ← clear(ledger) 把文档压到 1515px，scrollY 被浏览器夹到 616
+> rst  after=707051 delta=707056 yIn=1128  yOut=708185   ← 从被夹住的位置出发，仍然正确还原
+> cap  ySave=715080  yReal=616   doc=1515
+> rst  after=-6      delta=0      yIn=708185 yOut=708185 ← 已稳定，每轮 delta 0
+> ```
+>
+> `restoreRowAnchor()` **本身是对的**，即使起点被夹到 616 / 2,051，它也能算出正确的 delta 并落回原位。丢失发生在另一处：那次点击落在**轮询建行途中**，`ledgerBuildToken` 让在途 `buildStep()` 提前 return，而那个 return **跳过了 `restoreRowAnchor`**。下一轮于是从一个已经被摧毁的位置捕获锚点，`docYWas == docYNow == 5515` 证明它忠实地还原到了错误的地方。完整机制见 **D14**。
+>
+> **代价量清了，不采用的理由只剩一条：这是别人的缺陷，不是这条路的代价。** 归因表明逐组推导版没有引入任何新的滚动问题——它只是把建行从 3,956 ms 缩到 782 ms，而 D14 的触发窗口宽度正好等于建行时长，所以这条路反而把窗口从 3,956 ms 收窄到 782 ms（窗口**占整个轮询周期的比例**本轮没有单独量，不在这里给数）。修 D14 之后，这条路可以重新提交。
+
+**修法**：一次 `requestAnimationFrame` 建至多 `LEDGER_BATCH_GROUPS = 25` 轮组就交还主线程；`setLedgerProgress()` 把「已建 N / 共 M 条」交给 `updateWindowBar()` 输出（唯一写手）；每一轮 `renderLedger()` 先 `ledgerBuildToken += 1`，在途分批下次醒来发现 token 变了就地退出、不碰 DOM；`startPolling()` 的 tick 发现 `ledgerBuilding()` 为真就记住这一拍，等构建结束由 `flushDeferredPoll()` 补跑一次——因为 3,956 ms > 2,500 ms 的轮询间隔，不这么做的话读者会看着计数一次次归零，永远看不到终点。
+
+**剩下的杠杆没动，因为它要改承诺**：真正把「两万行」这个数字本身变小，只有两条路——给「显示全部」封顶，或者走增量协议（`?since=`）。前者是口径变更，后者是协议变更，两者都该先在这里定口径再动手，不该由一个性能修复顺手做掉。
+
+### D13 — 检视面板能改窗口，于是「已显示 200 条」在一秒内变成 15,224 条 **已修**
+
+**现象**：在「显示全部」下选中一条早期记录，点「显示最新 200 条」，那条记录离开窗口，表里再没有行带选中标记，**但检视面板还在描述它**。
+
+**根因**不是漏了清空，是 `revealSelection()` 在**切片之前**判定，并且会 `state.limit = Math.min(needed, entries.length)` —— 它主动把窗口撑大到能装下那条选中：
+
+```
+点下「显示最新 200 条」
+  此刻窗口条   已显示 200 条
+  下一秒       已显示 15,224 条      ← 差值 15,024 = 选中记录在 matched 里的位置
+```
+
+读者自己点的按钮把窗口条上的数字改了，而且是在点击之后才改。
+
+**两条错**：
+
+1. **窗口成了检视面板能写的东西。** `state.limit` 因此有两个写手（窗口控件 / 一次判定），这正是本文件里每一个双写手缺陷的形状（R1）。
+2. **判据错了。** 「读者能看见什么」是**窗口**，不是筛选结果。判在 `matched` 上，一条通过了全部筛选、却被窗口切掉的记录会继续留着选中。
+
+**修法**：`revealSelection(entries)` 收成纯谓词——只写 `state.selectedId`，不再碰 `state.limit`；调用点从切片前挪到切片后，参数从 `matched` 改成 `windowed`。窗口收窄到不含选中记录时**取消选中**，不撑大窗口：读者的窗口选择优先于更早的那次点击，且与筛选轴的既有规则一致（记录被滤掉即取消选中）。
+
+**口径变更，读点已逐个改**（`tests/verify-selection.mjs` 整份重写，14 断言）：
+
+| 旧承诺 | 新承诺 |
+| --- | --- |
+| 「窗口会被拉到选中所在处，按表计数」（`limit === 8`） | 「选中在窗口之下时取消选中，且窗口原地不动」（`limit === 3`） |
+| 判定发生在切片**之前** | 判定发生在切片**之后**，参数是 `windowed` |
+| —— | 新增：`revealSelection` 源码里不允许出现 `limit` 这个词 |
+
+`tests/mutate-selection.py` 里有**两条变异是改写而不是删除的**：原来的「窗口不会被拉到选中」守的正是现在删掉的那行 `state.limit` 写入，它现在改为弄坏替换它的新规则；原来的「判定发生在切片之后」守的是相反的顺序，现在改为弄坏「判定用的是窗口而不是筛选结果」。
+
+### D14 — 在途建行被取代时跳过 `restoreRowAnchor()`，滚动位置永久丢失 **已修**
+
+**归层** L5 的建行路径，但**归属的规则是 D9**：滚动位置只能由 `restoreRowAnchor()` 这一个出口决定。它写的是 L5 的什么状态？一个还没有的字段——修法需要新增一个（见下）。
+
+**关联** 与 `ledgerBuildToken` **从属且同源**：D12 引入 `ledgerBuildToken` 是为了让在途分批「就地退出、不碰 DOM」，那条规则是对的，坏的是退出时顺手把 D9 的还原也一起跳过了。与 `firstVisibleRow()` / `anchorOffset()` 并列，是锚点三件套的第四个成员——它管的是**跨建行的意图**，不是单次测量。
+
+**布局** 不新增 DOM、不新增面板。纯 JS：一个模块级变量 + `renderLedger()` 里一处赋值 + `restoreRowAnchor()` 里一处清空。
+
+**口径** 不改变任何已有数字。「显示全部」仍显示全部；窗口条读数不变；选中语义不变。可观察变化只有一条：滚动位置不再丢失。
+
+**实测（19,626 行 / 155 轮 / 文档高 716,000 px / 视口 841×900 / 已发布代码无探针）**：
+
+`renderLedger()` 在 `clear(ledger)` 之前捕获 `{anchor, scrollY}`，这一点是对的。问题在 `clear(ledger)` 的副作用：
+
+```
+clear(ledger) 之前   doc = 716,016 px    scrollY = 715,080
+clear(ledger) 之后   doc =    1515 px    scrollY =     616   ← 文档塌了，浏览器把 scrollY 夹到底
+建行 6 帧，约 3,956 ms，期间 scrollY 停在被夹住的位置
+buildStep() 收尾     restoreRowAnchor() 把位置算回来
+```
+
+所以位置**不是丢失，是被摧毁再重建**——中间那 3,956 ms 里读者看到的是第 1 轮。`restoreRowAnchor()` 本身完全正确，从被夹住的 2,051 出发也能算出 `delta = +103,559` 落回 105,610。
+
+**真正的丢失点是 `buildStep()` 的提前 return：**
+
+```js
+function buildStep() {
+  if (build.token !== ledgerBuildToken) return;   // ← 这一句把 restoreRowAnchor() 也跳过了
+  ...
+  restoreRowAnchor(anchor, scrollY);
+}
+```
+
+D12 给在途分批定的规则是「就地退出、不碰 DOM」——退出得对。但退出时**没人把滚动位置交还给下一个建行**，而下一个建行捕获锚点时读到的是已经被夹断的位置：
+
+```
+cap  ySave=715080 yReal=616 doc=1515     ← 轮询建行开始，位置被摧毁
+     （无 rst：这次建行被点击取代，restoreRowAnchor 从未执行）
+cap  ySave=5530  yReal=1065 doc=1965     ← 点击触发的 renderLedger，锚点已经错了
+rst  after=-15 delta=0 yIn=5530 yOut=5530
+     docYWas=5515 docYNow=5515           ← 忠实地还原到了一个错误的位置
+```
+
+一旦落到顶，之后每一轮都拿「第 1 轮」当锚点，**自我维持**，读者再也回不去。
+
+**触发面**：任何在轮询建行途中直接调用 `renderLedger()` 的读者动作。最大的一处是 `selectRecord()`——**点任意一行都会整表重建**。「显示全部」下建行 3,956 ms、轮询 2.5 s，所以点一行大概率落在建行途中。
+
+**对照组（证明与 `content-visibility` 无关）**：在无 `content-visibility` 的已发布代码上，点行时**没有**建行在途，则 `rst` 为 `delta 0 / yIn = yOut = 105,494`，位置纹丝不动。同一份代码、同一处点击，唯一变量是「有没有建行在途」。
+
+**修法**：把「读者想去哪」从「建行结束时算」提前成「第一次捕获时记下，此后每次建行转交」。一个模块级字段 `pendingAnchor`，一个写手 `forgetScrollAnchor()`：
+
+- `renderLedger()` 只在 `pendingAnchor` 为空时捕获 `{row: firstVisibleRow(), y: window.scrollY}`，之后每一趟都沿用；空的那一趟才读实时位置。
+- `restoreRowAnchor()` 第一句就是 `forgetScrollAnchor()`——它是唯一以「还原」结束一链的地方，所以也是唯一必须消费它的地方。
+- 五条提前返回（加载中、硬错误、无 payload、无会话、无命中）各调一次 `forgetScrollAnchor()`：它们把账本换成一个状态块，没有可锚的行，**丢弃而不是还原**——否则会把一个针对旧会话或旧筛选测出来的位置，套到另一个上面。
+
+**顺带修掉的**：`ledgerBuildToken += 1` 从 `applyFilterScope()` 那一侧移到 `clear(ledger)` **之上**。这不是顺手，是上面那条的前提——四条提前返回都在自增之前返回，它们同样清空账本，却什么都不退休，于是在途建行会继续往骨架屏里追加轮组，随后还会拿一张已经不存在的表的锚点去移动页面。现在自增在清空之前，四条返回路径和正常路径走的是同一句。
+
+**守卫**：`tests/verify-anchor-carry.mjs`（10 条断言）。捕获那三句是**跑**出来的——`firstVisibleRow()` 与 `window.scrollY` 换成返回**另一个**位置的桩，一个每次重读的版本会给出桩的答案而不是预设的答案；消费者则按条数点，`clear(ledger)` 到 `var groups =` 之间的 `return;` 必须和 `forgetScrollAnchor()` 一一对应。`tests/mutate-anchor-carry.py` 6 条变异全捕。
+
+`mutate-ledger-batch.py` 里原有两条变异锚在 `ledgerBuildToken += 1;` 后面那一行上，自增移动后失效——**已重新锚定到 `clear(ledger);`，一条未删**，并新增一条「把自增放回提前返回之下」忠实复现本条缺陷。`verify-ledger-batch.mjs` 相应从「数一次自增」加强为「数自增与 `clear()` 之间的 `return;`」——原来那条断言对四条提前返回完全失明。
+
+**浏览器实测（本机，19,991 条 / 156 轮 / 视口 841×900）**：显示全部 → 滚到第 133 轮 / #17188 → 点一行 → 等重建。建行途中视口短暂塌到第 51 轮（预期内，文档正在重建），**建行收尾后回到第 134 轮 / #17207**，正是点行前那一行（会话实时增长，序号整体前移）。再点一行，仍在第 134 轮 / #17215，被点的 #17226 带选中标记。修复前同一操作把读者永久留在第 1 轮。
+
+---
+
+## 3. 分层模型
+
+| 层 | 名称 | 拥有 | 回答 | 读 |
+| --- | --- | --- | --- | --- |
+| **L0** | 数据 | `server.mjs` 的 payload | 会话目录里有什么 | — |
+| **L1** | 上下文 | 会话、上下文代、跟随最新、刷新 | **看哪段数据** | L0 |
+| **L2** | 筛选 | 类型、异常规则、搜索、时间区间 | **看哪些记录** | L1 |
+| **L3** | 投影 | 总览条、轴模式（等宽/真实）、窗口分页 | 同一批记录怎么画、画多少 | L2 |
+| **L4** | 汇总 | KPI 卡 | 这段时间的整场会话 | L2 的**区间一个字段** |
+| **L5** | 列表 | 账本行、轮头 | 逐条记录 | L2 + L3 |
+| **L6** | 检视 | 单条记录的四视图 | 这一条长什么样 | L5 选中的 id |
+
+流向单向：`L6 ← L5 ← L3 ← L2 ← L1`，`L0` 在最底下。**唯一允许的向上写**是 L3 → L2 的区间刷选（见 R5）。
+
+### 五条不可违反的规则
+
+- **R1 一个字段一个写者。** 每个 `state.*` 只允许一个 setter 函数写入。互斥关系必须在这一处表达，不能散在两个渲染函数里。
+- **R2 可见性只有一个入口。** 「这条记录在不在屏上」只有一个函数回答；L3 的 span、L5 的行、L4 的口径全部走它。现在 `visibleEntries()` 和 `spanPassesFilter()` 是两个入口，这是 D 类缺陷的结构来源。
+- **R3 L4 只读 L2 的区间字段，其余不读。** KPI 不是筛选的函数，它不因类型轴变化而变化。
+- **R4 L6 不回查。** 检视只接受 L5 交付的选中记录 id。
+- **R5 L3 → L2 只有区间一条回写，且必须走同一个 setter。** 总览条不允许自己维护第二份区间。
+- **R6 控件位置与它写入的层可以不同，但必须声明。** 本页已知的两处：`window-bar` 在 L5 面板内、写 L3；`overview` 是 L3 的投影，同时持有写 L2 的控件。
+
+---
+
+## 4. 加功能之前：四个问题
+
+**顺序是硬的**：这四个问题的答案写下来（进 PR 描述或本文件的增量）之后才允许写实现代码。答不上第一个，说明这个功能不属于这个页面，或者需要先改模型。
+
+1. **归层** —— 它改的是哪一层的状态？
+   改不了层归属的，不做。
+2. **关联** —— 它和**同层**已有控件是并列、互斥还是从属？
+   互斥必须表达在同一个地方（R1）。不能靠「B 改的时候顺便把 A 清掉」这种跨函数约定。
+3. **布局** —— 它的容器是哪个已有层容器？需要新的 sticky、panel 或层吗？和邻居的视觉语言一致吗？
+4. **口径** —— 它是否改变任何已有层**对外承诺的数字**？
+   若改变，列出所有读那个数字的地方（按钮、提示、KPI、span、轮头），逐个加断言。这一问是「联动异常」的主要来源：加了一个能力，改了一个数字，别的地方还在按旧口径说话。
+
+### 反模式清单（每条都从本页的代价里长出来）
+
+- ❌ 把新控件放进「离它作用对象最近的地方」，而不是「离它所属的层最近的地方」。
+- ❌ 用「加一套第二系统」的方式扩展，而不是给现有系统加一个字段（异常轴本可以是 `anomaly: {mode, rules}` 一个字段）。
+- ❌ 让新控件自己解释全局状态（合计、是否已是默认、按下态），而不是读同一份快照。
+- ❌ 把只读汇总放在操作区上方，让读者以为它随操作变化。
+- ❌ 在没有共享层的前提下，用散落的互斥分支维持不变量。
+- ❌ 先实现、再补布局、再补守卫。**这条的顺序反过来才对**：归层 → 关联 → 布局 → 口径 → 不变量 → 实现 → 守卫。
+
+---
+
+## 5. 分阶段迁移
+
+每阶段一个独立改动、独立守卫、独立浏览器实测，不合并。
+
+### ~~Stage 1 — 把 L2 在文档里收成连续的（纯结构）~~ **已否决，不做**
+
+这一阶段的全部内容作废，理由见 D1：查询条件是聚合，UI 与请求构造本来就该拆开；强行收成一整块要付出窄屏可用面积。`docs/STAGE1-SPEC.md` 已标注不采纳。
+
+### Stage 0 — 谁负责重算（D8 / D9，**已完成**）
+
+先修「位置与位置变了之后由谁负责重算」，再谈其它。这一步已经落地：
+
+- 检视面板的选中判定收进 `revealSelection(entries)` 一个函数，参数就是**将要建行的那批行**，调用点收进 `renderLedger()`（D8）。
+- sticky 偏移的测量同样收进 `renderLedger()` 出口，并补 `resize` 挂钩（D9）。
+- 建行也走同一个出口：分批、进度、一轮新的渲染作废在途分批（D12）。
+- 选中的判定不再兼管窗口（D13）：`state.limit` 回到只有窗口控件一个写手。
+
+三条共用同一个出口，是因为它们回答的是同一个问题：**这次重画，哪些状态要重新判定。**
+
+### Stage 2 — 把异常轴变成 L2 的字段（模型）
+
+- `anomalyRules + multiAnomaly + anomalyLast` 收成一个 `anomaly: {mode, rules, last}`。
+- `visibleEntries()` 与 `spanPassesFilter()` 合成 R2 的单一入口。
+- `resetBaseFilters()` 变成对 L2 模型的一次赋值，取代逐控件清理（D5）。
+- 删掉 `state.kinds` 上那句「the only filter」的注释（D2），因为它不再成立。
+
+### Stage 3 — 声明跨层关系（R6）
+
+- 为「window-bar 在 L5 面板内、写 L3」和「overview 持有写 L2 的控件」各加一条断言：改位置或改归属时，断言先红。
+
+---
+
+## 6. 本轮明确不做
+
+- **不再做 Stage 1 的结构搬动。** D1 已撤回为「设计如此」，`STAGE1-SPEC.md` 已标不采纳。剩下的 Stage 2（异常轴建模）与 Stage 3（声明跨层关系）等明确指示。
+- 没有把 L4 改成跟随全部筛选。那是一次口径变更，按第 4 节的第 4 问处理：先列全部读点，再逐个加断言，最后才改。
+- 没有为了「层要连续」去动任何控件的位置。D9 修的是**重算责任**，不是布局。
+
+---
+
+## 7. 未做清单（2026-10-12 记）
+
+第 1 项是上一轮自己留下的，**D12 只修了一半**：分批改的是等待的形状（进度可见、批次之间交还主线程、在途可被打断），等待的长度没有变。18,924 行仍然是 3,956 ms。
+
+| # | 未做的是什么 | 属于 | 阻塞条件 | 下一步 |
+| --- | --- | --- | --- | --- |
+| 1 | **A 的墙钟时间没缩短。** 「显示全部」建 18,924 行仍要 3,956 ms。 | 代码 | **阻塞已解除** | 逐组推导 `contain-intrinsic-size` 版**已实现并实测**（782 ms / 5.1×，高度误差 −0.04%，深层行可点可读），回退的唯一理由是那次**视口从第 27 轮跳回第 1 轮**的滚动回归。该回归**已归因：不是回归，是既有缺陷 D14**，逐组推导版的唯一阻塞解除。下一步：先修 D14，再把这条路重新提交。详见 D12 与 D14。 |
+| 1b | ~~D14 — 点行时滚动位置永久丢失~~ **已修** | 代码 | — | 「显示全部」下点任意一行，若此刻有轮询建行在途，`buildStep()` 的 `if (build.token !== ledgerBuildToken) return;` 会连 `restoreRowAnchor()` 一起跳过，位置被 `clear(ledger)` 造成的塌缩永久丢弃。已用「滚动意图跨建行转交」修掉，并顺带把 token 自增移到 `clear(ledger)` 之上（否则四条提前返回什么都不退休）。浏览器实测通过。详见 D14。 |
+| 2 | **增量协议 `?since=`**（只发新增尾部） | 代码 + 协议 | 需先在本文定口径 | 性能上严格支配 D10 的按代缓存：1,400 ms → ~10 ms 量级，且不需要 116 MB 常驻。**但它主要省网络与 JSON 解析，对 #1 那 4 秒的 DOM + layout 成本帮助有限**，不要指望它顺带解决 A。 |
+| 3 | ~~给「显示全部」封顶~~ **已否决，不做** | 口径 | — | **chli 2026-10-12 定：不封顶。** 理由是「无限大无非是极端情况下假死，碰到的几率很小」。补充一条事实（已告知，不影响决定）：18,924 行不是极端情况，就是本会话现在的规模，3,956 ms 就是在它上面测出来的。封顶还会把「读完整个会话」从点一次变成点约 69 次「向上加载更早的 200 条」，而那个控件今天只在 `hiddenAbove > 0` 时出现，等于新增一条路。此路不再讨论。 |
+| 4 | **Stage 2 — 异常轴建模**（见 5.3） | 代码 | 等明确指示 | `anomalyRules/multiAnomaly/anomalyLast` 收成 `anomaly: {mode, rules, last}`；`visibleEntries()` 与 `spanPassesFilter()` 合成 R2 的单一入口；`resetBaseFilters()` 变成对 L2 模型的一次赋值（解 D5）；删掉 `state.kinds` 上那句已经不成立的「the only filter」注释（解 D2）。 |
+| 5 | **Stage 3 — 声明跨层关系（R6）** | 代码 | 无 | 小活：为「window-bar 在 L5 面板内、写 L3」和「overview 持有写 L2 的控件」各加一条断言，改位置或改归属时断言先红。 |
+| 6 | **窄屏 sticky 只有代码证据，没有浏览器实测** | 验证 | 环境 | in-app 浏览器视口固定 735×900 且不可 resize。目前窄屏那条路只有源码和网络请求证据。 |
+| 7 | **跨家族验证只有 codex 一条腿** | 验证 | 环境 | claude OAuth 过期、codebuddy 要 `/login`，需 chli 交互式处理。 |
+| 8 | **PR #16 reviews=0**；`.probe\perf-payload.json` 34 MB 临时产物待删 | 流程 | 等 maintainer | — |
+
diff --git a/plugins/avatasia/mmc-trajectory/docs/STAGE1-SPEC.md b/plugins/avatasia/mmc-trajectory/docs/STAGE1-SPEC.md
new file mode 100644
index 0000000..3f57f5e
--- /dev/null
+++ b/plugins/avatasia/mmc-trajectory/docs/STAGE1-SPEC.md
@@ -0,0 +1,247 @@
+# Stage 1 冻结 spec：把 L2 在文档里收成连续的
+
+> # ⛔ 不采纳 — 请勿实施
+>
+> **状态：已否决（2026-10-11）。本文件保留只为记录否决理由，任何人不得据此改动页面代码。**
+>
+> **否决理由**：上游把「查询条件在文档里被 KPI 区隔开」当成了需要偿还的结构债（D1）。这个判断是错的——
+> 查询条件是一个**聚合**，前端 UI 与最终请求参数本来就该拆开，两块甚至更多块 UI 各拼一部分参数是正常形态
+> （是否 MVVM 与此无关）。要求它们在文档里连续，是把「层要连续」当成了设计洁癖。
+>
+> 提的搬动方案（把搜索框与时间区间移进 sticky 筛选带）也被否决：**窄屏上 sticky 会占满视口，可用区域反而更小**，
+> 搜索框尤其如此。
+>
+> `LAYERS.md` 的 D1 已同步改写为「设计如此，不是缺陷」，并指向真正的问题 **D9（钉住偏移的重算责任只挂在一根线上）**——
+> 那一条已经修掉了，与本 spec 无关。
+>
+> 下面 17KB 的正文（15 条断言 V1–V12、7 条后果 F1–F7、4 条浏览器补测 B1–B4）全部作废，只作为「这条路走过」的记录保留。
+
+状态：**不采纳**
+日期：2026-10-11 · 上游：`docs/LAYERS.md` D1（已撤回） · 查漏：`codex / gpt-5.6-sol`（OpenAI，跨家族）
+
+这一份把 `LAYERS.md` 第 4 节的四个问题在本阶段答完，并把它们变成可判定的断言。
+**实现代码在本文件冻结之前一行都不写。**
+
+> 修订记录见文末第 8 节。那一轮查漏改了 6 条断言、撤了 1 条、加了 3 条后果，
+> 并改正了我自己写错的一个函数名和一条错误理由。
+
+---
+
+## 0. 这一阶段只解决一个缺陷
+
+`LAYERS.md` D1：「看哪些记录」这一个职责住在文档位置 3（`form.toolbar`）和位置 5（`.filter-sticky`）两处，
+中间隔着整块 KPI 区。读者要滚过 5 张统计卡才够得着筛选控件。
+
+上一轮的 sticky 修复是这笔债的利息。Stage 1 动本金：**让这一层在文档里就是连续的**，
+sticky 从「补丁」退化成「这一层本来就该一直在手边」。
+
+---
+
+## 1. Scope
+
+**做**：
+
+- 新建 L2 容器，包住全部四组「看哪些记录」的控件：
+  1. 搜索框（`.field.field-grow` / `#search-input`）
+  2. 时间区间（`#range-from` `#range-to` + 4 个快捷 + `#range-refresh` + `#range-clear` + `#range-hint`）
+  3. 类型轴（`.traj-controls#kind-controls`）
+  4. 异常轴（`.anomaly-bar#anomaly-bar`，含多选 + `#anomaly-mode-note`）
+- 这四组在**文档顺序上连续**，中间不插入任何非 L2 元素。
+- 容器不透明、带 sticky。保留现有实测偏移机制（`syncStickyOffsets()`）。
+
+**不做**（范围闸门，超出即停）：
+
+- 不动 L1：`#session-select` / `#generation-select` 留在容器外。
+- 不动 Stage 2：异常轴仍是三字段（`anomalyRules` / `multiAnomaly` / `anomalyLast`），
+  `visibleEntries()` 与 `spanPassesFilter()` 仍是两个入口。**这一阶段不碰模型。**
+- 不改任何数字口径 —— 见第 4 问，本阶段一个数字都不改。
+- 不删任何现有守卫。断言位置变了就重推，不是因为「搬家了不好测」而删。
+- 不改 `#kpi-scope` 的三句措辞，也不动它发布的两个数字。
+
+---
+
+## 2. 四问
+
+### ① 归层
+
+| 控件 | 归属 | 写的 state |
+| --- | --- | --- |
+| `#search-input` | L2 | `query` |
+| 时间区间全部 | L2 | `rangeFrom` `rangeTo` `rangeCutoff` `rangeFromText` `rangeToText` |
+| 类型轴 | L2 | `kinds` |
+| 异常轴 | L2 | `anomalyRules` `multiAnomaly` `anomalyLast` |
+| `#session-select` `#generation-select` | **L1** | `sessionId` `generation` |
+| `#kpi-grid` `#kpi-scope` | L4 | —（只读） |
+
+### ② 关联
+
+- 搜索 / 区间 / 类型轴 / 异常轴：**同层并列**，四组同时可读、互不置灰。
+- 异常轴与其它三者：**互斥**，且这个互斥只由 `visibleEntries()` / `spanPassesFilter()` 表达一次
+  （`resetBaseFilters()` 负责把另外三者写回默认值）。本阶段不动这段逻辑，只保证容器不破坏它。
+- `#kpi-scope` 与 L2：**从属**。它是 L4 对 L2 的一句声明，视觉上必须与 L2 区隔。
+
+### ③ 布局
+
+```
+header.page-header
+#error-bar / #stale-bar
+form.toolbar#toolbar            ← 只剩 L1 一行（会话 / 上下文代）
+section.kpi-section#kpi-section ← L4，在 L2 之外，带自己的口径行
+div.filter-sticky#filter-sticky ← L2，四组控件，连续，不透明
+section.overview#overview
+main.columns > panel 轨迹 / panel 检视
+```
+
+KPI **留在 L2 上方**（它不是筛选的一部分，视觉上要分开），但它上方已有的 `#kpi-scope`
+措辞已经承担了口径声明，本阶段不新增任何标注。
+
+### ④ 口径
+
+**本阶段不改变任何数字。** 但「KPI 跟区间、不跟类型轴/搜索/异常轴」这条口径的全部读点，
+必须先盘清楚，因为 Stage 1 动的正是 KPI 与筛选层的相对位置：
+
+| 读点 | 谁写的 | 读什么 | 现在断言它的守卫 |
+| --- | --- | --- | --- |
+| 5 张卡 | `renderKpi()` | `messages` `toolCalls` `turns` `tokens` `duration` | `client-check.mjs`（类型链接走 `onKindToggle`）、`mutate-turn-breakdown.py` |
+| `#kpi-scope` 措辞 | `applyFilterScope()`（5372） | —（纯文本） | 无功能断言 |
+| **`#kpi-scope` 里的数字** | `applyFilterScope()`（5383-5387） | `stats.messages`、**`stats.turnsWithPrompt`** | 无 |
+| `#range-hint` | `updateRangeHint()` | `stats.messages` | `verify-time-range.mjs` 234/236 |
+| `#generation-hint` | `statsAll()` | `payload.stats.messagesAll` | 无 |
+
+> 上一版把写 `#kpi-scope` 的函数记成了 `updateKpiScope()`——**那个函数不存在**，
+> 真正的写入者是 `applyFilterScope()`，也就是第 F4 条说「名字与职责不符」的那个。
+> 我在同一份文档里把它的名字写错了一次，正好印证那条结论。
+
+**风险，必须写下来**：守着 KPI↔区间这条口径的功能性断言（`verify-time-range.mjs`）
+在 `run.mjs` 的 `SKIP` 集合里，**默认不跑**——它的数字针对的是多代长会话，而提交的夹具是单代几十行。
+所以这条口径在**默认 24 项验收**里没有覆盖。Stage 1 恰好改 KPI 的位置，因此必须补一条能在
+默认套件里跑的断言，而不是依赖那个跳过文件。（补法见 V6。）
+
+---
+
+## 3. 不变量（可判定的）
+
+| | 不变量 | 怎么判 |
+| --- | --- | --- |
+| I1 | L2 容器的**直属子节点**恰好是四组控件，顺序为 搜索 → 区间 → 类型轴 → 异常轴，且它们之间不夹任何别的元素 | 解析容器子树的**标签序列**，按 id 定位四组；断言它们在子节点序列里**连续**。不能只比下标大小——那样一个插在中间的 KPI 段不会被发现 |
+| I2 | `#kpi-grid` 与 `#kpi-scope` 都不在 L2 容器内部 | 子树解析 |
+| I3 | `#session-select` / `#generation-select` 不在 L2 容器内部 | 子树解析 |
+| I4 | L2 容器不透明 | 解析出的 `background` 必须是**已定义的 `--mcode-*` token**；`transparent` / `rgba` / `hsla` / 含 `/ 0` 的 rgb 一律不算 |
+| I5 | L2 容器的偏移仍在 `render()` **末尾**实测写入 | 静态：`syncStickyOffsets();` 是 render 最后一句。运行态由浏览器实测补（见 §6） |
+| I6 | `#kpi-scope` 的三句措辞与它发布的两个数字一字未改 | 运行态断言，见 V6 |
+
+---
+
+## 4. verify 清单
+
+每条给出：**断言名** / **它必须拒绝的错误实现** / **配套变异**。
+变异之间必须**互不等价**：两条断言共用一个变异，等于其中一条没被测到。
+
+| 断言名 | 必须拒绝的错误实现 | 变异 |
+| --- | --- | --- |
+| V1 `the four filter controls are direct children of one layer, in order, with nothing between them` | 在搜索与区间之间塞一个 KPI 摘要条或标题 div（**插在中间**，不是接在末尾） | 把 `#kpi-section` 整段移到 `#search-input` 的 field 之后、`#range-from` 之前 |
+| V2 `the KPI cards are not inside the filter layer` | 为了「视觉统一」把 KPI 并入筛选容器，且**接在四组之后** | 把 `kpi-section` 追加到 `.anomaly-bar` 之后（仍在容器内） |
+| V3 `the session picker stays out of the filter layer` | 顺手把会话选择器也搬进去（它是 L1，搬了就等于把上下文选择说成筛选） | 把 `#session-select` 的 field 挪进容器 |
+| V4 `the filter layer is opaque` | 去掉背景色「让页面更透气」，或改成 `rgb(0 0 0 / 0)` | 把 `background: var(--mcode-bg)` 换成 `transparent` |
+| V5 `the layer height is still measured at the end of render` | 把 `syncStickyOffsets()` 上移到 `syncAnomalyMode()` 之前 | 交换两行 |
+| V6 `the KPI says in words and in numbers which filter it follows` | KPI 位置移动后，那句声明或那两个数字消失／被改成与 `kpiStats()` 行为不符的话 | 把 `整场会话 · 类型与搜索只筛列表` 换回旧措辞 |
+| V7 `the range filter and the type chips are siblings inside one layer` | 把区间做成类型轴的子控件（读者会以为区间是「某一类记录的区间」） | 把时间区间 field 嵌进 `#kind-controls` |
+| V8 `the time range no longer depends on a toolbar row for its layout` | 搬进容器却没给 L2 容器自己的 flex 规则，靠 `.toolbar-row` 的旧样式蒙混过关 | 删掉 L2 容器的 `display:flex` |
+| V9 `the search form no longer calls itself a search landmark` | 保留 `role="search"` 于一个已不含搜索框的表单 | 把 `role="search"` 加回去 |
+| V10a/b/c `anomaly mode still silences the other three filter groups` | 搜索、区间、类型轴中**任意一组**丢掉 `data-filter-scope` | 分别给三个 field 去掉该属性，**三条独立变异** |
+| V11 `the anomaly axis is not silenced by its own mode` | 给 `.anomaly-bar` 加上 `data-filter-scope` | 给 `.anomaly-bar` 加 `data-filter-scope` |
+| V12 `the KPI publishes the same numbers kpiStats returns` | 让 `#kpi-scope` 里的 `N 条消息` 变成别处的数字 | 把 `stats.messages` 换成 `statsAll()` |
+
+V7 是这一阶段最容易犯的错：为了少一个容器，把区间塞进类型轴。两者是同层并列，不是从属。
+
+**为什么 V1 的变异必须插在中间**：上一版写的是「把 KPI 整段移进容器」，而接在四组**之后**时四组仍然连续，
+V1 照样通过——**那是一条空操作变异**。现在改成插在搜索与区间之间，它才会真正打断连续性。
+
+### 4.1 静态断言测不到、必须浏览器补的
+
+| | 内容 | 怎么测 |
+| --- | --- | --- |
+| B1 | 异常模式下搜索 / 区间 / 类型轴确实 `inert`（运行时属性），且 Tab 到不了 | 浏览器读 `element.inert` + 逐个 Tab |
+| B2 | 异常轴在异常模式下**仍可 Tab 到** | 同上 |
+| B3 | 三个 sticky 带在窄屏换行、提示出现/消失后仍不重叠 | 735px 视口截图 + 量盒 |
+| B4 | 最小视口高度下四组控件没有把可用高度吃光 | 断言 `filter-sticky` 高度 < 视口高度的某个比例 |
+
+V10 与 B1 不是一回事：V10 证明标记还在（静态），B1 证明浏览器真的把它 inert 了（运行态）。
+
+### 4.2 结构改动会引出的后果（本阶段必须显式决策）
+
+| | 后果 | 证据 | 本阶段决定 |
+| --- | --- | --- | --- |
+| **F1** | `.toolbar-row` 承载区间那一行的 `display:flex; flex-wrap: wrap; align-items: center`。区间 field 一旦移出表单，这段规则不再命中它——**布局会静默变样，没有任何报错** | 两条 `.toolbar-row` 规则（默认 + 窄屏 `align-items: stretch`） | L2 容器自己给布局规则，V8 断言 |
+| **F2** | `form#toolbar` 上的 `submit` → `preventDefault()` 唯一职责是拦搜索框的隐式提交。移走后表单里只剩两个 `<select>`，handler 成了死代码 | `index.html:6660-6662` | **删掉 handler**。`<form>` 外壳保留（它给这一行一个语义容器），但 `role="search"` 必须去掉——一个不含搜索框的 search landmark 是假话。V9 断言。**更正**：上一版说「保留 form 因为 select 需要 label 关联」——这是错的，`<label for>` 按 `id` 关联，与是否在 form 内无关 |
+| **F3** | 异常模式靠 `body[data-anomaly-mode='on'] [data-filter-scope]` 把其它三组标 inert。这是**后代选择器**，搬家后仍生效；异常轴本身不带该属性 | `563` 规则；`6517-6518` 写入；`2032/2039/2065/2083` 四处标记 | V10a/b/c + V11 + B1/B2 |
+| **F4** | `applyFilterScope()` 名字说 L2、只写 L4 的口径行；真正的 inert 在 `syncAnomalyMode()` | 函数体首行 `if (!dom.kpiScope) return;` | **不在本阶段改名**（属 Stage 2）。但已记进 `LAYERS.md` D7。**注意**：上一版本 spec 把这个函数的名字写错成 `updateKpiScope()`，已更正 |
+| **F5** | **Tab 顺序变了**：现在是 会话→代→搜索→区间→KPI，搬家后变成 会话→代→KPI→搜索→区间，KPI 折叠按钮插进了筛选流程中间 | `2022-2083` 的 DOM 顺序 | **必须决策**：要么把 KPI 的折叠按钮移出 Tab 序列（`tabindex="-1"` + 保留可点击），要么明确接受这个顺序并在 §6 验收。**不能列为「不验证」** |
+| **F6** | `#kind-controls` 的 `aria-controls="overview"` 只说了总览条，但同一批筛选同时控制账本；新建的 L2 容器也没有整体名称 | `2083` | 给 L2 容器一个可访问名称（如 `role="group"` + `aria-label`），并复核 `aria-controls` 的目标 |
+| **F7** | 窄屏下四组控件全部 sticky，动态高度可能占满视口——实测偏移正确 ≠ 内容可用 | `6131-6138` | B3 + B4：断言 `filter-sticky` 高度不超过视口的 60%，且换行后不重叠 |
+
+---
+
+## 5. 现有断言中会被这一阶段触及的（只重推，不删）
+
+| 断言 | 判断 | 处理 |
+| --- | --- | --- |
+| `verify-anomaly.mjs:712`「KPI 卡不再夹在两条轴之间」 | 表达式 `!(kindAt < kpiAt && kpiAt < anomalyAt)` 在 KPI 位于两轴之前时通过，**Stage 1 后仍成立**（KPI 留在容器上方，三者相对先后不变） | 但这条只证明「KPI 不在三者的**之间**」，**不证明两轴相邻、同容器、或 KPI 不在 L2 内**。连续性由 V1 保证，容器边界由 V2 保证。**不得把它当作 Stage 1 的连续性保护** |
+| `verify-sticky.mjs` 20 条 | 「只改指向」**不足**。现有子树断言只要求 `kind-controls` 与 `anomaly-bar` 同在 band 内 | **必须重写子树成员与排他性**：覆盖搜索、区间、`#range-hint` 四组，并显式排除 L1（会话/代）与 L4（kpi-grid/kpi-scope）。三条内核（band 是一个块 / 偏移实测 / 被钉住的层不透明）保持 |
+| `client-check.mjs`「KPI kind links go through onKindToggle」 | 不受影响 | 浏览器点一遍确认 |
+
+---
+
+## 6. 验收
+
+- 现有 24 个守卫全绿，V1–V12 与 B1–B4 各自的断言与变异全绿
+- `make-fixtures.mjs --check` 无漂移、`npm run validate` OK
+- 浏览器在**三个滚动位置**（页顶 / 面板标题刚滚走 / 账本底部）截图判读：L2 四组连续、无缝隙、无重叠
+- 键盘：735px 视口下逐个 Tab 走一遍 L2，确认 F5 的顺序是**决策过**的，且异常模式下 Tab 到不了的三组确实到不了（B1/B2）
+
+> 上一版把「窄屏键盘可达性」划在本阶段不验证，**已撤销**：DOM 顺序与 sticky 高度正是本阶段直接改变的行为，
+> 把它排除在外等于把最该验的东西排除掉。
+
+---
+
+## 7. 冻结
+
+**仍未冻结。** 需要下面两项都完成：
+
+1. 把这份**修订版**再交给跨家族只读查漏一轮
+2. 查漏结论回写，标明哪些不变量被补、哪些被撤及理由
+
+### 7.1 第一次查漏：跑通了
+
+Windows 沙箱在 `codex exec` 下初始化失败（`setup refresh had errors`），三种执行方式全被拒，
+第一次评审因此**交白卷**（它明确拒绝捏造 `文件:行`，且哈希确认未改动文件）。改为把材料
+内联进 stdin 后跑通：
+
+```
+codex exec -s read-only --skip-git-repo-check -m gpt-5.6-sol -
+```
+
+模型只有 `gpt-6.1-sol` 被 ChatGPT 账号拒绝（`not supported when using Codex with a ChatGPT account`），
+`gpt-5.6-sol` / `gpt-6-sol` / `gpt-5.5` 等均可。详见 `~/.codex/models_cache.json`。
+
+---
+
+## 8. 第一次查漏的结论与处置
+
+| # | 它指出的 | 处置 |
+| --- | --- | --- |
+| 1 | V1 的变异是空操作（KPI 接在末尾时四组仍连续） | **接受**，改为插在搜索与区间之间 |
+| 2 | V1 与 V2 共用同一变异 | **接受**，V2 改为「接在四组之后」 |
+| 3 | V10 只覆盖「异常轴被加了属性」一种 | **接受**，拆成 V10a/b/c + V11 |
+| 4 | `#kpi-scope` 不只是措辞，还发布 `messages` / `turnsWithPrompt` 两个数字 | **接受**，口径表补一行，spec 自己漏了这个读点 |
+| 5 | 写 `#kpi-scope` 的函数是 `applyFilterScope()` 不是 `updateKpiScope()` | **接受**，那是我写错的，已更正 |
+| 6 | 「保留 form 因为 select 需要 label 关联」不成立 | **接受**，`for`/`id` 与 form 无关，我的理由错了 |
+| 7 | `verify-sticky.mjs`「只改指向」不足，子树断言要重写 | **接受**，§5 已改 |
+| 8 | I1 用下标比大小发现不了中间的插入 | **接受**，改为解析容器子节点的标签序列 |
+| 9 | I4 的不透明判断太粗 | **接受**，限定为已定义的 `--mcode-*` token |
+| 10 | 焦点顺序变化不能列为「不验证」 | **接受**，新增 F5 并撤销 §6 的排除 |
+| 11 | `aria-controls` 目标与容器可访问名称 | **接受**，新增 F6 |
+| 12 | 窄屏 sticky 可能占满视口 | **接受**，新增 F7 + B3/B4 |
+| 13 | `kpiStats()` 的调用者集合应被断言 | **接受**，新增 V12 |
+| 14 | 「目前没有保护」过度表述 | **不成立**。spec 第 94 行原文是「在**默认套件里**目前没有保护」，已经限定了范围；它引的是第 88 行的表格行，那一行里没有这句话 |
+| 15 | `verify-anomaly.mjs:712` / `verify-sticky.mjs:79` 的行号 | **部分不成立**。`:712` 正确；`:79` 落在 `value()` 这个辅助函数上，它要谈的是子树成员断言，行号引错 |
\ No newline at end of file
diff --git a/plugins/avatasia/mmc-trajectory/miniapp/client/index.html b/plugins/avatasia/mmc-trajectory/miniapp/client/index.html
index c977097..28b81a0 100644
--- a/plugins/avatasia/mmc-trajectory/miniapp/client/index.html
+++ b/plugins/avatasia/mmc-trajectory/miniapp/client/index.html
@@ -504,6 +504,67 @@
         color: inherit;
       }
 
+      /* A rule with nothing to find stays listed — "none of these happened" is a different fact
+         from "this is not available" — but it is not dressed as a button that will return rows.
+         The count still carries it, so this is a dim, never a hide. */
+      .anomaly-btn.is-empty .anomaly-count {
+        opacity: 0.55;
+      }
+
+      /* 异常 sits directly under the type axis because both answer the same question — which
+         records the ledger shows — so the two read as one strip of choices. Same 16px gutter as
+         .traj-controls, so its left edge lines up with the 全部 button above it. */
+      .anomaly-bar {
+        display: flex;
+        flex: none;
+        flex-wrap: wrap;
+        align-items: center;
+        gap: 8px;
+        padding: 8px 16px;
+        border-bottom: 1px solid var(--mcode-border);
+      }
+
+      .anomaly-bar-label {
+        font-size: 12px;
+        color: var(--mcode-text-subtle);
+      }
+
+      /* The 多选 switch. It is a real checkbox so it is announced and operable by keyboard with
+         no extra work, and it is small so it reads as a switch rather than a third kind of
+         filter. Its own text, not colour, is what says which mode is in force. */
+      .anomaly-multi {
+        display: inline-flex;
+        align-items: center;
+        gap: 4px;
+        font-size: 12px;
+        color: var(--mcode-text-muted);
+        cursor: pointer;
+      }
+
+      .anomaly-multi input {
+        margin: 0;
+      }
+
+      .anomaly-multi:has(input:checked) {
+        color: var(--mcode-text);
+      }
+
+      .anomaly-bar-note {
+        font-size: 12px;
+        color: var(--mcode-text-subtle);
+      }
+
+      /* In 异常 mode the type axis, the search box and the time range do not apply. They are
+         dimmed rather than left looking live: a control that cannot change what is on screen
+         and still takes clicks is the exact defect this axis was moved to fix. The JS also sets
+         `inert` on them, so keyboard focus cannot land on a control that does nothing.
+         会话 / 上下文代 / 刷新 are deliberately unmarked — they choose which session is on
+         screen, not which records, and have to keep working. */
+      body[data-anomaly-mode='on'] [data-filter-scope] {
+        opacity: 0.4;
+        filter: grayscale(1);
+      }
+
       .range-sep {
         font-size: 12px;
         color: var(--mcode-text-subtle);
@@ -770,16 +831,32 @@
          on. The reference styles the glyph rather than the button, so the button stays
          flat when pressed and only the mark changes. */
 
-      .traj-controls {
+      /* One sticky band for both filter axes.
+
+         The type row and the 异常 row decide the same question — which records the ledger shows —
+         so they are pinned as a single block rather than one of them following the other out of
+         view. Only the type row claimed `position: sticky` before, and it did not survive: with
+         the ledger below it and both rows scrolled away, a session filtered down to a few hundred
+         rows gave no sign that anything was filtered at all. The band carries its own background
+         because it now sits over the ledger, which is opaque underneath it.
+
+         Everything pinned below this measures its offset from it rather than assuming it — see
+         syncStickyOffsets(). The anomaly row wraps at narrow widths and the note under it comes
+         and goes, so its height is not a number anyone can write down once. */
+      .filter-sticky {
         position: sticky;
         top: 0;
-        z-index: 5;
+        z-index: 6;
+        background: var(--mcode-bg);
+        border-bottom: 1px solid var(--mcode-border);
+      }
+
+      .traj-controls {
         display: flex;
         flex: none;
         align-items: center;
         padding: 6px 16px;
         background: var(--mcode-bg);
-        border-bottom: 1px solid var(--mcode-border);
       }
 
       .traj-controls-actions {
@@ -880,7 +957,7 @@
 
       .overview {
         position: sticky;
-        top: 32px;
+        top: var(--sticky-band-h, 32px);
         z-index: 4;
         border-bottom: 1px solid var(--mcode-border);
         user-select: none;
@@ -1146,7 +1223,11 @@
 
       .turn-head {
         position: sticky;
-        top: 0;
+        /* Below every band above it, measured. It used to pin at 0 with z-index 2 and simply got
+           drawn over — its turn title and its kind summary landed on the type row's buttons and on
+           the overview's tick labels, and neither could be read. */
+        top: calc(var(--sticky-band-h, 32px) + var(--sticky-overview-h, 51px)
+          + var(--sticky-window-h, 45px));
         z-index: 2;
         display: flex;
         align-items: center;
@@ -1525,11 +1606,12 @@
 
       .window-bar {
         position: sticky;
-        /* Sticky offsets stack here: the type row owns 0–32 and the overview strip owns
-           32–83 (32 + the 50px plot + its 1px border), so a bar pinned at 0 would simply
-           hide behind both of them. z-index 3 keeps it under the overview (4) and over the
-           turn head (2). */
-        top: 83px;
+        /* Sticky offsets stack here, and every one of them below the filter band is measured
+           rather than written down: the band is the two filter rows (whose height changes when
+           异常 wraps or when its note appears) plus the overview strip. The old numbers — 0–32 and
+           32–83 — were correct for a layout where the 异常 row was not in the band, and they are
+           exactly the kind of constant that goes stale silently. syncStickyOffsets() owns them. */
+        top: calc(var(--sticky-band-h, 32px) + var(--sticky-overview-h, 51px));
         z-index: 3;
         padding: 8px 16px;
         background: var(--mcode-bg);
@@ -1947,14 +2029,14 @@ <h1>会话轨迹</h1>
             <label class="field-label" for="generation-select">上下文代</label>
             <select id="generation-select" aria-describedby="generation-hint"></select>
           </div>
-          <div class="field field-grow">
+          <div class="field field-grow" data-filter-scope>
             <label class="field-label" for="search-input">搜索</label>
             <input type="search" id="search-input" placeholder="搜索摘要、正文、结果与思考" autocomplete="off" />
           </div>
         </div>
 
         <div class="toolbar-row">
-          <div class="field field-range" role="group" aria-labelledby="range-label" aria-describedby="range-hint">
+          <div class="field field-range" role="group" aria-labelledby="range-label" aria-describedby="range-hint" data-filter-scope>
             <span class="field-label" id="range-label">时间区间</span>
             <label class="range-part" for="range-from">
               <span class="range-part-label">起点</span>
@@ -1980,18 +2062,7 @@ <h1>会话轨迹</h1>
             <button type="button" class="btn btn-quiet" id="range-clear" aria-label="清空时间区间" hidden>清空区间</button>
           </div>
         </div>
-        <p class="range-hint" id="range-hint">留空 = 不限。选一个时间区间，或用快捷按钮。</p>
-
-        <div class="toolbar-row">
-          <div class="field field-anomaly" role="group" aria-labelledby="anomaly-label">
-            <span class="field-label" id="anomaly-label">异常</span>
-            <!-- The buttons are built from ANOMALY_RULES rather than written here. The rule
-                 table is the one place a rule is named, so a rename cannot leave a button
-                 showing one word and announcing another, and a new rule is an entry in that
-                 table instead of a second list to keep in step. -->
-            <div class="anomaly-quick" id="anomaly-controls" role="group" aria-label="只看异常记录"></div>
-          </div>
-        </div>
+        <p class="range-hint" id="range-hint" data-filter-scope>留空 = 不限。选一个时间区间，或用快捷按钮。</p>
 
       </form>
 
@@ -2008,7 +2079,8 @@ <h2 class="section-title" id="kpi-heading">关键指标</h2>
         <div class="kpi-grid" id="kpi-grid"></div>
       </section>
 
-      <div class="traj-controls" id="kind-controls" role="toolbar" aria-label="按类型筛选轨迹" aria-controls="overview">
+      <div class="filter-sticky" id="filter-sticky">
+        <div class="traj-controls" id="kind-controls" role="toolbar" aria-label="按类型筛选轨迹" aria-controls="overview" data-filter-scope>
         <nav class="traj-controls-actions" aria-label="按类型筛选轨迹">
           <button type="button" class="tbtn tbtn-action tbtn-all" id="kind-all" aria-pressed="true"
             aria-label="当前显示全部类型 · 点击只看空白" title="当前显示全部类型 · 点击只看空白">
@@ -2062,6 +2134,32 @@ <h2 class="section-title" id="kpi-heading">关键指标</h2>
         </nav>
         </div>
 
+        <!-- 异常 is a second filter system, not a fourth field of the first one, and it is said
+             so here rather than implied: while a rule is on, the kind axis, the search box and
+             the time range stop applying, and the controls that drive them are dimmed so that
+             a control that cannot change what is on screen does not still look like it can.
+             It sits directly under the kind axis because the two decide the same thing — which
+             records the ledger shows — and separated by the KPI cards it read as unrelated.
+             The buttons are built from ANOMALY_RULES rather than written here: the rule table
+             is the one place a rule is named, so a rename cannot leave a button showing one
+             word and announcing another, and a new rule is an entry in that table instead of a
+             second list to keep in step. -->
+        <div class="anomaly-bar" id="anomaly-bar">
+          <span class="anomaly-bar-label" id="anomaly-label">异常</span>
+          <!-- Single by default, because 「点什么就显示什么」 is the promise and a button that
+               adds to the selection breaks it: you ask for tool failures and get them plus
+               whatever was already on. The checkbox is how you ask for the union instead — it
+               is a mode switch, not a filter, which is why it sits outside the button group
+               rather than being one more rule. -->
+          <label class="anomaly-multi" for="anomaly-multi">
+            <input type="checkbox" id="anomaly-multi" />
+            <span>多选</span>
+          </label>
+          <div class="anomaly-quick" id="anomaly-controls" role="group" aria-labelledby="anomaly-label"></div>
+          <span class="anomaly-bar-note" id="anomaly-mode-note" hidden></span>
+        </div>
+      </div>
+
       <section class="overview" id="overview" aria-labelledby="overview-heading">
         <h2 class="sr-only" id="overview-heading">轨迹总览</h2>
         <div class="overview-plot">
@@ -2246,11 +2344,23 @@ <h2 class="section-title" id="inspector-heading">检视</h2>
         return rule.id;
       });
 
-      function anomalyRuleLabel(id) {
+      // Not a rule, so it has no id and no entry in the table: it is the state where no rule
+      // applies and the row above is in charge again. 重置, not 反选 — nothing is being inverted
+      // here, the row is being put back the way it was on arrival. Named here rather than in the
+      // markup so the bar cannot end up offering a way back that the handler and the note
+      // disagree with.
+      var ANOMALY_NONE_LABEL = '重置';
+
+      function anomalyRuleById(id) {
         for (var i = 0; i < ANOMALY_RULES.length; i += 1) {
-          if (ANOMALY_RULES[i].id === id) return ANOMALY_RULES[i].label;
+          if (ANOMALY_RULES[i].id === id) return ANOMALY_RULES[i];
         }
-        return id || DASH;
+        return null;
+      }
+
+      function anomalyRuleLabel(id) {
+        var rule = anomalyRuleById(id);
+        return rule ? rule.label : (id || DASH);
       }
 
       /**
@@ -2721,7 +2831,7 @@ <h2 class="section-title" id="inspector-heading">检视</h2>
         return { text: text.slice(0, cap), truncated: true };
       }
 
-      function buildHandoffMarkdown(session, turn, record, rawText, rawTruncated) {
+      function buildHandoffMarkdown(session, turn, record, rawText, rawTruncated, rawOmitted) {
         var lines = [];
         lines.push('请分析这条会话轨迹记录，说明它在做什么、有没有问题，以及是否需要改进。');
         lines.push('');
@@ -2754,7 +2864,7 @@ <h2 class="section-title" id="inspector-heading">检视</h2>
         if (record.api) lines.push('- 接口：' + record.api);
         if (record.stopReason) lines.push('- 结束原因：' + record.stopReason);
         if (record.textTruncated) lines.push('- 提示：正文已被上游截断。');
-        if (record.rawOmitted) lines.push('- 提示：原文过大已被省略。');
+        if (rawOmitted) lines.push('- 提示：原文过大已被省略。');
         if (record.isError || record.error) {
           lines.push('- 状态：失败');
           lines.push('- 错误：' + safeText(record.error));
@@ -2961,6 +3071,15 @@ <h2 class="section-title" id="inspector-heading">检视</h2>
         // Kept as a list of rule ids rather than a boolean so a later rule is one more entry
         // here and one more button, not a second piece of state that has to agree with this.
         anomalyRules: [],
+        // Whether a second rule adds to the selection or replaces it. Off by default: a plain
+        // click answers 「点什么就显示什么」, and adding to what is already ticked breaks that.
+        // Turned on, the buttons union. It is a mode and not a rule, so it lives beside
+        // `anomalyRules` rather than in it.
+        multiAnomaly: false,
+        // The rule the reader ticked last. Only used when 多选 is switched off while several
+        // rules are standing: one of them has to survive, and the one they were last looking at
+        // is the one they meant.
+        anomalyLast: null,
         query: '',
         // Time range, in milliseconds since the session started — the same zero the ledger's
         // `+893 分 21 秒` column counts from. `null` on either side means that end is open,
@@ -3028,6 +3147,7 @@ <h2 class="section-title" id="inspector-heading">检视</h2>
         dom.staleBar = document.getElementById('stale-bar');
         dom.toolbar = document.getElementById('toolbar');
         dom.kindControls = document.getElementById('kind-controls');
+        dom.filterSticky = document.getElementById('filter-sticky');
         dom.sessionSelect = document.getElementById('session-select');
         dom.generationField = document.getElementById('generation-field');
         dom.generationSelect = document.getElementById('generation-select');
@@ -3040,7 +3160,10 @@ <h2 class="section-title" id="inspector-heading">检视</h2>
         dom.rangeQuick = document.querySelector('.range-quick');
         dom.rangeHint = document.getElementById('range-hint');
         dom.anomalyControls = document.getElementById('anomaly-controls');
+        dom.anomalyNote = document.getElementById('anomaly-mode-note');
+        dom.anomalyMulti = document.getElementById('anomaly-multi');
         dom.windowBar = document.getElementById('window-bar');
+        dom.overview = document.getElementById('overview');
         dom.headerToggle = document.getElementById('header-toggle');
         dom.kpiToggle = document.getElementById('kpi-toggle');
         dom.kpiGrid = document.getElementById('kpi-grid');
@@ -3223,10 +3346,11 @@ <h2 class="section-title" id="inspector-heading">检视</h2>
           if (payloadTurns[t] && payloadTurns[t].id) turnById.set(payloadTurns[t].id, payloadTurns[t]);
         }
 
-        if (changed) {
-          rePinWindow();
-          revealSelection();
-        }
+        // Only the window is re-decided here. Whether the selected record is still in the table is
+        // settled inside renderLedger(), which is the one exit every path that changes what the
+        // table shows goes through; answering the question here as well would give the field two
+        // writers, and the poll path is the one that used to leave it stale.
+        if (changed) rePinWindow();
         render();
         if (manual) announce('已刷新，正在显示最新数据。');
       }
@@ -4409,26 +4533,76 @@ <h2 class="section-title" id="inspector-heading">检视</h2>
       }
 
       /**
-       * How many records each rule would keep, given every other filter exactly as it stands.
-       * Counted through passesBaseFilter so a button can never advertise a number the ledger
-       * will not deliver. `any` counts records, not rule hits: one row can trip two rules,
-       * and 「全部异常」 promising more rows than exist is the same lie as promising fewer.
+       * What each 异常 button would show if it were the only one ticked.
+       *
+       * Counted over every record with no other filter applied, because that is exactly what
+       * 异常 mode does: the type axis, the search box and the time range all stop applying the
+       * moment a rule is on. Counting through passesBaseFilter — which is what this used to do,
+       * while the ledger was also applying those filters — produced a number no click could
+       * ever deliver, and that is the whole of the original defect: a button promising 283
+       * rows above a list showing 1,494. The only fix is to count the way the ledger filters,
+       * so the invariant is stated as a property of this function: the number on a button is
+       * what you get when you tick that button and nothing else.
+       *
+       * Two units, because the rules are two kinds of thing. A record rule counts 条. A turn
+       * rule counts 轮, and counts the *turns*, not the records inside them: 无答复 fires on
+       * every record of a turn that never answered, so counted in records it advertised 1,244
+       * "unanswered" rows that carry no sign of being unanswered — while the session was in
+       * fact broken a dozen times. A unit is a claim about what the number counts, and the two
+       * cannot share one.
+       *
+       * `any` counts records, not rule hits: one row can trip two rules, so it never equals the
+       * sum of the parts. That is why it is labelled as the union and not as a total.
+       *
+       * `selected` is the union of the rules that are actually ticked, which is a different
+       * number from `any` whenever the selection is not the whole table. It is counted here rather
+       * than recomputed where it is used because this loop already holds `hits` for every record:
+       * asking again would be a second full walk of a session that can hold twenty thousand rows
+       * and re-renders on every poll. And `visibleEntries()` filters on exactly this predicate, so
+       * `selected` is the length of the list under the buttons — the same promise every other
+       * number on this row makes.
+       *
+       * @returns {{byRule: Object, unit: Object, any: number, selected: number, total: number}}
        */
       function anomalyCounts() {
         var byRule = {};
-        for (var i = 0; i < ANOMALY_RULES.length; i += 1) byRule[ANOMALY_RULES[i].id] = 0;
+        var unit = {};
+        for (var i = 0; i < ANOMALY_RULES.length; i += 1) {
+          byRule[ANOMALY_RULES[i].id] = 0;
+          unit[ANOMALY_RULES[i].id] = ANOMALY_RULES[i].turn ? '轮' : '条';
+        }
         var any = 0;
-        var selection = state.overviewSelection;
+        var selected = 0;
+        var sel = state.anomalyRules;
         var live = liveTurn();
+        var counted = {};
         for (var j = 0; j < state.flat.length; j += 1) {
           var entry = state.flat[j];
-          if (!passesBaseFilter(entry.record, selection)) continue;
           var hits = recordAnomalyRules(entry.record, { turn: entry.turn, liveTurn: live });
           if (!hits.length) continue;
           any += 1;
-          for (var k = 0; k < hits.length; k += 1) byRule[hits[k]] += 1;
+          for (var s = 0; s < hits.length; s += 1) {
+            if (sel.indexOf(hits[s]) >= 0) {
+              selected += 1;
+              break;
+            }
+          }
+          for (var k = 0; k < hits.length; k += 1) {
+            var id = hits[k];
+            var rule = anomalyRuleById(id);
+            if (!rule || !rule.turn) {
+              byRule[id] += 1;
+              continue;
+            }
+            // A turn rule reaches every record of its turn, so the turn is what gets counted,
+            // and only the first record of that turn to arrive counts it.
+            var key = id + '#' + entry.turn.index;
+            if (counted[key]) continue;
+            counted[key] = true;
+            byRule[id] += 1;
+          }
         }
-        return { byRule: byRule, any: any };
+        return { byRule: byRule, unit: unit, any: any, selected: selected, total: state.flat.length };
       }
 
       /**
@@ -4445,30 +4619,78 @@ <h2 class="section-title" id="inspector-heading">检视</h2>
         return out;
       }
 
+      /**
+       * Two filter systems, one of them at a time.
+       *
+       * 异常 mode is entered by ticking a rule and left with 全部数据. While it is on, the type
+       * axis, the search box, the time range and the overview brush are all switched off —
+       * deliberately. 异常 is a short list, and narrowing a short list by a second axis is how
+       * a reader ends up staring at an empty ledger with four filters set and no way to tell
+       * which one emptied it. So this is an either/or and not two independent tests: with no
+       * rule ticked the anomaly branch cannot run at all, because passesAnomaly() treats an
+       * empty list as "off" and lets everything through.
+       */
       function visibleEntries() {
         var out = [];
         var selection = state.overviewSelection;
+        var anomalyMode = state.anomalyRules.length > 0;
         for (var i = 0; i < state.flat.length; i += 1) {
           var entry = state.flat[i];
-          if (!passesBaseFilter(entry.record, selection)) continue;
-          if (!passesAnomaly(entry.record, anomalyContext(entry), state.anomalyRules)) continue;
+          if (anomalyMode) {
+            if (!passesAnomaly(entry.record, anomalyContext(entry), state.anomalyRules)) continue;
+          } else if (!passesBaseFilter(entry.record, selection)) {
+            continue;
+          }
           out.push(entry);
         }
         return out;
       }
 
-      function revealSelection() {
-        if (!state.selectedId) return;
-        for (var i = 0; i < state.flat.length; i += 1) {
-          if (state.flat[i].record.id === state.selectedId) {
-            var needed = state.flat.length - i;
-            if (needed > state.limit) state.limit = Math.min(needed, state.flat.length);
-            return;
-          }
+      /**
+       * Whether the record the inspector is showing still belongs to the table.
+       *
+       * It used to ask `state.flat` — the whole session, unfiltered — so a record stayed selected
+       * after every filter had already removed it: the ledger read 已显示 2 条, the inspector still
+       * showed the row the reader had picked, and no row anywhere carried the selection mark. The
+       * list handed in here is the same one the rows are built from, so the two agree by
+       * construction instead of by convention.
+       *
+       * It runs from renderLedger(), which is the one exit every path that changes what the table
+       * shows goes through: the filters that call render() and the ones that call renderLedger()
+       * directly.
+       *
+       * The list is the *windowed* rows, not the filtered ones, and this is where the order
+       * finally settled. It used to be judged before the slice and used to raise `state.limit` to
+       * reach a selection sitting below the window — see docs/LAYERS.md D13 for the two things
+       * that were wrong with that. It writes one field, `state.selectedId`, and nothing else: the
+       * window belongs to the window controls, and a judgement that also moves it is a second
+       * writer of `state.limit`.
+       *
+       * @param {Array<{record: any}>} entries the rows about to be built from
+       * @returns {boolean} true when it dropped the selection — the caller has to redraw the panel,
+       *   because nine of the paths that reach here never redraw it themselves
+       */
+      function revealSelection(entries) {
+        if (!state.selectedId) return false;
+        for (var i = 0; i < entries.length; i += 1) {
+          if (entries[i].record.id === state.selectedId) return false;
         }
         state.selectedId = null;
+        return true;
       }
 
+      /**
+       * The selected record, or null.
+       *
+       * This looks the id up in `state.flat` on purpose, and it is not where the selection is
+       * judged: `flat` is the unfiltered session, and treating it as "what the reader can see" is
+       * the bug this file's revealSelection() exists to prevent. By the time anything calls this,
+       * `state.selectedId` has already survived the filter that produced the rows on screen, so a
+       * plain lookup is correct — and staying a lookup keeps the five readers of it (the inspector,
+       * copy, hand-off, the hand-off button) from each re-deciding the question for themselves.
+       *
+       * @returns {{record: any}|null}
+       */
       function selectedRecord() {
         if (!state.selectedId) return null;
         for (var i = 0; i < state.flat.length; i += 1) {
@@ -4677,17 +4899,25 @@ <h2 class="section-title" id="inspector-heading">检视</h2>
        * but nothing changed" happened.
        */
       function spanPassesFilter(record, hasQuery) {
+        // The strip is handed a bare record, so the owning turn comes back out of turnById
+        // instead of off the flat entry the ledger gets — the same question, the same table,
+        // one lookup apart.
+        var owner = record ? turnById.get(record.turnId) : null;
+        // 异常 mode replaces the filter outright, strip included. Branching first is what makes
+        // this agree with visibleEntries() step for step: the strip must not draw a span for a
+        // record the ledger is not going to render, which is the "filtered but nothing changed"
+        // this function exists to prevent. Running the kind, query and range tests first and
+        // the anomaly test last — the order this used to be in — drew spans for records the
+        // list had stopped filtering on the moment a rule was ticked.
+        if (state.anomalyRules.length > 0) {
+          return passesAnomaly(record, { turn: owner || null, liveTurn: liveTurn() }, state.anomalyRules);
+        }
         if (!hasKind(record, state.kinds)) return false;
         if (hasQuery && !matchesQuery(record, state.query)) return false;
         // The range is a filter here too. Leaving it out made the overview draw spans for
         // records the list refused to render — the same "filtered but nothing changed" this
         // function exists to prevent.
         if (!inTimeRange(record)) return false;
-        // 异常 belongs here for the same reason. The strip is handed a bare record, so the
-        // owning turn comes back out of turnById instead of off the flat entry the ledger
-        // gets — the same question, the same table, one lookup apart.
-        var owner = record ? turnById.get(record.turnId) : null;
-        if (!passesAnomaly(record, { turn: owner || null, liveTurn: liveTurn() }, state.anomalyRules)) return false;
         return true;
       }
 
@@ -4834,6 +5064,78 @@ <h2 class="section-title" id="inspector-heading">检视</h2>
         return state.limit;
       }
 
+      /* ---------------- batched row build ---------------- */
+
+      /**
+       * Turn groups built per frame once a window is too large for one.
+       *
+       * Measured, not chosen. On this session at 18,924 rows across 150 turns, 25 groups is
+       * ~3,150 rows and ~145 ms of row construction — the largest slice of a frame this loop can
+       * take before the page stops answering the pointer. The full picture, including the
+       * content-visibility alternative that was measured and rejected, is in docs/LAYERS.md D12.
+       */
+      var LEDGER_BATCH_GROUPS = 25;
+
+      /**
+       * Bumped by every renderLedger() before it touches the ledger.
+       *
+       * A batch in flight carries the token it started with and stops the moment that no longer
+       * matches, so a new exit never has to hunt down and abort a callback: there is exactly one
+       * thing to check and it is this number. Without it, the ten writers of "what the table
+       * shows" would have to interleave into one ledger and the reader would see two tables
+       * interleaved in the order their row loops happened to finish.
+       */
+      var ledgerBuildToken = 0;
+
+      /** {rows, total} while a batched build runs, null the rest of the time. */
+      var ledgerProgress = null;
+
+      /**
+       * The last (shown, hiddenAbove, total) updateWindowBar() was given.
+       *
+       * Kept so that progress can be re-reported by re-running that function rather than by
+       * writing the count node directly — the window bar has one writer and a second one is the
+       * two-writers defect this exit exists to prevent (D8).
+       */
+      var ledgerWindow = null;
+
+      /** A poll tick that arrived while the ledger was still being built. */
+      var pollDeferred = false;
+
+      /** Whether a batched build is running. One tick every 2.5 s asks this before it redraws. */
+      function ledgerBuilding() {
+        return ledgerProgress !== null;
+      }
+
+      /**
+       * Report how far a batched build has got, or that it is over.
+       *
+       * @param {number|null} rows rows built so far, or null when the build has finished
+       * @param {number} [total] the rows the window will hold when it finishes
+       */
+      function setLedgerProgress(rows, total) {
+        ledgerProgress = rows === null ? null : { rows: rows, total: total };
+        if (ledgerWindow) {
+          updateWindowBar(ledgerWindow.shown, ledgerWindow.hiddenAbove, ledgerWindow.total);
+        }
+      }
+
+      /**
+       * The one poll tick that was held back while the ledger was being built.
+       *
+       * An 全部 window over 18,924 rows takes about 4 s to lay out — longer than the poll interval
+       * — so admitting every tick would restart the build before it ever reached the end and the
+       * reader would watch the count reset forever. Instead the tick is remembered and this runs
+       * once the build finishes, which brings the session up to date without making the reader
+       * pay for a second build they did not ask for.
+       */
+      function flushDeferredPoll() {
+        if (!pollDeferred) return;
+        pollDeferred = false;
+        fetchSessions();
+        fetchTrajectory(false);
+      }
+
       function renderLedger() {
         var ledger = dom.ledger;
         /* Restoring the raw pixel offset is what made the list creep out from under the
@@ -4841,14 +5143,36 @@ <h2 class="section-title" id="inspector-heading">检视</h2>
            whole slice forward: the oldest row falls off the top and everything below it
            rises by one row. Restoring scrollY keeps the pixel but not the content, so
            each poll quietly moved the page. Anchor on the topmost row that is actually
-           on screen and restore *its* position instead. */
-        var anchor = firstVisibleRow();
-        var scrollY = window.scrollY || window.pageYOffset || 0;
+           on screen and restore *its* position instead.
+
+           The intent is captured once per chain, not once per pass. clear(ledger) below
+           collapses a 716,000px document to about 1,500px and the browser clamps scrollY
+           to match (measured 715,080 → 616), so there is no scroll position at all between
+           here and the build that puts it back. A pass that is superseded before it gets
+           there has to hand the intent on rather than re-read it from the wreckage — that
+           is what dropped the reader on the first turn. See docs/LAYERS.md D14. */
+        if (!pendingAnchor) {
+          pendingAnchor = { row: firstVisibleRow(), y: window.scrollY || window.pageYOffset || 0 };
+        }
+        var anchor = pendingAnchor.row;
+        var scrollY = pendingAnchor.y;
+
+        /* Any build still in flight belongs to the table this call is about to replace.
+           Bumping the token here retires it — there is no abort call to get wrong and no
+           window in which two loops append to the same list.
+
+           It sits *above* clear(ledger) rather than further down, because the four early
+           returns between them clear the ledger as well. With the bump below them a pass
+           that returned early retired nothing, leaving the previous build alive to append
+           turn groups into a skeleton — and, since it would then reach restoreRowAnchor()
+           with an anchor from a table that no longer exists, to move the page for it. */
+        ledgerBuildToken += 1;
         clear(ledger);
 
         if (state.loading) {
           ledger.appendChild(buildSkeleton());
           dom.ledgerMeta.textContent = '加载中';
+          forgetScrollAnchor();
           return;
         }
 
@@ -4857,12 +5181,14 @@ <h2 class="section-title" id="inspector-heading">检视</h2>
             stateBlock(null, '轨迹暂时不可用', '服务恢复后会自动重试，页面结构保持不变。')
           );
           dom.ledgerMeta.textContent = '不可用';
+          forgetScrollAnchor();
           return;
         }
 
         if (!state.payload) {
           ledger.appendChild(buildSkeleton());
           dom.ledgerMeta.textContent = '加载中';
+          forgetScrollAnchor();
           return;
         }
 
@@ -4876,6 +5202,7 @@ <h2 class="section-title" id="inspector-heading">检视</h2>
           );
           dom.ledgerMeta.textContent = '共 0 条';
           applyFilterScope();
+          forgetScrollAnchor();
           return;
         }
 
@@ -4883,6 +5210,26 @@ <h2 class="section-title" id="inspector-heading">检视</h2>
         var total = state.flat.length;
         applyFilterScope();
 
+        var windowed = matched.length > state.limit ? matched.slice(matched.length - state.limit) : matched;
+        var hiddenAbove = matched.length - windowed.length;
+
+        // Both answers belong to this exit rather than to each of its callers: whether the record
+        // the inspector is showing is still in the table, and how tall the pinned strips above it
+        // are now. Nine writers reach the table without going through render(), and judging the
+        // selection here is what stops the inspector describing a row that is no longer on screen.
+        //
+        // `windowed`, not `matched`: what the reader can see is the window, not the filter result.
+        // Judged before the slice this used to raise `state.limit` to reach a selection below the
+        // window, which made the window a thing the inspector could widen — and left the promise
+        // 「已显示 200 条」 true at the moment the reader pressed 显示最新 200 条 and false a
+        // second later. See docs/LAYERS.md D13.
+        //
+        // The redraw is part of that, not a follow-up: clearing the id on its own is not enough.
+        // The search box, the type axis and the overview brush call renderLedger() and nothing
+        // else, so the panel kept showing the record that had just been dropped — no row carried
+        // the selection mark and the inspector still named one.
+        if (revealSelection(windowed)) renderInspector();
+
         if (matched.length === 0) {
           var reset = el('button', 'btn', '清除筛选');
           reset.type = 'button';
@@ -4892,12 +5239,10 @@ <h2 class="section-title" id="inspector-heading">检视</h2>
           ledger.appendChild(
             stateBlock(null, '当前筛选条件下没有命中记录', '共 ' + total + ' 条记录中没有匹配项，可以放宽类型或搜索词。', reset)
           );
+          forgetScrollAnchor();
           return;
         }
 
-        var windowed = matched.length > state.limit ? matched.slice(matched.length - state.limit) : matched;
-        var hiddenAbove = matched.length - windowed.length;
-
         updateWindowBar(windowed, hiddenAbove, total);
 
         var groups = visibleTurns(windowed);
@@ -4911,30 +5256,84 @@ <h2 class="section-title" id="inspector-heading">检视</h2>
         var lastTurn = groups.length ? groups[groups.length - 1].turn.index : null;
         dom.ledgerMeta.textContent = turnRangeLabel(firstTurn, lastTurn);
 
-        for (var i = 0; i < groups.length; i += 1) {
-          var group = groups[i];
-          var section = el('section', 'turn-group');
-          section.setAttribute('aria-label', '第 ' + (isCount(group.turn.index) ? group.turn.index : DASH) + ' 轮');
-          section.appendChild(buildTurnHead(group.turn, group.entries));
-          var list = el('ul', 'row-list');
-          // Every entry that survived the filters becomes a row. There is no second pass
-          // that hides anything, so what is on screen is exactly what was selected.
-          var rails = railStates(group.entries);
-          for (var j = 0; j < group.entries.length; j += 1) {
-            var item = el('li');
-            if (group.entries[j].record.kind === 'compaction') {
-              item.className = 'compaction-cell';
-              item.appendChild(buildCompactionBand(group.entries[j]));
-            } else {
-              item.appendChild(buildRow(group.entries[j], rails[j]));
+        /**
+         * One batch: build up to LEDGER_BATCH_GROUPS turns, then hand the frame back.
+         *
+         * Declared here rather than beside the other helpers so that the row loop — including the
+         * compaction routing, which client-check.mjs reads out of renderLedger() for exactly this
+         * reason — stays the text it has always been. What the rows *are* has not changed; only
+         * how many are built before the browser gets the thread back.
+         *
+         * Nothing here changes what the window promises to show. 「显示全部」 still means every
+         * record; it just stops meaning it inside a single unbroken second and a half.
+         */
+        var build = { token: ledgerBuildToken, at: 0, rows: 0 };
+        var buildTotal = 0;
+        for (var b = 0; b < groups.length; b += 1) buildTotal += groups[b].entries.length;
+
+        function buildStep() {
+          // A newer renderLedger() owns the ledger now. Stop without touching it: the rows half
+          // built here belong to a table that no longer exists, and the exit that replaced it has
+          // already cleared the list.
+          if (build.token !== ledgerBuildToken) return;
+          var built = 0;
+          while (build.at < groups.length && built < LEDGER_BATCH_GROUPS) {
+            var group = groups[build.at];
+            build.at += 1;
+            var section = el('section', 'turn-group');
+            section.setAttribute('aria-label', '第 ' + (isCount(group.turn.index) ? group.turn.index : DASH) + ' 轮');
+            section.appendChild(buildTurnHead(group.turn, group.entries));
+            var list = el('ul', 'row-list');
+            // Every entry that survived the filters becomes a row. There is no second pass
+            // that hides anything, so what is on screen is exactly what was selected.
+            var rails = railStates(group.entries);
+            for (var j = 0; j < group.entries.length; j += 1) {
+              var item = el('li');
+              if (group.entries[j].record.kind === 'compaction') {
+                item.className = 'compaction-cell';
+                item.appendChild(buildCompactionBand(group.entries[j]));
+              } else {
+                item.appendChild(buildRow(group.entries[j], rails[j]));
+              }
+              list.appendChild(item);
             }
-            list.appendChild(item);
+            section.appendChild(list);
+            ledger.appendChild(section);
+            build.rows += group.entries.length;
+            built += 1;
           }
-          section.appendChild(list);
-          ledger.appendChild(section);
-        }
 
-        restoreRowAnchor(anchor, scrollY);
+          if (build.at < groups.length) {
+            setLedgerProgress(build.rows, buildTotal);
+            window.requestAnimationFrame(buildStep);
+            return;
+          }
+
+          setLedgerProgress(null);
+          restoreRowAnchor(anchor, scrollY);
+          // Before the measurement, not after it. flushDeferredPoll() only starts fetches, so
+          // nothing can re-enter the ledger from inside it today — but the exit that does this
+          // measuring has to stay the last word, and a trailing statement is the one place where
+          // a future synchronous call would quietly measure an empty page.
+          flushDeferredPoll();
+          // Measured here rather than at the end of render(): this is the one exit every path that
+          // changes what the table shows goes through — the filters that call render() and the nine
+          // that call renderLedger() directly. A filter that grows the band therefore cannot leave
+          // the offsets above describing the page as it was before the reader touched anything.
+          // syncAnomalyMode(), which writes the 异常 note that gives the band its third line, runs
+          // before this point inside render(), so the height is already final here.
+          // The early returns above deliberately do not measure: none of them can change the band,
+          // and emptying the ledger mid-flight is not a reason to move a pinned strip.
+          syncStickyOffsets();
+        }
+
+        // Windows of a few groups never reach the yield: the while loop inside buildStep consumes
+        // all of them and falls straight through, so the default 200-row table is built exactly as
+        // it always was, in one pass, with no progress written and no frame spent. Seeding the
+        // progress only when there is more than one batch is what keeps that true — otherwise the
+        // common path paid for a 「正在显示 0 / 200 条」 that no reader ever saw.
+        if (groups.length > LEDGER_BATCH_GROUPS) setLedgerProgress(0, buildTotal);
+        buildStep();
       }
 
       /**
@@ -4964,12 +5363,26 @@ <h2 class="section-title" id="inspector-heading">检视</h2>
           clear(wrap);
           wrap.appendChild(parts.actions);
         }
+        // Kept so a mid-build progress tick can be re-reported by re-running this function rather
+        // than by writing the count node from somewhere else. See ledgerWindow's comment.
+        ledgerWindow = { shown: shown, hiddenAbove: hiddenAbove, total: total };
 
         applyAxisButton(parts.axis);
         applyWindowMode(parts, hiddenAbove);
         // The session's total turn count lives here, beside the record counts it explains —
         // not in the panel title, which describes only the rows on screen.
         var sessionTurns = state.payload && state.payload.stats ? state.payload.stats.turns : null;
+        if (ledgerProgress) {
+          // Mid-build the count reports what is actually on screen, not what the window will hold.
+          // 「已显示 18,924 条」 above three thousand rows that exist is the page promising a number
+          // it has not reached yet, which is the same defect as the one this whole exit exists to
+          // prevent — one surface describing a table that is not there.
+          parts.count.textContent =
+            (isCount(sessionTurns) ? '全场 ' + formatInt(sessionTurns) + ' 轮 · ' : '') +
+            '共 ' + formatInt(total) + ' 条 · 正在显示 ' + formatInt(ledgerProgress.rows) +
+            ' / ' + formatInt(ledgerProgress.total) + ' 条';
+          return;
+        }
         parts.count.textContent =
           (isCount(sessionTurns) ? '全场 ' + formatInt(sessionTurns) + ' 轮 · ' : '') +
           '共 ' + formatInt(total) + ' 条 · 已显示 ' + formatInt(shown.length) + ' 条' +
@@ -5108,6 +5521,33 @@ <h2 class="section-title" id="inspector-heading">检视</h2>
         return null;
       }
 
+      /**
+       * The reader's scroll intent, carried across builds.
+       *
+       * It has to be carried, because there is no moment where the position survives on its
+       * own. renderLedger() clears the ledger — which takes the document from 716,000px to
+       * about 1,500px, and the browser clamps scrollY to match — and the position only comes
+       * back at the end of the build, from restoreRowAnchor(). So the first pass of a chain
+       * writes down where the reader was, every pass after it re-uses that, and the pass that
+       * finishes consumes it. Anything else and each pass reads an anchor out of the wreckage:
+       * measured, a click on any row that landed while a poll build was in flight left the page
+       * anchored on the first turn for good, because the superseded build stopped at the token
+       * check and never reached the restore. See docs/LAYERS.md D14.
+       *
+       * It is dropped, not restored, by the paths that end a chain with no table to anchor to —
+       * loading, error, no payload, no sessions, no matches. Carrying an intent across one of
+       * those would apply it to a different session or a different filter than the one it was
+       * measured against.
+       *
+       * @type {{row: {id: string, top: number} | null, y: number} | null}
+       */
+      var pendingAnchor = null;
+
+      /** End a scroll-intent chain without restoring it. One writer, so one place. */
+      function forgetScrollAnchor() {
+        pendingAnchor = null;
+      }
+
       /**
        * Put the anchored row back where it was.
        *
@@ -5115,8 +5555,13 @@ <h2 class="section-title" id="inspector-heading">检视</h2>
        * can arrive to push it out of the window entirely. Then there is nothing to hold on
        * to and the old pixel offset is the best answer available, so fall back to it
        * rather than jumping to the top.
+       *
+       * Consuming the intent belongs here and not at the call site: this is the one place a
+       * chain ends, and a chain that ended without being consumed would hand its anchor to
+       * whatever came next.
        */
       function restoreRowAnchor(anchor, fallbackY) {
+        forgetScrollAnchor();
         if (anchor) {
           var after = anchorOffset(anchor.id);
           if (after !== null) {
@@ -5175,6 +5620,14 @@ <h2 class="section-title" id="inspector-heading">检视</h2>
        */
       function applyFilterScope() {
         if (!dom.kpiScope) return;
+        if (state.anomalyRules.length > 0) {
+          // This line exists to name the filters the KPI does not follow. In 异常 mode there are
+          // none of them in force, so the usual wording would be pointing at two controls that
+          // are switched off and filtering nothing.
+          dom.kpiScope.textContent = '整场会话 · 当前只看异常记录';
+          dom.kpiScope.hidden = false;
+          return;
+        }
         if (hasTimeRange()) {
           var stats = kpiStats();
           var scope = '已按区间 ' + timeRangeLabel() + ' 统计';
@@ -5278,11 +5731,14 @@ <h2 class="section-title" id="inspector-heading">检视</h2>
         state.kinds = KIND_ORDER.slice();
         state.query = '';
         state.anomalyRules = [];
+        state.anomalyLast = null;
+        state.multiAnomaly = false;
         clearTimeRange();
         resetWindowMode();
         if (dom.searchInput) dom.searchInput.value = '';
+        if (dom.anomalyMulti) dom.anomalyMulti.checked = false;
         syncKindButtons();
-        syncAnomalyButtons();
+        syncAnomalyButtons(anomalyCounts());
         render();
       }
 
@@ -5699,8 +6155,9 @@ <h2 class="section-title" id="inspector-heading">检视</h2>
         var attempt = requestRaw(index).then(function (result) {
           delete rawPending[key];
           if (result.ok && result.body && Object.prototype.hasOwnProperty.call(result.body, 'raw')) {
-            rawCache[key] = result.body.raw;
-            return result.body.raw;
+            var entry = { raw: result.body.raw, omitted: result.body.omitted === true };
+            rawCache[key] = entry;
+            return entry;
           }
           var code = result.body && typeof result.body.error === 'string' ? result.body.error : '';
           var err = new Error(code || 'raw_unavailable');
@@ -5720,15 +6177,19 @@ <h2 class="section-title" id="inspector-heading">检视</h2>
       /**
        * What a reader should show for a record's message.
        *
-       * A record whose message was too large to carry resolves to null, which callers read
-       * as "there is no message body" and say so. Everything else resolves to the message or
-       * rejects: silently substituting the normalized row would put different content under
-       * a label that promises 原文, with nothing on the page to say it had happened.
+       * Resolves to `{ raw, omitted }`. Whether the message was too large to carry used to be
+       * a field on the record, checked here to short-circuit the fetch; it now travels with
+       * the answer instead, because deciding it meant serializing every message in the session
+       * on every poll to measure them against a cap — see docs/LAYERS.md D11.
+       *
+       * `omitted` and `raw === null` are the same state stated two ways, and a caller may test
+       * either. Everything else resolves to the message or rejects: silently substituting the
+       * normalized row would put different content under a label that promises 原文, with
+       * nothing on the page to say it had happened.
        *
        * @param {Record<string, any>} record
        */
       function rawSourceFor(record) {
-        if (record && record.rawOmitted) return Promise.resolve(null);
         return fetchRaw(record);
       }
 
@@ -5737,26 +6198,30 @@ <h2 class="section-title" id="inspector-heading">检视</h2>
         wrap.style.display = 'flex';
         wrap.style.flexDirection = 'column';
         wrap.style.gap = '8px';
-        if (record.rawOmitted) {
-          wrap.appendChild(el('p', 'note note-danger', '原文过大，已省略。可以从参数与结果页查看已保留的部分。'));
-        }
         if (record.textTruncated) {
           wrap.appendChild(el('p', 'note', '正文已截断：仅保留前段内容。'));
         }
         var pre = el('pre', 'pre');
         pre.setAttribute('tabindex', '0');
         wrap.appendChild(pre);
-        if (record.rawOmitted) {
-          pre.textContent = DASH;
-        } else {
-          pre.textContent = '正在读取原文…';
-          rawSourceFor(record).then(function (source) {
-            if (source === null || source === undefined) pre.textContent = DASH;
-            else pre.innerHTML = jsonColorize(source);
-          }, function () {
-            pre.textContent = '原文读取失败，请重试。';
-          });
-        }
+        // The two states the reader sees are unchanged; they now arrive with the answer rather
+        // than ahead of it, because deciding which one applied was what made the bulk response
+        // serialize every message in the session — see docs/LAYERS.md D11.
+        pre.textContent = '正在读取原文…';
+        rawSourceFor(record).then(function (fetched) {
+          if (fetched.omitted === true) {
+            wrap.insertBefore(
+              el('p', 'note note-danger', '原文过大，已省略。可以从参数与结果页查看已保留的部分。'),
+              pre
+            );
+            pre.textContent = DASH;
+            return;
+          }
+          if (fetched.raw === null || fetched.raw === undefined) pre.textContent = DASH;
+          else pre.innerHTML = jsonColorize(fetched.raw);
+        }, function () {
+          pre.textContent = '原文读取失败，请重试。';
+        });
         return wrap;
       }
 
@@ -5797,8 +6262,9 @@ <h2 class="section-title" id="inspector-heading">检视</h2>
         var done = function (ok) {
           inspectorSay(ok ? '已复制该记录的 JSON。' : '复制失败，请手动选择文本后复制。');
         };
-        rawSourceFor(record).then(function (source) {
-          var text = source === null || source === undefined ? stringify(record) : stringify(source);
+        rawSourceFor(record).then(function (fetched) {
+          var noRaw = fetched.omitted === true || fetched.raw === null || fetched.raw === undefined;
+          var text = noRaw ? stringify(record) : stringify(fetched.raw);
           if (navigator.clipboard && typeof navigator.clipboard.writeText === 'function') {
             navigator.clipboard.writeText(text).then(
               function () {
@@ -5874,14 +6340,18 @@ <h2 class="section-title" id="inspector-heading">检视</h2>
         rawSourceFor(record).then(function (fetched) {
           // A message too large to carry has no raw; the normalized record is then the most
           // there is, which is what this sent before raw became a separate fetch.
-          var rawSource = fetched === null || fetched === undefined ? stripVolatile(record) : fetched;
+          var omitted = fetched.omitted === true;
+          var rawSource = omitted || fetched.raw === null || fetched.raw === undefined
+            ? stripVolatile(record)
+            : fetched.raw;
           var raw = truncateJson(rawSource, HANDOFF_RAW_LIMIT);
           var text = buildHandoffMarkdown(
             state.payload ? state.payload.session : null,
             entry.turn,
             record,
             raw.text,
-            raw.truncated
+            raw.truncated,
+            omitted
           );
           inspectorSay('已发出请求，等待你在弹出的确认框中确认…');
           var result = message.append(text);
@@ -5909,6 +6379,44 @@ <h2 class="section-title" id="inspector-heading">检视</h2>
 
       /* ---------------- top-level render ---------------- */
 
+      /**
+       * Publishes the heights of the pinned bands so everything below them can be positioned from
+       * a measurement instead of a number written down once.
+       *
+       * The alternative was three constants — 32 for the type row, 51 for the overview strip, 45
+       * for the window bar — and they were already wrong the moment the 异常 row joined the band:
+       * that row wraps at narrow widths and grows a line when its note appears, so no constant can
+       * stay right. This runs at the end of `render()`, after the note has been written and the
+       * buttons re-counted, which is the only moment the band's height is final. `offsetHeight`
+       * rather than `getBoundingClientRect().height`, so a fractional device-pixel ratio cannot
+       * make the bands overlap by a third of a pixel per poll.
+       */
+      function syncStickyOffsets() {
+        if (!dom.filterSticky || !dom.overview || !dom.windowBar) return;
+        var root = document.documentElement.style;
+        var band = dom.filterSticky.offsetHeight;
+        var overview = dom.overview.offsetHeight;
+        root.setProperty('--sticky-band-h', band + 'px');
+        root.setProperty('--sticky-overview-h', overview + 'px');
+        root.setProperty('--sticky-window-h', dom.windowBar.offsetHeight + 'px');
+      }
+
+      var stickyFrame = null;
+
+      /**
+       * One measurement per frame, however many resize events arrive.
+       *
+       * Every call reads three offsetHeights, which forces layout; a window drag fires `resize`
+       * continuously, and measuring on each one turns a drag into a layout thrash.
+       */
+      function scheduleStickyOffsets() {
+        if (stickyFrame !== null) return;
+        stickyFrame = window.requestAnimationFrame(function () {
+          stickyFrame = null;
+          syncStickyOffsets();
+        });
+      }
+
       function render() {
         renderBars();
         renderGeneration();
@@ -5928,7 +6436,14 @@ <h2 class="section-title" id="inspector-heading">检视</h2>
         syncRangeBounds();
         // The 异常 buttons carry a count that has to follow the session and every other filter,
         // exactly like the refresh button's decision to appear.
-        syncAnomalyButtons();
+        // Which of the two filter systems is in force is decided here, before anything reads a
+        // count or draws a span, so the strip, the buttons and the ledger cannot each answer a
+        // different question. One walk feeds both: `render()` hands the same object to the note
+        // and to the buttons, so the number in the prose and the number on a button are two
+        // readings of one snapshot rather than two walks of a session that is still growing.
+        var anomaly = anomalyCounts();
+        syncAnomalyMode(anomaly);
+        syncAnomalyButtons(anomaly);
         renderOverview();
         renderLedger();
         renderInspector();
@@ -6062,6 +6577,18 @@ <h2 class="section-title" id="inspector-heading">检视</h2>
       function buildAnomalyButtons() {
         if (!dom.anomalyControls) return;
         dom.anomalyControls.textContent = '';
+
+        // First, and not as one choice among the others: this is the state the page opens in
+        // and the only way back out of them. Built here rather than written into the markup so
+        // it cannot drift out of step with the buttons it has to reverse.
+        var none = el('button', 'btn btn-quiet anomaly-btn anomaly-btn-none');
+        none.type = 'button';
+        none.id = 'anomaly-none';
+        none.setAttribute('data-anomaly-none', '');
+        none.setAttribute('aria-pressed', 'true');
+        none.appendChild(el('span', 'anomaly-label', ANOMALY_NONE_LABEL));
+        dom.anomalyControls.appendChild(none);
+
         for (var i = 0; i < ANOMALY_RULES.length; i += 1) {
           var rule = ANOMALY_RULES[i];
           var button = el('button', 'btn btn-quiet anomaly-btn');
@@ -6073,6 +6600,8 @@ <h2 class="section-title" id="inspector-heading">检视</h2>
           button.appendChild(el('span', 'anomaly-count', '0'));
           dom.anomalyControls.appendChild(button);
         }
+
+        // Last, so the row reads left to right as: everything, then each kind, then any kind.
         var all = el('button', 'btn btn-quiet anomaly-btn');
         all.type = 'button';
         all.id = 'anomaly-all';
@@ -6080,54 +6609,214 @@ <h2 class="section-title" id="inspector-heading">检视</h2>
         all.setAttribute('aria-pressed', 'false');
         all.appendChild(el('span', 'anomaly-label', '全部异常'));
         all.appendChild(el('span', 'anomaly-count', '0'));
-        dom.anomalyControls.insertBefore(all, dom.anomalyControls.firstChild);
+        dom.anomalyControls.appendChild(all);
       }
 
       /**
        * Counts and pressed state for the 异常 buttons. Both are read from the same pass the
        * ledger filters through, so a number on a button and the rows below it are the same
        * statement about the same records.
+       *
+       * The counts are passed in rather than walked again here: `render()` takes one snapshot and
+       * hands the same object to this and to `syncAnomalyMode()`. That is not only cheaper — two
+       * walks over a live session can disagree, because the session grows between them, and a
+       * button count that did not come from the same read as the note beside it is the exact
+       * mismatch this row was built to end.
        */
-      function syncAnomalyButtons() {
+      function syncAnomalyButtons(counts) {
         if (!dom.anomalyControls) return;
-        var counts = anomalyCounts();
         var buttons = dom.anomalyControls.querySelectorAll('.anomaly-btn');
         for (var i = 0; i < buttons.length; i += 1) {
           var button = buttons[i];
+          var isNone = button.hasAttribute('data-anomaly-none');
           var isAll = button.hasAttribute('data-anomaly-all');
           var id = button.getAttribute('data-anomaly-rule');
-          var n = isAll ? counts.any : (counts.byRule[id] || 0);
-          var on = isAll
-            ? state.anomalyRules.length === ANOMALY_RULES.length
-            : state.anomalyRules.indexOf(id) >= 0;
-          var noun = isAll ? '全部异常' : anomalyRuleLabel(id);
-          var label = noun + ' ' + formatInt(n) + ' 条 · ' + (on ? '当前只看这些 · 点击取消' : '当前未启用 · 点击只看这些');
-          button.querySelector('.anomaly-count').textContent = formatInt(n);
+          var on;
+          var n;
+          var noun;
+          var unit;
+          var label;
+          if (isNone) {
+            // 重置 carries no number. The other buttons answer "how much would this keep", and
+            // that question is meaningless for a control that keeps whatever the row above says
+            // — the row above's own count is already on the window bar.
+            //
+            // 多选 counts towards "is this row at its default" because it is: the axis opens in
+            // 单选, and 多选 changes what every other button on this row does when pressed. A row
+            // with 多选 on is not the state 重置 describes, so it must not claim to be it — and
+            // 重置 is the only control that turns 多选 off, so a reader told the row is already at
+            // its default would never press the one button that would put it back.
+            on = state.anomalyRules.length === 0 && !state.multiAnomaly;
+            noun = ANOMALY_NONE_LABEL;
+            label = noun + ' · ' + (on ? '已是默认状态 · 表格按上一行的条件筛选'
+              : '点击回到默认状态 · 表格按上一行的条件筛选');
+            n = null;
+          } else if (isAll) {
+            on = state.anomalyRules.length === ANOMALY_RULES.length;
+            n = counts.any;
+            noun = '全部异常';
+            unit = '条';
+            label = ruleLabelFor(noun, n, unit, on);
+          } else {
+            on = state.anomalyRules.indexOf(id) >= 0;
+            n = counts.byRule[id] || 0;
+            noun = anomalyRuleLabel(id);
+            unit = counts.unit[id] || '条';
+            label = ruleLabelFor(noun, n, unit, on);
+          }
+          var cell = button.querySelector('.anomaly-count');
+          if (cell) cell.textContent = formatInt(n) + ' ' + unit;
           button.setAttribute('aria-pressed', on ? 'true' : 'false');
           button.setAttribute('aria-label', label);
           button.setAttribute('title', label);
-          button.classList.toggle('is-empty', n === 0);
+          button.classList.toggle('is-empty', n !== null && n === 0);
         }
       }
 
+      /**
+       * One rule's button name, built from the same two facts the number is.
+       *
+       * The unit is printed next to the number rather than assumed: 条 for a rule about a
+       * record, 轮 for a rule about a turn. A bare number cannot carry that difference, and a
+       * reader who cannot tell them apart is exactly who reads 1,244 条 as 1,244 unanswered
+       * replies when the session was broken thirteen times.
+       */
+      function ruleLabelFor(noun, n, unit, on) {
+        return noun + ' ' + formatInt(n) + ' ' + unit + ' · '
+          + (on ? '当前只看这些 · 点击取消' : '当前未启用 · 点击只看这些');
+      }
+
       function onAnomalyToggle(ruleId) {
         var next;
         if (ruleId === null) {
+          // 全部异常: every rule, or none of them.
           next = state.anomalyRules.length === ANOMALY_RULES.length ? [] : ANOMALY_RULE_IDS.slice();
-        } else {
+          state.anomalyLast = next.length ? null : state.anomalyLast;
+        } else if (state.multiAnomaly) {
+          // Union mode. A click adds the rule, or takes it back off — unless it was the last
+          // one standing, because a filter that refuses to turn off is a filter nobody can leave.
           next = state.anomalyRules.filter(function (id) {
             return id !== ruleId;
           });
           if (next.length === state.anomalyRules.length) next = next.concat([ruleId]);
-          next.sort(function (a, b) {
-            return ANOMALY_RULE_IDS.indexOf(a) - ANOMALY_RULE_IDS.indexOf(b);
-          });
+          state.anomalyLast = ruleId;
+        } else if (state.anomalyRules.length === 1 && state.anomalyRules[0] === ruleId) {
+          next = [];
+          state.anomalyLast = null;
+        } else {
+          // Single mode is a replacement, not an addition: you asked for this rule, and this is
+          // what you get. Anything already ticked was a previous question, not a standing one.
+          next = [ruleId];
+          state.anomalyLast = ruleId;
         }
+        next.sort(function (a, b) {
+          return ANOMALY_RULE_IDS.indexOf(a) - ANOMALY_RULE_IDS.indexOf(b);
+        });
         state.anomalyRules = next;
+        if (next.length > 0) resetBaseFilters();
+        resetWindowMode();
+        render();
+      }
+
+      /**
+       * 多选 on or off.
+       *
+       * Turning it off has to leave exactly one rule standing, because the buttons are about to
+       * stop being able to say more than one at a time and a selection of three that the buttons
+       * now claim to be one is the mismatch this whole axis was moved to fix. The survivor is
+       * the rule the reader ticked last — the one they were looking at a moment ago — and not
+       * the first in table order, which would be an answer to a question they did not ask.
+       */
+      function onAnomalyMultiChange(checked) {
+        state.multiAnomaly = checked;
+        if (!checked && state.anomalyRules.length > 1) {
+          var last = state.anomalyLast;
+          state.anomalyRules = [last && state.anomalyRules.indexOf(last) >= 0
+            ? last
+            : state.anomalyRules[0]];
+        }
+        if (state.anomalyRules.length === 0) state.anomalyLast = null;
+        render();
+      }
+
+      /**
+       * Back to the default: no anomaly rule, and the table filtered by the row above.
+       *
+       * Deliberately not a toggle. 重置 is the state the page opens in, so a toggle would mean
+       * the second click on an already-active button silently filtered the list — the reader
+       * pressed "put it back" and got less of it. And deliberately it does not restore what the
+       * row above used to hold either: it is a reset, so the row above is already at its default
+       * and the table follows from there.
+       */
+      function onAnomalyReset() {
+        if (state.anomalyRules.length === 0 && !state.multiAnomaly) return;
+        state.anomalyRules = [];
+        state.anomalyLast = null;
+        // 多选 is back to its default too. 重置 means the default state, and 单选 is what this
+        // axis opens in — leaving a mode switch on is not a filter the reader would think to
+        // clear by pressing the button they just pressed.
+        state.multiAnomaly = false;
+        if (dom.anomalyMulti) dom.anomalyMulti.checked = false;
         resetWindowMode();
         render();
       }
 
+      /**
+       * The row above, put back to its default: every kind, no query, no range, no brush.
+       *
+       * Written once and called from both directions into anomaly mode, because the controls and
+       * the state have to move together — setting `state.kinds` without `syncKindButtons()` is
+       * how the axis ends up showing 「用户」 while the table is not filtered by it.
+       */
+      function resetBaseFilters() {
+        state.kinds = KIND_ORDER.slice();
+        state.query = '';
+        state.overviewSelection = null;
+        clearTimeRange();
+        if (dom.searchInput) dom.searchInput.value = '';
+        syncKindButtons();
+      }
+
+      /**
+       * Keeps the page honest about which filter system is in force.
+       *
+       * The controls for the inactive one are made inert as well as dimmed, because a control
+       * that accepts a click and then changes nothing on screen is the defect that put this
+       * axis where it was — reintroducing it one line away would be worse than the original.
+       * 会话 / 上下文代 / 刷新 carry no marker: they choose which session is on screen, not which
+       * records of it, so they have to keep working while an anomaly rule is ticked.
+       */
+      function syncAnomalyMode(counts) {
+        var on = state.anomalyRules.length > 0;
+        document.body.setAttribute('data-anomaly-mode', on ? 'on' : 'off');
+        var scopes = document.querySelectorAll('[data-filter-scope]');
+        for (var i = 0; i < scopes.length; i += 1) scopes[i].inert = on;
+        // The checkbox is state too, and a poll re-renders from state. Writing it here means
+        // turning 多选 off by hand cannot leave it drawn on while the buttons are single again.
+        if (dom.anomalyMulti) dom.anomalyMulti.checked = state.multiAnomaly;
+        if (!dom.anomalyNote) return;
+        dom.anomalyNote.hidden = !on;
+        if (on) {
+          // Two rules on means the per-rule numbers do not add up to the list — one record can
+          // trip both — so the reader needs the total for *their* selection. It used to be
+          // answered with 合计见「全部异常」, which is the union of all four rules: for a stack of
+          // two it pointed at a number 1,300 rows larger than what was on screen. The total is
+          // counted instead, and it is the length of the ledger under these buttons.
+          //
+          // 叠加 is 多选's word. In 单选 the only way more than one rule is ever on is 全部异常,
+          // which is not the reader stacking anything, so it is described as all of them being in
+          // force rather than as a stack they did not build.
+          var n = state.anomalyRules.length;
+          var stacked = n > 1
+            ? (state.multiAnomaly
+              ? ' · 已叠加 ' + formatInt(n) + ' 条规则 · 合计 ' + formatInt(counts.selected) + ' 条'
+              : ' · 全部 ' + formatInt(n) + ' 条规则同时生效 · 合计 ' + formatInt(counts.selected) + ' 条')
+            : '';
+          dom.anomalyNote.textContent = '异常筛选已开启 · 类型、搜索、时间区间与总览已回到默认且不参与 · 点「'
+            + ANOMALY_NONE_LABEL + '」回到默认筛选' + stacked;
+        }
+      }
+
       function syncKindButtons() {
         var buttons = dom.kindControls.querySelectorAll('.tbtn-action');
         for (var i = 0; i < buttons.length; i += 1) {
@@ -6180,6 +6869,15 @@ <h2 class="section-title" id="inspector-heading">检视</h2>
         stopPolling();
         pollTimer = window.setInterval(function () {
           if (document.hidden) return;
+          // A table that is still being built is not a table this tick may replace. An 全部 window
+          // over 18,924 rows takes about 4 s to lay out — longer than this interval — so letting
+          // every tick through would restart the build before it reached the end, and the reader
+          // would watch the count reset from 3,000 back to 0 forever. The tick is remembered
+          // instead, and flushDeferredPoll() runs it once the build finishes.
+          if (ledgerBuilding()) {
+            pollDeferred = true;
+            return;
+          }
           fetchSessions();
           fetchTrajectory(false);
         }, POLL_INTERVAL);
@@ -6193,6 +6891,12 @@ <h2 class="section-title" id="inspector-heading">检视</h2>
       }
 
       function wire() {
+        // Nothing re-measured the band when the window changed shape. On a session whose payload has
+        // stopped growing every poll is a 304 and render() never runs, so a resize that wrapped the
+        // type row or the 异常 row left the pinned strips sitting at the old width — until new
+        // records happened to arrive, which on a finished session is never.
+        window.addEventListener('resize', scheduleStickyOffsets);
+
         dom.followBtn.addEventListener('click', function () {
           setFollow(!state.followLatest);
         });
@@ -6288,14 +6992,26 @@ <h2 class="section-title" id="inspector-heading">检视</h2>
         var anomalyButtons = dom.anomalyControls.querySelectorAll('.anomaly-btn');
         for (var a = 0; a < anomalyButtons.length; a += 1) {
           anomalyButtons[a].addEventListener('click', function () {
-            // Read the pressed state at click time rather than closing over it: the buttons
+            // Read which button this is at click time rather than closing over it: the buttons
             // are re-synced on every poll, and a captured flag goes stale between the render
             // and the click.
+            if (this.hasAttribute('data-anomaly-none')) {
+              onAnomalyReset();
+              return;
+            }
             var id = this.getAttribute('data-anomaly-rule');
             onAnomalyToggle(id || null);
           });
         }
 
+        // `change`, not `click`: a checkbox operated by keyboard fires change and nothing else,
+        // and this control has to work the same way for both.
+        if (dom.anomalyMulti) {
+          dom.anomalyMulti.addEventListener('change', function () {
+            onAnomalyMultiChange(this.checked);
+          });
+        }
+
         var kindButtons = dom.kindControls.querySelectorAll('.tbtn-action');
         for (var j = 0; j < kindButtons.length; j += 1) {
           if (kindButtons[j].id === 'kind-all') continue;
diff --git a/plugins/avatasia/mmc-trajectory/miniapp/node/server.mjs b/plugins/avatasia/mmc-trajectory/miniapp/node/server.mjs
index 78d7bd1..9d54365 100644
--- a/plugins/avatasia/mmc-trajectory/miniapp/node/server.mjs
+++ b/plugins/avatasia/mmc-trajectory/miniapp/node/server.mjs
@@ -38,6 +38,33 @@ const LIST_CACHE_TTL_MS = 1000;
 const SESSION_CACHE_TTL_MS = 5000;
 const SESSION_CACHE_ENTRIES = 80;
 const TRAJECTORY_CACHE_ENTRIES = 4;
+/**
+ * Upper bound on the parsed generation rows kept resident, in bytes.
+ *
+ * The whole-session cache above stores serialized bodies; this one stores parsed object
+ * graphs, which cost several times their source text. Measured on this machine: JSON.parse
+ * retains 1.36x the text of the emitted payload, and that is a floor — the payload has
+ * already had its message bodies stripped by splitRawRecords, so the rows graph is larger.
+ * A 95 MB lineage lands somewhere in 130-290 MB.
+ *
+ * The trade is deliberate: it converts roughly 350 MB of allocation every 2.5 s into one
+ * resident cost. See docs/LAYERS.md D10.
+ */
+const PARSED_ROWS_CACHE_BYTES = 256 * 1024 * 1024;
+/**
+ * Heap charged to one cache entry per source byte read. V8 cannot report an object graph's
+ * size, so a byte budget needs a proxy.
+ *
+ * Measured on this machine's own lineage: 95.3 MB of messages.jsonl retained 116 MB of heap
+ * after two forced collections, i.e. 1.22x the source. 2x leaves headroom over that while
+ * still erring on the side of over-counting, because a proxy that under-counts would let the
+ * cache grow past its own budget without noticing.
+ *
+ * It was 3x before, and that was wrong in the direction that matters: 95.3 MB x 3 charged
+ * 286 MB against a 256 MB budget, so the LRU evicted entries it had room for in reality and
+ * re-parsed them on the next poll. The budget is only as good as this number.
+ */
+const PARSED_ROWS_HEAP_PER_SOURCE_BYTE = 2;
 const SESSION_STORE_TOKEN = '<session-store>';
 const JSON_HEADERS = { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store' };
 const ROLE_PATTERN = /"role"\s*:\s*"(user|assistant|toolResult|custom)"/g;
@@ -788,34 +815,42 @@ export function toolCallSummary(name, args) {
 }
 
 /**
- * Moves `raw` off every record into an index-keyed map.
+ * Moves the raw-message locator off every record into an index-keyed map.
+ *
+ * Two things used to happen here and only one of them was load-bearing.
  *
- * On a real session the untouched message is about two thirds of the payload, and the page
- * reads it for exactly one record at a time: the inspector's raw tab, one clipboard copy,
- * one handoff. Carrying it on every row pays that weight on every poll and buys nothing
- * until a row is actually opened, so it leaves the bulk response and is fetched per record
- * instead.
+ * The message itself was carried on every row and taken off again by this function. That is
+ * what kept the bulk response small, and it stays true. What did not survive scrutiny is how
+ * the size was decided: buildRawPayload() had to JSON.stringify the message to measure it, so
+ * every rebuild serialized about 100 MB of message bodies to compare them against a 64 KB cap
+ * and then threw the string away — for a body the page reads for one record at a time, if at
+ * all. See docs/LAYERS.md D11.
  *
- * `rawOmitted` deliberately stays on the row. Whether a message was too large to carry at
- * all is a fact the list itself has to be able to state — it is one boolean per row, and
- * it is what lets the inspector say "omitted" instead of silently showing something else.
+ * What the row carries now is the position of the message it came from. One row can produce
+ * several records (an assistant message yields its thinking, its text and each tool call),
+ * and they all answer with the same message, so the locator is per row, not per segment.
  *
  * Records are carried per turn, not as one flat list, so this walks the turns.
  *
  * @param {Array<Record<string, any>>} turns
- * @returns {Map<number, unknown>}
+ * @returns {Map<number, number>}
  */
 export function splitRawRecords(turns) {
-  /** @type {Map<number, unknown>} */
+  /** @type {Map<number, number>} */
   const raws = new Map();
   if (!Array.isArray(turns)) return raws;
   for (const turn of turns) {
     if (!turn || typeof turn !== 'object' || !Array.isArray(turn.records)) continue;
     for (const record of turn.records) {
-      if (!record || typeof record !== 'object' || !('raw' in record)) continue;
+      if (!record || typeof record !== 'object' || !('rawRow' in record)) continue;
       const index = Number(record.index);
-      if (Number.isInteger(index) && index > 0) raws.set(index, record.raw);
-      delete record.raw;
+      // Not Number(record.rawRow): Number(null) is 0, so a record whose locator is absent
+      // would resolve to the first row and answer with the wrong message.
+      const rowIndex = record.rawRow;
+      if (Number.isInteger(index) && index > 0 && typeof rowIndex === 'number' && Number.isInteger(rowIndex) && rowIndex >= 0) {
+        raws.set(index, rowIndex);
+      }
+      delete record.rawRow;
     }
   }
   return raws;
@@ -883,7 +918,8 @@ export function buildTrajectoryPayload(input) {
     return turn;
   };
 
-  for (const row of rows) {
+  for (let rowIndex = 0; rowIndex < rows.length; rowIndex += 1) {
+    const row = rows[rowIndex];
     const message = row && typeof row.message === 'object' && row.message !== null ? row.message : {};
     const source = /** @type {Record<string, any>} */ (message);
     const role = typeof source.role === 'string' ? source.role : 'unknown';
@@ -910,7 +946,6 @@ export function buildTrajectoryPayload(input) {
       if (turn.endedAt === null || timestamp > turn.endedAt) turn.endedAt = timestamp;
     }
 
-    const raw = buildRawPayload(source, redact);
     const usage = normalizeUsage(source.usage);
     if (usage) {
       stats.tokens.input += usage.input;
@@ -955,8 +990,9 @@ export function buildTrajectoryPayload(input) {
       api: typeof source.api === 'string' ? source.api : null,
       stopReason: typeof source.stopReason === 'string' ? source.stopReason : null,
       isError: source.isError === true ? true : source.isError === false ? false : null,
-      raw: raw.value,
-      rawOmitted: raw.omitted,
+      // Where the untouched message lives, not the message itself. /raw follows this back
+      // when a reader actually opens the record; nothing else reads it.
+      rawRow: rowIndex,
       textTruncated: false,
     };
 
@@ -1385,7 +1421,7 @@ function redactStructure(value, redact, depth = 0) {
  * @param {Record<string, any>} message
  * @param {(value: string) => string} redact
  */
-function buildRawPayload(message, redact) {
+export function buildRawPayload(message, redact) {
   if (!message || typeof message !== 'object') return { value: null, omitted: true };
   let serialized = '';
   try {
@@ -1498,6 +1534,134 @@ export function trajectoryCacheKey(entry, identity, binding, filter) {
   return `${entry.dir}|gen=${gen}|${lineage}|${entry.sizeBytes}|${entry.lastActiveAt}|${identity.catalogBytes ?? ''}|${bind}`;
 }
 
+/**
+ * @typedef {{ rows: Array<Record<string, any>>, skipped: number, size: number, read: number, empty: boolean, truncated: boolean }} ParsedRows
+ */
+
+/**
+ * Cache key for one generation file's parsed rows.
+ *
+ * Built from what the filesystem says right now, never from the catalog. The catalog's
+ * byteLength is a snapshot — this file documents that as going stale, and the active file
+ * grows past it between polls — so a key built from it would eventually serve a stale parse.
+ *
+ * The key names the full path, not the basename: every session has a `messages.jsonl`, so a
+ * basename key lets two sessions' identical files collide.
+ *
+ * `limit` participates because readHead truncates at it, and whether the file was truncated is
+ * part of what this entry holds.
+ *
+ * @param {string} filePath
+ * @param {number} size
+ * @param {number} mtimeMs
+ * @param {number} limit
+ * @returns {string}
+ */
+export function parsedRowsKey(filePath, size, mtimeMs, limit) {
+  return `${filePath}|${size}|${mtimeMs}|${limit}`;
+}
+
+/**
+ * LRU over parsed generation rows, bounded by bytes.
+ *
+ * Bounded by bytes rather than entries because entries say nothing about volume: one
+ * generation file is 40 KB and the next is 10 MB. A single entry larger than the whole budget
+ * is not stored at all — it would evict everything else and still miss every time.
+ *
+ * @param {number} budget
+ */
+export function createParsedRowsCache(budget) {
+  /** @type {Map<string, { value: ParsedRows, size: number }>} */
+  const entries = new Map();
+  let bytes = 0;
+  return {
+    get bytes() { return bytes; },
+    get size() { return entries.size; },
+    /**
+     * @param {string} key
+     * @returns {ParsedRows | null}
+     */
+    get(key) {
+      const hit = entries.get(key);
+      if (hit === undefined) return null;
+      // Re-reading is the only signal that a file is still hot, so it refreshes recency.
+      entries.delete(key);
+      entries.set(key, hit);
+      return hit.value;
+    },
+    /**
+     * @param {string} key
+     * @param {ParsedRows} value
+     * @param {number} size
+     * @returns {number}
+     */
+    set(key, value, size) {
+      const previous = entries.get(key);
+      if (previous !== undefined) {
+        bytes -= previous.size;
+        entries.delete(key);
+      }
+      if (size > budget) return bytes;
+      entries.set(key, { value, size });
+      bytes += size;
+      while (bytes > budget && entries.size > 1) {
+        const oldest = entries.keys().next();
+        if (oldest.done) break;
+        const victim = entries.get(oldest.value);
+        entries.delete(oldest.value);
+        bytes -= victim ? victim.size : 0;
+      }
+      return bytes;
+    },
+    clear() {
+      entries.clear();
+      bytes = 0;
+    },
+  };
+}
+
+/**
+ * One generation file's rows, from the cache when the filesystem still agrees with the key.
+ *
+ * Extracted from the route so a test can run the real step twice and compare: a cache hit
+ * that is even slightly different from a cold read is the one failure this cache may not
+ * have, and it is invisible to any test that does not run this function.
+ *
+ * Throws whatever readHead throws; the caller owns the error response, because the route
+ * needs to answer 500 and the test needs the throw.
+ *
+ * @param {ReturnType<typeof createParsedRowsCache>} cache
+ * @param {string} filePath
+ * @param {number} limit
+ * @returns {Promise<ParsedRows>}
+ */
+export async function loadParsedRows(cache, filePath, limit) {
+  // Stat for the key rather than trusting the catalog, for the same reason the read limit is
+  // not taken from it: the active file grows past its recorded size between polls. If the file
+  // changes between this stat and readHead the entry ends up keyed on a size it does not
+  // match, and the next poll — which stats again — misses and re-reads. The race can only cost
+  // a redundant read; it can never serve a stale parse, because a different size is a
+  // different key.
+  const current = await stat(filePath);
+  const key = parsedRowsKey(filePath, current.size, current.mtimeMs, limit);
+  const hit = cache.get(key);
+  if (hit !== null) return hit;
+
+  const head = await readHead(filePath, limit);
+  const parsed = parseMessagesJsonl(head.text);
+  const value = {
+    rows: parsed.rows,
+    skipped: parsed.skipped,
+    size: head.size,
+    read: head.read,
+    empty: head.text === '',
+    // Truncated means our cap cut the read, nothing else.
+    truncated: truncatedByCap(head.size, limit),
+  };
+  cache.set(key, value, Math.ceil(head.size * PARSED_ROWS_HEAP_PER_SOURCE_BYTE));
+  return value;
+}
+
 /**
  * Sends an already-serialized JSON body. Unlike {@link sendJson} it supports revalidation:
  * `no-store` would suppress the 304 path, so revalidated responses advertise `no-cache`
@@ -1561,9 +1725,15 @@ export async function start(context) {
    * but is only ever read for one record at a time, so keeping it beside the body means
    * the poll transfers the small payload and the record that gets opened still costs
    * nothing extra.
-   * @type {Map<string, { at: number, etag: string, body: string, raws: Map<number, unknown> }>}
+   * @type {Map<string, { at: number, etag: string, body: string, raws: Map<number, number>, rows: Array<Record<string, any>> }>}
    */
   const trajectoryCache = new Map();
+  /**
+   * Parsed generation rows, keyed by path+size+mtime+limit. Beside trajectoryCache, not
+   * inside it: a whole-session hit still short-circuits before this is touched at all, so
+   * the two caches never answer for each other. See docs/LAYERS.md D10.
+   */
+  const parsedRows = createParsedRowsCache(PARSED_ROWS_CACHE_BYTES);
 
   const loadClientEntry = async () => {
     if (clientEntry) return clientEntry;
@@ -1893,24 +2063,28 @@ export async function start(context) {
       // a file that was merely newer than its catalog entry. `readHead` already clamps to the real
       // stat size, so MAX_MESSAGE_BYTES bounds memory on its own.
       const limit = MAX_MESSAGE_BYTES;
-      let head;
+      /** @type {ParsedRows} */
+      let parsedFile;
       try {
-        head = await readHead(filePath, limit);
+        parsedFile = await loadParsedRows(parsedRows, filePath, limit);
       } catch (error) {
         context.logger.error('miniapp.trajectory.read_error', { reason: 'messages_unreadable', code: errorCode(error) });
         sendError(response, 500, 'trajectory_unreadable', '会话数据暂时无法读取');
         return;
       }
-      if (head.text === '') {
+      // Kept as a flag on the cached value rather than a log line at the read site: a file that
+      // parsed empty once will parse empty every time, and a hit must still say so.
+      if (parsedFile.empty) {
         context.logger.warn('miniapp.trajectory.read_error', { reason: 'empty_messages' });
       }
-      // Truncated means our cap cut the read, nothing else.
-      if (truncatedByCap(head.size, limit)) truncated = true;
-      readBytes += head.read;
-      const parsed = parseMessagesJsonl(head.text);
-      skippedTotal += parsed.skipped;
+      if (parsedFile.truncated) truncated = true;
+      readBytes += parsedFile.read;
+      skippedTotal += parsedFile.skipped;
       const keep = filter === null || filter === link.generation;
-      for (const row of parsed.rows) {
+      // The rows are shared with the cache and with every other request that read this file.
+      // Stamping the generation is the only write to them, and one filePath always maps to one
+      // generation, so it is idempotent — see docs/LAYERS.md D10.
+      for (const row of parsedFile.rows) {
         if (keep) {
           row[ROW_GENERATION] = link.generation;
           rows.push(row);
@@ -1953,6 +2127,10 @@ export async function start(context) {
 
     // Last thing before serializing, and the only place `raw` is ever touched: from here on
     // the body carries no message bodies at all.
+    // The locator map plus the rows it points into. Both are references: the rows are the
+    // same objects the parsed-rows cache holds, so this adds a map of numbers and an array of
+    // pointers rather than a second copy of the session. Keeping the array here also means
+    // /raw still answers after the parsed-rows cache has evicted the file.
     const raws = splitRawRecords(payload.turns);
 
     let body;
@@ -1962,7 +2140,7 @@ export async function start(context) {
       sendJson(response, 500, { error: 'trajectory_unserializable', message: '会话数据暂时无法读取' });
       return;
     }
-    trajectoryCache.set(cacheKey, { at: Date.now(), etag, body, raws });
+    trajectoryCache.set(cacheKey, { at: Date.now(), etag, body, raws, rows });
     while (trajectoryCache.size > TRAJECTORY_CACHE_ENTRIES) {
       const oldest = trajectoryCache.keys().next();
       if (oldest.done) break;
@@ -1995,11 +2173,17 @@ export async function start(context) {
       sendError(response, 503, 'trajectory_not_cached', '会话数据已释放，请重新加载');
       return;
     }
-    if (!cached.raws.has(wanted)) {
+    const rowIndex = cached.raws.get(wanted);
+    const row = rowIndex === undefined ? undefined : cached.rows[rowIndex];
+    if (rowIndex === undefined || !row || typeof row !== 'object') {
       sendError(response, 404, 'record_not_found', '找不到该记录');
       return;
     }
-    sendJson(response, 200, { index: wanted, raw: cached.raws.get(wanted) });
+    // The one place the untouched message is materialised, for one record, on request. The
+    // size verdict travels with it because the page has to be able to say "omitted" rather
+    // than silently show something else — see docs/LAYERS.md D11.
+    const built = buildRawPayload(row.message, redact);
+    sendJson(response, 200, { index: wanted, raw: built.value, omitted: built.omitted });
   };
 
   const handleDashboard = async (response) => {
diff --git a/plugins/avatasia/mmc-trajectory/tests/METHODOLOGY.md b/plugins/avatasia/mmc-trajectory/tests/METHODOLOGY.md
new file mode 100644
index 0000000..df0c0aa
--- /dev/null
+++ b/plugins/avatasia/mmc-trajectory/tests/METHODOLOGY.md
@@ -0,0 +1,308 @@
+# How to verify a change here
+
+`README.md` in this directory says what the guards are. This says how to arrive at them, and — more
+usefully — what has gone wrong when this was not followed. Every rule below is here because it
+cost a real defect or a real false alarm, not because it is good practice in the abstract.
+
+The short version:
+
+> Black-box the behaviour first. Freeze the data before you write any number. Derive the expected
+> value by hand. Then make the guard fail on purpose, and keep the failing mutation or fix the
+> guard — never delete it.
+
+---
+
+## 1. Drive the page before you read the code
+
+Reading a 285 KB client file to find a defect in a filter row is slow, and it is how you end up
+asserting the implementation you happened to read instead of the behaviour someone reported.
+
+Open the dashboard and walk the states. For the 异常 row the matrix that matters is:
+
+| | no rule | one rule | several | 重置 pressed |
+| --- | --- | --- | --- | --- |
+| **单选** | 重置 | replace on each press | unreachable | — |
+| **多选** | 重置 | stack | union, untick one at a time | — |
+
+That walk found three defects that no amount of reading would have surfaced, because all three are
+about what a control *says* rather than what it computes.
+
+### Reading the state of a row of controls
+
+Read the **parent container's** `outerHTML`, not a filtered set of children:
+
+```
+query(kind="dom", selector="#anomaly-bar")     → every button with its aria-pressed
+```
+
+A selector like `#anomaly-controls button[aria-pressed="true"]` returns only the **first** match,
+and a comma-separated list returns one of the matches in unspecified order. Both look exactly like
+"the stacking did not work". During this work that reading produced a confident claim that a
+working feature was broken, and the only reason it was caught is that the note text disagreed with
+it.
+
+Two more that matter on this page:
+
+- **checkbox state does not appear in serialised DOM.** `syncAnomalyMode` writes
+  `dom.anomalyMulti.checked`, which is a property; the serialised `<input>` is identical whether it
+  is ticked or not. `query(kind="semantic")` does not expose it either. To see it, screenshot.
+- **the session grows while you measure.** Every number on this page moves every 2.5 seconds. A
+  reading of `1,705` against a ledger of `1,706` is not a defect. See §2.
+
+---
+
+## 2. Never take a number from the page as the expectation
+
+This is the rule that would have prevented the original 异常 defects, and the one that is easiest to
+break while writing new guards.
+
+The counts on the 异常 row are computed by walking the session. If a guard computes its expected
+value with the same walk, it is a tautology: two implementations of the same mistake agree.
+
+Every expected number comes from **committed fixture data**, counted by code that shares nothing
+with the client — the guard reads `payload.turns[]` itself and never calls `anomalyCounts()`:
+
+```
+node tests/verify-anomaly.mjs
+fixture: 23 turns, 88 records, 21 turns that never answered
+OK  (234 assertions; 70 anomalous records of 88)
+```
+
+If you must compare against the live page to close a report, do it on a **stable** quantity — the
+ledger window, which shows `已显示 N 条 · 更早的 M 条未加载`, so the total is `N + M` and readable in
+one snapshot. Even then, treat a ±1 difference as the session growing, and re-read before calling
+it a bug.
+
+`--real` runs the same guards against this machine's `~/.minimax`. It is a second opinion about
+*shape*, never a source of expected values: that file grows too.
+
+---
+
+## 3. Derive the expectation by hand, and write down the derivation
+
+Before writing an assertion, work out what it should be and check that it is not boring:
+
+```
+noReply   → 21 turns are `closed === false` and are not the live turn   → 21 轮
+           those turns hold N records in total                        → N 条 shown
+toolError → a `toolResult`/`toolCall` pair whose result says it failed → some 条
+```
+
+Three things this catches that a green suite does not:
+
+- **Units.** `byRule` counts turns for a turn rule and records for a record rule. `21 轮` and `N 条`
+  are not comparable, and a session broken 21 times once advertised 1,244 "unanswered" rows.
+- **Unions do not add up.** One record can trip two rules. `工具失败 335 条` and `上下文压缩 19 条`
+  can be `354 条` or `353 条` and both are correct. A guard that asserts `a + b == total` will be
+  flaky, and one that asserts `a + b == total` while the fixture happens to have no overlap will
+  pass forever without testing anything — hence the explicit `some pair of rules genuinely overlaps`
+  assertion, which fails loudly if the fixture stops containing an overlap.
+- **Partial selections.** `全部异常` is the union of **all** rules. It is never the total of the two
+  rules currently ticked. An earlier version of the hint said `合计见「全部异常」`, which was true
+  only for the full set; for a two-rule stack it pointed 1,300 rows above the ledger.
+
+---
+
+## 4. Give every invariant a mutation, and keep it alive
+
+A guard that cannot fail reads as coverage. For each new invariant, add a case to
+`mutate-anomaly.py` that breaks exactly that rule, and require it to be caught **by the assertion
+that owns it**:
+
+```
+python tests/mutate-anomaly.py
+OK  (70 mutations, each caught by the guard that owns the defect)
+index.html restored byte-for-byte
+```
+
+The runner refuses three outcomes, and all three are things that have happened here:
+
+| runner reports | what it means | what to do |
+| --- | --- | --- |
+| `anchor matched N times` | the anchor is not unique, or the source moved | re-derive the anchor from the current file. **Never** loosen it to `>= 1` |
+| `NOT CAUGHT` | the guard is not testing what it claims | fix the guard. Do not delete the mutation |
+| `CRASHED` | the probe died before reporting | this is not a catch. Fix the crash |
+
+### A mutation that is a no-op is worse than no mutation
+
+The first attempt at "count the partial union" was:
+
+```python
+# wrong — `sel.length === 0` is false whenever rules are ticked, so this changes nothing
+-  if (sel.indexOf(hits[s]) >= 0) {
+-    selected += 1;
+-    break;
+-  }
++  if (sel.length === 0 || sel.indexOf(hits[s]) >= 0) { ... }
+```
+
+It survived, and the survival was correct: the mutation was dead code. The replacement drops the
+`break`, which turns the union into a count of rule-hits — wrong exactly when two rules overlap on
+one record, and correct otherwise. **Prefer mutations that only differ under the condition the
+invariant is about.** A mutation that is always different is usually breaking something the
+assertion never covered.
+
+### The owner must have a stable name
+
+`assert()` names are the runner's interface. Two traps:
+
+- **No colons.** The probe used to recover names with `split(':')[0]`, so `单选: ticking a second…`
+  was truncated to `单选` and mutations that *had* been caught were reported as uncaught. Names are
+  now collected separately; keep them colon-free anyway, because it is still how failures are read.
+- **A name that varies with the input cannot own a mutation.** Per-pair assertions named
+  `… — compaction + toolError` are excellent for a human reading a failure and unusable as a
+  mutation owner, because *which* pair fires depends on the fixture. Keep both: one family-level
+  assertion with a stable name, plus the per-instance ones for diagnostics.
+
+---
+
+## 5. Assert prose by running it
+
+A sentence can be grammatical and wrong. `合计见「全部异常」` was, and no regex over the source
+would have said so.
+
+`syncAnomalyMode` is loaded into the VM and its **rendered text** is read back:
+
+```js
+page.dom.anomalyNote = { hidden: true, textContent: '' };
+vm.runInContext(fnSource('function syncAnomalyMode(counts)'), page);
+page.syncAnomalyMode(page.anomalyCounts());
+const printed = page.dom.anomalyNote.textContent;   // what the reader is actually shown
+```
+
+and the number is **parsed back out** of the string rather than matched as a phrase, so rewording
+the sentence does not break the guard while repointing the number still does:
+
+```js
+const countOf = (text) => Number((text.match(/合计 ([\d,]+) 条/) || [])[1]?.replace(/,/g, ''));
+```
+
+Use source-shape assertions for wiring — is it wired to `change` or `click`, is it marked
+`data-filter-scope` — and use execution for anything a reader would be misled by.
+
+---
+
+## 6. When a guard goes red after an unrelated change, re-derive it
+
+Changing a signature breaks every `fnSource('function syncAnomalyButtons()')` anchor at once. The
+failure is noise, not evidence. Re-read what the function now promises and rewrite the assertion
+onto the new contract.
+
+Two of the 14 red assertions in this session were **inverted on purpose** and say so in their own
+comment:
+
+- `ticking a second keeps table order, not click order` required the toggle to stack
+  unconditionally. True of the code, false of the requirement. It now asserts 单选 replacement,
+  and the union it described is re-asserted in the 多选 block with the checkbox actually on.
+- `重置 is pressed exactly when no rule is` was true of the *filter* and false of the *row*: 多选 is
+  part of the row's state and is the only control that turns it off.
+
+An assertion that has to be deleted has usually found a requirement that was not written down yet.
+Write that down in the assertion's comment, or the next reader will delete it too.
+
+---
+
+## 7. One render, one snapshot
+
+`render()` took the counts twice — once for the hint, once for the buttons. Two walks of a session
+that is still growing can disagree, and the note would have published a number the button row did
+not have.
+
+```js
+var anomaly = anomalyCounts();
+syncAnomalyMode(anomaly);
+syncAnomalyButtons(anomaly);
+```
+
+Two guards hold this: the exact call sequence, and that `render()` contains exactly **one**
+`anomalyCounts()` call. Anything a reader can add up must come from one read.
+
+---
+
+## 8. Measure the layout; never write it down
+
+A sticky offset is a measurement, not a constant. This file carried `top: 32px` and `top: 83px`
+with a comment explaining them, and both were correct only while the layout had exactly one filter
+row above the strip. Adding a second filter row — one that wraps at narrow widths and grows a line
+when its note appears — invalidated them silently: nothing overlaps at the width the comment was
+written at, and at 735px the window bar sits on top of the strip.
+
+```css
+/* wrong: correct for one layout, and there is no way to tell from reading it */
+.overview  { top: 32px; }
+.window-bar { top: 83px; }
+```
+
+```js
+function syncStickyOffsets() {
+  if (!dom.filterSticky || !dom.overview || !dom.windowBar) return;
+  var root = document.documentElement.style;
+  var band = dom.filterSticky.offsetHeight;
+  var overview = dom.overview.offsetHeight;
+  root.setProperty('--sticky-band-h', band + 'px');
+  root.setProperty('--sticky-overview-h', overview + 'px');
+  root.setProperty('--sticky-window-h', dom.windowBar.offsetHeight + 'px');
+}
+```
+
+`offsetHeight`, not `getBoundingClientRect().height`: this runs on every 2.5s poll, and a
+fractional device-pixel ratio would otherwise accumulate a third of a pixel per poll into an
+overlap nobody can see and everybody inherits.
+
+Three rules make that hold, and each of them needed a mutation before it was believed:
+
+- **Pin what answers one question as one block.** The two filter rows were pinned separately, which
+  allowed the state where the type row is still on screen and the 异常 row is not. Half a filter
+  visible is worse than none: the reader is told nothing is filtered.
+- **The set of variables the stylesheet reads must equal the set the measurement writes.** One
+  direction lets a fallback govern a band that nothing measures; the other lets the measurement
+  keep writing a variable nobody reads, which is what "the offsets went back to being constants"
+  looks like from the outside.
+- **Everything pinned over the ledger paints a background.** The rows underneath are
+  `background: transparent`, so a pinned band that stops covering them shows them through.
+
+And the general form of the third one: **an element named in markup and an element named in a
+selector are two names, and nothing checks that they agree.** A band looked up by an id the markup
+does not ship measures nothing, all three offsets fall back to their constants, and no error is
+raised anywhere. A guard that hands the function a stub cannot catch this — the stub supplies
+exactly what the function asked for — so the binding is checked against the markup instead.
+
+---
+
+## 9. Say what you did not manage to check
+
+Some things cannot be driven through the browser harness. The honest form is the useful one:
+
+> Keyboard operation of the 多选 checkbox is not verified end to end. `Shift+Tab` does not move
+> focus in this harness — the focus ring stayed on 重置 and `Space` did nothing. The guard asserts
+> the binding is `change` rather than `click` (`click` does not fire for a keyboard-toggled
+> checkbox), with a mutation that fails if it is rewritten. That plus the platform guarantee is the
+> whole of the claim.
+
+A harness limitation reported as a limitation is useful. The same limitation silently treated as
+"probably works" is how a keyboard-only path ships broken.
+
+---
+
+## Checklist
+
+```
+[ ] walked the states in the browser first, and read a parent container for a row of controls
+[ ] every expected number comes from the fixture, counted without calling the code under test
+[ ] units, unions and partial selections worked out by hand before the assertion was written
+[ ] each new invariant has a mutation that is non-trivial (differs under the condition) and unique-anchored
+[ ] family-level assertions own the mutations; per-instance ones are for humans
+[ ] prose assertions are produced by running the function, numbers parsed back out of the string
+[ ] no assertion name contains a colon
+[ ] everything one reader can compare came from one snapshot
+[ ] no layout offset is written down; anything pinned is measured, and measured at the end of render
+[ ] every variable the stylesheet reads is written by the measurement, and one written is one read
+[ ] every element the measurement reads is bound to an id the markup actually ships
+[ ] anything not verified is written down as not verified
+```
+
+```
+node tests/run.mjs            # everything
+node tests/run.mjs --real     # same guards, this machine's ~/.minimax
+node tests/make-fixtures.mjs --check    # fixture must not drift under a change
+```
\ No newline at end of file
diff --git a/plugins/avatasia/mmc-trajectory/tests/README.md b/plugins/avatasia/mmc-trajectory/tests/README.md
new file mode 100644
index 0000000..a1dc44e
--- /dev/null
+++ b/plugins/avatasia/mmc-trajectory/tests/README.md
@@ -0,0 +1,235 @@
+# Regression guards
+
+These are the checks that decide whether this plugin is still correct. They are not part of the
+runtime payload — `miniapp.json` declares only `artifacts.client` and `artifacts.node`, and this
+directory is neither, so nothing here is shipped.
+
+```
+node tests/run.mjs              run everything
+node tests/run.mjs verify-      only the verifiers
+node tests/run.mjs mutate-      only the mutation controls
+node tests/run.mjs --real       read this machine's ~/.minimax instead of the fixture
+```
+
+Requires Node (the client guards run the inline script through `node --check`) and Python 3 (the
+mutation controls are Python). No network, no running Mini App, no machine-specific paths: every
+path resolves from this directory's own location.
+
+## Why half of these are `mutate-*`
+
+A guard that cannot fail is not a guard, because it reads as coverage. Each `mutate-*` file breaks
+exactly one rule in the shipped source, runs the guard that owns that rule, requires it to fail
+**and** to name the right check, then restores the file and requires green again. If a mutation is
+reported as surviving, the guard it exercised was not testing anything.
+
+That is also why they exist as separate files rather than as extra assertions: the mutation has to
+be able to make the real guard go red, which an assertion inside the guard cannot do to itself.
+
+`METHODOLOGY.md` is the other half: not what these guards are, but how to arrive at new ones — why
+an expected number may never come from the code under test, what to do when a mutation survives, and
+why an assertion that has to be deleted usually means a requirement was never written down.
+
+## The session store under test
+
+`verify-parsers.mjs` and `verify-prompt-fix.mjs` need a session store on disk. Reading the
+developer's own `~/.minimax` made them machine-dependent: on a clean CI runner the suite dropped
+to 13/15 — `verify-parsers` crashed and `verify-prompt-fix` failed two checks. They now read the
+committed synthetic store under `fixtures/minimax-home/`.
+
+The fixture is **distilled from real transcripts, not hand-written**. `make-fixtures.mjs` reads
+this machine's `~/.minimax` and keeps exactly the structure the assertions depend on — roles,
+content-part types, `stopReason` (the reply/narration split turns on it), `toolCallId` pairing,
+usage numbers, and the injection markers `splitUserMessage()` branches on — while replacing every
+string payload. No conversation text, path, or identifier from the real machine reaches the
+fixture: a leak assertion on the rendered bytes refuses to write if one would.
+
+Regenerate it when the store's format changes:
+
+```
+node tests/make-fixtures.mjs            report what would change, write nothing
+node tests/make-fixtures.mjs --record   rewrite fixtures/minimax-home/
+node tests/make-fixtures.mjs --selftest prove the leak assertion can actually fail
+```
+
+The generator also refuses to write unless every shape the guards rely on is present — user
+prompt, injected block, tool call, thinking, reply, narration, tool result, compaction. Without
+that gate a sparse sample would pass CI by accident and fail the moment anyone read it.
+
+Run both ways when you touch the parsers: the fixture proves the verdicts are reproducible,
+`--real` proves they still hold against transcripts nobody curated.
+
+## The payload
+
+Seven guards used to want one `/api/trajectory` body and got it by booting the service and
+fetching from a port. The route at `server.mjs` is `buildTrajectoryPayload(...)` plus a handful of
+`session.*` fields, so the same body falls out of the fixture store offline. `make-payload.mjs`
+writes it once:
+
+```
+node tests/make-payload.mjs            report, write nothing
+node tests/make-payload.mjs --record   rewrite fixtures/trajectory.json
+node tests/make-payload.mjs --check    fail if the committed payload is stale
+node tests/make-payload.mjs --real     the same report against this machine's ~/.minimax
+```
+
+`--check` is what keeps the two fixtures honest with each other: change `make-fixtures.mjs` and
+forget `--record`, and the payload stops matching the store it claims to come from.
+
+The fixture distiller walks a session's whole lineage, not just `messages.jsonl`. A compacted
+session keeps its old messages in `snapshots/g<gen>--ctx_*.jsonl`, and the shapes the guards need
+— an empty reply above all — live in those older generations. Reading only the active file finds
+none of them, and the guards then fail for want of something to find.
+
+## Files
+
+| file | what it pins |
+| --- | --- |
+| `client-check.mjs` | the inline script parses; the DOM-free helpers; the static policy rules |
+| `check-light-theme.mjs` | every `--mcode-*` token the page consumes is defined in both themes |
+| `verify-overview.mjs` | the overview strip, toolbar controls and window bar |
+| `verify-generations.mjs` | the compaction lineage walk: chain, orphans, generation totals |
+| `verify-parsers.mjs` | session labels and multi-session parse counts |
+| `verify-compaction-turn.mjs` | a compaction checkpoint is attributed to the turn it interrupted |
+| `verify-pr15-fixes.mjs` | the six fixes made for the PR #15 review comments |
+| `verify-prompt-fix.mjs` | injected-block splitting via `canonicalTextRange` |
+| `verify-window-widen.mjs` | `向上加载更早的 N 条` survives the next poll (self-contained: the shipped rule is transcribed) |
+| `verify-anomaly.mjs` | the four 异常 rules, their units, their position on the page, and their exclusivity with the other axis |
+| `verify-sticky.mjs` | both filter rows pin as one band, and every band below it is measured rather than written down |
+| `verify-block-order.mjs` | assistant blocks are ordered per message: thinking → text → toolCall |
+| `verify-response-rail.mjs` | every row carries the rail of the response it came from |
+| `verify-call-fold-coverage.mjs` | folding every tool call really removes them from the rendered build |
+| `make-fixtures.mjs` | distils the local session store into the committed fixture; refuses to write on a leak |
+| `make-payload.mjs` | builds `/api/trajectory` offline from that fixture; `--check` catches drift |
+| `mutate-index-col.py` | the record-index column has room for the numbers it shows |
+| `mutate-label-source.py` | kind button labels come from `KIND_LABELS`, not from markup |
+| `mutate-name-collision.py` | no record kind is labelled with a name that means something else |
+| `mutate-turn-breakdown.py` | the turn breakdown parts sum to the headline |
+| `mutate-compaction-turn.py` | the compaction-turn attribution is not a free-text label |
+| `mutate-pr15-fixes.py` | each of the six PR #15 fixes has a guard that can fail |
+| `mutate-anomaly.py` | each of the 70 异常 mutations, in the page, has a guard that can fail |
+| `mutate-steer.py` | the steer split and the turn classification hold |
+| `mutate-window-default.py` | the window defaults, labels, resets and load-more hold |
+| `mutate-sticky.py` | each of the 18 pinned-band rules has a guard that can fail |
+
+## The 异常 axis, and what it promises
+
+`异常` is a second filter system, not a fourth field of the first one. Entering it switches the
+type axis, the search box, the time range and the overview brush off **and puts them back to their
+default**; `重置` returns the row to its default, where the table is filtered by the row above
+again. Five properties are asserted, each with a mutation control, because each was observed to
+be false in this file's own history:
+
+1. **Ticking a rule puts the row above back to its default.** In this mode that row filters
+   nothing, so leaving it holding 「用户」 would be the page displaying a condition that is not in
+   force — the same defect as a button whose number does not match its list, one control over.
+   `resetBaseFilters()` sets the state *and* calls `syncKindButtons()`; a write without the sync
+   leaves the axis drawing what was there before, and that is what the last mutation control here
+   breaks. `重置` is not a toggle either: the second press filters nothing, it does nothing at all.
+   And `重置` carries no count, because 「怎么多会留下多少」 is a question about a rule, and a control
+   that keeps whatever the row above says has no answer to it.
+2. **The number on a button is what you get when you tick that button.** `anomalyCounts()` walks
+   the same records `visibleEntries()` does and neither of them walks the other axis. Counting
+   through `passesBaseFilter` — which is what this guard used to *require* — produced a button
+   promising 283 rows above a list of 1,494, and no functional assertion could tell, because the
+   ledger was filtering the same way the count was.
+3. **The unit is part of the claim.** A rule scoped to a record is published in 条; a rule scoped
+   to a turn is published in 轮, and counted once per *turn*. `无答复` counted in records is how
+   a session broken 13 times came to advertise 1,244 "unanswered" rows, none of which carried a
+   sign of being unanswered. `verify-anomaly.mjs` checks the unit against the rule table, not
+   against a literal, so renaming or rescoping a rule cannot leave the two disagreeing.
+4. **The two axes are alternatives, not a stack.** `visibleEntries()` and `spanPassesFilter()`
+   branch on the mode before the other axis. The strip has to agree with the list: when it
+   drew spans for records the list was not rendering, the "filtered but nothing changed" failure
+   the overview had already paid for once came straight back.
+5. **A control that cannot change what is on screen must not look like it can.** The inactive
+   axis is `inert`, not merely dimmed, so neither the pointer nor keyboard focus can reach a
+   button that does nothing. The session and generation pickers are deliberately unmarked — they
+   choose which session is on screen, not which records of it — and the guard asserts exactly
+   which four elements carry the marker.
+
+Position is asserted too, on its own terms: the axis has to come after the type axis, must not
+be a field of the search form any more, and the KPI cards must not come between them. It used
+to be the last field of the form, four cards above the axis it reads as part of — a layout defect
+that no functional assertion in the suite could see.
+
+## The pinned bands, and why none of them carries a number
+
+Four things pin themselves while the ledger scrolls under them: the filter band (both axes), the
+overview strip, the window bar, and the turn head. Three properties are asserted, and each one was
+false in this file's own history.
+
+1. **The two filter rows pin as one block.** They answer the same question — which records the
+   ledger shows — so a state where the type row is still pinned and the 异常 row has scrolled away
+   is the worst of both: the reader is told nothing is filtered while half the filter is off
+   screen. Only the type row ever claimed `position: sticky` and it did not survive; the guard
+   now asserts that neither row pins itself and that both are inside the band, because a band that
+   does not contain both is the same defect wearing a different hat.
+2. **No pinned offset is written down.** The band is two rows whose height changes when the 异常 row
+   wraps at narrow widths and when its note appears or disappears, so `0–32` and `32–83` were
+   correct only for a layout without the 异常 row. `syncStickyOffsets()` measures the three bands at
+   the end of `render()` and writes them into `--sticky-band-h`, `--sticky-overview-h` and
+   `--sticky-window-h`; the stylesheet only ever reads those. The guard runs that function against
+   stub heights of 137 / 65 / 57 — no constant in the file is any of them — so a version that
+   writes a number instead of a measurement fails, and so does one that measures the band for the
+   strip.
+3. **Anything pinned over the ledger has to paint a background.** The rows underneath are
+   `background: transparent`, so a pinned band that stops covering them shows them through. The
+   strip paints through `.overview-plot` rather than through the sticky section, which is why the
+   guard names that rule and not `.overview`.
+
+Two more assertions exist because the mutation control found them missing: the set of variables the
+stylesheet reads has to be **exactly** the set the measurement writes (one side alone lets a stale
+fallback or a dead measurement through), and every band the function reads has to be bound to an
+element the markup actually ships. A band that is never bound measures nothing, all three offsets
+fall back to their constants, and no error is reported anywhere — the stub the guard measures with
+cannot catch it, so the binding is checked against the markup instead.
+
+The order of `render()` is asserted too: the measurement has to be the last statement, because the
+异常 note is written by `syncAnomalyMode()` and that note is what changes the band's height.
+
+## Deliberately not in the default run
+
+Shipping a suite that is red teaches reviewers to ignore it, so these are present but skipped,
+with the reason stated rather than quietly dropped.
+
+- **`mutate-filter-guards.mjs`** — not carried. Guards the layer buttons (`turns-btn`, `setLayer`,
+  `LAYER_KINDS`, `applyLayerToKinds`). Those were removed when the layer presets were dropped in
+  favour of the type chips; all five symbols now occur zero times in `index.html`. The rule it
+  guards is gone.
+- **`mutate-qa-lens.py`** — not carried. Guards the 问答 turn-lens. Same removal; no lens symbol
+  remains.
+- **`verify-time-range.mjs`** and its control **`mutate-time-range.py`** — present, skipped by
+  `run.mjs`. Its assertions are calibrated against a full multi-generation session:
+  `stats.messages > 1000`, and a checkpoint nested inside a turn rather than being one. The
+  committed fixture is a single-file session of a few dozen rows. Reproducing those numbers
+  faithfully would mean committing a multi-megabyte payload; relaxing them would stop exercising
+  the timezone arithmetic the file exists for. Run it by hand against a booted service:
+  `node tests/verify-time-range.mjs <port>`.
+
+### Two anchors that were wrong, and one mutation that could not be caught
+
+Kept here because each cost real time to find, and each would look like "the guard is stale":
+
+- **`mutate-steer.py`** was not stale. `server.mjs` is CRLF and the anchor joined its lines with
+  `\n`, so a multi-line anchor matched zero times and read as drift. Single-line anchors in the
+  same file matched fine. Anchors are now built in the file's own line ending.
+- **`mutate-window-default.py`** was genuinely stale, but not where it looked: the rule still
+  exists, and `rePinWindow` had gained a time-range early-return *between* the two lines the
+  anchor spanned. It is anchored on the one line that is the rule.
+- **`mutate-anomaly.py`** does not carry a case that nulls the page's `liveTurn`, even though that
+  looked like the obvious thing to break. `verify-anomaly.mjs` re-derives the live turn itself
+  instead of calling the page's function, so the mutation is invisible to every assertion in the
+  file — it was tried and the probe passed. Shipping it would mean shipping a mutation known to
+  be unobservable. Until the harness stops re-deriving it, the page's `liveTurn` has no guard of
+  its own.
+
+## One-shot patches are not here either
+
+Development also produced scripts that **write the package** to apply one specific edit. They are
+deliberately excluded: they have no dry-run and no backup, they write straight back to
+`index.html` / `server.mjs` / the READMEs, and re-running one now edits text that has since moved
+on. They have since been removed rather than kept with a warning header — what each one did is
+recorded in the development directory's index instead.
+
+**Do not go looking for a one-shot patch runner.** If you need to change the client or the service,
+edit the file and let the guards below tell you whether you broke something.
\ No newline at end of file
diff --git a/plugins/avatasia/mmc-trajectory/tests/check-light-theme.mjs b/plugins/avatasia/mmc-trajectory/tests/check-light-theme.mjs
new file mode 100644
index 0000000..7ef8cf9
--- /dev/null
+++ b/plugins/avatasia/mmc-trajectory/tests/check-light-theme.mjs
@@ -0,0 +1,140 @@
+/**
+ * Light-theme token coverage check.
+ *
+ * The README states the light theme is defined but was not visually verified.
+ * We cannot emulate prefers-color-scheme from here, but we can verify the
+ * stronger structural property: every --mcode-* token that the stylesheet
+ * CONSUMES must be defined in BOTH themes, otherwise light mode silently
+ * falls back to an undefined value.
+ *
+ * Actual stylesheet shape in this page:
+ *   :root, :root[data-theme='light'] { ... }        <- light
+ *   :root[data-theme='dark']          { ... }        <- dark
+ *   @media (prefers-color-scheme: dark) {
+ *     :root:not([data-theme])        { ... }        <- pre-JS dark fallback
+ *   }
+ */
+import { readFile } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+const html = await readFile(path.join(here, '..', 'miniapp', 'client', 'index.html'), 'utf8');
+
+const css = html.match(/<style[^>]*>([\s\S]*?)<\/style>/i)?.[1];
+if (!css) {
+  console.error('FAIL: no <style> block found');
+  process.exit(1);
+}
+
+function classify(selector) {
+  const s = selector.trim();
+  if (/@media\s*\(prefers-color-scheme\s*:\s*light\s*\)/i.test(s)) return 'light';
+  if (/@media\s*\(prefers-color-scheme\s*:\s*dark\s*\)/i.test(s)) return 'dark';
+  if (/:root\[data-theme=['"]?dark/i.test(s)) return 'dark';
+  if (/:root\[data-theme=['"]?light/i.test(s)) return 'light';
+  if (/^:root\b/i.test(s) && !/\[data-theme/i.test(s)) return 'light'; // bare :root carries light values
+  if (/:root:not\(\[data-theme\]\)/i.test(s)) return 'dark'; // pre-JS fallback
+  return 'other';
+}
+
+// Walk the CSS, tracking the selector of each declaration block.
+const defs = new Map(); // token -> Set(theme)
+const uses = new Set();
+let pending = [];       // selectors of currently open blocks
+let depthOfTheme = [];  // theme per open brace
+let buf = '';
+let media = 'none';
+
+for (let i = 0; i < css.length; i++) {
+  const ch = css[i];
+  if (ch === '{') {
+    const sel = buf.replace(/\s+/g, ' ').trim();
+    let theme = classify(sel);
+    if (media === 'dark' && theme === 'other') theme = 'dark';
+    if (media === 'light' && theme === 'other') theme = 'light';
+    pending.push(sel);
+    depthOfTheme.push(theme);
+    buf = '';
+    continue;
+  }
+  if (ch === '}') {
+    // flush any declarations that were pending
+    consume(buf);
+    buf = '';
+    const closed = depthOfTheme.pop();
+    pending.pop();
+    if (pending.length === 0 && closed === 'dark' && media === 'dark') media = 'none';
+    continue;
+  }
+  if (ch === ';' || ch === '{') consume(buf), (buf = ''); // statement outside a block
+  buf += ch;
+
+  function consume(text) {
+    const t = text.trim();
+    if (!t || !pending.length) return;
+    const theme = depthOfTheme[depthOfTheme.length - 1];
+    const defRe = /(--mcode-[A-Za-z0-9_-]+)\s*:\s*[^;{}]+/g;
+    let m;
+    while ((m = defRe.exec(t))) {
+      if (!defs.has(m[1])) defs.set(m[1], new Set());
+      defs.get(m[1]).add(theme);
+    }
+    const useRe = /var\(\s*(--mcode-[A-Za-z0-9_-]+)/g;
+    while ((m = useRe.exec(t))) uses.add(m[1]);
+  }
+}
+
+// media query tracking (single level is enough for this sheet)
+const mediaRe = /@media\s*\(([^)]*)\)/gi;
+let mm;
+const mediaRanges = [];
+while ((mm = mediaRe.exec(css))) mediaRanges.push({ at: mm.index, len: mm[0].length, text: mm[1] });
+
+// Re-scan with media awareness for declarations inside @media
+{
+  let cursor = 0;
+  const lines = css.split(/\r?\n/);
+  let offset = 0;
+  let curTheme = 'light';
+  for (const line of lines) {
+    const at = offset;
+    offset += line.length + 1;
+    for (const r of mediaRanges) {
+      if (r.at === at) curTheme = /light/i.test(r.text) ? 'light' : 'dark';
+    }
+    const selMatch = /^\s*(:root[^{]*|\[data-theme[^{]*)\{\s*$/.exec(line);
+    if (selMatch) {
+      const theme = classify(selMatch[1]);
+      if (theme !== 'other') curTheme = theme;
+      else if (curTheme === 'none') curTheme = 'other';
+    }
+    const defRe = /(--mcode-[A-Za-z0-9_-]+)\s*:\s*[^;]+;/g;
+    let m;
+    while ((m = defRe.exec(line))) {
+      if (!defs.has(m[1])) defs.set(m[1], new Set());
+      defs.get(m[1]).add(curTheme);
+    }
+    const useRe = /var\(\s*(--mcode-[A-Za-z0-9_-]+)/g;
+    while ((m = useRe.exec(line))) uses.add(m[1]);
+  }
+}
+
+const problems = [];
+for (const token of [...uses].sort()) {
+  const where = defs.get(token);
+  if (!where) problems.push(`UNDEFINED  ${token} (used but never defined)`);
+  else if (!where.has('light')) problems.push(`LIGHT_GAP  ${token} (no light-theme definition)`);
+  else if (!where.has('dark')) problems.push(`DARK_GAP   ${token} (no dark-theme definition)`);
+}
+
+console.log(`tokens defined : ${defs.size}`);
+console.log(`tokens used    : ${uses.size}`);
+console.log(`theme map      : ${[...defs].map(([t, s]) => `${t}{${[...s].join(',')}}`).slice(0, 3).join(' ')} ...`);
+
+if (problems.length === 0) {
+  console.log('\nOK  every consumed --mcode-* token is defined in BOTH light and dark');
+  process.exit(0);
+}
+console.log('\n' + problems.map((p) => 'FAIL ' + p).join('\n'));
+process.exit(1);
diff --git a/plugins/avatasia/mmc-trajectory/tests/client-check.mjs b/plugins/avatasia/mmc-trajectory/tests/client-check.mjs
new file mode 100644
index 0000000..155283b
--- /dev/null
+++ b/plugins/avatasia/mmc-trajectory/tests/client-check.mjs
@@ -0,0 +1,792 @@
+// Offline self-check for miniapp/client/index.html (read-only w.r.t. the package).
+// 1) extracts the inline <script> and runs `node --check`
+// 2) extracts the PURE:START/PURE:END block and unit-tests the DOM-free helpers
+import { readFileSync, writeFileSync, mkdtempSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { execFileSync } from 'node:child_process';
+import vm from 'node:vm';
+
+const HTML = fileURLToPath(new URL('../miniapp/client/index.html', import.meta.url));
+const SERVER = fileURLToPath(new URL('../miniapp/node/server.mjs', import.meta.url));
+// Scratch files go to a throwaway directory, not into the checkout: this script writes
+// an extracted copy of the inline script and runs `node --check` on it.
+const OUT = mkdtempSync(join(tmpdir(), 'traj-client-check-'));
+
+const html = readFileSync(HTML, 'utf8');
+
+/* ---------- 1) syntax check of the inline script ---------- */
+const scripts = [...html.matchAll(/<script>([\s\S]*?)<\/script>/g)].map((m) => m[1]);
+if (scripts.length !== 1) throw new Error('expected exactly one inline script, got ' + scripts.length);
+writeFileSync(OUT + '/client-extracted.mjs', scripts[0]);
+try {
+  execFileSync(process.execPath, ['--check', OUT + '/client-extracted.mjs'], { stdio: 'pipe' });
+  console.log('[1] node --check: PASS (' + scripts[0].split('\n').length + ' script lines)');
+} catch (error) {
+  console.log('[1] node --check: FAIL\n' + error.stderr);
+  process.exit(1);
+}
+
+/* ---------- 2) pure helpers ---------- */
+const rawSlice = html.split('PURE:START')[1].split('PURE:END')[0];
+let block = rawSlice.slice(rawSlice.indexOf('*/') + 2);           // drop the PURE:START header comment
+const lastCloser = block.lastIndexOf('*/');                      // drop the dangling PURE:END header opener
+const dangling = block.indexOf('/*', lastCloser === -1 ? 0 : lastCloser + 2);
+if (dangling >= 0) block = block.slice(0, dangling);
+const sandbox = { console };
+vm.createContext(sandbox);
+vm.runInContext(block, sandbox);
+
+let pass = 0;
+const failures = [];
+function check(name, actual, expected) {
+  const ok = JSON.stringify(actual) === JSON.stringify(expected);
+  if (ok) pass += 1;
+  else failures.push(name + ': got ' + JSON.stringify(actual) + ', want ' + JSON.stringify(expected));
+}
+function assert(name, cond) {
+  if (cond) pass += 1;
+  else failures.push(name);
+}
+
+/* null rendering — never 0, never invented */
+check('duration null', sandbox.formatDuration(null), '—');
+check('duration undefined', sandbox.formatDuration(undefined), '—');
+check('duration zero', sandbox.formatDuration(0), '0 ms');
+check('duration 431', sandbox.formatDuration(431), '431 ms');
+check('duration 1500', sandbox.formatDuration(1500), '1.50 s');
+check('duration 90000', sandbox.formatDuration(90000), '1 分 30 秒');
+check('duration NaN', sandbox.formatDuration(NaN), '—');
+check('int null', sandbox.formatInt(null), '—');
+check('int group', sandbox.formatInt(1234567), '1,234,567');
+check('int zero', sandbox.formatInt(0), '0');
+check('compact null', sandbox.formatCompact(null), '—');
+check('compact 12500', sandbox.formatCompact(12500), '12.5k');
+check('compact 2500000', sandbox.formatCompact(2500000), '2.5M');
+check('offset null', sandbox.formatOffset(null), '—');
+check('offset 887', sandbox.formatOffset(887), '+887 ms');
+check('offset 12000', sandbox.formatOffset(12000), '+12 s');
+check('offset 0', sandbox.formatOffset(0), '+0 ms');
+check('clock null', sandbox.formatClock(null), '—');
+check('ago null', sandbox.formatAgo(null, Date.now()), '—');
+check('ago 30s', sandbox.formatAgo(Date.now() - 30000, Date.now()), '刚刚');
+check('ago 5min', sandbox.formatAgo(Date.now() - 300000, Date.now()), '5 分钟前');
+check('bytes null', sandbox.formatBytes(null), '—');
+check('bytes 244100', sandbox.formatBytes(244100), '238.4 KB');
+check('safeText null', sandbox.safeText(null), '');
+check('safeText obj', sandbox.safeText({ a: 1 }), '{"a":1}');
+check('truncate empty', sandbox.truncateText('', 10), '');
+check('truncate long', sandbox.truncateText('abcdefghij', 5), 'abcd…');
+check('labels', sandbox.KIND_LABELS.toolResult, '工具结果');
+
+/* kind label — a compaction is its own kind, so it can never be called 系统 */
+check('kindLabel compaction', sandbox.kindLabel({ kind: 'compaction', title: 'compaction' }), '压缩');
+check('kindLabel plain system', sandbox.kindLabel({ kind: 'system', title: 'context' }), '系统');
+check('kindLabel reply', sandbox.kindLabel({ kind: 'reply' }), '答复');
+check('kindLabel narration', sandbox.kindLabel({ kind: 'narration' }), '过程');
+check('kindLabel unknown falls back to kind', sandbox.kindLabel({ kind: 'weird' }), 'weird');
+check('kindLabel null record is dash', sandbox.kindLabel(null), '—');
+check('kindLabel null record is dash string', sandbox.kindLabel('x'), '—');
+// 问答 already means something else here: the server classifies *turns* that way — the
+// exchange where the agent asked the reader something and the reply came back through the
+// tool result. That turn is a composite, not a record. A record kind wearing the same
+// name once shipped as `qa` and was really 答复 (stopReason === 'stop'), so this asserts
+// no record kind may claim the word. If a future kind genuinely is a Q&A exchange, it
+// belongs at turn level, and this line is the one to argue with first.
+check('no record kind is labelled 问答',
+  sandbox.KIND_ORDER.some((k) => sandbox.KIND_LABELS[k] === '问答'), false);
+// The label follows the kind and nothing else. A title that used to mean "compaction"
+// now means what it says: the filter decides what a record is, so the name has to as well.
+check('kindLabel ignores title', sandbox.kindLabel({ kind: 'system', title: 'compaction' }), '系统');
+check('every kind has a label', sandbox.KIND_ORDER.every((k) => typeof sandbox.KIND_LABELS[k] === 'string' && sandbox.KIND_LABELS[k].length > 0), true);
+check('every label has a kind', Object.keys(sandbox.KIND_LABELS).every((k) => sandbox.KIND_ORDER.indexOf(k) >= 0), true);
+
+/* generation selector — one generation is not a choice, and the newest comes first */
+const gens = [
+  { generation: 0, kind: 'snapshot', messageCount: 676, active: false },
+  { generation: 1, kind: 'snapshot', messageCount: 548, active: false },
+  { generation: 2, kind: 'active', messageCount: 186, active: true }
+];
+check('generationOptions empty for one', sandbox.generationOptions([{ generation: 0 }], 0), []);
+check('generationOptions empty for none', sandbox.generationOptions([], null), []);
+check('generationOptions empty for junk', sandbox.generationOptions(null, 0), []);
+const opts = sandbox.generationOptions(gens, 2);
+check('generationOptions count includes the all option', opts.length, 4);
+check('generationOptions leads with the whole lineage', opts[0].generation, 'all');
+check('generationOptions all label', opts[0].label, '全部（默认）');
+check('generationOptions all is never marked active', opts[0].active, false);
+check('generationOptions newest generation first', opts[1].generation, 2);
+check('generationOptions active marked', opts[1].active, true);
+check('generationOptions active label', opts[1].label, '第 2 代（当前）');
+check('generationOptions archived label carries count', opts[2].label, '第 1 代（548 条）');
+check('generationOptions last option', opts[3].generation, 0);
+check(
+  'generationOptions drops entries without a generation',
+  sandbox.generationOptions([{ generation: 1 }, null, { kind: 'x' }, { generation: 2, active: true }], 2).length,
+  3
+);
+check('generationOptions falls back to the active flag', sandbox.generationOptions(gens, null)[1].active, true);
+check(
+  'generationOptions missing count drops the suffix',
+  sandbox.generationOptions([{ generation: 0, messageCount: null }, { generation: 1, messageCount: 5, active: true }], 1)[2].label,
+  '第 0 代'
+);
+
+/* escaping / hostile text */
+const XSS = '</pre><script>alert("xss")</script>&`${danger}';
+const escaped = sandbox.escapeHtml(XSS);
+assert('escapeHtml has no raw <', !escaped.includes('<'));
+assert('escapeHtml has no raw >', !escaped.includes('>'));
+assert('escapeHtml has no raw quote', !escaped.includes('"'));
+assert('escapeHtml escapes amp', escaped.includes('&amp;'));
+check('safeText keeps hostile text verbatim', sandbox.safeText(XSS), XSS);
+
+const colored = sandbox.jsonColorize({ evil: XSS, n: 42, b: true, z: null, s: 'a$&b' });
+assert('jsonColorize emits no injected tag', !colored.includes('<script') && !colored.includes('</pre>'));
+assert('jsonColorize keeps literal $&', colored.includes('$&'));
+const stripped = colored.replace(/<[^>]+>/g, '');
+check('jsonColorize round-trips to escaped json', stripped, sandbox.escapeHtml(JSON.stringify({ evil: XSS, n: 42, b: true, z: null, s: 'a$&b' }, null, 2)));
+assert('jsonColorize colors numbers', colored.includes('tok-num'));
+check('jsonColorize undefined', sandbox.jsonColorize(undefined), '');
+check('jsonColorize null', sandbox.jsonColorize(null), '<span class="tok-null">null</span>');
+
+/* search: case-insensitive over summary + text + result + thinking, hostile content */
+const hostile = {
+  kind: 'reply',
+  summary: 'Ask about <script>alert(1)</script>',
+  text: 'Answering now',
+  result: null,
+  thinking: null
+};
+check('match lowercase', sandbox.matchesQuery(hostile, 'script'), true);
+check('match uppercase', sandbox.matchesQuery(hostile, 'ALERT'), true);
+check('match miss', sandbox.matchesQuery(hostile, 'zzz'), false);
+check('match empty query', sandbox.matchesQuery(hostile, ''), true);
+check('match result field', sandbox.matchesQuery({ kind: 'toolResult', result: { code: 'ENOENT' } }, 'enoent'), true);
+check('match thinking object', sandbox.matchesQuery({ kind: 'thinking', thinking: { text: 'chain of thought' } }, 'thought'), true);
+check('match null thinking safe', sandbox.matchesQuery({ kind: 'thinking', thinking: null }, 'thought'), false);
+check('no kinds match', sandbox.hasKind({ kind: 'system' }, ['user']), false);
+
+/* flatten + signature */
+check('flatten empty', sandbox.flattenTurns(undefined), []);
+check('flatten junk', sandbox.flattenTurns([{ id: 'a' }, null, { id: 'b', records: [null, { id: 'r' }] }]).length, 1);
+check('signature empty', sandbox.signatureOf(null), 'empty');
+const payload = {
+  session: { id: 'mvs_1' },
+  stats: { messages: 5, toolCalls: 2, errors: 0, durationMs: 100, tokens: { totalTokens: 9 } },
+  turns: [{ id: 't1', index: 1, records: [{ id: 'r1', kind: 'user' }, { id: 'r2', kind: 'narration' }] }]
+};
+const sigA = sandbox.signatureOf(payload);
+check('signature stable', sigA, sandbox.signatureOf(JSON.parse(JSON.stringify(payload))));
+payload.stats.messages = 6;
+assert('signature changes with counts', sigA !== sandbox.signatureOf(payload));
+
+/* handoff markdown */
+const turn = { id: 't1', index: 3 };
+const failing = {
+  kind: 'toolCall', index: 42, toolName: 'read', toolCallId: 'call_bb89',
+  timestamp: 1791603931971, relativeMs: 887, durationMs: null, isError: true,
+  error: 'boom <b>x</b>', model: 'MiniMax-M3.1-Flash-Preview', provider: 'minimax',
+  api: 'anthropic-messages', stopReason: 'toolUse', textTruncated: true,
+  tokens: { input: 10, output: 5, cacheRead: 0, cacheWrite: 0, totalTokens: 15 },
+  arguments: { path: 'a.txt' }
+};
+const raw = sandbox.truncateJson({ blob: 'x'.repeat(20000) }, sandbox.HANDOFF_RAW_LIMIT);
+check('truncateJson caps at 8000', raw.text.length, 8000);
+check('truncateJson flags', raw.truncated, true);
+check('truncateJson small', sandbox.truncateJson({ a: 1 }, 8000).truncated, false);
+// 「原文过大」 is not a field on the record any more: it arrives with the /raw answer, because
+// deciding it meant serializing every message in the session on every poll (LAYERS.md D11).
+// The markdown therefore takes the verdict as its own argument, and this asserts that a
+// caller who passes it still gets the line — and that one who does not, gets silence.
+const md = sandbox.buildHandoffMarkdown({ id: 'mvs_1', label: '测试会话' }, turn, failing, raw.text, raw.truncated, true);
+const mdWithoutVerdict = sandbox.buildHandoffMarkdown({ id: 'mvs_1', label: '测试会话' }, turn, failing, raw.text, raw.truncated);
+assert('md omits the flag when no verdict was passed', !mdWithoutVerdict.includes('原文过大已被省略'));
+assert('md locates turn', md.includes('第 3 轮'));
+assert('md locates record', md.includes('#42'));
+assert('md names kind', md.includes('工具调用'));
+assert('md marks failure', md.includes('状态：失败') && md.includes('boom <b>x</b>'));
+assert('md renders null duration as dash', md.includes('耗时：—'));
+assert('md notes truncation', md.includes('已截断到 8000 字符'));
+assert('md notes flags', md.includes('原文过大已被省略') && md.includes('正文已被上游截断'));
+assert('md reports limit constant', sandbox.HANDOFF_RAW_LIMIT === 8000);
+
+/* a compaction must read as 压缩 in the handoff text too, not 系统 */
+const compaction = {
+  kind: 'compaction', title: 'compaction', index: 1, role: 'compactionSummary',
+  tokensBefore: 367401, summary: '## Goal ...'
+};
+const mdCompaction = sandbox.buildHandoffMarkdown(
+  { id: 'mvs_1', label: '测试会话' },
+  { id: 't0', index: 1 },
+  compaction,
+  '{"kind":"compactionSummary"}',
+  false
+);
+assert('md names a compaction 压缩', mdCompaction.includes('· 压缩'));
+assert('md never calls a compaction 系统', !mdCompaction.includes('· 系统'));
+
+/* large-session fixture: 3,000 records / 40 turns, plus null-heavy rows */
+const turns = [];
+let n = 0;
+for (let t = 0; t < 40; t += 1) {
+  const records = [];
+  for (let r = 0; r < 75; r += 1) {
+    n += 1;
+    records.push({
+      index: n, id: 'msg-' + n, turnId: 't' + t,
+      kind: sandbox.KIND_ORDER[n % 6],
+      timestamp: 1791603931971 + n, relativeMs: n * 37,
+      title: 'read', summary: n % 11 === 0 ? XSS : '第 ' + n + ' 条 ' + 'x'.repeat(80),
+      text: n % 7 === 0 ? YAMLED() : null,
+      thinking: n % 5 === 0 ? { text: 'thinking ' + n } : null,
+      arguments: n % 3 === 0 ? { path: 'p' + n } : null,
+      result: n % 4 === 0 ? null : { ok: true, out: 'y'.repeat(400) },
+      error: n % 13 === 0 ? 'boom' : null,
+      isError: n % 13 === 0,
+      durationMs: n % 17 === 0 ? null : n % 900,
+      tokens: n % 6 === 0 ? null : { input: n, output: n, cacheRead: 0, cacheWrite: 0, totalTokens: n * 2 },
+      raw: n % 8 === 0 ? { big: 'z'.repeat(2000) } : null,
+      rawOmitted: n % 9 === 0, textTruncated: n % 12 === 0
+    });
+  }
+  turns.push({ id: 't' + t, index: t + 1, toolCalls: 12, errors: t % 4 === 0 ? 1 : 0, durationMs: t % 6 === 0 ? null : 12000, tokens: { input: 10, output: 5, cacheRead: 2, cacheWrite: 0, totalTokens: 17 }, records });
+}
+function YAMLED() { return XSS; }
+const big = { session: { id: 'mvs_big', truncated: true }, stats: { messages: n, turns: 40, durationMs: 900000, tokens: { totalTokens: 30000 } }, turns };
+
+const t0 = process.hrtime.bigint();
+const flat = sandbox.flattenTurns(big.turns);
+let matched = 0;
+for (const entry of flat) if (sandbox.matchesQuery(entry.record, 'x')) matched += 1;
+for (const entry of flat) sandbox.escapeHtml(sandbox.safeText(entry.record.summary));
+const t1 = process.hrtime.bigint();
+const elapsedMs = Number(t1 - t0) / 1e6;
+
+check('large fixture record count', flat.length, 3000);
+assert('large fixture search matches', matched > 0);
+assert('large fixture pipeline under 800ms (' + elapsedMs.toFixed(1) + 'ms)', elapsedMs < 800);
+assert('page window stays at 200 of 3000', Math.min(200, flat.length) === 200);
+check('window slicing keeps newest', flat.slice(flat.length - 200)[0].record.id, flat[flat.length - 200].record.id);
+assert('signature on large fixture stable', sandbox.signatureOf(big) === sandbox.signatureOf(big));
+
+/* ---------- 3) static policy checks on the delivered file ---------- */
+// An unterminated CSS comment silently swallows every rule after it, and the page
+// still renders — just unstyled. Compare the rule set with comments stripped so a
+// swallowed block fails here instead of showing up as a strange-looking button.
+const styleBlock = (html.match(/<style>([\s\S]*?)<\/style>/) || ['', ''])[1];
+const styleNoComments = styleBlock.replace(/\/\*[\s\S]*?\*\//g, '');
+const opensBeforeCloses = (styleBlock.match(/\/\*/g) || []).length - (styleBlock.match(/\*\//g) || []).length;
+assert('style block has balanced /* */ comments', opensBeforeCloses === 0);
+for (const selector of ['.tbtn', '.tbtn-icon', '.overview-plot', '.ov-span', '.window-bar', '.turn-head']) {
+  assert('css rule survives comment stripping: ' + selector, styleNoComments.includes(selector + ' {') || styleNoComments.includes(selector + ','));
+}
+
+// turnContext builds its string from turnContextParts, and turnContextSuffix calls
+// turnContext, so a check that wants to RUN any of them has to lift all three, in dependency
+// order. Lifting by regex is acceptable here because these are leaf functions ending in a
+// single `}` at a fixed indent; the alternative — moving them into the PURE block — would put
+// UI string helpers in the unit-tested core for no unit test's benefit.
+function fnSource(signature) {
+  const m = html.match(new RegExp(signature.replace(/[()]/g, '\\$&') + ' \\{[\\s\\S]*?\\n {6}\\}'));
+  return m ? m[0] : null;
+}
+function liftTurnFns() {
+  for (const name of [
+    'function turnContextParts(stats)',
+    'function turnContext(stats)',
+    'function turnContextSuffix(stats)',
+  ]) {
+    const src = fnSource(name);
+    if (!src) return false;
+    vm.runInContext(src, sandbox);
+  }
+  return true;
+}
+
+const checks = [
+  ['no remote http(s) resource', !/<(script|link|img|iframe)[^>]+(src|href)=["']https?:/i.test(html)],
+  ['no @import', !/@import/.test(html)],
+  ['no emoji', !/[\u{1F300}-\u{1FAFF}\u{2600}-\u{27BF}]/u.test(html)],
+  ['no gradient', !/gradient\(/i.test(html)],
+  ['no backdrop-filter glass', !/backdrop-filter/.test(html)],
+  ['no fixed h-screen', !/h-screen|100vh/.test(html)],
+  ['has --mcode-* tokens', (html.match(/--mcode-/g) || []).length > 40],
+  ['no --dsw-* leakage', !/--dsw-/.test(html)],
+  ['no remote font family names', !/JetBrains|Inter['"]?\s*,|@font-face/.test(html)],
+  ['innerHTML only on pre via jsonColorize', (html.match(/\.innerHTML/g) || []).length === 2],
+  ['lang zh-CN', /<html lang="zh-CN">/.test(html)],
+  ['title 会话轨迹', /<title>会话轨迹<\/title>/.test(html)],
+  ['AbortController used', /new AbortController\(\)/.test(html)],
+  ['no alert/confirm', !/\b(alert|confirm|prompt)\s*\(/.test(html)],
+  // The rule is "no session data in browser storage", not "never touch the storage
+  // API". The Duration button persists one boolean view preference, exactly as the
+  // reference implementation does, so the check looks at what is actually written
+  // rather than at whether the word localStorage appears anywhere.
+  ['no localStorage of domain data', (() => {
+    const allowed = /window\.localStorage\.(?:get|set)Item\(\s*DURATION_PREF_KEY\s*,?\s*(?:'true'\s*\|\s*'false'|value\s*\?\s*'true'\s*:\s*'false')?\s*\)/g;
+    const stripped = html.replace(allowed, '');
+    return !/localStorage|sessionStorage/.test(stripped);
+  })()],
+  ['duration preference stores only true/false', /DURATION_PREF_KEY = 'mmc-trajectory\.duration'/.test(html) && !/localStorage\.setItem\([^)]*state\./.test(html)],
+  ['reduced motion honored', /prefers-reduced-motion: reduce/.test(html)],
+  ['role=alert present', /role="alert"/.test(html)],
+  ['role=status present', (html.match(/role="status"/g) || []).length >= 3],
+  ['semantic header/main/section/footer/nav/form', ['<header', '<main', '<section', '<footer', '<nav', '<form'].every((tag) => html.includes(tag))],
+  ['semantic table rendered (static or via createElement)', html.includes('<table') || html.includes("el('table'")],
+  ['poll interval 2500ms', /POLL_INTERVAL = 2500/.test(html)],
+  ['handoff raw limit 8000', /HANDOFF_RAW_LIMIT = 8000/.test(html)],
+  ['all 6 append error codes handled', ['user_cancelled', 'invalid_request', 'text_too_large', 'not_allowed', 'target_unavailable', 'result_unknown'].every((c) => html.includes(c))],
+  // The type chips are the one filter. A second row of layer buttons was removed because a
+  // preset the reader can outgrow ends up contradicting the chips it was meant to summarise;
+  // these assertions are here so a future "simplify" or "restore" does not quietly bring
+  // it back, and so nobody re-adds a parallel copy of state.kinds.
+  ['no layer buttons in the markup', !/turns-btn|thinking-btn|calls-btn/.test(html)],
+  ['no layer machinery in the script', !/LAYER_KINDS|LAYER_ORDER|layerSelected|layerPartial|applyLayerToKinds|setLayerButton|dom\.turnsBtn|dom\.thinkingBtn|dom\.callsBtn/.test(html)],
+  // Every kind the server can emit has to be reachable as a control. A kind with no control
+// is a kind the reader cannot keep or drop on its own — which is exactly what compaction
+// was while it sat inside `system`. The list is written out rather than derived from the
+// markup so that adding a kind without one fails here instead of quietly shipping.
+// Derived from KIND_ORDER rather than written out, so adding a kind cannot leave this list
+// behind. It was hardcoded once and went stale the moment `steer` landed — the guard fired
+// correctly, but only because a human had to notice.
+['every kind has a control',
+  sandbox.KIND_ORDER.every((k) => html.includes('data-kind="' + k + '"'))],
+['every kind has exactly one control', (() => {
+  // A count alone is not enough: renaming one control to another kind keeps the count at
+  // 9 while leaving a kind unreachable and another listed twice. Compare the multiset.
+  // Written out on purpose rather than derived from KIND_ORDER — deriving it would make
+  // this compare the markup against itself and pass for any set of controls at all.
+  const found = [...html.matchAll(/class="tbtn tbtn-action" data-kind="([^"]+)"/g)].map((m) => m[1]);
+  const expected = ['user', 'steer', 'reply', 'narration', 'thinking', 'toolCall', 'toolResult', 'system', 'compaction'];
+  return found.length === expected.length
+    && expected.every((k) => found.filter((f) => f === k).length === 1);
+})()],
+['compaction is not filed under system', !/kind:\s*'system',\s*\n\s*title:\s*'compaction'/.test(readFileSync(SERVER, 'utf8'))],
+// Every kind button's visible word has to be the one in KIND_LABELS. The two used to be
+// written independently — the label in the markup, the accessible name in applyKindButton —
+// so renaming a kind half-applied: the button showed 问答 while announcing 答复. Neither
+// copy was wrong on its own and no other assertion could see the disagreement.
+['kind button labels match KIND_LABELS', (() => {
+  const buttons = [...html.matchAll(
+    /data-kind="(\w+)"[\s\S]{0,200}?class="tbtn-label">([^<]*)</g)];
+  if (buttons.length !== sandbox.KIND_ORDER.length) return false;
+  return sandbox.KIND_ORDER.every((k) => {
+    const hit = buttons.filter((b) => b[1] === k);
+    return hit.length === 1 && hit[0][2] === sandbox.KIND_LABELS[k];
+  });
+})()],
+['every kind button has a label span', (html.match(/class="tbtn-label"/g) || []).length === sandbox.KIND_ORDER.length],
+  // The window bar used to be rebuilt on every render, and a render happens every poll, so
+  // a click landing between the clear and the re-append went to a button that was no
+  // longer in the document. It is built once into its own container now; a rebuild is a
+  // regression of that, not a stylistic choice.
+  ['window bar is updated, not rebuilt', /windowBarParts = buildWindowBarParts\(\)/.test(html) && !/ledger\.appendChild\(buildWindowBar/.test(html)],
+  ['window bar container is static markup', /<div class="window-bar" id="window-bar"/.test(html)],
+  ['the axis button is built with the window bar, not hardcoded in the page', !/id="duration-btn"/.test(html) && /var axis = el\('button', 'tbtn tbtn-toggle window-bar-axis'\)/.test(html)],
+  ['the axis button is applied by a helper, not by two callers', /function applyAxisButton\(button\)/.test(html) && !/function renderViewControls/.test(html)],
+  // One filter means one writer per control and no parallel copy. Four controls assign
+  // state.kinds — the per-kind buttons, 全部, 清除筛选, and 异常's own reset, which has to put
+  // the axis back because in that mode the axis filters nothing and must not go on displaying a
+  // condition that is not in force. A fifth would be another path deciding what is on screen,
+  // which is what this check exists to catch; if one is ever genuinely wanted, change the check
+  // in the same commit that adds the control rather than loosening it silently.
+  ['state.kinds is written from exactly four controls', (html.match(/state\.kinds\s*=[^=]/g) || []).length === 4],
+  // That the fourth writer also updates the buttons is checked by verify-anomaly.mjs, not here:
+  // it is a property of 异常, and it needs a mutation control that mutate-anomaly.py can run.
+  // The breakdown is the only place the turn count explains itself, and its whole job is that
+  // the parts add up to the headline and that the first two add up to the reply count. Those
+  // were comments until a probe showed them wrong: the line used to read 已收尾 54 · 提问待答 5
+  // · 中断 4 while the comment claimed 已收尾 and the reply count were the same number. They
+  // were 54 and 59, because a turn that stops to ask gets its answer in the NEXT turn. The
+  // function is lifted out of the page and run against synthetic stats so the arithmetic is
+  // checked, not assumed.
+  ['turn breakdown parts sum to the headline', (() => {
+  const src = html.match(/function turnBreakdown\(stats\) \{[\s\S]*?\n {6}\}/);
+  if (!src) return false;
+  vm.runInContext(src[0], sandbox);
+  const cases = [
+    { turnsWithPrompt: 63, qaTurns: 5, openTurns: 9 },
+    { turnsWithPrompt: 0, qaTurns: 0, openTurns: 0 },
+    { turnsWithPrompt: 10, qaTurns: 0, openTurns: 0 },
+    { turnsWithPrompt: 10, qaTurns: 3, openTurns: 3 },
+    { turnsWithPrompt: 1, qaTurns: 1, openTurns: 1 },
+  ];
+  return cases.every((stats) => {
+    const line = sandbox.turnBreakdown(stats);
+    const nums = [...line.matchAll(/(\d[\d,]*)/g)].map((m) => Number(m[1].replace(/,/g, '')));
+    // Every number printed must be one of the three parts, and the parts must total the headline.
+    const sum = nums.reduce((a, n) => a + n, 0);
+    return sum === stats.turnsWithPrompt;
+  });
+})()],
+  // Scoped to the rendered label, not the whole file: the doc comment above turnContext
+  // explains why 续作答答 was renamed and has to be able to say so.
+  ['turn breakdown renders 提问轮, not 提问待答',
+    /'提问轮 ' \+ formatInt\(asked\)/.test(html) && !/'提问待答 ' \+ formatInt/.test(html) && !/'续作答答 ' \+ formatInt/.test(html)],
+  // The line under 对话轮次 is one string of `·`-separated parts, and a reader adds up what
+  // they see. The breakdown group sums to the headline; the context group does not belong to
+  // it. Shipping them unmarked is what made two disjoint fives (the turns that asked, and the
+  // prompt-less turns that answered) read as one number counted twice. The boundary word is
+  // the fix, so assert it is there rather than asserting the reader will notice.
+['context group is marked as a separate population', (() => {
+  if (!liftTurnFns()) return false;
+  const suffix = sandbox.turnContextSuffix({ steers: 15, compactionTurns: 10, continuationTurns: 5 });
+  // The boundary is the separator FOLLOWED by 另有. The leading `·` is what joins this group
+  // to the breakdown and must stay — an earlier version of this guard asserted it was absent,
+  // which was wrong: without it the two groups run together, which is the original defect.
+  return /·\s*另有\s/.test(suffix);
+})()],
+  // And the whole rendered line, as the reader receives it, still partitions correctly once
+  // the context group is set aside: the numbers before 另有 sum to the headline.
+  ['numbers before 另有 sum to the headline', (() => {
+  const line = sandbox.turnBreakdown({ turnsWithPrompt: 63, qaTurns: 5, openTurns: 9 })
+    + sandbox.turnContextSuffix({ steers: 15, compactionTurns: 10, continuationTurns: 5 });
+  const before = line.split('另有')[0];
+  const nums = [...before.matchAll(/(\d[\d,]*)/g)].map((m) => Number(m[1].replace(/,/g, '')));
+  return nums.reduce((a, n) => a + n, 0) === 63;
+})()],
+  // The two record-counting terms on the KPI line are the kind chips spelled inline. If they
+  // grew their own writer, state.kinds would have a fourth opinion and the number on the card
+  // could stop matching what the chip below it is actually showing — the same class of bug as
+  // the layer buttons that were deleted earlier. Scoped to this function's own source: an
+  // unbounded `[\s\S]*?` also reaches onKindToggle's legitimate assignment further down and
+  // reports a violation that is not there.
+  ['KPI kind links go through onKindToggle, not a second writer', (() => {
+  const src = fnSource('function turnSubNode(stats)');
+  if (!src) return false;
+  return /onKindToggle\(kind, state\.kinds\.indexOf\(kind\) < 0\)/.test(src)
+    && !/state\.kinds\s*=[^=]/.test(src);
+})()],
+  // ...and they read state at click time. A captured flag goes stale between the poll that
+  // re-rendered the card and the click, which shows up as a link whose look and its effect
+  // disagree — the exact failure the layer-button era had.
+  ['KPI kind links do not close over a rendered flag', (() => {
+  const src = fnSource('function turnSubNode(stats)');
+  return Boolean(src) && !/onKindToggle\([^)]*,\s*(?:on|true|false)\s*\)/.test(src);
+})()],
+  // Exactly the two terms that count records become controls. 续作轮 counts turns, as do the
+  // three breakdown terms, and a turn outcome is not a record kind — a 收尾 turn holds eight
+  // kinds at once, so no kind set can select it. Wiring those up would be a second axis
+  // wearing a kind's name.
+  ['exactly the record-counting context terms are links', (() => {
+  if (!liftTurnFns()) return false;
+  const parts = sandbox.turnContextParts({ steers: 15, compactions: 10, compactionTurns: 0, continuationTurns: 5 });
+  const linked = parts.filter((p) => p.kind).map((p) => p.kind).sort();
+  const unlinked = parts.filter((p) => !p.kind).map((p) => p.label);
+  return linked.length === 2
+    && linked[0] === 'compaction' && linked[1] === 'steer'
+    && unlinked.length === 1 && unlinked[0] === '续作轮'
+    // and each linked kind is a real kind with a chip behind it
+    && linked.every((k) => sandbox.KIND_ORDER.includes(k));
+})()],
+  // The fixture above carries `compactionTurns: 0` next to `compactions: 10` on purpose. A
+  // checkpoint is filed inside the turn it interrupted, so counting turns reports zero for every
+  // session that was ever compacted — which is the one thing the reader most wants to know. This
+  // guard fails the moment the term goes back to reading the turn count.
+  ['the compaction term counts checkpoints, not checkpoint-turns', (() => {
+  if (!liftTurnFns()) return false;
+  const parts = sandbox.turnContextParts({ steers: 0, compactions: 12, compactionTurns: 0, continuationTurns: 0 });
+  return parts.length === 1
+    && parts[0].label === '压缩'
+    && parts[0].value === '12'
+    && parts[0].kind === 'compaction';
+})()],
+  // The explanation has to exist on the card, be reachable without a mouse, and be named by
+  // aria-describedby rather than only by a `title` (which is invisible to touch and to most
+  // assistive tech once the hover is gone).
+  ['turn card carries an accessible explanation', (() => {
+  if (!/function turnTipLines\(stats\)/.test(html)) return false;
+  if (!/turnSubNode\(stats\),\s*\n\s*false,\s*\n\s*'kpi-tip-turns',\s*\n\s*turnTipLines\(stats\)/.test(html)) return false;
+  return /card\.setAttribute\('aria-describedby', tipId\)/.test(html)
+    && /tipNode\.setAttribute\('role', 'tooltip'\)/.test(html)
+    && /card\.classList\.add\('has-tip'\)/.test(html)
+    && /card\.setAttribute\('tabindex', '0'\)/.test(html);
+})()],
+  // Every term on the line has to be explained, or the tooltip is decoration. The breakdown's
+  // three terms, both linked context terms, and the unlinked one.
+  ['the tip explains every term on the line', (() => {
+  const src = fnSource('function turnTipLines(stats)');
+  if (!src) return false;
+  return ['收尾 ', '提问轮 ', '中断 ', '追加与压缩', '续作轮'].every((term) => src.includes(term));
+})()],
+  // 总数与序号不能共用一个词，而且总数旁边必须说出窗口实际覆盖的范围。The panel title printed
+  // stats.turns (every turn in the file) as 「轮次 82」 and a turn header printed turn.index as
+  // 「轮次 78」 — same two characters, two different quantities, which coincided while the
+  // newest turn had a row. That left a second, steadier trap: with a 200-record window the
+  // table can start at 第 81 轮 under a title saying 共 83 轮, because the window begins
+  // mid-session. Both numbers were right and nothing said so, so it read as a wrong total.
+  // 「共 N 轮」 can only be a total; 「第 N 轮」 can only be an ordinal; and the title must
+  // carry the visible range whenever the window does not cover the whole session.
+  ['panel title reads a total, turn headers read an ordinal', (() => {
+  const head = /var title = '第 ' \+ \(isCount\(turn\.index\) \? turn\.index : DASH\) \+ ' 轮';/;
+  if (!head.test(html)) return false;
+  return !/'轮次 ' \+ \(isCount\((?:turn|group\.turn)\.index\)/.test(html)
+    && !/'轮次 ' \+ turnIndex/.test(html)
+    && !/\? '轮次 ' \+ turn\.index : DASH/.test(html);
+})()],
+  // The panel title must describe the table and nothing else. It used to lead with
+  // 「共 84 轮」 — the session total — above a table whose first header read 第 82 轮, because
+  // the default window holds only the newest 200 records and turn 82 alone holds 183 of them.
+  // Both numbers were true and nothing said so, so the pair read as a contradiction, and the
+  // natural expectation ("these should be equal, equal to 84") could not be satisfied by any
+  // wording. The fix is not a better word: it is to stop putting two different scopes in the
+  // same spot. The title is now the rendered range; the session total moved to the window bar,
+  // next to the record counts it explains.
+  ['panel title states only the rendered turn range', (() => {
+  const src = fnSource('function turnRangeLabel(firstTurn, lastTurn)');
+  if (!src) return false;
+  if (/共 /.test(src)) return false;                       // no session total in the title
+  if (!/'第 ' \+ formatInt\(firstTurn\) \+ '–' \+ formatInt\(lastTurn\) \+ ' 轮'/.test(src)) return false;
+  return /'第 ' \+ formatInt\(firstTurn\) \+ ' 轮'/.test(src);
+})()],
+  ['the session total lives on the window bar instead', (() => {
+  const src = fnSource('function updateWindowBar(shown, hiddenAbove, total)');
+  if (!src) return false;
+  if (!/var sessionTurns = state\.payload && state\.payload\.stats \? state\.payload\.stats\.turns : null;/.test(src)) return false;
+  // Both readings of the count have to name it, not one of them. The bar shows 已显示 … once a
+  // window is settled and 正在显示 N / M … while a batched build is still running, and the two are
+  // separate statements rather than one text with a suffix. A mid-build line that quietly dropped
+  // the session total would leave the reader, mid-scroll through 18,924 rows, without the one
+  // number saying how much of the session is left — so each branch is pinned on its own, with its
+  // own indentation, rather than "the string appears somewhere in this function".
+  const branches = [
+    "          (isCount(sessionTurns) ? '全场 ' + formatInt(sessionTurns) + ' 轮 · ' : '') +\n"
+      + "          '共 ' + formatInt(total) + ' 条 · 已显示 '",
+    "            (isCount(sessionTurns) ? '全场 ' + formatInt(sessionTurns) + ' 轮 · ' : '') +\n"
+      + "            '共 ' + formatInt(total) + ' 条 · 正在显示 '"
+  ];
+  return branches.every((branch) => src.indexOf(branch) >= 0);
+})()],
+  ['the title is written after the groups are built', (() => {
+  // If it is set before `visibleTurns`, the range is not knowable and the label silently
+  // degrades — the exact defect, back again.
+  const at = html.indexOf('dom.ledgerMeta.textContent = turnRangeLabel');
+  const groupsAt = html.indexOf('var groups = visibleTurns(windowed)');
+  return at > 0 && groupsAt > 0 && at > groupsAt;
+})()],
+  // The window opens on the newest page, and the button names the ACTION rather than the state.
+  //
+  // It briefly opened on 全部, on the theory that a page hiding 8,000 records behind a click
+  // makes a poor first impression. Measured on this session that froze the page: ~9,900 rows
+  // and ~57,000 real DOM elements with no virtual scrolling, rebuilt every 2.5s poll — a
+  // single inspect took 13.7s. So 全部 is opt-in.
+  //
+  // The label went the other way twice and is now settled: it names what pressing the button
+  // will do. The count beside it already reports the current state, so a label restating the
+  // state spends its width saying nothing — at the default it read 只看最新 200 条 directly
+  // above 已显示 200 条. Action and report answer different questions and cannot contradict.
+  ['the window opens on the newest page, and the button names the action', (() => {
+  if (!/allRecords: false,/.test(html)) return false;
+  if (!/limit: PAGE_STEP,/.test(html)) return false;
+  if (!/var DEFAULT_WINDOW_MODE = 'latest';/.test(html)) return false;
+  const src = fnSource('function applyWindowMode(parts, hiddenAbove)');
+  if (!src) return false;
+  // Arms opposite to the count: allRecords true -> offer the page, false -> offer everything.
+  if (!/state\.allRecords \? '显示最新 ' \+ formatInt\(PAGE_STEP\) \+ ' 条' : '显示全部'/.test(src)) return false;
+  // aria-pressed stays on the state, which is why the accessible name repeats it.
+  if (!/'aria-pressed', state\.allRecords \? 'true' : 'false'/.test(src)) return false;
+  if (!/classList\.toggle\('btn-quiet', state\.allRecords\)/.test(src)) return false;
+  return /state\.allRecords \? '正在显示全部记录 · 点击改为只显示最新 ' \+ formatInt\(PAGE_STEP\) \+ ' 条'/.test(src);
+})()],
+  // One definition of the default, quoted by every reset. Eight call sites used to hard-code
+  // 'latest', so changing the default left all eight resetting to a window that may no longer
+  // be the default — a reader whose view was reset by any filter click would land somewhere
+  // nobody chose. The constant's value is checked by the guard above; this one checks only
+  // that the resets quote it rather than repeating it.
+  ['every window reset quotes the default, not a literal', (() => {
+  if (!/var DEFAULT_WINDOW_MODE = '(?:latest|all)'/.test(html)) return false;
+  const reset = fnSource('function resetWindowMode()');
+  if (!reset || !/setWindowMode\(DEFAULT_WINDOW_MODE\)/.test(reset)) return false;
+  // A reset must not read the window it is resetting; that preserves the value being discarded.
+  if (/state\.allRecords/.test(reset)) return false;
+  // No reset may name a mode literally. The only legitimate caller that reads state is the
+  // mode button, which *toggles* rather than resets — so the test is "does any call pass
+  // a literal", not "does any call avoid DEFAULT".
+  const resets = html.match(/setWindowMode\('(latest|all)'\);/g) || [];
+  if (resets.length) return false;
+  // One direct setWindowMode call: the toggle in buildWindowBarParts. Everything else goes
+  // through the helper. The \b matters — resetWindowMode contains the substring setWindowMode,
+  // and without it every reset counts as a direct call and the guard can never pass.
+  //
+  // The reset count is an inventory, not a rule: eight when every filter reset the window,
+  // ten since the time range gained resets on both sides of its own lifecycle, eleven once
+  // 异常 became a filter of its own and had to reset the window like the others do, and twelve
+  // once 异常 grew a way back — 全部数据 — which is a filter change like any other and would
+  // otherwise leave the reader on a stale window after leaving anomaly mode. It used to force
+  // 「全部」 instead of resetting, which would have shown up here as a second direct call — and
+  // measured, that cost a 414,000px document on a range covering the session.
+  const direct = (html.match(/\bsetWindowMode\((?!mode\)|DEFAULT_WINDOW_MODE)/g) || []).length;
+  return direct === 1 && (html.match(/resetWindowMode\(\);/g) || []).length === 12;
+})()],
+  // Clicking the window button must not move the page. It scrolled to the document tail
+  // whenever it narrowed the window, on the theory that "back to the tail" should land on the
+  // newest record. The reader clicked a control they were already looking at, so the jump threw
+  // away whatever they had been reading; renderLedger's row anchor is the correct behaviour.
+  ['the window button does not scroll the page', (() => {
+  const src = fnSource('function buildWindowBarParts()');
+  if (!src) return false;
+  const click = src.slice(src.indexOf('var mode = el('));
+  if (!click) return false;
+  // No scroll call inside the mode button's own handler.
+  return !/window\.scroll(To|By)/.test(click)
+    && /setWindowMode\(state\.allRecords \? 'latest' : 'all'\);\s*\n\s*renderLedger\(\);/.test(click);
+})()],
+  // `.btn` sets display:inline-flex, which outranks the user-agent [hidden] rule. So a `.btn`
+  // toggled off with .hidden stayed on screen — and 「向上加载更早的 N 条」 only wrote its label
+  // when it was showing, so on load it rendered as a bordered empty box between the axis toggle
+  // and the window button. Six other classes in this file already carry the patch; `.btn` was
+  // the one that was missed, and it is patched on the class rather than on the instance.
+  ['a .btn toggled with hidden is actually hidden', (() => {
+  // No space before the attribute selector: the rule reads `.btn[hidden]`, not `.btn [hidden]`.
+  // The brackets are escaped — unescaped, [hidden] is a character class and this can never
+  // match anything.
+  if (!/\n      \.btn\[hidden\] \{\n        display: none;\n      \}/.test(html)) return false;
+  // And the button that exposed it must not be blank even when hidden.
+  const mode = fnSource('function applyWindowMode(parts, hiddenAbove)');
+  if (!mode) return false;
+  return /parts\.more\.textContent = '向上加载更早的 ' \+ formatInt\(Math\.min\(PAGE_STEP, Math\.max\(hiddenAbove, 0\)\)\) \+ ' 条';/.test(mode)
+    && !/if \(hiddenAbove > 0\) \{\s*\n\s*parts\.more\.textContent/.test(mode);
+})()],
+  // 「向上加载更早的 N 条」 is meaningless in 全部: state.limit is Infinity, and Infinity + 200
+  // is still Infinity, so the click would re-render and change nothing. Hidden in that mode, but
+  // the guard keeps "it is hidden" from being the only thing standing between a reader and a
+  // dead button.
+  ['the load-more button does nothing in 全部 instead of pretending to', (() => {
+  const src = fnSource('function buildWindowBarParts()');
+  if (!src) return false;
+  const more = src.slice(src.indexOf('var more = el('), src.indexOf('var mode = el('));
+  if (!more) return false;
+  return /if \(state\.allRecords\) return;/.test(more)
+    && /state\.limit \+= PAGE_STEP;/.test(more);
+})()],
+  // `limit` above PAGE_STEP means the reader pressed 向上加载更早的 N 条. A poll that resets it
+  // takes that back silently, so the button re-renders and appears to do nothing — which is
+  // what it did: this session grows fast enough that the count looked unchanged either way.
+  // Only a limit that is still exactly PAGE_STEP is tail-following, and only that re-pins.
+  ['a poll does not undo a window the reader widened', (() => {
+  const src = fnSource('function rePinWindow()');
+  if (!src) return false;
+  if (!/if \(state\.allRecords\) return state\.limit;/.test(src)) return false;
+  return /if \(state\.limit > PAGE_STEP\) return state\.limit;/.test(src);
+})()],
+  // A checkpoint is drawn as a band, not as a row. It has to be routed there in the one place
+  // the ledger builds its list — routing it anywhere else would leave the row grid laying it out
+  // like ordinary work while the CSS sits unused.
+  ['a compaction record renders as a band, not as a row', (() => {
+  if (!/function buildCompactionBand\(entry\)/.test(html)) return false;
+  const render = fnSource('function renderLedger()');
+  if (!render) return false;
+  const loop = render.slice(render.indexOf('var rails = railStates('));
+  if (!loop) return false;
+  return /group\.entries\[j\]\.record\.kind === 'compaction'/.test(loop)
+    && /item\.className = 'compaction-cell'/.test(loop)
+    && /item\.appendChild\(buildCompactionBand\(group\.entries\[j\]\)\)/.test(loop);
+})()],
+  // The band is a real control: it carries the same data-row-id the inspector looks up, so
+  // clicking it opens the checkpoint's details rather than doing nothing.
+  ['the compaction band is selectable and states what it is', (() => {
+  const src = fnSource('function buildCompactionBand(entry)');
+  if (!src) return false;
+  return /setAttribute\('data-row-id', record\.id \|\| String\(record\.index\)\)/.test(src)
+    && /selectRecord\(record\.id\)/.test(src)
+    // The point of the band is that it says what changed, so the generation and the moment both
+    // have to be in it. Neither is decoration. The condition is matched whole: a mutation that
+    // hard-codes `opened` still leaves `record.generation` sitting in the branch it no longer
+    // reaches, and this has to fail on that.
+    && /var opened = isCount\(record\.generation\)/.test(src)
+    && /formatOffset\(record\.relativeMs\)/.test(src)
+    && /record\.index/.test(src);
+})()],
+  // `display: inline-flex` on the pills beat the UA `[hidden]` rule once already in this file, so a
+  // band that can be hidden needs its own rule rather than trusting the user-agent sheet.
+  ['the compaction band has its own styles, using defined tokens only', (() => {
+  if (!/\n      \.compaction-band \{/.test(html)) return false;
+  const block = html.slice(html.indexOf('\n      .compaction-band {'));
+  if (!block) return false;
+  const rule = block.slice(0, block.indexOf('\n      }'));
+  // Every custom property it names has to be one this file actually defines for both themes.
+  const used = [...rule.matchAll(/var\((--mcode-[a-z-]+)\)/g)].map((m) => m[1]);
+  const defined = new Set(
+    [...html.matchAll(/^\s*(--mcode-[a-z-]+):/gm)].map((m) => m[1])
+  );
+  return used.length > 0 && used.every((token) => defined.has(token));
+})()],
+  // ---- the 记录序号 column -------------------------------------------------
+  // The first grid track was 42px, which holds `#` plus four digits. A session that
+  // passed 10,000 records pushed the fifth digit out of the track, and a grid item is
+  // `overflow: visible` by default, so the digit spilled into the kind column and was
+  // painted over by the opaque pill: `#10950`..`#10959` all read `#1095`. Ten rows in a
+  // row showed the reader one number, and unlike a wrong number that one cannot be
+  // checked — it looks exactly like a real index.
+  //
+  // The requirement below is derived rather than asserted. The old track held five
+  // characters and would not hold six, so one character is at most 42 / 5 = 8.4px. A
+  // label is `#` plus at most seven digits, so 8 characters need at most 67.2px.
+  ['the 序号 column is wide enough for the label it must show', (() => {
+    const labelChars = 8;
+    const maxCharPx = 42 / 5;
+    const required = Math.ceil(labelChars * maxCharPx);
+    const hits = [...html.matchAll(/--traj-index-col:\s*(\d+)px/g)];
+    // Exactly one declaration: a second one would be a value some of these tracks use
+    // and the rest do not, which is the drift this constant exists to prevent.
+    if (hits.length !== 1) return false;
+    return Number(hits[0][1]) >= required;
+  })()],
+  ['every grid that renders a 序号 uses the shared column', (() => {
+    const rules = [
+      ['.row', /\n {6}\.row \{[^}]*?grid-template-columns:\s*([^;]+);/s],
+      ['.compaction-band', /\n {6}\.compaction-band \{[^}]*?grid-template-columns:\s*([^;]+);/s],
+      ['.skeleton-row', /\n {6}\.skeleton-row \{[^}]*?grid-template-columns:\s*([^;]+);/s],
+      // The narrow-screen override is the one that used to shrink this track to 28px.
+      ['narrow override', /\n {8}\.row,\n {8}\.skeleton-row \{[^}]*?grid-template-columns:\s*([^;]+);/s]
+    ];
+    return rules.every(([, pattern]) => {
+      const match = pattern.exec(html);
+      return !!match && match[1].trim().startsWith('var(--traj-index-col)');
+    });
+  })()],
+  // The 时间区间 pickers must be sized by their own content. A `datetime-local` is laid out by
+  // the browser from the localized date it has to draw, so a width in the stylesheet is a guess
+  // about something the user agent already knows — and the guess was made twice and wrong both
+  // times: 18ch clipped the year off the text box that preceded it, and 20ch clipped the minutes
+  // behind the calendar icon on the picker itself. What must not come back is a fixed width, or
+  // a flex context that lets the toolbar squeeze the control, which is the same clipping by
+  // another route.
+  ['the 时间区间 pickers are sized by their content, not by a fixed width', (() => {
+    const rule = /\n {6}\.range-input \{([^}]*)\}/.exec(html);
+    if (!rule) return false;
+    if (/^\s*(min-)?width\s*:/m.test(rule[1])) return false;
+    return /flex:\s*none;/.test(rule[1]);
+  })()],
+  // Exactly one rule: a second one could carry the width this is here to prevent.
+  ['and no later rule gives the 时间区间 pickers a width', (() => {
+    const rules = [...html.matchAll(/\.range-input[^{]*\{([^}]*)\}/g)];
+    return rules.length === 1 && !/^\s*(min-)?width\s*:/m.test(rules[0][1]);
+  })()],
+  // Containment is what turns a future width regression from a lie into a visible
+  // ellipsis. The digit spilling onto the pill is the whole defect: both the missing
+  // digit and the number it was hiding are invisible, and the row reads as a
+  // different, entirely valid index.
+  ['a 序号 that still does not fit is ellipsised, never spilled onto the pill', (() => {
+    const start = html.indexOf('\n      .row-index {');
+    if (start < 0) return false;
+    const rule = html.slice(start, html.indexOf('\n      }', start));
+    return /overflow:\s*hidden/.test(rule)
+      && /text-overflow:\s*ellipsis/.test(rule)
+      && /white-space:\s*nowrap/.test(rule);
+  })()],
+];
+for (const [name, ok] of checks) {
+  if (ok) pass += 1;
+  else failures.push('policy: ' + name);
+}
+
+console.log('[2] pure helpers: ' + pass + ' passed, ' + failures.length + ' failed');
+if (failures.length) {
+  console.log('FAILURES:\n - ' + failures.join('\n - '));
+  process.exit(1);
+}
+console.log('[3] static policy checks: PASS');
+console.log('OK  (large-fixture pipeline ' + elapsedMs.toFixed(1) + 'ms for 3000 records)');
diff --git a/plugins/avatasia/mmc-trajectory/tests/fixtures/minimax-home/v2/sessions/fixture-agent/00-00-00-000-session_fixture00/manifest.json b/plugins/avatasia/mmc-trajectory/tests/fixtures/minimax-home/v2/sessions/fixture-agent/00-00-00-000-session_fixture00/manifest.json
new file mode 100644
index 0000000..888d847
--- /dev/null
+++ b/plugins/avatasia/mmc-trajectory/tests/fixtures/minimax-home/v2/sessions/fixture-agent/00-00-00-000-session_fixture00/manifest.json
@@ -0,0 +1,4 @@
+{
+  "sessionId": "mvs_00000000000000000000000000000001",
+  "createdAtMs": 1750000000000
+}
\ No newline at end of file
diff --git a/plugins/avatasia/mmc-trajectory/tests/fixtures/minimax-home/v2/sessions/fixture-agent/00-00-00-000-session_fixture00/messages.jsonl b/plugins/avatasia/mmc-trajectory/tests/fixtures/minimax-home/v2/sessions/fixture-agent/00-00-00-000-session_fixture00/messages.jsonl
new file mode 100644
index 0000000..f4832d2
--- /dev/null
+++ b/plugins/avatasia/mmc-trajectory/tests/fixtures/minimax-home/v2/sessions/fixture-agent/00-00-00-000-session_fixture00/messages.jsonl
@@ -0,0 +1,60 @@
+{"message_id":"msg-0000","turn_id":"turn-001","message":{"role":"user","content":[{"type":"text","text":"<system-reminder>\nfixture injected-0001 block"}],"timestamp":1791603931910,"canonicalTextRange":{"startOffset":5109,"endOffset":5722}}}
+{"message_id":"msg-0002","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-0003 placeholder","thinkingSignature":"fixture text-0004 placeholder"},{"type":"text","text":"fixture text-0005 placeholder"},{"type":"toolCall","id":"call_0000","name":"tool_00","arguments":{"name":"tool_01"}}],"api":"fixture text-0006 placeholder","provider":"fixture text-0007 placeholder","model":"fixture text-0008 placeholder","usage":{"input":44829,"output":432,"cacheRead":4224,"cacheWrite":0,"totalTokens":49485,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791603931971,"responseId":"fixture text-0009 placeholder"}}
+{"message_id":"msg-000a","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0000","toolName":"tool_00","content":[{"type":"text","text":"fixture text-000b placeholder"}],"details":{"kind":"skill","skill":"fixture text-000c placeholder","found":true,"readable":true,"owner":"fixture text-000d placeholder","source":"fixture text-000e placeholder","location":"fixture text-000f placeholder"},"isError":false,"timestamp":1791603943228}}
+{"message_id":"msg-000g","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-000h placeholder","thinkingSignature":"fixture text-000i placeholder"},{"type":"text","text":"fixture text-000j placeholder"},{"type":"toolCall","id":"call_0001","name":"tool_02","arguments":{"task_id":"fixture text-000k placeholder"}}],"api":"fixture text-000l placeholder","provider":"fixture text-000m placeholder","model":"fixture text-000n placeholder","usage":{"input":4210,"output":82,"cacheRead":76544,"cacheWrite":0,"totalTokens":80836,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604127714,"responseId":"fixture text-000o placeholder"}}
+{"message_id":"msg-000p","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"toolCall","id":"call_0002","name":"tool_02","arguments":{"task_id":"fixture text-000q placeholder","wait_ms":30000}}],"api":"fixture text-000r placeholder","provider":"fixture text-000s placeholder","model":"fixture text-000t placeholder","usage":{"input":268,"output":62,"cacheRead":102144,"cacheWrite":0,"totalTokens":102474,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604504788,"responseId":"fixture text-000u placeholder"}}
+{"message_id":"msg-000v","turn_id":"turn-001","message":{"role":"user","content":"fixture text-000w placeholder","timestamp":1791604626776}}
+{"message_id":"msg-000x","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"toolCall","id":"call_0003","name":"tool_03","arguments":{"command":"fixture text-000y placeholder","description":"fixture text-000z placeholder"}}],"api":"fixture text-0010 placeholder","provider":"fixture text-0011 placeholder","model":"fixture text-0012 placeholder","usage":{"input":2672,"output":61,"cacheRead":113536,"cacheWrite":0,"totalTokens":116269,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604764455,"responseId":"fixture text-0013 placeholder"}}
+{"message_id":"msg-0014","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0004","toolName":"tool_03","content":[{"type":"text","text":"fixture text-0015 placeholder"}],"details":{"execution":{"status":"fixture text-0016 placeholder","reason":"fixture text-0017 placeholder","exitCode":1,"message":"fixture text-0018 placeholder"},"timing":{"commandTimeoutSeconds":3600,"commandTimerStartedAt":1791604878663,"commandDeadlineAt":1791608478663},"output":{"rawBytes":644,"persistence":"fixture text-0019 placeholder","omittedBytes":0},"processOutput":{"stdout":"fixture text-001a placeholder","stderr":"fixture text-001b placeholder","exitCode":1,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false,"rawOutputPath":"fixture text-001c placeholder"},"description":"fixture text-001d placeholder","fullOutputPath":"fixture text-001e placeholder","status":"fixture text-001f placeholder","task_id":"fixture text-001g placeholder","is_error":true},"isError":true,"timestamp":1791604879414}}
+{"message_id":"msg-001h","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"toolCall","id":"call_0005","name":"tool_03","arguments":{"command":"fixture text-001i placeholder","description":"fixture text-001j placeholder"}}],"api":"fixture text-001k placeholder","provider":"fixture text-001l placeholder","model":"fixture text-001m placeholder","usage":{"input":142,"output":107,"cacheRead":135424,"cacheWrite":0,"totalTokens":135673,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604894030,"responseId":"fixture text-001n placeholder"}}
+{"message_id":"msg-001o","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"toolCall","id":"call_0006","name":"tool_03","arguments":{"command":"fixture text-001p placeholder","description":"fixture text-001q placeholder"}}],"api":"fixture text-001r placeholder","provider":"fixture text-001s placeholder","model":"fixture text-001t placeholder","usage":{"input":714,"output":176,"cacheRead":167040,"cacheWrite":0,"totalTokens":167930,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791605044287,"responseId":"fixture text-001u placeholder"}}
+{"message_id":"msg-001v","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-001w placeholder","thinkingSignature":"fixture text-001x placeholder"},{"type":"toolCall","id":"call_0007","name":"tool_04","arguments":{"action":"fixture text-001y placeholder","input":{"kind":"text","maxChars":600,"selector":"fixture text-001z placeholder"}}}],"api":"fixture text-0020 placeholder","provider":"fixture text-0021 placeholder","model":"fixture text-0022 placeholder","usage":{"input":832,"output":316,"cacheRead":178688,"cacheWrite":0,"totalTokens":179836,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791605219170,"responseId":"fixture text-0023 placeholder"}}
+{"message_id":"msg-0024","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-0025 placeholder","thinkingSignature":"fixture text-0026 placeholder"},{"type":"toolCall","id":"call_0008","name":"tool_04","arguments":{"action":"fixture text-0027 placeholder","input":{"selector":"fixture text-0028 placeholder"}}}],"api":"fixture text-0029 placeholder","provider":"fixture text-002a placeholder","model":"fixture text-002b placeholder","usage":{"input":100,"output":91,"cacheRead":194176,"cacheWrite":0,"totalTokens":194367,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791605423541,"responseId":"fixture text-002c placeholder"}}
+{"message_id":"msg-002d","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"text","text":"fixture text-002e placeholder"}],"api":"fixture text-002f placeholder","provider":"fixture text-002g placeholder","model":"fixture text-002h placeholder","usage":{"input":59,"output":897,"cacheRead":203392,"cacheWrite":0,"totalTokens":204348,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"stop","timestamp":1791605485479,"responseId":"fixture text-002i placeholder"}}
+{"message_id":"msg-002j","turn_id":"turn-002","message":{"role":"assistant","content":[{"type":"toolCall","id":"call_0009","name":"tool_05","arguments":{"limit":30,"offset":1618,"path":"fixture text-002k placeholder"}}],"api":"fixture text-002l placeholder","provider":"fixture text-002m placeholder","model":"fixture text-002n placeholder","usage":{"input":1658,"output":69,"cacheRead":210432,"cacheWrite":0,"totalTokens":212159,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791605691616,"responseId":"fixture text-002o placeholder"}}
+{"message_id":"msg-002p","turn_id":"turn-003","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-002q placeholder","thinkingSignature":"fixture text-002r placeholder"},{"type":"text","text":"fixture text-002s placeholder"},{"type":"toolCall","id":"call_0010","name":"tool_06","arguments":{"todos":[{"content":"fixture text-002t placeholder","priority":"fixture text-002u placeholder","status":"fixture text-002v placeholder"},{"content":"fixture text-002w placeholder","priority":"fixture text-002x placeholder","status":"fixture text-002y placeholder"},{"content":"fixture text-002z placeholder","priority":"fixture text-0030 placeholder","status":"fixture text-0031 placeholder"},{"content":"fixture text-0032 placeholder","priority":"fixture text-0033 placeholder","status":"fixture text-0034 placeholder"},{"content":"fixture text-0035 placeholder","priority":"fixture text-0036 placeholder","status":"fixture text-0037 placeholder"}]}}],"api":"fixture text-0038 placeholder","provider":"fixture text-0039 placeholder","model":"fixture text-003a placeholder","usage":{"input":2260,"output":2251,"cacheRead":220800,"cacheWrite":0,"totalTokens":225311,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791606195742,"responseId":"fixture text-003b placeholder"}}
+{"message_id":"msg-003c","turn_id":"turn-003","message":{"role":"toolResult","toolCallId":"call_0011","toolName":"tool_07","content":[{"type":"text","text":"fixture text-003d placeholder"}],"details":{"created":true,"bytes_written":1777,"encoding":"fixture text-003e placeholder","bom":false},"isError":false,"timestamp":1791606432109}}
+{"message_id":"msg-003f","turn_id":"turn-004","message":{"role":"assistant","content":[{"type":"toolCall","id":"call_0012","name":"tool_03","arguments":{"command":"fixture text-003g placeholder","description":"fixture text-003h placeholder"}}],"api":"fixture text-003i placeholder","provider":"fixture text-003j placeholder","model":"fixture text-003k placeholder","usage":{"input":254227,"output":405,"cacheRead":4224,"cacheWrite":0,"totalTokens":258856,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791610762301,"responseId":"fixture text-003l placeholder"}}
+{"message_id":"msg-003m","turn_id":"turn-004","message":{"role":"toolResult","toolCallId":"call_0013","toolName":"tool_03","content":[{"type":"text","text":"fixture text-003n placeholder"}],"details":{"execution":{"status":"fixture text-003o placeholder","reason":"fixture text-003p placeholder","exitCode":0},"timing":{"commandTimeoutSeconds":3600,"commandTimerStartedAt":1791610981057,"commandDeadlineAt":1791614581057},"output":{"rawBytes":218,"persistence":"fixture text-003q placeholder","omittedBytes":0},"processOutput":{"stdout":"fixture text-003r placeholder","stderr":"fixture text-003s placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false,"rawOutputPath":"fixture text-003t placeholder"},"description":"fixture text-003u placeholder","fullOutputPath":"fixture text-003v placeholder","status":"fixture text-003w placeholder","task_id":"fixture text-003x placeholder"},"isError":false,"timestamp":1791610983663}}
+{"message_id":"msg-003y","turn_id":"turn-004","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-003z placeholder","thinkingSignature":"fixture text-0040 placeholder"},{"type":"text","text":"fixture text-0041 placeholder"},{"type":"toolCall","id":"call_0014","name":"tool_08","arguments":{"file_path":"fixture text-0042 placeholder","new_string":"fixture text-0043 placeholder","old_string":"fixture text-0044 placeholder"}}],"api":"fixture text-0045 placeholder","provider":"fixture text-0046 placeholder","model":"fixture text-0047 placeholder","usage":{"input":4226,"output":759,"cacheRead":272896,"cacheWrite":0,"totalTokens":277881,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791611180154,"responseId":"fixture text-0048 placeholder"}}
+{"message_id":"msg-0049","turn_id":"turn-005","message":{"role":"toolResult","toolCallId":"call_0015","toolName":"tool_03","content":[{"type":"text","text":"fixture text-004a placeholder"}],"details":{"execution":{"status":"fixture text-004b placeholder","reason":"fixture text-004c placeholder","exitCode":0},"timing":{"commandTimeoutSeconds":3600,"commandTimerStartedAt":1791611784292,"commandDeadlineAt":1791615384292},"output":{"rawBytes":1402,"persistence":"fixture text-004d placeholder","omittedBytes":0},"processOutput":{"stdout":"fixture text-004e placeholder","stderr":"fixture text-004f placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false,"rawOutputPath":"fixture text-004g placeholder"},"description":"fixture text-004h placeholder","fullOutputPath":"fixture text-004i placeholder","envSanitized":["fixture text-004j placeholder","fixture text-004k placeholder","fixture text-004l placeholder","fixture text-004m placeholder","fixture text-004n placeholder"],"status":"fixture text-004o placeholder","task_id":"fixture text-004p placeholder"},"isError":false,"timestamp":1791611784883}}
+{"message_id":"msg-004q","turn_id":"turn-006","message":{"role":"toolResult","toolCallId":"call_0016","toolName":"tool_07","content":[{"type":"text","text":"fixture text-004r placeholder"}],"details":{"created":true,"bytes_written":384,"encoding":"fixture text-004s placeholder","bom":false},"isError":false,"timestamp":1791612294290}}
+{"message_id":"msg-004t","turn_id":"turn-007","message":{"role":"compactionSummary","summary":"fixture text-004u placeholder","tokensBefore":365642,"timestamp":1791613412089}}
+{"message_id":"msg-004v","turn_id":"turn-008","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-004w placeholder","thinkingSignature":"fixture text-004x placeholder"},{"type":"text","text":"fixture text-004y placeholder"},{"type":"toolCall","id":"call_0017","name":"tool_09","arguments":{"pattern":"fixture text-004z placeholder","path":"fixture text-0050 placeholder","output_mode":"fixture text-0051 placeholder"}},{"type":"toolCall","id":"call_0018","name":"tool_09","arguments":{"pattern":"fixture text-0052 placeholder","path":"fixture text-0053 placeholder","output_mode":"fixture text-0054 placeholder","limit":30}}],"api":"fixture text-0055 placeholder","provider":"fixture text-0056 placeholder","model":"fixture text-0057 placeholder","usage":{"input":2171,"output":429,"cacheRead":54272,"cacheWrite":0,"totalTokens":56872,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791613490565,"responseId":"fixture text-0058 placeholder"}}
+{"message_id":"msg-0059","turn_id":"turn-009","message":{"role":"toolResult","toolCallId":"call_0019","toolName":"tool_09","content":[{"type":"text","text":"fixture text-005a placeholder"}],"details":{},"isError":false,"timestamp":1791614563489}}
+{"message_id":"msg-005b","turn_id":"turn-009","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-005c placeholder","thinkingSignature":"fixture text-005d placeholder"},{"type":"text","text":"fixture text-005e placeholder"},{"type":"toolCall","id":"call_0020","name":"tool_05","arguments":{"path":"fixture text-005f placeholder","limit":14}}],"api":"fixture text-005g placeholder","provider":"fixture text-005h placeholder","model":"fixture text-005i placeholder","usage":{"input":634,"output":1426,"cacheRead":120019,"cacheWrite":0,"totalTokens":122079,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791614731831,"responseId":"fixture text-005j placeholder"}}
+{"message_id":"msg-005k","turn_id":"turn-010","message":{"role":"user","content":[{"type":"text","text":"fixture text-005l placeholder"}],"timestamp":1791615045716,"canonicalTextRange":{"startOffset":0,"endOffset":10},"hostMetadata":{"immediateSendBatchId":"fixture text-005m placeholder"}}}
+{"message_id":"msg-005n","turn_id":"turn-011","message":{"role":"toolResult","toolCallId":"call_0021","toolName":"tool_03","content":[{"type":"text","text":"fixture text-005o placeholder"}],"details":{"execution":{"status":"fixture text-005p placeholder","reason":"fixture text-005q placeholder","exitCode":0},"timing":{"commandTimeoutSeconds":3600,"commandTimerStartedAt":1791615476257,"commandDeadlineAt":1791619076257},"output":{"rawBytes":557,"persistence":"fixture text-005r placeholder","omittedBytes":0},"processOutput":{"stdout":"fixture text-005s placeholder","stderr":"fixture text-005t placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false,"rawOutputPath":"fixture text-005u placeholder"},"description":"fixture text-005v placeholder","fullOutputPath":"fixture text-005w placeholder","status":"fixture text-005x placeholder","task_id":"fixture text-005y placeholder"},"isError":false,"timestamp":1791615477302}}
+{"message_id":"msg-005z","turn_id":"turn-011","message":{"role":"toolResult","toolCallId":"call_0022","toolName":"tool_03","content":[{"type":"text","text":"fixture text-0060 placeholder"}],"details":{"execution":{"status":"fixture text-0061 placeholder","reason":"fixture text-0062 placeholder","exitCode":0},"timing":{"commandTimeoutSeconds":3600,"commandTimerStartedAt":1791615900851,"commandDeadlineAt":1791619500851},"output":{"rawBytes":634,"persistence":"fixture text-0063 placeholder","omittedBytes":0},"processOutput":{"stdout":"fixture text-0064 placeholder","stderr":"fixture text-0065 placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false,"rawOutputPath":"fixture text-0066 placeholder"},"description":"fixture text-0067 placeholder","fullOutputPath":"fixture text-0068 placeholder","status":"fixture text-0069 placeholder","task_id":"fixture text-006a placeholder"},"isError":false,"timestamp":1791615904587}}
+{"message_id":"msg-006b","turn_id":"turn-012","message":{"role":"assistant","content":[{"type":"toolCall","id":"call_0023","name":"tool_08","arguments":{"file_path":"fixture text-006c placeholder","new_string":"fixture text-006d placeholder","old_string":"fixture text-006e placeholder"}}],"api":"fixture text-006f placeholder","provider":"fixture text-006g placeholder","model":"fixture text-006h placeholder","usage":{"input":806,"output":332,"cacheRead":215296,"cacheWrite":0,"totalTokens":216434,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791616197977,"responseId":"fixture text-006i placeholder"}}
+{"message_id":"msg-006j","turn_id":"turn-012","message":{"role":"toolResult","toolCallId":"call_0024","toolName":"tool_08","content":[{"type":"text","text":"fixture text-006k placeholder"}],"details":{"diff":"fixture text-006l placeholder","patch":"fixture text-006m placeholder","firstChangedLine":19},"isError":false,"timestamp":1791616341161}}
+{"message_id":"msg-006n","turn_id":"turn-013","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-006o placeholder","thinkingSignature":"fixture text-006p placeholder"},{"type":"text","text":"fixture text-006q placeholder"},{"type":"toolCall","id":"call_0025","name":"tool_03","arguments":{"command":"fixture text-006r placeholder","description":"fixture text-006s placeholder","timeout":120}}],"api":"fixture text-006t placeholder","provider":"fixture text-006u placeholder","model":"fixture text-006v placeholder","usage":{"input":2780,"output":1648,"cacheRead":257536,"cacheWrite":0,"totalTokens":261964,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791616657094,"responseId":"fixture text-006w placeholder"}}
+{"message_id":"msg-006x","turn_id":"turn-014","message":{"role":"toolResult","toolCallId":"call_0026","toolName":"tool_07","content":[{"type":"text","text":"fixture text-006y placeholder"}],"details":{"created":true,"bytes_written":4484,"encoding":"fixture text-006z placeholder","bom":false},"isError":false,"timestamp":1791617021128}}
+{"message_id":"msg-0070","turn_id":"turn-015","message":{"role":"assistant","content":[{"type":"toolCall","id":"call_0027","name":"tool_05","arguments":{"limit":40,"offset":2108,"path":"fixture text-0071 placeholder"}}],"api":"fixture text-0072 placeholder","provider":"fixture text-0073 placeholder","model":"fixture text-0074 placeholder","usage":{"input":1087,"output":70,"cacheRead":312832,"cacheWrite":0,"totalTokens":313989,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791617468106,"responseId":"fixture text-0075 placeholder"}}
+{"message_id":"msg-0076","turn_id":"turn-016","message":{"role":"user","content":[{"type":"text","text":"<system-reminder>\nfixture injected-0077 block"}],"timestamp":1791617651220,"canonicalTextRange":{"startOffset":3003,"endOffset":3066}}}
+{"message_id":"msg-0078","turn_id":"turn-016","message":{"role":"assistant","content":[{"type":"toolCall","id":"call_0028","name":"tool_03","arguments":{"command":"fixture text-0079 placeholder","description":"fixture text-007a placeholder","timeout":240}}],"api":"fixture text-007b placeholder","provider":"fixture text-007c placeholder","model":"fixture text-007d placeholder","usage":{"input":859,"output":309,"cacheRead":349952,"cacheWrite":0,"totalTokens":351120,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791617812028,"responseId":"fixture text-007e placeholder"}}
+{"message_id":"msg-007f","turn_id":"turn-016","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-007g placeholder","thinkingSignature":"fixture text-007h placeholder"},{"type":"toolCall","id":"call_0029","name":"tool_09","arguments":{"context":2,"limit":8,"output_mode":"fixture text-007i placeholder","path":"fixture text-007j placeholder","pattern":"fixture text-007k placeholder"}}],"api":"fixture text-007l placeholder","provider":"fixture text-007m placeholder","model":"fixture text-007n placeholder","usage":{"input":1825,"output":630,"cacheRead":68352,"cacheWrite":0,"totalTokens":70807,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791618043996,"responseId":"fixture text-007o placeholder"}}
+{"message_id":"msg-007p","turn_id":"turn-016","message":{"role":"toolResult","toolCallId":"call_0030","toolName":"tool_05","content":[{"type":"text","text":"fixture text-007q placeholder"}],"details":{"textFile":{"path":"fixture text-007r placeholder","content":"fixture text-007s placeholder","numLines":14,"startLine":1231,"totalLines":2912,"truncatedByOutputLimit":false,"wholeFileAutoTruncated":false}},"isError":false,"timestamp":1791618210903}}
+{"message_id":"msg-007t","turn_id":"turn-016","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-007u placeholder","thinkingSignature":"fixture text-007v placeholder"},{"type":"toolCall","id":"call_0031","name":"tool_03","arguments":{"command":"fixture text-007w placeholder","description":"fixture text-007x placeholder","timeout":420}}],"api":"fixture text-007y placeholder","provider":"fixture text-007z placeholder","model":"fixture text-0080 placeholder","usage":{"input":79,"output":189,"cacheRead":89856,"cacheWrite":0,"totalTokens":90124,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791618408954,"responseId":"fixture text-0081 placeholder"}}
+{"message_id":"msg-0082","turn_id":"turn-016","message":{"role":"toolResult","toolCallId":"call_0032","toolName":"tool_03","content":[{"type":"text","text":"fixture text-0083 placeholder"}],"details":{"execution":{"status":"fixture text-0084 placeholder","reason":"fixture text-0085 placeholder","exitCode":0},"timing":{"commandTimeoutSeconds":300,"commandTimerStartedAt":1791618643593,"commandDeadlineAt":1791618943593},"output":{"rawBytes":174,"persistence":"fixture text-0086 placeholder","omittedBytes":0},"processOutput":{"stdout":"fixture text-0087 placeholder","stderr":"fixture text-0088 placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false,"rawOutputPath":"fixture text-0089 placeholder"},"description":"fixture text-008a placeholder","fullOutputPath":"fixture text-008b placeholder","status":"fixture text-008c placeholder","task_id":"fixture text-008d placeholder"},"isError":false,"timestamp":1791618644926}}
+{"message_id":"msg-008e","turn_id":"turn-017","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-008f placeholder","thinkingSignature":"fixture text-008g placeholder"},{"type":"toolCall","id":"call_0033","name":"tool_03","arguments":{"command":"fixture text-008h placeholder","description":"fixture text-008i placeholder","timeout":120}}],"api":"fixture text-008j placeholder","provider":"fixture text-008k placeholder","model":"fixture text-008l placeholder","usage":{"input":452,"output":939,"cacheRead":118656,"cacheWrite":0,"totalTokens":120047,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791619060246,"responseId":"fixture text-008m placeholder"}}
+{"message_id":"msg-008n","turn_id":"turn-017","message":{"role":"toolResult","toolCallId":"call_0034","toolName":"tool_08","content":[{"type":"text","text":"fixture text-008o placeholder"}],"details":{"diff":"fixture text-008p placeholder","patch":"fixture text-008q placeholder","firstChangedLine":1127},"isError":false,"timestamp":1791619266573}}
+{"message_id":"msg-008r","turn_id":"turn-017","message":{"role":"toolResult","toolCallId":"call_0035","toolName":"tool_08","content":[{"type":"text","text":"fixture text-008s placeholder"}],"details":{"diff":"fixture text-008t placeholder","patch":"fixture text-008u placeholder","firstChangedLine":1185},"isError":false,"timestamp":1791619441758}}
+{"message_id":"msg-008v","turn_id":"turn-017","message":{"role":"toolResult","toolCallId":"call_0036","toolName":"tool_03","content":[{"type":"text","text":"fixture text-008w placeholder"}],"details":{"execution":{"status":"fixture text-008x placeholder","reason":"fixture text-008y placeholder","exitCode":1,"message":"fixture text-008z placeholder"},"timing":{"commandTimeoutSeconds":180,"commandTimerStartedAt":1791619594718,"commandDeadlineAt":1791619774718},"output":{"rawBytes":929,"persistence":"fixture text-0090 placeholder","omittedBytes":0},"processOutput":{"stdout":"fixture text-0091 placeholder","stderr":"fixture text-0092 placeholder","exitCode":1,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false,"rawOutputPath":"fixture text-0093 placeholder"},"description":"fixture text-0094 placeholder","fullOutputPath":"fixture text-0095 placeholder","status":"fixture text-0096 placeholder","task_id":"fixture text-0097 placeholder","is_error":true},"isError":true,"timestamp":1791619595453}}
+{"message_id":"msg-0098","turn_id":"turn-017","message":{"role":"assistant","content":[{"type":"toolCall","id":"call_0037","name":"tool_04","arguments":{"action":"fixture text-0099 placeholder","input":{}}}],"api":"fixture text-009a placeholder","provider":"fixture text-009b placeholder","model":"fixture text-009c placeholder","usage":{"input":3978,"output":36,"cacheRead":162816,"cacheWrite":0,"totalTokens":166830,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791619777303,"responseId":"fixture text-009d placeholder"}}
+{"message_id":"msg-009e","turn_id":"turn-017","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-009f placeholder","thinkingSignature":"fixture text-009g placeholder"},{"type":"toolCall","id":"call_0038","name":"tool_03","arguments":{"command":"fixture text-009h placeholder","description":"fixture text-009i placeholder","timeout":180}}],"api":"fixture text-009j placeholder","provider":"fixture text-009k placeholder","model":"fixture text-009l placeholder","usage":{"input":625,"output":823,"cacheRead":184832,"cacheWrite":0,"totalTokens":186280,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791620008455,"responseId":"fixture text-009m placeholder"}}
+{"message_id":"msg-009n","turn_id":"turn-017","message":{"role":"toolResult","toolCallId":"call_0039","toolName":"tool_04","content":[{"type":"text","text":"fixture text-009o placeholder"}],"details":{},"isError":true,"timestamp":1791620261774}}
+{"message_id":"msg-009p","turn_id":"turn-017","message":{"role":"toolResult","toolCallId":"call_0040","toolName":"tool_10","content":[{"type":"text","text":"fixture text-009q placeholder"}],"details":{"kind":"memory","ok":true,"target":"fixture text-009r placeholder"},"isError":false,"timestamp":1791620468950}}
+{"message_id":"msg-009s","turn_id":"turn-018","message":{"role":"toolResult","toolCallId":"call_0041","toolName":"tool_08","content":[{"type":"text","text":"fixture text-009t placeholder"}],"details":{"diff":"fixture text-009u placeholder","patch":"fixture text-009v placeholder","firstChangedLine":1545},"isError":false,"timestamp":1791620759811}}
+{"message_id":"msg-009w","turn_id":"turn-018","message":{"role":"assistant","content":[{"type":"toolCall","id":"call_0042","name":"tool_03","arguments":{"command":"fixture text-009x placeholder","description":"fixture text-009y placeholder","timeout":120}}],"api":"fixture text-009z placeholder","provider":"fixture text-00a0 placeholder","model":"fixture text-00a1 placeholder","usage":{"input":1473,"output":346,"cacheRead":255104,"cacheWrite":0,"totalTokens":256923,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791621014224,"responseId":"fixture text-00a2 placeholder"}}
+{"message_id":"msg-00a3","turn_id":"turn-018","message":{"role":"toolResult","toolCallId":"call_0043","toolName":"tool_03","content":[{"type":"text","text":"fixture text-00a4 placeholder"}],"details":{"execution":{"status":"fixture text-00a5 placeholder","reason":"fixture text-00a6 placeholder","exitCode":0},"timing":{"commandTimeoutSeconds":180,"commandTimerStartedAt":1791621281302,"commandDeadlineAt":1791621461302},"output":{"rawBytes":29,"persistence":"fixture text-00a7 placeholder","omittedBytes":0},"processOutput":{"stdout":"fixture text-00a8 placeholder","stderr":"fixture text-00a9 placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false,"rawOutputPath":"fixture text-00aa placeholder"},"description":"fixture text-00ab placeholder","fullOutputPath":"fixture text-00ac placeholder","status":"fixture text-00ad placeholder","task_id":"fixture text-00ae placeholder"},"isError":false,"timestamp":1791621281924}}
+{"message_id":"msg-00af","turn_id":"turn-019","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-00ag placeholder","thinkingSignature":"fixture text-00ah placeholder"},{"type":"toolCall","id":"call_0044","name":"tool_03","arguments":{"command":"fixture text-00ai placeholder","description":"fixture text-00aj placeholder","timeout":180}}],"api":"fixture text-00ak placeholder","provider":"fixture text-00al placeholder","model":"fixture text-00am placeholder","usage":{"input":2297,"output":1329,"cacheRead":277632,"cacheWrite":0,"totalTokens":281258,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791621759959,"responseId":"fixture text-00an placeholder"}}
+{"message_id":"msg-00ao","turn_id":"turn-019","message":{"role":"toolResult","toolCallId":"call_0045","toolName":"tool_04","content":[{"type":"text","text":"fixture text-00ap placeholder"}],"details":{"action":"fixture text-00aq placeholder","result":{"success":true,"duration":5000}},"isError":false,"timestamp":1791622044235}}
+{"message_id":"msg-00ar","turn_id":"turn-020","message":{"role":"assistant","content":[{"type":"toolCall","id":"call_0046","name":"tool_11","arguments":{"action":"fixture text-00as placeholder","pluginId":"fixture text-00at placeholder","sourcePath":"fixture text-00au placeholder"}}],"api":"fixture text-00av placeholder","provider":"fixture text-00aw placeholder","model":"fixture text-00ax placeholder","usage":{"input":11033,"output":69,"cacheRead":299264,"cacheWrite":0,"totalTokens":310366,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791622638009,"responseId":"fixture text-00ay placeholder"}}
+{"message_id":"msg-00az","turn_id":"turn-021","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-00b0 placeholder","thinkingSignature":"fixture text-00b1 placeholder"},{"type":"text","text":"fixture text-00b2 placeholder"},{"type":"toolCall","id":"call_0047","name":"tool_03","arguments":{"command":"fixture text-00b3 placeholder","description":"fixture text-00b4 placeholder","timeout":300}}],"api":"fixture text-00b5 placeholder","provider":"fixture text-00b6 placeholder","model":"fixture text-00b7 placeholder","usage":{"input":175,"output":244,"cacheRead":319744,"cacheWrite":0,"totalTokens":320163,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791623384388,"responseId":"fixture text-00b8 placeholder"}}
+{"message_id":"msg-00b9","turn_id":"turn-022","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-00ba placeholder","thinkingSignature":"fixture text-00bb placeholder"},{"type":"text","text":"fixture text-00bc placeholder"},{"type":"toolCall","id":"call_0048","name":"tool_12","arguments":{"task_id":"fixture text-00bd placeholder","reason":"fixture text-00be placeholder"}}],"api":"fixture text-00bf placeholder","provider":"fixture text-00bg placeholder","model":"fixture text-00bh placeholder","usage":{"input":4906,"output":149,"cacheRead":56576,"cacheWrite":0,"totalTokens":61631,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791624351892,"responseId":"fixture text-00bi placeholder"}}
+{"message_id":"msg-00bj","turn_id":"turn-022","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-00bk placeholder","thinkingSignature":"fixture text-00bl placeholder"},{"type":"toolCall","id":"call_0049","name":"tool_02","arguments":{"task_id":"fixture text-00bm placeholder","wait_ms":30000}}],"api":"fixture text-00bn placeholder","provider":"fixture text-00bo placeholder","model":"fixture text-00bp placeholder","usage":{"input":4023,"output":283,"cacheRead":98560,"cacheWrite":0,"totalTokens":102866,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791624527065,"responseId":"fixture text-00bq placeholder"}}
+{"message_id":"msg-00br","turn_id":"turn-022","message":{"role":"user","content":[{"type":"text","text":"<background-task-finished>\nfixture injected-00bs block"}],"timestamp":1791624769221,"canonicalTextRange":{"startOffset":496,"endOffset":496},"hostMetadata":{"backgroundTaskOrigin":{"kind":"background-task-terminal","taskIds":["fixture text-00bt placeholder"],"observedTerminalCount":330}}}}
+{"message_id":"msg-00bu","turn_id":"turn-022","message":{"role":"toolResult","toolCallId":"call_0050","toolName":"tool_08","content":[{"type":"text","text":"fixture text-00bv placeholder"}],"details":{"diff":"fixture text-00bw placeholder","patch":"fixture text-00bx placeholder","firstChangedLine":1987},"isError":false,"timestamp":1791624899122}}
+{"message_id":"msg-00by","turn_id":"turn-022","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-00bz placeholder","thinkingSignature":"fixture text-00c0 placeholder"},{"type":"toolCall","id":"call_0051","name":"tool_03","arguments":{"command":"fixture text-00c1 placeholder","description":"fixture text-00c2 placeholder"}}],"api":"fixture text-00c3 placeholder","provider":"fixture text-00c4 placeholder","model":"fixture text-00c5 placeholder","usage":{"input":684,"output":238,"cacheRead":179712,"cacheWrite":0,"totalTokens":180634,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791625062330,"responseId":"fixture text-00c6 placeholder"}}
+{"message_id":"msg-00c7","turn_id":"turn-023","message":{"role":"assistant","content":[],"api":"fixture text-00c8 placeholder","provider":"fixture text-00c9 placeholder","model":"fixture text-00ca placeholder","usage":{"input":1188,"output":82,"cacheRead":267008,"cacheWrite":0,"totalTokens":268278,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"stop","timestamp":1791627571957,"responseId":"fixture text-00cb placeholder"}}
diff --git a/plugins/avatasia/mmc-trajectory/tests/fixtures/minimax-home/v2/sessions/fixture-agent/00-00-01-000-session_fixture01/manifest.json b/plugins/avatasia/mmc-trajectory/tests/fixtures/minimax-home/v2/sessions/fixture-agent/00-00-01-000-session_fixture01/manifest.json
new file mode 100644
index 0000000..7d311d4
--- /dev/null
+++ b/plugins/avatasia/mmc-trajectory/tests/fixtures/minimax-home/v2/sessions/fixture-agent/00-00-01-000-session_fixture01/manifest.json
@@ -0,0 +1,4 @@
+{
+  "sessionId": "mvs_00000000000000000000000000000002",
+  "createdAtMs": 1750000001000
+}
\ No newline at end of file
diff --git a/plugins/avatasia/mmc-trajectory/tests/fixtures/minimax-home/v2/sessions/fixture-agent/00-00-01-000-session_fixture01/messages.jsonl b/plugins/avatasia/mmc-trajectory/tests/fixtures/minimax-home/v2/sessions/fixture-agent/00-00-01-000-session_fixture01/messages.jsonl
new file mode 100644
index 0000000..94d4573
--- /dev/null
+++ b/plugins/avatasia/mmc-trajectory/tests/fixtures/minimax-home/v2/sessions/fixture-agent/00-00-01-000-session_fixture01/messages.jsonl
@@ -0,0 +1,60 @@
+{"message_id":"msg-00bu","turn_id":"turn-001","message":{"role":"user","content":[{"type":"text","text":"<system-reminder>\nfixture injected-00bv block"}],"timestamp":1791624423621,"canonicalTextRange":{"startOffset":3858,"endOffset":3858}}}
+{"message_id":"msg-00bw","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"text","text":"fixture text-00bx placeholder"},{"type":"toolCall","id":"call_0058","name":"tool_01","arguments":{"command":"fixture text-00by placeholder","description":"fixture text-00bz placeholder"}}],"api":"fixture text-00c0 placeholder","provider":"fixture text-00c1 placeholder","model":"fixture text-00c2 placeholder","usage":{"input":9997,"output":158,"cacheRead":188,"cacheWrite":0,"totalTokens":10343,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791624423646,"responseId":"fixture text-00c3 placeholder"}}
+{"message_id":"msg-00c4","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0058","toolName":"tool_01","content":[{"type":"text","text":"fixture text-00c5 placeholder"}],"details":{"execution":{"status":"fixture text-00c6 placeholder","reason":"fixture text-00c7 placeholder","exitCode":0},"timing":{"commandTimerStartedAt":1791624425417,"commandDeadlineAt":1791624545417,"commandTimeoutSeconds":120},"output":{"rawBytes":3519,"persistence":"fixture text-00c8 placeholder"},"processOutput":{"stdout":"fixture text-00c9 placeholder","stderr":"fixture text-00ca placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false},"envSanitized":["fixture text-00cb placeholder","fixture text-00cc placeholder","fixture text-00cd placeholder","fixture text-00ce placeholder","fixture text-00cf placeholder"],"description":"fixture text-00cg placeholder"},"isError":false,"timestamp":1791624426055}}
+{"message_id":"msg-00ch","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-00ci placeholder","thinkingSignature":"fixture text-00cj placeholder"},{"type":"text","text":"fixture text-00ck placeholder"},{"type":"toolCall","id":"call_0059","name":"tool_00","arguments":{"path":"fixture text-00cl placeholder"}}],"api":"fixture text-00cm placeholder","provider":"fixture text-00cn placeholder","model":"fixture text-00co placeholder","usage":{"input":1055,"output":85,"cacheRead":10185,"cacheWrite":0,"totalTokens":11325,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791624426069,"responseId":"fixture text-00cp placeholder"}}
+{"message_id":"msg-00cq","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0059","toolName":"tool_00","content":[{"type":"text","text":"fixture text-00cr placeholder"}],"details":{"textFile":{"path":"fixture text-00cs placeholder","content":"fixture text-00ct placeholder","numLines":739,"startLine":1,"totalLines":740,"truncatedByOutputLimit":false,"wholeFileAutoTruncated":false},"desktop_output_truncation":{"truncated":true,"has_more":true,"strategy":"fixture text-00cu placeholder","original_bytes":32703,"returned_bytes":24519,"max_bytes":24576,"next_offset":565,"offset_unit":"fixture text-00cv placeholder","continuation_hint":{"tool":"fixture text-00cw placeholder","preserve_args":["fixture text-00cx placeholder"],"instruction":"fixture text-00cy placeholder"}},"desktop_output_continuation":{"has_more":true,"next_offset":565,"offset_unit":"fixture text-00cz placeholder","continuation_hint":{"tool":"fixture text-00d0 placeholder","preserve_args":["fixture text-00d1 placeholder"],"instruction":"fixture text-00d2 placeholder"}}},"isError":false,"timestamp":1791624427338}}
+{"message_id":"msg-00d3","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-00d4 placeholder","thinkingSignature":"fixture text-00d5 placeholder"},{"type":"toolCall","id":"call_0060","name":"tool_00","arguments":{"path":"fixture text-00d6 placeholder","offset":565}}],"api":"fixture text-00d7 placeholder","provider":"fixture text-00d8 placeholder","model":"fixture text-00d9 placeholder","usage":{"input":7154,"output":67,"cacheRead":11240,"cacheWrite":0,"totalTokens":18461,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791624427358,"responseId":"fixture text-00da placeholder"}}
+{"message_id":"msg-00db","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0060","toolName":"tool_00","content":[{"type":"text","text":"fixture text-00dc placeholder"}],"details":{"textFile":{"path":"fixture text-00dd placeholder","content":"fixture text-00de placeholder","numLines":175,"startLine":565,"totalLines":740,"truncatedByOutputLimit":false,"wholeFileAutoTruncated":false}},"isError":false,"timestamp":1791624429267}}
+{"message_id":"msg-00df","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-00dg placeholder","thinkingSignature":"fixture text-00dh placeholder"},{"type":"text","text":"fixture text-00di placeholder"},{"type":"toolCall","id":"call_0061","name":"tool_00","arguments":{"path":"fixture text-00dj placeholder"}}],"api":"fixture text-00dk placeholder","provider":"fixture text-00dl placeholder","model":"fixture text-00dm placeholder","usage":{"input":2119,"output":115,"cacheRead":18394,"cacheWrite":0,"totalTokens":20628,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791624429284,"responseId":"fixture text-00dn placeholder"}}
+{"message_id":"msg-00do","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0061","toolName":"tool_00","content":[{"type":"text","text":"fixture text-00dp placeholder"}],"details":{"textFile":{"path":"fixture text-00dq placeholder","content":"fixture text-00dr placeholder","numLines":327,"startLine":1,"totalLines":328,"truncatedByOutputLimit":false,"wholeFileAutoTruncated":false}},"isError":false,"timestamp":1791624435417}}
+{"message_id":"msg-00ds","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-00dt placeholder","thinkingSignature":"fixture text-00du placeholder"},{"type":"text","text":"fixture text-00dv placeholder"},{"type":"toolCall","id":"call_0062","name":"tool_03","arguments":{"pattern":"fixture text-00dw placeholder","path":"fixture text-00dx placeholder","output_mode":"fixture text-00dy placeholder","limit":200}}],"api":"fixture text-00dz placeholder","provider":"fixture text-00e0 placeholder","model":"fixture text-00e1 placeholder","usage":{"input":3525,"output":167,"cacheRead":20513,"cacheWrite":0,"totalTokens":24205,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791624435436,"responseId":"fixture text-00e2 placeholder"}}
+{"message_id":"msg-00e3","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0062","toolName":"tool_03","content":[{"type":"text","text":"fixture text-00e4 placeholder"}],"details":{},"isError":false,"timestamp":1791624437393}}
+{"message_id":"msg-00e5","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-00e6 placeholder","thinkingSignature":"fixture text-00e7 placeholder"},{"type":"toolCall","id":"call_0063","name":"tool_00","arguments":{"path":"fixture text-00e8 placeholder","limit":200}}],"api":"fixture text-00e9 placeholder","provider":"fixture text-00ea placeholder","model":"fixture text-00eb placeholder","usage":{"input":902,"output":93,"cacheRead":24038,"cacheWrite":0,"totalTokens":25033,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791624437460,"responseId":"fixture text-00ec placeholder"}}
+{"message_id":"msg-00ed","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0063","toolName":"tool_00","content":[{"type":"text","text":"fixture text-00ee placeholder"}],"details":{"textFile":{"path":"fixture text-00ef placeholder","content":"fixture text-00eg placeholder","numLines":200,"startLine":1,"totalLines":1182,"truncatedByOutputLimit":false,"wholeFileAutoTruncated":false}},"isError":false,"timestamp":1791624439234}}
+{"message_id":"msg-00eh","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-00ei placeholder","thinkingSignature":"fixture text-00ej placeholder"},{"type":"toolCall","id":"call_0064","name":"tool_00","arguments":{"limit":250,"offset":200,"path":"fixture text-00ek placeholder"}}],"api":"fixture text-00el placeholder","provider":"fixture text-00em placeholder","model":"fixture text-00en placeholder","usage":{"input":2589,"output":90,"cacheRead":24940,"cacheWrite":0,"totalTokens":27619,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791624439252,"responseId":"fixture text-00eo placeholder"}}
+{"message_id":"msg-00ep","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0064","toolName":"tool_00","content":[{"type":"text","text":"fixture text-00eq placeholder"}],"details":{"textFile":{"path":"fixture text-00er placeholder","content":"fixture text-00es placeholder","numLines":250,"startLine":200,"totalLines":1182,"truncatedByOutputLimit":false,"wholeFileAutoTruncated":false}},"isError":false,"timestamp":1791624440781}}
+{"message_id":"msg-00et","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"toolCall","id":"call_0065","name":"tool_00","arguments":{"limit":240,"offset":450,"path":"fixture text-00eu placeholder"}}],"api":"fixture text-00ev placeholder","provider":"fixture text-00ew placeholder","model":"fixture text-00ex placeholder","usage":{"input":3260,"output":66,"cacheRead":27529,"cacheWrite":0,"totalTokens":30855,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791624440801,"responseId":"fixture text-00ey placeholder"}}
+{"message_id":"msg-00ez","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0065","toolName":"tool_00","content":[{"type":"text","text":"fixture text-00f0 placeholder"}],"details":{"textFile":{"path":"fixture text-00f1 placeholder","content":"fixture text-00f2 placeholder","numLines":240,"startLine":450,"totalLines":1182,"truncatedByOutputLimit":false,"wholeFileAutoTruncated":false}},"isError":false,"timestamp":1791624441904}}
+{"message_id":"msg-00f3","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-00f4 placeholder","thinkingSignature":"fixture text-00f5 placeholder"},{"type":"toolCall","id":"call_0066","name":"tool_00","arguments":{"limit":310,"offset":690,"path":"fixture text-00f6 placeholder"}}],"api":"fixture text-00f7 placeholder","provider":"fixture text-00f8 placeholder","model":"fixture text-00f9 placeholder","usage":{"input":3141,"output":101,"cacheRead":30789,"cacheWrite":0,"totalTokens":34031,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791624441925,"responseId":"fixture text-00fa placeholder"}}
+{"message_id":"msg-00fb","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0066","toolName":"tool_00","content":[{"type":"text","text":"fixture text-00fc placeholder"}],"details":{"textFile":{"path":"fixture text-00fd placeholder","content":"fixture text-00fe placeholder","numLines":310,"startLine":690,"totalLines":1182,"truncatedByOutputLimit":false,"wholeFileAutoTruncated":false}},"isError":false,"timestamp":1791624444271}}
+{"message_id":"msg-00ff","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-00fg placeholder","thinkingSignature":"fixture text-00fh placeholder"},{"type":"text","text":"fixture text-00fi placeholder"},{"type":"toolCall","id":"call_0067","name":"tool_00","arguments":{"path":"fixture text-00fj placeholder"}}],"api":"fixture text-00fk placeholder","provider":"fixture text-00fl placeholder","model":"fixture text-00fm placeholder","usage":{"input":4254,"output":193,"cacheRead":33930,"cacheWrite":0,"totalTokens":38377,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791624444301,"responseId":"fixture text-00fn placeholder"}}
+{"message_id":"msg-00fo","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0067","toolName":"tool_00","content":[{"type":"text","text":"fixture text-00fp placeholder"}],"details":{"textFile":{"path":"fixture text-00fq placeholder","content":"fixture text-00fr placeholder","numLines":147,"startLine":1,"totalLines":148,"truncatedByOutputLimit":false,"wholeFileAutoTruncated":false}},"isError":false,"timestamp":1791624446572}}
+{"message_id":"msg-00fs","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-00ft placeholder","thinkingSignature":"fixture text-00fu placeholder"},{"type":"text","text":"fixture text-00fv placeholder"},{"type":"toolCall","id":"call_0068","name":"tool_03","arguments":{"limit":120,"output_mode":"fixture text-00fw placeholder","path":"fixture text-00fx placeholder","pattern":"fixture text-00fy placeholder"}}],"api":"fixture text-00fz placeholder","provider":"fixture text-00g0 placeholder","model":"fixture text-00g1 placeholder","usage":{"input":2132,"output":168,"cacheRead":38184,"cacheWrite":0,"totalTokens":40484,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791624446594,"responseId":"fixture text-00g2 placeholder"}}
+{"message_id":"msg-00g3","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0068","toolName":"tool_03","content":[{"type":"text","text":"fixture text-00g4 placeholder"}],"details":{"matchLimitReached":120},"isError":false,"timestamp":1791624449165}}
+{"message_id":"msg-00g5","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-00g6 placeholder","thinkingSignature":"fixture text-00g7 placeholder"},{"type":"toolCall","id":"call_0069","name":"tool_03","arguments":{"limit":80,"output_mode":"fixture text-00g8 placeholder","path":"fixture text-00g9 placeholder","pattern":"fixture text-00ga placeholder","offset":0}}],"api":"fixture text-00gb placeholder","provider":"fixture text-00gc placeholder","model":"fixture text-00gd placeholder","usage":{"input":2347,"output":179,"cacheRead":40316,"cacheWrite":0,"totalTokens":42842,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791624449186,"responseId":"fixture text-00ge placeholder"}}
+{"message_id":"msg-00gf","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0069","toolName":"tool_03","content":[{"type":"text","text":"fixture text-00gg placeholder"}],"details":{},"isError":false,"timestamp":1791624451277}}
+{"message_id":"msg-00gh","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"toolCall","id":"call_0070","name":"tool_00","arguments":{"limit":70,"offset":595,"path":"fixture text-00gi placeholder"}}],"api":"fixture text-00gj placeholder","provider":"fixture text-00gk placeholder","model":"fixture text-00gl placeholder","usage":{"input":503,"output":69,"cacheRead":42663,"cacheWrite":0,"totalTokens":43235,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791624451299,"responseId":"fixture text-00gm placeholder"}}
+{"message_id":"msg-00gn","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0070","toolName":"tool_00","content":[{"type":"text","text":"fixture text-00go placeholder"}],"details":{"textFile":{"path":"fixture text-00gp placeholder","content":"fixture text-00gq placeholder","numLines":70,"startLine":595,"totalLines":3519,"truncatedByOutputLimit":false,"wholeFileAutoTruncated":false}},"isError":false,"timestamp":1791624453361}}
+{"message_id":"msg-00gr","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-00gs placeholder","thinkingSignature":"fixture text-00gt placeholder"},{"type":"toolCall","id":"call_0071","name":"tool_03","arguments":{"limit":60,"output_mode":"fixture text-00gu placeholder","path":"fixture text-00gv placeholder","pattern":"fixture text-00gw placeholder"}}],"api":"fixture text-00gx placeholder","provider":"fixture text-00gy placeholder","model":"fixture text-00gz placeholder","usage":{"input":960,"output":197,"cacheRead":43166,"cacheWrite":0,"totalTokens":44323,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791624453380,"responseId":"fixture text-00h0 placeholder"}}
+{"message_id":"msg-00h1","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0071","toolName":"tool_03","content":[{"type":"text","text":"fixture text-00h2 placeholder"}],"details":{},"isError":false,"timestamp":1791624455703}}
+{"message_id":"msg-00h3","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-00h4 placeholder","thinkingSignature":"fixture text-00h5 placeholder"},{"type":"toolCall","id":"call_0072","name":"tool_03","arguments":{"limit":60,"output_mode":"fixture text-00h6 placeholder","path":"fixture text-00h7 placeholder","pattern":"fixture text-00h8 placeholder"}}],"api":"fixture text-00h9 placeholder","provider":"fixture text-00ha placeholder","model":"fixture text-00hb placeholder","usage":{"input":363,"output":220,"cacheRead":44126,"cacheWrite":0,"totalTokens":44709,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791624455724,"responseId":"fixture text-00hc placeholder"}}
+{"message_id":"msg-00hd","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0072","toolName":"tool_03","content":[{"type":"text","text":"fixture text-00he placeholder"}],"details":{"matchLimitReached":60},"isError":false,"timestamp":1791624463239}}
+{"message_id":"msg-00hf","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-00hg placeholder","thinkingSignature":"fixture text-00hh placeholder"},{"type":"toolCall","id":"call_0073","name":"tool_00","arguments":{"path":"fixture text-00hi placeholder"}}],"api":"fixture text-00hj placeholder","provider":"fixture text-00hk placeholder","model":"fixture text-00hl placeholder","usage":{"input":1695,"output":195,"cacheRead":44489,"cacheWrite":0,"totalTokens":46379,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791624463262,"responseId":"fixture text-00hm placeholder"}}
+{"message_id":"msg-00hn","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0073","toolName":"tool_00","content":[{"type":"text","text":"fixture text-00ho placeholder"}],"details":{"textFile":{"path":"fixture text-00hp placeholder","content":"fixture text-00hq placeholder","numLines":83,"startLine":1,"totalLines":84,"truncatedByOutputLimit":false,"wholeFileAutoTruncated":false}},"isError":false,"timestamp":1791624466737}}
+{"message_id":"msg-00hr","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-00hs placeholder","thinkingSignature":"fixture text-00ht placeholder"},{"type":"toolCall","id":"call_0074","name":"tool_00","arguments":{"path":"fixture text-00hu placeholder"}}],"api":"fixture text-00hv placeholder","provider":"fixture text-00hw placeholder","model":"fixture text-00hx placeholder","usage":{"input":1160,"output":168,"cacheRead":46184,"cacheWrite":0,"totalTokens":47512,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791624466759,"responseId":"fixture text-00hy placeholder"}}
+{"message_id":"msg-00hz","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0074","toolName":"tool_00","content":[{"type":"text","text":"fixture text-00i0 placeholder"}],"details":{"textFile":{"path":"fixture text-00i1 placeholder","content":"fixture text-00i2 placeholder","numLines":35,"startLine":1,"totalLines":36,"truncatedByOutputLimit":false,"wholeFileAutoTruncated":false}},"isError":false,"timestamp":1791624468564}}
+{"message_id":"msg-00i3","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-00i4 placeholder","thinkingSignature":"fixture text-00i5 placeholder"},{"type":"toolCall","id":"call_0075","name":"tool_00","arguments":{"limit":120,"offset":2160,"path":"fixture text-00i6 placeholder"}}],"api":"fixture text-00i7 placeholder","provider":"fixture text-00i8 placeholder","model":"fixture text-00i9 placeholder","usage":{"input":596,"output":195,"cacheRead":47344,"cacheWrite":0,"totalTokens":48135,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791624468590,"responseId":"fixture text-00ia placeholder"}}
+{"message_id":"msg-00ib","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0075","toolName":"tool_00","content":[{"type":"text","text":"fixture text-00ic placeholder"}],"details":{"textFile":{"path":"fixture text-00id placeholder","content":"fixture text-00ie placeholder","numLines":120,"startLine":2160,"totalLines":3519,"truncatedByOutputLimit":false,"wholeFileAutoTruncated":false}},"isError":false,"timestamp":1791624471434}}
+{"message_id":"msg-00if","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-00ig placeholder","thinkingSignature":"fixture text-00ih placeholder"},{"type":"toolCall","id":"call_0076","name":"tool_00","arguments":{"limit":150,"offset":2620,"path":"fixture text-00ii placeholder"}}],"api":"fixture text-00ij placeholder","provider":"fixture text-00ik placeholder","model":"fixture text-00il placeholder","usage":{"input":1993,"output":102,"cacheRead":47940,"cacheWrite":0,"totalTokens":50035,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791624471462,"responseId":"fixture text-00im placeholder"}}
+{"message_id":"msg-00in","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0076","toolName":"tool_00","content":[{"type":"text","text":"fixture text-00io placeholder"}],"details":{"textFile":{"path":"fixture text-00ip placeholder","content":"fixture text-00iq placeholder","numLines":150,"startLine":2620,"totalLines":3519,"truncatedByOutputLimit":false,"wholeFileAutoTruncated":false}},"isError":false,"timestamp":1791624473170}}
+{"message_id":"msg-00ir","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-00is placeholder","thinkingSignature":"fixture text-00it placeholder"},{"type":"toolCall","id":"call_0077","name":"tool_00","arguments":{"limit":150,"offset":2770,"path":"fixture text-00iu placeholder"}}],"api":"fixture text-00iv placeholder","provider":"fixture text-00iw placeholder","model":"fixture text-00ix placeholder","usage":{"input":2317,"output":129,"cacheRead":49933,"cacheWrite":0,"totalTokens":52379,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791624473196,"responseId":"fixture text-00iy placeholder"}}
+{"message_id":"msg-00iz","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0077","toolName":"tool_00","content":[{"type":"text","text":"fixture text-00j0 placeholder"}],"details":{"textFile":{"path":"fixture text-00j1 placeholder","content":"fixture text-00j2 placeholder","numLines":150,"startLine":2770,"totalLines":3519,"truncatedByOutputLimit":false,"wholeFileAutoTruncated":false}},"isError":false,"timestamp":1791624474943}}
+{"message_id":"msg-00j3","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-00j4 placeholder","thinkingSignature":"fixture text-00j5 placeholder"},{"type":"toolCall","id":"call_0078","name":"tool_00","arguments":{"limit":105,"offset":2515,"path":"fixture text-00j6 placeholder"}}],"api":"fixture text-00j7 placeholder","provider":"fixture text-00j8 placeholder","model":"fixture text-00j9 placeholder","usage":{"input":2028,"output":179,"cacheRead":52250,"cacheWrite":0,"totalTokens":54457,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791624475077,"responseId":"fixture text-00ja placeholder"}}
+{"message_id":"msg-00jb","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0078","toolName":"tool_00","content":[{"type":"text","text":"fixture text-00jc placeholder"}],"details":{"textFile":{"path":"fixture text-00jd placeholder","content":"fixture text-00je placeholder","numLines":105,"startLine":2515,"totalLines":3519,"truncatedByOutputLimit":false,"wholeFileAutoTruncated":false}},"isError":false,"timestamp":1791624478597}}
+{"message_id":"msg-00jf","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-00jg placeholder","thinkingSignature":"fixture text-00jh placeholder"},{"type":"toolCall","id":"call_0079","name":"tool_03","arguments":{"context":3,"output_mode":"fixture text-00ji placeholder","path":"fixture text-00jj placeholder","pattern":"fixture text-00jk placeholder"}}],"api":"fixture text-00jl placeholder","provider":"fixture text-00jm placeholder","model":"fixture text-00jn placeholder","usage":{"input":1517,"output":346,"cacheRead":54278,"cacheWrite":0,"totalTokens":56141,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791624478622,"responseId":"fixture text-00jo placeholder"}}
+{"message_id":"msg-00jp","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0079","toolName":"tool_03","content":[{"type":"text","text":"fixture text-00jq placeholder"}],"details":{},"isError":false,"timestamp":1791624482818}}
+{"message_id":"msg-00jr","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-00js placeholder","thinkingSignature":"fixture text-00jt placeholder"},{"type":"toolCall","id":"call_0080","name":"tool_03","arguments":{"context":2,"output_mode":"fixture text-00ju placeholder","path":"fixture text-00jv placeholder","pattern":"fixture text-00jw placeholder"}}],"api":"fixture text-00jx placeholder","provider":"fixture text-00jy placeholder","model":"fixture text-00jz placeholder","usage":{"input":816,"output":103,"cacheRead":55795,"cacheWrite":0,"totalTokens":56714,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791624482841,"responseId":"fixture text-00k0 placeholder"}}
+{"message_id":"msg-00k1","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0080","toolName":"tool_03","content":[{"type":"text","text":"fixture text-00k2 placeholder"}],"details":{},"isError":false,"timestamp":1791624484967}}
+{"message_id":"msg-00k3","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-00k4 placeholder","thinkingSignature":"fixture text-00k5 placeholder"},{"type":"toolCall","id":"call_0081","name":"tool_00","arguments":{"path":"fixture text-00k6 placeholder"}}],"api":"fixture text-00k7 placeholder","provider":"fixture text-00k8 placeholder","model":"fixture text-00k9 placeholder","usage":{"input":709,"output":180,"cacheRead":56611,"cacheWrite":0,"totalTokens":57500,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791624484990,"responseId":"fixture text-00ka placeholder"}}
+{"message_id":"msg-00kb","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0081","toolName":"tool_00","content":[{"type":"text","text":"fixture text-00kc placeholder"}],"details":{"textFile":{"path":"fixture text-00kd placeholder","content":"fixture text-00ke placeholder","numLines":96,"startLine":1,"totalLines":97,"truncatedByOutputLimit":false,"wholeFileAutoTruncated":false}},"isError":false,"timestamp":1791624487977}}
+{"message_id":"msg-00kf","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-00kg placeholder","thinkingSignature":"fixture text-00kh placeholder"},{"type":"toolCall","id":"call_0082","name":"tool_00","arguments":{"limit":90,"offset":665,"path":"fixture text-00ki placeholder"}}],"api":"fixture text-00kj placeholder","provider":"fixture text-00kk placeholder","model":"fixture text-00kl placeholder","usage":{"input":1301,"output":288,"cacheRead":57320,"cacheWrite":0,"totalTokens":58909,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791624488002,"responseId":"fixture text-00km placeholder"}}
+{"message_id":"msg-00kn","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0082","toolName":"tool_00","content":[{"type":"text","text":"fixture text-00ko placeholder"}],"details":{"textFile":{"path":"fixture text-00kp placeholder","content":"fixture text-00kq placeholder","numLines":90,"startLine":665,"totalLines":3519,"truncatedByOutputLimit":false,"wholeFileAutoTruncated":false}},"isError":false,"timestamp":1791624491807}}
+{"message_id":"msg-00kr","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-00ks placeholder","thinkingSignature":"fixture text-00kt placeholder"},{"type":"text","text":"fixture text-00ku placeholder"},{"type":"toolCall","id":"call_0083","name":"tool_03","arguments":{"output_mode":"fixture text-00kv placeholder","path":"fixture text-00kw placeholder","pattern":"fixture text-00kx placeholder"}}],"api":"fixture text-00ky placeholder","provider":"fixture text-00kz placeholder","model":"fixture text-00l0 placeholder","usage":{"input":1454,"output":177,"cacheRead":58621,"cacheWrite":0,"totalTokens":60252,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791624491838,"responseId":"fixture text-00l1 placeholder"}}
+{"message_id":"msg-00l2","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0083","toolName":"tool_03","content":[{"type":"text","text":"fixture text-00l3 placeholder"}],"details":{},"isError":false,"timestamp":1791624494317}}
+{"message_id":"msg-00l4","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-00l5 placeholder","thinkingSignature":"fixture text-00l6 placeholder"},{"type":"toolCall","id":"call_0084","name":"tool_03","arguments":{"glob":"fixture text-00l7 placeholder","output_mode":"fixture text-00l8 placeholder","path":"fixture text-00l9 placeholder","pattern":"fixture text-00la placeholder","limit":40}}],"api":"fixture text-00lb placeholder","provider":"fixture text-00lc placeholder","model":"fixture text-00ld placeholder","usage":{"input":346,"output":222,"cacheRead":60075,"cacheWrite":0,"totalTokens":60643,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791624494341,"responseId":"fixture text-00le placeholder"}}
+{"message_id":"msg-00lf","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0084","toolName":"tool_03","content":[{"type":"text","text":"fixture text-00lg placeholder"}],"details":{},"isError":true,"timestamp":1791624526657}}
+{"message_id":"msg-00lh","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"toolCall","id":"call_0085","name":"tool_03","arguments":{"limit":40,"output_mode":"fixture text-00li placeholder","path":"fixture text-00lj placeholder","pattern":"fixture text-00lk placeholder"}}],"api":"fixture text-00ll placeholder","provider":"fixture text-00lm placeholder","model":"fixture text-00ln placeholder","usage":{"input":240,"output":84,"cacheRead":60421,"cacheWrite":0,"totalTokens":60745,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791624526712,"responseId":"fixture text-00lo placeholder"}}
+{"message_id":"msg-00lp","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0085","toolName":"tool_03","content":[{"type":"text","text":"fixture text-00lq placeholder"}],"details":{},"isError":false,"timestamp":1791624528298}}
+{"message_id":"msg-00lr","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-00ls placeholder","thinkingSignature":"fixture text-00lt placeholder"},{"type":"toolCall","id":"call_0086","name":"tool_01","arguments":{"command":"fixture text-00lu placeholder","description":"fixture text-00lv placeholder"}}],"api":"fixture text-00lw placeholder","provider":"fixture text-00lx placeholder","model":"fixture text-00ly placeholder","usage":{"input":165,"output":336,"cacheRead":60661,"cacheWrite":0,"totalTokens":61162,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791624528322,"responseId":"fixture text-00lz placeholder"}}
+{"message_id":"msg-00m0","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0086","toolName":"tool_01","content":[{"type":"text","text":"fixture text-00m1 placeholder"}],"details":{"execution":{"status":"fixture text-00m2 placeholder","reason":"fixture text-00m3 placeholder","exitCode":0},"timing":{"commandTimerStartedAt":1791624532604,"commandDeadlineAt":1791624652604,"commandTimeoutSeconds":120},"output":{"rawBytes":526,"persistence":"fixture text-00m4 placeholder"},"processOutput":{"stdout":"fixture text-00m5 placeholder","stderr":"fixture text-00m6 placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false},"description":"fixture text-00m7 placeholder"},"isError":false,"timestamp":1791624537070}}
+{"message_id":"msg-00m8","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-00m9 placeholder","thinkingSignature":"fixture text-00ma placeholder"},{"type":"text","text":"fixture text-00mb placeholder"}],"api":"fixture text-00mc placeholder","provider":"fixture text-00md placeholder","model":"fixture text-00me placeholder","usage":{"input":3194,"output":8427,"cacheRead":78561,"cacheWrite":0,"totalTokens":90182,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"stop","timestamp":1791624603766,"responseId":"fixture text-00mf placeholder"}}
diff --git a/plugins/avatasia/mmc-trajectory/tests/fixtures/minimax-home/v2/sessions/fixture-agent/00-00-02-000-session_fixture02/manifest.json b/plugins/avatasia/mmc-trajectory/tests/fixtures/minimax-home/v2/sessions/fixture-agent/00-00-02-000-session_fixture02/manifest.json
new file mode 100644
index 0000000..5e08f8c
--- /dev/null
+++ b/plugins/avatasia/mmc-trajectory/tests/fixtures/minimax-home/v2/sessions/fixture-agent/00-00-02-000-session_fixture02/manifest.json
@@ -0,0 +1,4 @@
+{
+  "sessionId": "mvs_00000000000000000000000000000003",
+  "createdAtMs": 1750000002000
+}
\ No newline at end of file
diff --git a/plugins/avatasia/mmc-trajectory/tests/fixtures/minimax-home/v2/sessions/fixture-agent/00-00-02-000-session_fixture02/messages.jsonl b/plugins/avatasia/mmc-trajectory/tests/fixtures/minimax-home/v2/sessions/fixture-agent/00-00-02-000-session_fixture02/messages.jsonl
new file mode 100644
index 0000000..64e292e
--- /dev/null
+++ b/plugins/avatasia/mmc-trajectory/tests/fixtures/minimax-home/v2/sessions/fixture-agent/00-00-02-000-session_fixture02/messages.jsonl
@@ -0,0 +1,31 @@
+{"message_id":"msg-00mg","turn_id":"turn-001","message":{"role":"user","content":[{"type":"text","text":"<system-reminder>\nfixture injected-00mh block"}],"timestamp":1791621403078,"canonicalTextRange":{"startOffset":5109,"endOffset":5134}}}
+{"message_id":"msg-00mi","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-00mj placeholder","thinkingSignature":"fixture text-00mk placeholder"},{"type":"text","text":"fixture text-00ml placeholder"},{"type":"toolCall","id":"call_0087","name":"tool_01","arguments":{"command":"fixture text-00mm placeholder","description":"fixture text-00mn placeholder"}},{"type":"toolCall","id":"call_0088","name":"tool_01","arguments":{"command":"fixture text-00mo placeholder","description":"fixture text-00mp placeholder"}}],"api":"fixture text-00mq placeholder","provider":"fixture text-00mr placeholder","model":"fixture text-00ms placeholder","usage":{"input":47204,"output":477,"cacheRead":1537,"cacheWrite":0,"totalTokens":49218,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791621403112,"responseId":"fixture text-00mt placeholder"}}
+{"message_id":"msg-00mu","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0087","toolName":"tool_01","content":[{"type":"text","text":"fixture text-00mv placeholder"}],"details":{"execution":{"status":"fixture text-00mw placeholder","reason":"fixture text-00mx placeholder","exitCode":0},"timing":{"commandTimeoutSeconds":3600,"commandTimerStartedAt":1791621409560,"commandDeadlineAt":1791625009560},"output":{"rawBytes":710,"persistence":"fixture text-00my placeholder","omittedBytes":0},"processOutput":{"stdout":"fixture text-00mz placeholder","stderr":"fixture text-00n0 placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false,"rawOutputPath":"fixture text-00n1 placeholder"},"description":"fixture text-00n2 placeholder","fullOutputPath":"fixture text-00n3 placeholder","envSanitized":["fixture text-00n4 placeholder","fixture text-00n5 placeholder","fixture text-00n6 placeholder","fixture text-00n7 placeholder","fixture text-00n8 placeholder"],"status":"fixture text-00n9 placeholder","task_id":"fixture text-00na placeholder"},"isError":false,"timestamp":1791621411134}}
+{"message_id":"msg-00nb","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0088","toolName":"tool_01","content":[{"type":"text","text":"fixture text-00nc placeholder"}],"details":{"execution":{"status":"fixture text-00nd placeholder","reason":"fixture text-00ne placeholder","exitCode":0},"timing":{"commandTimeoutSeconds":3600,"commandTimerStartedAt":1791621411265,"commandDeadlineAt":1791625011265},"output":{"rawBytes":1583,"persistence":"fixture text-00nf placeholder","omittedBytes":0},"processOutput":{"stdout":"fixture text-00ng placeholder","stderr":"fixture text-00nh placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false,"rawOutputPath":"fixture text-00ni placeholder"},"description":"fixture text-00nj placeholder","fullOutputPath":"fixture text-00nk placeholder","status":"fixture text-00nl placeholder","task_id":"fixture text-00nm placeholder"},"isError":false,"timestamp":1791621412040}}
+{"message_id":"msg-00nn","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-00no placeholder","thinkingSignature":"fixture text-00np placeholder"},{"type":"text","text":"fixture text-00nq placeholder"},{"type":"toolCall","id":"call_0089","name":"tool_00","arguments":{"path":"fixture text-00nr placeholder"}},{"type":"toolCall","id":"call_0090","name":"tool_01","arguments":{"command":"fixture text-00ns placeholder","description":"fixture text-00nt placeholder"}}],"api":"fixture text-00nu placeholder","provider":"fixture text-00nv placeholder","model":"fixture text-00nw placeholder","usage":{"input":1117,"output":716,"cacheRead":48741,"cacheWrite":0,"totalTokens":50574,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791621412066,"responseId":"fixture text-00nx placeholder"}}
+{"message_id":"msg-00ny","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0089","toolName":"tool_00","content":[{"type":"text","text":"fixture text-00nz placeholder"}],"details":{"textFile":{"path":"fixture text-00o0 placeholder","content":"fixture text-00o1 placeholder","numLines":151,"startLine":1,"totalLines":152,"truncatedByOutputLimit":false,"wholeFileAutoTruncated":false}},"isError":false,"timestamp":1791621418751}}
+{"message_id":"msg-00o2","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0090","toolName":"tool_01","content":[{"type":"text","text":"fixture text-00o3 placeholder"}],"details":{"execution":{"status":"fixture text-00o4 placeholder","reason":"fixture text-00o5 placeholder","exitCode":0},"timing":{"commandTimeoutSeconds":3600,"commandTimerStartedAt":1791621418888,"commandDeadlineAt":1791625018888},"output":{"rawBytes":588,"persistence":"fixture text-00o6 placeholder","omittedBytes":0},"processOutput":{"stdout":"fixture text-00o7 placeholder","stderr":"fixture text-00o8 placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false,"rawOutputPath":"fixture text-00o9 placeholder"},"description":"fixture text-00oa placeholder","fullOutputPath":"fixture text-00ob placeholder","status":"fixture text-00oc placeholder","task_id":"fixture text-00od placeholder"},"isError":false,"timestamp":1791621419686}}
+{"message_id":"msg-00oe","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-00of placeholder","thinkingSignature":"fixture text-00og placeholder"},{"type":"text","text":"fixture text-00oh placeholder"},{"type":"toolCall","id":"call_0091","name":"tool_01","arguments":{"command":"fixture text-00oi placeholder","description":"fixture text-00oj placeholder"}},{"type":"toolCall","id":"call_0092","name":"tool_01","arguments":{"command":"fixture text-00ok placeholder","description":"fixture text-00ol placeholder"}}],"api":"fixture text-00om placeholder","provider":"fixture text-00on placeholder","model":"fixture text-00oo placeholder","usage":{"input":2465,"output":983,"cacheRead":49858,"cacheWrite":0,"totalTokens":53306,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791621419712,"responseId":"fixture text-00op placeholder"}}
+{"message_id":"msg-00oq","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0091","toolName":"tool_01","content":[{"type":"text","text":"fixture text-00or placeholder"}],"details":{"execution":{"status":"fixture text-00os placeholder","reason":"fixture text-00ot placeholder","exitCode":0},"timing":{"commandTimeoutSeconds":3600,"commandTimerStartedAt":1791621429020,"commandDeadlineAt":1791625029020},"output":{"rawBytes":1537,"persistence":"fixture text-00ou placeholder","omittedBytes":0},"processOutput":{"stdout":"fixture text-00ov placeholder","stderr":"fixture text-00ow placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false,"rawOutputPath":"fixture text-00ox placeholder"},"description":"fixture text-00oy placeholder","fullOutputPath":"fixture text-00oz placeholder","status":"fixture text-00p0 placeholder","task_id":"fixture text-00p1 placeholder"},"isError":false,"timestamp":1791621429630}}
+{"message_id":"msg-00p2","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0092","toolName":"tool_01","content":[{"type":"text","text":"fixture text-00p3 placeholder"}],"details":{"execution":{"status":"fixture text-00p4 placeholder","reason":"fixture text-00p5 placeholder","exitCode":0},"timing":{"commandTimeoutSeconds":3600,"commandTimerStartedAt":1791621429764,"commandDeadlineAt":1791625029764},"output":{"rawBytes":1315,"persistence":"fixture text-00p6 placeholder","omittedBytes":0},"processOutput":{"stdout":"fixture text-00p7 placeholder","stderr":"fixture text-00p8 placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false,"rawOutputPath":"fixture text-00p9 placeholder"},"description":"fixture text-00pa placeholder","fullOutputPath":"fixture text-00pb placeholder","status":"fixture text-00pc placeholder","task_id":"fixture text-00pd placeholder"},"isError":false,"timestamp":1791621437863}}
+{"message_id":"msg-00pe","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-00pf placeholder","thinkingSignature":"fixture text-00pg placeholder"},{"type":"text","text":"fixture text-00ph placeholder"},{"type":"toolCall","id":"call_0093","name":"tool_01","arguments":{"command":"fixture text-00pi placeholder","description":"fixture text-00pj placeholder"}},{"type":"toolCall","id":"call_0094","name":"tool_01","arguments":{"command":"fixture text-00pk placeholder","description":"fixture text-00pl placeholder"}}],"api":"fixture text-00pm placeholder","provider":"fixture text-00pn placeholder","model":"fixture text-00po placeholder","usage":{"input":1928,"output":994,"cacheRead":52323,"cacheWrite":0,"totalTokens":55245,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791621437890,"responseId":"fixture text-00pp placeholder"}}
+{"message_id":"msg-00pq","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0093","toolName":"tool_01","content":[{"type":"text","text":"fixture text-00pr placeholder"}],"details":{"execution":{"status":"fixture text-00ps placeholder","reason":"fixture text-00pt placeholder","exitCode":0},"timing":{"commandTimeoutSeconds":3600,"commandTimerStartedAt":1791621447419,"commandDeadlineAt":1791625047419},"output":{"rawBytes":349,"persistence":"fixture text-00pu placeholder","omittedBytes":0},"processOutput":{"stdout":"fixture text-00pv placeholder","stderr":"fixture text-00pw placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false,"rawOutputPath":"fixture text-00px placeholder"},"description":"fixture text-00py placeholder","fullOutputPath":"fixture text-00pz placeholder","status":"fixture text-00q0 placeholder","task_id":"fixture text-00q1 placeholder"},"isError":false,"timestamp":1791621456320}}
+{"message_id":"msg-00q2","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0094","toolName":"tool_01","content":[{"type":"text","text":"fixture text-00q3 placeholder"}],"details":{"execution":{"status":"fixture text-00q4 placeholder","reason":"fixture text-00q5 placeholder","exitCode":0},"timing":{"commandTimeoutSeconds":3600,"commandTimerStartedAt":1791621456458,"commandDeadlineAt":1791625056458},"output":{"rawBytes":298,"persistence":"fixture text-00q6 placeholder","omittedBytes":0},"processOutput":{"stdout":"fixture text-00q7 placeholder","stderr":"fixture text-00q8 placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false,"rawOutputPath":"fixture text-00q9 placeholder"},"description":"fixture text-00qa placeholder","fullOutputPath":"fixture text-00qb placeholder","status":"fixture text-00qc placeholder","task_id":"fixture text-00qd placeholder"},"isError":false,"timestamp":1791621459129}}
+{"message_id":"msg-00qe","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-00qf placeholder","thinkingSignature":"fixture text-00qg placeholder"},{"type":"text","text":"fixture text-00qh placeholder"},{"type":"toolCall","id":"call_0095","name":"tool_01","arguments":{"command":"fixture text-00qi placeholder","description":"fixture text-00qj placeholder"}},{"type":"toolCall","id":"call_0096","name":"tool_01","arguments":{"command":"fixture text-00qk placeholder","description":"fixture text-00ql placeholder"}}],"api":"fixture text-00qm placeholder","provider":"fixture text-00qn placeholder","model":"fixture text-00qo placeholder","usage":{"input":1247,"output":1001,"cacheRead":54251,"cacheWrite":0,"totalTokens":56499,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791621459156,"responseId":"fixture text-00qp placeholder"}}
+{"message_id":"msg-00qq","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0095","toolName":"tool_01","content":[{"type":"text","text":"fixture text-00qr placeholder"}],"details":{"execution":{"status":"fixture text-00qs placeholder","reason":"fixture text-00qt placeholder","exitCode":0},"timing":{"commandTimeoutSeconds":3600,"commandTimerStartedAt":1791621469768,"commandDeadlineAt":1791625069768},"output":{"rawBytes":2463,"persistence":"fixture text-00qu placeholder","omittedBytes":0},"processOutput":{"stdout":"fixture text-00qv placeholder","stderr":"fixture text-00qw placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false,"rawOutputPath":"fixture text-00qx placeholder"},"description":"fixture text-00qy placeholder","fullOutputPath":"fixture text-00qz placeholder","status":"fixture text-00r0 placeholder","task_id":"fixture text-00r1 placeholder"},"isError":false,"timestamp":1791621470817}}
+{"message_id":"msg-00r2","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0096","toolName":"tool_01","content":[{"type":"text","text":"fixture text-00r3 placeholder"}],"details":{"execution":{"status":"fixture text-00r4 placeholder","reason":"fixture text-00r5 placeholder","exitCode":0},"timing":{"commandTimeoutSeconds":3600,"commandTimerStartedAt":1791621470965,"commandDeadlineAt":1791625070965},"output":{"rawBytes":1080,"persistence":"fixture text-00r6 placeholder","omittedBytes":0},"processOutput":{"stdout":"fixture text-00r7 placeholder","stderr":"fixture text-00r8 placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false,"rawOutputPath":"fixture text-00r9 placeholder"},"description":"fixture text-00ra placeholder","fullOutputPath":"fixture text-00rb placeholder","status":"fixture text-00rc placeholder","task_id":"fixture text-00rd placeholder"},"isError":false,"timestamp":1791621472605}}
+{"message_id":"msg-00re","turn_id":"turn-001","message":{"role":"user","content":[{"type":"text","text":"fixture text-00rf placeholder"}],"timestamp":1791621464663,"canonicalTextRange":{"startOffset":0,"endOffset":30},"hostMetadata":{"immediateSendBatchId":"fixture text-00rg placeholder"}}}
+{"message_id":"msg-00rh","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-00ri placeholder","thinkingSignature":"fixture text-00rj placeholder"},{"type":"text","text":"fixture text-00rk placeholder"},{"type":"toolCall","id":"call_0097","name":"tool_01","arguments":{"command":"fixture text-00rl placeholder","description":"fixture text-00rm placeholder"}},{"type":"toolCall","id":"call_0098","name":"tool_01","arguments":{"command":"fixture text-00rn placeholder","description":"fixture text-00ro placeholder"}}],"api":"fixture text-00rp placeholder","provider":"fixture text-00rq placeholder","model":"fixture text-00rr placeholder","usage":{"input":2226,"output":1213,"cacheRead":55498,"cacheWrite":0,"totalTokens":58937,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791621472654,"responseId":"fixture text-00rs placeholder"}}
+{"message_id":"msg-00rt","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0097","toolName":"tool_01","content":[{"type":"text","text":"fixture text-00ru placeholder"}],"details":{"execution":{"status":"fixture text-00rv placeholder","reason":"fixture text-00rw placeholder","exitCode":0},"timing":{"commandTimeoutSeconds":3600,"commandTimerStartedAt":1791621488916,"commandDeadlineAt":1791625088916},"output":{"rawBytes":226,"persistence":"fixture text-00rx placeholder","omittedBytes":0},"processOutput":{"stdout":"fixture text-00ry placeholder","stderr":"fixture text-00rz placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false,"rawOutputPath":"fixture text-00s0 placeholder"},"description":"fixture text-00s1 placeholder","fullOutputPath":"fixture text-00s2 placeholder","status":"fixture text-00s3 placeholder","task_id":"fixture text-00s4 placeholder"},"isError":false,"timestamp":1791621492478}}
+{"message_id":"msg-00s5","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0098","toolName":"tool_01","content":[{"type":"text","text":"fixture text-00s6 placeholder"}],"details":{"execution":{"status":"fixture text-00s7 placeholder","reason":"fixture text-00s8 placeholder","exitCode":1,"message":"fixture text-00s9 placeholder"},"timing":{"commandTimeoutSeconds":3600,"commandTimerStartedAt":1791621492614,"commandDeadlineAt":1791625092614},"output":{"rawBytes":329,"persistence":"fixture text-00sa placeholder","omittedBytes":0},"processOutput":{"stdout":"fixture text-00sb placeholder","stderr":"fixture text-00sc placeholder","exitCode":1,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false,"rawOutputPath":"fixture text-00sd placeholder"},"description":"fixture text-00se placeholder","fullOutputPath":"fixture text-00sf placeholder","status":"fixture text-00sg placeholder","task_id":"fixture text-00sh placeholder","is_error":true},"isError":true,"timestamp":1791621493805}}
+{"message_id":"msg-00si","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-00sj placeholder","thinkingSignature":"fixture text-00sk placeholder"},{"type":"text","text":"fixture text-00sl placeholder"},{"type":"toolCall","id":"call_0099","name":"tool_01","arguments":{"command":"fixture text-00sm placeholder","description":"fixture text-00sn placeholder"}}],"api":"fixture text-00so placeholder","provider":"fixture text-00sp placeholder","model":"fixture text-00sq placeholder","usage":{"input":1428,"output":2265,"cacheRead":57724,"cacheWrite":0,"totalTokens":61417,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791621493835,"responseId":"fixture text-00sr placeholder"}}
+{"message_id":"msg-00ss","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0099","toolName":"tool_01","content":[{"type":"text","text":"fixture text-00st placeholder"}],"details":{},"isError":true,"timestamp":1791621519598}}
+{"message_id":"msg-00su","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-00sv placeholder","thinkingSignature":"fixture text-00sw placeholder"},{"type":"text","text":"fixture text-00sx placeholder"},{"type":"toolCall","id":"call_0100","name":"tool_01","arguments":{"command":"fixture text-00sy placeholder","description":"fixture text-00sz placeholder"}}],"api":"fixture text-00t0 placeholder","provider":"fixture text-00t1 placeholder","model":"fixture text-00t2 placeholder","usage":{"input":2373,"output":481,"cacheRead":59152,"cacheWrite":0,"totalTokens":62006,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791621519630,"responseId":"fixture text-00t3 placeholder"}}
+{"message_id":"msg-00t4","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0100","toolName":"tool_01","content":[{"type":"text","text":"fixture text-00t5 placeholder"}],"details":{"execution":{"status":"fixture text-00t6 placeholder","reason":"fixture text-00t7 placeholder","exitCode":0},"timing":{"commandTimeoutSeconds":3600,"commandTimerStartedAt":1791621524656,"commandDeadlineAt":1791625124656},"output":{"rawBytes":777,"persistence":"fixture text-00t8 placeholder","omittedBytes":0},"processOutput":{"stdout":"fixture text-00t9 placeholder","stderr":"fixture text-00ta placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false,"rawOutputPath":"fixture text-00tb placeholder"},"description":"fixture text-00tc placeholder","fullOutputPath":"fixture text-00td placeholder","status":"fixture text-00te placeholder","task_id":"fixture text-00tf placeholder"},"isError":false,"timestamp":1791621525997}}
+{"message_id":"msg-00tg","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-00th placeholder","thinkingSignature":"fixture text-00ti placeholder"},{"type":"text","text":"fixture text-00tj placeholder"},{"type":"toolCall","id":"call_0101","name":"tool_01","arguments":{"command":"fixture text-00tk placeholder","description":"fixture text-00tl placeholder"}},{"type":"toolCall","id":"call_0102","name":"tool_01","arguments":{"command":"fixture text-00tm placeholder","description":"fixture text-00tn placeholder"}}],"api":"fixture text-00to placeholder","provider":"fixture text-00tp placeholder","model":"fixture text-00tq placeholder","usage":{"input":716,"output":1013,"cacheRead":61525,"cacheWrite":0,"totalTokens":63254,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791621526028,"responseId":"fixture text-00tr placeholder"}}
+{"message_id":"msg-00ts","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0101","toolName":"tool_01","content":[{"type":"text","text":"fixture text-00tt placeholder"}],"details":{"execution":{"status":"fixture text-00tu placeholder","reason":"fixture text-00tv placeholder","exitCode":0},"timing":{"commandTimeoutSeconds":3600,"commandTimerStartedAt":1791621534984,"commandDeadlineAt":1791625134984},"output":{"rawBytes":176,"persistence":"fixture text-00tw placeholder","omittedBytes":0},"processOutput":{"stdout":"fixture text-00tx placeholder","stderr":"fixture text-00ty placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false,"rawOutputPath":"fixture text-00tz placeholder"},"description":"fixture text-00u0 placeholder","fullOutputPath":"fixture text-00u1 placeholder","status":"fixture text-00u2 placeholder","task_id":"fixture text-00u3 placeholder"},"isError":false,"timestamp":1791621535886}}
+{"message_id":"msg-00u4","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0102","toolName":"tool_01","content":[{"type":"text","text":"fixture text-00u5 placeholder"}],"details":{"execution":{"status":"fixture text-00u6 placeholder","reason":"fixture text-00u7 placeholder","exitCode":0},"timing":{"commandTimeoutSeconds":3600,"commandTimerStartedAt":1791621536021,"commandDeadlineAt":1791625136021},"output":{"rawBytes":1058,"persistence":"fixture text-00u8 placeholder","omittedBytes":0},"processOutput":{"stdout":"fixture text-00u9 placeholder","stderr":"fixture text-00ua placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false,"rawOutputPath":"fixture text-00ub placeholder"},"description":"fixture text-00uc placeholder","fullOutputPath":"fixture text-00ud placeholder","status":"fixture text-00ue placeholder","task_id":"fixture text-00uf placeholder"},"isError":false,"timestamp":1791621536992}}
+{"message_id":"msg-00ug","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-00uh placeholder","thinkingSignature":"fixture text-00ui placeholder"},{"type":"text","text":"fixture text-00uj placeholder"},{"type":"toolCall","id":"call_0103","name":"tool_00","arguments":{"path":"fixture text-00uk placeholder"}},{"type":"toolCall","id":"call_0104","name":"tool_03","arguments":{"pattern":"fixture text-00ul placeholder","path":"fixture text-00um placeholder","output_mode":"fixture text-00un placeholder","ignoreCase":true,"glob":"fixture text-00uo placeholder","limit":30}}],"api":"fixture text-00up placeholder","provider":"fixture text-00uq placeholder","model":"fixture text-00ur placeholder","usage":{"input":1385,"output":466,"cacheRead":62241,"cacheWrite":0,"totalTokens":64092,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791621537023,"responseId":"fixture text-00us placeholder"}}
+{"message_id":"msg-00ut","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0103","toolName":"tool_00","content":[{"type":"text","text":"fixture text-00uu placeholder"}],"details":{"textFile":{"path":"fixture text-00uv placeholder","content":"fixture text-00uw placeholder","numLines":206,"startLine":1,"totalLines":206,"truncatedByOutputLimit":false,"wholeFileAutoTruncated":false}},"isError":false,"timestamp":1791621541985}}
+{"message_id":"msg-00ux","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0104","toolName":"tool_03","content":[{"type":"text","text":"fixture text-00uy placeholder"}],"details":{},"isError":false,"timestamp":1791621541998}}
+{"message_id":"msg-00uz","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-00v0 placeholder","thinkingSignature":"fixture text-00v1 placeholder"},{"type":"text","text":"fixture text-00v2 placeholder"}],"api":"fixture text-00v3 placeholder","provider":"fixture text-00v4 placeholder","model":"fixture text-00v5 placeholder","usage":{"input":3056,"output":2419,"cacheRead":63626,"cacheWrite":0,"totalTokens":69101,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"stop","timestamp":1791621542030,"responseId":"fixture text-00v6 placeholder"}}
diff --git a/plugins/avatasia/mmc-trajectory/tests/fixtures/minimax-home/v2/sessions/fixture-agent/00-00-03-000-session_fixture03/manifest.json b/plugins/avatasia/mmc-trajectory/tests/fixtures/minimax-home/v2/sessions/fixture-agent/00-00-03-000-session_fixture03/manifest.json
new file mode 100644
index 0000000..4204700
--- /dev/null
+++ b/plugins/avatasia/mmc-trajectory/tests/fixtures/minimax-home/v2/sessions/fixture-agent/00-00-03-000-session_fixture03/manifest.json
@@ -0,0 +1,4 @@
+{
+  "sessionId": "mvs_00000000000000000000000000000004",
+  "createdAtMs": 1750000003000
+}
\ No newline at end of file
diff --git a/plugins/avatasia/mmc-trajectory/tests/fixtures/minimax-home/v2/sessions/fixture-agent/00-00-03-000-session_fixture03/messages.jsonl b/plugins/avatasia/mmc-trajectory/tests/fixtures/minimax-home/v2/sessions/fixture-agent/00-00-03-000-session_fixture03/messages.jsonl
new file mode 100644
index 0000000..5350bd9
--- /dev/null
+++ b/plugins/avatasia/mmc-trajectory/tests/fixtures/minimax-home/v2/sessions/fixture-agent/00-00-03-000-session_fixture03/messages.jsonl
@@ -0,0 +1,17 @@
+{"message_id":"msg-00vp","turn_id":"turn-001","message":{"role":"user","content":[{"type":"text","text":"<system-reminder>\nfixture injected-00vq block"}],"timestamp":1791612580100,"canonicalTextRange":{"startOffset":5109,"endOffset":5123}}}
+{"message_id":"msg-00vr","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-00vs placeholder","thinkingSignature":"fixture text-00vt placeholder"},{"type":"text","text":"fixture text-00vu placeholder"},{"type":"toolCall","id":"call_0099","name":"tool_13","arguments":{"query":"fixture text-00vv placeholder","count":10}},{"type":"toolCall","id":"call_0100","name":"tool_13","arguments":{"query":"fixture text-00vw placeholder","count":10}}],"api":"fixture text-00vx placeholder","provider":"fixture text-00vy placeholder","model":"fixture text-00vz placeholder","usage":{"input":44595,"output":182,"cacheRead":4224,"cacheWrite":0,"totalTokens":49001,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791612580145,"responseId":"fixture text-00w0 placeholder"}}
+{"message_id":"msg-00w1","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0099","toolName":"tool_13","content":[{"type":"text","text":"fixture text-00w2 placeholder"}],"details":{"mcp":{"kind":"mcp_tool_result_artifact","version":1,"externalized":true,"reference":"fixture text-00w3 placeholder","original_bytes":46629,"content_type":"fixture text-00w4 placeholder","read_format":"fixture text-00w5 placeholder","content_sha256":"fixture text-00w6 placeholder","raw_reference":"fixture text-00w7 placeholder"},"server":"fixture text-00w8 placeholder","tool":"fixture text-00w9 placeholder","is_error":false},"isError":false,"timestamp":1791612583693}}
+{"message_id":"msg-00wa","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0100","toolName":"tool_13","content":[{"type":"text","text":"fixture text-00wb placeholder"}],"details":{"mcp":{"kind":"mcp_tool_result_artifact","version":1,"externalized":true,"reference":"fixture text-00wc placeholder","original_bytes":74957,"content_type":"fixture text-00wd placeholder","read_format":"fixture text-00we placeholder","content_sha256":"fixture text-00wf placeholder","raw_reference":"fixture text-00wg placeholder"},"server":"fixture text-00wh placeholder","tool":"fixture text-00wi placeholder","is_error":false,"tool_output_budget":{"externalized":true,"fallback":false,"original_bytes":74369,"reference":"fixture text-00wj placeholder","artifact_kind":"fixture text-00wk placeholder","sensitive":false,"content_sha256":"fixture text-00wl placeholder","read_format":"fixture text-00wm placeholder","raw_reference":"fixture text-00wn placeholder"}},"isError":false,"timestamp":1791612584706}}
+{"message_id":"msg-00wo","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-00wp placeholder","thinkingSignature":"fixture text-00wq placeholder"},{"type":"text","text":"fixture text-00wr placeholder"},{"type":"toolCall","id":"call_0101","name":"tool_09","arguments":{"pattern":"fixture text-00ws placeholder","path":"fixture text-00wt placeholder","output_mode":"fixture text-00wu placeholder"}}],"api":"fixture text-00wv placeholder","provider":"fixture text-00ww placeholder","model":"fixture text-00wx placeholder","usage":{"input":10990,"output":278,"cacheRead":48896,"cacheWrite":0,"totalTokens":60164,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791612584784,"responseId":"fixture text-00wy placeholder"}}
+{"message_id":"msg-00wz","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0101","toolName":"tool_09","content":[{"type":"text","text":"fixture text-00x0 placeholder"}],"details":{"files":1,"matches":193},"isError":false,"timestamp":1791612588244}}
+{"message_id":"msg-00x1","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-00x2 placeholder","thinkingSignature":"fixture text-00x3 placeholder"},{"type":"toolCall","id":"call_0102","name":"tool_09","arguments":{"output_mode":"fixture text-00x4 placeholder","path":"fixture text-00x5 placeholder","pattern":"fixture text-00x6 placeholder","limit":15}}],"api":"fixture text-00x7 placeholder","provider":"fixture text-00x8 placeholder","model":"fixture text-00x9 placeholder","usage":{"input":344,"output":243,"cacheRead":59904,"cacheWrite":0,"totalTokens":60491,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791612588271,"responseId":"fixture text-00xa placeholder"}}
+{"message_id":"msg-00xb","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0102","toolName":"tool_09","content":[{"type":"text","text":"fixture text-00xc placeholder"}],"details":{},"isError":false,"timestamp":1791612591165}}
+{"message_id":"msg-00xd","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-00xe placeholder","thinkingSignature":"fixture text-00xf placeholder"},{"type":"toolCall","id":"call_0103","name":"tool_09","arguments":{"limit":10,"output_mode":"fixture text-00xg placeholder","path":"fixture text-00xh placeholder","pattern":"fixture text-00xi placeholder"}}],"api":"fixture text-00xj placeholder","provider":"fixture text-00xk placeholder","model":"fixture text-00xl placeholder","usage":{"input":952,"output":274,"cacheRead":60416,"cacheWrite":0,"totalTokens":61642,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791612591192,"responseId":"fixture text-00xm placeholder"}}
+{"message_id":"msg-00xn","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0103","toolName":"tool_09","content":[{"type":"text","text":"fixture text-00xo placeholder"}],"details":{},"isError":false,"timestamp":1791612594543}}
+{"message_id":"msg-00xp","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-00xq placeholder","thinkingSignature":"fixture text-00xr placeholder"},{"type":"text","text":"fixture text-00xs placeholder"}],"api":"fixture text-00xt placeholder","provider":"fixture text-00xu placeholder","model":"fixture text-00xv placeholder","usage":{"input":92,"output":919,"cacheRead":61568,"cacheWrite":0,"totalTokens":62579,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"stop","timestamp":1791612594569,"responseId":"fixture text-00xw placeholder"}}
+{"message_id":"msg-00xx","turn_id":"turn-002","message":{"role":"user","content":[{"type":"text","text":"<system-reminder>\nfixture injected-00xy block"}],"timestamp":1791612642186,"canonicalTextRange":{"startOffset":3003,"endOffset":3015}}}
+{"message_id":"msg-00xz","turn_id":"turn-002","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-00y0 placeholder","thinkingSignature":"fixture text-00y1 placeholder"},{"type":"text","text":"fixture text-00y2 placeholder"},{"type":"toolCall","id":"call_0104","name":"tool_13","arguments":{"count":10,"query":"fixture text-00y3 placeholder"}}],"api":"fixture text-00y4 placeholder","provider":"fixture text-00y5 placeholder","model":"fixture text-00y6 placeholder","usage":{"input":745,"output":160,"cacheRead":62464,"cacheWrite":0,"totalTokens":63369,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791612642215,"responseId":"fixture text-00y7 placeholder"}}
+{"message_id":"msg-00y8","turn_id":"turn-002","message":{"role":"toolResult","toolCallId":"call_0104","toolName":"tool_13","content":[{"type":"text","text":"fixture text-00y9 placeholder"}],"details":{"mcp":{"content":[{"type":"text","text":"fixture text-00ya placeholder"}],"isError":false,"_meta":{"matrix":{"server":"fixture text-00yb placeholder","tool":"fixture text-00yc placeholder"},"details":{"ok":true,"path":"fixture text-00yd placeholder"}}},"server":"fixture text-00ye placeholder","tool":"fixture text-00yf placeholder","is_error":false},"isError":false,"timestamp":1791612645507}}
+{"message_id":"msg-00yg","turn_id":"turn-002","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-00yh placeholder","thinkingSignature":"fixture text-00yi placeholder"},{"type":"text","text":"fixture text-00yj placeholder"},{"type":"toolCall","id":"call_0105","name":"tool_13","arguments":{"count":10,"query":"fixture text-00yk placeholder"}}],"api":"fixture text-00yl placeholder","provider":"fixture text-00ym placeholder","model":"fixture text-00yn placeholder","usage":{"input":7405,"output":405,"cacheRead":63360,"cacheWrite":0,"totalTokens":71170,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791612645561,"responseId":"fixture text-00yo placeholder"}}
+{"message_id":"msg-00yp","turn_id":"turn-002","message":{"role":"toolResult","toolCallId":"call_0105","toolName":"tool_13","content":[{"type":"text","text":"fixture text-00yq placeholder"}],"details":{"mcp":{"content":[{"type":"text","text":"fixture text-00yr placeholder"}],"isError":false,"_meta":{"matrix":{"server":"fixture text-00ys placeholder","tool":"fixture text-00yt placeholder"},"details":{"ok":true,"path":"fixture text-00yu placeholder"}}},"server":"fixture text-00yv placeholder","tool":"fixture text-00yw placeholder","is_error":false},"isError":false,"timestamp":1791612651988}}
+{"message_id":"msg-00yx","turn_id":"turn-002","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-00yy placeholder","thinkingSignature":"fixture text-00yz placeholder"},{"type":"text","text":"fixture text-00z0 placeholder"}],"api":"fixture text-00z1 placeholder","provider":"fixture text-00z2 placeholder","model":"fixture text-00z3 placeholder","usage":{"input":7276,"output":616,"cacheRead":71168,"cacheWrite":0,"totalTokens":79060,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"stop","timestamp":1791612652040,"responseId":"fixture text-00z4 placeholder"}}
diff --git a/plugins/avatasia/mmc-trajectory/tests/fixtures/minimax-home/v2/sessions/fixture-agent/00-00-04-000-session_fixture04/manifest.json b/plugins/avatasia/mmc-trajectory/tests/fixtures/minimax-home/v2/sessions/fixture-agent/00-00-04-000-session_fixture04/manifest.json
new file mode 100644
index 0000000..1ff39ad
--- /dev/null
+++ b/plugins/avatasia/mmc-trajectory/tests/fixtures/minimax-home/v2/sessions/fixture-agent/00-00-04-000-session_fixture04/manifest.json
@@ -0,0 +1,4 @@
+{
+  "sessionId": "mvs_00000000000000000000000000000005",
+  "createdAtMs": 1750000004000
+}
\ No newline at end of file
diff --git a/plugins/avatasia/mmc-trajectory/tests/fixtures/minimax-home/v2/sessions/fixture-agent/00-00-04-000-session_fixture04/messages.jsonl b/plugins/avatasia/mmc-trajectory/tests/fixtures/minimax-home/v2/sessions/fixture-agent/00-00-04-000-session_fixture04/messages.jsonl
new file mode 100644
index 0000000..27338ac
--- /dev/null
+++ b/plugins/avatasia/mmc-trajectory/tests/fixtures/minimax-home/v2/sessions/fixture-agent/00-00-04-000-session_fixture04/messages.jsonl
@@ -0,0 +1,45 @@
+{"message_id":"msg-0160","turn_id":"turn-001","message":{"role":"user","content":[{"type":"text","text":"<system-reminder>\nfixture injected-0161 block"}],"timestamp":1791606232442,"canonicalTextRange":{"startOffset":4050,"endOffset":4050}}}
+{"message_id":"msg-0162","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-0163 placeholder","thinkingSignature":"fixture text-0164 placeholder"},{"type":"toolCall","id":"call_0127","name":"tool_08","arguments":{"pattern":"fixture text-0165 placeholder","path":"fixture text-0166 placeholder"}},{"type":"toolCall","id":"call_0128","name":"tool_08","arguments":{"pattern":"fixture text-0167 placeholder","path":"fixture text-0168 placeholder"}},{"type":"toolCall","id":"call_0129","name":"tool_08","arguments":{"pattern":"fixture text-0169 placeholder","path":"fixture text-016a placeholder","limit":150}}],"api":"fixture text-016b placeholder","provider":"fixture text-016c placeholder","model":"fixture text-016d placeholder","usage":{"input":10144,"output":259,"cacheRead":188,"cacheWrite":0,"totalTokens":10591,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791606232469,"responseId":"fixture text-016e placeholder"}}
+{"message_id":"msg-016f","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0127","toolName":"tool_08","content":[{"type":"text","text":"fixture text-016g placeholder"}],"details":{"matched":11,"limit":200,"offset":0},"isError":false,"timestamp":1791606238945}}
+{"message_id":"msg-016h","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0128","toolName":"tool_08","content":[{"type":"text","text":"fixture text-016i placeholder"}],"details":{"matched":4,"limit":200,"offset":0},"isError":false,"timestamp":1791606238956}}
+{"message_id":"msg-016j","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0129","toolName":"tool_08","content":[{"type":"text","text":"fixture text-016k placeholder"}],"details":{"matched":150,"limit":150,"offset":0,"truncated":true,"next_offset":150,"desktop_output_continuation":{"has_more":true,"next_offset":150,"offset_unit":"fixture text-016l placeholder","continuation_hint":{"tool":"fixture text-016m placeholder","preserve_args":["fixture text-016n placeholder","fixture text-016o placeholder","fixture text-016p placeholder","fixture text-016q placeholder","fixture text-016r placeholder"],"instruction":"fixture text-016s placeholder"}}},"isError":false,"timestamp":1791606238964}}
+{"message_id":"msg-016t","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-016u placeholder","thinkingSignature":"fixture text-016v placeholder"},{"type":"toolCall","id":"call_0130","name":"tool_00","arguments":{"path":"fixture text-016w placeholder"}},{"type":"toolCall","id":"call_0131","name":"tool_03","arguments":{"pattern":"fixture text-016x placeholder","path":"fixture text-016y placeholder","output_mode":"fixture text-016z placeholder","glob":"fixture text-0170 placeholder"}}],"api":"fixture text-0171 placeholder","provider":"fixture text-0172 placeholder","model":"fixture text-0173 placeholder","usage":{"input":8049,"output":122,"cacheRead":10331,"cacheWrite":0,"totalTokens":18502,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791606238982,"responseId":"fixture text-0174 placeholder"}}
+{"message_id":"msg-0175","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0130","toolName":"tool_00","content":[{"type":"text","text":"fixture text-0176 placeholder"}],"details":{"textFile":{"path":"fixture text-0177 placeholder","content":"fixture text-0178 placeholder","numLines":234,"startLine":1,"totalLines":235,"truncatedByOutputLimit":false,"wholeFileAutoTruncated":false}},"isError":false,"timestamp":1791606242988}}
+{"message_id":"msg-0179","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0131","toolName":"tool_03","content":[{"type":"text","text":"fixture text-017a placeholder"}],"details":{"files":1},"isError":false,"timestamp":1791606242999}}
+{"message_id":"msg-017b","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-017c placeholder","thinkingSignature":"fixture text-017d placeholder"},{"type":"toolCall","id":"call_0132","name":"tool_00","arguments":{"path":"fixture text-017e placeholder"}},{"type":"toolCall","id":"call_0133","name":"tool_01","arguments":{"command":"fixture text-017f placeholder","description":"fixture text-017g placeholder"}},{"type":"toolCall","id":"call_0134","name":"tool_01","arguments":{"command":"fixture text-017h placeholder","description":"fixture text-017i placeholder"}}],"api":"fixture text-017j placeholder","provider":"fixture text-017k placeholder","model":"fixture text-017l placeholder","usage":{"input":3731,"output":359,"cacheRead":18379,"cacheWrite":0,"totalTokens":22469,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791606243018,"responseId":"fixture text-017m placeholder"}}
+{"message_id":"msg-017n","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0132","toolName":"tool_00","content":[{"type":"text","text":"fixture text-017o placeholder"}],"details":{"textFile":{"path":"fixture text-017p placeholder","content":"fixture text-017q placeholder","numLines":21,"startLine":1,"totalLines":22,"truncatedByOutputLimit":false,"wholeFileAutoTruncated":false}},"isError":false,"timestamp":1791606262994}}
+{"message_id":"msg-017r","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0133","toolName":"tool_01","content":[{"type":"text","text":"fixture text-017s placeholder"}],"details":{"execution":{"status":"fixture text-017t placeholder","reason":"fixture text-017u placeholder","exitCode":0},"timing":{"commandTimerStartedAt":1791606263120,"commandDeadlineAt":1791606383120,"commandTimeoutSeconds":120},"output":{"rawBytes":341,"persistence":"fixture text-017v placeholder"},"processOutput":{"stdout":"fixture text-017w placeholder","stderr":"fixture text-017x placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false},"envSanitized":["fixture text-017y placeholder","fixture text-017z placeholder","fixture text-0180 placeholder","fixture text-0181 placeholder","fixture text-0182 placeholder"],"description":"fixture text-0183 placeholder"},"isError":false,"timestamp":1791606263557}}
+{"message_id":"msg-0184","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0134","toolName":"tool_01","content":[{"type":"text","text":"fixture text-0185 placeholder"}],"details":{"execution":{"status":"fixture text-0186 placeholder","reason":"fixture text-0187 placeholder","exitCode":1,"message":"fixture text-0188 placeholder"},"timing":{"commandTimerStartedAt":1791606263680,"commandDeadlineAt":1791606383680,"commandTimeoutSeconds":120},"output":{"rawBytes":253,"persistence":"fixture text-0189 placeholder"},"processOutput":{"stdout":"fixture text-018a placeholder","stderr":"fixture text-018b placeholder","exitCode":1,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false},"description":"fixture text-018c placeholder","is_error":true},"isError":true,"timestamp":1791606264379}}
+{"message_id":"msg-018d","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-018e placeholder","thinkingSignature":"fixture text-018f placeholder"},{"type":"toolCall","id":"call_0135","name":"tool_01","arguments":{"command":"fixture text-018g placeholder","description":"fixture text-018h placeholder"}},{"type":"toolCall","id":"call_0136","name":"tool_01","arguments":{"command":"fixture text-018i placeholder","description":"fixture text-018j placeholder"}}],"api":"fixture text-018k placeholder","provider":"fixture text-018l placeholder","model":"fixture text-018m placeholder","usage":{"input":876,"output":413,"cacheRead":22109,"cacheWrite":0,"totalTokens":23398,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791606264394,"responseId":"fixture text-018n placeholder"}}
+{"message_id":"msg-018o","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0135","toolName":"tool_01","content":[{"type":"text","text":"fixture text-018p placeholder"}],"details":{"truncation":{"content":"fixture text-018q placeholder","truncated":true,"truncatedBy":"fixture text-018r placeholder","totalLines":857,"totalBytes":34046,"outputLines":540,"outputBytes":22475,"lastLinePartial":false,"firstLineExceedsLimit":false,"maxLines":9007199254740991,"maxBytes":22528},"fullOutputPath":"fixture text-018s placeholder","execution":{"status":"fixture text-018t placeholder","reason":"fixture text-018u placeholder","exitCode":0},"timing":{"commandTimerStartedAt":1791606279378,"commandDeadlineAt":1791606399378,"commandTimeoutSeconds":120},"output":{"rawBytes":34046,"persistence":"fixture text-018v placeholder"},"processOutput":{"stdout":"fixture text-018w placeholder","stderr":"fixture text-018x placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false,"rawOutputPath":"fixture text-018y placeholder"},"desktop_output_truncation":{"truncated":true,"has_more":true,"strategy":"fixture text-018z placeholder","original_bytes":34046,"returned_bytes":22631,"max_bytes":24576,"continuation_hint":{"tool":"fixture text-0190 placeholder","preserve_args":["fixture text-0191 placeholder"],"instruction":"fixture text-0192 placeholder"}},"desktop_output_continuation":{"has_more":true,"continuation_hint":{"tool":"fixture text-0193 placeholder","preserve_args":["fixture text-0194 placeholder"],"instruction":"fixture text-0195 placeholder"}},"description":"fixture text-0196 placeholder"},"isError":false,"timestamp":1791606279902}}
+{"message_id":"msg-0197","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0136","toolName":"tool_01","content":[{"type":"text","text":"fixture text-0198 placeholder"}],"details":{"execution":{"status":"fixture text-0199 placeholder","reason":"fixture text-019a placeholder","exitCode":0},"timing":{"commandTimerStartedAt":1791606280027,"commandDeadlineAt":1791606400027,"commandTimeoutSeconds":120},"output":{"rawBytes":1704,"persistence":"fixture text-019b placeholder"},"processOutput":{"stdout":"fixture text-019c placeholder","stderr":"fixture text-019d placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false},"description":"fixture text-019e placeholder"},"isError":false,"timestamp":1791606280744}}
+{"message_id":"msg-019f","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-019g placeholder","thinkingSignature":"fixture text-019h placeholder"},{"type":"toolCall","id":"call_0137","name":"tool_01","arguments":{"command":"fixture text-019i placeholder","description":"fixture text-019j placeholder"}},{"type":"toolCall","id":"call_0138","name":"tool_01","arguments":{"command":"fixture text-019k placeholder","description":"fixture text-019l placeholder"}}],"api":"fixture text-019m placeholder","provider":"fixture text-019n placeholder","model":"fixture text-019o placeholder","usage":{"input":5778,"output":578,"cacheRead":22984,"cacheWrite":0,"totalTokens":29340,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791606280764,"responseId":"fixture text-019p placeholder"}}
+{"message_id":"msg-019q","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0137","toolName":"tool_01","content":[{"type":"text","text":"fixture text-019r placeholder"}],"details":{"execution":{"status":"fixture text-019s placeholder","reason":"fixture text-019t placeholder","exitCode":0},"timing":{"commandTimerStartedAt":1791606295575,"commandDeadlineAt":1791606415575,"commandTimeoutSeconds":120},"output":{"rawBytes":8639,"persistence":"fixture text-019u placeholder"},"processOutput":{"stdout":"fixture text-019v placeholder","stderr":"fixture text-019w placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false},"description":"fixture text-019x placeholder"},"isError":false,"timestamp":1791606296979}}
+{"message_id":"msg-019y","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0138","toolName":"tool_01","content":[{"type":"text","text":"fixture text-019z placeholder"}],"details":{"execution":{"status":"fixture text-01a0 placeholder","reason":"fixture text-01a1 placeholder","exitCode":0},"timing":{"commandTimerStartedAt":1791606297099,"commandDeadlineAt":1791606417099,"commandTimeoutSeconds":120},"output":{"rawBytes":3277,"persistence":"fixture text-01a2 placeholder"},"processOutput":{"stdout":"fixture text-01a3 placeholder","stderr":"fixture text-01a4 placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false},"description":"fixture text-01a5 placeholder"},"isError":false,"timestamp":1791606297652}}
+{"message_id":"msg-01a6","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-01a7 placeholder","thinkingSignature":"fixture text-01a8 placeholder"},{"type":"toolCall","id":"call_0139","name":"tool_01","arguments":{"command":"fixture text-01a9 placeholder","description":"fixture text-01aa placeholder"}},{"type":"toolCall","id":"call_0140","name":"tool_03","arguments":{"output_mode":"fixture text-01ab placeholder","pattern":"fixture text-01ac placeholder","path":"fixture text-01ad placeholder","ignoreCase":true,"limit":60}}],"api":"fixture text-01ae placeholder","provider":"fixture text-01af placeholder","model":"fixture text-01ag placeholder","usage":{"input":3909,"output":625,"cacheRead":28761,"cacheWrite":0,"totalTokens":33295,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791606297670,"responseId":"fixture text-01ah placeholder"}}
+{"message_id":"msg-01ai","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0139","toolName":"tool_01","content":[{"type":"text","text":"fixture text-01aj placeholder"}],"details":{"execution":{"status":"fixture text-01ak placeholder","reason":"fixture text-01al placeholder","exitCode":0},"timing":{"commandTimerStartedAt":1791606310936,"commandDeadlineAt":1791606430936,"commandTimeoutSeconds":120},"output":{"rawBytes":1125,"persistence":"fixture text-01am placeholder"},"processOutput":{"stdout":"fixture text-01an placeholder","stderr":"fixture text-01ao placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false},"description":"fixture text-01ap placeholder"},"isError":false,"timestamp":1791606311400}}
+{"message_id":"msg-01aq","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0140","toolName":"tool_03","content":[{"type":"text","text":"fixture text-01ar placeholder"}],"details":{},"isError":false,"timestamp":1791606311561}}
+{"message_id":"msg-01as","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-01at placeholder","thinkingSignature":"fixture text-01au placeholder"},{"type":"toolCall","id":"call_0141","name":"tool_01","arguments":{"command":"fixture text-01av placeholder","description":"fixture text-01aw placeholder"}}],"api":"fixture text-01ax placeholder","provider":"fixture text-01ay placeholder","model":"fixture text-01az placeholder","usage":{"input":1026,"output":291,"cacheRead":32669,"cacheWrite":0,"totalTokens":33986,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791606311578,"responseId":"fixture text-01b0 placeholder"}}
+{"message_id":"msg-01b1","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0141","toolName":"tool_01","content":[{"type":"text","text":"fixture text-01b2 placeholder"}],"details":{"execution":{"status":"fixture text-01b3 placeholder","reason":"fixture text-01b4 placeholder","exitCode":0},"timing":{"commandTimerStartedAt":1791606326155,"commandDeadlineAt":1791606446155,"commandTimeoutSeconds":120},"output":{"rawBytes":3945,"persistence":"fixture text-01b5 placeholder"},"processOutput":{"stdout":"fixture text-01b6 placeholder","stderr":"fixture text-01b7 placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false},"description":"fixture text-01b8 placeholder"},"isError":false,"timestamp":1791606326758}}
+{"message_id":"msg-01b9","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-01ba placeholder","thinkingSignature":"fixture text-01bb placeholder"},{"type":"toolCall","id":"call_0142","name":"tool_01","arguments":{"command":"fixture text-01bc placeholder","description":"fixture text-01bd placeholder"}}],"api":"fixture text-01be placeholder","provider":"fixture text-01bf placeholder","model":"fixture text-01bg placeholder","usage":{"input":2338,"output":173,"cacheRead":33694,"cacheWrite":0,"totalTokens":36205,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791606326777,"responseId":"fixture text-01bh placeholder"}}
+{"message_id":"msg-01bi","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0142","toolName":"tool_01","content":[{"type":"text","text":"fixture text-01bj placeholder"}],"details":{"execution":{"status":"fixture text-01bk placeholder","reason":"fixture text-01bl placeholder","exitCode":0},"timing":{"commandTimerStartedAt":1791606337216,"commandDeadlineAt":1791606457216,"commandTimeoutSeconds":120},"output":{"rawBytes":4277,"persistence":"fixture text-01bm placeholder"},"processOutput":{"stdout":"fixture text-01bn placeholder","stderr":"fixture text-01bo placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false},"description":"fixture text-01bp placeholder"},"isError":false,"timestamp":1791606337783}}
+{"message_id":"msg-01bq","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-01br placeholder","thinkingSignature":"fixture text-01bs placeholder"},{"type":"toolCall","id":"call_0143","name":"tool_01","arguments":{"command":"fixture text-01bt placeholder","description":"fixture text-01bu placeholder"}}],"api":"fixture text-01bv placeholder","provider":"fixture text-01bw placeholder","model":"fixture text-01bx placeholder","usage":{"input":1920,"output":356,"cacheRead":36031,"cacheWrite":0,"totalTokens":38307,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791606337803,"responseId":"fixture text-01by placeholder"}}
+{"message_id":"msg-01bz","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0143","toolName":"tool_01","content":[{"type":"text","text":"fixture text-01c0 placeholder"}],"details":{"execution":{"status":"fixture text-01c1 placeholder","reason":"fixture text-01c2 placeholder","exitCode":0},"timing":{"commandTimerStartedAt":1791606353426,"commandDeadlineAt":1791606473426,"commandTimeoutSeconds":120},"output":{"rawBytes":2579,"persistence":"fixture text-01c3 placeholder"},"processOutput":{"stdout":"fixture text-01c4 placeholder","stderr":"fixture text-01c5 placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false},"description":"fixture text-01c6 placeholder"},"isError":false,"timestamp":1791606353951}}
+{"message_id":"msg-01c7","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-01c8 placeholder","thinkingSignature":"fixture text-01c9 placeholder"},{"type":"toolCall","id":"call_0144","name":"tool_03","arguments":{"glob":"fixture text-01ca placeholder","ignoreCase":true,"output_mode":"fixture text-01cb placeholder","path":"fixture text-01cc placeholder","pattern":"fixture text-01cd placeholder","limit":40}},{"type":"toolCall","id":"call_0145","name":"tool_03","arguments":{"ignoreCase":true,"output_mode":"fixture text-01ce placeholder","path":"fixture text-01cf placeholder","pattern":"fixture text-01cg placeholder","limit":30}}],"api":"fixture text-01ch placeholder","provider":"fixture text-01ci placeholder","model":"fixture text-01cj placeholder","usage":{"input":1477,"output":456,"cacheRead":37950,"cacheWrite":0,"totalTokens":39883,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791606353969,"responseId":"fixture text-01ck placeholder"}}
+{"message_id":"msg-01cl","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0144","toolName":"tool_03","content":[{"type":"text","text":"fixture text-01cm placeholder"}],"details":{},"isError":false,"timestamp":1791606386692}}
+{"message_id":"msg-01cn","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0145","toolName":"tool_03","content":[{"type":"text","text":"fixture text-01co placeholder"}],"details":{"matchLimitReached":30},"isError":false,"timestamp":1791606386706}}
+{"message_id":"msg-01cp","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-01cq placeholder","thinkingSignature":"fixture text-01cr placeholder"},{"type":"toolCall","id":"call_0146","name":"tool_00","arguments":{"path":"fixture text-01cs placeholder","offset":270,"limit":45}},{"type":"toolCall","id":"call_0147","name":"tool_00","arguments":{"path":"fixture text-01ct placeholder"}}],"api":"fixture text-01cu placeholder","provider":"fixture text-01cv placeholder","model":"fixture text-01cw placeholder","usage":{"input":2160,"output":236,"cacheRead":39426,"cacheWrite":0,"totalTokens":41822,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791606386726,"responseId":"fixture text-01cx placeholder"}}
+{"message_id":"msg-01cy","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0146","toolName":"tool_00","content":[{"type":"text","text":"fixture text-01cz placeholder"}],"details":{"textFile":{"path":"fixture text-01d0 placeholder","content":"fixture text-01d1 placeholder","numLines":45,"startLine":270,"totalLines":341,"truncatedByOutputLimit":false,"wholeFileAutoTruncated":false}},"isError":false,"timestamp":1791606440595}}
+{"message_id":"msg-01d2","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0147","toolName":"tool_00","content":[{"type":"text","text":"fixture text-01d3 placeholder"}],"details":{"textFile":{"path":"fixture text-01d4 placeholder","content":"fixture text-01d5 placeholder","numLines":129,"startLine":1,"totalLines":130,"truncatedByOutputLimit":false,"wholeFileAutoTruncated":false}},"isError":false,"timestamp":1791606440608}}
+{"message_id":"msg-01d6","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-01d7 placeholder","thinkingSignature":"fixture text-01d8 placeholder"},{"type":"toolCall","id":"call_0148","name":"tool_03","arguments":{"ignoreCase":true,"limit":40,"output_mode":"fixture text-01d9 placeholder","path":"fixture text-01da placeholder","pattern":"fixture text-01db placeholder"}},{"type":"toolCall","id":"call_0149","name":"tool_03","arguments":{"limit":30,"output_mode":"fixture text-01dc placeholder","path":"fixture text-01dd placeholder","pattern":"fixture text-01de placeholder"}}],"api":"fixture text-01df placeholder","provider":"fixture text-01dg placeholder","model":"fixture text-01dh placeholder","usage":{"input":3094,"output":301,"cacheRead":41585,"cacheWrite":0,"totalTokens":44980,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791606440628,"responseId":"fixture text-01di placeholder"}}
+{"message_id":"msg-01dj","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0148","toolName":"tool_03","content":[{"type":"text","text":"fixture text-01dk placeholder"}],"details":{},"isError":false,"timestamp":1791606449849}}
+{"message_id":"msg-01dl","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0149","toolName":"tool_03","content":[{"type":"text","text":"fixture text-01dm placeholder"}],"details":{},"isError":false,"timestamp":1791606449862}}
+{"message_id":"msg-01dn","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-01do placeholder","thinkingSignature":"fixture text-01dp placeholder"},{"type":"toolCall","id":"call_0150","name":"tool_00","arguments":{"limit":60,"path":"fixture text-01dq placeholder"}},{"type":"toolCall","id":"call_0151","name":"tool_03","arguments":{"ignoreCase":true,"output_mode":"fixture text-01dr placeholder","path":"fixture text-01ds placeholder","pattern":"fixture text-01dt placeholder"}}],"api":"fixture text-01du placeholder","provider":"fixture text-01dv placeholder","model":"fixture text-01dw placeholder","usage":{"input":378,"output":308,"cacheRead":44678,"cacheWrite":0,"totalTokens":45364,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791606449882,"responseId":"fixture text-01dx placeholder"}}
+{"message_id":"msg-01dy","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0150","toolName":"tool_00","content":[{"type":"text","text":"fixture text-01dz placeholder"}],"details":{"textFile":{"path":"fixture text-01e0 placeholder","content":"fixture text-01e1 placeholder","numLines":60,"startLine":1,"totalLines":97,"truncatedByOutputLimit":false,"wholeFileAutoTruncated":false}},"isError":false,"timestamp":1791606465980}}
+{"message_id":"msg-01e2","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0151","toolName":"tool_03","content":[{"type":"text","text":"fixture text-01e3 placeholder"}],"details":{},"isError":false,"timestamp":1791606465994}}
+{"message_id":"msg-01e4","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-01e5 placeholder","thinkingSignature":"fixture text-01e6 placeholder"},{"type":"toolCall","id":"call_0152","name":"tool_01","arguments":{"command":"fixture text-01e7 placeholder","description":"fixture text-01e8 placeholder"}},{"type":"toolCall","id":"call_0153","name":"tool_01","arguments":{"command":"fixture text-01e9 placeholder","description":"fixture text-01ea placeholder"}}],"api":"fixture text-01eb placeholder","provider":"fixture text-01ec placeholder","model":"fixture text-01ed placeholder","usage":{"input":1307,"output":679,"cacheRead":45055,"cacheWrite":0,"totalTokens":47041,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791606466015,"responseId":"fixture text-01ee placeholder"}}
+{"message_id":"msg-01ef","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0152","toolName":"tool_01","content":[{"type":"text","text":"fixture text-01eg placeholder"}],"details":{"execution":{"status":"fixture text-01eh placeholder","reason":"fixture text-01ei placeholder","exitCode":0},"timing":{"commandTimerStartedAt":1791606527802,"commandDeadlineAt":1791606647802,"commandTimeoutSeconds":120},"output":{"rawBytes":2135,"persistence":"fixture text-01ej placeholder"},"processOutput":{"stdout":"fixture text-01ek placeholder","stderr":"fixture text-01el placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false},"description":"fixture text-01em placeholder"},"isError":false,"timestamp":1791606528296}}
+{"message_id":"msg-01en","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0153","toolName":"tool_01","content":[{"type":"text","text":"fixture text-01eo placeholder"}],"details":{"execution":{"status":"fixture text-01ep placeholder","reason":"fixture text-01eq placeholder","exitCode":0},"timing":{"commandTimerStartedAt":1791606528425,"commandDeadlineAt":1791606648425,"commandTimeoutSeconds":120},"output":{"rawBytes":324,"persistence":"fixture text-01er placeholder"},"processOutput":{"stdout":"fixture text-01es placeholder","stderr":"fixture text-01et placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false},"description":"fixture text-01eu placeholder"},"isError":false,"timestamp":1791606529850}}
+{"message_id":"msg-01ev","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-01ew placeholder","thinkingSignature":"fixture text-01ex placeholder"},{"type":"toolCall","id":"call_0154","name":"tool_01","arguments":{"command":"fixture text-01ey placeholder","description":"fixture text-01ez placeholder"}},{"type":"toolCall","id":"call_0155","name":"tool_03","arguments":{"ignoreCase":false,"output_mode":"fixture text-01f0 placeholder","path":"fixture text-01f1 placeholder","pattern":"fixture text-01f2 placeholder"}}],"api":"fixture text-01f3 placeholder","provider":"fixture text-01f4 placeholder","model":"fixture text-01f5 placeholder","usage":{"input":1401,"output":579,"cacheRead":46361,"cacheWrite":0,"totalTokens":48341,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791606529873,"responseId":"fixture text-01f6 placeholder"}}
+{"message_id":"msg-01f7","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0154","toolName":"tool_01","content":[{"type":"text","text":"fixture text-01f8 placeholder"}],"details":{"execution":{"status":"fixture text-01f9 placeholder","reason":"fixture text-01fa placeholder","exitCode":0},"timing":{"commandTimerStartedAt":1791606538556,"commandDeadlineAt":1791606658556,"commandTimeoutSeconds":120},"output":{"rawBytes":110,"persistence":"fixture text-01fb placeholder"},"processOutput":{"stdout":"fixture text-01fc placeholder","stderr":"fixture text-01fd placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false},"description":"fixture text-01fe placeholder"},"isError":false,"timestamp":1791606543498}}
+{"message_id":"msg-01ff","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0155","toolName":"tool_03","content":[{"type":"text","text":"fixture text-01fg placeholder"}],"details":{},"isError":true,"timestamp":1791606543619}}
diff --git a/plugins/avatasia/mmc-trajectory/tests/fixtures/minimax-home/v2/sessions/fixture-agent/00-00-05-000-session_fixture05/manifest.json b/plugins/avatasia/mmc-trajectory/tests/fixtures/minimax-home/v2/sessions/fixture-agent/00-00-05-000-session_fixture05/manifest.json
new file mode 100644
index 0000000..191e6fd
--- /dev/null
+++ b/plugins/avatasia/mmc-trajectory/tests/fixtures/minimax-home/v2/sessions/fixture-agent/00-00-05-000-session_fixture05/manifest.json
@@ -0,0 +1,4 @@
+{
+  "sessionId": "mvs_00000000000000000000000000000006",
+  "createdAtMs": 1750000005000
+}
\ No newline at end of file
diff --git a/plugins/avatasia/mmc-trajectory/tests/fixtures/minimax-home/v2/sessions/fixture-agent/00-00-05-000-session_fixture05/messages.jsonl b/plugins/avatasia/mmc-trajectory/tests/fixtures/minimax-home/v2/sessions/fixture-agent/00-00-05-000-session_fixture05/messages.jsonl
new file mode 100644
index 0000000..c073f6e
--- /dev/null
+++ b/plugins/avatasia/mmc-trajectory/tests/fixtures/minimax-home/v2/sessions/fixture-agent/00-00-05-000-session_fixture05/messages.jsonl
@@ -0,0 +1,60 @@
+{"message_id":"msg-01fh","turn_id":"turn-001","message":{"role":"user","content":[{"type":"text","text":"<system-reminder>\nfixture injected-01fi block"}],"timestamp":1791604308368,"canonicalTextRange":{"startOffset":12190,"endOffset":12190}}}
+{"message_id":"msg-01fj","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"text","text":"fixture text-01fk placeholder"},{"type":"toolCall","id":"call_0156","name":"tool_00","arguments":{"path":"fixture text-01fl placeholder"}},{"type":"toolCall","id":"call_0157","name":"tool_00","arguments":{"path":"fixture text-01fm placeholder"}}],"api":"fixture text-01fn placeholder","provider":"fixture text-01fo placeholder","model":"fixture text-01fp placeholder","usage":{"input":16669,"output":107,"cacheRead":384,"cacheWrite":0,"totalTokens":17160,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604308387,"responseId":"fixture text-01fq placeholder"}}
+{"message_id":"msg-01fr","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0156","toolName":"tool_00","content":[{"type":"text","text":"fixture text-01fs placeholder"}],"details":{"textFile":{"path":"fixture text-01ft placeholder","content":"fixture text-01fu placeholder","numLines":310,"startLine":1,"totalLines":311,"truncatedByOutputLimit":false,"wholeFileAutoTruncated":false}},"isError":false,"timestamp":1791604310438}}
+{"message_id":"msg-01fv","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0157","toolName":"tool_00","content":[{"type":"text","text":"fixture text-01fw placeholder"}],"details":{"textFile":{"path":"fixture text-01fx placeholder","content":"fixture text-01fy placeholder","numLines":129,"startLine":1,"totalLines":130,"truncatedByOutputLimit":false,"wholeFileAutoTruncated":false}},"isError":false,"timestamp":1791604310448}}
+{"message_id":"msg-01fz","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-01g0 placeholder","thinkingSignature":"fixture text-01g1 placeholder"},{"type":"text","text":"fixture text-01g2 placeholder"},{"type":"toolCall","id":"call_0158","name":"tool_00","arguments":{"path":"fixture text-01g3 placeholder"}},{"type":"toolCall","id":"call_0159","name":"tool_00","arguments":{"path":"fixture text-01g4 placeholder"}}],"api":"fixture text-01g5 placeholder","provider":"fixture text-01g6 placeholder","model":"fixture text-01g7 placeholder","usage":{"input":6748,"output":118,"cacheRead":17152,"cacheWrite":0,"totalTokens":24018,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604310463,"responseId":"fixture text-01g8 placeholder"}}
+{"message_id":"msg-01g9","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0158","toolName":"tool_00","content":[{"type":"text","text":"fixture text-01ga placeholder"}],"details":{"textFile":{"path":"fixture text-01gb placeholder","content":"fixture text-01gc placeholder","numLines":38,"startLine":1,"totalLines":39,"truncatedByOutputLimit":false,"wholeFileAutoTruncated":false}},"isError":false,"timestamp":1791604313553}}
+{"message_id":"msg-01gd","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0159","toolName":"tool_00","content":[{"type":"text","text":"fixture text-01ge placeholder"}],"details":{"textFile":{"path":"fixture text-01gf placeholder","content":"fixture text-01gg placeholder","numLines":11,"startLine":1,"totalLines":12,"truncatedByOutputLimit":false,"wholeFileAutoTruncated":false}},"isError":false,"timestamp":1791604313562}}
+{"message_id":"msg-01gh","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-01gi placeholder","thinkingSignature":"fixture text-01gj placeholder"},{"type":"text","text":"fixture text-01gk placeholder"},{"type":"toolCall","id":"call_0160","name":"tool_08","arguments":{"pattern":"fixture text-01gl placeholder","path":"fixture text-01gm placeholder","limit":60}},{"type":"toolCall","id":"call_0161","name":"tool_08","arguments":{"pattern":"fixture text-01gn placeholder","path":"fixture text-01go placeholder","limit":60}}],"api":"fixture text-01gp placeholder","provider":"fixture text-01gq placeholder","model":"fixture text-01gr placeholder","usage":{"input":771,"output":211,"cacheRead":23936,"cacheWrite":0,"totalTokens":24918,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604313578,"responseId":"fixture text-01gs placeholder"}}
+{"message_id":"msg-01gt","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0160","toolName":"tool_08","content":[{"type":"text","text":"fixture text-01gu placeholder"}],"details":{"matched":53,"limit":60,"offset":0},"isError":false,"timestamp":1791604317517}}
+{"message_id":"msg-01gv","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0161","toolName":"tool_08","content":[{"type":"text","text":"fixture text-01gw placeholder"}],"details":{"matched":6,"limit":60,"offset":0},"isError":false,"timestamp":1791604317527}}
+{"message_id":"msg-01gx","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-01gy placeholder","thinkingSignature":"fixture text-01gz placeholder"},{"type":"text","text":"fixture text-01h0 placeholder"},{"type":"toolCall","id":"call_0162","name":"tool_00","arguments":{"path":"fixture text-01h1 placeholder","limit":80}},{"type":"toolCall","id":"call_0163","name":"tool_00","arguments":{"path":"fixture text-01h2 placeholder","limit":60}}],"api":"fixture text-01h3 placeholder","provider":"fixture text-01h4 placeholder","model":"fixture text-01h5 placeholder","usage":{"input":626,"output":175,"cacheRead":24832,"cacheWrite":0,"totalTokens":25633,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604317542,"responseId":"fixture text-01h6 placeholder"}}
+{"message_id":"msg-01h7","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0162","toolName":"tool_00","content":[{"type":"text","text":"fixture text-01h8 placeholder"}],"details":{"textFile":{"path":"fixture text-01h9 placeholder","content":"fixture text-01ha placeholder","numLines":80,"startLine":1,"totalLines":584,"truncatedByOutputLimit":false,"wholeFileAutoTruncated":false}},"isError":false,"timestamp":1791604324558}}
+{"message_id":"msg-01hb","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0163","toolName":"tool_00","content":[{"type":"text","text":"fixture text-01hc placeholder"}],"details":{"textFile":{"path":"fixture text-01hd placeholder","content":"fixture text-01he placeholder","numLines":60,"startLine":1,"totalLines":148,"truncatedByOutputLimit":false,"wholeFileAutoTruncated":false}},"isError":false,"timestamp":1791604324569}}
+{"message_id":"msg-01hf","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-01hg placeholder","thinkingSignature":"fixture text-01hh placeholder"},{"type":"toolCall","id":"call_0164","name":"tool_00","arguments":{"path":"fixture text-01hi placeholder"}},{"type":"toolCall","id":"call_0165","name":"tool_01","arguments":{"command":"fixture text-01hj placeholder","description":"fixture text-01hk placeholder"}}],"api":"fixture text-01hl placeholder","provider":"fixture text-01hm placeholder","model":"fixture text-01hn placeholder","usage":{"input":1881,"output":252,"cacheRead":25600,"cacheWrite":0,"totalTokens":27733,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604324587,"responseId":"fixture text-01ho placeholder"}}
+{"message_id":"msg-01hp","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0164","toolName":"tool_00","content":[{"type":"text","text":"fixture text-01hq placeholder"}],"details":{"textFile":{"path":"fixture text-01hr placeholder","content":"fixture text-01hs placeholder","numLines":20,"startLine":1,"totalLines":21,"truncatedByOutputLimit":false,"wholeFileAutoTruncated":false}},"isError":false,"timestamp":1791604328356}}
+{"message_id":"msg-01ht","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0165","toolName":"tool_01","content":[{"type":"text","text":"fixture text-01hu placeholder"}],"details":{"execution":{"status":"fixture text-01hv placeholder","reason":"fixture text-01hw placeholder","exitCode":0},"timing":{"commandTimeoutSeconds":3600,"commandTimerStartedAt":1791604328496,"commandDeadlineAt":1791607928496},"output":{"rawBytes":16,"persistence":"fixture text-01hx placeholder","omittedBytes":0},"processOutput":{"stdout":"fixture text-01hy placeholder","stderr":"fixture text-01hz placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false,"rawOutputPath":"fixture text-01i0 placeholder"},"description":"fixture text-01i1 placeholder","fullOutputPath":"fixture text-01i2 placeholder","envSanitized":["fixture text-01i3 placeholder","fixture text-01i4 placeholder","fixture text-01i5 placeholder","fixture text-01i6 placeholder","fixture text-01i7 placeholder"],"status":"fixture text-01i8 placeholder","task_id":"fixture text-01i9 placeholder"},"isError":false,"timestamp":1791604329161}}
+{"message_id":"msg-01ia","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-01ib placeholder","thinkingSignature":"fixture text-01ic placeholder"},{"type":"text","text":"fixture text-01id placeholder"},{"type":"toolCall","id":"call_0166","name":"tool_02","arguments":{"path":"fixture text-01ie placeholder","content":"fixture text-01if placeholder"}}],"api":"fixture text-01ig placeholder","provider":"fixture text-01ih placeholder","model":"fixture text-01ii placeholder","usage":{"input":26792,"output":32142,"cacheRead":1152,"cacheWrite":0,"totalTokens":60086,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604329184,"responseId":"fixture text-01ij placeholder"}}
+{"message_id":"msg-01ik","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0166","toolName":"tool_02","content":[{"type":"text","text":"fixture text-01il placeholder"}],"details":{"created":false,"bytes_written":89061,"encoding":"fixture text-01im placeholder","bom":false,"patch":"fixture text-01in placeholder","firstChangedLine":2},"isError":false,"timestamp":1791604539423}}
+{"message_id":"msg-01io","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-01ip placeholder","thinkingSignature":"fixture text-01iq placeholder"},{"type":"text","text":"fixture text-01ir placeholder"},{"type":"toolCall","id":"call_0167","name":"tool_02","arguments":{"content":"fixture text-01is placeholder","path":"fixture text-01it placeholder"}}],"api":"fixture text-01iu placeholder","provider":"fixture text-01iv placeholder","model":"fixture text-01iw placeholder","usage":{"input":110,"output":4675,"cacheRead":60032,"cacheWrite":0,"totalTokens":64817,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604539453,"responseId":"fixture text-01ix placeholder"}}
+{"message_id":"msg-01iy","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0167","toolName":"tool_02","content":[{"type":"text","text":"fixture text-01iz placeholder"}],"details":{"created":true,"bytes_written":12613,"encoding":"fixture text-01j0 placeholder","bom":false},"isError":false,"timestamp":1791604580688}}
+{"message_id":"msg-01j1","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"toolCall","id":"call_0168","name":"tool_01","arguments":{"command":"fixture text-01j2 placeholder","description":"fixture text-01j3 placeholder"}}],"api":"fixture text-01j4 placeholder","provider":"fixture text-01j5 placeholder","model":"fixture text-01j6 placeholder","usage":{"input":64730,"output":59,"cacheRead":128,"cacheWrite":0,"totalTokens":64917,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604580712,"responseId":"fixture text-01j7 placeholder"}}
+{"message_id":"msg-01j8","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0168","toolName":"tool_01","content":[{"type":"text","text":"fixture text-01j9 placeholder"}],"details":{"execution":{"status":"fixture text-01ja placeholder","reason":"fixture text-01jb placeholder","exitCode":1,"message":"fixture text-01jc placeholder"},"timing":{"commandTimeoutSeconds":3600,"commandTimerStartedAt":1791604584863,"commandDeadlineAt":1791608184863},"output":{"rawBytes":674,"persistence":"fixture text-01jd placeholder","omittedBytes":0},"processOutput":{"stdout":"fixture text-01je placeholder","stderr":"fixture text-01jf placeholder","exitCode":1,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false,"rawOutputPath":"fixture text-01jg placeholder"},"description":"fixture text-01jh placeholder","fullOutputPath":"fixture text-01ji placeholder","status":"fixture text-01jj placeholder","task_id":"fixture text-01jk placeholder","is_error":true},"isError":true,"timestamp":1791604585468}}
+{"message_id":"msg-01jl","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-01jm placeholder","thinkingSignature":"fixture text-01jn placeholder"},{"type":"text","text":"fixture text-01jo placeholder"},{"type":"toolCall","id":"call_0169","name":"tool_06","arguments":{"file_path":"fixture text-01jp placeholder","old_string":"fixture text-01jq placeholder","new_string":"fixture text-01jr placeholder"}}],"api":"fixture text-01js placeholder","provider":"fixture text-01jt placeholder","model":"fixture text-01ju placeholder","usage":{"input":232,"output":335,"cacheRead":64896,"cacheWrite":0,"totalTokens":65463,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604585493,"responseId":"fixture text-01jv placeholder"}}
+{"message_id":"msg-01jw","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0169","toolName":"tool_06","content":[{"type":"text","text":"fixture text-01jx placeholder"}],"details":{"diff":"fixture text-01jy placeholder","patch":"fixture text-01jz placeholder","firstChangedLine":27},"isError":false,"timestamp":1791604589750}}
+{"message_id":"msg-01k0","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"toolCall","id":"call_0170","name":"tool_01","arguments":{"command":"fixture text-01k1 placeholder","description":"fixture text-01k2 placeholder"}}],"api":"fixture text-01k3 placeholder","provider":"fixture text-01k4 placeholder","model":"fixture text-01k5 placeholder","usage":{"input":737,"output":60,"cacheRead":64768,"cacheWrite":0,"totalTokens":65565,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604589777,"responseId":"fixture text-01k6 placeholder"}}
+{"message_id":"msg-01k7","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0170","toolName":"tool_01","content":[{"type":"text","text":"fixture text-01k8 placeholder"}],"details":{"execution":{"status":"fixture text-01k9 placeholder","reason":"fixture text-01ka placeholder","exitCode":1,"message":"fixture text-01kb placeholder"},"timing":{"commandTimeoutSeconds":3600,"commandTimerStartedAt":1791604592648,"commandDeadlineAt":1791608192648},"output":{"rawBytes":644,"persistence":"fixture text-01kc placeholder","omittedBytes":0},"processOutput":{"stdout":"fixture text-01kd placeholder","stderr":"fixture text-01ke placeholder","exitCode":1,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false,"rawOutputPath":"fixture text-01kf placeholder"},"description":"fixture text-01kg placeholder","fullOutputPath":"fixture text-01kh placeholder","status":"fixture text-01ki placeholder","task_id":"fixture text-01kj placeholder","is_error":true},"isError":true,"timestamp":1791604593254}}
+{"message_id":"msg-01kk","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-01kl placeholder","thinkingSignature":"fixture text-01km placeholder"},{"type":"toolCall","id":"call_0171","name":"tool_06","arguments":{"file_path":"fixture text-01kn placeholder","new_string":"fixture text-01ko placeholder","old_string":"fixture text-01kp placeholder"}}],"api":"fixture text-01kq placeholder","provider":"fixture text-01kr placeholder","model":"fixture text-01ks placeholder","usage":{"input":64610,"output":1442,"cacheRead":1152,"cacheWrite":0,"totalTokens":67204,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604593280,"responseId":"fixture text-01kt placeholder"}}
+{"message_id":"msg-01ku","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0171","toolName":"tool_06","content":[{"type":"text","text":"fixture text-01kv placeholder"}],"details":{"diff":"fixture text-01kw placeholder","patch":"fixture text-01kx placeholder","firstChangedLine":27},"isError":false,"timestamp":1791604607802}}
+{"message_id":"msg-01ky","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"toolCall","id":"call_0172","name":"tool_01","arguments":{"command":"fixture text-01kz placeholder","description":"fixture text-01l0 placeholder"}}],"api":"fixture text-01l1 placeholder","provider":"fixture text-01l2 placeholder","model":"fixture text-01l3 placeholder","usage":{"input":1710,"output":60,"cacheRead":65536,"cacheWrite":0,"totalTokens":67306,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604607828,"responseId":"fixture text-01l4 placeholder"}}
+{"message_id":"msg-01l5","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0172","toolName":"tool_01","content":[{"type":"text","text":"fixture text-01l6 placeholder"}],"details":{"execution":{"status":"fixture text-01l7 placeholder","reason":"fixture text-01l8 placeholder","exitCode":1,"message":"fixture text-01l9 placeholder"},"timing":{"commandTimeoutSeconds":3600,"commandTimerStartedAt":1791604616826,"commandDeadlineAt":1791608216826},"output":{"rawBytes":988,"persistence":"fixture text-01la placeholder","omittedBytes":0},"processOutput":{"stdout":"fixture text-01lb placeholder","stderr":"fixture text-01lc placeholder","exitCode":1,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false,"rawOutputPath":"fixture text-01ld placeholder"},"description":"fixture text-01le placeholder","fullOutputPath":"fixture text-01lf placeholder","status":"fixture text-01lg placeholder","task_id":"fixture text-01lh placeholder","is_error":true},"isError":true,"timestamp":1791604617382}}
+{"message_id":"msg-01li","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-01lj placeholder","thinkingSignature":"fixture text-01lk placeholder"},{"type":"toolCall","id":"call_0173","name":"tool_06","arguments":{"file_path":"fixture text-01ll placeholder","new_string":"fixture text-01lm placeholder","old_string":"fixture text-01ln placeholder"}}],"api":"fixture text-01lo placeholder","provider":"fixture text-01lp placeholder","model":"fixture text-01lq placeholder","usage":{"input":2193,"output":176,"cacheRead":65408,"cacheWrite":0,"totalTokens":67777,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604617408,"responseId":"fixture text-01lr placeholder"}}
+{"message_id":"msg-01ls","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0173","toolName":"tool_06","content":[{"type":"text","text":"fixture text-01lt placeholder"}],"details":{"diff":"fixture text-01lu placeholder","patch":"fixture text-01lv placeholder","firstChangedLine":27},"isError":false,"timestamp":1791604621230}}
+{"message_id":"msg-01lw","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"toolCall","id":"call_0174","name":"tool_01","arguments":{"command":"fixture text-01lx placeholder","description":"fixture text-01ly placeholder"}}],"api":"fixture text-01lz placeholder","provider":"fixture text-01m0 placeholder","model":"fixture text-01m1 placeholder","usage":{"input":619,"output":60,"cacheRead":67200,"cacheWrite":0,"totalTokens":67879,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604621257,"responseId":"fixture text-01m2 placeholder"}}
+{"message_id":"msg-01m3","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0174","toolName":"tool_01","content":[{"type":"text","text":"fixture text-01m4 placeholder"}],"details":{"execution":{"status":"fixture text-01m5 placeholder","reason":"fixture text-01m6 placeholder","exitCode":1,"message":"fixture text-01m7 placeholder"},"timing":{"commandTimeoutSeconds":3600,"commandTimerStartedAt":1791604625506,"commandDeadlineAt":1791608225506},"output":{"rawBytes":231,"persistence":"fixture text-01m8 placeholder","omittedBytes":0},"processOutput":{"stdout":"fixture text-01m9 placeholder","stderr":"fixture text-01ma placeholder","exitCode":1,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false,"rawOutputPath":"fixture text-01mb placeholder"},"description":"fixture text-01mc placeholder","fullOutputPath":"fixture text-01md placeholder","status":"fixture text-01me placeholder","task_id":"fixture text-01mf placeholder","is_error":true},"isError":true,"timestamp":1791604626139}}
+{"message_id":"msg-01mg","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-01mh placeholder","thinkingSignature":"fixture text-01mi placeholder"},{"type":"text","text":"fixture text-01mj placeholder"},{"type":"toolCall","id":"call_0175","name":"tool_06","arguments":{"file_path":"fixture text-01mk placeholder","new_string":"fixture text-01ml placeholder","old_string":"fixture text-01mm placeholder"}}],"api":"fixture text-01mn placeholder","provider":"fixture text-01mo placeholder","model":"fixture text-01mp placeholder","usage":{"input":257,"output":305,"cacheRead":67712,"cacheWrite":0,"totalTokens":68274,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604626166,"responseId":"fixture text-01mq placeholder"}}
+{"message_id":"msg-01mr","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0175","toolName":"tool_06","content":[{"type":"text","text":"fixture text-01ms placeholder"}],"details":{"diff":"fixture text-01mt placeholder","patch":"fixture text-01mu placeholder","firstChangedLine":94},"isError":false,"timestamp":1791604630568}}
+{"message_id":"msg-01mv","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"toolCall","id":"call_0176","name":"tool_06","arguments":{"file_path":"fixture text-01mw placeholder","new_string":"fixture text-01mx placeholder","old_string":"fixture text-01my placeholder"}}],"api":"fixture text-01mz placeholder","provider":"fixture text-01n0 placeholder","model":"fixture text-01n1 placeholder","usage":{"input":476,"output":182,"cacheRead":67840,"cacheWrite":0,"totalTokens":68498,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604630597,"responseId":"fixture text-01n2 placeholder"}}
+{"message_id":"msg-01n3","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0176","toolName":"tool_06","content":[{"type":"text","text":"fixture text-01n4 placeholder"}],"details":{"diff":"fixture text-01n5 placeholder","patch":"fixture text-01n6 placeholder","firstChangedLine":215},"isError":false,"timestamp":1791604636195}}
+{"message_id":"msg-01n7","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"toolCall","id":"call_0177","name":"tool_01","arguments":{"command":"fixture text-01n8 placeholder","description":"fixture text-01n9 placeholder"}}],"api":"fixture text-01na placeholder","provider":"fixture text-01nb placeholder","model":"fixture text-01nc placeholder","usage":{"input":59,"output":60,"cacheRead":68480,"cacheWrite":0,"totalTokens":68599,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604636221,"responseId":"fixture text-01nd placeholder"}}
+{"message_id":"msg-01ne","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0177","toolName":"tool_01","content":[{"type":"text","text":"fixture text-01nf placeholder"}],"details":{"execution":{"status":"fixture text-01ng placeholder","reason":"fixture text-01nh placeholder","exitCode":0},"timing":{"commandTimeoutSeconds":3600,"commandTimerStartedAt":1791604639097,"commandDeadlineAt":1791608239097},"output":{"rawBytes":165,"persistence":"fixture text-01ni placeholder","omittedBytes":0},"processOutput":{"stdout":"fixture text-01nj placeholder","stderr":"fixture text-01nk placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false,"rawOutputPath":"fixture text-01nl placeholder"},"description":"fixture text-01nm placeholder","fullOutputPath":"fixture text-01nn placeholder","status":"fixture text-01no placeholder","task_id":"fixture text-01np placeholder"},"isError":false,"timestamp":1791604639741}}
+{"message_id":"msg-01nq","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-01nr placeholder","thinkingSignature":"fixture text-01ns placeholder"},{"type":"text","text":"fixture text-01nt placeholder"},{"type":"toolCall","id":"call_0178","name":"tool_06","arguments":{"file_path":"fixture text-01nu placeholder","new_string":"fixture text-01nv placeholder","old_string":"fixture text-01nw placeholder"}}],"api":"fixture text-01nx placeholder","provider":"fixture text-01ny placeholder","model":"fixture text-01nz placeholder","usage":{"input":189,"output":2972,"cacheRead":68480,"cacheWrite":0,"totalTokens":71641,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604639768,"responseId":"fixture text-01o0 placeholder"}}
+{"message_id":"msg-01o1","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0178","toolName":"tool_06","content":[{"type":"text","text":"fixture text-01o2 placeholder"}],"details":{"diff":"fixture text-01o3 placeholder","patch":"fixture text-01o4 placeholder","firstChangedLine":1873},"isError":false,"timestamp":1791604683359}}
+{"message_id":"msg-01o5","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-01o6 placeholder","thinkingSignature":"fixture text-01o7 placeholder"},{"type":"toolCall","id":"call_0179","name":"tool_06","arguments":{"file_path":"fixture text-01o8 placeholder","new_string":"fixture text-01o9 placeholder","old_string":"fixture text-01oa placeholder"}}],"api":"fixture text-01ob placeholder","provider":"fixture text-01oc placeholder","model":"fixture text-01od placeholder","usage":{"input":3468,"output":440,"cacheRead":68224,"cacheWrite":0,"totalTokens":72132,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604683387,"responseId":"fixture text-01oe placeholder"}}
+{"message_id":"msg-01of","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0179","toolName":"tool_06","content":[{"type":"text","text":"fixture text-01og placeholder"}],"details":{"diff":"fixture text-01oh placeholder","patch":"fixture text-01oi placeholder","firstChangedLine":1873},"isError":false,"timestamp":1791604688185}}
+{"message_id":"msg-01oj","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"text","text":"fixture text-01ok placeholder"},{"type":"toolCall","id":"call_0180","name":"tool_06","arguments":{"file_path":"fixture text-01ol placeholder","new_string":"fixture text-01om placeholder","old_string":"fixture text-01on placeholder"}}],"api":"fixture text-01oo placeholder","provider":"fixture text-01op placeholder","model":"fixture text-01oq placeholder","usage":{"input":72055,"output":245,"cacheRead":128,"cacheWrite":0,"totalTokens":72428,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604688213,"responseId":"fixture text-01or placeholder"}}
+{"message_id":"msg-01os","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0180","toolName":"tool_06","content":[{"type":"text","text":"fixture text-01ot placeholder"}],"details":{"diff":"fixture text-01ou placeholder","patch":"fixture text-01ov placeholder","firstChangedLine":991},"isError":false,"timestamp":1791604692961}}
+{"message_id":"msg-01ow","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"toolCall","id":"call_0181","name":"tool_06","arguments":{"file_path":"fixture text-01ox placeholder","new_string":"fixture text-01oy placeholder","old_string":"fixture text-01oz placeholder"}}],"api":"fixture text-01p0 placeholder","provider":"fixture text-01p1 placeholder","model":"fixture text-01p2 placeholder","usage":{"input":158,"output":148,"cacheRead":72320,"cacheWrite":0,"totalTokens":72626,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604692989,"responseId":"fixture text-01p3 placeholder"}}
+{"message_id":"msg-01p4","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0181","toolName":"tool_06","content":[{"type":"text","text":"fixture text-01p5 placeholder"}],"details":{"diff":"fixture text-01p6 placeholder","patch":"fixture text-01p7 placeholder","firstChangedLine":2349},"isError":false,"timestamp":1791604695220}}
+{"message_id":"msg-01p8","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"toolCall","id":"call_0182","name":"tool_06","arguments":{"file_path":"fixture text-01p9 placeholder","new_string":"fixture text-01pa placeholder","old_string":"fixture text-01pb placeholder"}}],"api":"fixture text-01pc placeholder","provider":"fixture text-01pd placeholder","model":"fixture text-01pe placeholder","usage":{"input":612,"output":398,"cacheRead":72064,"cacheWrite":0,"totalTokens":73074,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604695247,"responseId":"fixture text-01pf placeholder"}}
+{"message_id":"msg-01pg","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0182","toolName":"tool_06","content":[{"type":"text","text":"fixture text-01ph placeholder"}],"details":{"diff":"fixture text-01pi placeholder","patch":"fixture text-01pj placeholder","firstChangedLine":1720},"isError":false,"timestamp":1791604699191}}
+{"message_id":"msg-01pk","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"toolCall","id":"call_0183","name":"tool_06","arguments":{"file_path":"fixture text-01pl placeholder","new_string":"fixture text-01pm placeholder","old_string":"fixture text-01pn placeholder"}}],"api":"fixture text-01po placeholder","provider":"fixture text-01pp placeholder","model":"fixture text-01pq placeholder","usage":{"input":548,"output":235,"cacheRead":72576,"cacheWrite":0,"totalTokens":73359,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604699219,"responseId":"fixture text-01pr placeholder"}}
+{"message_id":"msg-01ps","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0183","toolName":"tool_06","content":[{"type":"text","text":"fixture text-01pt placeholder"}],"details":{"diff":"fixture text-01pu placeholder","patch":"fixture text-01pv placeholder","firstChangedLine":1762},"isError":false,"timestamp":1791604703808}}
+{"message_id":"msg-01pw","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-01px placeholder","thinkingSignature":"fixture text-01py placeholder"},{"type":"toolCall","id":"call_0184","name":"tool_01","arguments":{"command":"fixture text-01pz placeholder","description":"fixture text-01q0 placeholder"}}],"api":"fixture text-01q1 placeholder","provider":"fixture text-01q2 placeholder","model":"fixture text-01q3 placeholder","usage":{"input":1857,"output":243,"cacheRead":71552,"cacheWrite":0,"totalTokens":73652,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604703837,"responseId":"fixture text-01q4 placeholder"}}
+{"message_id":"msg-01q5","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0184","toolName":"tool_01","content":[{"type":"text","text":"fixture text-01q6 placeholder"}],"details":{"execution":{"status":"fixture text-01q7 placeholder","reason":"fixture text-01q8 placeholder","exitCode":0},"timing":{"commandTimeoutSeconds":3600,"commandTimerStartedAt":1791604707485,"commandDeadlineAt":1791608307485},"output":{"rawBytes":165,"persistence":"fixture text-01q9 placeholder","omittedBytes":0},"processOutput":{"stdout":"fixture text-01qa placeholder","stderr":"fixture text-01qb placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false,"rawOutputPath":"fixture text-01qc placeholder"},"description":"fixture text-01qd placeholder","fullOutputPath":"fixture text-01qe placeholder","status":"fixture text-01qf placeholder","task_id":"fixture text-01qg placeholder"},"isError":false,"timestamp":1791604708217}}
+{"message_id":"msg-01qh","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"toolCall","id":"call_0185","name":"tool_03","arguments":{"pattern":"fixture text-01qi placeholder","path":"fixture text-01qj placeholder","output_mode":"fixture text-01qk placeholder"}}],"api":"fixture text-01ql placeholder","provider":"fixture text-01qm placeholder","model":"fixture text-01qn placeholder","usage":{"input":123,"output":82,"cacheRead":73600,"cacheWrite":0,"totalTokens":73805,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604708246,"responseId":"fixture text-01qo placeholder"}}
+{"message_id":"msg-01qp","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0185","toolName":"tool_03","content":[{"type":"text","text":"fixture text-01qq placeholder"}],"details":{},"isError":true,"timestamp":1791604712148}}
+{"message_id":"msg-01qr","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"toolCall","id":"call_0186","name":"tool_03","arguments":{"output_mode":"fixture text-01qs placeholder","path":"fixture text-01qt placeholder","pattern":"fixture text-01qu placeholder","context":42}}],"api":"fixture text-01qv placeholder","provider":"fixture text-01qw placeholder","model":"fixture text-01qx placeholder","usage":{"input":72719,"output":81,"cacheRead":1152,"cacheWrite":0,"totalTokens":73952,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604712188,"responseId":"fixture text-01qy placeholder"}}
+{"message_id":"msg-01qz","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0186","toolName":"tool_03","content":[{"type":"text","text":"fixture text-01r0 placeholder"}],"details":{"files":1},"isError":false,"timestamp":1791604725843}}
+{"message_id":"msg-01r1","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-01r2 placeholder","thinkingSignature":"fixture text-01r3 placeholder"},{"type":"toolCall","id":"call_0187","name":"tool_03","arguments":{"output_mode":"fixture text-01r4 placeholder","path":"fixture text-01r5 placeholder","pattern":"fixture text-01r6 placeholder","context":40}}],"api":"fixture text-01r7 placeholder","provider":"fixture text-01r8 placeholder","model":"fixture text-01r9 placeholder","usage":{"input":633,"output":100,"cacheRead":73344,"cacheWrite":0,"totalTokens":74077,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604725871,"responseId":"fixture text-01ra placeholder"}}
+{"message_id":"msg-01rb","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-01rc placeholder","thinkingSignature":"fixture text-01rd placeholder"},{"type":"text","text":"fixture text-01re placeholder"}],"api":"fixture text-01rf placeholder","provider":"fixture text-01rg placeholder","model":"fixture text-01rh placeholder","usage":{"input":4125,"output":708,"cacheRead":74240,"cacheWrite":0,"totalTokens":79073,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"stop","timestamp":1791604777675,"responseId":"fixture text-01ri placeholder"}}
diff --git a/plugins/avatasia/mmc-trajectory/tests/fixtures/minimax-home/v2/sessions/fixture-agent/00-00-06-000-session_fixture06/manifest.json b/plugins/avatasia/mmc-trajectory/tests/fixtures/minimax-home/v2/sessions/fixture-agent/00-00-06-000-session_fixture06/manifest.json
new file mode 100644
index 0000000..d654ff8
--- /dev/null
+++ b/plugins/avatasia/mmc-trajectory/tests/fixtures/minimax-home/v2/sessions/fixture-agent/00-00-06-000-session_fixture06/manifest.json
@@ -0,0 +1,4 @@
+{
+  "sessionId": "mvs_00000000000000000000000000000007",
+  "createdAtMs": 1750000006000
+}
\ No newline at end of file
diff --git a/plugins/avatasia/mmc-trajectory/tests/fixtures/minimax-home/v2/sessions/fixture-agent/00-00-06-000-session_fixture06/messages.jsonl b/plugins/avatasia/mmc-trajectory/tests/fixtures/minimax-home/v2/sessions/fixture-agent/00-00-06-000-session_fixture06/messages.jsonl
new file mode 100644
index 0000000..2162b9d
--- /dev/null
+++ b/plugins/avatasia/mmc-trajectory/tests/fixtures/minimax-home/v2/sessions/fixture-agent/00-00-06-000-session_fixture06/messages.jsonl
@@ -0,0 +1,60 @@
+{"message_id":"msg-01rj","turn_id":"turn-001","message":{"role":"user","content":[{"type":"text","text":"<system-reminder>\nfixture injected-01rk block"}],"timestamp":1791604273610,"canonicalTextRange":{"startOffset":13057,"endOffset":13057}}}
+{"message_id":"msg-01rl","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-01rm placeholder","thinkingSignature":"fixture text-01rn placeholder"},{"type":"text","text":"fixture text-01ro placeholder"},{"type":"toolCall","id":"call_0188","name":"tool_00","arguments":{"path":"fixture text-01rp placeholder"}},{"type":"toolCall","id":"call_0189","name":"tool_00","arguments":{"path":"fixture text-01rq placeholder"}}],"api":"fixture text-01rr placeholder","provider":"fixture text-01rs placeholder","model":"fixture text-01rt placeholder","usage":{"input":16908,"output":123,"cacheRead":188,"cacheWrite":0,"totalTokens":17219,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604273723,"responseId":"fixture text-01ru placeholder"}}
+{"message_id":"msg-01rv","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0188","toolName":"tool_00","content":[{"type":"text","text":"fixture text-01rw placeholder"}],"details":{"textFile":{"path":"fixture text-01rx placeholder","content":"fixture text-01ry placeholder","numLines":96,"startLine":1,"totalLines":97,"truncatedByOutputLimit":false,"wholeFileAutoTruncated":false}},"isError":false,"timestamp":1791604275205}}
+{"message_id":"msg-01rz","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0189","toolName":"tool_00","content":[{"type":"text","text":"fixture text-01s0 placeholder"}],"details":{"textFile":{"path":"fixture text-01s1 placeholder","content":"fixture text-01s2 placeholder","numLines":38,"startLine":1,"totalLines":39,"truncatedByOutputLimit":false,"wholeFileAutoTruncated":false}},"isError":false,"timestamp":1791604275214}}
+{"message_id":"msg-01s3","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-01s4 placeholder","thinkingSignature":"fixture text-01s5 placeholder"},{"type":"toolCall","id":"call_0190","name":"tool_00","arguments":{"path":"fixture text-01s6 placeholder"}},{"type":"toolCall","id":"call_0191","name":"tool_00","arguments":{"path":"fixture text-01s7 placeholder"}},{"type":"toolCall","id":"call_0192","name":"tool_00","arguments":{"path":"fixture text-01s8 placeholder"}}],"api":"fixture text-01s9 placeholder","provider":"fixture text-01sa placeholder","model":"fixture text-01sb placeholder","usage":{"input":2277,"output":153,"cacheRead":17096,"cacheWrite":0,"totalTokens":19526,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604275231,"responseId":"fixture text-01sc placeholder"}}
+{"message_id":"msg-01sd","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0190","toolName":"tool_00","content":[{"type":"text","text":"fixture text-01se placeholder"}],"details":{"textFile":{"path":"fixture text-01sf placeholder","content":"fixture text-01sg placeholder","numLines":134,"startLine":1,"totalLines":135,"truncatedByOutputLimit":false,"wholeFileAutoTruncated":false}},"isError":false,"timestamp":1791604276499}}
+{"message_id":"msg-01sh","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0191","toolName":"tool_00","content":[{"type":"text","text":"fixture text-01si placeholder"}],"details":{"textFile":{"path":"fixture text-01sj placeholder","content":"fixture text-01sk placeholder","numLines":62,"startLine":1,"totalLines":63,"truncatedByOutputLimit":false,"wholeFileAutoTruncated":false}},"isError":false,"timestamp":1791604276508}}
+{"message_id":"msg-01sl","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0192","toolName":"tool_00","content":[{"type":"text","text":"fixture text-01sm placeholder"}],"details":{"textFile":{"path":"fixture text-01sn placeholder","content":"fixture text-01so placeholder","numLines":109,"startLine":1,"totalLines":110,"truncatedByOutputLimit":false,"wholeFileAutoTruncated":false}},"isError":false,"timestamp":1791604276518}}
+{"message_id":"msg-01sp","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-01sq placeholder","thinkingSignature":"fixture text-01sr placeholder"},{"type":"toolCall","id":"call_0193","name":"tool_00","arguments":{"path":"fixture text-01ss placeholder"}},{"type":"toolCall","id":"call_0194","name":"tool_00","arguments":{"path":"fixture text-01st placeholder"}},{"type":"toolCall","id":"call_0195","name":"tool_08","arguments":{"pattern":"fixture text-01su placeholder"}}],"api":"fixture text-01sv placeholder","provider":"fixture text-01sw placeholder","model":"fixture text-01sx placeholder","usage":{"input":4150,"output":138,"cacheRead":19373,"cacheWrite":0,"totalTokens":23661,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604276534,"responseId":"fixture text-01sy placeholder"}}
+{"message_id":"msg-01sz","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0193","toolName":"tool_00","content":[{"type":"text","text":"fixture text-01t0 placeholder"}],"details":{"textFile":{"path":"fixture text-01t1 placeholder","content":"fixture text-01t2 placeholder","numLines":43,"startLine":1,"totalLines":44,"truncatedByOutputLimit":false,"wholeFileAutoTruncated":false}},"isError":false,"timestamp":1791604278015}}
+{"message_id":"msg-01t3","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0194","toolName":"tool_00","content":[{"type":"text","text":"fixture text-01t4 placeholder"}],"details":{"textFile":{"path":"fixture text-01t5 placeholder","content":"fixture text-01t6 placeholder","numLines":20,"startLine":1,"totalLines":21,"truncatedByOutputLimit":false,"wholeFileAutoTruncated":false}},"isError":false,"timestamp":1791604278025}}
+{"message_id":"msg-01t7","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0195","toolName":"tool_08","content":[{"type":"text","text":"fixture text-01t8 placeholder"}],"details":{"matched":6,"limit":200,"offset":0},"isError":false,"timestamp":1791604278035}}
+{"message_id":"msg-01t9","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-01ta placeholder","thinkingSignature":"fixture text-01tb placeholder"},{"type":"text","text":"fixture text-01tc placeholder"},{"type":"toolCall","id":"call_0196","name":"tool_01","arguments":{"command":"fixture text-01td placeholder","description":"fixture text-01te placeholder"}}],"api":"fixture text-01tf placeholder","provider":"fixture text-01tg placeholder","model":"fixture text-01th placeholder","usage":{"input":973,"output":245,"cacheRead":23523,"cacheWrite":0,"totalTokens":24741,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604278050,"responseId":"fixture text-01ti placeholder"}}
+{"message_id":"msg-01tj","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0196","toolName":"tool_01","content":[{"type":"text","text":"fixture text-01tk placeholder"}],"details":{"execution":{"status":"fixture text-01tl placeholder","reason":"fixture text-01tm placeholder","exitCode":0},"timing":{"commandTimeoutSeconds":3600,"commandTimerStartedAt":1791604279781,"commandDeadlineAt":1791607879781},"output":{"rawBytes":723,"persistence":"fixture text-01tn placeholder","omittedBytes":0},"processOutput":{"stdout":"fixture text-01to placeholder","stderr":"fixture text-01tp placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false,"rawOutputPath":"fixture text-01tq placeholder"},"description":"fixture text-01tr placeholder","fullOutputPath":"fixture text-01ts placeholder","envSanitized":["fixture text-01tt placeholder","fixture text-01tu placeholder","fixture text-01tv placeholder","fixture text-01tw placeholder","fixture text-01tx placeholder"],"status":"fixture text-01ty placeholder","task_id":"fixture text-01tz placeholder"},"isError":false,"timestamp":1791604280600}}
+{"message_id":"msg-01u0","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-01u1 placeholder","thinkingSignature":"fixture text-01u2 placeholder"},{"type":"toolCall","id":"call_0197","name":"tool_01","arguments":{"command":"fixture text-01u3 placeholder","description":"fixture text-01u4 placeholder"}}],"api":"fixture text-01u5 placeholder","provider":"fixture text-01u6 placeholder","model":"fixture text-01u7 placeholder","usage":{"input":637,"output":221,"cacheRead":24496,"cacheWrite":0,"totalTokens":25354,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604280616,"responseId":"fixture text-01u8 placeholder"}}
+{"message_id":"msg-01u9","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0197","toolName":"tool_01","content":[{"type":"text","text":"fixture text-01ua placeholder"}],"details":{"execution":{"status":"fixture text-01ub placeholder","reason":"fixture text-01uc placeholder","exitCode":0},"timing":{"commandTimeoutSeconds":3600,"commandTimerStartedAt":1791604282336,"commandDeadlineAt":1791607882336},"output":{"rawBytes":2058,"persistence":"fixture text-01ud placeholder","omittedBytes":0},"processOutput":{"stdout":"fixture text-01ue placeholder","stderr":"fixture text-01uf placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false,"rawOutputPath":"fixture text-01ug placeholder"},"description":"fixture text-01uh placeholder","fullOutputPath":"fixture text-01ui placeholder","status":"fixture text-01uj placeholder","task_id":"fixture text-01uk placeholder"},"isError":false,"timestamp":1791604283004}}
+{"message_id":"msg-01ul","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-01um placeholder","thinkingSignature":"fixture text-01un placeholder"},{"type":"toolCall","id":"call_0198","name":"tool_01","arguments":{"command":"fixture text-01uo placeholder","description":"fixture text-01up placeholder"}}],"api":"fixture text-01uq placeholder","provider":"fixture text-01ur placeholder","model":"fixture text-01us placeholder","usage":{"input":1083,"output":317,"cacheRead":25133,"cacheWrite":0,"totalTokens":26533,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604283021,"responseId":"fixture text-01ut placeholder"}}
+{"message_id":"msg-01uu","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0198","toolName":"tool_01","content":[{"type":"text","text":"fixture text-01uv placeholder"}],"details":{"execution":{"status":"fixture text-01uw placeholder","reason":"fixture text-01ux placeholder","exitCode":0},"timing":{"commandTimeoutSeconds":3600,"commandTimerStartedAt":1791604284903,"commandDeadlineAt":1791607884903},"output":{"rawBytes":925,"persistence":"fixture text-01uy placeholder","omittedBytes":0},"processOutput":{"stdout":"fixture text-01uz placeholder","stderr":"fixture text-01v0 placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false,"rawOutputPath":"fixture text-01v1 placeholder"},"description":"fixture text-01v2 placeholder","fullOutputPath":"fixture text-01v3 placeholder","status":"fixture text-01v4 placeholder","task_id":"fixture text-01v5 placeholder"},"isError":false,"timestamp":1791604285571}}
+{"message_id":"msg-01v6","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-01v7 placeholder","thinkingSignature":"fixture text-01v8 placeholder"},{"type":"toolCall","id":"call_0199","name":"tool_01","arguments":{"command":"fixture text-01v9 placeholder","description":"fixture text-01va placeholder"}}],"api":"fixture text-01vb placeholder","provider":"fixture text-01vc placeholder","model":"fixture text-01vd placeholder","usage":{"input":639,"output":370,"cacheRead":26216,"cacheWrite":0,"totalTokens":27225,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604285589,"responseId":"fixture text-01ve placeholder"}}
+{"message_id":"msg-01vf","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0199","toolName":"tool_01","content":[{"type":"text","text":"fixture text-01vg placeholder"}],"details":{"execution":{"status":"fixture text-01vh placeholder","reason":"fixture text-01vi placeholder","exitCode":0},"timing":{"commandTimeoutSeconds":3600,"commandTimerStartedAt":1791604292446,"commandDeadlineAt":1791607892446},"output":{"rawBytes":344,"persistence":"fixture text-01vj placeholder","omittedBytes":0},"processOutput":{"stdout":"fixture text-01vk placeholder","stderr":"fixture text-01vl placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false,"rawOutputPath":"fixture text-01vm placeholder"},"description":"fixture text-01vn placeholder","fullOutputPath":"fixture text-01vo placeholder","status":"fixture text-01vp placeholder","task_id":"fixture text-01vq placeholder"},"isError":false,"timestamp":1791604293102}}
+{"message_id":"msg-01vr","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-01vs placeholder","thinkingSignature":"fixture text-01vt placeholder"},{"type":"toolCall","id":"call_0200","name":"tool_02","arguments":{"path":"fixture text-01vu placeholder","content":"fixture text-01vv placeholder"}}],"api":"fixture text-01vw placeholder","provider":"fixture text-01vx placeholder","model":"fixture text-01vy placeholder","usage":{"input":491,"output":1232,"cacheRead":26855,"cacheWrite":0,"totalTokens":28578,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604293120,"responseId":"fixture text-01vz placeholder"}}
+{"message_id":"msg-01w0","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0200","toolName":"tool_02","content":[{"type":"text","text":"fixture text-01w1 placeholder"}],"details":{"created":true,"bytes_written":3691,"encoding":"fixture text-01w2 placeholder","bom":false},"isError":false,"timestamp":1791604300601}}
+{"message_id":"msg-01w3","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"toolCall","id":"call_0201","name":"tool_01","arguments":{"command":"fixture text-01w4 placeholder","description":"fixture text-01w5 placeholder","timeout":180}}],"api":"fixture text-01w6 placeholder","provider":"fixture text-01w7 placeholder","model":"fixture text-01w8 placeholder","usage":{"input":1273,"output":70,"cacheRead":27346,"cacheWrite":0,"totalTokens":28689,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604300618,"responseId":"fixture text-01w9 placeholder"}}
+{"message_id":"msg-01wa","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0201","toolName":"tool_01","content":[{"type":"text","text":"fixture text-01wb placeholder"}],"details":{"execution":{"status":"fixture text-01wc placeholder","reason":"fixture text-01wd placeholder","exitCode":0},"timing":{"commandTimeoutSeconds":180,"commandTimerStartedAt":1791604301766,"commandDeadlineAt":1791604481766},"output":{"rawBytes":637,"persistence":"fixture text-01we placeholder","omittedBytes":0},"processOutput":{"stdout":"fixture text-01wf placeholder","stderr":"fixture text-01wg placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false,"rawOutputPath":"fixture text-01wh placeholder"},"description":"fixture text-01wi placeholder","fullOutputPath":"fixture text-01wj placeholder","status":"fixture text-01wk placeholder","task_id":"fixture text-01wl placeholder"},"isError":false,"timestamp":1791604302544}}
+{"message_id":"msg-01wm","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-01wn placeholder","thinkingSignature":"fixture text-01wo placeholder"},{"type":"toolCall","id":"call_0202","name":"tool_01","arguments":{"command":"fixture text-01wp placeholder","description":"fixture text-01wq placeholder","timeout":180}}],"api":"fixture text-01wr placeholder","provider":"fixture text-01ws placeholder","model":"fixture text-01wt placeholder","usage":{"input":304,"output":599,"cacheRead":28619,"cacheWrite":0,"totalTokens":29522,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604302563,"responseId":"fixture text-01wu placeholder"}}
+{"message_id":"msg-01wv","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0202","toolName":"tool_01","content":[{"type":"text","text":"fixture text-01ww placeholder"}],"details":{"execution":{"status":"fixture text-01wx placeholder","reason":"fixture text-01wy placeholder","exitCode":0},"timing":{"commandTimeoutSeconds":180,"commandTimerStartedAt":1791604306254,"commandDeadlineAt":1791604486254},"output":{"rawBytes":2318,"persistence":"fixture text-01wz placeholder","omittedBytes":0},"processOutput":{"stdout":"fixture text-01x0 placeholder","stderr":"fixture text-01x1 placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false,"rawOutputPath":"fixture text-01x2 placeholder"},"description":"fixture text-01x3 placeholder","fullOutputPath":"fixture text-01x4 placeholder","status":"fixture text-01x5 placeholder","task_id":"fixture text-01x6 placeholder"},"isError":false,"timestamp":1791604307128}}
+{"message_id":"msg-01x7","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-01x8 placeholder","thinkingSignature":"fixture text-01x9 placeholder"},{"type":"toolCall","id":"call_0203","name":"tool_01","arguments":{"command":"fixture text-01xa placeholder","description":"fixture text-01xb placeholder","timeout":180}}],"api":"fixture text-01xc placeholder","provider":"fixture text-01xd placeholder","model":"fixture text-01xe placeholder","usage":{"input":1301,"output":634,"cacheRead":28923,"cacheWrite":0,"totalTokens":30858,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604307148,"responseId":"fixture text-01xf placeholder"}}
+{"message_id":"msg-01xg","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0203","toolName":"tool_01","content":[{"type":"text","text":"fixture text-01xh placeholder"}],"details":{"execution":{"status":"fixture text-01xi placeholder","reason":"fixture text-01xj placeholder","exitCode":0},"timing":{"commandTimeoutSeconds":180,"commandTimerStartedAt":1791604311191,"commandDeadlineAt":1791604491191},"output":{"rawBytes":223,"persistence":"fixture text-01xk placeholder","omittedBytes":0},"processOutput":{"stdout":"fixture text-01xl placeholder","stderr":"fixture text-01xm placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false,"rawOutputPath":"fixture text-01xn placeholder"},"description":"fixture text-01xo placeholder","fullOutputPath":"fixture text-01xp placeholder","status":"fixture text-01xq placeholder","task_id":"fixture text-01xr placeholder"},"isError":false,"timestamp":1791604312079}}
+{"message_id":"msg-01xs","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-01xt placeholder","thinkingSignature":"fixture text-01xu placeholder"},{"type":"text","text":"fixture text-01xv placeholder"},{"type":"toolCall","id":"call_0204","name":"tool_02","arguments":{"content":"fixture text-01xw placeholder","path":"fixture text-01xx placeholder"}}],"api":"fixture text-01xy placeholder","provider":"fixture text-01xz placeholder","model":"fixture text-01y0 placeholder","usage":{"input":747,"output":19198,"cacheRead":30224,"cacheWrite":0,"totalTokens":50169,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604312102,"responseId":"fixture text-01y1 placeholder"}}
+{"message_id":"msg-01y2","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0204","toolName":"tool_02","content":[{"type":"text","text":"fixture text-01y3 placeholder"}],"details":{"created":false,"bytes_written":37273,"encoding":"fixture text-01y4 placeholder","bom":false,"patch":"fixture text-01y5 placeholder","firstChangedLine":1},"isError":false,"timestamp":1791604417061}}
+{"message_id":"msg-01y6","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-01y7 placeholder","thinkingSignature":"fixture text-01y8 placeholder"},{"type":"text","text":"fixture text-01y9 placeholder"},{"type":"toolCall","id":"call_0205","name":"tool_06","arguments":{"file_path":"fixture text-01ya placeholder","old_string":"fixture text-01yb placeholder","new_string":"fixture text-01yc placeholder"}}],"api":"fixture text-01yd placeholder","provider":"fixture text-01ye placeholder","model":"fixture text-01yf placeholder","usage":{"input":19253,"output":624,"cacheRead":30971,"cacheWrite":0,"totalTokens":50848,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604417085,"responseId":"fixture text-01yg placeholder"}}
+{"message_id":"msg-01yh","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0205","toolName":"tool_06","content":[{"type":"text","text":"fixture text-01yi placeholder"}],"details":{"diff":"fixture text-01yj placeholder","patch":"fixture text-01yk placeholder","firstChangedLine":256},"isError":false,"timestamp":1791604420697}}
+{"message_id":"msg-01yl","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"toolCall","id":"call_0206","name":"tool_06","arguments":{"file_path":"fixture text-01ym placeholder","new_string":"fixture text-01yn placeholder","old_string":"fixture text-01yo placeholder"}}],"api":"fixture text-01yp placeholder","provider":"fixture text-01yq placeholder","model":"fixture text-01yr placeholder","usage":{"input":672,"output":109,"cacheRead":50224,"cacheWrite":0,"totalTokens":51005,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604420720,"responseId":"fixture text-01ys placeholder"}}
+{"message_id":"msg-01yt","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0206","toolName":"tool_06","content":[{"type":"text","text":"fixture text-01yu placeholder"}],"details":{"diff":"fixture text-01yv placeholder","patch":"fixture text-01yw placeholder","firstChangedLine":3},"isError":false,"timestamp":1791604421835}}
+{"message_id":"msg-01yx","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"toolCall","id":"call_0207","name":"tool_06","arguments":{"file_path":"fixture text-01yy placeholder","new_string":"fixture text-01yz placeholder","old_string":"fixture text-01z0 placeholder"}}],"api":"fixture text-01z1 placeholder","provider":"fixture text-01z2 placeholder","model":"fixture text-01z3 placeholder","usage":{"input":159,"output":108,"cacheRead":50896,"cacheWrite":0,"totalTokens":51163,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604421858,"responseId":"fixture text-01z4 placeholder"}}
+{"message_id":"msg-01z5","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0207","toolName":"tool_06","content":[{"type":"text","text":"fixture text-01z6 placeholder"}],"details":{},"isError":true,"timestamp":1791604423217}}
+{"message_id":"msg-01z7","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-01z8 placeholder","thinkingSignature":"fixture text-01z9 placeholder"},{"type":"toolCall","id":"call_0208","name":"tool_06","arguments":{"file_path":"fixture text-01za placeholder","new_string":"fixture text-01zb placeholder","old_string":"fixture text-01zc placeholder"}}],"api":"fixture text-01zd placeholder","provider":"fixture text-01ze placeholder","model":"fixture text-01zf placeholder","usage":{"input":174,"output":255,"cacheRead":51055,"cacheWrite":0,"totalTokens":51484,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604423241,"responseId":"fixture text-01zg placeholder"}}
+{"message_id":"msg-01zh","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0208","toolName":"tool_06","content":[{"type":"text","text":"fixture text-01zi placeholder"}],"details":{"diff":"fixture text-01zj placeholder","patch":"fixture text-01zk placeholder","firstChangedLine":267},"isError":false,"timestamp":1791604425304}}
+{"message_id":"msg-01zl","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"text","text":"fixture text-01zm placeholder"},{"type":"toolCall","id":"call_0209","name":"tool_06","arguments":{"file_path":"fixture text-01zn placeholder","new_string":"fixture text-01zo placeholder","old_string":"fixture text-01zp placeholder"}}],"api":"fixture text-01zq placeholder","provider":"fixture text-01zr placeholder","model":"fixture text-01zs placeholder","usage":{"input":303,"output":126,"cacheRead":51229,"cacheWrite":0,"totalTokens":51658,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604425328,"responseId":"fixture text-01zt placeholder"}}
+{"message_id":"msg-01zu","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0209","toolName":"tool_06","content":[{"type":"text","text":"fixture text-01zv placeholder"}],"details":{"diff":"fixture text-01zw placeholder","patch":"fixture text-01zx placeholder","firstChangedLine":601},"isError":false,"timestamp":1791604426624}}
+{"message_id":"msg-01zy","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"toolCall","id":"call_0210","name":"tool_06","arguments":{"file_path":"fixture text-01zz placeholder","new_string":"fixture text-0200 placeholder","old_string":"fixture text-0201 placeholder"}}],"api":"fixture text-0202 placeholder","provider":"fixture text-0203 placeholder","model":"fixture text-0204 placeholder","usage":{"input":174,"output":408,"cacheRead":51532,"cacheWrite":0,"totalTokens":52114,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604426647,"responseId":"fixture text-0205 placeholder"}}
+{"message_id":"msg-0206","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0210","toolName":"tool_06","content":[{"type":"text","text":"fixture text-0207 placeholder"}],"details":{"diff":"fixture text-0208 placeholder","patch":"fixture text-0209 placeholder","firstChangedLine":960},"isError":false,"timestamp":1791604428769}}
+{"message_id":"msg-020a","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-020b placeholder","thinkingSignature":"fixture text-020c placeholder"},{"type":"toolCall","id":"call_0211","name":"tool_06","arguments":{"file_path":"fixture text-020d placeholder","new_string":"fixture text-020e placeholder","old_string":"fixture text-020f placeholder"}}],"api":"fixture text-020g placeholder","provider":"fixture text-020h placeholder","model":"fixture text-020i placeholder","usage":{"input":456,"output":322,"cacheRead":51706,"cacheWrite":0,"totalTokens":52484,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604428795,"responseId":"fixture text-020j placeholder"}}
+{"message_id":"msg-020k","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0211","toolName":"tool_06","content":[{"type":"text","text":"fixture text-020l placeholder"}],"details":{"diff":"fixture text-020m placeholder","patch":"fixture text-020n placeholder","firstChangedLine":957},"isError":false,"timestamp":1791604430888}}
+{"message_id":"msg-020o","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"text","text":"fixture text-020p placeholder"},{"type":"toolCall","id":"call_0212","name":"tool_01","arguments":{"command":"fixture text-020q placeholder","description":"fixture text-020r placeholder"}}],"api":"fixture text-020s placeholder","provider":"fixture text-020t placeholder","model":"fixture text-020u placeholder","usage":{"input":370,"output":206,"cacheRead":52162,"cacheWrite":0,"totalTokens":52738,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604430912,"responseId":"fixture text-020v placeholder"}}
+{"message_id":"msg-020w","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0212","toolName":"tool_01","content":[{"type":"text","text":"fixture text-020x placeholder"}],"details":{"execution":{"status":"fixture text-020y placeholder","reason":"fixture text-020z placeholder","exitCode":0},"timing":{"commandTimeoutSeconds":3600,"commandTimerStartedAt":1791604432729,"commandDeadlineAt":1791608032729},"output":{"rawBytes":202,"persistence":"fixture text-0210 placeholder","omittedBytes":0},"processOutput":{"stdout":"fixture text-0211 placeholder","stderr":"fixture text-0212 placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false,"rawOutputPath":"fixture text-0213 placeholder"},"description":"fixture text-0214 placeholder","fullOutputPath":"fixture text-0215 placeholder","status":"fixture text-0216 placeholder","task_id":"fixture text-0217 placeholder"},"isError":false,"timestamp":1791604433469}}
+{"message_id":"msg-0218","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-0219 placeholder","thinkingSignature":"fixture text-021a placeholder"},{"type":"text","text":"fixture text-021b placeholder"},{"type":"toolCall","id":"call_0213","name":"tool_06","arguments":{"file_path":"fixture text-021c placeholder","new_string":"fixture text-021d placeholder","old_string":"fixture text-021e placeholder"}}],"api":"fixture text-021f placeholder","provider":"fixture text-021g placeholder","model":"fixture text-021h placeholder","usage":{"input":285,"output":333,"cacheRead":52532,"cacheWrite":0,"totalTokens":53150,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604433495,"responseId":"fixture text-021i placeholder"}}
+{"message_id":"msg-021j","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0213","toolName":"tool_06","content":[{"type":"text","text":"fixture text-021k placeholder"}],"details":{"diff":"fixture text-021l placeholder","patch":"fixture text-021m placeholder","firstChangedLine":199},"isError":false,"timestamp":1791604436221}}
+{"message_id":"msg-021n","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"toolCall","id":"call_0214","name":"tool_06","arguments":{"file_path":"fixture text-021o placeholder","new_string":"fixture text-021p placeholder","old_string":"fixture text-021q placeholder"}}],"api":"fixture text-021r placeholder","provider":"fixture text-021s placeholder","model":"fixture text-021t placeholder","usage":{"input":383,"output":91,"cacheRead":52817,"cacheWrite":0,"totalTokens":53291,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604436246,"responseId":"fixture text-021u placeholder"}}
+{"message_id":"msg-021v","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0214","toolName":"tool_06","content":[{"type":"text","text":"fixture text-021w placeholder"}],"details":{"diff":"fixture text-021x placeholder","patch":"fixture text-021y placeholder","firstChangedLine":237},"isError":false,"timestamp":1791604437248}}
+{"message_id":"msg-021z","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"toolCall","id":"call_0215","name":"tool_06","arguments":{"file_path":"fixture text-0220 placeholder","new_string":"fixture text-0221 placeholder","old_string":"fixture text-0222 placeholder"}}],"api":"fixture text-0223 placeholder","provider":"fixture text-0224 placeholder","model":"fixture text-0225 placeholder","usage":{"input":141,"output":95,"cacheRead":53200,"cacheWrite":0,"totalTokens":53436,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604437273,"responseId":"fixture text-0226 placeholder"}}
+{"message_id":"msg-0227","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0215","toolName":"tool_06","content":[{"type":"text","text":"fixture text-0228 placeholder"}],"details":{"diff":"fixture text-0229 placeholder","patch":"fixture text-022a placeholder","firstChangedLine":250},"isError":false,"timestamp":1791604439391}}
+{"message_id":"msg-022b","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"text","text":"fixture text-022c placeholder"},{"type":"toolCall","id":"call_0216","name":"tool_02","arguments":{"content":"fixture text-022d placeholder","path":"fixture text-022e placeholder"}}],"api":"fixture text-022f placeholder","provider":"fixture text-022g placeholder","model":"fixture text-022h placeholder","usage":{"input":145,"output":2872,"cacheRead":53341,"cacheWrite":0,"totalTokens":56358,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604439416,"responseId":"fixture text-022i placeholder"}}
+{"message_id":"msg-022j","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0216","toolName":"tool_02","content":[{"type":"text","text":"fixture text-022k placeholder"}],"details":{"created":true,"bytes_written":10444,"encoding":"fixture text-022l placeholder","bom":false},"isError":false,"timestamp":1791604455951}}
+{"message_id":"msg-022m","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"toolCall","id":"call_0217","name":"tool_01","arguments":{"command":"fixture text-022n placeholder","description":"fixture text-022o placeholder","timeout":300}}],"api":"fixture text-022p placeholder","provider":"fixture text-022q placeholder","model":"fixture text-022r placeholder","usage":{"input":2913,"output":113,"cacheRead":53486,"cacheWrite":0,"totalTokens":56512,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604455978,"responseId":"fixture text-022s placeholder"}}
+{"message_id":"msg-022t","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0217","toolName":"tool_01","content":[{"type":"text","text":"fixture text-022u placeholder"}],"details":{"execution":{"status":"fixture text-022v placeholder","reason":"fixture text-022w placeholder","exitCode":1,"message":"fixture text-022x placeholder"},"timing":{"commandTimeoutSeconds":300,"commandTimerStartedAt":1791604458233,"commandDeadlineAt":1791604758233},"output":{"rawBytes":3368,"persistence":"fixture text-022y placeholder","omittedBytes":0},"processOutput":{"stdout":"fixture text-022z placeholder","stderr":"fixture text-0230 placeholder","exitCode":1,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false,"rawOutputPath":"fixture text-0231 placeholder"},"description":"fixture text-0232 placeholder","fullOutputPath":"fixture text-0233 placeholder","status":"fixture text-0234 placeholder","task_id":"fixture text-0235 placeholder","is_error":true},"isError":true,"timestamp":1791604459036}}
+{"message_id":"msg-0236","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-0237 placeholder","thinkingSignature":"fixture text-0238 placeholder"},{"type":"text","text":"fixture text-0239 placeholder"},{"type":"toolCall","id":"call_0218","name":"tool_06","arguments":{"file_path":"fixture text-023a placeholder","new_string":"fixture text-023b placeholder","old_string":"fixture text-023c placeholder"}}],"api":"fixture text-023d placeholder","provider":"fixture text-023e placeholder","model":"fixture text-023f placeholder","usage":{"input":1128,"output":2504,"cacheRead":56399,"cacheWrite":0,"totalTokens":60031,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604459064,"responseId":"fixture text-023g placeholder"}}
+{"message_id":"msg-023h","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0218","toolName":"tool_06","content":[{"type":"text","text":"fixture text-023i placeholder"}],"details":{"diff":"fixture text-023j placeholder","patch":"fixture text-023k placeholder","firstChangedLine":29},"isError":false,"timestamp":1791604476002}}
+{"message_id":"msg-023l","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"toolCall","id":"call_0219","name":"tool_06","arguments":{"file_path":"fixture text-023m placeholder","new_string":"fixture text-023n placeholder","old_string":"fixture text-023o placeholder"}}],"api":"fixture text-023p placeholder","provider":"fixture text-023q placeholder","model":"fixture text-023r placeholder","usage":{"input":2554,"output":187,"cacheRead":57527,"cacheWrite":0,"totalTokens":60268,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604476030,"responseId":"fixture text-023s placeholder"}}
+{"message_id":"msg-023t","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"text","text":"fixture text-023u placeholder"}],"api":"fixture text-023v placeholder","provider":"fixture text-023w placeholder","model":"fixture text-023x placeholder","usage":{"input":160,"output":577,"cacheRead":74828,"cacheWrite":0,"totalTokens":75565,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"stop","timestamp":1791604561913,"responseId":"fixture text-023y placeholder"}}
diff --git a/plugins/avatasia/mmc-trajectory/tests/fixtures/minimax-home/v2/sessions/fixture-agent/00-00-07-000-session_fixture07/manifest.json b/plugins/avatasia/mmc-trajectory/tests/fixtures/minimax-home/v2/sessions/fixture-agent/00-00-07-000-session_fixture07/manifest.json
new file mode 100644
index 0000000..a949c12
--- /dev/null
+++ b/plugins/avatasia/mmc-trajectory/tests/fixtures/minimax-home/v2/sessions/fixture-agent/00-00-07-000-session_fixture07/manifest.json
@@ -0,0 +1,4 @@
+{
+  "sessionId": "mvs_00000000000000000000000000000008",
+  "createdAtMs": 1750000007000
+}
\ No newline at end of file
diff --git a/plugins/avatasia/mmc-trajectory/tests/fixtures/minimax-home/v2/sessions/fixture-agent/00-00-07-000-session_fixture07/messages.jsonl b/plugins/avatasia/mmc-trajectory/tests/fixtures/minimax-home/v2/sessions/fixture-agent/00-00-07-000-session_fixture07/messages.jsonl
new file mode 100644
index 0000000..9b22e77
--- /dev/null
+++ b/plugins/avatasia/mmc-trajectory/tests/fixtures/minimax-home/v2/sessions/fixture-agent/00-00-07-000-session_fixture07/messages.jsonl
@@ -0,0 +1,52 @@
+{"message_id":"msg-023z","turn_id":"turn-001","message":{"role":"user","content":[{"type":"text","text":"<system-reminder>\nfixture injected-0240 block"}],"timestamp":1791603988755,"canonicalTextRange":{"startOffset":3279,"endOffset":3279}}}
+{"message_id":"msg-0241","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-0242 placeholder","thinkingSignature":"fixture text-0243 placeholder"},{"type":"text","text":"fixture text-0244 placeholder"},{"type":"toolCall","id":"call_0220","name":"tool_01","arguments":{"command":"fixture text-0245 placeholder","description":"fixture text-0246 placeholder"}},{"type":"toolCall","id":"call_0221","name":"tool_01","arguments":{"command":"fixture text-0247 placeholder","description":"fixture text-0248 placeholder"}}],"api":"fixture text-0249 placeholder","provider":"fixture text-024a placeholder","model":"fixture text-024b placeholder","usage":{"input":9057,"output":262,"cacheRead":1024,"cacheWrite":0,"totalTokens":10343,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791603988770,"responseId":"fixture text-024c placeholder"}}
+{"message_id":"msg-024d","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0220","toolName":"tool_01","content":[{"type":"text","text":"fixture text-024e placeholder"}],"details":{"execution":{"status":"fixture text-024f placeholder","reason":"fixture text-024g placeholder","exitCode":0},"timing":{"commandTimerStartedAt":1791603991675,"commandDeadlineAt":1791604111675,"commandTimeoutSeconds":120},"output":{"rawBytes":1994,"persistence":"fixture text-024h placeholder"},"processOutput":{"stdout":"fixture text-024i placeholder","stderr":"fixture text-024j placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false},"envSanitized":["fixture text-024k placeholder","fixture text-024l placeholder","fixture text-024m placeholder","fixture text-024n placeholder","fixture text-024o placeholder"],"description":"fixture text-024p placeholder"},"isError":false,"timestamp":1791603992137}}
+{"message_id":"msg-024q","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0221","toolName":"tool_01","content":[{"type":"text","text":"fixture text-024r placeholder"}],"details":{"execution":{"status":"fixture text-024s placeholder","reason":"fixture text-024t placeholder","exitCode":0},"timing":{"commandTimerStartedAt":1791603992255,"commandDeadlineAt":1791604112255,"commandTimeoutSeconds":120},"output":{"rawBytes":1105,"persistence":"fixture text-024u placeholder"},"processOutput":{"stdout":"fixture text-024v placeholder","stderr":"fixture text-024w placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false},"description":"fixture text-024x placeholder"},"isError":false,"timestamp":1791603996701}}
+{"message_id":"msg-024y","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-024z placeholder","thinkingSignature":"fixture text-0250 placeholder"},{"type":"text","text":"fixture text-0251 placeholder"},{"type":"toolCall","id":"call_0222","name":"tool_01","arguments":{"command":"fixture text-0252 placeholder","description":"fixture text-0253 placeholder"}},{"type":"toolCall","id":"call_0223","name":"tool_01","arguments":{"command":"fixture text-0254 placeholder","description":"fixture text-0255 placeholder"}}],"api":"fixture text-0256 placeholder","provider":"fixture text-0257 placeholder","model":"fixture text-0258 placeholder","usage":{"input":1653,"output":266,"cacheRead":9728,"cacheWrite":0,"totalTokens":11647,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791603996716,"responseId":"fixture text-0259 placeholder"}}
+{"message_id":"msg-025a","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0222","toolName":"tool_01","content":[{"type":"text","text":"fixture text-025b placeholder"}],"details":{"execution":{"status":"fixture text-025c placeholder","reason":"fixture text-025d placeholder","exitCode":0},"timing":{"commandTimerStartedAt":1791603998985,"commandDeadlineAt":1791604118985,"commandTimeoutSeconds":120},"output":{"rawBytes":2818,"persistence":"fixture text-025e placeholder"},"processOutput":{"stdout":"fixture text-025f placeholder","stderr":"fixture text-025g placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false},"description":"fixture text-025h placeholder"},"isError":false,"timestamp":1791603999529}}
+{"message_id":"msg-025i","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0223","toolName":"tool_01","content":[{"type":"text","text":"fixture text-025j placeholder"}],"details":{"execution":{"status":"fixture text-025k placeholder","reason":"fixture text-025l placeholder","exitCode":0},"timing":{"commandTimerStartedAt":1791603999659,"commandDeadlineAt":1791604119659,"commandTimeoutSeconds":120},"output":{"rawBytes":3593,"persistence":"fixture text-025m placeholder"},"processOutput":{"stdout":"fixture text-025n placeholder","stderr":"fixture text-025o placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false},"description":"fixture text-025p placeholder"},"isError":false,"timestamp":1791604000303}}
+{"message_id":"msg-025q","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-025r placeholder","thinkingSignature":"fixture text-025s placeholder"},{"type":"text","text":"fixture text-025t placeholder"},{"type":"toolCall","id":"call_0224","name":"tool_01","arguments":{"command":"fixture text-025u placeholder","description":"fixture text-025v placeholder"}},{"type":"toolCall","id":"call_0225","name":"tool_01","arguments":{"command":"fixture text-025w placeholder","description":"fixture text-025x placeholder"}}],"api":"fixture text-025y placeholder","provider":"fixture text-025z placeholder","model":"fixture text-0260 placeholder","usage":{"input":3138,"output":365,"cacheRead":11008,"cacheWrite":0,"totalTokens":14511,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604000351,"responseId":"fixture text-0261 placeholder"}}
+{"message_id":"msg-0262","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0224","toolName":"tool_01","content":[{"type":"text","text":"fixture text-0263 placeholder"}],"details":{"execution":{"status":"fixture text-0264 placeholder","reason":"fixture text-0265 placeholder","exitCode":0},"timing":{"commandTimerStartedAt":1791604003504,"commandDeadlineAt":1791604123504,"commandTimeoutSeconds":120},"output":{"rawBytes":40,"persistence":"fixture text-0266 placeholder"},"processOutput":{"stdout":"fixture text-0267 placeholder","stderr":"fixture text-0268 placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false},"description":"fixture text-0269 placeholder"},"isError":false,"timestamp":1791604003937}}
+{"message_id":"msg-026a","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0225","toolName":"tool_01","content":[{"type":"text","text":"fixture text-026b placeholder"}],"details":{"execution":{"status":"fixture text-026c placeholder","reason":"fixture text-026d placeholder","exitCode":0},"timing":{"commandTimerStartedAt":1791604004056,"commandDeadlineAt":1791604124056,"commandTimeoutSeconds":120},"output":{"rawBytes":5240,"persistence":"fixture text-026e placeholder"},"processOutput":{"stdout":"fixture text-026f placeholder","stderr":"fixture text-026g placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false},"description":"fixture text-026h placeholder"},"isError":false,"timestamp":1791604004708}}
+{"message_id":"msg-026i","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-026j placeholder","thinkingSignature":"fixture text-026k placeholder"},{"type":"text","text":"fixture text-026l placeholder"},{"type":"toolCall","id":"call_0226","name":"tool_01","arguments":{"command":"fixture text-026m placeholder","description":"fixture text-026n placeholder"}},{"type":"toolCall","id":"call_0227","name":"tool_01","arguments":{"command":"fixture text-026o placeholder","description":"fixture text-026p placeholder"}}],"api":"fixture text-026q placeholder","provider":"fixture text-026r placeholder","model":"fixture text-026s placeholder","usage":{"input":2177,"output":442,"cacheRead":13824,"cacheWrite":0,"totalTokens":16443,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604004723,"responseId":"fixture text-026t placeholder"}}
+{"message_id":"msg-026u","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0226","toolName":"tool_01","content":[{"type":"text","text":"fixture text-026v placeholder"}],"details":{"execution":{"status":"fixture text-026w placeholder","reason":"fixture text-026x placeholder","exitCode":0},"timing":{"commandTimerStartedAt":1791604008583,"commandDeadlineAt":1791604128583,"commandTimeoutSeconds":120},"output":{"rawBytes":4811,"persistence":"fixture text-026y placeholder"},"processOutput":{"stdout":"fixture text-026z placeholder","stderr":"fixture text-0270 placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false},"description":"fixture text-0271 placeholder"},"isError":false,"timestamp":1791604009557}}
+{"message_id":"msg-0272","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0227","toolName":"tool_01","content":[{"type":"text","text":"fixture text-0273 placeholder"}],"details":{"execution":{"status":"fixture text-0274 placeholder","reason":"fixture text-0275 placeholder","exitCode":1,"message":"fixture text-0276 placeholder"},"timing":{"commandTimerStartedAt":1791604009679,"commandDeadlineAt":1791604129679,"commandTimeoutSeconds":120},"output":{"rawBytes":73,"persistence":"fixture text-0277 placeholder"},"processOutput":{"stdout":"fixture text-0278 placeholder","stderr":"fixture text-0279 placeholder","exitCode":1,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false},"description":"fixture text-027a placeholder","is_error":true},"isError":true,"timestamp":1791604010537}}
+{"message_id":"msg-027b","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-027c placeholder","thinkingSignature":"fixture text-027d placeholder"},{"type":"text","text":"fixture text-027e placeholder"},{"type":"toolCall","id":"call_0228","name":"tool_01","arguments":{"command":"fixture text-027f placeholder","description":"fixture text-027g placeholder"}},{"type":"toolCall","id":"call_0229","name":"tool_01","arguments":{"command":"fixture text-027h placeholder","description":"fixture text-027i placeholder"}}],"api":"fixture text-027j placeholder","provider":"fixture text-027k placeholder","model":"fixture text-027l placeholder","usage":{"input":2871,"output":397,"cacheRead":15616,"cacheWrite":0,"totalTokens":18884,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604010554,"responseId":"fixture text-027m placeholder"}}
+{"message_id":"msg-027n","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0228","toolName":"tool_01","content":[{"type":"text","text":"fixture text-027o placeholder"}],"details":{"execution":{"status":"fixture text-027p placeholder","reason":"fixture text-027q placeholder","exitCode":0},"timing":{"commandTimerStartedAt":1791604013817,"commandDeadlineAt":1791604133817,"commandTimeoutSeconds":120},"output":{"rawBytes":4454,"persistence":"fixture text-027r placeholder"},"processOutput":{"stdout":"fixture text-027s placeholder","stderr":"fixture text-027t placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false},"description":"fixture text-027u placeholder"},"isError":false,"timestamp":1791604014363}}
+{"message_id":"msg-027v","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0229","toolName":"tool_01","content":[{"type":"text","text":"fixture text-027w placeholder"}],"details":{"execution":{"status":"fixture text-027x placeholder","reason":"fixture text-027y placeholder","exitCode":0},"timing":{"commandTimerStartedAt":1791604014484,"commandDeadlineAt":1791604134484,"commandTimeoutSeconds":120},"output":{"rawBytes":7788,"persistence":"fixture text-027z placeholder"},"processOutput":{"stdout":"fixture text-0280 placeholder","stderr":"fixture text-0281 placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false},"description":"fixture text-0282 placeholder"},"isError":false,"timestamp":1791604015156}}
+{"message_id":"msg-0283","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-0284 placeholder","thinkingSignature":"fixture text-0285 placeholder"},{"type":"text","text":"fixture text-0286 placeholder"},{"type":"toolCall","id":"call_0230","name":"tool_01","arguments":{"command":"fixture text-0287 placeholder","description":"fixture text-0288 placeholder"}},{"type":"toolCall","id":"call_0231","name":"tool_01","arguments":{"command":"fixture text-0289 placeholder","description":"fixture text-028a placeholder"}}],"api":"fixture text-028b placeholder","provider":"fixture text-028c placeholder","model":"fixture text-028d placeholder","usage":{"input":4136,"output":1060,"cacheRead":18176,"cacheWrite":0,"totalTokens":23372,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604015175,"responseId":"fixture text-028e placeholder"}}
+{"message_id":"msg-028f","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0230","toolName":"tool_01","content":[{"type":"text","text":"fixture text-028g placeholder"}],"details":{"execution":{"status":"fixture text-028h placeholder","reason":"fixture text-028i placeholder","exitCode":0},"timing":{"commandTimerStartedAt":1791604022627,"commandDeadlineAt":1791604142627,"commandTimeoutSeconds":120},"output":{"rawBytes":260,"persistence":"fixture text-028j placeholder"},"processOutput":{"stdout":"fixture text-028k placeholder","stderr":"fixture text-028l placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false},"description":"fixture text-028m placeholder"},"isError":false,"timestamp":1791604023027}}
+{"message_id":"msg-028n","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0231","toolName":"tool_01","content":[{"type":"text","text":"fixture text-028o placeholder"}],"details":{"execution":{"status":"fixture text-028p placeholder","reason":"fixture text-028q placeholder","exitCode":1,"message":"fixture text-028r placeholder"},"timing":{"commandTimerStartedAt":1791604023152,"commandDeadlineAt":1791604143152,"commandTimeoutSeconds":120},"output":{"rawBytes":1356,"persistence":"fixture text-028s placeholder"},"processOutput":{"stdout":"fixture text-028t placeholder","stderr":"fixture text-028u placeholder","exitCode":1,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false},"description":"fixture text-028v placeholder","is_error":true},"isError":true,"timestamp":1791604023872}}
+{"message_id":"msg-028w","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-028x placeholder","thinkingSignature":"fixture text-028y placeholder"},{"type":"text","text":"fixture text-028z placeholder"},{"type":"toolCall","id":"call_0232","name":"tool_01","arguments":{"command":"fixture text-0290 placeholder","description":"fixture text-0291 placeholder"}},{"type":"toolCall","id":"call_0233","name":"tool_01","arguments":{"command":"fixture text-0292 placeholder","description":"fixture text-0293 placeholder"}}],"api":"fixture text-0294 placeholder","provider":"fixture text-0295 placeholder","model":"fixture text-0296 placeholder","usage":{"input":1871,"output":821,"cacheRead":22016,"cacheWrite":0,"totalTokens":24708,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604023890,"responseId":"fixture text-0297 placeholder"}}
+{"message_id":"msg-0298","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0232","toolName":"tool_01","content":[{"type":"text","text":"fixture text-0299 placeholder"}],"details":{"execution":{"status":"fixture text-029a placeholder","reason":"fixture text-029b placeholder","exitCode":0},"timing":{"commandTimerStartedAt":1791604029489,"commandDeadlineAt":1791604149489,"commandTimeoutSeconds":120},"output":{"rawBytes":3470,"persistence":"fixture text-029c placeholder"},"processOutput":{"stdout":"fixture text-029d placeholder","stderr":"fixture text-029e placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false},"description":"fixture text-029f placeholder"},"isError":false,"timestamp":1791604029972}}
+{"message_id":"msg-029g","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0233","toolName":"tool_01","content":[{"type":"text","text":"fixture text-029h placeholder"}],"details":{"execution":{"status":"fixture text-029i placeholder","reason":"fixture text-029j placeholder","exitCode":0},"timing":{"commandTimerStartedAt":1791604030096,"commandDeadlineAt":1791604150096,"commandTimeoutSeconds":120},"output":{"rawBytes":434,"persistence":"fixture text-029k placeholder"},"processOutput":{"stdout":"fixture text-029l placeholder","stderr":"fixture text-029m placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false},"description":"fixture text-029n placeholder"},"isError":false,"timestamp":1791604030815}}
+{"message_id":"msg-029o","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-029p placeholder","thinkingSignature":"fixture text-029q placeholder"},{"type":"text","text":"fixture text-029r placeholder"},{"type":"toolCall","id":"call_0234","name":"tool_00","arguments":{"path":"fixture text-029s placeholder"}},{"type":"toolCall","id":"call_0235","name":"tool_01","arguments":{"command":"fixture text-029t placeholder","description":"fixture text-029u placeholder"}}],"api":"fixture text-029v placeholder","provider":"fixture text-029w placeholder","model":"fixture text-029x placeholder","usage":{"input":2614,"output":794,"cacheRead":23552,"cacheWrite":0,"totalTokens":26960,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604030849,"responseId":"fixture text-029y placeholder"}}
+{"message_id":"msg-029z","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0234","toolName":"tool_00","content":[{"type":"text","text":"fixture text-02a0 placeholder"}],"details":{"textFile":{"path":"fixture text-02a1 placeholder","content":"fixture text-02a2 placeholder","numLines":16,"startLine":1,"totalLines":17,"truncatedByOutputLimit":false,"wholeFileAutoTruncated":false}},"isError":false,"timestamp":1791604036081}}
+{"message_id":"msg-02a3","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0235","toolName":"tool_01","content":[{"type":"text","text":"fixture text-02a4 placeholder"}],"details":{"execution":{"status":"fixture text-02a5 placeholder","reason":"fixture text-02a6 placeholder","exitCode":0},"timing":{"commandTimerStartedAt":1791604036346,"commandDeadlineAt":1791604156346,"commandTimeoutSeconds":120},"output":{"rawBytes":1978,"persistence":"fixture text-02a7 placeholder"},"processOutput":{"stdout":"fixture text-02a8 placeholder","stderr":"fixture text-02a9 placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false},"description":"fixture text-02aa placeholder"},"isError":false,"timestamp":1791604037736}}
+{"message_id":"msg-02ab","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-02ac placeholder","thinkingSignature":"fixture text-02ad placeholder"},{"type":"text","text":"fixture text-02ae placeholder"},{"type":"toolCall","id":"call_0236","name":"tool_01","arguments":{"command":"fixture text-02af placeholder","description":"fixture text-02ag placeholder"}},{"type":"toolCall","id":"call_0237","name":"tool_01","arguments":{"command":"fixture text-02ah placeholder","description":"fixture text-02ai placeholder"}}],"api":"fixture text-02aj placeholder","provider":"fixture text-02ak placeholder","model":"fixture text-02al placeholder","usage":{"input":2362,"output":928,"cacheRead":25856,"cacheWrite":0,"totalTokens":29146,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604037755,"responseId":"fixture text-02am placeholder"}}
+{"message_id":"msg-02an","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0236","toolName":"tool_01","content":[{"type":"text","text":"fixture text-02ao placeholder"}],"details":{"execution":{"status":"fixture text-02ap placeholder","reason":"fixture text-02aq placeholder","exitCode":0},"timing":{"commandTimerStartedAt":1791604043229,"commandDeadlineAt":1791604163229,"commandTimeoutSeconds":120},"output":{"rawBytes":1171,"persistence":"fixture text-02ar placeholder"},"processOutput":{"stdout":"fixture text-02as placeholder","stderr":"fixture text-02at placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false},"description":"fixture text-02au placeholder"},"isError":false,"timestamp":1791604043701}}
+{"message_id":"msg-02av","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0237","toolName":"tool_01","content":[{"type":"text","text":"fixture text-02aw placeholder"}],"details":{"execution":{"status":"fixture text-02ax placeholder","reason":"fixture text-02ay placeholder","exitCode":0},"timing":{"commandTimerStartedAt":1791604043830,"commandDeadlineAt":1791604163830,"commandTimeoutSeconds":120},"output":{"rawBytes":1280,"persistence":"fixture text-02az placeholder"},"processOutput":{"stdout":"fixture text-02b0 placeholder","stderr":"fixture text-02b1 placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false},"description":"fixture text-02b2 placeholder"},"isError":false,"timestamp":1791604044530}}
+{"message_id":"msg-02b3","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-02b4 placeholder","thinkingSignature":"fixture text-02b5 placeholder"},{"type":"text","text":"fixture text-02b6 placeholder"},{"type":"toolCall","id":"call_0238","name":"tool_01","arguments":{"command":"fixture text-02b7 placeholder","description":"fixture text-02b8 placeholder"}},{"type":"toolCall","id":"call_0239","name":"tool_01","arguments":{"command":"fixture text-02b9 placeholder","description":"fixture text-02ba placeholder"}}],"api":"fixture text-02bb placeholder","provider":"fixture text-02bc placeholder","model":"fixture text-02bd placeholder","usage":{"input":1999,"output":895,"cacheRead":27904,"cacheWrite":0,"totalTokens":30798,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604044549,"responseId":"fixture text-02be placeholder"}}
+{"message_id":"msg-02bf","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0238","toolName":"tool_01","content":[{"type":"text","text":"fixture text-02bg placeholder"}],"details":{"execution":{"status":"fixture text-02bh placeholder","reason":"fixture text-02bi placeholder","exitCode":0},"timing":{"commandTimerStartedAt":1791604049712,"commandDeadlineAt":1791604169712,"commandTimeoutSeconds":120},"output":{"rawBytes":2330,"persistence":"fixture text-02bj placeholder"},"processOutput":{"stdout":"fixture text-02bk placeholder","stderr":"fixture text-02bl placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false},"description":"fixture text-02bm placeholder"},"isError":false,"timestamp":1791604050185}}
+{"message_id":"msg-02bn","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0239","toolName":"tool_01","content":[{"type":"text","text":"fixture text-02bo placeholder"}],"details":{"execution":{"status":"fixture text-02bp placeholder","reason":"fixture text-02bq placeholder","exitCode":0},"timing":{"commandTimerStartedAt":1791604050312,"commandDeadlineAt":1791604170312,"commandTimeoutSeconds":120},"output":{"rawBytes":1116,"persistence":"fixture text-02br placeholder"},"processOutput":{"stdout":"fixture text-02bs placeholder","stderr":"fixture text-02bt placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false},"description":"fixture text-02bu placeholder"},"isError":false,"timestamp":1791604050963}}
+{"message_id":"msg-02bv","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-02bw placeholder","thinkingSignature":"fixture text-02bx placeholder"},{"type":"text","text":"fixture text-02by placeholder"},{"type":"toolCall","id":"call_0240","name":"tool_01","arguments":{"command":"fixture text-02bz placeholder","description":"fixture text-02c0 placeholder"}},{"type":"toolCall","id":"call_0241","name":"tool_01","arguments":{"command":"fixture text-02c1 placeholder","description":"fixture text-02c2 placeholder"}}],"api":"fixture text-02c3 placeholder","provider":"fixture text-02c4 placeholder","model":"fixture text-02c5 placeholder","usage":{"input":2463,"output":1049,"cacheRead":29440,"cacheWrite":0,"totalTokens":32952,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604050989,"responseId":"fixture text-02c6 placeholder"}}
+{"message_id":"msg-02c7","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0240","toolName":"tool_01","content":[{"type":"text","text":"fixture text-02c8 placeholder"}],"details":{"execution":{"status":"fixture text-02c9 placeholder","reason":"fixture text-02ca placeholder","exitCode":0},"timing":{"commandTimerStartedAt":1791604057459,"commandDeadlineAt":1791604177459,"commandTimeoutSeconds":120},"output":{"rawBytes":1470,"persistence":"fixture text-02cb placeholder"},"processOutput":{"stdout":"fixture text-02cc placeholder","stderr":"fixture text-02cd placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false},"description":"fixture text-02ce placeholder"},"isError":false,"timestamp":1791604058015}}
+{"message_id":"msg-02cf","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0241","toolName":"tool_01","content":[{"type":"text","text":"fixture text-02cg placeholder"}],"details":{"execution":{"status":"fixture text-02ch placeholder","reason":"fixture text-02ci placeholder","exitCode":0},"timing":{"commandTimerStartedAt":1791604058149,"commandDeadlineAt":1791604178149,"commandTimeoutSeconds":120},"output":{"rawBytes":2429,"persistence":"fixture text-02cj placeholder"},"processOutput":{"stdout":"fixture text-02ck placeholder","stderr":"fixture text-02cl placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false},"description":"fixture text-02cm placeholder"},"isError":false,"timestamp":1791604059057}}
+{"message_id":"msg-02cn","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-02co placeholder","thinkingSignature":"fixture text-02cp placeholder"},{"type":"text","text":"fixture text-02cq placeholder"},{"type":"toolCall","id":"call_0242","name":"tool_01","arguments":{"command":"fixture text-02cr placeholder","description":"fixture text-02cs placeholder"}},{"type":"toolCall","id":"call_0243","name":"tool_01","arguments":{"command":"fixture text-02ct placeholder","description":"fixture text-02cu placeholder"}}],"api":"fixture text-02cv placeholder","provider":"fixture text-02cw placeholder","model":"fixture text-02cx placeholder","usage":{"input":3192,"output":945,"cacheRead":31488,"cacheWrite":0,"totalTokens":35625,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604059078,"responseId":"fixture text-02cy placeholder"}}
+{"message_id":"msg-02cz","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0242","toolName":"tool_01","content":[{"type":"text","text":"fixture text-02d0 placeholder"}],"details":{"execution":{"status":"fixture text-02d1 placeholder","reason":"fixture text-02d2 placeholder","exitCode":0},"timing":{"commandTimerStartedAt":1791604065388,"commandDeadlineAt":1791604185388,"commandTimeoutSeconds":120},"output":{"rawBytes":603,"persistence":"fixture text-02d3 placeholder"},"processOutput":{"stdout":"fixture text-02d4 placeholder","stderr":"fixture text-02d5 placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false},"description":"fixture text-02d6 placeholder"},"isError":false,"timestamp":1791604069641}}
+{"message_id":"msg-02d7","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0243","toolName":"tool_01","content":[{"type":"text","text":"fixture text-02d8 placeholder"}],"details":{"execution":{"status":"fixture text-02d9 placeholder","reason":"fixture text-02da placeholder","exitCode":0},"timing":{"commandTimerStartedAt":1791604069765,"commandDeadlineAt":1791604189765,"commandTimeoutSeconds":120},"output":{"rawBytes":2286,"persistence":"fixture text-02db placeholder"},"processOutput":{"stdout":"fixture text-02dc placeholder","stderr":"fixture text-02dd placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false},"description":"fixture text-02de placeholder"},"isError":false,"timestamp":1791604070417}}
+{"message_id":"msg-02df","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-02dg placeholder","thinkingSignature":"fixture text-02dh placeholder"},{"type":"text","text":"fixture text-02di placeholder"},{"type":"toolCall","id":"call_0244","name":"tool_00","arguments":{"path":"fixture text-02dj placeholder"}},{"type":"toolCall","id":"call_0245","name":"tool_00","arguments":{"path":"fixture text-02dk placeholder"}}],"api":"fixture text-02dl placeholder","provider":"fixture text-02dm placeholder","model":"fixture text-02dn placeholder","usage":{"input":2074,"output":158,"cacheRead":34304,"cacheWrite":0,"totalTokens":36536,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604070440,"responseId":"fixture text-02do placeholder"}}
+{"message_id":"msg-02dp","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0244","toolName":"tool_00","content":[{"type":"text","text":"fixture text-02dq placeholder"}],"details":{"textFile":{"path":"fixture text-02dr placeholder","content":"fixture text-02ds placeholder","numLines":96,"startLine":1,"totalLines":97,"truncatedByOutputLimit":false,"wholeFileAutoTruncated":false}},"isError":false,"timestamp":1791604072830}}
+{"message_id":"msg-02dt","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0245","toolName":"tool_00","content":[{"type":"text","text":"fixture text-02du placeholder"}],"details":{"textFile":{"path":"fixture text-02dv placeholder","content":"fixture text-02dw placeholder","numLines":62,"startLine":1,"totalLines":63,"truncatedByOutputLimit":false,"wholeFileAutoTruncated":false}},"isError":false,"timestamp":1791604072844}}
+{"message_id":"msg-02dx","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-02dy placeholder","thinkingSignature":"fixture text-02dz placeholder"},{"type":"text","text":"fixture text-02e0 placeholder"},{"type":"toolCall","id":"call_0246","name":"tool_00","arguments":{"path":"fixture text-02e1 placeholder"}},{"type":"toolCall","id":"call_0247","name":"tool_01","arguments":{"command":"fixture text-02e2 placeholder","description":"fixture text-02e3 placeholder"}}],"api":"fixture text-02e4 placeholder","provider":"fixture text-02e5 placeholder","model":"fixture text-02e6 placeholder","usage":{"input":2789,"output":377,"cacheRead":36096,"cacheWrite":0,"totalTokens":39262,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604072864,"responseId":"fixture text-02e7 placeholder"}}
+{"message_id":"msg-02e8","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0246","toolName":"tool_00","content":[{"type":"text","text":"fixture text-02e9 placeholder"}],"details":{"textFile":{"path":"fixture text-02ea placeholder","content":"fixture text-02eb placeholder","numLines":109,"startLine":1,"totalLines":110,"truncatedByOutputLimit":false,"wholeFileAutoTruncated":false}},"isError":false,"timestamp":1791604076212}}
+{"message_id":"msg-02ec","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0247","toolName":"tool_01","content":[{"type":"text","text":"fixture text-02ed placeholder"}],"details":{"execution":{"status":"fixture text-02ee placeholder","reason":"fixture text-02ef placeholder","exitCode":0},"timing":{"commandTimerStartedAt":1791604076342,"commandDeadlineAt":1791604196342,"commandTimeoutSeconds":120},"output":{"rawBytes":875,"persistence":"fixture text-02eg placeholder"},"processOutput":{"stdout":"fixture text-02eh placeholder","stderr":"fixture text-02ei placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false},"description":"fixture text-02ej placeholder"},"isError":false,"timestamp":1791604077229}}
+{"message_id":"msg-02ek","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-02el placeholder","thinkingSignature":"fixture text-02em placeholder"},{"type":"text","text":"fixture text-02en placeholder"},{"type":"toolCall","id":"call_0248","name":"tool_01","arguments":{"command":"fixture text-02eo placeholder","description":"fixture text-02ep placeholder"}}],"api":"fixture text-02eq placeholder","provider":"fixture text-02er placeholder","model":"fixture text-02es placeholder","usage":{"input":2309,"output":832,"cacheRead":38400,"cacheWrite":0,"totalTokens":41541,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604077250,"responseId":"fixture text-02et placeholder"}}
+{"message_id":"msg-02eu","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0248","toolName":"tool_01","content":[{"type":"text","text":"fixture text-02ev placeholder"}],"details":{"execution":{"status":"fixture text-02ew placeholder","reason":"fixture text-02ex placeholder","exitCode":0},"timing":{"commandTimerStartedAt":1791604083120,"commandDeadlineAt":1791604203120,"commandTimeoutSeconds":120},"output":{"rawBytes":1596,"persistence":"fixture text-02ey placeholder"},"processOutput":{"stdout":"fixture text-02ez placeholder","stderr":"fixture text-02f0 placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false},"description":"fixture text-02f1 placeholder"},"isError":false,"timestamp":1791604083831}}
+{"message_id":"msg-02f2","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-02f3 placeholder","thinkingSignature":"fixture text-02f4 placeholder"},{"type":"text","text":"fixture text-02f5 placeholder"},{"type":"toolCall","id":"call_0249","name":"tool_01","arguments":{"command":"fixture text-02f6 placeholder","description":"fixture text-02f7 placeholder"}}],"api":"fixture text-02f8 placeholder","provider":"fixture text-02f9 placeholder","model":"fixture text-02fa placeholder","usage":{"input":1786,"output":1277,"cacheRead":40448,"cacheWrite":0,"totalTokens":43511,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604083853,"responseId":"fixture text-02fb placeholder"}}
+{"message_id":"msg-02fc","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0249","toolName":"tool_01","content":[{"type":"text","text":"fixture text-02fd placeholder"}],"details":{"execution":{"status":"fixture text-02fe placeholder","reason":"fixture text-02ff placeholder","exitCode":1,"message":"fixture text-02fg placeholder"},"timing":{"commandTimerStartedAt":1791604092588,"commandDeadlineAt":1791604212588,"commandTimeoutSeconds":120},"output":{"rawBytes":209,"persistence":"fixture text-02fh placeholder"},"processOutput":{"stdout":"fixture text-02fi placeholder","stderr":"fixture text-02fj placeholder","exitCode":1,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false},"description":"fixture text-02fk placeholder","is_error":true},"isError":true,"timestamp":1791604093274}}
+{"message_id":"msg-02fl","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-02fm placeholder","thinkingSignature":"fixture text-02fn placeholder"},{"type":"text","text":"fixture text-02fo placeholder"},{"type":"toolCall","id":"call_0250","name":"tool_01","arguments":{"command":"fixture text-02fp placeholder","description":"fixture text-02fq placeholder"}}],"api":"fixture text-02fr placeholder","provider":"fixture text-02fs placeholder","model":"fixture text-02ft placeholder","usage":{"input":1870,"output":395,"cacheRead":41728,"cacheWrite":0,"totalTokens":43993,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604093296,"responseId":"fixture text-02fu placeholder"}}
+{"message_id":"msg-02fv","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0250","toolName":"tool_01","content":[{"type":"text","text":"fixture text-02fw placeholder"}],"details":{"execution":{"status":"fixture text-02fx placeholder","reason":"fixture text-02fy placeholder","exitCode":0},"timing":{"commandTimerStartedAt":1791604096709,"commandDeadlineAt":1791604216709,"commandTimeoutSeconds":120},"output":{"rawBytes":128,"persistence":"fixture text-02fz placeholder"},"processOutput":{"stdout":"fixture text-02g0 placeholder","stderr":"fixture text-02g1 placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false},"description":"fixture text-02g2 placeholder"},"isError":false,"timestamp":1791604097353}}
+{"message_id":"msg-02g3","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-02g4 placeholder","thinkingSignature":"fixture text-02g5 placeholder"},{"type":"text","text":"fixture text-02g6 placeholder"},{"type":"toolCall","id":"call_0251","name":"tool_01","arguments":{"command":"fixture text-02g7 placeholder","description":"fixture text-02g8 placeholder"}}],"api":"fixture text-02g9 placeholder","provider":"fixture text-02ga placeholder","model":"fixture text-02gb placeholder","usage":{"input":784,"output":740,"cacheRead":43264,"cacheWrite":0,"totalTokens":44788,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604097374,"responseId":"fixture text-02gc placeholder"}}
+{"message_id":"msg-02gd","turn_id":"turn-001","message":{"role":"toolResult","toolCallId":"call_0251","toolName":"tool_01","content":[{"type":"text","text":"fixture text-02ge placeholder"}],"details":{"execution":{"status":"fixture text-02gf placeholder","reason":"fixture text-02gg placeholder","exitCode":0},"timing":{"commandTimerStartedAt":1791604103283,"commandDeadlineAt":1791604223283,"commandTimeoutSeconds":120},"output":{"rawBytes":544,"persistence":"fixture text-02gh placeholder"},"processOutput":{"stdout":"fixture text-02gi placeholder","stderr":"fixture text-02gj placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false},"description":"fixture text-02gk placeholder"},"isError":false,"timestamp":1791604103959}}
+{"message_id":"msg-02gl","turn_id":"turn-001","message":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-02gm placeholder","thinkingSignature":"fixture text-02gn placeholder"},{"type":"text","text":"fixture text-02go placeholder"}],"api":"fixture text-02gp placeholder","provider":"fixture text-02gq placeholder","model":"fixture text-02gr placeholder","usage":{"input":1212,"output":3633,"cacheRead":43776,"cacheWrite":0,"totalTokens":48621,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"stop","timestamp":1791604103981,"responseId":"fixture text-02gs placeholder"}}
diff --git a/plugins/avatasia/mmc-trajectory/tests/fixtures/trajectory.json b/plugins/avatasia/mmc-trajectory/tests/fixtures/trajectory.json
new file mode 100644
index 0000000..bb73481
--- /dev/null
+++ b/plugins/avatasia/mmc-trajectory/tests/fixtures/trajectory.json
@@ -0,0 +1 @@
+{"session":{"id":"mvs_00000000000000000000000000000001","label":"fixture text-000w placeholder","messageCount":60,"turnCount":23,"startedAt":1791603931910,"lastActiveAt":1750000480000,"sizeBytes":37267,"truncated":false,"maxMessageBytes":67108864,"generation":null,"generations":[],"orphans":[],"activeGeneration":null,"stitched":false,"binding":"fixture","leased":false},"stats":{"messages":60,"userMessages":2,"assistantMessages":32,"toolCalls":31,"toolResults":22,"thinkingBlocks":18,"injectedBlocks":3,"compactions":1,"turns":23,"turnsWithPrompt":2,"continuationTurns":1,"qaTurns":0,"openTurns":1,"steers":0,"compactionTurns":1,"turnsWithoutPrompt":19,"errors":3,"tokens":{"input":357272,"output":15279,"cacheRead":5571539,"cacheWrite":0,"totalTokens":5944090},"durationMs":23640047,"messagesAll":60},"turns":[{"id":"turn-001","index":1,"startedAt":1791603931910,"endedAt":1791605485479,"durationMs":1553569,"toolCalls":8,"errors":1,"tokens":{"input":53826,"output":2224,"cacheRead":1175168,"cacheWrite":0,"totalTokens":1231218},"turnClass":"prompt","askedReader":false,"closed":true,"records":[{"id":"msg-0000","turnId":"turn-001","role":"user","generation":null,"timestamp":1791603931910,"responseId":null,"relativeMs":0,"durationMs":null,"toolName":null,"toolCallId":null,"tokens":null,"model":null,"provider":null,"api":null,"stopReason":null,"isError":null,"raw":{"role":"user","content":[{"type":"text","text":"<system-reminder>\nfixture injected-0001 block"}],"timestamp":1791603931910,"canonicalTextRange":{"startOffset":5109,"endOffset":5722}},"rawOmitted":false,"textTruncated":false,"index":1,"text":"<system-reminder>\nfixture injected-0001 block","thinking":null,"arguments":null,"result":null,"error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"system","title":"injected","summary":"<system-reminder> fixture injected-0001 block"},{"id":"msg-0002","turnId":"turn-001","role":"assistant","generation":null,"timestamp":1791603931971,"responseId":"fixture text-0009 placeholder","relativeMs":61,"durationMs":null,"toolName":null,"toolCallId":null,"model":"fixture text-0008 placeholder","provider":"fixture text-0007 placeholder","api":"fixture text-0006 placeholder","stopReason":"toolUse","isError":null,"raw":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-0003 placeholder","thinkingSignature":"fixture text-0004 placeholder"},{"type":"text","text":"fixture text-0005 placeholder"},{"type":"toolCall","id":"call_0000","name":"tool_00","arguments":{"name":"tool_01"}}],"api":"fixture text-0006 placeholder","provider":"fixture text-0007 placeholder","model":"fixture text-0008 placeholder","usage":{"input":44829,"output":432,"cacheRead":4224,"cacheWrite":0,"totalTokens":49485,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791603931971,"responseId":"fixture text-0009 placeholder"},"rawOmitted":false,"textTruncated":false,"index":2,"text":null,"thinking":"fixture text-0003 placeholder","arguments":null,"result":null,"error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"thinking","title":"thinking","summary":"fixture text-0003 placeholder"},{"id":"msg-0002","turnId":"turn-001","role":"assistant","generation":null,"timestamp":1791603931971,"responseId":"fixture text-0009 placeholder","relativeMs":61,"durationMs":null,"toolName":null,"toolCallId":null,"tokens":{"input":44829,"output":432,"cacheRead":4224,"cacheWrite":0,"totalTokens":49485},"model":"fixture text-0008 placeholder","provider":"fixture text-0007 placeholder","api":"fixture text-0006 placeholder","stopReason":"toolUse","isError":null,"raw":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-0003 placeholder","thinkingSignature":"fixture text-0004 placeholder"},{"type":"text","text":"fixture text-0005 placeholder"},{"type":"toolCall","id":"call_0000","name":"tool_00","arguments":{"name":"tool_01"}}],"api":"fixture text-0006 placeholder","provider":"fixture text-0007 placeholder","model":"fixture text-0008 placeholder","usage":{"input":44829,"output":432,"cacheRead":4224,"cacheWrite":0,"totalTokens":49485,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791603931971,"responseId":"fixture text-0009 placeholder"},"rawOmitted":false,"textTruncated":false,"index":3,"text":"fixture text-0005 placeholder","thinking":null,"arguments":null,"result":null,"error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"narration","title":"assistant","summary":"fixture text-0005 placeholder"},{"id":"msg-0002","turnId":"turn-001","role":"assistant","generation":null,"timestamp":1791603931971,"responseId":"fixture text-0009 placeholder","relativeMs":61,"durationMs":11257,"toolName":"tool_00","toolCallId":"call_0000","model":"fixture text-0008 placeholder","provider":"fixture text-0007 placeholder","api":"fixture text-0006 placeholder","stopReason":"toolUse","isError":null,"raw":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-0003 placeholder","thinkingSignature":"fixture text-0004 placeholder"},{"type":"text","text":"fixture text-0005 placeholder"},{"type":"toolCall","id":"call_0000","name":"tool_00","arguments":{"name":"tool_01"}}],"api":"fixture text-0006 placeholder","provider":"fixture text-0007 placeholder","model":"fixture text-0008 placeholder","usage":{"input":44829,"output":432,"cacheRead":4224,"cacheWrite":0,"totalTokens":49485,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791603931971,"responseId":"fixture text-0009 placeholder"},"rawOmitted":false,"textTruncated":false,"index":4,"text":null,"thinking":null,"arguments":{"name":"tool_01"},"result":null,"error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"toolCall","title":"tool_00","summary":"tool_00{name=\"tool_01\"} → fixture text-000b placeholder","argumentsOmitted":false},{"id":"msg-000a","turnId":"turn-001","role":"toolResult","generation":null,"timestamp":1791603943228,"responseId":null,"relativeMs":11318,"durationMs":11257,"toolName":"tool_00","toolCallId":"call_0000","tokens":null,"model":null,"provider":null,"api":null,"stopReason":null,"isError":false,"raw":{"role":"toolResult","toolCallId":"call_0000","toolName":"tool_00","content":[{"type":"text","text":"fixture text-000b placeholder"}],"details":{"kind":"skill","skill":"fixture text-000c placeholder","found":true,"readable":true,"owner":"fixture text-000d placeholder","source":"fixture text-000e placeholder","location":"fixture text-000f placeholder"},"isError":false,"timestamp":1791603943228},"rawOmitted":false,"textTruncated":false,"index":5,"text":null,"thinking":null,"arguments":null,"result":"fixture text-000b placeholder","error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"toolResult","title":"tool_00","summary":"fixture text-000b placeholder"},{"id":"msg-000g","turnId":"turn-001","role":"assistant","generation":null,"timestamp":1791604127714,"responseId":"fixture text-000o placeholder","relativeMs":195804,"durationMs":null,"toolName":null,"toolCallId":null,"model":"fixture text-000n placeholder","provider":"fixture text-000m placeholder","api":"fixture text-000l placeholder","stopReason":"toolUse","isError":null,"raw":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-000h placeholder","thinkingSignature":"fixture text-000i placeholder"},{"type":"text","text":"fixture text-000j placeholder"},{"type":"toolCall","id":"call_0001","name":"tool_02","arguments":{"task_id":"fixture text-000k placeholder"}}],"api":"fixture text-000l placeholder","provider":"fixture text-000m placeholder","model":"fixture text-000n placeholder","usage":{"input":4210,"output":82,"cacheRead":76544,"cacheWrite":0,"totalTokens":80836,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604127714,"responseId":"fixture text-000o placeholder"},"rawOmitted":false,"textTruncated":false,"index":6,"text":null,"thinking":"fixture text-000h placeholder","arguments":null,"result":null,"error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"thinking","title":"thinking","summary":"fixture text-000h placeholder"},{"id":"msg-000g","turnId":"turn-001","role":"assistant","generation":null,"timestamp":1791604127714,"responseId":"fixture text-000o placeholder","relativeMs":195804,"durationMs":null,"toolName":null,"toolCallId":null,"tokens":{"input":4210,"output":82,"cacheRead":76544,"cacheWrite":0,"totalTokens":80836},"model":"fixture text-000n placeholder","provider":"fixture text-000m placeholder","api":"fixture text-000l placeholder","stopReason":"toolUse","isError":null,"raw":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-000h placeholder","thinkingSignature":"fixture text-000i placeholder"},{"type":"text","text":"fixture text-000j placeholder"},{"type":"toolCall","id":"call_0001","name":"tool_02","arguments":{"task_id":"fixture text-000k placeholder"}}],"api":"fixture text-000l placeholder","provider":"fixture text-000m placeholder","model":"fixture text-000n placeholder","usage":{"input":4210,"output":82,"cacheRead":76544,"cacheWrite":0,"totalTokens":80836,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604127714,"responseId":"fixture text-000o placeholder"},"rawOmitted":false,"textTruncated":false,"index":7,"text":"fixture text-000j placeholder","thinking":null,"arguments":null,"result":null,"error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"narration","title":"assistant","summary":"fixture text-000j placeholder"},{"id":"msg-000g","turnId":"turn-001","role":"assistant","generation":null,"timestamp":1791604127714,"responseId":"fixture text-000o placeholder","relativeMs":195804,"durationMs":null,"toolName":"tool_02","toolCallId":"call_0001","model":"fixture text-000n placeholder","provider":"fixture text-000m placeholder","api":"fixture text-000l placeholder","stopReason":"toolUse","isError":null,"raw":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-000h placeholder","thinkingSignature":"fixture text-000i placeholder"},{"type":"text","text":"fixture text-000j placeholder"},{"type":"toolCall","id":"call_0001","name":"tool_02","arguments":{"task_id":"fixture text-000k placeholder"}}],"api":"fixture text-000l placeholder","provider":"fixture text-000m placeholder","model":"fixture text-000n placeholder","usage":{"input":4210,"output":82,"cacheRead":76544,"cacheWrite":0,"totalTokens":80836,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604127714,"responseId":"fixture text-000o placeholder"},"rawOmitted":false,"textTruncated":false,"index":8,"text":null,"thinking":null,"arguments":{"task_id":"fixture text-000k placeholder"},"result":null,"error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"toolCall","title":"tool_02","summary":"tool_02{task_id=\"fixture text-000k placeholder\"}","argumentsOmitted":false},{"id":"msg-000p","turnId":"turn-001","role":"assistant","generation":null,"timestamp":1791604504788,"responseId":"fixture text-000u placeholder","relativeMs":572878,"durationMs":null,"toolName":"tool_02","toolCallId":"call_0002","tokens":{"input":268,"output":62,"cacheRead":102144,"cacheWrite":0,"totalTokens":102474},"model":"fixture text-000t placeholder","provider":"fixture text-000s placeholder","api":"fixture text-000r placeholder","stopReason":"toolUse","isError":null,"raw":{"role":"assistant","content":[{"type":"toolCall","id":"call_0002","name":"tool_02","arguments":{"task_id":"fixture text-000q placeholder","wait_ms":30000}}],"api":"fixture text-000r placeholder","provider":"fixture text-000s placeholder","model":"fixture text-000t placeholder","usage":{"input":268,"output":62,"cacheRead":102144,"cacheWrite":0,"totalTokens":102474,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604504788,"responseId":"fixture text-000u placeholder"},"rawOmitted":false,"textTruncated":false,"index":9,"text":null,"thinking":null,"arguments":{"task_id":"fixture text-000q placeholder","wait_ms":30000},"result":null,"error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"toolCall","title":"tool_02","summary":"tool_02{task_id=\"fixture text-000q placeholder\", wait_ms=\"30000\"}","argumentsOmitted":false},{"id":"msg-000v","turnId":"turn-001","role":"user","generation":null,"timestamp":1791604626776,"responseId":null,"relativeMs":694866,"durationMs":null,"toolName":null,"toolCallId":null,"tokens":null,"model":null,"provider":null,"api":null,"stopReason":null,"isError":null,"raw":{"role":"user","content":"fixture text-000w placeholder","timestamp":1791604626776},"rawOmitted":false,"textTruncated":false,"index":10,"text":"fixture text-000w placeholder","thinking":null,"arguments":null,"result":null,"error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"user","title":"user","summary":"fixture text-000w placeholder","steered":false},{"id":"msg-000x","turnId":"turn-001","role":"assistant","generation":null,"timestamp":1791604764455,"responseId":"fixture text-0013 placeholder","relativeMs":832545,"durationMs":null,"toolName":"tool_03","toolCallId":"call_0003","tokens":{"input":2672,"output":61,"cacheRead":113536,"cacheWrite":0,"totalTokens":116269},"model":"fixture text-0012 placeholder","provider":"fixture text-0011 placeholder","api":"fixture text-0010 placeholder","stopReason":"toolUse","isError":null,"raw":{"role":"assistant","content":[{"type":"toolCall","id":"call_0003","name":"tool_03","arguments":{"command":"fixture text-000y placeholder","description":"fixture text-000z placeholder"}}],"api":"fixture text-0010 placeholder","provider":"fixture text-0011 placeholder","model":"fixture text-0012 placeholder","usage":{"input":2672,"output":61,"cacheRead":113536,"cacheWrite":0,"totalTokens":116269,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604764455,"responseId":"fixture text-0013 placeholder"},"rawOmitted":false,"textTruncated":false,"index":11,"text":null,"thinking":null,"arguments":{"command":"fixture text-000y placeholder","description":"fixture text-000z placeholder"},"result":null,"error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"toolCall","title":"tool_03","summary":"tool_03{command=\"fixture text-000y placeholder\", description=\"fixture text-000z placeholder\"}","argumentsOmitted":false},{"id":"msg-0014","turnId":"turn-001","role":"toolResult","generation":null,"timestamp":1791604879414,"responseId":null,"relativeMs":947504,"durationMs":null,"toolName":"tool_03","toolCallId":"call_0004","tokens":null,"model":null,"provider":null,"api":null,"stopReason":null,"isError":true,"raw":{"role":"toolResult","toolCallId":"call_0004","toolName":"tool_03","content":[{"type":"text","text":"fixture text-0015 placeholder"}],"details":{"execution":{"status":"fixture text-0016 placeholder","reason":"fixture text-0017 placeholder","exitCode":1,"message":"fixture text-0018 placeholder"},"timing":{"commandTimeoutSeconds":3600,"commandTimerStartedAt":1791604878663,"commandDeadlineAt":1791608478663},"output":{"rawBytes":644,"persistence":"fixture text-0019 placeholder","omittedBytes":0},"processOutput":{"stdout":"fixture text-001a placeholder","stderr":"fixture text-001b placeholder","exitCode":1,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false,"rawOutputPath":"fixture text-001c placeholder"},"description":"fixture text-001d placeholder","fullOutputPath":"fixture text-001e placeholder","status":"fixture text-001f placeholder","task_id":"fixture text-001g placeholder","is_error":true},"isError":true,"timestamp":1791604879414},"rawOmitted":false,"textTruncated":false,"index":12,"text":null,"thinking":null,"arguments":null,"result":"fixture text-0015 placeholder","error":"fixture text-0015 placeholder","tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"toolResult","title":"tool_03","summary":"fixture text-0015 placeholder"},{"id":"msg-001h","turnId":"turn-001","role":"assistant","generation":null,"timestamp":1791604894030,"responseId":"fixture text-001n placeholder","relativeMs":962120,"durationMs":null,"toolName":"tool_03","toolCallId":"call_0005","tokens":{"input":142,"output":107,"cacheRead":135424,"cacheWrite":0,"totalTokens":135673},"model":"fixture text-001m placeholder","provider":"fixture text-001l placeholder","api":"fixture text-001k placeholder","stopReason":"toolUse","isError":null,"raw":{"role":"assistant","content":[{"type":"toolCall","id":"call_0005","name":"tool_03","arguments":{"command":"fixture text-001i placeholder","description":"fixture text-001j placeholder"}}],"api":"fixture text-001k placeholder","provider":"fixture text-001l placeholder","model":"fixture text-001m placeholder","usage":{"input":142,"output":107,"cacheRead":135424,"cacheWrite":0,"totalTokens":135673,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791604894030,"responseId":"fixture text-001n placeholder"},"rawOmitted":false,"textTruncated":false,"index":13,"text":null,"thinking":null,"arguments":{"command":"fixture text-001i placeholder","description":"fixture text-001j placeholder"},"result":null,"error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"toolCall","title":"tool_03","summary":"tool_03{command=\"fixture text-001i placeholder\", description=\"fixture text-001j placeholder\"}","argumentsOmitted":false},{"id":"msg-001o","turnId":"turn-001","role":"assistant","generation":null,"timestamp":1791605044287,"responseId":"fixture text-001u placeholder","relativeMs":1112377,"durationMs":null,"toolName":"tool_03","toolCallId":"call_0006","tokens":{"input":714,"output":176,"cacheRead":167040,"cacheWrite":0,"totalTokens":167930},"model":"fixture text-001t placeholder","provider":"fixture text-001s placeholder","api":"fixture text-001r placeholder","stopReason":"toolUse","isError":null,"raw":{"role":"assistant","content":[{"type":"toolCall","id":"call_0006","name":"tool_03","arguments":{"command":"fixture text-001p placeholder","description":"fixture text-001q placeholder"}}],"api":"fixture text-001r placeholder","provider":"fixture text-001s placeholder","model":"fixture text-001t placeholder","usage":{"input":714,"output":176,"cacheRead":167040,"cacheWrite":0,"totalTokens":167930,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791605044287,"responseId":"fixture text-001u placeholder"},"rawOmitted":false,"textTruncated":false,"index":14,"text":null,"thinking":null,"arguments":{"command":"fixture text-001p placeholder","description":"fixture text-001q placeholder"},"result":null,"error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"toolCall","title":"tool_03","summary":"tool_03{command=\"fixture text-001p placeholder\", description=\"fixture text-001q placeholder\"}","argumentsOmitted":false},{"id":"msg-001v","turnId":"turn-001","role":"assistant","generation":null,"timestamp":1791605219170,"responseId":"fixture text-0023 placeholder","relativeMs":1287260,"durationMs":null,"toolName":null,"toolCallId":null,"tokens":{"input":832,"output":316,"cacheRead":178688,"cacheWrite":0,"totalTokens":179836},"model":"fixture text-0022 placeholder","provider":"fixture text-0021 placeholder","api":"fixture text-0020 placeholder","stopReason":"toolUse","isError":null,"raw":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-001w placeholder","thinkingSignature":"fixture text-001x placeholder"},{"type":"toolCall","id":"call_0007","name":"tool_04","arguments":{"action":"fixture text-001y placeholder","input":{"kind":"text","maxChars":600,"selector":"fixture text-001z placeholder"}}}],"api":"fixture text-0020 placeholder","provider":"fixture text-0021 placeholder","model":"fixture text-0022 placeholder","usage":{"input":832,"output":316,"cacheRead":178688,"cacheWrite":0,"totalTokens":179836,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791605219170,"responseId":"fixture text-0023 placeholder"},"rawOmitted":false,"textTruncated":false,"index":15,"text":null,"thinking":"fixture text-001w placeholder","arguments":null,"result":null,"error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"thinking","title":"thinking","summary":"fixture text-001w placeholder"},{"id":"msg-001v","turnId":"turn-001","role":"assistant","generation":null,"timestamp":1791605219170,"responseId":"fixture text-0023 placeholder","relativeMs":1287260,"durationMs":null,"toolName":"tool_04","toolCallId":"call_0007","model":"fixture text-0022 placeholder","provider":"fixture text-0021 placeholder","api":"fixture text-0020 placeholder","stopReason":"toolUse","isError":null,"raw":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-001w placeholder","thinkingSignature":"fixture text-001x placeholder"},{"type":"toolCall","id":"call_0007","name":"tool_04","arguments":{"action":"fixture text-001y placeholder","input":{"kind":"text","maxChars":600,"selector":"fixture text-001z placeholder"}}}],"api":"fixture text-0020 placeholder","provider":"fixture text-0021 placeholder","model":"fixture text-0022 placeholder","usage":{"input":832,"output":316,"cacheRead":178688,"cacheWrite":0,"totalTokens":179836,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791605219170,"responseId":"fixture text-0023 placeholder"},"rawOmitted":false,"textTruncated":false,"index":16,"text":null,"thinking":null,"arguments":{"action":"fixture text-001y placeholder","input":{"kind":"text","maxChars":600,"selector":"fixture text-001z placeholder"}},"result":null,"error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"toolCall","title":"tool_04","summary":"tool_04{action=\"fixture text-001y placeholder\", input=\"{…}\"}","argumentsOmitted":false},{"id":"msg-0024","turnId":"turn-001","role":"assistant","generation":null,"timestamp":1791605423541,"responseId":"fixture text-002c placeholder","relativeMs":1491631,"durationMs":null,"toolName":null,"toolCallId":null,"tokens":{"input":100,"output":91,"cacheRead":194176,"cacheWrite":0,"totalTokens":194367},"model":"fixture text-002b placeholder","provider":"fixture text-002a placeholder","api":"fixture text-0029 placeholder","stopReason":"toolUse","isError":null,"raw":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-0025 placeholder","thinkingSignature":"fixture text-0026 placeholder"},{"type":"toolCall","id":"call_0008","name":"tool_04","arguments":{"action":"fixture text-0027 placeholder","input":{"selector":"fixture text-0028 placeholder"}}}],"api":"fixture text-0029 placeholder","provider":"fixture text-002a placeholder","model":"fixture text-002b placeholder","usage":{"input":100,"output":91,"cacheRead":194176,"cacheWrite":0,"totalTokens":194367,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791605423541,"responseId":"fixture text-002c placeholder"},"rawOmitted":false,"textTruncated":false,"index":17,"text":null,"thinking":"fixture text-0025 placeholder","arguments":null,"result":null,"error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"thinking","title":"thinking","summary":"fixture text-0025 placeholder"},{"id":"msg-0024","turnId":"turn-001","role":"assistant","generation":null,"timestamp":1791605423541,"responseId":"fixture text-002c placeholder","relativeMs":1491631,"durationMs":null,"toolName":"tool_04","toolCallId":"call_0008","model":"fixture text-002b placeholder","provider":"fixture text-002a placeholder","api":"fixture text-0029 placeholder","stopReason":"toolUse","isError":null,"raw":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-0025 placeholder","thinkingSignature":"fixture text-0026 placeholder"},{"type":"toolCall","id":"call_0008","name":"tool_04","arguments":{"action":"fixture text-0027 placeholder","input":{"selector":"fixture text-0028 placeholder"}}}],"api":"fixture text-0029 placeholder","provider":"fixture text-002a placeholder","model":"fixture text-002b placeholder","usage":{"input":100,"output":91,"cacheRead":194176,"cacheWrite":0,"totalTokens":194367,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791605423541,"responseId":"fixture text-002c placeholder"},"rawOmitted":false,"textTruncated":false,"index":18,"text":null,"thinking":null,"arguments":{"action":"fixture text-0027 placeholder","input":{"selector":"fixture text-0028 placeholder"}},"result":null,"error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"toolCall","title":"tool_04","summary":"tool_04{action=\"fixture text-0027 placeholder\", input=\"{…}\"}","argumentsOmitted":false},{"id":"msg-002d","turnId":"turn-001","role":"assistant","generation":null,"timestamp":1791605485479,"responseId":"fixture text-002i placeholder","relativeMs":1553569,"durationMs":null,"toolName":null,"toolCallId":null,"tokens":{"input":59,"output":897,"cacheRead":203392,"cacheWrite":0,"totalTokens":204348},"model":"fixture text-002h placeholder","provider":"fixture text-002g placeholder","api":"fixture text-002f placeholder","stopReason":"stop","isError":null,"raw":{"role":"assistant","content":[{"type":"text","text":"fixture text-002e placeholder"}],"api":"fixture text-002f placeholder","provider":"fixture text-002g placeholder","model":"fixture text-002h placeholder","usage":{"input":59,"output":897,"cacheRead":203392,"cacheWrite":0,"totalTokens":204348,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"stop","timestamp":1791605485479,"responseId":"fixture text-002i placeholder"},"rawOmitted":false,"textTruncated":false,"index":19,"text":"fixture text-002e placeholder","thinking":null,"arguments":null,"result":null,"error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"reply","title":"assistant","summary":"fixture text-002e placeholder"}]},{"id":"turn-002","index":2,"startedAt":1791605691616,"endedAt":1791605691616,"durationMs":0,"toolCalls":1,"errors":0,"tokens":{"input":1658,"output":69,"cacheRead":210432,"cacheWrite":0,"totalTokens":212159},"turnClass":"none","askedReader":false,"closed":false,"records":[{"id":"msg-002j","turnId":"turn-002","role":"assistant","generation":null,"timestamp":1791605691616,"responseId":"fixture text-002o placeholder","relativeMs":1759706,"durationMs":null,"toolName":"tool_05","toolCallId":"call_0009","tokens":{"input":1658,"output":69,"cacheRead":210432,"cacheWrite":0,"totalTokens":212159},"model":"fixture text-002n placeholder","provider":"fixture text-002m placeholder","api":"fixture text-002l placeholder","stopReason":"toolUse","isError":null,"raw":{"role":"assistant","content":[{"type":"toolCall","id":"call_0009","name":"tool_05","arguments":{"limit":30,"offset":1618,"path":"fixture text-002k placeholder"}}],"api":"fixture text-002l placeholder","provider":"fixture text-002m placeholder","model":"fixture text-002n placeholder","usage":{"input":1658,"output":69,"cacheRead":210432,"cacheWrite":0,"totalTokens":212159,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791605691616,"responseId":"fixture text-002o placeholder"},"rawOmitted":false,"textTruncated":false,"index":20,"text":null,"thinking":null,"arguments":{"limit":30,"offset":1618,"path":"fixture text-002k placeholder"},"result":null,"error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"toolCall","title":"tool_05","summary":"tool_05{limit=\"30\", offset=\"1618\", path=\"fixture text-002k placeholder\"}","argumentsOmitted":false}]},{"id":"turn-003","index":3,"startedAt":1791606195742,"endedAt":1791606432109,"durationMs":236367,"toolCalls":1,"errors":0,"tokens":{"input":2260,"output":2251,"cacheRead":220800,"cacheWrite":0,"totalTokens":225311},"turnClass":"none","askedReader":false,"closed":false,"records":[{"id":"msg-002p","turnId":"turn-003","role":"assistant","generation":null,"timestamp":1791606195742,"responseId":"fixture text-003b placeholder","relativeMs":2263832,"durationMs":null,"toolName":null,"toolCallId":null,"model":"fixture text-003a placeholder","provider":"fixture text-0039 placeholder","api":"fixture text-0038 placeholder","stopReason":"toolUse","isError":null,"raw":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-002q placeholder","thinkingSignature":"fixture text-002r placeholder"},{"type":"text","text":"fixture text-002s placeholder"},{"type":"toolCall","id":"call_0010","name":"tool_06","arguments":{"todos":[{"content":"fixture text-002t placeholder","priority":"fixture text-002u placeholder","status":"fixture text-002v placeholder"},{"content":"fixture text-002w placeholder","priority":"fixture text-002x placeholder","status":"fixture text-002y placeholder"},{"content":"fixture text-002z placeholder","priority":"fixture text-0030 placeholder","status":"fixture text-0031 placeholder"},{"content":"fixture text-0032 placeholder","priority":"fixture text-0033 placeholder","status":"fixture text-0034 placeholder"},{"content":"fixture text-0035 placeholder","priority":"fixture text-0036 placeholder","status":"fixture text-0037 placeholder"}]}}],"api":"fixture text-0038 placeholder","provider":"fixture text-0039 placeholder","model":"fixture text-003a placeholder","usage":{"input":2260,"output":2251,"cacheRead":220800,"cacheWrite":0,"totalTokens":225311,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791606195742,"responseId":"fixture text-003b placeholder"},"rawOmitted":false,"textTruncated":false,"index":21,"text":null,"thinking":"fixture text-002q placeholder","arguments":null,"result":null,"error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"thinking","title":"thinking","summary":"fixture text-002q placeholder"},{"id":"msg-002p","turnId":"turn-003","role":"assistant","generation":null,"timestamp":1791606195742,"responseId":"fixture text-003b placeholder","relativeMs":2263832,"durationMs":null,"toolName":null,"toolCallId":null,"tokens":{"input":2260,"output":2251,"cacheRead":220800,"cacheWrite":0,"totalTokens":225311},"model":"fixture text-003a placeholder","provider":"fixture text-0039 placeholder","api":"fixture text-0038 placeholder","stopReason":"toolUse","isError":null,"raw":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-002q placeholder","thinkingSignature":"fixture text-002r placeholder"},{"type":"text","text":"fixture text-002s placeholder"},{"type":"toolCall","id":"call_0010","name":"tool_06","arguments":{"todos":[{"content":"fixture text-002t placeholder","priority":"fixture text-002u placeholder","status":"fixture text-002v placeholder"},{"content":"fixture text-002w placeholder","priority":"fixture text-002x placeholder","status":"fixture text-002y placeholder"},{"content":"fixture text-002z placeholder","priority":"fixture text-0030 placeholder","status":"fixture text-0031 placeholder"},{"content":"fixture text-0032 placeholder","priority":"fixture text-0033 placeholder","status":"fixture text-0034 placeholder"},{"content":"fixture text-0035 placeholder","priority":"fixture text-0036 placeholder","status":"fixture text-0037 placeholder"}]}}],"api":"fixture text-0038 placeholder","provider":"fixture text-0039 placeholder","model":"fixture text-003a placeholder","usage":{"input":2260,"output":2251,"cacheRead":220800,"cacheWrite":0,"totalTokens":225311,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791606195742,"responseId":"fixture text-003b placeholder"},"rawOmitted":false,"textTruncated":false,"index":22,"text":"fixture text-002s placeholder","thinking":null,"arguments":null,"result":null,"error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"narration","title":"assistant","summary":"fixture text-002s placeholder"},{"id":"msg-002p","turnId":"turn-003","role":"assistant","generation":null,"timestamp":1791606195742,"responseId":"fixture text-003b placeholder","relativeMs":2263832,"durationMs":null,"toolName":"tool_06","toolCallId":"call_0010","model":"fixture text-003a placeholder","provider":"fixture text-0039 placeholder","api":"fixture text-0038 placeholder","stopReason":"toolUse","isError":null,"raw":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-002q placeholder","thinkingSignature":"fixture text-002r placeholder"},{"type":"text","text":"fixture text-002s placeholder"},{"type":"toolCall","id":"call_0010","name":"tool_06","arguments":{"todos":[{"content":"fixture text-002t placeholder","priority":"fixture text-002u placeholder","status":"fixture text-002v placeholder"},{"content":"fixture text-002w placeholder","priority":"fixture text-002x placeholder","status":"fixture text-002y placeholder"},{"content":"fixture text-002z placeholder","priority":"fixture text-0030 placeholder","status":"fixture text-0031 placeholder"},{"content":"fixture text-0032 placeholder","priority":"fixture text-0033 placeholder","status":"fixture text-0034 placeholder"},{"content":"fixture text-0035 placeholder","priority":"fixture text-0036 placeholder","status":"fixture text-0037 placeholder"}]}}],"api":"fixture text-0038 placeholder","provider":"fixture text-0039 placeholder","model":"fixture text-003a placeholder","usage":{"input":2260,"output":2251,"cacheRead":220800,"cacheWrite":0,"totalTokens":225311,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791606195742,"responseId":"fixture text-003b placeholder"},"rawOmitted":false,"textTruncated":false,"index":23,"text":null,"thinking":null,"arguments":{"todos":[{"content":"fixture text-002t placeholder","priority":"fixture text-002u placeholder","status":"fixture text-002v placeholder"},{"content":"fixture text-002w placeholder","priority":"fixture text-002x placeholder","status":"fixture text-002y placeholder"},{"content":"fixture text-002z placeholder","priority":"fixture text-0030 placeholder","status":"fixture text-0031 placeholder"},{"content":"fixture text-0032 placeholder","priority":"fixture text-0033 placeholder","status":"fixture text-0034 placeholder"},{"content":"fixture text-0035 placeholder","priority":"fixture text-0036 placeholder","status":"fixture text-0037 placeholder"}]},"result":null,"error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"toolCall","title":"tool_06","summary":"tool_06{todos=\"[{…}, {…}, {…}, …]\"}","argumentsOmitted":false},{"id":"msg-003c","turnId":"turn-003","role":"toolResult","generation":null,"timestamp":1791606432109,"responseId":null,"relativeMs":2500199,"durationMs":null,"toolName":"tool_07","toolCallId":"call_0011","tokens":null,"model":null,"provider":null,"api":null,"stopReason":null,"isError":false,"raw":{"role":"toolResult","toolCallId":"call_0011","toolName":"tool_07","content":[{"type":"text","text":"fixture text-003d placeholder"}],"details":{"created":true,"bytes_written":1777,"encoding":"fixture text-003e placeholder","bom":false},"isError":false,"timestamp":1791606432109},"rawOmitted":false,"textTruncated":false,"index":24,"text":null,"thinking":null,"arguments":null,"result":"fixture text-003d placeholder","error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"toolResult","title":"tool_07","summary":"fixture text-003d placeholder"}]},{"id":"turn-004","index":4,"startedAt":1791610762301,"endedAt":1791611180154,"durationMs":417853,"toolCalls":2,"errors":0,"tokens":{"input":258453,"output":1164,"cacheRead":277120,"cacheWrite":0,"totalTokens":536737},"turnClass":"none","askedReader":false,"closed":false,"records":[{"id":"msg-003f","turnId":"turn-004","role":"assistant","generation":null,"timestamp":1791610762301,"responseId":"fixture text-003l placeholder","relativeMs":6830391,"durationMs":null,"toolName":"tool_03","toolCallId":"call_0012","tokens":{"input":254227,"output":405,"cacheRead":4224,"cacheWrite":0,"totalTokens":258856},"model":"fixture text-003k placeholder","provider":"fixture text-003j placeholder","api":"fixture text-003i placeholder","stopReason":"toolUse","isError":null,"raw":{"role":"assistant","content":[{"type":"toolCall","id":"call_0012","name":"tool_03","arguments":{"command":"fixture text-003g placeholder","description":"fixture text-003h placeholder"}}],"api":"fixture text-003i placeholder","provider":"fixture text-003j placeholder","model":"fixture text-003k placeholder","usage":{"input":254227,"output":405,"cacheRead":4224,"cacheWrite":0,"totalTokens":258856,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791610762301,"responseId":"fixture text-003l placeholder"},"rawOmitted":false,"textTruncated":false,"index":25,"text":null,"thinking":null,"arguments":{"command":"fixture text-003g placeholder","description":"fixture text-003h placeholder"},"result":null,"error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"toolCall","title":"tool_03","summary":"tool_03{command=\"fixture text-003g placeholder\", description=\"fixture text-003h placeholder\"}","argumentsOmitted":false},{"id":"msg-003m","turnId":"turn-004","role":"toolResult","generation":null,"timestamp":1791610983663,"responseId":null,"relativeMs":7051753,"durationMs":null,"toolName":"tool_03","toolCallId":"call_0013","tokens":null,"model":null,"provider":null,"api":null,"stopReason":null,"isError":false,"raw":{"role":"toolResult","toolCallId":"call_0013","toolName":"tool_03","content":[{"type":"text","text":"fixture text-003n placeholder"}],"details":{"execution":{"status":"fixture text-003o placeholder","reason":"fixture text-003p placeholder","exitCode":0},"timing":{"commandTimeoutSeconds":3600,"commandTimerStartedAt":1791610981057,"commandDeadlineAt":1791614581057},"output":{"rawBytes":218,"persistence":"fixture text-003q placeholder","omittedBytes":0},"processOutput":{"stdout":"fixture text-003r placeholder","stderr":"fixture text-003s placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false,"rawOutputPath":"fixture text-003t placeholder"},"description":"fixture text-003u placeholder","fullOutputPath":"fixture text-003v placeholder","status":"fixture text-003w placeholder","task_id":"fixture text-003x placeholder"},"isError":false,"timestamp":1791610983663},"rawOmitted":false,"textTruncated":false,"index":26,"text":null,"thinking":null,"arguments":null,"result":"fixture text-003n placeholder","error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"toolResult","title":"tool_03","summary":"fixture text-003n placeholder"},{"id":"msg-003y","turnId":"turn-004","role":"assistant","generation":null,"timestamp":1791611180154,"responseId":"fixture text-0048 placeholder","relativeMs":7248244,"durationMs":null,"toolName":null,"toolCallId":null,"model":"fixture text-0047 placeholder","provider":"fixture text-0046 placeholder","api":"fixture text-0045 placeholder","stopReason":"toolUse","isError":null,"raw":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-003z placeholder","thinkingSignature":"fixture text-0040 placeholder"},{"type":"text","text":"fixture text-0041 placeholder"},{"type":"toolCall","id":"call_0014","name":"tool_08","arguments":{"file_path":"fixture text-0042 placeholder","new_string":"fixture text-0043 placeholder","old_string":"fixture text-0044 placeholder"}}],"api":"fixture text-0045 placeholder","provider":"fixture text-0046 placeholder","model":"fixture text-0047 placeholder","usage":{"input":4226,"output":759,"cacheRead":272896,"cacheWrite":0,"totalTokens":277881,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791611180154,"responseId":"fixture text-0048 placeholder"},"rawOmitted":false,"textTruncated":false,"index":27,"text":null,"thinking":"fixture text-003z placeholder","arguments":null,"result":null,"error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"thinking","title":"thinking","summary":"fixture text-003z placeholder"},{"id":"msg-003y","turnId":"turn-004","role":"assistant","generation":null,"timestamp":1791611180154,"responseId":"fixture text-0048 placeholder","relativeMs":7248244,"durationMs":null,"toolName":null,"toolCallId":null,"tokens":{"input":4226,"output":759,"cacheRead":272896,"cacheWrite":0,"totalTokens":277881},"model":"fixture text-0047 placeholder","provider":"fixture text-0046 placeholder","api":"fixture text-0045 placeholder","stopReason":"toolUse","isError":null,"raw":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-003z placeholder","thinkingSignature":"fixture text-0040 placeholder"},{"type":"text","text":"fixture text-0041 placeholder"},{"type":"toolCall","id":"call_0014","name":"tool_08","arguments":{"file_path":"fixture text-0042 placeholder","new_string":"fixture text-0043 placeholder","old_string":"fixture text-0044 placeholder"}}],"api":"fixture text-0045 placeholder","provider":"fixture text-0046 placeholder","model":"fixture text-0047 placeholder","usage":{"input":4226,"output":759,"cacheRead":272896,"cacheWrite":0,"totalTokens":277881,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791611180154,"responseId":"fixture text-0048 placeholder"},"rawOmitted":false,"textTruncated":false,"index":28,"text":"fixture text-0041 placeholder","thinking":null,"arguments":null,"result":null,"error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"narration","title":"assistant","summary":"fixture text-0041 placeholder"},{"id":"msg-003y","turnId":"turn-004","role":"assistant","generation":null,"timestamp":1791611180154,"responseId":"fixture text-0048 placeholder","relativeMs":7248244,"durationMs":null,"toolName":"tool_08","toolCallId":"call_0014","model":"fixture text-0047 placeholder","provider":"fixture text-0046 placeholder","api":"fixture text-0045 placeholder","stopReason":"toolUse","isError":null,"raw":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-003z placeholder","thinkingSignature":"fixture text-0040 placeholder"},{"type":"text","text":"fixture text-0041 placeholder"},{"type":"toolCall","id":"call_0014","name":"tool_08","arguments":{"file_path":"fixture text-0042 placeholder","new_string":"fixture text-0043 placeholder","old_string":"fixture text-0044 placeholder"}}],"api":"fixture text-0045 placeholder","provider":"fixture text-0046 placeholder","model":"fixture text-0047 placeholder","usage":{"input":4226,"output":759,"cacheRead":272896,"cacheWrite":0,"totalTokens":277881,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791611180154,"responseId":"fixture text-0048 placeholder"},"rawOmitted":false,"textTruncated":false,"index":29,"text":null,"thinking":null,"arguments":{"file_path":"fixture text-0042 placeholder","new_string":"fixture text-0043 placeholder","old_string":"fixture text-0044 placeholder"},"result":null,"error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"toolCall","title":"tool_08","summary":"tool_08{file_path=\"fixture text-0042 placeholder\", new_string=\"fixture text-0043 placeholder\", old_string=\"fixture text-0044 placeholder\"}","argumentsOmitted":false}]},{"id":"turn-005","index":5,"startedAt":1791611784883,"endedAt":1791611784883,"durationMs":0,"toolCalls":0,"errors":0,"tokens":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"totalTokens":0},"turnClass":"none","askedReader":false,"closed":false,"records":[{"id":"msg-0049","turnId":"turn-005","role":"toolResult","generation":null,"timestamp":1791611784883,"responseId":null,"relativeMs":7852973,"durationMs":null,"toolName":"tool_03","toolCallId":"call_0015","tokens":null,"model":null,"provider":null,"api":null,"stopReason":null,"isError":false,"raw":{"role":"toolResult","toolCallId":"call_0015","toolName":"tool_03","content":[{"type":"text","text":"fixture text-004a placeholder"}],"details":{"execution":{"status":"fixture text-004b placeholder","reason":"fixture text-004c placeholder","exitCode":0},"timing":{"commandTimeoutSeconds":3600,"commandTimerStartedAt":1791611784292,"commandDeadlineAt":1791615384292},"output":{"rawBytes":1402,"persistence":"fixture text-004d placeholder","omittedBytes":0},"processOutput":{"stdout":"fixture text-004e placeholder","stderr":"fixture text-004f placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false,"rawOutputPath":"fixture text-004g placeholder"},"description":"fixture text-004h placeholder","fullOutputPath":"fixture text-004i placeholder","envSanitized":["fixture text-004j placeholder","fixture text-004k placeholder","fixture text-004l placeholder","fixture text-004m placeholder","fixture text-004n placeholder"],"status":"fixture text-004o placeholder","task_id":"fixture text-004p placeholder"},"isError":false,"timestamp":1791611784883},"rawOmitted":false,"textTruncated":false,"index":30,"text":null,"thinking":null,"arguments":null,"result":"fixture text-004a placeholder","error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"toolResult","title":"tool_03","summary":"fixture text-004a placeholder"}]},{"id":"turn-006","index":6,"startedAt":1791612294290,"endedAt":1791612294290,"durationMs":0,"toolCalls":0,"errors":0,"tokens":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"totalTokens":0},"turnClass":"none","askedReader":false,"closed":false,"records":[{"id":"msg-004q","turnId":"turn-006","role":"toolResult","generation":null,"timestamp":1791612294290,"responseId":null,"relativeMs":8362380,"durationMs":null,"toolName":"tool_07","toolCallId":"call_0016","tokens":null,"model":null,"provider":null,"api":null,"stopReason":null,"isError":false,"raw":{"role":"toolResult","toolCallId":"call_0016","toolName":"tool_07","content":[{"type":"text","text":"fixture text-004r placeholder"}],"details":{"created":true,"bytes_written":384,"encoding":"fixture text-004s placeholder","bom":false},"isError":false,"timestamp":1791612294290},"rawOmitted":false,"textTruncated":false,"index":31,"text":null,"thinking":null,"arguments":null,"result":"fixture text-004r placeholder","error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"toolResult","title":"tool_07","summary":"fixture text-004r placeholder"}]},{"id":"turn-007","index":7,"startedAt":1791613412089,"endedAt":1791613412089,"durationMs":0,"toolCalls":0,"errors":0,"tokens":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"totalTokens":0},"turnClass":"compaction","askedReader":false,"closed":false,"records":[{"id":"msg-004t","turnId":"turn-007","role":"compactionSummary","generation":null,"timestamp":1791613412089,"responseId":null,"relativeMs":9480179,"durationMs":null,"toolName":null,"toolCallId":null,"tokens":null,"model":null,"provider":null,"api":null,"stopReason":null,"isError":null,"raw":{"role":"compactionSummary","summary":"fixture text-004u placeholder","tokensBefore":365642,"timestamp":1791613412089},"rawOmitted":false,"textTruncated":false,"index":32,"text":"fixture text-004u placeholder","thinking":null,"arguments":null,"result":null,"error":null,"tokensBefore":365642,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"compaction","title":"compaction","summary":"fixture text-004u placeholder"}]},{"id":"turn-008","index":8,"startedAt":1791613490565,"endedAt":1791613490565,"durationMs":0,"toolCalls":2,"errors":0,"tokens":{"input":2171,"output":429,"cacheRead":54272,"cacheWrite":0,"totalTokens":56872},"turnClass":"none","askedReader":false,"closed":false,"records":[{"id":"msg-004v","turnId":"turn-008","role":"assistant","generation":null,"timestamp":1791613490565,"responseId":"fixture text-0058 placeholder","relativeMs":9558655,"durationMs":null,"toolName":null,"toolCallId":null,"model":"fixture text-0057 placeholder","provider":"fixture text-0056 placeholder","api":"fixture text-0055 placeholder","stopReason":"toolUse","isError":null,"raw":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-004w placeholder","thinkingSignature":"fixture text-004x placeholder"},{"type":"text","text":"fixture text-004y placeholder"},{"type":"toolCall","id":"call_0017","name":"tool_09","arguments":{"pattern":"fixture text-004z placeholder","path":"fixture text-0050 placeholder","output_mode":"fixture text-0051 placeholder"}},{"type":"toolCall","id":"call_0018","name":"tool_09","arguments":{"pattern":"fixture text-0052 placeholder","path":"fixture text-0053 placeholder","output_mode":"fixture text-0054 placeholder","limit":30}}],"api":"fixture text-0055 placeholder","provider":"fixture text-0056 placeholder","model":"fixture text-0057 placeholder","usage":{"input":2171,"output":429,"cacheRead":54272,"cacheWrite":0,"totalTokens":56872,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791613490565,"responseId":"fixture text-0058 placeholder"},"rawOmitted":false,"textTruncated":false,"index":33,"text":null,"thinking":"fixture text-004w placeholder","arguments":null,"result":null,"error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"thinking","title":"thinking","summary":"fixture text-004w placeholder"},{"id":"msg-004v","turnId":"turn-008","role":"assistant","generation":null,"timestamp":1791613490565,"responseId":"fixture text-0058 placeholder","relativeMs":9558655,"durationMs":null,"toolName":null,"toolCallId":null,"tokens":{"input":2171,"output":429,"cacheRead":54272,"cacheWrite":0,"totalTokens":56872},"model":"fixture text-0057 placeholder","provider":"fixture text-0056 placeholder","api":"fixture text-0055 placeholder","stopReason":"toolUse","isError":null,"raw":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-004w placeholder","thinkingSignature":"fixture text-004x placeholder"},{"type":"text","text":"fixture text-004y placeholder"},{"type":"toolCall","id":"call_0017","name":"tool_09","arguments":{"pattern":"fixture text-004z placeholder","path":"fixture text-0050 placeholder","output_mode":"fixture text-0051 placeholder"}},{"type":"toolCall","id":"call_0018","name":"tool_09","arguments":{"pattern":"fixture text-0052 placeholder","path":"fixture text-0053 placeholder","output_mode":"fixture text-0054 placeholder","limit":30}}],"api":"fixture text-0055 placeholder","provider":"fixture text-0056 placeholder","model":"fixture text-0057 placeholder","usage":{"input":2171,"output":429,"cacheRead":54272,"cacheWrite":0,"totalTokens":56872,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791613490565,"responseId":"fixture text-0058 placeholder"},"rawOmitted":false,"textTruncated":false,"index":34,"text":"fixture text-004y placeholder","thinking":null,"arguments":null,"result":null,"error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"narration","title":"assistant","summary":"fixture text-004y placeholder"},{"id":"msg-004v","turnId":"turn-008","role":"assistant","generation":null,"timestamp":1791613490565,"responseId":"fixture text-0058 placeholder","relativeMs":9558655,"durationMs":null,"toolName":"tool_09","toolCallId":"call_0017","model":"fixture text-0057 placeholder","provider":"fixture text-0056 placeholder","api":"fixture text-0055 placeholder","stopReason":"toolUse","isError":null,"raw":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-004w placeholder","thinkingSignature":"fixture text-004x placeholder"},{"type":"text","text":"fixture text-004y placeholder"},{"type":"toolCall","id":"call_0017","name":"tool_09","arguments":{"pattern":"fixture text-004z placeholder","path":"fixture text-0050 placeholder","output_mode":"fixture text-0051 placeholder"}},{"type":"toolCall","id":"call_0018","name":"tool_09","arguments":{"pattern":"fixture text-0052 placeholder","path":"fixture text-0053 placeholder","output_mode":"fixture text-0054 placeholder","limit":30}}],"api":"fixture text-0055 placeholder","provider":"fixture text-0056 placeholder","model":"fixture text-0057 placeholder","usage":{"input":2171,"output":429,"cacheRead":54272,"cacheWrite":0,"totalTokens":56872,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791613490565,"responseId":"fixture text-0058 placeholder"},"rawOmitted":false,"textTruncated":false,"index":35,"text":null,"thinking":null,"arguments":{"pattern":"fixture text-004z placeholder","path":"fixture text-0050 placeholder","output_mode":"fixture text-0051 placeholder"},"result":null,"error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"toolCall","title":"tool_09","summary":"tool_09{pattern=\"fixture text-004z placeholder\", path=\"fixture text-0050 placeholder\", output_mode=\"fixture text-0051 placeholder\"}","argumentsOmitted":false},{"id":"msg-004v","turnId":"turn-008","role":"assistant","generation":null,"timestamp":1791613490565,"responseId":"fixture text-0058 placeholder","relativeMs":9558655,"durationMs":null,"toolName":"tool_09","toolCallId":"call_0018","model":"fixture text-0057 placeholder","provider":"fixture text-0056 placeholder","api":"fixture text-0055 placeholder","stopReason":"toolUse","isError":null,"raw":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-004w placeholder","thinkingSignature":"fixture text-004x placeholder"},{"type":"text","text":"fixture text-004y placeholder"},{"type":"toolCall","id":"call_0017","name":"tool_09","arguments":{"pattern":"fixture text-004z placeholder","path":"fixture text-0050 placeholder","output_mode":"fixture text-0051 placeholder"}},{"type":"toolCall","id":"call_0018","name":"tool_09","arguments":{"pattern":"fixture text-0052 placeholder","path":"fixture text-0053 placeholder","output_mode":"fixture text-0054 placeholder","limit":30}}],"api":"fixture text-0055 placeholder","provider":"fixture text-0056 placeholder","model":"fixture text-0057 placeholder","usage":{"input":2171,"output":429,"cacheRead":54272,"cacheWrite":0,"totalTokens":56872,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791613490565,"responseId":"fixture text-0058 placeholder"},"rawOmitted":false,"textTruncated":false,"index":36,"text":null,"thinking":null,"arguments":{"pattern":"fixture text-0052 placeholder","path":"fixture text-0053 placeholder","output_mode":"fixture text-0054 placeholder","limit":30},"result":null,"error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"toolCall","title":"tool_09","summary":"tool_09{pattern=\"fixture text-0052 placeholder\", path=\"fixture text-0053 placeholder\", output_mode=\"fixture text-0054 placeholder\", limit=\"30\"}","argumentsOmitted":false}]},{"id":"turn-009","index":9,"startedAt":1791614563489,"endedAt":1791614731831,"durationMs":168342,"toolCalls":1,"errors":0,"tokens":{"input":634,"output":1426,"cacheRead":120019,"cacheWrite":0,"totalTokens":122079},"turnClass":"none","askedReader":false,"closed":false,"records":[{"id":"msg-0059","turnId":"turn-009","role":"toolResult","generation":null,"timestamp":1791614563489,"responseId":null,"relativeMs":10631579,"durationMs":null,"toolName":"tool_09","toolCallId":"call_0019","tokens":null,"model":null,"provider":null,"api":null,"stopReason":null,"isError":false,"raw":{"role":"toolResult","toolCallId":"call_0019","toolName":"tool_09","content":[{"type":"text","text":"fixture text-005a placeholder"}],"details":{},"isError":false,"timestamp":1791614563489},"rawOmitted":false,"textTruncated":false,"index":37,"text":null,"thinking":null,"arguments":null,"result":"fixture text-005a placeholder","error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"toolResult","title":"tool_09","summary":"fixture text-005a placeholder"},{"id":"msg-005b","turnId":"turn-009","role":"assistant","generation":null,"timestamp":1791614731831,"responseId":"fixture text-005j placeholder","relativeMs":10799921,"durationMs":null,"toolName":null,"toolCallId":null,"model":"fixture text-005i placeholder","provider":"fixture text-005h placeholder","api":"fixture text-005g placeholder","stopReason":"toolUse","isError":null,"raw":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-005c placeholder","thinkingSignature":"fixture text-005d placeholder"},{"type":"text","text":"fixture text-005e placeholder"},{"type":"toolCall","id":"call_0020","name":"tool_05","arguments":{"path":"fixture text-005f placeholder","limit":14}}],"api":"fixture text-005g placeholder","provider":"fixture text-005h placeholder","model":"fixture text-005i placeholder","usage":{"input":634,"output":1426,"cacheRead":120019,"cacheWrite":0,"totalTokens":122079,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791614731831,"responseId":"fixture text-005j placeholder"},"rawOmitted":false,"textTruncated":false,"index":38,"text":null,"thinking":"fixture text-005c placeholder","arguments":null,"result":null,"error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"thinking","title":"thinking","summary":"fixture text-005c placeholder"},{"id":"msg-005b","turnId":"turn-009","role":"assistant","generation":null,"timestamp":1791614731831,"responseId":"fixture text-005j placeholder","relativeMs":10799921,"durationMs":null,"toolName":null,"toolCallId":null,"tokens":{"input":634,"output":1426,"cacheRead":120019,"cacheWrite":0,"totalTokens":122079},"model":"fixture text-005i placeholder","provider":"fixture text-005h placeholder","api":"fixture text-005g placeholder","stopReason":"toolUse","isError":null,"raw":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-005c placeholder","thinkingSignature":"fixture text-005d placeholder"},{"type":"text","text":"fixture text-005e placeholder"},{"type":"toolCall","id":"call_0020","name":"tool_05","arguments":{"path":"fixture text-005f placeholder","limit":14}}],"api":"fixture text-005g placeholder","provider":"fixture text-005h placeholder","model":"fixture text-005i placeholder","usage":{"input":634,"output":1426,"cacheRead":120019,"cacheWrite":0,"totalTokens":122079,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791614731831,"responseId":"fixture text-005j placeholder"},"rawOmitted":false,"textTruncated":false,"index":39,"text":"fixture text-005e placeholder","thinking":null,"arguments":null,"result":null,"error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"narration","title":"assistant","summary":"fixture text-005e placeholder"},{"id":"msg-005b","turnId":"turn-009","role":"assistant","generation":null,"timestamp":1791614731831,"responseId":"fixture text-005j placeholder","relativeMs":10799921,"durationMs":null,"toolName":"tool_05","toolCallId":"call_0020","model":"fixture text-005i placeholder","provider":"fixture text-005h placeholder","api":"fixture text-005g placeholder","stopReason":"toolUse","isError":null,"raw":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-005c placeholder","thinkingSignature":"fixture text-005d placeholder"},{"type":"text","text":"fixture text-005e placeholder"},{"type":"toolCall","id":"call_0020","name":"tool_05","arguments":{"path":"fixture text-005f placeholder","limit":14}}],"api":"fixture text-005g placeholder","provider":"fixture text-005h placeholder","model":"fixture text-005i placeholder","usage":{"input":634,"output":1426,"cacheRead":120019,"cacheWrite":0,"totalTokens":122079,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791614731831,"responseId":"fixture text-005j placeholder"},"rawOmitted":false,"textTruncated":false,"index":40,"text":null,"thinking":null,"arguments":{"path":"fixture text-005f placeholder","limit":14},"result":null,"error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"toolCall","title":"tool_05","summary":"tool_05{path=\"fixture text-005f placeholder\", limit=\"14\"}","argumentsOmitted":false}]},{"id":"turn-010","index":10,"startedAt":1791615045716,"endedAt":1791615045716,"durationMs":0,"toolCalls":0,"errors":0,"tokens":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"totalTokens":0},"turnClass":"prompt","askedReader":false,"closed":false,"records":[{"id":"msg-005k","turnId":"turn-010","role":"user","generation":null,"timestamp":1791615045716,"responseId":null,"relativeMs":11113806,"durationMs":null,"toolName":null,"toolCallId":null,"tokens":null,"model":null,"provider":null,"api":null,"stopReason":null,"isError":null,"raw":{"role":"user","content":[{"type":"text","text":"fixture text-005l placeholder"}],"timestamp":1791615045716,"canonicalTextRange":{"startOffset":0,"endOffset":10},"hostMetadata":{"immediateSendBatchId":"fixture text-005m placeholder"}},"rawOmitted":false,"textTruncated":false,"index":41,"text":"fixture te","thinking":null,"arguments":null,"result":null,"error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"user","title":"user","summary":"fixture te","steered":false}]},{"id":"turn-011","index":11,"startedAt":1791615477302,"endedAt":1791615904587,"durationMs":427285,"toolCalls":0,"errors":0,"tokens":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"totalTokens":0},"turnClass":"none","askedReader":false,"closed":false,"records":[{"id":"msg-005n","turnId":"turn-011","role":"toolResult","generation":null,"timestamp":1791615477302,"responseId":null,"relativeMs":11545392,"durationMs":null,"toolName":"tool_03","toolCallId":"call_0021","tokens":null,"model":null,"provider":null,"api":null,"stopReason":null,"isError":false,"raw":{"role":"toolResult","toolCallId":"call_0021","toolName":"tool_03","content":[{"type":"text","text":"fixture text-005o placeholder"}],"details":{"execution":{"status":"fixture text-005p placeholder","reason":"fixture text-005q placeholder","exitCode":0},"timing":{"commandTimeoutSeconds":3600,"commandTimerStartedAt":1791615476257,"commandDeadlineAt":1791619076257},"output":{"rawBytes":557,"persistence":"fixture text-005r placeholder","omittedBytes":0},"processOutput":{"stdout":"fixture text-005s placeholder","stderr":"fixture text-005t placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false,"rawOutputPath":"fixture text-005u placeholder"},"description":"fixture text-005v placeholder","fullOutputPath":"fixture text-005w placeholder","status":"fixture text-005x placeholder","task_id":"fixture text-005y placeholder"},"isError":false,"timestamp":1791615477302},"rawOmitted":false,"textTruncated":false,"index":42,"text":null,"thinking":null,"arguments":null,"result":"fixture text-005o placeholder","error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"toolResult","title":"tool_03","summary":"fixture text-005o placeholder"},{"id":"msg-005z","turnId":"turn-011","role":"toolResult","generation":null,"timestamp":1791615904587,"responseId":null,"relativeMs":11972677,"durationMs":null,"toolName":"tool_03","toolCallId":"call_0022","tokens":null,"model":null,"provider":null,"api":null,"stopReason":null,"isError":false,"raw":{"role":"toolResult","toolCallId":"call_0022","toolName":"tool_03","content":[{"type":"text","text":"fixture text-0060 placeholder"}],"details":{"execution":{"status":"fixture text-0061 placeholder","reason":"fixture text-0062 placeholder","exitCode":0},"timing":{"commandTimeoutSeconds":3600,"commandTimerStartedAt":1791615900851,"commandDeadlineAt":1791619500851},"output":{"rawBytes":634,"persistence":"fixture text-0063 placeholder","omittedBytes":0},"processOutput":{"stdout":"fixture text-0064 placeholder","stderr":"fixture text-0065 placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false,"rawOutputPath":"fixture text-0066 placeholder"},"description":"fixture text-0067 placeholder","fullOutputPath":"fixture text-0068 placeholder","status":"fixture text-0069 placeholder","task_id":"fixture text-006a placeholder"},"isError":false,"timestamp":1791615904587},"rawOmitted":false,"textTruncated":false,"index":43,"text":null,"thinking":null,"arguments":null,"result":"fixture text-0060 placeholder","error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"toolResult","title":"tool_03","summary":"fixture text-0060 placeholder"}]},{"id":"turn-012","index":12,"startedAt":1791616197977,"endedAt":1791616341161,"durationMs":143184,"toolCalls":1,"errors":0,"tokens":{"input":806,"output":332,"cacheRead":215296,"cacheWrite":0,"totalTokens":216434},"turnClass":"none","askedReader":false,"closed":false,"records":[{"id":"msg-006b","turnId":"turn-012","role":"assistant","generation":null,"timestamp":1791616197977,"responseId":"fixture text-006i placeholder","relativeMs":12266067,"durationMs":null,"toolName":"tool_08","toolCallId":"call_0023","tokens":{"input":806,"output":332,"cacheRead":215296,"cacheWrite":0,"totalTokens":216434},"model":"fixture text-006h placeholder","provider":"fixture text-006g placeholder","api":"fixture text-006f placeholder","stopReason":"toolUse","isError":null,"raw":{"role":"assistant","content":[{"type":"toolCall","id":"call_0023","name":"tool_08","arguments":{"file_path":"fixture text-006c placeholder","new_string":"fixture text-006d placeholder","old_string":"fixture text-006e placeholder"}}],"api":"fixture text-006f placeholder","provider":"fixture text-006g placeholder","model":"fixture text-006h placeholder","usage":{"input":806,"output":332,"cacheRead":215296,"cacheWrite":0,"totalTokens":216434,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791616197977,"responseId":"fixture text-006i placeholder"},"rawOmitted":false,"textTruncated":false,"index":44,"text":null,"thinking":null,"arguments":{"file_path":"fixture text-006c placeholder","new_string":"fixture text-006d placeholder","old_string":"fixture text-006e placeholder"},"result":null,"error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"toolCall","title":"tool_08","summary":"tool_08{file_path=\"fixture text-006c placeholder\", new_string=\"fixture text-006d placeholder\", old_string=\"fixture text-006e placeholder\"}","argumentsOmitted":false},{"id":"msg-006j","turnId":"turn-012","role":"toolResult","generation":null,"timestamp":1791616341161,"responseId":null,"relativeMs":12409251,"durationMs":null,"toolName":"tool_08","toolCallId":"call_0024","tokens":null,"model":null,"provider":null,"api":null,"stopReason":null,"isError":false,"raw":{"role":"toolResult","toolCallId":"call_0024","toolName":"tool_08","content":[{"type":"text","text":"fixture text-006k placeholder"}],"details":{"diff":"fixture text-006l placeholder","patch":"fixture text-006m placeholder","firstChangedLine":19},"isError":false,"timestamp":1791616341161},"rawOmitted":false,"textTruncated":false,"index":45,"text":null,"thinking":null,"arguments":null,"result":"fixture text-006k placeholder","error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"toolResult","title":"tool_08","summary":"fixture text-006k placeholder"}]},{"id":"turn-013","index":13,"startedAt":1791616657094,"endedAt":1791616657094,"durationMs":0,"toolCalls":1,"errors":0,"tokens":{"input":2780,"output":1648,"cacheRead":257536,"cacheWrite":0,"totalTokens":261964},"turnClass":"none","askedReader":false,"closed":false,"records":[{"id":"msg-006n","turnId":"turn-013","role":"assistant","generation":null,"timestamp":1791616657094,"responseId":"fixture text-006w placeholder","relativeMs":12725184,"durationMs":null,"toolName":null,"toolCallId":null,"model":"fixture text-006v placeholder","provider":"fixture text-006u placeholder","api":"fixture text-006t placeholder","stopReason":"toolUse","isError":null,"raw":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-006o placeholder","thinkingSignature":"fixture text-006p placeholder"},{"type":"text","text":"fixture text-006q placeholder"},{"type":"toolCall","id":"call_0025","name":"tool_03","arguments":{"command":"fixture text-006r placeholder","description":"fixture text-006s placeholder","timeout":120}}],"api":"fixture text-006t placeholder","provider":"fixture text-006u placeholder","model":"fixture text-006v placeholder","usage":{"input":2780,"output":1648,"cacheRead":257536,"cacheWrite":0,"totalTokens":261964,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791616657094,"responseId":"fixture text-006w placeholder"},"rawOmitted":false,"textTruncated":false,"index":46,"text":null,"thinking":"fixture text-006o placeholder","arguments":null,"result":null,"error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"thinking","title":"thinking","summary":"fixture text-006o placeholder"},{"id":"msg-006n","turnId":"turn-013","role":"assistant","generation":null,"timestamp":1791616657094,"responseId":"fixture text-006w placeholder","relativeMs":12725184,"durationMs":null,"toolName":null,"toolCallId":null,"tokens":{"input":2780,"output":1648,"cacheRead":257536,"cacheWrite":0,"totalTokens":261964},"model":"fixture text-006v placeholder","provider":"fixture text-006u placeholder","api":"fixture text-006t placeholder","stopReason":"toolUse","isError":null,"raw":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-006o placeholder","thinkingSignature":"fixture text-006p placeholder"},{"type":"text","text":"fixture text-006q placeholder"},{"type":"toolCall","id":"call_0025","name":"tool_03","arguments":{"command":"fixture text-006r placeholder","description":"fixture text-006s placeholder","timeout":120}}],"api":"fixture text-006t placeholder","provider":"fixture text-006u placeholder","model":"fixture text-006v placeholder","usage":{"input":2780,"output":1648,"cacheRead":257536,"cacheWrite":0,"totalTokens":261964,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791616657094,"responseId":"fixture text-006w placeholder"},"rawOmitted":false,"textTruncated":false,"index":47,"text":"fixture text-006q placeholder","thinking":null,"arguments":null,"result":null,"error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"narration","title":"assistant","summary":"fixture text-006q placeholder"},{"id":"msg-006n","turnId":"turn-013","role":"assistant","generation":null,"timestamp":1791616657094,"responseId":"fixture text-006w placeholder","relativeMs":12725184,"durationMs":null,"toolName":"tool_03","toolCallId":"call_0025","model":"fixture text-006v placeholder","provider":"fixture text-006u placeholder","api":"fixture text-006t placeholder","stopReason":"toolUse","isError":null,"raw":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-006o placeholder","thinkingSignature":"fixture text-006p placeholder"},{"type":"text","text":"fixture text-006q placeholder"},{"type":"toolCall","id":"call_0025","name":"tool_03","arguments":{"command":"fixture text-006r placeholder","description":"fixture text-006s placeholder","timeout":120}}],"api":"fixture text-006t placeholder","provider":"fixture text-006u placeholder","model":"fixture text-006v placeholder","usage":{"input":2780,"output":1648,"cacheRead":257536,"cacheWrite":0,"totalTokens":261964,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791616657094,"responseId":"fixture text-006w placeholder"},"rawOmitted":false,"textTruncated":false,"index":48,"text":null,"thinking":null,"arguments":{"command":"fixture text-006r placeholder","description":"fixture text-006s placeholder","timeout":120},"result":null,"error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"toolCall","title":"tool_03","summary":"tool_03{command=\"fixture text-006r placeholder\", description=\"fixture text-006s placeholder\", timeout=\"120\"}","argumentsOmitted":false}]},{"id":"turn-014","index":14,"startedAt":1791617021128,"endedAt":1791617021128,"durationMs":0,"toolCalls":0,"errors":0,"tokens":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"totalTokens":0},"turnClass":"none","askedReader":false,"closed":false,"records":[{"id":"msg-006x","turnId":"turn-014","role":"toolResult","generation":null,"timestamp":1791617021128,"responseId":null,"relativeMs":13089218,"durationMs":null,"toolName":"tool_07","toolCallId":"call_0026","tokens":null,"model":null,"provider":null,"api":null,"stopReason":null,"isError":false,"raw":{"role":"toolResult","toolCallId":"call_0026","toolName":"tool_07","content":[{"type":"text","text":"fixture text-006y placeholder"}],"details":{"created":true,"bytes_written":4484,"encoding":"fixture text-006z placeholder","bom":false},"isError":false,"timestamp":1791617021128},"rawOmitted":false,"textTruncated":false,"index":49,"text":null,"thinking":null,"arguments":null,"result":"fixture text-006y placeholder","error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"toolResult","title":"tool_07","summary":"fixture text-006y placeholder"}]},{"id":"turn-015","index":15,"startedAt":1791617468106,"endedAt":1791617468106,"durationMs":0,"toolCalls":1,"errors":0,"tokens":{"input":1087,"output":70,"cacheRead":312832,"cacheWrite":0,"totalTokens":313989},"turnClass":"none","askedReader":false,"closed":false,"records":[{"id":"msg-0070","turnId":"turn-015","role":"assistant","generation":null,"timestamp":1791617468106,"responseId":"fixture text-0075 placeholder","relativeMs":13536196,"durationMs":null,"toolName":"tool_05","toolCallId":"call_0027","tokens":{"input":1087,"output":70,"cacheRead":312832,"cacheWrite":0,"totalTokens":313989},"model":"fixture text-0074 placeholder","provider":"fixture text-0073 placeholder","api":"fixture text-0072 placeholder","stopReason":"toolUse","isError":null,"raw":{"role":"assistant","content":[{"type":"toolCall","id":"call_0027","name":"tool_05","arguments":{"limit":40,"offset":2108,"path":"fixture text-0071 placeholder"}}],"api":"fixture text-0072 placeholder","provider":"fixture text-0073 placeholder","model":"fixture text-0074 placeholder","usage":{"input":1087,"output":70,"cacheRead":312832,"cacheWrite":0,"totalTokens":313989,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791617468106,"responseId":"fixture text-0075 placeholder"},"rawOmitted":false,"textTruncated":false,"index":50,"text":null,"thinking":null,"arguments":{"limit":40,"offset":2108,"path":"fixture text-0071 placeholder"},"result":null,"error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"toolCall","title":"tool_05","summary":"tool_05{limit=\"40\", offset=\"2108\", path=\"fixture text-0071 placeholder\"}","argumentsOmitted":false}]},{"id":"turn-016","index":16,"startedAt":1791617651220,"endedAt":1791618644926,"durationMs":993706,"toolCalls":3,"errors":0,"tokens":{"input":2763,"output":1128,"cacheRead":508160,"cacheWrite":0,"totalTokens":512051},"turnClass":"none","askedReader":false,"closed":false,"records":[{"id":"msg-0076","turnId":"turn-016","role":"user","generation":null,"timestamp":1791617651220,"responseId":null,"relativeMs":13719310,"durationMs":null,"toolName":null,"toolCallId":null,"tokens":null,"model":null,"provider":null,"api":null,"stopReason":null,"isError":null,"raw":{"role":"user","content":[{"type":"text","text":"<system-reminder>\nfixture injected-0077 block"}],"timestamp":1791617651220,"canonicalTextRange":{"startOffset":3003,"endOffset":3066}},"rawOmitted":false,"textTruncated":false,"index":51,"text":"<system-reminder>\nfixture injected-0077 block","thinking":null,"arguments":null,"result":null,"error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"system","title":"injected","summary":"<system-reminder> fixture injected-0077 block"},{"id":"msg-0078","turnId":"turn-016","role":"assistant","generation":null,"timestamp":1791617812028,"responseId":"fixture text-007e placeholder","relativeMs":13880118,"durationMs":null,"toolName":"tool_03","toolCallId":"call_0028","tokens":{"input":859,"output":309,"cacheRead":349952,"cacheWrite":0,"totalTokens":351120},"model":"fixture text-007d placeholder","provider":"fixture text-007c placeholder","api":"fixture text-007b placeholder","stopReason":"toolUse","isError":null,"raw":{"role":"assistant","content":[{"type":"toolCall","id":"call_0028","name":"tool_03","arguments":{"command":"fixture text-0079 placeholder","description":"fixture text-007a placeholder","timeout":240}}],"api":"fixture text-007b placeholder","provider":"fixture text-007c placeholder","model":"fixture text-007d placeholder","usage":{"input":859,"output":309,"cacheRead":349952,"cacheWrite":0,"totalTokens":351120,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791617812028,"responseId":"fixture text-007e placeholder"},"rawOmitted":false,"textTruncated":false,"index":52,"text":null,"thinking":null,"arguments":{"command":"fixture text-0079 placeholder","description":"fixture text-007a placeholder","timeout":240},"result":null,"error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"toolCall","title":"tool_03","summary":"tool_03{command=\"fixture text-0079 placeholder\", description=\"fixture text-007a placeholder\", timeout=\"240\"}","argumentsOmitted":false},{"id":"msg-007f","turnId":"turn-016","role":"assistant","generation":null,"timestamp":1791618043996,"responseId":"fixture text-007o placeholder","relativeMs":14112086,"durationMs":null,"toolName":null,"toolCallId":null,"tokens":{"input":1825,"output":630,"cacheRead":68352,"cacheWrite":0,"totalTokens":70807},"model":"fixture text-007n placeholder","provider":"fixture text-007m placeholder","api":"fixture text-007l placeholder","stopReason":"toolUse","isError":null,"raw":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-007g placeholder","thinkingSignature":"fixture text-007h placeholder"},{"type":"toolCall","id":"call_0029","name":"tool_09","arguments":{"context":2,"limit":8,"output_mode":"fixture text-007i placeholder","path":"fixture text-007j placeholder","pattern":"fixture text-007k placeholder"}}],"api":"fixture text-007l placeholder","provider":"fixture text-007m placeholder","model":"fixture text-007n placeholder","usage":{"input":1825,"output":630,"cacheRead":68352,"cacheWrite":0,"totalTokens":70807,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791618043996,"responseId":"fixture text-007o placeholder"},"rawOmitted":false,"textTruncated":false,"index":53,"text":null,"thinking":"fixture text-007g placeholder","arguments":null,"result":null,"error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"thinking","title":"thinking","summary":"fixture text-007g placeholder"},{"id":"msg-007f","turnId":"turn-016","role":"assistant","generation":null,"timestamp":1791618043996,"responseId":"fixture text-007o placeholder","relativeMs":14112086,"durationMs":null,"toolName":"tool_09","toolCallId":"call_0029","model":"fixture text-007n placeholder","provider":"fixture text-007m placeholder","api":"fixture text-007l placeholder","stopReason":"toolUse","isError":null,"raw":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-007g placeholder","thinkingSignature":"fixture text-007h placeholder"},{"type":"toolCall","id":"call_0029","name":"tool_09","arguments":{"context":2,"limit":8,"output_mode":"fixture text-007i placeholder","path":"fixture text-007j placeholder","pattern":"fixture text-007k placeholder"}}],"api":"fixture text-007l placeholder","provider":"fixture text-007m placeholder","model":"fixture text-007n placeholder","usage":{"input":1825,"output":630,"cacheRead":68352,"cacheWrite":0,"totalTokens":70807,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791618043996,"responseId":"fixture text-007o placeholder"},"rawOmitted":false,"textTruncated":false,"index":54,"text":null,"thinking":null,"arguments":{"context":2,"limit":8,"output_mode":"fixture text-007i placeholder","path":"fixture text-007j placeholder","pattern":"fixture text-007k placeholder"},"result":null,"error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"toolCall","title":"tool_09","summary":"tool_09{context=\"2\", limit=\"8\", output_mode=\"fixture text-007i placeholder\", path=\"fixture text-007j placeholder\"}","argumentsOmitted":false},{"id":"msg-007p","turnId":"turn-016","role":"toolResult","generation":null,"timestamp":1791618210903,"responseId":null,"relativeMs":14278993,"durationMs":null,"toolName":"tool_05","toolCallId":"call_0030","tokens":null,"model":null,"provider":null,"api":null,"stopReason":null,"isError":false,"raw":{"role":"toolResult","toolCallId":"call_0030","toolName":"tool_05","content":[{"type":"text","text":"fixture text-007q placeholder"}],"details":{"textFile":{"path":"fixture text-007r placeholder","content":"fixture text-007s placeholder","numLines":14,"startLine":1231,"totalLines":2912,"truncatedByOutputLimit":false,"wholeFileAutoTruncated":false}},"isError":false,"timestamp":1791618210903},"rawOmitted":false,"textTruncated":false,"index":55,"text":null,"thinking":null,"arguments":null,"result":"fixture text-007q placeholder","error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"toolResult","title":"tool_05","summary":"fixture text-007q placeholder"},{"id":"msg-007t","turnId":"turn-016","role":"assistant","generation":null,"timestamp":1791618408954,"responseId":"fixture text-0081 placeholder","relativeMs":14477044,"durationMs":null,"toolName":null,"toolCallId":null,"tokens":{"input":79,"output":189,"cacheRead":89856,"cacheWrite":0,"totalTokens":90124},"model":"fixture text-0080 placeholder","provider":"fixture text-007z placeholder","api":"fixture text-007y placeholder","stopReason":"toolUse","isError":null,"raw":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-007u placeholder","thinkingSignature":"fixture text-007v placeholder"},{"type":"toolCall","id":"call_0031","name":"tool_03","arguments":{"command":"fixture text-007w placeholder","description":"fixture text-007x placeholder","timeout":420}}],"api":"fixture text-007y placeholder","provider":"fixture text-007z placeholder","model":"fixture text-0080 placeholder","usage":{"input":79,"output":189,"cacheRead":89856,"cacheWrite":0,"totalTokens":90124,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791618408954,"responseId":"fixture text-0081 placeholder"},"rawOmitted":false,"textTruncated":false,"index":56,"text":null,"thinking":"fixture text-007u placeholder","arguments":null,"result":null,"error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"thinking","title":"thinking","summary":"fixture text-007u placeholder"},{"id":"msg-007t","turnId":"turn-016","role":"assistant","generation":null,"timestamp":1791618408954,"responseId":"fixture text-0081 placeholder","relativeMs":14477044,"durationMs":null,"toolName":"tool_03","toolCallId":"call_0031","model":"fixture text-0080 placeholder","provider":"fixture text-007z placeholder","api":"fixture text-007y placeholder","stopReason":"toolUse","isError":null,"raw":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-007u placeholder","thinkingSignature":"fixture text-007v placeholder"},{"type":"toolCall","id":"call_0031","name":"tool_03","arguments":{"command":"fixture text-007w placeholder","description":"fixture text-007x placeholder","timeout":420}}],"api":"fixture text-007y placeholder","provider":"fixture text-007z placeholder","model":"fixture text-0080 placeholder","usage":{"input":79,"output":189,"cacheRead":89856,"cacheWrite":0,"totalTokens":90124,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791618408954,"responseId":"fixture text-0081 placeholder"},"rawOmitted":false,"textTruncated":false,"index":57,"text":null,"thinking":null,"arguments":{"command":"fixture text-007w placeholder","description":"fixture text-007x placeholder","timeout":420},"result":null,"error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"toolCall","title":"tool_03","summary":"tool_03{command=\"fixture text-007w placeholder\", description=\"fixture text-007x placeholder\", timeout=\"420\"}","argumentsOmitted":false},{"id":"msg-0082","turnId":"turn-016","role":"toolResult","generation":null,"timestamp":1791618644926,"responseId":null,"relativeMs":14713016,"durationMs":null,"toolName":"tool_03","toolCallId":"call_0032","tokens":null,"model":null,"provider":null,"api":null,"stopReason":null,"isError":false,"raw":{"role":"toolResult","toolCallId":"call_0032","toolName":"tool_03","content":[{"type":"text","text":"fixture text-0083 placeholder"}],"details":{"execution":{"status":"fixture text-0084 placeholder","reason":"fixture text-0085 placeholder","exitCode":0},"timing":{"commandTimeoutSeconds":300,"commandTimerStartedAt":1791618643593,"commandDeadlineAt":1791618943593},"output":{"rawBytes":174,"persistence":"fixture text-0086 placeholder","omittedBytes":0},"processOutput":{"stdout":"fixture text-0087 placeholder","stderr":"fixture text-0088 placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false,"rawOutputPath":"fixture text-0089 placeholder"},"description":"fixture text-008a placeholder","fullOutputPath":"fixture text-008b placeholder","status":"fixture text-008c placeholder","task_id":"fixture text-008d placeholder"},"isError":false,"timestamp":1791618644926},"rawOmitted":false,"textTruncated":false,"index":58,"text":null,"thinking":null,"arguments":null,"result":"fixture text-0083 placeholder","error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"toolResult","title":"tool_03","summary":"fixture text-0083 placeholder"}]},{"id":"turn-017","index":17,"startedAt":1791619060246,"endedAt":1791620468950,"durationMs":1408704,"toolCalls":3,"errors":2,"tokens":{"input":5055,"output":1798,"cacheRead":466304,"cacheWrite":0,"totalTokens":473157},"turnClass":"none","askedReader":false,"closed":false,"records":[{"id":"msg-008e","turnId":"turn-017","role":"assistant","generation":null,"timestamp":1791619060246,"responseId":"fixture text-008m placeholder","relativeMs":15128336,"durationMs":null,"toolName":null,"toolCallId":null,"tokens":{"input":452,"output":939,"cacheRead":118656,"cacheWrite":0,"totalTokens":120047},"model":"fixture text-008l placeholder","provider":"fixture text-008k placeholder","api":"fixture text-008j placeholder","stopReason":"toolUse","isError":null,"raw":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-008f placeholder","thinkingSignature":"fixture text-008g placeholder"},{"type":"toolCall","id":"call_0033","name":"tool_03","arguments":{"command":"fixture text-008h placeholder","description":"fixture text-008i placeholder","timeout":120}}],"api":"fixture text-008j placeholder","provider":"fixture text-008k placeholder","model":"fixture text-008l placeholder","usage":{"input":452,"output":939,"cacheRead":118656,"cacheWrite":0,"totalTokens":120047,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791619060246,"responseId":"fixture text-008m placeholder"},"rawOmitted":false,"textTruncated":false,"index":59,"text":null,"thinking":"fixture text-008f placeholder","arguments":null,"result":null,"error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"thinking","title":"thinking","summary":"fixture text-008f placeholder"},{"id":"msg-008e","turnId":"turn-017","role":"assistant","generation":null,"timestamp":1791619060246,"responseId":"fixture text-008m placeholder","relativeMs":15128336,"durationMs":null,"toolName":"tool_03","toolCallId":"call_0033","model":"fixture text-008l placeholder","provider":"fixture text-008k placeholder","api":"fixture text-008j placeholder","stopReason":"toolUse","isError":null,"raw":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-008f placeholder","thinkingSignature":"fixture text-008g placeholder"},{"type":"toolCall","id":"call_0033","name":"tool_03","arguments":{"command":"fixture text-008h placeholder","description":"fixture text-008i placeholder","timeout":120}}],"api":"fixture text-008j placeholder","provider":"fixture text-008k placeholder","model":"fixture text-008l placeholder","usage":{"input":452,"output":939,"cacheRead":118656,"cacheWrite":0,"totalTokens":120047,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791619060246,"responseId":"fixture text-008m placeholder"},"rawOmitted":false,"textTruncated":false,"index":60,"text":null,"thinking":null,"arguments":{"command":"fixture text-008h placeholder","description":"fixture text-008i placeholder","timeout":120},"result":null,"error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"toolCall","title":"tool_03","summary":"tool_03{command=\"fixture text-008h placeholder\", description=\"fixture text-008i placeholder\", timeout=\"120\"}","argumentsOmitted":false},{"id":"msg-008n","turnId":"turn-017","role":"toolResult","generation":null,"timestamp":1791619266573,"responseId":null,"relativeMs":15334663,"durationMs":null,"toolName":"tool_08","toolCallId":"call_0034","tokens":null,"model":null,"provider":null,"api":null,"stopReason":null,"isError":false,"raw":{"role":"toolResult","toolCallId":"call_0034","toolName":"tool_08","content":[{"type":"text","text":"fixture text-008o placeholder"}],"details":{"diff":"fixture text-008p placeholder","patch":"fixture text-008q placeholder","firstChangedLine":1127},"isError":false,"timestamp":1791619266573},"rawOmitted":false,"textTruncated":false,"index":61,"text":null,"thinking":null,"arguments":null,"result":"fixture text-008o placeholder","error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"toolResult","title":"tool_08","summary":"fixture text-008o placeholder"},{"id":"msg-008r","turnId":"turn-017","role":"toolResult","generation":null,"timestamp":1791619441758,"responseId":null,"relativeMs":15509848,"durationMs":null,"toolName":"tool_08","toolCallId":"call_0035","tokens":null,"model":null,"provider":null,"api":null,"stopReason":null,"isError":false,"raw":{"role":"toolResult","toolCallId":"call_0035","toolName":"tool_08","content":[{"type":"text","text":"fixture text-008s placeholder"}],"details":{"diff":"fixture text-008t placeholder","patch":"fixture text-008u placeholder","firstChangedLine":1185},"isError":false,"timestamp":1791619441758},"rawOmitted":false,"textTruncated":false,"index":62,"text":null,"thinking":null,"arguments":null,"result":"fixture text-008s placeholder","error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"toolResult","title":"tool_08","summary":"fixture text-008s placeholder"},{"id":"msg-008v","turnId":"turn-017","role":"toolResult","generation":null,"timestamp":1791619595453,"responseId":null,"relativeMs":15663543,"durationMs":null,"toolName":"tool_03","toolCallId":"call_0036","tokens":null,"model":null,"provider":null,"api":null,"stopReason":null,"isError":true,"raw":{"role":"toolResult","toolCallId":"call_0036","toolName":"tool_03","content":[{"type":"text","text":"fixture text-008w placeholder"}],"details":{"execution":{"status":"fixture text-008x placeholder","reason":"fixture text-008y placeholder","exitCode":1,"message":"fixture text-008z placeholder"},"timing":{"commandTimeoutSeconds":180,"commandTimerStartedAt":1791619594718,"commandDeadlineAt":1791619774718},"output":{"rawBytes":929,"persistence":"fixture text-0090 placeholder","omittedBytes":0},"processOutput":{"stdout":"fixture text-0091 placeholder","stderr":"fixture text-0092 placeholder","exitCode":1,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false,"rawOutputPath":"fixture text-0093 placeholder"},"description":"fixture text-0094 placeholder","fullOutputPath":"fixture text-0095 placeholder","status":"fixture text-0096 placeholder","task_id":"fixture text-0097 placeholder","is_error":true},"isError":true,"timestamp":1791619595453},"rawOmitted":false,"textTruncated":false,"index":63,"text":null,"thinking":null,"arguments":null,"result":"fixture text-008w placeholder","error":"fixture text-008w placeholder","tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"toolResult","title":"tool_03","summary":"fixture text-008w placeholder"},{"id":"msg-0098","turnId":"turn-017","role":"assistant","generation":null,"timestamp":1791619777303,"responseId":"fixture text-009d placeholder","relativeMs":15845393,"durationMs":null,"toolName":"tool_04","toolCallId":"call_0037","tokens":{"input":3978,"output":36,"cacheRead":162816,"cacheWrite":0,"totalTokens":166830},"model":"fixture text-009c placeholder","provider":"fixture text-009b placeholder","api":"fixture text-009a placeholder","stopReason":"toolUse","isError":null,"raw":{"role":"assistant","content":[{"type":"toolCall","id":"call_0037","name":"tool_04","arguments":{"action":"fixture text-0099 placeholder","input":{}}}],"api":"fixture text-009a placeholder","provider":"fixture text-009b placeholder","model":"fixture text-009c placeholder","usage":{"input":3978,"output":36,"cacheRead":162816,"cacheWrite":0,"totalTokens":166830,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791619777303,"responseId":"fixture text-009d placeholder"},"rawOmitted":false,"textTruncated":false,"index":64,"text":null,"thinking":null,"arguments":{"action":"fixture text-0099 placeholder","input":{}},"result":null,"error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"toolCall","title":"tool_04","summary":"tool_04{action=\"fixture text-0099 placeholder\", input=\"{…}\"}","argumentsOmitted":false},{"id":"msg-009e","turnId":"turn-017","role":"assistant","generation":null,"timestamp":1791620008455,"responseId":"fixture text-009m placeholder","relativeMs":16076545,"durationMs":null,"toolName":null,"toolCallId":null,"tokens":{"input":625,"output":823,"cacheRead":184832,"cacheWrite":0,"totalTokens":186280},"model":"fixture text-009l placeholder","provider":"fixture text-009k placeholder","api":"fixture text-009j placeholder","stopReason":"toolUse","isError":null,"raw":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-009f placeholder","thinkingSignature":"fixture text-009g placeholder"},{"type":"toolCall","id":"call_0038","name":"tool_03","arguments":{"command":"fixture text-009h placeholder","description":"fixture text-009i placeholder","timeout":180}}],"api":"fixture text-009j placeholder","provider":"fixture text-009k placeholder","model":"fixture text-009l placeholder","usage":{"input":625,"output":823,"cacheRead":184832,"cacheWrite":0,"totalTokens":186280,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791620008455,"responseId":"fixture text-009m placeholder"},"rawOmitted":false,"textTruncated":false,"index":65,"text":null,"thinking":"fixture text-009f placeholder","arguments":null,"result":null,"error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"thinking","title":"thinking","summary":"fixture text-009f placeholder"},{"id":"msg-009e","turnId":"turn-017","role":"assistant","generation":null,"timestamp":1791620008455,"responseId":"fixture text-009m placeholder","relativeMs":16076545,"durationMs":null,"toolName":"tool_03","toolCallId":"call_0038","model":"fixture text-009l placeholder","provider":"fixture text-009k placeholder","api":"fixture text-009j placeholder","stopReason":"toolUse","isError":null,"raw":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-009f placeholder","thinkingSignature":"fixture text-009g placeholder"},{"type":"toolCall","id":"call_0038","name":"tool_03","arguments":{"command":"fixture text-009h placeholder","description":"fixture text-009i placeholder","timeout":180}}],"api":"fixture text-009j placeholder","provider":"fixture text-009k placeholder","model":"fixture text-009l placeholder","usage":{"input":625,"output":823,"cacheRead":184832,"cacheWrite":0,"totalTokens":186280,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791620008455,"responseId":"fixture text-009m placeholder"},"rawOmitted":false,"textTruncated":false,"index":66,"text":null,"thinking":null,"arguments":{"command":"fixture text-009h placeholder","description":"fixture text-009i placeholder","timeout":180},"result":null,"error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"toolCall","title":"tool_03","summary":"tool_03{command=\"fixture text-009h placeholder\", description=\"fixture text-009i placeholder\", timeout=\"180\"}","argumentsOmitted":false},{"id":"msg-009n","turnId":"turn-017","role":"toolResult","generation":null,"timestamp":1791620261774,"responseId":null,"relativeMs":16329864,"durationMs":null,"toolName":"tool_04","toolCallId":"call_0039","tokens":null,"model":null,"provider":null,"api":null,"stopReason":null,"isError":true,"raw":{"role":"toolResult","toolCallId":"call_0039","toolName":"tool_04","content":[{"type":"text","text":"fixture text-009o placeholder"}],"details":{},"isError":true,"timestamp":1791620261774},"rawOmitted":false,"textTruncated":false,"index":67,"text":null,"thinking":null,"arguments":null,"result":"fixture text-009o placeholder","error":"fixture text-009o placeholder","tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"toolResult","title":"tool_04","summary":"fixture text-009o placeholder"},{"id":"msg-009p","turnId":"turn-017","role":"toolResult","generation":null,"timestamp":1791620468950,"responseId":null,"relativeMs":16537040,"durationMs":null,"toolName":"tool_10","toolCallId":"call_0040","tokens":null,"model":null,"provider":null,"api":null,"stopReason":null,"isError":false,"raw":{"role":"toolResult","toolCallId":"call_0040","toolName":"tool_10","content":[{"type":"text","text":"fixture text-009q placeholder"}],"details":{"kind":"memory","ok":true,"target":"fixture text-009r placeholder"},"isError":false,"timestamp":1791620468950},"rawOmitted":false,"textTruncated":false,"index":68,"text":null,"thinking":null,"arguments":null,"result":"fixture text-009q placeholder","error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"toolResult","title":"tool_10","summary":"fixture text-009q placeholder"}]},{"id":"turn-018","index":18,"startedAt":1791620759811,"endedAt":1791621281924,"durationMs":522113,"toolCalls":1,"errors":0,"tokens":{"input":1473,"output":346,"cacheRead":255104,"cacheWrite":0,"totalTokens":256923},"turnClass":"none","askedReader":false,"closed":false,"records":[{"id":"msg-009s","turnId":"turn-018","role":"toolResult","generation":null,"timestamp":1791620759811,"responseId":null,"relativeMs":16827901,"durationMs":null,"toolName":"tool_08","toolCallId":"call_0041","tokens":null,"model":null,"provider":null,"api":null,"stopReason":null,"isError":false,"raw":{"role":"toolResult","toolCallId":"call_0041","toolName":"tool_08","content":[{"type":"text","text":"fixture text-009t placeholder"}],"details":{"diff":"fixture text-009u placeholder","patch":"fixture text-009v placeholder","firstChangedLine":1545},"isError":false,"timestamp":1791620759811},"rawOmitted":false,"textTruncated":false,"index":69,"text":null,"thinking":null,"arguments":null,"result":"fixture text-009t placeholder","error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"toolResult","title":"tool_08","summary":"fixture text-009t placeholder"},{"id":"msg-009w","turnId":"turn-018","role":"assistant","generation":null,"timestamp":1791621014224,"responseId":"fixture text-00a2 placeholder","relativeMs":17082314,"durationMs":null,"toolName":"tool_03","toolCallId":"call_0042","tokens":{"input":1473,"output":346,"cacheRead":255104,"cacheWrite":0,"totalTokens":256923},"model":"fixture text-00a1 placeholder","provider":"fixture text-00a0 placeholder","api":"fixture text-009z placeholder","stopReason":"toolUse","isError":null,"raw":{"role":"assistant","content":[{"type":"toolCall","id":"call_0042","name":"tool_03","arguments":{"command":"fixture text-009x placeholder","description":"fixture text-009y placeholder","timeout":120}}],"api":"fixture text-009z placeholder","provider":"fixture text-00a0 placeholder","model":"fixture text-00a1 placeholder","usage":{"input":1473,"output":346,"cacheRead":255104,"cacheWrite":0,"totalTokens":256923,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791621014224,"responseId":"fixture text-00a2 placeholder"},"rawOmitted":false,"textTruncated":false,"index":70,"text":null,"thinking":null,"arguments":{"command":"fixture text-009x placeholder","description":"fixture text-009y placeholder","timeout":120},"result":null,"error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"toolCall","title":"tool_03","summary":"tool_03{command=\"fixture text-009x placeholder\", description=\"fixture text-009y placeholder\", timeout=\"120\"}","argumentsOmitted":false},{"id":"msg-00a3","turnId":"turn-018","role":"toolResult","generation":null,"timestamp":1791621281924,"responseId":null,"relativeMs":17350014,"durationMs":null,"toolName":"tool_03","toolCallId":"call_0043","tokens":null,"model":null,"provider":null,"api":null,"stopReason":null,"isError":false,"raw":{"role":"toolResult","toolCallId":"call_0043","toolName":"tool_03","content":[{"type":"text","text":"fixture text-00a4 placeholder"}],"details":{"execution":{"status":"fixture text-00a5 placeholder","reason":"fixture text-00a6 placeholder","exitCode":0},"timing":{"commandTimeoutSeconds":180,"commandTimerStartedAt":1791621281302,"commandDeadlineAt":1791621461302},"output":{"rawBytes":29,"persistence":"fixture text-00a7 placeholder","omittedBytes":0},"processOutput":{"stdout":"fixture text-00a8 placeholder","stderr":"fixture text-00a9 placeholder","exitCode":0,"interrupted":false,"stdoutTruncated":false,"stderrTruncated":false,"rawOutputPath":"fixture text-00aa placeholder"},"description":"fixture text-00ab placeholder","fullOutputPath":"fixture text-00ac placeholder","status":"fixture text-00ad placeholder","task_id":"fixture text-00ae placeholder"},"isError":false,"timestamp":1791621281924},"rawOmitted":false,"textTruncated":false,"index":71,"text":null,"thinking":null,"arguments":null,"result":"fixture text-00a4 placeholder","error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"toolResult","title":"tool_03","summary":"fixture text-00a4 placeholder"}]},{"id":"turn-019","index":19,"startedAt":1791621759959,"endedAt":1791622044235,"durationMs":284276,"toolCalls":1,"errors":0,"tokens":{"input":2297,"output":1329,"cacheRead":277632,"cacheWrite":0,"totalTokens":281258},"turnClass":"none","askedReader":false,"closed":false,"records":[{"id":"msg-00af","turnId":"turn-019","role":"assistant","generation":null,"timestamp":1791621759959,"responseId":"fixture text-00an placeholder","relativeMs":17828049,"durationMs":null,"toolName":null,"toolCallId":null,"tokens":{"input":2297,"output":1329,"cacheRead":277632,"cacheWrite":0,"totalTokens":281258},"model":"fixture text-00am placeholder","provider":"fixture text-00al placeholder","api":"fixture text-00ak placeholder","stopReason":"toolUse","isError":null,"raw":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-00ag placeholder","thinkingSignature":"fixture text-00ah placeholder"},{"type":"toolCall","id":"call_0044","name":"tool_03","arguments":{"command":"fixture text-00ai placeholder","description":"fixture text-00aj placeholder","timeout":180}}],"api":"fixture text-00ak placeholder","provider":"fixture text-00al placeholder","model":"fixture text-00am placeholder","usage":{"input":2297,"output":1329,"cacheRead":277632,"cacheWrite":0,"totalTokens":281258,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791621759959,"responseId":"fixture text-00an placeholder"},"rawOmitted":false,"textTruncated":false,"index":72,"text":null,"thinking":"fixture text-00ag placeholder","arguments":null,"result":null,"error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"thinking","title":"thinking","summary":"fixture text-00ag placeholder"},{"id":"msg-00af","turnId":"turn-019","role":"assistant","generation":null,"timestamp":1791621759959,"responseId":"fixture text-00an placeholder","relativeMs":17828049,"durationMs":null,"toolName":"tool_03","toolCallId":"call_0044","model":"fixture text-00am placeholder","provider":"fixture text-00al placeholder","api":"fixture text-00ak placeholder","stopReason":"toolUse","isError":null,"raw":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-00ag placeholder","thinkingSignature":"fixture text-00ah placeholder"},{"type":"toolCall","id":"call_0044","name":"tool_03","arguments":{"command":"fixture text-00ai placeholder","description":"fixture text-00aj placeholder","timeout":180}}],"api":"fixture text-00ak placeholder","provider":"fixture text-00al placeholder","model":"fixture text-00am placeholder","usage":{"input":2297,"output":1329,"cacheRead":277632,"cacheWrite":0,"totalTokens":281258,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791621759959,"responseId":"fixture text-00an placeholder"},"rawOmitted":false,"textTruncated":false,"index":73,"text":null,"thinking":null,"arguments":{"command":"fixture text-00ai placeholder","description":"fixture text-00aj placeholder","timeout":180},"result":null,"error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"toolCall","title":"tool_03","summary":"tool_03{command=\"fixture text-00ai placeholder\", description=\"fixture text-00aj placeholder\", timeout=\"180\"}","argumentsOmitted":false},{"id":"msg-00ao","turnId":"turn-019","role":"toolResult","generation":null,"timestamp":1791622044235,"responseId":null,"relativeMs":18112325,"durationMs":null,"toolName":"tool_04","toolCallId":"call_0045","tokens":null,"model":null,"provider":null,"api":null,"stopReason":null,"isError":false,"raw":{"role":"toolResult","toolCallId":"call_0045","toolName":"tool_04","content":[{"type":"text","text":"fixture text-00ap placeholder"}],"details":{"action":"fixture text-00aq placeholder","result":{"success":true,"duration":5000}},"isError":false,"timestamp":1791622044235},"rawOmitted":false,"textTruncated":false,"index":74,"text":null,"thinking":null,"arguments":null,"result":"fixture text-00ap placeholder","error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"toolResult","title":"tool_04","summary":"fixture text-00ap placeholder"}]},{"id":"turn-020","index":20,"startedAt":1791622638009,"endedAt":1791622638009,"durationMs":0,"toolCalls":1,"errors":0,"tokens":{"input":11033,"output":69,"cacheRead":299264,"cacheWrite":0,"totalTokens":310366},"turnClass":"none","askedReader":false,"closed":false,"records":[{"id":"msg-00ar","turnId":"turn-020","role":"assistant","generation":null,"timestamp":1791622638009,"responseId":"fixture text-00ay placeholder","relativeMs":18706099,"durationMs":null,"toolName":"tool_11","toolCallId":"call_0046","tokens":{"input":11033,"output":69,"cacheRead":299264,"cacheWrite":0,"totalTokens":310366},"model":"fixture text-00ax placeholder","provider":"fixture text-00aw placeholder","api":"fixture text-00av placeholder","stopReason":"toolUse","isError":null,"raw":{"role":"assistant","content":[{"type":"toolCall","id":"call_0046","name":"tool_11","arguments":{"action":"fixture text-00as placeholder","pluginId":"fixture text-00at placeholder","sourcePath":"fixture text-00au placeholder"}}],"api":"fixture text-00av placeholder","provider":"fixture text-00aw placeholder","model":"fixture text-00ax placeholder","usage":{"input":11033,"output":69,"cacheRead":299264,"cacheWrite":0,"totalTokens":310366,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791622638009,"responseId":"fixture text-00ay placeholder"},"rawOmitted":false,"textTruncated":false,"index":75,"text":null,"thinking":null,"arguments":{"action":"fixture text-00as placeholder","pluginId":"fixture text-00at placeholder","sourcePath":"fixture text-00au placeholder"},"result":null,"error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"toolCall","title":"tool_11","summary":"tool_11{action=\"fixture text-00as placeholder\", pluginId=\"fixture text-00at placeholder\", sourcePath=\"fixture text-00au placeholder\"}","argumentsOmitted":false}]},{"id":"turn-021","index":21,"startedAt":1791623384388,"endedAt":1791623384388,"durationMs":0,"toolCalls":1,"errors":0,"tokens":{"input":175,"output":244,"cacheRead":319744,"cacheWrite":0,"totalTokens":320163},"turnClass":"none","askedReader":false,"closed":false,"records":[{"id":"msg-00az","turnId":"turn-021","role":"assistant","generation":null,"timestamp":1791623384388,"responseId":"fixture text-00b8 placeholder","relativeMs":19452478,"durationMs":null,"toolName":null,"toolCallId":null,"model":"fixture text-00b7 placeholder","provider":"fixture text-00b6 placeholder","api":"fixture text-00b5 placeholder","stopReason":"toolUse","isError":null,"raw":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-00b0 placeholder","thinkingSignature":"fixture text-00b1 placeholder"},{"type":"text","text":"fixture text-00b2 placeholder"},{"type":"toolCall","id":"call_0047","name":"tool_03","arguments":{"command":"fixture text-00b3 placeholder","description":"fixture text-00b4 placeholder","timeout":300}}],"api":"fixture text-00b5 placeholder","provider":"fixture text-00b6 placeholder","model":"fixture text-00b7 placeholder","usage":{"input":175,"output":244,"cacheRead":319744,"cacheWrite":0,"totalTokens":320163,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791623384388,"responseId":"fixture text-00b8 placeholder"},"rawOmitted":false,"textTruncated":false,"index":76,"text":null,"thinking":"fixture text-00b0 placeholder","arguments":null,"result":null,"error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"thinking","title":"thinking","summary":"fixture text-00b0 placeholder"},{"id":"msg-00az","turnId":"turn-021","role":"assistant","generation":null,"timestamp":1791623384388,"responseId":"fixture text-00b8 placeholder","relativeMs":19452478,"durationMs":null,"toolName":null,"toolCallId":null,"tokens":{"input":175,"output":244,"cacheRead":319744,"cacheWrite":0,"totalTokens":320163},"model":"fixture text-00b7 placeholder","provider":"fixture text-00b6 placeholder","api":"fixture text-00b5 placeholder","stopReason":"toolUse","isError":null,"raw":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-00b0 placeholder","thinkingSignature":"fixture text-00b1 placeholder"},{"type":"text","text":"fixture text-00b2 placeholder"},{"type":"toolCall","id":"call_0047","name":"tool_03","arguments":{"command":"fixture text-00b3 placeholder","description":"fixture text-00b4 placeholder","timeout":300}}],"api":"fixture text-00b5 placeholder","provider":"fixture text-00b6 placeholder","model":"fixture text-00b7 placeholder","usage":{"input":175,"output":244,"cacheRead":319744,"cacheWrite":0,"totalTokens":320163,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791623384388,"responseId":"fixture text-00b8 placeholder"},"rawOmitted":false,"textTruncated":false,"index":77,"text":"fixture text-00b2 placeholder","thinking":null,"arguments":null,"result":null,"error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"narration","title":"assistant","summary":"fixture text-00b2 placeholder"},{"id":"msg-00az","turnId":"turn-021","role":"assistant","generation":null,"timestamp":1791623384388,"responseId":"fixture text-00b8 placeholder","relativeMs":19452478,"durationMs":null,"toolName":"tool_03","toolCallId":"call_0047","model":"fixture text-00b7 placeholder","provider":"fixture text-00b6 placeholder","api":"fixture text-00b5 placeholder","stopReason":"toolUse","isError":null,"raw":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-00b0 placeholder","thinkingSignature":"fixture text-00b1 placeholder"},{"type":"text","text":"fixture text-00b2 placeholder"},{"type":"toolCall","id":"call_0047","name":"tool_03","arguments":{"command":"fixture text-00b3 placeholder","description":"fixture text-00b4 placeholder","timeout":300}}],"api":"fixture text-00b5 placeholder","provider":"fixture text-00b6 placeholder","model":"fixture text-00b7 placeholder","usage":{"input":175,"output":244,"cacheRead":319744,"cacheWrite":0,"totalTokens":320163,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791623384388,"responseId":"fixture text-00b8 placeholder"},"rawOmitted":false,"textTruncated":false,"index":78,"text":null,"thinking":null,"arguments":{"command":"fixture text-00b3 placeholder","description":"fixture text-00b4 placeholder","timeout":300},"result":null,"error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"toolCall","title":"tool_03","summary":"tool_03{command=\"fixture text-00b3 placeholder\", description=\"fixture text-00b4 placeholder\", timeout=\"300\"}","argumentsOmitted":false}]},{"id":"turn-022","index":22,"startedAt":1791624351892,"endedAt":1791625062330,"durationMs":710438,"toolCalls":3,"errors":0,"tokens":{"input":9613,"output":670,"cacheRead":334848,"cacheWrite":0,"totalTokens":345131},"turnClass":"none","askedReader":false,"closed":false,"records":[{"id":"msg-00b9","turnId":"turn-022","role":"assistant","generation":null,"timestamp":1791624351892,"responseId":"fixture text-00bi placeholder","relativeMs":20419982,"durationMs":null,"toolName":null,"toolCallId":null,"model":"fixture text-00bh placeholder","provider":"fixture text-00bg placeholder","api":"fixture text-00bf placeholder","stopReason":"toolUse","isError":null,"raw":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-00ba placeholder","thinkingSignature":"fixture text-00bb placeholder"},{"type":"text","text":"fixture text-00bc placeholder"},{"type":"toolCall","id":"call_0048","name":"tool_12","arguments":{"task_id":"fixture text-00bd placeholder","reason":"fixture text-00be placeholder"}}],"api":"fixture text-00bf placeholder","provider":"fixture text-00bg placeholder","model":"fixture text-00bh placeholder","usage":{"input":4906,"output":149,"cacheRead":56576,"cacheWrite":0,"totalTokens":61631,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791624351892,"responseId":"fixture text-00bi placeholder"},"rawOmitted":false,"textTruncated":false,"index":79,"text":null,"thinking":"fixture text-00ba placeholder","arguments":null,"result":null,"error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"thinking","title":"thinking","summary":"fixture text-00ba placeholder"},{"id":"msg-00b9","turnId":"turn-022","role":"assistant","generation":null,"timestamp":1791624351892,"responseId":"fixture text-00bi placeholder","relativeMs":20419982,"durationMs":null,"toolName":null,"toolCallId":null,"tokens":{"input":4906,"output":149,"cacheRead":56576,"cacheWrite":0,"totalTokens":61631},"model":"fixture text-00bh placeholder","provider":"fixture text-00bg placeholder","api":"fixture text-00bf placeholder","stopReason":"toolUse","isError":null,"raw":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-00ba placeholder","thinkingSignature":"fixture text-00bb placeholder"},{"type":"text","text":"fixture text-00bc placeholder"},{"type":"toolCall","id":"call_0048","name":"tool_12","arguments":{"task_id":"fixture text-00bd placeholder","reason":"fixture text-00be placeholder"}}],"api":"fixture text-00bf placeholder","provider":"fixture text-00bg placeholder","model":"fixture text-00bh placeholder","usage":{"input":4906,"output":149,"cacheRead":56576,"cacheWrite":0,"totalTokens":61631,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791624351892,"responseId":"fixture text-00bi placeholder"},"rawOmitted":false,"textTruncated":false,"index":80,"text":"fixture text-00bc placeholder","thinking":null,"arguments":null,"result":null,"error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"narration","title":"assistant","summary":"fixture text-00bc placeholder"},{"id":"msg-00b9","turnId":"turn-022","role":"assistant","generation":null,"timestamp":1791624351892,"responseId":"fixture text-00bi placeholder","relativeMs":20419982,"durationMs":null,"toolName":"tool_12","toolCallId":"call_0048","model":"fixture text-00bh placeholder","provider":"fixture text-00bg placeholder","api":"fixture text-00bf placeholder","stopReason":"toolUse","isError":null,"raw":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-00ba placeholder","thinkingSignature":"fixture text-00bb placeholder"},{"type":"text","text":"fixture text-00bc placeholder"},{"type":"toolCall","id":"call_0048","name":"tool_12","arguments":{"task_id":"fixture text-00bd placeholder","reason":"fixture text-00be placeholder"}}],"api":"fixture text-00bf placeholder","provider":"fixture text-00bg placeholder","model":"fixture text-00bh placeholder","usage":{"input":4906,"output":149,"cacheRead":56576,"cacheWrite":0,"totalTokens":61631,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791624351892,"responseId":"fixture text-00bi placeholder"},"rawOmitted":false,"textTruncated":false,"index":81,"text":null,"thinking":null,"arguments":{"task_id":"fixture text-00bd placeholder","reason":"fixture text-00be placeholder"},"result":null,"error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"toolCall","title":"tool_12","summary":"tool_12{task_id=\"fixture text-00bd placeholder\", reason=\"fixture text-00be placeholder\"}","argumentsOmitted":false},{"id":"msg-00bj","turnId":"turn-022","role":"assistant","generation":null,"timestamp":1791624527065,"responseId":"fixture text-00bq placeholder","relativeMs":20595155,"durationMs":null,"toolName":null,"toolCallId":null,"tokens":{"input":4023,"output":283,"cacheRead":98560,"cacheWrite":0,"totalTokens":102866},"model":"fixture text-00bp placeholder","provider":"fixture text-00bo placeholder","api":"fixture text-00bn placeholder","stopReason":"toolUse","isError":null,"raw":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-00bk placeholder","thinkingSignature":"fixture text-00bl placeholder"},{"type":"toolCall","id":"call_0049","name":"tool_02","arguments":{"task_id":"fixture text-00bm placeholder","wait_ms":30000}}],"api":"fixture text-00bn placeholder","provider":"fixture text-00bo placeholder","model":"fixture text-00bp placeholder","usage":{"input":4023,"output":283,"cacheRead":98560,"cacheWrite":0,"totalTokens":102866,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791624527065,"responseId":"fixture text-00bq placeholder"},"rawOmitted":false,"textTruncated":false,"index":82,"text":null,"thinking":"fixture text-00bk placeholder","arguments":null,"result":null,"error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"thinking","title":"thinking","summary":"fixture text-00bk placeholder"},{"id":"msg-00bj","turnId":"turn-022","role":"assistant","generation":null,"timestamp":1791624527065,"responseId":"fixture text-00bq placeholder","relativeMs":20595155,"durationMs":null,"toolName":"tool_02","toolCallId":"call_0049","model":"fixture text-00bp placeholder","provider":"fixture text-00bo placeholder","api":"fixture text-00bn placeholder","stopReason":"toolUse","isError":null,"raw":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-00bk placeholder","thinkingSignature":"fixture text-00bl placeholder"},{"type":"toolCall","id":"call_0049","name":"tool_02","arguments":{"task_id":"fixture text-00bm placeholder","wait_ms":30000}}],"api":"fixture text-00bn placeholder","provider":"fixture text-00bo placeholder","model":"fixture text-00bp placeholder","usage":{"input":4023,"output":283,"cacheRead":98560,"cacheWrite":0,"totalTokens":102866,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791624527065,"responseId":"fixture text-00bq placeholder"},"rawOmitted":false,"textTruncated":false,"index":83,"text":null,"thinking":null,"arguments":{"task_id":"fixture text-00bm placeholder","wait_ms":30000},"result":null,"error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"toolCall","title":"tool_02","summary":"tool_02{task_id=\"fixture text-00bm placeholder\", wait_ms=\"30000\"}","argumentsOmitted":false},{"id":"msg-00br","turnId":"turn-022","role":"user","generation":null,"timestamp":1791624769221,"responseId":null,"relativeMs":20837311,"durationMs":null,"toolName":null,"toolCallId":null,"tokens":null,"model":null,"provider":null,"api":null,"stopReason":null,"isError":null,"raw":{"role":"user","content":[{"type":"text","text":"<background-task-finished>\nfixture injected-00bs block"}],"timestamp":1791624769221,"canonicalTextRange":{"startOffset":496,"endOffset":496},"hostMetadata":{"backgroundTaskOrigin":{"kind":"background-task-terminal","taskIds":["fixture text-00bt placeholder"],"observedTerminalCount":330}}},"rawOmitted":false,"textTruncated":false,"index":84,"text":"<background-task-finished>\nfixture injected-00bs block","thinking":null,"arguments":null,"result":null,"error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"system","title":"injected","summary":"<background-task-finished> fixture injected-00bs block"},{"id":"msg-00bu","turnId":"turn-022","role":"toolResult","generation":null,"timestamp":1791624899122,"responseId":null,"relativeMs":20967212,"durationMs":null,"toolName":"tool_08","toolCallId":"call_0050","tokens":null,"model":null,"provider":null,"api":null,"stopReason":null,"isError":false,"raw":{"role":"toolResult","toolCallId":"call_0050","toolName":"tool_08","content":[{"type":"text","text":"fixture text-00bv placeholder"}],"details":{"diff":"fixture text-00bw placeholder","patch":"fixture text-00bx placeholder","firstChangedLine":1987},"isError":false,"timestamp":1791624899122},"rawOmitted":false,"textTruncated":false,"index":85,"text":null,"thinking":null,"arguments":null,"result":"fixture text-00bv placeholder","error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"toolResult","title":"tool_08","summary":"fixture text-00bv placeholder"},{"id":"msg-00by","turnId":"turn-022","role":"assistant","generation":null,"timestamp":1791625062330,"responseId":"fixture text-00c6 placeholder","relativeMs":21130420,"durationMs":null,"toolName":null,"toolCallId":null,"tokens":{"input":684,"output":238,"cacheRead":179712,"cacheWrite":0,"totalTokens":180634},"model":"fixture text-00c5 placeholder","provider":"fixture text-00c4 placeholder","api":"fixture text-00c3 placeholder","stopReason":"toolUse","isError":null,"raw":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-00bz placeholder","thinkingSignature":"fixture text-00c0 placeholder"},{"type":"toolCall","id":"call_0051","name":"tool_03","arguments":{"command":"fixture text-00c1 placeholder","description":"fixture text-00c2 placeholder"}}],"api":"fixture text-00c3 placeholder","provider":"fixture text-00c4 placeholder","model":"fixture text-00c5 placeholder","usage":{"input":684,"output":238,"cacheRead":179712,"cacheWrite":0,"totalTokens":180634,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791625062330,"responseId":"fixture text-00c6 placeholder"},"rawOmitted":false,"textTruncated":false,"index":86,"text":null,"thinking":"fixture text-00bz placeholder","arguments":null,"result":null,"error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"thinking","title":"thinking","summary":"fixture text-00bz placeholder"},{"id":"msg-00by","turnId":"turn-022","role":"assistant","generation":null,"timestamp":1791625062330,"responseId":"fixture text-00c6 placeholder","relativeMs":21130420,"durationMs":null,"toolName":"tool_03","toolCallId":"call_0051","model":"fixture text-00c5 placeholder","provider":"fixture text-00c4 placeholder","api":"fixture text-00c3 placeholder","stopReason":"toolUse","isError":null,"raw":{"role":"assistant","content":[{"type":"thinking","thinking":"fixture text-00bz placeholder","thinkingSignature":"fixture text-00c0 placeholder"},{"type":"toolCall","id":"call_0051","name":"tool_03","arguments":{"command":"fixture text-00c1 placeholder","description":"fixture text-00c2 placeholder"}}],"api":"fixture text-00c3 placeholder","provider":"fixture text-00c4 placeholder","model":"fixture text-00c5 placeholder","usage":{"input":684,"output":238,"cacheRead":179712,"cacheWrite":0,"totalTokens":180634,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1791625062330,"responseId":"fixture text-00c6 placeholder"},"rawOmitted":false,"textTruncated":false,"index":87,"text":null,"thinking":null,"arguments":{"command":"fixture text-00c1 placeholder","description":"fixture text-00c2 placeholder"},"result":null,"error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"toolCall","title":"tool_03","summary":"tool_03{command=\"fixture text-00c1 placeholder\", description=\"fixture text-00c2 placeholder\"}","argumentsOmitted":false}]},{"id":"turn-023","index":23,"startedAt":1791627571957,"endedAt":1791627571957,"durationMs":0,"toolCalls":0,"errors":0,"tokens":{"input":1188,"output":82,"cacheRead":267008,"cacheWrite":0,"totalTokens":268278},"turnClass":"continuation","askedReader":false,"closed":true,"records":[{"id":"msg-00c7","turnId":"turn-023","role":"assistant","generation":null,"timestamp":1791627571957,"responseId":"fixture text-00cb placeholder","relativeMs":23640047,"durationMs":null,"toolName":null,"toolCallId":null,"tokens":{"input":1188,"output":82,"cacheRead":267008,"cacheWrite":0,"totalTokens":268278},"model":"fixture text-00ca placeholder","provider":"fixture text-00c9 placeholder","api":"fixture text-00c8 placeholder","stopReason":"stop","isError":null,"raw":{"role":"assistant","content":[],"api":"fixture text-00c8 placeholder","provider":"fixture text-00c9 placeholder","model":"fixture text-00ca placeholder","usage":{"input":1188,"output":82,"cacheRead":267008,"cacheWrite":0,"totalTokens":268278,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"stop","timestamp":1791627571957,"responseId":"fixture text-00cb placeholder"},"rawOmitted":false,"textTruncated":false,"index":88,"text":null,"thinking":null,"arguments":null,"result":null,"error":null,"tokensBefore":null,"producedBy":null,"parentGeneration":null,"parentCompactionId":null,"parentRevision":null,"kind":"reply","title":"assistant","summary":""}]}]}
\ No newline at end of file
diff --git a/plugins/avatasia/mmc-trajectory/tests/make-fixtures.mjs b/plugins/avatasia/mmc-trajectory/tests/make-fixtures.mjs
new file mode 100644
index 0000000..e7bccac
--- /dev/null
+++ b/plugins/avatasia/mmc-trajectory/tests/make-fixtures.mjs
@@ -0,0 +1,297 @@
+// Distil the developer's real ~/.minimax session store into a synthetic fixture tree.
+//
+//   node tests/make-fixtures.mjs            report what would be distilled, write nothing
+//   node tests/make-fixtures.mjs --record   write tests/fixtures/minimax-home/
+//
+// The guards must not depend on whoever runs them: a clean CI runner has no ~/.minimax, and
+// the two guards that read the real store went red there (13/15). So the store is distilled
+// here once, the payload text is replaced, and the structure is committed.
+//
+// What is preserved is exactly what the assertions look at: roles, content-part types,
+// stopReason (the reply/narration split turns on it), toolCallId pairing, usage numbers,
+// numeric ranges, and the injection markers splitUserMessage keys off. What is replaced is
+// every string payload. No conversation text, path, or identifier from the real machine
+// reaches the fixture.
+import { mkdir, readFile, rm, utimes, writeFile } from 'node:fs/promises';
+import { join, relative } from 'node:path';
+import * as server from '../miniapp/node/server.mjs';
+
+const { resolveSessionsRoot, collectSessionEntries, readHead, resolveArtifactPath } = server;
+
+const HERE = new URL('.', import.meta.url).pathname.replace(/^\/([A-Za-z]:)/, '$1');
+const OUT_ROOT = join(HERE, 'fixtures', 'minimax-home');
+const SESSIONS_WANTED = 8;
+const ROWS_PER_SESSION = 60;
+const SCAN_BYTES = 8 * 1024 * 1024;
+const SCAN_ROWS = 6000;
+
+// Strings that are structural, not payload: dropping them would change what the parser sees.
+const KEEP_KEYS = new Set(['type', 'role', 'stopReason', 'finishReason', 'subtype', 'kind', 'sender']);
+
+// Prefixes splitUserMessage() branches on. Losing one would silently stop exercising that branch.
+const INJECT_PREFIXES = [
+  '<system-reminder>', '<background-task-finished>', '<runaway guard>',
+  '<agent-context>', '<async-audit>', '<media-output-reminder>',
+];
+
+// Coverage the committed guards require. --record refuses to write unless all of it is present,
+// otherwise the fixture would pass CI by accident and fail the moment someone looked.
+const NEEDED = {
+  userPrompt: (r) => r.role === 'user' && !INJECT_PREFIXES.some((p) => String(r.text || '').startsWith(p)),
+  injected: (r) => r.role === 'user' && INJECT_PREFIXES.some((p) => String(r.text || '').startsWith(p)),
+  toolCall: (r) => r.role === 'assistant' && r.parts.includes('toolCall'),
+  thinking: (r) => r.role === 'assistant' && r.parts.includes('thinking'),
+  reply: (r) => r.role === 'assistant' && r.stopReason === 'stop' && r.text,
+  narration: (r) => r.role === 'assistant' && r.stopReason === 'toolUse' && r.text,
+  toolResult: (r) => r.role === 'toolResult' || r.role === 'tool',
+  compaction: (r) => r.role === 'compactionSummary' || r.role === 'compaction',
+  // verify-anomaly.mjs asserts the anomaly rules against this payload, which is only meaningful
+  // if there is something to find: a reply that delivered nothing, and a tool result that
+  // failed. A sample without them makes the guard vacuous.
+  // `silent` has to be an assistant message that produced no segment at all -- server.mjs:1094
+  // only pushes a text:null reply when segmentOrder is empty. An assistant message that called
+  // a tool but said nothing still emits its toolCall record, so it is not a silent reply.
+  silent: (r) => r.role === 'assistant' && r.stopReason === 'stop' && !r.text && r.parts.length === 0,
+  toolError: (r) => (r.role === 'toolResult' || r.role === 'tool') && r.isError === true,
+};
+
+let seq = 0;
+const sid = (tag) => `${tag}${(seq++).toString(36).padStart(4, '0')}`;
+
+// A toolCall's id and its toolResult's toolCallId must stay equal: verify-parsers asserts the
+// corpus pairs up and that the pair counts agree. Regenerating each occurrence independently
+// silently breaks the pairing, so ids are memoised per original value.
+const ID_KEYS = new Set(['id', 'toolCallId', 'parentToolCallId']);
+const idMap = new Map();
+const toolMap = new Map();
+
+function synthString(value, key) {
+  if (KEEP_KEYS.has(key)) return value;
+  const raw = String(value);
+  const prefix = INJECT_PREFIXES.find((p) => raw.startsWith(p));
+  if (prefix) return `${prefix}\nfixture ${sid('injected-')} block`;
+  if (ID_KEYS.has(key) && raw) {
+    if (!idMap.has(raw)) idMap.set(raw, `call_${String(idMap.size).padStart(4, '0')}`);
+    return idMap.get(raw);
+  }
+  // Tool names are structural -- nothing in the payload branches on them, but the parser
+  // keys records by them, and a result must name the same tool as its call.
+  if ((key === 'name' || key === 'toolName') && /^[A-Za-z_][A-Za-z0-9_.-]{0,40}$/.test(raw)) {
+    if (!toolMap.has(raw)) toolMap.set(raw, `tool_${String(toolMap.size).padStart(2, '0')}`);
+    return toolMap.get(raw);
+  }
+  return `fixture ${sid('text-')} placeholder`;
+}
+
+// Nothing that identifies this machine may reach the committed fixture. Checked on the
+// rendered bytes, not on the synthesised objects, because the leak path runs through
+// arguments and summaries as easily as through text.
+const LEAKS = [/[A-Za-z]:[\\/]/, /\/Users\//, /\bava\b/, /\.minimax/i, /homedir/i];
+
+function assertNoLeaks(text, where) {
+  for (const re of LEAKS) {
+    const at = text.match(re);
+    if (at) {
+      const from = Math.max(0, at.index - 60);
+      throw new Error(`fixture leak ${re} in ${where}: ${JSON.stringify(text.slice(from, at.index + 90))}`);
+    }
+  }
+}
+
+function synth(value, key = '') {
+  if (typeof value === 'string') return synthString(value, key);
+  if (Array.isArray(value)) return value.map((v) => synth(v, key));
+  if (value && typeof value === 'object') {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) out[k] = synth(v, k);
+    return out;
+  }
+  return value;                       // numbers and booleans are structure, not payload
+}
+
+// A privacy gate that cannot fail is worse than no gate: it would be trusted.
+if (process.argv.includes('--selftest')) {
+  const dirty = [
+    ['windows path', 'see C:\\Users\\ava\\notes.md'],
+    ['posix path', 'see /Users/ava/notes.md'],
+    ['user name', 'owner ava rebuilt it'],
+    ['store path', 'root is .minimax here'],
+    ['homedir call', 'resolved via homedir()'],
+  ];
+  let ok = true;
+  for (const [label, text] of dirty) {
+    try { assertNoLeaks(text, label); console.log(`  MISSED  ${label}`); ok = false; }
+    catch { console.log(`  caught  ${label}`); }
+  }
+  try { assertNoLeaks('fixture text-0001 placeholder', 'control'); console.log('  ok      clean control passes'); }
+  catch { console.log('  MISSED  clean control wrongly rejected'); ok = false; }
+  console.log(ok ? '\nself-test passed' : '\nself-test FAILED');
+  process.exit(ok ? 0 : 1);
+}
+
+function classify(message) {
+  const parts = Array.isArray(message.content) ? message.content : [];
+  const text = parts.filter((p) => p.type === 'text').map((p) => p.text).join('');
+  return {
+    role: message.role,
+    parts: parts.map((p) => p.type),
+    stopReason: message.stopReason,
+    isError: message.isError === true,
+    text,
+  };
+}
+
+const record = process.argv.includes('--record');
+const location = resolveSessionsRoot();
+const entries = await collectSessionEntries(location.sessionsRoot);
+if (!entries.length) {
+  console.error(`no sessions under ${location.sessionsRoot} -- nothing to distil`);
+  process.exit(2);
+}
+
+// A compacted session does not keep its old messages in messages.jsonl: the runtime rotates
+// them into g<gen>--ctx_*.jsonl and records the lineage in history-catalog.json. The shapes the
+// guards need -- an empty reply above all -- live in those older generations, so scanning the
+// active file alone finds none of them.
+async function lineageFiles(dir) {
+  let artifacts = [];
+  try {
+    const cat = JSON.parse(await readFile(join(dir, 'history-catalog.json'), 'utf8'));
+    if (Array.isArray(cat.artifacts)) artifacts = [...cat.artifacts].sort((a, b) => a.generation - b.generation);
+  } catch { /* never compacted: the active file is the whole session */ }
+  // Snapshots live in a `snapshots/` subdirectory and the active file at the root; that split is
+  // the service's own rule, so reuse resolveArtifactPath rather than restating it.
+  const files = artifacts.map((a) => resolveArtifactPath(dir, { ...a, active: a.kind === 'active' })).filter(Boolean);
+  if (!files.length) files.push(join(dir, 'messages.jsonl'));
+  return files;
+}
+
+const picked = entries;
+const fixtureSessions = [];
+const seen = new Set();
+
+const parseLine = (line) => {
+  if (!line.trim()) return null;
+  let parsed;
+  try { parsed = JSON.parse(line); } catch { return null; }
+  const message = parsed && typeof parsed === 'object' ? (parsed.message ?? parsed) : null;
+  if (!message || typeof message !== 'object' || typeof message.role !== 'string') return null;
+  return { turn_id: parsed.turn_id, message, shape: classify(message) };
+};
+
+for (const entry of picked) {
+  // Keep walking until the quota is met: the newest entries include sessions too short to
+  // distil, and verify-parsers asserts `entries.length > 5`, so a short run would sit exactly
+  // on the boundary.
+  if (fixtureSessions.length >= SESSIONS_WANTED) break;
+  const files = await lineageFiles(entry.dir);
+
+  // Two passes over the lineage. The first only locates the first row of each required shape
+  // and counts rows per file; the second keeps the selected rows. Holding every parsed row of a
+  // compacted 80 MB session would cost far more than that.
+  const counts = [];
+  const firstAt = new Map();
+  let total = 0;
+  outer:
+  for (const file of files) {
+    const head = await readHead(file, Number.MAX_SAFE_INTEGER);
+    let n = 0;
+    for (const line of head.text.split('\n')) {
+      const row = parseLine(line);
+      if (!row) continue;
+      for (const [name, test] of Object.entries(NEEDED)) if (!firstAt.has(name) && test(row.shape)) firstAt.set(name, total);
+      n += 1; total += 1;
+    }
+    counts.push(n);
+    if (firstAt.size === Object.keys(NEEDED).length) break outer;
+  }
+  if (total < 12) continue;
+
+  const chosen = new Set(firstAt.values());
+  const stride = Math.max(1, Math.floor(total / ROWS_PER_SESSION));
+  for (let i = 0; i < total && chosen.size < ROWS_PER_SESSION; i += stride) chosen.add(i);
+
+  const pickedRows = [];
+  let base = 0;
+  for (let f = 0; f < files.length && pickedRows.length < ROWS_PER_SESSION; f += 1) {
+    const head = await readHead(files[f], Number.MAX_SAFE_INTEGER);
+    let at = base;
+    for (const line of head.text.split('\n')) {
+      const row = parseLine(line);
+      if (!row) continue;
+      if (chosen.has(at)) pickedRows.push(row);
+      at += 1;
+      if (pickedRows.length >= ROWS_PER_SESSION) break;
+    }
+    base += counts[f];
+  }
+
+  const turnSeq = new Map();
+  let rows = pickedRows.map((r) => {
+    const key = typeof r.turn_id === 'string' && r.turn_id ? r.turn_id : `turn-${r.shape.role}`;
+    if (!turnSeq.has(key)) turnSeq.set(key, `turn-${String(turnSeq.size + 1).padStart(3, '0')}`);
+    for (const [name, test] of Object.entries(NEEDED)) if (!seen.has(name) && test(r.shape)) seen.add(name);
+    return { message_id: sid('msg-'), turn_id: turnSeq.get(key), message: synth(r.message), __shape: r.shape };
+  });
+
+  // A live session's last turn is the one still running, so it has no answer yet. The anomaly
+  // guard's live-turn exclusion only means anything if the fixture has such a turn: if the last
+  // turn were closed, mutating liveTurn to return null would change no count and the mutation
+  // would survive. The distilled session therefore ends on an open turn, like the real one.
+  const answers = (r) => r.__shape.role === 'assistant' && r.__shape.stopReason === 'stop' && r.__shape.text;
+  for (;;) {
+    const lastTurn = rows.length ? rows[rows.length - 1].turn_id : null;
+    if (!lastTurn || !rows.some((r) => r.turn_id === lastTurn && answers(r))) break;
+    const trimmed = rows.filter((r) => r.turn_id !== lastTurn);
+    if (trimmed.length < 12) break;          // a session this short is not worth reshaping
+    rows = trimmed;
+  }
+
+  console.log(`  ${entry.dir.split(/[\\/]/).pop().slice(0, 28)}  files=${files.length}  rows=${total}  kept=${rows.length}`);
+  fixtureSessions.push({ dir: entry.dir, rows });
+}
+
+console.log(`sessions on disk : ${entries.length}`);
+console.log(`distilling       : ${fixtureSessions.length}`);
+console.log(`rows per session : ${ROWS_PER_SESSION} (cap)`);
+console.log(`coverage needed  : ${Object.keys(NEEDED).join(', ')}`);
+console.log(`coverage present : ${[...seen].join(', ')}`);
+const absent = Object.keys(NEEDED).filter((k) => !seen.has(k));
+if (absent.length) {
+  console.error(`\nMISSING coverage : ${absent.join(', ')}`);
+  console.error('raise SESSIONS_WANTED or ROWS_PER_SESSION and re-run');
+  process.exit(1);
+}
+
+let bytes = 0;
+const planned = [];
+fixtureSessions.forEach((session, i) => {
+  const name = `00-00-0${i}-000-session_fixture${String(i).padStart(2, '0')}`;
+  const dir = join(OUT_ROOT, 'v2', 'sessions', 'fixture-agent', name);
+  const body = session.rows.map((r) => JSON.stringify({ message_id: r.message_id, turn_id: r.turn_id, message: r.message })).join('\n') + '\n';
+  const manifest = JSON.stringify({
+    sessionId: `mvs_${'0'.repeat(24)}${(i + 1).toString(16).padStart(8, '0')}`,
+    createdAtMs: 1750000000000 + i * 1000,
+  }, null, 2);
+  assertNoLeaks(body, name);
+  assertNoLeaks(manifest, name);
+  bytes += Buffer.byteLength(body, 'utf8') + Buffer.byteLength(manifest, 'utf8');
+  planned.push({ dir, body, manifest, order: i });
+});
+
+console.log(`\nfixture would be ${planned.length} sessions, ${(bytes / 1024).toFixed(0)} KB at ${relative(process.cwd(), OUT_ROOT)}`);
+if (!record) {
+  console.log('\n(dry run -- pass --record to write)');
+  process.exit(0);
+}
+
+await rm(OUT_ROOT, { recursive: true, force: true });
+for (const s of planned) {
+  await mkdir(s.dir, { recursive: true });
+  await writeFile(join(s.dir, 'messages.jsonl'), s.body, 'utf8');
+  await writeFile(join(s.dir, 'manifest.json'), s.manifest, 'utf8');
+  // deterministic ordering: collectSessionEntries sorts by mtimeMs descending
+  const when = new Date(1750000000000 + (planned.length - s.order) * 60000);
+  await utimes(join(s.dir, 'messages.jsonl'), when, when);
+}
+console.log(`\nwritten: ${OUT_ROOT}`);
diff --git a/plugins/avatasia/mmc-trajectory/tests/make-payload.mjs b/plugins/avatasia/mmc-trajectory/tests/make-payload.mjs
new file mode 100644
index 0000000..6774d1a
--- /dev/null
+++ b/plugins/avatasia/mmc-trajectory/tests/make-payload.mjs
@@ -0,0 +1,88 @@
+// Produce the `/api/trajectory` payload offline, from the committed fixture store.
+//
+//   node tests/make-payload.mjs            report, write nothing
+//   node tests/make-payload.mjs --record   rewrite fixtures/trajectory.json
+//   node tests/make-payload.mjs --check    fail if the committed payload is stale
+//
+// Five guards want one `/api/trajectory` body and used to get it by booting the service and
+// fetching from it, which meant a port, a listener, and a machine that had sessions. The route
+// at server.mjs:1925 is `buildTrajectoryPayload(...)` plus a handful of `session.*` fields, so
+// the same body falls out of the fixture store offline.
+import { readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import * as server from '../miniapp/node/server.mjs';
+
+const { resolveSessionsRoot, collectSessionEntries, readSessionIdentity, readHead,
+  parseMessagesJsonl, buildTrajectoryPayload, createRedactor } = server;
+
+const HERE = fileURLToPath(new URL('.', import.meta.url));
+const USE_REAL = process.argv.includes('--real');
+const FIXTURE_HOME = join(HERE, 'fixtures', 'minimax-home');
+const OUT = join(HERE, 'fixtures', 'trajectory.json');
+
+const location = USE_REAL ? resolveSessionsRoot() : resolveSessionsRoot({ MAVIS_HOME: FIXTURE_HOME });
+const entries = await collectSessionEntries(location.sessionsRoot);
+if (!entries.length) {
+  console.error(`no sessions under ${location.sessionsRoot} -- run make-fixtures.mjs --record first`);
+  process.exit(2);
+}
+
+// `?session=latest` resolves to the most recently touched store, which is how collectSessionEntries
+// already orders them.
+const entry = entries[0];
+const identity = await readSessionIdentity(entry.dir);
+const head = await readHead(join(entry.dir, 'messages.jsonl'), entry.sizeBytes);
+const parsed = parseMessagesJsonl(head.text);
+const redact = createRedactor([location.sessionsRoot, location.root]);
+
+const payload = buildTrajectoryPayload({
+  session: { id: identity.id, createdAtMs: entry.lastActiveAt },
+  rows: parsed.rows,
+  sizeBytes: head.size,
+  truncated: head.read < head.size,
+  redact,
+});
+// the fields the route sets after building; kept in step with server.mjs:1935-1952
+payload.session.lastActiveAt = entry.lastActiveAt;
+payload.session.activeGeneration = null;
+payload.session.stitched = false;
+payload.session.binding = 'fixture';
+payload.session.leased = false;
+
+// The fixture store is already synthetic, but this file gets committed: assert it, do not assume.
+// --real deliberately reports on real transcripts, which do contain paths, so it is not asserted.
+const text = JSON.stringify(payload);
+if (!USE_REAL) {
+  for (const re of [/[A-Za-z]:[\\/]/, /\/Users\//, /\bava\b/, /\.minimax/i]) {
+    const at = text.match(re);
+    if (at) {
+      console.error(`payload leak ${re}: ${JSON.stringify(text.slice(Math.max(0, at.index - 60), at.index + 80))}`);
+      process.exit(1);
+    }
+  }
+}
+
+const flat = payload.turns.flatMap((t) => t.records);
+console.log(`session   : ${payload.session.id}${USE_REAL ? '  (real store)' : ''}`);
+console.log(`turns     : ${payload.turns.length}  records: ${flat.length}  rows: ${parsed.rows.length} (${parsed.skipped} skipped)`);
+console.log(`kinds     : ${[...new Set(flat.map((r) => r.kind))].sort().join(', ')}`);
+console.log(`anomalies : toolError=${flat.filter((r) => r.isError === true).length}`
+  + `  compaction=${flat.filter((r) => r.kind === 'compaction').length}`
+  + `  openTurns=${payload.turns.filter((t) => t.closed === false).length}`
+  + `  silentReplies=${flat.filter((r) => r.kind === 'reply' && !r.text).length}`);
+console.log(`size      : ${(text.length / 1024).toFixed(0)} KB -> ${OUT}`);
+
+if (process.argv.includes('--check')) {
+  let current = null;
+  try { current = readFileSync(OUT, 'utf8'); } catch { /* missing */ }
+  if (current === text) { console.log('payload up to date'); process.exit(0); }
+  console.log(`payload OUT OF DATE (${current ? current.length : 0} -> ${text.length} chars)`);
+  process.exit(1);
+}
+if (!process.argv.includes('--record')) {
+  console.log('\n(dry run -- pass --record to write)');
+  process.exit(0);
+}
+writeFileSync(OUT, text, 'utf8');
+console.log('\nwritten');
diff --git a/plugins/avatasia/mmc-trajectory/tests/mutate-anchor-carry.py b/plugins/avatasia/mmc-trajectory/tests/mutate-anchor-carry.py
new file mode 100644
index 0000000..c89263e
--- /dev/null
+++ b/plugins/avatasia/mmc-trajectory/tests/mutate-anchor-carry.py
@@ -0,0 +1,119 @@
+"""Break the scroll-intent chain in the shipped client and require verify-anchor-carry.mjs to
+report each break by name.
+
+The defect this guards (docs/LAYERS.md D14) had two halves and both were invisible: the capture
+re-read the position every pass instead of carrying it, and the paths that end the ledger early
+never dropped the intent. Each mutation below reproduces one of them, or the shape a future edit
+would take that reintroduces it.
+
+Anchors are multi-line and index.html is LF, so they are written with bare \\n and the file is read
+and written with newline='' — matching on normalised text while preserving the file's own endings.
+"""
+import io
+import os
+import subprocess
+import sys
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+CLIENT = os.path.join(os.path.dirname(HERE), "miniapp", "client", "index.html")
+PROBE = os.path.join(HERE, "verify-anchor-carry.mjs")
+
+# Every anchor below is a statement the rule is *written on*, not a phrase in its comment: a
+# comment can be reworded without the rule changing, and an anchor that survives a reword is an
+# anchor that will report drift the next time the comment is edited for real.
+MUTATIONS = [
+    # The original defect. Capturing unconditionally puts every pass back where the defect was:
+    # reading a position the browser has already clamped to a document that no longer exists.
+    ("the intent is re-read on every pass",
+     [("        if (!pendingAnchor) {\n          pendingAnchor = { row: firstVisibleRow(), y: window.scrollY || window.pageYOffset || 0 };\n        }\n",
+       "        pendingAnchor = { row: firstVisibleRow(), y: window.scrollY || window.pageYOffset || 0 };\n")],
+     "a pass inside a chain re-uses the intent it was handed"),
+
+    # Half of the same break: the row is carried, the pixel offset is not. The fallback only runs
+    # when the anchor row is gone, so this is the rarer half — but it is the half that lands the
+    # reader on the clamped position, which is the top of the document.
+    ("the fallback offset is re-read instead of carried",
+     [("        var scrollY = pendingAnchor.y;\n",
+       "        var scrollY = window.scrollY || window.pageYOffset || 0;\n")],
+     "the live position is read in exactly one place"),
+
+    # The consuming half. Without it the intent stays armed, and the next chain starts by
+    # re-anchoring on a position that was already spent.
+    ("restoring does not consume the intent",
+     [("      function restoreRowAnchor(anchor, fallbackY) {\n        forgetScrollAnchor();\n",
+       "      function restoreRowAnchor(anchor, fallbackY) {\n")],
+     "restoring consumes the intent"),
+
+    # A second writer. forgetScrollAnchor() exists so that nulling it has one home; inlining the
+    # assignment is how the next edit ends up with two places to keep in agreement.
+    ("the intent is nulled inline as well",
+     [("      function restoreRowAnchor(anchor, fallbackY) {\n        forgetScrollAnchor();\n",
+       "      function restoreRowAnchor(anchor, fallbackY) {\n        pendingAnchor = null;\n")],
+     "restoring consumes the intent"),
+
+    # One of the five early returns stops dropping the intent. The ledger is left holding a block
+    # rather than rows, so carrying an anchor measured against the previous table into whatever
+    # comes next is applying a position to a different session or a different filter.
+    ("an early return keeps the intent it cannot honour",
+     [("          dom.ledgerMeta.textContent = '不可用';\n          forgetScrollAnchor();\n          return;\n",
+       "          dom.ledgerMeta.textContent = '不可用';\n          return;\n")],
+     "every early return after the clear drops the intent"),
+
+    # The other kind of half-measure: the helper grows a second job. Nulling it is the whole
+    # contract; a pass that also touches the reader's state would make the caller's intent
+    # unreadable from the call.
+    ("forgetScrollAnchor grows a second job",
+     [("      function forgetScrollAnchor() {\n        pendingAnchor = null;\n      }\n",
+       "      function forgetScrollAnchor() {\n        pendingAnchor = null;\n        state.selectedId = null;\n      }\n")],
+     "forgetScrollAnchor nulls it and does nothing else"),
+]
+
+original = io.open(CLIENT, encoding="utf-8", newline="").read()
+
+
+def run():
+    proc = subprocess.run(["node", PROBE], cwd=HERE,
+                          capture_output=True, text=True, encoding="utf-8", errors="replace")
+    return proc.returncode, proc.stdout + proc.stderr
+
+
+ok = True
+code, baseline = run()
+base_ok = code == 0 and "0 failed" in baseline
+print(("ok   " if base_ok else "FAIL ") + "baseline green")
+ok = ok and base_ok
+
+caught = []
+for title, edits, expect in MUTATIONS:
+    for old, _ in edits:
+        hits = original.count(old)
+        if hits != 1:
+            raise SystemExit("FAIL  anchor for %r matched %d times" % (title, hits))
+    try:
+        mutated = original
+        for old, new in edits:
+            mutated = mutated.replace(old, new, 1)
+        io.open(CLIENT, "w", encoding="utf-8", newline="").write(mutated)
+        during_code, during = run()
+        named = expect in during
+        red = during_code != 0
+        # A guard that crashes is not a guard that caught anything: the rule has to be reported by
+        # name, or the mutation only proved that the file no longer parses.
+        print(("ok   " if (named and red) else "FAIL ") + "guard catches: " + title)
+        if not named:
+            print("       no assertion reported %r" % expect)
+            for line in during.splitlines()[-4:]:
+                print("       " + line.strip())
+        elif not red:
+            print("       the rule was reported but the guard still exited 0")
+        caught.append(named and red)
+    finally:
+        io.open(CLIENT, "w", encoding="utf-8", newline="").write(original)
+
+restored = io.open(CLIENT, encoding="utf-8", newline="").read()
+after_code, after = run()
+after_ok = after_code == 0 and "0 failed" in after
+print(("ok   " if restored == original else "FAIL ") + "client restored byte for byte")
+print(("ok   " if after_ok else "FAIL ") + "green again after restore")
+
+sys.exit(0 if (ok and all(caught) and restored == original and after_ok) else 1)
\ No newline at end of file
diff --git a/plugins/avatasia/mmc-trajectory/tests/mutate-anomaly.py b/plugins/avatasia/mmc-trajectory/tests/mutate-anomaly.py
new file mode 100644
index 0000000..1fab8b7
--- /dev/null
+++ b/plugins/avatasia/mmc-trajectory/tests/mutate-anomaly.py
@@ -0,0 +1,436 @@
+"""Mutation control for the 异常 guards.
+
+Each mutation has to be caught, and caught *by the guard that owns the defect*. The probe prints
+the exact names of the assertions that failed (`FAILED_NAMES\t[...]`), and a mutation is only
+accepted when the named guard is among them — a substring match would let any nearby assertion
+vouch for a mutation it knows nothing about, which is how a whole batch of these looked green
+while testing nothing.
+
+index.html is read and written as bytes and only the mutated substring is replaced, so line
+endings are never touched — it is LF, and a blanket read_text/write_text round trip would
+rewrite it to CRLF and trip CSS regexes that have nothing to do with this filter.
+"""
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parent
+ROOT = HERE.parent
+PROBE = HERE / "verify-anomaly.mjs"
+WATCHED = ROOT / "miniapp" / "client" / "index.html"
+
+# The live-turn exclusion, kept as one constant because three mutations strip different halves
+# of it and they must not drift apart.
+NO_REPLY = "            return !!turn && turn.closed === false && turn !== ctx.liveTurn;"
+
+CASES = [
+    # --- the rule predicates: each is one comparison, and each one is the whole rule ---
+    # The count on real data is unchanged by this one — every failing row in this session
+    # carries a boolean — so the guard that owns it is the one that pins true-vs-truthy.
+    ("a failure read as any truthy isError", 'the string "true" is not a failure either',
+     "            return !!record && record.isError === true;",
+     "            return !!record && !!record.isError;"),
+    ("compaction widened to swallow 系统 rows too", "compaction count matches the payload",
+     "            return !!record && record.kind === 'compaction';",
+     "            return !!record && (record.kind === 'compaction' || record.kind === 'system');"),
+    ("the live turn no longer excluded from 无答复", "the turn still running is not an anomaly",
+     NO_REPLY, "            return !!turn && turn.closed === false;"),
+    ("无答复 flipped to the turns that did answer", "a turn that never answered, seen from inside it",
+     NO_REPLY, "            return !!turn && turn.closed === true && turn !== ctx.liveTurn;"),
+    # NOTE: nulling the page's own `liveTurn` is deliberately NOT a case here. verify-anomaly.mjs
+    # re-derives the live turn itself (`const liveTurn = payload.turns[payload.turns.length - 1]`)
+    # instead of reading the page's function, so that mutation is invisible to every assertion in
+    # the file -- it was tried, and the probe passed. Keeping the case would mean shipping a
+    # mutation known to be unobservable, which is worse than naming the gap: the page's liveTurn
+    # has no guard of its own until the harness stops re-deriving it.
+    ("the turn head reads record-scoped rules as turn-scoped",
+     "a rule that is record-scoped never tags a turn",
+     "          if (rule.turn && rule.turn(turn, ctx)) out.push(rule.id);",
+     "          if (rule.record || rule.turn(turn, ctx)) out.push(rule.id);"),
+
+    # --- the filter's off state ---
+    # Off has to mean "let everything through". Reading it as "match nothing" empties the
+    # ledger the moment the filter is switched off, which looks like data loss, not a filter.
+    ("off read as match-nothing", "the filter off lets a clean record through",
+     "        if (!enabled || !enabled.length) return true;",
+     "        if (!enabled) return true;"),
+    ("the filter admits everything, ticked or not", "all rules on drops the clean record",
+     "          if (enabled.indexOf(hits[i]) >= 0) return true;\n        }\n        return false;",
+     "          if (enabled.indexOf(hits[i]) >= 0) return true;\n        }\n        return true;"),
+    ("the enabled-rule test inverted, so one rule keeps what it should drop",
+     "one rule on keeps only that rule",
+     "          if (enabled.indexOf(hits[i]) >= 0) return true;",
+     "          if (enabled.indexOf(hits[i]) < 0) return true;"),
+
+    # --- the base filter: one predicate, walked by the ledger and nothing else ---
+    # anomalyCounts used to walk this too, so a button could promise 246 while the list showed
+    # 12. That walk is gone — 异常 mode ignores this axis — and what replaces the old assertion
+    # is that the ledger still filters when no rule is ticked. This mutation keeps that true
+    # case honest: if passesBaseFilter stopped applying the query, the list would stop being
+    # filtered at all and the exclusivity check above it would pass for the wrong reason.
+    ("the base filter stops applying the query",
+     "but with no rule ticked the search is still a filter for the list",
+     "        if (state.query && !matchesQuery(record, state.query)) return false;",
+     "        if (false && state.query) return false;"),
+    # Dropping the range from passesBaseFilter is deliberately NOT here: that guard lives in
+    # verify-time-range.mjs, and a case listed against a probe that does not own it would be
+    # reported as "not caught" while the real owner sat unmutated. It is in mutate-time-range.py.
+    ("any counts rule hits instead of records, so a row trips two rules is counted twice",
+     "the union count matches the payload",
+     "          any += 1;", "          any += hits.length;"),
+    # This one attacks the call site rather than the function, so it belongs to the guard that owns
+# the call site: repointed rather than dropped, because dropping it would leave the render wiring
+# with no mutation at all.
+("the buttons read counts from somewhere else entirely",
+     "the mode is settled before anything reads a count",
+     "        var anomaly = anomalyCounts();\n        syncAnomalyMode(anomaly);\n        syncAnomalyButtons(anomaly);",
+     "        var anomaly = anomalyCounts();\n        syncAnomalyMode(anomaly);\n        syncAnomalyButtons({ byRule: {}, unit: {}, any: 0, selected: 0 });"),
+
+    # --- the strip is handed a bare record ---
+    # 无答复 is a property of the turn, and the overview path only has the record, so the turn
+    # has to come back out of the index. Losing that lookup makes the strip answer a different
+    # question than the ledger directly above it.
+    ("the strip cannot find the owning turn", "the strip and the ledger keep the same records",
+     "        var owner = record ? turnById.get(record.turnId) : null;",
+     "        var owner = null;"),
+    ("the strip stopped applying 异常 at all", "the strip applies it",
+     "          return passesAnomaly(record, { turn: owner || null, liveTurn: liveTurn() }, state.anomalyRules);",
+     "          return true;"),
+    ("the ledger stopped applying 异常", "the ledger applies it",
+     "            if (!passesAnomaly(entry.record, anomalyContext(entry), state.anomalyRules)) continue;\n", ""),
+
+    # --- the state has to remember the ticks, or a poll re-renders the buttons from nothing ---
+    ("the filter is not counted as a filter", "the filter counts as a filter",
+     "          || state.anomalyRules.length !== 0", "          || false"),
+    ("清除筛选 leaves the filter on", "清除筛选 drops it too",
+     "        state.anomalyRules = [];\n        state.anomalyLast = null;\n        state.multiAnomaly = false;\n        clearTimeRange();",
+     "        state.anomalyLast = null;\n        state.multiAnomaly = false;\n        clearTimeRange();"),
+    ("清除筛选 leaves the buttons showing the old state", "and re-syncs the buttons with it",
+     "        syncKindButtons();\n        syncAnomalyButtons(anomalyCounts());\n        render();",
+     "        syncKindButtons();\n        render();"),
+    ("a poll stops refreshing the counts", "every poll re-syncs the buttons",
+     "        syncAnomalyButtons(anomaly);\n        renderOverview();",
+     "        renderOverview();"),
+
+    # --- ticking, run rather than read ---
+    ("ticking no longer resets the window", "and it resets the window like every other filter",
+     "        if (next.length > 0) resetBaseFilters();\n        resetWindowMode();",
+     "        if (next.length > 0) resetBaseFilters();"),
+    # The guard it names moved into the 多选 block when 单选 became the default, which is where the
+    # untick actually happens now: single mode replaces, so removal only exists with the checkbox on.
+    ("unticking re-adds the rule it just removed", "多选: unticking removes only that one",
+     "          if (next.length === state.anomalyRules.length) next = next.concat([ruleId]);",
+     "          if (next.length <= state.anomalyRules.length) next = next.concat([ruleId]);"),
+    ("全部异常 ticks the rule table itself instead of a copy",
+     "全部异常 ticks a copy, not the table itself",
+     "          next = state.anomalyRules.length === ANOMALY_RULES.length ? [] : ANOMALY_RULE_IDS.slice();",
+     "          next = state.anomalyRules.length === ANOMALY_RULES.length ? [] : ANOMALY_RULE_IDS;"),
+
+    # --- what the reader is shown ---
+    ("the turn head stops naming the rule", "with the rule name, not a bare colour",
+     "anomalyRuleLabel(turnFlags[flag])", "turnFlags[flag]"),
+    ("the turn head drops the tag entirely", "the head tags a broken turn",
+     "        var turnFlags = turnAnomalyRules(turn);", "        var turnFlags = [];"),
+    # `ANOMALY_RULES[i]` also appears in turnAnomalyRules, so the anchor reaches into the next
+    # line to say which of the two is being mutated.
+    ("every button is built from the first rule", "one button per rule",
+     "          var rule = ANOMALY_RULES[i];\n          var button = el('button', 'btn btn-quiet anomaly-btn');",
+     "          var rule = ANOMALY_RULES[0];\n          var button = el('button', 'btn btn-quiet anomaly-btn');"),
+    # A rule name written into the markup is a second list of names. The kind chips already had
+    # this bug once: a rename left the button showing one word and announcing another.
+    ("a rule name hardcoded into the markup", "no rule is hardcoded in the markup",
+     '<div class="anomaly-quick" id="anomaly-controls" role="group" aria-labelledby="anomaly-label"></div>',
+     '<div class="anomaly-quick" id="anomaly-controls" role="group" aria-labelledby="anomaly-label">工具失败</div>'),
+
+    # --- the two axes are alternatives. Every one of these turns a mutually exclusive pair back
+    # --- into a stack, which is the shape that produced "283 on the button, 1,494 in the list".
+    ("the mode is read backwards, so the search stops filtering at all",
+     "but with no rule ticked the search is still a filter for the list",
+     "        var anomalyMode = state.anomalyRules.length > 0;",
+     "        var anomalyMode = state.anomalyRules.length >= 0;"),
+    ("the two axes stacked instead of alternated",
+     "and treats the two axes as alternatives, not a stack",
+     "          } else if (!passesBaseFilter(entry.record, selection)) {",
+     "          }\n          if (!passesBaseFilter(entry.record, selection)) {"),
+    ("the button count follows the search box again",
+     "a search does not move the union count",
+     "          var hits = recordAnomalyRules(entry.record, { turn: entry.turn, liveTurn: live });",
+     "          var hits = state.query ? [] : recordAnomalyRules(entry.record, { turn: entry.turn, liveTurn: live });"),
+    ("the strip branches after the other axis instead of before it",
+     "and branches on the mode before the other axis, so strip and list agree",
+     "        if (state.anomalyRules.length > 0) {\n          return passesAnomaly(",
+     "        if (false) {\n          return passesAnomaly("),
+
+    # --- a turn rule is counted in turns. Counting its records is the original lie.
+    ("a turn rule counted per record instead of per turn",
+     "unanswered count matches the payload, counted in turns",
+     "            var key = id + '#' + entry.turn.index;",
+     "            var key = id + '#' + entry.record.id;"),
+    ("every rule published in 条, whatever it is scoped to",
+     "the turn rule publishes itself in 轮",
+     "          unit[ANOMALY_RULES[i].id] = ANOMALY_RULES[i].turn ? '轮' : '条';",
+     "          unit[ANOMALY_RULES[i].id] = '条';"),
+
+    # --- there has to be a way out of the mode there is a way into.
+    ("重置 is not built", "and one to put the row back to its default",
+     "        none.id = 'anomaly-none';", "        none.id = 'anomaly-all-data';"),
+    ("重置 ticks the whole set instead of clearing it",
+     "重置 returns the row to its default",
+     "        if (state.anomalyRules.length === 0 && !state.multiAnomaly) return;\n        state.anomalyRules = [];",
+     "        if (state.anomalyRules.length === 0 && !state.multiAnomaly) return;\n        state.anomalyRules = ANOMALY_RULE_IDS.slice();"),
+    # 重置 has no count of its own: 「怎么多会留下多少」 is a question about a rule, and a control
+    # that keeps whatever the row above says has no answer to it. Printing one anyway invites
+    # adding it up against the numbers beside it.
+    ("重置 given a count it cannot keep", "重置 advertises no count of its own",
+     "        none.appendChild(el('span', 'anomaly-label', ANOMALY_NONE_LABEL));\n        dom.anomalyControls.appendChild(none);",
+     "        none.appendChild(el('span', 'anomaly-label', ANOMALY_NONE_LABEL));\n        none.appendChild(el('span', 'anomaly-count', '0'));\n        dom.anomalyControls.appendChild(none);"),
+    # In 异常 mode the row above filters nothing. Leaving it holding 「用户」 would be the page
+    # showing a condition that is not in force — the same defect as a button whose number does
+    # not match its list, one control over.
+    ("ticking a rule no longer puts the row above back to default",
+     "ticking a rule puts every type back",
+     "        if (next.length > 0) resetBaseFilters();",
+     "        if (next.length > 0 && false) resetBaseFilters();"),
+    ("the reset forgets the search box", "and drops the search",
+     "        state.query = '';\n        state.overviewSelection = null;",
+     "        state.overviewSelection = null;"),
+    ("the reset forgets the overview brush", "and drops the overview brush",
+     "        state.overviewSelection = null;\n        clearTimeRange();",
+     "        clearTimeRange();"),
+    # Setting state.kinds without syncKindButtons() is how the axis ends up drawing a condition
+    # the table is not filtered by, which is the whole reason the reset exists.
+    ("the reset sets the state but never the buttons",
+     "the reset updates the buttons, or the axis would show a condition that is not in force",
+     "        syncKindButtons();\n      }\n\n      /**\n       * Keeps the page honest",
+     "      }\n\n      /**\n       * Keeps the page honest"),
+    ("the inactive axis is dimmed but still takes clicks",
+     "the inactive axis is made inert, not merely dimmed",
+     "        for (var i = 0; i < scopes.length; i += 1) scopes[i].inert = on;",
+     "        for (var i = 0; i < scopes.length; i += 1) scopes[i].inert = false;"),
+    ("the 异常 axis moved back out from under the type axis",
+     "the 异常 axis comes after it",
+     '        <div class="anomaly-bar" id="anomaly-bar">',
+     '        <div class="anomaly-bar" id="anomaly-strip">'),
+
+    # --- 多选: one checkbox, two ways to read the same buttons.
+    # Before this the toggle stacked unconditionally, so every one of these is a way to end up
+    # back there — silently, and with a selection the controls can no longer express.
+    ("单选 stacks instead of replacing",
+     "单选: ticking a second replaces the first instead of stacking",
+     "          next = [ruleId];\n          state.anomalyLast = ruleId;",
+     "          next = state.anomalyRules.concat([ruleId]);\n          state.anomalyLast = ruleId;"),
+    ("单选 cannot be turned off by pressing the rule that is on",
+     "单选: pressing the rule already on turns it off again",
+     "        } else if (state.anomalyRules.length === 1 && state.anomalyRules[0] === ruleId) {\n          next = [];",
+     "        } else if (false) {\n          next = [];"),
+    ("多选 stacks without removing anything",
+     "多选: unticking removes only that one",
+     "          next = state.anomalyRules.filter(function (id) {\n            return id !== ruleId;\n          });\n          if (next.length === state.anomalyRules.length) next = next.concat([ruleId]);",
+     "          next = state.anomalyRules.concat([ruleId]);"),
+    ("the union branch is never taken, so 多选 is only a label",
+     "多选: ticking a second stacks instead of replacing",
+     "        } else if (state.multiAnomaly) {",
+     "        } else if (false) {"),
+    # Which rule survives is a decision, so it is asserted. Table order is the wrong answer to
+    # "which one was I looking at": it silently moves the reader to a filter they did not pick.
+    ("turning 多选 off keeps the first rule in table order instead of the last one ticked",
+     "turning 多选 off keeps the rule ticked last, not the first in table order",
+     "          state.anomalyRules = [last && state.anomalyRules.indexOf(last) >= 0\n            ? last\n            : state.anomalyRules[0]];",
+     "          state.anomalyRules = [state.anomalyRules[0]];"),
+    # The collapse is gated on turning 多选 *off*. Ungated, 全部异常 — which is legal in 单选 —
+    # would lose three of its four rules the moment the reader asked for the union.
+    ("turning 多选 on also collapses the selection",
+     "turning 多选 on changes the mode and nothing else",
+     "        if (!checked && state.anomalyRules.length > 1) {",
+     "        if (state.anomalyRules.length > 1) {"),
+    ("重置 leaves 多选 on", "and 多选 goes off with it",
+     "        state.multiAnomaly = false;\n        if (dom.anomalyMulti) dom.anomalyMulti.checked = false;",
+     "        if (dom.anomalyMulti) dom.anomalyMulti.checked = false;"),
+    ("重置 clears the state but leaves the box drawn as ticked",
+     "and the checkbox stops reading as on",
+     "        state.multiAnomaly = false;\n        if (dom.anomalyMulti) dom.anomalyMulti.checked = false;\n        resetWindowMode();",
+     "        state.multiAnomaly = false;\n        resetWindowMode();"),
+    # The checkbox sits outside `#anomaly-controls` precisely so it cannot be swept up by the
+    # inert-marking that switches the other axis off.
+    ("the 多选 checkbox marked as a filter control, so it goes inert with the rest",
+     "and it is never marked as a filter control, so it cannot be made inert",
+     '<label class="anomaly-multi" for="anomaly-multi">',
+     '<label class="anomaly-multi" data-filter-scope for="anomaly-multi">'),
+    ("the checkbox is never re-drawn from state, so a poll can strand it ticked",
+     "every poll re-draws the checkbox from state, not from where the reader left it",
+     "        if (dom.anomalyMulti) dom.anomalyMulti.checked = state.multiAnomaly;",
+     ""),
+    ("多选 opens on, so the documented default is a union",
+     "多选 opens off, because 单选 is the documented default",
+     "        multiAnomaly: false,", "        multiAnomaly: true,"),
+    ("the checkbox bound to click, which a keyboard toggle never fires",
+     "the checkbox is bound to the mode handler",
+     "        dom.anomalyMulti.addEventListener('change', function () {",
+     "        dom.anomalyMulti.addEventListener('click', function () {"),
+
+    # --- 合计: the number the note publishes has to be the number under the buttons.
+    # The defect this replaces printed 合计见「全部异常」, which is the union of all four rules and
+    # therefore described a different selection than the one on screen.
+    ("the partial union is counted as the whole table",
+     "a partial union is the length of the list behind it",
+     "            if (sel.indexOf(hits[s]) >= 0) {\n              selected += 1;\n              break;\n            }",
+     "            if (sel.length === 0 || sel.indexOf(hits[s]) >= 0) {\n              selected += 1;\n            }"),
+    # Dropping the `break` turns the union into a count of rule-hits: correct until two rules
+    # overlap on one record, which is exactly the case the note exists to account for. A mutation
+    # that only differs when there is overlap is worth more than one that is always different.
+    ("a record tripping two rules is counted twice in the union",
+     "a partial union is the length of the list behind it",
+     "            if (sel.indexOf(hits[s]) >= 0) {\n              selected += 1;\n              break;\n            }",
+     "            if (sel.indexOf(hits[s]) >= 0) {\n              selected += 1;\n            }"),
+    ("the note publishes 全部异常's number for a partial selection",
+     "the note publishes the total for the rules that are ticked",
+     "              ? ' · 已叠加 ' + formatInt(n) + ' 条规则 · 合计 ' + formatInt(counts.selected) + ' 条'",
+     "              ? ' · 已叠加 ' + formatInt(n) + ' 条规则 · 合计 ' + formatInt(counts.any) + ' 条'"),
+    # The defect, stated as the shape that would reintroduce it. A partial selection is not
+    # 全部异常, so a total that is not the partial selection's own is the failure however it is
+    # worded — which is why the assertion parses the number back out instead of matching a phrase.
+    ("the note goes back to pointing at 全部异常",
+     "and it is a number, not a pointer somewhere else",
+     "              ? ' · 已叠加 ' + formatInt(n) + ' 条规则 · 合计 ' + formatInt(counts.selected) + ' 条'",
+     "              ? ' · 已叠加 ' + formatInt(n) + ' 条规则，合计见「全部异常」'"),
+    # 叠加 is 多选's word. In 单选 the only way to get here is 全部异常, which the reader did not
+    # stack — and the note was telling a reader who had not turned 多选 on that they had.
+    ("the note calls 全部异常 a stack even when 多选 is off",
+     "单选 does not claim a stack the reader never built",
+     "            : ' · 全部 ' + formatInt(n) + ' 条规则同时生效 · 合计 ' + formatInt(counts.selected) + ' 条')",
+     "            : ' · 已叠加 ' + formatInt(n) + ' 条规则 · 合计 ' + formatInt(counts.selected) + ' 条')"),
+    # 重置 describes the whole row, and 多选 is part of that row. Leaving it out made the button
+    # claim the reader was already at the default while the mode was not, and it is the only
+    # control that puts the mode back.
+    ("重置 claims default while 多选 is on",
+     "重置 is pressed only when both the rules and the mode are at their default",
+     "            on = state.anomalyRules.length === 0 && !state.multiAnomaly;",
+     "            on = state.anomalyRules.length === 0;"),
+    # Two walks of a session that is still growing can hand the note and the buttons different
+    # numbers. This is the guard that keeps them on one read.
+    ("the note walks the session a second time",
+     "and the note and the buttons are handed the same walk, not two of them",
+     "        var anomaly = anomalyCounts();\n        syncAnomalyMode(anomaly);",
+     "        var anomaly = anomalyCounts();\n        syncAnomalyMode(anomalyCounts());"),
+    ("the buttons walk the session again instead of taking the snapshot",
+     "the count comes from the pass render() took, not a second walk",
+     "      function syncAnomalyButtons(counts) {\n        if (!dom.anomalyControls) return;",
+     "      function syncAnomalyButtons(counts) {\n        if (!dom.anomalyControls) return;\n        counts = anomalyCounts();"),
+
+    # --- 空答复: a reply the runtime finished and then delivered nothing into.
+    # Every other rule tests a field that was there. This one tests an absence, so most of the
+    # ways to get it wrong are over-matching rather than under-matching.
+    ("an empty answer rule that ignores the body", "a reply that said something is not",
+     "            return !!record && record.kind === 'reply' && isNil(record.text);",
+     "            return !!record && record.kind === 'reply';"),
+    ("the no-body test inverted, so every spoken reply becomes an anomaly",
+     "a reply with no body is an empty answer",
+     "            return !!record && record.kind === 'reply' && isNil(record.text);",
+     "            return !!record && record.kind === 'reply' && !isNil(record.text);"),
+    ("the kind test inverted, so every non-reply is an empty answer",
+     "a normal row is not an anomaly",
+     "            return !!record && record.kind === 'reply' && isNil(record.text);",
+     "            return !!record && record.kind !== 'reply' && isNil(record.text);"),
+    # Dropping the body and reading truncation instead hits the plain no-body case first, on a
+    # record that carries no truncation flag at all. That assertion is the one that owns it.
+    ("no-body judged by truncation instead of by absence", "a reply with no body is an empty answer",
+     "            return !!record && record.kind === 'reply' && isNil(record.text);",
+     "            return !!record && record.kind === 'reply' && record.textTruncated === false;"),
+    ("a checkpoint counted twice, once as a checkpoint and once as an empty answer",
+     "a checkpoint is not also an empty answer",
+     "            return !!record && record.kind === 'reply' && isNil(record.text);",
+     "            return !!record && isNil(record.text);"),
+    ("the empty-answer rule never fires", "empty answer count matches the payload",
+     "            return !!record && record.kind === 'reply' && isNil(record.text);",
+     "            return false;"),
+
+    # --- and the row, because a filter that shows these without marking them shows nothing
+    ("the empty-answer marker removed from the row", "an empty reply is marked on its row",
+     "        var silent = record.kind === 'reply' && isNil(record.text);",
+     "        var silent = false;"),
+    ("the row's marker branch dropped, leaving the duration cell instead",
+     "and it reuses the duration cell instead of adding a column",
+     "        } else if (silent) {\n"
+     "          // The name comes from the rule table, not from a second copy written here. A label\n"
+     "          // that exists in two places is the drift this page already paid for once on the kind\n"
+     "          // chips: rename the rule and the row keeps announcing the old word.\n"
+     "          row.appendChild(pill(anomalyRuleLabel('silent'), 'error'));\n"
+     "          row.title = anomalyRuleLabel('silent') + ' · 模型正常结束，但没有返回任何内容';\n"
+     "        } else {",
+     "        } else {"),
+    ("the row's marker written from a literal label instead of the rule table",
+     "the row never paints a rule name literally — silent",
+     "          row.appendChild(pill(anomalyRuleLabel('silent'), 'error'));",
+     "          row.appendChild(pill('空答复', 'error'));"),
+    ("the marker branch made unreachable", "and it reuses the duration cell instead of adding a column",
+     "        } else if (silent) {", "        } else if (false) {"),
+]
+
+
+def run_probe():
+    proc = subprocess.run(
+        ["node", str(PROBE)], cwd=str(ROOT), capture_output=True, text=True,
+        encoding="utf-8", errors="replace",
+    )
+    fired = []
+    saw_report = False
+    for line in proc.stdout.splitlines():
+        if line.startswith("FAILED_NAMES\t"):
+            fired = json.loads(line.split("\t", 1)[1])
+            saw_report = True
+    # A probe that throws never reaches its report. Treating that as a catch would let any
+    # mutation that breaks the script outright — rather than the rule it was aimed at — pass
+    # for evidence, which is the whole failure mode this runner exists to prevent.
+    return proc.returncode == 0, (fired if saw_report else None), proc.stdout + proc.stderr
+
+
+def main():
+    original = WATCHED.read_bytes()
+    ok, fired, output = run_probe()
+    if not ok or fired:
+        print("baseline verify-anomaly.mjs did not pass; refusing to run mutations")
+        print(output)
+        return 1
+
+    failures = []
+    for name, expected, old, new in CASES:
+        text = original.decode("utf-8")
+        if text.count(old) != 1:
+            failures.append(f"{name}: anchor matched {text.count(old)} times, expected exactly 1")
+            continue
+
+        WATCHED.write_bytes(text.replace(old, new, 1).encode("utf-8"))
+        try:
+            passed, fired, _ = run_probe()
+        finally:
+            WATCHED.write_bytes(original)
+
+        if fired is None:
+            failures.append(f"{name}: CRASHED — the probe stopped before reporting; that is not a catch")
+            continue
+        if passed:
+            failures.append(f"{name}: NOT CAUGHT — probe still passed")
+            continue
+        if expected not in fired:
+            failures.append(f"{name}: caught by {fired}, expected {expected!r}")
+            continue
+        print(f"  caught by {expected}: {name}")
+
+    if WATCHED.read_bytes() != original:
+        failures.append("index.html was not restored byte-for-byte")
+    else:
+        print("index.html restored byte-for-byte")
+
+    if failures:
+        print("\nFAILURES:")
+        for line in failures:
+            print(" - " + line)
+        return 1
+
+    print(f"\nOK  ({len(CASES)} mutations, each caught by the guard that owns the defect)")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/plugins/avatasia/mmc-trajectory/tests/mutate-compaction-turn.py b/plugins/avatasia/mmc-trajectory/tests/mutate-compaction-turn.py
new file mode 100644
index 0000000..2253f34
--- /dev/null
+++ b/plugins/avatasia/mmc-trajectory/tests/mutate-compaction-turn.py
@@ -0,0 +1,141 @@
+"""Mutation control for the compaction-turn fix and the band that renders it.
+
+Each mutation reintroduces exactly one thing the probes are supposed to catch. The probe must FAIL
+every time, and the file must come back byte-for-byte afterwards.
+"""
+import subprocess
+import sys
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parent
+ROOT = HERE.parent
+SERVER = ROOT / "miniapp" / "node" / "server.mjs"
+CLIENT = ROOT / "miniapp" / "client" / "index.html"
+PROBES = [
+    HERE / "verify-compaction-turn.mjs",
+    HERE / "client-check.mjs",
+]
+
+MUTATIONS = [
+    (
+        "server: key the turn on the whole id again (the phantom turn returns)",
+        SERVER,
+        "    const turn = ensureTurn(turnKey);",
+        "    const turn = ensureTurn(turnId);",
+    ),
+    (
+        "server: strip the suffix from any id, not just a checkpoint",
+        SERVER,
+        "    const turnKey = role === 'compactionSummary'\n",
+        "    const turnKey = (role === 'compactionSummary' || true)\n",
+    ),
+    (
+        "server: drop the length guard, so ':compaction' collapses into the turn-less bucket",
+        SERVER,
+        "      && turnId.length > COMPACTION_TURN_SUFFIX.length\n",
+        "",
+    ),
+    (
+        "server: a turn containing a checkpoint is called a checkpoint again",
+        SERVER,
+        "    } else if (isCompaction && turn.records.length === 1) {",
+        "    } else if (isCompaction) {",
+    ),
+    (
+        "server: leave the file's suffixed id on the record",
+        SERVER,
+        "      turnId: turnKey,",
+        "      turnId,",
+    ),
+    (
+        "client: the compaction term goes back to counting turns",
+        CLIENT,
+        "        if (isCount(stats.compactions) && stats.compactions > 0) {",
+        "        if (isCount(stats.compactionTurns) && stats.compactionTurns > 0) {",
+    ),
+    (
+        "client: the band loses the generation it opened",
+        CLIENT,
+        "        var opened = isCount(record.generation)",
+        "        var opened = false",
+    ),
+    (
+        "client: the ledger stops routing checkpoints to the band",
+        CLIENT,
+        "            if (group.entries[j].record.kind === 'compaction') {",
+        "            if (false) {",
+    ),
+]
+
+
+def read_exact(path):
+    """Read with every line ending normalised to \\n, and remember which style the file used.
+
+    `Path.read_text` folds CRLF into LF and `Path.write_text` puts the platform's line ending
+    back, so the usual pair silently rewrites a file's endings for the duration of a mutation.
+    That is not cosmetic here: server.mjs is CRLF and index.html is LF, several guards match CSS
+    rules with a literal `\\n`, and matching an anchor written with `\\n` against a CRLF file finds
+    nothing. So: match on the normalised text, write back in the file's own style.
+    """
+    raw = path.read_bytes().decode("utf-8")
+    return raw.replace("\r\n", "\n"), ("\r\n" if "\r\n" in raw else "\n")
+
+
+def write_exact(path, text, newline):
+    with open(path, "wb") as handle:
+        handle.write(text.replace("\n", newline).encode("utf-8"))
+
+
+def run_probe():
+    for probe in PROBES:
+        result = subprocess.run(
+            ["node", str(probe)], cwd=str(HERE), capture_output=True, text=True
+        )
+        if result.returncode != 0:
+            return probe.name, result.stdout + result.stderr
+    return None, ""
+
+
+def main():
+    name, output = run_probe()
+    if name:
+        print(f"baseline {name} does not pass; fix that first")
+        print(output)
+        return 1
+    print("baseline clean")
+
+    originals = {path: path.read_bytes() for path in {m[1] for m in MUTATIONS}}
+    missed = []
+    for label, path, old, new in MUTATIONS:
+        text, newline = read_exact(path)
+        if text.count(old) != 1:
+            print(f"SKIP  {label}: anchor appears {text.count(old)} times, expected 1")
+            missed.append(label)
+            continue
+        write_exact(path, text.replace(old, new, 1), newline)
+        try:
+            name, output = run_probe()
+        finally:
+            path.write_bytes(originals[path])
+        if name is None:
+            print(f"MISSED {label}: every probe still passed")
+            missed.append(label)
+        else:
+            detail = [line.strip() for line in output.splitlines() if line.strip().startswith("-")]
+            print(f"caught {label}\n         -> {name}: {detail[0] if detail else '(no detail)'}")
+
+    for path, data in originals.items():
+        if path.read_bytes() != data:
+            print(f"NOT RESTORED {path}")
+            return 1
+    print("all files restored byte-for-byte")
+
+    if missed:
+        print(f"\n{len(missed)} mutation(s) got through")
+        return 1
+    print(f"\nall {len(MUTATIONS)} mutations caught")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
\ No newline at end of file
diff --git a/plugins/avatasia/mmc-trajectory/tests/mutate-index-col.py b/plugins/avatasia/mmc-trajectory/tests/mutate-index-col.py
new file mode 100644
index 0000000..cc3e02c
--- /dev/null
+++ b/plugins/avatasia/mmc-trajectory/tests/mutate-index-col.py
@@ -0,0 +1,138 @@
+"""Mutation control for the 记录序号 column guards in client-check.mjs.
+
+Every mutation here has to be caught, and caught *by the guard that owns the defect*.
+A mutation that trips some unrelated assertion proves nothing, so each case names the
+guard it expects and the runner fails loudly when a different one fires.
+
+The file is read and written as bytes and only the mutated substring is replaced, so
+line endings are never touched: index.html is LF, and a blanket read_text/write_text
+round trip would rewrite it to CRLF and trip CSS regexes that have nothing to do with
+this bug.
+"""
+import subprocess
+import sys
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parent
+ROOT = HERE.parent
+CLIENT = ROOT / "miniapp" / "client" / "index.html"
+CHECK = HERE / "client-check.mjs"
+
+WIDTH_GUARD = "the 序号 column is wide enough for the label it must show"
+SHARED_GUARD = "every grid that renders a 序号 uses the shared column"
+CONTAIN_GUARD = "a 序号 that still does not fit is ellipsised, never spilled onto the pill"
+RANGE_WIDTH_GUARD = "the 时间区间 pickers are sized by their content, not by a fixed width"
+RANGE_NO_PX_GUARD = "and no later rule gives the 时间区间 pickers a width"
+
+# A `datetime-local` is laid out by the browser from the localized date it has to draw, so the
+# guard is about the absence of a fixed width rather than about a number. The mutations are the
+# two ways that absence could end: a width added, and the flex context that stops the toolbar
+# squeezing the control removed.
+# `flex: none` appears on a dozen rules, so the anchor carries the line above it — which is the
+# end of this rule's own comment, so it cannot drift onto another rule.
+RANGE_FLEX = "another route. */\n        flex: none;\n"
+
+CASES = [
+    # Guard 1 — the width. 42px is the value that caused the report; 60px is a
+    # plausible-looking but still-insufficient number (needs 67.2), so a check that
+    # merely demanded "not 42" would let this through.
+    ("width back to 42px", WIDTH_GUARD,
+     "--traj-index-col: 72px;", "--traj-index-col: 42px;"),
+    ("width narrowed to 60px", WIDTH_GUARD,
+     "--traj-index-col: 72px;", "--traj-index-col: 60px;"),
+    # Guard 1 — uniqueness. A second declaration leaves the tracks disagreeing.
+    ("second declaration of the column", WIDTH_GUARD,
+     "--traj-index-col: 72px;", "--traj-index-col: 72px;\n      }\n      :root {\n        --traj-index-col: 40px;"),
+    # Guard 2 — every site that renders a 序号, including the narrow override that
+    # silently produced the phone behaviour.
+    (".row track back to a literal 42px", SHARED_GUARD,
+     "grid-template-columns: var(--traj-index-col) 76px minmax(0, 1fr) 68px 76px;\n        align-items: center;",
+     "grid-template-columns: 42px 76px minmax(0, 1fr) 68px 76px;\n        align-items: center;"),
+    (".compaction-band track back to a literal 42px", SHARED_GUARD,
+     "grid-template-columns: var(--traj-index-col) auto minmax(0, 1fr) auto;",
+     "grid-template-columns: 42px auto minmax(0, 1fr) auto;"),
+    (".skeleton-row track back to a literal 42px", SHARED_GUARD,
+     "grid-template-columns: var(--traj-index-col) 76px minmax(0, 1fr) 68px 76px;\n        gap: 8px;",
+     "grid-template-columns: 42px 76px minmax(0, 1fr) 68px 76px;\n        gap: 8px;"),
+    ("narrow override back to 28px", SHARED_GUARD,
+     "grid-template-columns: var(--traj-index-col) 64px minmax(0, 1fr) 54px 66px;",
+     "grid-template-columns: 28px 64px minmax(0, 1fr) 54px 66px;"),
+    # Guard 3 — containment. Anchored on the comment rather than on the three
+    # declarations: `overflow/text-overflow/white-space` appears elsewhere in this file,
+    # so the properties alone are not a unique key.
+    ("containment dropped", CONTAIN_GUARD,
+     "ellipsis reads as a number this row could not show in full. */\n"
+     "        overflow: hidden;\n        text-overflow: ellipsis;\n        white-space: nowrap;\n",
+     "ellipsis reads as a number this row could not show in full. */\n"),
+
+    # The 时间区间 pickers, which had the same defect twice and a third way: a width fixed by
+    # yesterday's content, on a control the browser already knows how wide to make.
+    ("the picker given a fixed width again", RANGE_WIDTH_GUARD,
+     RANGE_FLEX, "        width: 20ch;\n"),
+    ("the picker left shrinkable inside the toolbar", RANGE_WIDTH_GUARD,
+     RANGE_FLEX, ""),
+    ("a later rule puts a width back", RANGE_NO_PX_GUARD,
+     "\n      .range-sep {", "\n      .range-input {\n        width: 88px;\n      }\n      .range-sep {"),
+]
+
+
+def run_check():
+    proc = subprocess.run(
+        [ "node", str(CHECK) ], cwd=str(HERE), capture_output=True, text=True,
+        encoding="utf-8", errors="replace",
+    )
+    return proc.returncode == 0, proc.stdout + proc.stderr
+
+
+def main():
+    original = CLIENT.read_bytes()
+    ok, output = run_check()
+    if not ok:
+        print("baseline client-check.mjs did not pass; refusing to run mutations")
+        print(output)
+        return 1
+
+    failures = []
+    for name, expected_guard, old, new in CASES:
+        text = original.decode("utf-8")
+        if text.count(old) != 1:
+            failures.append(f"{name}: anchor matched {text.count(old)} times, expected exactly 1")
+            continue
+
+        CLIENT.write_bytes(text.replace(old, new, 1).encode("utf-8"))
+        try:
+            passed, mutated_output = run_check()
+        finally:
+            CLIENT.write_bytes(original)
+
+        if passed:
+            failures.append(f"{name}: NOT CAUGHT — client-check.mjs still passed")
+            continue
+
+        fired = [g for g in (WIDTH_GUARD, SHARED_GUARD, CONTAIN_GUARD,
+                             RANGE_WIDTH_GUARD, RANGE_NO_PX_GUARD)
+                 if ("policy: " + g) in mutated_output]
+        if fired != [expected_guard]:
+            failures.append(f"{name}: caught by {fired or 'nothing'}, expected ['{expected_guard}']")
+            continue
+
+        print(f"  caught by the right guard: {name}")
+
+    restored = CLIENT.read_bytes() == original
+    if not restored:
+        failures.append("index.html was not restored byte-for-byte")
+    else:
+        print("index.html restored byte-for-byte")
+
+    if failures:
+        print("\nFAILURES:")
+        for line in failures:
+            print(" - " + line)
+        return 1
+
+    print(f"\nOK  ({len(CASES)} mutations, each caught by its own guard)")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/plugins/avatasia/mmc-trajectory/tests/mutate-label-source.py b/plugins/avatasia/mmc-trajectory/tests/mutate-label-source.py
new file mode 100644
index 0000000..2502d3f
--- /dev/null
+++ b/plugins/avatasia/mmc-trajectory/tests/mutate-label-source.py
@@ -0,0 +1,66 @@
+"""Mutation control for the two label-source guards.
+
+Without this, "kind button labels match KIND_LABELS" and "every kind button has a label
+span" could both be satisfied by a page that has no drift because nothing ever drifted —
+the same false green that let the 问答→答复 rename half-apply in the first place.
+"""
+import io
+import os
+import subprocess
+import sys
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+ROOT = os.path.dirname(HERE)
+CLIENT = os.path.join(ROOT, "miniapp", "client", "index.html")
+PROBE = os.path.join(HERE, "client-check.mjs")
+
+MUTATIONS = [
+    ("markup label drifts from KIND_LABELS",
+     '<span class="tbtn-label">\u7b54\u590d</span>',
+     '<span class="tbtn-label">\u95ee\u7b54</span>',
+     "kind button labels match KIND_LABELS"),
+    ("a kind button loses its label span",
+     '<span class="tbtn-label">\u601d\u8003</span>',
+     '<span>\u601d\u8003</span>',
+     "every kind button has a label span"),
+]
+
+original = io.open(CLIENT, encoding="utf-8", newline="").read()
+
+
+def run():
+    proc = subprocess.run(["node", PROBE], cwd=HERE,
+                          capture_output=True, text=True, encoding="utf-8", errors="replace")
+    return proc.stdout + proc.stderr
+
+
+ok = True
+baseline = run()
+base_ok = "0 failed" in baseline
+print(("ok   " if base_ok else "FAIL ") + "baseline green")
+ok = ok and base_ok
+
+caught_all = []
+for title, old, new, expect in MUTATIONS:
+    if original.count(old) != 1:
+        raise SystemExit("FAIL  anchor for %r matched %d times" % (title, original.count(old)))
+    try:
+        io.open(CLIENT, "w", encoding="utf-8", newline="").write(original.replace(old, new, 1))
+        during = run()
+        named = expect in during
+        failed = "0 failed" not in during
+        print(("ok   " if (named and failed) else "FAIL ") + "guard catches: " + title)
+        for line in during.splitlines():
+            if "label" in line and line.strip().startswith("-"):
+                print("       " + line.strip())
+        caught_all.append(named and failed)
+    finally:
+        io.open(CLIENT, "w", encoding="utf-8", newline="").write(original)
+
+restored = io.open(CLIENT, encoding="utf-8", newline="").read()
+after = run()
+after_ok = "0 failed" in after
+print(("ok   " if restored == original else "FAIL ") + "client restored byte for byte")
+print(("ok   " if after_ok else "FAIL ") + "green again after restore")
+
+sys.exit(0 if (ok and all(caught_all) and restored == original and after_ok) else 1)
diff --git a/plugins/avatasia/mmc-trajectory/tests/mutate-ledger-batch.py b/plugins/avatasia/mmc-trajectory/tests/mutate-ledger-batch.py
new file mode 100644
index 0000000..2aee741
--- /dev/null
+++ b/plugins/avatasia/mmc-trajectory/tests/mutate-ledger-batch.py
@@ -0,0 +1,237 @@
+"""Mutation control for the batched ledger build.
+
+A guard that cannot fail is not a guard. Each mutation below breaks one of the rules in
+verify-ledger-batch.mjs the way it would actually break in the file, and requires that guard to fail
+with the right reason before the file is restored byte for byte.
+
+The rules come in four groups, and the mutations are grouped the same way: the frame is really
+handed back; a new exit retires the build in flight; progress goes through the one writer of the
+count; and a poll defers without swallowing the tick.
+
+Two of them are about things that are easy to write and hard to see. "The batch size is not a cap"
+is the promise 「显示全部」 makes — a loop bounded by the batch constant instead of the group count
+still looks like a batched build and quietly shows only the first N turns. And "the token is tested
+before the first row is built" is the difference between a stale build stopping and a stale build
+putting one more section into a ledger that has already been emptied.
+"""
+import io
+import os
+import subprocess
+import sys
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+ROOT = os.path.dirname(HERE)
+CLIENT = os.path.join(ROOT, "miniapp", "client", "index.html")
+PROBE = os.path.join(HERE, "verify-ledger-batch.mjs")
+
+MUTATIONS = [
+    # ---- 1. the frame is really handed back ------------------------------------
+
+    # The original defect wearing a batch: recursion instead of a frame callback is still one
+    # unbroken second and a half of main thread.
+    ("the batch recurses instead of yielding a frame",
+     [("            window.requestAnimationFrame(buildStep);\n",
+       "            buildStep();\n")],
+     "the build hands the frame back between batches"),
+
+    # The guard above the hand-off moved below it. Harmless-looking, and it re-arms a frame after
+    # the last group — the build never ends and the count never stops moving.
+    ("the frame is handed back even when there is nothing left to build",
+     [("          if (build.at < groups.length) {\n"
+       "            setLedgerProgress(build.rows, buildTotal);\n"
+       "            window.requestAnimationFrame(buildStep);\n"
+       "            return;\n"
+       "          }\n",
+       "          setLedgerProgress(build.rows, buildTotal);\n"
+       "          window.requestAnimationFrame(buildStep);\n"
+       "          if (build.at < groups.length) return;\n")],
+     "a window that fits in one batch does not spend a frame"),
+
+    # ---- the promise is unchanged ----------------------------------------------
+
+    # 「显示全部」 stops meaning all. Still looks like a batched build.
+    ("the batch size becomes a cap on what the table holds",
+     [("          while (build.at < groups.length && built < LEDGER_BATCH_GROUPS) {\n",
+       "          while (build.at < LEDGER_BATCH_GROUPS) {\n")],
+     "显示全部 still means every record: the batch size is not a cap"),
+
+    ("the batch stops advancing its cursor",
+     [("            build.at += 1;\n", "")],
+     "the batch always advances its cursor"),
+
+    # Zero groups never increments `built`, so the loop schedules itself every frame forever.
+    ("the batch is zero groups",
+     [("      var LEDGER_BATCH_GROUPS = 25;\n", "      var LEDGER_BATCH_GROUPS = 0;\n")],
+     "the batch is at least one group"),
+
+    # ---- 2. a new exit retires the build in flight ------------------------------
+    #
+    # Re-anchored 2026-10-12 for D14. These two used to hang off `ledgerBuildToken += 1;`
+    # followed by `applyFilterScope();`, which is where the bump sat before the four early
+    # returns below it were found to retire nothing. The bump now sits directly above
+    # `clear(ledger);`, so the line that follows it changed. The rules they encode did not.
+
+    ("the exit retires the build twice",
+     [("        ledgerBuildToken += 1;\n        clear(ledger);\n",
+       "        ledgerBuildToken += 1;\n        ledgerBuildToken += 1;\n        clear(ledger);\n")],
+     "every pass through the exit retires the build in flight"),
+
+    # The new build is handed the token the previous build was still using, so the two compare
+    # equal and the interleaving the token exists to prevent becomes possible.
+    ("the new build claims a token that is not yet retired",
+     [("        ledgerBuildToken += 1;\n        clear(ledger);\n", "        clear(ledger);\n"),
+      ("        var build = { token: ledgerBuildToken, at: 0, rows: 0 };\n",
+       "        var build = { token: ledgerBuildToken, at: 0, rows: 0 };\n        ledgerBuildToken += 1;\n")],
+     "the exit retires the old build before the new one claims a token"),
+
+    # D14: the bump has to be above clear(ledger), not merely somewhere earlier. Put it back
+    # where it was — below the four early returns — and a pass that returns early (loading,
+    # error, no payload, no sessions) retires nothing, so the previous build goes on appending
+    # turn groups into whatever that pass left in the ledger. The bump line itself is still
+    # there and still unique, which is why verify-ledger-batch.mjs counts the returns between it
+    # and clear() rather than asserting a position.
+    ("a pass that returns early retires nothing",
+     [("        ledgerBuildToken += 1;\n        clear(ledger);\n", "        clear(ledger);\n"),
+      ("        var matched = visibleEntries();\n",
+       "        ledgerBuildToken += 1;\n        var matched = visibleEntries();\n")],
+     "no early return sits between the token bump and the clear"),
+
+    ("a replaced build keeps appending",
+     [("          if (build.token !== ledgerBuildToken) return;\n", "")],
+     "a build whose exit has been replaced stops without appending"),
+
+    # Checks after the work rather than before it: the stale build puts one more section into a
+    # ledger renderLedger() has already emptied.
+    ("the token is checked after the rows are already built",
+     [("          if (build.token !== ledgerBuildToken) return;\n", ""),
+      ("          if (build.at < groups.length) {\n",
+       "          if (build.token !== ledgerBuildToken) return;\n          if (build.at < groups.length) {\n")],
+     "the token is tested before the first row is built"),
+
+    # ---- 3. one writer of the count --------------------------------------------
+
+    ("progress reaches for the count node itself",
+     [("        ledgerProgress = rows === null ? null : { rows: rows, total: total };\n",
+       "        ledgerProgress = rows === null ? null : { rows: rows, total: total };\n"
+       "        document.getElementById('window-count').textContent = String(rows);\n")],
+     "progress is reported through the one writer of the count"),
+
+    # A second writer of the count. The variable is fetched into a local `parts` on purpose: the
+    # guard counts `parts.count.textContent =` occurrences, and writing through windowBarParts
+    # directly would not match that pattern — a mutation that does not actually add a writer proves
+    # nothing about whether the guard would notice one.
+    ("a second writer of the window bar count",
+     [("        if (ledgerWindow) {\n",
+       "        var parts = windowBarParts;\n        if (parts) parts.count.textContent = 'building';\n        if (ledgerWindow) {\n")],
+     "the window bar count has exactly one writer"),
+
+    # 「已显示 18,924 条」 above three thousand rows that exist — the page promising a number it
+    # has not reached, which is the defect this exit exists to prevent.
+    ("the mid-build count claims the rows are already shown",
+     [("            '共 ' + formatInt(total) + ' 条 · 正在显示 ' + formatInt(ledgerProgress.rows) +\n"
+       "            ' / ' + formatInt(ledgerProgress.total) + ' 条';\n",
+       "            '共 ' + formatInt(total) + ' 条 · 已显示 ' + formatInt(shown.length) + ' 条';\n")],
+     "the mid-build count reports rows built, not rows promised"),
+
+    ("progress outlives the build",
+     [("          setLedgerProgress(null);\n          restoreRowAnchor(anchor, scrollY);\n",
+       "          restoreRowAnchor(anchor, scrollY);\n")],
+     "progress cannot outlive the build"),
+
+    # Falls through and overwrites itself with the progress line, so a settled window keeps
+    # reading 「正在显示 …」 for ever.
+    ("a settled window is still reported as mid-build",
+     [("            ' / ' + formatInt(ledgerProgress.total) + ' 条';\n          return;\n        }\n",
+       "            ' / ' + formatInt(ledgerProgress.total) + ' 条';\n        }\n")],
+     "a settled window is not reported as mid-build"),
+
+    # ---- 4. the poll defers, and the deferral is not swallowed ------------------
+
+    # The build takes ~4 s and the interval is 2.5 s, so this is the difference between a progress
+    # bar and a counter that resets to zero forever.
+    ("a poll replaces a table that is still being built",
+     [("          if (ledgerBuilding()) {\n"
+       "            pollDeferred = true;\n"
+       "            return;\n"
+       "          }\n", "")],
+     "a poll never replaces a table that is still being built"),
+
+    # Cleared after the fetch, so every flush re-arms itself and the page polls once per frame.
+    ("the held-back poll re-arms itself",
+     [("        pollDeferred = false;\n        fetchSessions();\n        fetchTrajectory(false);\n",
+       "        fetchSessions();\n        fetchTrajectory(false);\n        pollDeferred = false;\n")],
+     "the held-back poll is run once, and only once"),
+
+    ("the held-back poll is swallowed at the end of a build",
+     [("          flushDeferredPoll();\n", "          /* dropped */\n")],
+     "the held-back poll is not swallowed at the end of a build"),
+
+    # A second flag that has to agree with the progress one, and the day it stops agreeing the
+    # poll starts replacing tables that are still being built.
+    ("the in-flight flag becomes a second variable",
+     [("      function ledgerBuilding() {\n        return ledgerProgress !== null;\n      }\n",
+       "      function ledgerBuilding() {\n        return buildRunning !== null;\n      }\n")],
+     "the in-flight flag is derived from the progress, not a second variable"),
+
+    # ---- the finishing path -----------------------------------------------------
+
+    # Measuring first and flushing second puts the strip measurement ahead of a call that can
+    # start the next exit. verify-sticky.mjs pins the measurement as the last thing the finishing
+    # path does; this breaks that from the other end. The second anchor carries the closing brace,
+    # because `syncStickyOffsets();` on its own also matches scheduleStickyOffsets' own call.
+    ("the finishing path measures before it flushes",
+     [("          flushDeferredPoll();\n", "          /* moved below */\n"),
+      ("          syncStickyOffsets();\n        }\n",
+       "          syncStickyOffsets();\n          flushDeferredPoll();\n        }\n")],
+     "the finishing path anchors, then flushes, then measures"),
+]
+
+original = io.open(CLIENT, encoding="utf-8", newline="").read()
+
+
+def run():
+    proc = subprocess.run(["node", PROBE], cwd=HERE,
+                          capture_output=True, text=True, encoding="utf-8", errors="replace")
+    return proc.returncode, proc.stdout + proc.stderr
+
+
+ok = True
+code, baseline = run()
+base_ok = code == 0 and "0 failed" in baseline
+print(("ok   " if base_ok else "FAIL ") + "baseline green")
+ok = ok and base_ok
+
+caught = []
+for title, edits, expect in MUTATIONS:
+    for old, _ in edits:
+        hits = original.count(old)
+        if hits != 1:
+            raise SystemExit("FAIL  anchor for %r matched %d times" % (title, hits))
+    try:
+        mutated = original
+        for old, new in edits:
+            mutated = mutated.replace(old, new, 1)
+        io.open(CLIENT, "w", encoding="utf-8", newline="").write(mutated)
+        during_code, during = run()
+        named = expect in during
+        red = during_code != 0
+        # A guard that crashes is not a guard that caught anything: the rule has to be reported by
+        # name, or the mutation only proved that the file no longer parses.
+        print(("ok   " if (named and red) else "FAIL ") + "guard catches: " + title)
+        if not named:
+            print("       no assertion reported %r" % expect)
+            for line in during.splitlines()[-4:]:
+                print("       " + line.strip())
+        elif not red:
+            print("       the rule was reported but the guard still exited 0")
+        caught.append(named and red)
+    finally:
+        io.open(CLIENT, "w", encoding="utf-8", newline="").write(original)
+
+restored = io.open(CLIENT, encoding="utf-8", newline="").read()
+after_code, after = run()
+after_ok = after_code == 0 and "0 failed" in after
+print(("ok   " if restored == original else "FAIL ") + "client restored byte for byte")
+print(("ok   " if after_ok else "FAIL ") + "green again after restore")
+
+sys.exit(0 if (ok and all(caught) and restored == original and after_ok) else 1)
diff --git a/plugins/avatasia/mmc-trajectory/tests/mutate-name-collision.py b/plugins/avatasia/mmc-trajectory/tests/mutate-name-collision.py
new file mode 100644
index 0000000..9b3bc99
--- /dev/null
+++ b/plugins/avatasia/mmc-trajectory/tests/mutate-name-collision.py
@@ -0,0 +1,58 @@
+"""Mutation control for the new "no record kind is labelled 问答" guard.
+
+A guard that cannot fail proves nothing. Flip the real client source so a record kind
+does claim 问答, confirm the guard fires, put the file back byte for byte, and confirm
+it goes green again. If either half is skipped the assertion is worthless.
+"""
+import io
+import os
+import subprocess
+import sys
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+ROOT = os.path.dirname(HERE)
+CLIENT = os.path.join(ROOT, "miniapp", "client", "index.html")
+PROBE = os.path.join(HERE, "client-check.mjs")
+
+original = io.open(CLIENT, encoding="utf-8", newline="").read()
+mutated = original.replace("reply: '\u7b54\u590d'", "reply: '\u95ee\u7b54'", 1)
+if mutated == original:
+    sys.exit("FAIL  anchor not found — the rename must land before this runs")
+
+
+def run():
+    proc = subprocess.run([sys.executable and "node", PROBE], cwd=HERE,
+                          capture_output=True, text=True, encoding="utf-8", errors="replace")
+    return proc.stdout + proc.stderr
+
+
+try:
+    # baseline
+    baseline = run()
+    ok_before = "0 failed" in baseline
+    print(("ok   " if ok_before else "FAIL ") + "baseline green before mutation")
+
+    # mutated
+    io.open(CLIENT, "w", encoding="utf-8", newline="").write(mutated)
+    during = run()
+    # How many assertions this breaks depends on how far KIND_LABELS feeds the rest of the
+    # page — renaming the label breaks the helper test, the static check, and the button-markup
+    # comparison together, so it was 3 before anyone read the number. Test "not green" and
+    # "the guard is named", not a hardcoded failure count that goes stale on the next change.
+    named = "no record kind is labelled" in during
+    failed = not ("0 failed" in during)
+    caught = named and failed
+    print(("ok   " if caught else "FAIL ") + "guard fires when a record kind claims 问答")
+    for line in during.splitlines():
+        if "问答" in line or "failed" in line:
+            print("       " + line.strip())
+finally:
+    io.open(CLIENT, "w", encoding="utf-8", newline="").write(original)
+
+restored = io.open(CLIENT, encoding="utf-8", newline="").read()
+print(("ok   " if restored == original else "FAIL ") + "client source restored byte for byte")
+after = run()
+ok_after = "0 failed" in after
+print(("ok   " if ok_after else "FAIL ") + "green again after restore")
+
+sys.exit(0 if (ok_before and caught and restored == original and ok_after) else 1)
diff --git a/plugins/avatasia/mmc-trajectory/tests/mutate-parsed-rows.py b/plugins/avatasia/mmc-trajectory/tests/mutate-parsed-rows.py
new file mode 100644
index 0000000..ef3b6b9
--- /dev/null
+++ b/plugins/avatasia/mmc-trajectory/tests/mutate-parsed-rows.py
@@ -0,0 +1,193 @@
+"""Mutation control for verify-parsed-rows.mjs.
+
+Each mutation reintroduces exactly one bug the probe is supposed to catch. The probe must FAIL
+every time, and the file must come back byte-for-byte identical afterwards. A mutation that the
+probe still passes means the assertion was tautological; a mutation whose anchor no longer
+exists means the assertion went dead, which is worse — the runner reports those as misses too.
+
+Every mutation here is non-trivial: it changes behaviour under the condition the assertion is
+about, not just text. In particular the four key mutations each break a *different* component,
+because a key that drops two of them would still be caught by the wrong test and we would not
+learn which one mattered.
+"""
+import subprocess
+import sys
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parent
+ROOT = HERE.parent
+SERVER = ROOT / "miniapp" / "node" / "server.mjs"
+PROBE = HERE / "verify-parsed-rows.mjs"
+
+MUTATIONS = [
+    # ---- the key: each component removed on its own -------------------------------
+    (
+        "server: the key stops naming the file, so two sessions share their messages.jsonl",
+        SERVER,
+        "  return `${filePath}|${size}|${mtimeMs}|${limit}`;",
+        "  return `${filePath.split(/[\\\\/]/).pop()}|${size}|${mtimeMs}|${limit}`;",
+    ),
+    (
+        "server: the key stops carrying the size, so a grown file serves a stale tail",
+        SERVER,
+        "  return `${filePath}|${size}|${mtimeMs}|${limit}`;",
+        "  return `${filePath}|${mtimeMs}|${limit}`;",
+    ),
+    (
+        "server: the key stops carrying the mtime, so a same-size rewrite serves stale rows",
+        SERVER,
+        "  return `${filePath}|${size}|${mtimeMs}|${limit}`;",
+        "  return `${filePath}|${size}|${limit}`;",
+    ),
+    (
+        "server: the key stops carrying the limit, so the truncation verdict is read at another width",
+        SERVER,
+        "  return `${filePath}|${size}|${mtimeMs}|${limit}`;",
+        "  return `${filePath}|${size}|${mtimeMs}|64 * 1024 * 1024`;",
+    ),
+    # ---- the cache value ----------------------------------------------------------
+    (
+        "server: `empty` is not carried on the cached value, so a hit stops reporting it",
+        SERVER,
+        "    empty: head.text === '',\n",
+        "    empty: false,\n",
+    ),
+    (
+        "server: `skipped` is not carried, so a hit under-counts the lines it dropped",
+        SERVER,
+        "    skipped: parsed.skipped,\n",
+        "    skipped: 0,\n",
+    ),
+    # ---- the budget ---------------------------------------------------------------
+    (
+        "the budget stops evicting, so the cache grows without limit",
+        SERVER,
+        """      while (bytes > budget && entries.size > 1) {
+        const oldest = entries.keys().next();
+        if (oldest.done) break;
+        const victim = entries.get(oldest.value);
+        entries.delete(oldest.value);
+        bytes -= victim ? victim.size : 0;
+      }
+""",
+        "",
+    ),
+    (
+        "reading stops refreshing recency, so the 22 frozen files get evicted by insertion order",
+        SERVER,
+        """      // Re-reading is the only signal that a file is still hot, so it refreshes recency.
+      entries.delete(key);
+      entries.set(key, hit);
+      return hit.value;
+""",
+        "      return hit.value;\n",
+    ),
+    (
+        "an entry larger than the whole budget is stored anyway, evicting everything for one hit",
+        SERVER,
+        "      if (size > budget) return bytes;\n",
+        "",
+    ),
+    (
+        "re-storing a key double-counts it, so the budget shrinks over time",
+        SERVER,
+        """      const previous = entries.get(key);
+      if (previous !== undefined) {
+        bytes -= previous.size;
+        entries.delete(key);
+      }
+""",
+        "",
+    ),
+    # ---- structure ----------------------------------------------------------------
+    (
+        "the cache becomes a module-level singleton, shared across every runtime instance",
+        SERVER,
+        "  const parsedRows = createParsedRowsCache(PARSED_ROWS_CACHE_BYTES);",
+        "  globalThis.__parsedRows = globalThis.__parsedRows || createParsedRowsCache(PARSED_ROWS_CACHE_BYTES);\n  const parsedRows = globalThis.__parsedRows;",
+    ),
+    (
+        "the route parses the file inline again instead of going through the cache",
+        SERVER,
+        "        parsedFile = await loadParsedRows(parsedRows, filePath, limit);",
+        "        parsedFile = await (async () => { const h = await readHead(filePath, limit); const p = parseMessagesJsonl(h.text); return { rows: p.rows, skipped: p.skipped, size: h.size, read: h.read, empty: h.text === '', truncated: truncatedByCap(h.size, limit) }; })();",
+    ),
+]
+
+
+def read_exact(path):
+    """Normalise to LF for matching, and report the file's own newline so it can be put back.
+
+    server.mjs is CRLF in the working tree. Matching against the raw bytes would make every
+    multi-line anchor miss — which the runner reports as a surviving mutation, so the failure
+    looks like a dead guard rather than a broken anchor.
+    """
+    data = path.read_bytes()
+    text = data.decode("utf-8").replace("\r\n", "\n")
+    return text, ("\r\n" if b"\r\n" in data else "\n")
+
+
+def write_exact(path, text, newline):
+    if newline == "\r\n":
+        text = text.replace("\n", "\r\n")
+    path.write_bytes(text.encode("utf-8"))
+
+
+def run_probe():
+    proc = subprocess.run(
+        ["node", str(PROBE)],
+        cwd=str(ROOT),
+        capture_output=True,
+        text=True,
+        encoding="utf-8",
+        errors="replace",
+    )
+    return proc.returncode, (proc.stdout or "") + (proc.stderr or "")
+
+
+def main():
+    code, output = run_probe()
+    if code != 0:
+        print("baseline probe does not pass; fix that first")
+        print(output)
+        return 1
+    print("baseline clean")
+
+    originals = {path: path.read_bytes() for path in {m[1] for m in MUTATIONS}}
+    missed = []
+    for label, path, old, new in MUTATIONS:
+        text, newline = read_exact(path)
+        if old not in text:
+            print(f"SKIP  {label}: anchor not found in {path.name}")
+            missed.append(label)
+            continue
+        write_exact(path, text.replace(old, new, 1), newline)
+        try:
+            code, output = run_probe()
+        finally:
+            path.write_bytes(originals[path])
+        if code == 0:
+            print(f"MISSED {label}: the probe still passed")
+            missed.append(label)
+        else:
+            first = next(
+                (line.strip() for line in output.splitlines() if line.strip().startswith("- ")),
+                "(no detail)",
+            )
+            print(f"caught {label}\n         -> {first}")
+
+    for path, data in originals.items():
+        if path.read_bytes() != data:
+            print(f"NOT RESTORED {path}")
+            return 1
+    print("all files restored byte-for-byte")
+
+    if missed:
+        print(f"\n{len(missed)} mutation(s) got through")
+        return 1
+    print(f"\nall {len(MUTATIONS)} mutations caught")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
\ No newline at end of file
diff --git a/plugins/avatasia/mmc-trajectory/tests/mutate-pr15-fixes.py b/plugins/avatasia/mmc-trajectory/tests/mutate-pr15-fixes.py
new file mode 100644
index 0000000..62e3aac
--- /dev/null
+++ b/plugins/avatasia/mmc-trajectory/tests/mutate-pr15-fixes.py
@@ -0,0 +1,149 @@
+"""Mutation control for verify-pr15-fixes.mjs.
+
+Each mutation reintroduces exactly one bug the probe is supposed to catch. The probe must FAIL
+every time, and the file must come back byte-for-byte identical afterwards. A mutation that the
+probe still passes means the assertion was tautological.
+"""
+import subprocess
+import sys
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parent
+ROOT = HERE.parent
+SERVER = ROOT / "miniapp" / "node" / "server.mjs"
+CLIENT = ROOT / "miniapp" / "client" / "index.html"
+PROBE = HERE / "verify-pr15-fixes.mjs"
+
+MUTATIONS = [
+    (
+        "server: list the whole catalog again (orphan counted + offered)",
+        SERVER,
+        "  const generations = (Array.isArray(input.generations) ? input.generations : [])\n"
+        "    .filter((entry) => !orphanFiles.has(entry.fileName));",
+        "  const generations = Array.isArray(input.generations) ? input.generations : [];",
+    ),
+    (
+        "server: match orphans by generation number instead of file name",
+        SERVER,
+        "  const orphanFiles = new Set(orphans.map((orphan) => orphan.fileName));",
+        "  const orphanFiles = new Set(orphans.map((orphan) => String(orphan.generation)));",
+    ),
+    (
+        "server: truncation fires on any read that fell short of the file",
+        SERVER,
+        "  return size > limit;",
+        "  return size >= limit - 1;",
+    ),
+    (
+        "server: truncation fires on any read that fell short of the file (strict)",
+        SERVER,
+        "  return size > limit;",
+        "  return size !== limit;",
+    ),
+    (
+        # The verdict now lives where the parse result is built rather than at the point of
+        # use, because a cache hit has to carry it too — otherwise a hit would silently report
+        # an untruncated file that the read that populated it had cut short.
+        "server: the route stops using the tested helper",
+        SERVER,
+        "truncated: truncatedByCap(head.size, limit),",
+        "truncated: head.read < head.size,",
+    ),
+    (
+        "server: catalog-recorded size as the read limit again",
+        SERVER,
+        "      const limit = MAX_MESSAGE_BYTES;",
+        "      const limit = Math.min(entry.sizeBytes, identity.catalogBytes ?? MAX_MESSAGE_BYTES, MAX_MESSAGE_BYTES);",
+    ),
+    (
+        "server: probe reads a truncated head budget again",
+        SERVER,
+        "const head = await readHead(filePath, GENERATION_PROBE_BYTES);",
+        "const head = await readHead(filePath, 512);",
+    ),
+    (
+        "server: stop sending the cap to the page",
+        SERVER,
+        "      maxMessageBytes: MAX_MESSAGE_BYTES,\n",
+        "",
+    ),
+    (
+        "client: hardcode the number instead of rendering the cap",
+        CLIENT,
+        "          dom.footerTruncated.textContent = '文件过大，仅显示前 ' + formatBytes(session.maxMessageBytes) + '。';",
+        "          dom.footerTruncated.textContent = '文件过大，仅显示前 8 MB。';",
+    ),
+]
+
+
+def read_exact(path):
+    """Read with every line ending normalised to \\n, and remember which style the file used.
+
+    `Path.read_text` folds CRLF into LF and `Path.write_text` puts the platform's line ending
+    back, so the usual pair silently rewrites a file's endings for the duration of a mutation.
+    server.mjs is CRLF and index.html is LF here, and several client guards match CSS rules with
+    a literal `\\n`, so a mutated client run would fail them for a reason that has nothing to do
+    with the mutation and the report would name the wrong guard.
+    """
+    raw = path.read_bytes().decode("utf-8")
+    return raw.replace("\r\n", "\n"), ("\r\n" if "\r\n" in raw else "\n")
+
+
+def write_exact(path, text, newline):
+    with open(path, "wb") as handle:
+        handle.write(text.replace("\n", newline).encode("utf-8"))
+
+
+def run_probe():
+    result = subprocess.run(
+        ["node", str(PROBE)], cwd=str(HERE), capture_output=True, text=True
+    )
+    return result.returncode, result.stdout + result.stderr
+
+
+def main():
+    code, output = run_probe()
+    if code != 0:
+        print("baseline probe does not pass; fix that first")
+        print(output)
+        return 1
+    print("baseline clean")
+
+    originals = {path: path.read_bytes() for path in {m[1] for m in MUTATIONS}}
+    missed = []
+    for label, path, old, new in MUTATIONS:
+        text, newline = read_exact(path)
+        if old not in text:
+            print(f"SKIP  {label}: anchor not found in {path.name}")
+            missed.append(label)
+            continue
+        write_exact(path, text.replace(old, new, 1), newline)
+        try:
+            code, output = run_probe()
+        finally:
+            path.write_bytes(originals[path])
+        if code == 0:
+            print(f"MISSED {label}: the probe still passed")
+            missed.append(label)
+        else:
+            first = next(
+                (line.strip() for line in output.splitlines() if line.strip().startswith("-")),
+                "(no detail)",
+            )
+            print(f"caught {label}\n         -> {first}")
+
+    for path, data in originals.items():
+        if path.read_bytes() != data:
+            print(f"NOT RESTORED {path}")
+            return 1
+    print("all files restored byte-for-byte")
+
+    if missed:
+        print(f"\n{len(missed)} mutation(s) got through")
+        return 1
+    print(f"\nall {len(MUTATIONS)} mutations caught")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
\ No newline at end of file
diff --git a/plugins/avatasia/mmc-trajectory/tests/mutate-raw-lazy.py b/plugins/avatasia/mmc-trajectory/tests/mutate-raw-lazy.py
new file mode 100644
index 0000000..3c23487
--- /dev/null
+++ b/plugins/avatasia/mmc-trajectory/tests/mutate-raw-lazy.py
@@ -0,0 +1,189 @@
+"""Mutation control for verify-raw-lazy.mjs.
+
+Each mutation reintroduces exactly one regression the probe is supposed to catch, and the
+file must come back byte-for-byte afterwards. Anchors are matched against LF-normalised text
+and written back in each file's own newline (server.mjs is CRLF, index.html is LF) — matching
+raw bytes would make every multi-line anchor miss, and the runner reports a missed anchor the
+same way it reports a surviving mutation, which hides which one broke.
+"""
+import subprocess
+import sys
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parent
+ROOT = HERE.parent
+SERVER = ROOT / "miniapp" / "node" / "server.mjs"
+CLIENT = ROOT / "miniapp" / "client" / "index.html"
+PROBE = HERE / "verify-raw-lazy.mjs"
+
+MUTATIONS = [
+    # ---- the bulk payload must not carry the message -------------------------
+    (
+        "server: the record carries the message again, so every poll serializes the session",
+        SERVER,
+        "      rawRow: rowIndex,\n",
+        "      rawRow: rowIndex, raw: source,\n",
+    ),
+    (
+        "server: the omitted verdict goes back on the record",
+        SERVER,
+        "      rawRow: rowIndex,\n",
+        "      rawRow: rowIndex, rawOmitted: false,\n",
+    ),
+    # ---- the locator must actually point at the row -------------------------
+    (
+        "server: every locator points at the first row",
+        SERVER,
+        "      raws.set(index, rowIndex);",
+        "      raws.set(index, 0);",
+    ),
+    (
+        # The line grew a `typeof` clause when a null locator was found resolving to row zero;
+        # the check this removes is the same one, at the same place.
+        "server: a locator past the end of rows is accepted",
+        SERVER,
+        "      if (Number.isInteger(index) && index > 0 && typeof rowIndex === 'number' && Number.isInteger(rowIndex) && rowIndex >= 0) {\n",
+        "      if (Number.isInteger(index) && index > 0) {\n",
+    ),
+    (
+        "server: the locator is not removed from the record, so it reaches the page",
+        SERVER,
+        "      delete record.rawRow;\n",
+        "",
+    ),
+    # ---- /raw must build, and must say --------------------------------------
+    (
+        "server: /raw hands back a stored message instead of building one",
+        SERVER,
+        "    const built = buildRawPayload(row.message, redact);\n",
+        "    const built = { value: row.message, omitted: false };\n",
+    ),
+    (
+        "server: /raw stops reporting whether the message was too large",
+        SERVER,
+        "sendJson(response, 200, { index: wanted, raw: built.value, omitted: built.omitted });",
+        "sendJson(response, 200, { index: wanted, raw: built.value });",
+    ),
+    (
+        "server: /raw keeps the rows out of the cache entry, so it cannot resolve a locator",
+        SERVER,
+        "trajectoryCache.set(cacheKey, { at: Date.now(), etag, body, raws, rows });",
+        "trajectoryCache.set(cacheKey, { at: Date.now(), etag, body, raws });",
+    ),
+    # ---- the cap must still hold, wherever it now lives ----------------------
+    (
+        "server: the 64 KB cap stops being applied, so a huge message is carried whole",
+        SERVER,
+        "  if (Buffer.byteLength(serialized, 'utf8') > MAX_RAW_BYTES) return { value: null, omitted: true };",
+        "  if (false) return { value: null, omitted: true };",
+    ),
+    # ---- the five readers ---------------------------------------------------
+    (
+        "client: the handoff reads the verdict off the record again",
+        CLIENT,
+        "        if (rawOmitted) lines.push('- 提示：原文过大已被省略。');",
+        "        if (record.rawOmitted) lines.push('- 提示：原文过大已被省略。');",
+    ),
+    (
+        "client: rawSourceFor short-circuits on a field that no longer exists",
+        CLIENT,
+        "      function rawSourceFor(record) {\n        return fetchRaw(record);\n      }",
+        "      function rawSourceFor(record) {\n        if (record && record.rawOmitted) return Promise.resolve({ raw: null, omitted: true });\n        return fetchRaw(record);\n      }",
+    ),
+    (
+        "client: the raw tab stops drawing the omitted notice",
+        CLIENT,
+        "          if (fetched.omitted === true) {\n",
+        "          if (false) {\n",
+    ),
+    (
+        "client: the raw tab shows the message even when it was omitted",
+        CLIENT,
+        "            pre.textContent = DASH;\n            return;",
+        "            pre.innerHTML = jsonColorize(fetched.raw);\n            return;",
+    ),
+    (
+        "client: copySelected stops honouring the omitted verdict",
+        CLIENT,
+        "          var noRaw = fetched.omitted === true || fetched.raw === null || fetched.raw === undefined;",
+        "          var noRaw = fetched.raw === null || fetched.raw === undefined;",
+    ),
+    (
+        "client: fetchRaw caches the message but drops the verdict",
+        CLIENT,
+        "            var entry = { raw: result.body.raw, omitted: result.body.omitted === true };",
+        "            var entry = { raw: result.body.raw, omitted: false };",
+    ),
+]
+
+
+def read_exact(path):
+    data = path.read_bytes()
+    text = data.decode("utf-8").replace("\r\n", "\n")
+    return text, ("\r\n" if b"\r\n" in data else "\n")
+
+
+def write_exact(path, text, newline):
+    if newline == "\r\n":
+        text = text.replace("\n", "\r\n")
+    path.write_bytes(text.encode("utf-8"))
+
+
+def run_probe():
+    proc = subprocess.run(
+        ["node", str(PROBE)],
+        cwd=str(ROOT),
+        capture_output=True,
+        text=True,
+        encoding="utf-8",
+        errors="replace",
+    )
+    return proc.returncode, (proc.stdout or "") + (proc.stderr or "")
+
+
+def main():
+    code, output = run_probe()
+    if code != 0:
+        print("baseline probe does not pass; fix that first")
+        print(output)
+        return 1
+    print("baseline clean")
+
+    originals = {path: path.read_bytes() for path in {m[1] for m in MUTATIONS}}
+    missed = []
+    for label, path, old, new in MUTATIONS:
+        text, newline = read_exact(path)
+        if old not in text:
+            print(f"SKIP  {label}: anchor not found in {path.name}")
+            missed.append(label)
+            continue
+        write_exact(path, text.replace(old, new, 1), newline)
+        try:
+            code, output = run_probe()
+        finally:
+            path.write_bytes(originals[path])
+        if code == 0:
+            print(f"MISSED {label}: the probe still passed")
+            missed.append(label)
+        else:
+            first = next(
+                (line.strip() for line in output.splitlines() if line.strip().startswith("- ")),
+                "(no detail)",
+            )
+            print(f"caught {label}\n         -> {first}")
+
+    for path, data in originals.items():
+        if path.read_bytes() != data:
+            print(f"NOT RESTORED {path}")
+            return 1
+    print("all files restored byte-for-byte")
+
+    if missed:
+        print(f"\n{len(missed)} mutation(s) got through")
+        return 1
+    print(f"\nall {len(MUTATIONS)} mutations caught")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
\ No newline at end of file
diff --git a/plugins/avatasia/mmc-trajectory/tests/mutate-selection.py b/plugins/avatasia/mmc-trajectory/tests/mutate-selection.py
new file mode 100644
index 0000000..4c1a5ed
--- /dev/null
+++ b/plugins/avatasia/mmc-trajectory/tests/mutate-selection.py
@@ -0,0 +1,159 @@
+"""Mutation control for the selection guards.
+
+A guard that cannot fail is not a guard. Each mutation below breaks one of the rules in
+verify-selection.mjs the way it would actually break in the file, and requires that guard to fail
+with the right reason before the file is restored byte for byte.
+
+Each mutation is a list of edits rather than one substitution, so that a rule which spans two lines
+that have to move together can be broken in one go — a substitution that changes the text without
+changing what the page does proves nothing.
+
+The first one is the bug this file exists for: reading `state.flat` instead of the list handed in.
+The stub in the guard carries both, so the reverted version runs to a wrong answer rather than
+throwing — it keeps a selection the reader can no longer see, which is exactly what shipped.
+
+Two of these used to guard the opposite rule and were rewritten rather than dropped when the
+window stopped being the judgement's to widen (docs/LAYERS.md D13). The mutation
+"the window is never pulled down to the selection" was guarding a behaviour that was itself the
+defect: it pinned the `state.limit` write in place. It now breaks the rule that replaced it, and
+"the selection is judged after the window is sliced" guards the ordering the other way round.
+"""
+import io
+import os
+import subprocess
+import sys
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+ROOT = os.path.dirname(HERE)
+CLIENT = os.path.join(ROOT, "miniapp", "client", "index.html")
+PROBE = os.path.join(HERE, "verify-selection.mjs")
+
+MUTATIONS = [
+    # The bug. The rows come from visibleEntries(); the selection was checked against the whole
+    # session, so a filtered-out record stayed selected and the inspector kept describing a row that
+    # was no longer on screen.
+    ("the selection is judged against the whole session again",
+     [("        for (var i = 0; i < entries.length; i += 1) {\n"
+       "          if (entries[i].record.id === state.selectedId) return false;\n"
+       "        }\n",
+       "        for (var i = 0; i < state.flat.length; i += 1) {\n"
+       "          if (state.flat[i].record.id === state.selectedId) return false;\n"
+       "        }\n")],
+     "a record the filter removed loses its selection"),
+
+    # A filtered-out record that is never cleared: the panel keeps showing it and no row carries the
+    # mark, so nothing on the page contradicts anything else on the page.
+    ("a filtered-out record keeps its selection",
+     [("        state.selectedId = null;\n        return true;\n      }\n\n      /**\n       * The selected record, or null.\n",
+       "      }\n\n      /**\n       * The selected record, or null.\n")],
+     "a record the filter removed loses its selection"),
+
+    # The window is the window controls' to move. A judgement that grows it to reach a selection is
+    # a second writer of `state.limit`, and it is what made pressing 「显示最新 200 条」 leave the
+    # bar reading 15,224 条 a second after promising 200. Reinstating the write must be caught by
+    # name — the old version of this mutation guarded the very line it now breaks.
+    ("the judgement grows the window again",
+     [("        for (var i = 0; i < entries.length; i += 1) {\n"
+       "          if (entries[i].record.id === state.selectedId) return false;\n"
+       "        }\n",
+       "        for (var i = 0; i < entries.length; i += 1) {\n"
+       "          if (entries[i].record.id === state.selectedId) {\n"
+       "            var needed = entries.length - i;\n"
+       "            if (needed > state.limit) state.limit = Math.min(needed, entries.length);\n"
+       "            return false;\n"
+       "          }\n"
+       "        }\n")],
+     "the judgement never touches the window"),
+
+    # The poll path was the only caller, which is why a local filter change never reached it.
+    ("the selection is never re-judged when the table changes",
+     [("        if (revealSelection(windowed)) renderInspector();\n", "")],
+     "the selection is re-judged at the one exit every filter passes through"),
+
+    # The half that is easy to miss, because the state is correct afterwards and only the DOM is
+    # stale: nine writers reach renderLedger() without redrawing the panel, so the search box left
+    # the inspector naming a record that had just been dropped.
+    ("the judgement is made but the panel is never redrawn",
+     [("        if (revealSelection(windowed)) renderInspector();\n",
+       "        revealSelection(windowed);\n")],
+     "the panel is redrawn when the selection is dropped"),
+
+    # And the other half: a verdict nobody is told about cannot be acted on.
+    ("dropping the selection is never reported",
+     [("        state.selectedId = null;\n        return true;\n",
+       "        state.selectedId = null;\n        return false;\n")],
+     "dropping the selection is reported so the panel can be redrawn"),
+
+    # Judged against `matched` — the filter result — rather than `windowed`. A record that survived
+    # every filter and was still cut off by the window keeps its selection, and the inspector goes
+    # on describing a row that is not on screen. That was this mutation's premise before the
+    # ordering changed; the defect it names has simply moved to the other side of the slice.
+    ("the selection is judged against the filtered rows rather than the window",
+     [("        if (revealSelection(windowed)) renderInspector();\n",
+       "        if (revealSelection(matched)) renderInspector();\n")],
+     "the selection is judged against the window, not the filter result"),
+
+    # Two writers. The poll path judged the selection again, and a reader could be told two
+    # different things depending on which one ran last.
+    ("the poll path judges the selection a second time",
+     [("        if (changed) rePinWindow();\n        render();\n",
+       "        if (changed) { rePinWindow(); revealSelection(visibleEntries()); }\n        render();\n")],
+     "the poll path does not judge the selection a second time"),
+
+    # The list becomes a second read. The caller hands over the rows it is about to build and the
+    # function goes and works out a list of its own, which can only agree with the first by luck.
+    ("the list to judge against is re-read instead of handed in",
+     [("function revealSelection(entries) {\n        if (!state.selectedId) return false;\n",
+       "function revealSelection() {\n        if (!state.selectedId) return false;\n        var entries = visibleEntries();\n")],
+     "the list to judge against is an argument rather than a second read"),
+]
+
+original = io.open(CLIENT, encoding="utf-8", newline="").read()
+
+
+def run():
+    proc = subprocess.run(["node", PROBE], cwd=HERE,
+                          capture_output=True, text=True, encoding="utf-8", errors="replace")
+    return proc.returncode, proc.stdout + proc.stderr
+
+
+ok = True
+code, baseline = run()
+base_ok = code == 0 and "0 failed" in baseline
+print(("ok   " if base_ok else "FAIL ") + "baseline green")
+ok = ok and base_ok
+
+caught = []
+for title, edits, expect in MUTATIONS:
+    for old, _ in edits:
+        hits = original.count(old)
+        if hits != 1:
+            raise SystemExit("FAIL  anchor for %r matched %d times" % (title, hits))
+    try:
+        mutated = original
+        for old, new in edits:
+            mutated = mutated.replace(old, new, 1)
+        io.open(CLIENT, "w", encoding="utf-8", newline="").write(mutated)
+        during_code, during = run()
+        named = expect in during
+        red = during_code != 0
+        # A guard that crashes is not a guard that caught anything: the rule has to be reported by
+        # name, or the mutation only proved that the file no longer parses.
+        print(("ok   " if (named and red) else "FAIL ") + "guard catches: " + title)
+        if not named:
+            print("       no assertion reported %r" % expect)
+            for line in during.splitlines()[-4:]:
+                print("       " + line.strip())
+        elif not red:
+            print("       the rule was reported but the guard still exited 0")
+        caught.append(named and red)
+    finally:
+        io.open(CLIENT, "w", encoding="utf-8", newline="").write(original)
+
+restored = io.open(CLIENT, encoding="utf-8", newline="").read()
+after_code, after = run()
+after_ok = after_code == 0 and "0 failed" in after
+print(("ok   " if restored == original else "FAIL ") + "client restored byte for byte")
+print(("ok   " if after_ok else "FAIL ") + "green again after restore")
+
+sys.exit(0 if (ok and all(caught) and restored == original and after_ok) else 1)
\ No newline at end of file
diff --git a/plugins/avatasia/mmc-trajectory/tests/mutate-steer.py b/plugins/avatasia/mmc-trajectory/tests/mutate-steer.py
new file mode 100644
index 0000000..15ad23c
--- /dev/null
+++ b/plugins/avatasia/mmc-trajectory/tests/mutate-steer.py
@@ -0,0 +1,93 @@
+"""Mutation controls for the steer split and the turn classification.
+
+Two mistakes worth being able to catch automatically:
+
+  1. Filing every prompt in a turn as `user`. The count then reads as conversations but is
+     really messages, and a turn can show three of them — the exact mismatch that sent
+     someone looking for a mechanism.
+  2. Filing 问答 as the turn *after* the question again, which puts the label on a turn while
+     the reader still has not answered.
+
+Both are one-line edits, which is exactly why they need a guard that has been seen to fail.
+"""
+import io
+import os
+import subprocess
+import sys
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+ROOT = os.path.dirname(HERE)
+SERVER = os.path.join(ROOT, "miniapp", "node", "server.mjs")
+PROBE = os.path.join(HERE, "verify-generations.mjs")
+
+# server.mjs is CRLF. A multi-line anchor written with bare \n never matches it, which reads as
+# "the anchor drifted" and sends you off to re-find a rule that never moved. Build every anchor
+# in the file's own line ending.
+original = io.open(SERVER, encoding="utf-8", newline="").read()
+NL = "\r\n" if "\r\n" in original else "\n"
+
+
+def anchored(*lines):
+    return NL.join(lines)
+
+
+OLD_STEER = "        const steered = turn.records.some((r) => r.kind === 'user');"
+OLD_CONT = anchored("    } else if (closed) {",
+                    "      turn.turnClass = 'continuation';",
+                    "      continuationTurns += 1;")
+
+MUTATIONS = [
+    ("every prompt in a turn is counted as dialogue",
+     OLD_STEER,
+     "        const steered = false;",
+     "a prompt written mid-turn is counted apart"),
+    ("the first prompt of a turn is called a steer",
+     OLD_STEER,
+     "        const steered = true;",
+     "the prompt that opened the turn is the only one counted as dialogue"),
+    ("Q and A goes back to the turn after the question",
+     OLD_CONT,
+     "    } else if (closed) {\n"
+     "      turn.turnClass = 'qa';\n"
+     "      continuationTurns += 1;\n"
+     "      qaTurns += 1;",
+     "the turn after it is a continuation, not a Q&A"),
+]
+
+
+def run():
+    proc = subprocess.run(["node", PROBE], cwd=HERE,
+                          capture_output=True, text=True, encoding="utf-8", errors="replace")
+    return proc.stdout + proc.stderr
+
+
+ok = True
+baseline = run()
+base_ok = "0 failed" in baseline
+print(("ok   " if base_ok else "FAIL ") + "baseline green before any mutation")
+ok = ok and base_ok
+
+caught = []
+for title, old, new, expect in MUTATIONS:
+    if original.count(old) != 1:
+        raise SystemExit("FAIL  anchor for %r matched %d times" % (title, original.count(old)))
+    try:
+        io.open(SERVER, "w", encoding="utf-8", newline="").write(original.replace(old, new, 1))
+        during = run()
+        named = expect in during
+        failed = "0 failed" not in during
+        print(("ok   " if (named and failed) else "FAIL ") + "guard catches: " + title)
+        for line in during.splitlines():
+            if line.strip().startswith("FAIL"):
+                print("       " + line.strip())
+        caught.append(named and failed)
+    finally:
+        io.open(SERVER, "w", encoding="utf-8", newline="").write(original)
+
+restored = io.open(SERVER, encoding="utf-8", newline="").read()
+print(("ok   " if restored == original else "FAIL ") + "server restored byte for byte")
+after = run()
+after_ok = "0 failed" in after
+print(("ok   " if after_ok else "FAIL ") + "green again after restore")
+
+sys.exit(0 if (ok and all(caught) and restored == original and after_ok) else 1)
diff --git a/plugins/avatasia/mmc-trajectory/tests/mutate-sticky.py b/plugins/avatasia/mmc-trajectory/tests/mutate-sticky.py
new file mode 100644
index 0000000..cc9d0b4
--- /dev/null
+++ b/plugins/avatasia/mmc-trajectory/tests/mutate-sticky.py
@@ -0,0 +1,228 @@
+"""Mutation control for the sticky band guards.
+
+A guard that cannot fail is not a guard. Each mutation below breaks one of the rules in
+verify-sticky.mjs the way it would actually break in the file, and requires that guard to fail
+with the right reason before the file is restored byte for byte.
+
+Three of these are the ones a reader should be least able to guess: the band going transparent
+(rows are `background: transparent`, so a band that stops covering them shows them through), the
+strip being measured from the band (both are measured, both get written, and the layout still
+looks plausible at first), and the measurement moving above the render lines that change the
+band's height.
+"""
+import io
+import os
+import subprocess
+import sys
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+ROOT = os.path.dirname(HERE)
+CLIENT = os.path.join(ROOT, "miniapp", "client", "index.html")
+PROBE = os.path.join(HERE, "verify-sticky.mjs")
+
+MUTATIONS = [
+    # The band is the fix. Without position: sticky the two filter rows scroll away again, which is
+    # the report this whole change answers.
+    ("the band is not pinned at all",
+     "      .filter-sticky {\n        position: sticky;\n        top: 0;",
+     "      .filter-sticky {\n        top: 0;",
+     "the filter band pins to the top of the page"),
+
+    # The band sits over the ledger now. Opaque is the whole difference between a band and a hole.
+    ("the band goes transparent over the ledger",
+     "      .filter-sticky {\n        position: sticky;\n        top: 0;\n        z-index: 6;\n        background: var(--mcode-bg);\n",
+     "      .filter-sticky {\n        position: sticky;\n        top: 0;\n        z-index: 6;\n",
+     "the filter band is opaque"),
+
+    # The old half-fixed state: the type row sticks, the 异常 row scrolls out from under it.
+    ("the type row pins itself again, leaving the 异常 row behind",
+     "      .traj-controls {\n        display: flex;",
+     "      .traj-controls {\n        position: sticky;\n        top: 0;\n        display: flex;",
+     "the band is the only pinned element for the two filter rows"),
+
+    # The band ends before the 异常 row, so the anomaly axis is back on its own.
+    ("the 异常 row leaves the band",
+     "        <div class=\"anomaly-bar\" id=\"anomaly-bar\">",
+     "        </div>\n        <div class=\"anomaly-bar\" id=\"anomaly-bar\">",
+     "both filter rows ship inside one sticky band"),
+
+    # Markup and stylesheet name the same thing in two places. If they drift, the rule still parses
+    # and the element still has an id, and nothing is pinned at all.
+    ("the band's class drifts from the rule that pins it",
+     "      <div class=\"filter-sticky\" id=\"filter-sticky\">",
+     "      <div class=\"filter-band\" id=\"filter-sticky\">",
+     "the band element ships the class the stylesheet pins"),
+
+    # The number the measurement replaced. It was correct for a layout without the 异常 row.
+    ("the strip pins at a written-down constant again",
+     "        top: var(--sticky-band-h, 32px);\n",
+     "        top: 32px;\n",
+     "the strip pins below the band it measures, not below a constant"),
+
+    ("the window bar forgets the band above it",
+     "        top: calc(var(--sticky-band-h, 32px) + var(--sticky-overview-h, 51px));\n",
+     "        top: calc(var(--sticky-overview-h, 51px));\n",
+     "the window bar pins below the band and the strip"),
+
+    ("a turn head forgets the window bar",
+     "        top: calc(var(--sticky-band-h, 32px) + var(--sticky-overview-h, 51px)\n          + var(--sticky-window-h, 45px));\n",
+     "        top: calc(var(--sticky-band-h, 32px) + var(--sticky-overview-h, 51px));\n",
+     "a turn head pins below the band, the strip and the window bar"),
+
+    # Everything pinned over the ledger has to cover it. The rows underneath are transparent.
+    ("the strip goes transparent",
+     "        height: 50px;\n        overflow: hidden;\n        background: var(--mcode-surface-muted);\n",
+     "        height: 50px;\n        overflow: hidden;\n",
+     "the overview strip is opaque"),
+
+    ("the window bar goes transparent",
+     "        z-index: 3;\n        padding: 8px 16px;\n        background: var(--mcode-bg);\n        border-bottom: 1px solid var(--mcode-border);\n      }\n",
+     "        z-index: 3;\n        padding: 8px 16px;\n        border-bottom: 1px solid var(--mcode-border);\n      }\n",
+     "the window bar is opaque"),
+
+    ("a pinned turn head goes transparent",
+     "        border: 0;\n        border-bottom: 1px solid var(--mcode-border);\n        background: var(--mcode-bg-secondary);\n",
+     "        border: 0;\n        border-bottom: 1px solid var(--mcode-border);\n",
+     "the turn head is opaque"),
+
+    # The stub heights are 137 / 65 / 57 for exactly this reason: no constant in the file is any of
+    # them, so a version that writes a number instead of measuring cannot pass.
+    ("the band height is written down instead of measured",
+     "        var band = dom.filterSticky.offsetHeight;",
+     "        var band = 32;",
+     "the measured band height is the one that gets written"),
+
+    ("the strip is measured from the band",
+     "        var overview = dom.overview.offsetHeight;",
+     "        var overview = dom.filterSticky.offsetHeight;",
+     "the measured strip height is the one that gets written"),
+
+    # Nothing reads this variable any more, so the stylesheet silently falls back to 45px.
+    ("the window bar height is measured but never written",
+     "        root.setProperty('--sticky-window-h', dom.windowBar.offsetHeight + 'px');\n",
+     "",
+     "every pinned offset is written by the measurement, not by the stylesheet"),
+
+    # A band that is never bound measures nothing: the function stands down, all three offsets fall
+    # back to their constants, and nothing anywhere reports an error.
+    ("the band element is no longer found",
+     "        dom.filterSticky = document.getElementById('filter-sticky');\n",
+     "",
+     "every band the measurement reads is bound to an element the markup ships"),
+
+    # The quieter version of the same thing: an id that is not on the page.
+    ("the band is looked up by an id that is not there",
+     "        dom.filterSticky = document.getElementById('filter-sticky');",
+     "        dom.filterSticky = document.getElementById('filter-band');",
+     "every band the measurement reads is bound to an element the markup ships"),
+
+    # Reads a null off the page instead of standing down.
+    ("the measurement no longer stands down without the band",
+     "        if (!dom.filterSticky || !dom.overview || !dom.windowBar) return;",
+     "",
+     "the measurement stands down when the band is not on the page"),
+
+    # Where the measurement happens, and who is allowed to trigger it. The 异常 note is written by
+    # syncAnomalyMode and it is the note that adds a line to the band, so the order of the two
+    # decides whether the strips below are pinned at the height the band had before the reader
+    # changed anything.
+    ("the ledger stops measuring the band",
+     "          // and emptying the ledger mid-flight is not a reason to move a pinned strip.\n"
+     "          syncStickyOffsets();\n",
+     "          // and emptying the ledger mid-flight is not a reason to move a pinned strip.\n",
+     "the heights are measured at the one exit every filter passes through"),
+
+    ("the measurement moves off the ledger's last line",
+     "          restoreRowAnchor(anchor, scrollY);\n          // Before the measurement",
+     "          syncStickyOffsets();\n          restoreRowAnchor(anchor, scrollY);\n          // Before the measurement",
+     "the heights are measured at the one exit every filter passes through"),
+
+    # A second call site is the shape that let the eight filter writers nobody was thinking about go
+    # unmeasured in the first place.
+    ("the measurement is taken twice on the render path",
+     "        updateHandoffButton();\n      }\n\n      function renderGeneration() {",
+     "        updateHandoffButton();\n        syncStickyOffsets();\n      }\n\n      function renderGeneration() {",
+     "the measurement has exactly one call site on the render path"),
+
+    ("the band note is written after the heights are measured",
+     "        syncAnomalyMode(anomaly);\n"
+     "        syncAnomalyButtons(anomaly);\n"
+     "        renderOverview();\n"
+     "        renderLedger();\n",
+     "        syncAnomalyButtons(anomaly);\n"
+     "        renderOverview();\n"
+     "        renderLedger();\n"
+     "        syncAnomalyMode(anomaly);\n",
+     "the band note is written before the heights are measured"),
+
+    # Nothing re-measured when the window changed shape. On a session whose payload has stopped
+    # growing every poll is a 304 and render() is never called, so a resize that wrapped the type
+    # row left the strips pinned at the old width until new records arrived.
+    ("a window resize measures nothing",
+     "        window.addEventListener('resize', scheduleStickyOffsets);\n\n",
+     "",
+     "a window resize re-measures the band"),
+
+    ("the resize is registered against a handler that measures nothing",
+     "        stickyFrame = window.requestAnimationFrame(function () {\n"
+     "          stickyFrame = null;\n"
+     "          syncStickyOffsets();\n"
+     "        });\n",
+     "        stickyFrame = window.requestAnimationFrame(function () {\n"
+     "          stickyFrame = null;\n"
+     "        });\n",
+     "a resize reaches the measurement it was registered for"),
+
+    # Correct but a layout thrash: each measurement reads three offsetHeights, and a window drag
+    # fires `resize` continuously.
+    ("a resize is measured on every event instead of once per frame",
+     "        window.addEventListener('resize', scheduleStickyOffsets);\n",
+     "        window.addEventListener('resize', syncStickyOffsets);\n",
+     "a resize measures once per frame, not once per event"),
+]
+
+original = io.open(CLIENT, encoding="utf-8", newline="").read()
+
+
+def run():
+    proc = subprocess.run(["node", PROBE], cwd=HERE,
+                          capture_output=True, text=True, encoding="utf-8", errors="replace")
+    return proc.returncode, proc.stdout + proc.stderr
+
+
+ok = True
+code, baseline = run()
+base_ok = code == 0 and "0 failed" in baseline
+print(("ok   " if base_ok else "FAIL ") + "baseline green")
+ok = ok and base_ok
+
+caught = []
+for title, old, new, expect in MUTATIONS:
+    hits = original.count(old)
+    if hits != 1:
+        raise SystemExit("FAIL  anchor for %r matched %d times" % (title, hits))
+    try:
+        io.open(CLIENT, "w", encoding="utf-8", newline="").write(original.replace(old, new, 1))
+        during_code, during = run()
+        named = expect in during
+        red = during_code != 0
+        # A guard that crashes is not a guard that caught anything: the rule has to be reported by
+        # name, or the mutation only proved that the file no longer parses.
+        print(("ok   " if (named and red) else "FAIL ") + "guard catches: " + title)
+        if not named:
+            print("       no assertion reported %r" % expect)
+            for line in during.splitlines()[-4:]:
+                print("       " + line.strip())
+        elif not red:
+            print("       the rule was reported but the guard still exited 0")
+        caught.append(named and red)
+    finally:
+        io.open(CLIENT, "w", encoding="utf-8", newline="").write(original)
+
+restored = io.open(CLIENT, encoding="utf-8", newline="").read()
+after_code, after = run()
+after_ok = after_code == 0 and "0 failed" in after
+print(("ok   " if restored == original else "FAIL ") + "client restored byte for byte")
+print(("ok   " if after_ok else "FAIL ") + "green again after restore")
+
+sys.exit(0 if (ok and all(caught) and restored == original and after_ok) else 1)
diff --git a/plugins/avatasia/mmc-trajectory/tests/mutate-turn-breakdown.py b/plugins/avatasia/mmc-trajectory/tests/mutate-turn-breakdown.py
new file mode 100644
index 0000000..6296f4d
--- /dev/null
+++ b/plugins/avatasia/mmc-trajectory/tests/mutate-turn-breakdown.py
@@ -0,0 +1,163 @@
+"""Mutation control for the two turn-breakdown guards.
+
+Without this, "turn breakdown parts sum to the headline" and "turn breakdown names 续作答答,
+not 提问待答" could both be satisfied by a page that has nothing to do with the turns: the sum
+check runs the real function against synthetic stats, but only once anyone writes it, and the
+naming check is a regex over the whole file. This proves each guard actually fires.
+"""
+import io
+import os
+import subprocess
+import sys
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+ROOT = os.path.dirname(HERE)
+CLIENT = os.path.join(ROOT, "miniapp", "client", "index.html")
+PROBE = os.path.join(HERE, "client-check.mjs")
+
+# Anchored with the following line so it cannot also match turnTipLines, which builds the same
+# expression for the tooltip — a shared substring is an ambiguous anchor, not a safe one.
+CLOSED = ("'收尾 ' + formatInt(Math.max(0, total - open)),\n"
+          "          '提问轮 ' + formatInt(asked)")
+OPENED = "if (open > asked) parts.push('中断 ' + formatInt(open - asked));"
+BOTH_PARTS = ("parts = [\n          '收尾 ' + formatInt(Math.max(0, total - open)),\n"
+              "          '提问轮 ' + formatInt(asked)\n        ];")
+
+MUTATIONS = [
+    # If the closed part swallowed the open turns, the parts would total more than the
+    # headline and the line would claim turns closed that never delivered a reply.
+    ("closed part counts open turns too",
+     CLOSED,
+     "'收尾 ' + formatInt(total)",
+     "turn breakdown parts sum to the headline"),
+    # If the asked part were dropped, the gap would be silently absorbed by 中断.
+    ("asked part dropped from the line",
+     BOTH_PARTS,
+     "parts = [\n          '收尾 ' + formatInt(Math.max(0, total - open))\n        ];",
+     "turn breakdown parts sum to the headline"),
+    # The word the earlier version shipped, and the boundary mark added after two disjoint
+    # fives read as one number counted twice. Anchored on the rendered label / the boundary
+    # string, not the bare word: the doc comments above these functions also talk about the
+    # old names, and explaining a rename is not shipping it.
+    ("label regressed to 提问待答",
+     "'提问轮 ' + formatInt(asked)\n        ];",
+     "'提问待答 ' + formatInt(asked)\n        ];",
+     "turn breakdown renders 提问轮, not 提问待答"),
+    # Removing 另有 is the exact regression this guard exists for: the two groups go back to
+    # being one undifferentiated `·` run.
+    ("boundary mark 另有 removed",
+     "   ·   另有 ' + context",
+     "   ·   ' + context",
+     "context group is marked as a separate population"),
+    ("whole breakdown and context line claims to sum to the headline",
+     OPENED,
+     "if (open > asked) parts.push('中断 ' + formatInt(0));",
+     "turn breakdown parts sum to the headline"),
+    # The inline links become a second opinion: they write state.kinds themselves instead of
+    # going through the one writer, so the card and the chip could disagree.
+    ("KPI link grows its own writer",
+     "onKindToggle(kind, state.kinds.indexOf(kind) < 0);",
+     "state.kinds = state.kinds.indexOf(kind) >= 0 ? state.kinds.filter(function (k) { return k !== kind; }) : state.kinds.concat([kind]);\n            renderLedger();",
+     "KPI kind links go through onKindToggle, not a second writer"),
+    # ...and they close over the rendered flag, which is stale the moment a poll lands between
+    # the render and the click. Looks right, does the opposite.
+    ("KPI link closes over a rendered flag",
+     "onKindToggle(kind, state.kinds.indexOf(kind) < 0);",
+     "onKindToggle(kind, on);",
+     "KPI kind links do not close over a rendered flag"),
+    # 续作轮 counts turns, not records. Wiring it up as if it were a kind would put a second
+    # axis behind a name the chips already use.
+    ("unlinkable term wired to a kind",
+     "{ label: '续作轮', value: formatInt(stats.continuationTurns), kind: null }",
+     "{ label: '续作轮', value: formatInt(stats.continuationTurns), kind: 'narration' }",
+     "exactly the record-counting context terms are links"),
+    # A tooltip nobody can reach without a mouse, or one the card no longer points at.
+    ("tooltip loses its accessible name",
+     "card.setAttribute('aria-describedby', tipId);",
+     "card.setAttribute('data-note', tipId);",
+     "turn card carries an accessible explanation"),
+    # A tooltip that stops explaining the line it sits under.
+    ("tooltip drops a term",
+     "'收尾 ' + formatInt(Math.max(0, total - open)) + ' · 答复在本轮内交付',",
+     "'这一类轮次在本轮内交付了答复',",
+     "the tip explains every term on the line"),
+    # The original defect: title and header both said 轮次, one a total one an ordinal. Put the
+    # shared label back on either side and the two numbers look like they should be equal.
+    ("turn header reverts to the shared label",
+     "var title = '第 ' + (isCount(turn.index) ? turn.index : DASH) + ' 轮';",
+     "var title = '轮次 ' + (isCount(turn.index) ? turn.index : DASH);",
+     "panel title reads a total, turn headers read an ordinal"),
+    # Put the session total back beside the range. This is the report verbatim: 共 84 轮 above
+    # 第 82 轮, two scopes in one label, so the pair reads as a contradiction that no wording
+    # can fix. Both numbers were true.
+    ("session total put back in the title",
+     "if (!isCount(firstTurn) || !isCount(lastTurn)) return DASH;",
+     "if (!isCount(firstTurn) || !isCount(lastTurn)) return DASH;\n        var totalTurns = state.payload.stats.turns;\n        if (firstTurn === lastTurn) return '共 ' + formatInt(totalTurns) + ' 轮 · 当前第 ' + formatInt(firstTurn) + ' 轮';\n        return '共 ' + formatInt(totalTurns) + ' 轮 · 当前第 ' + formatInt(firstTurn) + '–' + formatInt(lastTurn) + ' 轮';",
+     "panel title states only the rendered turn range"),
+    ("title drops the range entirely",
+     "return '第 ' + formatInt(firstTurn) + '–' + formatInt(lastTurn) + ' 轮';",
+     "return '轨迹';",
+     "panel title states only the rendered turn range"),
+    # Anchored on two lines with their indentation: updateWindowBar() now writes the 全场 total in
+    # both its mid-build and its settled branch, and a one-line anchor matches both.
+    ("session total dropped from the window bar",
+     "          (isCount(sessionTurns) ? '全场 ' + formatInt(sessionTurns) + ' 轮 · ' : '') +\n"
+     "          '共 ' + formatInt(total) + ' 条 · 已显示 ' + formatInt(shown.length) + ' 条' +\n",
+     "          '共 ' + formatInt(total) + ' 条 · 已显示 ' + formatInt(shown.length) + ' 条' +\n",
+     "the session total lives on the window bar instead"),
+
+    # The same rule for the other branch. The mid-build line is the one a reader is actually
+    # looking at while an 18,924-row 全部 window is being built, so losing the session total there
+    # is at least as bad as losing it once the table has settled.
+    ("session total dropped from the mid-build count",
+     "            (isCount(sessionTurns) ? '全场 ' + formatInt(sessionTurns) + ' 轮 · ' : '') +\n"
+     "            '共 ' + formatInt(total) + ' 条 · 正在显示 ' + formatInt(ledgerProgress.rows) +\n",
+     "            '共 ' + formatInt(total) + ' 条 · 正在显示 ' + formatInt(ledgerProgress.rows) +\n",
+     "the session total lives on the window bar instead"),
+    # Write the title before the groups exist. The label still renders, it just silently
+    # degrades — the failure the guard above is about.
+    ("title written before the groups are built",
+     "dom.ledgerMeta.textContent = turnRangeLabel(firstTurn, lastTurn);",
+     "dom.ledgerMeta.textContent = '共 ' + formatInt(state.payload.stats.turns) + ' 轮';",
+     "the title is written after the groups are built"),
+]
+
+original = io.open(CLIENT, encoding="utf-8", newline="").read()
+
+
+def run():
+    proc = subprocess.run(["node", PROBE], cwd=HERE,
+                          capture_output=True, text=True, encoding="utf-8", errors="replace")
+    return proc.stdout + proc.stderr
+
+
+ok = True
+baseline = run()
+base_ok = "0 failed" in baseline
+print(("ok   " if base_ok else "FAIL ") + "baseline green")
+ok = ok and base_ok
+
+caught_all = []
+for title, old, new, expect in MUTATIONS:
+    if original.count(old) != 1:
+        raise SystemExit("FAIL  anchor for %r matched %d times" % (title, original.count(old)))
+    try:
+        io.open(CLIENT, "w", encoding="utf-8", newline="").write(original.replace(old, new, 1))
+        during = run()
+        named = expect in during
+        failed = "0 failed" not in during
+        print(("ok   " if (named and failed) else "FAIL ") + "guard catches: " + title)
+        for line in during.splitlines():
+            if line.strip().startswith("-") and "breakdown" in line:
+                print("       " + line.strip())
+        caught_all.append(named and failed)
+    finally:
+        io.open(CLIENT, "w", encoding="utf-8", newline="").write(original)
+
+restored = io.open(CLIENT, encoding="utf-8", newline="").read()
+after = run()
+after_ok = "0 failed" in after
+print(("ok   " if restored == original else "FAIL ") + "client restored byte for byte")
+print(("ok   " if after_ok else "FAIL ") + "green again after restore")
+
+sys.exit(0 if (ok and all(caught_all) and restored == original and after_ok) else 1)
\ No newline at end of file
diff --git a/plugins/avatasia/mmc-trajectory/tests/mutate-window-default.py b/plugins/avatasia/mmc-trajectory/tests/mutate-window-default.py
new file mode 100644
index 0000000..681b257
--- /dev/null
+++ b/plugins/avatasia/mmc-trajectory/tests/mutate-window-default.py
@@ -0,0 +1,140 @@
+"""Mutation control for the window guards.
+
+A guard that cannot fail is not a guard. Each mutation below breaks one of the new rules in
+the way it would actually break in the file — the default opening on 全部 again, the label going
+back to naming the state, a reset hard-coding a literal, the scroll creeping back into the click
+handler, the [hidden] patch being dropped, and a poll undoing a widened window.
+"""
+import io
+import os
+import subprocess
+import sys
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+ROOT = os.path.dirname(HERE)
+CLIENT = os.path.join(ROOT, "miniapp", "client", "index.html")
+PROBE = os.path.join(HERE, "client-check.mjs")
+
+MUTATIONS = [
+    # 全部 is opt-in because it froze the page: ~9,900 rows and ~57,000 real DOM elements with
+    # no virtual scrolling, rebuilt every 2.5s poll. Opening on it by default is the regression.
+    ("default opened on 全部 again",
+     "        allRecords: false,",
+     "        allRecords: true,",
+     "the window opens on the newest page, and the button names the action"),
+    ("default opened on 全部's uncapped limit",
+     "        limit: PAGE_STEP,",
+     "        limit: Infinity,",
+     "the window opens on the newest page, and the button names the action"),
+    ("the shared default constant diverges from the state default",
+     "      var DEFAULT_WINDOW_MODE = 'latest';",
+     "      var DEFAULT_WINDOW_MODE = 'all';",
+     "the window opens on the newest page, and the button names the action"),
+    # The label shipped naming the state, which put 只看最新 200 条 directly above 已显示 200 条 —
+    # the button echoing the count beside it. It must name the action, and in both directions.
+    ("button label reverts to naming the state",
+     "parts.mode.textContent = state.allRecords ? '显示最新 ' + formatInt(PAGE_STEP) + ' 条' : '显示全部';",
+     "parts.mode.textContent = state.allRecords ? '已显示全部' : '只看最新 ' + formatInt(PAGE_STEP) + ' 条';",
+     "the window opens on the newest page, and the button names the action"),
+    ("button label arms swapped",
+     "parts.mode.textContent = state.allRecords ? '显示最新 ' + formatInt(PAGE_STEP) + ' 条' : '显示全部';",
+     "parts.mode.textContent = state.allRecords ? '显示全部' : '显示最新 ' + formatInt(PAGE_STEP) + ' 条';",
+     "the window opens on the newest page, and the button names the action"),
+    # aria-pressed stays on the state, which is why the accessible name repeats it.
+    ("pressed state inverted away from the state it reports",
+     "parts.mode.setAttribute('aria-pressed', state.allRecords ? 'true' : 'false');",
+     "parts.mode.setAttribute('aria-pressed', state.allRecords ? 'false' : 'true');",
+     "the window opens on the newest page, and the button names the action"),
+    # The accessible name is what a screen reader reads first, so it has to carry the state.
+    ("accessible name loses the state",
+     "var modeLabel = state.allRecords ? '正在显示全部记录 · 点击改为只显示最新 ' + formatInt(PAGE_STEP) + ' 条'",
+     "var modeLabel = state.allRecords ? '显示全部'",
+     "the window opens on the newest page, and the button names the action"),
+    ("quiet styling inverted with the arms",
+     "parts.mode.classList.toggle('btn-quiet', state.allRecords);",
+     "parts.mode.classList.toggle('btn-quiet', !state.allRecords);",
+     "the window opens on the newest page, and the button names the action"),
+    # A reset that preserves the window it is resetting is the bug this helper exists to prevent.
+    ("reset reads the window it is discarding",
+     "        setWindowMode(DEFAULT_WINDOW_MODE);",
+     "        setWindowMode(state.allRecords ? 'all' : 'latest');",
+     "every window reset quotes the default, not a literal"),
+    # One reset going back to a literal is how the flipped default was left half-applied.
+    # Anchored on the onKindToggle reset, whose following line makes it unique.
+    ("one reset hard-codes the old mode",
+     "        resetWindowMode();\n        syncKindButtons();",
+     "        setWindowMode('latest');\n        syncKindButtons();",
+     "every window reset quotes the default, not a literal"),
+    # The scroll, back. It threw away whatever the reader had on screen.
+    ("the window button scrolls to the tail again",
+     "          setWindowMode(state.allRecords ? 'latest' : 'all');\n          renderLedger();",
+     "          setWindowMode(state.allRecords ? 'latest' : 'all');\n          renderLedger();\n          window.scrollTo(0, document.documentElement.scrollHeight);",
+     "the window button does not scroll the page"),
+    # Drop the [hidden] patch on .btn and `hidden` loses to display:inline-flex, so the
+    # load-more button comes back as a bordered empty box on load.
+    ("the .btn hidden patch removed",
+     "      .btn[hidden] {\n        display: none;\n      }\n\n",
+     "",
+     "a .btn toggled with hidden is actually hidden"),
+    # Guard the label again, so the button is blank whenever it is showing.
+    ("load-more label written only when showing",
+     "        parts.more.textContent = '向上加载更早的 ' + formatInt(Math.min(PAGE_STEP, Math.max(hiddenAbove, 0))) + ' 条';",
+     "        if (hiddenAbove > 0) {\n          parts.more.textContent = '向上加载更早的 ' + formatInt(Math.min(PAGE_STEP, hiddenAbove)) + ' 条';\n        }",
+     "a .btn toggled with hidden is actually hidden"),
+    # The dead button: Infinity + 200 is still Infinity, so the click would do nothing.
+    ("load-more tries to load while showing everything",
+     "          if (state.allRecords) return;\n          state.limit += PAGE_STEP;",
+     "          state.limit += PAGE_STEP;",
+     "the load-more button does nothing in 全部 instead of pretending to"),
+    # The reason 向上加载更早的 N 条 never worked: the next poll reset the limit the reader had
+    # just widened. This session grows fast enough that the count barely moved, so it looked
+    # like a no-op rather than like a bug.
+    #
+    # Anchored on the guard line alone. It used to be anchored on the two lines above it as one
+    # block, but rePinWindow gained a time-range early-return between them, so the block stopped
+    # matching even though neither line moved. The rule is the one line.
+    ("a poll resets a window the reader widened",
+     "        if (state.limit > PAGE_STEP) return state.limit;",
+     "",
+     "a poll does not undo a window the reader widened"),
+]
+
+original = io.open(CLIENT, encoding="utf-8", newline="").read()
+
+
+def run():
+    proc = subprocess.run(["node", PROBE], cwd=HERE,
+                          capture_output=True, text=True, encoding="utf-8", errors="replace")
+    return proc.stdout + proc.stderr
+
+
+ok = True
+baseline = run()
+base_ok = "0 failed" in baseline
+print(("ok   " if base_ok else "FAIL ") + "baseline green")
+ok = ok and base_ok
+
+caught = []
+for title, old, new, expect in MUTATIONS:
+    if original.count(old) != 1:
+        raise SystemExit("FAIL  anchor for %r matched %d times" % (title, original.count(old)))
+    try:
+        io.open(CLIENT, "w", encoding="utf-8", newline="").write(original.replace(old, new, 1))
+        during = run()
+        named = expect in during
+        failed = "0 failed" not in during
+        print(("ok   " if (named and failed) else "FAIL ") + "guard catches: " + title)
+        for line in during.splitlines():
+            if line.strip().startswith("-") and "window" in line:
+                print("       " + line.strip())
+        caught.append(named and failed)
+    finally:
+        io.open(CLIENT, "w", encoding="utf-8", newline="").write(original)
+
+restored = io.open(CLIENT, encoding="utf-8").read()
+after = run()
+after_ok = "0 failed" in after
+print(("ok   " if restored == original else "FAIL ") + "client restored byte for byte")
+print(("ok   " if after_ok else "FAIL ") + "green again after restore")
+
+sys.exit(0 if (ok and all(caught) and restored == original and after_ok) else 1)
diff --git a/plugins/avatasia/mmc-trajectory/tests/run.mjs b/plugins/avatasia/mmc-trajectory/tests/run.mjs
new file mode 100644
index 0000000..883d991
--- /dev/null
+++ b/plugins/avatasia/mmc-trajectory/tests/run.mjs
@@ -0,0 +1,63 @@
+// Run every regression guard in this directory.
+//
+//   node tests/run.mjs            run all of them
+//   node tests/run.mjs verify-    run only the verifiers
+//   node tests/run.mjs mutate-   run only the mutation controls
+//
+// A guard that cannot fail is not a guard. That is what the mutate-* files are for: each one
+// breaks one rule in the shipped source, runs the guard that owns that rule, and requires it to
+// fail with the right reason before restoring the file byte-for-byte. If a mutation is reported
+// as "survived", the guard it exercised is not actually testing anything.
+//
+// Nothing here needs a running Mini App, a network, or a specific machine's paths: every path
+// resolves from this file's own location.
+import { spawnSync } from 'node:child_process';
+import { readdirSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { join } from 'node:path';
+
+const HERE = fileURLToPath(new URL('.', import.meta.url));
+const args = process.argv.slice(2);
+const REAL = args.includes('--real');
+const filter = args.find((a) => !a.startsWith('--')) ?? '';
+
+// verify-time-range.mjs is here but not run. Its assertions are calibrated against a full
+// multi-generation session — stats.messages > 1000, a checkpoint nested inside a turn — and the
+// committed fixture is a single-file session of a few dozen rows. Shipping it in the default set
+// would mean shipping a red suite; relax the numbers instead and the timezone arithmetic stops
+// being exercised at all. Run it by hand against a booted service: see its own header.
+const SKIP = new Set(['verify-time-range.mjs']);
+
+const files = readdirSync(HERE)
+  .filter((n) => n !== 'run.mjs' && n !== 'README.md' && !SKIP.has(n)
+    && (n.startsWith('verify-') || n.startsWith('mutate-')
+      || n === 'client-check.mjs' || n === 'check-light-theme.mjs'))
+  .filter((n) => !filter || n.startsWith(filter))
+  .sort();
+
+const results = [];
+for (const name of files) {
+  const isPy = name.endsWith('.py');
+  const cmd = isPy
+    ? ['python', join(HERE, name)]
+    : [process.execPath, join(HERE, name), ...(REAL ? ['--real'] : [])];
+  const started = Date.now();
+  const r = spawnSync(cmd[0], cmd.slice(1), {
+    cwd: HERE,
+    encoding: 'utf8',
+    env: { ...process.env, PYTHONIOENCODING: 'utf-8' },
+    maxBuffer: 64 * 1024 * 1024,
+  });
+  const out = `${r.stdout ?? ''}${r.stderr ?? ''}`.trim();
+  const ok = r.status === 0;
+  results.push({ name, ok, ms: Date.now() - started, tail: out.split('\n').filter(Boolean).slice(-1)[0] ?? '' });
+  console.log(`${ok ? 'PASS' : 'FAIL'}  ${name.padEnd(30)} ${String(Date.now() - started).padStart(6)}ms  ${results.at(-1).tail.slice(0, 70)}`);
+}
+
+const failed = results.filter((r) => !r.ok);
+console.log();
+console.log(`${results.length - failed.length}/${results.length} guards passed`);
+if (failed.length) {
+  console.log('failed: ' + failed.map((f) => f.name).join(', '));
+  process.exitCode = 1;
+}
\ No newline at end of file
diff --git a/plugins/avatasia/mmc-trajectory/tests/verify-anchor-carry.mjs b/plugins/avatasia/mmc-trajectory/tests/verify-anchor-carry.mjs
new file mode 100644
index 0000000..64fefa0
--- /dev/null
+++ b/plugins/avatasia/mmc-trajectory/tests/verify-anchor-carry.mjs
@@ -0,0 +1,154 @@
+/**
+ * The reader's scroll position has to survive a rebuild.
+ *
+ * There is no moment where it survives on its own. `renderLedger()` clears the ledger, which
+ * takes the document from 716,000px to about 1,500px, and the browser clamps `scrollY` to match —
+ * measured 715,080 → 616. The position only comes back at the end of the build, from
+ * `restoreRowAnchor()`. So between the capture and the restore there is nothing, and every pass in
+ * between has to carry the intent rather than re-read it.
+ *
+ * That is the whole defect. `buildStep()` stops at `if (build.token !== ledgerBuildToken) return;`
+ * when it is superseded, so a superseded pass never reached the restore — and the pass that
+ * replaced it captured its anchor from the wreckage. Measured: a click on any row that landed while
+ * a poll build was in flight left the page on the first turn for good, because that is now what
+ * the anchor said. See docs/LAYERS.md D14.
+ *
+ * The rule has two halves and both are checked here. The capture is *run* against a preset intent,
+ * so a version that re-reads it produces a different answer rather than merely looking different.
+ * The consumers are counted, because the half that was broken was a missing call on a path that
+ * ends the ledger early.
+ *
+ * mutate-anchor-carry.py breaks each of these in the shipped file and requires this guard to
+ * report it, so a rule nothing tests cannot be added here.
+ */
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import vm from 'node:vm';
+
+const HTML = fileURLToPath(new URL('../miniapp/client/index.html', import.meta.url));
+const html = readFileSync(HTML, 'utf8');
+
+let pass = 0;
+const failures = [];
+function assert(name, cond) {
+  if (cond) pass += 1;
+  else failures.push(name);
+}
+
+function functionSource(name) {
+  const at = html.indexOf('function ' + name + '(');
+  if (at < 0) return null;
+  let i = html.indexOf('{', at);
+  let depth = 0;
+  for (let j = i; j < html.length; j += 1) {
+    if (html[j] === '{') depth += 1;
+    else if (html[j] === '}') {
+      depth -= 1;
+      if (depth === 0) return html.slice(at, j + 1);
+    }
+  }
+  return null;
+}
+
+const ledger = functionSource('renderLedger');
+assert('renderLedger is in the shipped script', !!ledger);
+
+/* ---------- the capture, run ---------- */
+
+/**
+ * The three statements that decide what a pass anchors on, lifted out of renderLedger() and run
+ * against an intent that is already set. `firstVisibleRow()` and `window.scrollY` are stubs that
+ * report a *different* position from the preset one, so a capture that re-reads them returns the
+ * stub's answer and the assertion below sees it. If the capture honours the intent it returns the
+ * preset's, which is the behaviour that keeps the reader where they were.
+ */
+function capture({ preset, visible, scrollY }) {
+  const sandbox = {
+    pendingAnchor: preset,
+    firstVisibleRow: () => visible,
+    window: { scrollY, pageYOffset: 0 },
+  };
+  vm.createContext(sandbox);
+  const at = ledger.indexOf('if (!pendingAnchor)');
+  if (at < 0) return { error: 'the guarded capture is not in renderLedger' };
+  const end = ledger.indexOf('var scrollY = pendingAnchor.y;', at);
+  if (end < 0) return { error: 'the capture does not end where this guard expects' };
+  const src = ledger.slice(at, end) + '\nanchor = pendingAnchor.row;\nscrollY = pendingAnchor.y;\n';
+  try {
+    return vm.runInContext(src + '({ anchor: anchor, scrollY: scrollY });', sandbox);
+  } catch (err) {
+    return { error: String(err && err.message) };
+  }
+}
+
+const kept = capture({
+  preset: { row: { id: 'anchor-1', top: 412 }, y: 715080 },
+  visible: { id: 'anchor-9', top: -6 },
+  scrollY: 616,
+});
+
+assert('a pass inside a chain re-uses the intent it was handed',
+  !kept.error && kept.anchor && kept.anchor.id === 'anchor-1' && kept.anchor.top === 412);
+assert('a pass inside a chain re-uses the pixel offset too, not the clamped one',
+  !kept.error && kept.scrollY === 715080);
+
+const fresh = capture({ preset: null, visible: { id: 'anchor-9', top: -6 }, scrollY: 616 });
+assert('the first pass of a chain reads the live position',
+  !fresh.error && fresh.anchor && fresh.anchor.id === 'anchor-9' && fresh.scrollY === 616);
+
+/* ---------- one writer ---------- */
+
+// `pendingAnchor` is nulled in exactly one place. Two writers is how the chain would learn to
+// expect a promise it cannot keep — and this page has paid for a two-writer state field before
+// (state.limit, see docs/LAYERS.md D13). The declaration is not a write; the lookbehind is what
+// keeps `var pendingAnchor = null;` out of the count, since it contains the same nine characters.
+const clears = (html.match(/(?<!var )pendingAnchor = null;/g) ?? []).length;
+assert('pendingAnchor has one writer', clears === 1);
+
+const forget = functionSource('forgetScrollAnchor');
+assert('forgetScrollAnchor nulls it and does nothing else',
+  !!forget && forget.replace(/\s+/g, ' ') === 'function forgetScrollAnchor() { pendingAnchor = null; }');
+
+/* ---------- the consumers ---------- */
+
+// restoreRowAnchor() is the one place a chain ends by restoring, so it is the one place that has to
+// consume. Not calling it leaves the intent armed for whatever runs next.
+const restore = functionSource('restoreRowAnchor');
+assert('restoring consumes the intent',
+  !!restore && restore.indexOf('forgetScrollAnchor();') >= 0
+    && restore.indexOf('forgetScrollAnchor();') < restore.indexOf('if (anchor)'));
+
+const forgetCalls = (html.match(/forgetScrollAnchor\(\);/g) ?? []).length;
+assert('forgetScrollAnchor is called from both endings and nothing else',
+  forgetCalls === 6); // 1 in restoreRowAnchor + 5 early returns
+
+// The five early returns between the clear and the build: loading, hard error, no payload, no
+// sessions, no matches. Each leaves the ledger holding a block rather than rows, so there is
+// nothing to anchor to and the intent has to go. Carrying it would apply a position measured
+// against one session or one filter to a different one.
+if (ledger) {
+  const from = ledger.indexOf('clear(ledger);');
+  const to = ledger.indexOf('var groups = visibleTurns(');
+  const head = from >= 0 && to > from ? ledger.slice(from, to) : '';
+  const earlyReturns = (head.match(/^\s*return;$/gm) ?? []).length;
+  const earlyForgets = (head.match(/forgetScrollAnchor\(\);/g) ?? []).length;
+  assert('every early return after the clear drops the intent',
+    earlyReturns > 0 && earlyReturns === earlyForgets);
+}
+
+// `firstVisibleRow()` and `window.scrollY` are how a pass could re-read a position that no longer
+// describes anything. One call site each, both inside the guarded capture.
+assert('the live position is read in exactly one place',
+  !!ledger
+    && (ledger.match(/firstVisibleRow\(\)/g) ?? []).length === 1
+    && (ledger.match(/window\.scrollY/g) ?? []).length === 1);
+
+if (failures.length) {
+  console.error(`[anchor-carry] ${pass} passed, ${failures.length} failed`);
+  for (const f of failures) console.error('  FAIL  ' + f);
+  process.exit(1);
+}
+// "0 failed" on success is not decoration: mutate-anchor-carry.py reads this line to decide the
+// baseline is green, and a guard whose success marker it cannot match makes the mutation run
+// report every mutation as caught while it was in fact testing nothing.
+console.log(`[anchor-carry] ${pass} passed, 0 failed`);
\ No newline at end of file
diff --git a/plugins/avatasia/mmc-trajectory/tests/verify-anomaly.mjs b/plugins/avatasia/mmc-trajectory/tests/verify-anomaly.mjs
new file mode 100644
index 0000000..ca95cab
--- /dev/null
+++ b/plugins/avatasia/mmc-trajectory/tests/verify-anomaly.mjs
@@ -0,0 +1,900 @@
+// Evidence for the 异常 filter.
+//
+// The rule set is three predicates, and two of them are one comparison each — a table like that
+// cannot be wrong in an interesting way. What can be wrong, and what a fixture cannot show, is
+// whether the page's own bookkeeping agrees with the payload:
+//
+//  1. The rule counts on the buttons are computed by a second walk of the flat list. If that walk
+//     and `visibleEntries()` ever disagree, a button promises a number the ledger will not
+//     deliver — which is the same class of bug this file has been bitten by twice already.
+//  2. 无答复 is a property of a TURN, and the strip is handed a bare record. So the turn has to
+//     come back out of an index. If that index is wrong or missing, the strip and the ledger
+//     answer different questions about the same row.
+//  3. The turn still running must not be flagged. It is open because it is going.
+//
+// So the load-bearing checks below all run against the live session payload, and the expected
+// numbers are counted straight off it by code that shares nothing with the page.
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import vm from 'node:vm';
+
+const HERE = fileURLToPath(new URL('.', import.meta.url));
+const HTML = join(HERE, '..', 'miniapp', 'client', 'index.html');
+// Section 4 used to boot the service and fetch /api/trajectory from a port read out of
+// .probe/port.txt. The payload is now the committed one from make-payload.mjs.
+const PAYLOAD = join(HERE, 'fixtures', 'trajectory.json');
+
+const html = readFileSync(HTML, 'utf8');
+
+/* ---------- helpers ---------- */
+let pass = 0;
+const failures = [];
+// Names are kept separately from the human-readable detail. They used to be recovered from the
+// detail line with `split(':')[0]`, which quietly truncates any assertion whose name contains a
+// colon — and the mutation runner matches on these names, so a truncated name reads as a
+// mutation that went uncaught by a guard that in fact caught it.
+const failedNames = [];
+function check(name, actual, expected) {
+  const ok = JSON.stringify(actual) === JSON.stringify(expected);
+  if (ok) pass += 1;
+  else {
+    failedNames.push(name);
+    failures.push(name + ': got ' + JSON.stringify(actual) + ', want ' + JSON.stringify(expected));
+  }
+}
+function assert(name, cond) {
+  if (cond) pass += 1;
+  else {
+    failedNames.push(name);
+    failures.push(name);
+  }
+}
+function fnSource(sig) {
+  const start = html.indexOf(sig);
+  if (start < 0) return '';
+  let i = html.indexOf('{', start);
+  let depth = 0;
+  for (let j = i; j < html.length; j += 1) {
+    if (html[j] === '{') depth += 1;
+    else if (html[j] === '}') {
+      depth -= 1;
+      if (depth === 0) return html.slice(start, j + 1);
+    }
+  }
+  return '';
+}
+
+/* ---------- 1) the rule table itself ---------- */
+const rawSlice = html.split('PURE:START')[1].split('PURE:END')[0];
+let block = rawSlice.slice(rawSlice.indexOf('*/') + 2);
+const lastCloser = block.lastIndexOf('*/');
+const dangling = block.indexOf('/*', lastCloser === -1 ? 0 : lastCloser + 2);
+if (dangling >= 0) block = block.slice(0, dangling);
+const pure = { console };
+vm.createContext(pure);
+vm.runInContext(block, pure);
+
+check('the rule set', pure.ANOMALY_RULE_IDS, ['toolError', 'compaction', 'noReply', 'silent']);
+check('rule labels', pure.ANOMALY_RULES.map((r) => r.label), ['工具失败', '上下文压缩', '无答复', '空答复']);
+
+// A rule is scoped to a record or to a turn, never both and never neither. A rule with neither
+// would silently match nothing and still get a button with a count on it.
+for (const rule of pure.ANOMALY_RULES) {
+  assert('rule ' + rule.id + ' has exactly one scope', !!rule.record !== !!rule.turn);
+  assert('rule ' + rule.id + ' has an id and a label', !!rule.id && !!rule.label);
+}
+assert('rule ids are unique', new Set(pure.ANOMALY_RULE_IDS).size === pure.ANOMALY_RULES.length);
+check('an unknown id labels as itself', pure.anomalyRuleLabel('nope'), 'nope');
+check('an empty id labels as the dash', pure.anomalyRuleLabel(''), '—');
+
+/* ---------- 2) rule semantics on hand-built records ---------- */
+const CLOSED = { index: 1, closed: true, records: [] };
+const BROKEN = { index: 2, closed: false, records: [] };
+const LIVE = { index: 3, closed: false, records: [] };
+const withLive = (turn) => ({ turn, liveTurn: LIVE });
+
+check('a failing tool result is a tool failure',
+  pure.recordAnomalyRules({ kind: 'toolResult', isError: true }, { turn: CLOSED, liveTurn: LIVE }),
+  ['toolError']);
+check('a successful tool result is not',
+  pure.recordAnomalyRules({ kind: 'toolResult', isError: false }, { turn: CLOSED, liveTurn: LIVE }), []);
+check('an absent isError is not a failure — null is not true',
+  pure.recordAnomalyRules({ kind: 'toolResult', isError: null }, { turn: CLOSED, liveTurn: LIVE }), []);
+check('the string "true" is not a failure either',
+  pure.recordAnomalyRules({ kind: 'toolResult', isError: 'true' }, { turn: CLOSED, liveTurn: LIVE }), []);
+check('a checkpoint is a compaction',
+  pure.recordAnomalyRules({ kind: 'compaction' }, { turn: CLOSED, liveTurn: LIVE }), ['compaction']);
+// A thinking row is the clean case. `{ kind: 'reply' }` is not — a reply with no body is now
+// an anomaly, which is the whole point of the rule below.
+check('a normal row is not an anomaly',
+  pure.recordAnomalyRules({ kind: 'thinking' }, { turn: CLOSED, liveTurn: LIVE }), []);
+
+check('a turn that never answered, seen from inside it',
+  pure.recordAnomalyRules({ kind: 'thinking' }, withLive(BROKEN)), ['noReply']);
+check('a turn that answered is not one',
+  pure.recordAnomalyRules({ kind: 'thinking' }, withLive(CLOSED)), []);
+
+// This is the one that would have made the filter unusable: the live turn is open on every poll
+// for as long as the session runs, so a rule that flagged it re-flagged the newest thing on
+// screen every 2.5s and could never be left on.
+check('the turn still running is not an anomaly',
+  pure.recordAnomalyRules({ kind: 'thinking' }, { turn: LIVE, liveTurn: LIVE }), []);
+assert('and the exclusion is by identity, not by position',
+  pure.recordAnomalyRules({ kind: 'thinking' }, { turn: { index: 3, closed: false }, liveTurn: LIVE })
+    .indexOf('noReply') >= 0);
+
+// Two rules on one row is a real shape: a checkpoint sits inside a turn that never answered.
+check('two rules can fire on one record',
+  pure.recordAnomalyRules({ kind: 'compaction', isError: true }, withLive(BROKEN)),
+  ['toolError', 'compaction', 'noReply']);
+
+/* ---------- 2b) an empty reply: a reply AND an anomaly, and neither rule alone sees it ---------- */
+// This is the shape a reader actually met. The turn finished normally and delivered nothing,
+// so `closed` is true and 无答复 cannot fire — and the record is still `kind: 'reply'`, so it
+// remains a real reply that the 答复 chip counts. Missing it was a hole in the rule set, not a
+// subtlety: every other rule tests a field that was present, this one tests an absence.
+const SILENT = { kind: 'reply', text: null, summary: '', title: 'assistant', stopReason: 'stop' };
+const SPOKE = { kind: 'reply', text: '答完了。', summary: '答完了。', stopReason: 'stop' };
+
+check('a reply with no body is an empty answer',
+  pure.recordAnomalyRules(SILENT, { turn: CLOSED, liveTurn: LIVE }), ['silent']);
+check('a reply that said something is not',
+  pure.recordAnomalyRules(SPOKE, { turn: CLOSED, liveTurn: LIVE }), []);
+
+// 既算回复也算异常, checked from both sides rather than asserted once.
+assert('an empty answer keeps its kind — it is still a reply',
+  SILENT.kind === 'reply' && pure.hasKind(SILENT, ['reply']) === true);
+assert('and the whole kind set still contains it',
+  pure.hasKind(SILENT, pure.KIND_ORDER) === true);
+assert('so unchecking 答复 hides it, exactly as it hides any other reply',
+  pure.hasKind(SILENT, pure.KIND_ORDER.filter((k) => k !== 'reply')) === false);
+
+// 无答复 must NOT double-count it: an empty reply closes its turn, so the turn-level rule has
+// nothing to fire on and the whole thing rests on the one record-level rule.
+check('an empty answer in a closed turn is only the empty answer',
+  pure.recordAnomalyRules(SILENT, { turn: CLOSED, liveTurn: LIVE }), ['silent']);
+check('the same record in a turn that never answered fires both',
+  pure.recordAnomalyRules(SILENT, withLive(BROKEN)), ['noReply', 'silent']);
+
+// An empty string counts as no body; whitespace does not, because a reader sees something.
+check('an empty string is an empty answer',
+  pure.recordAnomalyRules({ kind: 'reply', text: '' }, { turn: CLOSED, liveTurn: LIVE }), ['silent']);
+check('whitespace is not an empty answer',
+  pure.recordAnomalyRules({ kind: 'reply', text: ' ' }, { turn: CLOSED, liveTurn: LIVE }), []);
+// A clipped reply still has a body, however short. textTruncated is not the test.
+check('a clipped reply is not an empty answer',
+  pure.recordAnomalyRules({ kind: 'reply', text: '很长的…', textTruncated: true },
+    { turn: CLOSED, liveTurn: LIVE }), []);
+// Only replies. A checkpoint has no body by design and is already its own rule; counting it
+// twice would make the union smaller than the parts, which is the one thing `any` must not be.
+check('a checkpoint is not also an empty answer',
+  pure.recordAnomalyRules({ kind: 'compaction', text: null }, { turn: CLOSED, liveTurn: LIVE }),
+  ['compaction']);
+check('a system record with no body is not an empty answer',
+  pure.recordAnomalyRules({ kind: 'system', text: null }, { turn: CLOSED, liveTurn: LIVE }), []);
+
+/* ---------- 3) off is not "match nothing" ---------- */
+const OFF = [];
+const ALL = pure.ANOMALY_RULE_IDS.slice();
+assert('the filter off lets a clean record through',
+  pure.passesAnomaly({ kind: 'reply' }, { turn: CLOSED, liveTurn: LIVE }, OFF) === true);
+assert('the filter off lets an anomalous record through too',
+  pure.passesAnomaly({ kind: 'compaction' }, { turn: CLOSED, liveTurn: LIVE }, OFF) === true);
+assert('no rule at all is off, not an empty result',
+  pure.passesAnomaly({ kind: 'reply' }, { turn: CLOSED, liveTurn: LIVE }, null) === true);
+assert('undefined enabled is off too',
+  pure.passesAnomaly({ kind: 'reply' }, { turn: CLOSED, liveTurn: LIVE }, undefined) === true);
+
+assert('all rules on keeps the anomaly',
+  pure.passesAnomaly({ kind: 'compaction' }, { turn: CLOSED, liveTurn: LIVE }, ALL) === true);
+assert('all rules on drops the clean record',
+  pure.passesAnomaly({ kind: 'thinking' }, { turn: CLOSED, liveTurn: LIVE }, ALL) === false);
+assert('one rule on keeps only that rule',
+  pure.passesAnomaly({ kind: 'compaction' }, { turn: CLOSED, liveTurn: LIVE }, ['compaction']) === true);
+assert('one rule on drops a record only another rule matches',
+  pure.passesAnomaly({ kind: 'toolResult', isError: true }, { turn: CLOSED, liveTurn: LIVE }, ['compaction']) === false);
+assert('a rule nothing matches drops everything it is asked about',
+  pure.passesAnomaly({ kind: 'reply' }, { turn: CLOSED, liveTurn: LIVE }, ['compaction']) === false);
+assert('an enabled id that is not in the table matches nothing rather than everything',
+  pure.passesAnomaly({ kind: 'compaction' }, { turn: CLOSED, liveTurn: LIVE }, ['bogus']) === false);
+
+/* ---------- 4) against the committed payload ---------- */
+const payload = JSON.parse(readFileSync(PAYLOAD, 'utf8'));
+
+const page = { console, state: null };
+vm.createContext(page);
+// The whole PURE block runs here, verbatim, so the rules under test are the page's own rules
+// and not a reconstruction of them. Only the functions that reach for state come from the
+// client file.
+vm.runInContext(block, page);
+vm.runInContext('var turnById = new Map(); var overviewSpansById = new Map();', page);
+page.state = {
+  payload,
+  flat: payload.turns.flatMap((turn) => turn.records.map((record) => ({ turn, record }))),
+  kinds: pure.KIND_ORDER.slice(),
+  query: '',
+  anomalyRules: [],
+  // 多选 defaults to off, so a reader who has never touched the checkbox is in single mode —
+  // which is the behaviour the toggle is asserted on below, and not an accident of the harness
+  // having left `multiAnomaly` undefined. Stated here rather than omitted so that forgetting it
+  // fails loudly instead of quietly testing the union branch.
+  multiAnomaly: false,
+  anomalyLast: null,
+  rangeFrom: null,
+  rangeTo: null,
+  rangeCutoff: null,
+  overviewSelection: null
+};
+for (const turn of payload.turns) if (turn && turn.id) page.turnById.set(turn.id, turn);
+
+for (const name of ['recordInRange', 'hasTimeRange', 'inTimeRange', 'recordInSelection',
+  'passesBaseFilter', 'liveTurn', 'anomalyContext', 'anomalyCounts', 'visibleEntries',
+  'turnAnomalyRules', 'spanPassesFilter']) {
+  const src = fnSource('function ' + name + '(');
+  if (!src) throw new Error('could not extract ' + name);
+  vm.runInContext(src, page);
+}
+
+/* The expected numbers, counted straight off the payload by code that shares nothing with the
+   page. This is the whole point of the file. */
+const liveTurn = payload.turns[payload.turns.length - 1];
+const brokenTurns = new Set(payload.turns.filter((t) => t.closed === false && t !== liveTurn));
+// `noReply` is counted in turns, because that is the unit the page publishes it in: it is a
+// rule about a turn, and counting the records inside it is what produced the original lie —
+// over a thousand "unanswered" rows in a session that was actually broken a dozen times. The
+// record count is still needed for the overlap check, so it is kept under its own name rather
+// than being quietly dropped.
+const expect = { toolError: 0, compaction: 0, noReply: brokenTurns.size, silent: 0 };
+let noReplyRecords = 0;
+let expectAny = 0;
+const emptyReplies = [];
+for (const turn of payload.turns) {
+  for (const record of turn.records) {
+    const hits = [];
+    if (record.isError === true) { expect.toolError += 1; hits.push(1); }
+    if (record.kind === 'compaction') { expect.compaction += 1; hits.push(1); }
+    if (brokenTurns.has(turn)) { noReplyRecords += 1; hits.push(1); }
+    // Written out rather than calling isNil, so this stays an independent reading of the
+    // payload rather than a second call into the rule the check is meant to test.
+    if (record.kind === 'reply'
+      && (record.text === null || record.text === undefined || record.text === '')) {
+      expect.silent += 1;
+      hits.push(1);
+      emptyReplies.push({ turn, record });
+    }
+    if (hits.length) expectAny += 1;
+  }
+}
+
+console.log('fixture: ' + payload.turns.length + ' turns, '
+  + payload.turns.reduce((n, t) => n + t.records.length, 0) + ' records, '
+  + brokenTurns.size + ' turns that never answered');
+
+assert('the fixture has failures to find', expect.toolError > 0);
+assert('the fixture has checkpoints to find', expect.compaction > 0);
+assert('the fixture has unanswered turns to find', expect.noReply > 0);
+assert('and it holds replies that delivered nothing', expect.silent > 0);
+assert('they overlap, so `any` is not the sum',
+  expectAny < expect.toolError + expect.compaction + expect.silent + noReplyRecords);
+
+// Every empty reply in this session sits in a turn that closed, which is precisely why 无答复
+// never reported it. If one of them ever landed in an unclosed turn, the two rules would start
+// overlapping and the claim "the empty-answer rule is the only one that can see these" would
+// stop being true — so it is checked against the live session rather than assumed.
+assert('every empty reply sits in a turn that closed',
+  emptyReplies.every((e) => e.turn.closed === true));
+assert('so 无答复 genuinely cannot see them',
+  emptyReplies.every((e) => brokenTurns.has(e.turn) === false));
+assert('and they keep their kind', emptyReplies.every((e) => e.record.kind === 'reply'));
+
+const all = page.anomalyCounts();
+check('tool failure count matches the payload', all.byRule.toolError, expect.toolError);
+check('compaction count matches the payload', all.byRule.compaction, expect.compaction);
+check('unanswered count matches the payload, counted in turns', all.byRule.noReply, expect.noReply);
+check('empty answer count matches the payload', all.byRule.silent, expect.silent);
+check('the union count matches the payload', all.any, expectAny);
+
+// The unit is part of the claim, not decoration on it. A number without one is read as 条 by
+// default, which is exactly how a turn rule came to advertise a thousand records.
+check('the turn rule publishes itself in 轮', all.unit.noReply, '轮');
+assert('and every record rule publishes itself in 条',
+  pure.ANOMALY_RULE_IDS.every((id) => all.unit[id] === '条' || all.unit[id] === '轮'));
+assert('the unit follows the rule table, not the button',
+  pure.ANOMALY_RULES.every((r) => all.unit[r.id] === (r.turn ? '轮' : '条')));
+
+// The button and the ledger are the same statement about the same records. If these ever drift,
+// a button is advertising rows the list refuses to render. The filter has to be on first —
+// compared with it off, the ledger returns everything and the check would pass for free.
+page.state.anomalyRules = pure.ANOMALY_RULE_IDS.slice();
+check('the button count is the length of the list behind it', all.any, page.visibleEntries().length);
+for (const id of pure.ANOMALY_RULE_IDS) {
+  page.state.anomalyRules = [id];
+  const only = page.visibleEntries();
+  if (all.unit[id] === '条') {
+    check('one rule on shows exactly what it counts — ' + id, only.length, all.byRule[id]);
+  } else {
+    // A turn rule publishes turns and puts on screen every record of those turns. Both halves
+    // are checked, because a button promising N turns above a list of M records only adds up
+    // if the list is exactly the records of N turns — and if those turns are the ones it named.
+    check('a turn rule shows every record of the turns it counts — ' + id, only.length, noReplyRecords);
+    check('and exactly the turns it published — ' + id,
+      new Set(only.map((e) => e.turn.index)).size, all.byRule[id]);
+  }
+  assert('nothing else leaked into that filter — ' + id,
+    only.every((e) => pure.recordAnomalyRules(e.record, { turn: e.turn, liveTurn })
+      .indexOf(id) >= 0));
+  assert('that filter is not the whole ledger — ' + id, only.length < page.state.flat.length);
+}
+
+/* A partial union is the one case the button counts above cannot reach. `all.any` is the union of
+   every rule, and each single-rule check only ever selects one — so before this block nothing
+   tested the selection 多选 exists to produce. The expected number is counted here by code that
+   shares nothing with the page: a record is in the union when it trips any *selected* rule.
+   Without it, `selected` could be the count of the whole table and every assertion above would
+   still pass. */
+const expectUnion = (ids) => page.state.flat.filter((e) => {
+  const hits = pure.recordAnomalyRules(e.record, { turn: e.turn, liveTurn });
+  return ids.some((id) => hits.indexOf(id) >= 0);
+}).length;
+// Record-level, not `byRule`: for a turn rule `byRule` counts turns, so adding it to a record
+// count would subtract apples from oranges and report an overlap that is not there.
+const recordCount = {};
+for (const id of pure.ANOMALY_RULE_IDS) recordCount[id] = expectUnion([id]);
+
+// Each pair, including the pairs with nothing in common. Every one of them has to give a number
+// the ledger reproduces, which is the whole claim: a button, a note and a list that agree.
+const pairResults = [];
+for (const a of pure.ANOMALY_RULE_IDS) {
+  for (const b of pure.ANOMALY_RULE_IDS) {
+    if (b <= a) continue;
+    page.state.anomalyRules = [a, b];
+    pairResults.push({
+      a,
+      b,
+      selected: page.anomalyCounts().selected,
+      listed: page.visibleEntries().length,
+      expected: expectUnion([a, b]),
+      overlap: recordCount[a] + recordCount[b] - expectUnion([a, b])
+    });
+  }
+}
+assert('a partial union is not the whole table, so it has to be counted separately',
+  pairResults.some((p) => p.selected < all.any));
+// One family assertion per pair on top of the per-pair ones below. The per-pair names carry the
+// pair, which is what makes a failure readable — and which also makes them unusable as the owner
+// of a mutation, because which pair fires depends on the fixture. The family assertion has a
+// stable name and is the one the mutation runner is pointed at.
+check('a partial union is the length of the list behind it',
+  pairResults.every((p) => p.selected === p.listed), true);
+check('and it is the union of those rules and not some other set',
+  pairResults.every((p) => p.selected === p.expected), true);
+for (const p of pairResults) {
+  check('a partial union is the length of the list behind it — ' + p.a + ' + ' + p.b,
+    p.selected, p.listed);
+  check('and it is the union of those two rules and not some other set — ' + p.a + ' + ' + p.b,
+    p.selected, p.expected);
+}
+// The overlap is why the per-rule numbers cannot be added by hand, and why the note has to state
+// the total instead of pointing at 全部异常 — which is the union of all four rules and therefore a
+// different number again for any selection that is not all of them.
+assert('some pair of rules genuinely overlaps, or the total would just be the sum',
+  pairResults.some((p) => p.overlap > 0));
+assert('and every partial union is smaller than 全部异常, so the two can never be confused',
+  pairResults.every((p) => p.selected < all.any));
+
+page.state.anomalyRules = pure.ANOMALY_RULE_IDS.slice();
+const everything = page.visibleEntries();
+assert('every rule on is still only the anomalies', everything.length === expectAny);
+
+// The strip is handed a bare record, so the turn comes back out of the index. If that lookup
+// were missing, 无答复 would silently match nothing on the strip and everything in the ledger.
+page.state.anomalyRules = ['noReply'];
+const byLedger = new Set(page.visibleEntries().map((e) => e.record.id));
+const byStrip = new Set();
+for (const entry of page.state.flat) {
+  if (page.spanPassesFilter(entry.record, false)) byStrip.add(entry.record.id);
+}
+check('the strip and the ledger keep the same records', byStrip.size, byLedger.size);
+assert('and it is the same records', [...byLedger].every((id) => byStrip.has(id)));
+assert('the strip is not keeping everything', byStrip.size < page.state.flat.length);
+
+page.state.anomalyRules = [];
+
+/* ---------- the two axes are exclusive, so the count must not follow the other one ----------
+   This inverts what this file used to assert. It required a search to narrow the button count,
+   which held exactly while the ledger narrowed it too — and that was the defect: the number was
+   describing a filtered view that anomaly mode does not produce, so ticking the rule it was
+   advertising gave the reader something else. The number on a button is what you get when you
+   tick that button, so it cannot depend on a filter that is switched off at that moment. */
+page.state.query = 'verify-time-range';
+const searched = page.anomalyCounts();
+check('a search does not move the union count', searched.any, expectAny);
+check('nor a single record rule', searched.byRule.toolError, expect.toolError);
+check('nor the turn rule', searched.byRule.noReply, expect.noReply);
+// The list has to agree with that, or the count would be honest and the table would not be.
+page.state.anomalyRules = ['toolError'];
+check('and while a rule is ticked the search does not narrow the list either',
+  page.visibleEntries().length, expect.toolError);
+page.state.anomalyRules = [];
+assert('but with no rule ticked the search is still a filter for the list',
+  page.visibleEntries().length < page.state.flat.length);
+page.state.query = '';
+
+page.state.kinds = pure.KIND_ORDER.filter((k) => k !== 'toolResult');
+const withoutToolResults = page.anomalyCounts();
+check('unchecking 工具结果 does not move the count either',
+  withoutToolResults.byRule.toolError, expect.toolError);
+assert('and it still leaves the checkpoints alone',
+  withoutToolResults.byRule.compaction === expect.compaction);
+assert('but with no rule ticked it is still a filter for the list',
+  page.visibleEntries().length < page.state.flat.length);
+page.state.kinds = pure.KIND_ORDER.slice();
+
+/* Turn-level, read on its own: the tag on the turn head. */
+const flagged = payload.turns.filter((t) => page.turnAnomalyRules(t).length > 0);
+check('every unanswered turn is flagged', flagged.length, brokenTurns.size);
+assert('the live turn is not among them', flagged.indexOf(liveTurn) === -1);
+check('a closed turn is never flagged',
+  page.turnAnomalyRules({ index: 99, closed: true }).length, 0);
+check('a rule that is record-scoped never tags a turn',
+  page.turnAnomalyRules({ index: 98, closed: false, id: 'x' }).length, 1);
+// The turn head is the only place 无答复 is written. A row-level badge was considered and
+// dropped: turn 82 alone would have carried the tag 352 times, which buries it.
+assert('no rule is tagged on a record',
+  pure.ANOMALY_RULES.every((r) => typeof r.record !== 'function' || typeof r.turn !== 'function'));
+
+/* ---------- 5) ticking, run rather than read ---------- */
+// The static guards below can only see the shape of onAnomalyToggle. These run it, because the
+// shape of a toggle is the same whether it adds, removes or does nothing.
+page.resetWindowMode = () => {};
+let renders = 0;
+page.render = () => { renders += 1; };
+const toggleSource = fnSource('function onAnomalyToggle(');
+if (!toggleSource) throw new Error('could not extract onAnomalyToggle');
+vm.runInContext(toggleSource, page);
+// resetBaseFilters is real here, not stubbed: it is the thing that decides whether the row above
+// ends up displaying a condition that is not in force. Only its two DOM-touching steps are
+// stubbed, because what they do to the widgets is checked by their own guards.
+const resetBaseSource = fnSource('function resetBaseFilters(');
+if (!resetBaseSource) throw new Error('could not extract resetBaseFilters');
+vm.runInContext(resetBaseSource, page);
+let rangeCleared = 0;
+page.clearTimeRange = () => { rangeCleared += 1; };
+page.syncKindButtons = () => {};
+// The checkbox is the only part of 多选 that exists outside `state`, and 重置 has to write it.
+// A stub with a real `checked` field is what lets that be asserted as behaviour rather than
+// inferred from the assignment appearing in the source.
+page.dom = { searchInput: null, anomalyMulti: { checked: false } };
+
+/* The note, run rather than read. Its whole job is to publish a number that describes the rows
+   under it, and the defect it replaces — 合计见「全部异常」, which pointed at the union of all four
+   rules for a selection of two — is a sentence that is perfectly well-formed and wrong. Source
+   shape cannot tell a correct sentence from a plausible one; running it can. */
+page.document = { body: { setAttribute() {} }, querySelectorAll() { return []; } };
+page.dom.anomalyNote = { hidden: true, textContent: '' };
+for (const name of ['formatInt', 'syncAnomalyMode']) {
+  const src = fnSource('function ' + name + '(');
+  if (!src) throw new Error('could not extract ' + name);
+  vm.runInContext(src, page);
+}
+const noteText = (rules, multi) => {
+  page.state.anomalyRules = rules;
+  page.state.multiAnomaly = multi;
+  page.dom.anomalyNote.textContent = '';
+  page.syncAnomalyMode(page.anomalyCounts());
+  return page.dom.anomalyNote.textContent;
+};
+const hasNumber = (text, n) => text.includes(page.formatInt(n) + ' 条');
+const countOf = (text) => {
+  const m = text.match(/合计 ([\d,]+) 条/);
+  return m ? Number(m[1].replace(/,/g, '')) : null;
+};
+const pairs = [];
+for (const a of pure.ANOMALY_RULE_IDS) {
+  for (const b of pure.ANOMALY_RULE_IDS) if (b > a) pairs.push([a, b]);
+}
+
+// The defect, stated as the shape that would reintroduce it. A partial selection is not 全部异常,
+// so a total that is not the partial selection's own is the failure, however it is worded.
+const notePairs = pairs.map(([a, b]) => {
+  const text = noteText([a, b], true);
+  page.state.anomalyRules = [a, b];
+  const expected = page.anomalyCounts().selected;
+  return { a, b, text, expected, printed: countOf(text) };
+});
+check('the note publishes the total for the rules that are ticked',
+  notePairs.every((p) => p.printed === p.expected), true);
+check('and it is a number, not a pointer somewhere else',
+  notePairs.every((p) => hasNumber(p.text, p.expected)), true);
+for (const p of notePairs) {
+  check('the note publishes the total for the rules that are ticked — ' + p.a + ' + ' + p.b,
+    p.printed, p.expected);
+  assert('and it is a number, not a pointer somewhere else — ' + p.a + ' + ' + p.b,
+    hasNumber(p.text, p.expected));
+}
+page.state.anomalyRules = [pure.ANOMALY_RULE_IDS[0], pure.ANOMALY_RULE_IDS[1]];
+check('the whole set says the same thing',
+  countOf(noteText(pure.ANOMALY_RULE_IDS.slice(), true)), all.any);
+
+// 叠加 is 多选's word. In 单选 the only way more than one rule is ever on is 全部异常 — which the
+// reader pressed one button to get, rather than stacked four times.
+const textMulti = noteText(['toolError', 'compaction'], true);
+const textSingle = noteText(['toolError', 'compaction'], false);
+assert('多选 calls a stack a stack', textMulti.includes('已叠加'));
+assert('单选 does not claim a stack the reader never built', !textSingle.includes('已叠加'));
+assert('and 单选 says what is actually happening instead', textSingle.includes('同时生效'));
+
+page.state.anomalyRules = [];
+page.state.multiAnomaly = false;
+
+/* 单选 is what the page opens in, so it is what the toggle is read in first. Two assertions here
+   used to say the opposite — that ticking a second rule *adds* to the first, and that unticking
+   takes off only the one clicked — because the toggle had no mode and stacked unconditionally.
+   Those were true of the old code and are false of the new one by request, so they are rewritten
+   onto 单选 rather than deleted, and the union they were written for is re-asserted below with
+   多选 actually turned on. Nothing here is checked from the source text: a toggle's shape is the
+   same whether it adds, removes, replaces or does nothing, so it has to be run. */
+page.state.anomalyRules = [];
+page.state.multiAnomaly = false;
+page.state.anomalyLast = null;
+page.onAnomalyToggle('toolError');
+check('单选: ticking one rule', page.state.anomalyRules, ['toolError']);
+page.onAnomalyToggle('compaction');
+check('单选: ticking a second replaces the first instead of stacking',
+  page.state.anomalyRules, ['compaction']);
+page.onAnomalyToggle('compaction');
+check('单选: pressing the rule already on turns it off again',
+  page.state.anomalyRules, []);
+check('and that did not turn 多选 on as a side effect', page.state.multiAnomaly, false);
+
+page.onAnomalyToggle(null);
+check('全部异常 ticks the whole set', page.state.anomalyRules, pure.ANOMALY_RULE_IDS);
+vm.runInContext('this.__aliased = state.anomalyRules === ANOMALY_RULE_IDS;', page);
+check('全部异常 ticks a copy, not the table itself', page.__aliased, false);
+page.onAnomalyToggle(null);
+check('and 全部异常 again unticks it', page.state.anomalyRules, []);
+
+page.state.anomalyRules = ['compaction'];
+page.onAnomalyToggle(null);
+check('全部异常 from a partial selection ticks everything, not just the rest',
+  page.state.anomalyRules, pure.ANOMALY_RULE_IDS);
+
+/* 多选 on: the union the two rewritten assertions above used to describe, now reachable. */
+page.state.anomalyRules = [];
+page.state.multiAnomaly = true;
+page.onAnomalyToggle('compaction');
+check('多选: the first rule is ticked the same way it is in 单选',
+  page.state.anomalyRules, ['compaction']);
+page.onAnomalyToggle('toolError');
+check('多选: ticking a second stacks instead of replacing',
+  page.state.anomalyRules, ['toolError', 'compaction']);
+page.onAnomalyToggle('noReply');
+check('多选: three rules stack, and in table order rather than click order',
+  page.state.anomalyRules, ['toolError', 'compaction', 'noReply']);
+page.onAnomalyToggle('toolError');
+check('多选: unticking removes only that one', page.state.anomalyRules,
+  ['compaction', 'noReply']);
+page.onAnomalyToggle('compaction');
+check('and the stack can be taken all the way down to nothing',
+  page.state.anomalyRules, ['noReply']);
+
+/* Turning 多选 off. The buttons stop being able to hold more than one rule, so a stack of three
+   has to lose two of them here rather than at the next click — otherwise the controls are showing
+   a selection they can no longer express, which is the same class of mismatch as a button whose
+   number does not match its list. Which two lose is asserted, not left open. */
+const multiSrc = fnSource('function onAnomalyMultiChange(');
+if (!multiSrc) throw new Error('could not extract onAnomalyMultiChange');
+vm.runInContext(multiSrc, page);
+page.state.anomalyRules = ['toolError', 'compaction'];
+page.state.anomalyLast = 'compaction';
+page.state.multiAnomaly = true;
+page.onAnomalyMultiChange(false);
+check('turning 多选 off keeps the rule ticked last, not the first in table order',
+  page.state.anomalyRules, ['compaction']);
+check('and the mode itself is recorded as off', page.state.multiAnomaly, false);
+
+page.state.anomalyRules = ['toolError', 'silent'];
+page.state.anomalyLast = 'noReply';
+page.state.multiAnomaly = true;
+page.onAnomalyMultiChange(false);
+check('when the last-ticked rule has since been unticked, a rule still remains',
+  page.state.anomalyRules, ['toolError']);
+
+page.state.anomalyRules = ['silent'];
+page.state.anomalyLast = 'silent';
+page.state.multiAnomaly = true;
+page.onAnomalyMultiChange(false);
+check('turning 多选 off with only one rule selected keeps it', page.state.anomalyRules, ['silent']);
+// The other direction is not a no-op by construction: 全部异常 can leave four rules ticked while
+// the mode is 单选, and turning 多选 on then must not quietly thin them down.
+page.state.anomalyRules = pure.ANOMALY_RULE_IDS.slice();
+page.state.anomalyLast = null;
+page.state.multiAnomaly = false;
+page.onAnomalyMultiChange(true);
+check('turning 多选 on changes the mode and nothing else',
+  page.state.anomalyRules, pure.ANOMALY_RULE_IDS);
+check('and the mode is recorded as on', page.state.multiAnomaly, true);
+page.state.multiAnomaly = false;
+
+// Ticking a rule puts the row above back to its default. In anomaly mode that row filters
+// nothing, so leaving it holding 「用户」 would be the page showing a condition that is not in
+// force — the same class of defect as a button whose number does not match its list, one
+// control over. Set up a non-default row above, tick, and read the row above again.
+page.state.kinds = pure.KIND_ORDER.filter((k) => k !== 'user');
+page.state.query = 'verify-time-range';
+page.state.overviewSelection = { from: 1, to: 2 };
+rangeCleared = 0;
+page.state.anomalyRules = [];
+page.onAnomalyToggle('toolError');
+check('ticking a rule puts every type back', page.state.kinds, pure.KIND_ORDER);
+check('and drops the search', page.state.query, '');
+assert('and drops the overview brush', page.state.overviewSelection === null);
+check('and clears the time range', rangeCleared, 1);
+
+// 重置 is the way out, and it is run here for the same reason the toggle is: the shape of a
+// handler is the same whether it clears, toggles, or does nothing at all.
+const resetSource = fnSource('function onAnomalyReset(');
+if (!resetSource) throw new Error('could not extract onAnomalyReset');
+vm.runInContext(resetSource, page);
+page.state.anomalyRules = ['toolError', 'silent'];
+page.state.anomalyLast = 'silent';
+page.state.multiAnomaly = true;
+page.dom.anomalyMulti.checked = true;
+page.onAnomalyReset();
+check('重置 returns the row to its default', page.state.anomalyRules, []);
+check('and the row above is the default, so the table follows it',
+  page.state.kinds, pure.KIND_ORDER);
+// 重置 puts the row back to the state it opens in, and the row opens in 单选. Leaving the mode
+// switch on would mean the one button that is supposed to mean "default" lands on a non-default
+// mode — and the reader has no other way back to it, because that switch is not a filter.
+check('and 多选 goes off with it', page.state.multiAnomaly, false);
+check('and the checkbox stops reading as on', page.dom.anomalyMulti.checked, false);
+const beforeSecondPress = renders;
+page.onAnomalyReset();
+check('and pressing it again is not a toggle into a filtered view', page.state.anomalyRules, []);
+assert('the second press does not even re-render', renders === beforeSecondPress);
+page.state.anomalyRules = [];
+
+/* ---------- 6) what the reader is shown ---------- */
+
+assert('the group is named by the label beside it',
+  /id="anomaly-controls" role="group" aria-labelledby="anomaly-label"/.test(html));
+assert('and it is named, not just glyphed',
+  /id="anomaly-label">异常</.test(html));
+// The buttons are built from ANOMALY_RULES. Written into the markup they would be a second
+// list of rule names, and the same class of drift the kind chips already had once: a rename
+// leaving a button showing one word and announcing another.
+assert('no rule is hardcoded in the markup', !/>工具失败</.test(html) && !/>上下文压缩</.test(html));
+assert('the container is empty in the markup',
+  /<div class="anomaly-quick" id="anomaly-controls" role="group" aria-labelledby="anomaly-label"><\/div>/.test(html));
+
+/* 多选 is a mode switch, not a fifth rule, and the difference is load-bearing: as a rule it would
+   be inert the moment another rule is ticked, taking away the only way back from a union. */
+const multiBox = /<input type="checkbox" id="anomaly-multi" \/>/.test(html);
+assert('多选 is a real checkbox', multiBox);
+assert('and it is labelled, so clicking the word is clicking the control',
+  /<label class="anomaly-multi" for="anomaly-multi">/.test(html));
+// Position is asserted rather than left to the surrounding markup: the checkbox has to sit before
+// the rule buttons to read as "these buttons are now single", and after the 异常 heading to read
+// as part of that row rather than as a control of its own.
+const multiAt = html.indexOf('id="anomaly-multi"');
+const labelAt = html.indexOf('id="anomaly-label"');
+const groupAt = html.indexOf('id="anomaly-controls"');
+assert('多选 sits inside the 异常 row', multiAt > labelAt && labelAt > 0);
+assert('and before the rule buttons it changes the meaning of', multiAt < groupAt);
+assert('it is not one of the rule buttons', multiAt > 0 && groupAt > 0
+  && !html.slice(multiAt, groupAt).includes('anomaly-btn'));
+// The one that matters most: `data-filter-scope` is what `syncAnomalyMode` makes inert while an
+// anomaly rule is on. A checkbox inside it would be dead exactly when it is needed, and nothing
+// else in this file would notice.
+assert('and it is never marked as a filter control, so it cannot be made inert',
+  !html.slice(html.lastIndexOf('<div class="anomaly-bar', multiAt), groupAt)
+    .includes('data-filter-scope'));
+assert('the 异常 row itself is not inert-able either',
+  !/<div class="anomaly-bar"[^>]*data-filter-scope/.test(html));
+// Native checkbox state is the accessible source of truth for the mode. The stylesheet also
+// recolours the label, which is a nicety; if the input were replaced by something drawn in CSS,
+// that recolouring would be the only signal left and it would fail silently in both themes.
+assert('and the mode is carried by the input itself, not by a drawn-in-CSS stand-in',
+  multiBox && /\.anomaly-multi input\s*\{/.test(html));
+
+/* Position. It is a second filter axis, so it belongs beside the first one. It used to be the
+   last field of the search form, which put it above the KPI cards and the type axis — four cards
+   away from the control it reads as part of. A layout defect of that kind is invisible to every
+   functional assertion in this file, so it is asserted on its own terms. */
+const formEnd = html.indexOf('</form>');
+const kindAt = html.indexOf('id="kind-controls"');
+const anomalyAt = html.indexOf('id="anomaly-bar"');
+const kpiAt = html.indexOf('id="kpi-grid"');
+assert('the type axis is still there to sit beside', kindAt > 0);
+assert('the 异常 axis comes after it', anomalyAt > kindAt);
+assert('and the KPI cards are no longer between the two axes',
+  !(kindAt < kpiAt && kpiAt < anomalyAt));
+assert('it is no longer a field of the search form', formEnd > 0 && anomalyAt > formEnd);
+
+const buildSrc = fnSource('function buildAnomalyButtons(');
+assert('the buttons are built from the table', /ANOMALY_RULES\.length/.test(buildSrc));
+assert('one button per rule', /ANOMALY_RULES\[i\]/.test(buildSrc) && /rule\.id/.test(buildSrc));
+assert('plus one for the whole set', /'anomaly-all'/.test(buildSrc));
+// The page has to be able to get out of the mode it can get into. A way back that only exists
+// in the markup, or that a rename of the button would orphan, is not a way back.
+assert('and one to put the row back to its default',
+  /'anomaly-none'/.test(buildSrc) && /data-anomaly-none/.test(buildSrc));
+assert('the way back is built first, so the row reads default-then-kinds',
+  buildSrc.indexOf("'anomaly-none'") < buildSrc.indexOf('ANOMALY_RULES.length'));
+// 重置 carries no number. 「怎么多会留下多少」 is a question about a rule; a control that keeps
+// whatever the row above says has no count of its own, and printing one invites adding it up
+// against the numbers beside it.
+const noneBlock = buildSrc.slice(buildSrc.indexOf("var none = el("), buildSrc.indexOf('for (var i = 0;'));
+assert('重置 advertises no count of its own',
+  /ANOMALY_NONE_LABEL/.test(noneBlock) && !/anomaly-count/.test(noneBlock));
+assert('every rule button does carry one', /anomaly-count/.test(buildSrc));
+
+const syncSrc = fnSource('function syncAnomalyButtons(counts)');
+assert('a button states how many rows it would keep', /anomaly-count/.test(syncSrc));
+const labelSrc = fnSource('function ruleLabelFor(');
+assert('and the number it publishes carries the unit it was counted in',
+  /formatInt\(n\) \+ ' ' \+ unit/.test(labelSrc));
+assert('one builder for every rule button, so the wording cannot drift between them',
+  /ruleLabelFor\(noun, n, unit, on\)/.test(syncSrc));
+assert('the unit comes from the counting pass, not a literal beside each button',
+  /counts\.unit\[id\]/.test(syncSrc));
+assert('pressed state comes from state, not a captured flag',
+  /state\.anomalyRules\.indexOf\(id\) >= 0/.test(syncSrc));
+// Inverted, and the reason matters. It required 重置 to be pressed whenever no rule was ticked,
+// which is true of the filter and false of the row: the axis opens in 单选, and 多选 changes what
+// every other button here does when pressed, so a row with 多选 on is not the state 重置 names —
+// and 重置 is the only control that turns 多选 off. A reader told the row is already at its
+// default has no reason to press the one button that would put it back.
+assert('重置 is pressed only when both the rules and the mode are at their default',
+  /if \(isNone\) \{[\s\S]*?state\.anomalyRules\.length === 0 && !state\.multiAnomaly/.test(syncSrc));
+assert('and a rule button with nothing to find is dimmed, never hidden',
+  /n !== null && n === 0/.test(syncSrc));
+// The counts arrive from `render()`. Two walks of a live session can disagree — the session grows
+// between them — and a button count taken from a different read than the note beside it is the
+// same mismatch this row exists to end, just one step further along.
+assert('the count comes from the pass render() took, not a second walk',
+  /function syncAnomalyButtons\(counts\)/.test(syncSrc) && !/anomalyCounts\(\)/.test(syncSrc));
+
+const countsSrc = fnSource('function anomalyCounts()');
+// Inverted from what this asserted before. It required the counts to be drawn through
+// passesBaseFilter, which made the number describe a view that anomaly mode does not produce —
+// the whole "283 on the button, 1,494 in the list" defect. What has to hold instead is that the
+// counts ignore the axis that is switched off while they are on screen.
+assert('the counts do NOT walk the other axis, because anomaly mode does not',
+  !/passesBaseFilter/.test(countsSrc));
+assert('nor read the overview selection', !/state\.overviewSelection/.test(countsSrc));
+assert('a turn rule is counted once per turn, not once per record',
+  /rule\.turn/.test(countsSrc) && /counted\[key\]/.test(countsSrc));
+assert('and its unit is taken from the rule table', /ANOMALY_RULES\[i\]\.turn \? '轮' : '条'/.test(countsSrc));
+assert('the total it publishes is the whole ledger', /total: state\.flat\.length/.test(countsSrc));
+
+// The state has to remember the ticks, or a poll re-renders the buttons from nothing.
+const stateSrc = fnSource('var state = {');
+assert('the filter opens off', /anomalyRules: \[\],/.test(stateSrc));
+const toggleSrc = fnSource('function onAnomalyToggle(');
+assert('ticking adds, unticking removes', /next\.length === state\.anomalyRules\.length/.test(toggleSrc));
+assert('全部异常 toggles the whole set', /ANOMALY_RULE_IDS\.slice\(\)/.test(toggleSrc));
+assert('and it resets the window like every other filter', /resetWindowMode\(\);/.test(toggleSrc));
+assert('and re-renders', /render\(\);/.test(toggleSrc));
+const clearSrc = fnSource('function clearFilters()');
+assert('清除筛选 drops it too', /state\.anomalyRules = \[\];/.test(clearSrc));
+assert('and re-syncs the buttons with it', /syncAnomalyButtons\(anomalyCounts\(\)\);/.test(clearSrc));
+
+assert('the filter counts as a filter',
+  /state\.anomalyRules\.length !== 0/.test(fnSource('function isFiltering()')));
+
+const visibleSrc = fnSource('function visibleEntries()');
+assert('the ledger applies it', /passesAnomaly\(entry\.record, anomalyContext\(entry\), state\.anomalyRules\)/.test(visibleSrc));
+// The two axes are alternatives, not a stack. Getting this wrong is not a matter of taste: a
+// list built from both predicates at once is the 1,494 rows a 283-row button could never
+// deliver, and the reason the two modes could not be told apart from the result alone.
+assert('and treats the two axes as alternatives, not a stack',
+  /if \(anomalyMode\) \{[\s\S]*?\} else if \(!passesBaseFilter/.test(visibleSrc));
+
+const stripSrc = fnSource('function spanPassesFilter(');
+assert('the strip applies it', /passesAnomaly/.test(stripSrc));
+assert('and branches on the mode before the other axis, so strip and list agree',
+  /if \(state\.anomalyRules\.length > 0\) \{\s*return passesAnomaly/.test(stripSrc));
+
+const renderSrc = fnSource('function render()');
+// Still ordered mode-then-buttons: the strip, the note and the ledger must not each answer a
+// different question mid-render. What changed is that both now read one snapshot — a second walk
+// of a session that is still growing could hand the note and the buttons different numbers.
+assert('the mode is settled before anything reads a count',
+  /var anomaly = anomalyCounts\(\);\s*syncAnomalyMode\(anomaly\);\s*syncAnomalyButtons\(anomaly\);/.test(renderSrc));
+assert('every poll re-syncs the buttons', /syncAnomalyButtons\(anomaly\);/.test(renderSrc));
+assert('and the note and the buttons are handed the same walk, not two of them',
+  (renderSrc.match(/anomalyCounts\(\)/g) || []).length === 1);
+
+const modeSrc = fnSource('function syncAnomalyMode(counts)');
+// Setting state.kinds without syncKindButtons() leaves the axis drawing whatever was there
+// before — which is how 异常 would end up showing 「用户」 while the table was showing something
+// else entirely. The count of writers is client-check's business; whether the new one syncs is
+// a property of this axis, and this is the file whose mutation control can exercise it.
+const baseSrc = fnSource('function resetBaseFilters(');
+assert('the reset updates the buttons, or the axis would show a condition that is not in force',
+  !!baseSrc && /state\.kinds = KIND_ORDER\.slice\(\);/.test(baseSrc) && /syncKindButtons\(\);/.test(baseSrc));
+assert('and it clears every part of the row above, not just the types',
+  !!baseSrc && /state\.query = '';/.test(baseSrc) && /state\.overviewSelection = null;/.test(baseSrc)
+  && /clearTimeRange\(\);/.test(baseSrc));
+const toggleFull = fnSource('function onAnomalyToggle(');
+assert('and it runs on every tick into the mode, not only the first',
+  !!toggleFull && /if \(next\.length > 0\) resetBaseFilters\(\);/.test(toggleFull));
+assert('ticking a rule does not reset the row above on the way back out',
+  !!toggleFull && !/if \(next\.length === 0\) resetBaseFilters/.test(toggleFull));
+// Dimming alone would leave a control that takes a click and changes nothing — the same class
+// of defect this change is about, reintroduced one line away.
+assert('the inactive axis is made inert, not merely dimmed', /\.inert = on/.test(modeSrc));
+assert('and the body is marked so the dimming has something to key off',
+  /data-anomaly-mode/.test(modeSrc));
+assert('the note says what stopped applying and how to undo it',
+  /异常筛选已开启/.test(modeSrc) && /ANOMALY_NONE_LABEL/.test(modeSrc));
+// A poll re-renders from state, so a checkbox left to remember its own position is a checkbox
+// that can end up drawn ticked while the buttons are single again — the two disagreeing on screen
+// with nothing to reconcile them.
+assert('every poll re-draws the checkbox from state, not from where the reader left it',
+  /dom\.anomalyMulti\.checked = state\.multiAnomaly/.test(modeSrc));
+assert('and the checkbox is looked up once, with the rest of the anomaly controls',
+  /dom\.anomalyMulti = document\.getElementById\('anomaly-multi'\)/.test(html));
+assert('多选 opens off, because 单选 is the documented default',
+  /multiAnomaly: false/.test(stateSrc));
+
+const wireSrc = fnSource('function wire(');
+// Scoped to the checkbox's own binding rather than the whole of `wire`, which has other change
+// listeners in it — a whole-function test would stay green with this one rewritten to `click`,
+// which is exactly the mistake this assertion exists to catch.
+const multiBindAt = wireSrc.indexOf('dom.anomalyMulti.addEventListener');
+const multiBind = wireSrc.slice(multiBindAt, wireSrc.indexOf('});', multiBindAt) + 3);
+// `change` rather than `click`: a checkbox toggled from the keyboard fires change and nothing
+// else, so binding click leaves the mode unreachable without a mouse.
+assert('the checkbox is bound to the mode handler',
+  multiBindAt > 0 && /addEventListener\('change'/.test(multiBind)
+    && /onAnomalyMultiChange\(this\.checked\)/.test(multiBind));
+
+const muted = html.match(/<[a-z]+[^>]*\sdata-filter-scope[^>]*>/g) || [];
+check('exactly the four controls that stop applying are marked', muted.length, 4);
+assert('the kind axis is one of them', muted.some((tag) => /id="kind-controls"/.test(tag)));
+assert('the search box is one of them', muted.some((tag) => /field-grow/.test(tag)));
+assert('the time range is one of them', muted.some((tag) => /field-range/.test(tag)));
+assert('but neither picker is — they choose the session, not the records in it',
+  muted.every((tag) => !/<select/.test(tag) && !/session-select/.test(tag) && !/generation-select/.test(tag)));
+assert('and the dimming is keyed to the mode being on',
+  /body\[data-anomaly-mode='on'\] \[data-filter-scope\]/.test(html));
+
+assert('the head tags a broken turn', /turnAnomalyRules\(turn\)/.test(fnSource('function buildTurnHead(')));
+assert('with the rule name, not a bare colour', /anomalyRuleLabel\(turnFlags\[flag\]\)/.test(fnSource('function buildTurnHead(')));
+
+// An empty reply has to say so on its own row, not only through the filter. It keeps the 答复
+// pill — it is a reply — but with no body the marker is the only thing telling the reader this
+// is not an answer, and the duration cell is where 失败 already took one.
+const rowSrc = fnSource('function buildRow(');
+assert('an empty reply is marked on its row',
+  /record\.kind === 'reply' && isNil\(record\.text\)/.test(rowSrc));
+assert('and it reuses the duration cell instead of adding a column',
+  /else if \(silent\) \{[\s\S]*?anomalyRuleLabel\('silent'\)[\s\S]*?\} else \{/.test(rowSrc));
+assert('the row names the rule from the table, not from a label written here',
+  /pill\(anomalyRuleLabel\('silent'\)/.test(rowSrc));
+// The kind chips had this bug once: the visible word and the announced word lived in different
+// places and both were individually correct, so a rename left the button showing one word and
+// announcing another. So no rule name may be painted from a literal on the row.
+//
+// Scoped to the row on purpose. Counting occurrences across the whole file would be wrong: the
+// compaction band legitimately prints 上下文压缩 — that names a record *kind*, while this
+// filters for an anomaly — and three of the other hits are in comments.
+for (const rule of pure.ANOMALY_RULES) {
+  assert('the row never paints a rule name literally — ' + rule.id,
+    !new RegExp("(pill\\(|\\.title\\s*=)[^;]*" + rule.label).test(rowSrc));
+}
+
+/* ---------- report ---------- */
+console.log('FAILED_NAMES\t' + JSON.stringify(failedNames));
+if (failures.length) {
+  console.log('FAILURES:');
+  for (const f of failures) console.log(' - ' + f);
+  console.error('FAIL ' + pass + ' passed, ' + failures.length + ' failed');
+  process.exit(1);
+}
+console.log('OK  (' + pass + ' assertions; ' + expectAny + ' anomalous records of '
+  + page.state.flat.length + ')');
diff --git a/plugins/avatasia/mmc-trajectory/tests/verify-block-order.mjs b/plugins/avatasia/mmc-trajectory/tests/verify-block-order.mjs
new file mode 100644
index 0000000..601b806
--- /dev/null
+++ b/plugins/avatasia/mmc-trajectory/tests/verify-block-order.mjs
@@ -0,0 +1,113 @@
+/**
+ * Verifies the explicit assistant-block ordering rule the page now enforces:
+ *   thinking -> text -> toolCall(s)
+ * and that Token usage still lands on the assistant answer, never on the reasoning block.
+ *
+ * It checks the rule against the served payload rather than the file, because the rule is
+ * the page's own — it must hold even if the session writer ever changes its block order.
+ * The rule is per assistant message: see the comment at the run-splitting loop below.
+ */
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import * as server from '../miniapp/node/server.mjs';
+
+const { resolveSessionsRoot, collectSessionEntries, readHead } = server;
+
+const HERE = fileURLToPath(new URL('.', import.meta.url));
+const FIXTURE_HOME = join(HERE, 'fixtures', 'minimax-home');
+const PAYLOAD = join(HERE, 'fixtures', 'trajectory.json');
+
+const location = resolveSessionsRoot({ MAVIS_HOME: FIXTURE_HOME });
+const entries = await collectSessionEntries(location.sessionsRoot);
+if (!entries.length) { console.log('no fixture sessions -- run make-fixtures.mjs --record'); process.exit(1); }
+const entry = entries[0];
+
+const rawText = (await readHead(join(entry.dir, 'messages.jsonl'), entry.sizeBytes)).text;
+const raw = rawText.split('\n').filter(Boolean).map((l) => JSON.parse(l));
+const p = JSON.parse(readFileSync(PAYLOAD, 'utf8'));
+const flat = [];
+for (const t of p.turns) for (const r of t.records ?? []) flat.push(r);
+
+const RANK = { thinking: 0, qa: 1, narration: 1, toolCall: 2 };
+let violations = 0;
+let checked = 0;
+
+// Walk consecutive assistant-family runs; within each run the rank must be non-decreasing.
+let run = [];
+function flush() {
+  if (run.length < 2) { run = []; return; }
+  checked += 1;
+  for (let i = 1; i < run.length; i += 1) {
+    if (RANK[run[i].kind] < RANK[run[i - 1].kind]) {
+      violations += 1;
+      if (violations <= 5) console.log(`  VIOLATION near #${run[i].index}: ${run[i - 1].kind}(#${run[i - 1].index}) -> ${run[i].kind}(#${run[i].index})`);
+    }
+  }
+  run = [];
+}
+for (const r of flat) {
+  const assistant = r.kind === 'reply' || r.kind === 'narration' || r.kind === 'thinking' || r.kind === 'toolCall';
+  // The rule orders the blocks *within one assistant message*. Two assistant messages in the
+  // same turn are two separate runs: the page reorders blocks inside a message, never across
+  // messages, so ranking across that boundary flagged a toolCall -> thinking pair that never
+  // occurred inside any message.
+  if (assistant && run.length && run[0].id !== r.id) flush();
+  if (assistant) run.push(r);
+  else flush();
+}
+flush();
+
+console.log(`\nordering rule  : thinking -> text -> toolCall`);
+console.log(`runs checked   : ${checked}`);
+console.log(`violations     : ${violations}`);
+console.log(violations === 0 ? '  OK — the rule holds everywhere in the session' : '  FAIL');
+
+// The rule must hold regardless of what order the writer used, so confirm it also holds
+// for a session whose raw blocks are deliberately out of rule order.
+let rawDisagrees = 0;
+for (const r of raw) {
+  const c = r.message?.content;
+  if (r.message?.role !== 'assistant' || !Array.isArray(c)) continue;
+  const kinds = c.map((b) => b?.type).filter((k) => k === 'thinking' || k === 'text' || k === 'toolCall');
+  for (let i = 1; i < kinds.length; i += 1) {
+    if (RANK[kinds[i]] < RANK[kinds[i - 1]]) { rawDisagrees += 1; break; }
+  }
+}
+console.log(`\nraw file blocks that violate the rule : ${rawDisagrees}`);
+console.log(rawDisagrees === 0
+  ? '  (the writer happens to agree with the rule today; the page does not depend on it)'
+  : '  (the writer DISAGREES in places — the page reorders them to the rule)');
+
+// Token usage placement
+let onAssistant = 0, onThinking = 0, onOther = 0;
+for (const r of flat) {
+  if (!r.tokens) continue;
+  if (r.kind === 'reply') onAssistant += 1;
+  else if (r.kind === 'thinking') onThinking += 1;
+  else onOther += 1;
+}
+let thinkNoText = 0;
+// Counted from the payload, grouped by the message each row came out of — not from the raw
+// file. The payload spans every generation of a compacted session while `messages.jsonl`
+// holds only the active one, so comparing the two would measure two different sets of
+// messages and report a bug that is not there.
+const byMessage = new Map();
+for (const r of flat) {
+  if (r.kind !== 'reply' && r.kind !== 'narration' && r.kind !== 'thinking') continue;
+  let m = byMessage.get(r.id);
+  if (!m) { m = { thinking: false, text: false }; byMessage.set(r.id, m); }
+  if (r.kind === 'thinking') m.thinking = true;
+  else m.text = true;
+}
+for (const m of byMessage.values()) if (m.thinking && !m.text) thinkNoText += 1;
+console.log(`\nusage placement: assistant=${onAssistant}  thinking=${onThinking}  other=${onOther}`);
+console.log(`  messages with reasoning but no answer: ${thinkNoText}`);
+console.log(`  ${onThinking <= thinkNoText
+  ? 'OK — a reasoning block only carries usage when its message produced no answer'
+  : 'BUG — reasoning took usage from a message that had an answer'}`);
+
+const sum = (p.turns ?? []).reduce((n, t) => n + (t.tokens?.totalTokens ?? 0), 0);
+console.log(`\nturn totals still sum: header=${p.stats.tokens.totalTokens}  sum=${sum}  match=${sum === p.stats.tokens.totalTokens}`);
+
+process.exit(violations === 0 && onThinking <= thinkNoText && sum === p.stats.tokens.totalTokens ? 0 : 1);
diff --git a/plugins/avatasia/mmc-trajectory/tests/verify-call-fold-coverage.mjs b/plugins/avatasia/mmc-trajectory/tests/verify-call-fold-coverage.mjs
new file mode 100644
index 0000000..3e76a97
--- /dev/null
+++ b/plugins/avatasia/mmc-trajectory/tests/verify-call-fold-coverage.mjs
@@ -0,0 +1,103 @@
+// Coverage probe: with "fold every call" on, how much tool work is still on screen?
+//
+// The user reported that most tool calls and tool results stayed visible after folding.
+// Rather than trust a screenshot, this drives the delivered buildTurnPlan over the real
+// served payload with every collapsible owner folded, and counts what survives.
+//
+// It loads the delivered index.html itself and runs its real inline script in a sandbox,
+// so there is no copied logic that could drift from what ships.
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import vm from 'node:vm';
+
+const HERE = fileURLToPath(new URL('.', import.meta.url));
+const HTML = join(HERE, '..', 'miniapp', 'client', 'index.html');
+const PAYLOAD = join(HERE, 'fixtures', 'trajectory.json');
+
+const html = readFileSync(HTML, 'utf8');
+const script = [...html.matchAll(/<script>([\s\S]*?)<\/script>/g)].map((m) => m[1])[0];
+if (!script) throw new Error('no inline script found');
+
+const bootIndex = script.lastIndexOf("if (document.readyState === 'loading')");
+const body = bootIndex === -1 ? script : script.slice(0, bootIndex);
+const noop = () => {};
+const sandbox = {
+  console,
+  window: {
+    localStorage: { getItem: () => null, setItem: noop },
+    matchMedia: () => ({ addEventListener: noop, addListener: noop }),
+    setTimeout: () => 0,
+    clearTimeout: noop,
+    setInterval: () => 0,
+    clearInterval: noop
+  },
+  document: { documentElement: { dataset: {} }, body: { classList: { add: noop, remove: noop } } }
+};
+vm.createContext(sandbox);
+vm.runInContext(body, sandbox);
+
+const payload = JSON.parse(readFileSync(PAYLOAD, 'utf8'));
+const entries = [];
+for (const turn of payload.turns ?? []) {
+  for (const record of turn.records ?? []) entries.push({ turn, record });
+}
+const groups = sandbox.visibleTurns(entries);
+
+// The client renders through visibleEntries(), so that is the only definition of "on
+// screen" this probe may use. Anything else would test the probe's own idea of the filter.
+sandbox.state.flat = entries;
+sandbox.state.kinds = sandbox.KIND_ORDER.slice();
+sandbox.state.query = '';
+sandbox.state.overviewSelection = null;
+
+function countByKind(groups) {
+  const out = {};
+  for (const group of groups) {
+    for (const entry of group.entries) out[entry.record.kind] = (out[entry.record.kind] ?? 0) + 1;
+  }
+  return out;
+}
+
+// Unticking the two tool kinds is the whole filter, so this is the same state the reader
+// leaves the page in after clearing 工具调用 and 工具结果 in the chip row.
+const NO_TOOL_KINDS = sandbox.KIND_ORDER.filter((k) => k !== 'toolCall' && k !== 'toolResult');
+const withToolKinds = sandbox.KIND_ORDER.filter((k) => k === 'toolCall' || k === 'toolResult');
+sandbox.state.kinds = NO_TOOL_KINDS;
+const after = countByKind(sandbox.visibleTurns(sandbox.visibleEntries()));
+sandbox.state.kinds = sandbox.KIND_ORDER.slice();
+
+const before = countByKind(groups);
+const kinds = [...new Set([...Object.keys(before), ...Object.keys(after)])].sort();
+console.log(`session      : ${payload.session.id}`);
+console.log(`records      : ${entries.length}   turns: ${groups.length}\n`);
+console.log('kind          on-screen   hidden by unticking the tool kinds');
+let leaks = 0;
+for (const kind of kinds) {
+  const b = before[kind] ?? 0;
+  const a = after[kind] ?? 0;
+  const isCall = kind === 'toolCall' || kind === 'toolResult';
+  if (isCall && a !== 0) leaks += a;
+  console.log(`  ${kind.padEnd(12)} ${String(a).padStart(9)} ${String(b - a).padStart(11)}${isCall && a ? '  <-- LEAK' : ''}`);
+}
+
+/* The list renders a window, not the whole session. Unticking the tool kinds has to hide
+ * every tool row in that window with no placeholder row standing in for them, so the count
+ * of tool rows on screen has to be exactly zero — not "few", not "the ones that happened to
+ * have an assistant row above them". */
+const WINDOW = 200;
+sandbox.state.kinds = NO_TOOL_KINDS;
+const cut = sandbox.visibleEntries().slice(-WINDOW);
+const cutKinds = countByKind(sandbox.visibleTurns(cut));
+sandbox.state.kinds = sandbox.KIND_ORDER.slice();
+const windowLeak = (cutKinds.toolCall ?? 0) + (cutKinds.toolResult ?? 0);
+const lastRow = cut[cut.length - 1];
+console.log(`\n--- window of the newest ${WINDOW} ---`);
+console.log(`  first record shown : #${cut[0].record.index} ${cut[0].record.kind}`);
+console.log(`  last record shown  : #${lastRow.record.index} ${lastRow.record.kind}`);
+console.log(`  tool rows on screen: ${windowLeak}`);
+
+console.log(leaks === 0 && windowLeak === 0
+  ? '\nOK — unticking 工具调用 and 工具结果 leaves no tool call and no tool result anywhere it can be seen'
+  : `\nLEAK — ${leaks + windowLeak} tool rows still visible with the tool kinds unticked`);
+process.exit(leaks === 0 && windowLeak === 0 ? 0 : 1);
diff --git a/plugins/avatasia/mmc-trajectory/tests/verify-compaction-turn.mjs b/plugins/avatasia/mmc-trajectory/tests/verify-compaction-turn.mjs
new file mode 100644
index 0000000..5717c7a
--- /dev/null
+++ b/plugins/avatasia/mmc-trajectory/tests/verify-compaction-turn.mjs
@@ -0,0 +1,164 @@
+// The runtime writes a turn's compaction checkpoint under "<turnId>:compaction" while every row
+// after it carries the bare id. Keying on the whole string gave the checkpoint a turn of its own,
+// emitted after the whole turn it interrupts. These checks pin the corrected grouping.
+//
+// Read-only: imports the pure builder, never starts the runtime.
+import { buildTrajectoryPayload } from '../miniapp/node/server.mjs';
+
+let pass = 0;
+const failures = [];
+function check(name, actual, expected) {
+  const ok = JSON.stringify(actual) === JSON.stringify(expected);
+  if (ok) pass += 1;
+  else failures.push(`${name}: got ${JSON.stringify(actual)}, want ${JSON.stringify(expected)}`);
+}
+function assert(name, cond) {
+  if (cond) pass += 1;
+  else failures.push(name);
+}
+
+const T = 1_700_000_000_000;
+const user = (turn, text, at) => ({
+  message_id: `u-${turn}`,
+  turn_id: turn,
+  message: { role: 'user', content: [{ type: 'text', text }], timestamp: at },
+});
+const assistant = (turn, text, at) => ({
+  message_id: `a-${turn}`,
+  turn_id: turn,
+  message: { role: 'assistant', content: [{ type: 'text', text }], timestamp: at, stopReason: 'stop' },
+});
+const checkpoint = (turn, generation, at) => ({
+  message_id: `c-${turn}`,
+  turn_id: `${turn}:compaction`,
+  history_artifact: { generation, parentSnapshot: { generation: generation - 1 } },
+  message: { role: 'compactionSummary', content: [{ type: 'text', text: 'summary' }], timestamp: at },
+});
+
+/* ---- a turn interrupted by a compaction stays one turn, in order ---- */
+const TURN = 'turn-1';
+const payload = buildTrajectoryPayload({
+  session: { id: 'mvs_1', createdAtMs: T },
+  rows: [
+    user(TURN, 'do the thing', T),
+    assistant(TURN, 'working on it', T + 1000),
+    checkpoint(TURN, 1, T + 2000),
+    assistant(TURN, 'done', T + 3000),
+  ],
+});
+
+check('the checkpoint does not open a turn of its own', payload.turns.length, 1);
+check(
+  'every record is in that one turn',
+  payload.turns[0].records.map((r) => r.kind),
+  ['user', 'reply', 'compaction', 'reply'],
+);
+check('indexes run 1..n with no gap', payload.turns[0].records.map((r) => r.index), [1, 2, 3, 4]);
+check('the turn keeps the bare id it interrupted', payload.turns[0].id, TURN);
+assert(
+  'the turn is classified by what it did, not by the checkpoint inside it',
+  payload.turns[0].turnClass !== 'compaction',
+);
+check('the checkpoint is still counted as a record', payload.stats.compactions, 1);
+check('no turn is left classified as a checkpoint', payload.stats.compactionTurns, 0);
+// A record has to name a turn that exists. The file's suffixed id names none, so leaving it on
+// the record is how a checkpoint ends up claiming a turn the payload never contains.
+check(
+  'every record names a turn that exists',
+  payload.turns.every((t) => t.records.every((r) => r.turnId === t.id)),
+  true,
+);
+check('the checkpoint record names that turn', payload.turns[0].records[2].turnId, TURN);
+
+/* ---- the suffix is only stripped from an actual checkpoint ---- */
+// Same id shape, but an ordinary assistant row. It must keep its own turn: the rule is gated on
+// the role, not on the string, so a turn genuinely named "...:compaction" is not swallowed.
+const impostor = buildTrajectoryPayload({
+  session: { id: 'mvs_1', createdAtMs: T },
+  rows: [
+    user(TURN, 'hello', T),
+    assistant(TURN, 'hi', T + 10),
+    { message_id: 'x', turn_id: `${TURN}:compaction`, message: { role: 'assistant', content: [{ type: 'text', text: 'not a checkpoint' }], timestamp: T + 20 } },
+  ],
+});
+check('a non-checkpoint keeps its own turn', impostor.turns.length, 2);
+check('and it is not counted as a compaction', impostor.stats.compactions, 0);
+
+/* ---- a bare suffix must not collapse into the turn-less bucket ---- */
+// turn_id exactly ":compaction" strips to "", which is the key every row with no turn_id uses.
+// Guarded by the length check so it stays its own turn instead of merging with all of them.
+// Built inline rather than through `checkpoint()`, which would have made it ":compaction:compaction".
+const bareCheckpoint = {
+  message_id: 'bare',
+  turn_id: ':compaction',
+  history_artifact: { generation: 1, parentSnapshot: { generation: 0 } },
+  message: { role: 'compactionSummary', content: [{ type: 'text', text: 'summary' }], timestamp: T + 5 },
+};
+const bare = buildTrajectoryPayload({
+  session: { id: 'mvs_1', createdAtMs: T },
+  rows: [
+    { message_id: 'n1', message: { role: 'user', content: [{ type: 'text', text: 'no turn id' }], timestamp: T } },
+    bareCheckpoint,
+  ],
+});
+check('a bare ":compaction" id stays separate from turn-less rows', bare.turns.length, 2);
+check('and the turn-less row is still first', bare.turns[0].records[0].kind, 'user');
+
+/* ---- a turn with no prompt and no reply is not a checkpoint just for holding one ---- */
+// It is a stretch of work the file never opened. Calling it a checkpoint would take it out of the
+// prompted count and name it after something it is not.
+// Built without the prompt on purpose: what is under test is the classification of a turn that
+// holds a checkpoint alongside work but was never opened by the reader.
+const workOnly = buildTrajectoryPayload({
+  session: { id: 'mvs_1', createdAtMs: T },
+  rows: [
+    checkpoint('turn-w', 1, T + 10),
+    { message_id: 'c1', turn_id: 'turn-w', message: { role: 'toolCall', content: [{ type: 'toolCall', name: 'bash' }], timestamp: T + 20 } },
+    { message_id: 'c2', turn_id: 'turn-w', message: { role: 'toolResult', content: [{ type: 'text', text: 'ok' }], timestamp: T + 30 } },
+  ],
+});
+assert('a turn holding work and a checkpoint is not classed as a checkpoint', workOnly.turns[0].turnClass !== 'compaction');
+check('it counts as a turn without a prompt', workOnly.stats.turnsWithoutPrompt, 1);
+check('and it is not in the prompted count either', workOnly.stats.turnsWithPrompt, 0);
+
+/* ---- two turns separated by a checkpoint each keep their own ---- */
+const both = buildTrajectoryPayload({
+  session: { id: 'mvs_1', createdAtMs: T },
+  rows: [
+    user('turn-a', 'first', T),
+    checkpoint('turn-a', 1, T + 10),
+    assistant('turn-a', 'a done', T + 20),
+    user('turn-b', 'second', T + 1000),
+    checkpoint('turn-b', 2, T + 1010),
+    assistant('turn-b', 'b done', T + 1020),
+  ],
+});
+check('two turns stay two turns', both.turns.map((t) => t.id), ['turn-a', 'turn-b']);
+check('each turn keeps its own checkpoint', both.turns.map((t) => t.records.length), [3, 3]);
+check('indexes are contiguous across both', both.turns.flatMap((t) => t.records.map((r) => r.index)), [1, 2, 3, 4, 5, 6]);
+check('both checkpoints counted', both.stats.compactions, 2);
+
+/* ---- timestamps going backwards inside a turn stay put ---- */
+// A steer carries the time the reader typed, which is before the tool result it interrupted. The
+// ledger order is causal and must not be re-sorted to hide that.
+const steered = buildTrajectoryPayload({
+  session: { id: 'mvs_1', createdAtMs: T },
+  rows: [
+    user('turn-s', 'go', T),
+    { message_id: 'r1', turn_id: 'turn-s', message: { role: 'toolResult', content: [{ type: 'text', text: 'ok' }], timestamp: T + 5000 } },
+    { message_id: 's1', turn_id: 'turn-s', message: { role: 'user', content: [{ type: 'text', text: 'actually, do this instead' }], timestamp: T + 1000 } },
+  ],
+});
+check(
+  'a steer stays after the tool result it interrupted',
+  steered.turns[0].records.map((r) => r.kind),
+  ['user', 'toolResult', 'steer'],
+);
+check('and its index still follows the file order', steered.turns[0].records.map((r) => r.index), [1, 2, 3]);
+
+if (failures.length > 0) {
+  console.error(`FAIL  ${failures.length} of ${pass + failures.length}`);
+  for (const failure of failures) console.error('  - ' + failure);
+  process.exit(1);
+}
+console.log(`\nALL ${pass} CHECKS PASSED`);
\ No newline at end of file
diff --git a/plugins/avatasia/mmc-trajectory/tests/verify-generations.mjs b/plugins/avatasia/mmc-trajectory/tests/verify-generations.mjs
new file mode 100644
index 0000000..2af031f
--- /dev/null
+++ b/plugins/avatasia/mmc-trajectory/tests/verify-generations.mjs
@@ -0,0 +1,405 @@
+// Server-side checks for the history-generation chain introduced by compaction.
+// Read-only: imports the pure helpers, never starts the runtime.
+import { resolve } from 'node:path';
+import {
+  parseCatalogGenerations,
+  activeCatalogGeneration,
+  resolveArtifactPath,
+  trajectoryCacheKey,
+  buildTrajectoryPayload,
+  parseMessagesJsonl,
+  readGenerationMarker,
+  walkLineage,
+  ROW_GENERATION,
+} from '../miniapp/node/server.mjs';
+
+let pass = 0;
+const failures = [];
+function check(name, actual, expected) {
+  const ok = JSON.stringify(actual) === JSON.stringify(expected);
+  if (ok) pass += 1;
+  else failures.push(`${name}: got ${JSON.stringify(actual)}, want ${JSON.stringify(expected)}`);
+}
+function assert(name, cond) {
+  if (cond) pass += 1;
+  else failures.push(name);
+}
+
+const CATALOG = {
+  schemaVersion: 1,
+  sessionId: 'mvs_1',
+  activeGeneration: 2,
+  activeRevision: 'sha256:aa0ee431211d51509d33f4f5ceebcf94987951d606fca17b4cb648b423a3a907',
+  artifacts: [
+    { revision: 'sha256:1a78ed0edac4cacefdf13606f47fa36c04fafe4ac9e4b85b46b62f763a72a088', generation: 0, kind: 'snapshot', fileName: 'g000000000000--ctx_456bed0e.jsonl', byteLength: 4109759, messageCount: 676 },
+    { revision: 'sha256:73ec52fa210562ec193e9bf72a6700bc58abde6ebec2e032d5b7cd4444544647', generation: 1, kind: 'snapshot', fileName: 'g000000000001--ctx_652d24b2.jsonl', byteLength: 3029414, messageCount: 548 },
+    { revision: 'sha256:aa0ee431211d51509d33f4f5ceebcf94987951d606fca17b4cb648b423a3a907', generation: 2, kind: 'active', fileName: 'messages.jsonl', byteLength: 1302171, messageCount: 186 },
+  ],
+};
+
+/* ---- shape ---- */
+const gens = parseCatalogGenerations(CATALOG);
+check('three generations', gens.length, 3);
+check('ordered by generation', gens.map((g) => g.generation), [0, 1, 2]);
+check('active flag on the active artifact', gens[2].active, true);
+check('snapshots are not active', gens.slice(0, 2).map((g) => g.active), [false, false]);
+check('byteLength kept', gens[0].byteLength, 4109759);
+check('messageCount kept', gens[1].messageCount, 548);
+check('revision kept', gens[2].revision, CATALOG.activeRevision);
+check('active generation', activeCatalogGeneration(CATALOG, gens), 2);
+
+/* ---- degraded catalogs must never invent data ---- */
+check('null catalog', parseCatalogGenerations(null), []);
+check('array catalog', parseCatalogGenerations([]), []);
+check('catalog without artifacts', parseCatalogGenerations({ schemaVersion: 1 }), []);
+check('active generation with no catalog entries', activeCatalogGeneration({}, []), null);
+check('active generation falls back to the active flag', activeCatalogGeneration({}, [{ generation: 5, active: true }]), 5);
+check('active generation falls back to the last one', activeCatalogGeneration({}, [{ generation: 7, active: false }]), 7);
+check('declared generation not in the list is ignored', activeCatalogGeneration({ activeGeneration: 9 }, gens), 2);
+
+/* ---- malformed entries are dropped, not coerced ---- */
+const messy = parseCatalogGenerations({
+  artifacts: [
+    null,
+    'nope',
+    [],
+    { generation: -1, fileName: 'a.jsonl' },
+    { generation: 1.5, fileName: 'a.jsonl' },
+    { generation: '1', fileName: 'a.jsonl' },
+    { generation: 0, fileName: 'messages.txt' },
+    { generation: 0, fileName: '.hidden.jsonl' },
+    { generation: 0, fileName: 'a b.jsonl' },
+    { generation: 0, fileName: 'ok.jsonl', byteLength: -5, messageCount: 'x', revision: 'md5:zzz' },
+    { generation: 0, fileName: 'float.jsonl', byteLength: 1.5, messageCount: 2.5 },
+    { generation: true, fileName: 'bool.jsonl' },
+  ],
+});
+check('every malformed entry dropped', messy.filter((g) => g.fileName !== 'ok.jsonl').length, 0);
+check('the one well-named entry survives', messy.map((g) => g.fileName), ['ok.jsonl']);
+check('bad numbers on a surviving entry become null', [messy[0].byteLength, messy[0].messageCount, messy[0].revision], [null, null, null]);
+const partial = parseCatalogGenerations({ artifacts: [{ generation: 3, fileName: 'g3.jsonl', byteLength: null, messageCount: null, revision: null }] });
+check('missing numbers become null, not zero', [partial[0].byteLength, partial[0].messageCount, partial[0].revision], [null, null, null]);
+check('missing kind defaults to snapshot', partial[0].kind, 'snapshot');
+const dup = parseCatalogGenerations({ artifacts: [{ generation: 4, fileName: 'first.jsonl' }, { generation: 4, fileName: 'second.jsonl' }] });
+check('duplicate generation keeps the first', dup.map((g) => g.fileName), ['first.jsonl']);
+
+/* ---- path traversal: a catalog must not get to choose a file ---- */
+const dir = resolve('D:/sess/2026/10/10/abc-session');
+const snap = gens[0];
+const activeArt = gens[2];
+check('snapshot resolves under snapshots/', resolveArtifactPath(dir, snap), resolve(dir, 'snapshots/g000000000000--ctx_456bed0e.jsonl'));
+check('active resolves to the plain file', resolveArtifactPath(dir, activeArt), resolve(dir, 'messages.jsonl'));
+const escapes = [
+  '../../../../Windows/System32/config/SAM',
+  '..\\..\\evil.jsonl',
+  '/etc/passwd',
+  'C:/Windows/win.ini',
+  'sub/dir.jsonl',
+  'sub\\dir.jsonl',
+  '..',
+  '.',
+  '',
+  'a'.repeat(201) + '.jsonl',
+  null,
+  undefined,
+  {},
+];
+for (const name of escapes) {
+  check(`rejected path: ${JSON.stringify(name)}`, resolveArtifactPath(dir, { generation: 1, fileName: name, active: false }), null);
+}
+check('rejected path for an active artifact too', resolveArtifactPath(dir, { generation: 1, fileName: '../evil.jsonl', active: true }), null);
+
+/* ---- cache keys must not collide across generations ---- */
+const entry = { dir, sizeBytes: 1302171, lastActiveAt: 1791617886354 };
+const identity = { catalogBytes: 1302171 };
+const keys = [0, 1, 2].map((g) => trajectoryCacheKey(entry, identity, null, g));
+assert('three distinct keys', new Set(keys).size === 3);
+const autoKey = trajectoryCacheKey(entry, identity, null, null);
+assert('auto key differs from every explicit generation', !keys.includes(autoKey));
+assert(
+  'unchanged session still reuses a key',
+  trajectoryCacheKey(entry, identity, null, 2) === trajectoryCacheKey(entry, identity, null, 2)
+);
+
+/* ---- payload: session-wide totals and the checkpoint's own story ---- */
+const rows = [
+  {
+    message_id: 'msg-c1',
+    turn_id: 't0',
+    history_artifact: {
+      schemaVersion: 1,
+      generation: 2,
+      producedBy: 'llm_checkpoint',
+      parentSnapshot: {
+        generation: 1,
+        compactionId: 'ctx_652d24b2-73c0-40cc-8276-c58676946733',
+        revision: 'sha256:73ec52fa210562ec193e9bf72a6700bc58abde6ebec2e032d5b7cd4444544647',
+      },
+    },
+    message: { role: 'compactionSummary', summary: '## Goal …', tokensBefore: 367401, timestamp: 1791617886354 },
+  },
+  { message_id: 'msg-a1', turn_id: 't1', message: { role: 'assistant', content: [{ type: 'text', text: 'ok' }], timestamp: 1791617891000 } },
+];
+const payload = buildTrajectoryPayload({
+  session: { id: 'mvs_1', createdAtMs: 1791617886354 },
+  rows,
+  sizeBytes: 1302171,
+  generations: gens,
+  generation: 2,
+});
+check('messages counts this generation only', payload.stats.messages, 2);
+check('messagesAll spans every generation', payload.stats.messagesAll, 676 + 548 + 186);
+check('compactions counted', payload.stats.compactions, 1);
+check('generation echoed on the session', payload.session.generation, 2);
+check('generation list passed through', payload.session.generations.length, 3);
+
+const comp = payload.turns.flatMap((t) => t.records).find((r) => r.title === 'compaction');
+assert('compaction record exists', !!comp);
+check('tokensBefore survives', comp.tokensBefore, 367401);
+check('producedBy survives', comp.producedBy, 'llm_checkpoint');
+check('generation survives', comp.generation, 2);
+check('parentGeneration survives', comp.parentGeneration, 1);
+check('parentCompactionId survives', comp.parentCompactionId, 'ctx_652d24b2-73c0-40cc-8276-c58676946733');
+check('parentRevision survives', comp.parentRevision, CATALOG.artifacts[1].revision);
+
+const plain = buildTrajectoryPayload({ session: { id: 'mvs_2' }, rows: rows.slice(1), generations: [{ generation: 0, messageCount: 9, active: true }], generation: 0 });
+check('single generation falls back to the row count', plain.stats.messagesAll, 1);
+const plainSystem = buildTrajectoryPayload({ session: { id: 'mvs_3' }, rows: [{ message_id: 'm-s', turn_id: 't0', message: { role: 'system', content: 'injected', timestamp: 1 } }] });
+const sysRecord = plainSystem.turns.flatMap((t) => t.records)[0];
+check('an ordinary system record gains no checkpoint fields', [sysRecord.producedBy, sysRecord.generation, sysRecord.parentCompactionId], [null, null, null]);
+check('no generations means messagesAll mirrors messages', plainSystem.stats.messagesAll, 1);
+
+/* ---- generation markers: a rotation is only believable because the file says so ---- */
+const markerRow = (generation, parentGeneration) => JSON.stringify({
+  message_id: 'msg-c' + generation,
+  turn_id: 't0',
+  history_artifact: {
+    schemaVersion: 1,
+    generation,
+    producedBy: 'llm_checkpoint',
+    parentSnapshot: {
+      generation: parentGeneration,
+      compactionId: 'ctx-' + generation,
+      revision: 'sha256:' + 'a'.repeat(64),
+    },
+  },
+  message: { role: 'compactionSummary', summary: '## Goal', tokensBefore: 100 + generation, timestamp: generation },
+}) + '\n';
+const plainRow = JSON.stringify({
+  message_id: 'msg-a1', turn_id: 't1',
+  message: { role: 'assistant', content: [{ type: 'text', text: 'ok' }], timestamp: 9 },
+}) + '\n';
+
+const m2 = readGenerationMarker(markerRow(2, 1) + plainRow);
+check('marker reads the generation it opened', m2.generation, 2);
+check('marker reads the parent generation', m2.parentGeneration, 1);
+check('marker reads the parent compaction id', m2.parentCompactionId, 'ctx-2');
+check('marker reads the parent revision', m2.parentRevision, 'sha256:' + 'a'.repeat(64));
+check('a file with no marker is generation 0', readGenerationMarker(plainRow), null);
+check('an empty file has no marker', readGenerationMarker(''), null);
+check('junk has no marker', readGenerationMarker('not json\n'), null);
+check('a null artifact has no marker', readGenerationMarker(JSON.stringify({ message: { role: 'compactionSummary' } }) + '\n'), null);
+check('generation 0 cannot be a rotation marker', readGenerationMarker(markerRow(0, null)), null);
+check('a string generation is not trusted', readGenerationMarker(JSON.stringify({
+  history_artifact: { generation: '2' }, message: { role: 'compactionSummary' },
+}) + '\n'), null);
+check('a bogus parent revision is dropped, not passed on', readGenerationMarker(JSON.stringify({
+  history_artifact: { generation: 2, parentSnapshot: { generation: 1, revision: 'md5:zz' } },
+  message: { role: 'compactionSummary' },
+}) + '\n').parentRevision, null);
+
+/* ---- walking the lineage, the way the runtime walks it ---- */
+const FILES = {
+  'messages.jsonl': markerRow(2, 1) + plainRow,
+  'g1.jsonl': markerRow(1, 0) + plainRow,
+  'g0.jsonl': plainRow,
+};
+const CATALOG_GENS = parseCatalogGenerations(CATALOG);
+/** A catalog with the generation of each file spelled out, so a test can lie on purpose. */
+const fixtureCatalog = (pairs) => ({
+  generations: pairs.map(([generation, fileName]) => ({
+    generation,
+    kind: fileName === 'messages.jsonl' ? 'active' : 'snapshot',
+    fileName,
+    byteLength: 1000,
+    messageCount: 10,
+    revision: 'sha256:' + String(generation).repeat(64).slice(0, 64),
+    active: fileName === 'messages.jsonl',
+  })),
+});
+const probeFrom = (files) => async (generation) => {
+  const name = generation === null ? 'messages.jsonl' : files[`gen${generation}`];
+  if (name === undefined || files[name] === undefined) return null;
+  return { fileName: name, marker: readGenerationMarker(files[name]) };
+};
+
+const full = await walkLineage(fixtureCatalog([[0,'g0.jsonl'],[1,'g1.jsonl'],[2,'messages.jsonl']]), probeFrom({
+  ...FILES, gen0: 'g0.jsonl', gen1: 'g1.jsonl',
+}));
+check('lineage covers every generation', full.chain.map((l) => l.generation), [0, 1, 2]);
+check('lineage is oldest first', full.chain.map((l) => l.fileName), ['g0.jsonl', 'g1.jsonl', 'messages.jsonl']);
+check('no orphans on a clean chain', full.orphans, []);
+
+const single = await walkLineage(fixtureCatalog([[0,'messages.jsonl']]), probeFrom({ ...FILES, gen1: 'g1.jsonl', 'messages.jsonl': plainRow }));
+check('an uncompacted session is one generation', single.chain.map((l) => l.generation), [0]);
+
+/* a snapshot whose parent generation is not exactly one lower is not part of this lineage */
+const skipped = await walkLineage(fixtureCatalog([[0,'g0.jsonl'],[1,'g1.jsonl'],[2,'messages.jsonl']]), probeFrom({
+  ...FILES, gen0: 'g0.jsonl', gen1: 'g1.jsonl',
+  'g1.jsonl': markerRow(1, 5) + plainRow,
+}));
+check('a generation with a diverging parent is refused', skipped.chain.map((l) => l.generation), [2]);
+check('everything below the break is orphaned', skipped.orphans.map((o) => o.generation), [0, 1]);
+
+/* a file that claims a different generation than it was reached for is refused */
+const lying = await walkLineage(fixtureCatalog([[0,'g0.jsonl'],[1,'g1.jsonl'],[2,'messages.jsonl']]), probeFrom({
+  ...FILES, gen0: 'g0.jsonl', gen1: 'g1.jsonl',
+  'g1.jsonl': markerRow(7, 6) + plainRow,
+}));
+check('a file claiming the wrong generation is refused', lying.chain.map((l) => l.generation), [2]);
+check('the refused file and everything below it are orphaned', lying.orphans.map((o) => o.generation), [0, 1]);
+
+/* a gap in the chain: generation 0 is missing from the catalog */
+const gapped = await walkLineage(fixtureCatalog([[1,'g1.jsonl'],[2,'messages.jsonl']]), probeFrom({ ...FILES, gen1: 'g1.jsonl' }));
+check('a missing ancestor stops the walk', gapped.chain.map((l) => l.generation), [1, 2]);
+
+/* a fork leaves snapshots behind that the active chain never reaches */
+const forked = await walkLineage(
+  { generations: [...fixtureCatalog([[0,'g0.jsonl'],[1,'g1.jsonl'],[2,'messages.jsonl']]).generations, { generation: 5, kind: 'snapshot', fileName: 'orphan.jsonl', byteLength: 10, messageCount: 1, revision: null, active: false }] },
+  probeFrom({ ...FILES, gen0: 'g0.jsonl', gen1: 'g1.jsonl' })
+);
+check('an unreachable snapshot is left out of the chain', forked.chain.map((l) => l.generation), [0, 1, 2]);
+check('an unreachable snapshot is reported', forked.orphans.map((o) => o.fileName), ['orphan.jsonl']);
+
+check('a missing active file yields no chain', (await walkLineage(fixtureCatalog([[0,'messages.jsonl']]), async () => null)).chain, []);
+
+/* ---- rows carry their generation without leaking into JSON ---- */
+const stitched = [];
+for (const [gen, text] of [[0, plainRow], [1, markerRow(1, 0) + plainRow], [2, markerRow(2, 1) + plainRow]]) {
+  for (const row of parseMessagesJsonl(text).rows) {
+    row[ROW_GENERATION] = gen;
+    stitched.push(row);
+  }
+}
+const stitchedPayload = buildTrajectoryPayload({
+  session: { id: 'mvs_9', createdAtMs: 1 },
+  rows: stitched,
+  generations: fixtureCatalog([[0,'g0.jsonl'],[1,'g1.jsonl'],[2,'messages.jsonl']]).generations,
+  orphans: [{ generation: 5, fileName: 'orphan.jsonl' }],
+});
+const allRecords = stitchedPayload.turns.flatMap((t) => t.records);
+check('every record carries a generation', allRecords.every((r) => Number.isInteger(r.generation)), true);
+check('generations appear in stitch order', [...new Set(allRecords.map((r) => r.generation))], [0, 1, 2]);
+check('the symbol never reaches the body', JSON.stringify(stitchedPayload).includes('rowGeneration'), false);
+check('orphans are reported on the session', stitchedPayload.session.orphans.map((o) => o.generation), [5]);
+check('the fixture catalog counts match the stitched rows', stitchedPayload.stats.messagesAll, 30);
+check('a stitched view still reports the session-wide total', stitchedPayload.stats.messagesAll >= stitchedPayload.stats.messages, true);
+
+/* ---- a turn total is only readable if it says what it is made of ---- */
+const turnRows = [];
+const push = (turnId, message) => turnRows.push({ message_id: turnId + '-' + message.role + Math.random().toString(36).slice(2, 7), turn_id: turnId, message });
+push('t-prompt', { role: 'user', content: 'hello', timestamp: 1 });
+push('t-prompt', { role: 'assistant', content: [{ type: 'text', text: 'hi' }], timestamp: 2 });
+push('t-injected', { role: 'user', content: '<system-reminder>x</system-reminder>', canonicalTextRange: [0, 22], timestamp: 3 });
+push('t-injected', { role: 'assistant', content: [{ type: 'text', text: 'ok' }], timestamp: 4 });
+push('t-compact', {
+  role: 'compactionSummary',
+  summary: '## Goal',
+  tokensBefore: 10,
+  timestamp: 5,
+});
+const turnPayload = buildTrajectoryPayload({ session: { id: 'mvs_t', createdAtMs: 1 }, rows: turnRows, generations: [] });
+check('every turn is counted once', turnPayload.stats.turns, 3);
+check('only a turn with a typed prompt counts as dialogue', turnPayload.stats.turnsWithPrompt, 1);
+check('a turn whose only user record was injected has no prompt', turnPayload.stats.turnsWithoutPrompt, 1);
+check('the parts add up to the total', turnPayload.stats.turnsWithPrompt + turnPayload.stats.compactionTurns + turnPayload.stats.turnsWithoutPrompt, turnPayload.stats.turns);
+check('a checkpoint turn is counted as a compaction, not as dialogue', turnPayload.stats.compactionTurns, 1);
+const noCompactions = buildTrajectoryPayload({
+  session: { id: 'mvs_u', createdAtMs: 1 },
+  rows: [{ message_id: 'a', turn_id: 't', message: { role: 'user', content: 'hi', timestamp: 1 } }],
+  generations: [],
+});
+check('the breakdown exists even with a single turn', [noCompactions.stats.turns, noCompactions.stats.turnsWithPrompt, noCompactions.stats.turnsWithoutPrompt, noCompactions.stats.compactionTurns], [1, 1, 0, 0]);
+
+/* ---- 问答 is the turn that asked, and it has not closed ----
+ *
+ * The reader's answer to a question card does not arrive as a message, so the turn the agent
+ * asked in keeps going and the work that follows lands in a later, prompt-less turn. The old
+ * rule filed that later turn as 问答 — which meant a turn could read 问答 while the reader still had
+ * not answered, and that a turn holding hundreds of tool calls was labelled a Q&A.
+ *
+ * What is true of the data: a turn either ends with exactly one reply (stopReason: stop) or
+ * with none, and the turn that called a tool which waits on the reader is one that has not
+ * ended. So 问答 is a prompted turn that is still open, and the continuation is conversation.
+ *
+ * stopReason is set on the assistant messages below. Without it their text files as
+ * narration, and the answer turn looks unlabelled for a reason that has nothing to do with
+ * the rule under test.
+ */
+const askThenAnswer = [
+  { message_id: 'q1', turn_id: 't-ask', message: { role: 'user', content: 'pick one', timestamp: 1 } },
+  { message_id: 'q2', turn_id: 't-ask', message: { role: 'assistant', content: [{ type: 'toolCall', id: 'c1', name: 'ask_user', arguments: {} }], stopReason: 'toolUse', timestamp: 2 } },
+  { message_id: 'q3', turn_id: 't-ask', message: { role: 'toolResult', toolCallId: 'c1', content: 'waiting for the local user', timestamp: 3 } },
+  { message_id: 'q4', turn_id: 't-compact', message: { role: 'compactionSummary', summary: '## Goal', tokensBefore: 5, timestamp: 4 } },
+  { message_id: 'q5', turn_id: 't-answer', message: { role: 'user', content: '<system-reminder><agent-context>x</agent-context></system-reminder>', canonicalTextRange: [0, 52], timestamp: 5 } },
+  { message_id: 'q6', turn_id: 't-answer', message: { role: 'assistant', content: [{ type: 'text', text: 'done' }], stopReason: 'stop', timestamp: 6 } },
+];
+const answerPayload = buildTrajectoryPayload({ session: { id: 'mvs_a', createdAtMs: 1 }, rows: askThenAnswer, generations: [] });
+const answerClasses = answerPayload.turns.map((t) => t.turnClass);
+check('问答 counts the turn that asked, and only that turn', answerPayload.stats.qaTurns, 1);
+check('the turn holding the ask_user call is the one that counts as 问答', answerClasses[0], 'prompt');
+check('the turn after it is a continuation, not a Q&A', answerClasses[2], 'continuation');
+check('a continuation still counts as conversation work', answerPayload.stats.continuationTurns, 1);
+check('the asking turn is open because the reader has not answered', answerPayload.stats.openTurns, 1);
+check('the continuation closed, so it is not open', answerPayload.stats.openTurns === 1, true);
+check('a checkpoint between them is still a checkpoint', answerPayload.stats.compactionTurns, 1);
+check('nothing is left in the unlabelled bucket', answerPayload.stats.turnsWithoutPrompt, 0);
+check('the four classes partition the turns',
+  answerPayload.stats.turnsWithPrompt + answerPayload.stats.continuationTurns
+    + answerPayload.stats.compactionTurns + answerPayload.stats.turnsWithoutPrompt,
+  answerPayload.stats.turns);
+
+/* a turn that asks and is then answered still shows the open turn until the answer lands */
+check('a closed turn is not a Q&A even when it once asked', (() => {
+  const closed = [
+    { message_id: 'k1', turn_id: 't', message: { role: 'user', content: 'pick', timestamp: 1 } },
+    { message_id: 'k2', turn_id: 't', message: { role: 'assistant', content: [{ type: 'toolCall', id: 'c', name: 'ask_user', arguments: {} }], stopReason: 'toolUse', timestamp: 2 } },
+    { message_id: 'k3', turn_id: 't', message: { role: 'toolResult', toolCallId: 'c', content: 'waiting', timestamp: 3 } },
+    { message_id: 'k4', turn_id: 't', message: { role: 'assistant', content: [{ type: 'text', text: 'ok' }], stopReason: 'stop', timestamp: 4 } },
+  ];
+  const p = buildTrajectoryPayload({ session: { id: 'mvs_d', createdAtMs: 1 }, rows: closed, generations: [] });
+  return [p.stats.qaTurns, p.stats.openTurns, p.turns[0].closed];
+})(), [0, 0, true]);
+
+/* a second prompt inside a turn is a steer: same turn, not another conversation turn */
+const withSteer = [
+  { message_id: 's1', turn_id: 't', message: { role: 'user', content: 'do the thing', timestamp: 1 } },
+  { message_id: 's2', turn_id: 't', message: { role: 'assistant', content: [{ type: 'toolCall', id: 'c1', name: 'bash', arguments: {} }], stopReason: 'toolUse', timestamp: 2 } },
+  { message_id: 's3', turn_id: 't', message: { role: 'user', content: 'no, the other one', timestamp: 3 } },
+  { message_id: 's4', turn_id: 't', message: { role: 'assistant', content: [{ type: 'text', text: 'ok' }], stopReason: 'stop', timestamp: 4 } },
+];
+const steerPayload = buildTrajectoryPayload({ session: { id: 'mvs_e', createdAtMs: 1 }, rows: withSteer, generations: [] });
+check('the prompt that opened the turn is the only one counted as dialogue', steerPayload.stats.userMessages, 1);
+check('a prompt written mid-turn is counted apart', steerPayload.stats.steers, 1);
+check('the steer does not open a second conversation turn', steerPayload.stats.turnsWithPrompt, 1);
+check('the turn still closes exactly once', steerPayload.stats.openTurns, 0);
+check('the records are filed user then steer',
+  steerPayload.turns[0].records.filter((r) => r.kind === 'user' || r.kind === 'steer').map((r) => r.kind),
+  ['user', 'steer']);
+check('the steer is marked, so the detail panel can say where it came from',
+  steerPayload.turns[0].records.filter((r) => r.kind === 'steer').map((r) => r.steered), [true]);
+
+/* a prompt-less turn that neither asked nor closed stays unlabelled */
+const orphanTurn = [
+  { message_id: 'o1', turn_id: 't-plain', message: { role: 'user', content: 'hello', timestamp: 1 } },
+  { message_id: 'o2', turn_id: 't-plain', message: { role: 'assistant', content: [{ type: 'text', text: 'hi' }], stopReason: 'stop', timestamp: 2 } },
+  { message_id: 'o3', turn_id: 't-mystery', message: { role: 'user', content: '<system-reminder>y</system-reminder>', canonicalTextRange: [0, 26], timestamp: 3 } },
+  { message_id: 'o4', turn_id: 't-mystery', message: { role: 'assistant', content: [{ type: 'text', text: '?' }], stopReason: 'toolUse', timestamp: 4 } },
+];
+const orphanPayload = buildTrajectoryPayload({ session: { id: 'mvs_c', createdAtMs: 1 }, rows: orphanTurn, generations: [] });
+check('a prompt-less turn with no cause is not guessed at', orphanPayload.stats.turnsWithoutPrompt, 1);
+check('a prompt-less turn with no cause is not called a Q&A', orphanPayload.stats.qaTurns, 0);
+
+console.log(`[1] generations: ${pass} passed, ${failures.length} failed`);
+for (const f of failures) console.log('  FAIL ' + f);
+process.exit(failures.length === 0 ? 0 : 1);
\ No newline at end of file
diff --git a/plugins/avatasia/mmc-trajectory/tests/verify-ledger-batch.mjs b/plugins/avatasia/mmc-trajectory/tests/verify-ledger-batch.mjs
new file mode 100644
index 0000000..3fcc10c
--- /dev/null
+++ b/plugins/avatasia/mmc-trajectory/tests/verify-ledger-batch.mjs
@@ -0,0 +1,219 @@
+/**
+ * A window too large for one frame has to stop being a frozen page.
+ *
+ * The defect: pressing 「显示全部」 on an 18,924-row session put every row into the ledger inside a
+ * single synchronous loop. Measured on this machine, that is about 3,956 ms of main thread during
+ * which the page answers nothing, with no indication that anything was happening. The reader's
+ * only evidence was that clicking had not worked yet.
+ *
+ * The fix does not change what 「显示全部」 promises — every record is still shown. It changes how
+ * many rows are built before the browser gets the thread back, and it says so while it does it.
+ * See docs/LAYERS.md D12, which also records the `content-visibility: auto` alternative that was
+ * measured (3,956 ms → 979 ms) and rejected: its `contain-intrinsic-size` is one number for a
+ * distribution spanning 2,667 px to 29,754 px, so the scrollbar it produces does not describe the
+ * page.
+ *
+ * Four things have to hold together, and each one is a way this can go wrong on its own:
+ *
+ *   1. The frame is actually handed back. A loop that recurses synchronously instead of through
+ *      requestAnimationFrame is the original defect wearing a batch.
+ *   2. A new exit retires the build in flight. Ten writers change "what the table shows"; two
+ *      loops appending to one ledger is how the page ends up with two tables interleaved.
+ *   3. Progress is reported through the one writer of that count. setLedgerProgress() reaching for
+ *      the node itself is the two-writers defect D8 exists to prevent, one layer in.
+ *   4. A poll never replaces a table that is still being built, and the tick it holds back is
+ *      actually run afterwards. The build takes longer than the poll interval, so this is not a
+ *      theoretical concern; and a deferral that is never flushed is a silently dropped refresh.
+ *
+ * The batch size is checked for the property that makes it terminate rather than for the value that
+ * was measured: a batch of zero groups never advances `built`, so the loop would re-schedule itself
+ * every frame forever. 25 is what the measurement gave; 1 is what correctness requires.
+ *
+ * mutate-ledger-batch.py breaks each of these in the shipped file and requires this guard to fail
+ * by name.
+ */
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+
+const HTML = fileURLToPath(new URL('../miniapp/client/index.html', import.meta.url));
+const html = readFileSync(HTML, 'utf8');
+
+let pass = 0;
+const failures = [];
+function assert(name, cond) {
+  if (cond) pass += 1;
+  else failures.push(name);
+}
+
+/** The body of a top-level `function name(...)`, braces matched. */
+function functionBody(name) {
+  const at = html.indexOf('function ' + name + '(');
+  if (at < 0) return null;
+  const open = html.indexOf('{', at);
+  let depth = 0;
+  for (let j = open; j < html.length; j += 1) {
+    if (html[j] === '{') depth += 1;
+    else if (html[j] === '}') {
+      depth -= 1;
+      if (depth === 0) return html.slice(open + 1, j);
+    }
+  }
+  return null;
+}
+
+/** The body of the nested `function buildStep()` inside renderLedger. */
+function buildStepBody() {
+  const ledger = functionBody('renderLedger');
+  if (!ledger) return null;
+  const at = ledger.indexOf('function buildStep()');
+  if (at < 0) return null;
+  const open = ledger.indexOf('{', at);
+  let depth = 0;
+  for (let j = open; j < ledger.length; j += 1) {
+    if (ledger[j] === '{') depth += 1;
+    else if (ledger[j] === '}') {
+      depth -= 1;
+      if (depth === 0) return ledger.slice(open + 1, j);
+    }
+  }
+  return null;
+}
+
+const ledger = functionBody('renderLedger');
+const step = buildStepBody();
+
+assert('the ledger exit still exists and the batch step is declared inside it',
+  !!ledger && !!step);
+
+/* ---------- 1. the frame is handed back ---------- */
+
+assert('the build hands the frame back between batches',
+  !!step && /window\.requestAnimationFrame\(buildStep\);/.test(step));
+
+// Not merely present — reached only when there is more to build. A rAF outside the "is there more"
+// test costs every window, including the default 200-row one, a frame it never needed to spend.
+const moreBlock = step && step.indexOf('if (build.at < groups.length)');
+const rafAt = step && step.indexOf('window.requestAnimationFrame(buildStep);');
+assert('a window that fits in one batch does not spend a frame',
+  moreBlock >= 0 && rafAt > moreBlock
+  && step.slice(moreBlock, step.indexOf('}', moreBlock) + 1).includes('requestAnimationFrame'));
+
+/* ---------- the promise is unchanged ---------- */
+
+// LEDGER_BATCH_GROUPS gates how much runs per frame. It must not gate how much exists: the loop's
+// progress bound is the group count, and the batch size is a second, narrower term beside it.
+assert('显示全部 still means every record: the batch size is not a cap',
+  !!step && /while \(build\.at < groups\.length && built < LEDGER_BATCH_GROUPS\)/.test(step));
+
+assert('the batch always advances its cursor',
+  !!step && /build\.at \+= 1;/.test(step));
+
+// A batch of zero groups never increments `built`, so the loop would re-schedule itself on every
+// frame forever and the page would spin instead of building. Correctness needs 1; the measurement
+// chose 25.
+const batchDecl = /var LEDGER_BATCH_GROUPS = (\d+);/.exec(html);
+assert('the batch is at least one group',
+  !!batchDecl && Number(batchDecl[1]) >= 1);
+
+/* ---------- 2. a new exit retires the build in flight ---------- */
+
+assert('every pass through the exit retires the build in flight',
+  !!ledger && (ledger.match(/ledgerBuildToken \+= 1;/g) ?? []).length === 1);
+
+// The bump has to precede the line that *records* the new build's token. If it came after, the
+// build would be handed the token the previous build was still using, and two concurrent builds
+// would compare equal — the exact interleaving the token exists to prevent.
+const bumpAt = ledger && ledger.indexOf('ledgerBuildToken += 1;');
+const claimAt = ledger && ledger.indexOf('var build = { token: ledgerBuildToken');
+assert('the exit retires the old build before the new one claims a token',
+  bumpAt >= 0 && claimAt >= 0 && bumpAt < claimAt);
+
+// And it has to sit above `clear(ledger)`, not merely somewhere earlier in the function. Four
+// early returns sit between them — loading, hard error, no payload, no sessions — and each of
+// them clears the ledger too. A bump below them means a pass that returned early retired
+// nothing, so the previous build stayed alive and went on appending turn groups into whatever
+// that pass had put there. Counting one bump in the source cannot see that; counting the
+// returns between the two lines can. See docs/LAYERS.md D14.
+const clearAt = ledger && ledger.indexOf('clear(ledger);');
+const between = bumpAt >= 0 && clearAt > bumpAt ? ledger.slice(bumpAt, clearAt) : '';
+assert('no early return sits between the token bump and the clear it precedes',
+  !!between && !/\breturn;/.test(between));
+
+assert('a build whose exit has been replaced stops without appending',
+  !!step && /if \(build\.token !== ledgerBuildToken\) return;/.test(step));
+
+// The check has to come first. A version that appended one more batch before testing would put a
+// section into a ledger that renderLedger() had already emptied — rows appearing in a table that
+// does not exist yet.
+assert('the token is tested before the first row is built',
+  !!step && step.indexOf('if (build.token !== ledgerBuildToken) return;')
+  < step.indexOf('while (build.at < groups.length'));
+
+/* ---------- 3. one writer of the count ---------- */
+
+const setProgress = functionBody('setLedgerProgress');
+const updateBar = functionBody('updateWindowBar');
+
+assert('progress is reported through the one writer of the count',
+  !!setProgress && /updateWindowBar\(/.test(setProgress)
+  && !/textContent/.test(setProgress) && !/window-count/.test(setProgress));
+
+assert('the window bar count has exactly one writer',
+  !!updateBar && (updateBar.match(/parts\.count\.textContent =/g) ?? []).length === 2
+  && (html.match(/parts\.count\.textContent =/g) ?? []).length === 2);
+
+// Two because updateWindowBar reports two states, and both have to be honest. Mid-build the bar
+// must not claim 已显示 for rows that do not exist yet — the count promising a table that is not
+// there is the same defect D8 was written for.
+assert('the mid-build count reports rows built, not rows promised',
+  !!updateBar && /正在显示 ' \+ formatInt\(ledgerProgress\.rows\)/.test(updateBar)
+  && /\/ ' \+ formatInt\(ledgerProgress\.total\)/.test(updateBar));
+
+assert('progress cannot outlive the build',
+  !!step && /setLedgerProgress\(null\);/.test(step));
+
+assert('a settled window is not reported as mid-build',
+  !!updateBar && /if \(ledgerProgress\) \{[\s\S]*?return;\n        \}/.test(updateBar));
+
+/* ---------- 4. the poll defers, and the deferral is not swallowed ---------- */
+
+const pollSrc = functionBody('startPolling');
+assert('a poll never replaces a table that is still being built',
+  !!pollSrc && /if \(ledgerBuilding\(\)\) \{/.test(pollSrc)
+  && /pollDeferred = true;/.test(pollSrc)
+  && /return;/.test(pollSrc));
+
+// The deferral has to be cleared before the fetch, or every flush would re-arm itself and the
+// page would poll once per frame instead of once per 2.5 s.
+const flush = functionBody('flushDeferredPoll');
+assert('the held-back poll is run once, and only once',
+  !!flush && flush.indexOf('pollDeferred = false;') >= 0
+  && flush.indexOf('pollDeferred = false;') < flush.indexOf('fetchTrajectory(false);'));
+
+assert('the held-back poll is not swallowed at the end of a build',
+  !!step && /flushDeferredPoll\(\);/.test(step));
+
+// One source of truth. A separate "is a build running" flag is a second thing that has to agree
+// with the progress flag, and the day it stops agreeing the poll starts replacing tables that are
+// still being built while the bar still says they are.
+assert('the in-flight flag is derived from the progress, not a second variable',
+  /function ledgerBuilding\(\) \{\s*return ledgerProgress !== null;\s*\}/.test(html)
+  && (html.match(/var\s+ledgerBuilding\b/g) ?? []).length === 0);
+
+// The finishing path, in order. restoreRowAnchor moves the page, so measuring before it would pin
+// the strips against a scroll position the reader is no longer at; verify-sticky.mjs pins that
+// same ordering and its own mutations break it.
+if (step) {
+  const atRestore = step.indexOf('restoreRowAnchor(anchor, scrollY);');
+  const atFlush = step.indexOf('flushDeferredPoll();');
+  const atMeasure = step.lastIndexOf('syncStickyOffsets();');
+  assert('the finishing path anchors, then flushes, then measures',
+    atRestore >= 0 && atFlush > atRestore && atMeasure > atFlush);
+}
+
+console.log('[ledger-batch] ' + pass + ' passed, ' + failures.length + ' failed');
+if (failures.length) {
+  console.log('FAILURES:\n - ' + failures.join('\n - '));
+  process.exit(1);
+}
+console.log('[ledger-batch] OK');
diff --git a/plugins/avatasia/mmc-trajectory/tests/verify-overview.mjs b/plugins/avatasia/mmc-trajectory/tests/verify-overview.mjs
new file mode 100644
index 0000000..09f05ed
--- /dev/null
+++ b/plugins/avatasia/mmc-trajectory/tests/verify-overview.mjs
@@ -0,0 +1,592 @@
+// Behavioural self-check for the overview strip and the view controls.
+//
+// These assertions are the evidence that the type chips filter the list, the overview and
+// the turn headers together, and that the 时长 button reports the strip it draws. Every
+// expected value below is derived by hand from the fixture, not from running the code, so
+// the probe can fail rather than merely agree with itself.
+//
+// It loads the delivered index.html itself and runs its real inline script in a
+// sandbox, so there is no copied logic that could drift from what ships.
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import vm from 'node:vm';
+
+const HTML = fileURLToPath(new URL('../miniapp/client/index.html', import.meta.url));
+const html = readFileSync(HTML, 'utf8');
+
+const script = [...html.matchAll(/<script>([\s\S]*?)<\/script>/g)].map((m) => m[1])[0];
+if (!script) throw new Error('no inline script found');
+
+// Cut the bootstrap: the page must not try to fetch or mount while under test.
+const bootIndex = script.lastIndexOf("if (document.readyState === 'loading')");
+const body = bootIndex === -1 ? script : script.slice(0, bootIndex);
+
+const store = new Map();
+const noop = () => {};
+
+/** Boot the delivered script in a sandbox, optionally with storage pre-seeded. */
+function buildSandbox(seed) {
+  const local = seed || new Map();
+  const sandbox = {
+    console,
+    window: {
+      localStorage: {
+        getItem: (k) => (local.has(k) ? local.get(k) : null),
+        setItem: (k, v) => local.set(k, String(v))
+      },
+      matchMedia: () => ({ addEventListener: noop, addListener: noop }),
+      setTimeout: () => 0,
+      clearTimeout: noop,
+      setInterval: () => 0,
+      clearInterval: noop
+    },
+    document: { documentElement: { dataset: {} }, body: { classList: { add: noop, remove: noop } } }
+  };
+  vm.createContext(sandbox);
+  vm.runInContext(body, sandbox);
+  return sandbox;
+}
+
+const sandbox = buildSandbox(store);
+
+let pass = 0;
+const failures = [];
+function check(name, actual, expected) {
+  const ok = JSON.stringify(actual) === JSON.stringify(expected);
+  if (ok) pass += 1;
+  else failures.push(`${name}\n      got  ${JSON.stringify(actual)}\n      want ${JSON.stringify(expected)}`);
+}
+function assert(name, cond) {
+  if (cond) pass += 1;
+  else failures.push(name);
+}
+
+/* ------------------------------------------------------------------ fixtures */
+function rec(id, kind, timestamp, durationMs, extra) {
+  return Object.assign({ id, kind, timestamp, durationMs: durationMs ?? null, summary: id }, extra || {});
+}
+function ent(record, turnIndex) {
+  return { record, turn: { id: 'turn-' + (turnIndex ?? 1), index: turnIndex ?? 1, toolCalls: 0, errors: 0, tokens: {} } };
+}
+
+/* r2/r3/r4 overlap; r5 starts 8.5s after the rest ends — one big idle gap. */
+const MIXED = [
+  ent(rec('r1', 'user', 1000, 0), 1),
+  ent(rec('r2', 'narration', 1100, 400, { responseId: 'R1' }), 1),
+  ent(rec('r3', 'toolCall', 1200, 200, { responseId: 'R1', toolCallId: 'tc1', toolName: 'bash' }), 1),
+  ent(rec('r4', 'toolResult', 1200, 200, { toolCallId: 'tc1' }), 1),
+  ent(rec('r5', 'user', 10000, 0), 2)
+];
+
+/* ---------------------------------------------------------------- Duration off */
+sandbox.state.actualDuration = false;
+const seq = sandbox.overviewModel(MIXED);
+check('Duration off: span count', seq.spans.length, 5);
+check('Duration off: every span is one unit wide', seq.spans.map((s) => s.end - s.start), [1, 1, 1, 1, 1]);
+check('Duration off: domain starts at zero', seq.start, 0);
+check('Duration off: domain is the record count', seq.end, 5);
+assert(
+  'Duration off: recorded timing has no effect on the axis',
+  JSON.stringify(seq.spans.map((s) => s.start)) === JSON.stringify([0, 1, 2, 3, 4])
+);
+check('Duration off: one boundary per turn', seq.turnBoundaries.length, 2);
+check('Duration off: boundaries sit on span starts', seq.turnBoundaries.map((b) => b.time), [0, 4]);
+
+/* ----------------------------------------------------------------- Duration on */
+sandbox.state.actualDuration = true;
+const dur = sandbox.overviewModel(MIXED);
+check('Duration on: span count', dur.spans.length, 5);
+// r1 prompt      -> arrival only, zero width
+// r2 assistant   -> spans the wait since r1 landed          [1000,1100]
+// r3/r4 tool     -> measured run                            [1200,1400]
+// r5 prompt      -> arrival only, zero width
+check('Duration on: a prompt is a zero-width start marker', dur.spans[0].end - dur.spans[0].start, 0);
+check('Duration on: an assistant row spans the wait before it', dur.spans[1].end - dur.spans[1].start, 100);
+check('Duration on: a tool call keeps its measured run', dur.spans[2].end - dur.spans[2].start, 200);
+check('Duration on: a tool result keeps its measured run', dur.spans[3].end - dur.spans[3].start, 200);
+check('Duration on: domain start', dur.start, 1000);
+check('Duration on: domain end', dur.end, 1300);
+check('Duration on: compressed axis is far shorter than wall clock', dur.end - dur.start < 9000, true);
+check('Duration on: idle gap is removed, not shrunk', dur.spans[4].start, 1300);
+check('Duration on: boundaries follow the same compression', dur.turnBoundaries.map((b) => b.time), [1000, 1300]);
+
+/* timedRange is the rule the two modes share, so it gets checked on its own */
+check('timedRange: a prompt never claims a length',
+  sandbox.timedRange({ kind: 'user' }, 0, 500), { start: 500, end: 500, measured: false });
+check('timedRange: an assistant takes the gap since the previous event',
+  sandbox.timedRange({ kind: 'narration' }, 0, 500), { start: 0, end: 500, measured: true });
+check('timedRange: a tool call uses its own measured duration, not the gap',
+  sandbox.timedRange({ kind: 'toolCall', durationMs: 30 }, 0, 500), { start: 500, end: 530, measured: true });
+check('timedRange: an unpaired tool call is a marker, not a guess',
+  sandbox.timedRange({ kind: 'toolCall', durationMs: null }, 0, 500), { start: 500, end: 500, measured: false });
+check('timedRange: a backwards or missing previous stamp falls back to the arrival',
+  sandbox.timedRange({ kind: 'narration' }, null, 500), { start: 500, end: 500, measured: false });
+check('timedRange: a previous stamp after this one is not used',
+  sandbox.timedRange({ kind: 'narration' }, 900, 500), { start: 500, end: 500, measured: false });
+
+/* overlapping spans must not double count the covered interval */
+const OVERLAP = [
+  ent(rec('o1', 'narration', 0, 1000), 1),
+  ent(rec('o2', 'narration', 100, 1000), 1)
+];
+const overlapModel = sandbox.overviewModel(OVERLAP);
+check('overlap: the second assistant reuses the covered interval', overlapModel.end - overlapModel.start, 100);
+
+/* --------------------------------------------------------------- lane mapping */
+check(
+  'lanes follow dsh laneFor',
+  MIXED.map((e) => sandbox.overviewLane(e.record)),
+  [0, 1, 2, 2, 0]
+);
+check('lane: thinking is model lane', sandbox.overviewLane({ kind: 'thinking' }), 1);
+// 问答 and 过程 are both assistant-family text, so the lane and the real-time axis must
+// treat them the same. Checking one and assuming the other is how a whole category ends
+// up missing from the strip with nothing red.
+check('both qa and narration take the text lane',
+  sandbox.overviewLane({ kind: 'reply' }), sandbox.overviewLane({ kind: 'narration' }));
+check('both qa and narration get the same timed range',
+  JSON.stringify(sandbox.timedRange({ kind: 'reply' }, 0, 500)),
+  JSON.stringify(sandbox.timedRange({ kind: 'narration' }, 0, 500)));
+check('lane: injected system is input lane', sandbox.overviewLane({ kind: 'system' }), 0);
+check('lane: a checkpoint is model lane, not input', sandbox.overviewLane({ kind: 'system', title: 'compaction' }), 0);
+
+/* ------------------------------------------------- undated records stay honest */
+const UNDATED = [ent(rec('u1', 'user', null, null), 1), ent(rec('u2', 'user', 500, 0), 1)];
+check('a record with no timestamp is not given a position', sandbox.overviewModel(UNDATED).spans.map((s) => s.id), ['u2']);
+check('no timed records yields no timeline at all', sandbox.overviewModel([ent(rec('u1', 'user', null, null), 1)]), null);
+
+/* ------------------------------------------------------------- layer filters */
+/* 轮次 / 思考 / 调用 are presets over the same kind set the type chips edit — one filter,
+ * two ways of setting it, so nothing here is a second copy that could disagree. Cancelling
+ * a layer leaves no placeholder: the records it covers are simply not in the render plan.
+ * Every expectation below is derived by hand from the fixture, not from running the code. */
+
+const LAYER = {
+  turn: { id: 'turn-1', index: 1, toolCalls: 1, errors: 0, tokens: {} },
+  entries: [
+    ent(rec('a1', 'system', 10, 0, { title: 'system-reminder' }), 1),
+    ent(rec('a2', 'user', 20, 0), 1),
+    ent(rec('a3', 'thinking', 25, 5, { responseId: 'A1' }), 1),
+    ent(rec('a4', 'narration', 30, 10, { responseId: 'A1' }), 1),
+    ent(rec('a5', 'toolCall', 40, 5, { responseId: 'A1', toolCallId: 'x1', toolName: 'bash' }), 1),
+    ent(rec('a6', 'toolResult', 41, 5, { toolCallId: 'x1' }), 1)
+  ]
+};
+sandbox.state.flat = LAYER.entries;
+sandbox.state.kinds = sandbox.KIND_ORDER.slice();
+sandbox.state.query = '';
+sandbox.state.overviewSelection = null;
+
+// The chip set is the one filter, so an assertion sets it the way a reader would: by naming
+// the kinds that stay on. There is no second control that could move it behind the probe's
+// back, so every expectation below is the render the shipped page would produce.
+const only = (...kinds) => { sandbox.state.kinds = kinds; };
+const all = () => { sandbox.state.kinds = sandbox.KIND_ORDER.slice(); };
+
+check('filter: everything is visible by default',
+  sandbox.visibleEntries().map((e) => e.record.id),
+  ['a1', 'a2', 'a3', 'a4', 'a5', 'a6']);
+
+// The conversation is just the two kinds the reader ticks. Hiding 用户 and 过程 leaves the
+// thinking row, the system row and the two tool rows: hiding what was said is not a reason
+// to hide how the model reasoned.
+only('thinking', 'toolCall', 'toolResult', 'system');
+check('filter: dropping the conversation kinds removes those rows and nothing else',
+  sandbox.visibleEntries().map((e) => e.record.id),
+  ['a1', 'a3', 'a5', 'a6']);
+all();
+
+// 思考 is one kind, and nothing else.
+only('user', 'narration', 'toolCall', 'toolResult', 'system');
+check('filter: dropping 思考 removes the thinking row and nothing else',
+  sandbox.visibleEntries().map((e) => e.record.id),
+  ['a1', 'a2', 'a4', 'a5', 'a6']);
+check('filter: dropping 思考 leaves no thinking record anywhere',
+  sandbox.visibleEntries().filter((e) => e.record.kind === 'thinking').length, 0);
+all();
+
+// The tool layer is both call and result, and they go together.
+only('user', 'narration', 'thinking', 'system');
+check('filter: dropping the tool kinds removes both the calls and their results',
+  sandbox.visibleEntries().map((e) => e.record.id),
+  ['a1', 'a2', 'a3', 'a4']);
+all();
+
+// Kinds are independent, so narrowing one never takes part of another with it.
+only('system');
+check('filter: narrowing to 系统 alone leaves only that row',
+  sandbox.visibleEntries().map((e) => e.record.id), ['a1']);
+only('thinking', 'toolCall', 'toolResult', 'system');
+check('filter: the conversation and the tool kinds are independent of each other',
+  sandbox.visibleEntries().map((e) => e.record.id), ['a1', 'a3', 'a5', 'a6']);
+all();
+
+// The whole point of naming kinds instead of picking presets: arbitrary subsets.
+only('user');
+check('filter: only the user questions is a set a reader can pick',
+  sandbox.visibleEntries().map((e) => e.record.id), ['a2']);
+only('system');
+check('filter: only the system records is too',
+  sandbox.visibleEntries().map((e) => e.record.id), ['a1']);
+only('narration', 'toolResult');
+check('filter: a scattered pair of kinds is a set a reader can pick',
+  sandbox.visibleEntries().map((e) => e.record.id), ['a4', 'a6']);
+all();
+
+// The overview strip has to agree with the list, span for span.
+check('filter: the overview agrees with the list when nothing is ticked off',
+  sandbox.spanPassesFilter(LAYER.entries[4].record, false), true);
+only('user', 'narration', 'thinking', 'system');
+check('filter: the overview drops a span the list refuses to render',
+  sandbox.spanPassesFilter(LAYER.entries[4].record, false), false);
+check('filter: the overview keeps the rows the list still shows',
+  sandbox.spanPassesFilter(LAYER.entries[2].record, false), true);
+all();
+
+// A hidden kind is a filter, so the turn headers must recount rather than keep quoting
+// whole-turn numbers for rows that are no longer on screen.
+check('filter: nothing is filtered while every kind is on', sandbox.isFiltering(), false);
+only('user', 'narration', 'thinking', 'system');
+check('filter: a hidden kind counts as filtering', sandbox.isFiltering(), true);
+all();
+
+// Turn headers describe the rows that survived. With the tool kinds hidden, a1(system@10),
+// a2(user@20), a3(thinking@25) and a4(assistant@30) are what is left: no tool call, and a
+// span of 10 -> 30 rather than the whole turn's 10 -> 41.
+only('user', 'narration', 'thinking', 'system');
+sandbox.state.flat = LAYER.entries;
+check('filter: a turn head recounts from the surviving rows',
+  sandbox.turnTotalsFromEntries(sandbox.visibleEntries()),
+  { toolCalls: 0, errors: 0, input: 0, output: 0, cacheRead: 0, cacheWrite: 0, first: 10, last: 30, durationMs: 20 });
+all();
+sandbox.state.flat = [];
+
+
+/* -------------------------------------------------------------- brush filtering */
+const spans = new Map(dur.spans.map((s) => [s.id, s]));
+sandbox.state.overviewSelection = { start: 1090, end: 1300 };
+check('brush: a span overlapping the range is inside it', sandbox.recordInSelection(MIXED[2].record, sandbox.state.overviewSelection, spans), true);
+check('brush: a span ending before the range is outside it', sandbox.recordInSelection(MIXED[0].record, sandbox.state.overviewSelection, spans), false);
+check('brush: a span with no position cannot be claimed', sandbox.recordInSelection({ id: 'ghost' }, sandbox.state.overviewSelection, spans), false);
+check('brush: no selection means no filtering', sandbox.recordInSelection(MIXED[0].record, null, spans), true);
+
+/* ------------------------------------------------------------- tooltip wording */
+const DASH = '—';
+const clockOf = (ms) => {
+  const d = new Date(ms);
+  const p = (n) => (n < 10 ? '0' + n : String(n));
+  return d.getFullYear() + '-' + p(d.getMonth() + 1) + '-' + p(d.getDate()) + ' ' + p(d.getHours()) + ':' + p(d.getMinutes()) + ':' + p(d.getSeconds());
+};
+
+/* MIXED: r3/r4 are the tool pair measured at 200 ms; r2's width is the 100 ms gap
+ * between r1's arrival and r2's own; r1 is a zero-width prompt marker.
+ * Durations below use the page's own "<n> ms" sub-second convention; what is being
+ * asserted is which of the two bases is named, not the unit wording. */
+check('tooltip: a tool result is labelled as measured runtime, not as a gap',
+  sandbox.overviewTipLines(MIXED[3].record, { start: 1200, end: 1400 }, true),
+  ['工具结果', clockOf(1200) + ' → ' + clockOf(1400), '实测耗时 200 ms']);
+check('tooltip: a tool call with no measured result is a bare arrival marker',
+  sandbox.overviewTipLines(rec('r9', 'toolCall', 5000, null, { toolCallId: 'x' }), { start: 5000, end: 5000 }, true),
+  ['工具调用', clockOf(5000), '仅记录了到达时刻']);
+check('tooltip: an assistant-family row is labelled as the wait since the previous event',
+  sandbox.overviewTipLines(MIXED[1].record, { start: 1000, end: 1100 }, true),
+  ['过程', clockOf(1000) + ' → ' + clockOf(1100), '距上一条事件 100 ms']);
+check('tooltip: a zero-width prompt claims no duration at all',
+  sandbox.overviewTipLines(MIXED[0].record, { start: 1000, end: 1000 }, true),
+  ['用户', clockOf(1000), '仅记录了到达时刻']);
+/* Equal-width mode has index bounds, not clocks — printing those as times would be
+ * a 1970 date, so the clock line must come from the record instead. */
+check('tooltip: equal-width mode prints the arrival stamp and never the span index',
+  sandbox.overviewTipLines(MIXED[3].record, { start: 3, end: 4 }, false),
+  ['工具结果', clockOf(1200), '等宽模式 · 每条记录占一格']);
+check('tooltip: an undated record drops the clock line entirely',
+  sandbox.overviewTipLines(rec('r10', 'narration', null), { start: 0, end: 0 }, true),
+  ['过程', '仅记录了到达时刻']);
+check('tooltip: no clock line claims a time the record never had',
+  sandbox.overviewTipLines(MIXED[0].record, { start: 1000, end: 1000 }, false),
+  ['用户', clockOf(1000), '等宽模式 · 每条记录占一格']);
+assert('tooltip never reads a start field off the record', (() => {
+  const src = html.slice(html.indexOf('function overviewTipLines'));
+  const body = src.slice(0, src.indexOf('\n      function '));
+  return !/record\.start/.test(body);
+})());
+
+/* ------------------------------------------------- preference survives a reload */
+/* A second sandbox with the storage already seeded proves the key is actually
+ * read at boot. This is the regression guard for a `var` constant declared below
+ * the `state` literal that initialises it: hoisted but still undefined, so the
+ * read silently used the key "undefined" and the mode reset on every reload. */
+const seeded = new Map([['mmc-trajectory.duration', 'true']]);
+const sandbox2 = buildSandbox(seeded);
+check('preference: duration mode is restored on boot', sandbox2.state.actualDuration, true);
+check('preference: nothing was written to a stray "undefined" key', seeded.has('undefined'), false);
+
+const seededFalse = new Map([['mmc-trajectory.duration', 'false']]);
+check('preference: an explicit false is restored as equal-width',
+  buildSandbox(seededFalse).state.actualDuration, false);
+check('preference: with no stored value the mode defaults to equal-width',
+  buildSandbox(new Map()).state.actualDuration, false);
+// The write path needs a DOM (setActualDuration re-renders), so it stays covered
+// statically: client-check.mjs allows exactly one localStorage write key.
+
+/* ------------------------------------------------- an abandoned brush cannot stick */
+/* A pointerup that never arrives leaves the brush armed. If anything can clear the
+ * range while that is still true, the very next pointer move repaints a range out of
+ * a gesture the user already gave up on — the strip filters with no visible way out. */
+const stubNoop = () => {};
+const stubNode = () => ({ hidden: false, style: { setProperty: stubNoop } });
+sandbox.dom.overviewSelection = stubNode();
+sandbox.dom.overviewClear = stubNode();
+sandbox.dom.overviewHover = stubNode();
+sandbox.dom.overviewLanes = { querySelectorAll: () => [] };
+sandbox.dom.overviewTrack = {
+  getBoundingClientRect: () => ({ left: 0, right: 1000, width: 1000 }),
+  setAttribute: stubNoop,
+  removeAttribute: stubNoop,
+  setPointerCapture: stubNoop,
+  releasePointerCapture: stubNoop
+};
+sandbox.overviewCache.view = { start: 0, duration: 1000 };
+sandbox.overviewCache.model = { start: 0, end: 1000 };
+
+sandbox.overviewDrag = { pointerId: 7, anchorClientX: 0, moved: true, start: 100, end: 400 };
+sandbox.state.overviewSelection = { start: 100, end: 400 };
+sandbox.abortOverviewDrag();
+check('an abandoned brush is disarmed', sandbox.overviewDrag, null);
+
+/* Same guard on the live path: only the pointer that pressed may drive the range. */
+sandbox.overviewDrag = {
+  pointerId: 7, anchorClientX: 0, anchorFraction: 0, anchorTime: 0,
+  start: 0, end: 0, moved: false, button: 0, panning: false, viewport: null
+};
+sandbox.state.overviewSelection = { start: 100, end: 400 };
+sandbox.onOverviewPointerMove({ clientX: 600, clientY: 10, pointerId: 99 });
+check('a pointermove from another pointer cannot repaint the range',
+  sandbox.state.overviewSelection, { start: 100, end: 400 });
+
+/* The owning pointer still brushes normally, so the guard did not simply mute input. */
+sandbox.onOverviewPointerMove({ clientX: 600, clientY: 10, pointerId: 7 });
+check('the owning pointer still brushes', sandbox.state.overviewSelection, { start: 0, end: 600 });
+sandbox.overviewDrag = null;
+sandbox.state.overviewSelection = null;
+
+/* A cancelled gesture is not a finished one: it must leave the range alone. */
+sandbox.overviewDrag = {
+  pointerId: 7, anchorClientX: 0, anchorFraction: 0, anchorTime: 0,
+  start: 100, end: 600, moved: true, button: 0, panning: false, viewport: null
+};
+sandbox.state.overviewSelection = null;
+sandbox.onOverviewPointerUp({ type: 'pointercancel', pointerId: 7, clientX: 600, clientY: 10 });
+check('a cancelled gesture commits nothing', sandbox.state.overviewSelection, null);
+check('a cancelled gesture still disarms the brush', sandbox.overviewDrag, null);
+
+/* ------------------------------------------------------------------- wheel zoom */
+/* Domain 0..1000. OVERVIEW_MIN_ZOOM_SPANS is 4, so the floor is a 250-unit window. */
+const ZMODEL = { start: 0, end: 1000 };
+const WHOLE = { start: 0, duration: 1000 };
+const zin = sandbox.zoomViewport(ZMODEL, WHOLE, 0.5, -300);
+check('zoom: a wheel-up narrows the window', zin.duration < 1000 && zin.duration > 0, true);
+check('zoom: zooming about the middle keeps the middle put',
+  [Math.round(zin.start + zin.duration / 2)], [500]);
+check('zoom: zooming about the left edge pins the left edge',
+  [Math.round(sandbox.zoomViewport(ZMODEL, WHOLE, 0, -300).start)], [0]);
+check('zoom: zooming about the right edge pins the right edge',
+  [Math.round(sandbox.zoomViewport(ZMODEL, WHOLE, 1, -300).start + sandbox.zoomViewport(ZMODEL, WHOLE, 1, -300).duration)], [1000]);
+check('zoom: the window never runs past the domain',
+  sandbox.zoomViewport(ZMODEL, { start: 800, duration: 200 }, 1, -300).start + sandbox.zoomViewport(ZMODEL, { start: 800, duration: 200 }, 1, -300).duration <= 1000, true);
+check('zoom: it never opens back past the domain either',
+  sandbox.zoomViewport(ZMODEL, { start: 100, duration: 300 }, 0.5, 300).duration <= 1000, true);
+check('zoom: zooming out all the way returns the whole session, not a sliver',
+  sandbox.zoomViewport(ZMODEL, { start: 100, duration: 300 }, 0.5, 3000), null);
+/* One gesture is a step, not a reset: exp(0.45) ≈ 1.568, so 300 widens to ~470. */
+check('zoom: one wheel-down step is a bounded widening, not a jump to the end',
+  [Math.round(sandbox.zoomViewport(ZMODEL, { start: 100, duration: 300 }, 0.5, 300).duration)],
+  [Math.round(300 * Math.exp(300 * 0.0015))]);
+check('zoom: it stops at the floor instead of collapsing onto one record',
+  sandbox.zoomViewport(ZMODEL, WHOLE, 0.5, -5000).duration, 250);
+check('zoom: a wheel-down on an unzoomed axis is a no-op',
+  sandbox.zoomViewport(ZMODEL, WHOLE, 0.5, 300), null);
+
+/* ------------------------------------ a type filter survives a live session */
+/* The session this page watches keeps growing. A fold set records the ids it covered, so
+ * a reply that landed after the click was never in it. A filter has no such memory: it
+ * decides per record, per render, so unticking 工具调用 covers the replies that have not
+ * happened yet without any re-application step. */
+const a1 = rec('a1', 'narration', 1000, 0, { responseId: 'R1' });
+const c1 = rec('c1', 'toolCall', 1010, 50, { responseId: 'R1', toolCallId: 'tc1', toolName: 'bash' });
+const a2 = rec('a2', 'narration', 2000, 0, { responseId: 'R2' });
+const c2 = rec('c2', 'toolCall', 2010, 50, { responseId: 'R2', toolCallId: 'tc2', toolName: 'read' });
+const turnA = { id: 'turn-A', index: 1, toolCalls: 1, errors: 0, tokens: {} };
+const turnB = { id: 'turn-B', index: 2, toolCalls: 1, errors: 0, tokens: {} };
+const entryA = [{ record: a1, turn: turnA }, { record: c1, turn: turnA }];
+const entryB = [{ record: a2, turn: turnB }, { record: c2, turn: turnB }];
+
+all();
+sandbox.state.query = '';
+sandbox.state.overviewSelection = null;
+
+const NO_TOOLS = ['user', 'narration', 'thinking', 'system'];
+only(...NO_TOOLS);
+sandbox.state.flat = entryA.slice();
+check('live: unticking the tool kinds covers the first turn',
+  sandbox.visibleEntries().map((e) => e.record.id), ['a1']);
+
+/* The conversation moves on: a new turn with its own tool call arrives. */
+sandbox.state.flat = entryA.concat(entryB);
+check('live: a turn that arrived after the untick is covered too, with no re-apply step',
+  sandbox.visibleEntries().map((e) => e.record.id), ['a1', 'a2']);
+
+all();
+check('live: ticking them back shows every tool row, old and new',
+  sandbox.visibleEntries().map((e) => e.record.id), ['a1', 'c1', 'a2', 'c2']);
+sandbox.state.flat = [];
+all();
+
+
+/* -------------------------------------------------- what the 总览轴 button actually says */
+/* A lit button has to mean "the strip is drawing this". Getting that backwards would leave
+ * a lit 总览轴 sitting above a strip that is laying every record out the same width.
+ *
+ * The wording is asserted literally, because a control whose purpose the reader has to
+ * guess is a defect no functional test would catch. It was labelled 「时长」 and read as a
+ * filter on duration; both labels now have to name the strip and the axis. */
+function stubButton() {
+  const attrs = {};
+  return {
+    attrs,
+    setAttribute: (k, v) => { attrs[k] = v; },
+    getAttribute: (k) => attrs[k]
+  };
+}
+const btnAxis = stubButton();
+
+const readAxis = () => {
+  sandbox.applyAxisButton(btnAxis);
+  return {
+    pressed: btnAxis.getAttribute('aria-pressed'),
+    label: btnAxis.getAttribute('aria-label'),
+    title: btnAxis.getAttribute('title')
+  };
+};
+
+sandbox.state.payload = { turns: [], stats: { turns: 1 } };
+sandbox.state.flat = [{ record: a1, turn: turnA }, { record: c1, turn: turnA }];
+
+sandbox.state.actualDuration = false;
+const axisOff = readAxis();
+check('axis: off reads as equal-width and says what the click will do',
+  axisOff,
+  {
+    pressed: 'false',
+    label: '总览条当前等宽显示：每条记录一样宽，与耗时无关 · 点击改为真实时间轴',
+    title: '总览条当前等宽显示：每条记录一样宽，与耗时无关 · 点击改为真实时间轴'
+  });
+// The label has to say which strip it changes, or it reads as a page-wide filter.
+assert('axis: the equal-width label names the strip', axisOff.label.indexOf('总览条') >= 0);
+assert('axis: the equal-width label says the click changes the axis', axisOff.label.indexOf('点击改为真实时间轴') >= 0);
+assert('axis: the label never says 时长 on its own', axisOff.label.indexOf('「时长」') < 0);
+
+sandbox.state.actualDuration = true;
+const axisOn = readAxis();
+check('axis: on reads as the real clock and says what the click will do',
+  axisOn,
+  {
+    pressed: 'true',
+    label: '总览条当前按真实时间轴显示：宽度等于该记录的真实耗时 · 点击改为等宽，每条记录一样宽',
+    title: '总览条当前按真实时间轴显示：宽度等于该记录的真实耗时 · 点击改为等宽，每条记录一样宽'
+  });
+assert('axis: the real-clock label names the strip', axisOn.label.indexOf('总览条') >= 0);
+assert('axis: each label names the mode the other one switches to',
+  axisOff.label.indexOf('真实时间轴') >= 0 && axisOn.label.indexOf('等宽') >= 0);
+
+/* It is a projection control, not a filter: the same records are on screen either way,
+ * which is what tells the reader no count on the page moved. */
+check('axis: switching it leaves the visible records alone',
+  sandbox.visibleEntries().map((e) => e.record.id), ['a1', 'c1']);
+
+/* It reads off one flag, so it has an answer before any record arrives — a control that
+ * waits for data cannot report that it is already on. */
+sandbox.state.payload = null;
+sandbox.state.flat = [];
+check('axis: it still reports its state before any data arrives',
+  readAxis().pressed, 'true');
+sandbox.state.actualDuration = false;
+
+/* Untick one kind and the button must not move: the strip's clock is not a kind filter. */
+sandbox.state.flat = [{ record: a1, turn: turnA }, { record: c1, turn: turnA }];
+all();
+only(...NO_TOOLS);
+check('axis: filtering by kind does not disturb the axis button',
+  readAxis().pressed, 'false');
+all();
+sandbox.state.flat = [];
+
+
+/* --------------------------------------------- a filter has to reach the numbers too */
+/* Dropping the rows is not filtering if every figure beside them still describes the
+ * rows that were dropped. The turn header has to be rebuilt from what survived. */
+// Written out, not derived: a list read from the code under test agrees with itself. This one
+// is the independent statement of what the shipped kinds are, and the assert below checks it
+// against the shipped order.
+const ALL_KINDS = ['user', 'steer', 'reply', 'narration', 'thinking', 'toolCall', 'toolResult', 'system', 'compaction'];
+assert('the written-out kind list is the shipped one',
+  JSON.stringify(ALL_KINDS) === JSON.stringify(sandbox.KIND_ORDER));
+const fCall = rec('c', 'toolCall', 1000, 50, { responseId: 'R', toolCallId: 'tc', toolName: 'bash' });
+const fOk = rec('k', 'toolResult', 1100, 50, { toolCallId: 'tc' });
+const fBad = rec('b', 'toolResult', 1200, 50, { toolCallId: 'tc2', isError: true });
+const fUser = rec('u', 'user', 3000, 0);
+const fThink = rec('h', 'thinking', 3100, 0, { tokens: { input: 10, output: 3, cacheRead: 100, cacheWrite: 0 } });
+
+check('turn totals: tool calls and failures are counted from the rows given',
+  (() => {
+    const t = sandbox.turnTotalsFromEntries([fCall, fOk, fBad].map((r) => ({ record: r, turn: turnA })));
+    return [t.toolCalls, t.errors];
+  })(), [1, 1]);
+check('turn totals: tokens are summed from the rows given',
+  sandbox.turnTotalsFromEntries([{ record: fThink, turn: turnA }]).input, 10);
+check('turn totals: duration is the span of the rows given',
+  sandbox.turnTotalsFromEntries([fCall, fBad].map((r) => ({ record: r, turn: turnA }))).durationMs, 200);
+check('turn totals: a filtered turn with no tool work reports none',
+  (() => {
+    const t = sandbox.turnTotalsFromEntries([{ record: fUser, turn: turnA }]);
+    return [t.toolCalls, t.errors, t.input];
+  })(), [0, 0, 0]);
+check('turn totals: rows with no timestamp do not invent a duration',
+  sandbox.turnTotalsFromEntries([{ record: rec('z', 'user', null), turn: turnA }]).durationMs, null);
+
+check('filter scope: nothing set means not filtering', sandbox.isFiltering(), false);
+sandbox.state.kinds = ['user'];
+check('filter scope: turning a kind off counts as filtering', sandbox.isFiltering(), true);
+sandbox.state.kinds = ALL_KINDS;
+sandbox.state.query = 'x';
+check('filter scope: a search counts as filtering', sandbox.isFiltering(), true);
+sandbox.state.query = '';
+sandbox.state.overviewSelection = { start: 0, end: 1 };
+check('filter scope: a brushed range counts as filtering', sandbox.isFiltering(), true);
+sandbox.state.overviewSelection = null;
+
+sandbox.state.kinds = ['user'];
+check('strip: a record of a filtered-out kind is not drawn', sandbox.spanPassesFilter(fCall, false), false);
+check('strip: a record of a kept kind is drawn', sandbox.spanPassesFilter(fUser, false), true);
+/* Search is checked on its own, with every kind back on, so a pass can only come from
+ * the text and a fail can only come from the text. */
+sandbox.state.kinds = ALL_KINDS;
+sandbox.state.query = 'needle-that-is-absent';
+check('strip: search rejects a record that does not contain the needle',
+  sandbox.spanPassesFilter(fThink, true), false);
+sandbox.state.query = 'bash';
+check('strip: search keeps a record that does',
+  sandbox.spanPassesFilter(fCall, true), true);
+check('strip: the same record is dropped when the needle is elsewhere',
+  sandbox.spanPassesFilter(fThink, true), false);
+sandbox.state.query = '';
+check('strip: with nothing filtered every record is drawn',
+  sandbox.spanPassesFilter(fCall, false), true);
+
+/* ----------------------------------------------------------------------- report */
+console.log('overview + toolbar controls: ' + pass + ' passed, ' + failures.length + ' failed');
+if (failures.length) {
+  for (const f of failures) console.log('FAIL  ' + f);
+  process.exit(1);
+}
+console.log('ALL CHECKS PASSED');
diff --git a/plugins/avatasia/mmc-trajectory/tests/verify-parsed-rows.mjs b/plugins/avatasia/mmc-trajectory/tests/verify-parsed-rows.mjs
new file mode 100644
index 0000000..2c8cabb
--- /dev/null
+++ b/plugins/avatasia/mmc-trajectory/tests/verify-parsed-rows.mjs
@@ -0,0 +1,342 @@
+/**
+ * The parsed-rows cache may not change a single byte of what the page receives.
+ *
+ * `handleTrajectory()` used to re-read and re-parse every generation file in the lineage on
+ * every poll, because `trajectoryCacheKey()` carries each generation's byteLength: while the
+ * session is still growing the key changes, the whole-session cache misses, and all of it is
+ * redone. Measured on a 23-generation session, that was 99,986,501 source bytes per poll of
+ * which 99.90% was byte-identical to the previous poll, costing 1,138 ms.
+ *
+ * The cache that fixes it holds parsed object graphs across requests, which makes it the one
+ * piece of this service that can silently serve yesterday's file. So the invariant is stated
+ * as the strongest thing available: run the real per-file step twice — once cold, once
+ * through the cache — build the payload both ways, and require the serialized bodies to be
+ * identical. Not "looks the same", identical.
+ *
+ * The key's three components are each tested by the failure they exist to prevent:
+ * a path, because every session has a `messages.jsonl` and a basename key lets two of them
+ * collide; a size, because the active file grows; a limit, because readHead truncates at it.
+ *
+ * Read-only: imports the pure helpers, never starts the runtime.
+ * mutate-parsed-rows.py breaks each of these in the shipped file.
+ */
+import { mkdtemp, mkdir, writeFile, rm, utimes, stat } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { readFileSync } from 'node:fs';
+import {
+  ROW_GENERATION,
+  buildTrajectoryPayload,
+  createParsedRowsCache,
+  loadParsedRows,
+  parsedRowsKey,
+} from '../miniapp/node/server.mjs';
+
+const SERVER = readFileSync(new URL('../miniapp/node/server.mjs', import.meta.url), 'utf8');
+
+let pass = 0;
+const failures = [];
+function check(name, actual, expected) {
+  if (JSON.stringify(actual) === JSON.stringify(expected)) pass += 1;
+  else failures.push(`${name}: got ${JSON.stringify(actual)}, want ${JSON.stringify(expected)}`);
+}
+function assert(name, cond) {
+  if (cond) pass += 1;
+  else failures.push(name);
+}
+
+const LIMIT = 64 * 1024 * 1024;
+const root = await mkdtemp(join(tmpdir(), 'parsed-rows-'));
+
+/* =====================================================================
+ * fixture — hand-written, so every expectation below is countable
+ * ===================================================================== */
+
+// 6 well-formed lines across 2 turns, one line deliberately corrupt so `skipped` is 1, and
+// one line that is not an object.
+const ROWS = [
+  { message_id: 'm1', turn_id: 't1', message: { role: 'user', content: 'first', timestamp: 1791617886000 } },
+  { message_id: 'm2', turn_id: 't1', message: { role: 'assistant', content: [{ type: 'text', text: 'ok' }], timestamp: 1791617891000, usage: { input_tokens: 10, output_tokens: 5 } } },
+  { message_id: 'm3', turn_id: 't2', message: { role: 'user', content: 'second', timestamp: 1791617895000 } },
+  { message_id: 'm4', turn_id: 't2', message: { role: 'assistant', content: [{ type: 'toolCall', name: 'bash' }], timestamp: 1791617896000 } },
+  { message_id: 'm5', turn_id: 't2', message: { role: 'toolResult', content: 'done', timestamp: 1791617897000 } },
+  { message_id: 'm6', turn_id: 't3', message: { role: 'assistant', content: [], timestamp: 1791617900000 } },
+];
+const CORRUPT = '{ this is not json';
+const NOT_OBJECT = '"just a string"';
+
+const jsonl = [
+  ...ROWS.map((r) => JSON.stringify(r)),
+  CORRUPT,
+  NOT_OBJECT,
+  '',
+].join('\n') + '\n';
+
+// 6 parseable rows, 2 skipped (one unparseable, one not an object). Counted by hand.
+const EXPECTED_SKIPPED = 2;
+
+const other = { session: { id: 'sess-b', createdAtMs: 1791617886000 }, sizeBytes: 0, truncated: false };
+
+/** Build the body the way the route does, from a set of per-file results. */
+async function buildBody(files, filter) {
+  const rows = [];
+  let truncated = false;
+  let readBytes = 0;
+  let skipped = 0;
+  for (const file of files) {
+    const parsedFile = await loadParsedRows(file.cache, file.path, LIMIT);
+    if (parsedFile.truncated) truncated = true;
+    readBytes += parsedFile.read;
+    skipped += parsedFile.skipped;
+    const keep = filter === null || filter === file.generation;
+    for (const row of parsedFile.rows) {
+      if (keep) {
+        row[ROW_GENERATION] = file.generation;
+        rows.push(row);
+      }
+    }
+  }
+  const payload = buildTrajectoryPayload({
+    session: { id: 'sess-a', createdAtMs: 1791617886000 },
+    rows,
+    sizeBytes: readBytes,
+    truncated,
+    ...other,
+  });
+  return { body: JSON.stringify(payload), rows, skipped, readBytes };
+}
+
+/* =====================================================================
+ * 1 — a hit is byte-identical to a cold read
+ * ===================================================================== */
+
+const a = join(root, 'gen0.jsonl');
+await writeFile(a, jsonl);
+
+const coldCache = createParsedRowsCache(64 * 1024 * 1024);
+const warmCache = createParsedRowsCache(64 * 1024 * 1024);
+
+// cold: empty cache. warm: primed by a first pass that is thrown away.
+const cold = await buildBody([{ cache: coldCache, path: a, generation: 0 }], null);
+await buildBody([{ cache: warmCache, path: a, generation: 0 }], null);
+const warm = await buildBody([{ cache: warmCache, path: a, generation: 0 }], null);
+
+assert('a cache hit produces a body byte-identical to a cold read', cold.body === warm.body);
+check('the payload really did carry records (so the comparison is not empty-vs-empty)',
+  JSON.parse(cold.body).turns.length > 0, true);
+check('a hit reports the same skipped count as a cold read', warm.skipped, cold.skipped);
+check('a hit reports the same read byte count as a cold read', warm.readBytes, cold.readBytes);
+check('two lines are skipped: one unparseable, one not an object', cold.skipped, EXPECTED_SKIPPED);
+check('the record count survives the round trip', JSON.parse(cold.body).stats.messages, ROWS.length);
+
+// the same, with a generation filter in force, because `keep` is the other thing that walks rows
+const coldF = await buildBody([{ cache: coldCache, path: a, generation: 0 }], 0);
+const warmF = await buildBody([{ cache: warmCache, path: a, generation: 0 }], 0);
+assert('a hit is byte-identical to a cold read under a generation filter too', coldF.body === warmF.body);
+
+// three turns is what these rows make: t1 (m1,m2), t2 (m3,m4,m5), t3 (m6)
+check('the fixture really does group into three turns', JSON.parse(cold.body).turns.length, 3);
+
+/* =====================================================================
+ * 2 — a hit is a hit, and a miss is a miss
+ * ===================================================================== */
+
+const before = await loadParsedRows(warmCache, a, LIMIT);
+const second = await loadParsedRows(warmCache, a, LIMIT);
+assert('an unchanged file is served from the cache (same object, not a re-read)', before === second);
+check('the cache holds exactly one entry after two reads', warmCache.size, 1);
+
+// A rewrite that lands on the same length is invisible to the size, so mtime is the only thing
+// that can tell it apart. The timestamp is set explicitly rather than left to the filesystem's
+// resolution, so this cannot pass or fail by accident on a slow clock.
+const rw = join(root, 'rewritten.jsonl');
+await writeFile(rw, jsonl);
+const rwCache = createParsedRowsCache(64 * 1024 * 1024);
+const rwFirst = await loadParsedRows(rwCache, rw, LIMIT);
+await writeFile(rw, jsonl.replace('"m6"', '"mX"'));
+check('the rewrite really is the same byte length', Buffer.byteLength(jsonl.replace('"m6"', '"mX"')), Buffer.byteLength(jsonl));
+await utimes(rw, new Date(1791617886000 + 60_000), new Date(1791617886000 + 60_000));
+const rwSecond = await loadParsedRows(rwCache, rw, LIMIT);
+assert('a same-size rewrite is noticed, via mtime', rwSecond.rows[5].message_id === 'mX');
+assert('and it is a different object, not the cached one', rwFirst !== rwSecond);
+
+// Growing the file must miss: this is the whole reason the cache exists, and a key that did
+// not notice would pin the page to a stale tail forever.
+await writeFile(a, jsonl + JSON.stringify({ message_id: 'm7', turn_id: 't3', message: { role: 'assistant', content: 'more', timestamp: 1791617905000 } }) + '\n');
+const grown = await loadParsedRows(warmCache, a, LIMIT);
+check('appending to the file is noticed: one more row', grown.rows.length, before.rows.length + 1);
+assert('the appended row is the one that was added', grown.rows[grown.rows.length - 1].message_id === 'm7');
+check('the cache now holds two entries', warmCache.size, 2);
+
+/* =====================================================================
+ * 3 — two sessions must not collide on messages.jsonl
+ *
+ * Every session has a `messages.jsonl`. If the key were a basename, two sessions whose active
+ * files happened to be the same length at the same instant would share parsed rows — one
+ * session's conversation rendered as another's.
+ * ===================================================================== */
+
+const dirX = join(root, 'sess-x');
+const dirY = join(root, 'sess-y');
+await mkdir(dirX);
+await mkdir(dirY);
+await writeFile(join(dirX, 'messages.jsonl'), jsonl);
+
+// The other session holds one different row, padded to exactly the same byte length with a
+// whitespace line. parseMessagesJsonl skips a line whose trim() is empty, so the padding
+// changes the file's size without changing what it means — which is precisely the collision:
+// two sessions, same basename, same size, same mtime, different conversations.
+const otherLine = JSON.stringify({
+  message_id: 'zz',
+  turn_id: 'tz',
+  message: { role: 'user', content: 'other session', timestamp: 1791617886000 },
+}) + '\n';
+const pad = Buffer.byteLength(jsonl) - Buffer.byteLength(otherLine);
+assert('the collision fixture can be padded at all', pad > 0);
+// No trailing newline after the padding: it would add a byte and break the exact match.
+const padded = otherLine + ' '.repeat(pad);
+await writeFile(join(dirY, 'messages.jsonl'), padded);
+
+const forced = new Date(1791617886000);
+await utimes(join(dirX, 'messages.jsonl'), forced, forced);
+await utimes(join(dirY, 'messages.jsonl'), forced, forced);
+
+const sx = await stat(join(dirX, 'messages.jsonl'));
+const sy = await stat(join(dirY, 'messages.jsonl'));
+check('the fixture really does give both sessions the same size', sx.size, sy.size);
+check('the fixture really does give both sessions the same mtime', sx.mtimeMs, sy.mtimeMs);
+
+const shareCache = createParsedRowsCache(64 * 1024 * 1024);
+const fromX = await loadParsedRows(shareCache, join(dirX, 'messages.jsonl'), LIMIT);
+const fromY = await loadParsedRows(shareCache, join(dirY, 'messages.jsonl'), LIMIT);
+check('two sessions with identically-sized, identically-timed messages.jsonl do not share rows',
+  fromY.rows.length, 1);
+assert('and the first one was not served the second one\'s content',
+  fromY.rows[0].message_id === 'zz' && fromX.rows[0].message_id === 'm1');
+check('the cache kept both', shareCache.size, 2);
+
+/* =====================================================================
+ * 4 — the key is built from all four things it must be built from
+ * ===================================================================== */
+
+const base = '/tmp/x/messages.jsonl';
+const k = (p, s, m, l) => parsedRowsKey(p, s, m, l);
+assert('the path is part of the key (two sessions, one basename)', k(base, 100, 5, 9) !== k('/tmp/y/messages.jsonl', 100, 5, 9));
+assert('the size is part of the key (the active file grows)', k(base, 100, 5, 9) !== k(base, 101, 5, 9));
+assert('the mtime is part of the key (a rewrite at the same size)', k(base, 100, 5, 9) !== k(base, 100, 6, 9));
+assert('the limit is part of the key (readHead truncates at it)', k(base, 100, 5, 9) !== k(base, 100, 5, 10));
+assert('nothing else perturbs it', k(base, 100, 5, 9), k(base, 100, 5, 9));
+
+/* =====================================================================
+ * 5 — the budget
+ * ===================================================================== */
+
+const small = createParsedRowsCache(100);
+small.set('a', { rows: [], skipped: 0, size: 0, read: 0, empty: false, truncated: false }, 40);
+small.set('b', { rows: [], skipped: 0, size: 0, read: 0, empty: false, truncated: false }, 40);
+check('two 40-byte entries fit in a 100-byte budget', small.bytes, 80);
+small.set('c', { rows: [], skipped: 0, size: 0, read: 0, empty: false, truncated: false }, 40);
+check('the third evicts the oldest, keeping the budget', small.bytes, 80);
+check('and the total stays inside the budget', small.bytes <= 100, true);
+assert('the least recently used entry is the one that went', small.get('a') === null);
+assert('the newest is still there', small.get('c') !== null);
+
+// reading refreshes recency: the 22 frozen snapshots are read on every rebuild, so the cache
+// that evicts by insertion order would throw away the ones it is for.
+const lru = createParsedRowsCache(100);
+const val = { rows: [], skipped: 0, size: 0, read: 0, empty: false, truncated: false };
+lru.set('a', val, 40);
+lru.set('b', val, 40);
+lru.get('a');
+lru.set('c', val, 40);
+assert('a file that was just read survives the eviction that follows', lru.get('a') !== null);
+assert('the file that was not read is the one evicted', lru.get('b') === null);
+
+// one file bigger than the whole budget: storing it would evict everything and still miss
+const huge = createParsedRowsCache(100);
+huge.set('small', val, 40);
+huge.set('huge', val, 500);
+check('a single entry larger than the budget is not stored', huge.bytes, 40);
+assert('and it is not retrievable', huge.get('huge') === null);
+
+// re-setting a key must not double-count it
+const recount = createParsedRowsCache(1000);
+recount.set('k', val, 500);
+recount.set('k', val, 500);
+check('re-storing the same key counts once', recount.bytes, 500);
+check('and keeps one entry', recount.size, 1);
+
+/* =====================================================================
+ * 6 — sharing must not leak writes between requests
+ *
+ * The rows are handed to every request that reads the file. buildTrajectoryPayload is handed
+ * the same objects, so anything it did to them would persist into the next poll's answer.
+ * ===================================================================== */
+
+const shareRows = createParsedRowsCache(64 * 1024 * 1024);
+const one = await loadParsedRows(shareRows, a, LIMIT);
+const beforeShape = JSON.stringify(one.rows);
+await buildBody([{ cache: shareRows, path: a, generation: 4 }], null);
+const two = await loadParsedRows(shareRows, a, LIMIT);
+assert('building a payload leaves the cached rows byte-identical', beforeShape === JSON.stringify(two.rows));
+assert('and it is literally the same array, not a copy', one === two);
+// ROW_GENERATION is the one write the route makes to a cached row, and one path maps to one
+// generation — so stamping twice leaves the same value.
+check('stamping the generation is idempotent', two.rows[0][ROW_GENERATION], 4);
+
+/* =====================================================================
+ * 7 — truncation still comes from the tested helper
+ * ===================================================================== */
+
+const big = join(root, 'big.jsonl');
+await writeFile(big, jsonl.repeat(20));
+const truncCache = createParsedRowsCache(64 * 1024 * 1024);
+const cut = await loadParsedRows(truncCache, big, 64);
+assert('a file past the cap reports truncated', cut.truncated === true);
+const whole = await loadParsedRows(createParsedRowsCache(64 * 1024 * 1024), big, LIMIT);
+assert('a file inside the cap does not', whole.truncated === false);
+
+// and an empty file says so on a hit too, because the flag rides on the cached value
+const emptyPath = join(root, 'empty.jsonl');
+await writeFile(emptyPath, '');
+const emptyCache = createParsedRowsCache(1024);
+const e1 = await loadParsedRows(emptyCache, emptyPath, LIMIT);
+const e2 = await loadParsedRows(emptyCache, emptyPath, LIMIT);
+assert('an empty file reports empty on a cold read', e1.empty === true);
+assert('an empty file still reports empty on a hit', e2.empty === true);
+assert('and the hit is a hit', e1 === e2);
+
+/* =====================================================================
+ * 8 — structure: where the cache lives and what it is keyed on
+ * ===================================================================== */
+
+const startAt = SERVER.indexOf('export async function start(');
+assert('start() exists', startAt > 0);
+const startBody = SERVER.slice(startAt);
+assert('the cache is created inside start(), not at module level',
+  startBody.indexOf('const parsedRows = createParsedRowsCache(') > 0
+  && !/\nconst parsedRows = createParsedRowsCache\(/.test(SERVER.slice(0, startAt)));
+
+assert('the route reaches the file through loadParsedRows()',
+  startBody.includes('await loadParsedRows(parsedRows, filePath, limit)'));
+assert('the route no longer parses messages inline',
+  !startBody.includes('parseMessagesJsonl(head.text)'));
+assert('the key is built from a stat of the file, not from the catalog',
+  /const current = await stat\(filePath\);/.test(SERVER)
+  && !/parsedRowsKey\(filePath, entry\.sizeBytes/.test(SERVER)
+  && !/parsedRowsKey\(filePath, identity\.catalogBytes/.test(SERVER));
+assert('the truncation verdict comes from truncatedByCap',
+  SERVER.includes('truncated: truncatedByCap(head.size, limit),'));
+assert('loadParsedRows is exported so a test can run the real step',
+  SERVER.includes('export async function loadParsedRows('));
+
+await rm(root, { recursive: true, force: true });
+
+/* ===================================================================== */
+
+if (failures.length) {
+  console.error(`\n[parsed-rows] ${failures.length} FAILED, ${pass} passed`);
+  for (const f of failures) console.error('  - ' + f);
+  process.exit(1);
+}
+console.log(`\n[parsed-rows] ${pass} assertions passed`);
\ No newline at end of file
diff --git a/plugins/avatasia/mmc-trajectory/tests/verify-parsers.mjs b/plugins/avatasia/mmc-trajectory/tests/verify-parsers.mjs
new file mode 100644
index 0000000..fa3e1f5
--- /dev/null
+++ b/plugins/avatasia/mmc-trajectory/tests/verify-parsers.mjs
@@ -0,0 +1,246 @@
+// Authoring-time verification probe. Lives OUTSIDE the Mini App payload on purpose.
+// Run: node tests/run.mjs
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import * as server from '../miniapp/node/server.mjs';
+
+const {
+  resolveSessionsRoot,
+  collectSessionEntries,
+  readSessionIdentity,
+  readHead,
+  parseMessagesJsonl,
+  countRolesInPrefix,
+  buildTrajectoryPayload,
+  createRedactor,
+  isSessionDirName,
+  normalizeLimit,
+  toolCallSummary,
+  normalizeUsage,
+  buildRawPayload,
+  splitRawRecords,
+} = server;
+
+const MAX_MESSAGE_BYTES = 8 * 1024 * 1024;
+const LIST_PEEK_BYTES = 256 * 1024;
+
+// The store under test is the committed synthetic fixture, so this guard means the same thing
+// on a clean CI runner as it does here. `--real` points it at this machine's ~/.minimax instead,
+// which is how you check a change against actual transcripts.
+const HERE = fileURLToPath(new URL('.', import.meta.url));
+const FIXTURE_HOME = join(HERE, 'fixtures', 'minimax-home');
+const USE_REAL = process.argv.includes('--real');
+const failures = [];
+const check = (name, ok, detail = '') => {
+  if (!ok) failures.push(`${name} :: ${detail}`);
+  console.log(`${ok ? 'PASS' : 'FAIL'}  ${name}${detail ? `  ${detail}` : ''}`);
+};
+
+// --- pure helpers ------------------------------------------------------------
+check('isSessionDirName rejects mutation folders', isSessionDirName('.history-mutation-abc') === false);
+check('isSessionDirName accepts session folders', isSessionDirName('03-51-13-137-session_bXZz') === true);
+check('normalizeLimit clamps', normalizeLimit('abc', 20, 1, 50) === 20
+  && normalizeLimit('0', 20, 1, 50) === 1
+  && normalizeLimit('999', 20, 1, 50) === 50
+  && normalizeLimit('12', 20, 1, 50) === 12);
+check('normalizeUsage rejects absent usage', normalizeUsage(undefined) === null);
+check('normalizeUsage maps input/output', JSON.stringify(normalizeUsage({ input: 5, output: 7, cacheRead: 1, cacheWrite: 0, totalTokens: 12 })) === '{"input":5,"output":7,"cacheRead":1,"cacheWrite":0,"totalTokens":12}');
+check('toolCallSummary renders braces', toolCallSummary('read', { path: 'a\nb' }).includes('path='));
+
+// torn-line tolerance
+const torn = '{"message_id":"msg-a","turn_id":"t1","message":{"role":"user","content":"a"}}\n{"message_id":"msg-b","tur';
+const tornParsed = parseMessagesJsonl(torn);
+check('torn trailing line is skipped and counted', tornParsed.rows.length === 1 && tornParsed.skipped === 1, JSON.stringify(tornParsed));
+const broken = '{"message_id":"msg-a","turn_id":"t1","message":{"role":"user","content":"a"}}\nnot json at all\n{"message_id":"msg-c","turn_id":"t1","message":{"role":"custom","content":"raw string"}}';
+const brokenParsed = parseMessagesJsonl(broken);
+check('bad middle line counted not thrown', brokenParsed.rows.length === 2 && brokenParsed.skipped === 1);
+const bareString = buildTrajectoryPayload({
+  session: { id: 'mvs_probe0000' },
+  rows: [{ message_id: 'msg-c', turn_id: 't1', message: { role: 'custom', content: '<system-reminder>x' } }],
+});
+check('bare-string custom content survives', bareString.turns[0].records[0].kind === 'system'
+  && bareString.turns[0].records[0].text === '<system-reminder>x');
+const noContent = buildTrajectoryPayload({
+  session: { id: 'mvs_probe0000' },
+  rows: [{ message_id: 'msg-d', turn_id: 't1', message: { role: 'compactionSummary', summary: '# checkpoint', timestamp: 1 } }],
+});
+check('a compaction with no content still yields one record',
+  noContent.turns[0].records.length === 1 && noContent.turns[0].records[0].kind === 'compaction');
+
+// --- the session store ------------------------------------------------------
+const location = USE_REAL ? resolveSessionsRoot() : resolveSessionsRoot({ MAVIS_HOME: FIXTURE_HOME });
+console.log(`\nsession store: ${USE_REAL ? 'real ~/.minimax' : 'committed fixture'} (${location.sessionsRoot})`);
+const redact = createRedactor([location.sessionsRoot, location.root]);
+
+const entries = await collectSessionEntries(location.sessionsRoot);
+check('enumerates > 5 sessions', entries.length > 5, `found ${entries.length}`);
+check('all entries have messages.jsonl bytes', entries.every((e) => e.sizeBytes > 0));
+
+let idOk = 0;
+let idBad = 0;
+for (const entry of entries) {
+  const identity = await readSessionIdentity(entry.dir);
+  if (/^mvs_[0-9a-f]{32}$/.test(identity.id)) idOk += 1;
+  else {
+    idBad += 1;
+    console.log(`  unexpected id: ${identity.id}`);
+  }
+}
+check('session ids match mvs_<32 hex>', idOk === entries.length, `${idOk} ok / ${idBad} bad`);
+
+const latest = entries[0];
+const identity = await readSessionIdentity(latest.dir);
+const head = await readHead(join(latest.dir, 'messages.jsonl'), Math.min(latest.sizeBytes, identity.catalogBytes ?? MAX_MESSAGE_BYTES, MAX_MESSAGE_BYTES));
+const parsed = parseMessagesJsonl(head.text);
+check('latest session parses > 0 messages', parsed.rows.length > 0, `rows=${parsed.rows.length} skipped=${parsed.skipped} bytes=${head.read}/${head.size}`);
+
+const payload = buildTrajectoryPayload({
+  session: { id: identity.id, createdAtMs: latest.lastActiveAt },
+  rows: parsed.rows,
+  sizeBytes: latest.sizeBytes,
+  truncated: head.read < head.size,
+  redact,
+});
+console.log(`\nlatest=${identity.id}`);
+console.log(`  label          = ${JSON.stringify(payload.session.label)}`);
+console.log(`  messages       = ${payload.stats.messages}`);
+console.log(`  turns          = ${payload.stats.turns}`);
+console.log(`  toolCalls      = ${payload.stats.toolCalls}`);
+console.log(`  toolResults    = ${payload.stats.toolResults}`);
+console.log(`  thinkingBlocks = ${payload.stats.thinkingBlocks}`);
+console.log(`  tokens         = ${JSON.stringify(payload.stats.tokens)}`);
+console.log(`  durationMs     = ${payload.stats.durationMs}`);
+console.log(`  truncated      = ${payload.session.truncated}`);
+
+check('messages parsed', payload.stats.messages > 0);
+check('turns grouped', payload.stats.turns > 0 && payload.stats.turns <= payload.stats.messages);
+check('turn indexes are 1-based and sequential',
+  payload.turns.every((t, i) => t.index === i + 1));
+
+const allRecords = payload.turns.flatMap((t) => t.records);
+const globalIndexes = allRecords.map((r) => r.index);
+check('record indexes are globally continuous 1-based',
+  globalIndexes.length > 0
+  && globalIndexes[0] === 1
+  && globalIndexes.every((v, i) => v === i + 1),
+  `records=${allRecords.length}`);
+check('every record has a turn', allRecords.every((r) => payload.turns.some((t) => t.id === r.turnId)));
+
+const KIND_CONTRACT = ['user', 'steer', 'reply', 'narration', 'thinking', 'toolCall', 'toolResult', 'system', 'compaction'];
+const kinds = new Set(allRecords.map((r) => r.kind));
+// Checked against a written-out list, not against the client's own KIND_ORDER: the point
+// is that the service emits nothing outside the contract, so reading the expectation from
+// the code under test would make this assertion agree with itself.
+check('kinds within contract', [...kinds].every((k) => KIND_CONTRACT.includes(k)), [...kinds].join(','));
+check('assistant split into multiple kinds', kinds.has('toolCall') && kinds.has('thinking'), [...kinds].join(','));
+// Assistant text splits on stopReason: `stop` is the answer a turn delivered (答复), `toolUse`
+// is the commentary written on the way to a tool call (过程). A single kind covering both
+// buried 51 answers under 901 preambles in a working session.
+// `qa` is deliberately NOT in this contract. 问答 belongs to the turn — the exchange where
+// the agent asked the reader something and the reply came back as a tool result — and a
+// record may not claim that word. client-check.mjs asserts the same thing from the other side.
+check('no record kind is named qa', !kinds.has('qa'), [...kinds].join(','));
+// A checkpoint is its own kind precisely so it can be kept or dropped on its own; if it
+// stopped appearing here the ledger would be folding it back into something else.
+check('compactions are their own kind, not filed under system',
+  allRecords.filter((r) => r.title === 'compaction').every((r) => r.kind === 'compaction'));
+
+// NOTE: pairing invariants are asserted over a 12-session corpus further down,
+// not over entries[0]. The newest session is whatever is being appended to right
+// now, so a mid-write file can legitimately contain zero completed tool calls and
+// would make a newest-session-only assertion flip between runs.
+check('non-assistant records have null tokens',
+  allRecords.filter((r) => r.kind === 'user' || r.kind === 'system' || r.kind === 'toolResult' || r.kind === 'compaction').every((r) => r.tokens === null));
+
+// field caps
+const overCap = allRecords.filter((r) => (r.text?.length ?? 0) > 20000 || (r.thinking?.length ?? 0) > 20000 || (r.result?.length ?? 0) > 20000);
+check('text/thinking/result capped at 20000', overCap.length === 0, `${overCap.length} over cap`);
+check('truncated flag set only when capped', allRecords.every((r) => r.textTruncated === true || (r.text?.length ?? 0) <= 20000));
+// The raw-message cap. It used to be asserted here by reading `record.raw` off the payload,
+// which is exactly the thing that is no longer there: the message now travels with the /raw
+// response, built on request. The cap is still a promise the page makes — 「原文过大，已省略」
+// — so the assertion follows the locator instead of asserting the field is absent and moving on.
+const rawLocators = splitRawRecords(payload.turns);
+check('the payload carries no raw message body',
+  allRecords.every((r) => !('raw' in r) && !('rawOmitted' in r)));
+check('every record has a locator back to its row',
+  allRecords.every((r) => Number.isInteger(rawLocators.get(r.index))));
+check('every locator lands on a real row',
+  [...rawLocators.values()].every((i) => i >= 0 && i < parsed.rows.length));
+check('raw dropped over 65536 bytes, or reported as omitted', (() => {
+  for (const record of allRecords) {
+    const row = parsed.rows[rawLocators.get(record.index)];
+    if (!row || typeof row !== 'object') return false;
+    const built = buildRawPayload(row.message, redact);
+    if (built.omitted === true) continue;
+    if (built.value === null) continue;
+    if (Buffer.byteLength(JSON.stringify(built.value), 'utf8') > 65536) return false;
+  }
+  return true;
+})());
+
+const serialized = JSON.stringify(payload);
+// leak check across the whole serialized payload
+const leakPatterns = ['C:\\Users\\ava\\.minimax', 'C:/Users/ava/.minimax', '/Users/ava/.minimax', '.minimax\\v2', '.minimax/v2', '.minimax\\'];
+const leaks = leakPatterns.filter((p) => serialized.includes(p));
+check('no absolute .minimax path in payload', leaks.length === 0, leaks.join(' | '));
+
+// labels across many sessions
+const labels = [];
+for (const entry of entries.slice(0, 12)) {
+  const id2 = await readSessionIdentity(entry.dir);
+  const peek = await readHead(join(entry.dir, 'messages.jsonl'), LIST_PEEK_BYTES);
+  const counts = countRolesInPrefix(peek.text);
+  labels.push({ id: id2.id, label: undefined, counts, payload: null });
+}
+const withRows = [];
+for (const entry of entries.slice(0, 12)) {
+  const id2 = await readSessionIdentity(entry.dir);
+  const peek = await readHead(join(entry.dir, 'messages.jsonl'), Math.min(entry.sizeBytes, MAX_MESSAGE_BYTES));
+  const p = parseMessagesJsonl(peek.text);
+  const built = buildTrajectoryPayload({ session: { id: id2.id }, rows: p.rows, sizeBytes: entry.sizeBytes, redact });
+  withRows.push({ id: id2.id, label: built.session.label, rows: p.rows.length, turns: built.stats.turns, json: JSON.stringify(built), records: built.turns.flatMap((t) => t.records) });
+}
+
+// --- pairing invariants over the whole corpus (deterministic) ---------------
+const corpusCalls = withRows.flatMap((r) => r.records.filter((x) => x.kind === 'toolCall'));
+const corpusResults = withRows.flatMap((r) => r.records.filter((x) => x.kind === 'toolResult'));
+check('corpus contains completed tool activity', corpusResults.length > 0 && corpusCalls.length > 0,
+  `${corpusCalls.length} calls / ${corpusResults.length} results across ${withRows.length} sessions`);
+const corpusCallIds = new Set(corpusCalls.map((c) => c.toolCallId).filter(Boolean));
+const corpusPaired = corpusResults.filter((r) => r.toolCallId && corpusCallIds.has(r.toolCallId));
+check('corpus: every paired result carries a measured duration',
+  corpusPaired.length > 0
+  && corpusPaired.every((r) => typeof r.durationMs === 'number' && r.durationMs >= 0),
+  `${corpusPaired.length}/${corpusResults.length} results paired and timed`);
+check('corpus: unpaired toolResults report null duration, never a guess',
+  corpusResults.filter((r) => !corpusCallIds.has(r.toolCallId)).every((r) => r.durationMs === null),
+  `${corpusResults.length - corpusPaired.length} unpaired results, all null`);
+check('corpus: toolCall records share the measured pair duration',
+  corpusCalls.filter((c) => typeof c.durationMs === 'number').length === corpusPaired.length,
+  `${corpusCalls.filter((c) => typeof c.durationMs === 'number').length} timed calls vs ${corpusPaired.length} pairs`);
+const corpusKinds = new Set(withRows.flatMap((r) => r.records.map((x) => x.kind)));
+check('corpus: assistant content splits into toolCall + thinking',
+  corpusKinds.has('toolCall') && corpusKinds.has('thinking'), [...corpusKinds].sort().join(','));
+const allSampled = JSON.stringify(withRows.map((r) => r.json));
+const crossLeaks = ['C:\\Users\\ava\\.minimax', 'C:/Users/ava/.minimax', '/Users/ava/.minimax', '.minimax\\v2', '.minimax/v2', '.minimax\\']
+  .filter((p) => allSampled.includes(p));
+check('no .minimax path across 12 sampled sessions', crossLeaks.length === 0, crossLeaks.join(' | '));
+console.log('\nper-session sample (latest first):');
+for (const row of withRows.slice(0, 6)) {
+  console.log(`  ${row.id}  msgs=${String(row.rows).padStart(3)}  turns=${String(row.turns).padStart(2)}  label=${JSON.stringify(row.label).slice(0, 78)}`);
+}
+check('all sampled sessions produced a label', withRows.every((r) => typeof r.label === 'string' && r.label.length > 0));
+check('labels are single-line and <= 60 chars', withRows.every((r) => !r.label.includes('\n') && r.label.length <= 60));
+check('list peek counts stay approximate but non-zero', labels.some((l) => l.counts.messages > 0));
+
+const totalRows = withRows.reduce((sum, r) => sum + r.rows, 0);
+check('multi-session parse produced records', totalRows > 0, `${totalRows} rows across ${withRows.length} sessions`);
+
+// no-session-id-mutation double counting: a folder must never appear twice
+const dirs = entries.map((e) => e.dir);
+check('no duplicate session folders', new Set(dirs).size === dirs.length);
+
+console.log(`\n${failures.length === 0 ? 'ALL CHECKS PASSED' : `${failures.length} FAILURES`}`);
+for (const failure of failures) console.log(` - ${failure}`);
+process.exit(failures.length === 0 ? 0 : 1);
\ No newline at end of file
diff --git a/plugins/avatasia/mmc-trajectory/tests/verify-pr15-fixes.mjs b/plugins/avatasia/mmc-trajectory/tests/verify-pr15-fixes.mjs
new file mode 100644
index 0000000..b9d23e8
--- /dev/null
+++ b/plugins/avatasia/mmc-trajectory/tests/verify-pr15-fixes.mjs
@@ -0,0 +1,139 @@
+// Proves the six fixes made for the PR #15 review comments. Read-only: imports the pure
+// helpers, never starts the runtime. Every assertion that could pass on any input at all
+// is paired with a counter-example that pins what actually changed the number.
+import { mkdtemp, writeFile, rm, stat } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { readFileSync } from 'node:fs';
+import {
+  buildTrajectoryPayload,
+  readHead,
+  truncatedByCap,
+} from '../miniapp/node/server.mjs';
+
+const MAX_MESSAGE_BYTES = 64 * 1024 * 1024;
+
+let pass = 0;
+const failures = [];
+function check(name, actual, expected) {
+  const ok = JSON.stringify(actual) === JSON.stringify(expected);
+  if (ok) pass += 1;
+  else failures.push(`${name}: got ${JSON.stringify(actual)}, want ${JSON.stringify(expected)}`);
+}
+function assert(name, cond) {
+  if (cond) pass += 1;
+  else failures.push(name);
+}
+
+const SERVER = readFileSync(new URL('../miniapp/node/server.mjs', import.meta.url), 'utf8');
+const CLIENT = readFileSync(new URL('../miniapp/client/index.html', import.meta.url), 'utf8');
+
+/* =====================================================================
+ * comment #2 — orphan generations inflated messagesAll and were offered in the picker
+ * ===================================================================== */
+const CATALOG_GENS = [
+  { generation: 0, kind: 'snapshot', fileName: 'g000000000000--ctx_aaa.jsonl', byteLength: 4_109_759, messageCount: 676, revision: 'sha256:a', active: false },
+  { generation: 1, kind: 'snapshot', fileName: 'g000000000001--ctx_bbb.jsonl', byteLength: 3_029_414, messageCount: 548, revision: 'sha256:b', active: false },
+  { generation: 2, kind: 'active', fileName: 'messages.jsonl', byteLength: 1_302_171, messageCount: 186, revision: 'sha256:c', active: true },
+];
+// A fork left generation 7 on disk. It is a real file with a real messageCount, and it is
+// not part of this conversation.
+const FORKED = { generation: 7, kind: 'snapshot', fileName: 'g000000000007--ctx_zzz.jsonl', byteLength: 812_000, messageCount: 999, revision: 'sha256:z', active: false };
+
+const baseRows = [
+  { message_id: 'msg-a1', turn_id: 't1', message: { role: 'user', content: 'hi', timestamp: 1791617886000 } },
+  { message_id: 'msg-a2', turn_id: 't1', message: { role: 'assistant', content: [{ type: 'text', text: 'ok' }], timestamp: 1791617891000 } },
+];
+const baseInput = {
+  session: { id: 'mvs_1', createdAtMs: 1791617886354 },
+  rows: baseRows,
+  sizeBytes: 1_302_171,
+  generations: CATALOG_GENS.concat([FORKED]),
+  orphans: [{ generation: 7, fileName: FORKED.fileName }],
+};
+
+const withFork = buildTrajectoryPayload(baseInput);
+check('messagesAll leaves the forked generation out', withFork.stats.messagesAll, 676 + 548 + 186);
+check(
+  'the picker never offers the forked generation',
+  withFork.session.generations.map((g) => g.generation),
+  [0, 1, 2]
+);
+check('the fork is still disclosed as an orphan', withFork.session.orphans.map((o) => o.generation), [7]);
+
+// Counter-example: the identical catalog with nothing marked as an orphan. This is what
+// the page got before the fix, and it is what proves the filter is what moved the number
+// rather than the sum itself being wrong.
+const noOrphans = buildTrajectoryPayload({ ...baseInput, orphans: [] });
+check('counter-example: an unmarked extra generation is still counted', noOrphans.stats.messagesAll, 676 + 548 + 186 + 999);
+check(
+  'counter-example: an unmarked extra generation is still listed',
+  noOrphans.session.generations.map((g) => g.generation),
+  [0, 1, 2, 7]
+);
+check(
+  'orphans are matched by file, not by generation number',
+  buildTrajectoryPayload({ ...baseInput, orphans: [{ generation: 2, fileName: 'something-else.jsonl' }] })
+    .session.generations.map((g) => g.generation),
+  [0, 1, 2, 7]
+);
+
+/* =====================================================================
+ * comment #4 — a stale catalog size made an actively-appended file look too large
+ * ===================================================================== */
+const dir = await mkdtemp(join(tmpdir(), 'mmc-pr15-'));
+const live = join(dir, 'messages.jsonl');
+const LINE = `${JSON.stringify({ message_id: 'x', message: { role: 'user', content: 'a'.repeat(100) } })}\n`;
+await writeFile(live, LINE.repeat(200), 'utf8');
+
+const catalogBytes = (await stat(live)).size;
+await writeFile(live, LINE.repeat(400), 'utf8');
+const grownSize = (await stat(live)).size;
+const staleRead = await readHead(live, Math.min(catalogBytes, MAX_MESSAGE_BYTES));
+assert('a stale catalog limit really does stop the read short', staleRead.read < staleRead.size);
+assert('the file really did grow past its catalog entry', grownSize > catalogBytes);
+
+// The reported bug: the active file had grown to 5.2 MB while the catalog still said 5 MB, and the
+// read stopped at 5 MB, so the page claimed truncation. With `limit` pinned to our own cap that
+// file is simply read whole — which is what the assertions below pin down.
+check('the reported file is not truncation', truncatedByCap(5_200_000, MAX_MESSAGE_BYTES), false);
+check('a file under the cap is not truncation', truncatedByCap(1_302_171, MAX_MESSAGE_BYTES), false);
+check('a file exactly at the cap is not', truncatedByCap(MAX_MESSAGE_BYTES, MAX_MESSAGE_BYTES), false);
+check('a file over the cap is truncated', truncatedByCap(MAX_MESSAGE_BYTES + 1, MAX_MESSAGE_BYTES), true);
+check('an unknown size does not claim truncation', truncatedByCap(NaN, MAX_MESSAGE_BYTES), false);
+check('an unknown cap does not claim truncation', truncatedByCap(1_000, NaN), false);
+
+// Counter-example: the old predicate is `head.read < head.size`, which fires on exactly this file.
+assert('counter-example: the old head.read < head.size test would have reported truncation', staleRead.read < staleRead.size);
+assert('counter-example: the new predicate does not', !truncatedByCap(grownSize, MAX_MESSAGE_BYTES));
+
+// The read is bounded by MAX_MESSAGE_BYTES alone.
+assert('the read is bounded by MAX_MESSAGE_BYTES alone', /const limit = MAX_MESSAGE_BYTES;/.test(SERVER));
+assert(
+  'no catalog-recorded size is used as a read limit any more',
+  !/Math\.min\(entry\.sizeBytes,\s*identity\.catalogBytes/.test(SERVER),
+  );
+assert(
+  'the probe reads a fixed head, not a catalog-derived budget',
+  /readHead\(filePath, GENERATION_PROBE_BYTES\)/.test(SERVER)
+);
+assert('the route actually calls the tested helper', /truncatedByCap\(head\.size, limit\)/.test(SERVER));
+
+/* =====================================================================
+ * comment #3 — the footer said 8 MB while the server reads 64 MB
+ * ===================================================================== */
+check('the server sends the cap it applied', buildTrajectoryPayload(baseInput).session.maxMessageBytes, MAX_MESSAGE_BYTES);
+check('64 MB is what that cap is', MAX_MESSAGE_BYTES, 64 * 1024 * 1024);
+assert('the client renders the cap it was sent', /session\.maxMessageBytes/.test(CLIENT));
+assert('the client formats it rather than restating a number', /formatBytes\(session\.maxMessageBytes\)/.test(CLIENT));
+assert('no hardcoded 8 MB survives in the markup', !/8 MB/.test(CLIENT));
+assert('no hardcoded 64 MB either — the value comes from the payload', !/64 MB/.test(CLIENT));
+
+await rm(dir, { recursive: true, force: true });
+
+if (failures.length > 0) {
+  console.error(`FAIL  ${failures.length} of ${pass + failures.length}`);
+  for (const failure of failures) console.error('  - ' + failure);
+  process.exit(1);
+}
+console.log(`\nALL ${pass} CHECKS PASSED`);
\ No newline at end of file
diff --git a/plugins/avatasia/mmc-trajectory/tests/verify-prompt-fix.mjs b/plugins/avatasia/mmc-trajectory/tests/verify-prompt-fix.mjs
new file mode 100644
index 0000000..03270c2
--- /dev/null
+++ b/plugins/avatasia/mmc-trajectory/tests/verify-prompt-fix.mjs
@@ -0,0 +1,97 @@
+// Verify the canonicalTextRange fix: real prompts are recovered, injected blocks are demoted to `system`.
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import {
+  resolveSessionsRoot,
+  collectSessionEntries,
+  readSessionIdentity,
+  readHead,
+  parseMessagesJsonl,
+  buildTrajectoryPayload,
+  createRedactor,
+  splitUserMessage,
+  canonicalPromptRange,
+} from '../miniapp/node/server.mjs';
+
+const MAX_MESSAGE_BYTES = 8 * 1024 * 1024;
+
+// Committed fixture by default so a clean runner gets the same verdicts; `--real` reads this
+// machine's ~/.minimax. See make-fixtures.mjs for how the fixture is distilled.
+const HERE = fileURLToPath(new URL('.', import.meta.url));
+const FIXTURE_HOME = join(HERE, 'fixtures', 'minimax-home');
+const USE_REAL = process.argv.includes('--real');
+
+let failures = 0;
+const check = (name, cond, extra = '') => {
+  if (cond) console.log('PASS ', name, extra);
+  else {
+    failures += 1;
+    console.log('FAIL ', name, extra);
+  }
+};
+
+const location = USE_REAL ? resolveSessionsRoot() : resolveSessionsRoot({ MAVIS_HOME: FIXTURE_HOME });
+console.log(`session store: ${USE_REAL ? 'real ~/.minimax' : 'committed fixture'}`);
+const root = location.sessionsRoot;
+const redactor = createRedactor([root, location.root]);
+
+// --- unit: split semantics -------------------------------------------------
+check('canonicalRange detected', canonicalPromptRange({ canonicalTextRange: { startOffset: 10, endOffset: 20 } })?.start === 10);
+check('no range -> null', canonicalPromptRange({}) === null);
+check('range + prefix splits', (() => {
+  const r = splitUserMessage({ canonicalTextRange: { startOffset: 10, endOffset: 14 } }, '<reminder>REAL');
+  return r.injected === '<reminder>' && r.prompt === 'REAL';
+})());
+check('pure injected -> no prompt', splitUserMessage({}, '<system-reminder>\nx\n</system-reminder>').prompt === null);
+check('background-task injection -> no prompt', splitUserMessage({}, '<background-task-finished> hi').prompt === null);
+check('runaway guard -> no prompt', splitUserMessage({}, '  [runaway guard] repeated').prompt === null);
+check('plain user text -> prompt', splitUserMessage({}, '  你好，帮我看下这个').prompt === '你好，帮我看下这个');
+
+// --- integration: real sessions -------------------------------------------
+const entries = await collectSessionEntries(root);
+let labelsFixed = 0;
+let promptsFound = 0;
+let fakeUsers = 0;
+
+for (const entry of entries.slice(0, 10)) {
+  const identity = await readSessionIdentity(entry.dir);
+  const head = await readHead(join(entry.dir, 'messages.jsonl'), MAX_MESSAGE_BYTES);
+  const parsed = parseMessagesJsonl(head.text);
+  const payload = buildTrajectoryPayload({
+    session: identity,
+    rows: parsed.rows,
+    sizeBytes: head.size,
+    truncated: entry.sizeBytes > MAX_MESSAGE_BYTES,
+    redact: redactor,
+  });
+
+  const all = payload.turns.flatMap((t) => t.records);
+  const users = all.filter((r) => r.kind === 'user');
+  const injected = all.filter((r) => r.title === 'injected');
+
+  if (users.some((u) => u.summary.startsWith('<system-reminder>'))) fakeUsers += 1;
+  if (users.length) promptsFound += 1;
+  if (injected.length) labelsFixed += 1;
+
+  const json = JSON.stringify(payload);
+  if (json.includes('.minimax')) check('no path leak', false, entry.sessionId);
+
+  if (entry === entries[0]) {
+    console.log('\n--- latest session detail ---');
+    console.log('label        :', payload.session.label);
+    console.log('userMessages :', payload.stats.userMessages, '| injectedBlocks:', payload.stats.injectedBlocks);
+    console.log('kinds        :', [...new Set(all.map((r) => r.kind))].join(', '));
+    console.log('turns        :', payload.turns.length, '| records:', all.length);
+    console.log('first user   :', users[0] ? JSON.stringify(users[0].summary.slice(0, 70)) : '(none)');
+    console.log('first inject :', injected[0] ? JSON.stringify(injected[0].summary.slice(0, 70)) : '(none)');
+    console.log('');
+  }
+}
+
+check('no fake "user" rows starting with <system-reminder>', fakeUsers === 0, `offenders=${fakeUsers}`);
+check('sessions with a real prompt are labelled', promptsFound > 0, `promptsFound=${promptsFound}`);
+check('injected blocks are demoted to system records', labelsFixed > 0, `sessionsWithInjected=${labelsFixed}`);
+check('stats.injectedBlocks present', typeof buildTrajectoryPayload({ session: { id: 'x' }, rows: [] }).stats.injectedBlocks === 'number');
+
+console.log(failures === 0 ? '\nALL CHECKS PASSED' : `\n${failures} CHECK(S) FAILED`);
+process.exit(failures === 0 ? 0 : 1);
diff --git a/plugins/avatasia/mmc-trajectory/tests/verify-raw-lazy.mjs b/plugins/avatasia/mmc-trajectory/tests/verify-raw-lazy.mjs
new file mode 100644
index 0000000..3b0b9d5
--- /dev/null
+++ b/plugins/avatasia/mmc-trajectory/tests/verify-raw-lazy.mjs
@@ -0,0 +1,203 @@
+/**
+ * 「原文过大，已省略」 must still be true — it just moved.
+ *
+ * Deciding it was the expensive part of every poll: buildRawPayload() serialized each message
+ * to measure it against a 64 KB cap, so a rebuild serialized about 100 MB of message bodies to
+ * answer a question the page asks for one record at a time, and threw the string away. The
+ * record now carries the position of its message instead, and /raw builds it on request.
+ *
+ * That is a contract change, and a口径 that moved is a口径 nobody is watching. So every reader
+ * of the old field is listed in docs/LAYERS.md D11 and asserted here by name, the cap is
+ * asserted through the new path rather than dropped, and the one thing that must never come
+ * back — the message body on the bulk response — is asserted absent.
+ *
+ * Read-only: imports the pure helpers, never starts the runtime.
+ * mutate-raw-lazy.py breaks each of these in the shipped file.
+ */
+import { readFileSync } from 'node:fs';
+import {
+  buildRawPayload,
+  buildTrajectoryPayload,
+  createRedactor,
+  splitRawRecords,
+} from '../miniapp/node/server.mjs';
+
+const SERVER = readFileSync(new URL('../miniapp/node/server.mjs', import.meta.url), 'utf8');
+const CLIENT = readFileSync(new URL('../miniapp/client/index.html', import.meta.url), 'utf8');
+
+let pass = 0;
+const failures = [];
+function check(name, actual, expected) {
+  if (JSON.stringify(actual) === JSON.stringify(expected)) pass += 1;
+  else failures.push(`${name}: got ${JSON.stringify(actual)}, want ${JSON.stringify(expected)}`);
+}
+function assert(name, cond) {
+  if (cond) pass += 1;
+  else failures.push(name);
+}
+
+const MAX_RAW_BYTES = 65536;
+const redact = createRedactor(['C:\\Users\\ava\\.minimax']);
+
+/* =====================================================================
+ * 1 — the bulk response stops carrying the message, and says where it is
+ * ===================================================================== */
+
+const rows = [
+  {
+    message_id: 'm1', turn_id: 't1', message: { role: 'user', content: 'hello', timestamp: 1791617886000 },
+  },
+  {
+    message_id: 'm2',
+    turn_id: 't1',
+    message: {
+      role: 'assistant',
+      timestamp: 1791617891000,
+      stopReason: 'stop',
+      content: [{ type: 'text', text: 'the answer' }, { type: 'thinking', thinking: 'why' }],
+    },
+  },
+  {
+    message_id: 'm3', turn_id: 't2', message: { role: 'user', content: 'x'.repeat(MAX_RAW_BYTES * 2), timestamp: 1791617895000 },
+  },
+];
+
+const payload = buildTrajectoryPayload({
+  session: { id: 'sess', createdAtMs: 1791617886000 },
+  rows,
+  sizeBytes: 0,
+  redact,
+});
+const records = payload.turns.flatMap((t) => t.records);
+const locators = splitRawRecords(payload.turns);
+
+check('every record was built', records.length, 4);
+assert('no record carries a raw message body', records.every((r) => !('raw' in r)));
+assert('no record carries the omitted verdict', records.every((r) => !('rawOmitted' in r)));
+assert('every record has a locator', records.every((r) => Number.isInteger(locators.get(r.index))));
+assert('every locator lands on a row', [...locators.values()].every((i) => rows[i] !== undefined));
+// The locator is an internal address, not part of the answer. It is stripped on the way out,
+// and a leftover one would ship `rawRow` to the page on every poll.
+assert('the locator is stripped before the payload is serialized',
+  records.every((r) => !('rawRow' in r)));
+
+// A locator the caller cannot honour has to be dropped, not passed through: /raw would index
+// `rows` with it and either throw or answer with a neighbour's message. Both are worse than a
+// 404, so the split refuses anything that is not a real row position.
+const poisoned = splitRawRecords([
+  { records: [{ index: 1, rawRow: -1 }] },
+  { records: [{ index: 2, rawRow: 'x' }] },
+  { records: [{ index: 3, rawRow: 1.5 }] },
+  { records: [{ index: 4, rawRow: null }] },
+  { records: [{ index: 0, rawRow: 0 }] },
+  { records: [{ index: 5 }] },
+  { records: [{ index: 6, rawRow: 0 }] },
+]);
+check('a locator that is not a row position is dropped', [...poisoned.keys()], [6]);
+check('a record index below 1 is not a record', poisoned.has(0), false);
+check('a record with no locator is not entered at all', poisoned.has(5), false);
+check('a null locator is not silently row zero', poisoned.has(4), false);
+
+// One row can produce several records; they must all answer with the same message, which is
+// what sharing a locator per row (rather than per record) means. Grouped by locator, not by
+// turn — two different rows in one turn are two different messages.
+const byLocator = new Map();
+for (const record of records) {
+  const key = locators.get(record.index);
+  byLocator.set(key, (byLocator.get(key) || 0) + 1);
+}
+const shared = [...byLocator.values()].filter((n) => n > 1);
+assert('a row that split into several records gives them one locator', shared.length > 0);
+assert('and every locator is used by at most the records of its own row',
+  Math.max(...byLocator.values()) === shared.sort((a, b) => b - a)[0]);
+
+// And a locator resolves to its own row's message, not to a neighbour's.
+const assistantLocator = [...byLocator.entries()].find(([, n]) => n > 1)[0];
+const assistantRecord = records.find((r) => locators.get(r.index) === assistantLocator);
+check('the locator resolves to the row it was cut from',
+  rows[locators.get(assistantRecord.index)].message_id, 'm2');
+
+/* =====================================================================
+ * 2 — the cap still holds, on the path that now owns it
+ * ===================================================================== */
+
+const built = records.map((r) => buildRawPayload(rows[locators.get(r.index)].message, redact));
+check('exactly one record is over the cap', built.filter((b) => b.omitted).length, 1);
+assert('and it is the one whose message is large',
+  built[built.findIndex((b) => b.omitted)].raw === undefined || built[built.findIndex((b) => b.omitted)].value === null);
+assert('everything under the cap comes back with its message',
+  built.filter((b) => !b.omitted).every((b) => b.value !== null && b.value !== undefined));
+assert('nothing under the cap exceeds the cap',
+  built.filter((b) => !b.omitted).every((b) => Buffer.byteLength(JSON.stringify(b.value), 'utf8') <= MAX_RAW_BYTES));
+
+// A secret in a message must still be redacted on the way out.
+const leaky = buildRawPayload(
+  { role: 'user', content: 'see C:\\Users\\ava\\.minimax\\sessions\\x.jsonl', timestamp: 1 },
+  redact,
+);
+check('a secret path is redacted on the way out', JSON.stringify(leaky.value).includes('.minimax'), false);
+assert('and the message was still returned', leaky.omitted === false);
+
+/* =====================================================================
+ * 3 — the server builds it on request, and the answer carries the verdict
+ * ===================================================================== */
+
+const handleRawAt = SERVER.indexOf('const handleRaw = async');
+assert('handleRaw exists', handleRawAt > 0);
+const handleRawBody = SERVER.slice(handleRawAt, SERVER.indexOf('};', handleRawAt));
+assert('it calls buildRawPayload, i.e. it builds rather than looks up a stored message',
+  handleRawBody.includes('buildRawPayload(row.message, redact)'));
+assert('it follows the locator back to a row', handleRawBody.includes('cached.rows[rowIndex]'));
+assert('it reports the verdict alongside the message', /omitted: built\.omitted/.test(handleRawBody));
+assert('a missing row is still a 404, not an empty message', handleRawBody.includes("'record_not_found'"));
+assert('the cache entry keeps the rows the locators point into',
+  SERVER.includes('raws: Map<number, number>, rows: Array<Record<string, any>>'));
+assert('the cache entry is written with the rows', SERVER.includes('{ at: Date.now(), etag, body, raws, rows }'));
+
+/* =====================================================================
+ * 4 — each of the five readers, by name
+ *
+ * D11 lists them. A reader left behind would either silently lose the 「过大」 notice or read a
+ * field that no longer exists, and neither shows up in a functional test.
+ * ===================================================================== */
+
+assert('1 handoff: the line reads the argument, not the record',
+  CLIENT.includes("if (rawOmitted) lines.push('- 提示：原文过大已被省略。');"));
+assert('1 handoff: buildHandoffMarkdown takes the verdict',
+  /function buildHandoffMarkdown\(session, turn, record, rawText, rawTruncated, rawOmitted\)/.test(CLIENT));
+assert('1 handoff: the caller passes it', CLIENT.includes('raw.truncated,\n            omitted\n          );'));
+
+assert('2 rawSourceFor: no longer short-circuits on the record',
+  /function rawSourceFor\(record\) \{\s*return fetchRaw\(record\);/.test(CLIENT));
+assert('2 rawSourceFor: documents the new shape', CLIENT.includes('Resolves to `{ raw, omitted }`'));
+
+assert('3 raw tab: draws the omitted note from the answer',
+  CLIENT.includes('if (fetched.omitted === true) {'));
+assert('3 raw tab: and the note still says the same thing',
+  CLIENT.includes('原文过大，已省略。可以从参数与结果页查看已保留的部分。'));
+
+assert('4 raw tab: an omitted message renders the dash', CLIENT.includes('pre.textContent = DASH;\n            return;'));
+assert('5 copySelected: reads the new shape',
+  CLIENT.includes('var noRaw = fetched.omitted === true || fetched.raw === null || fetched.raw === undefined;'));
+assert('handoff: reads the new shape', CLIENT.includes('var omitted = fetched.omitted === true;'));
+
+assert('fetchRaw caches the verdict, not just the message',
+  CLIENT.includes("var entry = { raw: result.body.raw, omitted: result.body.omitted === true };"));
+
+/* =====================================================================
+ * 5 — the field is gone from the client, entirely
+ * ===================================================================== */
+
+const stale = [...CLIENT.matchAll(/record\.rawOmitted|record && record\.rawOmitted/g)];
+check('no reader still looks for rawOmitted on a record', stale.length, 0);
+assert('and the payload no longer carries it either',
+  !SERVER.includes('rawOmitted: raw.omitted') && !SERVER.includes('raw: raw.value'));
+
+/* ===================================================================== */
+
+if (failures.length) {
+  console.error(`\n[raw-lazy] ${failures.length} FAILED, ${pass} passed`);
+  for (const f of failures) console.error('  - ' + f);
+  process.exit(1);
+}
+console.log(`\n[raw-lazy] ${pass} assertions passed`);
\ No newline at end of file
diff --git a/plugins/avatasia/mmc-trajectory/tests/verify-response-rail.mjs b/plugins/avatasia/mmc-trajectory/tests/verify-response-rail.mjs
new file mode 100644
index 0000000..9b20cf2
--- /dev/null
+++ b/plugins/avatasia/mmc-trajectory/tests/verify-response-rail.mjs
@@ -0,0 +1,99 @@
+/**
+ * Verifies the response rail: every row must carry the responseId of the model call it came
+ * from, rows sharing one must be adjacent, and the four rail states must describe the
+ * visible sequence correctly under filtering (where groupmates can be hidden).
+ */
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+// The payload used to come from a booted service on a port passed in. It is now the committed
+// one built from the fixture store by make-payload.mjs, so this runs anywhere.
+const HERE = fileURLToPath(new URL('.', import.meta.url));
+const p = JSON.parse(readFileSync(join(HERE, 'fixtures', 'trajectory.json'), 'utf8'));
+const flat = [];
+for (const t of p.turns) for (const r of t.records ?? []) flat.push(r);
+
+console.log(`session=${p.session.id} records=${flat.length}`);
+
+// 1. responseId presence
+let withResp = 0, without = 0;
+const byKind = {};
+for (const r of flat) {
+  byKind[r.kind] = byKind[r.kind] ?? { n: 0, resp: 0 };
+  byKind[r.kind].n += 1;
+  if (r.responseId) { withResp += 1; byKind[r.kind].resp += 1; } else without += 1;
+}
+console.log(`\nresponseId present on ${withResp} records, absent on ${without}`);
+console.log('  by kind:');
+for (const [k, v] of Object.entries(byKind)) {
+  console.log(`    ${k.padEnd(11)} ${String(v.resp).padStart(4)}/${String(v.n).padEnd(4)} carry responseId`);
+}
+
+// 2. rows sharing a responseId must be contiguous
+const seen = new Map();
+let nonContiguous = 0;
+flat.forEach((r, i) => {
+  if (!r.responseId) return;
+  if (!seen.has(r.responseId)) seen.set(r.responseId, []);
+  seen.get(r.responseId).push(i);
+});
+for (const [rid, idxs] of seen) {
+  for (let k = 1; k < idxs.length; k += 1) {
+    if (idxs[k] !== idxs[k - 1] + 1) { nonContiguous += 1; break; }
+  }
+}
+console.log(`\nresponseIds spanning >1 row : ${[...seen.values()].filter((v) => v.length > 1).length}`);
+console.log(`  of those, non-contiguous  : ${nonContiguous}  ${nonContiguous === 0 ? '(a single rail span is always valid)' : '<-- rail would bridge unrelated rows'}`);
+
+// 3. the rail algorithm, replayed on the visible sequence
+function railStates(entries) {
+  const positions = new Map();
+  entries.forEach((e, i) => {
+    const rid = e.record.responseId;
+    if (!rid) return;
+    if (!positions.has(rid)) positions.set(rid, []);
+    positions.get(rid).push(i);
+  });
+  const out = new Array(entries.length).fill(null);
+  positions.forEach((idxs) => {
+    idxs.forEach((at, n) => {
+      const state = idxs.length === 1 ? 'solo' : at === idxs[0] ? 'start' : at === idxs[idxs.length - 1] ? 'end' : 'mid';
+      out[at] = { state, index: n + 1, size: idxs.length };
+    });
+  });
+  return out;
+}
+
+function report(label, entries) {
+  const rails = railStates(entries);
+  const counts = {};
+  for (const r of rails) if (r) counts[r.state] = (counts[r.state] ?? 0) + 1;
+  const rowsWithRail = rails.filter(Boolean).length;
+  const groups = new Set(entries.map((e) => e.record.responseId).filter(Boolean)).size;
+  console.log(`\n${label}`);
+  console.log(`  rows=${entries.length}  response groups=${groups}  rows carrying a rail=${rowsWithRail}`);
+  console.log(`  states: ${Object.entries(counts).map(([k, v]) => `${k}=${v}`).join(' ') || '(none)'}`);
+  // invariant: every row of a group gets a rail, every row without a responseId gets none
+  let bad = 0;
+  entries.forEach((e, i) => {
+    const has = Boolean(rails[i]);
+    if (has !== Boolean(e.record.responseId)) bad += 1;
+  });
+  console.log(`  invariant (rail iff responseId): ${bad === 0 ? 'OK' : `BROKEN in ${bad} rows`}`);
+  return bad;
+}
+
+console.log('\n--- unfiltered ---');
+let bad = report('all records', flat.map((record) => ({ record })));
+
+console.log('\n--- filtered to thinking only (groupmates hidden) ---');
+const thinkOnly = flat.filter((r) => r.kind === 'thinking').map((record) => ({ record }));
+bad += report('thinking only', thinkOnly);
+
+console.log('\n--- filtered to assistant + thinking (partial groups) ---');
+const partial = flat.filter((r) => r.kind === 'assistant' || r.kind === 'thinking').map((record) => ({ record }));
+bad += report('assistant+thinking', partial);
+
+console.log(`\nVERDICT: ${bad === 0 ? 'rail grouping is correct in every view' : `${bad} problem(s)`}`);
+process.exit(bad === 0 ? 0 : 1);
diff --git a/plugins/avatasia/mmc-trajectory/tests/verify-selection.mjs b/plugins/avatasia/mmc-trajectory/tests/verify-selection.mjs
new file mode 100644
index 0000000..73a3d1a
--- /dev/null
+++ b/plugins/avatasia/mmc-trajectory/tests/verify-selection.mjs
@@ -0,0 +1,197 @@
+/**
+ * The inspector has to describe the table the reader is looking at.
+ *
+ * Selecting a record and then changing a filter used to leave the inspector pointing at a record
+ * that was no longer in the table: the ledger read 已显示 2 条, the inspector still showed the row
+ * that had been picked, and no row anywhere carried the selection mark. Two functions decided what
+ * "selected" meant and they read different lists — the rows were built from `visibleEntries()`, the
+ * selection was checked against `state.flat`, the whole session with nothing filtered out of it.
+ *
+ * The fix is not a second check bolted onto the poll path. `revealSelection()` is handed the very
+ * array the rows are built from and is called from `renderLedger()`, which is the one exit every
+ * path that changes what the table shows goes through — nine of them call it directly instead of
+ * calling render().
+ *
+ * What changed since, and why (docs/LAYERS.md D13): it used to be judged *before* the window was
+ * sliced, and it used to raise `state.limit` to reach a selection sitting below the window. Two
+ * things were wrong with that. The window became something the inspector could widen, so pressing
+ * 「显示最新 200 条」 left the bar promising 200 条 and then, a second later, 15,224 条 — the
+ * reader's own click contradicted the number on screen. And `state.limit` had two writers: the
+ * window controls, and a judgement. Every other two-writer defect in this client has had that
+ * shape.
+ *
+ * So the judgement is now a predicate over the rows that will actually be drawn, and it writes
+ * `state.selectedId` and nothing else. A selection below the window is *dropped*, not revealed:
+ * the reader's explicit window choice outranks an earlier click, and it matches what the filter
+ * axes already do.
+ *
+ * It is checked by *running* revealSelection() against a `state` that carries both the unfiltered
+ * session and the filtered list, so a version that reads the unfiltered one again produces the
+ * wrong answer here rather than looking plausible — and the same run asserts that `state.limit`
+ * comes out untouched, which is the half that used to be silently wrong.
+ *
+ * mutate-selection.py breaks each of these in the shipped file and requires this guard to catch it
+ * with the right reason, so a rule nothing tests cannot be added here.
+ */
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import vm from 'node:vm';
+
+const HTML = fileURLToPath(new URL('../miniapp/client/index.html', import.meta.url));
+const html = readFileSync(HTML, 'utf8');
+
+let pass = 0;
+const failures = [];
+function assert(name, cond) {
+  if (cond) pass += 1;
+  else failures.push(name);
+}
+
+function functionSource(name) {
+  const at = html.indexOf('function ' + name + '(');
+  if (at < 0) return null;
+  let i = html.indexOf('{', at);
+  let depth = 0;
+  for (let j = i; j < html.length; j += 1) {
+    if (html[j] === '{') depth += 1;
+    else if (html[j] === '}') {
+      depth -= 1;
+      if (depth === 0) return html.slice(at, j + 1);
+    }
+  }
+  return null;
+}
+
+/* ---------- the behaviour, run ---------- */
+
+const rec = (id) => ({ record: { id } });
+
+/**
+ * Run revealSelection(entries) against a state that also carries `flat` — the unfiltered session —
+ * so a version that reads `flat` instead of its argument runs to a wrong answer rather than
+ * throwing, and the failure below is a decision rather than a crash. `limit` comes back out too:
+ * the judgement is allowed to end with the window exactly where it found it.
+ */
+function reveal({ selectedId, limit, entries, flat }) {
+  const state = { selectedId, limit, flat: flat ?? entries };
+  const sandbox = { state };
+  vm.createContext(sandbox);
+  const src = functionSource('revealSelection');
+  if (!src) return { error: 'revealSelection is not in the shipped script' };
+  try {
+    vm.runInContext(src, sandbox);
+    var dropped = sandbox.revealSelection(entries);
+  } catch (error) {
+    return { error: String(error && error.message) };
+  }
+  return { selectedId: state.selectedId, limit: state.limit, dropped: dropped === true, error: null };
+}
+
+// Ten rows survive the filter; five more exist in the session but were filtered out. The selected
+// record is row 3 — present in the table, and three rows from the end of the *session* rather than
+// of the table.
+const rows = Array.from({ length: 10 }, (_, i) => rec('r' + i));
+const hidden = Array.from({ length: 5 }, (_, i) => rec('hidden' + i));
+const session = rows.concat(hidden);
+
+// The bug: the record is in the session and gone from the table.
+const gone = reveal({ selectedId: 'hidden0', limit: 10, entries: rows, flat: session });
+assert('a record the filter removed loses its selection',
+  gone.error === null && gone.selectedId === null && gone.dropped === true);
+
+// The normal case: still in the table, still selected, window untouched.
+const kept = reveal({ selectedId: 'r3', limit: 10, entries: rows, flat: session });
+assert('a record still in the table keeps its selection',
+  kept.error === null && kept.selectedId === 'r3' && kept.limit === 10 && kept.dropped === false);
+
+// Below the window. This is the reported defect: the reader had an old record selected in 全部,
+// pressed 「显示最新 200 条」, the record left the table and the inspector went on naming it.
+//
+// It used to be answered by widening the window to reach the selection — which is why pressing
+// 显示最新 200 条 could leave the bar reading 「已显示 15,224 条」 a second after promising 200.
+// The selection is dropped instead, and the window is left exactly where the reader put it.
+const belowWindow = reveal({ selectedId: 'r2', limit: 3, entries: rows.slice(7), flat: session });
+assert('a selection below the window is dropped, and the window is left alone',
+  belowWindow.error === null && belowWindow.selectedId === null
+  && belowWindow.limit === 3 && belowWindow.dropped === true);
+
+const none = reveal({ selectedId: null, limit: 10, entries: rows, flat: session });
+assert('no selection means nothing to reveal',
+  none.error === null && none.selectedId === null && none.dropped === false);
+
+// Clearing the id is half the answer. Nine writers reach the table through renderLedger() without
+// going on to redraw the panel — the search box among them — so a judgement that drops the selection
+// has to say so, and the exit has to act on it. Otherwise the panel goes on naming the record that
+// was just dropped while no row carries the mark: the page contradicting itself again, one layer
+// further along.
+assert('dropping the selection is reported so the panel can be redrawn',
+  /function revealSelection\(entries\)[\s\S]*?state\.selectedId = null;\s*\n\s*return true;/.test(
+    functionSource('revealSelection') ?? ''));
+
+// One writer per field. `state.limit` belongs to the window controls — setWindowMode,
+// resetWindowMode, the 「向上加载更早的 N 条」 button and rePinWindow — and a judgement that also
+// moves it makes it a second writer, which is the shape every two-writer defect in this file has
+// taken. Asserted on the source rather than on the run above, because a version that reaches for
+// the window through some route other than `state.limit` would still pass the behaviour check.
+const revealSrc = functionSource('revealSelection') ?? '';
+assert('the judgement never touches the window',
+  revealSrc.length > 0 && !/\blimit\b/.test(revealSrc));
+
+// An empty table is the same verdict as a filtered-out record, reached by a different route.
+const empty = reveal({ selectedId: 'r0', limit: 10, entries: [], flat: session });
+assert('a table with nothing in it clears the selection',
+  empty.error === null && empty.selectedId === null && empty.dropped === true);
+
+/* ---------- where it is called from ---------- */
+
+const ledgerSrc = functionSource('renderLedger');
+const ledgerBody = ledgerSrc ? ledgerSrc.slice(ledgerSrc.indexOf('{') + 1, ledgerSrc.lastIndexOf('}')) : '';
+const ledgerCalls = ledgerBody.match(/revealSelection\(/g) ?? [];
+assert('the selection is re-judged at the one exit every filter passes through', ledgerCalls.length === 1);
+
+// Judged against the rows the table will actually draw, and after they are sliced. Judging the
+// filtered list would leave a selection standing on a record that survived the filters and was
+// still cut off by the window — the same page-contradicts-itself defect, one layer further in.
+const atMatched = ledgerBody.indexOf('var matched = visibleEntries();');
+const atSlice = ledgerBody.indexOf('var windowed');
+const atReveal = ledgerBody.indexOf('revealSelection(windowed)');
+assert('the re-judgement runs against the rows the table will actually draw',
+  atMatched >= 0 && atSlice > atMatched && atReveal > atSlice);
+
+assert('the selection is judged against the window, not the filter result',
+  /revealSelection\(windowed\)/.test(ledgerBody) && !/revealSelection\(matched\)/.test(ledgerBody));
+
+// The poll path used to be the only caller, which is precisely why a local filter change — none of
+// which go through applyPayload — never touched it.
+const payloadSrc = functionSource('applyPayload');
+assert('the poll path does not judge the selection a second time',
+  !!payloadSrc && !/revealSelection\(/.test(payloadSrc));
+
+// The argument is a parameter, not a re-read of the page. A version that recomputes the list inside
+// the function can be handed one list and judge another.
+assert('the list to judge against is an argument rather than a second read',
+  !!revealSrc && /function revealSelection\(entries\)/.test(revealSrc));
+
+// And the ledger really does build its rows from visibleEntries(), which is what makes "the same
+// list" a fact about the page rather than an intention in a comment.
+assert('the rows on screen are built from the same list',
+  atMatched >= 0 && /var windowed = matched\.length > state\.limit/.test(ledgerBody));
+
+// Clearing the id is half the answer. Nine writers reach the table through renderLedger() without
+// going on to redraw the panel — the search box, the type axis and the overview brush among them —
+// so a judgement that drops the selection has to be acted on here. Otherwise the panel goes on
+// naming the record that was just dropped while no row carries the mark: the page contradicting
+// itself again, one layer further along. This is the half that is easy to miss, because the state
+// is correct after the judgement and only the DOM is stale.
+assert('the panel is redrawn when the selection is dropped',
+  /if\s*\(\s*revealSelection\(windowed\)\s*\)\s*renderInspector\(\);/.test(ledgerBody));
+
+console.log('[selection] ' + pass + ' passed, ' + failures.length + ' failed');
+for (const [label, run] of Object.entries({ gone, kept, belowWindow, none, empty })) {
+  if (run.error) console.log('  ' + label + ' threw: ' + run.error);
+}
+if (failures.length) {
+  console.log('FAILURES:\n - ' + failures.join('\n - '));
+  process.exit(1);
+}
+console.log('[selection] OK');
diff --git a/plugins/avatasia/mmc-trajectory/tests/verify-sticky.mjs b/plugins/avatasia/mmc-trajectory/tests/verify-sticky.mjs
new file mode 100644
index 0000000..332b2fc
--- /dev/null
+++ b/plugins/avatasia/mmc-trajectory/tests/verify-sticky.mjs
@@ -0,0 +1,304 @@
+/**
+ * The filter band has to stay pinned while the ledger scrolls under it, and everything pinned
+ * below it has to land on the band it actually has rather than on a number written down once.
+ *
+ * Three things break, and each is checked here:
+ *
+ *   1. the two filter rows stop being one block. Only the type row ever claimed `position: sticky`
+ *      and it did not survive: with the ledger below it and both rows scrolled away, a session
+ *      filtered down to a few hundred rows gave no sign that anything was filtered at all.
+ *   2. an offset is written down as a constant. The 异常 row wraps at narrow widths and its note
+ *      comes and goes, so any number ages into a silent overlap — which is what the old 0–32 and
+ *      32–83 comments encoded.
+ *   3. the band is measured at the wrong moment, or from a different element than the one that is
+ *      pinned.
+ *
+ * The measurement is checked by *running* syncStickyOffsets() against stub heights chosen to
+ * differ from the stylesheet's fallbacks (32 / 51 / 45), so a version that writes a constant, or
+ * writes one band's height into another's variable, fails here instead of looking plausible.
+ *
+ * Everything pinned over the ledger must also paint a background: the ledger rows underneath are
+ * `background: transparent`, so a pinned strip that does not cover them lets them show through.
+ *
+ * mutate-sticky.py breaks each of these in the shipped file and requires this guard to catch it
+ * with the right reason, so a rule nothing tests cannot be added here.
+ */
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import vm from 'node:vm';
+
+const HTML = fileURLToPath(new URL('../miniapp/client/index.html', import.meta.url));
+const html = readFileSync(HTML, 'utf8');
+
+const styleMatch = /<style>([\s\S]*?)<\/style>/.exec(html);
+if (!styleMatch) {
+  console.log('FAIL: no <style> block in the client');
+  process.exit(1);
+}
+// Comments first: the reasoning about these rules lives in comments, and a rule body read out of
+// commented source would let a deleted rule look present.
+const css = styleMatch[1].replace(/\/\*[\s\S]*?\*\//g, '');
+
+let pass = 0;
+const failures = [];
+function assert(name, cond) {
+  if (cond) pass += 1;
+  else failures.push(name);
+}
+
+/* ---------- CSS: read a declaration out of the rule, not out of the prose ---------- */
+
+/** Every rule whose selector list contains exactly `sel`, joined. */
+function rulesFor(sel) {
+  const out = [];
+  // Anchored on a line start, not on the previous rule's closing brace: a brace anchor is consumed
+  // by the match that uses it, which makes every other rule invisible to the scan.
+  const re = /^[ \t]*([^{}@][^{}]*?)\{[^{}]*\}/gm;
+  let m;
+  while ((m = re.exec(css))) {
+    const selectors = m[1].split(',').map((s) => s.trim());
+    if (selectors.includes(sel)) out.push(m[0].slice(m[0].indexOf('{') + 1, m[0].lastIndexOf('}')));
+  }
+  return out;
+}
+
+/** The declarations of `sel`, as a property -> last value map. */
+function decls(sel) {
+  const map = new Map();
+  for (const body of rulesFor(sel)) {
+    for (const part of body.split(';')) {
+      const at = part.indexOf(':');
+      if (at < 0) continue;
+      map.set(part.slice(0, at).trim(), part.slice(at + 1).replace(/\s+/g, ' ').trim());
+    }
+  }
+  return map;
+}
+
+function value(sel, prop) {
+  const d = decls(sel);
+  return d.has(prop) ? d.get(prop) : null;
+}
+
+/** The custom properties a declaration reads, e.g. `--sticky-band-h`. */
+function varsRead(text) {
+  const out = new Set();
+  if (!text) return out;
+  for (const m of text.matchAll(/var\(\s*(--[\w-]+)/g)) out.add(m[1]);
+  return out;
+}
+
+function isOpaqueBackground(v) {
+  return !!v && v !== 'transparent' && !v.startsWith('rgba') && !v.startsWith('hsla');
+}
+
+/* ---------- markup: the subtree of the band, by counting tags ---------- */
+
+function subtreeFrom(start) {
+  let i = start;
+  let depth = 1;
+  const tag = /<\/?div\b[^>]*>/g;
+  tag.lastIndex = i;
+  let t;
+  while ((t = tag.exec(html))) {
+    depth += t[0][1] === '/' ? -1 : 1;
+    if (depth === 0) return html.slice(i, t.index);
+  }
+  return null;
+}
+
+// The band is located by the id the script looks it up by, and its class is checked on its own:
+// those are two names in two different places, and if they drift the rule still parses, the element
+// still has an id, and nothing is pinned at all.
+const bandOpen = /<div([^>]*\bid="filter-sticky"[^>]*)>/.exec(html);
+const bandClass = bandOpen ? /class="([^"]*)"/.exec(bandOpen[1]) : null;
+const bandInner = bandOpen ? subtreeFrom(bandOpen.index + bandOpen[0].length) : null;
+
+assert('both filter rows ship inside one sticky band',
+  !!bandInner && bandInner.includes('id="kind-controls"') && bandInner.includes('id="anomaly-bar"'));
+assert('the band element ships the class the stylesheet pins',
+  !!bandClass && bandClass[1].split(/\s+/).includes('filter-sticky')
+  && value('.filter-sticky', 'position') === 'sticky');
+assert('the band is written before the strip, and the strip before the window bar',
+  html.indexOf('id="filter-sticky"') < html.indexOf('<section class="overview"')
+  && html.indexOf('<section class="overview"') < html.indexOf('<div class="window-bar" id="window-bar"'));
+
+/* ---------- CSS: one pinned block for the two filter rows ---------- */
+
+assert('the filter band pins to the top of the page',
+  value('.filter-sticky', 'position') === 'sticky' && value('.filter-sticky', 'top') === '0');
+assert('the band is the only pinned element for the two filter rows',
+  value('.traj-controls', 'position') !== 'sticky' && value('.anomaly-bar', 'position') !== 'sticky');
+
+assert('the filter band is opaque', isOpaqueBackground(value('.filter-sticky', 'background')));
+// The strip paints through its plot, not through the section: the section is the sticky box and
+// the plot is the 50px that fills it. A reader scrolling a 200-row ledger sees the rows pass under.
+assert('the overview strip is opaque', isOpaqueBackground(value('.overview-plot', 'background')));
+assert('the window bar is opaque', isOpaqueBackground(value('.window-bar', 'background')));
+assert('the turn head is opaque', isOpaqueBackground(value('.turn-head', 'background')));
+
+/* ---------- CSS: the offsets come from variables, and chain down the page ---------- */
+
+const overviewTop = value('.overview', 'top');
+const windowTop = value('.window-bar', 'top');
+const turnTop = value('.turn-head', 'top');
+
+assert('the strip pins below the band it measures, not below a constant',
+  varsRead(overviewTop).has('--sticky-band-h'));
+assert('the window bar pins below the band and the strip',
+  varsRead(windowTop).has('--sticky-band-h') && varsRead(windowTop).has('--sticky-overview-h'));
+assert('a turn head pins below the band, the strip and the window bar',
+  varsRead(turnTop).has('--sticky-band-h')
+  && varsRead(turnTop).has('--sticky-overview-h')
+  && varsRead(turnTop).has('--sticky-window-h'));
+
+/* ---------- the measurement itself, run ---------- */
+
+function functionSource(name) {
+  const at = html.indexOf('function ' + name + '(');
+  if (at < 0) return null;
+  let i = html.indexOf('{', at);
+  let depth = 0;
+  for (let j = i; j < html.length; j += 1) {
+    if (html[j] === '{') depth += 1;
+    else if (html[j] === '}') {
+      depth -= 1;
+      if (depth === 0) return html.slice(at, j + 1);
+    }
+  }
+  return null;
+}
+
+/** Run syncStickyOffsets() against stub bands and report what it wrote. */
+function measure(dom) {
+  const written = {};
+  const sandbox = {
+    dom,
+    document: {
+      documentElement: {
+        style: { setProperty(name, val) { written[name] = val; } },
+      },
+    },
+  };
+  vm.createContext(sandbox);
+  const src = functionSource('syncStickyOffsets');
+  if (!src) return { written, error: 'syncStickyOffsets is not in the shipped script' };
+  try {
+    vm.runInContext(src, sandbox);
+    sandbox.syncStickyOffsets();
+  } catch (error) {
+    return { written, error: String(error && error.message) };
+  }
+  return { written, error: null };
+}
+
+// 137 / 65 / 57 against fallbacks of 32 / 51 / 45: no plausible constant can pass for a
+// measurement, and the three differ so a height written into the wrong variable is caught too.
+const stub = {
+  filterSticky: { offsetHeight: 137 },
+  overview: { offsetHeight: 65 },
+  windowBar: { offsetHeight: 57 },
+};
+const run = measure(stub);
+assert('the measurement runs without throwing on the page it ships with', run.error === null);
+assert('the measured band height is the one that gets written',
+  run.written['--sticky-band-h'] === '137px');
+assert('the measured strip height is the one that gets written',
+  run.written['--sticky-overview-h'] === '65px');
+assert('the measured window bar height is the one that gets written',
+  run.written['--sticky-window-h'] === '57px');
+
+// The set of variables the stylesheet reads has to be exactly the set the measurement writes. One
+// side alone is not enough: a variable the stylesheet reads but nothing writes falls back to its
+// constant silently, and a variable the measurement writes but nothing reads is a dead measurement
+// that means the offsets went back to being constants.
+const read = varsRead([overviewTop, windowTop, turnTop].join(' '));
+const writtenSet = new Set(Object.keys(run.written));
+const orphan = [...read].filter((v) => !writtenSet.has(v));
+const dead = [...writtenSet].filter((v) => !read.has(v));
+assert('every pinned offset is written by the measurement, not by the stylesheet',
+  read.size > 0 && orphan.length === 0);
+assert('the measurement writes exactly the offsets the stylesheet reads', dead.length === 0);
+
+// A band that is not on the page must not take the rest of the page down with it.
+const missing = measure({ filterSticky: null, overview: { offsetHeight: 65 }, windowBar: { offsetHeight: 57 } });
+assert('the measurement stands down when the band is not on the page',
+  missing.error === null && Object.keys(missing.written).length === 0);
+
+// A band that is never bound measures nothing: the function stands down, every offset falls back to
+// its written-down constant, and the page looks the way it looked before this change. The stub
+// below cannot catch that, because a stub hands the function the elements it asked for.
+function boundId(prop) {
+  const m = new RegExp("dom\\." + prop + "\\s*=\\s*document\\.getElementById\\('([^']+)'\\)").exec(html);
+  return m ? m[1] : null;
+}
+const bands = ['filterSticky', 'overview', 'windowBar'].map(boundId);
+assert('every band the measurement reads is bound to an element the markup ships',
+  bands.every((id) => !!id && html.includes('id="' + id + '"')));
+
+// The measurement has to run at an exit every filter passes through. Nine places change what the
+// table shows by calling renderLedger() directly — the type axis among them — and only some of
+// those go on to call render(). Measuring at the end of render() covered the filters that do and
+// silently missed the ones that don't, so the invariant lived in a convention rather than in the
+// structure. renderLedger() is the one exit all of them share.
+const renderLedgerSrc = functionSource('renderLedger');
+const ledgerBody = renderLedgerSrc
+  ? renderLedgerSrc.slice(renderLedgerSrc.indexOf('{') + 1, renderLedgerSrc.lastIndexOf('}'))
+  : '';
+const ledgerCalls = ledgerBody.match(/syncStickyOffsets\(\);/g) ?? [];
+// The exit ends in a batch loop, so "the measurement is the last statement" is a claim about the
+// path that finishes the table, not about where the text sits. buildStep() is that path: the last
+// batch runs it synchronously and the earlier ones run it from a frame callback, and either way it
+// falls out at the same place. What must hold is that nothing which moves the page — the anchor
+// restore above it — runs after the measurement, because the strips would then be pinned against
+// a scroll position the reader is no longer at. mutate-sticky.py moves the call up past
+// restoreRowAnchor() to break exactly that.
+const buildStepSrc = functionSource('buildStep');
+const stepBody = buildStepSrc
+  ? buildStepSrc.slice(buildStepSrc.indexOf('{') + 1, buildStepSrc.lastIndexOf('}'))
+  : '';
+const stepLast = stepBody.lastIndexOf('syncStickyOffsets();');
+assert('the heights are measured at the one exit every filter passes through',
+  ledgerCalls.length === 1 && stepLast >= 0
+  && stepBody.slice(stepLast + 'syncStickyOffsets();'.length).trim() === ''
+  && /buildStep\(\);/.test(ledgerBody));
+
+// One writer, one call site. A second call in render() would not be wrong on its own, but it is
+// the shape that let the eight writers nobody was thinking about go unmeasured.
+const renderSrc = functionSource('render');
+const renderBody = renderSrc ? renderSrc.slice(renderSrc.indexOf('{') + 1, renderSrc.lastIndexOf('}')) : '';
+assert('the measurement has exactly one call site on the render path',
+  !/syncStickyOffsets\(\);/.test(renderBody));
+
+// The 异常 note is written by syncAnomalyMode, and it is the note that adds a line to the band.
+// Measuring at the renderLedger exit is only correct because that note is already written by then:
+// if the call moved above syncAnomalyMode the band would be pinned at its height before the reader
+// changed anything, which is the bug the measured offsets replaced.
+assert('the band note is written before the heights are measured',
+  renderBody.indexOf('syncAnomalyMode(') >= 0
+  && renderBody.indexOf('syncAnomalyMode(') < renderBody.indexOf('renderLedger();'));
+
+// Nothing re-measured when the window changed shape. On a session whose payload has stopped growing
+// every poll is a 304 and render() is never called, so a resize that wrapped the type row left the
+// strips pinned at the old width indefinitely.
+const resizeHook = /window\.addEventListener\(\s*'resize'\s*,\s*(\w+)\s*\)/.exec(html);
+assert('a window resize re-measures the band', !!resizeHook);
+const scheduleSrc = resizeHook ? functionSource(resizeHook[1]) : null;
+assert('a resize reaches the measurement it was registered for',
+  !!scheduleSrc && /syncStickyOffsets\(\);/.test(scheduleSrc));
+
+// Each measurement reads three offsetHeights, which forces layout. A window drag fires `resize`
+// continuously, so the handler coalesces into one frame — otherwise a drag becomes a layout thrash.
+assert('a resize measures once per frame, not once per event',
+  !!scheduleSrc && /requestAnimationFrame/.test(scheduleSrc)
+  && /stickyFrame\s*!==\s*null/.test(scheduleSrc));
+
+console.log('[sticky] ' + pass + ' passed, ' + failures.length + ' failed');
+if (orphan.length) console.log('  read but never written: ' + orphan.join(', '));
+if (dead.length) console.log('  written but never read: ' + dead.join(', '));
+if (run.error) console.log('  measurement error: ' + run.error);
+if (failures.length) {
+  console.log('FAILURES:\n - ' + failures.join('\n - '));
+  process.exit(1);
+}
+console.log('[sticky] OK');
diff --git a/plugins/avatasia/mmc-trajectory/tests/verify-time-range.mjs b/plugins/avatasia/mmc-trajectory/tests/verify-time-range.mjs
new file mode 100644
index 0000000..cd35eb3
--- /dev/null
+++ b/plugins/avatasia/mmc-trajectory/tests/verify-time-range.mjs
@@ -0,0 +1,523 @@
+// Evidence for the time-range filter.
+//
+// Two things here are load-bearing and neither can be checked with a fixture:
+//
+// 1. A range wide enough to cover the whole session must reproduce `payload.stats` field for
+//    field. The range KPI is re-derived in the page from `state.flat` instead of being asked
+//    for, so a headline and the table under it cannot be computed from two different sets. That
+//    is only safe if the re-derivation agrees with the server where both are defined.
+// 2. A wall-clock range must select exactly the records whose `timestamp` falls in that window,
+//    counted straight off the payload. The control is a `datetime-local`, but the ledger filters
+//    on `relativeMs`, so every bound is a subtraction — and a subtraction that is off by the
+//    machine's distance from Greenwich still looks like a working filter.
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import vm from 'node:vm';
+
+const HERE = fileURLToPath(new URL('.', import.meta.url));
+const HTML = join(HERE, '..', 'miniapp', 'client', 'index.html');
+
+// NOT part of `run.mjs`, and deliberately so. Its assertions are calibrated against a full
+// multi-generation session -- `stats.messages > 1000`, and a checkpoint that sits inside a turn
+// rather than being one -- and the committed fixture is a single-file session of a few dozen
+// rows. Reproducing those numbers faithfully would mean committing a multi-megabyte payload.
+// Relaxing them to fit would be worse: the point of this file is the timezone arithmetic, which
+// a small window would stop exercising.
+//
+// Run it against a booted service instead:
+//   node tests/verify-time-range.mjs <port>
+const port = process.argv[2];
+if (!port) {
+  console.error('usage: node verify-time-range.mjs <port>   (needs a running Mini App)');
+  process.exit(2);
+}
+const BASE_URL = 'http://127.0.0.1:' + port;
+
+const html = readFileSync(HTML, 'utf8');
+
+/* ---------- helpers ---------- */
+let pass = 0;
+const failures = [];
+function check(name, actual, expected) {
+  const ok = JSON.stringify(actual) === JSON.stringify(expected);
+  if (ok) pass += 1;
+  else failures.push(name + ': got ' + JSON.stringify(actual) + ', want ' + JSON.stringify(expected));
+}
+function assert(name, cond) {
+  if (cond) pass += 1;
+  else failures.push(name);
+}
+function fnSource(sig) {
+  const start = html.indexOf(sig);
+  if (start < 0) return '';
+  let i = html.indexOf('{', start);
+  let depth = 0;
+  for (let j = i; j < html.length; j += 1) {
+    if (html[j] === '{') depth += 1;
+    else if (html[j] === '}') {
+      depth -= 1;
+      if (depth === 0) return html.slice(start, j + 1);
+    }
+  }
+  return '';
+}
+
+/* ---------- 1) pure helpers, straight out of the PURE block ---------- */
+const rawSlice = html.split('PURE:START')[1].split('PURE:END')[0];
+let block = rawSlice.slice(rawSlice.indexOf('*/') + 2);
+const lastCloser = block.lastIndexOf('*/');
+const dangling = block.indexOf('/*', lastCloser === -1 ? 0 : lastCloser + 2);
+if (dangling >= 0) block = block.slice(0, dangling);
+const pure = { console };
+vm.createContext(pure);
+vm.runInContext(block, pure);
+
+/* The offsets this page measures from, chosen to straddle a midnight: this session began
+   2026-10-10 11:45:31 local, and the checks below sit either side of 2026-10-11 00:00. */
+const CLOCK = new Date(2026, 9, 10, 11, 45, 31).getTime();
+const MIDNIGHT = new Date(2026, 9, 11, 0, 0, 0).getTime();
+const NOW = new Date(2026, 9, 11, 11, 30, 0).getTime();
+
+/* parsing: empty is null, unreadable is NaN, and the two must never be confused */
+check('parse empty', pure.parseRangeBound('', CLOCK), null);
+check('parse spaces', pure.parseRangeBound('   ', CLOCK), null);
+check('parse null', pure.parseRangeBound(null, CLOCK), null);
+check('parse at session start', pure.parseRangeBound('2026-10-10T11:45', CLOCK), -31000);
+check('parse with seconds', pure.parseRangeBound('2026-10-10T11:45:31', CLOCK), 0);
+check('parse across midnight', pure.parseRangeBound('2026-10-11T00:00', CLOCK), 44069000);
+check('parse a space instead of T', pure.parseRangeBound('2026-10-11 00:00', CLOCK), NaN);
+
+assert('junk is refused', Number.isNaN(pure.parseRangeBound('abc', CLOCK)));
+assert('a date with no time is refused', Number.isNaN(pure.parseRangeBound('2026-10-11', CLOCK)));
+assert('a lone time is refused', Number.isNaN(pure.parseRangeBound('11:45', CLOCK)));
+assert('an impossible hour is refused', Number.isNaN(pure.parseRangeBound('2026-10-11T25:00', CLOCK)));
+assert('hour 24 is refused, not rolled into the next day',
+  Number.isNaN(pure.parseRangeBound('2026-10-11T24:00', CLOCK)));
+assert('an impossible month is refused', Number.isNaN(pure.parseRangeBound('2026-13-01T00:00', CLOCK)));
+// Date would roll 2026-02-30 forward into March and hand back a range nobody asked for.
+assert('a day that does not exist is refused', Number.isNaN(pure.parseRangeBound('2026-02-30T00:00', CLOCK)));
+assert('leap day is accepted', pure.parseRangeBound('2028-02-29T00:00', CLOCK) > 0);
+assert('minute 60 is refused, not rolled', Number.isNaN(pure.parseRangeBound('2026-10-11T12:60', CLOCK)));
+assert('a trailing Z is refused, since the control never sends one',
+  Number.isNaN(pure.parseRangeBound('2026-10-11T00:00Z', CLOCK)));
+// A bound before the session began stays negative: it is true, and clamping it would hide a
+// window the reader chose that this session cannot answer for.
+assert('a bound before session start is negative', pure.parseRangeBound('2026-10-09T00:00', CLOCK) < 0);
+// No session to measure from is the one way a bound fails silently, so it must not be silent.
+assert('a bound with no session start is refused', Number.isNaN(pure.parseRangeBound('2026-10-11T00:00', null)));
+
+/* formatting, and a round trip so a resolved value can be typed back in */
+check('format a bound', pure.formatRangeInput(MIDNIGHT), '2026-10-11T00:00');
+check('format the session start', pure.formatRangeInput(CLOCK), '2026-10-10T11:45');
+check('format null', pure.formatRangeInput(null), '');
+check('format NaN', pure.formatRangeInput(NaN), '');
+for (const ms of [0, 1000, MIDNIGHT, MIDNIGHT + 3600000, NOW]) {
+  const round = pure.parseRangeBound(pure.formatRangeInput(ms), CLOCK);
+  // The control has minute resolution, so a value floors to the minute on the way back.
+  assert('round trip ' + ms, Math.abs(round - (ms - CLOCK)) < 60000);
+}
+
+/* local midnights, and the day before, stepped through the calendar */
+check('local midnight', pure.startOfLocalDay(NOW), MIDNIGHT);
+check('the day before', pure.previousLocalMidnight(NOW), new Date(2026, 9, 10, 0, 0, 0, 0).getTime());
+check('local midnight of nothing', pure.startOfLocalDay(NaN), null);
+check('previous midnight of nothing', pure.previousLocalMidnight(NaN), null);
+
+/* the quick picks — the four buttons, resolved without touching the DOM */
+const q15 = pure.quickRange('15m', CLOCK, NOW);
+assert('15m ends now', q15.to === NOW - CLOCK);
+assert('15m starts fifteen minutes earlier', q15.from === Math.max(q15.to - 15 * 60000, 0));
+const q1h = pure.quickRange('1h', CLOCK, NOW);
+assert('1h ends now', q1h.to === NOW - CLOCK);
+assert('1h starts an hour earlier', q1h.from === Math.max(q1h.to - 3600000, 0));
+const qToday = pure.quickRange('today', CLOCK, NOW);
+assert('today ends now', qToday.to === NOW - CLOCK);
+assert('today starts at local midnight', CLOCK + qToday.from === MIDNIGHT);
+// Yesterday is the interesting one: this session began at 11:45 on the 10th, so yesterday's
+// window opens before the session exists. Clamping says "from the beginning", and the hint
+// then explains that the window is empty — which is the truth. Not clamping would report a
+// negative range the reader never asked for.
+const qYest = pure.quickRange('yesterday', CLOCK, NOW);
+assert('yesterday ends at midnight', qYest.to === MIDNIGHT - CLOCK);
+assert('yesterday is clamped to the start of the session', qYest.from === 0);
+// And on a session old enough to cover it, the clamp must not fire.
+const OLD = new Date(2026, 8, 1, 9, 0, 0).getTime();
+const qOld = pure.quickRange('yesterday', OLD, NOW);
+assert('yesterday on a session that covers it is not clamped',
+  OLD + qOld.from === new Date(2026, 9, 10, 0, 0, 0, 0).getTime());
+check('an unknown pick is refused', pure.quickRange('lastweek', CLOCK, NOW), null);
+check('a pick with no session start is refused', pure.quickRange('today', null, NOW), null);
+check('a pick with no now is refused', pure.quickRange('today', CLOCK, NaN), null);
+
+/* the comparison, on its own terms */
+const rec = (ms) => ({ relativeMs: ms });
+assert('no range keeps everything', pure.recordInRange(rec(999), null, null) === true);
+assert('no range keeps an undated record', pure.recordInRange({}, null, null) === true);
+assert('from only, before', pure.recordInRange(rec(10), 100, null) === false);
+assert('from only, after', pure.recordInRange(rec(150), 100, null) === true);
+assert('to only, before', pure.recordInRange(rec(10), null, 100) === true);
+assert('to only, after', pure.recordInRange(rec(150), null, 100) === false);
+assert('from is inclusive', pure.recordInRange(rec(100), 100, null) === true);
+assert('to is inclusive', pure.recordInRange(rec(100), null, 100) === true);
+// An undated record cannot be placed on this clock. Keeping it would put a row on screen whose
+// timestamp says nothing about whether it belongs; the brush already drops these.
+assert('an undated record leaves a set range', pure.recordInRange({}, 0, 1000) === false);
+
+check('label both open', pure.rangeLabel(null, null, CLOCK), '');
+check('label from only', pure.rangeLabel(44069000, null, CLOCK), '2026-10-11 00:00:00 – 现在');
+check('label to only', pure.rangeLabel(null, 44069000, CLOCK), '开始 – 2026-10-11 00:00:00');
+check('label both ends', pure.rangeLabel(44069000, 45269000, CLOCK),
+  '2026-10-11 00:00:00 – 2026-10-11 00:20:00');
+// A bound before the session prints the date it names, not a negative offset — the one place
+// the sign would have carried the message, and now the date does.
+check('label a bound before the session', pure.rangeLabel(-42331000, 44069000, CLOCK),
+  '2026-10-10 00:00:00 – 2026-10-11 00:00:00');
+check('label without a session to measure from', pure.rangeLabel(0, 1, null), '');
+
+/* ---------- 2) the hint, run rather than read ----------
+   An unreadable picker is never written into state — that is the rule the filter rests on — so
+   a hint keyed on `state.rangeTo` can never report it. Checked by running it, because a regex
+   over the source cannot tell a live branch from a dead one: neutering the condition leaves
+   every identifier a regex looks for exactly where it was. */
+const hint = fnSource('function updateRangeHint()');
+assert('the hint reads the pickers, not the filter',
+  /parseRangeBound\(state\.rangeFromText/.test(hint) && /parseRangeBound\(state\.rangeToText/.test(hint));
+assert('the unreadable branch names the range still in force', /hasTimeRange\(\) \? '\uff08'/.test(hint));
+{
+  const say = (statePatch, extra) => {
+    const note = { textContent: '', classes: [], classList: { add: (c) => note.classes.push(c), remove: () => {} } };
+    const ctx = {
+      console,
+      dom: { rangeHint: note },
+      state: Object.assign({ payload: null, flat: [], rangeFrom: null, rangeTo: null, rangeCutoff: null }, statePatch)
+    };
+    vm.createContext(ctx);
+    vm.runInContext('var isCount = ' + pure.isCount.toString() + ';', ctx);
+    for (const name of ['pad2', 'formatInt', 'formatClock', 'parseRangeBound', 'formatRangeInput',
+      'startOfLocalDay', 'previousLocalMidnight', 'quickRange', 'rangeLabel', 'recordsPastCutoff',
+      'latestRecordIndex', 'latestRecordTimestamp', 'hasTimeRange', 'inTimeRange', 'recordInRange',
+      'rangeHasRecords', 'sessionStartedAt', 'timeRangeLabel', 'updateRangeHint']) {
+      vm.runInContext(fnSource('function ' + name + '('), ctx);
+    }
+    vm.runInContext('function kpiStats() { return ' + (extra || 'null') + '; }', ctx);
+    ctx.updateRangeHint();
+    return note;
+  };
+  const withSession = (patch) => Object.assign({ payload: { session: { startedAt: CLOCK } } }, patch);
+
+  const live = withSession({ rangeFrom: 44069000, rangeTo: 2700000,
+    rangeFromText: '2026-10-11T00:00', rangeToText: 'abc' });
+  assert('an unreadable box says so', say(live).textContent.indexOf('这一刻无法识别') === 0);
+  assert('and names the range still in force', say(live).textContent.indexOf('2026-10-11 00:00:00') >= 0);
+
+  assert('a reversed range says so',
+    say(withSession({ rangeFrom: 44069000, rangeTo: 729000,
+      rangeFromText: '2026-10-11T00:00', rangeToText: '2026-10-11T00:01' }))
+      .textContent === '起点晚于终点，没有记录落在这段时间里。');
+
+  assert('no range is the plain instruction',
+    say(withSession({ rangeFromText: '', rangeToText: '' })).textContent.indexOf('留空 = 不限') === 0);
+
+  // The window is well formed and the session has nothing in it. This is what 昨天 does on a
+  // session that began this morning, and the reader is owed where the session actually starts.
+  const empty = say(withSession({ rangeFrom: 0, rangeTo: 44069000,
+    rangeFromText: '2026-10-10T00:00', rangeToText: '2026-10-11T00:00' }));
+  assert('an empty window says there is nothing in it',
+    empty.textContent.indexOf('这段时间里没有记录') === 0);
+  assert('and names where the session starts', empty.textContent.indexOf('2026-10-10 11:45:31') >= 0);
+
+  const set = say(withSession({ rangeFrom: 44069000, rangeTo: 45269000,
+    rangeFromText: '2026-10-11T00:00', rangeToText: '2026-10-11T00:20',
+    flat: [{ record: { index: 1, relativeMs: 44500000 } }] }), '{ messages: 3 }');
+  assert('a live range reports itself', set.textContent.indexOf('区间 2026-10-11 00:00:00 – 2026-10-11 00:20:00') === 0);
+  assert('a live range says the KPI follows it', set.textContent.indexOf('关键指标已按此区间统计') >= 0);
+  assert('a live range says it is fixed', set.textContent.indexOf('已固定在设定时的样子') >= 0);
+  assert('and counts the messages inside it', set.textContent.indexOf('3 条消息') >= 0);
+
+  // A session whose records carry no timestamp has no origin to convert against.
+  const noBase = say({ rangeFrom: 44069000, rangeTo: null, rangeFromText: '2026-10-11T00:00', rangeToText: '' });
+  assert('a session with no timestamps says so',
+    noBase.textContent.indexOf('没有时间戳') >= 0);
+  assert('and does not blame the value', noBase.textContent.indexOf('无法识别') < 0);
+}
+
+/* ---------- 3) against the live session ---------- */
+const payload = await (await fetch(BASE_URL + '/api/trajectory')).json();
+
+const scoped = { console, state: { payload, flat: [], rangeFrom: null, rangeTo: null, rangeCutoff: null } };
+scoped.state.flat = payload.turns.flatMap((turn) => turn.records.map((record) => ({ turn, record })));
+vm.createContext(scoped);
+for (const name of ['recordInRange', 'hasTimeRange', 'inTimeRange', 'scopedStats', 'pad2', 'formatClock',
+  'parseRangeBound', 'formatRangeInput', 'startOfLocalDay', 'previousLocalMidnight', 'quickRange',
+  'rangeLabel', 'sessionStartedAt', 'timeRangeLabel']) {
+  const src = fnSource('function ' + name + '(');
+  if (!src) throw new Error('could not extract ' + name);
+  vm.runInContext(src, scoped);
+}
+// The pure block's own isCount, so the comparison inside scopedStats is the real one.
+vm.runInContext('var isCount = ' + pure.isCount.toString() + ';', scoped);
+
+let mins = Infinity;
+let maxs = -Infinity;
+for (const entry of scoped.state.flat) {
+  if (Number.isFinite(entry.record.relativeMs)) {
+    if (entry.record.relativeMs < mins) mins = entry.record.relativeMs;
+    if (entry.record.relativeMs > maxs) maxs = entry.record.relativeMs;
+  }
+}
+
+// A range covering the whole session must land on the server's own numbers. Anything else is a
+// definitional difference, and every scoped number below it inherits that difference.
+scoped.state.rangeFrom = mins;
+scoped.state.rangeTo = maxs;
+const whole = scoped.scopedStats();
+
+const FIELDS = [
+  'messages', 'userMessages', 'toolCalls', 'toolResults', 'thinkingBlocks', 'errors',
+  'compactions', 'turnsWithPrompt', 'continuationTurns', 'qaTurns', 'openTurns',
+  'turnsWithoutPrompt', 'compactionTurns', 'durationMs'
+];
+for (const field of FIELDS) {
+  check('whole-session ' + field, whole[field], payload.stats[field]);
+}
+for (const field of ['input', 'output', 'cacheRead', 'cacheWrite', 'totalTokens']) {
+  check('whole-session tokens.' + field, whole.tokens[field], payload.stats.tokens[field]);
+}
+
+// The one field that must NOT be re-scoped: 「全程 N」 beside the range is the comparison the
+// reader wants, and re-scoping it would leave the note with nothing to say.
+check('messagesAll stays whole-session', whole.messagesAll, payload.stats.messagesAll);
+assert('the fixture is big enough to be worth checking', payload.stats.messages > 1000);
+assert('compactionTurns is 0 after the turn fix, as it must be', payload.stats.compactionTurns === 0);
+
+// A narrower range must produce strictly fewer messages, or the filter is not filtering.
+const halfEnd = Math.floor((mins + maxs) / 2);
+scoped.state.rangeFrom = mins;
+scoped.state.rangeTo = halfEnd;
+const half = scoped.scopedStats();
+assert('a narrower range holds fewer messages', half.messages < whole.messages);
+assert('a narrower range holds fewer tool calls', half.toolCalls < whole.toolCalls);
+assert('a narrower range still holds something', half.messages > 0);
+
+// And it must equal a count taken straight from the rows, which is the property that makes
+// the headline and the table one statement rather than two.
+const kept = scoped.state.flat.filter(
+  (entry) => Number.isFinite(entry.record.relativeMs)
+    && entry.record.relativeMs >= mins
+    && entry.record.relativeMs <= halfEnd
+);
+check('half-range messages == distinct ids of the rows kept',
+  half.messages, new Set(kept.map((e) => e.record.id)).size);
+
+// Duration has to be the span of the rows kept, not the span of the session. Quoting the
+// session's own number here would have passed the whole-range comparison above untouched.
+const keptTimes = kept.map((e) => e.record.relativeMs);
+check('half-range duration == span of the rows kept',
+  half.durationMs, Math.max(...keptTimes) - Math.min(...keptTimes));
+
+/* ---------- 3b) a wall-clock range is the window it names ---------- */
+// The control is a `datetime-local`; the ledger filters on `relativeMs`. Every bound is
+// therefore a subtraction, and a subtraction that is off by this machine's distance from
+// Greenwich still looks like a working filter — so it is checked against timestamps read
+// straight off the payload, over a window that crosses midnight.
+const START = payload.session.startedAt;
+assert('the payload carries a session start', Number.isFinite(START) && START > 0);
+{
+  const wallFrom = new Date(2026, 9, 10, 23, 50, 0).getTime();
+  const wallTo = new Date(2026, 9, 11, 0, 20, 0).getTime();
+  const from = pure.parseRangeBound('2026-10-10T23:50', START);
+  const to = pure.parseRangeBound('2026-10-11T00:20', START);
+  check('a pair of bounds across midnight converts to the window it names',
+    [from, to], [wallFrom - START, wallTo - START]);
+
+  const byDate = scoped.state.flat.filter((e) => pure.recordInRange(e.record, from, to));
+  const byClock = scoped.state.flat.filter(
+    (e) => Number.isFinite(e.record.timestamp) && e.record.timestamp >= wallFrom && e.record.timestamp <= wallTo);
+  check('a date range selects exactly the records inside that wall-clock window',
+    byDate.length, byClock.length);
+  assert('the window has records in it, or the equality above proves nothing', byClock.length > 0);
+  assert('and it is a small slice of the session', byClock.length < scoped.state.flat.length / 10);
+
+  scoped.state.rangeFrom = from;
+  scoped.state.rangeTo = to;
+  scoped.state.rangeFromText = '2026-10-10T23:50';
+  scoped.state.rangeToText = '2026-10-11T00:20';
+  const stats = scoped.scopedStats();
+  check('the KPI over a date range equals the distinct ids of those rows',
+    stats.messages, new Set(byClock.map((e) => e.record.id)).size);
+  check('and the page-level label reads back as the wall clock it was typed as',
+    scoped.timeRangeLabel(), '2026-10-10 23:50:00 – 2026-10-11 00:20:00');
+
+  // And the same window, typed into the pickers as what the control actually sends.
+  check('the control round trips back to the same offsets',
+    [pure.parseRangeBound(pure.formatRangeInput(START + from), START),
+      pure.parseRangeBound(pure.formatRangeInput(START + to), START)],
+    [from, to]);
+}
+
+/* ---------- 4) one line, many records ---------- */
+// The session on disk happens to split every failing tool call into exactly one record, so
+// de-duplicating errors by id changes nothing here and a live check cannot tell a correct
+// de-dup from a missing one. The synthetic case is what actually pins the rule.
+{
+  const one = { turns: [{ index: 1, turnClass: 'none', closed: true, askedReader: false, records: [] }] };
+  const split = [
+    { turn: one.turns[0], record: { id: 'm1', kind: 'thinking', relativeMs: 0, isError: true, tokens: null } },
+    { turn: one.turns[0], record: { id: 'm1', kind: 'toolResult', relativeMs: 5, isError: true, tokens: null } }
+  ];
+  const synth = { console, state: { payload: { ...one, stats: {} }, flat: split, rangeFrom: 0, rangeTo: 100 } };
+  vm.createContext(synth);
+  vm.runInContext('var isCount = ' + pure.isCount.toString() + ';', synth);
+  for (const name of ['recordInRange', 'hasTimeRange', 'inTimeRange', 'scopedStats']) {
+    vm.runInContext(fnSource('function ' + name + '('), synth);
+  }
+  const out = synth.scopedStats();
+  check('a split line counts as one message', out.messages, 1);
+  check('a split failing line counts as one error', out.errors, 1);
+}
+
+/* ---------- 5) the range is a snapshot, not a subscription ---------- */
+// Measured in the browser before this existed: with 起点 set and 终点 left open, the session
+// grew by 11 records and 「已显示 588」 became 「已显示 599」 with nobody touching anything.
+// The cutoff is what stops that, so it gets checked directly.
+{
+  const snap = { console, state: { flat: [], rangeFrom: 0, rangeTo: null, rangeCutoff: null } };
+  vm.createContext(snap);
+  vm.runInContext('var isCount = ' + pure.isCount.toString() + ';', snap);
+  for (const name of ['recordInRange', 'hasTimeRange', 'inTimeRange', 'latestRecordIndex',
+    'latestRecordTimestamp', 'recordsPastCutoff', 'rangeHasRecords']) {
+    const src = fnSource('function ' + name + '(');
+    if (!src) throw new Error('could not extract ' + name);
+    vm.runInContext(src, snap);
+  }
+  snap.state.flat = [1, 2, 3, 4].map((i) => ({ record: { index: i, relativeMs: i * 1000, timestamp: CLOCK + i * 1000 } }));
+
+  check('latest record index', snap.latestRecordIndex(), 4);
+  check('latest record timestamp', snap.latestRecordTimestamp(), CLOCK + 4000);
+
+  assert('without a cutoff the range accepts the newest record',
+    snap.inTimeRange({ index: 4, relativeMs: 4000 }) === true);
+
+  snap.state.rangeCutoff = 2;
+  check('records behind the cutoff', snap.recordsPastCutoff(), 2);
+  assert('a record inside the range but past the cutoff is held back',
+    snap.inTimeRange({ index: 3, relativeMs: 3000 }) === false);
+  assert('a record inside both the range and the cutoff still shows',
+    snap.inTimeRange({ index: 2, relativeMs: 2000 }) === true);
+  // The cutoff is a record bound, not a clock. Judging it by time instead would re-admit a
+  // record that arrived late but was stamped early — the fixture makes the two readings
+  // disagree, so this is the assertion that tells them apart.
+  assert('the cutoff judges by index, not by clock',
+    snap.inTimeRange({ index: 3, relativeMs: 1 }) === false);
+
+  assert('the range holds something', snap.rangeHasRecords() === true);
+  snap.state.rangeFrom = 90000;
+  snap.state.rangeTo = 200000;
+  assert('and a range that holds nothing says so', snap.rangeHasRecords() === false);
+}
+
+/* ---------- 6) the controls on screen ---------- */
+assert('the picker is a calendar, not a text box',
+  /<input type="datetime-local" id="range-from"/.test(html) && /<input type="datetime-local" id="range-to"/.test(html));
+assert('no text input survived on the range row', !/<input type="text" id="range-/.test(html));
+assert('the clear button exists', /id="range-clear"/.test(html));
+assert('the clear button starts hidden', /id="range-clear"[^>]*hidden/.test(html));
+assert('the refresh button exists', /id="range-refresh"/.test(html));
+assert('the refresh button starts hidden', /id="range-refresh"[^>]*hidden/.test(html));
+
+const QUICKS = ['15m', '1h', 'today', 'yesterday'];
+const quickSrc = html.match(/data-range-quick="[^"]+"/g) || [];
+check('the four quick picks are on the page', quickSrc.map((s) => s.slice('data-range-quick="'.length, -1)).sort(), [...QUICKS].sort());
+// Every one of them has to resolve, or the button silently does nothing.
+for (const kind of QUICKS) {
+  assert('the ' + kind + ' pick resolves', pure.quickRange(kind, CLOCK, NOW) !== null);
+}
+const bindSrc = fnSource('function applyQuickRange(kind)');
+assert('a quick pick goes through the same filter', /applyTimeRange\(\);/.test(bindSrc));
+assert('a quick pick writes the pickers, so the reader can see and adjust what it chose',
+  /dom\.rangeFrom\.value = state\.rangeFromText;/.test(bindSrc)
+  && /dom\.rangeTo\.value = state\.rangeToText;/.test(bindSrc));
+const listeners = html.slice(html.indexOf("dom.rangeFrom.addEventListener('change'"));
+assert('the pickers commit on change, not on every keystroke',
+  listeners.indexOf("dom.rangeTo.addEventListener('change'") > 0);
+const boundsSrc = fnSource('function syncRangeBounds()');
+assert('the pickers are bounded by the span the session covers',
+  /dom\.rangeFrom\.min = low;/.test(boundsSrc) && /dom\.rangeTo\.max = high;/.test(boundsSrc));
+const renderSrc = fnSource('function render()');
+assert('the refresh button is re-decided on every render', /syncRangeButtons\(\)/.test(renderSrc));
+assert('the bounds are re-decided on every render', /syncRangeBounds\(\)/.test(renderSrc));
+
+// Not `hidden` on "nothing waiting": that count changes every poll, and the button appearing
+// and disappearing moved 清空区间 sideways so clicks on it landed on nothing.
+const syncButtons = fnSource('function syncRangeButtons()');
+assert('the refresh button keeps its box when there is nothing to bring in',
+  /dom\.rangeRefresh\.hidden = !isSet;/.test(syncButtons)
+  && /dom\.rangeRefresh\.disabled = !isSet \|\| recordsPastCutoff\(\) === 0;/.test(syncButtons));
+const applyRange2 = fnSource('function applyTimeRange()');
+assert('applying a range re-cuts the snapshot', /state\.rangeCutoff = latestRecordIndex\(\)/.test(applyRange2));
+const clearRange2 = fnSource('function clearTimeRange()');
+assert('clearing drops the snapshot', /state\.rangeCutoff = null;/.test(clearRange2));
+
+// A range used to force 「全部」 so that the newest-200 window could not hide the start of
+// it. Measured on a range covering the whole session — 全部 rendered ~11,000 rows, the document
+// reached 414,000px and one query took 19s.
+// \b matters: resetWindowMode contains the substring setWindowMode, so without it the helper it
+// is supposed to be calling would read as a direct mode change.
+assert('a range never forces 全部 on screen', !/\bsetWindowMode\(/.test(applyRange2));
+assert('a range resets the window like every other filter', /\bresetWindowMode\(\);/.test(applyRange2));
+
+// The range has to reach every predicate that decides what is drawn. The ledger and the
+// turn-grouping strip used to keep a test each and drifted apart once already; they now share
+// one predicate, and these pin both the predicate and the two callers reaching for it.
+const baseSrc = fnSource('function passesBaseFilter(');
+assert('the shared ledger predicate applies the range',
+  /if \(!inTimeRange\(record\)\) return false;/.test(baseSrc));
+assert('visibleEntries filters through the shared predicate',
+  /if \(!passesBaseFilter\(entry\.record, selection\)\) continue;/.test(fnSource('function visibleEntries()')));
+assert('spanPassesFilter applies the range',
+  /if \(!inTimeRange\(record\)\) return false;/.test(fnSource('function spanPassesFilter(')));
+
+// A range is a snapshot, so the window must stop following the tail on its own. Without this
+// the newest-200 window would drag the view forward every poll under a fixed filter.
+assert('a range stops the window following the tail',
+  /if \(hasTimeRange\(\)\) return state\.limit;/.test(fnSource('function rePinWindow()')));
+
+// The KPI re-derivation is only legitimate because with no range it is the server's own number,
+// verbatim. Re-scoping an unscoped view would report a different headline over the same table.
+assert('no range means the server numbers, untouched',
+  /if \(!hasTimeRange\(\)\) \{\s*\n\s*return state\.payload/.test(fnSource('function kpiStats()')));
+
+// Defaults and clearing: a range that opens set filters the session before anyone asks, and one
+// that survives 清除筛选 is a filter the reader cannot see and cannot turn off.
+const stateSrc = fnSource('var state = {');
+assert('the range opens unset', /rangeFrom: null,\s*\n\s*rangeTo: null,/.test(stateSrc));
+// Order, not adjacency. 清除筛选 grew a line when 异常 became a filter of its own, and the old
+// two-line regex failed on that instead of on anything wrong — it had frozen the shape of the
+// function rather than what the function has to do. What matters is that both are cleared and
+// that the query goes before the range, so the ledger never re-renders once with neither.
+const clearSrc = fnSource('function clearFilters()');
+const queryAt = clearSrc.indexOf("state.query = '';");
+const rangeAt = clearSrc.indexOf('clearTimeRange();');
+assert('清除筛选 also drops the range', queryAt >= 0 && rangeAt > queryAt);
+
+// A picker the page could not read must not reach the filter. `NaN` fails the `isCount` test
+// behind `hasTimeRange`, so assigning it would switch the whole range off mid-edit and hand back
+// the entire session — the one failure that looks like the filter simply did nothing.
+assert('an unreadable box is not assigned',
+  /if \(!isNaN\(from\)\) state\.rangeFrom = from;/.test(applyRange2)
+  && /if \(!isNaN\(to\)\) state\.rangeTo = to;/.test(applyRange2));
+
+/* ---------- report ---------- */
+console.log('[1] parse / format / compare: ' + pass + ' assertions, ' + failures.length + ' failed');
+console.log('    fixture: ' + payload.stats.messages + ' messages, ' + scoped.state.flat.length + ' records, '
+  + payload.turns.length + ' turns, span ' + maxs + ' ms');
+// Machine-readable, so the mutation runner can require the *named* guard to fire instead of
+// matching on a substring that any nearby assertion can satisfy by accident. Assertion names
+// must not contain a colon: this splits on the first one to strip the ": got …" suffix.
+console.log('FAILED_NAMES\t' + JSON.stringify(failures.map((f) => f.split(':')[0])));
+if (failures.length) {
+  console.log('FAILURES:\n - ' + failures.join('\n - '));
+  process.exit(1);
+}
+console.log('OK  (a whole-session range reproduces payload.stats field for field)');
diff --git a/plugins/avatasia/mmc-trajectory/tests/verify-window-widen.mjs b/plugins/avatasia/mmc-trajectory/tests/verify-window-widen.mjs
new file mode 100644
index 0000000..e5abc6e
--- /dev/null
+++ b/plugins/avatasia/mmc-trajectory/tests/verify-window-widen.mjs
@@ -0,0 +1,91 @@
+// Does 向上加载更早的 N 条 actually widen the window, and does a poll keep it widened?
+//
+// The bug this checks: rePinWindow reset state.limit to PAGE_STEP on every changed poll, so
+// the button's `limit += PAGE_STEP` was undone within a second. It looked inert because this
+// session grows several records per poll, so "200 shown" and "400 shown" were both roughly
+// "200-ish" against a total moving in the same direction.
+//
+// Expected values are derived by hand from the constants, not from running the client.
+
+const PAGE_STEP = 200;
+
+// The shipped rePinWindow, transcribed. Kept literal so the probe fails if the rule changes.
+function rePinWindow(state) {
+  if (state.allRecords) return state.limit;
+  if (state.limit > PAGE_STEP) return state.limit;
+  state.limit = Math.min(PAGE_STEP, state.flatLength) || PAGE_STEP;
+  return state.limit;
+}
+
+function show(value) {
+  // JSON.stringify turns Infinity into null, which reads as a failure when it is the answer.
+  return value === Infinity ? 'Infinity' : JSON.stringify(value);
+}
+
+function check(name, got, want) {
+  const ok = Object.is(got, want) || JSON.stringify(got) === JSON.stringify(want);
+  console.log((ok ? 'ok   ' : 'FAIL ') + name + ': got ' + show(got) + (ok ? '' : ', want ' + show(want)));
+  return ok;
+}
+
+let all = true;
+
+// A reader who just narrowed is at exactly PAGE_STEP, so the window follows the tail.
+{
+  const state = { allRecords: false, limit: 200, flatLength: 9893 };
+  all &= check('tail-following re-pins to one page', rePinWindow(state), 200);
+}
+
+// Press 向上加载 once: 200 -> 400.
+{
+  const state = { allRecords: false, limit: 400, flatLength: 9893 };
+  all &= check('a widened window survives a poll', rePinWindow(state), 400);
+}
+
+// Twice more, across several polls in a row.
+{
+  const state = { allRecords: false, limit: 400, flatLength: 9893 };
+  rePinWindow(state);
+  state.limit += 200;
+  all &= check('widening again after a poll', state.limit, 600);
+  rePinWindow(state);
+  all &= check('and it is still 600 after another poll', state.limit, 600);
+}
+
+// 全部 has no cap to undo.
+{
+  const state = { allRecords: true, limit: Infinity, flatLength: 9893 };
+  all &= check('全部 is never re-pinned', rePinWindow(state), Infinity);
+}
+
+// The tail-following case must still grow with a short session: fewer records than a page.
+{
+  const state = { allRecords: false, limit: 200, flatLength: 37 };
+  all &= check('a session shorter than a page shows all of it', rePinWindow(state), 37);
+}
+
+// A session shorter than a page, after the reader asked for 400: there is nothing left to load,
+// so the window covers everything there is and stays there.
+{
+  const state = { allRecords: false, limit: 400, flatLength: 37 };
+  all &= check('a widened window in a short session is untouched', rePinWindow(state), 400);
+}
+
+// The regression this fixes, stated as an explicit counter-example: the old rule reset 400.
+{
+  const old = (state) => {
+    if (state.allRecords) return state.limit;
+    state.limit = Math.min(PAGE_STEP, state.flatLength) || PAGE_STEP;
+    return state.limit;
+  };
+  const state = { allRecords: false, limit: 400, flatLength: 9893 };
+  const result = old(state);
+  const regressed = result === 200;
+  console.log((regressed ? 'ok   ' : 'FAIL ') +
+    'counter-example: the old rule really did undo 400 -> ' + result);
+  all &= regressed;
+}
+
+console.log();
+console.log(all ? 'ALL CHECKS PASSED' : 'FAILURES PRESENT');
+process.exit(all ? 0 : 1);