claude-code-session-manager 0.98.0 → 0.100.0

package/src/main/__tests__/telemetrySettings.test.cjs

@@ -1,210 +0,0 @@
-/**
- * telemetrySettings.test.cjs — unit tests for the telemetry consent/config store.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/telemetrySettings.test.cjs
- */
-'use strict';
-
-import { test, expect, beforeEach, afterEach } from 'vitest';
-const fs = require('node:fs');
-const fsp = require('node:fs/promises');
-const os = require('node:os');
-const path = require('node:path');
-
-const tmpDirs = [];
-let originalHome;
-
-beforeEach(() => {
-  originalHome = process.env.HOME;
-});
-
-afterEach(async () => {
-  if (originalHome !== undefined) process.env.HOME = originalHome;
-  delete process.env.SM_TELEMETRY;
-  delete process.env.SM_TELEMETRY_ENDPOINT;
-  while (tmpDirs.length) {
-    const d = tmpDirs.pop();
-    await fsp.rm(d, { recursive: true, force: true });
-  }
-});
-
-async function freshModule(home) {
-  process.env.HOME = home;
-  const modPath = require.resolve('../lib/telemetrySettings.cjs');
-  delete require.cache[modPath];
-  delete require.cache[require.resolve('../config.cjs')];
-  return require('../lib/telemetrySettings.cjs');
-}
-
-async function mkHome() {
-  const dir = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-telemetry-home-'));
-  tmpDirs.push(dir);
-  return dir;
-}
-
-test('DEFAULTS carries no identity-shaped key', async () => {
-  const home = await mkHome();
-  const telemetrySettings = await freshModule(home);
-  const keys = Object.keys(telemetrySettings.DEFAULTS);
-  const identityLike = keys.filter((k) => /email|user|name|host|account/i.test(k));
-  expect(identityLike).toEqual([]);
-});
-
-test('isValid rejects a config carrying an unknown extra identity-shaped key', async () => {
-  const home = await mkHome();
-  const telemetrySettings = await freshModule(home);
-  const base = { ...telemetrySettings.DEFAULTS, installId: 'abc' };
-  expect(telemetrySettings.isValid(base)).toBe(true);
-  const withExtra = { ...base, identifyEmail: 'someone@example.com' };
-  expect(telemetrySettings.isValid(withExtra)).toBe(false);
-});
-
-test('load() mints installId once via crypto.randomUUID and persists it', async () => {
-  const home = await mkHome();
-  const telemetrySettings = await freshModule(home);
-
-  const first = await telemetrySettings.load();
-  expect(typeof first.installId).toBe('string');
-  expect(first.installId.length).toBeGreaterThan(0);
-
-  const second = await telemetrySettings.load();
-  expect(second.installId).toBe(first.installId);
-
-  const raw = JSON.parse(fs.readFileSync(telemetrySettings.storePath(), 'utf8'));
-  expect(raw.installId).toBe(first.installId);
-
-  const freshRead = await freshModule(home);
-  const third = await freshRead.load();
-  expect(third.installId).toBe(first.installId);
-});
-
-test('isEnabled: hard kill switch SM_TELEMETRY=0 overrides persisted enabled:true', async () => {
-  const home = await mkHome();
-  const telemetrySettings = await freshModule(home);
-  const cfg = { ...telemetrySettings.DEFAULTS, installId: 'x', enabled: true };
-  process.env.SM_TELEMETRY = '0';
-  expect(telemetrySettings.isEnabled(cfg)).toBe(false);
-});
-
-test('isEnabled: returns false when persisted enabled is false', async () => {
-  const home = await mkHome();
-  const telemetrySettings = await freshModule(home);
-  const cfg = { ...telemetrySettings.DEFAULTS, installId: 'x', enabled: false };
-  expect(telemetrySettings.isEnabled(cfg)).toBe(false);
-});
-
-test('isEnabled: returns true when persisted enabled is true and no kill switch', async () => {
-  const home = await mkHome();
-  const telemetrySettings = await freshModule(home);
-  const cfg = { ...telemetrySettings.DEFAULTS, installId: 'x', enabled: true };
-  expect(telemetrySettings.isEnabled(cfg)).toBe(true);
-});
-
-test('resolveEndpoint prefers SM_TELEMETRY_ENDPOINT over persisted endpoint', async () => {
-  const home = await mkHome();
-  const telemetrySettings = await freshModule(home);
-  const cfg = { ...telemetrySettings.DEFAULTS, installId: 'x', endpoint: 'https://persisted.example' };
-  process.env.SM_TELEMETRY_ENDPOINT = 'https://env-override.example';
-  expect(telemetrySettings.resolveEndpoint(cfg)).toBe('https://env-override.example');
-});
-
-test('resolveEndpoint falls back to persisted endpoint when no env override', async () => {
-  const home = await mkHome();
-  const telemetrySettings = await freshModule(home);
-  const cfg = { ...telemetrySettings.DEFAULTS, installId: 'x', endpoint: 'https://persisted.example' };
-  expect(telemetrySettings.resolveEndpoint(cfg)).toBe('https://persisted.example');
-});
-
-test('isDailyFlushDue: true when lastDailyFlushAt is null', async () => {
-  const home = await mkHome();
-  const telemetrySettings = await freshModule(home);
-  const cfg = { ...telemetrySettings.DEFAULTS, installId: 'x', lastDailyFlushAt: null };
-  expect(telemetrySettings.isDailyFlushDue(cfg, Date.now())).toBe(true);
-});
-
-test('isDailyFlushDue: false when lastDailyFlushAt is 23h before now', async () => {
-  const home = await mkHome();
-  const telemetrySettings = await freshModule(home);
-  const now = Date.now();
-  const cfg = { ...telemetrySettings.DEFAULTS, installId: 'x', lastDailyFlushAt: new Date(now - 23 * 60 * 60 * 1000).toISOString() };
-  expect(telemetrySettings.isDailyFlushDue(cfg, now)).toBe(false);
-});
-
-test('isDailyFlushDue: true when lastDailyFlushAt is 25h before now', async () => {
-  const home = await mkHome();
-  const telemetrySettings = await freshModule(home);
-  const now = Date.now();
-  const cfg = { ...telemetrySettings.DEFAULTS, installId: 'x', lastDailyFlushAt: new Date(now - 25 * 60 * 60 * 1000).toISOString() };
-  expect(telemetrySettings.isDailyFlushDue(cfg, now)).toBe(true);
-});
-
-test('isMachineReportDue: true when app version changed', async () => {
-  const home = await mkHome();
-  const telemetrySettings = await freshModule(home);
-  const now = Date.now();
-  const cfg = {
-    ...telemetrySettings.DEFAULTS,
-    installId: 'x',
-    lastMachineReportVersion: '0.80.0',
-    lastMachineReportAt: new Date(now).toISOString(),
-  };
-  expect(telemetrySettings.isMachineReportDue(cfg, { now, appVersion: '0.81.0' })).toBe(true);
-});
-
-test('isMachineReportDue: true when lastMachineReportAt is null (same version)', async () => {
-  const home = await mkHome();
-  const telemetrySettings = await freshModule(home);
-  const now = Date.now();
-  const cfg = { ...telemetrySettings.DEFAULTS, installId: 'x', lastMachineReportVersion: '0.81.0', lastMachineReportAt: null };
-  expect(telemetrySettings.isMachineReportDue(cfg, { now, appVersion: '0.81.0' })).toBe(true);
-});
-
-test('isMachineReportDue: true when lastMachineReportAt is more than 30 days before now (same version)', async () => {
-  const home = await mkHome();
-  const telemetrySettings = await freshModule(home);
-  const now = Date.now();
-  const thirtyOneDaysAgo = new Date(now - 31 * 24 * 60 * 60 * 1000).toISOString();
-  const cfg = { ...telemetrySettings.DEFAULTS, installId: 'x', lastMachineReportVersion: '0.81.0', lastMachineReportAt: thirtyOneDaysAgo };
-  expect(telemetrySettings.isMachineReportDue(cfg, { now, appVersion: '0.81.0' })).toBe(true);
-});
-
-test('save() merges a partial patch onto a fresh disk read — concurrent savers do not clobber each other', async () => {
-  const home = await mkHome();
-  const telemetrySettings = await freshModule(home);
-  const base = await telemetrySettings.load(); // mints + persists installId
-  expect(base.installId).not.toBe('');
-
-  // Two independent writers, each stamping a DIFFERENT field, racing each
-  // other — mirrors telemetryBoot's install-report stamp landing around the
-  // same time as telemetryClient's own daily-flush stamp. Neither holds the
-  // other's snapshot; each passes only the field it intends to change.
-  await Promise.all([
-    telemetrySettings.save({ lastMachineReportAt: '2026-01-01T00:00:00.000Z', lastMachineReportVersion: '2.0.0' }),
-    telemetrySettings.save({ lastDailyFlushAt: '2026-01-01T01:00:00.000Z' }),
-  ]);
-
-  const onDisk = await telemetrySettings.load();
-  expect(onDisk.lastMachineReportAt).toBe('2026-01-01T00:00:00.000Z');
-  expect(onDisk.lastMachineReportVersion).toBe('2.0.0');
-  expect(onDisk.lastDailyFlushAt).toBe('2026-01-01T01:00:00.000Z');
-  // Neither save touched installId/enabled/endpoint — they must survive too.
-  expect(onDisk.installId).toBe(base.installId);
-  expect(onDisk.enabled).toBe(base.enabled);
-  expect(onDisk.endpoint).toBe(base.endpoint);
-});
-
-test('save() rejects an unknown key without touching disk', async () => {
-  const home = await mkHome();
-  const telemetrySettings = await freshModule(home);
-  await telemetrySettings.load();
-  await expect(telemetrySettings.save({ notARealField: 'x' })).rejects.toThrow('Invalid telemetry config');
-});
-
-test('isMachineReportDue: false when same version and reported less than 30 days ago', async () => {
-  const home = await mkHome();
-  const telemetrySettings = await freshModule(home);
-  const now = Date.now();
-  const oneDayAgo = new Date(now - 24 * 60 * 60 * 1000).toISOString();
-  const cfg = { ...telemetrySettings.DEFAULTS, installId: 'x', lastMachineReportVersion: '0.81.0', lastMachineReportAt: oneDayAgo };
-  expect(telemetrySettings.isMachineReportDue(cfg, { now, appVersion: '0.81.0' })).toBe(false);
-});

