metona-ai-desktop/electron/services/__tests__/session-recorder.test.ts

/**
 * SessionRecorder 测试（v0.7.2 覆盖补齐 —— 此前零测试）
 *
 * 锁定 TRACE 层录制契约（P1-6 重构的回归防线）：
 * 1. startRecording 建文件并写 session_start；stopRecording 同步 flush + session_end
 * 2. 多会话隔离（P1-6：每会话独立文件/seq，并发录制互不串扰）
 * 3. setEnabled(false) 总开关丢弃事件（F-8 接通契约）
 * 4. 缓冲上限（MAX_BUFFER_SIZE）强制同步落盘防 OOM
 * 5. 事件 seq 递增与 9 类事件的载荷形状
 */

import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
import { mkdtempSync, readFileSync, existsSync, rmSync, readdirSync } from 'fs';
import { join } from 'path';
import { tmpdir } from 'os';

vi.mock('electron-log', () => ({
  default: { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() },
}));

import { SessionRecorder } from '../session-recorder.service';

let wsRoot: string;
let recorder: SessionRecorder;

beforeEach(() => {
  wsRoot = mkdtempSync(join(tmpdir(), 'metona-rec-'));
  recorder = new SessionRecorder(wsRoot);
});

afterEach(() => {
  try {
    rmSync(wsRoot, { recursive: true, force: true });
  } catch {
    /* ignore */
  }
});

function readLines(sessionId: string): Array<Record<string, unknown>> {
  const dir = join(wsRoot, 'logs');
  const files = readdirSync(dir) as string[];
  const target = files.filter((f) => f.includes(`session_${sessionId}_`));
  expect(target.length).toBeGreaterThan(0);
  const content = readFileSync(join(dir, target[0]), 'utf-8');
  return content
    .split('\n')
    .filter((l) => l.trim())
    .map((l) => JSON.parse(l) as Record<string, unknown>);
}

describe('SessionRecorder — 基本录制链路', () => {
  it('startRecording 会话开启后首条事件即 session_start（seq 0，经 flush 落盘）', async () => {
    recorder.startRecording('s1');
    // 事件先进缓冲（100ms 定时 flush），stopRecording 的 flushSync 保证落盘后断言
    await recorder.stopRecording('s1', {
      totalIterations: 0,
      totalTokens: 0,
      durationMs: 0,
      terminationReason: 'completed',
    });
    const lines = readLines('s1');
    expect(lines).toHaveLength(2); // session_start + session_end
    expect(lines[0]).toMatchObject({ event: 'session_start', sessionId: 's1' });
    expect(lines[0].ts).toBeDefined();
    expect(lines[0].seq).toBe(0);
    expect(lines[1].event).toBe('session_end');
  });

  it('stopRecording 同步 flush 全部缓冲并写 session_end（#35 契约）', async () => {
    recorder.startRecording('s1');
    recorder.recordToolCall({
      sessionId: 's1',
      iteration: 1,
      toolName: 'read_file',
      args: { p: 'x' },
    });
    recorder.recordIterationStart('s1', 1);
    await recorder.stopRecording('s1', {
      totalIterations: 1,
      totalTokens: 100,
      durationMs: 50,
      terminationReason: 'completed',
    });

    const lines = readLines('s1');
    const events = lines.map((l) => l.event);
    expect(events).toEqual(['session_start', 'tool_call', 'iteration_start', 'session_end']);
    const end = lines[lines.length - 1];
    expect(end).toMatchObject({
      totalIterations: 1,
      totalTokens: 100,
      terminationReason: 'completed',
    });
  });

  it('事件 seq 在会话内单调递增', async () => {
    recorder.startRecording('s1');
    recorder.recordIterationStart('s1', 1);
    recorder.recordIterationStart('s1', 2);
    await recorder.stopRecording('s1', {
      totalIterations: 2,
      totalTokens: 0,
      durationMs: 1,
      terminationReason: 'completed',
    });

    // session_start(0) + iteration_start×2(1,2) + session_end(3)
    const seqs = readLines('s1').map((l) => l.seq as number);
    expect(seqs).toEqual([0, 1, 2, 3]);
  });

  it('recordLLMResponse 载荷：content 截断 200 字符', async () => {
    recorder.startRecording('s1');
    recorder.recordLLMResponse({
      sessionId: 's1',
      iteration: 1,
      content: 'y'.repeat(500),
      finishReason: 'stop',
      tokenUsage: { input: 10, output: 20, total: 30 },
    });
    await recorder.stopRecording('s1', {
      totalIterations: 1,
      totalTokens: 30,
      durationMs: 1,
      terminationReason: 'completed',
    });

    const llm = readLines('s1').find((l) => l.event === 'llm_response') as Record<string, unknown>;
    expect((llm.contentPreview as string).length).toBe(200);
    expect(llm.tokenUsage).toEqual({ input: 10, output: 20, total: 30 });
  });

  it('recordToolResult 载荷：success/durationMs/resultPreview 截断 500/error', async () => {
    recorder.startRecording('s1');
    recorder.recordToolResult({
      sessionId: 's1',
      iteration: 1,
      toolName: 'web_fetch',
      success: false,
      durationMs: 42,
      resultPreview: 'z'.repeat(800),
      error: 'HTTP 403',
    });
    await recorder.stopRecording('s1', {
      totalIterations: 1,
      totalTokens: 0,
      durationMs: 1,
      terminationReason: 'error',
    });

    const tr = readLines('s1').find((l) => l.event === 'tool_result') as Record<string, unknown>;
    expect(tr.success).toBe(false);
    expect(tr.durationMs).toBe(42);
    expect((tr.resultPreview as string).length).toBe(500);
    expect(tr.error).toBe('HTTP 403');
  });
});

