repoburg 1.3.188 → 1.3.196

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

@@ -1,46 +1,156 @@
-import { Codex, type Thread, type ThreadEvent, type ThreadItem, type ThreadOptions } from '@openai/codex-sdk';
+import type { SessionRuntimeConfig, ModelInfo } from '@agentpane/shared';
 import { v4 as uuidv4 } from 'uuid';
-import Database from 'better-sqlite3';
-import { readFileSync, writeFileSync, unlinkSync } from 'node:fs';
+import type Database from 'better-sqlite3';
 import { getDb } from '../db/index.ts';
 import { broadcast } from '../ws/index.ts';
 import { mapItemData, getItemStatus } from './item-mapper.ts';
+import { AppServerClient } from './app-server-client.ts';
+import type {
+  ItemNotification,
+  TurnFailedNotification,
+  ThreadStartResult,
+  TurnStartResult,
+  AppServerItem,
+  AgentMessageDeltaNotification,
+  TokenUsageNotification,
+  ModelListResult,
+} from './app-server-types.ts';
+import { mapTokenUsage } from './app-server-types.ts';
+import { getSharedAppServer, closeSharedAppServer } from './shared-app-server.ts';
 import type { Session, Turn, Item, ItemStatus } from '../db/schema.ts';
+import type { RuntimeProvider } from '../providers/runtime-provider.ts';
 
