repoburg 1.3.202 → 1.3.209

package/agent-pane/backend/src/integration/threads.test.ts

@@ -1,309 +0,0 @@
-/**
- * Integration test: discussion threads — create, followup, resolve, delete, list.
- *
- * Tests the REST CRUD endpoints and verifies DB state + WS broadcasts.
- * Uses the real codex-provider (mocked AppServerClient) for startTurn calls.
- */
-
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { readFileSync } from 'node:fs';
-import { resolve } from 'node:path';
-import type Database from 'better-sqlite3';
-import { createAppServerMock, type Fixture } from './helpers/app-server-mock.ts';
-import { clearBroadcasts, capturedBroadcasts } from './helpers/ws-capture.ts';
-import type { TestApp } from './helpers/test-app.ts';
-
-const fixture = JSON.parse(readFileSync(resolve(__dirname, '__fixtures__/simple-turn.json'), 'utf-8')) as Fixture;
-
-vi.mock('../codex/app-server-client.ts', () => ({
-  AppServerClient: createAppServerMock(fixture),
-}));
-
-vi.mock('../ws/index.ts', async (importOriginal) => {
-  const actual = (await importOriginal()) as Record<string, unknown>;
-  return {
-    ...actual,
-    broadcast: vi.fn((event: string, data: unknown) => {
-      capturedBroadcasts.push({ event, data });
-    }),
-  };
-});
-
-const { getDb } = await import('../db/index.ts');
-const { createTestApp, insertTestSession } = await import('./helpers/test-app.ts');
-
-describe('Integration: discussion threads', () => {
-  let testApp: TestApp;
-
-  beforeEach(async () => {
-    vi.clearAllMocks();
-    clearBroadcasts();
-    testApp = await createTestApp();
-  });
-
-  afterEach(async () => {
-    await testApp.cleanup();
-  });
-
-  it('creates a thread + first AI turn', async () => {
-    const db: Database.Database = getDb();
-    insertTestSession(db, 's1', { runtime_type: 'codex' });
-
-    // Insert an anchor turn + item (the agent_message being annotated)
-    const now = '2025-01-01T00:00:00Z';
-    db.prepare(
-      `INSERT INTO turns (id, session_id, user_prompt, agent_response, thoughts, token_usage, external_turn_id, status, error, created_at, updated_at)
-       VALUES (?, ?, 'prompt', 'response', NULL, NULL, NULL, 'completed', NULL, ?, ?)`,
-    ).run('t1', 's1', now, now);
-    db.prepare(
-      `INSERT INTO items (id, turn_id, external_item_id, type, data, status, created_at, updated_at)
-       VALUES (?, ?, 'ext1', 'agent_message', ?, 'completed', ?, ?)`,
-    ).run('i1', 't1', JSON.stringify({ text: 'Some text to discuss' }), now, now);
-
-    const res = await testApp.app.inject({
-      method: 'POST',
-      url: '/api/sessions/s1/threads',
-      payload: {
-        itemId: 'i1',
-        turnId: 't1',
-        startOffset: 0,
-        endOffset: 10,
-        selectedText: 'Some text ',
-        message: 'What does this mean?',
-      },
-    });
-
-    expect(res.statusCode).toBe(200);
-    const body = res.json();
-    expect(body.thread).toBeDefined();
-    expect(body.thread.id).toBeDefined();
-    expect(body.thread.status).toBe('open');
-    expect(body.thread.selected_text).toBe('Some text ');
-    expect(body.turn).toBeDefined();
-    expect(body.turn.thread_id).toBe(body.thread.id);
-
-    // Verify DB state
-    const threadRow = db.prepare('SELECT * FROM discussion_threads WHERE id = ?').get(body.thread.id);
-    expect(threadRow).toBeDefined();
-    expect((threadRow as { status: string }).status).toBe('open');
-
-    const turnRow = db.prepare('SELECT * FROM turns WHERE id = ?').get(body.turn.id) as { thread_id: string | null; user_prompt: string };
-    expect(turnRow.thread_id).toBe(body.thread.id);
-    expect(turnRow.user_prompt).toContain('[Quoting from your previous response]');
-    expect(turnRow.user_prompt).toContain('Some text ');
-    expect(turnRow.user_prompt).toContain('What does this mean?');
-
-    // Verify broadcast
-    const createdEvent = capturedBroadcasts.find((b) => b.event === 'thread:created');
-    expect(createdEvent).toBeDefined();
-    expect((createdEvent!.data as { sessionId: string }).sessionId).toBe('s1');
-  });
-
-  it('returns 409 when a turn is already running', async () => {
-    const db: Database.Database = getDb();
-    insertTestSession(db, 's1', { is_running: 1 });
-
-    const res = await testApp.app.inject({
-      method: 'POST',
-      url: '/api/sessions/s1/threads',
-      payload: {
-        itemId: 'i1',
-        turnId: 't1',
-        startOffset: 0,
-        endOffset: 5,
-        selectedText: 'text',
-        message: 'test',
-      },
-    });
-
-    expect(res.statusCode).toBe(409);
-  });
-
-  it('resolves and reopens a thread', async () => {
-    const db: Database.Database = getDb();
-    insertTestSession(db, 's1', { runtime_type: 'codex' });
-
-    const now = '2025-01-01T00:00:00Z';
-    db.prepare(
-      `INSERT INTO turns (id, session_id, user_prompt, agent_response, thoughts, token_usage, external_turn_id, status, error, created_at, updated_at)
-       VALUES (?, ?, 'prompt', 'response', NULL, NULL, NULL, 'completed', NULL, ?, ?)`,
-    ).run('t1', 's1', now, now);
-    db.prepare(
-      `INSERT INTO items (id, turn_id, external_item_id, type, data, status, created_at, updated_at)
-       VALUES (?, ?, 'ext1', 'agent_message', ?, 'completed', ?, ?)`,
-    ).run('i1', 't1', JSON.stringify({ text: 'text' }), now, now);
-
-    // Manually insert a thread
-    db.prepare(
-      `INSERT INTO discussion_threads (id, session_id, item_id, turn_id, start_offset, end_offset, selected_text, status, created_at, updated_at)
-       VALUES (?, ?, ?, ?, 0, 4, 'text', 'open', ?, ?)`,
-    ).run('th1', 's1', 'i1', 't1', now, now);
-
-    // Resolve
-    const resolveRes = await testApp.app.inject({
-      method: 'PATCH',
-      url: '/api/sessions/s1/threads/th1',
-      payload: { status: 'resolved' },
-    });
-    expect(resolveRes.statusCode).toBe(200);
-    expect(resolveRes.json().status).toBe('resolved');
-
-    const thread = db.prepare('SELECT status, resolved_at FROM discussion_threads WHERE id = ?').get('th1') as { status: string; resolved_at: string | null };
-    expect(thread.status).toBe('resolved');
-    expect(thread.resolved_at).not.toBeNull();
-
-    const resolvedEvent = capturedBroadcasts.find((b) => b.event === 'thread:resolved');
-    expect(resolvedEvent).toBeDefined();
-
-    // Reopen
-    clearBroadcasts();
-    const reopenRes = await testApp.app.inject({
-      method: 'PATCH',
-      url: '/api/sessions/s1/threads/th1',
-      payload: { status: 'open' },
-    });
-    expect(reopenRes.statusCode).toBe(200);
-    expect(reopenRes.json().status).toBe('open');
-
-    const reopened = db.prepare('SELECT status FROM discussion_threads WHERE id = ?').get('th1') as { status: string };
-    expect(reopened.status).toBe('open');
-  });
-
-  it('deletes a thread and its turns + items', async () => {
-    const db: Database.Database = getDb();
-    insertTestSession(db, 's1', { runtime_type: 'codex' });
-
-    const now = '2025-01-01T00:00:00Z';
-    // Insert anchor turn + item
-    db.prepare(
-      `INSERT INTO turns (id, session_id, user_prompt, agent_response, thoughts, token_usage, external_turn_id, status, error, created_at, updated_at)
-       VALUES (?, ?, 'prompt', 'response', NULL, NULL, NULL, 'completed', NULL, ?, ?)`,
-    ).run('t1', 's1', now, now);
-    db.prepare(
-      `INSERT INTO items (id, turn_id, external_item_id, type, data, status, created_at, updated_at)
-       VALUES (?, ?, 'ext1', 'agent_message', ?, 'completed', ?, ?)`,
-    ).run('i1', 't1', JSON.stringify({ text: 'text' }), now, now);
-
-    // Insert thread + thread turn + thread item
-    db.prepare(
-      `INSERT INTO discussion_threads (id, session_id, item_id, turn_id, start_offset, end_offset, selected_text, status, created_at, updated_at)
-       VALUES (?, ?, ?, ?, 0, 4, 'text', 'open', ?, ?)`,
-    ).run('th1', 's1', 'i1', 't1', now, now);
-    db.prepare(
-      `INSERT INTO turns (id, session_id, user_prompt, agent_response, thoughts, token_usage, external_turn_id, status, error, thread_id, created_at, updated_at)
-       VALUES (?, ?, 'thread msg', 'thread resp', NULL, NULL, NULL, 'completed', NULL, ?, ?, ?)`,
-    ).run('tt1', 's1', 'th1', now, now);
-    db.prepare(
-      `INSERT INTO items (id, turn_id, external_item_id, type, data, status, created_at, updated_at)
-       VALUES (?, ?, 'ext2', 'agent_message', ?, 'completed', ?, ?)`,
-    ).run('ti1', 'tt1', JSON.stringify({ text: 'thread response' }), now, now);
-
-    const res = await testApp.app.inject({
-      method: 'DELETE',
-      url: '/api/sessions/s1/threads/th1',
-    });
-    expect(res.statusCode).toBe(200);
-    expect(res.json().success).toBe(true);
-
-    // Thread row deleted
-    const thread = db.prepare('SELECT id FROM discussion_threads WHERE id = ?').get('th1');
-    expect(thread).toBeUndefined();
-
-    // Thread turn deleted
-    const turn = db.prepare('SELECT id FROM turns WHERE id = ?').get('tt1');
-    expect(turn).toBeUndefined();
-
-    // Thread item deleted
-    const item = db.prepare('SELECT id FROM items WHERE id = ?').get('ti1');
-    expect(item).toBeUndefined();
-
-    // Anchor turn + item still exist
-    const anchorTurn = db.prepare('SELECT id FROM turns WHERE id = ?').get('t1');
-    expect(anchorTurn).toBeDefined();
-    const anchorItem = db.prepare('SELECT id FROM items WHERE id = ?').get('i1');
-    expect(anchorItem).toBeDefined();
-
-    const deletedEvent = capturedBroadcasts.find((b) => b.event === 'thread:deleted');
-    expect(deletedEvent).toBeDefined();
-  });
-
-  it('lists threads with nested turns', async () => {
-    const db: Database.Database = getDb();
-    insertTestSession(db, 's1', { runtime_type: 'codex' });
-
-    const now = '2025-01-01T00:00:00Z';
-    // Anchor turn + item
-    db.prepare(
-      `INSERT INTO turns (id, session_id, user_prompt, agent_response, thoughts, token_usage, external_turn_id, status, error, created_at, updated_at)
-       VALUES (?, ?, 'prompt', 'response', NULL, NULL, NULL, 'completed', NULL, ?, ?)`,
-    ).run('t1', 's1', now, now);
-    db.prepare(
-      `INSERT INTO items (id, turn_id, external_item_id, type, data, status, created_at, updated_at)
-       VALUES (?, ?, 'ext1', 'agent_message', ?, 'completed', ?, ?)`,
-    ).run('i1', 't1', JSON.stringify({ text: 'text' }), now, now);
-
-    // Thread + thread turn + thread item
-    db.prepare(
-      `INSERT INTO discussion_threads (id, session_id, item_id, turn_id, start_offset, end_offset, selected_text, status, created_at, updated_at)
-       VALUES (?, ?, ?, ?, 0, 4, 'text', 'open', ?, ?)`,
-    ).run('th1', 's1', 'i1', 't1', now, now);
-    db.prepare(
-      `INSERT INTO turns (id, session_id, user_prompt, agent_response, thoughts, token_usage, external_turn_id, status, error, thread_id, created_at, updated_at)
-       VALUES (?, ?, 'msg', 'resp', NULL, NULL, NULL, 'completed', NULL, ?, ?, ?)`,
-    ).run('tt1', 's1', 'th1', now, now);
-    db.prepare(
-      `INSERT INTO items (id, turn_id, external_item_id, type, data, status, created_at, updated_at)
-       VALUES (?, ?, 'ext2', 'agent_message', ?, 'completed', ?, ?)`,
-    ).run('ti1', 'tt1', JSON.stringify({ text: 'response' }), now, now);
-
-    const res = await testApp.app.inject({
-      method: 'GET',
-      url: '/api/sessions/s1/threads',
-    });
-    expect(res.statusCode).toBe(200);
-    const threads = res.json();
-    expect(threads).toHaveLength(1);
-    expect(threads[0].id).toBe('th1');
-    expect(threads[0].turns).toHaveLength(1);
-    expect(threads[0].turns[0].id).toBe('tt1');
-    expect(threads[0].turns[0].items).toHaveLength(1);
-    expect(threads[0].turns[0].items[0].id).toBe('ti1');
-  });
-
-  it('GET /api/sessions/:id includes threads', async () => {
-    const db: Database.Database = getDb();
-    insertTestSession(db, 's1', { runtime_type: 'codex' });
-
-    const now = '2025-01-01T00:00:00Z';
-    db.prepare(
-      `INSERT INTO turns (id, session_id, user_prompt, agent_response, thoughts, token_usage, external_turn_id, status, error, created_at, updated_at)
-       VALUES (?, ?, 'prompt', 'response', NULL, NULL, NULL, 'completed', NULL, ?, ?)`,
-    ).run('t1', 's1', now, now);
-    db.prepare(
-      `INSERT INTO items (id, turn_id, external_item_id, type, data, status, created_at, updated_at)
-       VALUES (?, ?, 'ext1', 'agent_message', ?, 'completed', ?, ?)`,
-    ).run('i1', 't1', JSON.stringify({ text: 'text' }), now, now);
-
-    db.prepare(
-      `INSERT INTO discussion_threads (id, session_id, item_id, turn_id, start_offset, end_offset, selected_text, status, created_at, updated_at)
-       VALUES (?, ?, ?, ?, 0, 4, 'text', 'open', ?, ?)`,
-    ).run('th1', 's1', 'i1', 't1', now, now);
-    db.prepare(
-      `INSERT INTO turns (id, session_id, user_prompt, agent_response, thoughts, token_usage, external_turn_id, status, error, thread_id, created_at, updated_at)
-       VALUES (?, ?, 'msg', 'resp', NULL, NULL, NULL, 'completed', NULL, ?, ?, ?)`,
-    ).run('tt1', 's1', 'th1', now, now);
-
-    const res = await testApp.app.inject({ method: 'GET', url: '/api/sessions/s1' });
-    expect(res.statusCode).toBe(200);
-    const detail = res.json();
-    expect(detail.threads).toBeDefined();
-    expect(detail.threads).toHaveLength(1);
-    expect(detail.threads[0].id).toBe('th1');
-    expect(detail.threads[0].turns).toHaveLength(1);
-
-    // Thread turns should also be in the main turns array
-    expect(detail.turns).toHaveLength(2);
-    const threadTurn = detail.turns.find((t: { thread_id: string | null }) => t.thread_id === 'th1');
-    expect(threadTurn).toBeDefined();
-  });
-});