package/src/main/__tests__/transcripts-batch-flush.test.cjs

@@ -1,249 +0,0 @@
-/**
- * transcripts-batch-flush.test.cjs — unit tests for the batched IPC flush
- * (PRD transcript-batch-flush): transcripts.cjs's doFlush now sends the
- * events produced by ONE flush as a SINGLE `transcript:event:<tabId>` IPC
- * message (an array), instead of one message per event, while still
- * recording one OTEL span per event and preserving exact event order.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/transcripts-batch-flush.test.cjs
- */
-
-'use strict';
-
-import { test, expect, beforeEach, afterEach, vi } from 'vitest';
-
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-
-const {
-  subscribe,
-  closeTab,
-  transcriptPath,
-  attachWindow,
-  __getSubForTest,
-  __doFlushForTest,
-  MAX_EVENTS_PER_BATCH,
-} = require('../transcripts.cjs');
-const otel = require('../otel.cjs');
-
-let cwd;
-
-beforeEach(() => {
-  cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-batch-flush-test-'));
-});
-
-afterEach(() => {
-  fs.rmSync(cwd, { recursive: true, force: true });
-  fs.rmSync(path.dirname(transcriptPath(cwd, 'x')), { recursive: true, force: true });
-  attachWindow(null);
-});
-
-function writeTranscript(cwdArg, sessionId, lines) {
-  const filePath = transcriptPath(cwdArg, sessionId);
-  fs.mkdirSync(path.dirname(filePath), { recursive: true });
-  fs.writeFileSync(filePath, lines.map((l) => JSON.stringify(l)).join('\n') + '\n');
-  return filePath;
-}
-
-function appendTranscript(filePath, lines) {
-  fs.appendFileSync(filePath, lines.map((l) => JSON.stringify(l)).join('\n') + '\n');
-}
-
-/** A fake BrowserWindow that records every webContents.send call. */
-function makeFakeWindow() {
-  const sent = [];
-  return {
-    sent,
-    isDestroyed: () => false,
-    webContents: {
-      isDestroyed: () => false,
-      isCrashed: () => false,
-      send: (channel, payload) => sent.push({ channel, payload }),
-    },
-  };
-}
-
-function assistantLine(text, toolId) {
-  return {
-    type: 'assistant',
-    message: {
-      content: [
-        { type: 'text', text },
-        { type: 'tool_use', name: 'Bash', id: toolId, input: { command: 'ls' } },
-      ],
-    },
-  };
-}
-
-test('one flush with several multi-event lines sends exactly ONE IPC message carrying the whole ordered batch', async () => {
-  const sessionId = 'sess-one-batch';
-  const tabId = 'tab-one-batch';
-  const filePath = writeTranscript(cwd, sessionId, []);
-
-  const res = await subscribe({ tabId, cwd, sessionUuid: sessionId });
-  expect(res.ok).toBe(true);
-
-  const win = makeFakeWindow();
-  attachWindow(win);
-
-  // 5 lines * 2 events each = 10 events, well under MAX_EVENTS_PER_BATCH.
-  appendTranscript(
-    filePath,
-    Array.from({ length: 5 }, (_, i) => assistantLine(`line ${i}`, `tu-${i}`)),
-  );
-  const sub = __getSubForTest(tabId);
-  await sub.watcher?.close();
-  await __doFlushForTest(sub);
-
-  const messages = win.sent.filter((m) => m.channel === `transcript:event:${tabId}`);
-  expect(messages).toHaveLength(1);
-  expect(Array.isArray(messages[0].payload)).toBe(true);
-  expect(messages[0].payload).toHaveLength(10);
-  // Event order preserved: text/tool_use pairs in line order.
-  expect(messages[0].payload.map((e) => e.kind)).toEqual([
-    'assistant', 'tool_use', 'assistant', 'tool_use', 'assistant', 'tool_use', 'assistant', 'tool_use', 'assistant', 'tool_use',
-  ]);
-  expect(messages[0].payload.map((e) => e.data?.id ?? e.data).filter(Boolean)).toEqual(
-    expect.arrayContaining(['tu-0', 'tu-1', 'tu-2', 'tu-3', 'tu-4']),
-  );
-
-  closeTab(tabId);
-});
-
-test('order is preserved exactly across a multi-event flush (matches per-event order semantics)', async () => {
-  const sessionId = 'sess-order';
-  const tabId = 'tab-order';
-  const filePath = writeTranscript(cwd, sessionId, []);
-  const res = await subscribe({ tabId, cwd, sessionUuid: sessionId });
-  expect(res.ok).toBe(true);
-
-  const win = makeFakeWindow();
-  attachWindow(win);
-
-  appendTranscript(filePath, [
-    { type: 'user', message: { content: 'first' } },
-    assistantLine('second', 'tu-order-1'),
-    { type: 'user', message: { content: 'third' } },
-  ]);
-  const sub = __getSubForTest(tabId);
-  await sub.watcher?.close();
-  await __doFlushForTest(sub);
-
-  const messages = win.sent.filter((m) => m.channel === `transcript:event:${tabId}`);
-  expect(messages).toHaveLength(1);
-  const kinds = messages[0].payload.map((e) => e.kind);
-  const texts = messages[0].payload.map((e) =>
-    typeof e.data === 'string' ? e.data : e.data?.id ?? e.data?.message?.content,
-  );
-  expect(kinds).toEqual(['user', 'assistant', 'tool_use', 'user']);
-  expect(texts).toEqual(['first', 'second', 'tu-order-1', 'third']);
-
-  closeTab(tabId);
-});
-
-test('OTEL still records ONE span per event, not one per batch', async () => {
-  const sessionId = 'sess-otel-batch';
-  const tabId = 'tab-otel-batch';
-  const filePath = writeTranscript(cwd, sessionId, []);
-  const res = await subscribe({ tabId, cwd, sessionUuid: sessionId });
-  expect(res.ok).toBe(true);
-
-  const win = makeFakeWindow();
-  attachWindow(win);
-
-  const spy = vi.spyOn(otel, 'recordTranscriptEvent');
-  const before = spy.mock.calls.length;
-
-  appendTranscript(
-    filePath,
-    Array.from({ length: 6 }, (_, i) => assistantLine(`otel line ${i}`, `otel-tu-${i}`)),
-  );
-  const sub = __getSubForTest(tabId);
-  await sub.watcher?.close();
-  await __doFlushForTest(sub);
-
-  // 6 lines * 2 events = 12 spans, sent as one IPC batch.
-  expect(spy.mock.calls.length - before).toBe(12);
-  const messages = win.sent.filter((m) => m.channel === `transcript:event:${tabId}`);
-  expect(messages).toHaveLength(1);
-  expect(messages[0].payload).toHaveLength(12);
-
-  spy.mockRestore();
-  closeTab(tabId);
-});
-
-test('backpressure: a flush producing more than MAX_EVENTS_PER_BATCH events is sent as multiple ordered, capped batches', async () => {
-  const sessionId = 'sess-backpressure';
-  const tabId = 'tab-backpressure';
-  const filePath = writeTranscript(cwd, sessionId, []);
-  const res = await subscribe({ tabId, cwd, sessionUuid: sessionId });
-  expect(res.ok).toBe(true);
-
-  const win = makeFakeWindow();
-  attachWindow(win);
-
-  // Each line yields 2 events; pick a line count that produces more than
-  // 2x the cap so at least 3 batches are required.
-  const lineCount = Math.ceil((MAX_EVENTS_PER_BATCH * 2.5) / 2);
-  const totalEvents = lineCount * 2;
-  appendTranscript(
-    filePath,
-    Array.from({ length: lineCount }, (_, i) => assistantLine(`bp line ${i}`, `bp-tu-${i}`)),
-  );
-  const sub = __getSubForTest(tabId);
-  await sub.watcher?.close();
-  await __doFlushForTest(sub);
-
-  const messages = win.sent.filter((m) => m.channel === `transcript:event:${tabId}`);
-  expect(messages.length).toBeGreaterThan(1);
-  for (const m of messages) {
-    expect(m.payload.length).toBeLessThanOrEqual(MAX_EVENTS_PER_BATCH);
-  }
-  // Concatenating every batch in send order reproduces the full ordered
-  // event list — no event dropped, none duplicated, none reordered.
-  const flattened = messages.flatMap((m) => m.payload);
-  expect(flattened).toHaveLength(totalEvents);
-  const ids = flattened.map((e) => (e.kind === 'tool_use' ? e.data.id : null)).filter(Boolean);
-  expect(ids).toEqual(Array.from({ length: lineCount }, (_, i) => `bp-tu-${i}`));
-
-  closeTab(tabId);
-});
-
-test('benchmark: IPC message count drops from N-per-event to a small number of batches for a 20+ event flush', async () => {
-  const sessionId = 'sess-benchmark';
-  const tabId = 'tab-benchmark';
-  const filePath = writeTranscript(cwd, sessionId, []);
-  const res = await subscribe({ tabId, cwd, sessionUuid: sessionId });
-  expect(res.ok).toBe(true);
-
-  const win = makeFakeWindow();
-  attachWindow(win);
-
-  // 12 lines * 2 events = 24 events — at least 20, comfortably under one cap.
-  const lineCount = 12;
-  appendTranscript(
-    filePath,
-    Array.from({ length: lineCount }, (_, i) => assistantLine(`bench line ${i}`, `bench-tu-${i}`)),
-  );
-  const sub = __getSubForTest(tabId);
-  await sub.watcher?.close();
-  await __doFlushForTest(sub);
-
-  const messages = win.sent.filter((m) => m.channel === `transcript:event:${tabId}`);
-  const totalEvents = messages.reduce((n, m) => n + m.payload.length, 0);
-  expect(totalEvents).toBeGreaterThanOrEqual(20);
-
-  // BEFORE this PRD: doFlush sent one IPC message PER EVENT, so a 24-event
-  // flush meant 24 messages and (in the renderer) 24 store commits. AFTER:
-  // one message per flush (bounded by MAX_EVENTS_PER_BATCH), so the same
-  // flush is 1 message — a >20x reduction in IPC round-trips, and the
-  // renderer's live.ts/chat.ts now fold that one message into exactly one
-  // store commit each (see live.test.ts / chatTranscriptFeed.test.ts).
-  const beforeMessageCount = totalEvents; // one send per event, historically
-  const afterMessageCount = messages.length;
-  expect(afterMessageCount).toBeLessThan(beforeMessageCount);
-  expect(afterMessageCount).toBe(1);
-
-  closeTab(tabId);
-});

