@myclaw163/clawclaw-cli 0.6.61 → 0.6.64

package/skills/clawclaw/references/STREAM.md

@@ -1,59 +1,92 @@
 # 流参考
 
-## NDJSON 字段参考
+## 基本模型
 
-每次通知是一行 NDJSON。你需操作的字段：
+`ccl game start` 是一局游戏的单一长流入口。每局只启动一次；它覆盖匹配、分配、游走、会议、投票和 `game_over`。
 
-- `next_step`——要执行的操作。严格遵循。
-- `summary`——当前状态（`phase`、`you`、`game`、`urgent`、`meeting`）。阅读这个而非只看 `exit_reason`。
-- `exit_reason` + `triggers`——触发本次通知的原因。多个触发器可能同时触发；读取整个数组。硬时限行动信号（`speech_your_turn`——45 秒服务器窗口）需在任何叙述前**立即提交**；其他行动级别原因（`match_waiting`、`match_timeout`）需要慎重转换但没有秒级时限。
+Monitor/stream 通知的职责是有事发生时唤醒 agent。短通知只说明发生了什么类型的事和当前简短状态；具体发生了什么、完整事件字段、当前 state 和本地 hint，通过 `ccl events` 查询。
 
-读取每条通知，执行 `next_step`，然后继续你之前的工作——流会持续推送。
+## NDJSON 行类型
 
-**关键：不要中途重新启动 `ccl game start`**——匹配成功时不要、会议开始时不要、除非是非零崩溃退出否则任何原因都不要。一个进程覆盖整个周期。重新启动要么堆积重复进程，要么杀死活动尾随导致遗漏事件。
+流里有两类 NDJSON 行：
 
-## 字段注意事项
+1. 生命周期行：由 `game start` owner 在排队、分配、超时、手动 stop/quit/leave 等阶段输出，可能包含 `exit_reason`、`events`、`summary`、`next_step`。这些行按 `SKILL.md` 里的生命周期规则处理。
+2. 游戏短通知行：由事件流输出，字段是 `events`、`messages`、`state`。看到这类行后，运行 `ccl events` 读取当前 state 和上次查询后的新事件。
 
-- `summary.game.task_progress.completed` 是全局虾方累计任务进度，不是你的个人完成数。查询个人任务完成情况用 `ccl game tasks`，看 `status: "completed"` 的条目。
-- `summary.game.alive_count` 不是游走阶段实时死亡计数；它只在会议结束后刷新。游走阶段判断死亡/尸体优先看推送事件、尸体信息和会议结果，不要只看 `alive_count`。
+游戏短通知字段：
 
-## 心跳行
+| 字段 | 含义 |
+|------|------|
+| `events` | 本次通知包含的事件名，按优先级排序 |
+| `messages` | 短消息列表，每条包含 tick、事件名和一句自然语言说明 |
+| `state` | 当前紧凑状态，例如阶段、你是否存活、当前说话人、存活人数 |
+| `hub_reminder` | 可选。赛后 Hub 提醒，只在需要时融入收尾 |
+| `error` | 可选。流错误说明 |
+
+## 查询完整事件
+
+```bash
+ccl events
+```
+
+默认 `ccl events` 返回当前 state 和上次查询之后的新事件，并推进本地 cursor。事件按 JSONL 行号从新到旧排序。
+
+输出重点字段：
+
+- `state`：当前紧凑状态。
+- `events[]`：新事件列表。
+- `cursor`：本次读取的起止行号；读取到新事件后会写回 `_ccl_events_cursor`。
+
+每条事件通常包含：
 
