repoburg 1.3.199 → 1.3.202

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

@@ -2,14 +2,21 @@ 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
+// 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(),
@@ -65,6 +72,7 @@ describe('Session routes', () => {
 
   beforeEach(async () => {
     vi.clearAllMocks();
+    mocks.rewindRuntimeActive = false; // default provider has NO rewindRuntime
     initDb(':memory:');
     app = Fastify();
     await registerSessionRoutes(app);
@@ -384,6 +392,94 @@ describe('Session routes', () => {
       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', () => {
@@ -446,6 +542,104 @@ describe('Session routes', () => {
       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();
@@ -491,6 +685,26 @@ describe('Session routes', () => {
       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();

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

@@ -1,13 +1,16 @@
 import type { FastifyInstance } from 'fastify';
+import path from 'node:path';
 import { v4 as uuidv4 } from 'uuid';
 import { getDb } from '../db/index.ts';
 import { getProvider } from '../providers/registry.ts';
 import type { Session, SessionDetail, Turn, Item, DiscussionThread, Attachment } from '../db/schema.ts';
 
-/** Raw DB row for turns — token_usage and attachments are JSON strings, not parsed; no items field. */
-interface TurnRow extends Omit<Turn, 'token_usage' | 'items' | 'attachments'> {
+/** Raw DB row for turns — token_usage, attachments and runtime_input_ids are
+ *  JSON strings, not parsed; no items field. */
+interface TurnRow extends Omit<Turn, 'token_usage' | 'items' | 'attachments' | 'runtime_input_ids'> {
   token_usage: string | null;
   attachments: string | null;
+  runtime_input_ids: string | null;
 }
 
 /** Raw DB row for items — data is a JSON string, not parsed. */
@@ -71,6 +74,7 @@ export async function registerSessionRoutes(fastify: FastifyInstance): Promise<v
         ...row,
         token_usage: row.token_usage ? JSON.parse(row.token_usage) : null,
         attachments: row.attachments ? (JSON.parse(row.attachments) as Attachment[]) : null,
+        runtime_input_ids: row.runtime_input_ids ? (JSON.parse(row.runtime_input_ids) as string[]) : null,
         items: itemsByTurn.get(row.id) ?? [],
       })),
     };
@@ -87,6 +91,18 @@ export async function registerSessionRoutes(fastify: FastifyInstance): Promise<v
       }));
     }
 
+    // Restore persisted context-window usage so the status-bar counter survives reload.
+    const cuRow = db.prepare('SELECT context_usage FROM sessions WHERE id = ?').get(id) as
+      | { context_usage: string | null }
+      | undefined;
+    if (cuRow?.context_usage) {
+      try {
+        detail.contextUsage = JSON.parse(cuRow.context_usage) as SessionDetail['contextUsage'];
+      } catch {
+        // Corrupt JSON — leave contextUsage unset.
+      }
+    }
+
     return detail;
   });
 
@@ -148,7 +164,7 @@ export async function registerSessionRoutes(fastify: FastifyInstance): Promise<v
     return { success: true };
   });
 
-  // PATCH /api/sessions/:id — update session (title, lifecycle, has_unreviewed, model, model_reasoning_effort, runtime_config)
+  // PATCH /api/sessions/:id — update session (title, lifecycle, has_unreviewed, model, model_reasoning_effort, runtime_config, cwd)
   fastify.patch<{
     Params: { id: string };
     Body: {
@@ -159,6 +175,7 @@ export async function registerSessionRoutes(fastify: FastifyInstance): Promise<v
       model_reasoning_effort?: string | null;
       runtime_config?: string | null;
       runtime_type?: string;
+      cwd?: string | null;
     };
   }>('/api/sessions/:id', {
     schema: {
@@ -172,12 +189,13 @@ export async function registerSessionRoutes(fastify: FastifyInstance): Promise<v
           model_reasoning_effort: { type: ['string', 'null'] },
           runtime_config: { type: ['string', 'null'] },
           runtime_type: { type: 'string' },
+          cwd: { type: ['string', 'null'] },
         },
       },
     },
   }, async (request, reply) => {
     const { id } = request.params;
-    const { title, lifecycle, has_unreviewed, model, model_reasoning_effort, runtime_config, runtime_type } = request.body || {};
+    const { title, lifecycle, has_unreviewed, model, model_reasoning_effort, runtime_config, runtime_type, cwd } = request.body || {};
     const db = getDb();
 
     const existing = db.prepare('SELECT * FROM sessions WHERE id = ?').get(id) as Session | undefined;
@@ -227,6 +245,23 @@ export async function registerSessionRoutes(fastify: FastifyInstance): Promise<v
       }
     }
 
