@unpolarize/code-sessions 0.1.0

package/src/insights/heuristics.ts

@@ -0,0 +1,106 @@
+import type { Signal, Turn } from '@unpolarize/code-sessions-schema';
+
+/**
+ * Deterministic, LLM-free signal derivation. Runs regardless of provider so the
+ * store always has a useful baseline; the configured agent adds topic/tags/summary
+ * on top. Pure functions, easy to test.
+ */
+
+export const THRESHOLDS = {
+  stuckRepeat: 3, // N consecutive identical assistant/tool actions
+  highCostUsd: 0.5,
+  longSessionTurns: 80,
+  toolHeavyRatio: 1.5,
+};
+
+const ERROR_RE = /(error|exception|traceback|failed|fatal|panic)/i;
+
+function actionKey(t: Turn): string {
+  if (t.tool_calls.length > 0) {
+    return `tool:${t.tool_calls.map((c) => `${c.name}(${JSON.stringify(c.input ?? null)})`).join(',')}`;
+  }
+  return `${t.role}:${t.text.slice(0, 120)}`;
+}
+
+export function deriveSignals(turns: Turn[]): Signal[] {
+  const signals: Signal[] = [];
+
+  // stuck-loop: the same action repeated >= N times in a row
+  let runKey = '';
+  let runLen = 0;
+  let runStart = 0;
+  let flaggedStuck = false;
+  for (let i = 0; i < turns.length; i++) {
+    const key = actionKey(turns[i]!);
+    if (key === runKey) {
+      runLen++;
+    } else {
+      runKey = key;
+      runLen = 1;
+      runStart = i;
+    }
+    if (runLen >= THRESHOLDS.stuckRepeat && !flaggedStuck) {
+      signals.push({
+        kind: 'stuck-loop',
+        severity: 'warn',
+        turn_index: turns[runStart]!.turn_index,
+        note: `repeated action ×${runLen}`,
+      });
+      flaggedStuck = true;
+    }
+  }
+
+  // error-recovery: a tool/assistant turn whose text mentions an error
+  for (const t of turns) {
+    if (ERROR_RE.test(t.text)) {
+      signals.push({ kind: 'error-recovery', severity: 'info', turn_index: t.turn_index });
+      break;
+    }
+  }
+
+  // high-cost-turn
+  for (const t of turns) {
+    const cost = t.telemetry?.cost_usd ?? 0;
+    if (cost >= THRESHOLDS.highCostUsd) {
+      signals.push({
+        kind: 'high-cost-turn',
+        severity: 'warn',
+        turn_index: t.turn_index,
+        note: `$${cost.toFixed(2)}`,
+      });
+      break;
+    }
+  }
+
+  // long-session
+  if (turns.length >= THRESHOLDS.longSessionTurns) {
+    signals.push({ kind: 'long-session', severity: 'info', note: `${turns.length} turns` });
+  }
+
+  // tool-heavy
+  const toolCalls = turns.reduce((a, t) => a + t.tool_calls.length, 0);
+  if (turns.length > 0 && toolCalls / turns.length >= THRESHOLDS.toolHeavyRatio) {
+    signals.push({
+      kind: 'tool-heavy',
+      severity: 'info',
+      note: `${toolCalls} tool calls / ${turns.length} turns`,
+    });
+  }
+
+  return signals;
+}
+
+/** A cheap, deterministic topic guess: first meaningful words of the first user turn. */
+export function guessTopic(turns: Turn[]): string | undefined {
+  const firstUser = turns.find((t) => t.role === 'user' && t.text.trim().length > 0);
+  if (!firstUser) return undefined;
+  const words = firstUser.text.trim().split(/\s+/).slice(0, 8).join(' ');
+  return words.length > 0 ? words : undefined;
+}
+
+/** Tags from distinct tool names used in the session. */
+export function deriveTags(turns: Turn[]): string[] {
+  const tags = new Set<string>();
+  for (const t of turns) for (const c of t.tool_calls) tags.add(c.name);
+  return [...tags].slice(0, 12);
+}

package/src/insights/index.ts

@@ -0,0 +1,4 @@
+export * from './heuristics';
+export * from './provider';
+export * from './llm';
+export * from './labeler';

package/src/insights/labeler.test.ts