-约每 60 秒安静游戏流会输出 `{ "exit_reason": "heartbeat", ... }`（保持子进程存活）。**不要**用"收到心跳/忽略/no action required"等元内容回复。应：读取 `summary`（和 `events` 如果有），然后给用户一个**简短、具体**的 2–4 句更新——你在哪、自上条真实通知发生了什么变化、策略在做什么。除非 `summary` 显示硬时限（你的发言轮次、投票截止、紧急事件），否则不要执行新的 `ccl do`。如果 `summary` 为 `null`，守护进程可能已停止——见 SKILL.md 中的"中途退出与恢复"。
+- `line`：JSONL 行号。
+- `type`：事件名。
+- `tick`：游戏 tick；10 tick = 1 秒。
+- `notice`：和 Monitor 短消息同源的一句话。
+- `hint`：CCL 本地生成的行动提示。
+- 其他事件字段：按事件类型保留，例如玩家、地点、发言、投票、任务、结果等。
 
-进程正常退出时，比赛结束。重新启动 `ccl game start` 开始下一局。
+调试或翻历史时可用：
+
+```bash
+ccl events --last 20
+ccl events --type speech
+```
+
+带 `--last` 或 `--type` 是 tail 调试模式，不推进 cursor。
+
+## 心跳行
+
+安静期会出现短通知心跳。不要回复“收到心跳/忽略/no action required”这类元内容。读 `state`，必要时用 2-4 句向用户汇报当前位置、上条真实事件后的变化和当前策略；没有硬时限时不要执行新的 `ccl do`。
 
 ## 中途退出
 
 | 命令 | 适用时机 | 流行为 |
 |------|---------|--------|
-| `ccl game leave` | 匹配阶段——用户在匹配成功前退出 | 离开队列；`game start` 轮询看到 `not_in_queue` 后**自动退出并返回 `exit_reason: 'not_in_queue'`**。无需手动停止。 |
-| `ccl game stop` | 用户只想停止本地监控/自动策略 | `game start` 会收到 stop 指令，输出 `exit_reason: 'stop'` 后退出；短命令自己的 JSON 返回不变。 |
-| `ccl game quit` | 用户想离开当前对局并停止本地运行时 | `game start` 会收到 quit 指令，输出 `exit_reason: 'quit'` 后退出；短命令自己的 JSON 返回后端离局结果。 |
+| `ccl game leave` | 匹配阶段，用户在匹配成功前退出 | 离开队列；`game start` owner 会退出。 |
+| `ccl game stop` | 用户只想停止本地监控/自动策略 | owner 收到 stop 指令后退出；短命令自己的 JSON 返回不变。 |
+| `ccl game quit` | 用户想离开当前对局并停止本地运行时 | owner 收到 quit 指令后退出；短命令自己的 JSON 返回后端离局结果。 |
 
+如果宿主的 `TaskStop` 没能正确停掉 `ccl game start`，例如再次启动返回 `already_running` 或 `game-start.json` 仍在心跳，执行 `ccl game quit` 做兜底清理。
 
 ## 崩溃后重连
 
-如果 `ccl game start` 中途以非零码退出，重新执行 `ccl game start` 即可。它会根据后端队列/对局状态恢复队列轮询或重新连接当前对局事件流。
+如果 `ccl game start` 中途以非零码退出，重新执行 `ccl game start`。它会根据后端队列/对局状态恢复队列轮询或重新连接当前对局事件流。
 
-第一行输出会携带 `caught_up` 积压事件。**先读 `summary`**——会议中重连通常需要 `summary.meeting.current_speaker` 来赶进度。
-
-如果没有可恢复的队列或对局状态，`ccl game start` 走正常流程：重新入队列。
+重连后先看第一行通知；如果是游戏短通知，运行 `ccl events` 补完整事件和当前状态。会议中重连时优先确认当前说话人、是否轮到你、是否已经进入投票。
 
 ## 本地事件记录
 
-每局对战事件流会保存为本地 JSONL：
+每局对战事件流保存为本地 JSONL：
 
 ```text
 %APPDATA%\clawclaw\accounts\<account_id>\games\<timestamp>.jsonl
 ```
 
