repoburg 1.3.196 → 1.3.197

package/agent-pane/backend/src/claude/claude-types.ts

@@ -12,15 +12,27 @@ import type {
   ModelInfo as SdkModelInfo,
   SDKControlInitializeResponse,
   EffortLevel,
+  SDKUserMessage,
 } from '@anthropic-ai/claude-agent-sdk';
 
-export type { Query, SDKMessage, Options, EffortLevel, SdkModelInfo, SDKControlInitializeResponse };
+export type { Query, SDKMessage, Options, EffortLevel, SdkModelInfo, SDKControlInitializeResponse, SDKUserMessage };
 
-/** Per-session Claude query instance + state. */
+/** Structural type for the PromptQueue — avoids circular imports. */
+export interface PromptQueueLike {
+  push(message: SDKUserMessage): void;
+  close(): void;
+}
+
+/** Per-session Claude query instance + streaming-input state. */
 export interface ClaudeSessionEntry {
   query: Query;
-  sessionId: string | null;  // Claude session ID from SDKSystemMessage init
-  turnId: string | null;      // current AgentPane turn ID
+  sessionId: string | null;       // Claude session ID from SDKSystemMessage init
+  turnId: string | null;           // current AgentPane turn ID
+  cwd: string;                     // session working directory — used to construct Monitor output paths
+  promptQueue: PromptQueueLike;    // async iterable feeding user messages to the CLI
+  messageLoop: Promise<void> | null; // background for-await loop consuming SDK messages
+  /** Thread ID if this entry is for a branched thread conversation (null = main session). */
+  threadId?: string | null;
 }
 
 /** Map SDK effort values to UI labels. */

package/agent-pane/backend/src/codex/app-server-client.ts

@@ -68,6 +68,12 @@ export class AppServerClient {
     this.proc.on('exit', (code, signal) => {
       this.onProcessExit(code, signal);
     });
+
+    // Handle spawn errors (e.g. binary not found → ENOENT). Without this listener,
+    // an unhandled 'error' event crashes the entire process. See onProcessError.
+    this.proc.on('error', (err: Error) => {
+      this.onProcessError(err);
+    });
   }
 
   /** Perform the initialize handshake. Must be called before any other method. */
@@ -221,5 +227,21 @@ export class AppServerClient {
 
     this.events.emit('closed', reason);
   }
+
+  /** Handle a spawn/runtime error on the child process (e.g. ENOENT when the
+   *  binary is missing). Rejects pending requests and emits 'closed' so callers
+   *  can fail gracefully instead of crashing the whole process. */
+  private onProcessError(err: Error): void {
+    if (this.closed) return;
+    this.closed = true;
+
+    for (const [, entry] of this.pending) {
+      clearTimeout(entry.timer);
+      entry.reject(err);
+    }
+    this.pending.clear();
+
+    this.events.emit('closed', err.message);
+  }
 }
 

package/agent-pane/backend/src/db/index.ts

@@ -17,6 +17,7 @@ export function initDb(path: string = 'data.db'): Database.Database {
   db.pragma('foreign_keys = ON');
 
   createTables(db);
+  cleanupStaleState(db);
   return db;
 }
 
@@ -33,6 +34,35 @@ export function getDb(): Database.Database {
   return db;
 }
 