+    // Workspace (cwd) change — the runtime thread belongs to the old
+    // workspace backend, so it is cleared like a provider switch; the next
+    // turn creates a fresh runtime session on the new workspace.
+    // Compare resolve-normalized paths — cosmetic differences (trailing
+    // slash) are not a workspace change.
+    let workspaceChanged = false;
+    if (cwd !== undefined) {
+      const oldAbs = existing.cwd ? path.resolve(existing.cwd) : null;
+      const newAbs = cwd ? path.resolve(cwd) : null;
+      workspaceChanged = oldAbs !== newAbs;
+      if (workspaceChanged && existing.is_running) {
+        return reply.code(409).send({ error: 'Cannot change workspace while a turn is running' });
+      }
+      updates.push('cwd = ?');
+      params.push(cwd);
+    }
+
     // Model and reasoning changes update DB columns but do NOT clear the thread.
     // The Claude SDK supports query({ resume: sessionId, model: newModel }) —
     // changing the model within the same provider preserves conversation context.
@@ -257,11 +292,14 @@ export async function registerSessionRoutes(fastify: FastifyInstance): Promise<v
 
     db.prepare(`UPDATE sessions SET ${updates.join(', ')} WHERE id = ?`).run(...params, id);
 
-    // Only clear the thread when the PROVIDER changes (different provider can't resume).
+    // Clear the thread when the PROVIDER or WORKSPACE changes — the runtime
+    // session belongs to the old provider/backend and cannot be resumed.
     // Model/reasoning changes within the same provider keep the thread intact.
-    if (providerChanged && existing.external_thread_id) {
-      db.prepare('UPDATE sessions SET external_thread_id = NULL, rewound_at_turn_id = NULL, pre_rewind_thread_id = NULL, updated_at = ? WHERE id = ?').run(now, id);
-      // Use old provider to clear its in-memory thread state
+    if (providerChanged || workspaceChanged) {
+      if (existing.external_thread_id) {
+        db.prepare('UPDATE sessions SET external_thread_id = NULL, rewound_at_turn_id = NULL, pre_rewind_thread_id = NULL, updated_at = ? WHERE id = ?').run(now, id);
+      }
+      // Drop the in-memory entry even without a persisted thread id (stale state).
       getProvider(existing.runtime_type).clearThread(id);
     }
 
@@ -306,6 +344,35 @@ export async function registerSessionRoutes(fastify: FastifyInstance): Promise<v
         return reply.code(404).send({ error: 'Turn not found' });
       }
 
+      const provider = getProvider(session.runtime_type);
+
+      // RUNTIME-FIRST (repoburg in-place truncation): hard-delete the runtime
+      // history after the target turn BEFORE any local change. Errors pass
+      // through — on failure the local view stays untouched and consistent
+      // with the runtime (e.g. 400 summary-in-range from until-here).
+      if (provider.rewindRuntime) {
+        await provider.rewindRuntime(session, targetTurnFull);
+
+        // Platform-parity HARD DELETE: the runtime history after the anchor
+        // is permanently gone, so mirror it locally — delete the local turns
+        // after the target and leave NO rewind marker (nothing to restore).
+        // Stale markers are cleared too: a marker would hide every turn
+        // created after the rewind (GET /:id filters by rewound_at_turn_id).
+        const now2 = new Date().toISOString();
+        db.prepare(
+          'DELETE FROM items WHERE turn_id IN (SELECT id FROM turns WHERE session_id = ? AND created_at > ?)',
+        ).run(id, targetTurnFull.created_at);
+        db.prepare('DELETE FROM turns WHERE session_id = ? AND created_at > ?').run(
+          id,
+          targetTurnFull.created_at,
+        );
+        db.prepare(
+          'UPDATE sessions SET rewound_at_turn_id = NULL, pre_rewind_thread_id = NULL, updated_at = ? WHERE id = ?',
+        ).run(now2, id);
+        const truncated = db.prepare('SELECT * FROM sessions WHERE id = ?').get(id) as Session;
+        return truncated;
+      }
+
       const now = new Date().toISOString();
 
       // Mark the session as rewound (non-destructive — turns are NOT deleted, just hidden)
@@ -324,7 +391,6 @@ export async function registerSessionRoutes(fastify: FastifyInstance): Promise<v
       }
 
       // Fork the provider-native session so the provider has conversation context up to the target turn
