kanna-code 0.1.4 → 0.3.0

package/src/server/agent.ts

@@ -1,13 +1,26 @@
 import { query, type CanUseTool, type PermissionResult, type Query } from "@anthropic-ai/claude-agent-sdk"
+import type {
+  AgentProvider,
+  NormalizedToolCall,
+  PendingToolSnapshot,
+  KannaStatus,
+  TranscriptEntry,
+} from "../shared/types"
+import { normalizeToolCall } from "../shared/tools"
 import type { ClientCommand } from "../shared/protocol"
-
-import type { KannaStatus, PendingToolSnapshot } from "../shared/types"
 import { EventStore } from "./event-store"
+import { CodexAppServerManager } from "./codex-app-server"
 import { generateTitleForChat } from "./generate-title"
-
-const DEFAULT_MODEL = "opus"
-
-const TOOLSET = [
+import type { HarnessEvent, HarnessToolRequest, HarnessTurn } from "./harness-types"
+import {
+  codexServiceTierFromModelOptions,
+  getServerProviderCatalog,
+  normalizeClaudeModelOptions,
+  normalizeCodexModelOptions,
+  normalizeServerModel,
+} from "./provider-catalog"
+
+const CLAUDE_TOOLSET = [
   "Skill",
   "WebFetch",
   "WebSearch",
@@ -28,16 +41,21 @@ const TOOLSET = [
 
 interface PendingToolRequest {
   toolUseId: string
-  toolName: "AskUserQuestion" | "ExitPlanMode"
-  input: Record<string, unknown>
-  resolve: (result: PermissionResult) => void
+  tool: NormalizedToolCall & { toolKind: "ask_user_question" | "exit_plan_mode" }
+  resolve: (result: unknown) => void
 }
 
 interface ActiveTurn {
   chatId: string
-  query: Query
+  provider: AgentProvider
+  turn: HarnessTurn
+  model: string
+  effort?: string
+  serviceTier?: "fast"
+  planMode: boolean
   status: KannaStatus
   pendingTool: PendingToolRequest | null
+  postToolFollowUp: { content: string; planMode: boolean } | null
   hasFinalResult: boolean
   cancelRequested: boolean
   cancelRecorded: boolean
@@ -46,70 +64,268 @@ interface ActiveTurn {
 interface AgentCoordinatorArgs {
   store: EventStore
   onStateChange: () => void
+  codexManager?: CodexAppServerManager
+  generateTitle?: (messageContent: string, cwd: string) => Promise<string | null>
 }
 
-function buildUserPromptPayload(content: string) {
-  return JSON.stringify({ type: "user_prompt", content })
+function timestamped<T extends Omit<TranscriptEntry, "_id" | "createdAt">>(
+  entry: T,
+  createdAt = Date.now()
+): TranscriptEntry {
+  return {
+    _id: crypto.randomUUID(),
+    createdAt,
+    ...entry,
+  } as TranscriptEntry
 }
 
-function buildToolResultPayload(toolUseId: string, body: unknown) {
-  return JSON.stringify({
-    type: "user",
-    message: {
-      role: "user",
-      content: [
-        {
-          type: "tool_result",
-          tool_use_id: toolUseId,
-          content: JSON.stringify(body),
-        },
-      ],
-    },
-  })
+function stringFromUnknown(value: unknown) {
+  if (typeof value === "string") return value
+  try {
+    return JSON.stringify(value, null, 2)
+  } catch {
+    return String(value)
+  }
 }
 
-function buildCancelledPayload() {
-  return JSON.stringify({
-    type: "result",
-    subtype: "cancelled",
-    is_error: false,
-    duration_ms: 0,
-    result: "Interrupted by user",
-  })
-}
+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,
+      }),
+    ]
+  }
 
-function buildErrorPayload(message: string) {
-  return JSON.stringify({
-    type: "result",
-    subtype: "error",
-    is_error: true,
-    duration_ms: 0,
-    result: message,
-  })
+  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 []
 }
 
-function deriveChatTitle(content: string) {
-  const singleLine = content.replace(/\s+/g, " ").trim()
-  return singleLine.slice(0, 60) || "New Chat"
+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 }
+    }
+    for (const entry of normalizeClaudeStreamMessage(sdkMessage)) {
+      yield { type: "transcript", entry }
+    }
+  }
 }
 