+/**
+ * Clean up stale running state from a previous backend process that crashed
+ * or was killed while a turn was in progress.
+ *
+ * Resets all sessions with `is_running = 1` to `is_running = 0, status = 'active'`,
+ * and marks all turns with `status = 'running'` as `failed` with an explanatory
+ * error message. This prevents a deadlock where the frontend sees stale running
+ * state and blocks the input bar after a backend restart.
+ *
+ * No-op if no stale state exists (0 rows affected). Safe for tests (fresh DB).
+ */
+function cleanupStaleState(database: Database.Database): void {
+  const now = new Date().toISOString();
+
+  // Mark ALL in_progress items as failed — after a backend restart, no background
+  // task can still be running (the CLI process is dead). This includes in_progress
+  // background_task items inside completed turns (Monitor/Subagent tasks that
+  // outlive their turn via streaming-input mode).
+  const staleItems = database.prepare(
+    "UPDATE items SET status = 'failed', updated_at = ? WHERE status = 'in_progress'",
+  ).run(now);
+
+  const staleSessions = database.prepare('UPDATE sessions SET is_running = 0, status = ?, updated_at = ? WHERE is_running = 1').run('active', now);
+  const staleTurns = database.prepare("UPDATE turns SET status = 'failed', error = ?, updated_at = ? WHERE status = 'running'").run('Backend restarted while turn was running', now);
+  if (staleSessions.changes > 0 || staleTurns.changes > 0 || staleItems.changes > 0) {
+    console.log(`[db] Cleaned up stale state: ${staleSessions.changes} sessions, ${staleTurns.changes} turns, ${staleItems.changes} items`);
+  }
+}
+
 /**
  * Create all tables and run inline migrations for new columns.
  *
@@ -92,9 +122,26 @@ function createTables(database: Database.Database): void {
       created_at  TEXT NOT NULL
     );
 
+    CREATE TABLE IF NOT EXISTS discussion_threads (
+      id            TEXT PRIMARY KEY,
+      session_id    TEXT NOT NULL,
+      item_id       TEXT NOT NULL,
+      turn_id       TEXT NOT NULL,
+      start_offset  INTEGER NOT NULL,
+      end_offset    INTEGER NOT NULL,
+      selected_text TEXT NOT NULL,
+      status        TEXT NOT NULL DEFAULT 'open',
+      resolved_at   TEXT,
+      created_at    TEXT NOT NULL,
+      updated_at    TEXT NOT NULL,
+      FOREIGN KEY (session_id) REFERENCES sessions(id) ON DELETE CASCADE
+    );
+
     CREATE INDEX IF NOT EXISTS idx_turns_session_id ON turns(session_id);
     CREATE INDEX IF NOT EXISTS idx_items_turn_id ON items(turn_id);
     CREATE INDEX IF NOT EXISTS idx_workspaces_path ON workspaces(path);
+    CREATE INDEX IF NOT EXISTS idx_discussion_threads_session_id ON discussion_threads(session_id);
+    CREATE INDEX IF NOT EXISTS idx_discussion_threads_item_id ON discussion_threads(item_id);
   `);
 
   // Migration: add 'deleted' column to existing workspaces table if missing
@@ -119,4 +166,59 @@ function createTables(database: Database.Database): void {
   if (!sessColumns.some((c) => c.name === 'runtime_config')) {
     database.exec('ALTER TABLE sessions ADD COLUMN runtime_config TEXT');
   }
+
+  // Migration: add 'rewound_at_turn_id' + 'pre_rewind_thread_id' columns for non-destructive rewind
+  if (!sessColumns.some((c) => c.name === 'rewound_at_turn_id')) {
+    database.exec('ALTER TABLE sessions ADD COLUMN rewound_at_turn_id TEXT');
+  }
+  if (!sessColumns.some((c) => c.name === 'pre_rewind_thread_id')) {
+    database.exec('ALTER TABLE sessions ADD COLUMN pre_rewind_thread_id TEXT');
+  }
+
+  // Migration: add 'thread_id' column to turns table (discussion threads feature)
+  const turnColumns = database.prepare('PRAGMA table_info(turns)').all() as { name: string }[];
+  if (!turnColumns.some((c) => c.name === 'thread_id')) {
+    database.exec('ALTER TABLE turns ADD COLUMN thread_id TEXT');
+  }
+  database.exec('CREATE INDEX IF NOT EXISTS idx_turns_thread_id ON turns(thread_id)');
+
+  // Migration: add 'attachments' column to turns table (file upload feature)
+  if (!turnColumns.some((c) => c.name === 'attachments')) {
+    database.exec('ALTER TABLE turns ADD COLUMN attachments TEXT');
+  }
+
+  // Migration: add 'external_thread_id' column to discussion_threads (thread branching)
+  const threadColumns = database.prepare('PRAGMA table_info(discussion_threads)').all() as { name: string }[];
+  if (!threadColumns.some((c) => c.name === 'external_thread_id')) {
+    database.exec('ALTER TABLE discussion_threads ADD COLUMN external_thread_id TEXT');
+  }
+
+  // Migration: drop discussion_threads if it was created with FK constraints on
+  // item_id/turn_id (initial version). Those FKs fail when the frontend sends
+  // delta-* item IDs from live streaming. Recreate without those FKs.
+  const threadTableDef = database
+    .prepare("SELECT sql FROM sqlite_master WHERE type='table' AND name='discussion_threads'")
+    .get() as { sql: string } | undefined;
+  if (threadTableDef && threadTableDef.sql.includes('FOREIGN KEY (item_id)')) {
+    database.exec('DROP TABLE discussion_threads');
+    // Recreate with the new schema (no FKs on item_id/turn_id)
+    database.exec(`
+      CREATE TABLE IF NOT EXISTS discussion_threads (
+        id            TEXT PRIMARY KEY,
+        session_id    TEXT NOT NULL,
+        item_id       TEXT NOT NULL,
+        turn_id       TEXT NOT NULL,
+        start_offset  INTEGER NOT NULL,
+        end_offset    INTEGER NOT NULL,
+        selected_text TEXT NOT NULL,
+        status        TEXT NOT NULL DEFAULT 'open',
+        resolved_at   TEXT,
+        created_at    TEXT NOT NULL,
+        updated_at    TEXT NOT NULL,
+        FOREIGN KEY (session_id) REFERENCES sessions(id) ON DELETE CASCADE
+      );
+      CREATE INDEX IF NOT EXISTS idx_discussion_threads_session_id ON discussion_threads(session_id);
+      CREATE INDEX IF NOT EXISTS idx_discussion_threads_item_id ON discussion_threads(item_id);
+    `);
+  }
 }

package/agent-pane/backend/src/db/schema.ts

@@ -13,6 +13,8 @@ import type {
   Item,
   Workspace,
   SessionDetail,
+  DiscussionThread,
+  Attachment,
 } from '@agentpane/shared';
 
 // Re-export shared types for backward compatibility with existing imports.
@@ -27,4 +29,6 @@ export type {
   Item,
   Workspace,
   SessionDetail,
+  DiscussionThread,
+  Attachment,
 };

package/agent-pane/backend/src/index.ts

@@ -6,6 +6,7 @@ import { initDb } from './db/index.ts';
 import { initWs, handleUpgrade, getWss } from './ws/index.ts';
 import { registerSessionRoutes } from './routes/sessions.ts';
 import { registerTurnRoutes } from './routes/turns.ts';
+import { registerThreadRoutes } from './routes/threads.ts';
 import { registerWorkspaceRoutes } from './routes/workspaces.ts';
 import { registerProviderRoutes } from './routes/providers.ts';
 import { registerModelRoutes } from './routes/models.ts';
@@ -16,7 +17,7 @@ import { registerFileRoutes } from './routes/files.ts';
 import './providers/index.ts';
 import { shutdownAllProviders } from './providers/registry.ts';
 
-const PORT = 3001;
+const PORT = 3003;
 
 async function main(): Promise<void> {
   // Initialize database
@@ -31,6 +32,7 @@ async function main(): Promise<void> {
   // Register routes
   await registerSessionRoutes(fastify);
   await registerTurnRoutes(fastify);
+  await registerThreadRoutes(fastify);
   await registerWorkspaceRoutes(fastify);
   await registerProviderRoutes(fastify);
   await registerModelRoutes(fastify);

package/agent-pane/backend/src/integration/helpers/test-app.ts

@@ -19,6 +19,7 @@ import { initDb } from '../../db/index.ts';
 import { initWs } from '../../ws/index.ts';
 import { registerSessionRoutes } from '../../routes/sessions.ts';
 import { registerTurnRoutes } from '../../routes/turns.ts';
+import { registerThreadRoutes } from '../../routes/threads.ts';
 import { registerWorkspaceRoutes } from '../../routes/workspaces.ts';
 import { clearAllProviders } from '../../providers/registry.ts';
 import '../../providers/index.ts'; // register providers for integration tests
@@ -42,6 +43,7 @@ export async function createTestApp(): Promise<TestApp> {
 
   await registerSessionRoutes(app);
   await registerTurnRoutes(app);
+  await registerThreadRoutes(app);
   await registerWorkspaceRoutes(app);
 
   initWs();

package/agent-pane/backend/src/integration/session-operations.test.ts

@@ -46,7 +46,7 @@ describe('Integration: session operations', () => {
     await testApp.cleanup();
   });
 
-  it('rewind deletes turns after target and nulls external_thread_id', async () => {
+  it('rewind marks session as rewound (non-destructive) and saves pre_rewind_thread_id', async () => {
     const db: Database.Database = getDb();
 
     insertTestSession(db, 's1', { external_thread_id: 'thread_old' });
@@ -63,7 +63,7 @@ describe('Integration: session operations', () => {
        VALUES (?, ?, ?, NULL, NULL, NULL, NULL, 'completed', NULL, ?, ?)`,
     ).run('t2', 's1', 'second', now2, now2);
 
-    // Rewind to t1 — deletes t2 and after
+    // Rewind to t1 — non-destructive: turns are NOT deleted
     const res = await testApp.app.inject({
       method: 'POST',
       url: '/api/sessions/s1/rewind',
@@ -71,18 +71,24 @@ describe('Integration: session operations', () => {
     });
     expect(res.statusCode).toBe(200);
 
-    // Only t1 remains
+    // Both turns still exist (not deleted)
     const turns = db.prepare('SELECT id FROM turns WHERE session_id = ?').all('s1') as {
       id: string;
     }[];
-    expect(turns).toHaveLength(1);
-    expect(turns[0].id).toBe('t1');
+    expect(turns).toHaveLength(2);
 
-    // external_thread_id nulled
-    const session = db.prepare('SELECT external_thread_id FROM sessions WHERE id = ?').get('s1') as {
-      external_thread_id: string | null;
+    // Session marked as rewound, pre_rewind_thread_id saved
+    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.external_thread_id).toBeNull();
+    expect(session.rewound_at_turn_id).toBe('t1');
+    expect(session.pre_rewind_thread_id).toBe('thread_old');
+
+    // GET session filters turns (only t1 visible)
+    const getRes = await testApp.app.inject({ method: 'GET', url: '/api/sessions/s1' });
+    expect(getRes.json().turns).toHaveLength(1);
+    expect(getRes.json().turns[0].id).toBe('t1');
   });
 
   it('branch creates new session with copied turns and items', async () => {
@@ -128,7 +134,7 @@ describe('Integration: session operations', () => {
     expect(newItems[0].type).toBe('agent_message');
   });
 
-  it('model change clears thread when external_thread_id exists', async () => {
+  it('model change preserves thread when external_thread_id exists (same provider)', async () => {
     const db: Database.Database = getDb();
 
     insertTestSession(db, 's1', { model: 'gpt-4', external_thread_id: 'thread_123' });
@@ -144,7 +150,8 @@ describe('Integration: session operations', () => {
       external_thread_id: string | null;
       model: string | null;
     };
-    expect(session.external_thread_id).toBeNull();
+    // Thread must survive model change within the same provider
+    expect(session.external_thread_id).toBe('thread_123');
     expect(session.model).toBe('o3');
   });
 

package/agent-pane/backend/src/integration/threads.test.ts

@@ -0,0 +1,309 @@
+/**
+ * Integration test: discussion threads — create, followup, resolve, delete, list.
+ *
+ * Tests the REST CRUD endpoints and verifies DB state + WS broadcasts.
+ * Uses the real codex-provider (mocked AppServerClient) for startTurn calls.
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import type Database from 'better-sqlite3';
+import { createAppServerMock, type Fixture } from './helpers/app-server-mock.ts';
+import { clearBroadcasts, capturedBroadcasts } from './helpers/ws-capture.ts';
+import type { TestApp } from './helpers/test-app.ts';
+
+const fixture = JSON.parse(readFileSync(resolve(__dirname, '__fixtures__/simple-turn.json'), 'utf-8')) as Fixture;
+
+vi.mock('../codex/app-server-client.ts', () => ({
+  AppServerClient: createAppServerMock(fixture),
+}));
+
+vi.mock('../ws/index.ts', async (importOriginal) => {
+  const actual = (await importOriginal()) as Record<string, unknown>;
+  return {
+    ...actual,
+    broadcast: vi.fn((event: string, data: unknown) => {
+      capturedBroadcasts.push({ event, data });
+    }),
+  };
+});
+
+const { getDb } = await import('../db/index.ts');
+const { createTestApp, insertTestSession } = await import('./helpers/test-app.ts');
+
+describe('Integration: discussion threads', () => {
+  let testApp: TestApp;
+
+  beforeEach(async () => {
+    vi.clearAllMocks();
+    clearBroadcasts();
+    testApp = await createTestApp();
+  });
+
+  afterEach(async () => {
+    await testApp.cleanup();
+  });
+
+  it('creates a thread + first AI turn', async () => {
+    const db: Database.Database = getDb();
+    insertTestSession(db, 's1', { runtime_type: 'codex' });
+
+    // Insert an anchor turn + item (the agent_message being annotated)
+    const now = '2025-01-01T00:00:00Z';
+    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 (?, ?, 'prompt', 'response', NULL, NULL, NULL, 'completed', NULL, ?, ?)`,
+    ).run('t1', 's1', now, now);
+    db.prepare(
+      `INSERT INTO items (id, turn_id, external_item_id, type, data, status, created_at, updated_at)
+       VALUES (?, ?, 'ext1', 'agent_message', ?, 'completed', ?, ?)`,
+    ).run('i1', 't1', JSON.stringify({ text: 'Some text to discuss' }), now, now);
+
+    const res = await testApp.app.inject({
+      method: 'POST',
+      url: '/api/sessions/s1/threads',
+      payload: {
+        itemId: 'i1',
+        turnId: 't1',
+        startOffset: 0,
+        endOffset: 10,
+        selectedText: 'Some text ',
+        message: 'What does this mean?',
+      },
+    });
+
+    expect(res.statusCode).toBe(200);
+    const body = res.json();
+    expect(body.thread).toBeDefined();
+    expect(body.thread.id).toBeDefined();
+    expect(body.thread.status).toBe('open');
+    expect(body.thread.selected_text).toBe('Some text ');
+    expect(body.turn).toBeDefined();
+    expect(body.turn.thread_id).toBe(body.thread.id);
+
+    // Verify DB state
+    const threadRow = db.prepare('SELECT * FROM discussion_threads WHERE id = ?').get(body.thread.id);
+    expect(threadRow).toBeDefined();
+    expect((threadRow as { status: string }).status).toBe('open');
+
+    const turnRow = db.prepare('SELECT * FROM turns WHERE id = ?').get(body.turn.id) as { thread_id: string | null; user_prompt: string };
+    expect(turnRow.thread_id).toBe(body.thread.id);
+    expect(turnRow.user_prompt).toContain('[Quoting from your previous response]');
+    expect(turnRow.user_prompt).toContain('Some text ');
+    expect(turnRow.user_prompt).toContain('What does this mean?');
+
+    // Verify broadcast
+    const createdEvent = capturedBroadcasts.find((b) => b.event === 'thread:created');
+    expect(createdEvent).toBeDefined();
+    expect((createdEvent!.data as { sessionId: string }).sessionId).toBe('s1');
+  });
+
+  it('returns 409 when a turn is already running', async () => {
+    const db: Database.Database = getDb();
+    insertTestSession(db, 's1', { is_running: 1 });
+
+    const res = await testApp.app.inject({
+      method: 'POST',
+      url: '/api/sessions/s1/threads',
+      payload: {
+        itemId: 'i1',
+        turnId: 't1',
+        startOffset: 0,
+        endOffset: 5,
+        selectedText: 'text',
+        message: 'test',
+      },
+    });
+
+    expect(res.statusCode).toBe(409);
+  });
+
+  it('resolves and reopens a thread', async () => {
+    const db: Database.Database = getDb();
+    insertTestSession(db, 's1', { runtime_type: 'codex' });
+
+    const now = '2025-01-01T00:00:00Z';
+    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 (?, ?, 'prompt', 'response', NULL, NULL, NULL, 'completed', NULL, ?, ?)`,
+    ).run('t1', 's1', now, now);
+    db.prepare(
+      `INSERT INTO items (id, turn_id, external_item_id, type, data, status, created_at, updated_at)
+       VALUES (?, ?, 'ext1', 'agent_message', ?, 'completed', ?, ?)`,
+    ).run('i1', 't1', JSON.stringify({ text: 'text' }), now, now);
+
+    // Manually insert a thread
+    db.prepare(
+      `INSERT INTO discussion_threads (id, session_id, item_id, turn_id, start_offset, end_offset, selected_text, status, created_at, updated_at)
+       VALUES (?, ?, ?, ?, 0, 4, 'text', 'open', ?, ?)`,
+    ).run('th1', 's1', 'i1', 't1', now, now);
+
+    // Resolve
+    const resolveRes = await testApp.app.inject({
+      method: 'PATCH',
+      url: '/api/sessions/s1/threads/th1',
+      payload: { status: 'resolved' },
+    });
+    expect(resolveRes.statusCode).toBe(200);
+    expect(resolveRes.json().status).toBe('resolved');
+
+    const thread = db.prepare('SELECT status, resolved_at FROM discussion_threads WHERE id = ?').get('th1') as { status: string; resolved_at: string | null };
+    expect(thread.status).toBe('resolved');
+    expect(thread.resolved_at).not.toBeNull();
+
+    const resolvedEvent = capturedBroadcasts.find((b) => b.event === 'thread:resolved');
+    expect(resolvedEvent).toBeDefined();
+
+    // Reopen
+    clearBroadcasts();
+    const reopenRes = await testApp.app.inject({
+      method: 'PATCH',
+      url: '/api/sessions/s1/threads/th1',
+      payload: { status: 'open' },
+    });
+    expect(reopenRes.statusCode).toBe(200);
+    expect(reopenRes.json().status).toBe('open');
+
+    const reopened = db.prepare('SELECT status FROM discussion_threads WHERE id = ?').get('th1') as { status: string };
+    expect(reopened.status).toBe('open');
+  });
+
+  it('deletes a thread and its turns + items', async () => {
+    const db: Database.Database = getDb();
+    insertTestSession(db, 's1', { runtime_type: 'codex' });
+
+    const now = '2025-01-01T00:00:00Z';
+    // Insert anchor turn + item
+    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 (?, ?, 'prompt', 'response', NULL, NULL, NULL, 'completed', NULL, ?, ?)`,
+    ).run('t1', 's1', now, now);
+    db.prepare(
+      `INSERT INTO items (id, turn_id, external_item_id, type, data, status, created_at, updated_at)
+       VALUES (?, ?, 'ext1', 'agent_message', ?, 'completed', ?, ?)`,
+    ).run('i1', 't1', JSON.stringify({ text: 'text' }), now, now);
+
+    // Insert thread + thread turn + thread item
+    db.prepare(
+      `INSERT INTO discussion_threads (id, session_id, item_id, turn_id, start_offset, end_offset, selected_text, status, created_at, updated_at)
+       VALUES (?, ?, ?, ?, 0, 4, 'text', 'open', ?, ?)`,
+    ).run('th1', 's1', 'i1', 't1', now, now);
+    db.prepare(
+      `INSERT INTO turns (id, session_id, user_prompt, agent_response, thoughts, token_usage, external_turn_id, status, error, thread_id, created_at, updated_at)
+       VALUES (?, ?, 'thread msg', 'thread resp', NULL, NULL, NULL, 'completed', NULL, ?, ?, ?)`,
+    ).run('tt1', 's1', 'th1', now, now);
+    db.prepare(
+      `INSERT INTO items (id, turn_id, external_item_id, type, data, status, created_at, updated_at)
+       VALUES (?, ?, 'ext2', 'agent_message', ?, 'completed', ?, ?)`,
+    ).run('ti1', 'tt1', JSON.stringify({ text: 'thread response' }), now, now);
+
+    const res = await testApp.app.inject({
+      method: 'DELETE',
+      url: '/api/sessions/s1/threads/th1',
+    });
+    expect(res.statusCode).toBe(200);
+    expect(res.json().success).toBe(true);
+
+    // Thread row deleted
+    const thread = db.prepare('SELECT id FROM discussion_threads WHERE id = ?').get('th1');
+    expect(thread).toBeUndefined();
+
+    // Thread turn deleted
+    const turn = db.prepare('SELECT id FROM turns WHERE id = ?').get('tt1');
+    expect(turn).toBeUndefined();
+
+    // Thread item deleted
+    const item = db.prepare('SELECT id FROM items WHERE id = ?').get('ti1');
+    expect(item).toBeUndefined();
+
+    // Anchor turn + item still exist
+    const anchorTurn = db.prepare('SELECT id FROM turns WHERE id = ?').get('t1');
+    expect(anchorTurn).toBeDefined();
+    const anchorItem = db.prepare('SELECT id FROM items WHERE id = ?').get('i1');
+    expect(anchorItem).toBeDefined();
+
+    const deletedEvent = capturedBroadcasts.find((b) => b.event === 'thread:deleted');
+    expect(deletedEvent).toBeDefined();
+  });
+
+  it('lists threads with nested turns', async () => {
+    const db: Database.Database = getDb();
+    insertTestSession(db, 's1', { runtime_type: 'codex' });
+
+    const now = '2025-01-01T00:00:00Z';
+    // Anchor turn + item
+    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 (?, ?, 'prompt', 'response', NULL, NULL, NULL, 'completed', NULL, ?, ?)`,
+    ).run('t1', 's1', now, now);
+    db.prepare(
+      `INSERT INTO items (id, turn_id, external_item_id, type, data, status, created_at, updated_at)
+       VALUES (?, ?, 'ext1', 'agent_message', ?, 'completed', ?, ?)`,
+    ).run('i1', 't1', JSON.stringify({ text: 'text' }), now, now);
+
+    // Thread + thread turn + thread item
+    db.prepare(
+      `INSERT INTO discussion_threads (id, session_id, item_id, turn_id, start_offset, end_offset, selected_text, status, created_at, updated_at)
+       VALUES (?, ?, ?, ?, 0, 4, 'text', 'open', ?, ?)`,
+    ).run('th1', 's1', 'i1', 't1', now, now);
+    db.prepare(
+      `INSERT INTO turns (id, session_id, user_prompt, agent_response, thoughts, token_usage, external_turn_id, status, error, thread_id, created_at, updated_at)
+       VALUES (?, ?, 'msg', 'resp', NULL, NULL, NULL, 'completed', NULL, ?, ?, ?)`,
+    ).run('tt1', 's1', 'th1', now, now);
+    db.prepare(
+      `INSERT INTO items (id, turn_id, external_item_id, type, data, status, created_at, updated_at)
+       VALUES (?, ?, 'ext2', 'agent_message', ?, 'completed', ?, ?)`,
+    ).run('ti1', 'tt1', JSON.stringify({ text: 'response' }), now, now);
+
+    const res = await testApp.app.inject({
+      method: 'GET',
+      url: '/api/sessions/s1/threads',
+    });
+    expect(res.statusCode).toBe(200);
+    const threads = res.json();
+    expect(threads).toHaveLength(1);
+    expect(threads[0].id).toBe('th1');
+    expect(threads[0].turns).toHaveLength(1);
+    expect(threads[0].turns[0].id).toBe('tt1');
+    expect(threads[0].turns[0].items).toHaveLength(1);
+    expect(threads[0].turns[0].items[0].id).toBe('ti1');
+  });
+
+  it('GET /api/sessions/:id includes threads', async () => {
+    const db: Database.Database = getDb();
+    insertTestSession(db, 's1', { runtime_type: 'codex' });
+
+    const now = '2025-01-01T00:00:00Z';
+    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 (?, ?, 'prompt', 'response', NULL, NULL, NULL, 'completed', NULL, ?, ?)`,
+    ).run('t1', 's1', now, now);
+    db.prepare(
+      `INSERT INTO items (id, turn_id, external_item_id, type, data, status, created_at, updated_at)
+       VALUES (?, ?, 'ext1', 'agent_message', ?, 'completed', ?, ?)`,
+    ).run('i1', 't1', JSON.stringify({ text: 'text' }), now, now);
+
+    db.prepare(
+      `INSERT INTO discussion_threads (id, session_id, item_id, turn_id, start_offset, end_offset, selected_text, status, created_at, updated_at)
+       VALUES (?, ?, ?, ?, 0, 4, 'text', 'open', ?, ?)`,
+    ).run('th1', 's1', 'i1', 't1', now, now);
+    db.prepare(
+      `INSERT INTO turns (id, session_id, user_prompt, agent_response, thoughts, token_usage, external_turn_id, status, error, thread_id, created_at, updated_at)
+       VALUES (?, ?, 'msg', 'resp', NULL, NULL, NULL, 'completed', NULL, ?, ?, ?)`,
+    ).run('tt1', 's1', 'th1', now, now);
+
+    const res = await testApp.app.inject({ method: 'GET', url: '/api/sessions/s1' });
+    expect(res.statusCode).toBe(200);
+    const detail = res.json();
+    expect(detail.threads).toBeDefined();
+    expect(detail.threads).toHaveLength(1);
+    expect(detail.threads[0].id).toBe('th1');
+    expect(detail.threads[0].turns).toHaveLength(1);
+
+    // Thread turns should also be in the main turns array
+    expect(detail.turns).toHaveLength(2);
+    const threadTurn = detail.turns.find((t: { thread_id: string | null }) => t.thread_id === 'th1');
+    expect(threadTurn).toBeDefined();
+  });
+});

package/agent-pane/backend/src/providers/runtime-provider.ts

@@ -6,7 +6,7 @@
  */
 
 import type { Session, Turn } from '../db/schema.ts';