describe('SessionRecorder — 多会话隔离（P1-6）', () => {
  it('并发录制：每会话独立文件与独立 seq，互不串扰', async () => {
    recorder.startRecording('s1');
    recorder.startRecording('s2');

    recorder.recordToolCall({ sessionId: 's1', iteration: 1, toolName: 'tool_a', args: {} });
    recorder.recordToolCall({ sessionId: 's2', iteration: 1, toolName: 'tool_b', args: {} });

    await recorder.stopRecording('s1', {
      totalIterations: 1,
      totalTokens: 0,
      durationMs: 1,
      terminationReason: 'completed',
    });
    await recorder.stopRecording('s2', {
      totalIterations: 1,
      totalTokens: 0,
      durationMs: 1,
      terminationReason: 'completed',
    });

    const s1Tools = readLines('s1').filter((l) => l.event === 'tool_call');
    const s2Tools = readLines('s2').filter((l) => l.event === 'tool_call');
    expect(s1Tools[0].tool).toBe('tool_a');
    expect(s2Tools[0].tool).toBe('tool_b');
    // seq 各自从 0 起算（s1: start=0, tool=1, end=2；s2 同构）
    expect(s1Tools[0].seq).toBe(1);
    expect(s2Tools[0].seq).toBe(1);
  });

  it('未 startRecording 的会话事件被静默丢弃', async () => {
    recorder.recordToolCall({ sessionId: 'ghost', iteration: 1, toolName: 'x', args: {} });
    expect(recorder.getFilePath('ghost')).toBeNull();
  });

  it('stopRecording 幂等安全（未开始也会话状态不崩）', async () => {
    await expect(
      recorder.stopRecording('ghost', {
        totalIterations: 0,
        totalTokens: 0,
        durationMs: 0,
        terminationReason: 'error',
      }),
    ).resolves.toBeUndefined();
  });
});

describe('SessionRecorder — 总开关与缓冲上限', () => {
  it('setEnabled(false) 后事件全部丢弃（logging.traceEnabled 契约）', async () => {
    recorder.setEnabled(false);
    recorder.startRecording('s1');
    recorder.recordToolCall({ sessionId: 's1', iteration: 1, toolName: 'x', args: {} });
    await recorder.stopRecording('s1', {
      totalIterations: 1,
      totalTokens: 0,
      durationMs: 1,
      terminationReason: 'completed',
    });

    const dir = join(wsRoot, 'logs');
    const files = existsSync(dir) ? readdirSync(dir) : [];
    expect(files.filter((f) => f.startsWith('session_s1_'))).toEqual([]);
  });

  it('缓冲超过 MAX_BUFFER_SIZE 强制同步落盘（防 OOM）', async () => {
    recorder.startRecording('s1');
    // MAX_BUFFER_SIZE = 1000 —— 写入超限触发 flushSync（文件应提前出现在磁盘）
    for (let i = 0; i < 1001; i++) {
      recorder.recordIterationStart('s1', i);
    }
    await recorder.stopRecording('s1', {
      totalIterations: 1001,
      totalTokens: 0,
      durationMs: 1,
      terminationReason: 'completed',
    });

    const lines = readLines('s1');
    expect(lines.length).toBe(1003); // 1001 iterations + session_start + session_end
  });

  it('getFilePath 返回活动会话的录制文件路径；stop 后清除', async () => {
    recorder.startRecording('s1');
    expect(recorder.getFilePath('s1')).toContain('session_s1_');
    await recorder.stopRecording('s1', {
      totalIterations: 0,
      totalTokens: 0,
      durationMs: 0,
      terminationReason: 'completed',
    });
    expect(recorder.getFilePath('s1')).toBeNull();
  });
});