package/agent-pane/backend/src/integration/title-generation.test.ts

@@ -1,109 +0,0 @@
-/**
- * Integration test: title auto-generation.
- *
- * Verifies that after a turn completes, a throwaway Codex thread is
- * used to generate a title, which is saved to the DB and broadcast
- * via session:title.
- *
- * Uses HTTP POST to trigger the turn (fire-and-forget startTurn).
- */
-
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { readFileSync } from 'node:fs';
-import { resolve } from 'node:path';
-import type Database from 'better-sqlite3';
-import { createAppServerMock, type Fixture } from './helpers/app-server-mock.ts';
-import { clearBroadcasts, findBroadcast, capturedBroadcasts } from './helpers/ws-capture.ts';
-import type { TestApp } from './helpers/test-app.ts';
-
-const fixture = JSON.parse(readFileSync(resolve(__dirname, '__fixtures__/simple-turn.json'), 'utf-8')) as Fixture;
-
-vi.mock('../codex/app-server-client.ts', () => ({
-  AppServerClient: createAppServerMock(fixture),
-}));
-
-vi.mock('../ws/index.ts', async (importOriginal) => {
-  const actual = (await importOriginal()) as Record<string, unknown>;
-  return {
-    ...actual,
-    broadcast: vi.fn((event: string, data: unknown) => {
-      capturedBroadcasts.push({ event, data });
-    }),
-  };
-});
-
-const { getDb } = await import('../db/index.ts');
-const { createTestApp, waitForTurn, insertTestSession } = await import('./helpers/test-app.ts');
-
-describe('Integration: title generation', () => {
-  let testApp: TestApp;
-
-  beforeEach(async () => {
-    vi.clearAllMocks();
-    clearBroadcasts();
-    testApp = await createTestApp();
-  });
-
-  afterEach(async () => {
-    await testApp.cleanup();
-  });
-
-  it('generates title after first turn via throwaway thread', async () => {
-    const db: Database.Database = getDb();
-
-    insertTestSession(db, 's1');
-
-    // Submit turn via HTTP
-    const turnRes = await testApp.app.inject({
-      method: 'POST',
-      url: '/api/sessions/s1/turns',
-      payload: { user_prompt: 'Hello, how are you?' },
-    });
-    const turn = turnRes.json();
-
-    await waitForTurn(db, turn.id);
-
-    // Wait for fire-and-forget title generation
-    await new Promise((r) => setTimeout(r, 500));
-
-    // Title in DB
-    const dbSession = db.prepare('SELECT title FROM sessions WHERE id = ?').get('s1') as {
-      title: string | null;
-    };
-    expect(dbSession.title).toBe('Simple Hello Chat');
-
-    // session:title broadcast
-    const titleData = findBroadcast('session:title') as { sessionId: string; title: string };
-    expect(titleData.sessionId).toBe('s1');
-    expect(titleData.title).toBe('Simple Hello Chat');
-  });
-
-  it('does not regenerate title when session already has one', async () => {
-    const db: Database.Database = getDb();
-
-    insertTestSession(db, 's1', { title: 'Existing Title' });
-
-    // Submit turn via HTTP
-    const turnRes = await testApp.app.inject({
-      method: 'POST',
-      url: '/api/sessions/s1/turns',
-      payload: { user_prompt: 'Hello, how are you?' },
-    });
-    const turn = turnRes.json();
-
-    await waitForTurn(db, turn.id);
-
-    // Wait for any potential title generation
-    await new Promise((r) => setTimeout(r, 500));
-
-    // Title should NOT have changed
-    const dbSession = db.prepare('SELECT title FROM sessions WHERE id = ?').get('s1') as {
-      title: string | null;
-    };
-    expect(dbSession.title).toBe('Existing Title');
-
-    // No session:title broadcast
-    const titleBroadcasts = capturedBroadcasts.filter((b) => b.event === 'session:title');
-    expect(titleBroadcasts).toHaveLength(0);
-  });
-});

