repoburg 1.3.202 → 1.3.204

package/agent-pane/backend/src/integration/missing-item-started.test.ts

@@ -1,91 +0,0 @@
-/**
- * Integration test: missing item.started auto-insert fallback.
- *
- * Verifies that when item.updated or item.completed arrives without
- * a prior item.started, the handleEvent auto-inserts the item into DB.
- *
- * 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, capturedBroadcasts } from './helpers/ws-capture.ts';
-import type { TestApp } from './helpers/test-app.ts';
-
-const fixture = JSON.parse(
-  readFileSync(resolve(__dirname, '__fixtures__/missing-item-started.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: missing item.started auto-insert', () => {
-  let testApp: TestApp;
-
-  beforeEach(async () => {
-    vi.clearAllMocks();
-    clearBroadcasts();
-    testApp = await createTestApp();
-  });
-
-  afterEach(async () => {
-    await testApp.cleanup();
-  });
-
-  it('auto-inserts item when item.updated arrives without item.started', 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
-    const turnRes = await testApp.app.inject({
-      method: 'POST',
-      url: `/api/sessions/${session.id}/turns`,
-      payload: { user_prompt: 'Hello' },
-    });
-    const turn = turnRes.json();
-
-    await waitForTurn(db, turn.id);
-
-    // Only 1 item in DB (no duplicate from missing item.started)
-    const items = db.prepare('SELECT * FROM items WHERE turn_id = ? ORDER BY created_at ASC').all(turn.id) as {
-      type: string;
-      data: string;
-      status: string;
-    }[];
-    expect(items).toHaveLength(1);
-    expect(items[0].type).toBe('agent_message');
-    expect(items[0].status).toBe('completed');
-    expect(JSON.parse(items[0].data)).toEqual({ text: 'Hello! How can I help?' });
-
-    // Verify WS: item:updated broadcast fired (auto-insert path)
-    const updatedBroadcasts = capturedBroadcasts.filter((b) => b.event === 'item:updated');
-    expect(updatedBroadcasts).toHaveLength(1);
-
-    const completedBroadcasts = capturedBroadcasts.filter((b) => b.event === 'item:completed');
-    expect(completedBroadcasts).toHaveLength(1);
-  });
-});

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

@@ -1,121 +0,0 @@
-/**
- * Integration test: multi-turn session — thread reuse and title only once.
- *
- * Verifies that a second turn in the same session reuses the existing
- * thread (external_thread_id set after first turn) and that the title
- * is only generated once (for the first turn).
- *
- * Uses HTTP POST to trigger each 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, capturedBroadcasts } from './helpers/ws-capture.ts';
-import type { TestApp } from './helpers/test-app.ts';
-
-const fixture = JSON.parse(readFileSync(resolve(__dirname, '__fixtures__/multi-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: multi-turn', () => {
-  let testApp: TestApp;
-
-  beforeEach(async () => {
-    vi.clearAllMocks();
-    clearBroadcasts();
-    testApp = await createTestApp();
-  });
-
-  afterEach(async () => {
-    await testApp.cleanup();
-  });
-
-  it('handles two turns with thread reuse and title only once', async () => {
-    const db: Database.Database = getDb();
-
-    // Create session
-    const createRes = await testApp.app.inject({
-      method: 'POST',
-      url: '/api/sessions',
-      payload: {},
-    });
-    const session = createRes.json();
-
-    // Turn 1 via HTTP
-    const turn1Res = await testApp.app.inject({
-      method: 'POST',
-      url: `/api/sessions/${session.id}/turns`,
-      payload: { user_prompt: 'What is 2+2?' },
-    });
-    const turn1 = turn1Res.json();
-    await waitForTurn(db, turn1.id);
-
-    // After turn 1: external_thread_id should be set
-    const sessionAfterT1 = db
-      .prepare('SELECT external_thread_id, title FROM sessions WHERE id = ?')
-      .get(session.id) as { external_thread_id: string | null; title: string | null };
-    expect(sessionAfterT1.external_thread_id).toBe('thread_fix_005');
-
-    // Wait for title generation (fire-and-forget)
-    await new Promise((r) => setTimeout(r, 500));
-    const sessionTitled = db.prepare('SELECT title FROM sessions WHERE id = ?').get(session.id) as {
-      title: string | null;
-    };
-    expect(sessionTitled.title).toBe('Simple Math Questions');
-
-    // Turn 2 via HTTP
-    const turn2Res = await testApp.app.inject({
-      method: 'POST',
-      url: `/api/sessions/${session.id}/turns`,
-      payload: { user_prompt: 'What about 3+3?' },
-    });
-    const turn2 = turn2Res.json();
-    await waitForTurn(db, turn2.id);
-
-    // Both turns in DB
-    const turns = db.prepare('SELECT * FROM turns WHERE session_id = ? ORDER BY created_at ASC').all(session.id) as {
-      user_prompt: string;
-      agent_response: string | null;
-      status: string;
-    }[];
-    expect(turns).toHaveLength(2);
-    expect(turns[0].user_prompt).toBe('What is 2+2?');
-    expect(turns[0].agent_response).toBe('2+2 equals 4.');
-    expect(turns[0].status).toBe('completed');
-    expect(turns[1].user_prompt).toBe('What about 3+3?');
-    expect(turns[1].agent_response).toBe('3+3 equals 6.');
-    expect(turns[1].status).toBe('completed');
-
-    // Title should still be from first turn (not regenerated)
-    const finalTitle = db.prepare('SELECT title FROM sessions WHERE id = ?').get(session.id) as {
-      title: string | null;
-    };
-    expect(finalTitle.title).toBe('Simple Math Questions');
-
-    // Only one session:title broadcast (from first turn's title generation)
-    const titleBroadcasts = capturedBroadcasts.filter((b) => b.event === 'session:title');
-    expect(titleBroadcasts).toHaveLength(1);
-
-    // Two turn:completed broadcasts
-    const completedBroadcasts = capturedBroadcasts.filter((b) => b.event === 'turn:completed');
-    expect(completedBroadcasts).toHaveLength(2);
-  });
-});

package/agent-pane/backend/src/integration/session-operations.test.ts

@@ -1,175 +0,0 @@
-/**
- * Integration test: session operations — rewind, branch, model change.
- *
- * These operations interact with codex-provider's clearThread() function.
- * Uses the real codex-provider.ts (not mocked) with a simple-turn fixture
- * to populate DB state, then tests the operations via HTTP.
- */
-
-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: session operations', () => {
-  let testApp: TestApp;
-
-  beforeEach(async () => {
-    vi.clearAllMocks();
-    clearBroadcasts();
-    testApp = await createTestApp();
-  });
-
-  afterEach(async () => {
-    await testApp.cleanup();
-  });
-
-  it('rewind marks session as rewound (non-destructive) and saves pre_rewind_thread_id', async () => {
-    const db: Database.Database = getDb();
-
-    insertTestSession(db, 's1', { external_thread_id: 'thread_old' });
-
-    // Insert two turns manually
-    const now1 = '2025-01-01T00:00:00Z';
-    const now2 = '2025-01-01T01: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 (?, ?, ?, NULL, NULL, NULL, NULL, 'completed', NULL, ?, ?)`,
-    ).run('t1', 's1', 'first', now1, now1);
-    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, 'completed', NULL, ?, ?)`,
-    ).run('t2', 's1', 'second', now2, now2);
-
-    // Rewind to t1 — non-destructive: turns are NOT deleted
-    const res = await testApp.app.inject({
-      method: 'POST',
-      url: '/api/sessions/s1/rewind',
-      payload: { turn_id: 't1' },
-    });
-    expect(res.statusCode).toBe(200);
-
-    // Both turns still exist (not deleted)
-    const turns = db.prepare('SELECT id FROM turns WHERE session_id = ?').all('s1') as {
-      id: string;
-    }[];
-    expect(turns).toHaveLength(2);
-
-    // Session marked as rewound, pre_rewind_thread_id saved
-    const session = db.prepare('SELECT rewound_at_turn_id, pre_rewind_thread_id FROM sessions WHERE id = ?').get('s1') as {
-      rewound_at_turn_id: string | null;
-      pre_rewind_thread_id: string | null;
-    };
-    expect(session.rewound_at_turn_id).toBe('t1');
-    expect(session.pre_rewind_thread_id).toBe('thread_old');
-
-    // GET session filters turns (only t1 visible)
-    const getRes = await testApp.app.inject({ method: 'GET', url: '/api/sessions/s1' });
-    expect(getRes.json().turns).toHaveLength(1);
-    expect(getRes.json().turns[0].id).toBe('t1');
-  });
-
-  it('branch creates new session with copied turns and items', async () => {
-    const db: Database.Database = getDb();
-
-    insertTestSession(db, 's1', { title: 'Original', model: 'gpt-4' });
-
-    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 (?, ?, ?, 'answer', NULL, NULL, NULL, 'completed', NULL, ?, ?)`,
-    ).run('t1', 's1', 'hello', now, now);
-    db.prepare(
-      `INSERT INTO items (id, turn_id, external_item_id, type, data, status, created_at, updated_at)
-       VALUES (?, ?, ?, 'agent_message', ?, 'completed', ?, ?)`,
-    ).run('i1', 't1', 'ext1', JSON.stringify({ text: 'answer' }), now, now);
-
-    const res = await testApp.app.inject({
-      method: 'POST',
-      url: '/api/sessions/s1/branch',
-      payload: { turn_id: 't1' },
-    });
-    expect(res.statusCode).toBe(200);
-    const newSession = res.json();
-    expect(newSession.id).not.toBe('s1');
-    expect(newSession.title).toBe('Branch of Original');
-    expect(newSession.model).toBe('gpt-4');
-    expect(newSession.external_thread_id).toBeNull();
-
-    // New session has copied turn + item
-    const newTurns = db.prepare('SELECT * FROM turns WHERE session_id = ?').all(newSession.id) as {
-      user_prompt: string;
-      agent_response: string;
-    }[];
-    expect(newTurns).toHaveLength(1);
-    expect(newTurns[0].user_prompt).toBe('hello');
-    expect(newTurns[0].agent_response).toBe('answer');
-
-    const newItems = db
-      .prepare('SELECT * FROM items WHERE turn_id IN (SELECT id FROM turns WHERE session_id = ?)')
-      .all(newSession.id) as { type: string }[];
-    expect(newItems).toHaveLength(1);
-    expect(newItems[0].type).toBe('agent_message');
-  });
-
-  it('model change preserves thread when external_thread_id exists (same provider)', async () => {
-    const db: Database.Database = getDb();
-
-    insertTestSession(db, 's1', { model: 'gpt-4', external_thread_id: 'thread_123' });
-
-    const res = await testApp.app.inject({
-      method: 'PATCH',
-      url: '/api/sessions/s1',
-      payload: { model: 'o3' },
-    });
-    expect(res.statusCode).toBe(200);
-
-    const session = db.prepare('SELECT external_thread_id, model FROM sessions WHERE id = ?').get('s1') as {
-      external_thread_id: string | null;
-      model: string | null;
-    };
-    // Thread must survive model change within the same provider
-    expect(session.external_thread_id).toBe('thread_123');
-    expect(session.model).toBe('o3');
-  });
-
-  it('model change does NOT clear thread when external_thread_id is null', async () => {
-    const db: Database.Database = getDb();
-
-    insertTestSession(db, 's1', { model: 'gpt-4' });
-
-    const res = await testApp.app.inject({
-      method: 'PATCH',
-      url: '/api/sessions/s1',
-      payload: { model: 'o3' },
-    });
-    expect(res.statusCode).toBe(200);
-
-    const session = db.prepare('SELECT external_thread_id FROM sessions WHERE id = ?').get('s1') as {
-      external_thread_id: string | null;
-    };
-    expect(session.external_thread_id).toBeNull();
-  });
-});

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

