kaizenai 0.3.0 → 0.4.0

package/src/server/agent.ts

@@ -1,1159 +0,0 @@
-import { query, type CanUseTool, type PermissionResult, type Query, type SDKUserMessage } from "@anthropic-ai/claude-agent-sdk"
-import type {
-  AgentProvider,
-  ChatAttachment,
-  ChatAttachmentUpload,
-  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; attachments?: ChatAttachmentUpload[] } | 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" }
-type ClaudeImageMimeType = "image/png" | "image/jpeg" | "image/webp" | "image/gif"
-
-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; attachments?: ChatAttachmentUpload[] }) {
-  let text = ""
-  if (result.confirmed) {
-    text = result.message
-      ? `Proceed with the approved plan. Additional guidance: ${result.message}`
-      : "Proceed with the approved plan."
-  } else {
-    text = result.message
-      ? `Revise the plan using this feedback: ${result.message}`
-      : "Revise the plan using this feedback."
-  }
-
-  return {
-    content: text,
-    attachments: result.attachments,
-    planMode: !result.confirmed,
-  }
-}
-
-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: ClaudeImageMimeType }>,
-  sessionToken: string | null
-): Promise<string | AsyncIterable<SDKUserMessage>> {
-  if (attachmentFiles.length === 0) {
-    return content
-  }
-
-  const blocks: Exclude<SDKUserMessage["message"]["content"], string> = []
-  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,
-      },
-    }
-  })()
-}
-
-async function startClaudeTurn(args: {
-  content: string
-  attachmentFiles?: Array<{ filePath: string; mimeType: ClaudeImageMimeType }>
-  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 as ClaudeImageMimeType,
-      }
-    })
-
-    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 {
-          const messageEntry: UserPromptEntry = timestamped({
-            kind: "user_prompt" as const,
-            content: active.postToolFollowUp.content,
-          }) as UserPromptEntry
-
-          const attachments = await persistChatAttachments({
-            attachmentsDir: this.attachmentsDir,
-            chatId: active.chatId,
-            messageEntry,
-            uploads: active.postToolFollowUp.attachments,
-          })
-
-          if (attachments) {
-            messageEntry.attachments = attachments
-          }
-
-          await this.startTurnForChat({
-            chatId: active.chatId,
-            provider: active.provider,
-            content: active.postToolFollowUp.content,
-            attachments,
-            model: active.model,
-            effort: active.effort,
-            serviceTier: active.serviceTier,
-            fastMode: active.fastMode,
-            planMode: active.postToolFollowUp.planMode,
-            appendUserPrompt: attachments ? messageEntry : 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
-        attachments?: ChatAttachmentUpload[]
-      }
-      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)
-
-      const messageEntry: UserPromptEntry = timestamped({
-        kind: "user_prompt" as const,
-        content: followUp.content,
-      }) as UserPromptEntry
-
-      const attachments = await persistChatAttachments({
-        attachmentsDir: this.attachmentsDir,
-        chatId: command.chatId,
-        messageEntry,
-        uploads: followUp.attachments,
-      })
-
-      if (attachments) {
-        messageEntry.attachments = attachments
-      }
-
-      await this.startTurnForChat({
-        chatId: command.chatId,
-        provider: chat.provider,
-        content: followUp.content,
-        attachments,
-        model: settings.model,
-        effort: settings.effort,
-        serviceTier: settings.serviceTier,
-        fastMode: settings.fastMode,
-        planMode: followUp.planMode,
-        appendUserPrompt: attachments ? messageEntry : 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
-        attachments?: ChatAttachmentUpload[]
-      }
-      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()
-  }
-}