repoburg 1.3.202 → 1.3.204

package/agent-pane/backend/src/repoburg/repoburg-provider.test.ts

@@ -1,780 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-
-// Mock the HTTP client class — the provider must only talk to the interface.
-vi.mock('./repoburg-client.ts', () => ({
-  RepoburgHttpClient: vi.fn(),
-}));
-
-// Mock the daemon resolver — lifecycle logic has its own test file.
-vi.mock('./backend-resolver.ts', () => ({
-  resolveBackendUrl: vi.fn(),
-  invalidateBackend: vi.fn(),
-}));
-
-// Capture SSE stream invocations — deliver agent-runtime messages manually
-// and resolve the stream promise to simulate stream end / reconnect.
-interface StreamCall {
-  baseUrl: string;
-  sessionId: string;
-  onMessage: (message: AgentRuntimeMessage) => void;
-  opts: { signal?: AbortSignal; onActivity?: () => void };
-  resolve: (reason: string) => void;
-}
-const streamCalls: StreamCall[] = [];
-vi.mock('./agent-runtime-client.ts', () => ({
-  streamAgentRuntimeMessages: vi.fn(
-    (baseUrl: string, sessionId: string, onMessage: (m: AgentRuntimeMessage) => void, opts: StreamCall['opts']) =>
-      new Promise((resolve) => {
-        streamCalls.push({ baseUrl, sessionId, onMessage, opts, resolve });
-      }),
-  ),
-}));
-
-import { RepoburgHttpClient } from './repoburg-client.ts';
-import {
-  resolveBackendUrl,
-  invalidateBackend as invalidateBackendImport,
-} from './backend-resolver.ts';
-import { streamAgentRuntimeMessages } from './agent-runtime-client.ts';
-import type { AgentRuntimeMessage } from './agent-runtime-client.ts';
-import type { RepoburgRuntimeClient } from './repoburg-client.ts';
-
-// Capture broadcasts without touching a real WebSocket server.
-const captured: Array<{ event: string; data: unknown }> = [];
-vi.mock('../ws/index.ts', async (importOriginal) => {
-  const actual = (await importOriginal()) as Record<string, unknown>;
-  return {
-    ...actual,
-    broadcast: vi.fn((event: string, data: unknown) => {
-      captured.push({ event, data });
-    }),
-  };
-});
-
-// Import after mocks are set up
-import { repoburgProvider, mapReasoningEffort } from './repoburg-provider.ts';
-import { initDb } from '../db/index.ts';
-import type Database from 'better-sqlite3';
-import type { Session, Turn } from '../db/schema.ts';
-
-/** Build a mock runtime client (HTTP control surface only). */
-function makeMockClient(): { client: RepoburgRuntimeClient } {
-  const client = {
-    createSession: vi.fn(),
-    patchSession: vi.fn(),
-    getSession: vi.fn(),
-    createInput: vi.fn(),
-    getInputWithActions: vi.fn(),
-    getSessionInputs: vi.fn(),
-    deleteInputsUntilHere: vi.fn().mockResolvedValue(undefined),
-    cancel: vi.fn().mockResolvedValue({ success: true, cancelled: true }),
-    getModels: vi.fn(),
-  } as unknown as RepoburgRuntimeClient;
-  return { client };
-}
-
-let mock = makeMockClient();
-
-/** Deliver an agent-runtime message through the active stream. */
-function deliver(message: AgentRuntimeMessage): void {
-  const call = streamCalls[streamCalls.length - 1];
-  call.onMessage(message);
-  call.opts.onActivity?.();
-}
-
-describe('repoburgProvider', () => {
-  let db: Database.Database;
-
-  beforeEach(async () => {
-    vi.clearAllMocks();
-    await repoburgProvider.shutdown(); // reset module state + session map
-    mock = makeMockClient();
-    streamCalls.length = 0;
-    vi.mocked(RepoburgHttpClient).mockImplementation(() => mock.client as never);
-    vi.mocked(resolveBackendUrl)
-      .mockReset()
-      .mockResolvedValue({ baseUrl: 'http://repoburg.test', port: 1234, name: 'test' });
-    captured.length = 0;
-
-    db = initDb(':memory:');
-    const now = new Date().toISOString();
-    db.prepare(
-      `INSERT INTO sessions (id, title, runtime_type, model, model_reasoning_effort, status, is_running, lifecycle, created_at, updated_at)
-       VALUES ('s1', NULL, 'repoburg', 'ollama/glm-5.3:cloud', 'medium', 'active', 0, 'working', ?, ?)`,
-    ).run(now, now);
-  });
-
-  afterEach(() => {
-    db.close();
-  });
-
-  /** Insert a pending turn and load session + turn rows for startTurn. */
-  function seedTurn(turnId: string, prompt = 'hello'): { session: Session; turn: Turn } {
-    const now = new Date().toISOString();
-    db.prepare(
-      `INSERT INTO turns (id, session_id, user_prompt, status, created_at, updated_at)
-       VALUES (?, 's1', ?, 'pending', ?, ?)`,
-    ).run(turnId, prompt, now, now);
-    const session = db.prepare('SELECT * FROM sessions WHERE id = ?').get('s1') as Session;
-    const turn = db.prepare('SELECT * FROM turns WHERE id = ?').get(turnId) as Turn;
-    return { session, turn };
-  }
-
-  /** Start a seeded turn with a successfully created runtime session. */
-  async function startedTurn(turnId = 't1'): Promise<void> {
-    mock.client.createSession = vi.fn().mockResolvedValue({ id: 'rs-1' });
-    mock.client.createInput = vi.fn().mockResolvedValue({ id: 'in-1' });
-    const { session, turn } = seedTurn(turnId);
-    await repoburgProvider.startTurn(session, turn);
-    await vi.waitFor(() => expect(streamCalls.length).toBeGreaterThanOrEqual(1));
-  }
-
-  it('implements all RuntimeProvider methods', () => {
-    expect(repoburgProvider.startTurn).toBeTypeOf('function');
-    expect(repoburgProvider.interruptTurn).toBeTypeOf('function');
-    expect(repoburgProvider.clearThread).toBeTypeOf('function');
-    expect(repoburgProvider.clearAllThreads).toBeTypeOf('function');
-    expect(repoburgProvider.getModels).toBeTypeOf('function');
-    expect(repoburgProvider.shutdown).toBeTypeOf('function');
-  });
-it('implements all RuntimeProvider methods', () => {
-    expect(repoburgProvider.startTurn).toBeTypeOf('function');
-    expect(repoburgProvider.interruptTurn).toBeTypeOf('function');
-    expect(repoburgProvider.clearThread).toBeTypeOf('function');
-    expect(repoburgProvider.clearAllThreads).toBeTypeOf('function');
-    expect(repoburgProvider.getModels).toBeTypeOf('function');
-    expect(repoburgProvider.rewindRuntime).toBeTypeOf('function');
-    expect(repoburgProvider.shutdown).toBeTypeOf('function');
-  });
-
-  it('rewindRuntime truncates via until-here with the LAST runtime input id', async () => {
-    db.prepare('UPDATE sessions SET external_thread_id = ? WHERE id = ?').run('rs-1', 's1');
-    const { session } = seedTurn('t1');
-    db.prepare('UPDATE turns SET runtime_input_ids = ? WHERE id = ?').run(
-      JSON.stringify(['in-1', 'in-2', 'in-3']),
-      't1',
-    );
-    // Re-load the turn row AFTER the update (seedTurn fetched a stale row).
-    const turn = db.prepare('SELECT * FROM turns WHERE id = ?').get('t1') as Turn;
-
-    await repoburgProvider.rewindRuntime!(session, turn);
-
-    expect(mock.client.deleteInputsUntilHere).toHaveBeenCalledWith('rs-1', 'in-3');
-  });
-
-  it('rewindRuntime throws when the turn has no runtime input ids', async () => {
-    db.prepare('UPDATE sessions SET external_thread_id = ? WHERE id = ?').run('rs-1', 's1');
-    const { session, turn } = seedTurn('t1');
-
-    await expect(repoburgProvider.rewindRuntime!(session, turn)).rejects.toThrow(
-      'no runtime input ids',
-    );
-    expect(mock.client.deleteInputsUntilHere).not.toHaveBeenCalled();
-  });
-
-  it('rewindRuntime is a no-op when the session has no runtime thread', async () => {
-    const { session, turn } = seedTurn('t1');
-
-    await repoburgProvider.rewindRuntime!(session, turn);
-
-    expect(mock.client.deleteInputsUntilHere).not.toHaveBeenCalled();
-  });
-
-  it('rewindRuntime accepts the typed Turn array form of runtime_input_ids', async () => {
-    db.prepare('UPDATE sessions SET external_thread_id = ? WHERE id = ?').run('rs-1', 's1');
-    const { session, turn } = seedTurn('t1');
-    const typedTurn = { ...turn, runtime_input_ids: ['in-a', 'in-b'] } as Turn;
-
-    await repoburgProvider.rewindRuntime!(session, typedTurn);
-
-    expect(mock.client.deleteInputsUntilHere).toHaveBeenCalledWith('rs-1', 'in-b');
-  });
-
-  describe('mapReasoningEffort', () => {
-    it('passes valid Ollama levels through and clamps xhigh to high', () => {
-      expect(mapReasoningEffort('ollama/glm-5.3:cloud', 'low')).toBe('low');
-      expect(mapReasoningEffort('ollama/glm-5.3:cloud', 'medium')).toBe('medium');
-      expect(mapReasoningEffort('ollama/glm-5.3:cloud', 'high')).toBe('high');
-      expect(mapReasoningEffort('ollama/glm-5.3:cloud', 'xhigh')).toBe('high');
-    });
-
-    it('omits Ollama-inexpressible levels (minimal/none) and unknown values', () => {
-      expect(mapReasoningEffort('ollama/glm-5.3:cloud', 'minimal')).toBeUndefined();
-      expect(mapReasoningEffort('ollama/glm-5.3:cloud', 'none')).toBeUndefined();
-      expect(mapReasoningEffort('ollama/glm-5.3:cloud', 'ultra')).toBeUndefined();
-      expect(mapReasoningEffort('ollama/glm-5.3:cloud', null)).toBeUndefined();
-    });
-
-    it('passes the full root enum through for non-Ollama providers', () => {
-      expect(mapReasoningEffort('zai/glm-5', 'xhigh')).toBe('xhigh');
-      expect(mapReasoningEffort('zai/glm-5', 'minimal')).toBe('minimal');
-      expect(mapReasoningEffort(null, 'high')).toBe('high');
-    });
-  });
-
-  it('getModels maps runtime models to ModelInfo', async () => {
-    mock.client.getModels = vi.fn().mockResolvedValue([
-      { id: 'ollama/glm-5.3:cloud', name: 'glm-5.3:cloud' },
-    ]);
-
-    const models = await repoburgProvider.getModels();
-    expect(models).toHaveLength(1);
-    expect(models[0].slug).toBe('ollama/glm-5.3:cloud');
-    expect(models[0].displayName).toBe('glm-5.3:cloud');
-    expect(models[0].reasoningLevels.length).toBeGreaterThan(0);
-  });
-
-  it('getModels offers 3 levels for Ollama models, 4 for other providers', async () => {
-    mock.client.getModels = vi.fn().mockResolvedValue([
-      { id: 'ollama/glm-5.3:cloud', name: 'glm-5.3:cloud' },
-      { id: 'zai/glm-5', name: 'glm-5' },
-    ]);
-
-    const models = await repoburgProvider.getModels();
-    expect(models[0].reasoningLevels.map((l) => l.effort)).toEqual(['low', 'medium', 'high']);
-    expect(models[1].reasoningLevels.map((l) => l.effort)).toEqual([
-      'low',
-      'medium',
-      'high',
-      'xhigh',
-    ]);
-  });
-
-  it('getModels never auto-starts a backend (autoStart=false)', async () => {
-    mock.client.getModels = vi.fn().mockResolvedValue([]);
-    await repoburgProvider.getModels();
-    expect(resolveBackendUrl).toHaveBeenCalledWith(process.cwd(), { autoStart: false });
-  });
-
-  it('getModels returns empty array when no backend is running', async () => {
-    vi.mocked(resolveBackendUrl).mockResolvedValue(null);
-    const models = await repoburgProvider.getModels();
-    expect(models).toEqual([]);
-    expect(mock.client.getModels).not.toHaveBeenCalled();
-  });
-
-  it('getModels returns empty array on error', async () => {
-    mock.client.getModels = vi.fn().mockRejectedValue(new Error('backend down'));
-
-    const models = await repoburgProvider.getModels();
-    expect(models).toEqual([]);
-  });
-
-  it('startTurn resolves the workspace backend before creating the session', async () => {
-    mock.client.createSession = vi.fn().mockResolvedValue({ id: 'rs-1' });
-    mock.client.createInput = vi.fn().mockResolvedValue({ id: 'in-1' });
-    db.prepare('UPDATE sessions SET cwd = ? WHERE id = ?').run('/tmp/proj', 's1');
-
-    const { session, turn } = seedTurn('t1');
-    await repoburgProvider.startTurn(session, turn);
-
-    expect(resolveBackendUrl).toHaveBeenCalledWith('/tmp/proj');
-    expect(mock.client.createSession).toHaveBeenCalled();
-  });
-
-  it('startTurn fails the turn when backend resolution fails (daemon down)', async () => {
-    vi.mocked(resolveBackendUrl).mockRejectedValue(
-      new Error(
-        "Repoburg daemon not reachable at http://localhost:9998. Start it with 'repoburg-daemon'.",
-      ),
-    );
-
-    const { session, turn } = seedTurn('t1');
-    await repoburgProvider.startTurn(session, turn);
-
-    const failedTurn = db.prepare('SELECT status, error FROM turns WHERE id = ?').get('t1') as
-      | { status: string; error: string | null }
-      | undefined;
-    expect(failedTurn?.status).toBe('failed');
-    expect(failedTurn?.error).toMatch(/daemon not reachable/);
-
-    const failed = captured.find((b) => b.event === 'turn:failed');
-    expect(failed).toBeDefined();
-    expect(mock.client.createSession).not.toHaveBeenCalled();
-  });
-
-  it('startTurn invalidates the resolver cache when the backend connection drops', async () => {
-    mock.client.createSession = vi.fn().mockRejectedValue(new Error('fetch failed ECONNREFUSED'));
-
-    const { session, turn } = seedTurn('t1');
-    await repoburgProvider.startTurn(session, turn);
-
-    expect(vi.mocked(invalidateBackendImport)).toHaveBeenCalledWith('http://repoburg.test');
-    const failedTurn = db.prepare('SELECT status FROM turns WHERE id = ?').get('t1') as
-      | { status: string }
-      | undefined;
-    expect(failedTurn?.status).toBe('failed');
-  });
-
-  it('startTurn invalidates the resolver cache when createInput drops mid-turn', async () => {
-    mock.client.createSession = vi.fn().mockResolvedValue({ id: 'rs-1' });
-    mock.client.createInput = vi.fn().mockRejectedValue(new Error('fetch failed ECONNREFUSED'));
-
-    const { session, turn } = seedTurn('t1');
-    await repoburgProvider.startTurn(session, turn);
-
-    expect(vi.mocked(invalidateBackendImport)).toHaveBeenCalledWith('http://repoburg.test');
-    const failedTurn = db.prepare('SELECT status FROM turns WHERE id = ?').get('t1') as
-      | { status: string }
-      | undefined;
-    expect(failedTurn?.status).toBe('failed');
-    expect(captured.find((b) => b.event === 'turn:failed')).toBeDefined();
-  });
-
-  it('startTurn creates a runtime session, persists external_thread_id, and starts the input + SSE stream', async () => {
-    mock.client.createSession = vi.fn().mockResolvedValue({ id: 'rs-1' });
-    mock.client.createInput = vi.fn().mockResolvedValue({ id: 'in-1' });
-
-    const { session, turn } = seedTurn('t1');
-    await repoburgProvider.startTurn(session, turn);
-    await vi.waitFor(() => expect(streamCalls.length).toBeGreaterThanOrEqual(1));
-
-    // Runtime session created with the agent-pane model + reasoning config.
-    expect(mock.client.createSession).toHaveBeenCalledWith({
-      model_id: 'ollama/glm-5.3:cloud',
-      reasoning_effort: 'medium',
-    });
-    // Repoburg session id persisted as external_thread_id.
-    const row = db.prepare('SELECT external_thread_id FROM sessions WHERE id = ?').get('s1') as
-      | { external_thread_id: string | null }
-      | undefined;
-    expect(row?.external_thread_id).toBe('rs-1');
-
-    // Turn lifecycle started.
-    expect(captured.find((b) => b.event === 'turn:started')).toBeDefined();
-    expect(db.prepare('SELECT status FROM turns WHERE id = ?').get('t1')).toEqual({
-      status: 'running',
-    });
-
-    // SSE message stream opened against the runtime session.
-    expect(streamCalls[0].baseUrl).toBe('http://repoburg.test');
-    expect(streamCalls[0].sessionId).toBe('rs-1');
-    expect(streamCalls[0].opts.signal).toBeInstanceOf(AbortSignal);
-
-    // Input started with the autonomous execution strategy.
-    expect(mock.client.createInput).toHaveBeenCalledWith('rs-1', {
-      user_prompt: 'hello',
-      execution_strategy: 'auto_apply',
-    });
-  });
-
-  it('startTurn clamps Ollama xhigh to high when creating the session', async () => {
-    mock.client.createSession = vi.fn().mockResolvedValue({ id: 'rs-1' });
-    mock.client.createInput = vi.fn().mockResolvedValue({ id: 'in-1' });
-    db.prepare('UPDATE sessions SET model_reasoning_effort = ? WHERE id = ?').run('xhigh', 's1');
-
-    const { session, turn } = seedTurn('t1');
-    await repoburgProvider.startTurn(session, turn);
-
-    expect(mock.client.createSession).toHaveBeenCalledWith({
-      model_id: 'ollama/glm-5.3:cloud',
-      reasoning_effort: 'high', // xhigh is invalid for Ollama `think`
-    });
-  });
-
-  it('startTurn pushes a patch when only the reasoning effort changes', async () => {
-    mock.client.createSession = vi.fn().mockResolvedValue({ id: 'rs-1' });
-    mock.client.createInput = vi.fn().mockResolvedValue({ id: 'in-1' });
-
-    // First turn — model ollama/a, effort medium.
-    db.prepare('UPDATE sessions SET model = ? WHERE id = ?').run('ollama/a', 's1');
-    const first = seedTurn('t1');
-    await repoburgProvider.startTurn(first.session, first.turn);
-    expect(mock.client.patchSession).not.toHaveBeenCalled();
-
-    // Same model, different effort — patch must still fire.
-    db.prepare('UPDATE sessions SET model_reasoning_effort = ? WHERE id = ?').run('high', 's1');
-    const secondSession = db.prepare('SELECT * FROM sessions WHERE id = ?').get('s1') as Session;
-    const second = seedTurn('t2');
-    await repoburgProvider.startTurn(secondSession, second.turn);
-
-    expect(mock.client.patchSession).toHaveBeenCalledWith('rs-1', {
-      model_id: 'ollama/a',
-      reasoning_effort: 'high',
-    });
-  });
-
-  it('startTurn re-pushes the clamped effort on resumed sessions (self-heal)', async () => {
-    // Pre-fix session: runtime session already exists (external_thread_id) with
-    // an unsafe xhigh effort — the first new turn must PATCH the clamped value.
-    mock.client.createInput = vi.fn().mockResolvedValue({ id: 'in-1' });
-    db.prepare(
-      'UPDATE sessions SET external_thread_id = ?, model_reasoning_effort = ? WHERE id = ?',
-    ).run('rs-1', 'xhigh', 's1');
-
-    const { session, turn } = seedTurn('t1');
-    await repoburgProvider.startTurn(session, turn);
-
-    expect(mock.client.patchSession).toHaveBeenCalledWith('rs-1', {
-      model_id: 'ollama/glm-5.3:cloud',
-      reasoning_effort: 'high',
-    });
-  });
-
-  it('startTurn pushes mid-session model changes to the runtime session', async () => {
-    mock.client.createSession = vi.fn().mockResolvedValue({ id: 'rs-1' });
-    mock.client.createInput = vi.fn().mockResolvedValue({ id: 'in-1' });
-
-    // First turn — session created, model recorded as 'ollama/a'.
-    db.prepare('UPDATE sessions SET model = ? WHERE id = ?').run('ollama/a', 's1');
-    const first = seedTurn('t1');
-    await repoburgProvider.startTurn(first.session, first.turn);
-    expect(mock.client.patchSession).not.toHaveBeenCalled();
-
-    // Model changed in agent-pane — second turn pushes the change.
-    db.prepare('UPDATE sessions SET model = ? WHERE id = ?').run('ollama/b', 's1');
-    const secondSession = db.prepare('SELECT * FROM sessions WHERE id = ?').get('s1') as Session;
-    const second = seedTurn('t2');
-    await repoburgProvider.startTurn(secondSession, second.turn);
-
-    expect(mock.client.patchSession).toHaveBeenCalledWith('rs-1', {
-      model_id: 'ollama/b',
-      reasoning_effort: 'medium',
-    });
-  });
-
-  it('full turn: live deltas, assistant, tool results, result → completed turn with usage and title', async () => {
-    mock.client.getSession = vi.fn().mockResolvedValue({
-      id: 'rs-1',
-      session_title: 'Auto Title',
-      is_running: false,
-    });
-
-    await startedTurn('t1');
-
-    // Live text delta (starts the agent_message item)…
-    deliver({ type: 'stream_event', sessionId: 'rs-1', inputId: 'in-1', delta: { type: 'text', text: 'Hello' } });
-    const started = captured.find((b) => b.event === 'item:started');
-    expect(started).toBeDefined();
-    expect((started!.data as { item: { type: string } }).item.type).toBe('agent_message');
-
-    // …then a delta…
-    deliver({ type: 'stream_event', sessionId: 'rs-1', inputId: 'in-1', delta: { type: 'text', text: ' world' } });
-    const delta = captured.find((b) => b.event === 'item:delta');
-    expect(delta).toBeDefined();
-    expect((delta!.data as { itemId: string; delta: string }).itemId).toBe('in-1-text');
-    expect((delta!.data as { itemId: string; delta: string }).delta).toBe(' world');
-
-    // …and a thinking delta (starts the reasoning item).
-    deliver({ type: 'stream_event', sessionId: 'rs-1', inputId: 'in-1', delta: { type: 'thinking', text: 'thinking about it' } });
-    expect(
-      captured
-        .filter((b) => b.event === 'item:started')
-        .some((b) => (b.data as { item: { type: string } }).item.type === 'reasoning'),
-    ).toBe(true);
-
-    // Round ends — assistant completes the streamed items.
-    deliver({
-      type: 'assistant',
-      sessionId: 'rs-1',
-      inputId: 'in-1',
-      content: [
-        { type: 'thinking', thinking: 'thinking about it' },
-        { type: 'text', text: 'Hello world' },
-      ],
-    });
-
-    // Executed actions become items (one tool_result each).
-    deliver({
-      type: 'user',
-      sessionId: 'rs-1',
-      inputId: 'in-1',
-      content: [
-        {
-          type: 'tool_result',
-          tool_use_id: 'a1',
-          content: 'created',
-          is_error: false,
-          action: {
-            id: 'a1',
-            action_type: 'create_file',
-            file_path: 'src/a.ts',
-            command_string: null,
-            status: 'CONFIRMED_KEPT',
-            server_name: null,
-            tool_name: null,
-            arguments: null,
-            plain: null,
-            selections: null,
-            order_of_execution: 0,
-          },
-        },
-        {
-          type: 'tool_result',
-          tool_use_id: 'a2',
-          content: 'a.ts',
-          is_error: false,
-          action: {
-            id: 'a2',
-            action_type: 'run_command',
-            file_path: null,
-            command_string: 'ls',
-            status: 'CONFIRMED_KEPT',
-            server_name: null,
-            tool_name: null,
-            arguments: null,
-            plain: null,
-            selections: null,
-            order_of_execution: 1,
-          },
-        },
-      ],
-    });
-    expect(
-      captured.some(
-        (b) => b.event === 'item:completed' && (b.data as { item: { type: string } }).item.type === 'file_change',
-      ),
-    ).toBe(true);
-
-    const items = db.prepare('SELECT type, status FROM items WHERE turn_id = ? ORDER BY rowid').all('t1') as Array<{
-      type: string;
-      status: string;
-    }>;
-    expect(items.map((i) => i.type)).toEqual([
-      'agent_message',
-      'reasoning',
-      'file_change',
-      'command_execution',
-    ]);
-    expect(items.every((i) => i.status === 'completed')).toBe(true);
-
-    // Terminal result — turn completes with result text + accumulated usage.
-    deliver({
-      type: 'result',
-      subtype: 'success',
-      sessionId: 'rs-1',
-      is_error: false,
-      result: 'Hello world',
-      usage: {
-        input_tokens: 100,
-        output_tokens: 20,
-        cache_read_input_tokens: 5,
-        cache_creation_input_tokens: 0,
-      },
-      num_rounds: 1,
-    });
-
-    const completedTurn = db.prepare(
-      'SELECT status, agent_response, token_usage FROM turns WHERE id = ?',
-    ).get('t1') as { status: string; agent_response: string | null; token_usage: string | null } | undefined;
-    expect(completedTurn?.status).toBe('completed');
-    expect(completedTurn?.agent_response).toBe('Hello world');
-    expect(JSON.parse(completedTurn!.token_usage!)).toMatchObject({
-      input_tokens: 100,
-      output_tokens: 20,
-      cached_input_tokens: 5,
-    });
-    expect(captured.find((b) => b.event === 'turn:completed')).toBeDefined();
-
-    // Title synced from the runtime session (async — fire-and-forget).
-    await vi.waitFor(() => {
-      const sess = db.prepare('SELECT title, has_unreviewed FROM sessions WHERE id = ?').get('s1') as
-        | { title: string | null; has_unreviewed: number }
-        | undefined;
-      expect(sess?.title).toBe('Auto Title');
-      expect(sess?.has_unreviewed).toBe(1);
-    });
-    expect(captured.find((b) => b.event === 'session:title')).toBeDefined();
-
-    // Stream ends — no reconnect after the terminal result.
-    streamCalls[0].resolve('result');
-    await new Promise((r) => setTimeout(r, 20));
-    expect(streamCalls.length).toBe(1);
-  });
-
-  it('result error_during_execution fails the turn and closes open items as failed', async () => {
-    await startedTurn('t1');
-
-    deliver({ type: 'stream_event', sessionId: 'rs-1', inputId: 'in-1', delta: { type: 'text', text: 'partial' } });
-    deliver({
-      type: 'result',
-      subtype: 'error_during_execution',
-      sessionId: 'rs-1',
-      is_error: true,
-      result: '',
-      num_rounds: 1,
-      errors: ['boom'],
-    });
-
-    const failedTurn = db.prepare('SELECT status, error FROM turns WHERE id = ?').get('t1') as
-      | { status: string; error: string | null }
-      | undefined;
-    expect(failedTurn?.status).toBe('failed');
-    expect(failedTurn?.error).toBe('boom');
-
-    // The in_progress streamed item is closed as failed.
-    const items = db.prepare('SELECT status FROM items WHERE turn_id = ?').all('t1') as Array<{
-      status: string;
-    }>;
-    expect(items.length).toBe(1);
-    expect(items[0].status).toBe('failed');
-
-    const failed = captured.find((b) => b.event === 'turn:failed');
-    expect(failed).toBeDefined();
-    expect((failed!.data as { error: string }).error).toBe('boom');
-  });
-
-  it('result aborted aborts the turn', async () => {
-    await startedTurn('t1');
-
-    deliver({
-      type: 'result',
-      subtype: 'aborted',
-      sessionId: 'rs-1',
-      is_error: true,
-      result: '',
-      num_rounds: 0,
-    });
-
-    expect(db.prepare('SELECT status FROM turns WHERE id = ?').get('t1')).toEqual({
-      status: 'aborted',
-    });
-    expect(captured.find((b) => b.event === 'turn:cancelled')).toBeDefined();
-  });
-
-  it('replayed messages after reconnect are projected idempotently (no duplicate items)', async () => {
-    await startedTurn('t1');
-
-    deliver({
-      type: 'assistant',
-      sessionId: 'rs-1',
-      inputId: 'in-1',
-      content: [{ type: 'text', text: 'Hello world' }],
-    });
-    deliver({
-      type: 'user',
-      sessionId: 'rs-1',
-      inputId: 'in-1',
-      content: [
-        {
-          type: 'tool_result',
-          tool_use_id: 'a1',
-          content: 'created',
-          is_error: false,
-          action: {
-            id: 'a1',
-            action_type: 'create_file',
-            file_path: 'src/a.ts',
-            command_string: null,
-            status: 'CONFIRMED_KEPT',
-            server_name: null,
-            tool_name: null,
-            arguments: null,
-            plain: null,
-            selections: null,
-            order_of_execution: 0,
-          },
-        },
-      ],
-    });
-
-    // Reconnect: the SAME messages replay on a second stream call.
-    streamCalls[0].resolve('aborted'); // stall-style disconnect
-    await vi.waitFor(() => expect(streamCalls.length).toBe(2));
-    deliver({
-      type: 'assistant',
-      sessionId: 'rs-1',
-      inputId: 'in-1',
-      content: [{ type: 'text', text: 'Hello world' }],
-    });
-    deliver({
-      type: 'user',
-      sessionId: 'rs-1',
-      inputId: 'in-1',
-      content: [
-        {
-          type: 'tool_result',
-          tool_use_id: 'a1',
-          content: 'created',
-          is_error: false,
-          action: {
-            id: 'a1',
-            action_type: 'create_file',
-            file_path: 'src/a.ts',
-            command_string: null,
-            status: 'CONFIRMED_KEPT',
-            server_name: null,
-            tool_name: null,
-            arguments: null,
-            plain: null,
-            selections: null,
-            order_of_execution: 0,
-          },
-        },
-      ],
-    });
-
-    const items = db.prepare('SELECT external_item_id FROM items WHERE turn_id = ?').all('t1') as Array<{
-      external_item_id: string;
-    }>;
-    expect(items.map((i) => i.external_item_id).sort()).toEqual(['in-1-action-a1', 'in-1-text']);
-
-    deliver({
-      type: 'result',
-      subtype: 'success',
-      sessionId: 'rs-1',
-      is_error: false,
-      result: 'done',
-      num_rounds: 1,
-    });
-    expect(db.prepare('SELECT status FROM turns WHERE id = ?').get('t1')).toEqual({
-      status: 'completed',
-    });
-  });
-
-  it('stream session-not-found fails the turn', async () => {
-    await startedTurn('t1');
-
-    streamCalls[0].resolve('session-not-found');
-    await vi.waitFor(() => {
-      const failedTurn = db.prepare('SELECT status, error FROM turns WHERE id = ?').get('t1') as
-        | { status: string; error: string | null }
-        | undefined;
-      expect(failedTurn?.status).toBe('failed');
-      expect(failedTurn?.error).toMatch(/no longer exists/);
-    });
-  });
-
-  it('interruptTurn cancels the runtime round and aborts the turn', async () => {
-    await startedTurn('t1');
-
-    const cancelled = await repoburgProvider.interruptTurn('s1');
-    expect(cancelled).toBe(true);
-    expect(mock.client.cancel).toHaveBeenCalledWith('rs-1');
-
-    expect(db.prepare('SELECT status FROM turns WHERE id = ?').get('t1')).toEqual({
-      status: 'aborted',
-    });
-    expect(captured.find((b) => b.event === 'turn:cancelled')).toBeDefined();
-
-    // Messages after cancellation are ignored — the turn stays aborted.
-    deliver({ type: 'result', subtype: 'success', sessionId: 'rs-1', is_error: false, result: 'late', num_rounds: 1 });
-    expect(db.prepare('SELECT status FROM turns WHERE id = ?').get('t1')).toEqual({
-      status: 'aborted',
-    });
-
-    // The interrupted stream signal is aborted (fetch closed).
-    expect(streamCalls[0]!.opts.signal!.aborted).toBe(true);
-    streamCalls[0]!.resolve('aborted');
-  });
-
-  it('interruptTurn returns false for unknown session', async () => {
-    expect(await repoburgProvider.interruptTurn('unknown')).toBe(false);
-  });
-
-  it('clearThread removes session state', async () => {
-    await startedTurn('t1');
-
-    repoburgProvider.clearThread('s1');
-    expect(await repoburgProvider.interruptTurn('s1')).toBe(false);
-  });
-
-  it('clearAllThreads and shutdown do not throw when empty', async () => {
-    expect(() => repoburgProvider.clearAllThreads()).not.toThrow();
-    await expect(repoburgProvider.shutdown()).resolves.not.toThrow();
-  });
-
-  it('streamAgentRuntimeMessages is imported once and used per turn', () => {
-    expect(streamAgentRuntimeMessages).toBeDefined();
-  });
-});