-import type { ModelInfo } from '@agentpane/shared';
+import type { ModelInfo, ProviderSlashCommand } from '@agentpane/shared';
 
 /** Runtime provider — turn lifecycle, cleanup, metadata, and shutdown. */
 export interface RuntimeProvider {
@@ -16,10 +16,28 @@ export interface RuntimeProvider {
   interruptTurn(sessionId: string): Promise<boolean>;
   /** Remove session from in-memory state. Used after rewind/branch/model-change. */
   clearThread(sessionId: string): void;
+  /** Remove a specific thread's branched session entry. Used when a thread is deleted. */
+  clearThreadBranch?(sessionId: string, threadId: string): void;
   /** Clear all in-memory state. Used in test cleanup. */
   clearAllThreads(): void;
   /** Fetch available models for this provider. */
   getModels(): Promise<ModelInfo[]>;
+  /** Fetch provider-native slash commands (e.g. Claude CLI `/compact`, `/clear`).
+   *  Optional — providers without a command surface omit it and return `[]`. */
+  getCommands?(): Promise<ProviderSlashCommand[]>;
+  /** Fork the provider-native session at a branch point.
+   *  Returns the new provider-native session ID, or null if there is no thread to fork.
+   *  Optional — providers without fork support omit it. */
+  forkSession?(session: Session, targetTurn: Turn): Promise<string | null>;
+  /** Change the model for a running session without restarting the CLI process.
+   *  Only supported in streaming-input mode (Claude). If the session hasn't
+   *  started yet, the new model is read from the DB on next startTurn.
+   *  Optional — providers without mid-session model switching omit it. */
+  setModel?(sessionId: string, model: string): Promise<void>;
+  /** Stop a running background task (e.g. Monitor) by task ID.
+   *  Emits a task_notification with status 'stopped'.
+   *  Optional — providers without background task support omit it. */
+  stopTask?(sessionId: string, taskId: string): Promise<void>;
   /** Graceful shutdown — close processes, release resources. */
   shutdown(): Promise<void>;
 }