claude-code-session-manager 0.98.0 → 0.101.0

package/src/main/__tests__/chatRunner-epic-worktree-execcwd.test.cjs

@@ -1,125 +0,0 @@
-/**
- * chatRunner-epic-worktree-execcwd.test.cjs — PRD 1033, LOAD-BEARING
- * acceptance criterion: an Epic-backed headless `claude -p` run must spawn
- * with its `cwd` spawn option pointed at the Epic's isolated worktree dir
- * when one is recorded, while `session-manager-operations/` for that Epic's
- * project — the ops root — is never touched under the worktree dir. Mirrors
- * scheduler-worktree-exec-cwd.test.cjs's stub-`claude`-binary pattern
- * (SM_CLAUDE_BIN), which chatRunner.cjs's resolveClaudeBin also honors.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/chatRunner-epic-worktree-execcwd.test.cjs
- */
-
-'use strict';
-
-import { test, expect, beforeAll, afterAll, afterEach } from 'vitest';
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-
-let tmpHome;
-let originalHome;
-let cr;
-
-beforeAll(() => {
-  originalHome = process.env.HOME;
-  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-chatrunner-execcwd-home-'));
-  process.env.HOME = tmpHome;
-  cr = require('../chatRunner.cjs');
-});
-
-afterAll(() => {
-  process.env.HOME = originalHome;
-  fs.rmSync(tmpHome, { recursive: true, force: true });
-});
-
-afterEach(() => {
-  delete process.env.SM_CLAUDE_BIN;
-  cr.__resetQueueForTests();
-  cr.attachWindow(null);
-});
-
-// Writes a stub `claude` binary that records ITS OWN process.cwd() to a
-// marker file (proving where it actually ran), then emits a minimal
-// stream-json success result and exits 0 — same pattern as
-// scheduler-worktree-exec-cwd.test.cjs's writeClaudeStub.
-function writeClaudeStub() {
-  const stubPath = path.join(os.tmpdir(), `sm-chatrunner-claude-stub-${process.pid}-${Math.floor(Math.random() * 1e9)}.cjs`);
-  const body = `
-    const fs = require('fs');
-    const path = require('path');
-    fs.writeFileSync(path.join(process.cwd(), 'ran-here.marker'), 'yes', 'utf8');
-    process.stdout.write(JSON.stringify({ type: 'result', subtype: 'success', result: 'ok' }) + '\\n');
-    process.exit(0);
-  `;
-  fs.writeFileSync(stubPath, `#!${process.execPath}\n${body}\n`, { mode: 0o755 });
-  return stubPath;
-}
-
-function writeActiveIndexWithWorktree(cwd, { epicId, claudeSessionId, worktreeDir }) {
-  const dir = path.join(cwd, 'session-manager-operations', 'prompt-sessions');
-  fs.mkdirSync(dir, { recursive: true });
-  const session = {
-    id: epicId,
-    cwd,
-    goalText: 'test epic',
-    claudeSessionId,
-    status: 'active',
-    createdAt: new Date(0).toISOString(),
-    completedAt: null,
-    worktree: { dir: worktreeDir, branch: `sm-epic/${epicId}`, baseCwd: cwd, status: 'active' },
-  };
-  fs.writeFileSync(path.join(dir, 'active-index.json'), JSON.stringify({ sessions: { [epicId]: session }, events: {} }));
-}
-
-async function waitForFile(filePath, timeoutMs = 5000) {
-  const start = Date.now();
-  while (!fs.existsSync(filePath)) {
-    if (Date.now() - start > timeoutMs) throw new Error(`timed out waiting for ${filePath}`);
-    await new Promise((r) => setTimeout(r, 25));
-  }
-}
-
-test('executeRun spawns the claude child in the Epic worktree dir, while the project ops-root is never touched under it', async () => {
-  const mainCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-chatrunner-main-'));
-  const worktreeCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-chatrunner-worktree-'));
-  const sessionId = `epic-sess-${process.pid}`;
-  writeActiveIndexWithWorktree(mainCwd, { epicId: 'epic-1', claudeSessionId: sessionId, worktreeDir: worktreeCwd });
-  process.env.SM_CLAUDE_BIN = writeClaudeStub();
-
-  try {
-    cr.run({ tabId: 'tab-1', sessionId, prompt: 'hello', cwd: mainCwd, resume: false });
-    await waitForFile(path.join(worktreeCwd, 'ran-here.marker'));
-
-    // 1. The child process really ran with cwd = the Epic's worktree dir.
-    expect(fs.existsSync(path.join(worktreeCwd, 'ran-here.marker'))).toBe(true);
-    expect(fs.existsSync(path.join(mainCwd, 'ran-here.marker'))).toBe(false);
-
-    // 2. CRITICAL invariant: session-manager-operations/ for this Epic's
-    // project must never be touched under the worktree dir — only the real
-    // project cwd, which still holds exactly the active-index.json this
-    // test wrote.
-    expect(fs.existsSync(path.join(worktreeCwd, 'session-manager-operations'))).toBe(false);
-    const index = JSON.parse(
-      fs.readFileSync(path.join(mainCwd, 'session-manager-operations', 'prompt-sessions', 'active-index.json'), 'utf8'),
-    );
-    expect(index.sessions['epic-1'].claudeSessionId).toBe(sessionId);
-  } finally {
-    fs.rmSync(mainCwd, { recursive: true, force: true });
-    fs.rmSync(worktreeCwd, { recursive: true, force: true });
-  }
-});
-
-test('executeRun falls back to cwd unchanged when the Epic has no worktree recorded (unchanged behaviour)', async () => {
-  const mainCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-chatrunner-plain-'));
-  const sessionId = `plain-sess-${process.pid}`;
-  process.env.SM_CLAUDE_BIN = writeClaudeStub();
-
-  try {
-    cr.run({ tabId: 'tab-2', sessionId, prompt: 'hello', cwd: mainCwd, resume: false });
-    await waitForFile(path.join(mainCwd, 'ran-here.marker'));
-    expect(fs.existsSync(path.join(mainCwd, 'ran-here.marker'))).toBe(true);
-  } finally {
-    fs.rmSync(mainCwd, { recursive: true, force: true });
-  }
-});