// ===== v0.7.3 P3-3: JSONL 录制文件生命周期（stats + prune） =====

describe('SessionRecorder — 录制文件统计与清理（P3-3）', () => {
  const writeRecording = async (name: string, ageHours: number): Promise<void> => {
    const fs = await import('node:fs');
    const logsDir = join(wsRoot, 'logs');
    if (!existsSync(logsDir)) fs.mkdirSync(logsDir, { recursive: true });
    const filePath = join(logsDir, name);
    fs.writeFileSync(filePath, '{"event":"session_start"}\n', 'utf-8');
    const mtime = new Date(Date.now() - ageHours * 3600_000);
    fs.utimesSync(filePath, mtime, mtime);
  };

  it('getRecordingStats：统计 count 与 totalBytes；目录不存在返回零值', async () => {
    expect(recorder.getRecordingStats()).toEqual({ count: 0, totalBytes: 0 });

    await writeRecording('session_s1_2026-01-01.jsonl', 1);
    await writeRecording('session_s2_2026-01-02.jsonl', 2);
    // 非 session_*.jsonl 命名的文件不受治理（用户自放文件）
    await writeRecording('user-notes.txt', 3);

    const stats = recorder.getRecordingStats();
    expect(stats.count).toBe(2);
    expect(stats.totalBytes).toBeGreaterThan(0);
  });

  it('pruneOldRecordings：按 mtime 保留最近 N 个，删除其余', async () => {
    for (let i = 0; i < 6; i++) {
      await writeRecording(`session_s${i}_f.jsonl`, i + 1); // s0 最旧
    }
    const deleted = recorder.pruneOldRecordings(3);
    expect(deleted).toBe(3);

    const remaining = (readdirSync(join(wsRoot, 'logs')) as string[]).filter((f) =>
      f.startsWith('session_'),
    );
    expect(remaining).toHaveLength(3);
    // 保留的应是最新的 3 个（s0/s1/s2 —— 年龄 1/2/3 小时，s0 最新）
    for (const keep of ['session_s0_f.jsonl', 'session_s1_f.jsonl', 'session_s2_f.jsonl']) {
      expect(remaining).toContain(keep);
    }
  });

  it('pruneOldRecordings：仅治理 session_*.jsonl 命名，用户文件不受影响', async () => {
    await writeRecording('session_a.jsonl', 100);
    await writeRecording('my-data.jsonl', 100);
    const deleted = recorder.pruneOldRecordings(0);
    expect(deleted).toBe(1);
    expect(existsSync(join(wsRoot, 'logs', 'my-data.jsonl'))).toBe(true);
  });

  it('pruneOldRecordings：未超限返回 0 且不删除任何文件', async () => {
    await writeRecording('session_x.jsonl', 1);
    expect(recorder.pruneOldRecordings(200)).toBe(0);
    expect(existsSync(join(wsRoot, 'logs', 'session_x.jsonl'))).toBe(true);
  });

  it('pruneOldRecordings：maxFiles=0 时全部删除（保留 0 个）', async () => {
    await writeRecording('session_a.jsonl', 1);
    await writeRecording('session_b.jsonl', 2);
    const deleted = recorder.pruneOldRecordings(0);
    expect(deleted).toBe(2);
    const remaining = (readdirSync(join(wsRoot, 'logs')) as string[]).filter((f) =>
      f.startsWith('session_'),
    );
    expect(remaining).toHaveLength(0);
  });

  it('pruneOldRecordings：目录不存在返回 0（不抛错）', () => {
    expect(recorder.pruneOldRecordings(10)).toBe(0);
  });

  it('pruneOldRecordings：stat 失败的文件按 mtime=0 排最后（仍参与清理计数）', async () => {
    await writeRecording('session_f1.jsonl', 1);
    await writeRecording('session_f2.jsonl', 2);
    const logsDir = join(wsRoot, 'logs');
    // 构造 stat 抛错的文件：删除后 mtime 读取失败场景通过目录删除模拟 ——
    // 直接验证排序兜底不抛错
    expect(() => recorder.pruneOldRecordings(1)).not.toThrow();
    expect(readdirSync(logsDir).filter((f) => f.startsWith('session_'))).toHaveLength(1);
  });
});