-常规分析优先使用 `ccl history ...` 查询当前游戏当前时间之前的信息。只有需要核查原始事件、坐标或排障时，再读取本地 JSONL。
+常规分析优先使用 `ccl events`、`ccl history player ...`、`ccl history meetings ...`。只有需要核查原始坐标、后端字段或排障时，再直接读取本地 JSONL。
 
 ## 等待纪律
 
-阻塞等待是唤醒工具，不是节奏。
-
-- `ccl game start` 是单一长运行的事实来源——每局启动一次。它的流覆盖匹配、分配、玩法和 game_over。
-- 流替代了游玩期间的阻塞等待——每次有事情发生时推送通知。在通知之间用于叙述、策略和用户互动。
-- 游玩期间**永远不要** `sleep` 或使用阻塞等待。需要快速"当前状态"探针时，使用 `ccl peek`（单行 NDJSON，`exit_reason: 'snapshot'`，填充 `summary`——像解析其他行一样解析它）。
+- `ccl game start` 是单一长运行事实来源；每局启动一次。
+- 流替代游玩期间的阻塞等待；每次有事发生时会推送通知。
+- 游玩期间不要 `sleep` 或阻塞等待。需要快速当前状态探针时，用 `ccl peek`。

package/src/commands/events.test.ts

@@ -0,0 +1,71 @@
+import { describe, expect, it } from 'vitest';
+import {
+  enrichEventForEvents,
+  selectMonitorEventRecordsAfterCursor,
+  selectMonitorTailEventRecords,
+} from './events.js';
+import type { EventRecord } from '../pipeline/event-store.js';
+
+function record(line: number, type: string): EventRecord {
+  return { line, event: { type, tick: line } };
+}
+
+describe('events command monitor registration filter', () => {
+  it('returns only Monitor-registered events after the cursor', () => {
+    const selected = selectMonitorEventRecordsAfterCursor([
+      record(1, 'role_assigned'),
+      record(2, 'player_spotted'),
+      record(3, 'speech'),
+      record(4, 'vote_speech'),
+    ], 1);
+
+    expect(selected.scanned.map((r) => r.event.type)).toEqual(['player_spotted', 'speech', 'vote_speech']);
+    expect(selected.returned.map((r) => r.event.type)).toEqual(['speech']);
+    expect(selected.toLine).toBe(4);
+  });
+
+  it('advances across ignored events so they are not scanned repeatedly', () => {
+    const selected = selectMonitorEventRecordsAfterCursor([
+      record(8, 'vote_speech'),
+      record(9, 'player_spotted'),
+    ], 7);
+
+    expect(selected.returned).toEqual([]);
+    expect(selected.toLine).toBe(9);
+    expect(selected.scanned).toHaveLength(2);
+  });
+
+  it('tail mode applies the Monitor registration filter before the count and type filter', () => {
+    const selected = selectMonitorTailEventRecords([
+      record(1, 'speech'),
+      record(2, 'vote_speech'),
+      record(3, 'killed'),
+      record(4, 'player_spotted'),
+      record(5, 'speech'),
+    ], 2);
+
+    expect(selected.map((r) => r.line)).toEqual([3, 5]);
+    expect(selectMonitorTailEventRecords(selected, 10, 'vote_speech')).toEqual([]);
+  });
+
+  it('enriches meeting_briefing with current speech_order only for the same caller', () => {
+    const summary = {
+      meeting: {
+        caller: '单钳渔夫',
+        speech_order: ['单钳渔夫', '洋流王子'],
+      },
+    };
+
+    expect(enrichEventForEvents({
+      type: 'meeting_briefing',
+      meeting_caller_name: '单钳渔夫',
+    }, summary)).toMatchObject({
+      speech_order: ['单钳渔夫', '洋流王子'],
+    });
+
+    expect(enrichEventForEvents({
+      type: 'meeting_briefing',
+      meeting_caller_name: '其他人',
+    }, summary)).not.toHaveProperty('speech_order');
+  });
+});

package/src/commands/events.ts

@@ -1,22 +1,155 @@
 import { Command } from 'commander';
