kaizenai 0.1.0

package/src/server/agent.ts

@@ -0,0 +1,1120 @@
+import { query, type CanUseTool, type PermissionResult, type Query, type SDKUserMessage } from "@anthropic-ai/claude-agent-sdk"
+import type {
+  AgentProvider,
+  ChatAttachment,
+  ChatPendingToolSnapshot,
+  ChatUsageSnapshot,
+  NormalizedToolCall,
+  PendingToolSnapshot,
+  KaizenStatus,
+  TranscriptEntry,
+  UserPromptEntry,
+} from "../shared/types"
+import { normalizeToolCall } from "../shared/tools"
+import type { ClientCommand } from "../shared/protocol"
+import { EventStore } from "./event-store"
+import { persistChatAttachments, resolveAttachmentPath } from "./attachments"
+import { CodexAppServerManager } from "./codex-app-server"
+import { CursorAcpManager } from "./cursor-acp"
+import { GeminiAcpManager } from "./gemini-acp"
+import { generateTitleForChat } from "./generate-title"
+import type { HarnessEvent, HarnessToolRequest, HarnessTurn } from "./harness-types"
+import {
+  codexServiceTierFromModelOptions,
+  getServerProviderCatalog,
+  normalizeClaudeModelOptions,
+  normalizeCodexModelOptions,
+  normalizeCursorModelOptions,
+  normalizeGeminiModelOptions,
+  normalizeServerModel,
+} from "./provider-catalog"
+import { createClaudeRateLimitSnapshot } from "./usage/claude-usage"
+import { deriveProviderUsage } from "./usage/provider-usage"
+import type { ProviderUsageMap } from "../shared/types"
+import { resolveClaudeApiModelId } from "../shared/types"
+
+const CLAUDE_TOOLSET = [
+  "Skill",
+  "WebFetch",
+  "WebSearch",
+  "Task",
+  "TaskOutput",
+  "Bash",
+  "Glob",
+  "Grep",
+  "Read",
+  "Edit",
+  "Write",
+  "TodoWrite",
+  "KillShell",
+  "AskUserQuestion",
+  "EnterPlanMode",
+  "ExitPlanMode",
+] as const
+
+interface PendingToolRequest {
+  toolUseId: string
+  tool: NormalizedToolCall & { toolKind: "ask_user_question" | "exit_plan_mode" }
+  resolve: (result: unknown) => void
+}
+
+interface ActiveTurn {
+  chatId: string
+  provider: AgentProvider
+  turn: HarnessTurn
+  model: string
+  effort?: string
+  serviceTier?: "fast"
+  fastMode?: boolean
+  planMode: boolean
+  status: KaizenStatus
+  pendingTool: PendingToolRequest | null
+  postToolFollowUp: { content: string; planMode: boolean } | null
+  hasFinalResult: boolean
+  cancelRequested: boolean
+  cancelRecorded: boolean
+}
+
+interface AgentCoordinatorArgs {
+  store: EventStore
+  onStateChange: () => void
+  attachmentsDir: string
+  codexManager?: CodexAppServerManager
+  cursorManager?: CursorAcpManager
+  geminiManager?: GeminiAcpManager
+  generateTitle?: (messageContent: string, cwd: string) => Promise<string | null>
+}
+
+type RecoverablePendingTool = NormalizedToolCall & { toolKind: "ask_user_question" | "exit_plan_mode" }
+
+function timestamped<T extends Omit<TranscriptEntry, "_id" | "createdAt">>(
+  entry: T,
+  createdAt = Date.now()
+): TranscriptEntry {
+  return {
+    _id: crypto.randomUUID(),
+    createdAt,
+    ...entry,
+  } as TranscriptEntry
+}
+
+function stringFromUnknown(value: unknown) {
+  if (typeof value === "string") return value
+  try {
+    return JSON.stringify(value, null, 2)
+  } catch {
+    return String(value)
+  }
+}
+
+function discardedToolResult(
+  tool: NormalizedToolCall & { toolKind: "ask_user_question" | "exit_plan_mode" }
+) {
+  if (tool.toolKind === "ask_user_question") {
+    return {
+      discarded: true,
+      answers: {},
+    }
+  }
+
+  return {
+    discarded: true,
+  }
+}
+
+function asRecord(value: unknown): Record<string, unknown> | null {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null
+  return value as Record<string, unknown>
+}
+
+function shouldUseSyntheticPlanFollowUp(
+  provider: AgentProvider,
+  tool: NormalizedToolCall & { toolKind: "exit_plan_mode" }
+) {
+  if (provider === "codex") return true
+  if (provider !== "cursor") return false
+  return asRecord(tool.rawInput)?.source === "cursor/create_plan"
+}
+
+function findLatestRecoverablePendingTool(args: {
+  messages: TranscriptEntry[]
+  planMode: boolean
+}): RecoverablePendingTool | null {
+  const completedToolIds = new Set(
+    args.messages
+      .filter((entry): entry is Extract<TranscriptEntry, { kind: "tool_result" }> => entry.kind === "tool_result")
+      .map((entry) => entry.toolId)
+  )
+
+  for (let index = args.messages.length - 1; index >= 0; index -= 1) {
+    const entry = args.messages[index]
+    if (entry.kind !== "tool_call") continue
+    const tool = entry.tool
+    const isRecoverableAskUserQuestion = tool.toolKind === "ask_user_question"
+    const isRecoverableExitPlan = args.planMode && tool.toolKind === "exit_plan_mode"
+    if (!isRecoverableAskUserQuestion && !isRecoverableExitPlan) continue
+    if (completedToolIds.has(tool.toolId)) return null
+    return tool
+  }
+
+  return null
+}
+
+function formatRecoveredAskUserQuestionFollowUp(
+  tool: NormalizedToolCall & { toolKind: "ask_user_question" },
+  result: unknown
+) {
+  const record = asRecord(result)
+  const answersValue = asRecord(record?.answers) ?? record ?? {}
+  const lines = tool.input.questions.map((question) => {
+    const rawAnswer = (question.id ? answersValue[question.id] : undefined) ?? answersValue[question.question]
+    const answers = Array.isArray(rawAnswer)
+      ? rawAnswer.map((entry) => String(entry)).filter(Boolean)
+      : rawAnswer == null || rawAnswer === ""
+        ? []
+        : [String(rawAnswer)]
+    const label = question.question.trim() || question.id || "Question"
+    return `- ${label}: ${answers.length > 0 ? answers.join(", ") : "No response"}`
+  })
+
+  return [
+    "The app restarted while you were waiting for user input.",
+    "Resume from that point using the recovered answers below.",
+    "",
+    "Recovered user answers:",
+    ...lines,
+  ].join("\n")
+}
+
+function planModeFollowUp(result: { confirmed?: boolean; message?: string }) {
+  if (result.confirmed) {
+    return {
+      content: result.message
+        ? `Proceed with the approved plan. Additional guidance: ${result.message}`
+        : "Proceed with the approved plan.",
+      planMode: false,
+    }
+  }
+
+  return {
+    content: result.message
+      ? `Revise the plan using this feedback: ${result.message}`
+      : "Revise the plan using this feedback.",
+    planMode: true,
+  }
+}
+
+export function normalizeClaudeStreamMessage(message: any): TranscriptEntry[] {
+  const debugRaw = JSON.stringify(message)
+  const messageId = typeof message.uuid === "string" ? message.uuid : undefined
+
+  if (message.type === "system" && message.subtype === "init") {
+    return [
+      timestamped({
+        kind: "system_init",
+        messageId,
+        provider: "claude",
+        model: typeof message.model === "string" ? message.model : "unknown",
+        tools: Array.isArray(message.tools) ? message.tools : [],
+        agents: Array.isArray(message.agents) ? message.agents : [],
+        slashCommands: Array.isArray(message.slash_commands)
+          ? message.slash_commands.filter((entry: string) => !entry.startsWith("._"))
+          : [],
+        mcpServers: Array.isArray(message.mcp_servers) ? message.mcp_servers : [],
+        debugRaw,
+      }),
+    ]
+  }
+
+  if (message.type === "assistant" && Array.isArray(message.message?.content)) {
+    const entries: TranscriptEntry[] = []
+    for (const content of message.message.content) {
+      if (content.type === "text" && typeof content.text === "string") {
+        entries.push(timestamped({
+          kind: "assistant_text",
+          messageId,
+          text: content.text,
+          debugRaw,
+        }))
+      }
+      if (content.type === "tool_use" && typeof content.name === "string" && typeof content.id === "string") {
+        entries.push(timestamped({
+          kind: "tool_call",
+          messageId,
+          tool: normalizeToolCall({
+            toolName: content.name,
+            toolId: content.id,
+            input: (content.input ?? {}) as Record<string, unknown>,
+          }),
+          debugRaw,
+        }))
+      }
+    }
+    return entries
+  }
+
+  if (message.type === "user" && Array.isArray(message.message?.content)) {
+    const entries: TranscriptEntry[] = []
+    for (const content of message.message.content) {
+      if (content.type === "tool_result" && typeof content.tool_use_id === "string") {
+        entries.push(timestamped({
+          kind: "tool_result",
+          messageId,
+          toolId: content.tool_use_id,
+          content: content.content,
+          isError: Boolean(content.is_error),
+          debugRaw,
+        }))
+      }
+      if (message.message.role === "user" && typeof message.message.content === "string") {
+        entries.push(timestamped({
+          kind: "compact_summary",
+          messageId,
+          summary: message.message.content,
+          debugRaw,
+        }))
+      }
+    }
+    return entries
+  }
+
+  if (message.type === "result") {
+    if (message.subtype === "cancelled") {
+      return [timestamped({ kind: "interrupted", messageId, debugRaw })]
+    }
+    return [
+      timestamped({
+        kind: "result",
+        messageId,
+        subtype: message.is_error ? "error" : "success",
+        isError: Boolean(message.is_error),
+        durationMs: typeof message.duration_ms === "number" ? message.duration_ms : 0,
+        result: typeof message.result === "string" ? message.result : stringFromUnknown(message.result),
+        costUsd: typeof message.total_cost_usd === "number" ? message.total_cost_usd : undefined,
+        debugRaw,
+      }),
+    ]
+  }
+
+  if (message.type === "system" && message.subtype === "status" && typeof message.status === "string") {
+    return [timestamped({ kind: "status", messageId, status: message.status, debugRaw })]
+  }
+
+  if (message.type === "system" && message.subtype === "compact_boundary") {
+    return [timestamped({ kind: "compact_boundary", messageId, debugRaw })]
+  }
+
+  if (message.type === "system" && message.subtype === "context_cleared") {
+    return [timestamped({ kind: "context_cleared", messageId, debugRaw })]
+  }
+
+  if (
+    message.type === "user" &&
+    message.message?.role === "user" &&
+    typeof message.message.content === "string" &&
+    message.message.content.startsWith("This session is being continued")
+  ) {
+    return [timestamped({ kind: "compact_summary", messageId, summary: message.message.content, debugRaw })]
+  }
+
+  return []
+}
+
+async function* createClaudeHarnessStream(q: Query): AsyncGenerator<HarnessEvent> {
+  for await (const sdkMessage of q as AsyncIterable<any>) {
+    const sessionToken = typeof sdkMessage.session_id === "string" ? sdkMessage.session_id : null
+    if (sessionToken) {
+      yield { type: "session_token", sessionToken }
+    }
+
+    if (sdkMessage.type === "rate_limit_event") {
+      const rateLimitInfo = sdkMessage.rate_limit_info
+      const rawUtilization = typeof rateLimitInfo?.utilization === "number" ? rateLimitInfo.utilization : null
+      const usage = createClaudeRateLimitSnapshot(
+        rawUtilization !== null ? rawUtilization * 100 : null,
+        typeof rateLimitInfo?.resetsAt === "number" ? rateLimitInfo.resetsAt * 1000 : null
+      )
+      if (usage) {
+        yield { type: "usage", usage }
+      }
+    }
+
+    for (const entry of normalizeClaudeStreamMessage(sdkMessage)) {
+      yield { type: "transcript", entry }
+    }
+  }
+}
+
+async function createClaudePrompt(
+  content: string,
+  attachmentFiles: Array<{ filePath: string; mimeType: string }>,
+  sessionToken: string | null
+): Promise<string | AsyncIterable<SDKUserMessage>> {
+  if (attachmentFiles.length === 0) {
+    return content
+  }
+
+  const blocks: Array<Record<string, unknown>> = []
+  for (const attachment of attachmentFiles) {
+    const bytes = Buffer.from(await Bun.file(attachment.filePath).arrayBuffer())
+    blocks.push({
+      type: "image",
+      source: {
+        type: "base64",
+        media_type: attachment.mimeType,
+        data: bytes.toString("base64"),
+      },
+    })
+  }
+
+  if (content) {
+    blocks.push({
+      type: "text",
+      text: content,
+    })
+  }
+
+  return (async function* () {
+    yield {
+      type: "user",
+      session_id: sessionToken ?? crypto.randomUUID(),
+      parent_tool_use_id: null,
+      message: {
+        role: "user",
+        content: blocks,
+      } as SDKUserMessage["message"],
+    }
+  })()
+}
+
+async function startClaudeTurn(args: {
+  content: string
+  attachmentFiles?: Array<{ filePath: string; mimeType: string }>
+  localPath: string
+  model: string
+  effort?: string
+  planMode: boolean
+  sessionToken: string | null
+  onToolRequest: (request: HarnessToolRequest) => Promise<unknown>
+}): Promise<HarnessTurn> {
+  const canUseTool: CanUseTool = async (toolName, input, options) => {
+    if (toolName !== "AskUserQuestion" && toolName !== "ExitPlanMode") {
+      return {
+        behavior: "allow",
+        updatedInput: input,
+      }
+    }
+
+    const tool = normalizeToolCall({
+      toolName,
+      toolId: options.toolUseID,
+      input: (input ?? {}) as Record<string, unknown>,
+    })
+
+    if (tool.toolKind !== "ask_user_question" && tool.toolKind !== "exit_plan_mode") {
+      return {
+        behavior: "deny",
+        message: "Unsupported tool request",
+      }
+    }
+
+    const result = await args.onToolRequest({ tool })
+
+    if (tool.toolKind === "ask_user_question") {
+      const record = result && typeof result === "object" ? result as Record<string, unknown> : {}
+      return {
+        behavior: "allow",
+        updatedInput: {
+          ...(tool.rawInput ?? {}),
+          questions: record.questions ?? tool.input.questions,
+          answers: record.answers ?? result,
+        },
+      } satisfies PermissionResult
+    }
+
+    const record = result && typeof result === "object" ? result as Record<string, unknown> : {}
+    const confirmed = Boolean(record.confirmed)
+    if (confirmed) {
+      return {
+        behavior: "allow",
+        updatedInput: {
+          ...(tool.rawInput ?? {}),
+          ...record,
+        },
+      } satisfies PermissionResult
+    }
+
+    return {
+      behavior: "deny",
+      message: typeof record.message === "string"
+        ? `User wants to suggest edits to the plan: ${record.message}`
+        : "User wants to suggest edits to the plan before approving.",
+    } satisfies PermissionResult
+  }
+
+  const q = query({
+    prompt: await createClaudePrompt(args.content, args.attachmentFiles ?? [], args.sessionToken),
+    options: {
+      cwd: args.localPath,
+      model: args.model,
+      effort: args.effort as "low" | "medium" | "high" | "max" | undefined,
+      resume: args.sessionToken ?? undefined,
+      permissionMode: args.planMode ? "plan" : "acceptEdits",
+      canUseTool,
+      tools: [...CLAUDE_TOOLSET],
+      settingSources: ["user", "project", "local"],
+      env: (() => { const { CLAUDECODE: _, ...env } = process.env; return env })(),
+    },
+  })
+
+  return {
+    provider: "claude",
+    stream: createClaudeHarnessStream(q),
+    getAccountInfo: async () => {
+      try {
+        return await q.accountInfo()
+      } catch {
+        return null
+      }
+    },
+    interrupt: async () => {
+      await q.interrupt()
+    },
+    close: () => {
+      q.close()
+    },
+  }
+}
+
+export class AgentCoordinator {
+  private readonly store: EventStore
+  private readonly onStateChange: () => void
+  private readonly attachmentsDir: string
+  private readonly codexManager: CodexAppServerManager
+  private readonly cursorManager: CursorAcpManager
+  private readonly geminiManager: GeminiAcpManager
+  private readonly generateTitle: (messageContent: string, cwd: string) => Promise<string | null>
+  readonly activeTurns = new Map<string, ActiveTurn>()
+  readonly liveUsage = new Map<string, ChatUsageSnapshot>()
+
+  constructor(args: AgentCoordinatorArgs) {
+    this.store = args.store
+    this.onStateChange = args.onStateChange
+    this.attachmentsDir = args.attachmentsDir
+    this.codexManager = args.codexManager ?? new CodexAppServerManager()
+    this.cursorManager = args.cursorManager ?? new CursorAcpManager()
+    this.geminiManager = args.geminiManager ?? new GeminiAcpManager()
+    this.generateTitle = args.generateTitle ?? generateTitleForChat
+  }
+
+  getActiveStatuses() {
+    const statuses = new Map<string, KaizenStatus>()
+    for (const [chatId, turn] of this.activeTurns.entries()) {
+      statuses.set(chatId, turn.status)
+    }
+
+    for (const chat of this.store.state.chatsById.values()) {
+      if (chat.deletedAt || statuses.has(chat.id)) continue
+      if (this.getRecoveredPendingTool(chat.id)) {
+        statuses.set(chat.id, "waiting_for_user")
+      }
+    }
+
+    return statuses
+  }
+
+  getPendingTool(chatId: string): PendingToolSnapshot | null {
+    const pending = this.activeTurns.get(chatId)?.pendingTool
+    if (pending) {
+      return { toolUseId: pending.toolUseId, toolKind: pending.tool.toolKind }
+    }
+
+    return this.getRecoveredPendingTool(chatId)
+  }
+
+  getLiveUsage(chatId: string) {
+    return this.liveUsage.get(chatId) ?? null
+  }
+
+  getProviderUsage(): ProviderUsageMap {
+    return deriveProviderUsage(this.liveUsage, this.store)
+  }
+
+  getChatPendingTool(chatId: string): ChatPendingToolSnapshot | null {
+    const pending = this.activeTurns.get(chatId)?.pendingTool
+    if (pending) {
+      return {
+        toolUseId: pending.toolUseId,
+        toolKind: pending.tool.toolKind,
+        source: "active",
+      }
+    }
+
+    const recovered = this.getRecoveredPendingTool(chatId)
+    return recovered
+      ? {
+          ...recovered,
+          source: "recovered",
+        }
+      : null
+  }
+
+  private getRecoveredPendingToolRequest(chatId: string): RecoverablePendingTool | null {
+    if (this.activeTurns.has(chatId)) return null
+
+    const chat = this.store.getChat(chatId)
+    if (!chat || !chat.provider) return null
+
+    const pendingTool = findLatestRecoverablePendingTool({
+      messages: this.store.getMessages(chatId),
+      planMode: chat.planMode,
+    })
+    if (!pendingTool) return null
+
+    return pendingTool
+  }
+
+  private getRecoveredPendingTool(chatId: string): PendingToolSnapshot | null {
+    const pendingTool = this.getRecoveredPendingToolRequest(chatId)
+    if (!pendingTool) return null
+
+    return {
+      toolUseId: pendingTool.toolId,
+      toolKind: pendingTool.toolKind,
+    }
+  }
+
+  private resolveProvider(command: Extract<ClientCommand, { type: "chat.send" }>, currentProvider: AgentProvider | null) {
+    if (currentProvider) return currentProvider
+    return command.provider ?? "claude"
+  }
+
+  private getProviderSettings(provider: AgentProvider, command: Extract<ClientCommand, { type: "chat.send" }>) {
+    const catalog = getServerProviderCatalog(provider)
+    if (provider === "claude") {
+      const model = normalizeServerModel(provider, command.model)
+      const modelOptions = normalizeClaudeModelOptions(model, command.modelOptions, command.effort)
+      return {
+        model: resolveClaudeApiModelId(model, modelOptions.contextWindow),
+        effort: modelOptions.reasoningEffort,
+        serviceTier: undefined,
+        fastMode: undefined,
+        planMode: catalog.supportsPlanMode ? Boolean(command.planMode) : false,
+      }
+    }
+
+    if (provider === "gemini") {
+      const modelOptions = normalizeGeminiModelOptions(command.modelOptions)
+      return {
+        model: normalizeServerModel(provider, command.model),
+        effort: modelOptions.thinkingMode,
+        serviceTier: undefined,
+        fastMode: undefined,
+        planMode: catalog.supportsPlanMode ? Boolean(command.planMode) : false,
+      }
+    }
+
+    if (provider === "cursor") {
+      normalizeCursorModelOptions(command.modelOptions)
+      return {
+        model: normalizeServerModel(provider, command.model),
+        effort: undefined,
+        serviceTier: undefined,
+        fastMode: undefined,
+        planMode: catalog.supportsPlanMode ? Boolean(command.planMode) : false,
+      }
+    }
+
+    const modelOptions = normalizeCodexModelOptions(command.modelOptions, command.effort)
+    return {
+      model: normalizeServerModel(provider, command.model),
+      effort: modelOptions.reasoningEffort,
+      serviceTier: codexServiceTierFromModelOptions(modelOptions),
+      fastMode: undefined,
+      planMode: catalog.supportsPlanMode ? Boolean(command.planMode) : false,
+    }
+  }
+
+  private async startTurnForChat(args: {
+    chatId: string
+    provider: AgentProvider
+    content: string
+    attachments?: ChatAttachment[]
+    model: string
+    effort?: string
+    serviceTier?: "fast"
+    fastMode?: boolean
+    planMode: boolean
+    appendUserPrompt: UserPromptEntry | null
+  }) {
+    const chat = this.store.requireChat(args.chatId)
+    if (this.activeTurns.has(args.chatId)) {
+      throw new Error("Chat is already running")
+    }
+
+    if (!chat.provider) {
+      await this.store.setChatProvider(args.chatId, args.provider)
+    }
+    await this.store.setPlanMode(args.chatId, args.planMode)
+
+    const existingMessages = this.store.getMessages(args.chatId)
+    const shouldGenerateTitle = Boolean(args.appendUserPrompt) && chat.title === "New Chat" && existingMessages.length === 0
+
+    if (args.appendUserPrompt) {
+      await this.store.appendMessage(args.chatId, args.appendUserPrompt)
+    }
+    await this.store.recordTurnStarted(args.chatId)
+
+    const project = this.store.getProject(chat.projectId)
+    if (!project) {
+      throw new Error("Project not found")
+    }
+
+    const attachmentFiles = (args.attachments ?? []).map((attachment) => {
+      const filePath = resolveAttachmentPath(this.attachmentsDir, attachment.relativePath)
+      if (!filePath) {
+        throw new Error(`Failed to resolve attachment '${attachment.name}'.`)
+      }
+      return {
+        filePath,
+        mimeType: attachment.mimeType,
+      }
+    })
+
+    if (shouldGenerateTitle) {
+      void this.generateTitleInBackground(args.chatId, args.content, project.localPath)
+    }
+
+    const onToolRequest = async (request: HarnessToolRequest): Promise<unknown> => {
+      const active = this.activeTurns.get(args.chatId)
+      if (!active) {
+        throw new Error("Chat turn ended unexpectedly")
+      }
+
+      active.status = "waiting_for_user"
+      this.onStateChange()
+
+      return await new Promise<unknown>((resolve) => {
+        active.pendingTool = {
+          toolUseId: request.tool.toolId,
+          tool: request.tool,
+          resolve,
+        }
+      })
+    }
+
+    let turn: HarnessTurn
+    if (args.provider === "claude") {
+      turn = await startClaudeTurn({
+        content: args.content,
+        attachmentFiles,
+        localPath: project.localPath,
+        model: args.model,
+        effort: args.effort,
+        planMode: args.planMode,
+        sessionToken: chat.sessionToken,
+        onToolRequest,
+      })
+    } else if (args.provider === "gemini") {
+      turn = await this.geminiManager.startTurn({
+        chatId: args.chatId,
+        content: args.content,
+        localPath: project.localPath,
+        model: args.model,
+        thinkingMode: (args.effort as "off" | "standard" | "high" | undefined) ?? "standard",
+        planMode: args.planMode,
+        sessionToken: chat.sessionToken,
+        onToolRequest,
+      })
+    } else if (args.provider === "cursor") {
+      turn = await this.cursorManager.startTurn({
+        chatId: args.chatId,
+        content: args.content,
+        localPath: project.localPath,
+        model: args.model,
+        planMode: args.planMode,
+        sessionToken: chat.sessionToken,
+        onToolRequest,
+      })
+    } else {
+      await this.codexManager.startSession({
+        chatId: args.chatId,
+        cwd: project.localPath,
+        model: args.model,
+        serviceTier: args.serviceTier,
+        sessionToken: chat.sessionToken,
+      })
+      turn = await this.codexManager.startTurn({
+        chatId: args.chatId,
+        content: args.content,
+        attachments: attachmentFiles,
+        model: args.model,
+        effort: args.effort as any,
+        serviceTier: args.serviceTier,
+        planMode: args.planMode,
+        onToolRequest,
+      })
+    }
+
+    const active: ActiveTurn = {
+      chatId: args.chatId,
+      provider: args.provider,
+      turn,
+      model: args.model,
+      effort: args.effort,
+      serviceTier: args.serviceTier,
+      fastMode: args.fastMode,
+      planMode: args.planMode,
+      status: "starting",
+      pendingTool: null,
+      postToolFollowUp: null,
+      hasFinalResult: false,
+      cancelRequested: false,
+      cancelRecorded: false,
+    }
+    this.activeTurns.set(args.chatId, active)
+    this.onStateChange()
+
+    if (turn.getAccountInfo) {
+      void turn.getAccountInfo()
+        .then(async (accountInfo) => {
+          if (!accountInfo) return
+          await this.store.appendMessage(args.chatId, timestamped({ kind: "account_info", accountInfo }))
+          this.onStateChange()
+        })
+        .catch(() => undefined)
+    }
+
+    void this.runTurn(active)
+  }
+
+  async send(command: Extract<ClientCommand, { type: "chat.send" }>) {
+    let chatId = command.chatId
+
+    if (!chatId) {
+      if (!command.projectId) {
+        throw new Error("Missing projectId for new chat")
+      }
+      const created = await this.store.createChat(command.projectId)
+      chatId = created.id
+    }
+
+    const chat = this.store.requireChat(chatId)
+    const provider = this.resolveProvider(command, chat.provider)
+    const settings = this.getProviderSettings(provider, command)
+    const text = command.message.text.trim()
+    const userPrompt = timestamped({
+      kind: "user_prompt",
+      content: text,
+    }) as UserPromptEntry
+    const attachments = await persistChatAttachments({
+      attachmentsDir: this.attachmentsDir,
+      chatId,
+      messageEntry: userPrompt,
+      uploads: command.message.attachments,
+    })
+    userPrompt.attachments = attachments
+
+    if (!text && !attachments?.length) {
+      throw new Error("Message must include text or image attachments")
+    }
+
+    await this.startTurnForChat({
+      chatId,
+      provider,
+      content: text,
+      attachments,
+      model: settings.model,
+      effort: settings.effort,
+      serviceTier: settings.serviceTier,
+      fastMode: settings.fastMode,
+      planMode: settings.planMode,
+      appendUserPrompt: userPrompt,
+    })
+
+    return { chatId }
+  }
+
+  private async generateTitleInBackground(chatId: string, messageContent: string, cwd: string) {
+    try {
+      const title = messageContent.trim() ? await this.generateTitle(messageContent, cwd) : "Image request"
+      if (!title) return
+
+      const chat = this.store.requireChat(chatId)
+      if (chat.title !== "New Chat") return
+
+      await this.store.renameChat(chatId, title)
+      this.onStateChange()
+    } catch {
+      // Ignore background title generation failures.
+    }
+  }
+
+  private async runTurn(active: ActiveTurn) {
+    try {
+      for await (const event of active.turn.stream) {
+        if (event.type === "session_token" && event.sessionToken) {
+          await this.store.setSessionToken(active.chatId, event.sessionToken)
+          this.onStateChange()
+          continue
+        }
+
+        if (event.type === "usage" && event.usage) {
+          this.liveUsage.set(active.chatId, event.usage)
+          this.onStateChange()
+          continue
+        }
+
+        if (!event.entry) continue
+        if (active.hasFinalResult && event.entry.kind === "result") {
+          continue
+        }
+        await this.store.appendMessage(active.chatId, event.entry)
+
+        if (event.entry.kind === "system_init") {
+          active.status = "running"
+        }
+
+        if (event.entry.kind === "result") {
+          active.hasFinalResult = true
+          if (event.entry.isError) {
+            await this.store.recordTurnFailed(active.chatId, event.entry.result || "Turn failed")
+          } else if (!active.cancelRequested) {
+            await this.store.recordTurnFinished(active.chatId)
+          }
+        }
+
+        this.onStateChange()
+      }
+    } catch (error) {
+      if (!active.cancelRequested && !active.hasFinalResult) {
+        const message = error instanceof Error ? error.message : String(error)
+        await this.store.appendMessage(
+          active.chatId,
+          timestamped({
+            kind: "result",
+            subtype: "error",
+            isError: true,
+            durationMs: 0,
+            result: message,
+          })
+        )
+        await this.store.recordTurnFailed(active.chatId, message)
+      }
+    } finally {
+      if (active.cancelRequested && !active.cancelRecorded) {
+        await this.store.recordTurnCancelled(active.chatId)
+      }
+      active.turn.close()
+      this.activeTurns.delete(active.chatId)
+      this.onStateChange()
+
+      if (active.postToolFollowUp && !active.cancelRequested) {
+        try {
+          await this.startTurnForChat({
+            chatId: active.chatId,
+            provider: active.provider,
+            content: active.postToolFollowUp.content,
+            model: active.model,
+            effort: active.effort,
+            serviceTier: active.serviceTier,
+            fastMode: active.fastMode,
+            planMode: active.postToolFollowUp.planMode,
+            appendUserPrompt: null,
+          })
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error)
+          await this.store.appendMessage(
+            active.chatId,
+            timestamped({
+              kind: "result",
+              subtype: "error",
+              isError: true,
+              durationMs: 0,
+              result: message,
+            })
+          )
+          await this.store.recordTurnFailed(active.chatId, message)
+          this.onStateChange()
+        }
+      }
+    }
+  }
+
+  async cancel(chatId: string) {
+    const active = this.activeTurns.get(chatId)
+    if (!active) return
+
+    active.cancelRequested = true
+
+    const pendingTool = active.pendingTool
+    active.pendingTool = null
+
+    if (pendingTool) {
+      const result = discardedToolResult(pendingTool.tool)
+      await this.store.appendMessage(
+        chatId,
+        timestamped({
+          kind: "tool_result",
+          toolId: pendingTool.toolUseId,
+          content: result,
+        })
+      )
+      if (active.provider === "codex" && pendingTool.tool.toolKind === "exit_plan_mode") {
+        pendingTool.resolve(result)
+      }
+    }
+
+    await this.store.appendMessage(chatId, timestamped({ kind: "interrupted" }))
+    await this.store.recordTurnCancelled(chatId)
+    active.cancelRecorded = true
+    active.hasFinalResult = true
+
+    try {
+      await active.turn.interrupt()
+    } catch {
+      active.turn.close()
+    }
+
+    this.activeTurns.delete(chatId)
+    this.onStateChange()
+  }
+
+  async shutdown(chatId: string) {
+    const active = this.activeTurns.get(chatId)
+    if (!active) return
+
+    const pendingTool = active.pendingTool
+    const shouldPreservePendingTool =
+      pendingTool?.tool.toolKind === "ask_user_question"
+      || pendingTool?.tool.toolKind === "exit_plan_mode"
+
+    if (!shouldPreservePendingTool) {
+      await this.cancel(chatId)
+      return
+    }
+
+    active.cancelRequested = true
+    active.cancelRecorded = true
+    active.hasFinalResult = true
+    active.pendingTool = null
+    active.postToolFollowUp = null
+    active.turn.close()
+    this.activeTurns.delete(chatId)
+    this.onStateChange()
+  }
+
+  async respondTool(command: Extract<ClientCommand, { type: "chat.respondTool" }>) {
+    const active = this.activeTurns.get(command.chatId)
+    if (!active || !active.pendingTool) {
+      const recoveredPending = this.getRecoveredPendingToolRequest(command.chatId)
+      const chat = this.store.getChat(command.chatId)
+      if (!recoveredPending || !chat || !chat.provider) {
+        throw new Error("No pending tool request")
+      }
+
+      if (recoveredPending.toolId !== command.toolUseId) {
+        throw new Error("Tool response does not match active request")
+      }
+
+      await this.store.appendMessage(
+        command.chatId,
+        timestamped({
+          kind: "tool_result",
+          toolId: command.toolUseId,
+          content: command.result,
+        })
+      )
+
+      const settings = this.getProviderSettings(chat.provider, {
+        type: "chat.send",
+        chatId: command.chatId,
+        message: { text: "" },
+        planMode: chat.planMode,
+      })
+
+      if (recoveredPending.toolKind === "ask_user_question") {
+        await this.startTurnForChat({
+          chatId: command.chatId,
+          provider: chat.provider,
+          content: formatRecoveredAskUserQuestionFollowUp(recoveredPending, command.result),
+          model: settings.model,
+          effort: settings.effort,
+          serviceTier: settings.serviceTier,
+          fastMode: settings.fastMode,
+          planMode: chat.planMode,
+          appendUserPrompt: null,
+        })
+
+        this.onStateChange()
+        return
+      }
+
+      const result = (command.result ?? {}) as {
+        confirmed?: boolean
+        clearContext?: boolean
+        message?: string
+      }
+      if (result.confirmed && result.clearContext) {
+        this.liveUsage.delete(command.chatId)
+        await this.store.setSessionToken(command.chatId, null)
+        await this.store.appendMessage(command.chatId, timestamped({ kind: "context_cleared" }))
+      }
+
+      const followUp = planModeFollowUp(result)
+
+      await this.startTurnForChat({
+        chatId: command.chatId,
+        provider: chat.provider,
+        content: followUp.content,
+        model: settings.model,
+        effort: settings.effort,
+        serviceTier: settings.serviceTier,
+        fastMode: settings.fastMode,
+        planMode: followUp.planMode,
+        appendUserPrompt: null,
+      })
+
+      this.onStateChange()
+      return
+    }
+
+    const pending = active.pendingTool
+    if (pending.toolUseId !== command.toolUseId) {
+      throw new Error("Tool response does not match active request")
+    }
+
+    await this.store.appendMessage(
+      command.chatId,
+      timestamped({
+        kind: "tool_result",
+        toolId: command.toolUseId,
+        content: command.result,
+      })
+    )
+
+    active.pendingTool = null
+    active.status = "running"
+
+    if (pending.tool.toolKind === "exit_plan_mode") {
+      const result = (command.result ?? {}) as {
+        confirmed?: boolean
+        clearContext?: boolean
+        message?: string
+      }
+      if (result.confirmed && result.clearContext) {
+        this.liveUsage.delete(command.chatId)
+        await this.store.setSessionToken(command.chatId, null)
+        await this.store.appendMessage(command.chatId, timestamped({ kind: "context_cleared" }))
+      }
+
+      if (shouldUseSyntheticPlanFollowUp(active.provider, pending.tool)) {
+        active.postToolFollowUp = planModeFollowUp(result)
+      }
+    }
+
+    pending.resolve(command.result)
+
+    this.onStateChange()
+  }
+}