-interface ThreadEntry {
-  codex: Codex;
-  thread: Thread;
-  abortController: AbortController | null;
+/** Per-session app-server client + thread state. */
+interface SessionEntry {
+  client: AppServerClient;
+  threadId: string;
+  turnId: string | null;
 }
 
-const threadMap = new Map<string, ThreadEntry>();
+const sessionMap = new Map<string, SessionEntry>();
+
+/** 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,
+    );
+  }
+}
 
-function getThreadOptions(session: Session): ThreadOptions {
-  return {
-    model: session.model ?? undefined,
-    workingDirectory: session.cwd ?? undefined,
-    sandboxMode: 'workspace-write',
-    approvalPolicy: 'never',
-    skipGitRepoCheck: true,
-  };
+/** Parse runtime_config JSON from the session row. Returns null on parse failure. */
+function parseRuntimeConfig(session: Session): SessionRuntimeConfig | null {
+  if (!session.runtime_config) return null;
+  try {
+    return JSON.parse(session.runtime_config) as SessionRuntimeConfig;
+  } catch {
+    return null;
+  }
 }
 
-function getOrCreateThread(session: Session): { codex: Codex; thread: Thread } {
-  const existing = threadMap.get(session.id);
-  if (existing) {
-    return { codex: existing.codex, thread: existing.thread };
+/** Map runtime config sandbox mode to app-server sandbox type string (kebab-case). */
+function sandboxType(config: SessionRuntimeConfig | null): 'read-only' | 'workspace-write' | 'danger-full-access' {
+  switch (config?.sandboxMode) {
+    case 'read-only':
+      return 'read-only';
+    case 'danger-full-access':
+      return 'danger-full-access';
+    default:
+      return 'workspace-write';
   }
+}
+
+/** Convert app-server camelCase item type to DB snake_case item type. */
+function normalizeItemType(type: string): string {
+  const map: Record<string, string> = {
+    agentMessage: 'agent_message',
+    userMessage: 'user_message',
+    agentReasoning: 'reasoning',
+    commandExecution: 'command_execution',
+    fileChange: 'file_change',
+    mcpToolCall: 'mcp_tool_call',
+    webSearch: 'web_search',
+    todoList: 'todo_list',
+    error: 'error',
+  };
+  return map[type] ?? type;
+}
+
+/** Check if an item type should be skipped (not stored in DB). */
+function shouldSkipItem(type: string): boolean {
+  return type === 'userMessage' || type === 'user_message';
+}
+
+/** Check if a reasoning item has empty content (app-server sends summary: [], content: []). */
+function isEmptyReasoning(item: AppServerItem): boolean {
+  const summary = Array.isArray(item.summary) ? item.summary : [];
+  const content = Array.isArray(item.content) ? item.content : [];
+  const text = item.text ?? '';
+  return summary.length === 0 && content.length === 0 && text.length === 0;
+}
+
+/** Create or resume a thread for the session via a per-session app-server client. */
+async function getOrCreateThread(session: Session): Promise<SessionEntry> {
+  const existing = sessionMap.get(session.id);
+  if (existing) return existing;
+
+  const cwd = session.cwd ?? process.cwd();
+  const client = new AppServerClient({ cwd });
+  await client.initialize();
 
-  const codex = new Codex();
-  let thread: Thread;
+  const config = parseRuntimeConfig(session);
+  const sandbox = sandboxType(config);
+
+  let threadId: string;
 
   if (session.external_thread_id) {
-    thread = codex.resumeThread(session.external_thread_id, getThreadOptions(session));
+    const result = await client.request<ThreadStartResult>('thread/resume', {
+      threadId: session.external_thread_id,
+      cwd,
+      approvalPolicy: 'never',
+      sandbox,
+      model: session.model ?? undefined,
+    });
+    threadId = result.thread.id;
   } else {
-    thread = codex.startThread(getThreadOptions(session));
+    const result = await client.request<ThreadStartResult>('thread/start', {
+      cwd,
+      approvalPolicy: 'never',
+      sandbox,
+      model: session.model ?? undefined,
+    });
+    threadId = result.thread.id;
+
+    // Save the thread ID to the database
+    const db = getDb();
+    const now = new Date().toISOString();
+    db.prepare('UPDATE sessions SET external_thread_id = ?, updated_at = ? WHERE id = ?').run(
+      threadId,
+      now,
+      session.id,
+    );
   }
 
-  return { codex, thread };
+  const entry: SessionEntry = { client, threadId, turnId: null };
+  sessionMap.set(session.id, entry);
+  return entry;
 }
 
 /** Start a Codex turn. Fire-and-forget — streams events via WS. */
@@ -48,316 +158,462 @@ export async function startTurn(session: Session, turn: Turn): Promise<void> {
   const db = getDb();
 
   // Phase 1: create or resume thread
-  let codex: Codex;
-  let thread: Thread;
-
+  let entry: SessionEntry;
   try {
-    const result = getOrCreateThread(session);
-    codex = result.codex;
-    thread = result.thread;
+    entry = await getOrCreateThread(session);
   } catch (err) {
-    const errMsg = `Failed to create Codex thread: ${(err as Error).message}`;
+    const errMsg = `Failed to create app-server thread: ${(err as Error).message}`;
     const now = new Date().toISOString();
-    db.prepare('UPDATE turns SET status = ?, error = ?, updated_at = ? WHERE id = ?')
-      .run('failed', errMsg, now, turn.id);
-    db.prepare('UPDATE sessions SET is_running = 0, status = ?, updated_at = ? WHERE id = ?')
-      .run('failed', now, session.id);
+    db.prepare('UPDATE turns SET status = ?, error = ?, updated_at = ? WHERE id = ?').run(
+      'failed',
+      errMsg,
+      now,
+      turn.id,
+    );
+    setSessionStatus(db, session.id, 0, 'failed', now);
     broadcast('turn:failed', { sessionId: session.id, turnId: turn.id, error: errMsg });
     return;
   }
 
-  // Phase 2: set up abort controller and update status
-  const abortController = new AbortController();
-  threadMap.set(session.id, { codex, thread, abortController });
-
+  // Phase 2: update status
+  entry.turnId = turn.id;
   const now = new Date().toISOString();
-  db.prepare('UPDATE turns SET status = ?, updated_at = ? WHERE id = ?')
-    .run('running', now, turn.id);
-  db.prepare('UPDATE sessions SET is_running = 1, status = ?, updated_at = ? WHERE id = ?')
-    .run('running', now, session.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 });
 
-  // Phase 3: run the turn and handle events
-  try {
-    const { events } = await thread.runStreamed(turn.user_prompt, { signal: abortController.signal });
+  // Phase 3: register notification handlers and send turn/start
+  const { client, threadId } = entry;
+  const config = parseRuntimeConfig(session);
+  const sandbox = sandboxType(config);
 
-    for await (const event of events) {
-      handleEvent(event, session.id, turn.id);
-    }
-  } catch (err) {
-    const isAbort = abortController.signal.aborted || (err as Error).name === 'AbortError';
-    const errMsg = (err as Error).message;
-    const now2 = new Date().toISOString();
+  // Flag to prevent duplicate handler execution after turn ends
+  let turnDone = false;
 
-    if (isAbort) {
-      db.prepare('UPDATE turns SET status = ?, updated_at = ? WHERE id = ?')
-        .run('aborted', now2, turn.id);
-      db.prepare('UPDATE sessions SET is_running = 0, status = ?, updated_at = ? WHERE id = ?')
-        .run('active', now2, session.id);
-      broadcast('turn:failed', { sessionId: session.id, turnId: turn.id, error: 'Turn cancelled by user' });
+  // Register handlers for this turn (scoped by threadId — one active turn per session)
+  const handleItemStarted = (params: unknown) => {
+    if (turnDone) return;
+    const p = params as ItemNotification;
+    if (p.threadId !== threadId) return;
+    handleItemEvent(p, session.id, turn.id, 'in_progress', 'item:started');
+  };
+  const handleItemUpdated = (params: unknown) => {
+    if (turnDone) return;
+    const p = params as ItemNotification;
+    if (p.threadId !== threadId) return;
+    handleItemEvent(p, session.id, turn.id, 'in_progress', 'item:updated');
+  };
+  const handleItemCompleted = (params: unknown) => {
+    if (turnDone) return;
+    const p = params as ItemNotification;
+    if (p.threadId !== threadId) return;
+    const status = getItemStatus(p.item);
+    handleItemEvent(p, session.id, turn.id, status, 'item:completed');
+  };
+  const handleTurnCompleted = (params: unknown) => {
+    if (turnDone) return;
+    const p = params as { threadId: string; turn?: { id: string; status: string }; usage?: unknown };
+    if (p.threadId !== threadId) return;
+    turnDone = true;
+    const db = getDb();
+    const now = new Date().toISOString();
+    // Token usage may be in params (mock) or already saved via thread/tokenUsage/updated (real app-server).
+    // When p.usage is undefined, preserve existing token_usage (set by thread/tokenUsage/updated handler).
+    if (p.usage !== undefined) {
+      db.prepare('UPDATE turns SET status = ?, token_usage = ?, updated_at = ? WHERE id = ?').run(
+        'completed',
+        JSON.stringify(p.usage),
+        now,
+        turn.id,
+      );
+      broadcast('turn:completed', { sessionId: session.id, turnId: turn.id, usage: p.usage, hasUnreviewed: true });
     } else {
-      db.prepare('UPDATE turns SET status = ?, error = ?, updated_at = ? WHERE id = ?')
-        .run('failed', errMsg, now2, turn.id);
-      db.prepare('UPDATE sessions SET is_running = 0, status = ?, updated_at = ? WHERE id = ?')
-        .run('failed', now2, session.id);
-      broadcast('turn:failed', { sessionId: session.id, turnId: turn.id, error: errMsg });
-    }
-  } finally {
-    const entry = threadMap.get(session.id);
-    if (entry) {
-      threadMap.set(session.id, { ...entry, abortController: null });
+      db.prepare('UPDATE turns SET status = ?, updated_at = ? WHERE id = ?').run('completed', now, turn.id);
+      broadcast('turn:completed', { sessionId: session.id, turnId: turn.id, hasUnreviewed: true });
     }
-  }
-}
+    setSessionStatus(db, session.id, 0, 'active', now, true);
+    syncThreadTitle(session.id);
+  };
+  const handleTurnFailed = (params: unknown) => {
+    if (turnDone) return;
+    const p = params as TurnFailedNotification;
+    if (p.threadId !== threadId) return;
+    turnDone = true;
+    const db = getDb();
+    const now = new Date().toISOString();
+    db.prepare('UPDATE turns SET status = ?, error = ?, updated_at = ? WHERE id = ?').run(
+      'failed',
+      p.error.message,
+      now,
+      turn.id,
+    );
+    setSessionStatus(db, session.id, 0, 'failed', now);
+    broadcast('turn:failed', { sessionId: session.id, turnId: turn.id, error: p.error.message });
+  };
 
-/** Cancel a running turn by session ID. Returns true if a turn was cancelled. */
-export function interruptTurn(sessionId: string): boolean {
-  const entry = threadMap.get(sessionId);
-  if (entry?.abortController) {
-    entry.abortController.abort();
-    return true;
+  // Stream incremental text deltas to frontend — no DB write per delta (performance).
+  // The final text is written by handleItemEvent on item/completed.
+  const handleAgentMessageDelta = (params: unknown) => {
+    if (turnDone) return;
+    const p = params as AgentMessageDeltaNotification;
+    if (p.threadId !== threadId) return;
+    broadcast('item:delta', {
+      sessionId: session.id,
+      turnId: turn.id,
+      itemId: p.itemId,
+      delta: p.delta,
+    });
+  };
+
+  // Save token usage from thread/tokenUsage/updated — no turnDone guard (may arrive before or after turn/completed).
+  const handleTokenUsageUpdated = (params: unknown) => {
+    const p = params as TokenUsageNotification;
+    if (p.threadId !== threadId) return;
+    const usage = mapTokenUsage(p.tokenUsage.total);
+    const db = getDb();
+    const now = new Date().toISOString();
+    db.prepare('UPDATE turns SET token_usage = ?, updated_at = ? WHERE id = ?').run(
+      JSON.stringify(usage),
+      now,
+      turn.id,
+    );
+    broadcast('turn:tokenUsage', { sessionId: session.id, turnId: turn.id, usage });
+  };
+
+  // Note: onNotification adds to a list, so we register before sending turn/start
+  client.onNotification('item/started', handleItemStarted);
+  client.onNotification('item/updated', handleItemUpdated);
+  client.onNotification('item/completed', handleItemCompleted);
+  client.onNotification('item/agentMessage/delta', handleAgentMessageDelta);
+  client.onNotification('turn/completed', handleTurnCompleted);
+  client.onNotification('turn/failed', handleTurnFailed);
+  client.onNotification('thread/tokenUsage/updated', handleTokenUsageUpdated);
+
+  // Phase 4: send turn/start
+  try {
+    await client.request<TurnStartResult>('turn/start', {
+      threadId,
+      input: [{ type: 'text', text: turn.user_prompt }],
+      approvalPolicy: 'never',
+      sandbox: { type: sandbox },
+      model: session.model ?? undefined,
+      effort: session.model_reasoning_effort ?? undefined,
+    });
+
+    // The turn runs asynchronously — events arrive via notifications
+    // If the process closes unexpectedly, handle cleanup
+    client.events.once('closed', () => {
+      const db = getDb();
+      const now = new Date().toISOString();
+      const currentTurn = db.prepare('SELECT status FROM turns WHERE id = ?').get(turn.id) as
+        | { status: string }
+        | undefined;
+      if (currentTurn && currentTurn.status === 'running') {
+        db.prepare('UPDATE turns SET status = ?, error = ?, updated_at = ? WHERE id = ?').run(
+          'failed',
+          'App-server process closed unexpectedly',
+          now,
+          turn.id,
+        );
+        setSessionStatus(db, session.id, 0, 'failed', now);
+        broadcast('turn:failed', {
+          sessionId: session.id,
+          turnId: turn.id,
+          error: 'App-server process closed unexpectedly',
+        });
+      }
+    });
+  } 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 });
+    turnDone = true;
   }
-  return false;
 }
 
-function handleEvent(event: ThreadEvent, sessionId: string, turnId: string): void {
+/** Handle an item notification — insert or update DB row and broadcast. */
+function handleItemEvent(
+  params: ItemNotification,
+  sessionId: string,
+  turnId: string,
+  status: ItemStatus,
+  broadcastEvent: string,
+): void {
   const db = getDb();
   const now = new Date().toISOString();
+  const item = params.item;
 
-  switch (event.type) {
-    case 'thread.started': {
-      db.prepare('UPDATE sessions SET external_thread_id = ?, updated_at = ? WHERE id = ?')
-        .run(event.thread_id, now, sessionId);
-      break;
-    }
+  // Skip user messages — they are not agent output
+  if (shouldSkipItem(item.type)) return;
 
-    case 'turn.started': {
-      // Already broadcasted turn:started before the stream started.
-      break;
-    }
+  // Skip reasoning items with empty content — app-server sends summary: [], content: []
+  // These have no displayable text and would render as empty cards
+  if ((item.type === 'reasoning' || item.type === 'agentReasoning') && isEmptyReasoning(item)) return;
 
-    case 'item.started': {
-      const item = event.item;
-      const itemId = uuidv4();
-      const data = mapItemData(item);
-      db.prepare(
-        'INSERT INTO items (id, turn_id, external_item_id, type, data, status, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)',
-      ).run(itemId, turnId, item.id, item.type, JSON.stringify(data), 'in_progress', now, now);
+  const data = mapItemData(item);
+  const normalizedType = normalizeItemType(item.type);
 
-      broadcast('item:started', { sessionId, turnId, item: makeItem(itemId, turnId, item, 'in_progress', now, now) });
-      break;
-    }
+  // 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(data), status, now, item.id, turnId);
 
-    case 'item.updated': {
-      const item = event.item;
-      const data = mapItemData(item);
-      const result = db.prepare('UPDATE items SET data = ?, updated_at = ? WHERE external_item_id = ? AND turn_id = ?')
-        .run(JSON.stringify(data), now, item.id, turnId);
-
-      // SDK may skip item.started — insert if missing
-      if (result.changes === 0) {
-        const itemId = uuidv4();
-        db.prepare(
-          'INSERT INTO items (id, turn_id, external_item_id, type, data, status, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)',
-        ).run(itemId, turnId, item.id, item.type, JSON.stringify(data), 'in_progress', now, now);
-        broadcast('item:updated', { sessionId, turnId, item: makeItem(itemId, turnId, item, 'in_progress', now, now) });
-      } else {
-        const row = db.prepare('SELECT id, status, created_at FROM items WHERE external_item_id = ? AND turn_id = ?')
-          .get(item.id, turnId) as { id: string; status: ItemStatus; created_at: string } | undefined;
-        if (row) {
-          broadcast('item:updated', { sessionId, turnId, item: makeItem(row.id, turnId, item, row.status, row.created_at, now) });
-        }
+  let itemId: string;
+  let createdAt: string;
+
+  if (result.changes === 0) {
+    // Item not in DB yet — insert
+    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, item.id, normalizedType as Item['type'], JSON.stringify(data), status, now, now);
+  } else {
+    const row = db
+      .prepare('SELECT id, created_at FROM items WHERE external_item_id = ? AND turn_id = ?')
+      .get(item.id, turnId) as { id: string; created_at: string };
+    itemId = row.id;
+    createdAt = row.created_at;
+  }
+
+  // Update turn-level fields on item completion
+  if (status === 'completed' || status === 'in_progress') {
+    if (item.type === 'agentMessage' || item.type === 'agent_message') {
+      db.prepare('UPDATE turns SET agent_response = ?, updated_at = ? WHERE id = ?').run(item.text, now, turnId);
+    }
+    if (item.type === 'reasoning' || item.type === 'agentReasoning') {
+      const summary = Array.isArray(item.summary) ? (item.summary as string[]).join('\n') : '';
+      const thoughts = summary || item.text || '';
+      if (thoughts) {
+        db.prepare('UPDATE turns SET thoughts = ?, updated_at = ? WHERE id = ?').run(thoughts, now, turnId);
       }
-      break;
     }
+  }
 
-    case 'item.completed': {
-      const item = event.item;
-      const status = getItemStatus(item);
-      const data = mapItemData(item);
-      const result = db.prepare('UPDATE items SET data = ?, status = ?, updated_at = ? WHERE external_item_id = ? AND turn_id = ?')
-        .run(JSON.stringify(data), status, now, item.id, turnId);
-
-      // SDK may skip item.started — insert if missing
-      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, item.id, item.type, JSON.stringify(data), status, now, now);
-      } else {
-        const row = db.prepare('SELECT id, created_at FROM items WHERE external_item_id = ? AND turn_id = ?')
-          .get(item.id, 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: item.id,
+    type: normalizedType as Item['type'],
+    data,
+    status,
+    created_at: createdAt,
+    updated_at: now,
+  };
 
-      // Update turn-level fields
-      if (item.type === 'agent_message') {
-        db.prepare('UPDATE turns SET agent_response = ?, updated_at = ? WHERE id = ?')
-          .run(item.text, now, turnId);
-      }
-      if (item.type === 'reasoning') {
-        const existing = db.prepare('SELECT thoughts FROM turns WHERE id = ?').get(turnId) as { thoughts: string | null };
-        const thoughts = existing.thoughts ? existing.thoughts + '\n' + item.text : item.text;
-        db.prepare('UPDATE turns SET thoughts = ?, updated_at = ? WHERE id = ?')
-          .run(thoughts, now, turnId);
-      }
+  broadcast(broadcastEvent, { sessionId, turnId, item: wsItem });
+}
 
-      broadcast('item:completed', { sessionId, turnId, item: makeItem(itemId, turnId, item, status, createdAt, now) });
-      break;
-    }
+/** Cancel a running turn by session ID. Returns true if a turn was cancelled. */
+export async function interruptTurn(sessionId: string): Promise<boolean> {
+  const entry = sessionMap.get(sessionId);
+  if (!entry || !entry.turnId) return false;
 
-    case 'turn.completed': {
-      const usage = event.usage;
-      db.prepare('UPDATE turns SET status = ?, token_usage = ?, updated_at = ? WHERE id = ?')
-        .run('completed', JSON.stringify(usage), now, turnId);
-      db.prepare('UPDATE sessions SET is_running = 0, status = ?, has_unreviewed = 1, updated_at = ? WHERE id = ?')
-        .run('active', now, sessionId);
-      broadcast('turn:completed', { sessionId, turnId, usage, hasUnreviewed: true });
-
-      // Auto-generate session title from first turn (if title is still null)
-      syncThreadTitle(sessionId);
-      break;
-    }
+  try {
+    await entry.client.request('turn/interrupt', {
+      threadId: entry.threadId,
+      turnId: entry.turnId,
+    });
 
-    case 'turn.failed': {
-      db.prepare('UPDATE turns SET status = ?, error = ?, updated_at = ? WHERE id = ?')
-        .run('failed', event.error.message, now, turnId);
-      db.prepare('UPDATE sessions SET is_running = 0, status = ?, updated_at = ? WHERE id = ?')
-        .run('failed', now, sessionId);
-      broadcast('turn:failed', { sessionId, turnId, error: event.error.message });
-      break;
-    }
+    // Update DB and broadcast — the app-server may not send a turn/failed notification
+    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 });
 
-    case 'error': {
-      db.prepare('UPDATE turns SET status = ?, error = ?, updated_at = ? WHERE id = ?')
-        .run('failed', event.message, now, turnId);
-      db.prepare('UPDATE sessions SET is_running = 0, status = ?, updated_at = ? WHERE id = ?')
-        .run('failed', now, sessionId);
-      broadcast('turn:failed', { sessionId, turnId, error: event.message });
-      break;
-    }
+    // Clear turn ID so further notifications are ignored
+    entry.turnId = null;
+
+    return true;
+  } catch {
+    return false;
   }
 }
 
-function makeItem(
-  id: string,
-  turnId: string,
-  sdkItem: ThreadItem,
-  status: ItemStatus,
-  createdAt: string,
-  updatedAt: string,
-): Item {
-  return {
-    id,
-    turn_id: turnId,
-    external_item_id: sdkItem.id,
-    type: sdkItem.type,
-    data: mapItemData(sdkItem),
-    status,
-    created_at: createdAt,
-    updated_at: updatedAt,
-  };
+/** Remove a session's app-server client from the in-memory map. Used after rewind/branch. */
+export function clearThread(sessionId: string): void {
+  const entry = sessionMap.get(sessionId);
+  if (entry) {
+    entry.client.close().catch(() => {
+      // Ignore close errors
+    });
+    sessionMap.delete(sessionId);
+  }
 }
 
+/** Clear all session entries. Used in test cleanup. */
+export function clearAllThreads(): void {
+  for (const [, entry] of sessionMap) {
+    entry.client.close().catch(() => {});
+  }
+  sessionMap.clear();
+  titleGenerating.clear();
+}
+
+// --- Title generation ---
+
 /** Tracks sessions currently generating titles — prevents duplicate throwaway threads. */
 const titleGenerating = new Set<string>();
 
-/** Generate a title for the session using a throwaway Codex thread.
- *  Only runs once per session — guarded by title === null AND titleGenerating set. */
+/** Generate a title for the session using a throwaway app-server thread. */
 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; // Already has a title
-  if (titleGenerating.has(sessionId)) return; // Already generating
-
-  // Get the first turn's user_prompt and agent_response
-  const turn = db.prepare('SELECT user_prompt, agent_response FROM turns WHERE session_id = ? ORDER BY created_at ASC LIMIT 1')
+  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;
 
-  // Mark as generating — prevents concurrent title generation for same session
   titleGenerating.add(sessionId);
-
-  // Fire-and-forget — don't block the turn:completed handler
   generateTitleAsync(sessionId, turn.user_prompt, turn.agent_response).finally(() => {
     titleGenerating.delete(sessionId);
   });
 }
 
-/** Create a throwaway Codex thread, ask for a title, update the session, then clean up. */
-async function generateTitleAsync(sessionId: string, userPrompt: string, agentResponse: string | null): Promise<void> {
-  let throwawayThreadId: string | null = null;
+/** Create a throwaway app-server thread, ask for a title, update the session. */
+async function generateTitleAsync(
+  sessionId: string,
+  userPrompt: string,
+  agentResponse: string | null,
+): Promise<void> {
+  let client: AppServerClient | null = null;
   try {
-    const codex = new Codex();
-    const thread = codex.startThread({ skipGitRepoCheck: true });
-    throwawayThreadId = thread.id;
+    client = new AppServerClient({ cwd: process.cwd() });
+    await client.initialize();
+
+    const initResult = await client.request<ThreadStartResult>('thread/start', {
+      cwd: process.cwd(),
+      approvalPolicy: 'never',
+      sandbox: 'read-only',
+    });
+    const threadId = initResult.thread.id;
 
     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}"`;
 
-    const result = await thread.run(titlePrompt);
-    const title = result.finalResponse.trim().replace(/^["']|["']$/g, '').slice(0, 100);
+    // Set up promise to capture the title response
+    let titleResolve!: (value: string) => void;
+    let titleReject!: (error: Error) => void;
+    const titlePromise = new Promise<string>((resolve, reject) => {
+      titleResolve = resolve;
+      titleReject = reject;
+    });
+
+    // Capture agent_message text from item/completed
+    let titleResponse = '';
+    client.onNotification('item/completed', (params: unknown) => {
+      const p = params as ItemNotification;
+      if (p.threadId !== threadId) return;
+      if ((p.item.type === 'agentMessage' || p.item.type === 'agent_message') && p.item.text) {
+        titleResponse = p.item.text;
+      }
+    });
+
+    // Resolve on turn/completed
+    client.onNotification('turn/completed', (params: unknown) => {
+      const p = params as { threadId: string };
+      if (p.threadId !== threadId) return;
+      titleResolve(titleResponse);
+    });
+
+    // Reject on turn/failed
+    client.onNotification('turn/failed', (params: unknown) => {
+      const p = params as TurnFailedNotification;
+      if (p.threadId !== threadId) return;
+      titleReject(new Error(p.error.message));
+    });
 
-    if (title) {
+    // Set a timeout (30s)
+    const timeout = setTimeout(() => {
+      titleReject(new Error('Title generation timed out'));
+    }, 30_000);
+
+    // Send turn/start — events arrive via notifications
+    await client.request<TurnStartResult>('turn/start', {
+      threadId,
+      input: [{ type: 'text', text: titlePrompt }],
+      approvalPolicy: 'never',
+      sandbox: { type: 'read-only' },
+    });
+
+    const title = await titlePromise;
+    clearTimeout(timeout);
+
+    const cleanTitle = title.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(title, now, sessionId);
-      broadcast('session:title', { sessionId, title });
+      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 {
-    // Clean up the throwaway thread
-    if (throwawayThreadId) {
-      cleanupThrowawayThread(throwawayThreadId);
+    if (client) {
+      await client.close().catch(() => {});
     }
   }
 }
 
-/** Delete throwaway thread from Codex state DB, rollout file, and session_index.jsonl. */
-function cleanupThrowawayThread(threadId: string): void {
-  const home = process.env.HOME || process.env.USERPROFILE || '';
-
-  // 1. Delete from state DB and get rollout path
+// --- Provider interface ---
+
+/** Map SDK effort values to UI labels. */
+const EFFORT_LABELS: Record<string, string> = {
+  minimal: 'Minimal',
+  low: 'Low',
+  medium: 'Medium',
+  high: 'High',
+  xhigh: 'Extra High',
+  max: 'Max',
+  ultra: 'Ultra',
+};
+
+/** Fetch available models from the shared app-server and map to ModelInfo[]. */
+async function getModels(): Promise<ModelInfo[]> {
   try {
-    const codexDb = new Database(`${home}/.codex/state_5.sqlite`);
-    const row = codexDb.prepare('SELECT rollout_path FROM threads WHERE id = ?')
-      .get(threadId) as { rollout_path: string } | undefined;
-
-    codexDb.prepare('DELETE FROM thread_spawn_edges WHERE child_thread_id = ? OR parent_thread_id = ?').run(threadId, threadId);
-    codexDb.prepare('DELETE FROM threads WHERE id = ?').run(threadId);
-    codexDb.close();
-
-    // 2. Delete rollout file
-    if (row?.rollout_path) {
-      try { unlinkSync(row.rollout_path); } catch { /* file may not exist */ }
-    }
+    const result = await getSharedAppServer().request<ModelListResult>('model/list', {});
+    return (result.data ?? []).map((m) => ({
+      slug: m.id,
+      displayName: m.displayName,
+      description: m.description,
+      defaultReasoning: m.defaultReasoningEffort,
+      reasoningLevels: (m.supportedReasoningEfforts ?? []).map((r) => ({
+        effort: r.reasoningEffort,
+        label: EFFORT_LABELS[r.reasoningEffort] ?? r.reasoningEffort,
+      })),
+    }));
   } catch {
-    // DB not found — skip
+    return [];
   }
+}
 
-  // 3. Remove from session_index.jsonl
-  try {
-    const indexPath = `${home}/.codex/session_index.jsonl`;
-    const content = readFileSync(indexPath, 'utf-8');
-    const lines = content.trim().split('\n').filter((line) => {
-      try {
-        const entry = JSON.parse(line) as { id: string };
-        return entry.id !== threadId;
-      } catch {
-        return true; // keep unparseable lines
-      }
-    });
-    writeFileSync(indexPath, lines.join('\n') + '\n');
-  } catch {
-    // File not found — skip
-  }
-}
+/** Graceful shutdown — close shared metadata process and all per-session clients. */
+async function shutdown(): Promise<void> {
+  await closeSharedAppServer();
+  clearAllThreads();
+}
+
+/** Codex provider — implements RuntimeProvider interface. */
+export const codexProvider: RuntimeProvider = {
+  startTurn,
+  interruptTurn,
+  clearThread,
+  clearAllThreads,
+  getModels,
+  shutdown,
+};