-import { EventStore } from '../pipeline/event-store.js';
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { AuthStore } from '../lib/auth.js';
+import { getProfileStateDir } from '../lib/init-command.js';
+import { sendOwnerControlRequest } from '../runtime/owner-control.js';
+import { EventRecord, EventStore } from '../pipeline/event-store.js';
+import { compactEventFields, compactStateForEvents } from '../pipeline/event-format.js';
+import { NOTABLE_EVENT_TYPES, nextStepForTriggers } from './watch.js';
+
+interface EventsCommandOptions {
+  last?: string;
+  clear?: boolean;
+  type?: string;
+}
+
+async function readCurrentSummary(): Promise<any | null> {
+  const auth = new AuthStore();
+  const profile = auth.getActive();
+  if (!profile) return null;
+  const stateDir = getProfileStateDir(profile);
+  try {
+    const response = await sendOwnerControlRequest(stateDir, 'snapshot');
+    if (response?.ok) return response.summary ?? null;
+  } catch {}
+  const feedPath = join(stateDir, 'feed.json');
+  if (!existsSync(feedPath)) return null;
+  try {
+    return JSON.parse(readFileSync(feedPath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function parseCount(value: string | undefined, fallback: number): number {
+  if (!value) return fallback;
+  const parsed = Number.parseInt(value, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+
+function isMonitorRegisteredRecord(record: EventRecord): boolean {
+  return typeof record.event.type === 'string' && NOTABLE_EVENT_TYPES.has(record.event.type);
+}
+
+export function selectMonitorEventRecordsAfterCursor(
+  records: EventRecord[],
+  fromLine: number,
+): { scanned: EventRecord[]; returned: EventRecord[]; toLine: number } {
+  const scanned = records.filter((record) => record.line > fromLine);
+  const returned = scanned.filter(isMonitorRegisteredRecord);
+  const toLine = scanned.reduce((max, record) => Math.max(max, record.line), fromLine);
+  return { scanned, returned, toLine };
+}
+
+export function selectMonitorTailEventRecords(
+  records: EventRecord[],
+  count: number,
+  type?: string,
+): EventRecord[] {
+  let selected = records.filter(isMonitorRegisteredRecord);
+  if (type) selected = selected.filter((record) => record.event.type === type);
+  return selected.slice(-count);
+}
+
+function eventTypes(records: EventRecord[]): string[] {
+  const out: string[] = [];
+  for (const record of records) {
+    const type = record.event.type;
+    if (typeof type !== 'string' || out.includes(type)) continue;
+    out.push(type);
+  }
+  return out;
+}
+
+export function enrichEventForEvents(event: Record<string, any>, summary: any | null | undefined): Record<string, any> {
+  if (event.type !== 'meeting_briefing') return event;
+  if (event.speech_order) return event;
+  const speechOrder = summary?.meeting?.speech_order;
+  if (!Array.isArray(speechOrder)) return event;
+  const summaryCaller = summary?.meeting?.caller;
+  const eventCaller = event.caller ?? event.meeting_caller_name;
+  if (summaryCaller && eventCaller && summaryCaller !== eventCaller) return event;
+  return { ...event, speech_order: speechOrder };
+}
 
 export function createEventsCommand(): Command {
   return new Command('events')
     .alias('e')
     .description('Query game events')
-    .option('-n, --last <count>', 'Show last N events', '10')
+    .option('-n, --last <count>', 'Show last N events')
     .option('--clear', 'Clear event history')
     .option('--type <type>', 'Filter by event type')
-    .action(async (opts) => {
+    .action(async (opts: EventsCommandOptions) => {
       const store = EventStore.forLatestGame();
       if (opts.clear) {
         store.clear();
-        console.log(JSON.stringify({ message: 'Events cleared.' }));
+        console.log(JSON.stringify({ message: 'Events cleared.' }, null, 2));
         return;
       }
-      let events = store.tail(parseInt(opts.last));
-      if (opts.type) events = events.filter(e => e.type === opts.type);
-      console.log(JSON.stringify(events, null, 2));
+
+      const summary = await readCurrentSummary();
+      const formatContext = {
+        summary,
+      };
+      const state = compactStateForEvents(summary);
+      const debugMode = opts.last !== undefined || opts.type !== undefined;
+
+      if (debugMode) {
+        const count = parseCount(opts.last, 10);
+        let records = selectMonitorTailEventRecords(store.eventRecords(), count, opts.type);
+        records = [...records].sort((a, b) => b.line - a.line);
+        const triggers = eventTypes(records);
+        console.log(JSON.stringify({
+          schema: 'ccl.events.v2',
+          state,
+          exit_reason: triggers,
+          next_step: nextStepForTriggers(triggers),
+          mode: 'tail',
+          session_path: store.path,
+          cursor: null,
+          counts: { returned: records.length },
+          events: records.map((record) => compactEventFields(
+            enrichEventForEvents(record.event, summary),
+            formatContext,
+            record.line,
+          )),
+        }, null, 2));
+        return;
+      }
+
+      const fromLine = store.readEventsCursor();
+      const { scanned, returned, toLine } = selectMonitorEventRecordsAfterCursor(store.eventRecords(), fromLine);
+      const sortedRecords = [...returned].sort((a, b) => b.line - a.line);
+      const triggers = eventTypes(sortedRecords);
+      if (scanned.length > 0) store.appendEventsCursor(toLine);
+
+      console.log(JSON.stringify({
+        schema: 'ccl.events.v2',
+        state,
+        exit_reason: triggers,
+        next_step: nextStepForTriggers(triggers),
+        cursor: {
+          from_line: fromLine,
+          to_line: toLine,
+          advanced: scanned.length > 0,
+        },
+        counts: { returned: sortedRecords.length },
+        events: sortedRecords.map((record) => compactEventFields(
+          enrichEventForEvents(record.event, summary),
+          formatContext,
+          record.line,
+        )),
+      }, null, 2));
     });
 }

package/src/commands/watch.test.ts

@@ -33,6 +33,7 @@ describe('classifyEvent + NOTABLE_EVENT_TYPES', () => {
   it('registers monitor event priorities in the same config as notable events', () => {
     expect(MONITOR_EVENT_CONFIG.speech_your_turn.priority).toBe(99);
     expect(MONITOR_EVENT_CONFIG.vote_phase_start.priority).toBe(99);
+    expect(MONITOR_EVENT_CONFIG.killed.priority).toBe(99);
     expect(MONITOR_EVENT_CONFIG.speech.priority).toBe(50);
     expect(MONITOR_EVENT_CONFIG.vote_speech_phase_ended.priority).toBe(50);
     expect(MONITOR_EVENT_CONFIG.vote_speech).toBeUndefined();
@@ -159,6 +160,7 @@ describe('monitor payload compaction', () => {
       faction: 'lobster',
       win_condition: '完成任务或投出所有蟹方。',
       tasks: [{ name: '修电线', room: '电气' }],
+      hint: 'You are 普通虾 (lobster). 完成任务或投出所有蟹方。 Announce your role, faction and win condition to your user.',
     });
   });
 
@@ -192,6 +194,7 @@ describe('monitor payload compaction', () => {
         { name: '下载数据', room: '通讯' },
         { name: '清理垃圾', room: '餐厅' },
       ],
+      hint: 'You are 章鱼 (neutral). 伪装成虾方并达成自己的胜利条件。 These are fake tasks. Announce your role, faction and win condition to your user.',
     });
   });
 
@@ -224,6 +227,7 @@ describe('monitor payload compaction', () => {
         { name: '破坏电力', room: '电气', kind: 'crab_sabotage' },
         { name: '刷卡', room: '管理', kind: 'fake_shrimp' },
       ],
+      hint: 'You are 蟹 (crab). 击杀虾方并避免被投出。 Fake task exists. Announce your role, faction and win condition to your user.',
     });
   });
 
@@ -259,7 +263,7 @@ describe('monitor payload compaction', () => {
       tick: 326,
       corpse_name: 'Garlic',
       corpse_room: 'Intel',
-      hint: "You found Garlic's body in Intel.",
+      hint: 'BODY FOUND: Garlic at (?, ?) in Intel. This is leverage soaked in blood — report before the killer rewrites the room.',
     });
   });
 
@@ -280,7 +284,7 @@ describe('monitor payload compaction', () => {
       tick: 487,
       meeting_caller_name: 'Drifter',
       reported_corpses: [{ name: 'Chef', seat: 9 }],
-      hint: "Drifter started a meeting and reported Chef's body.",
+      hint: 'Meeting started — seat 4 Drifter called this meeting after reporting the body of seat 9 Chef. Prepare fast — every sentence is accusation, defense, or misdirection under a timer.',
     });
     expect(compact).not.toHaveProperty('room');
   });