package/src/main/__tests__/chatRunner-session-flag-retry.test.cjs

@@ -1,252 +0,0 @@
-/**
- * chatRunner-session-flag-retry.test.cjs — main is authoritative about
- * --session-id vs --resume, and a CLI flag rejection is retried exactly once
- * with the other flag without losing the turn.
- *
- * Run: timeout 300 npx vitest run src/main/__tests__/chatRunner-session-flag-retry.test.cjs
- */
-
-'use strict';
-
-import { test, expect, beforeAll, afterAll, afterEach } from 'vitest';
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-
-let tmpHome;
-let originalHome;
-let cr;
-let sent;
-
-beforeAll(() => {
-  originalHome = process.env.HOME;
-  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-chatrunner-flagretry-home-'));
-  process.env.HOME = tmpHome;
-  cr = require('../chatRunner.cjs');
-});
-
-afterAll(() => {
-  process.env.HOME = originalHome;
-  fs.rmSync(tmpHome, { recursive: true, force: true });
-});
-
-afterEach(() => {
-  delete process.env.SM_CLAUDE_BIN;
-  cr.__resetQueueForTests();
-  cr.attachWindow(null);
-});
-
-function attachRecorder() {
-  sent = [];
-  cr.attachWindow({
-    isDestroyed: () => false,
-    webContents: { isDestroyed: () => false, send: (channel, payload) => sent.push({ channel, payload }) },
-  });
-}
-
-// Stub claude: logs its argv (one JSON line per spawn) to logFile. Invocation 1
-// fails with `firstStderr` (optionally after emitting assistant text); later
-// invocations succeed.
-function writeStub(logFile, { firstStderr, textFirst, alwaysFail }) {
-  const stubPath = path.join(os.tmpdir(), `sm-flagretry-stub-${process.pid}-${Math.floor(Math.random() * 1e9)}.cjs`);
-  const body = `
-    const fs = require('fs');
-    const log = ${JSON.stringify(logFile)};
-    fs.appendFileSync(log, JSON.stringify(process.argv.slice(2)) + '\\n');
-    const n = fs.readFileSync(log, 'utf8').trim().split('\\n').length;
-    if (n === 1 || ${alwaysFail ? 'true' : 'false'}) {
-      ${textFirst ? "process.stdout.write(JSON.stringify({ type: 'assistant', message: { content: [{ type: 'text', text: 'partial' }] } }) + '\\n');" : ''}
-      process.stderr.write(${JSON.stringify(firstStderr)});
-      process.exit(1);
-    }
-    process.stdout.write(JSON.stringify({ type: 'result', subtype: 'success', result: 'ok' }) + '\\n');
-    process.exit(0);
-  `;
-  fs.writeFileSync(stubPath, `#!${process.execPath}\n${body}\n`, { mode: 0o755 });
-  return stubPath;
-}
-
-async function waitFor(pred, timeoutMs = 8000) {
-  const start = Date.now();
-  while (!pred()) {
-    if (Date.now() - start > timeoutMs) throw new Error('timed out');
-    await new Promise((r) => setTimeout(r, 25));
-  }
-}
-
-const TERMINAL = ['chat:run:complete', 'chat:run:needs-input', 'chat:run:error'];
-let curTab;
-const terminals = () => sent.filter((e) => TERMINAL.includes(e.channel) && e.payload.tabId === curTab);
-const spawns = (logFile) => fs.readFileSync(logFile, 'utf8').trim().split('\n').map((l) => JSON.parse(l));
-
-test('in-use error on --session-id retries once with --resume; one terminal event; lane freed', async () => {
-  attachRecorder();
-  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-flagretry-cwd-'));
-  const logFile = path.join(cwd, 'argv.log');
-  const sessionId = `flag-sess-${process.pid}`;
-  process.env.SM_CLAUDE_BIN = writeStub(logFile, { firstStderr: `Error: Session ID ${sessionId} is already in use.\n` });
-  try {
-    curTab = 'tab-a';
-    cr.run({ tabId: 'tab-a', sessionId, prompt: 'hello', cwd, resume: false });
-    await waitFor(() => terminals().length > 0);
-    await new Promise((r) => setTimeout(r, 100));
-
-    const argvs = spawns(logFile);
-    expect(argvs).toHaveLength(2);
-    expect(argvs[0]).toContain('--session-id');
-    expect(argvs[1]).toContain('--resume');
-    expect(argvs[1]).not.toContain('--session-id');
-    expect(argvs[1][argvs[1].indexOf('--model') + 1]).toBe(argvs[0][argvs[0].indexOf('--model') + 1]);
-    expect(argvs[1][1]).toBe(argvs[0][1]);
-
-    expect(terminals()).toHaveLength(1);
-    expect(terminals()[0].channel).toBe('chat:run:complete');
-    expect(sent.some((e) => e.channel === 'chat:run:notice')).toBe(true);
-
-    // Lane freed: the same tab accepts a new run immediately (not queued).
-    const again = cr.run({ tabId: 'tab-a', sessionId, prompt: 'again', cwd, resume: true });
-    expect(again.queued).toBe(false);
-    await cr.cancel('tab-a');
-  } finally {
-    fs.rmSync(cwd, { recursive: true, force: true });
-  }
-});
-
-test('no retry when the failed attempt already streamed assistant text', async () => {
-  attachRecorder();
-  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-flagretry-cwd-'));
-  const logFile = path.join(cwd, 'argv.log');
-  const sessionId = `flag-sess2-${process.pid}`;
-  process.env.SM_CLAUDE_BIN = writeStub(logFile, {
-    firstStderr: `Error: Session ID ${sessionId} is already in use.\n`,
-    textFirst: true,
-  });
-  try {
-    curTab = 'tab-b';
-    cr.run({ tabId: 'tab-b', sessionId, prompt: 'hello', cwd, resume: false });
-    await waitFor(() => terminals().length > 0);
-    await new Promise((r) => setTimeout(r, 100));
-
-    expect(spawns(logFile)).toHaveLength(1);
-    expect(terminals()).toHaveLength(1);
-    expect(terminals()[0].channel).toBe('chat:run:error');
-    expect(terminals()[0].payload.code).toBe('session_flag_exhausted');
-  } finally {
-    fs.rmSync(cwd, { recursive: true, force: true });
-  }
-});
-
-test('"No conversation found" on --resume retries once with --session-id (main overrides a wrong renderer flag only via transcript)', async () => {
-  attachRecorder();
-  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-flagretry-cwd-'));
-  const logFile = path.join(cwd, 'argv.log');
-  const sessionId = `flag-sess3-${process.pid}`;
-  process.env.SM_CLAUDE_BIN = writeStub(logFile, { firstStderr: `No conversation found with session ID: ${sessionId}\n` });
-  try {
-    // No transcript exists anywhere → main computes resume=false even though
-    // the renderer said true, so the first attempt is --session-id and the
-    // stub's failure is the wrong-direction message: no retry, error surfaces.
-    curTab = 'tab-c';
-    cr.run({ tabId: 'tab-c', sessionId, prompt: 'hello', cwd, resume: true });
-    await waitFor(() => terminals().length > 0);
-    const argvs = spawns(logFile);
-    expect(argvs).toHaveLength(1);
-    expect(argvs[0]).toContain('--session-id');
-    expect(terminals()[0].channel).toBe('chat:run:error');
-  } finally {
-    fs.rmSync(cwd, { recursive: true, force: true });
-  }
-});
-
-test('spent swap retry (both flags rejected) emits actionable session_flag_exhausted error', async () => {
-  attachRecorder();
-  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-flagretry-cwd-'));
-  const logFile = path.join(cwd, 'argv.log');
-  const sessionId = `flag-sess4-${process.pid}`;
-  process.env.SM_CLAUDE_BIN = writeStub(logFile, {
-    firstStderr: `Error: Session ID ${sessionId} is already in use.\n`,
-    alwaysFail: true,
-  });
-  try {
-    curTab = 'tab-d';
-    cr.run({ tabId: 'tab-d', sessionId, prompt: 'hello', cwd, resume: false });
-    await waitFor(() => terminals().length > 0);
-    await new Promise((r) => setTimeout(r, 100));
-
-    expect(spawns(logFile)).toHaveLength(2);
-    expect(terminals()).toHaveLength(1);
-    const { channel, payload } = terminals()[0];
-    expect(channel).toBe('chat:run:error');
-    expect(payload.code).toBe('session_flag_exhausted');
-    expect(payload.message).toContain(cwd);
-    expect(payload.message).toContain(`${sessionId}.jsonl`);
-    expect(payload.message).toContain('--resume');
-    expect(payload.message).toMatch(/App version: /);
-    expect(payload.message).toMatch(/update the app first/);
-  } finally {
-    fs.rmSync(cwd, { recursive: true, force: true });
-  }
-});
-
-test('non-zero exit with unrelated stderr keeps the generic fallback message', async () => {
-  attachRecorder();
-  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-flagretry-cwd-'));
-  const logFile = path.join(cwd, 'argv.log');
-  const sessionId = `flag-sess5-${process.pid}`;
-  process.env.SM_CLAUDE_BIN = writeStub(logFile, { firstStderr: 'boom: something else broke\n' });
-  try {
-    curTab = 'tab-e';
-    cr.run({ tabId: 'tab-e', sessionId, prompt: 'hello', cwd, resume: false });
-    await waitFor(() => terminals().length > 0);
-    const { channel, payload } = terminals()[0];
-    expect(channel).toBe('chat:run:error');
-    expect(payload.code).toBeUndefined();
-    expect(payload.message).toMatch(/^process exited without a result event/);
-  } finally {
-    fs.rmSync(cwd, { recursive: true, force: true });
-  }
-});
-
-// ---------- persona effort → --effort (agentEffortResolve.cjs) ----------
-
-async function chatArgvForPersona(effortLine) {
-  attachRecorder();
-  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-chat-effort-cwd-'));
-  const logFile = path.join(cwd, 'argv.log');
-  const sessionId = `effort-sess-${process.pid}-${Math.floor(Math.random() * 1e6)}`;
-  fs.mkdirSync(path.join(tmpHome, '.claude', 'agents'), { recursive: true });
-  fs.writeFileSync(
-    path.join(tmpHome, '.claude', 'agents', 'effort-persona.md'),
-    ['---', 'name: effort-persona', 'model: opus', ...(effortLine ? [effortLine] : []), '---', 'body'].join('\n'),
-  );
-  const opsDir = path.join(cwd, 'session-manager-operations', 'prompt-sessions');
-  fs.mkdirSync(opsDir, { recursive: true });
-  fs.writeFileSync(path.join(opsDir, 'active-index.json'), JSON.stringify({
-    sessions: { e1: { id: 'e1', claudeSessionId: sessionId, agentType: 'effort-persona' } }, events: {},
-  }));
-  // First call succeeds outright: firstStderr unused because alwaysFail/n===1 → use a passing stub.
-  const stubPath = path.join(os.tmpdir(), `sm-effort-stub-${process.pid}-${Math.floor(Math.random() * 1e9)}.cjs`);
-  fs.writeFileSync(stubPath, `#!${process.execPath}\nrequire('fs').appendFileSync(${JSON.stringify(logFile)}, JSON.stringify(process.argv.slice(2)) + '\\n');\nprocess.stdout.write(JSON.stringify({ type: 'result', subtype: 'success', result: 'ok' }) + '\\n');\n`, { mode: 0o755 });
-  process.env.SM_CLAUDE_BIN = stubPath;
-  try {
-    curTab = 'tab-effort';
-    cr.run({ tabId: 'tab-effort', sessionId, prompt: 'hello', cwd, resume: false });
-    await waitFor(() => terminals().length >= 1 && fs.existsSync(logFile));
-    return spawns(logFile)[0];
-  } finally {
-    fs.rmSync(cwd, { recursive: true, force: true });
-    fs.rmSync(stubPath, { force: true });
-  }
-}
-
-test('chat spawn: persona effort adds --effort <level> beside --model and --session-id', async () => {
-  const argv = await chatArgvForPersona('effort: xhigh');
-  expect(argv[argv.indexOf('--effort') + 1]).toBe('xhigh');
-  expect(argv[argv.indexOf('--model') + 1]).toBe('opus');
-  expect(argv).toContain('--session-id');
-});
-
-test('chat spawn: effort inherit / absent adds no --effort token', async () => {
-  expect(await chatArgvForPersona('effort: inherit')).not.toContain('--effort');
-  expect(await chatArgvForPersona(null)).not.toContain('--effort');
-});

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