-      const provider = getProvider(session.runtime_type);
       if (provider.forkSession) {
         try {
           const forkedId = await provider.forkSession(session, targetTurnFull);
@@ -359,6 +425,13 @@ export async function registerSessionRoutes(fastify: FastifyInstance): Promise<v
     if (!session.rewound_at_turn_id) {
       return reply.code(409).send({ error: 'Session is not rewound' });
     }
+    // Repoburg rewind = platform-parity HARD DELETE — the runtime history was
+    // permanently truncated, so local turns can never be restored.
+    if (session.runtime_type === 'repoburg') {
+      return reply.code(409).send({
+        error: 'Restore is not available for repoburg sessions — the rewind permanently deleted the runtime history.',
+      });
+    }
 
     const now = new Date().toISOString();
     // Restore the original external_thread_id and clear rewind markers

package/agent-pane/backend/src/routes/threads.ts

@@ -72,16 +72,31 @@ export async function registerThreadRoutes(fastify: FastifyInstance): Promise<vo
       const provider = getProvider(session.runtime_type);
       if (provider.forkSession) {
         try {
-          const anchorTurn = db.prepare('SELECT * FROM turns WHERE id = ?').get(turnId) as Turn | undefined;
-          if (anchorTurn) {
-            const forkedSessionId = await provider.forkSession(session, anchorTurn);
-            if (forkedSessionId) {
-              db.prepare('UPDATE discussion_threads SET external_thread_id = ? WHERE id = ?').run(forkedSessionId, threadId);
+          if (!session.external_thread_id) {
+            // No main session to fork from — the thread will start a fresh
+            // isolated session (startTurn skips the resume fallback), so the
+            // main session is never contaminated.
+            console.warn(`[threads] cannot fork for thread ${threadId}: session ${sessionId} has no external_thread_id — thread will start a fresh isolated session`);
+          } else {
+            const anchorTurn = db.prepare('SELECT * FROM turns WHERE id = ?').get(turnId) as Turn | undefined;
+            if (anchorTurn) {
+              const forkedSessionId = await provider.forkSession(session, anchorTurn);
+              if (forkedSessionId) {
+                db.prepare('UPDATE discussion_threads SET external_thread_id = ? WHERE id = ?').run(forkedSessionId, threadId);
+                console.log(`[threads] forked to ${forkedSessionId} for thread ${threadId} (session ${sessionId})`);
+              } else {
+                // forkSession returned null — thread will start a fresh isolated
+                // session in startTurn (NOT the main session), so isolation holds.
+                console.warn(`[threads] forkSession returned null for thread ${threadId} (external_thread_id=${session.external_thread_id}, upToMessageId=${anchorTurn.external_turn_id}) — thread will start a fresh isolated session`);
+              }
+            } else {
+              console.warn(`[threads] anchor turn ${turnId} not found for thread ${threadId} — cannot fork`);
             }
           }
         } catch (err) {
           console.error(`[threads] forkSession failed for thread ${threadId}:`, err);
-          // Non-fatal — thread falls back to main session conversation
+          // Non-fatal — thread falls back to a fresh isolated session (NOT the
+          // main session) so the main conversation is never contaminated.
         }
       }
 

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

@@ -54,7 +54,9 @@ describe('Turn routes', () => {
   beforeEach(async () => {
     vi.clearAllMocks();
     initDb(':memory:');
-    app = Fastify();
+    // Mirror the production Fastify config (index.ts) — bodyLimit must exceed the
+    // default 1 MiB so base64 image attachments fit in the JSON body.
+    app = Fastify({ bodyLimit: 50 * 1024 * 1024 });
     await registerTurnRoutes(app);
   });
 
@@ -122,6 +124,48 @@ describe('Turn routes', () => {
       expect(sessionArg.id).toBe('s1');
       expect(turnArg.user_prompt).toBe('hello');
     });
+
+    it('accepts a large base64 image attachment (>1 MiB) — regression for 413 Payload Too Large', async () => {
+      const db = getDb();
+      insertSession(db, 's1');
+      // ~2 MB of base64 — exceeds Fastify's default 1 MiB bodyLimit; the production
+      // server (index.ts) raises it to 50 MB so image attachments fit.
+      const bigBase64 = 'A'.repeat(2 * 1024 * 1024);
+      const res = await app.inject({
+        method: 'POST',
+        url: '/api/sessions/s1/turns',
+        payload: {
+          user_prompt: 'look at this',
+          attachments: [{ name: 'shot.png', media_type: 'image/png', data: bigBase64 }],
+        },
+      });
+      expect(res.statusCode).toBe(200);
+      const turn = res.json();
+      expect(turn.attachments).toEqual([{ name: 'shot.png', media_type: 'image/png', data: bigBase64 }]);
+      const [, turnArg] = mocks.startTurn.mock.calls[0];
+      // startTurn receives the raw DB row — attachments is still a JSON string there.
+      expect(typeof turnArg.attachments).toBe('string');
+      expect(JSON.parse(turnArg.attachments)).toEqual([{ name: 'shot.png', media_type: 'image/png', data: bigBase64 }]);
+    });
+
+    it('returns 413 on the default 1 MiB bodyLimit — documents why index.ts raises it', async () => {
+      const db = getDb();
+      insertSession(db, 's1');
+      const defaultApp = Fastify(); // default bodyLimit = 1 MiB
+      await registerTurnRoutes(defaultApp);
+      const bigBase64 = 'A'.repeat(2 * 1024 * 1024);
+      const res = await defaultApp.inject({
+        method: 'POST',
+        url: '/api/sessions/s1/turns',
+        payload: {
+          user_prompt: 'look at this',
+          attachments: [{ name: 'shot.png', media_type: 'image/png', data: bigBase64 }],
+        },
+      });
+      expect(res.statusCode).toBe(413);
+      expect(mocks.startTurn).not.toHaveBeenCalled();
+      await defaultApp.close();
+    });
   });
 
   describe('POST /api/sessions/:id/cancel', () => {