package/agent-pane/backend/src/integration/turn-cancel.test.ts

@@ -1,111 +0,0 @@
-/**
- * Integration test: turn cancellation.
- *
- * Verifies that aborting a running turn sets the correct DB state
- * and broadcasts turn:cancelled.
- *
- * Uses manual turn insertion + direct startTurn call to control cancel timing.
- */
-
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { readFileSync } from 'node:fs';
-import { resolve } from 'node:path';
-import type Database from 'better-sqlite3';
-import { createAppServerMock, type Fixture } from './helpers/app-server-mock.ts';
-import { clearBroadcasts, findBroadcast, capturedBroadcasts } from './helpers/ws-capture.ts';
-import type { TestApp } from './helpers/test-app.ts';
-
-const fixture = JSON.parse(readFileSync(resolve(__dirname, '__fixtures__/cancel-turn.json'), 'utf-8')) as Fixture;
-
-vi.mock('../codex/app-server-client.ts', () => ({
-  AppServerClient: createAppServerMock(fixture),
-}));
-
-vi.mock('../ws/index.ts', async (importOriginal) => {
-  const actual = (await importOriginal()) as Record<string, unknown>;
-  return {
-    ...actual,
-    broadcast: vi.fn((event: string, data: unknown) => {
-      capturedBroadcasts.push({ event, data });
-    }),
-  };
-});
-
-const { startTurn, interruptTurn } = await import('../codex/codex-provider.ts');
-const { getDb } = await import('../db/index.ts');
-const { createTestApp, waitForTurn, insertTestSession } = await import('./helpers/test-app.ts');
-
-describe('Integration: turn cancellation', () => {
-  let testApp: TestApp;
-
-  beforeEach(async () => {
-    vi.clearAllMocks();
-    clearBroadcasts();
-    testApp = await createTestApp();
-  });
-
-  afterEach(async () => {
-    await testApp.cleanup();
-  });
-
-  it('aborts a running turn and sets correct DB + WS state', async () => {
-    const db: Database.Database = getDb();
-
-    // Create session via HTTP
-    insertTestSession(db, 's1');
-
-    // Insert turn manually (not via HTTP — avoids fire-and-forget startTurn)
-    const now = new Date().toISOString();
-    db.prepare(
-      `INSERT INTO turns (id, session_id, user_prompt, agent_response, thoughts, token_usage, external_turn_id, status, error, created_at, updated_at)
-       VALUES (?, ?, ?, NULL, NULL, NULL, NULL, 'pending', NULL, ?, ?)`,
-    ).run('t1', 's1', 'Write a long essay about history', now, now);
-
-    const session = db.prepare('SELECT * FROM sessions WHERE id = ?').get('s1') as Record<string, unknown>;
-    const turn = db.prepare('SELECT * FROM turns WHERE id = ?').get('t1') as Record<string, unknown>;
-
-    // Start turn directly — do NOT await (need to cancel while running)
-    const turnPromise = startTurn(session as never, turn as never);
-
-    // Give it a moment to start streaming and set up abortController
-    await new Promise((r) => setTimeout(r, 50));
-
-    // Check that abortController is registered
-    const isRunning = db.prepare('SELECT is_running FROM sessions WHERE id = ?').get('s1') as { is_running: number };
-    expect(isRunning.is_running).toBe(1);
-
-    // Cancel the turn
-    const cancelled = await interruptTurn('s1');
-    expect(cancelled).toBe(true);
-
-    // Wait for the turn promise to resolve
-    await turnPromise;
-    await waitForTurn(db, 't1');
-
-    // Assert DB state
-    const dbTurn = db.prepare('SELECT status FROM turns WHERE id = ?').get('t1') as {
-      status: string;
-    };
-    expect(dbTurn.status).toBe('aborted');
-
-    const dbSession = db.prepare('SELECT is_running, status FROM sessions WHERE id = ?').get('s1') as {
-      is_running: number;
-      status: string;
-    };
-    expect(dbSession.is_running).toBe(0);
-    expect(dbSession.status).toBe('active');
-
-    // Assert WS broadcast
-    const cancelledData = findBroadcast('turn:cancelled') as {
-      sessionId: string;
-      turnId: string;
-    };
-    expect(cancelledData.sessionId).toBe('s1');
-    expect(cancelledData.turnId).toBe('t1');
-  });
-
-  it('returns false when interrupting a non-running session', async () => {
-    const result = await interruptTurn('nonexistent-session');
-    expect(result).toBe(false);
-  });
-});

