claude-code-session-manager 0.98.0 → 0.101.0

package/src/main/__tests__/transcripts-paged-reads.test.cjs

@@ -1,241 +0,0 @@
-/**
- * transcripts-paged-reads.test.cjs — unit tests for the line-offset index +
- * paged-read API that replaced transcripts.cjs's 500-entry ring buffer
- * (PRD 979). Covers:
- *  - scrolling to the top of a >500-event session returns the genuine first
- *    event via readPage/pageEvents, not a truncated window
- *  - paging is a bounded positional read, never a whole-file materialization
- *  - bounded memory: indexing a huge number of lines (plus one multi-MB
- *    line) keeps the persisted index far smaller than the raw content
- *  - inode-change rotation and truncation invalidate and rebuild the index
- *  - a partial trailing line is never indexed until it completes
- *  - a malformed JSON line still occupies its index slot (line numbering
- *    stays correct)
- *  - release()/re-subscribe fast-resume preserves the index, not just offset
- *  - paging never re-emits to OTEL (only the live doFlush ingest path does)
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/transcripts-paged-reads.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, release, closeTab, transcriptPath, pageEvents } = require('../transcripts.cjs');
-const otel = require('../otel.cjs');
-
-let cwd;
-
-beforeEach(() => {
-  cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-paged-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. Thousands
-  // 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('paging to line 0 of a >500-event session returns the genuine first event', async () => {
-  const sessionId = 'sess-page-top';
-  const tabId = 'tab-page-top';
-  const lines = Array.from({ length: 800 }, (_, i) => ({
-    type: 'user',
-    message: { content: [{ type: 'text', text: `event number ${i}` }] },
-  }));
-  writeTranscript(cwd, sessionId, lines);
-
-  const res = await subscribe({ tabId, cwd, sessionUuid: sessionId });
-  expect(res.ok).toBe(true);
-
-  const top = await pageEvents(tabId, 0, 0);
-  expect(top.totalLines).toBe(800);
-  expect(top.events).toHaveLength(1);
-  expect(top.events[0].data).toBe('event number 0');
-  expect(top.events[0].lineNumber).toBe(0);
-
-  const bottom = await pageEvents(tabId, 799, 799);
-  expect(bottom.events[0].data).toBe('event number 799');
-
-  closeTab(tabId);
-});
-
-test('bounded memory: indexing many lines plus one multi-MB line keeps the index far smaller than the raw content', async () => {
-  const sessionId = 'sess-bounded';
-  const tabId = 'tab-bounded';
-  const NUM_LINES = 20000;
-  const bigLineIndex = 10000;
-  const bigText = 'x'.repeat(5 * 1024 * 1024); // 5MB single line
-  const lines = Array.from({ length: NUM_LINES }, (_, i) => {
-    if (i === bigLineIndex) {
-      return { type: 'user', message: { content: [{ type: 'text', text: bigText }] } };
-    }
-    return { type: 'user', message: { content: [{ type: 'text', text: `line ${i}` }] } };
-  });
-  writeTranscript(cwd, sessionId, lines);
-
-  const res = await subscribe({ tabId, cwd, sessionUuid: sessionId });
-  expect(res.ok).toBe(true);
-
-  const sub = require('../transcripts.cjs').__getSubForTest?.(tabId);
-  // Fall back to reading the module's internal state via pageEvents' totalLines
-  // if the internal accessor isn't exported; either way, assert the ceiling on
-  // what actually persists: the index itself, not the file content.
-  const { totalLines } = await pageEvents(tabId, 0, 0);
-  expect(totalLines).toBe(NUM_LINES);
-
-  // Each index entry is two small integers (byteOffset, byteLength). Even a
-  // generous 64 bytes/entry ceiling for NUM_LINES entries is three orders of
-  // magnitude below the 5MB+ raw content of the one huge line — proving the
-  // index never holds the line's actual text.
-  const CEILING_BYTES = NUM_LINES * 64;
-  expect(CEILING_BYTES).toBeLessThan(bigText.length);
-  if (sub) {
-    const approxIndexBytes = sub.lineIndex.length * 16; // 2 numbers/entry
-    expect(approxIndexBytes).toBeLessThan(CEILING_BYTES);
-    // The big line's text must not appear anywhere in the index entries.
-    for (const entry of sub.lineIndex) {
-      expect(Object.keys(entry).sort()).toEqual(['byteLength', 'byteOffset']);
-    }
-  }
-
-  closeTab(tabId);
-});
-
-test('inode-change rotation invalidates and rebuilds the index — no stale offsets served', async () => {
-  const sessionId = 'sess-rotate';
-  const tabId = 'tab-rotate';
-  const filePath = writeTranscript(cwd, sessionId, [
-    { type: 'user', message: { content: [{ type: 'text', text: 'old-a' }] } },
-    { type: 'user', message: { content: [{ type: 'text', text: 'old-b' }] } },
-  ]);
-
-  const res = await subscribe({ tabId, cwd, sessionUuid: sessionId });
-  expect(res.ok).toBe(true);
-  let page = await pageEvents(tabId, 0, 1);
-  expect(page.totalLines).toBe(2);
-
-  // Simulate log rotation: unlink + recreate (new inode) with different content.
-  fs.unlinkSync(filePath);
-  fs.writeFileSync(filePath, [{ type: 'user', message: { content: [{ type: 'text', text: 'new-a' }] } }].map((l) => JSON.stringify(l)).join('\n') + '\n');
-
-  // The chokidar watcher on the live sub picks up the rotation and rebuilds
-  // the index via readDelta's inode-change reset — poll (bounded) rather
-  // than assume a fixed debounce delay.
-  // 30s ceiling, not 5s: the watcher event is starved under heavy CPU contention; the loop
-  // exits the instant the condition holds so idle cost is unchanged.
-  const deadline = Date.now() + 30000;
-  while (Date.now() < deadline) {
-    page = await pageEvents(tabId, 0, 0);
-    if (page.totalLines === 1 && page.events[0]?.data === 'new-a') break;
-    await new Promise((r) => setTimeout(r, 50));
-  }
-  expect(page.totalLines).toBe(1);
-  expect(page.events[0].data).toBe('new-a');
-  closeTab(tabId);
-}, 40000);
-
-test('a partial trailing line is not indexed until it completes', async () => {
-  const sessionId = 'sess-partial';
-  const tabId = 'tab-partial';
-  const filePath = transcriptPath(cwd, sessionId);
-  fs.mkdirSync(path.dirname(filePath), { recursive: true });
-  const complete = JSON.stringify({ type: 'user', message: { content: [{ type: 'text', text: 'first' }] } });
-  // No trailing newline — this line is "still being written".
-  fs.writeFileSync(filePath, complete + '\n' + '{"type":"user","message":{"content":[{"type":"text","text":"unfinishe');
-
-  const res = await subscribe({ tabId, cwd, sessionUuid: sessionId });
-  expect(res.ok).toBe(true);
-  let page = await pageEvents(tabId, 0, 10);
-  expect(page.totalLines).toBe(1);
-  expect(page.events[0].data).toBe('first');
-
-  closeTab(tabId);
-});
-
-test('a malformed JSON line still occupies its index slot — line numbering stays correct', async () => {
-  const sessionId = 'sess-malformed';
-  const tabId = 'tab-malformed';
-  const filePath = transcriptPath(cwd, sessionId);
-  fs.mkdirSync(path.dirname(filePath), { recursive: true });
-  const body = [
-    JSON.stringify({ type: 'user', message: { content: [{ type: 'text', text: 'ok-0' }] } }),
-    'not valid json {{{',
-    JSON.stringify({ type: 'user', message: { content: [{ type: 'text', text: 'ok-2' }] } }),
-  ].join('\n') + '\n';
-  fs.writeFileSync(filePath, body);
-
-  const res = await subscribe({ tabId, cwd, sessionUuid: sessionId });
-  expect(res.ok).toBe(true);
-  const page = await pageEvents(tabId, 0, 2);
-  expect(page.totalLines).toBe(3);
-  // Malformed line 1 produces no event, but line 2's numbering is unaffected.
-  expect(page.events.map((e) => e.lineNumber)).toEqual([0, 2]);
-  expect(page.events[1].data).toBe('ok-2');
-
-  closeTab(tabId);
-});
-
-test('release()/re-subscribe fast-resume preserves the index rather than re-reading from byte 0', async () => {
-  const sessionId = 'sess-resume';
-  const tabId = 'tab-resume';
-  writeTranscript(cwd, sessionId, [
-    { type: 'user', message: { content: [{ type: 'text', text: 'a' }] } },
-    { type: 'user', message: { content: [{ type: 'text', text: 'b' }] } },
-  ]);
-
-  const res = await subscribe({ tabId, cwd, sessionUuid: sessionId });
-  expect(res.ok).toBe(true);
-  const before = await pageEvents(tabId, 0, 1);
-  expect(before.totalLines).toBe(2);
-
-  release(tabId); // view-switch away — sub stays cached
-  // Re-subscribing the same tab should promote it back from the LRU cache
-  // rather than re-reading the transcript from scratch.
-  const res2 = await subscribe({ tabId, cwd, sessionUuid: sessionId });
-  expect(res2.ok).toBe(true);
-  const after = await pageEvents(tabId, 0, 1);
-  expect(after.totalLines).toBe(2);
-  expect(after.events.map((e) => e.data)).toEqual(['a', 'b']);
-
-  closeTab(tabId);
-});
-
-test('paging never re-emits to OTEL — only the live doFlush ingest path records', async () => {
-  const sessionId = 'sess-otel';
-  const tabId = 'tab-otel';
-  writeTranscript(cwd, sessionId, [
-    { type: 'user', message: { content: 'one' } },
-    { type: 'user', message: { content: 'two' } },
-  ]);
-
-  const spy = vi.spyOn(otel, 'recordTranscriptEvent');
-  const res = await subscribe({ tabId, cwd, sessionUuid: sessionId });
-  expect(res.ok).toBe(true);
-  const callsAfterSubscribe = spy.mock.calls.length;
-  expect(callsAfterSubscribe).toBeGreaterThan(0); // initial drain recorded both events
-
-  // Page over the same range repeatedly — must not add more OTEL calls.
-  await pageEvents(tabId, 0, 1);
-  await pageEvents(tabId, 0, 1);
-  await pageEvents(tabId, 0, 0);
-  expect(spy.mock.calls.length).toBe(callsAfterSubscribe);
-
-  spy.mockRestore();
-  closeTab(tabId);
-});

package/src/main/__tests__/transcripts-worktree-epic-path.test.cjs

@@ -1,154 +0,0 @@
-/**
- * transcripts-worktree-epic-path.test.cjs — transcriptPath()/subscribe() resolve
- * an Epic's transcript through epicTranscriptPath (worktree encoding), while a
- * non-Epic tab keeps the plain project encoding. Includes a parity check of the
- * renderer's transcriptExists() (EpicTerminalPane's resume-vs-create decision)
- * against the REAL transcriptPath instead of a constant mock.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/transcripts-worktree-epic-path.test.cjs
- */
-
-'use strict';
-
-import { test, expect, beforeAll, afterAll, beforeEach, afterEach, vi } from 'vitest';
-import { transcriptExists } from '../../renderer/lib/transcriptExists';
-
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-
-let tmpHome;
-let originalHome;
-let tr;
-let resolver;
-let encodeCwd;
-let proj;
-const SID = 'b8a5d6f4-0092-4db0-a687-009241f2a8b2';
-const WT = '/tmp/sm-wt-test-epic-worktree-dir';
-
-beforeAll(() => {
-  originalHome = process.env.HOME;
-  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-transcripts-wt-home-'));
-  process.env.HOME = tmpHome;
-  tr = require('../transcripts.cjs');
-  resolver = require('../lib/epicTranscriptPath.cjs');
-  ({ encodeCwd } = require('../lib/encodeCwd.cjs'));
-});
-
-afterAll(() => {
-  process.env.HOME = originalHome;
-  fs.rmSync(tmpHome, { recursive: true, force: true });
-});
-
-beforeEach(() => {
-  resolver.__resetCacheForTests();
-  proj = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-transcripts-wt-proj-'));
-});
-
-afterEach(() => {
-  fs.rmSync(proj, { recursive: true, force: true });
-  fs.rmSync(path.join(tmpHome, '.claude'), { recursive: true, force: true });
-  vi.unstubAllGlobals();
-});
-
-const projectsDir = () => path.join(tmpHome, '.claude', 'projects');
-const plain = (cwd, id = SID) => path.join(projectsDir(), encodeCwd(cwd), `${id}.jsonl`);
-
-function writeIndex(sessionId = SID) {
-  const dir = path.join(proj, 'session-manager-operations', 'prompt-sessions');
-  fs.mkdirSync(dir, { recursive: true });
-  const s = { id: 'epic-1', cwd: proj, claudeSessionId: sessionId, status: 'active', worktree: { dir: WT, branch: 'sm-epic/epic-1', baseCwd: proj, status: 'active' } };
-  fs.writeFileSync(path.join(dir, 'active-index.json'), JSON.stringify({ sessions: { 'epic-1': s }, events: {} }));
-}
-
-function writeTranscript(p, body = '{"type":"user"}\n') {
-  fs.mkdirSync(path.dirname(p), { recursive: true });
-  fs.writeFileSync(p, body);
-}
-
-test('worktree-present: transcript only under the worktree encoding resolves there', () => {
-  writeIndex();
-  fs.mkdirSync(WT, { recursive: true });
-  try {
-    writeTranscript(plain(WT));
-    expect(tr.transcriptPath(proj, SID)).toBe(plain(WT));
-  } finally {
-    fs.rmSync(WT, { recursive: true, force: true });
-  }
-});
-
-test('worktree-swept: worktree dir gone from disk, transcript still found', () => {
-  writeIndex();
-  expect(fs.existsSync(WT)).toBe(false);
-  writeTranscript(plain(WT));
-  expect(tr.transcriptPath(proj, SID)).toBe(plain(WT));
-});
-
-test('non-Epic tab resolves to exactly the pre-change path, even when an Epic exists', () => {
-  writeIndex();
-  writeTranscript(plain(WT));
-  const rawTab = 'raw-tab-id-123';
-  expect(tr.transcriptPath(proj, rawTab)).toBe(path.join(os.homedir(), '.claude', 'projects', encodeCwd(proj), `${rawTab}.jsonl`));
-  // no index at all
-  const other = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-transcripts-wt-other-'));
-  try {
-    expect(tr.transcriptPath(other, SID)).toBe(plain(other));
-    expect(path.isAbsolute(tr.transcriptPath(other, SID))).toBe(true);
-  } finally {
-    fs.rmSync(other, { recursive: true, force: true });
-  }
-});
-
-test('zero-byte transcript counts as existing and does not break usageFor', async () => {
-  writeIndex();
-  writeTranscript(plain(WT), '');
-  expect(tr.transcriptPath(proj, SID)).toBe(plain(WT));
-  const out = await tr.usageFor(proj, [SID]);
-  expect(out).toHaveProperty(SID);
-});
-
-test('subscribe does NOT mkdir when a transcript exists elsewhere (worktree encoding)', async () => {
-  writeIndex();
-  writeTranscript(plain(WT));
-  const before = fs.readdirSync(projectsDir()).sort();
-  const res = await tr.subscribe({ tabId: 'tab-wt', cwd: proj, sessionUuid: SID });
-  try {
-    expect(res.ok).toBe(true);
-    expect(res.path).toBe(plain(WT));
-    expect(fs.readdirSync(projectsDir()).sort()).toEqual(before);
-    expect(fs.existsSync(path.dirname(plain(proj)))).toBe(false);
-  } finally {
-    tr.closeTab('tab-wt');
-  }
-});
-
-test('subscribe of a brand-new Epic watches the spawn-cwd path and creates its dir', async () => {
-  writeIndex();
-  const res = await tr.subscribe({ tabId: 'tab-new', cwd: proj, sessionUuid: SID });
-  try {
-    expect(res.ok).toBe(true);
-    // no transcript anywhere → resolver's first candidate (spawn cwd), whose dir the CLI will write
-    expect(fs.existsSync(path.dirname(res.path))).toBe(true);
-    expect(fs.existsSync(res.path)).toBe(false);
-  } finally {
-    tr.closeTab('tab-new');
-  }
-});
-
-test('parity: renderer transcriptExists (Terminal resume decision) sees a worktree-only transcript', async () => {
-  writeIndex();
-  vi.stubGlobal('window', {
-    api: {
-      transcripts: { pathFor: async (c, s) => tr.transcriptPath(c, s) },
-      config: { exists: async (p) => fs.existsSync(p) },
-    },
-  });
-  expect(await transcriptExists(proj, SID)).toBe(false);
-  writeTranscript(plain(WT));
-  expect(await transcriptExists(proj, SID)).toBe(true);
-  // zero-byte still "exists"
-  writeTranscript(plain(WT), '');
-  expect(await transcriptExists(proj, SID)).toBe(true);
-  // raw tab never resolves into the Epic's worktree encoding
-  expect(await transcriptExists(proj, 'raw-tab')).toBe(false);
-});

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

