repoburg 1.3.202 → 1.3.204

package/agent-pane/backend/src/routes/sessions.test.ts

@@ -1,772 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import Fastify, { type FastifyInstance } from 'fastify';
-import { initDb, getDb } from '../db/index.ts';
-import { registerSessionRoutes } from './sessions.ts';
-// Mock registry to avoid spawning real provider processes.
-// rewindRuntime stays OUT of the default provider (only repoburg has it);
-// tests that exercise the runtime-first path opt in via `useRewindRuntime()`.
-const mocks = vi.hoisted(() => ({
-  clearThread: vi.fn(),
-  rewindRuntime: vi.fn(),
-  forkSession: vi.fn(),
-  rewindRuntimeActive: false,
-}));
-
-vi.mock('../providers/registry.ts', () => ({
-  getProvider: vi.fn(() => ({
-    clearThread: mocks.clearThread,
-    ...(mocks.rewindRuntimeActive ? { rewindRuntime: mocks.rewindRuntime } : {}),
-    forkSession: mocks.forkSession,
-    startTurn: vi.fn(),
-    interruptTurn: vi.fn(),
-    clearAllThreads: vi.fn(),
-    getModels: vi.fn(),
-    shutdown: vi.fn(),
-  })),
-  hasProvider: vi.fn(() => true),
-}));
-
-const NOW = '2025-01-01T00:00:00Z';
-
-/** Insert a session row with sensible defaults. */
-function insertSession(db: ReturnType<typeof getDb>, id: string, overrides: Record<string, unknown> = {}): void {
-  db.prepare(
-    `INSERT INTO sessions (id, title, runtime_type, model, model_reasoning_effort, cwd, external_thread_id, status, is_running, lifecycle, has_unreviewed, created_at, updated_at, runtime_config)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-  ).run(
-    id,
-    (overrides['title'] as string | null) ?? null,
-    (overrides['runtime_type'] as string) ?? 'codex',
-    (overrides['model'] as string | null) ?? null,
-    (overrides['model_reasoning_effort'] as string | null) ?? null,
-    (overrides['cwd'] as string | null) ?? null,
-    (overrides['external_thread_id'] as string | null) ?? null,
-    (overrides['status'] as string) ?? 'active',
-    (overrides['is_running'] as number) ?? 0,
-    (overrides['lifecycle'] as string) ?? 'working',
-    (overrides['has_unreviewed'] as number) ?? 0,
-    (overrides['created_at'] as string) ?? NOW,
-    (overrides['updated_at'] as string) ?? NOW,
-    (overrides['runtime_config'] as string | null) ?? null,
-  );
-}
-
-/** Insert a turn row. */
-function insertTurn(db: ReturnType<typeof getDb>, id: string, sessionId: string, createdAt = NOW): void {
-  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(id, sessionId, 'hello', createdAt, createdAt);
-}
-
-/** Insert an item row. */
-function insertItem(db: ReturnType<typeof getDb>, id: string, turnId: string, type = 'agent_message'): void {
-  db.prepare(
-    `INSERT INTO items (id, turn_id, external_item_id, type, data, status, created_at, updated_at)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
-  ).run(id, turnId, `ext-${id}`, type, JSON.stringify({ text: 'test' }), 'completed', NOW, NOW);
-}
-
-describe('Session routes', () => {
-  let app: FastifyInstance;
-
-  beforeEach(async () => {
-    vi.clearAllMocks();
-    mocks.rewindRuntimeActive = false; // default provider has NO rewindRuntime
-    initDb(':memory:');
-    app = Fastify();
-    await registerSessionRoutes(app);
-  });
-
-  describe('GET /api/sessions', () => {
-    it('returns empty array when no sessions', async () => {
-      const res = await app.inject({ method: 'GET', url: '/api/sessions' });
-      expect(res.statusCode).toBe(200);
-      expect(res.json()).toEqual([]);
-    });
-
-    it('returns sessions ordered by created_at DESC', async () => {
-      const db = getDb();
-      insertSession(db, 's1', { created_at: '2025-01-01T00:00:00Z' });
-      insertSession(db, 's2', { created_at: '2025-01-02T00:00:00Z' });
-      const res = await app.inject({ method: 'GET', url: '/api/sessions' });
-      const sessions = res.json();
-      expect(sessions).toHaveLength(2);
-      expect(sessions[0].id).toBe('s2');
-      expect(sessions[1].id).toBe('s1');
-    });
-  });
-
-  describe('GET /api/sessions/:id', () => {
-    it('returns 404 for missing session', async () => {
-      const res = await app.inject({ method: 'GET', url: '/api/sessions/nonexistent' });
-      expect(res.statusCode).toBe(404);
-      expect(res.json()).toEqual({ error: 'Session not found' });
-    });
-
-    it('returns session with turns and items', async () => {
-      const db = getDb();
-      insertSession(db, 's1');
-      insertTurn(db, 't1', 's1');
-      insertItem(db, 'i1', 't1', 'agent_message');
-
-      const res = await app.inject({ method: 'GET', url: '/api/sessions/s1' });
-      expect(res.statusCode).toBe(200);
-      const detail = res.json();
-      expect(detail.id).toBe('s1');
-      expect(detail.turns).toHaveLength(1);
-      expect(detail.turns[0].id).toBe('t1');
-      expect(detail.turns[0].items).toHaveLength(1);
-      expect(detail.turns[0].items[0].id).toBe('i1');
-      expect(detail.turns[0].items[0].data).toEqual({ text: 'test' });
-    });
-  });
-
-  describe('POST /api/sessions', () => {
-    it('creates a session with defaults', async () => {
-      const res = await app.inject({ method: 'POST', url: '/api/sessions', payload: {} });
-      expect(res.statusCode).toBe(200);
-      const session = res.json();
-      expect(session.id).toBeDefined();
-      expect(session.runtime_type).toBe('codex');
-      expect(session.status).toBe('active');
-      expect(session.is_running).toBe(0);
-      expect(session.title).toBeNull();
-      expect(session.model).toBeNull();
-    });
-
-    it('creates a session with provided values', async () => {
-      const res = await app.inject({
-        method: 'POST',
-        url: '/api/sessions',
-        payload: {
-          title: 'Test',
-          runtime_type: 'claude',
-          model: 'gpt-4',
-          model_reasoning_effort: 'high',
-          cwd: '/home',
-        },
-      });
-      expect(res.statusCode).toBe(200);
-      const session = res.json();
-      expect(session.title).toBe('Test');
-      expect(session.runtime_type).toBe('claude');
-      expect(session.model).toBe('gpt-4');
-      expect(session.model_reasoning_effort).toBe('high');
-      expect(session.cwd).toBe('/home');
-    });
-
-    it('creates a session with runtime_config', async () => {
-      const config = JSON.stringify({ sandboxMode: 'read-only' });
-      const res = await app.inject({
-        method: 'POST',
-        url: '/api/sessions',
-        payload: { runtime_config: config },
-      });
-      expect(res.statusCode).toBe(200);
-      expect(res.json().runtime_config).toBe(config);
-    });
-  });
-
-  describe('PATCH /api/sessions/:id — runtime_config', () => {
-    it('updates runtime_config', async () => {
-      const db = getDb();
-      insertSession(db, 's1');
-      const config = JSON.stringify({ sandboxMode: 'read-only', webSearchMode: 'live' });
-      const res = await app.inject({
-        method: 'PATCH',
-        url: '/api/sessions/s1',
-        payload: { runtime_config: config },
-      });
-      expect(res.statusCode).toBe(200);
-      expect(res.json().runtime_config).toBe(config);
-    });
-
-    it('clears runtime_config with null', async () => {
-      const db = getDb();
-      insertSession(db, 's1', { runtime_config: JSON.stringify({ sandboxMode: 'read-only' }) });
-      const res = await app.inject({
-        method: 'PATCH',
-        url: '/api/sessions/s1',
-        payload: { runtime_config: null },
-      });
-      expect(res.statusCode).toBe(200);
-      expect(res.json().runtime_config).toBeNull();
-    });
-  });
-
-  describe('DELETE /api/sessions/:id', () => {
-    it('returns 404 for missing session', async () => {
-      const res = await app.inject({ method: 'DELETE', url: '/api/sessions/nonexistent' });
-      expect(res.statusCode).toBe(404);
-    });
-
-    it('deletes session and cascades to turns and items', async () => {
-      const db = getDb();
-      insertSession(db, 's1');
-      insertTurn(db, 't1', 's1');
-      insertItem(db, 'i1', 't1');
-
-      const res = await app.inject({ method: 'DELETE', url: '/api/sessions/s1' });
-      expect(res.statusCode).toBe(200);
-      expect(res.json()).toEqual({ success: true });
-
-      expect(db.prepare('SELECT * FROM sessions WHERE id = ?').get('s1')).toBeUndefined();
-      expect(db.prepare('SELECT * FROM turns WHERE session_id = ?').get('s1')).toBeUndefined();
-      expect(db.prepare('SELECT * FROM items WHERE turn_id = ?').get('t1')).toBeUndefined();
-    });
-  });
-
-  describe('PATCH /api/sessions/:id', () => {
-    it('returns 404 for missing session', async () => {
-      const res = await app.inject({
-        method: 'PATCH',
-        url: '/api/sessions/nonexistent',
-        payload: { title: 'New' },
-      });
-      expect(res.statusCode).toBe(404);
-    });
-
-    it('updates title', async () => {
-      const db = getDb();
-      insertSession(db, 's1');
-      const res = await app.inject({ method: 'PATCH', url: '/api/sessions/s1', payload: { title: 'Updated' } });
-      expect(res.statusCode).toBe(200);
-      expect(res.json().title).toBe('Updated');
-    });
-
-    it('updates lifecycle', async () => {
-      const db = getDb();
-      insertSession(db, 's1');
-      const res = await app.inject({ method: 'PATCH', url: '/api/sessions/s1', payload: { lifecycle: 'finished' } });
-      expect(res.statusCode).toBe(200);
-      expect(res.json().lifecycle).toBe('finished');
-    });
-
-    it('updates has_unreviewed', async () => {
-      const db = getDb();
-      insertSession(db, 's1');
-      const res = await app.inject({ method: 'PATCH', url: '/api/sessions/s1', payload: { has_unreviewed: 1 } });
-      expect(res.statusCode).toBe(200);
-      expect(res.json().has_unreviewed).toBe(1);
-    });
-
-    it('preserves thread when model changes (same provider)', async () => {
-      const db = getDb();
-      insertSession(db, 's1', { model: 'gpt-4', external_thread_id: 'thread-123' });
-      const res = await app.inject({ method: 'PATCH', url: '/api/sessions/s1', payload: { model: 'claude-3' } });
-      expect(res.statusCode).toBe(200);
-      expect(mocks.clearThread).not.toHaveBeenCalled();
-      const session = db.prepare('SELECT external_thread_id, model FROM sessions WHERE id = ?').get('s1') as {
-        external_thread_id: string | null;
-        model: string | null;
-      };
-      expect(session.external_thread_id).toBe('thread-123');
-      expect(session.model).toBe('claude-3');
-    });
-
-    it('preserves thread when reasoning effort changes (same provider)', async () => {
-      const db = getDb();
-      insertSession(db, 's1', { model: 'claude-sonnet-4', model_reasoning_effort: 'medium', external_thread_id: 'thread-123' });
-      const res = await app.inject({
-        method: 'PATCH',
-        url: '/api/sessions/s1',
-        payload: { model: 'claude-sonnet-4', model_reasoning_effort: 'high' },
-      });
-      expect(res.statusCode).toBe(200);
-      expect(mocks.clearThread).not.toHaveBeenCalled();
-      const session = db.prepare('SELECT external_thread_id, model_reasoning_effort FROM sessions WHERE id = ?').get('s1') as {
-        external_thread_id: string | null;
-        model_reasoning_effort: string | null;
-      };
-      expect(session.external_thread_id).toBe('thread-123');
-      expect(session.model_reasoning_effort).toBe('high');
-    });
-
-    it('preserves thread when setting model from null to a value', async () => {
-      const db = getDb();
-      insertSession(db, 's1', { model: null, external_thread_id: 'thread-123' });
-      const res = await app.inject({ method: 'PATCH', url: '/api/sessions/s1', payload: { model: 'claude-sonnet-4' } });
-      expect(res.statusCode).toBe(200);
-      expect(mocks.clearThread).not.toHaveBeenCalled();
-      const session = db.prepare('SELECT external_thread_id, model FROM sessions WHERE id = ?').get('s1') as {
-        external_thread_id: string | null;
-        model: string | null;
-      };
-      expect(session.external_thread_id).toBe('thread-123');
-      expect(session.model).toBe('claude-sonnet-4');
-    });
-
-    it('preserves thread and rewind state when model changes on rewound session', async () => {
-      const db = getDb();
-      insertSession(db, 's1', { model: 'claude-sonnet-4', external_thread_id: 'forked-123' });
-      // Simulate a rewound session
-      db.prepare('UPDATE sessions SET rewound_at_turn_id = ?, pre_rewind_thread_id = ? WHERE id = ?')
-        .run('turn-1', 'original-123', 's1');
-
-      const res = await app.inject({
-        method: 'PATCH',
-        url: '/api/sessions/s1',
-        payload: { model: 'claude-opus-4' },
-      });
-      expect(res.statusCode).toBe(200);
-      expect(mocks.clearThread).not.toHaveBeenCalled();
-      const session = db.prepare('SELECT external_thread_id, rewound_at_turn_id, pre_rewind_thread_id, model FROM sessions WHERE id = ?').get('s1') as {
-        external_thread_id: string | null;
-        rewound_at_turn_id: string | null;
-        pre_rewind_thread_id: string | null;
-        model: string | null;
-      };
-      expect(session.external_thread_id).toBe('forked-123');
-      expect(session.rewound_at_turn_id).toBe('turn-1');
-      expect(session.pre_rewind_thread_id).toBe('original-123');
-      expect(session.model).toBe('claude-opus-4');
-    });
-
-    it('preserves thread when model changes on finished session', async () => {
-      const db = getDb();
-      insertSession(db, 's1', { model: 'claude-sonnet-4', external_thread_id: 'thread-123', lifecycle: 'finished' });
-      const res = await app.inject({
-        method: 'PATCH',
-        url: '/api/sessions/s1',
-        payload: { model: 'claude-opus-4' },
-      });
-      expect(res.statusCode).toBe(200);
-      expect(mocks.clearThread).not.toHaveBeenCalled();
-      const session = db.prepare('SELECT external_thread_id, model FROM sessions WHERE id = ?').get('s1') as {
-        external_thread_id: string | null;
-        model: string | null;
-      };
-      expect(session.external_thread_id).toBe('thread-123');
-      expect(session.model).toBe('claude-opus-4');
-    });
-
-    it('does not clear thread when model is unchanged', async () => {
-      const db = getDb();
-      insertSession(db, 's1', { model: 'gpt-4', external_thread_id: 'thread-123' });
-      const res = await app.inject({ method: 'PATCH', url: '/api/sessions/s1', payload: { model: 'gpt-4' } });
-      expect(res.statusCode).toBe(200);
-      expect(mocks.clearThread).not.toHaveBeenCalled();
-    });
-
-    it('switches runtime_type and clears thread', async () => {
-      const db = getDb();
-      insertSession(db, 's1', { runtime_type: 'codex', model: 'gpt-5.6-sol', external_thread_id: 'thread-123' });
-      const res = await app.inject({
-        method: 'PATCH',
-        url: '/api/sessions/s1',
-        payload: { runtime_type: 'claude' },
-      });
-      expect(res.statusCode).toBe(200);
-      const session = res.json();
-      expect(session.runtime_type).toBe('claude');
-      expect(session.model).toBeNull();
-      expect(session.model_reasoning_effort).toBeNull();
-      expect(session.external_thread_id).toBeNull();
-      expect(mocks.clearThread).toHaveBeenCalledWith('s1');
-    });
-
-    it('switches runtime_type with explicit model', async () => {
-      const db = getDb();
-      insertSession(db, 's1', { runtime_type: 'codex', model: 'gpt-5.6-sol' });
-      const res = await app.inject({
-        method: 'PATCH',
-        url: '/api/sessions/s1',
-        payload: { runtime_type: 'claude', model: 'claude-sonnet-5', model_reasoning_effort: 'high' },
-      });
-      expect(res.statusCode).toBe(200);
-      const session = res.json();
-      expect(session.runtime_type).toBe('claude');
-      expect(session.model).toBe('claude-sonnet-5');
-      expect(session.model_reasoning_effort).toBe('high');
-    });
-
-    it('returns 409 when switching provider while running', async () => {
-      const db = getDb();
-      insertSession(db, 's1', { runtime_type: 'codex', is_running: 1 });
-      const res = await app.inject({
-        method: 'PATCH',
-        url: '/api/sessions/s1',
-        payload: { runtime_type: 'claude' },
-      });
-      expect(res.statusCode).toBe(409);
-      expect(res.json().error).toContain('Cannot switch provider');
-    });
-describe('PATCH /api/sessions/:id — cwd (workspace) change', () => {
-      it('clears the thread when cwd changes on a repoburg session', async () => {
-        const db = getDb();
-        insertSession(db, 's1', {
-          runtime_type: 'repoburg',
-          cwd: '/tmp/workspace-a',
-          external_thread_id: 'rs-1',
-        });
-        const res = await app.inject({
-          method: 'PATCH',
-          url: '/api/sessions/s1',
-          payload: { cwd: '/tmp/workspace-b' },
-        });
-        expect(res.statusCode).toBe(200);
-        const session = res.json();
-        expect(session.cwd).toBe('/tmp/workspace-b');
-        expect(session.external_thread_id).toBeNull();
-        expect(mocks.clearThread).toHaveBeenCalledWith('s1');
-      });
-
-      it('clears rewind markers along with the thread on a cwd change', async () => {
-        const db = getDb();
-        insertSession(db, 's1', { runtime_type: 'claude', cwd: '/tmp/a', external_thread_id: 'thread-1' });
-        db.prepare('UPDATE sessions SET rewound_at_turn_id = ?, pre_rewind_thread_id = ? WHERE id = ?')
-          .run('turn-1', 'orig-1', 's1');
-
-        const res = await app.inject({ method: 'PATCH', url: '/api/sessions/s1', payload: { cwd: '/tmp/b' } });
-        expect(res.statusCode).toBe(200);
-        const session = db.prepare(
-          'SELECT rewound_at_turn_id, pre_rewind_thread_id, external_thread_id FROM sessions WHERE id = ?',
-        ).get('s1') as {
-          rewound_at_turn_id: string | null;
-          pre_rewind_thread_id: string | null;
-          external_thread_id: string | null;
-        };
-        expect(session.rewound_at_turn_id).toBeNull();
-        expect(session.pre_rewind_thread_id).toBeNull();
-        expect(session.external_thread_id).toBeNull();
-      });
-
-      it('returns 409 when changing cwd while a turn is running', async () => {
-        const db = getDb();
-        insertSession(db, 's1', {
-          runtime_type: 'repoburg',
-          cwd: '/tmp/a',
-          external_thread_id: 'rs-1',
-          is_running: 1,
-        });
-        const res = await app.inject({ method: 'PATCH', url: '/api/sessions/s1', payload: { cwd: '/tmp/b' } });
-        expect(res.statusCode).toBe(409);
-        expect(res.json().error).toContain('Cannot change workspace');
-        expect(mocks.clearThread).not.toHaveBeenCalled();
-        const session = db.prepare('SELECT cwd, external_thread_id FROM sessions WHERE id = ?').get('s1') as {
-          cwd: string | null;
-          external_thread_id: string | null;
-        };
-        expect(session.cwd).toBe('/tmp/a');
-        expect(session.external_thread_id).toBe('rs-1');
-      });
-
-      it('keeps the thread when the cwd is resolve-equal (trailing slash)', async () => {
-        const db = getDb();
-        insertSession(db, 's1', {
-          runtime_type: 'repoburg',
-          cwd: '/tmp/workspace-a',
-          external_thread_id: 'rs-1',
-        });
-        const res = await app.inject({
-          method: 'PATCH',
-          url: '/api/sessions/s1',
-          payload: { cwd: '/tmp/workspace-a/' },
-        });
-        expect(res.statusCode).toBe(200);
-        expect(res.json().cwd).toBe('/tmp/workspace-a/');
-        expect(res.json().external_thread_id).toBe('rs-1');
-        expect(mocks.clearThread).not.toHaveBeenCalled();
-      });
-
-      it('clears the thread when cwd is cleared to null', async () => {
-        const db = getDb();
-        insertSession(db, 's1', { runtime_type: 'repoburg', cwd: '/tmp/a', external_thread_id: 'rs-1' });
-        const res = await app.inject({ method: 'PATCH', url: '/api/sessions/s1', payload: { cwd: null } });
-        expect(res.statusCode).toBe(200);
-        expect(res.json().cwd).toBeNull();
-        expect(res.json().external_thread_id).toBeNull();
-        expect(mocks.clearThread).toHaveBeenCalledWith('s1');
-      });
-    });
-  });
-
-  describe('POST /api/sessions/:id/rewind', () => {
-    it('returns 400 when turn_id is missing', async () => {
-      const res = await app.inject({ method: 'POST', url: '/api/sessions/s1/rewind', payload: {} });
-      expect(res.statusCode).toBe(400);
-    });
-
-    it('returns 404 for missing session', async () => {
-      const res = await app.inject({
-        method: 'POST',
-        url: '/api/sessions/nonexistent/rewind',
-        payload: { turn_id: 't1' },
-      });
-      expect(res.statusCode).toBe(404);
-    });
-
-    it('returns 409 when session is running', async () => {
-      const db = getDb();
-      insertSession(db, 's1', { is_running: 1 });
-      const res = await app.inject({ method: 'POST', url: '/api/sessions/s1/rewind', payload: { turn_id: 't1' } });
-      expect(res.statusCode).toBe(409);
-    });
-
-    it('returns 404 when turn is not found', async () => {
-      const db = getDb();
-      insertSession(db, 's1');
-      const res = await app.inject({
-        method: 'POST',
-        url: '/api/sessions/s1/rewind',
-        payload: { turn_id: 'nonexistent' },
-      });
-      expect(res.statusCode).toBe(404);
-      expect(res.json().error).toBe('Turn not found');
-    });
-
-    it('marks session as rewound (non-destructive) and saves pre_rewind_thread_id', async () => {
-      const db = getDb();
-      insertSession(db, 's1', { external_thread_id: 'thread-123' });
-      insertTurn(db, 't1', 's1', '2025-01-01T00:00:00Z');
-      insertTurn(db, 't2', 's1', '2025-01-01T01:00:00Z');
-      insertTurn(db, 't3', 's1', '2025-01-01T02:00:00Z');
-
-      const res = await app.inject({ method: 'POST', url: '/api/sessions/s1/rewind', payload: { turn_id: 't1' } });
-      expect(res.statusCode).toBe(200);
-
-      // Turns are NOT deleted — all 3 still exist
-      const turns = db.prepare('SELECT id FROM turns WHERE session_id = ? ORDER BY created_at').all('s1') as {
-        id: string;
-      }[];
-      expect(turns).toHaveLength(3);
-
-      // Session is marked as rewound
-      const session = db.prepare('SELECT rewound_at_turn_id, pre_rewind_thread_id, external_thread_id FROM sessions WHERE id = ?').get('s1') as {
-        rewound_at_turn_id: string | null;
-        pre_rewind_thread_id: string | null;
-        external_thread_id: string | null;
-      };
-      expect(session.rewound_at_turn_id).toBe('t1');
-      expect(session.pre_rewind_thread_id).toBe('thread-123');
-      expect(mocks.clearThread).toHaveBeenCalledWith('s1');
-    });
-it('calls provider.rewindRuntime (runtime-first), hard-deletes local turns after anchor, leaves NO rewind marker', async () => {
-      const db = getDb();
-      mocks.rewindRuntimeActive = true; // repoburg provider
-      insertSession(db, 's1', { runtime_type: 'repoburg', external_thread_id: 'rs-1' });
-      insertTurn(db, 't1', 's1', '2025-01-01T00:00:00Z');
-      insertTurn(db, 't2', 's1', '2025-01-01T01:00:00Z');
-      db.prepare('UPDATE turns SET runtime_input_ids = ? WHERE id = ?').run(
-        JSON.stringify(['in-1', 'in-2']),
-        't1',
-      );
-      mocks.rewindRuntime.mockResolvedValueOnce(undefined);
-
-      const res = await app.inject({ method: 'POST', url: '/api/sessions/s1/rewind', payload: { turn_id: 't1' } });
-      expect(res.statusCode).toBe(200);
-      expect(mocks.rewindRuntime).toHaveBeenCalledTimes(1);
-      const [sessionArg, turnArg] = mocks.rewindRuntime.mock.calls[0];
-      expect(sessionArg.external_thread_id).toBe('rs-1');
-      expect(turnArg.id).toBe('t1');
-
-      // Local turns after the anchor are hard-deleted (platform parity).
-      const turns = db.prepare('SELECT id FROM turns WHERE session_id = ? ORDER BY created_at').all('s1') as { id: string }[];
-      expect(turns).toHaveLength(1);
-      expect(turns[0].id).toBe('t1');
-
-      // NO rewind marker — nothing is hidden or restorable for repoburg.
-      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).toBeNull();
-      expect(session.pre_rewind_thread_id).toBeNull();
-      expect(mocks.clearThread).not.toHaveBeenCalled();
-    });
-
-    it('repoburg rewind: turns created AFTER the rewind stay visible in GET /:id (regression)', async () => {
-      const db = getDb();
-      mocks.rewindRuntimeActive = true; // repoburg provider
-      insertSession(db, 's1', { runtime_type: 'repoburg', external_thread_id: 'rs-1' });
-      insertTurn(db, 't1', 's1', '2025-01-01T00:00:00Z');
-      insertTurn(db, 't2', 's1', '2025-01-01T01:00:00Z');
-      mocks.rewindRuntime.mockResolvedValue(undefined);
-
-      const res = await app.inject({ method: 'POST', url: '/api/sessions/s1/rewind', payload: { turn_id: 't1' } });
-      expect(res.statusCode).toBe(200);
-
-      // A NEW turn created after the rewind must appear in the session view —
-      // a leftover rewound_at_turn_id marker would filter it out.
-      insertTurn(db, 't3', 's1', '2025-01-02T00:00:00Z');
-
-      const view = await app.inject({ method: 'GET', url: '/api/sessions/s1' });
-      expect(view.statusCode).toBe(200);
-      const turnIds = (view.json().turns as { id: string }[]).map((t) => t.id);
-      expect(turnIds).toEqual(['t1', 't3']);
-    });
-
-    it('rewindRuntime failure → NO local rewind (error passes through)', async () => {
-      const db = getDb();
-      mocks.rewindRuntimeActive = true; // repoburg provider
-      insertSession(db, 's1', { runtime_type: 'repoburg', external_thread_id: 'rs-1' });
-      insertTurn(db, 't1', 's1', '2025-01-01T00:00:00Z');
-      db.prepare('UPDATE turns SET runtime_input_ids = ? WHERE id = ?').run(
-        JSON.stringify(['in-1']),
-        't1',
-      );
-      mocks.rewindRuntime.mockRejectedValueOnce(
-        new Error('DELETE /sessions/rs-1/inputs/in-1/until-here failed: 400 {"message":"Summaries can only be discarded, not deleted."}'),
-      );
-
-      const res = await app.inject({ method: 'POST', url: '/api/sessions/s1/rewind', payload: { turn_id: 't1' } });
-      expect(res.statusCode).toBe(500);
-      expect(res.json().message).toContain('Summaries can only be discarded');
-
-      // Local view untouched — no rewind markers, no clearThread
-      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).toBeNull();
-      expect(session.pre_rewind_thread_id).toBeNull();
-      expect(mocks.clearThread).not.toHaveBeenCalled();
-    });
-
-    it('rewindRuntime NOT called when the provider does not implement it (codex)', async () => {
-      const db = getDb();
-      insertSession(db, 's1', { external_thread_id: 'thread-123' });
-      insertTurn(db, 't1', 's1', '2025-01-01T00:00:00Z');
-      const { getProvider } = await import('../providers/registry.ts');
-      vi.mocked(getProvider).mockReturnValueOnce({ clearThread: mocks.clearThread } as never);
-
-      const res = await app.inject({ method: 'POST', url: '/api/sessions/s1/rewind', payload: { turn_id: 't1' } });
-      expect(res.statusCode).toBe(200);
-      expect(mocks.rewindRuntime).not.toHaveBeenCalled();
-
-      const session = db.prepare('SELECT rewound_at_turn_id FROM sessions WHERE id = ?').get('s1') as {
-        rewound_at_turn_id: string | null;
-      };
-      expect(session.rewound_at_turn_id).toBe('t1');
-    });
-
-    it('GET session filters turns when rewound', async () => {
-      const db = getDb();
-      insertSession(db, 's1');
-      insertTurn(db, 't1', 's1', '2025-01-01T00:00:00Z');
-      insertTurn(db, 't2', 's1', '2025-01-01T01:00:00Z');
-      insertTurn(db, 't3', 's1', '2025-01-01T02:00:00Z');
-
-      // Rewind to t2
-      await app.inject({ method: 'POST', url: '/api/sessions/s1/rewind', payload: { turn_id: 't2' } });
-
-      // GET should only show t1 and t2 (not t3)
-      const res = await app.inject({ method: 'GET', url: '/api/sessions/s1' });
-      expect(res.statusCode).toBe(200);
-      expect(res.json().turns).toHaveLength(2);
-      expect(res.json().turns[0].id).toBe('t1');
-      expect(res.json().turns[1].id).toBe('t2');
-    });
-
-    it('restore undoes rewind and shows all turns', async () => {
-      const db = getDb();
-      insertSession(db, 's1', { external_thread_id: 'thread-123' });
-      insertTurn(db, 't1', 's1', '2025-01-01T00:00:00Z');
-      insertTurn(db, 't2', 's1', '2025-01-01T01:00:00Z');
-
-      // Rewind
-      await app.inject({ method: 'POST', url: '/api/sessions/s1/rewind', payload: { turn_id: 't1' } });
-
-      // Restore
-      const res = await app.inject({ method: 'POST', url: '/api/sessions/s1/restore' });
-      expect(res.statusCode).toBe(200);
-
-      const session = db.prepare('SELECT rewound_at_turn_id, pre_rewind_thread_id, external_thread_id FROM sessions WHERE id = ?').get('s1') as {
-        rewound_at_turn_id: string | null;
-        pre_rewind_thread_id: string | null;
-        external_thread_id: string | null;
-      };
-      expect(session.rewound_at_turn_id).toBeNull();
-      expect(session.pre_rewind_thread_id).toBeNull();
-      expect(session.external_thread_id).toBe('thread-123');
-
-      // GET shows all turns again
-      const getRes = await app.inject({ method: 'GET', url: '/api/sessions/s1' });
-      expect(getRes.json().turns).toHaveLength(2);
-    });
-it('restore returns 409 for repoburg sessions (runtime history permanently deleted)', async () => {
-      // Simulate a LEGACY rewound repoburg session (marker set by a
-      // pre-hard-delete rewind) — restore must still be refused.
-      const db = getDb();
-      insertSession(db, 's1', { runtime_type: 'repoburg', external_thread_id: 'rs-1' });
-      insertTurn(db, 't1', 's1', '2025-01-01T00:00:00Z');
-      db.prepare(
-        'UPDATE sessions SET rewound_at_turn_id = ?, pre_rewind_thread_id = ? WHERE id = ?',
-      ).run('t1', 'rs-1', 's1');
-
-      const res = await app.inject({ method: 'POST', url: '/api/sessions/s1/restore' });
-      expect(res.statusCode).toBe(409);
-      expect(res.json().error).toContain('permanently deleted');
-
-      // Rewind state stays intact
-      const session = db.prepare('SELECT rewound_at_turn_id FROM sessions WHERE id = ?').get('s1') as {
-        rewound_at_turn_id: string | null;
-      };
-      expect(session.rewound_at_turn_id).toBe('t1');
-    });
-
-    it('restore returns 409 when not rewound', async () => {
-      const db = getDb();
-      insertSession(db, 's1');
-      const res = await app.inject({ method: 'POST', url: '/api/sessions/s1/restore' });
-      expect(res.statusCode).toBe(409);
-    });
-  });
-
-  describe('POST /api/sessions/:id/branch', () => {
-    it('returns 400 when turn_id is missing', async () => {
-      const res = await app.inject({ method: 'POST', url: '/api/sessions/s1/branch', payload: {} });
-      expect(res.statusCode).toBe(400);
-    });
-
-    it('returns 404 for missing session', async () => {
-      const res = await app.inject({
-        method: 'POST',
-        url: '/api/sessions/nonexistent/branch',
-        payload: { turn_id: 't1' },
-      });
-      expect(res.statusCode).toBe(404);
-    });
-
-    it('returns 404 when turn is not found', async () => {
-      const db = getDb();
-      insertSession(db, 's1');
-      const res = await app.inject({
-        method: 'POST',
-        url: '/api/sessions/s1/branch',
-        payload: { turn_id: 'nonexistent' },
-      });
-      expect(res.statusCode).toBe(404);
-      expect(res.json().error).toBe('Turn not found');
-    });
-
-    it('creates new session with copied turns up to target', async () => {
-      const db = getDb();
-      insertSession(db, 's1', { title: 'Original', model: 'gpt-4' });
-      insertTurn(db, 't1', 's1', '2025-01-01T00:00:00Z');
-      insertTurn(db, 't2', 's1', '2025-01-01T01:00:00Z');
-      insertItem(db, 'i1', 't1');
-
-      const res = await 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();
-
-      // Only t1 copied (not t2)
-      const newTurns = db
-        .prepare('SELECT * FROM turns WHERE session_id = ? ORDER BY created_at')
-        .all(newSession.id) as { id: string; user_prompt: string }[];
-      expect(newTurns).toHaveLength(1);
-      expect(newTurns[0].user_prompt).toBe('hello');
-
-      // Item copied
-      const newItems = db.prepare('SELECT * FROM items WHERE turn_id = ?').all(newTurns[0].id) as { type: string }[];
-      expect(newItems).toHaveLength(1);
-      expect(newItems[0].type).toBe('agent_message');
-    });
-  });
-});