package/agent-pane/backend/src/integration/turn-failure.test.ts

@@ -1,97 +0,0 @@
-/**
- * Integration test: turn failure handling.
- *
- * Verifies that error events from the SDK set the correct DB state
- * (turn=failed, session=failed) and broadcast turn:failed.
- *
- * Uses HTTP POST to trigger the turn (fire-and-forget startTurn).
- */
-
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { readFileSync } from 'node:fs';
-import { resolve } from 'node:path';
-import type Database from 'better-sqlite3';
-import { createAppServerMock, type Fixture } from './helpers/app-server-mock.ts';
-import { clearBroadcasts, findBroadcast, capturedBroadcasts } from './helpers/ws-capture.ts';
-import type { TestApp } from './helpers/test-app.ts';
-
-const fixture = JSON.parse(readFileSync(resolve(__dirname, '__fixtures__/failed-turn.json'), 'utf-8')) as Fixture;
-
-vi.mock('../codex/app-server-client.ts', () => ({
-  AppServerClient: createAppServerMock(fixture),
-}));
-
-vi.mock('../ws/index.ts', async (importOriginal) => {
-  const actual = (await importOriginal()) as Record<string, unknown>;
-  return {
-    ...actual,
-    broadcast: vi.fn((event: string, data: unknown) => {
-      capturedBroadcasts.push({ event, data });
-    }),
-  };
-});
-
-const { getDb } = await import('../db/index.ts');
-const { createTestApp, waitForTurn } = await import('./helpers/test-app.ts');
-
-describe('Integration: turn failure', () => {
-  let testApp: TestApp;
-
-  beforeEach(async () => {
-    vi.clearAllMocks();
-    clearBroadcasts();
-    testApp = await createTestApp();
-  });
-
-  afterEach(async () => {
-    await testApp.cleanup();
-  });
-
-  it('handles error event → turn=failed, session=failed, WS turn:failed', async () => {
-    const db: Database.Database = getDb();
-
-    // Create session
-    const createRes = await testApp.app.inject({
-      method: 'POST',
-      url: '/api/sessions',
-      payload: {},
-    });
-    const session = createRes.json();
-
-    // Submit turn via HTTP — triggers fire-and-forget startTurn
-    const turnRes = await testApp.app.inject({
-      method: 'POST',
-      url: `/api/sessions/${session.id}/turns`,
-      payload: { user_prompt: 'Do something that fails' },
-    });
-    const turn = turnRes.json();
-
-    await waitForTurn(db, turn.id);
-
-    // Assert DB — turn
-    const dbTurn = db.prepare('SELECT status, error FROM turns WHERE id = ?').get(turn.id) as {
-      status: string;
-      error: string | null;
-    };
-    expect(dbTurn.status).toBe('failed');
-    expect(dbTurn.error).toBe('Rate limit exceeded. Please try again later.');
-
-    // Assert DB — session
-    const dbSession = db.prepare('SELECT is_running, status FROM sessions WHERE id = ?').get(session.id) as {
-      is_running: number;
-      status: string;
-    };
-    expect(dbSession.is_running).toBe(0);
-    expect(dbSession.status).toBe('failed');
-
-    // Assert WS broadcast
-    const failedData = findBroadcast('turn:failed') as {
-      sessionId: string;
-      turnId: string;
-      error: string;
-    };
-    expect(failedData.sessionId).toBe(session.id);
-    expect(failedData.turnId).toBe(turn.id);
-    expect(failedData.error).toBe('Rate limit exceeded. Please try again later.');
-  });
-});