describe('SessionRecorder — flush 竞态与缓冲超限（P3-4）', () => {
  it('异步 flush 进行中 stopRecording 等待其完成且不丢数据', async () => {
    recorder.startRecording('race1');
    recorder.recordIterationStart('race1', 1);

    // 触发 100ms 定时 flush（异步）
    await new Promise((r) => setTimeout(r, 150));
    // 再次写事件后立即 stop —— flushSync 需等待 in-flight flush
    recorder.recordIterationStart('race1', 2);
    await recorder.stopRecording('race1', {
      totalIterations: 2,
      totalTokens: 0,
      durationMs: 1,
      terminationReason: 'completed',
    });

    const lines = readLines('race1');
    const events = lines.map((l) => l.event);
    // session_start + iteration_start×2 + session_end —— 无丢失
    expect(events).toEqual(['session_start', 'iteration_start', 'iteration_start', 'session_end']);
  });

  it('缓冲超限内联落盘：超限行即时落盘，文件在 stop 前已含早期事件', async () => {
    recorder.startRecording('buf');
    // MAX_BUFFER_SIZE = 1000；写入 1001 条触发内联 appendFileSync
    for (let i = 0; i < 1001; i++) {
      recorder.recordIterationStart('buf', i);
    }
    // 无需 stop：超限 flush 已写入前 1000 行（含 session_start）
    const dir = join(wsRoot, 'logs');
    const files = (readdirSync(dir) as string[]).filter((f) => f.startsWith('session_buf_'));
    expect(files).toHaveLength(1);
    const content = readFileSync(join(dir, files[0]), 'utf-8');
    const lines = content.split('\n').filter((l) => l.trim());
    expect(lines.length).toBeGreaterThanOrEqual(1000);
    // 超限内联写的是"当前 buffer 不含本行"，最后一行应仍留在 buffer 中
    expect(JSON.parse(lines[0]).event).toBe('session_start');
    await recorder.stopRecording('buf', {
      totalIterations: 1001,
      totalTokens: 0,
      durationMs: 1,
      terminationReason: 'completed',
    });
    const finalLines = readLines('buf');
    expect(finalLines.length).toBe(1003); // 1001 + start + end
  });

  it('多个会话并发触发异步 flush 互不串扰', async () => {
    recorder.startRecording('s1');
    recorder.startRecording('s2');
    recorder.recordIterationStart('s1', 1);
    recorder.recordIterationStart('s2', 1);
    recorder.recordIterationStart('s1', 2);
    recorder.recordIterationStart('s2', 2);
    await new Promise((r) => setTimeout(r, 200)); // 等待定时 flush
    await recorder.stopRecording('s1', {
      totalIterations: 2,
      totalTokens: 0,
      durationMs: 1,
      terminationReason: 'completed',
    });
    await recorder.stopRecording('s2', {
      totalIterations: 2,
      totalTokens: 0,
      durationMs: 1,
      terminationReason: 'completed',
    });
    expect(readLines('s1').filter((l) => l.event === 'iteration_start')).toHaveLength(2);
    expect(readLines('s2').filter((l) => l.event === 'iteration_start')).toHaveLength(2);
  });

  it('连续多次 stopRecording：第二次为 no-op（状态已清除）', async () => {
    recorder.startRecording('s1');
    const params = {
      totalIterations: 0,
      totalTokens: 0,
      durationMs: 0,
      terminationReason: 'completed',
    };
    await recorder.stopRecording('s1', params);
    await recorder.stopRecording('s1', params); // 不抛错
    expect(recorder.getFilePath('s1')).toBeNull();
  });
});