-function toTranscriptEntry(message: string, messageId?: string) {
+async function startClaudeTurn(args: {
+  content: 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: args.content,
+    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: { ...process.env },
+    },
+  })
+
   return {
-    _id: crypto.randomUUID(),
-    messageId,
-    message,
-    createdAt: Date.now(),
+    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 codexManager: CodexAppServerManager
+  private readonly generateTitle: (messageContent: string, cwd: string) => Promise<string | null>
   readonly activeTurns = new Map<string, ActiveTurn>()
 
   constructor(args: AgentCoordinatorArgs) {
     this.store = args.store
     this.onStateChange = args.onStateChange
+    this.codexManager = args.codexManager ?? new CodexAppServerManager()
+    this.generateTitle = args.generateTitle ?? generateTitleForChat
   }
 
   getActiveStatuses() {
@@ -123,153 +339,214 @@ export class AgentCoordinator {
   getPendingTool(chatId: string): PendingToolSnapshot | null {
     const pending = this.activeTurns.get(chatId)?.pendingTool
     if (!pending) return null
-    return { toolUseId: pending.toolUseId, toolName: pending.toolName }
+    return { toolUseId: pending.toolUseId, toolKind: pending.tool.toolKind }
   }
 
-  async send(command: Extract<ClientCommand, { type: "chat.send" }>) {
-    let chatId = command.chatId
+  private resolveProvider(command: Extract<ClientCommand, { type: "chat.send" }>, currentProvider: AgentProvider | null) {
+    if (currentProvider) return currentProvider
+    return command.provider ?? "claude"
+  }
 
-    if (!chatId) {
-      if (!command.projectId) {
-        throw new Error("Missing projectId for new chat")
+  private getProviderSettings(provider: AgentProvider, command: Extract<ClientCommand, { type: "chat.send" }>) {
+    const catalog = getServerProviderCatalog(provider)
+    if (provider === "claude") {
+      const modelOptions = normalizeClaudeModelOptions(command.modelOptions, command.effort)
+      return {
+        model: normalizeServerModel(provider, command.model),
+        effort: modelOptions.reasoningEffort,
+        serviceTier: undefined,
+        planMode: catalog.supportsPlanMode ? Boolean(command.planMode) : false,
       }
-      const created = await this.store.createChat(command.projectId)
-      chatId = created.id
     }
 
-    const chat = this.store.requireChat(chatId)
-    if (this.activeTurns.has(chatId)) {
+    const modelOptions = normalizeCodexModelOptions(command.modelOptions, command.effort)
+    return {
+      model: normalizeServerModel(provider, command.model),
+      effort: modelOptions.reasoningEffort,
+      serviceTier: codexServiceTierFromModelOptions(modelOptions),
+      planMode: catalog.supportsPlanMode ? Boolean(command.planMode) : false,
+    }
+  }
+
+  private async startTurnForChat(args: {
+    chatId: string
+    provider: AgentProvider
+    content: string
+    model: string
+    effort?: string
+    serviceTier?: "fast"
+    planMode: boolean
+    appendUserPrompt: boolean
+  }) {
+    const chat = this.store.requireChat(args.chatId)
+    if (this.activeTurns.has(args.chatId)) {
       throw new Error("Chat is already running")
     }
 
-    const existingMessages = this.store.getMessages(chatId)
-    if (chat.title === "New Chat" && existingMessages.length === 0) {
-      // Immediate placeholder: truncated first message
-      await this.store.renameChat(chatId, deriveChatTitle(command.content))
-
-      // Fire-and-forget: generate a better title with Haiku in parallel
-      void generateTitleForChat(command.content)
-        .then(async (title) => {
-          if (title) {
-            await this.store.renameChat(chatId!, title)
-            this.onStateChange()
-          }
-        })
-        .catch(() => undefined)
+    if (!chat.provider) {
+      await this.store.setChatProvider(args.chatId, args.provider)
     }
+    await this.store.setPlanMode(args.chatId, args.planMode)
 
-    await this.store.appendMessage(chatId, toTranscriptEntry(buildUserPromptPayload(command.content), crypto.randomUUID()))
-    await this.store.recordTurnStarted(chatId)
+    const existingMessages = this.store.getMessages(args.chatId)
+    const shouldGenerateTitle = args.appendUserPrompt && chat.title === "New Chat" && existingMessages.length === 0
 
-    const canUseTool: CanUseTool = async (toolName, input, options) => {
-      if (toolName !== "AskUserQuestion" && toolName !== "ExitPlanMode") {
-        return {
-          behavior: "allow",
-          updatedInput: input,
-        }
-      }
+    if (args.appendUserPrompt) {
+      await this.store.appendMessage(args.chatId, timestamped({ kind: "user_prompt", content: args.content }, Date.now()))
+    }
+    await this.store.recordTurnStarted(args.chatId)
 
-      const active = this.activeTurns.get(chatId!)
+    const project = this.store.getProject(chat.projectId)
+    if (!project) {
+      throw new Error("Project not found")
+    }
+
+    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) {
-        return {
-          behavior: "deny",
-          message: "Chat turn ended unexpectedly",
-        }
+        throw new Error("Chat turn ended unexpectedly")
       }
 
       active.status = "waiting_for_user"
       this.onStateChange()
 
-      return await new Promise<PermissionResult>((resolve) => {
+      return await new Promise<unknown>((resolve) => {
         active.pendingTool = {
-          toolUseId: options.toolUseID,
-          toolName,
-          input,
+          toolUseId: request.tool.toolId,
+          tool: request.tool,
           resolve,
         }
       })
     }
 
-    const project = this.store.getProject(chat.projectId)
-    if (!project) {
-      throw new Error("Project not found")
-    }
-
-    const resolvedModel = command.model || DEFAULT_MODEL
-    const resolvedEffort = (command.effort as "low" | "medium" | "high" | "max") || undefined
-    console.log(`[agent] query model=${resolvedModel} effort=${resolvedEffort} (command.model=${command.model})`)
-
-    const q = query({
-      prompt: command.content,
-      options: {
+    let turn: HarnessTurn
+    if (args.provider === "claude") {
+      turn = await startClaudeTurn({
+        content: args.content,
+        localPath: project.localPath,
+        model: args.model,
+        effort: args.effort,
+        planMode: args.planMode,
+        sessionToken: chat.sessionToken,
+        onToolRequest,
+      })
+    } else {
+      await this.codexManager.startSession({
+        chatId: args.chatId,
         cwd: project.localPath,
-        model: resolvedModel,
-        effort: resolvedEffort,
-        resume: chat.resumeSessionId ?? undefined,
-        permissionMode: command.planMode ? "plan" : "acceptEdits",
-        canUseTool,
-        tools: [...TOOLSET],
-        settingSources: ["user", "project", "local"],
-        env: {
-          ...process.env,
-          // CLAUDE_AGENT_SDK_CLIENT_APP: SDK_CLIENT_APP,
-        },
-      },
-    })
+        model: args.model,
+        serviceTier: args.serviceTier,
+        sessionToken: chat.sessionToken,
+      })
+      turn = await this.codexManager.startTurn({
+        chatId: args.chatId,
+        content: args.content,
+        model: args.model,
+        effort: args.effort as any,
+        serviceTier: args.serviceTier,
+        planMode: args.planMode,
+        onToolRequest,
+      })
+    }
 
     const active: ActiveTurn = {
-      chatId,
-      query: q,
+      chatId: args.chatId,
+      provider: args.provider,
+      turn,
+      model: args.model,
+      effort: args.effort,
+      serviceTier: args.serviceTier,
+      planMode: args.planMode,
       status: "starting",
       pendingTool: null,
+      postToolFollowUp: null,
       hasFinalResult: false,
       cancelRequested: false,
       cancelRecorded: false,
     }
-    this.activeTurns.set(chatId, active)
+    this.activeTurns.set(args.chatId, active)
     this.onStateChange()
 
-    void q.accountInfo()
-      .then(async (accountInfo) => {
-        await this.store.appendMessage(
-          chatId!,
-          toTranscriptEntry(JSON.stringify({ type: "system", subtype: "account_info", accountInfo }))
-        )
-        this.onStateChange()
-      })
-      .catch(() => undefined)
+    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)
+    await this.startTurnForChat({
+      chatId,
+      provider,
+      content: command.content,
+      model: settings.model,
+      effort: settings.effort,
+      serviceTier: settings.serviceTier,
+      planMode: settings.planMode,
+      appendUserPrompt: true,
+    })
 
     return { chatId }
   }
 
-  private async runTurn(active: ActiveTurn) {
+  private async generateTitleInBackground(chatId: string, messageContent: string, cwd: string) {
     try {
-      for await (const sdkMessage of active.query) {
-        const raw = JSON.stringify(sdkMessage)
-        const maybeMessageId = "uuid" in sdkMessage && sdkMessage.uuid ? String(sdkMessage.uuid) : crypto.randomUUID()
+      const title = await this.generateTitle(messageContent, cwd)
+      if (!title) return
 
-        await this.store.appendMessage(active.chatId, toTranscriptEntry(raw, maybeMessageId))
+      const chat = this.store.requireChat(chatId)
+      if (chat.title !== "New Chat") return
 
-        const sessionId = "session_id" in sdkMessage && typeof sdkMessage.session_id === "string"
-          ? sdkMessage.session_id
-          : null
-        if (sessionId) {
-          await this.store.setResumeSession(active.chatId, sessionId)
+      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 (sdkMessage.type === "system" && sdkMessage.subtype === "init") {
+        if (!event.entry) continue
+        await this.store.appendMessage(active.chatId, event.entry)
+
+        if (event.entry.kind === "system_init") {
           active.status = "running"
         }
 
-        if (sdkMessage.type === "result") {
+        if (event.entry.kind === "result") {
           active.hasFinalResult = true
-          if (sdkMessage.is_error) {
-            const errorText = "errors" in sdkMessage && Array.isArray(sdkMessage.errors)
-              ? sdkMessage.errors.join("\n")
-              : "Turn failed"
-            await this.store.recordTurnFailed(active.chatId, errorText)
+          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)
           }
@@ -280,16 +557,54 @@ export class AgentCoordinator {
     } catch (error) {
       if (!active.cancelRequested) {
         const message = error instanceof Error ? error.message : String(error)
-        await this.store.appendMessage(active.chatId, toTranscriptEntry(buildErrorPayload(message)))
+        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.query.close()
+      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,
+            planMode: active.postToolFollowUp.planMode,
+            appendUserPrompt: false,
+          })
+        } 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()
+        }
+      }
     }
   }
 
@@ -300,15 +615,15 @@ export class AgentCoordinator {
     active.cancelRequested = true
     active.pendingTool = null
 
-    await this.store.appendMessage(chatId, toTranscriptEntry(buildCancelledPayload(), crypto.randomUUID()))
+    await this.store.appendMessage(chatId, timestamped({ kind: "interrupted" }))
     await this.store.recordTurnCancelled(chatId)
     active.cancelRecorded = true
     active.hasFinalResult = true
 
     try {
-      await active.query.interrupt()
+      await active.turn.interrupt()
     } catch {
-      active.query.close()
+      active.turn.close()
     }
 
     this.activeTurns.delete(chatId)
@@ -328,56 +643,46 @@ export class AgentCoordinator {
 
     await this.store.appendMessage(
       command.chatId,
-      toTranscriptEntry(buildToolResultPayload(command.toolUseId, command.result), crypto.randomUUID())
+      timestamped({
+        kind: "tool_result",
+        toolId: command.toolUseId,
+        content: command.result,
+      })
     )
 
     active.pendingTool = null
     active.status = "running"
 
-    if (pending.toolName === "AskUserQuestion") {
-      const result = command.result as { questions?: unknown; answers?: unknown }
-      pending.resolve({
-        behavior: "allow",
-        updatedInput: {
-          ...(pending.input ?? {}),
-          questions: result.questions ?? (pending.input.questions as unknown),
-          answers: result.answers ?? result,
-        },
-      })
-      this.onStateChange()
-      return
-    }
-
-    const result = (command.result ?? {}) as {
-      confirmed?: boolean
-      clearContext?: boolean
-      message?: string
-    }
+    if (pending.tool.toolKind === "exit_plan_mode") {
+      const result = (command.result ?? {}) as {
+        confirmed?: boolean
+        clearContext?: boolean
+        message?: string
+      }
+      if (result.confirmed && result.clearContext) {
+        await this.store.setSessionToken(command.chatId, null)
+        await this.store.appendMessage(command.chatId, timestamped({ kind: "context_cleared" }))
+      }
 
-    if (result.confirmed) {
-      if (result.clearContext) {
-        await this.store.setResumeSession(command.chatId, null)
-        await this.store.appendMessage(
-          command.chatId,
-          toTranscriptEntry(JSON.stringify({ type: "system", subtype: "context_cleared" }), crypto.randomUUID())
-        )
+      if (active.provider === "codex") {
+        active.postToolFollowUp = result.confirmed
+          ? {
+              content: result.message
+                ? `Proceed with the approved plan. Additional guidance: ${result.message}`
+                : "Proceed with the approved plan.",
+              planMode: false,
+            }
+          : {
+              content: result.message
+                ? `Revise the plan using this feedback: ${result.message}`
+                : "Revise the plan using this feedback.",
+              planMode: true,
+            }
       }
-      pending.resolve({
-        behavior: "allow",
-        updatedInput: {
-          ...(pending.input ?? {}),
-          ...result,
-        },
-      })
-    } else {
-      pending.resolve({
-        behavior: "deny",
-        message: result.message
-          ? `User wants to suggest edits to the plan: ${result.message}`
-          : "User wants to suggest edits to the plan before approving.",
-      })
     }
 
+    pending.resolve(command.result)
+
     this.onStateChange()
   }
 }