repoburg 1.3.199 → 1.3.202

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

@@ -0,0 +1,780 @@
+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();
+  });
+});