repoburg 1.3.196 → 1.3.197

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

@@ -1,8 +1,10 @@
 /**
  * Claude provider — implements the RuntimeProvider interface.
  *
- * Uses `@anthropic-ai/claude-agent-sdk` `query()` function directly.
- * The SDK spawns the Claude CLI internally — no manual subprocess.
+ * 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,
@@ -11,18 +13,81 @@
  * Frontend needs zero changes.
  */
 
-import { query } from '@anthropic-ai/claude-agent-sdk';
-import type { SDKMessage, Options, ModelInfo as SdkModelInfo, Query } from '@anthropic-ai/claude-agent-sdk';
-import type { ModelInfo, TokenUsage } from '@agentpane/shared';
+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, type ItemDescriptor } from './claude-message-mapper.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>();
 
@@ -32,8 +97,26 @@ 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 (same pattern as codex-provider)
+// DB helpers
 // ---------------------------------------------------------------------------
 
 /** Update the running state and status of a session. */
@@ -57,20 +140,28 @@ function setSessionStatus(
 }
 
 // ---------------------------------------------------------------------------
-// startTurn
+// ensureSessionStarted — create streaming-input query for a session
 // ---------------------------------------------------------------------------
 
-/** Start a Claude turn. Fire-and-forget — streams events via WS. */
-async function startTurn(session: Session, turn: Turn): Promise<void> {
+/** 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 now = new Date().toISOString();
+  const key = mapKey ?? session.id;
+  const resumeId = resumeSessionId ?? session.external_thread_id ?? undefined;
 
-  // Update turn + session status
-  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 });
-
-  // Build options
+  // 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,
@@ -79,49 +170,204 @@ async function startTurn(session: Session, turn: Turn): Promise<void> {
     includePartialMessages: true,
     ...(process.env.CLAUDE_BIN ? { pathToClaudeCodeExecutable: process.env.CLAUDE_BIN } : {}),
     ...(session.model_reasoning_effort ? { effort: session.model_reasoning_effort as Options['effort'] } : {}),
-    ...(session.external_thread_id ? { resume: session.external_thread_id } : {}),
+    ...(resumeId ? { resume: resumeId } : {}),
   };
 
-  let q;
-  try {
-    q = query({ prompt: turn.user_prompt, options });
-  } 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;
-  }
+  const promptQueue = new PromptQueue();
+  const q: Query = query({ prompt: promptQueue, options });
 
-  const entry: ClaudeSessionEntry = { query: q, sessionId: null, turnId: turn.id };
-  sessionMap.set(session.id, entry);
+  const entry: ClaudeSessionEntry = {
+    query: q,
+    sessionId: null,
+    turnId: null,
+    cwd: session.cwd ?? process.cwd(),
+    promptQueue,
+    messageLoop: null,
+  };
+  sessionMap.set(key, entry);
 
-  // Iterate the async generator
-  try {
-    for await (const message of q) {
-      await handleMessage(message, session.id, turn.id, entry, db);
+  // 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();
 
-    // If turn is still running after generator ends, mark as completed
-    const currentTurn = db.prepare('SELECT status FROM turns WHERE id = ?').get(turn.id) as { status: string } | undefined;
-    if (currentTurn && currentTurn.status === 'running') {
-      completeTurn(db, session.id, turn.id, null);
+  // 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 forked session ID (stored in discussion_threads)
+        const thread = db
+          .prepare('SELECT external_thread_id FROM discussion_threads WHERE id = ?')
+          .get(turn.thread_id) as { external_thread_id: string | null } | undefined;
+        const resumeId = thread?.external_thread_id ?? session.external_thread_id ?? undefined;
+        entry = await ensureSessionStarted(session, mapKey, resumeId);
+      } 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;
     }
-  } catch (err) {
-    const errMsg = (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 });
-  } finally {
-    // Remove from session map if turn is done (not just idle)
-    if (entry.turnId === null) {
-      sessionMap.delete(session.id);
+  }
+
+  // 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. */
 async function handleMessage(
   message: SDKMessage,
@@ -132,13 +378,28 @@ async function handleMessage(
 ): Promise<void> {
   switch (message.type) {
     case 'system': {
-      if ('subtype' in message && message.subtype === 'init') {
-        // Save Claude session ID for resume
-        entry.sessionId = message.session_id;
-        const now = new Date().toISOString();
-        db.prepare('UPDATE sessions SET external_thread_id = ?, updated_at = ? WHERE id = ?').run(
-          message.session_id, now, sessionId,
-        );
+      if ('subtype' in message) {
+        const sub = (message as { subtype: string }).subtype;
+        if (sub === 'init') {
+          // Save Claude session ID for resume (idempotent — Monitor triggers multiple inits)
+          entry.sessionId = (message as { session_id: string }).session_id;
+          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;
     }
@@ -148,6 +409,11 @@ async function handleMessage(
       break;
     }
 
+    case 'user': {
+      handleUserMessage(message, sessionId, turnId, db);
+      break;
+    }
+
     case 'stream_event': {
       handleStreamEvent(message, sessionId, turnId);
       break;
@@ -158,85 +424,530 @@ async function handleMessage(
       break;
     }
 
-    // Skip user messages — tool outputs not captured in initial implementation.
     default:
       break;
   }
 }
 
-/** Handle SDKAssistantMessage — map content blocks to items. */
+// ---------------------------------------------------------------------------
+// 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 content = message.message.content;
   const messageId = message.uuid;
-  const descriptors = mapAssistantContent(content, messageId);
+  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) {
-    upsertItem(db, desc, sessionId, turnId, 'completed', 'item:completed');
+    if (desc.type === 'agent_message') desc.externalId = anthropicMsgId;
+  }
+  if (thinkingTexts) thinkingAccumulator.delete(messageId);
+  streamingMessageIds.delete(turnId);
 
-    // Update turn-level fields
-    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);
+  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 SDKPartialAssistantMessage — broadcast streaming deltas. */
+/** 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;
 
-  // Broadcast text deltas to frontend — no DB write per delta (performance).
+  // 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: message.uuid,
+      itemId: msgId,
       delta: delta.text,
     });
   }
-  // thinking_delta not broadcast as item:delta — reasoning captured from complete thinking block.
+  // 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 SDKResultMessage — complete the turn. */
+/** 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. */
 function handleResultMessage(
   message: SDKMessage & { type: 'result' },
   sessionId: string,
   turnId: string,
   db: Database.Database,
 ): 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 });
+
+    // Extract context window usage from modelUsage (cumulative, includes contextWindow per model).
+    // Total context ≈ input_tokens + cache_read + cache_creation for this turn.
+    const result = message as SDKMessage & { type: 'result'; subtype: 'success' };
+    const modelUsage = result.modelUsage;
+
+    // Look up the main agent's model in modelUsage to get the correct contextWindow.
+    // modelUsage includes ALL models (main + subagents + sidechains), so taking
+    // Object.values()[0] may pick a subagent model with a different contextWindow.
+    const session = db.prepare('SELECT model FROM sessions WHERE id = ?').get(sessionId) as
+      | { model: string | null }
+      | undefined;
+    const sessionModel = session?.model ?? null;
+
+    let modelEntry = undefined;
+    if (modelUsage) {
+      if (sessionModel && modelUsage[sessionModel]) {
+        modelEntry = modelUsage[sessionModel];
+      } else {
+        // Fallback: find an entry whose canonicalModel matches, else first entry
+        modelEntry = Object.values(modelUsage).find(
+          (e) => sessionModel && e.canonicalModel === sessionModel,
+        ) ?? Object.values(modelUsage)[0];
+      }
+    }
+
+    if (modelEntry && modelEntry.contextWindow > 0) {
+      const totalTokens =
+        result.usage.input_tokens +
+        (result.usage.cache_read_input_tokens ?? 0) +
+        (result.usage.cache_creation_input_tokens ?? 0);
+
+      if (totalTokens > 0) {
+        const contextUsage: ContextUsage = {
+          totalTokens,
+          contextWindow: modelEntry.contextWindow,
+          percentage: Math.round((totalTokens / modelEntry.contextWindow) * 100),
+        };
+        broadcast('turn:contextUsage', { sessionId, ...contextUsage });
+      }
+    }
+
     completeTurn(db, sessionId, turnId, usage);
   } else {
-    // Error result
+    // 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 });
   }
-
-  // Generate title after turn completes
-  syncThreadTitle(sessionId);
 }
 