@@ -1,241 +0,0 @@
-/**
- * Integration test: discussion threads — Claude fork isolation (BUG 1 + BUG 2).
- *
- * Exercises the REAL claudeProvider + REAL thread routes with a mocked Claude
- * SDK (`query` + `forkSession`). Verifies that creating a Discuss thread forks
- * the main session, stores the fork id on the thread row, and never corrupts
- * the main session's `external_thread_id`; and that a failed fork starts a
- * fresh isolated session instead of resuming (and contaminating) the main
- * session.
- */
-
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import type Database from 'better-sqlite3';
-import { clearBroadcasts, capturedBroadcasts } from './helpers/ws-capture.ts';
-import type { TestApp } from './helpers/test-app.ts';
-
-// Mock the Claude SDK — both the query factory and forkSession.
-vi.mock('@anthropic-ai/claude-agent-sdk', () => ({
-  query: vi.fn(),
-  forkSession: vi.fn(),
-}));
-
-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 });
-    }),
-  };
-});
-
-// Import after mocks are set up.
-import { query, forkSession } from '@anthropic-ai/claude-agent-sdk';
-import { clearAllThreads } from '../claude/claude-provider.ts';
-const { getDb } = await import('../db/index.ts');
-const { createTestApp, insertTestSession, waitForTurn } = await import('./helpers/test-app.ts');
-
-// ---------------------------------------------------------------------------
-// Mock helpers
-// ---------------------------------------------------------------------------
-
-/** Build a mock `Query` whose async iterator yields the given SDK messages in
- *  order, then ends. getContextUsage resolves an empty snapshot (0/0) so the
- *  result/success handler completes the turn without emitting contextUsage. */
-function createClaudeQueryMock(messages: unknown[]): unknown {
-  return {
-    getContextUsage: vi.fn().mockResolvedValue({
-      totalTokens: 0, maxTokens: 0, rawMaxTokens: 0, percentage: 0,
-      categories: [], gridRows: [], model: '', memoryFiles: [], mcpTools: [],
-    }),
-    interrupt: vi.fn(),
-    setModel: vi.fn(),
-    close: vi.fn(),
-    stopTask: vi.fn(),
-    initializationResult: vi.fn(),
-    [Symbol.asyncIterator]: async function* () {
-      for (const m of messages) yield m;
-    },
-  };
-}
-
-/** A `system/init` SDK message carrying the given Claude session id. */
-function initMsg(claudeSessionId: string): unknown {
-  return { type: 'system', subtype: 'init', session_id: claudeSessionId };
-}
-
-/** A `result/success` SDK message that completes a turn. */
-function resultSuccessMsg(claudeSessionId: string): unknown {
-  return {
-    type: 'result', subtype: 'success',
-    usage: { input_tokens: 10, cache_read_input_tokens: 0, cache_creation_input_tokens: 0, output_tokens: 5 },
-    modelUsage: {}, result: 'done', is_error: false, num_turns: 1,
-    stop_reason: 'end_turn', duration_ms: 1, duration_api_ms: 1, total_cost_usd: 0,
-    permission_denials: [], uuid: 'u1', session_id: claudeSessionId,
-  };
-}
-
-describe('Integration: discussion threads — Claude fork isolation', () => {
-  let testApp: TestApp;
-
-  beforeEach(async () => {
-    vi.clearAllMocks();
-    clearAllThreads();
-    clearBroadcasts();
-    testApp = await createTestApp();
-  });
-
-  afterEach(async () => {
-    clearAllThreads();
-    await testApp.cleanup();
-  });
-
-  /** Seed a Claude session + anchor turn/item, ready for a thread creation. */
-  function seedSession(db: Database.Database): void {
-    insertTestSession(db, 's1', { runtime_type: 'claude', external_thread_id: 'main-1', title: 'Test' });
-    const now = '2025-01-01T00:00:00Z';
-    db.prepare(
-      `INSERT INTO turns (id, session_id, user_prompt, agent_response, status, external_turn_id, created_at, updated_at)
-       VALUES ('t1', 's1', 'prompt', 'response', 'completed', 'msg-uuid-1', ?, ?)`,
-    ).run(now, now);
-    db.prepare(
-      `INSERT INTO items (id, turn_id, external_item_id, type, data, status, created_at, updated_at)
-       VALUES ('i1', 't1', 'ext1', 'agent_message', ?, 'completed', ?, ?)`,
-    ).run(JSON.stringify({ text: 'Some text to discuss' }), now, now);
-  }
-
-  /** The shared thread-creation POST payload. */
-  const threadPayload = {
-    itemId: 'i1',
-    turnId: 't1',
-    startOffset: 0,
-    endOffset: 10,
-    selectedText: 'Some text ',
-    message: 'What does this mean?',
-  };
-
-  it('successful fork: stores fork id, resumes the fork, does NOT corrupt the main session (BUG 1 + BUG 2)', async () => {
-    const db: Database.Database = getDb();
-    seedSession(db);
-
-    // forkSession returns a new forked session id.
-    vi.mocked(forkSession).mockResolvedValue({ sessionId: 'fork-9' } as never);
-    // The forked query emits init with the FORK's id, then completes the turn.
-    vi.mocked(query).mockReturnValue(createClaudeQueryMock([initMsg('fork-9'), resultSuccessMsg('fork-9')]) as never);
-
-    const res = await testApp.app.inject({
-      method: 'POST',
-      url: '/api/sessions/s1/threads',
-      payload: threadPayload,
-    });
-
-    expect(res.statusCode).toBe(200);
-    const body = res.json();
-    const threadId = body.thread.id as string;
-    const turnId = body.turn.id as string;
-
-    // forkSession was called with the MAIN session id + the anchor turn's message UUID.
-    expect(vi.mocked(forkSession).mock.calls[0][0]).toBe('main-1');
-    expect((vi.mocked(forkSession).mock.calls[0][1] as { upToMessageId?: string }).upToMessageId).toBe('msg-uuid-1');
-
-    // The fork id is stored on the THREAD row, not the main session.
-    const threadRow = db.prepare('SELECT external_thread_id FROM discussion_threads WHERE id = ?').get(threadId) as
-      | { external_thread_id: string | null }
-      | undefined;
-    expect(threadRow?.external_thread_id).toBe('fork-9');
-
-    // Wait for the thread turn to complete, then assert the main session is intact.
-    await waitForTurn(db, turnId);
-
-    // BUG 2: the thread turn resumed its OWN fork ('fork-9'), not the main session.
-    const opts = (vi.mocked(query).mock.calls[0][0] as { options: { resume?: string } }).options;
-    expect(opts.resume).toBe('fork-9');
-
-    // BUG 1: the main session's external_thread_id was NOT overwritten with the fork's id.
-    const sessionRow = db.prepare('SELECT external_thread_id FROM sessions WHERE id = ?').get('s1') as
-      | { external_thread_id: string | null }
-      | undefined;
-    expect(sessionRow?.external_thread_id).toBe('main-1');
-
-    // thread:created was broadcast.
-    expect(capturedBroadcasts.find((b) => b.event === 'thread:created')).toBeDefined();
-  });
-
-  it('failed fork (null): thread still created, starts a FRESH session (resume undefined), main session untouched (BUG 2)', async () => {
-    const db: Database.Database = getDb();
-    seedSession(db);
-
-    // forkSession returns null (e.g. no main session to fork from, or SDK refused).
-    vi.mocked(forkSession).mockResolvedValue(null as never);
-    // The fresh isolated session emits its own init id, then completes.
-    vi.mocked(query).mockReturnValue(createClaudeQueryMock([initMsg('fresh-1'), resultSuccessMsg('fresh-1')]) as never);
-
-    const res = await testApp.app.inject({
-      method: 'POST',
-      url: '/api/sessions/s1/threads',
-      payload: threadPayload,
-    });
-
-    expect(res.statusCode).toBe(200);
-    const body = res.json();
-    const threadId = body.thread.id as string;
-    const turnId = body.turn.id as string;
-
-    // The thread row has NO fork id.
-    const threadRow = db.prepare('SELECT external_thread_id FROM discussion_threads WHERE id = ?').get(threadId) as
-      | { external_thread_id: string | null }
-      | undefined;
-    expect(threadRow?.external_thread_id).toBeNull();
-
-    await waitForTurn(db, turnId);
-
-    // BUG 2: the thread started a FRESH session — no `resume` option — and did
-    // NOT fall back to the main session's 'main-1'.
-    const opts = (vi.mocked(query).mock.calls[0][0] as { options: { resume?: string } }).options;
-    expect(opts.resume).toBeUndefined();
-
-    // The main session is untouched.
-    const sessionRow = db.prepare('SELECT external_thread_id FROM sessions WHERE id = ?').get('s1') as
-      | { external_thread_id: string | null }
-      | undefined;
-    expect(sessionRow?.external_thread_id).toBe('main-1');
-  });
-
-  it('failed fork (throws): caught, thread still created, main session untouched (BUG 2)', async () => {
-    const db: Database.Database = getDb();
-    seedSession(db);
-
-    // forkSession throws — the route must catch it and still create the thread.
-    vi.mocked(forkSession).mockRejectedValue(new Error('boom') as never);
-    vi.mocked(query).mockReturnValue(createClaudeQueryMock([initMsg('fresh-2'), resultSuccessMsg('fresh-2')]) as never);
-
-    const res = await testApp.app.inject({
-      method: 'POST',
-      url: '/api/sessions/s1/threads',
-      payload: threadPayload,
-    });
-
-    expect(res.statusCode).toBe(200);
-    const body = res.json();
-    const threadId = body.thread.id as string;
-    const turnId = body.turn.id as string;
-
-    // The thread row has NO fork id (fork threw before storing anything).
-    const threadRow = db.prepare('SELECT external_thread_id FROM discussion_threads WHERE id = ?').get(threadId) as
-      | { external_thread_id: string | null }
-      | undefined;
-    expect(threadRow?.external_thread_id).toBeNull();
-
-    await waitForTurn(db, turnId);
-
-    // The thread started a fresh isolated session (no resume), not the main session.
-    const opts = (vi.mocked(query).mock.calls[0][0] as { options: { resume?: string } }).options;
-    expect(opts.resume).toBeUndefined();
-
-    const sessionRow = db.prepare('SELECT external_thread_id FROM sessions WHERE id = ?').get('s1') as
-      | { external_thread_id: string | null }
-      | undefined;
-    expect(sessionRow?.external_thread_id).toBe('main-1');
-  });
-});