@@ -1,101 +0,0 @@
-/**
- * classifyPromptTicket.test.cjs — unit tests for the PromptTicket
- * inline-vs-develop classifier (PRD 749).
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/classifyPromptTicket.test.cjs
- */
-
-'use strict';
-
-import { test, expect, beforeEach } from 'vitest';
-const { EventEmitter } = require('node:events');
-const {
-  classifyPromptTicket,
-  parseVerdict,
-  __setSpawnForTest,
-} = require('../lib/classifyPromptTicket.cjs');
-
-beforeEach(() => {
-  __setSpawnForTest(null); // restore real spawn between tests
-});
-
-test('parseVerdict returns "develop" only when the raw text contains the word develop', () => {
-  expect(parseVerdict('develop')).toBe('develop');
-  expect(parseVerdict('  Develop  ')).toBe('develop');
-  expect(parseVerdict('inline')).toBe('inline');
-  expect(parseVerdict('')).toBe('inline');
-  expect(parseVerdict(undefined)).toBe('inline');
-});
-
-function fakeChild() {
-  const child = new EventEmitter();
-  child.stdout = new EventEmitter();
-  child.stderr = new EventEmitter();
-  child.kill = () => {};
-  return child;
-}
-
-test('classifyPromptTicket resolves "develop" for a complex sample prompt (stubbed spawn)', async () => {
-  __setSpawnForTest(() => {
-    const child = fakeChild();
-    setTimeout(() => {
-      child.stdout.emit('data', Buffer.from('develop'));
-      child.emit('close', 0);
-    }, 0);
-    return child;
-  });
-
-  const verdict = await classifyPromptTicket('Build a full multi-tab prompt-queue feature with PRD decomposition');
-  expect(verdict).toBe('develop');
-});
-
-test('classifyPromptTicket resolves "inline" for a quick sample prompt (stubbed spawn)', async () => {
-  __setSpawnForTest(() => {
-    const child = fakeChild();
-    setTimeout(() => {
-      child.stdout.emit('data', Buffer.from('inline'));
-      child.emit('close', 0);
-    }, 0);
-    return child;
-  });
-
-  const verdict = await classifyPromptTicket('what time is it');
-  expect(verdict).toBe('inline');
-});
-
-test('classifyPromptTicket fails safe to "inline" when the child process errors', async () => {
-  __setSpawnForTest(() => {
-    const child = fakeChild();
-    setTimeout(() => child.emit('error', new Error('spawn failed')), 0);
-    return child;
-  });
-
-  const verdict = await classifyPromptTicket('anything');
-  expect(verdict).toBe('inline');
-});
-
-test('classifyPromptTicket spawns with a pinned model, argv array (no shell string), and closed stdin', async () => {
-  let capturedBin;
-  let capturedArgs;
-  let capturedOpts;
-  __setSpawnForTest((bin, args, opts) => {
-    capturedBin = bin;
-    capturedArgs = args;
-    capturedOpts = opts;
-    const child = fakeChild();
-    setTimeout(() => {
-      child.stdout.emit('data', Buffer.from('inline'));
-      child.emit('close', 0);
-    }, 0);
-    return child;
-  });
-
-  await classifyPromptTicket('hello');
-
-  expect(typeof capturedBin).toBe('string');
-  expect(Array.isArray(capturedArgs)).toBe(true);
-  expect(capturedArgs).toContain('--model');
-  expect(capturedArgs[capturedArgs.indexOf('--model') + 1]).toBe('sonnet');
-  expect(capturedOpts.stdio[0]).toBe('ignore');
-  expect(capturedOpts.shell).toBeFalsy();
-});

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