+// ---------------------------------------------------------------------------
+// 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();
@@ -250,6 +961,7 @@ function completeTurn(db: Database.Database, sessionId: string, turnId: string,
     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. */
@@ -303,9 +1015,23 @@ function upsertItem(
 // interruptTurn
 // ---------------------------------------------------------------------------
 
-/** Cancel a running turn by session ID. Returns true if a turn was cancelled. */
+/** 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> {
-  const entry = sessionMap.get(sessionId);
+  // 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 {
@@ -317,6 +1043,7 @@ async function interruptTurn(sessionId: string): Promise<boolean> {
     setSessionStatus(db, sessionId, 0, 'active', now);
     broadcast('turn:cancelled', { sessionId, turnId: entry.turnId });
 
+    streamingMessageIds.delete(entry.turnId);
     entry.turnId = null;
     return true;
   } catch {
@@ -328,18 +1055,53 @@ async function interruptTurn(sessionId: string): Promise<boolean> {
 // clearThread / clearAllThreads
 // ---------------------------------------------------------------------------
 
-/** Remove a session's Claude query from the in-memory map. */
+/** 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();
@@ -347,7 +1109,32 @@ export function clearAllThreads(): void {
 }
 
 // ---------------------------------------------------------------------------
-// getModels
+// 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[]. */
@@ -367,6 +1154,9 @@ async function getModels(): Promise<ModelInfo[]> {
     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,
@@ -384,6 +1174,24 @@ async function getModels(): Promise<ModelInfo[]> {
   }
 }
 
+/** 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
 // ---------------------------------------------------------------------------
@@ -467,6 +1275,27 @@ async function generateTitleAsync(
   }
 }
 
+// ---------------------------------------------------------------------------
+// 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
 // ---------------------------------------------------------------------------
@@ -476,7 +1305,12 @@ export const claudeProvider: RuntimeProvider = {
   startTurn,
   interruptTurn,
   clearThread,
+  clearThreadBranch,
   clearAllThreads,
   getModels,
+  getCommands,
+  forkSession: forkClaudeSession,
+  setModel,
+  stopTask,
   shutdown,
 };