@@ -0,0 +1,105 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { describe, expect, it } from 'vitest';
+import type { Turn } from '@unpolarize/code-sessions-schema';
+import { makeConfig, withTempDirAsync } from '../test/tmp';
+import { envelopeFile, insightsFile, sessionDir } from '../store/paths';
+import { rebuildEnvelope, writeTurnFile } from '../store/writer';
+import { FakeProvider, type Provider } from './provider';
+import { labelSession, makeProvider, reindexStore } from './labeler';
+
+function turn(i: number, over: Partial<Turn> = {}): Turn {
+  return {
+    schema: 'session-store/turn@1',
+    session_id: 's1',
+    host: 'h',
+    agent: 'claude-code',
+    turn_index: i,
+    ts: `2026-06-20T08:0${i}:00Z`,
+    role: 'assistant',
+    text: '',
+    tool_calls: [],
+    usage: { input_tokens: 0, output_tokens: 0, cache_read_tokens: 0, cache_write_tokens: 0 },
+    scrubbed: false,
+    raw_ref: null,
+    ...over,
+  };
+}
+
+function seedSession(store: string): string {
+  const dir = sessionDir(store, 'h', '2026-06', 's1');
+  writeTurnFile(dir, turn(0, { role: 'user', text: 'Fix the bug in foo.ts' }));
+  writeTurnFile(dir, turn(1, { tool_calls: [{ name: 'Edit' }], telemetry: { cost_usd: 0.9 }, text: 'editing' }));
+  rebuildEnvelope(store, 'h', '2026-06', 's1', { model: 'claude-opus-4-8' }, {
+    session_id: 's1',
+    host: 'h',
+    agent: 'claude-code',
+    native_uuid: 's1',
+  });
+  return dir;
+}
+
+describe('labelSession', () => {
+  it('writes insights and reflects labels onto the envelope', async () => {
+    await withTempDirAsync(async (store) => {
+      const dir = seedSession(store);
+      const ins = await labelSession(dir, { sessionId: 's1', host: 'h' }, new FakeProvider(), {
+        now: '2026-06-20T09:00:00Z',
+      });
+      expect(ins).toBeDefined();
+      expect(ins!.topic).toContain('Fix the bug');
+      expect(ins!.tags).toContain('Edit');
+      expect(ins!.signals.some((s) => s.kind === 'high-cost-turn')).toBe(true);
+      expect(ins!.generated_at).toBe('2026-06-20T09:00:00Z');
+      expect(existsSync(insightsFile(dir))).toBe(true);
+
+      const env = JSON.parse(readFileSync(envelopeFile(dir), 'utf8'));
+      expect(env.labels).toContain('Edit');
+    });
+  });
+
+  it('degrades to heuristics when the provider throws', async () => {
+    await withTempDirAsync(async (store) => {
+      const dir = seedSession(store);
+      const failing: Provider = {
+        name: 'broken',
+        label: async () => {
+          throw new Error('no cli');
+        },
+      };
+      const ins = await labelSession(dir, { sessionId: 's1', host: 'h' }, failing);
+      expect(ins).toBeDefined();
+      // heuristics still produced a high-cost signal and a topic guess
+      expect(ins!.signals.some((s) => s.kind === 'high-cost-turn')).toBe(true);
+      expect(ins!.topic).toContain('Fix the bug');
+    });
+  });
+
+  it('returns undefined for an empty session', async () => {
+    await withTempDirAsync(async (store) => {
+      const dir = sessionDir(store, 'h', '2026-06', 'empty');
+      const ins = await labelSession(dir, { sessionId: 'empty', host: 'h' }, new FakeProvider());
+      expect(ins).toBeUndefined();
+    });
+  });
+});
+
+describe('reindexStore', () => {
+  it('labels every session in the store', async () => {
+    await withTempDirAsync(async (store) => {
+      seedSession(store);
+      const res = await reindexStore(makeConfig(store), new FakeProvider(), {
+        now: '2026-06-20T09:00:00Z',
+      });
+      expect(res.count).toBe(1);
+      expect(res.sessions).toContain('s1');
+    });
+  });
+});
+
+describe('makeProvider', () => {
+  it('returns null when disabled and a FakeProvider when configured', () => {
+    expect(makeProvider(makeConfig('/tmp/x', { insights: { provider: 'none' } }))).toBeNull();
+    expect(makeProvider(makeConfig('/tmp/x', { insights: { provider: 'fake' } }))?.name).toBe('fake');
+    expect(makeProvider(makeConfig('/tmp/x', { insights: { provider: 'ollama' } }))?.name).toBe('ollama');
+  });
+});