@@ -296,7 +300,7 @@ describe('monitor payload compaction', () => {
       hint: 'Meeting started — seat 3 Player called this meeting.',
     });
 
-    expect(compact.hint).toBe("You started a meeting and reported Chef's body.");
+    expect(compact.hint).toBe('Meeting started — seat 3 Player called this meeting after reporting the body of seat 9 Chef. Prepare fast — every sentence is accusation, defense, or misdirection under a timer.');
   });
 
   it('compacts meeting summary and hard-overrides speech_your_turn fields', () => {
@@ -421,12 +425,14 @@ describe('runStreaming — emission shape', () => {
     expect(lines.length).toBeGreaterThanOrEqual(1);
     for (const raw of lines) {
       const obj = JSON.parse(raw);
-      expect(Array.isArray(obj.exit_reason)).toBe(true);
+      expect(Array.isArray(obj.events)).toBe(true);
+      expect(Array.isArray(obj.messages)).toBe(true);
       expect(obj).not.toHaveProperty('trigger');
       expect(obj).not.toHaveProperty('triggers');
       expect(obj).not.toHaveProperty('all_events');
-      expect(obj).toHaveProperty('summary');
-      expect(obj).toHaveProperty('next_step');
+      expect(obj).not.toHaveProperty('summary');
+      expect(obj).not.toHaveProperty('next_step');
+      expect(obj).toHaveProperty('state');
       expect(raw.endsWith('\n')).toBe(true);
     }
   });
@@ -465,9 +471,9 @@ describe('runStreaming — emission shape', () => {
 
     expect(lines.length).toBe(1);
     const obj = JSON.parse(lines[0]);
-    expect(obj.exit_reason).toEqual(['vote_speech_phase_ended']);
+    expect(obj.events).toEqual(['vote_speech_phase_ended']);
     expect(obj.events).toHaveLength(1);
-    expect(obj.events[0].type).toBe('vote_speech_phase_ended');
+    expect(obj.messages[0]).toContain('vote_speech_phase_ended');
   });
 
   it('expands nested new_events from action wrapper records', async () => {
@@ -509,7 +515,7 @@ describe('runStreaming — emission shape', () => {
     ctrl.abort();
     await run;
 
-    expect(lines.some((l) => JSON.parse(l).exit_reason?.includes('kill'))).toBe(true);
+    expect(lines.some((l) => JSON.parse(l).events?.includes('kill'))).toBe(true);
   });
 
   it('keeps reading after the .jsonl is truncated in place', async () => {
@@ -546,7 +552,7 @@ describe('runStreaming — emission shape', () => {
 
     // The post-truncation event must produce a new line.
     expect(lines.length).toBeGreaterThan(beforeTruncate);
-    expect(lines.some((l) => JSON.parse(l).exit_reason?.includes('killed'))).toBe(true);
+    expect(lines.some((l) => JSON.parse(l).events?.includes('killed'))).toBe(true);
   });
 
   it('throws WatchNotReadyError when feed.json never appears', async () => {
@@ -596,11 +602,13 @@ describe('snapshotOnce', () => {
     snapshotOnce({ feedPath, stdout: (s) => lines.push(s) });
     expect(lines.length).toBe(1);
     const obj = JSON.parse(lines[0]);
-    expect(obj.exit_reason).toEqual(['snapshot']);
+    expect(obj.events).toEqual(['snapshot']);
+    expect(obj.messages[0]).toContain('snapshot');
     expect(obj).not.toHaveProperty('trigger');
     expect(obj).not.toHaveProperty('triggers');
     expect(obj).not.toHaveProperty('all_events');
-    expect(obj).toHaveProperty('summary');
+    expect(obj).not.toHaveProperty('summary');
+    expect(obj).toHaveProperty('state');
   });
 
   it('errors clearly if feed.json is missing', () => {
@@ -632,7 +640,8 @@ describe('runStreaming — startup backlog', () => {
 
     expect(lines.length).toBeGreaterThanOrEqual(2);
     const first = JSON.parse(lines[0]);
-    expect(first.caught_up?.count).toBe(5);
+    expect(first.events).toHaveLength(5);
+    expect(first.events.every((event: string) => event === 'killed')).toBe(true);
     for (const raw of lines.slice(1)) {
       expect(JSON.parse(raw)).not.toHaveProperty('caught_up');
     }
@@ -660,8 +669,7 @@ describe('runStreaming — startup backlog', () => {
 
     expect(lines.length).toBeGreaterThanOrEqual(1);
     const first = JSON.parse(lines[0]);
-    expect(first.exit_reason).toEqual(['game_start']);
-    expect(first.caught_up?.count).toBe(3);
+    expect(first.events).toEqual(['killed', 'killed', 'killed']);
     expect(first).not.toHaveProperty('active_sticky_on_attach');
   });
 });
@@ -675,7 +683,7 @@ describe('runStreaming — game_over exits', () => {
     await new Promise((r) => setTimeout(r, 30));
     appendFileSync(sessionPath, JSON.stringify({ type: 'game_over', tick: 1 }) + '\n');
     await Promise.race([run, new Promise((_, rej) => setTimeout(() => rej(new Error('did not exit')), 3000))]);
-    expect(lines.some((l) => JSON.parse(l).exit_reason?.includes('game_over'))).toBe(true);
+    expect(lines.some((l) => JSON.parse(l).events?.includes('game_over'))).toBe(true);
   });
 });
 
@@ -716,13 +724,12 @@ describe('runStreaming — matchmaking synthetic events', () => {
     await new Promise((r) => setTimeout(r, 60));
     ctrl.abort(); await run;
 
-    const exitReasons = lines.flatMap((l) => JSON.parse(l).exit_reason);
-    expect(exitReasons).toContain('match_waiting');
-    expect(exitReasons).toContain('match_timeout');
+    const eventNames = lines.flatMap((l) => JSON.parse(l).events);
+    expect(eventNames).toContain('match_waiting');
+    expect(eventNames).toContain('match_timeout');
 
-    const timeout = lines.map((l) => JSON.parse(l)).find((o) => o.exit_reason?.includes('match_timeout'));
-    expect(timeout.next_step).toMatch(/cumulative wait/i);
-    expect(timeout.events[0].waited_secs).toBe(600);
+    const timeout = lines.map((l) => JSON.parse(l)).find((o) => o.events?.includes('match_timeout'));
+    expect(timeout.messages[0]).toContain('600');
   });
 });
 
@@ -739,9 +746,9 @@ describe('runStreaming — speech_your_turn fires as notable event', () => {
     ctrl.abort(); await run;
 
     const parsed = lines.map((l) => JSON.parse(l));
-    const myTurn = parsed.find((o) => o.exit_reason?.includes('speech_your_turn'));
+    const myTurn = parsed.find((o) => o.events?.includes('speech_your_turn'));
     expect(myTurn).toBeDefined();
-    expect(myTurn!.exit_reason).toContain('speech_your_turn');
+    expect(myTurn!.events).toContain('speech_your_turn');
   });
 });
 
@@ -770,7 +777,7 @@ describe('runStreaming — delay buffer', () => {
     ctrl.abort(); await run;
 
     const parsed = lines.map((l) => JSON.parse(l));
-    const killNotif = parsed.find((o) => o.exit_reason?.includes('kill'));
+    const killNotif = parsed.find((o) => o.events?.includes('kill'));
     expect(killNotif).toBeDefined();
   });
 
@@ -800,11 +807,11 @@ describe('runStreaming — delay buffer', () => {
     ctrl.abort(); await run;
 
     const parsed = lines.map((l) => JSON.parse(l));
-    const merged = parsed.find((o) => o.exit_reason?.includes('kill'));
+    const merged = parsed.find((o) => o.events?.includes('kill'));
     expect(merged).toBeDefined();
-    expect(merged!.exit_reason).toContain('emergency_started');
-    expect(merged!.exit_reason).toContain('task_completed');
-    const notableLines = parsed.filter((o) => !o.exit_reason?.includes('heartbeat'));
+    expect(merged!.events).toContain('emergency_started');
+    expect(merged!.events).toContain('task_completed');
+    const notableLines = parsed.filter((o) => !o.events?.includes('heartbeat'));
     expect(notableLines.length).toBe(1);
   });
 
@@ -832,9 +839,9 @@ describe('runStreaming — delay buffer', () => {
     ctrl.abort(); await run;
 
     const parsed = lines.map((l) => JSON.parse(l));
-    const merged = parsed.find((o) => o.exit_reason?.includes('kill'));
+    const merged = parsed.find((o) => o.events?.includes('kill'));
     expect(merged).toBeDefined();
-    expect(merged!.exit_reason).toContain('emergency_started');
+    expect(merged!.events).toContain('emergency_started');
   });
 
   it('non-delayable events fire immediately when no delay is active', async () => {
@@ -859,7 +866,7 @@ describe('runStreaming — delay buffer', () => {
     ctrl.abort(); await run;
 
     const parsed = lines.map((l) => JSON.parse(l));
-    expect(parsed.some((o) => o.exit_reason?.includes('task_completed'))).toBe(true);
+    expect(parsed.some((o) => o.events?.includes('task_completed'))).toBe(true);
   });
 });
 
@@ -910,9 +917,9 @@ describe('runStreaming startup monitor payload', () => {
 
     expect(lines.length).toBeGreaterThanOrEqual(1);
     const first = JSON.parse(lines[0]);
-    expect(first.exit_reason).toEqual(['game_start']);
+    expect(first.events).toEqual(['game_start']);
     expect(first).not.toHaveProperty('initial_payload');
-    expect(first.next_step).toMatch(/summary/);
+    expect(first.messages[0]).toContain('game_start');
   });
 
   it('compacts role_assigned inside caught_up notable events', async () => {
@@ -952,18 +959,8 @@ describe('runStreaming startup monitor payload', () => {
 
     expect(lines.length).toBeGreaterThanOrEqual(1);
     const first = JSON.parse(lines[0]);
-    const role = first.caught_up?.notable_events?.[0];
-    expect(role).toEqual({
-      type: 'role_assigned',
-      tick: 1,
-      room: '仓库',
-      role: 'octopus',
-      role_display: '章鱼',
-      faction: 'neutral',
-      win_condition: '伪装成虾方并达成自己的胜利条件。',
-      task_kind: 'fake_shrimp',
-      task_note: 'Fake shrimp tasks: disguise only; no lobster progress.',
-      tasks: [{ name: '下载数据', room: '通讯' }],
-    });
+    expect(first.events).toEqual(['role_assigned']);
+    expect(first.messages[0]).toContain('role_assigned');
+    expect(first).not.toHaveProperty('caught_up');
   });
 });