describe('SessionRecorder — 事件载荷形状', () => {
  it('recordContextBuilt 载荷：tokens 与 ratio 字段', async () => {
    recorder.startRecording('shape1');
    recorder.recordContextBuilt('shape1', { tokenCount: 8000, usageRatio: 0.32 });
    await recorder.stopRecording('shape1', {
      totalIterations: 0,
      totalTokens: 0,
      durationMs: 0,
      terminationReason: 'completed',
    });
    const evt = readLines('shape1').find((l) => l.event === 'context_built') as Record<
      string,
      unknown
    >;
    expect(evt.tokens).toBe(8000);
    expect(evt.ratio).toBe(0.32);
    expect(evt.sessionId).toBe('shape1');
  });

  it('recordLLMRequest 载荷：provider/model/messageCount/iteration', async () => {
    recorder.startRecording('shape2');
    recorder.recordLLMRequest({
      sessionId: 'shape2',
      iteration: 3,
      provider: 'deepseek',
      model: 'v4-pro',
      messageCount: 7,
    });
    await recorder.stopRecording('shape2', {
      totalIterations: 3,
      totalTokens: 0,
      durationMs: 0,
      terminationReason: 'completed',
    });
    const evt = readLines('shape2').find((l) => l.event === 'llm_request') as Record<
      string,
      unknown
    >;
    expect(evt).toMatchObject({
      provider: 'deepseek',
      model: 'v4-pro',
      messageCount: 7,
      iteration: 3,
    });
  });

  it('recordLLMResponse 载荷：contentPreview 截断 200、finishReason、tokenUsage', async () => {
    recorder.startRecording('shape3');
    recorder.recordLLMResponse({
      sessionId: 'shape3',
      iteration: 1,
      content: 'x'.repeat(300),
      finishReason: 'length',
      tokenUsage: { input: 100, output: 50, total: 150 },
    });
    await recorder.stopRecording('shape3', {
      totalIterations: 1,
      totalTokens: 150,
      durationMs: 1,
      terminationReason: 'completed',
    });
    const evt = readLines('shape3').find((l) => l.event === 'llm_response') as Record<
      string,
      unknown
    >;
    expect((evt.contentPreview as string).length).toBe(200);
    expect(evt.finishReason).toBe('length');
    expect(evt.tokenUsage).toEqual({ input: 100, output: 50, total: 150 });
  });

  it('recordIterationEnd 载荷：iteration 与 durationMs', async () => {
    recorder.startRecording('shape4');
    recorder.recordIterationEnd('shape4', { iteration: 2, durationMs: 1234 });
    await recorder.stopRecording('shape4', {
      totalIterations: 2,
      totalTokens: 0,
      durationMs: 0,
      terminationReason: 'completed',
    });
    const evt = readLines('shape4').find((l) => l.event === 'iteration_end') as Record<
      string,
      unknown
    >;
    expect(evt.iteration).toBe(2);
    expect(evt.durationMs).toBe(1234);
  });

  it('recordToolCall 载荷：tool 与 args 对象', async () => {
    recorder.startRecording('shape5');
    recorder.recordToolCall({
      sessionId: 'shape5',
      iteration: 1,
      toolName: 'git_diff',
      args: { a: 1, nested: { k: 'v' } },
    });
    await recorder.stopRecording('shape5', {
      totalIterations: 1,
      totalTokens: 0,
      durationMs: 0,
      terminationReason: 'completed',
    });
    const evt = readLines('shape5').find((l) => l.event === 'tool_call') as Record<string, unknown>;
    expect(evt.tool).toBe('git_diff');
    expect(evt.args).toEqual({ a: 1, nested: { k: 'v' } });
  });

  it('recordToolResult 无 resultPreview/error 时字段为 undefined（JSON 序列化后省略）', async () => {
    recorder.startRecording('shape6');
    recorder.recordToolResult({
      sessionId: 'shape6',
      iteration: 1,
      toolName: 'exec',
      success: true,
      durationMs: 5,
    });
    await recorder.stopRecording('shape6', {
      totalIterations: 1,
      totalTokens: 0,
      durationMs: 0,
      terminationReason: 'completed',
    });
    const evt = readLines('shape6').find((l) => l.event === 'tool_result') as Record<
      string,
      unknown
    >;
    expect(evt.success).toBe(true);
    expect(evt.durationMs).toBe(5);
    expect(evt.resultPreview).toBeUndefined();
    expect(evt.error).toBeUndefined();
  });

  it('session_end 事件载荷：totalIterations/totalTokens/durationMs/terminationReason', async () => {
    recorder.startRecording('shape7');
    await recorder.stopRecording('shape7', {
      totalIterations: 9,
      totalTokens: 7777,
      durationMs: 5500,
      terminationReason: 'max_tokens',
    });
    const end = readLines('shape7').find((l) => l.event === 'session_end') as Record<
      string,
      unknown
    >;
    expect(end).toMatchObject({
      totalIterations: 9,
      totalTokens: 7777,
      durationMs: 5500,
      terminationReason: 'max_tokens',
    });
    expect(end.seq).toBe(1); // start=0, end=1
  });

  it('每条事件都带 sessionId 与 ts（ISO 时间戳）', async () => {
    recorder.startRecording('shape8');
    recorder.recordIterationStart('shape8', 1);
    await recorder.stopRecording('shape8', {
      totalIterations: 1,
      totalTokens: 0,
      durationMs: 0,
      terminationReason: 'completed',
    });
    for (const line of readLines('shape8')) {
      expect(line.sessionId).toBe('shape8');
      expect(new Date(line.ts as string).getTime()).not.toBeNaN();
    }
  });

  it('文件名含时间戳且唯一（ISO 格式无冒号）', () => {
    recorder.startRecording('filename1');
    recorder.startRecording('filename1'); // 同 id 二次 start 覆盖
    const path = recorder.getFilePath('filename1') as string;
    expect(path).toMatch(/session_filename1_\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}\.jsonl$/);
  });
});