@@ -1,206 +0,0 @@
-/**
- * transcriptsUsageFor.test.cjs — unit tests for transcripts.cjs's usageFor(),
- * the batched token-usage reader backing the `transcript:usageFor` IPC (Epics
- * workspace tokens metric).
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/transcriptsUsageFor.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 { usageFor, transcriptPath } = require('../transcripts.cjs');
-
-let cwd;
-
-beforeEach(() => {
-  cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-usage-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. Thousands
-  // 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('sums input/output tokens across usage events in a session transcript', async () => {
-  const sessionId = 'sess-aaaa-1111';
-  writeTranscript(cwd, sessionId, [
-    { type: 'assistant', usage: { input_tokens: 100, output_tokens: 20 } },
-    { type: 'assistant', usage: { input_tokens: 50, output_tokens: 10 } },
-    { type: 'user', message: { content: 'no usage here' } },
-  ]);
-
-  const result = await usageFor(cwd, [sessionId]);
-  expect(result[sessionId]).toEqual({ inputTokens: 150, outputTokens: 30 });
-});
-
-test('maps a session with no transcript file to null', async () => {
-  const result = await usageFor(cwd, ['no-such-session']);
-  expect(result['no-such-session']).toBeNull();
-});
-
-test('batches multiple sessions in one call', async () => {
-  writeTranscript(cwd, 'sess-a', [{ usage: { input_tokens: 5, output_tokens: 1 } }]);
-  writeTranscript(cwd, 'sess-b', [{ usage: { input_tokens: 7, output_tokens: 2 } }]);
-
-  const result = await usageFor(cwd, ['sess-a', 'sess-b', 'sess-missing']);
-  expect(result).toEqual({
-    'sess-a': { inputTokens: 5, outputTokens: 1 },
-    'sess-b': { inputTokens: 7, outputTokens: 2 },
-    'sess-missing': null,
-  });
-});
-
-test('a repeat call against an unchanged file returns the same cached totals', async () => {
-  const sessionId = 'sess-cache';
-  writeTranscript(cwd, sessionId, [{ usage: { input_tokens: 10, output_tokens: 5 } }]);
-
-  const first = await usageFor(cwd, [sessionId]);
-  const second = await usageFor(cwd, [sessionId]);
-  expect(second[sessionId]).toEqual(first[sessionId]);
-  expect(second[sessionId]).toEqual({ inputTokens: 10, outputTokens: 5 });
-});
-
-test('a growing transcript is re-summed after the file mtime/size change', async () => {
-  const sessionId = 'sess-grow';
-  writeTranscript(cwd, sessionId, [{ usage: { input_tokens: 10, output_tokens: 5 } }]);
-  const before = await usageFor(cwd, [sessionId]);
-  expect(before[sessionId]).toEqual({ inputTokens: 10, outputTokens: 5 });
-
-  // Force a distinct mtime — some filesystems have coarse mtime resolution.
-  const filePath = transcriptPath(cwd, sessionId);
-  const future = new Date(Date.now() + 5000);
-  fs.appendFileSync(filePath, JSON.stringify({ usage: { input_tokens: 3, output_tokens: 1 } }) + '\n');
-  fs.utimesSync(filePath, future, future);
-
-  const after = await usageFor(cwd, [sessionId]);
-  expect(after[sessionId]).toEqual({ inputTokens: 13, outputTokens: 6 });
-});
-
-// ── incremental tail parse + bounded cache ─────────────────────────────────
-
-const fsp = require('node:fs/promises');
-const transcripts = require('../transcripts.cjs');
-
-function fromScratch(filePath) {
-  let inputTokens = 0;
-  let outputTokens = 0;
-  for (const line of fs.readFileSync(filePath, 'utf8').split('\n')) {
-    if (!line) continue;
-    let o;
-    try { o = JSON.parse(line); } catch { continue; }
-    const u = o.usage || {};
-    inputTokens += u.input_tokens ?? 0;
-    outputTokens += u.output_tokens ?? 0;
-  }
-  return { inputTokens, outputTokens };
-}
-
-test('incremental result equals a from-scratch parse across 5 appends (partial line + repeated id)', async () => {
-  const sessionId = 'sess-incr';
-  const filePath = writeTranscript(cwd, sessionId, [
-    { id: 'm1', usage: { input_tokens: 10, output_tokens: 1 } },
-  ]);
-  const check = async () => {
-    const r = await usageFor(cwd, [sessionId]);
-    expect(r[sessionId]).toEqual(fromScratch(filePath));
-  };
-  await check();
-  const l2 = JSON.stringify({ id: 'm2', usage: { input_tokens: 20, output_tokens: 2 } });
-  // 1: append ending mid-line
-  fs.appendFileSync(filePath, l2.slice(0, 15));
-  await check();
-  // 2: complete that line
-  fs.appendFileSync(filePath, l2.slice(15) + '\n');
-  await check();
-  // 3: repeat an earlier message id (full parse sums it again)
-  fs.appendFileSync(filePath, JSON.stringify({ id: 'm1', usage: { input_tokens: 10, output_tokens: 1 } }) + '\n');
-  await check();
-  // 4: non-usage + malformed line
-  fs.appendFileSync(filePath, JSON.stringify({ type: 'user' }) + '\nnot json\n');
-  await check();
-  // 5: multibyte content then usage
-  fs.appendFileSync(filePath, JSON.stringify({ t: 'héllo 日本', usage: { input_tokens: 4, output_tokens: 4 } }) + '\n');
-  await check();
-  expect((await usageFor(cwd, [sessionId]))[sessionId]).toEqual({ inputTokens: 44, outputTokens: 8 });
-});
-
-test('the call after a one-line append reads < 4 KB from disk', async () => {
-  const sessionId = 'sess-bytes';
-  const big = Array.from({ length: 2000 }, (_, i) => ({ i, pad: 'x'.repeat(100), usage: { input_tokens: 1, output_tokens: 1 } }));
-  const filePath = writeTranscript(cwd, sessionId, big);
-  await usageFor(cwd, [sessionId]);
-  expect(fs.statSync(filePath).size).toBeGreaterThan(200_000);
-
-  fs.appendFileSync(filePath, JSON.stringify({ usage: { input_tokens: 5, output_tokens: 5 } }) + '\n');
-  const fh = await fsp.open(filePath, 'r');
-  const proto = Object.getPrototypeOf(fh);
-  await fh.close();
-  const orig = proto.read;
-  const lengths = [];
-  const spy = vi.spyOn(proto, 'read').mockImplementation(function (buf, off, len, pos) {
-    lengths.push(len);
-    return orig.call(this, buf, off, len, pos);
-  });
-  try {
-    const r = await usageFor(cwd, [sessionId]);
-    expect(r[sessionId]).toEqual({ inputTokens: 2005, outputTokens: 2005 });
-  } finally {
-    spy.mockRestore();
-  }
-  expect(lengths.length).toBeGreaterThan(0);
-  expect(lengths.reduce((a, b) => a + b, 0)).toBeLessThan(4096);
-});
-
-test('truncation / replacement triggers a full re-parse', async () => {
-  const sessionId = 'sess-trunc';
-  const filePath = writeTranscript(cwd, sessionId, [
-    { usage: { input_tokens: 100, output_tokens: 100 } },
-    { usage: { input_tokens: 100, output_tokens: 100 } },
-  ]);
-  await usageFor(cwd, [sessionId]);
-  fs.writeFileSync(filePath, JSON.stringify({ usage: { input_tokens: 1, output_tokens: 2 } }) + '\n');
-  expect((await usageFor(cwd, [sessionId]))[sessionId]).toEqual({ inputTokens: 1, outputTokens: 2 });
-});
-
-test('usageCache is bounded and evicts the least-recently-used entry', async () => {
-  const cache = transcripts.__usageCacheForTest;
-  const max = transcripts.__usageCacheMaxForTest;
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-usage-lru-'));
-  try {
-    const files = [];
-    for (let i = 0; i < max + 5; i++) {
-      const f = path.join(dir, `s${i}.jsonl`);
-      fs.writeFileSync(f, JSON.stringify({ usage: { input_tokens: 1, output_tokens: 1 } }) + '\n');
-      files.push(f);
-    }
-    const before = cache.size;
-    for (const f of files) {
-      // usageForOne is reached through usageFor's path; call via a cwd-independent route.
-      await transcripts.__usageForOneForTest(f);
-    }
-    expect(cache.size).toBeLessThanOrEqual(max);
-    expect(before).toBeLessThanOrEqual(max);
-    expect(cache.has(files[0])).toBe(false);
-    expect(cache.has(files[files.length - 1])).toBe(true);
-  } finally {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});