repoburg 1.3.196 → 1.3.198

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

@@ -1,5 +1,6 @@
 import type { FastifyInstance } from 'fastify';
 import type { ProviderDefinition } from '@agentpane/shared';
+import { hasProvider, getProvider } from '../providers/registry.ts';
 
 /** Codex provider definition — all capabilities enabled. */
 const CODEX_PROVIDER: ProviderDefinition = {
@@ -54,4 +55,14 @@ export async function registerProviderRoutes(fastify: FastifyInstance): Promise<
     }
     return provider;
   });
+
+  // GET /api/providers/:id/commands — provider-native slash commands (dynamic, e.g. Claude CLI)
+  fastify.get<{ Params: { id: string } }>('/api/providers/:id/commands', async (request, reply) => {
+    const id = request.params.id;
+    if (!hasProvider(id)) {
+      return reply.code(404).send({ error: 'Provider not found' });
+    }
+    const provider = getProvider(id);
+    return provider.getCommands ? await provider.getCommands() : [];
+  });
 }

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

@@ -243,16 +243,94 @@ describe('Session routes', () => {
       expect(res.json().has_unreviewed).toBe(1);
     });
 
-    it('clears thread when model changes and external_thread_id exists', async () => {
+    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).toHaveBeenCalledWith('s1');
-      const session = db.prepare('SELECT external_thread_id FROM sessions WHERE id = ?').get('s1') as {
+      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).toBeNull();
+      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 () => {
@@ -342,7 +420,7 @@ describe('Session routes', () => {
       expect(res.json().error).toBe('Turn not found');
     });
 
-    it('deletes turns after target and nulls external_thread_id', async () => {
+    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');
@@ -352,18 +430,74 @@ describe('Session routes', () => {
       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(1);
-      expect(turns[0].id).toBe('t1');
+      expect(turns).toHaveLength(3);
 
-      const session = db.prepare('SELECT external_thread_id FROM sessions WHERE id = ?').get('s1') as {
+      // 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.external_thread_id).toBeNull();
+      expect(session.rewound_at_turn_id).toBe('t1');
+      expect(session.pre_rewind_thread_id).toBe('thread-123');
       expect(mocks.clearThread).toHaveBeenCalledWith('s1');
     });
+
+    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 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', () => {

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

@@ -2,11 +2,12 @@ import type { FastifyInstance } from 'fastify';
 import { v4 as uuidv4 } from 'uuid';
 import { getDb } from '../db/index.ts';
 import { getProvider } from '../providers/registry.ts';
-import type { Session, SessionDetail, Turn, Item } from '../db/schema.ts';
+import type { Session, SessionDetail, Turn, Item, DiscussionThread, Attachment } from '../db/schema.ts';
 
-/** Raw DB row for turns — token_usage is a JSON string, not parsed; no items field. */
-interface TurnRow extends Omit<Turn, 'token_usage' | 'items'> {
+/** 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'> {
   token_usage: string | null;
+  attachments: string | null;
 }
 
 /** Raw DB row for items — data is a JSON string, not parsed. */
@@ -31,14 +32,26 @@ export async function registerSessionRoutes(fastify: FastifyInstance): Promise<v
       return reply.code(404).send({ error: 'Session not found' });
     }
 
-    const turnRows = db
-      .prepare('SELECT * FROM turns WHERE session_id = ? ORDER BY created_at ASC')
-      .all(id) as TurnRow[];
+    // If the session is rewound, only show turns up to and including the rewind point
+    const turnFilter = session.rewound_at_turn_id
+      ? db.prepare('SELECT created_at FROM turns WHERE id = ?').get(session.rewound_at_turn_id) as { created_at: string } | undefined
+      : null;
+
+    const turnRows = turnFilter
+      ? db
+          .prepare('SELECT * FROM turns WHERE session_id = ? AND created_at <= ? ORDER BY created_at ASC')
+          .all(id, turnFilter.created_at) as TurnRow[]
+      : db
+          .prepare('SELECT * FROM turns WHERE session_id = ? ORDER BY created_at ASC')
+          .all(id) as TurnRow[];
+
     const itemRows = db
       .prepare(
-        'SELECT * FROM items WHERE turn_id IN (SELECT id FROM turns WHERE session_id = ?) ORDER BY created_at ASC',
+        'SELECT * FROM items WHERE turn_id IN (SELECT id FROM turns WHERE session_id = ?' +
+          (turnFilter ? ' AND created_at <= ?' : '') +
+          ') ORDER BY created_at ASC',
       )
-      .all(id) as ItemRow[];
+      .all(...(turnFilter ? [id, turnFilter.created_at] : [id])) as ItemRow[];
 
     // Parse item data from JSON string and group by turn_id
     const itemsByTurn = new Map<string, Item[]>();
@@ -57,10 +70,23 @@ export async function registerSessionRoutes(fastify: FastifyInstance): Promise<v
       turns: turnRows.map((row) => ({
         ...row,
         token_usage: row.token_usage ? JSON.parse(row.token_usage) : null,
+        attachments: row.attachments ? (JSON.parse(row.attachments) as Attachment[]) : null,
         items: itemsByTurn.get(row.id) ?? [],
       })),
     };
 
+    // Fetch discussion threads for this session and attach to the response
+    const threadRows = db
+      .prepare('SELECT * FROM discussion_threads WHERE session_id = ? ORDER BY created_at ASC')
+      .all(id) as DiscussionThread[];
+
+    if (threadRows.length > 0) {
+      detail.threads = threadRows.map((tr) => ({
+        ...tr,
+        turns: detail.turns.filter((t) => t.thread_id === tr.id),
+      }));
+    }
+
     return detail;
   });
 
@@ -168,7 +194,7 @@ export async function registerSessionRoutes(fastify: FastifyInstance): Promise<v
     const updates: string[] = ['updated_at = ?'];
     const params: (string | number | null)[] = [now];
 
-    let modelChanged = false;
+    let providerChanged = false;
 
     if (title !== undefined) {
       updates.push('title = ?');
@@ -185,7 +211,7 @@ export async function registerSessionRoutes(fastify: FastifyInstance): Promise<v
 
     // Provider switch — clear model/reasoning if not explicitly provided
     if (runtime_type !== undefined && runtime_type !== existing.runtime_type) {
-      modelChanged = true; // old model is invalid for new provider
+      providerChanged = true; // different provider can't resume the old thread
       updates.push('runtime_type = ?');
       params.push(runtime_type);
 
@@ -201,15 +227,28 @@ export async function registerSessionRoutes(fastify: FastifyInstance): Promise<v
       }
     }
 
+    // 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.
+    // In streaming-input mode, also call query.setModel() on the live session
+    // so the CLI switches models without restarting.
     if (model !== undefined) {
       updates.push('model = ?');
       params.push(model);
-      if (model !== existing.model) modelChanged = true;
+      // If the provider supports mid-session model switching and the model
+      // actually changed (same provider), update the live query.
+      if (model !== existing.model && !providerChanged) {
+        const provider = getProvider(existing.runtime_type);
+        if (provider.setModel) {
+          provider.setModel(id, model ?? '').catch((err) => {
+            console.error(`[patch] setModel failed for session ${id}:`, err);
+          });
+        }
+      }
     }
     if (model_reasoning_effort !== undefined) {
       updates.push('model_reasoning_effort = ?');
       params.push(model_reasoning_effort);
-      if (model_reasoning_effort !== existing.model_reasoning_effort) modelChanged = true;
     }
     if (runtime_config !== undefined) {
       updates.push('runtime_config = ?');
@@ -218,9 +257,10 @@ export async function registerSessionRoutes(fastify: FastifyInstance): Promise<v
 
     db.prepare(`UPDATE sessions SET ${updates.join(', ')} WHERE id = ?`).run(...params, id);
 
-    // If provider or model changed, clear the cached thread and clean up old provider
-    if (modelChanged && existing.external_thread_id) {
-      db.prepare('UPDATE sessions SET external_thread_id = NULL, updated_at = ? WHERE id = ?').run(now, id);
+    // Only clear the thread when the PROVIDER changes (different provider can't resume).
+    // 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
       getProvider(existing.runtime_type).clearThread(id);
     }
@@ -229,7 +269,7 @@ export async function registerSessionRoutes(fastify: FastifyInstance): Promise<v
     return session;
   });
 
-  // POST /api/sessions/:id/rewind — delete turns after target turn, reset Codex thread
+  // POST /api/sessions/:id/rewind — non-destructive rewind: hide turns after target, fork provider session
   fastify.post<{ Params: { id: string }; Body: { turn_id: string } }>(
     '/api/sessions/:id/rewind',
     {
@@ -259,27 +299,80 @@ export async function registerSessionRoutes(fastify: FastifyInstance): Promise<v
         return reply.code(409).send({ error: 'Cannot rewind while a turn is running' });
       }
 
-      const targetTurn = db.prepare('SELECT created_at FROM turns WHERE id = ? AND session_id = ?').get(turn_id, id) as
-        { created_at: string } | undefined;
-      if (!targetTurn) {
+      const targetTurnFull = db.prepare('SELECT * FROM turns WHERE id = ? AND session_id = ?').get(turn_id, id) as
+        | Turn
+        | undefined;
+      if (!targetTurnFull) {
         return reply.code(404).send({ error: 'Turn not found' });
       }
 
-      // Delete turns after the target (cascade deletes items via FK)
-      db.prepare('DELETE FROM turns WHERE session_id = ? AND created_at > ?').run(id, targetTurn.created_at);
-
-      // Null out external_thread_id — next turn creates a fresh Codex thread
       const now = new Date().toISOString();
-      db.prepare('UPDATE sessions SET external_thread_id = NULL, updated_at = ? WHERE id = ?').run(now, id);
 
-      // Clear in-memory thread entry
-      getProvider(session.runtime_type).clearThread(id);
+      // Mark the session as rewound (non-destructive — turns are NOT deleted, just hidden)
+      // Save the original external_thread_id only on the first rewind (don't overwrite on subsequent rewinds)
+      // Use explicit two-step logic instead of COALESCE to avoid any evaluation-order ambiguity
+      if (!session.pre_rewind_thread_id && session.external_thread_id) {
+        db.prepare(
+          'UPDATE sessions SET rewound_at_turn_id = ?, pre_rewind_thread_id = ?, updated_at = ? WHERE id = ?',
+        ).run(turn_id, session.external_thread_id, now, id);
+        console.log(`[rewind] saved pre_rewind_thread_id=${session.external_thread_id} for session ${id}`);
+      } else {
+        db.prepare(
+          'UPDATE sessions SET rewound_at_turn_id = ?, updated_at = ? WHERE id = ?',
+        ).run(turn_id, now, id);
+        console.log(`[rewind] pre_rewind_thread_id already set (${session.pre_rewind_thread_id}) or external_thread_id is null for session ${id}`);
+      }
+
+      // 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);
+          if (forkedId) {
+            db.prepare('UPDATE sessions SET external_thread_id = ?, updated_at = ? WHERE id = ?')
+              .run(forkedId, now, id);
+            console.log(`[rewind] forked to ${forkedId} for session ${id}`);
+          } else {
+            console.warn(`[rewind] forkSession returned null for session ${id} (external_thread_id=${session.external_thread_id}, upToMessageId=${targetTurnFull.external_turn_id})`);
+          }
+        } catch (err) {
+          console.error(`[rewind] forkSession threw for session ${id}:`, err);
+        }
+      }
+
+      // Clear in-memory thread entry (the Claude session ID changed)
+      provider.clearThread(id);
 
       const updated = db.prepare('SELECT * FROM sessions WHERE id = ?').get(id) as Session;
       return updated;
     },
   );
 