package/src/insights/labeler.ts

@@ -0,0 +1,136 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+import {
+  SCHEMA_VERSIONS,
+  parseSession,
+  type Insights,
+  type SessionEnvelope,
+  type Signal,
+} from '@unpolarize/code-sessions-schema';
+import type { CodeSessionsConfig } from '../config';
+import { envelopeFile, insightsFile } from '../store/paths';
+import { listSessionDirs } from '../store/scan';
+import { readTurns } from '../store/writer';
+import { deriveSignals, deriveTags, guessTopic } from './heuristics';
+import { FakeProvider, type LabelResult, type Provider } from './provider';
+import { LlmProvider, claudeRunner, grokRunner, ollamaRunner } from './llm';
+
+function writeJsonAtomic(path: string, value: unknown): void {
+  mkdirSync(dirname(path), { recursive: true });
+  const tmp = `${path}.tmp`;
+  writeFileSync(tmp, `${JSON.stringify(value, null, 2)}\n`);
+  renameSync(tmp, path);
+}
+
+function dedupeSignals(signals: Signal[]): Signal[] {
+  const seen = new Set<string>();
+  const out: Signal[] = [];
+  for (const s of signals) {
+    const key = `${s.kind}:${s.turn_index ?? ''}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(s);
+  }
+  return out;
+}
+
+export interface LabelOptions {
+  /** ISO timestamp for the insights record (injectable for deterministic tests) */
+  now?: string;
+}
+
+/** Build the provider configured in cfg, or null when insights are disabled. */
+export function makeProvider(cfg: CodeSessionsConfig): Provider | null {
+  const { provider, model } = cfg.insights;
+  switch (provider) {
+    case 'none':
+      return null;
+    case 'fake':
+      return new FakeProvider();
+    case 'claude':
+      return new LlmProvider('claude', claudeRunner(model));
+    case 'grok':
+      return new LlmProvider('grok', grokRunner(model));
+    case 'ollama':
+      return new LlmProvider('ollama', ollamaRunner(model));
+    default:
+      return null;
+  }
+}
+
+/**
+ * Label one session: deterministic heuristics + the configured provider, written
+ * to insights/labels.json and reflected as envelope labels. Provider failures
+ * degrade gracefully to heuristics-only.
+ */
+export async function labelSession(
+  sessionDir: string,
+  identity: { sessionId: string; host: string },
+  provider: Provider,
+  opts: LabelOptions = {},
+): Promise<Insights | undefined> {
+  const turns = readTurns(sessionDir);
+  if (turns.length === 0) return undefined;
+
+  const heuristicSignals = deriveSignals(turns);
+  let provided: LabelResult = { tags: [], signals: [] };
+  try {
+    provided = await provider.label({ sessionId: identity.sessionId, host: identity.host, turns });
+  } catch {
+    // provider unavailable (no CLI / API) — heuristics still apply
+  }
+
+  const topic = provided.topic ?? guessTopic(turns);
+  const tags = [...new Set([...provided.tags, ...deriveTags(turns)])].slice(0, 16);
+  const signals = dedupeSignals([...heuristicSignals, ...provided.signals]);
+
+  const insights: Insights = {
+    schema: SCHEMA_VERSIONS.insights,
+    session_id: identity.sessionId,
+    host: identity.host,
+    generated_at: opts.now ?? new Date().toISOString(),
+    provider: provider.name,
+    tags,
+    signals,
+  };
+  if (topic) insights.topic = topic;
+  if (provided.summary) insights.summary = provided.summary;
+
+  writeJsonAtomic(insightsFile(sessionDir), insights);
+  updateEnvelopeLabels(sessionDir, topic, tags);
+  return insights;
+}
+
+function updateEnvelopeLabels(sessionDir: string, topic: string | undefined, tags: string[]): void {
+  const path = envelopeFile(sessionDir);
+  if (!existsSync(path)) return;
+  let env: SessionEnvelope;
+  try {
+    env = parseSession(JSON.parse(readFileSync(path, 'utf8')));
+  } catch {
+    return;
+  }
+  env.labels = [...new Set([...(topic ? [topic] : []), ...tags])].slice(0, 16);
+  writeJsonAtomic(path, env);
+}
+
+export interface ReindexResult {
+  count: number;
+  sessions: string[];
+}
+
+/** Re-label every session in the store (optionally since a month). Post-processing path. */
+export async function reindexStore(
+  cfg: CodeSessionsConfig,
+  provider: Provider,
+  opts: { sinceMonth?: string; now?: string } = {},
+): Promise<ReindexResult> {
+  const refs = listSessionDirs(cfg.storeDir, opts.sinceMonth ? { sinceMonth: opts.sinceMonth } : {});
+  const labeled: string[] = [];
+  for (const ref of refs) {
+    const labelOpts = opts.now ? { now: opts.now } : {};
+    const res = await labelSession(ref.dir, { sessionId: ref.sessionId, host: ref.host }, provider, labelOpts);
+    if (res) labeled.push(ref.sessionId);
+  }
+  return { count: labeled.length, sessions: labeled };
+}

package/src/insights/llm.test.ts

@@ -0,0 +1,77 @@
+import { describe, expect, it } from 'vitest';
+import type { Turn } from '@unpolarize/code-sessions-schema';
+import { LlmProvider, buildPrompt, parseLabelJson } from './llm';
+
+function turn(i: number, role: Turn['role'], text: string): Turn {
+  return {
+    schema: 'session-store/turn@1',
+    session_id: 's',
+    host: 'h',
+    agent: 'claude-code',
+    turn_index: i,
+    ts: 't',
+    role,
+    text,
+    tool_calls: [],
+    usage: { input_tokens: 0, output_tokens: 0, cache_read_tokens: 0, cache_write_tokens: 0 },
+    scrubbed: false,
+    raw_ref: null,
+  };
+}
+
+describe('buildPrompt', () => {
+  it('includes the transcript and a JSON instruction', () => {
+    const p = buildPrompt({
+      sessionId: 's',
+      host: 'h',
+      turns: [turn(0, 'user', 'fix foo'), turn(1, 'assistant', 'done')],
+    });
+    expect(p).toContain('ONLY a JSON object');
+    expect(p).toContain('[user] fix foo');
+    expect(p).toContain('[assistant] done');
+  });
+});
+
+describe('parseLabelJson', () => {
+  it('parses a clean JSON object', () => {
+    const r = parseLabelJson('{"topic":"debugging","tags":["foo"],"summary":"s","signals":[]}');
+    expect(r.topic).toBe('debugging');
+    expect(r.tags).toEqual(['foo']);
+    expect(r.summary).toBe('s');
+  });
+
+  it('tolerates surrounding prose', () => {
+    const r = parseLabelJson('Sure! Here:\n{"topic":"x","tags":[]}\nHope that helps.');
+    expect(r.topic).toBe('x');
+  });
+
+  it('drops invalid signal kinds and coerces severity', () => {
+    const r = parseLabelJson(
+      '{"tags":[],"signals":[{"kind":"bogus"},{"kind":"stuck-loop","severity":"nope","note":"n"}]}',
+    );
+    expect(r.signals).toHaveLength(1);
+    expect(r.signals[0]).toMatchObject({ kind: 'stuck-loop', severity: 'info', note: 'n' });
+  });
+
+  it('returns empty on non-JSON', () => {
+    expect(parseLabelJson('no json here')).toEqual({ tags: [], signals: [] });
+  });
+});
+
+describe('LlmProvider', () => {
+  it('labels via an injected runner', async () => {
+    const provider = new LlmProvider('stub', async () => '{"topic":"t","tags":["a"],"signals":[]}');
+    const res = await provider.label({ sessionId: 's', host: 'h', turns: [turn(0, 'user', 'hi')] });
+    expect(res.topic).toBe('t');
+    expect(res.tags).toEqual(['a']);
+  });
+
+  it('propagates runner errors (labeler handles the fallback)', async () => {
+    const provider = new LlmProvider('stub', async () => {
+      throw new Error('no cli');
+    });
+    await expect(
+      provider.label({ sessionId: 's', host: 'h', turns: [turn(0, 'user', 'hi')] }),
+    ).rejects.toThrow('no cli');
+  });
+});

package/src/insights/llm.ts

@@ -0,0 +1,130 @@
+import { spawnSync } from 'node:child_process';
+import { SIGNAL_KINDS, type Signal } from '@unpolarize/code-sessions-schema';
+import type { LabelRequest, LabelResult, Provider } from './provider';
+
+/** Runs a prompt against some agent CLI/API and returns its raw text output. */
+export type CommandRunner = (prompt: string) => Promise<string>;
+
+const MAX_HEAD = 40;
+const MAX_TAIL = 10;
+const MAX_TURN_CHARS = 400;
+
+export function buildPrompt(req: LabelRequest): string {
+  const turns = req.turns;
+  const picked =
+    turns.length > MAX_HEAD + MAX_TAIL
+      ? [...turns.slice(0, MAX_HEAD), { role: '…', text: `(${turns.length - MAX_HEAD - MAX_TAIL} turns elided)`, tool_calls: [] as unknown[] }, ...turns.slice(-MAX_TAIL)]
+      : turns;
+  const transcript = picked
+    .map((t) => {
+      const tools = (t as { tool_calls?: { name: string }[] }).tool_calls
+        ?.map((c) => c.name)
+        .join(',');
+      const head = tools ? `[${t.role} tools:${tools}]` : `[${t.role}]`;
+      return `${head} ${String(t.text).slice(0, MAX_TURN_CHARS)}`;
+    })
+    .join('\n');
+
+  return [
+    'You label a coding-agent session. Respond with ONLY a JSON object, no prose:',
+    '{"topic": string, "tags": string[], "summary": string, "signals": [{"kind": one of ' +
+      SIGNAL_KINDS.join('|') +
+      ', "severity": "info"|"warn"|"critical", "note": string}]}',
+    'topic: 3-6 words. tags: tools/themes. summary: <=1 sentence. signals: only notable ones.',
+    '',
+    'Transcript:',
+    transcript,
+  ].join('\n');
+}
+
+const KIND_SET = new Set<string>(SIGNAL_KINDS);
+
+export function parseLabelJson(out: string): LabelResult {
+  const start = out.indexOf('{');
+  const end = out.lastIndexOf('}');
+  if (start < 0 || end <= start) return { tags: [], signals: [] };
+  let obj: Record<string, unknown>;
+  try {
+    obj = JSON.parse(out.slice(start, end + 1)) as Record<string, unknown>;
+  } catch {
+    return { tags: [], signals: [] };
+  }
+  const result: LabelResult = {
+    tags: Array.isArray(obj.tags) ? obj.tags.filter((t): t is string => typeof t === 'string') : [],
+    signals: coerceSignals(obj.signals),
+  };
+  if (typeof obj.topic === 'string') result.topic = obj.topic;
+  if (typeof obj.summary === 'string') result.summary = obj.summary;
+  return result;
+}
+
+function coerceSignals(raw: unknown): Signal[] {
+  if (!Array.isArray(raw)) return [];
+  const out: Signal[] = [];
+  for (const s of raw) {
+    if (!s || typeof s !== 'object') continue;
+    const o = s as Record<string, unknown>;
+    if (typeof o.kind !== 'string' || !KIND_SET.has(o.kind)) continue;
+    const sig: Signal = {
+      kind: o.kind as Signal['kind'],
+      severity:
+        o.severity === 'warn' || o.severity === 'critical' ? o.severity : 'info',
+    };
+    if (typeof o.note === 'string') sig.note = o.note;
+    if (typeof o.turn_index === 'number') sig.turn_index = o.turn_index;
+    out.push(sig);
+  }
+  return out;
+}
+
+/** A provider that shells out to a user-configured agent CLI/API. */
+export class LlmProvider implements Provider {
+  constructor(
+    readonly name: string,
+    private readonly runner: CommandRunner,
+  ) {}
+
+  async label(req: LabelRequest): Promise<LabelResult> {
+    const out = await this.runner(buildPrompt(req));
+    return parseLabelJson(out);
+  }
+}
+
+// ---- concrete runners (best-effort; require the tool to be installed) ----
+
+function spawnText(cmd: string, args: string[], input?: string): string {
+  const res = spawnSync(cmd, args, {
+    encoding: 'utf8',
+    input,
+    maxBuffer: 16 * 1024 * 1024,
+  });
+  if (res.error) throw new Error(`${cmd} failed: ${res.error.message}`);
+  if (res.status !== 0) throw new Error(`${cmd} exited ${res.status}: ${(res.stderr ?? '').slice(0, 200)}`);
+  return res.stdout ?? '';
+}
+
+/** `claude -p <prompt>` (print mode). */
+export const claudeRunner =
+  (model?: string): CommandRunner =>
+  async (prompt) =>
+    spawnText('claude', model ? ['-p', '--model', model, prompt] : ['-p', prompt]);
+
+/** `grok` CLI in non-interactive mode (best-effort flags). */
+export const grokRunner =
+  (model?: string): CommandRunner =>
+  async (prompt) =>
+    spawnText('grok', model ? ['--model', model, '-p', prompt] : ['-p', prompt]);
+
+/** Local Ollama HTTP API. */
+export const ollamaRunner =
+  (model = 'llama3.1', host = 'http://localhost:11434'): CommandRunner =>
+  async (prompt) => {
+    const res = await fetch(`${host}/api/generate`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ model, prompt, stream: false }),
+    });
+    if (!res.ok) throw new Error(`ollama ${res.status}`);
+    const data = (await res.json()) as { response?: string };
+    return data.response ?? '';
+  };

package/src/insights/provider.ts

@@ -0,0 +1,37 @@
+import type { Signal, Turn } from '@unpolarize/code-sessions-schema';
+import { deriveTags, guessTopic } from './heuristics';
+
+export interface LabelRequest {
+  sessionId: string;
+  host: string;
+  turns: Turn[];
+}
+
+export interface LabelResult {
+  topic?: string;
+  tags: string[];
+  signals: Signal[];
+  summary?: string;
+}
+
+/** An insights provider turns a session into topic/tags/summary (+ optional signals). */
+export interface Provider {
+  readonly name: string;
+  label(req: LabelRequest): Promise<LabelResult>;
+}
+
+/** No-LLM provider: deterministic topic/tags from the transcript. Always available. */
+export class FakeProvider implements Provider {
+  readonly name = 'fake';
+  async label(req: LabelRequest): Promise<LabelResult> {
+    const result: LabelResult = {
+      tags: deriveTags(req.turns),
+      signals: [],
+    };
+    const topic = guessTopic(req.turns);
+    if (topic) result.topic = topic;
+    const assistantText = req.turns.find((t) => t.role === 'assistant')?.text;
+    if (assistantText) result.summary = assistantText.slice(0, 160);
+    return result;
+  }
+}

package/src/ipc.test.ts

@@ -0,0 +1,35 @@
+import { describe, expect, it } from 'vitest';
+import { isSessionEndEvent, parseHookEvent } from './ipc';
+
+describe('parseHookEvent', () => {
+  it('accepts snake_case payloads', () => {
+    const e = parseHookEvent({
+      event: 'PostToolUse',
+      session_id: 's',
+      transcript_path: '/t.jsonl',
+      cwd: '/p',
+    });
+    expect(e).toEqual({ event: 'PostToolUse', session_id: 's', transcript_path: '/t.jsonl', cwd: '/p' });
+  });
+
+  it('accepts Claude hook_event_name + sessionId aliases', () => {
+    const e = parseHookEvent({ hook_event_name: 'Stop', sessionId: 's', transcriptPath: '/t' });
+    expect(e?.event).toBe('Stop');
+    expect(e?.session_id).toBe('s');
+    expect(e?.transcript_path).toBe('/t');
+  });
+
+  it('rejects payloads missing event or session id', () => {
+    expect(parseHookEvent({ event: 'Stop' })).toBeNull();
+    expect(parseHookEvent({ session_id: 's' })).toBeNull();
+    expect(parseHookEvent(null)).toBeNull();
+  });
+});
+
+describe('isSessionEndEvent', () => {
+  it('flags lifecycle-end events', () => {
+    expect(isSessionEndEvent('Stop')).toBe(true);
+    expect(isSessionEndEvent('SubagentStop')).toBe(true);
+    expect(isSessionEndEvent('PostToolUse')).toBe(false);
+  });
+});