@@ -1,201 +0,0 @@
-/**
- * classifyTranscriptLine.test.cjs — unit tests for src/main/lib/classifyTranscriptLine.cjs.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/classifyTranscriptLine.test.cjs
- */
-
-'use strict';
-
-import { test, expect } from 'vitest';
-
-const {
-  classifyLine,
-  trimContentArray,
-  makeRaw,
-  buildPreviewText,
-  MAX_RAW_STR,
-  PREVIEW_CHARS,
-  EXEMPT_TYPES,
-} = require('../lib/classifyTranscriptLine.cjs');
-
-test('classifyLine returns [] for non-object input', () => {
-  expect(classifyLine(null)).toEqual([]);
-  expect(classifyLine('not an object')).toEqual([]);
-});
-
-test('classifyLine tags usage events', () => {
-  const [ev] = classifyLine({ usage: { input_tokens: 10, output_tokens: 5 } });
-  expect(ev.kind).toBe('usage');
-  expect(ev.data).toEqual({ input_tokens: 10, output_tokens: 5 });
-});
-
-test('classifyLine tags TodoWrite tool_use as todo_write', () => {
-  const [ev] = classifyLine({
-    message: { content: [{ type: 'tool_use', name: 'TodoWrite', input: { todos: [{ content: 'x' }] } }] },
-  });
-  expect(ev.kind).toBe('todo_write');
-  expect(ev.data).toEqual([{ content: 'x' }]);
-});
-
-test('classifyLine tags ExitPlanMode as plan', () => {
-  const [ev] = classifyLine({
-    message: { content: [{ type: 'tool_use', name: 'ExitPlanMode', input: { plan: 'do things' } }] },
-  });
-  expect(ev.kind).toBe('plan');
-});
-
-test('classifyLine tags Agent/Task tool_use as agent_spawn with toolUseId', () => {
-  const [ev] = classifyLine({
-    message: { content: [{ type: 'tool_use', name: 'Agent', id: 'tool-1', input: { description: 'do work' } }] },
-  });
-  expect(ev.kind).toBe('agent_spawn');
-  expect(ev.data.toolUseId).toBe('tool-1');
-});
-
-test('classifyLine tags generic tool_use blocks', () => {
-  const [ev] = classifyLine({
-    message: { content: [{ type: 'tool_use', name: 'Bash', id: 'tool-2', input: { command: 'ls' } }] },
-  });
-  expect(ev.kind).toBe('tool_use');
-  expect(ev.data).toEqual({ name: 'Bash', input: { command: 'ls' }, id: 'tool-2' });
-});
-
-test('classifyLine tags tool_result blocks with toolUseId', () => {
-  const [ev] = classifyLine({
-    message: { content: [{ type: 'tool_result', tool_use_id: 'tool-1' }] },
-  });
-  expect(ev.kind).toBe('tool_result');
-  expect(ev.data).toEqual({ toolUseId: 'tool-1' });
-});
-
-test('classifyLine falls back to message kind for non-array content', () => {
-  const [ev] = classifyLine({ type: 'assistant', message: { content: 'hello' } });
-  expect(ev.kind).toBe('assistant');
-});
-
-test('CORE: a content array of [text, tool_use, tool_use] emits exactly 3 events, not 1', () => {
-  const events = classifyLine({
-    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' } },
-      ],
-    },
-  });
-  expect(events).toHaveLength(3);
-  expect(events[0].kind).toBe('assistant'); // text block inherits the message's own type
-  expect(events[0].data).toBe('doing two things');
-  expect(events[1].kind).toBe('tool_use');
-  expect(events[1].data.id).toBe('tu-1');
-  expect(events[2].kind).toBe('tool_use');
-  expect(events[2].data.id).toBe('tu-2');
-});
-
-test('CORE: a message carrying both usage AND non-empty content emits the usage event AND the content event(s)', () => {
-  const events = classifyLine({
-    type: 'assistant',
-    usage: { input_tokens: 100, output_tokens: 40 },
-    message: { content: [{ type: 'text', text: 'hello' }] },
-  });
-  expect(events).toHaveLength(2);
-  expect(events.map((e) => e.kind).sort()).toEqual(['assistant', 'usage']);
-  const usageEv = events.find((e) => e.kind === 'usage');
-  expect(usageEv.data).toEqual({ input_tokens: 100, output_tokens: 40 });
-  const textEv = events.find((e) => e.kind === 'assistant');
-  expect(textEv.data).toBe('hello');
-});
-
-test('unknown/future content block types are surfaced, not dropped', () => {
-  const events = classifyLine({
-    type: 'assistant',
-    message: { content: [{ type: 'server_tool_use', id: 'x', input: {} }] },
-  });
-  expect(events).toHaveLength(1);
-  expect(events[0].kind).toBe('content_server_tool_use');
-  expect(events[0].data).toEqual({ type: 'server_tool_use', id: 'x', input: {} });
-});
-
-test('trimContentArray passes through non-array input', () => {
-  expect(trimContentArray('not-an-array')).toBe('not-an-array');
-});
-
-test('trimContentArray truncates long text fields past MAX_RAW_STR', () => {
-  const longText = 'a'.repeat(MAX_RAW_STR + 100);
-  const [block] = trimContentArray([{ type: 'text', text: longText }]);
-  expect(block.text.length).toBe(MAX_RAW_STR + 1);
-  expect(block.text.endsWith('…')).toBe(true);
-});
-
-test('trimContentArray now trims tool_use/tool_result blocks too (EXEMPT_TYPES is empty — orchestrator.ts/race.ts, the sole prior consumers, were deleted 2026-07-30)', () => {
-  expect(EXEMPT_TYPES.size).toBe(0);
-  const longText = 'a'.repeat(MAX_RAW_STR + 100);
-  const [block] = trimContentArray([{ type: 'tool_use', text: longText }]);
-  expect(block.text.length).toBe(MAX_RAW_STR + 1);
-  expect(block.text.endsWith('…')).toBe(true);
-});
-
-test('makeRaw builds a projection from message content', () => {
-  const raw = makeRaw({ message: { content: [{ type: 'text', text: 'hi' }] } });
-  expect(raw.message.content).toEqual([{ type: 'text', text: 'hi' }]);
-});
-
-test('CORE: makeRaw preserves every top-level field on the line, not just message.content', () => {
-  const line = {
-    type: 'assistant',
-    message: { content: [{ type: 'text', text: 'hi' }] },
-    attributionSkill: 'develop',
-    attributionPlugin: 'session-manager-dev',
-    attributionMcpServer: 'some-server',
-    attributionMcpTool: 'some_tool',
-    effort: 'high',
-    gitBranch: 'main',
-    isSidechain: false,
-    isMeta: true,
-    requestId: 'req-123',
-    isApiErrorMessage: false,
-    interruptedByShutdown: false,
-    permissionMode: 'default',
-    promptSource: 'user',
-    toolUseResult: { ok: true },
-  };
-  const raw = makeRaw(line);
-  for (const key of [
-    'attributionSkill',
-    'attributionPlugin',
-    'attributionMcpServer',
-    'attributionMcpTool',
-    'effort',
-    'gitBranch',
-    'isSidechain',
-    'isMeta',
-    'requestId',
-    'isApiErrorMessage',
-    'interruptedByShutdown',
-    'permissionMode',
-    'promptSource',
-    'toolUseResult',
-  ]) {
-    expect(raw[key]).toEqual(line[key]);
-  }
-});
-
-test('CORE: every event carries a bounded previewText and, when a ref is passed, the ref survives untouched', () => {
-  const ref = { filePath: '/tmp/fake.jsonl', byteOffset: 128, byteLength: 64 };
-  const [ev] = classifyLine({ type: 'user', message: { content: 'a'.repeat(PREVIEW_CHARS + 500) } }, ref);
-  expect(ev.ref).toEqual(ref);
-  expect(ev.previewText.length).toBeLessThanOrEqual(PREVIEW_CHARS + 1);
-  expect(ev.previewText.endsWith('…')).toBe(true);
-});
-
-test('classifyLine omits ref (null) when the caller has no file context', () => {
-  const [ev] = classifyLine({ usage: { input_tokens: 1, output_tokens: 1 } });
-  expect(ev.ref).toBeNull();
-});
-
-test('buildPreviewText caps at PREVIEW_CHARS', () => {
-  const s = buildPreviewText('x'.repeat(PREVIEW_CHARS + 50));
-  expect(s.length).toBe(PREVIEW_CHARS + 1);
-  expect(s.endsWith('…')).toBe(true);
-});