+  // POST /api/sessions/:id/restore — undo rewind: show all turns again, restore original thread
+  fastify.post<{ Params: { id: string } }>('/api/sessions/:id/restore', async (request, reply) => {
+    const { id } = request.params;
+    const db = getDb();
+    const session = db.prepare('SELECT * FROM sessions WHERE id = ?').get(id) as Session | undefined;
+    if (!session) {
+      return reply.code(404).send({ error: 'Session not found' });
+    }
+    if (!session.rewound_at_turn_id) {
+      return reply.code(409).send({ error: 'Session is not rewound' });
+    }
+
+    const now = new Date().toISOString();
+    // Restore the original external_thread_id and clear rewind markers
+    db.prepare(
+      'UPDATE sessions SET rewound_at_turn_id = NULL, pre_rewind_thread_id = NULL, external_thread_id = COALESCE(pre_rewind_thread_id, external_thread_id), updated_at = ? WHERE id = ?',
+    ).run(now, id);
+
+    // Clear in-memory thread entry (the Claude session ID changed back)
+    getProvider(session.runtime_type).clearThread(id);
+
+    const updated = db.prepare('SELECT * FROM sessions WHERE id = ?').get(id) as Session;
+    return updated;
+  });
+
   // POST /api/sessions/:id/branch — create new session with turns up to and including target turn
   fastify.post<{ Params: { id: string }; Body: { turn_id: string; title?: string } }>(
     '/api/sessions/:id/branch',
@@ -342,8 +435,8 @@ export async function registerSessionRoutes(fastify: FastifyInstance): Promise<v
       for (const turn of turnRows) {
         const newTurnId = uuidv4();
         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 (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+          `INSERT INTO turns (id, session_id, user_prompt, agent_response, thoughts, token_usage, external_turn_id, status, error, attachments, created_at, updated_at)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
         ).run(
           newTurnId,
           newSessionId,
@@ -354,6 +447,7 @@ export async function registerSessionRoutes(fastify: FastifyInstance): Promise<v
           turn.external_turn_id,
           turn.status,
           turn.error,
+          turn.attachments,
           turn.created_at,
           turn.updated_at,
         );
@@ -380,6 +474,17 @@ export async function registerSessionRoutes(fastify: FastifyInstance): Promise<v
         }
       }
 
+      // Fork the provider-native session so the provider has conversation context
+      const provider = getProvider(session.runtime_type);
+      if (provider.forkSession) {
+        const targetTurnFull = db.prepare('SELECT * FROM turns WHERE id = ?').get(turn_id) as Turn;
+        const forkedId = await provider.forkSession(session, targetTurnFull);
+        if (forkedId) {
+          db.prepare('UPDATE sessions SET external_thread_id = ?, updated_at = ? WHERE id = ?')
+            .run(forkedId, now, newSessionId);
+        }
+      }
+
       const newSession = db.prepare('SELECT * FROM sessions WHERE id = ?').get(newSessionId) as Session;
       return newSession;
     },