describe('SessionRecorder — 生命周期统计细节', () => {
  it('getRecordingStats 统计单个文件字节数正确', async () => {
    const logsDir = join(wsRoot, 'logs');
    const fs = await import('node:fs');
    fs.mkdirSync(logsDir, { recursive: true });
    const content = '{"a":1}\n{"b":2}\n';
    fs.writeFileSync(join(logsDir, 'session_x.jsonl'), content, 'utf-8');
    const stats = recorder.getRecordingStats();
    expect(stats.count).toBe(1);
    expect(stats.totalBytes).toBe(Buffer.byteLength(content));
  });

  it('getRecordingStats 目录无 session 文件时 count=0', async () => {
    const logsDir = join(wsRoot, 'logs');
    const fs = await import('node:fs');
    fs.mkdirSync(logsDir, { recursive: true });
    fs.writeFileSync(join(logsDir, 'other.txt'), 'x', 'utf-8');
    const stats = recorder.getRecordingStats();
    expect(stats.count).toBe(0);
    expect(stats.totalBytes).toBe(0);
  });

  it('startRecording 自动创建 logs 目录并返回符合格式的路径', () => {
    expect(existsSync(join(wsRoot, 'logs'))).toBe(false);
    recorder.startRecording('dir1');
    // 目录立即创建
    expect(existsSync(join(wsRoot, 'logs'))).toBe(true);
    // 路径符合 session_<id>_<ISO 时间戳>.jsonl 格式（文件在首次 flush 后落盘）
    const path = recorder.getFilePath('dir1') as string;
    expect(path).toContain('session_dir1_');
    expect(path.endsWith('.jsonl')).toBe(true);
    // 触发 flush 后文件出现在磁盘
    return new Promise<void>((resolve) => {
      setTimeout(() => {
        expect(existsSync(path)).toBe(true);
        resolve();
      }, 200);
    });
  });

  it('setEnabled(true) 恢复录制（开关可逆；禁用期事件被丢弃）', async () => {
    recorder.setEnabled(false);
    recorder.startRecording('toggle');
    // 禁用期：session_start 被丢弃
    recorder.setEnabled(true);
    recorder.recordIterationStart('toggle', 1);
    await recorder.stopRecording('toggle', {
      totalIterations: 1,
      totalTokens: 0,
      durationMs: 0,
      terminationReason: 'completed',
    });
    const events = readLines('toggle').map((l) => l.event);
    expect(events).toEqual(['iteration_start', 'session_end']);
  });
});