repoburg 1.3.201 → 1.3.204

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

@@ -1,1319 +0,0 @@
-/**
- * Claude provider — implements the RuntimeProvider interface.
- *
- * Uses `@anthropic-ai/claude-agent-sdk` `query()` function in **streaming-input
- * mode** — a single `query()` per session, fed by an async iterable of
- * `SDKUserMessage` objects.  This keeps the CLI process alive between turns,
- * which is required for Monitor background tasks to survive turn boundaries.
- *
- * Same WebSocket event protocol as Codex:
- *   turn:started, item:started, item:completed, item:delta,
- *   turn:completed, turn:tokenUsage, turn:failed, turn:cancelled
- *
- * Frontend needs zero changes.
- */
-
-import { query, forkSession as sdkForkSession } from '@anthropic-ai/claude-agent-sdk';
-import type { SDKMessage, SDKUserMessage, Options, ModelInfo as SdkModelInfo, Query, SlashCommand as SdkSlashCommand } from '@anthropic-ai/claude-agent-sdk';
-import type { ModelInfo, TokenUsage, ProviderSlashCommand, Attachment, ContextUsage } from '@agentpane/shared';
-import { v4 as uuidv4 } from 'uuid';
-import { readFileSync } from 'fs';
-import { tmpdir } from 'os';
-import { join } from 'path';
-import type Database from 'better-sqlite3';
-import { getDb } from '../db/index.ts';
-import { broadcast } from '../ws/index.ts';
-import { mapAssistantContent, mapPartialDelta, mapUsage, applyToolResult, type ItemDescriptor, type ToolResultLike } from './claude-message-mapper.ts';
-import { EFFORT_LABELS, type ClaudeSessionEntry } from './claude-types.ts';
-import type { Session, Turn, Item, ItemStatus } from '../db/schema.ts';
-import type { RuntimeProvider } from '../providers/runtime-provider.ts';
-
-// ---------------------------------------------------------------------------
-// PromptQueue — async iterable that feeds user messages to the CLI
-// ---------------------------------------------------------------------------
-
-/** Async iterable queue of `SDKUserMessage` objects.
- *
- *  The `query()` function receives this as its `prompt` argument.  Each
- *  `push()` enqueues a message and resolves the pending `next()` call from
- *  the SDK's internal consumer.  `close()` signals end-of-iteration, which
- *  causes the CLI process to exit gracefully.
- *
- *  This is what keeps the CLI alive between turns: the SDK's for-await loop
- *  blocks on `next()` waiting for the next user message, so the process
- *  stays resident and background tasks (Monitor) keep running. */
-class PromptQueue {
-  private buffer: SDKUserMessage[] = [];
-  private resolver: ((value: IteratorResult<SDKUserMessage>) => void) | null = null;
-  private done = false;
-
-  push(message: SDKUserMessage): void {
-    if (this.done) return;
-    if (this.resolver) {
-      const r = this.resolver;
-      this.resolver = null;
-      r({ value: message, done: false });
-    } else {
-      this.buffer.push(message);
-    }
-  }
-
-  close(): void {
-    this.done = true;
-    if (this.resolver) {
-      const r = this.resolver;
-      this.resolver = null;
-      r({ value: undefined, done: true });
-    }
-  }
-
-  [Symbol.asyncIterator](): AsyncIterator<SDKUserMessage> {
-    return {
-      next: (): Promise<IteratorResult<SDKUserMessage>> => {
-        if (this.buffer.length > 0) {
-          return Promise.resolve({ value: this.buffer.shift()!, done: false });
-        }
-        if (this.done) {
-          return Promise.resolve({ value: undefined, done: true });
-        }
-        return new Promise((resolve) => {
-          this.resolver = resolve;
-        });
-      },
-    };
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Per-session state
-// ---------------------------------------------------------------------------
-
-/** Per-session Claude query instances. */
-const sessionMap = new Map<string, ClaudeSessionEntry>();
-
-/** Sessions currently generating titles — prevents duplicate throwaway queries. */
-const titleGenerating = new Set<string>();
-
-/** Cached model list from the SDK. */
-let cachedModels: ModelInfo[] | null = null;
-
-/** Cached provider-native slash commands from the SDK (e.g. /compact, /clear). */
-let cachedCommands: ProviderSlashCommand[] | null = null;
-
-/** Accumulated thinking_delta text per assistant message UUID → content block index → text.
- *  Stream events arrive before the final assistant message; the thinking block in the
- *  assistant message is signed-empty, so we accumulate the real text from thinking_delta
- *  events and feed it to mapAssistantContent. */
-const thinkingAccumulator = new Map<string, Map<number, string>>();
-
-/** Anthropic message ID captured from `message_start` stream events, keyed by turnId.
- *  Each SDKPartialAssistantMessage has a unique uuid (different per event), but the
- *  Anthropic message ID from `message_start` is stable across all stream events for one
- *  assistant message. We use it as the itemId for text delta broadcasts so the frontend
- *  accumulates into one item instead of creating N separate items. */
-const streamingMessageIds = new Map<string, string>();
-
-
-
-// ---------------------------------------------------------------------------
-// DB helpers
-// ---------------------------------------------------------------------------
-
-/** Update the running state and status of a session. */
-function setSessionStatus(
-  db: Database.Database,
-  sessionId: string,
-  isRunning: 0 | 1,
-  status: string,
-  now: string,
-  hasUnreviewed = false,
-): void {
-  if (hasUnreviewed) {
-    db.prepare('UPDATE sessions SET is_running = ?, status = ?, has_unreviewed = 1, updated_at = ? WHERE id = ?').run(
-      isRunning, status, now, sessionId,
-    );
-  } else {
-    db.prepare('UPDATE sessions SET is_running = ?, status = ?, updated_at = ? WHERE id = ?').run(
-      isRunning, status, now, sessionId,
-    );
-  }
-}
-
-// ---------------------------------------------------------------------------
-// ensureSessionStarted — create streaming-input query for a session
-// ---------------------------------------------------------------------------
-
-/** Create (or reuse) a streaming-input query for a session.
- *
- *  Builds options from the session's DB row (cwd, model, permissionMode, resume,
- *  etc.), creates a `PromptQueue`, calls `query({ prompt: queue, options })`,
- *  and starts a background message loop that dispatches SDK messages to
- *  `handleMessage` using the current `entry.turnId`.
- *
- *  The CLI process stays alive as long as the PromptQueue is not closed —
- *  this is what allows Monitor background tasks to survive between turns. */
-async function ensureSessionStarted(
-  session: Session,
-  mapKey?: string,
-  resumeSessionId?: string,
-): Promise<ClaudeSessionEntry> {
-  const db = getDb();
-  const key = mapKey ?? session.id;
-  // Main session (no mapKey) falls back to its persisted external_thread_id so it
-  // resumes the existing conversation. Thread (forked) entries must NOT fall back
-  // to the main session's external_thread_id — that would append the thread's
-  // messages to the MAIN session transcript (resume appends to the same file).
-  // An explicit undefined resume for a thread starts a fresh isolated session.
-  const resumeId = mapKey !== undefined ? resumeSessionId : (resumeSessionId ?? session.external_thread_id ?? undefined);
-
-  // Build options — same as the old per-turn options, but applied once per session.
-  const options: Options = {
-    cwd: session.cwd ?? process.cwd(),
-    model: session.model ?? undefined,
-    permissionMode: 'bypassPermissions',
-    allowDangerouslySkipPermissions: true,
-    includePartialMessages: true,
-    ...(process.env.CLAUDE_BIN ? { pathToClaudeCodeExecutable: process.env.CLAUDE_BIN } : {}),
-    ...(session.model_reasoning_effort ? { effort: session.model_reasoning_effort as Options['effort'] } : {}),
-    ...(resumeId ? { resume: resumeId } : {}),
-  };
-
-  const promptQueue = new PromptQueue();
-  const q: Query = query({ prompt: promptQueue, options });
-
-  const entry: ClaudeSessionEntry = {
-    query: q,
-    sessionId: null,
-    turnId: null,
-    cwd: session.cwd ?? process.cwd(),
-    promptQueue,
-    messageLoop: null,
-  };
-  sessionMap.set(key, entry);
-
-  // Background message loop — runs for the lifetime of the CLI process.
-  // Dispatches each SDK message to handleMessage using the current entry.turnId.
-  entry.messageLoop = (async () => {
-    try {
-      for await (const message of q) {
-        const currentTurnId = entry.turnId;
-        if (!currentTurnId) continue; // no active turn — skip (shouldn't happen normally)
-        await handleMessage(message, session.id, currentTurnId, entry, db);
-      }
-
-      // Generator ended (PromptQueue was closed via clearThread).
-      // Complete the current turn if it's still running.
-      if (entry.turnId) {
-        const currentTurn = db.prepare('SELECT status, token_usage FROM turns WHERE id = ?').get(entry.turnId) as
-          | { status: string; token_usage: string | null }
-          | undefined;
-        if (currentTurn && currentTurn.status === 'running') {
-          const usage = currentTurn.token_usage ? (JSON.parse(currentTurn.token_usage) as TokenUsage) : null;
-          completeTurn(db, session.id, entry.turnId, usage);
-        }
-        syncThreadTitle(session.id);
-      }
-    } catch (err) {
-      const errMsg = (err as Error).message;
-      console.error(`[claude] message loop error for session ${session.id}:`, errMsg);
-      if (entry.turnId) {
-        const now = new Date().toISOString();
-        // Mark ALL in_progress items for this session as failed — the CLI died so
-        // no background task (Monitor/Subagent) can still be running, even ones
-        // started in earlier completed turns.
-        const staleItems = db.prepare(
-          "UPDATE items SET status = 'failed', updated_at = ? WHERE status = 'in_progress' AND turn_id IN (SELECT id FROM turns WHERE session_id = ?)",
-        ).run(now, session.id) as { changes: number };
-
-        db.prepare('UPDATE turns SET status = ?, error = ?, updated_at = ? WHERE id = ?').run('failed', errMsg, now, entry.turnId);
-        setSessionStatus(db, session.id, 0, 'failed', now);
-        broadcast('turn:failed', { sessionId: session.id, turnId: entry.turnId, error: errMsg });
-
-        // Broadcast item:completed for each stale item so the frontend updates.
-        if (staleItems.changes > 0) {
-          const staleRows = db.prepare(
-            "SELECT id, turn_id, external_item_id, type, data, created_at FROM items WHERE turn_id IN (SELECT id FROM turns WHERE session_id = ?) AND status = 'failed' AND updated_at = ?",
-          ).all(session.id, now) as { id: string; turn_id: string; external_item_id: string; type: string; data: string | null; created_at: string }[];
-          for (const row of staleRows) {
-            broadcast('item:completed', {
-              sessionId: session.id,
-              turnId: row.turn_id,
-              item: {
-                id: row.id,
-                turn_id: row.turn_id,
-                external_item_id: row.external_item_id,
-                type: row.type,
-                data: row.data ? JSON.parse(row.data) : {},
-                status: 'failed',
-                created_at: row.created_at,
-                updated_at: now,
-              },
-            });
-          }
-        }
-      }
-    } finally {
-      // Clean up streaming state
-      if (entry.turnId) {
-        streamingMessageIds.delete(entry.turnId);
-      }
-      sessionMap.delete(key);
-    }
-  })();
-
-  return entry;
-}
-
-// ---------------------------------------------------------------------------
-// startTurn
-// ---------------------------------------------------------------------------
-
-/** Start a Claude turn using the streaming-input query.
- *
- *  1. Ensure the session's streaming query is running (create if needed).
- *  2. Complete the previous turn if it's still running.
- *  3. Set the new turn as active.
- *  4. Push the user message to the PromptQueue — the SDK picks it up and
- *     starts generating.  No new `query()` call is made. */
-async function startTurn(session: Session, turn: Turn): Promise<void> {
-  const db = getDb();
-  const now = new Date().toISOString();
-
-  // Get or create the streaming-input session entry.
-  // Thread turns use a composite key so they get their own forked Claude session.
-  const mapKey = turn.thread_id ? `${session.id}:thread:${turn.thread_id}` : session.id;
-  let entry = sessionMap.get(mapKey);
-  if (!entry) {
-    try {
-      if (turn.thread_id) {
-        // Thread turn — resume from the thread's OWN forked session id. Do NOT
-        // fall back to the main session's external_thread_id: if the fork failed
-        // (thread has no external_thread_id), start a FRESH isolated session
-        // instead, so the thread never appends to the main session transcript.
-        const thread = db
-          .prepare('SELECT external_thread_id FROM discussion_threads WHERE id = ?')
-          .get(turn.thread_id) as { external_thread_id: string | null } | undefined;
-        entry = await ensureSessionStarted(session, mapKey, thread?.external_thread_id ?? undefined);
-      } else {
-        entry = await ensureSessionStarted(session);
-      }
-    } catch (err) {
-      const errMsg = `Failed to start Claude query: ${(err as Error).message}`;
-      const now2 = new Date().toISOString();
-      db.prepare('UPDATE turns SET status = ?, error = ?, updated_at = ? WHERE id = ?').run('failed', errMsg, now2, turn.id);
-      setSessionStatus(db, session.id, 0, 'failed', now2);
-      broadcast('turn:failed', { sessionId: session.id, turnId: turn.id, error: errMsg });
-      return;
-    }
-  }
-
-  // Tag thread entries so the system/init handler can avoid corrupting the
-  // main session's external_thread_id with the fork's session id. Set on every
-  // startTurn (covers both freshly-created and reused sessionMap entries).
-  entry.threadId = turn.thread_id ?? null;
-
-  // Complete previous turn if still running (e.g. Monitor was active).
-  // All messages between user prompts belong to one AgentPane turn —
-  // Monitor-triggered internal turns do NOT create separate AgentPane turns.
-  if (entry.turnId) {
-    const prevTurn = db.prepare('SELECT status, token_usage FROM turns WHERE id = ?').get(entry.turnId) as
-      | { status: string; token_usage: string | null }
-      | undefined;
-    if (prevTurn && prevTurn.status === 'running') {
-      const usage = prevTurn.token_usage ? (JSON.parse(prevTurn.token_usage) as TokenUsage) : null;
-      completeTurn(db, session.id, entry.turnId, usage);
-    }
-    syncThreadTitle(session.id);
-    streamingMessageIds.delete(entry.turnId);
-  }
-  entry.turnId = turn.id;
-  db.prepare('UPDATE turns SET status = ?, updated_at = ? WHERE id = ?').run('running', now, turn.id);
-  setSessionStatus(db, session.id, 1, 'running', now);
-  broadcast('turn:started', { sessionId: session.id, turnId: turn.id });
-
-  // Push the user message to the PromptQueue — the SDK picks it up and starts generating.
-  // No new query() call — the CLI process is already alive.
-  // Build content blocks if attachments exist (images, PDFs, text files).
-  // turn.attachments is stored as a JSON string in the DB — parse it.
-  let content: string | SDKUserMessage['message']['content'];
-  const rawAttachments = turn.attachments as unknown as string | null;
-  let attachments: Attachment[] | null = null;
-  if (rawAttachments) {
-    try {
-      attachments = JSON.parse(rawAttachments) as Attachment[];
-    } catch {
-      attachments = null;
-    }
-  }
-  if (attachments && attachments.length > 0) {
-    const blocks: NonNullable<SDKUserMessage['message']['content']> = [{ type: 'text', text: turn.user_prompt }];
-    for (const att of attachments) {
-      if (att.media_type.startsWith('image/')) {
-        blocks.push({
-          type: 'image',
-          source: { type: 'base64', media_type: att.media_type as 'image/jpeg' | 'image/png' | 'image/gif' | 'image/webp', data: att.data },
-        });
-      } else if (att.media_type === 'application/pdf') {
-        blocks.push({
-          type: 'document',
-          source: { type: 'base64', media_type: att.media_type as 'application/pdf', data: att.data },
-        });
-      } else {
-        // Text files: inline as additional text blocks
-        const decoded = Buffer.from(att.data, 'base64').toString('utf-8');
-        blocks.push({ type: 'text', text: `\n--- ${att.name} ---\n${decoded}\n--- end ---` });
-      }
-    }
-    content = blocks;
-  } else {
-    content = turn.user_prompt; // plain string (backward compatible)
-  }
-
-  entry.promptQueue.push({
-    type: 'user',
-    message: { role: 'user', content },
-    parent_tool_use_id: null,
-  } as SDKUserMessage);
-}
-
-// ---------------------------------------------------------------------------
-// handleMessage — dispatch SDK messages to the correct handler
-// ---------------------------------------------------------------------------
-
-/** Handle a single SDK message — dispatch to the correct handler. */
-export async function handleMessage(
-  message: SDKMessage,
-  sessionId: string,
-  turnId: string,
-  entry: ClaudeSessionEntry,
-  db: Database.Database,
-): Promise<void> {
-  switch (message.type) {
-    case 'system': {
-      if ('subtype' in message) {
-        const sub = (message as { subtype: string }).subtype;
-        if (sub === 'init') {
-          // Always capture the Claude session id (needed for Monitor output-path
-          // construction). Idempotent — Monitor triggers multiple inits.
-          entry.sessionId = (message as { session_id: string }).session_id;
-          // Only persist the resume id for the MAIN session. For thread (forked)
-          // entries, the fork's session id already lives in
-          // discussion_threads.external_thread_id; writing it here would corrupt
-          // the MAIN session's external_thread_id, causing the main session to
-          // resume the fork after a restart/rewind and "remember" the thread's
-          // discussion.
-          if (!entry.threadId) {
-            const now = new Date().toISOString();
-            db.prepare('UPDATE sessions SET external_thread_id = ?, updated_at = ? WHERE id = ?').run(
-              (message as { session_id: string }).session_id, now, sessionId,
-            );
-          }
-        } else if (sub === 'compact_boundary') {
-          handleCompactBoundary(message as SDKMessage & { type: 'system'; subtype: 'compact_boundary' }, sessionId, turnId, db);
-        } else if (sub === 'task_started') {
-          handleTaskStarted(message as SDKMessage & { type: 'system'; subtype: 'task_started' }, sessionId, turnId, entry, db);
-        } else if (sub === 'task_progress') {
-          handleTaskProgress(message as SDKMessage & { type: 'system'; subtype: 'task_progress' }, sessionId, turnId, entry, db);
-        } else if (sub === 'task_updated') {
-          handleTaskUpdated(message as SDKMessage & { type: 'system'; subtype: 'task_updated' }, sessionId, turnId, db);
-        } else if (sub === 'task_notification') {
-          handleTaskNotification(message as SDKMessage & { type: 'system'; subtype: 'task_notification' }, sessionId, turnId, entry, db);
-        } else if (sub === 'background_tasks_changed') {
-          handleBackgroundTasksChanged(message as SDKMessage & { type: 'system'; subtype: 'background_tasks_changed' }, sessionId);
-        }
-      }
-      break;
-    }
-
-    case 'assistant': {
-      handleAssistantMessage(message, sessionId, turnId, db);
-      break;
-    }
-
-    case 'user': {
-      handleUserMessage(message, sessionId, turnId, db);
-      break;
-    }
-
-    case 'stream_event': {
-      handleStreamEvent(message, sessionId, turnId);
-      break;
-    }
-
-    case 'result': {
-      handleResultMessage(message, sessionId, turnId, entry, db);
-      break;
-    }
-
-    default:
-      break;
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Item / message handlers (unchanged from one-shot mode)
-// ---------------------------------------------------------------------------
-
-/** Item types produced from a tool_use block — they start `in_progress` and only
- *  complete when the matching tool_result arrives (handled in handleUserMessage). */
-const TOOL_CALL_TYPES = new Set(['command_execution', 'file_change', 'mcp_tool_call']);
-
-/** Handle SDKAssistantMessage — map content blocks to items.
- *  Text/thinking blocks are complete on arrival; tool_use blocks are in_progress
- *  until their tool_result is delivered by a later SDKUserMessage. */
-function handleAssistantMessage(
-  message: SDKMessage & { type: 'assistant' },
-  sessionId: string,
-  turnId: string,
-  db: Database.Database,
-): void {
-  const messageId = message.uuid;
-  const parentToolUseId = (message as { parent_tool_use_id?: string | null }).parent_tool_use_id ?? null;
-
-  // Subagent assistant message — don't create items in the parent transcript.
-  // Subagent progress is shown via background_task items (task_started/progress/notification).
-  // t3code approach: early return, only update external_turn_id for session forking.
-  if (parentToolUseId) {
-    const thinkingTexts = thinkingAccumulator.get(messageId);
-    if (thinkingTexts) thinkingAccumulator.delete(messageId);
-    const nowExt = new Date().toISOString();
-    db.prepare('UPDATE turns SET external_turn_id = ?, updated_at = ? WHERE id = ?').run(messageId, nowExt, turnId);
-    return;
-  }
-
-  // Main agent — normal handling
-  const content = message.message.content;
-  const anthropicMsgId = message.message?.id ?? messageId;
-  const thinkingTexts = thinkingAccumulator.get(messageId);
-  const descriptors = mapAssistantContent(content, messageId, thinkingTexts);
-  // Override externalId for agent_message items to match the streaming itemId
-  // (Anthropic message ID captured from message_start event, not the per-event SDK uuid).
-  for (const desc of descriptors) {
-    if (desc.type === 'agent_message') desc.externalId = anthropicMsgId;
-  }
-  if (thinkingTexts) thinkingAccumulator.delete(messageId);
-  streamingMessageIds.delete(turnId);
-
-  for (const desc of descriptors) {
-    const isToolCall = TOOL_CALL_TYPES.has(desc.type);
-    const status: ItemStatus = isToolCall ? 'in_progress' : 'completed';
-    const broadcastEvent = isToolCall ? 'item:started' : 'item:completed';
-    upsertItem(db, desc, sessionId, turnId, status, broadcastEvent);
-
-    // Update turn-level fields only for completed content blocks from the main agent
-    if (!isToolCall) {
-      const now = new Date().toISOString();
-      if (desc.type === 'agent_message') {
-        const text = (desc.data as { text: string }).text;
-        db.prepare('UPDATE turns SET agent_response = ?, updated_at = ? WHERE id = ?').run(text, now, turnId);
-      }
-      if (desc.type === 'reasoning') {
-        const text = (desc.data as { text: string }).text;
-        if (text) {
-          db.prepare('UPDATE turns SET thoughts = ?, updated_at = ? WHERE id = ?').run(text, now, turnId);
-        }
-      }
-    }
-  }
-
-  // Store the SDK assistant message UUID as external_turn_id — used as upToMessageId
-  // by forkSession() when branching from this turn.
-  const nowExt = new Date().toISOString();
-  db.prepare('UPDATE turns SET external_turn_id = ?, updated_at = ? WHERE id = ?').run(messageId, nowExt, turnId);
-}
-
-/** Handle SDKUserMessage — tool_result blocks carry the output of a prior tool_use.
- *  Match each tool_result to the existing item by external_item_id (tool_use_id),
- *  apply the result to the item's data, and mark it completed/failed. */
-function handleUserMessage(
-  message: SDKMessage & { type: 'user' },
-  sessionId: string,
-  turnId: string,
-  db: Database.Database,
-): void {
-  const parentToolUseId = (message as { parent_tool_use_id?: string | null }).parent_tool_use_id ?? null;
-
-  // Subagent tool results — skip entirely. The matching tool_use item was never
-  // created (handleAssistantMessage early-returns for subagent messages), so
-  // there's nothing to update.
-  if (parentToolUseId) return;
-
-  const content = message.message.content;
-  if (!Array.isArray(content)) return;
-
-  for (const block of content) {
-    if (typeof block !== 'object' || block === null) continue;
-    const b = block as { type?: string; tool_use_id?: string; is_error?: boolean; content?: unknown };
-    if (b.type !== 'tool_result' || !b.tool_use_id) continue;
-
-    const toolUseId = b.tool_use_id;
-    const isError = !!b.is_error;
-
-    // Find the item created from the matching tool_use block.
-    const row = db
-      .prepare('SELECT type, data FROM items WHERE external_item_id = ? AND turn_id = ?')
-      .get(toolUseId, turnId) as { type: string; data: string | null } | undefined;
-    if (!row) continue;
-
-    const existing = row.data ? (JSON.parse(row.data) as Record<string, unknown>) : {};
-    const updatedData = applyToolResult(row.type, existing, b as ToolResultLike, message.tool_use_result, isError);
-
-    upsertItem(
-      db,
-      { type: row.type, data: updatedData, externalId: toolUseId },
-      sessionId,
-      turnId,
-      isError ? 'failed' : 'completed',
-      'item:completed',
-    );
-  }
-}
-function handleStreamEvent(
-  message: SDKMessage & { type: 'stream_event' },
-  sessionId: string,
-  turnId: string,
-): void {
-  const rawEvent = message.event as {
-    type: string;
-    message?: { id: string };
-    content_block?: { type: string; id?: string };
-  };
-
-  // t3code approach: SDK already provides parent_tool_use_id on subagent stream events.
-  // If this stream event belongs to a subagent, drop text/thinking deltas so they
-  // don't leak into the main session's agent_response.
-  const parentToolUseId = (message as { parent_tool_use_id?: string | null }).parent_tool_use_id ?? null;
-
-  // Capture the Anthropic message ID from message_start events (stable across all stream
-  // events for one assistant message, unlike SDKPartialAssistantMessage.uuid which is unique per event).
-  // Skip for subagent streams — we don't want to overwrite the main agent's streamingMessageId.
-  if (rawEvent.type === 'message_start' && rawEvent.message?.id && !parentToolUseId) {
-    streamingMessageIds.set(turnId, rawEvent.message.id);
-  }
-
-  const delta = mapPartialDelta(message.event);
-  if (!delta) return;
-
-  // Drop subagent text/thinking deltas — they must not write into the parent transcript.
-  if (parentToolUseId) return;
-
-  // Broadcast text deltas to frontend — use the stable Anthropic message ID as itemId
-  // so the frontend accumulates all deltas into one item.
-  if (delta.kind === 'text') {
-    const msgId = streamingMessageIds.get(turnId) ?? `stream-text-${turnId}`;
-    broadcast('item:delta', {
-      sessionId,
-      turnId,
-      itemId: msgId,
-      delta: delta.text,
-    });
-  }
-  // Accumulate thinking_delta text for the final assistant message (which has signed-empty thinking).
-  if (delta.kind === 'thinking') {
-    let msgMap = thinkingAccumulator.get(message.uuid);
-    if (!msgMap) {
-      msgMap = new Map();
-      thinkingAccumulator.set(message.uuid, msgMap);
-    }
-    const existing = msgMap.get(delta.index) ?? '';
-    msgMap.set(delta.index, existing + delta.text);
-  }
-}
-
-/** Handle SDKCompactBoundaryMessage — context was compacted.
- *  Insert a `context_compaction` item so the UI can render a "Context compacted" row. */
-function handleCompactBoundary(
-  message: SDKMessage & { type: 'system'; subtype: 'compact_boundary' },
-  sessionId: string,
-  turnId: string,
-  db: Database.Database,
-): void {
-  const meta = (message.compact_metadata ?? {}) as {
-    trigger?: string;
-    pre_tokens?: number;
-    post_tokens?: number;
-  };
-  const externalId = `compact-${message.uuid ?? Date.now()}`;
-  upsertItem(
-    db,
-    {
-      type: 'context_compaction',
-      data: {
-        trigger: meta.trigger ?? 'auto',
-        pre_tokens: meta.pre_tokens ?? 0,
-        post_tokens: meta.post_tokens ?? 0,
-      },
-      externalId,
-    },
-    sessionId,
-    turnId,
-    'completed',
-    'item:completed',
-  );
-}
-
-/** Construct the expected Monitor output file path for a given task.
- *
- *  Monitor (task_type=local_bash) writes stdout to a file at a predictable path:
- *    {tmpdir}/claude-{uid}/{encoded-cwd}/{claude-session-id}/tasks/{task_id}.output
- *
- *  The SDK only exposes `output_file` on `task_notification` (not on `task_started`
- *  or `task_progress`), so we construct the path ourselves to read live output
- *  during execution.  Returns empty string if the Claude session ID is not yet
- *  known (entry.sessionId is set on the first `system/init` message). */
-function constructMonitorOutputPath(entry: ClaudeSessionEntry, taskId: string): string {
-  if (!entry.sessionId) return '';
-  const uid = typeof process.getuid === 'function' ? process.getuid() : 0;
-  const encodedCwd = entry.cwd.replace(/\//g, '-');
-  return join(tmpdir(), `claude-${uid}`, encodedCwd, entry.sessionId, 'tasks', `${taskId}.output`);
-}
-
-/** Handle SDKTaskStartedMessage — a background task (Monitor or subagent) started.
- *  Insert a `background_task` item so the UI can show the task lifecycle. */
-function handleTaskStarted(
-  message: SDKMessage & { type: 'system'; subtype: 'task_started' },
-  sessionId: string,
-  turnId: string,
-  entry: ClaudeSessionEntry,
-  db: Database.Database,
-): void {
-  const m = message as unknown as {
-    task_id: string;
-    description: string;
-    task_type?: string;
-    subagent_type?: string;
-    prompt?: string;
-    skip_transcript?: boolean;
-  };
-  // Respect skip_transcript — ambient tasks should not appear in the inline transcript.
-  if (m.skip_transcript) return;
-
-  // Construct the Monitor output file path for local_bash tasks so we can read
-  // live output on task_progress (the SDK only exposes output_file on task_notification).
-  const isMonitor = m.task_type === 'local_bash';
-  const outputFile = isMonitor ? constructMonitorOutputPath(entry, m.task_id) : null;
-
-  upsertItem(
-    db,
-    {
-      type: 'background_task',
-      data: {
-        task_id: m.task_id,
-        description: m.description,
-        task_type: m.task_type ?? 'unknown',
-        subagent_type: m.subagent_type ?? null,
-        prompt: m.prompt ?? null,
-        status: 'running',
-        summary: null,
-        output_file: outputFile,
-        output: '',
-        token_count: null,
-        last_tool_name: null,
-      },
-      externalId: m.task_id,
-    },
-    sessionId,
-    turnId,
-    'in_progress',
-    'item:started',
-  );
-}
-
-/** Handle SDKTaskProgressMessage — update the background_task item with progress info. */
-function handleTaskProgress(
-  message: SDKMessage & { type: 'system'; subtype: 'task_progress' },
-  sessionId: string,
-  turnId: string,
-  entry: ClaudeSessionEntry,
-  db: Database.Database,
-): void {
-  const m = message as unknown as {
-    task_id: string;
-    description: string;
-    subagent_type?: string;
-    last_tool_name?: string;
-    summary?: string;
-    usage?: { total_tokens: number; tool_uses: number; duration_ms: number };
-  };
-  const row = db
-    .prepare('SELECT data FROM items WHERE external_item_id = ? AND turn_id = ?')
-    .get(m.task_id, turnId) as { data: string | null } | undefined;
-  if (!row) return;
-
-  const existing = row.data ? (JSON.parse(row.data) as Record<string, unknown>) : {};
-
-  // Read live Monitor output — only for local_bash tasks (subagent outputs are
-  // JSONL transcripts, too large and not meant for display).
-  let output = (existing.output as string) ?? '';
-  const taskType = (existing.task_type as string) ?? 'unknown';
-  if (taskType === 'local_bash') {
-    const outputPath = (existing.output_file as string) || constructMonitorOutputPath(entry, m.task_id);
-    if (outputPath) {
-      try {
-        output = readFileSync(outputPath, 'utf-8');
-      } catch {
-        // File may not exist yet or may be temporarily unavailable — keep previous output
-      }
-    }
-  }
-
-  const updatedData = {
-    ...existing,
-    description: m.description,
-    subagent_type: m.subagent_type ?? existing.subagent_type ?? null,
-    summary: m.summary ?? existing.summary ?? null,
-    last_tool_name: m.last_tool_name ?? null,
-    token_count: m.usage?.total_tokens ?? existing.token_count ?? null,
-    output,
-  };
-
-  upsertItem(
-    db,
-    { type: 'background_task', data: updatedData, externalId: m.task_id },
-    sessionId,
-    turnId,
-    'in_progress',
-    'item:updated',
-  );
-}
-
-/** Handle SDKTaskUpdatedMessage — patch the background_task item's status. */
-function handleTaskUpdated(
-  message: SDKMessage & { type: 'system'; subtype: 'task_updated' },
-  sessionId: string,
-  turnId: string,
-  db: Database.Database,
-): void {
-  const m = message as unknown as {
-    task_id: string;
-    patch: { status?: string; description?: string; error?: string; is_backgrounded?: boolean };
-  };
-  const row = db
-    .prepare('SELECT data FROM items WHERE external_item_id = ? AND turn_id = ?')
-    .get(m.task_id, turnId) as { data: string | null } | undefined;
-  if (!row) return;
-
-  const existing = row.data ? (JSON.parse(row.data) as Record<string, unknown>) : {};
-  const updatedData = {
-    ...existing,
-    status: m.patch.status ?? existing.status,
-    description: m.patch.description ?? existing.description,
-    error: m.patch.error ?? existing.error ?? null,
-  };
-
-  upsertItem(
-    db,
-    { type: 'background_task', data: updatedData, externalId: m.task_id },
-    sessionId,
-    turnId,
-    'in_progress',
-    'item:updated',
-  );
-}
-
-/** Handle SDKTaskNotificationMessage — the background task completed/failed/stopped. */
-function handleTaskNotification(
-  message: SDKMessage & { type: 'system'; subtype: 'task_notification' },
-  sessionId: string,
-  turnId: string,
-  entry: ClaudeSessionEntry,
-  db: Database.Database,
-): void {
-  const m = message as unknown as {
-    task_id: string;
-    status: 'completed' | 'failed' | 'stopped';
-    summary: string;
-    output_file: string;
-    usage?: { total_tokens: number; tool_uses: number; duration_ms: number };
-  };
-  const row = db
-    .prepare('SELECT data FROM items WHERE external_item_id = ? AND turn_id = ?')
-    .get(m.task_id, turnId) as { data: string | null } | undefined;
-  if (!row) return;
-
-  const existing = row.data ? (JSON.parse(row.data) as Record<string, unknown>) : {};
-
-  // Determine the output file path — prefer the SDK-provided path, fall back to
-  // the constructed path (for cases where the SDK doesn't provide it).
-  const taskType = (existing.task_type as string) ?? 'unknown';
-  const sdkOutputFile = m.output_file || null;
-  const constructedPath = taskType === 'local_bash' ? constructMonitorOutputPath(entry, m.task_id) : '';
-  const outputPath = sdkOutputFile || constructedPath;
-
-  // Read the raw stdout output from the Monitor's output file.
-  let output = '';
-  if (outputPath) {
-    try {
-      output = readFileSync(outputPath, 'utf-8');
-    } catch {
-      // File may have been cleaned up or is inaccessible — leave output empty
-    }
-  }
-
-  const updatedData = {
-    ...existing,
-    status: m.status,
-    summary: m.summary,
-    output_file: outputPath,
-    output,
-    token_count: m.usage?.total_tokens ?? existing.token_count ?? null,
-  };
-
-  const itemStatus: ItemStatus = m.status === 'completed' ? 'completed' : 'failed';
-
-  upsertItem(
-    db,
-    { type: 'background_task', data: updatedData, externalId: m.task_id },
-    sessionId,
-    turnId,
-    itemStatus,
-    'item:completed',
-  );
-}
-
-/** Handle SDKBackgroundTasksChangedMessage — broadcast the full live task list.
- *  REPLACE semantics: frontend replaces its entire background task set. */
-function handleBackgroundTasksChanged(
-  message: SDKMessage & { type: 'system'; subtype: 'background_tasks_changed' },
-  sessionId: string,
-): void {
-  const m = message as unknown as {
-    tasks: Array<{ task_id: string; task_type: string; description: string }>;
-  };
-  broadcast('background_tasks', { sessionId, tasks: m.tasks ?? [] });
-}
-/** Handle SDKResultMessage — accumulate usage across multi-result turns (Monitor).
- *  Does NOT complete the turn on intermediate results — the turn completes when
- *  the next user message is pushed (in startTurn) or when the PromptQueue is
- *  closed (in the message loop's generator-end block). Only error results abort early. */
-export async function handleResultMessage(
-  message: SDKMessage & { type: 'result' },
-  sessionId: string,
-  turnId: string,
-  entry: ClaudeSessionEntry,
-  db: Database.Database,
-): Promise<void> {  // Subagent result — skip entirely. Prevents subagent token/context data from
-  // overwriting the main session's token_usage and contextUsage.
-  // SDKResultSuccess doesn't declare parent_tool_use_id in its type, but the SDK
-  // may set it at runtime (same pattern as handleAssistantMessage/handleUserMessage).
-  const parentToolUseId = (message as { parent_tool_use_id?: string | null }).parent_tool_use_id ?? null;
-  if (parentToolUseId) return;
-
-  if (message.subtype === 'success') {
-    // Update token usage and complete the turn immediately.
-    // The SDK emits exactly one result/success per turn — this is the turn-complete signal.
-    // The CLI process stays alive (PromptQueue not closed) so Monitor background tasks survive.
-    // entry.turnId is NOT set to null — Monitor-triggered internal turn messages still attach
-    // to this turn via entry.turnId. Multiple completeTurn calls are idempotent (status check).
-    const usage = mapUsage(message.usage);
-    const now = new Date().toISOString();
-    db.prepare('UPDATE turns SET token_usage = ?, updated_at = ? WHERE id = ?').run(
-      JSON.stringify(usage), now, turnId,
-    );
-    broadcast('turn:tokenUsage', { sessionId, turnId, usage });
-
-    // Context-window usage: use the SDK's own /context computation (Query.getContextUsage),
-    // NOT the accumulated result.usage input/cache sum. The hand formula double-counts /
-    // accumulates in streaming-input mode (e.g. shows 800K while /context shows the real
-    // 130K). getContextUsage returns the same structured data as the /context command —
-    // the authoritative current in-window fill, computed locally by the CLI.
-    try {
-      const ctx = await entry.query.getContextUsage();
-      if (ctx.totalTokens > 0 && ctx.maxTokens > 0) {
-        const contextUsage: ContextUsage = {
-          totalTokens: ctx.totalTokens,
-          contextWindow: ctx.maxTokens,
-          percentage: Math.round(ctx.percentage),
-        };
-        broadcast('turn:contextUsage', { sessionId, ...contextUsage });
-        // Persist so the status-bar counter survives page reload.
-        const cuNow = new Date().toISOString();
-        db.prepare('UPDATE sessions SET context_usage = ?, updated_at = ? WHERE id = ?').run(
-          JSON.stringify(contextUsage), cuNow, sessionId,
-        );
-      }
-    } catch {
-      // getContextUsage unavailable (older CLI) or failed — leave contextUsage unchanged.
-    }
-
-    completeTurn(db, sessionId, turnId, usage);
-  } else {
-    // Error result — abort the turn immediately.
-    const errorMsg = message.errors?.join('; ') ?? 'Claude turn failed';
-    const now = new Date().toISOString();
-    db.prepare('UPDATE turns SET status = ?, error = ?, updated_at = ? WHERE id = ?').run('failed', errorMsg, now, turnId);
-    setSessionStatus(db, sessionId, 0, 'failed', now);
-    broadcast('turn:failed', { sessionId, turnId, error: errorMsg });
-  }
-}
-
-// ---------------------------------------------------------------------------
-// completeTurn / upsertItem
-// ---------------------------------------------------------------------------
-
-/** Complete a turn — set status, broadcast turn:completed. */
-function completeTurn(db: Database.Database, sessionId: string, turnId: string, usage: TokenUsage | null): void {
-  const now = new Date().toISOString();
-  if (usage) {
-    db.prepare('UPDATE turns SET status = ?, token_usage = ?, updated_at = ? WHERE id = ?').run(
-      'completed', JSON.stringify(usage), now, turnId,
-    );
-    broadcast('turn:completed', { sessionId, turnId, usage, hasUnreviewed: true });
-  } else {
-    db.prepare('UPDATE turns SET status = ?, updated_at = ? WHERE id = ?').run('completed', now, turnId);
-    broadcast('turn:completed', { sessionId, turnId, hasUnreviewed: true });
-  }
-  setSessionStatus(db, sessionId, 0, 'active', now, true);
-  syncThreadTitle(sessionId);
-}
-
-/** Insert or update an item in the DB and broadcast. */
-function upsertItem(
-  db: Database.Database,
-  desc: ItemDescriptor,
-  sessionId: string,
-  turnId: string,
-  status: ItemStatus,
-  broadcastEvent: string,
-): void {
-  const now = new Date().toISOString();
-
-  // Try to update existing row
-  const result = db
-    .prepare('UPDATE items SET data = ?, status = ?, updated_at = ? WHERE external_item_id = ? AND turn_id = ?')
-    .run(JSON.stringify(desc.data), status, now, desc.externalId, turnId);
-
-  let itemId: string;
-  let createdAt: string;
-
-  if (result.changes === 0) {
-    itemId = uuidv4();
-    createdAt = now;
-    db.prepare(
-      'INSERT INTO items (id, turn_id, external_item_id, type, data, status, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)',
-    ).run(itemId, turnId, desc.externalId, desc.type as Item['type'], JSON.stringify(desc.data), status, now, now);
-  } else {
-    const row = db
-      .prepare('SELECT id, created_at FROM items WHERE external_item_id = ? AND turn_id = ?')
-      .get(desc.externalId, turnId) as { id: string; created_at: string };
-    itemId = row.id;
-    createdAt = row.created_at;
-  }
-
-  const wsItem: Item = {
-    id: itemId,
-    turn_id: turnId,
-    external_item_id: desc.externalId,
-    type: desc.type as Item['type'],
-    data: desc.data,
-    status,
-    created_at: createdAt,
-    updated_at: now,
-  };
-
-  broadcast(broadcastEvent, { sessionId, turnId, item: wsItem });
-}
-
-// ---------------------------------------------------------------------------
-// interruptTurn
-// ---------------------------------------------------------------------------
-
-/** Cancel a running turn by session ID. Returns true if a turn was cancelled.
- *
- *  Calls `query.interrupt()` to abort the current generation, but does NOT
- *  close the query or the PromptQueue — the CLI process stays alive so the
- *  user can send the next message without spawning a new process. */
-async function interruptTurn(sessionId: string): Promise<boolean> {
-  // Check main entry first, then thread entries
-  let entry = sessionMap.get(sessionId);
-  if (!entry || !entry.turnId) {
-    // Search thread entries for this session
-    for (const [key, threadEntry] of sessionMap) {
-      if (key.startsWith(`${sessionId}:thread:`) && threadEntry.turnId) {
-        entry = threadEntry;
-        break;
-      }
-    }
-  }
-  if (!entry || !entry.turnId) return false;
-
-  try {
-    await entry.query.interrupt();
-
-    const db = getDb();
-    const now = new Date().toISOString();
-    db.prepare('UPDATE turns SET status = ?, updated_at = ? WHERE id = ?').run('aborted', now, entry.turnId);
-    setSessionStatus(db, sessionId, 0, 'active', now);
-    broadcast('turn:cancelled', { sessionId, turnId: entry.turnId });
-
-    streamingMessageIds.delete(entry.turnId);
-    entry.turnId = null;
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-// ---------------------------------------------------------------------------
-// clearThread / clearAllThreads
-// ---------------------------------------------------------------------------
-
-/** Remove a session's streaming query from the in-memory map.
- *
- *  Closes the PromptQueue (signals end-of-iteration → CLI exits gracefully)
- *  and closes the Query object (forceful cleanup).  Used after rewind, branch,
- *  provider change, or restore — the next startTurn will create a fresh query. */
-function clearThread(sessionId: string): void {
-  // Main entry
-  const entry = sessionMap.get(sessionId);
-  if (entry) {
-    entry.promptQueue.close();
-    entry.query.close();
-    if (entry.turnId) {
-      streamingMessageIds.delete(entry.turnId);
-    }
-    sessionMap.delete(sessionId);
-  }
-  // All thread entries for this session
-  for (const [key, threadEntry] of sessionMap) {
-    if (key.startsWith(`${sessionId}:thread:`)) {
-      threadEntry.promptQueue.close();
-      threadEntry.query.close();
-      if (threadEntry.turnId) {
-        streamingMessageIds.delete(threadEntry.turnId);
-      }
-      sessionMap.delete(key);
-    }
-  }
-}
-
-/** Remove a single thread's branched session entry. Used when a thread is deleted. */
-function clearThreadBranch(sessionId: string, threadId: string): void {
-  const key = `${sessionId}:thread:${threadId}`;
-  const entry = sessionMap.get(key);
-  if (entry) {
-    entry.promptQueue.close();
-    entry.query.close();
-    if (entry.turnId) {
-      streamingMessageIds.delete(entry.turnId);
-    }
-    sessionMap.delete(key);
-  }
-}
-
-/** Clear all session entries. Used in test cleanup. */
-export function clearAllThreads(): void {
-  for (const [, entry] of sessionMap) {
-    entry.promptQueue.close();
-    entry.query.close();
-  }
-  sessionMap.clear();
-  titleGenerating.clear();
-}
-
-// ---------------------------------------------------------------------------
-// setModel — change model mid-session without restarting the CLI
-// ---------------------------------------------------------------------------
-
-/** Change the model for a running session. Only works in streaming-input mode.
- *  If the session hasn't started yet (no entry in sessionMap), the new model
- *  will be picked up when ensureSessionStarted creates the query. */
-async function setModel(sessionId: string, model: string): Promise<void> {
-  const entry = sessionMap.get(sessionId);
-  if (!entry) return; // session not started — model will be read from DB on next startTurn
-  await entry.query.setModel(model);
-}
-
-// ---------------------------------------------------------------------------
-// stopTask — kill a background task (Monitor/subagent) by task ID
-// ---------------------------------------------------------------------------
-
-/** Stop a running background task by task ID. Emits a task_notification with
- *  status 'stopped'. Enables a future "Kill Monitor" button in the UI. */
-async function stopTask(sessionId: string, taskId: string): Promise<void> {
-  const entry = sessionMap.get(sessionId);
-  if (!entry) return;
-  await entry.query.stopTask(taskId);
-}
-
-// ---------------------------------------------------------------------------
-// getModels / getCommands
-// ---------------------------------------------------------------------------
-
-/** Fetch available models from the Claude SDK and map to AgentPane ModelInfo[]. */
-async function getModels(): Promise<ModelInfo[]> {
-  if (cachedModels) return cachedModels;
-
-  try {
-    const q = query({
-      prompt: '',
-      options: {
-        cwd: process.cwd(),
-        permissionMode: 'bypassPermissions',
-        allowDangerouslySkipPermissions: true,
-      },
-    });
-
-    const initResult = await q.initializationResult();
-    q.close();
-
-    // Cache provider-native slash commands alongside models (single init call).
-    cachedCommands = mapSdkCommands(initResult.commands ?? []);
-
-    cachedModels = (initResult.models ?? []).map((m: SdkModelInfo) => ({
-      slug: m.value,
-      displayName: m.displayName,
-      description: m.description,
-      defaultReasoning: m.supportedEffortLevels?.[0] ?? 'medium',
-      reasoningLevels: (m.supportedEffortLevels ?? []).map((e) => ({
-        effort: e,
-        label: EFFORT_LABELS[e] ?? e,
-      })),
-    }));
-
-    return cachedModels;
-  } catch {
-    return [];
-  }
-}
-
-/** Fetch provider-native slash commands (cached from the models init call). */
-async function getCommands(): Promise<ProviderSlashCommand[]> {
-  if (cachedCommands) return cachedCommands;
-  // Trigger an init by fetching models (which caches commands as a side effect).
-  await getModels();
-  return cachedCommands ?? [];
-}
-
-/** Map SDK SlashCommand[] to the shared ProviderSlashCommand shape. */
-function mapSdkCommands(commands: SdkSlashCommand[]): ProviderSlashCommand[] {
-  return commands.map((c) => ({
-    name: c.name,
-    description: c.description,
-    ...(c.argumentHint ? { argumentHint: c.argumentHint } : {}),
-    ...(c.aliases?.length ? { aliases: c.aliases } : {}),
-  }));
-}
-
-// ---------------------------------------------------------------------------
-// shutdown
-// ---------------------------------------------------------------------------
-
-/** Graceful shutdown — close all query instances. */
-async function shutdown(): Promise<void> {
-  clearAllThreads();
-}
-
-// ---------------------------------------------------------------------------
-// Title generation
-// ---------------------------------------------------------------------------
-
-/** Generate a title for the session using a throwaway Claude query. */
-function syncThreadTitle(sessionId: string): void {
-  const db = getDb();
-  const session = db.prepare('SELECT title FROM sessions WHERE id = ?').get(sessionId) as
-    | { title: string | null }
-    | undefined;
-  if (!session || session.title !== null) return;
-  if (titleGenerating.has(sessionId)) return;
-
-  const turn = db
-    .prepare('SELECT user_prompt, agent_response FROM turns WHERE session_id = ? ORDER BY created_at ASC LIMIT 1')
-    .get(sessionId) as { user_prompt: string; agent_response: string | null } | undefined;
-  if (!turn) return;
-
-  titleGenerating.add(sessionId);
-  generateTitleAsync(sessionId, turn.user_prompt, turn.agent_response).finally(() => {
-    titleGenerating.delete(sessionId);
-  });
-}
-
-/** Create a throwaway Claude query, ask for a title, update the session. */
-async function generateTitleAsync(
-  sessionId: string,
-  userPrompt: string,
-  agentResponse: string | null,
-): Promise<void> {
-  let q: Query | null = null;
-  try {
-    const truncatedPrompt = userPrompt.slice(0, 500);
-    const truncatedResponse = (agentResponse ?? '').slice(0, 500);
-    const titlePrompt = `Generate a concise 3-5 word title for this conversation. Reply with only the title, nothing else.\n\nUser asked: "${truncatedPrompt}"\n\nAgent responded: "${truncatedResponse}"`;
-
-    q = query({
-      prompt: titlePrompt,
-      options: {
-        cwd: process.cwd(),
-        permissionMode: 'bypassPermissions',
-        allowDangerouslySkipPermissions: true,
-      },
-    });
-
-    let titleResponse = '';
-
-    for await (const message of q) {
-      if (message.type === 'assistant') {
-        for (const block of message.message.content) {
-          if (block.type === 'text') {
-            titleResponse += block.text;
-          }
-        }
-      }
-    }
-
-    const cleanTitle = titleResponse.trim().replace(/^["']|["']$/g, '').slice(0, 100);
-
-    if (cleanTitle) {
-      const db = getDb();
-      const now = new Date().toISOString();
-      db.prepare('UPDATE sessions SET title = ?, updated_at = ? WHERE id = ?').run(cleanTitle, now, sessionId);
-      broadcast('session:title', { sessionId, title: cleanTitle });
-    }
-  } catch {
-    // Silently skip on error — session keeps null title
-  } finally {
-    if (q) {
-      q.close();
-    }
-  }
-}
-
-// ---------------------------------------------------------------------------
-// forkSession
-// ---------------------------------------------------------------------------
-
-/** Fork the Claude session at a branch point using the SDK's forkSession().
- *  Copies the transcript up to the target turn's last assistant message,
- *  returning a new Claude session ID that can be resumed with full context. */
-async function forkClaudeSession(session: Session, targetTurn: Turn): Promise<string | null> {
-  if (!session.external_thread_id) return null;
-  try {
-    const result = await sdkForkSession(session.external_thread_id, {
-      dir: session.cwd ?? process.cwd(),
-      ...(targetTurn.external_turn_id ? { upToMessageId: targetTurn.external_turn_id } : {}),
-    });
-    return result.sessionId;
-  } catch (err) {
-    console.error('[claude] forkSession failed:', err);
-    return null;
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Provider export
-// ---------------------------------------------------------------------------
-
-/** Claude provider — implements RuntimeProvider interface. */
-export const claudeProvider: RuntimeProvider = {
-  startTurn,
-  interruptTurn,
-  clearThread,
-  clearThreadBranch,
-  clearAllThreads,
-  getModels,
-  getCommands,
-  forkSession: forkClaudeSession,
-  setModel,
-  stopTask,
-  shutdown,
-};