package/src/main/__tests__/transcripts-doFlush-array.test.cjs

@@ -1,124 +0,0 @@
-/**
- * transcripts-doFlush-array.test.cjs — unit tests for transcripts.cjs's
- * doFlush()/readDelta() handling of classifyLine's array-of-events shape.
- *
- * Covers: one line producing several events all land in the getBuffer()
- * drain flattened (not nested per line), a session with far more than the
- * old 500-entry ring cap still returns every event via the line-offset
- * index (the cap is gone), and each event's byte `ref` correctly points
- * back at its own line in the transcript file on disk.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/transcripts-doFlush-array.test.cjs
- */
-
-'use strict';
-
-import { test, expect, beforeEach, afterEach } from 'vitest';
-
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-
-const { subscribe, getBuffer, closeTab, transcriptPath } = require('../transcripts.cjs');
-
-let cwd;
-
-beforeEach(() => {
-  cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-doflush-test-'));
-});
-
-afterEach(() => {
-  fs.rmSync(cwd, { recursive: true, force: true });
-  // writeTranscript mkdir -p's this run's folder under the REAL
-  // ~/.claude/projects (that's where transcriptPath resolves to), so leaving
-  // it behind accumulates one phantom project directory per test run — 1760
-  // of them had piled up before this cleanup existed, and Home counted every
-  // one as a project. Remove it with the tmp cwd it mirrors.
-  fs.rmSync(path.dirname(transcriptPath(cwd, 'x')), { recursive: true, force: true });
-});
-
-function writeTranscript(cwdArg, sessionId, lines) {
-  const filePath = transcriptPath(cwdArg, sessionId);
-  fs.mkdirSync(path.dirname(filePath), { recursive: true });
-  fs.writeFileSync(filePath, lines.map((l) => JSON.stringify(l)).join('\n') + '\n');
-  return filePath;
-}
-
-test('a single multi-block line flattens into multiple buffered events', async () => {
-  const sessionId = 'sess-multi';
-  const tabId = 'tab-multi';
-  writeTranscript(cwd, sessionId, [
-    {
-      type: 'assistant',
-      message: {
-        content: [
-          { type: 'text', text: 'doing two things' },
-          { type: 'tool_use', name: 'Bash', id: 'tu-1', input: { command: 'ls' } },
-          { type: 'tool_use', name: 'Bash', id: 'tu-2', input: { command: 'pwd' } },
-        ],
-      },
-    },
-  ]);
-
-  const res = await subscribe({ tabId, cwd, sessionUuid: sessionId });
-  expect(res.ok).toBe(true);
-  const buf = await getBuffer(tabId);
-  expect(buf).toHaveLength(3);
-  expect(buf.map((e) => e.kind)).toEqual(['assistant', 'tool_use', 'tool_use']);
-  closeTab(tabId);
-});
-
-test('a session with far more than the old 500-entry cap still returns every event — the ring cap is gone', async () => {
-  const sessionId = 'sess-cap';
-  const tabId = 'tab-cap';
-  // 200 lines * 3 events each = 600 events > the old 500 cap.
-  const lines = Array.from({ length: 200 }, (_, i) => ({
-    type: 'assistant',
-    message: {
-      content: [
-        { type: 'text', text: `line ${i}` },
-        { type: 'tool_use', name: 'Bash', id: `tu-${i}-a`, input: { command: 'ls' } },
-        { type: 'tool_use', name: 'Bash', id: `tu-${i}-b`, input: { command: 'pwd' } },
-      ],
-    },
-  }));
-  writeTranscript(cwd, sessionId, lines);
-
-  const res = await subscribe({ tabId, cwd, sessionUuid: sessionId });
-  expect(res.ok).toBe(true);
-  const buf = await getBuffer(tabId);
-  expect(buf).toHaveLength(600);
-  // Nothing evicted — both the genuine first and last events survive.
-  expect(buf[0].data).toBe('line 0');
-  expect(buf[buf.length - 1].data.id).toBe('tu-199-b');
-  closeTab(tabId);
-});
-
-test('each event ref points at its own line — re-reading those bytes reproduces that exact line', async () => {
-  const sessionId = 'sess-ref';
-  const tabId = 'tab-ref';
-  const filePath = writeTranscript(cwd, sessionId, [
-    { type: 'user', message: { content: 'first line — some unicode: héllo 🎉' } },
-    { type: 'assistant', message: { content: 'second line' } },
-  ]);
-
-  const res = await subscribe({ tabId, cwd, sessionUuid: sessionId });
-  expect(res.ok).toBe(true);
-  const buf = await getBuffer(tabId);
-  expect(buf).toHaveLength(2);
-
-  const fd = fs.openSync(filePath, 'r');
-  try {
-    for (const ev of buf) {
-      expect(ev.ref).toBeTruthy();
-      expect(ev.ref.filePath).toBe(filePath);
-      const readBuf = Buffer.alloc(ev.ref.byteLength);
-      fs.readSync(fd, readBuf, 0, ev.ref.byteLength, ev.ref.byteOffset);
-      const parsed = JSON.parse(readBuf.toString('utf8'));
-      expect(parsed.type).toBe(ev.kind);
-    }
-  } finally {
-    fs.closeSync(fd);
-  }
-  closeTab(tabId);
-});