feat(cli): add saved remote servers

bun.lock

@@ -132,14 +132,18 @@
         "@opencode-ai/server": "workspace:*",
         "@opencode-ai/tui": "workspace:*",
         "@opentui/core": "catalog:",
+        "@opentui/keymap": "catalog:",
         "@opentui/solid": "catalog:",
         "@parcel/watcher": "2.5.1",
         "effect": "catalog:",
+        "fuzzysort": "catalog:",
         "immer": "11.1.4",
         "jsonc-parser": "3.3.1",
         "open": "10.1.2",
+        "opentui-spinner": "catalog:",
         "semver": "catalog:",
         "solid-js": "catalog:",
+        "strip-ansi": "7.1.2",
         "uqr": "0.1.3",
         "ws": "8.21.0",
       },
@@ -896,13 +900,9 @@
       "version": "1.17.13",
       "dependencies": {
         "@fontsource/commit-mono": "5.2.5",
-        "@fontsource/noto-sans-math": "5.2.5",
-        "@fontsource/noto-sans-symbols": "5.2.5",
-        "@fontsource/noto-sans-symbols-2": "5.2.5",
         "@napi-rs/canvas": "1.0.2",
         "@opencode-ai/ai": "workspace:*",
         "@opencode-ai/core": "workspace:*",
-        "@opencode-ai/plugin": "workspace:*",
         "@opentui/core": "catalog:",
         "effect": "catalog:",
       },
@@ -1026,7 +1026,6 @@
         "@opencode-ai/client": "workspace:*",
         "@opencode-ai/core": "workspace:*",
         "@opencode-ai/plugin": "workspace:*",
-        "@opencode-ai/schema": "workspace:*",
         "@opencode-ai/simulation": "workspace:*",
         "@opencode-ai/ui": "workspace:*",
         "@opentui/core": "catalog:",
@@ -1796,12 +1795,6 @@
 
     "@fontsource/inter": ["@fontsource/inter@5.2.8", "", {}, "sha512-P6r5WnJoKiNVV+zvW2xM13gNdFhAEpQ9dQJHt3naLvfg+LkF2ldgSLiF4T41lf1SQCM9QmkqPTn4TH568IRagg=="],
 
-    "@fontsource/noto-sans-math": ["@fontsource/noto-sans-math@5.2.5", "", {}, "sha512-1bxEvVlF51Vfgpju32mRZzI/CHvsfqjXjI2+sAuEyHYvXABUAIyj+93sCO3QZIoMG5drWyrzgoCqRQRaL6wQ8Q=="],
-
-    "@fontsource/noto-sans-symbols": ["@fontsource/noto-sans-symbols@5.2.5", "", {}, "sha512-mxoIRstsmZpZFzd/SRWiD+l6T7TGhpgCrGs7TEnnuGSQIfjVMrQT9Zej2enh9pkfmPNAFyeaGJkHkszJ1hH++w=="],
-
-    "@fontsource/noto-sans-symbols-2": ["@fontsource/noto-sans-symbols-2@5.2.5", "", {}, "sha512-F4O9WLifwoZS1quNzY1ebjMNo2cQPe/UP68Dmud0ONi2lOxaR6xp6fFPO2gG17MI7DwAnfMyQFl64A2tAd28hg=="],
-
     "@fuma-translate/react": ["@fuma-translate/react@1.0.2", "", { "peerDependencies": { "@types/react": "*", "react": "^19.2.0", "react-dom": "^19.2.0" }, "optionalPeers": ["@types/react"] }, "sha512-uOiOtBx3nRXR8Nu1GzBf1tApgF1FErDBTHxRIAQeyQdyOoZbrNRN6H4kDCWObY4qyGeGbHydG0DHzgeUgFDMIw=="],
 
     "@fumadocs/tailwind": ["@fumadocs/tailwind@0.1.0", "", { "peerDependencies": { "tailwindcss": "^4.0.0" }, "optionalPeers": ["tailwindcss"] }, "sha512-nF/DCAwOR21HZ4AkjIOv3Iqwyqywzb6pdyeMcoa+aZzirXj5ntvNZbe3jJ0v3ehhtrRfYYeXBezvjn8ZmV+fuQ=="],

packages/ai/README.md

@@ -1,6 +1,6 @@
 # @opencode-ai/ai
 
-Schema-first AI primitives for opencode. Provider quirks live in adapters, not in calling code.
+Schema-first LLM core for opencode. One typed request, response, event, and tool language; provider quirks live in adapters, not in calling code.
 
 ```ts
 import { Effect } from "effect"
@@ -24,45 +24,6 @@ const program = Effect.gen(function* () {
 
 Run `LLMClient.stream(request)` instead of `generate` when you want incremental `LLMEvent`s. The event stream is provider-neutral — same shape across OpenAI Chat, OpenAI Responses, Anthropic Messages, Gemini, Bedrock Converse, and any OpenAI-compatible deployment.
 
-## Image generation
-
-Use `Image.generate` with an image model for direct asset generation:
-
-```ts
-import { Image } from "@opencode-ai/ai"
-import { OpenAI } from "@opencode-ai/ai/providers"
-
-const program = Effect.gen(function* () {
-  const response = yield* Image.generate({
-    model: OpenAI.configure({ apiKey: process.env.OPENAI_API_KEY }).image("gpt-image-2"),
-    prompt: "A robot tending a rooftop garden",
-    count: 2,
-    size: { width: 1024, height: 1024 },
-    providerOptions: { openai: { quality: "high", outputFormat: "webp" } },
-  })
-
-  return response.images // GeneratedImage[] with owned bytes or a provider URL
-})
-```
-
-Conversational image generation remains part of the LLM interaction. OpenAI Responses exposes it through its hosted image tool:
-
-```ts
-const program = Effect.gen(function* () {
-  const response = yield* LLM.generate(
-    LLM.request({
-      model: OpenAI.configure({ apiKey }).responses("gpt-5"),
-      prompt: "Design a solarpunk rooftop garden, then show me.",
-      tools: [OpenAI.imageGeneration({ quality: "high" })],
-    }),
-  )
-
-  return response.message
-})
-```
-
-The hosted result is represented as a provider-executed tool call and tool result. Its image is a `file` content item with a data URI, so retaining `response.message` preserves the generated image for continuation.
-
 ## Public API
 
 - **`LLM.request({...})`** — build a provider-neutral `LLMRequest`. Accepts ergonomic inputs (`system: string`, `prompt: string`) that normalize into the canonical Schema classes.
@@ -71,8 +32,6 @@ The hosted result is represented as a provider-executed tool call and tool resul
 - **`Model.make(...)` / `ToolCallPart.make(...)` / `ToolResultPart.make(...)` / `ToolDefinition.make(...)`** — model and tool-related constructors from the canonical schema model.
 - **`LLMClient.prepare(request)`** — compile a request through protocol body construction, validation, and HTTP preparation without sending. Useful for inspection and testing.
 - **`LLMEvent.is.*`** — typed guards (`is.textDelta`, `is.toolCall`, `is.finish`, …) for filtering streams.
-- **`Image.generate({...})`** — generate images through a provider-neutral image request and response model.
-- **`ImageClient`** — Effect service and layer for image execution, parallel to `LLMClient`.
 
 ## Caching
 
@@ -223,7 +182,7 @@ Adding a new model or deployment is usually 5-15 lines using `Route.make({ proto
 
 ## Effect
 
-This package is built on Effect. Public methods return `Effect` or `Stream`; provide `LLMClient.layer` for LLM dispatch and `ImageClient.layer` for image dispatch, then import the provider/protocol modules for the routes you use. The example at `example/tutorial.ts` is a runnable walkthrough.
+This package is built on Effect. Public methods return `Effect` or `Stream`; provide `LLMClient.layer` for runtime dispatch and import the provider/protocol modules for the routes you use. The example at `example/tutorial.ts` is a runnable walkthrough.
 
 ## See also
 

packages/ai/src/image-client.ts

@@ -1,34 +0,0 @@
-import { Context, Effect, Layer } from "effect"
-import { RequestExecutor } from "./route/executor"
-import type { ImageRequest, ImageResponse } from "./image"
-import type { LLMError } from "./schema"
-
-export type Execute = RequestExecutor.Interface["execute"]
-
-export interface Interface {
-  readonly generate: (request: ImageRequest) => Effect.Effect<ImageResponse, LLMError>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/ImageClient") {}
-
-export const generate = (request: ImageRequest): Effect.Effect<ImageResponse, LLMError> =>
-  Effect.gen(function* () {
-    const client = yield* Service
-    return yield* client.generate(request)
-  }) as Effect.Effect<ImageResponse, LLMError>
-
-export const layer: Layer.Layer<Service, never, RequestExecutor.Service> = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const executor = yield* RequestExecutor.Service
-    return Service.of({
-      generate: (request) => request.model.route.generate(request, executor.execute),
-    })
-  }),
-)
-
-export const ImageClient = {
-  Service,
-  layer,
-  generate,
-} as const

packages/ai/src/image.ts

@@ -1,116 +0,0 @@
-import { Effect, Schema } from "effect"
-import { HttpOptions, InvalidRequestReason, LLMError, ModelID, ProviderID, ProviderMetadata, Usage } from "./schema"
-import { ImageClient, type Execute as ImageExecute } from "./image-client"
-
-export interface ImageRoute {
-  readonly id: string
-  readonly generate: (request: ImageRequest, execute: ImageExecute) => Effect.Effect<ImageResponse, LLMError>
-}
-
-export class ImageModel {
-  readonly id: ModelID
-  readonly provider: ProviderID
-  readonly route: ImageRoute
-  readonly defaults?: ImageModelDefaults
-
-  constructor(input: ImageModel.Input) {
-    this.id = input.id
-    this.provider = input.provider
-    this.route = input.route
-    this.defaults = input.defaults
-  }
-
-  static make(input: ImageModel.MakeInput) {
-    return new ImageModel({
-      id: ModelID.make(input.id),
-      provider: ProviderID.make(input.provider),
-      route: input.route,
-      defaults: input.defaults,
-    })
-  }
-}
-
-export namespace ImageModel {
-  export interface Input {
-    readonly id: ModelID
-    readonly provider: ProviderID
-    readonly route: ImageRoute
-    readonly defaults?: ImageModelDefaults
-  }
-
-  export interface MakeInput extends Omit<Input, "id" | "provider"> {
-    readonly id: string | ModelID
-    readonly provider: string | ProviderID
-  }
-}
-
-export interface ImageModelDefaults {
-  readonly providerOptions?: Record<string, Record<string, unknown>>
-  readonly http?: HttpOptions
-}
-
-export const ImageModelSchema = Schema.declare((value): value is ImageModel => value instanceof ImageModel, {
-  expected: "Image.Model",
-})
-
-export const ImageSize = Schema.Struct({
-  width: Schema.Int.check(Schema.isGreaterThanOrEqualTo(1)),
-  height: Schema.Int.check(Schema.isGreaterThanOrEqualTo(1)),
-}).annotate({ identifier: "Image.Size" })
-export type ImageSize = Schema.Schema.Type<typeof ImageSize>
-
-export class ImageRequest extends Schema.Class<ImageRequest>("Image.Request")({
-  model: ImageModelSchema,
-  prompt: Schema.String,
-  count: Schema.optional(Schema.Int.check(Schema.isGreaterThanOrEqualTo(1))),
-  size: Schema.optional(ImageSize),
-  aspectRatio: Schema.optional(Schema.String),
-  seed: Schema.optional(Schema.Number),
-  providerOptions: Schema.optional(Schema.Record(Schema.String, Schema.Record(Schema.String, Schema.Unknown))),
-  http: Schema.optional(HttpOptions),
-  metadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
-}) {}
-
-export type ImageRequestInput = Omit<ConstructorParameters<typeof ImageRequest>[0], "http"> & {
-  readonly http?: HttpOptions.Input
-}
-
-export class GeneratedImage extends Schema.Class<GeneratedImage>("Image.Generated")({
-  mediaType: Schema.String,
-  data: Schema.Union([Schema.String, Schema.Uint8Array]),
-  providerMetadata: Schema.optional(ProviderMetadata),
-}) {}
-
-export class ImageResponse extends Schema.Class<ImageResponse>("Image.Response")({
-  images: Schema.Array(GeneratedImage),
-  usage: Schema.optional(Usage),
-  providerMetadata: Schema.optional(ProviderMetadata),
-}) {
-  get image() {
-    return this.images[0]
-  }
-}
-
-export const request = (input: ImageRequest | ImageRequestInput) => {
-  if (input instanceof ImageRequest) return input
-  return new ImageRequest({
-    ...input,
-    http: input.http === undefined ? undefined : HttpOptions.make(input.http),
-  })
-}
-
-export const generate = (input: ImageRequest | ImageRequestInput) =>
-  Effect.try({
-    try: () => request(input),
-    catch: (error) =>
-      new LLMError({
-        module: "Image",
-        method: "generate",
-        reason: new InvalidRequestReason({ message: error instanceof Error ? error.message : String(error) }),
-      }),
-  }).pipe(Effect.flatMap(ImageClient.generate))
-
-export const Image = {
-  request,
-  generate,
-} as const

packages/ai/src/index.ts

@@ -1,5 +1,4 @@
 export { LLMClient } from "./route/client"
-export { ImageClient } from "./image-client"
 export { Auth } from "./route/auth"
 export { Provider } from "./provider"
 export { ProviderPackage } from "./provider-package"
@@ -11,9 +10,6 @@ export type {
   Service as LLMClientService,
 } from "./route/client"
 export * from "./schema"
-export { GeneratedImage, ImageModel, ImageRequest, ImageResponse, ImageSize } from "./image"
-export type { ImageModelDefaults, ImageRequestInput, ImageRoute } from "./image"
-export { Image } from "./image"
 export { Tool, ToolFailure, toDefinitions } from "./tool"
 export { ToolRuntime } from "./tool-runtime"
 export type { DispatchResult as ToolDispatchResult, ToolSettlement } from "./tool-runtime"

packages/ai/src/protocols/anthropic-messages.ts

@@ -703,14 +703,7 @@ const onContentBlockStart = (state: ParserState, event: AnthropicEvent): StepRes
           providerExecuted: block.type === "server_tool_use",
         }),
       },
-      [
-        ...events,
-        LLMEvent.toolInputStart({
-          id: block.id ?? String(event.index),
-          name: block.name ?? "",
-          providerExecuted: block.type === "server_tool_use" ? true : undefined,
-        }),
-      ],
+      [...events, LLMEvent.toolInputStart({ id: block.id ?? String(event.index), name: block.name ?? "" })],
     ]
   }
 

packages/ai/src/protocols/bedrock-converse.ts

@@ -561,9 +561,7 @@ const step = (state: ParserState, event: BedrockEvent) =>
       return [
         {
           ...state,
-          hasToolCalls:
-            resultEvents.some((event) => LLMEvent.is.toolCall(event) || LLMEvent.is.toolInputError(event)) ||
-            state.hasToolCalls,
+          hasToolCalls: resultEvents.some(LLMEvent.is.toolCall) ? true : state.hasToolCalls,
           lifecycle,
           tools: result.tools,
           reasoningSignatures: Object.fromEntries(

packages/ai/src/protocols/index.ts

@@ -2,7 +2,6 @@ export * as AnthropicMessages from "./anthropic-messages"
 export * as BedrockConverse from "./bedrock-converse"
 export * as Gemini from "./gemini"
 export * as OpenAIChat from "./openai-chat"
-export * as OpenAIImages from "./openai-images"
 export * as OpenAICompatibleChat from "./openai-compatible-chat"
 export * as OpenAICompatibleResponses from "./openai-compatible-responses"
 export * as OpenAIResponses from "./openai-responses"

packages/ai/src/protocols/openai-chat.ts

@@ -77,7 +77,6 @@ const OpenAIChatMessage = Schema.Union([
     reasoning_content: Schema.optional(Schema.String),
     reasoning: Schema.optional(Schema.String),
     reasoning_text: Schema.optional(Schema.String),
-    reasoning_details: optionalArray(Schema.Unknown),
   }),
   Schema.Struct({ role: Schema.Literal("tool"), tool_call_id: Schema.String, content: Schema.String }),
 ]).pipe(Schema.toTaggedUnion("role"))
@@ -150,7 +149,6 @@ const OpenAIChatDelta = Schema.Struct({
   reasoning_content: optionalNull(Schema.String),
   reasoning: optionalNull(Schema.String),
   reasoning_text: optionalNull(Schema.String),
-  reasoning_details: optionalNull(Schema.Array(Schema.Unknown)),
   tool_calls: optionalNull(Schema.Array(OpenAIChatToolCallDelta)),
 })
 
@@ -166,23 +164,13 @@ export const OpenAIChatEvent = Schema.Struct({
 export type OpenAIChatEvent = Schema.Schema.Type<typeof OpenAIChatEvent>
 type OpenAIChatRequestMessage = LLMRequest["messages"][number]
 
-interface PendingToolDelta {
-  readonly id?: string
-  readonly name?: string
-  readonly input: string
-}
-
 export interface ParserState {
   readonly tools: ToolStream.State<number>
-  readonly pendingTools: Partial<Record<number, PendingToolDelta>>
   readonly toolCallEvents: ReadonlyArray<LLMEvent>
   readonly usage?: Usage
   readonly finishReason?: FinishReason
   readonly lifecycle: Lifecycle.State
   readonly reasoningField?: "reasoning" | "reasoning_content" | "reasoning_text"
-  readonly reasoningDetails: Array<unknown>
-  readonly reasoningDetailsObserved: boolean
-  readonly reasoningEmitted: boolean
 }
 
 // =============================================================================
@@ -228,15 +216,7 @@ const openAICompatibleReasoningContent = (native: unknown) =>
 const reasoningField = (part: ReasoningPart) => {
   const field = part.providerMetadata?.openai?.reasoningField
   if (field === "reasoning" || field === "reasoning_content" || field === "reasoning_text") return field
-}
-
-const reasoningDetails = (parts: ReadonlyArray<ReasoningPart>, native: unknown) => {
-  const observed = parts.flatMap((part) => {
-    const details = part.providerMetadata?.openai?.reasoningDetails
-    return Array.isArray(details) ? details : []
-  })
-  if (parts.some((part) => Array.isArray(part.providerMetadata?.openai?.reasoningDetails))) return observed
-  if (isRecord(native) && Array.isArray(native.reasoning_details)) return native.reasoning_details
+  return "reasoning_content"
 }
 
 const lowerUserMessage = Effect.fn("OpenAIChat.lowerUserMessage")(function* (message: OpenAIChatRequestMessage) {
@@ -280,28 +260,19 @@ const lowerAssistantMessage = Effect.fn("OpenAIChat.lowerAssistantMessage")(func
     }
   }
   const text = reasoning.map((part) => part.text).join("")
-  const details = reasoningDetails(reasoning, message.native?.openaiCompatible)
-  const observedField = reasoning.map(reasoningField).find((value) => value !== undefined)
-  const nativeReasoning = openAICompatibleReasoningContent(message.native?.openaiCompatible)
-  const fullyStructured = reasoning.every((part) => Array.isArray(part.providerMetadata?.openai?.reasoningDetails))
-  const field = (() => {
-    if (reasoning.length === 0) return
-    if (observedField !== undefined) return observedField
-    if (nativeReasoning !== undefined) return "reasoning_content"
-    if (!fullyStructured) return "reasoning_content"
-  })()
-  const reasoningContent = (() => {
-    if (reasoning.length === 0) return nativeReasoning
-    if (field === "reasoning_content") return text
-  })()
+  const field = reasoning[0] ? reasoningField(reasoning[0]) : "reasoning_content"
   return {
     role: "assistant" as const,
     content: content.length === 0 ? null : ProviderShared.joinText(content),
     tool_calls: toolCalls.length === 0 ? undefined : toolCalls,
-    reasoning_content: reasoningContent,
+    reasoning_content:
+      reasoning.length === 0
+        ? openAICompatibleReasoningContent(message.native?.openaiCompatible)
+        : field === "reasoning_content"
+          ? text
+          : undefined,
     reasoning: reasoning.length > 0 && field === "reasoning" ? text : undefined,
     reasoning_text: reasoning.length > 0 && field === "reasoning_text" ? text : undefined,
-    reasoning_details: details,
   }
 })
 
@@ -452,59 +423,6 @@ const reasoningDelta = (delta: Schema.Schema.Type<typeof OpenAIChatDelta> | null
   if (delta?.reasoning_text) return { field: "reasoning_text", text: delta.reasoning_text } as const
 }
 
-const detailText = (details: ReadonlyArray<unknown>) => {
-  const text = details.flatMap((detail) => {
-    if (!isRecord(detail)) return []
-    if (detail.type === "reasoning.text" && typeof detail.text === "string" && detail.text) return [detail.text]
-    if (detail.type === "reasoning.summary" && typeof detail.summary === "string" && detail.summary)
-      return [detail.summary]
-    return []
-  })
-  if (text.length > 0) return text.join("")
-}
-
-const appendReasoningDetails = (result: Array<unknown>, details: ReadonlyArray<unknown>) => {
-  for (const detail of details) {
-    const previous = result.at(-1)
-    if (
-      !isRecord(previous) ||
-      previous.type !== "reasoning.text" ||
-      !isRecord(detail) ||
-      detail.type !== "reasoning.text" ||
-      conflictingReasoningTextDetails(previous, detail)
-    ) {
-      result.push(detail)
-      continue
-    }
-    result[result.length - 1] = {
-      ...previous,
-      ...Object.fromEntries(Object.entries(detail).filter((entry) => entry[1] !== undefined)),
-      text: `${typeof previous.text === "string" ? previous.text : ""}${typeof detail.text === "string" ? detail.text : ""}`,
-      signature: mergeDetailValue(previous.signature, detail.signature),
-      format: mergeDetailValue(previous.format, detail.format),
-    }
-  }
-}
-
-const mergeDetailValue = (previous: unknown, current: unknown) =>
-  previous || current || (previous !== undefined ? previous : current)
-
-const conflictingReasoningTextDetails = (previous: Record<string, unknown>, current: Record<string, unknown>) =>
-  conflictingDetailValue(previous.id, current.id) ||
-  conflictingDetailValue(previous.index, current.index) ||
-  conflictingDetailValue(previous.format, current.format) ||
-  (Boolean(previous.signature) && Boolean(current.signature) && previous.signature !== current.signature)
-
-const conflictingDetailValue = (previous: unknown, current: unknown) =>
-  previous !== undefined && previous !== null && current !== undefined && current !== null && previous !== current
-
-const reasoningMetadata = (field: ParserState["reasoningField"], details?: ReadonlyArray<unknown>) => ({
-  openai: {
-    ...(field ? { reasoningField: field } : {}),
-    ...(details ? { reasoningDetails: details } : {}),
-  },
-})
-
 const step = (state: ParserState, event: OpenAIChatEvent) =>
   Effect.gen(function* () {
     const events: LLMEvent[] = []
@@ -514,56 +432,29 @@ const step = (state: ParserState, event: OpenAIChatEvent) =>
     const delta = choice?.delta
     const toolDeltas = delta?.tool_calls ?? []
     let tools = state.tools
-    let pendingTools = state.pendingTools
 
     let lifecycle = state.lifecycle
 
     const reasoning = reasoningDelta(delta)
-    const reasoningField = state.reasoningField ?? (!state.lifecycle.text.has("text-0") ? reasoning?.field : undefined)
-    const detailDelta = Array.isArray(delta?.reasoning_details) ? delta.reasoning_details : undefined
-    if (detailDelta !== undefined) appendReasoningDetails(state.reasoningDetails, detailDelta)
-    const reasoningDetailsObserved = state.reasoningDetailsObserved || detailDelta !== undefined
-    const deltaMetadata = reasoningMetadata(reasoningField)
-    const text = detailDelta?.length ? (detailText(detailDelta) ?? reasoning?.text) : reasoning?.text
-    if (!state.lifecycle.text.has("text-0") && text !== undefined)
-      lifecycle = Lifecycle.reasoningDelta(lifecycle, events, "reasoning-0", text, deltaMetadata)
-    else if (
-      reasoningDetailsObserved &&
-      !lifecycle.reasoning.has("reasoning-0") &&
-      (Boolean(delta?.content) || toolDeltas.length > 0)
-    )
-      lifecycle = Lifecycle.reasoningStart(lifecycle, events, "reasoning-0", deltaMetadata)
-    const reasoningEmitted = state.reasoningEmitted || lifecycle.reasoning.has("reasoning-0")
+    const reasoningField = state.reasoningField ?? reasoning?.field
+    if (reasoning)
+      lifecycle = Lifecycle.reasoningDelta(lifecycle, events, "reasoning-0", reasoning.text, {
+        openai: { reasoningField: reasoningField ?? reasoning.field },
+      })
 
     if (delta?.content) {
-      lifecycle = Lifecycle.reasoningEnd(
-        lifecycle,
-        events,
-        "reasoning-0",
-        reasoningMetadata(reasoningField, reasoningDetailsObserved ? state.reasoningDetails : undefined),
-      )
+      lifecycle = Lifecycle.reasoningEnd(lifecycle, events, "reasoning-0")
       lifecycle = Lifecycle.textDelta(lifecycle, events, "text-0", delta.content)
     }
 
+    if (toolDeltas.length) lifecycle = Lifecycle.reasoningEnd(lifecycle, events, "reasoning-0")
+
     for (const tool of toolDeltas) {
-      const current = tools[tool.index]
-      const pending = pendingTools[tool.index]
-      const id = current?.id ?? pending?.id ?? (tool.id || undefined)
-      const name = current?.name ?? pending?.name ?? (tool.function?.name || undefined)
-      const text = `${pending?.input ?? ""}${tool.function?.arguments ?? ""}`
-      if (!current && (!id || !name)) {
-        pendingTools = { ...pendingTools, [tool.index]: { id: id || undefined, name: name || undefined, input: text } }
-        continue
-      }
-      if (pending) {
-        pendingTools = { ...pendingTools }
-        delete pendingTools[tool.index]
-      }
       const result = ToolStream.appendOrStart(
         ADAPTER,
         tools,
         tool.index,
-        { id: id || undefined, name: name || undefined, text },
+        { id: tool.id ?? undefined, name: tool.function?.name ?? undefined, text: tool.function?.arguments ?? "" },
         "OpenAI Chat tool call delta is missing id or name",
       )
       if (ToolStream.isError(result)) return yield* result
@@ -572,11 +463,8 @@ const step = (state: ParserState, event: OpenAIChatEvent) =>
       events.push(...result.events)
     }
 
-    if (finishReason !== undefined && state.finishReason === undefined && Object.keys(pendingTools).length > 0)
-      return yield* ProviderShared.eventError(ADAPTER, "OpenAI Chat tool call delta is missing id or name")
-
     // Finalize accumulated tool inputs eagerly when finish_reason arrives so
-    // valid calls and malformed local calls settle independently.
+    // JSON parse failures fail the stream at the boundary rather than at halt.
     const finished =
       finishReason !== undefined && state.finishReason === undefined && Object.keys(tools).length > 0
         ? yield* ToolStream.finishAll(ADAPTER, tools)
@@ -585,15 +473,11 @@ const step = (state: ParserState, event: OpenAIChatEvent) =>
     return [
       {
         tools: finished?.tools ?? tools,
-        pendingTools,
         toolCallEvents: finished?.events ?? state.toolCallEvents,
         usage,
         finishReason,
         lifecycle,
         reasoningField,
-        reasoningDetails: state.reasoningDetails,
-        reasoningDetailsObserved,
-        reasoningEmitted,
       },
       events,
     ] as const
@@ -603,16 +487,7 @@ const finishEvents = (state: ParserState): ReadonlyArray<LLMEvent> => {
   const events: LLMEvent[] = []
   const hasToolCalls = state.toolCallEvents.length > 0
   const reason = state.finishReason === "stop" && hasToolCalls ? "tool-calls" : state.finishReason
-  const metadata = reasoningMetadata(
-    state.reasoningField,
-    state.reasoningDetailsObserved ? state.reasoningDetails : undefined,
-  )
-  const started =
-    state.reasoningDetailsObserved && !state.reasoningEmitted
-      ? Lifecycle.reasoningStart(state.lifecycle, events, "reasoning-0", reasoningMetadata(state.reasoningField))
-      : state.lifecycle
-  const ended = Lifecycle.reasoningEnd(started, events, "reasoning-0", metadata)
-  const lifecycle = state.toolCallEvents.length ? Lifecycle.stepStart(ended, events) : ended
+  const lifecycle = state.toolCallEvents.length ? Lifecycle.stepStart(state.lifecycle, events) : state.lifecycle
   events.push(...state.toolCallEvents)
   if (reason) Lifecycle.finish(lifecycle, events, { reason, usage: state.usage })
   return events
@@ -637,13 +512,9 @@ export const protocol = Protocol.make({
     event: Protocol.jsonEvent(OpenAIChatEvent),
     initial: () => ({
       tools: ToolStream.empty<number>(),
-      pendingTools: {},
       toolCallEvents: [],
       lifecycle: Lifecycle.initial(),
       reasoningField: undefined,
-      reasoningDetails: [],
-      reasoningDetailsObserved: false,
-      reasoningEmitted: false,
     }),
     step,
     onHalt: finishEvents,

packages/ai/src/protocols/openai-images.ts

@@ -1,208 +0,0 @@
-import { Effect, Encoding, Schema } from "effect"
-import { Headers, HttpClientRequest } from "effect/unstable/http"
-import {
-  ImageModel,
-  GeneratedImage,
-  ImageResponse,
-  type ImageRequest,
-  type ImageModelDefaults,
-  type ImageRoute,
-} from "../image"
-import { Auth, type Definition as AuthDefinition } from "../route/auth"
-import { InvalidProviderOutputReason, LLMError, Usage, mergeHttpOptions, mergeJsonRecords } from "../schema"
-import { ProviderShared } from "./shared"
-import { OpenAIImage } from "./utils/openai-image"
-
-const ADAPTER = "openai-images"
-export const DEFAULT_BASE_URL = "https://api.openai.com/v1"
-export const PATH = "/images/generations"
-
-export interface OpenAIImageOptions {
-  readonly quality?: "auto" | "low" | "medium" | "high"
-  readonly background?: "auto" | "opaque" | "transparent"
-  readonly moderation?: "auto" | "low"
-  readonly outputFormat?: "png" | "jpeg" | "webp"
-  readonly outputCompression?: number
-}
-
-const OpenAIImageBody = Schema.Struct({
-  model: Schema.String,
-  prompt: Schema.String,
-  n: Schema.optional(Schema.Int.check(Schema.isGreaterThanOrEqualTo(1))),
-  size: Schema.optional(Schema.String),
-  quality: Schema.optional(Schema.Literals(["auto", "low", "medium", "high"])),
-  background: Schema.optional(Schema.Literals(["auto", "opaque", "transparent"])),
-  moderation: Schema.optional(Schema.Literals(["auto", "low"])),
-  output_format: Schema.optional(Schema.Literals(["png", "jpeg", "webp"])),
-  output_compression: Schema.optional(Schema.Int.check(Schema.isBetween({ minimum: 0, maximum: 100 }))),
-})
-export type OpenAIImageBody = Schema.Schema.Type<typeof OpenAIImageBody>
-
-const OpenAIImageResponse = Schema.Struct({
-  data: Schema.Array(
-    Schema.Struct({
-      b64_json: Schema.optional(Schema.String),
-      url: Schema.optional(Schema.String),
-      revised_prompt: Schema.optional(Schema.String),
-    }),
-  ),
-  output_format: Schema.optional(Schema.String),
-  usage: Schema.optional(
-    Schema.Struct({
-      input_tokens: Schema.optional(Schema.Number),
-      output_tokens: Schema.optional(Schema.Number),
-      total_tokens: Schema.optional(Schema.Number),
-      input_tokens_details: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
-      output_tokens_details: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
-    }),
-  ),
-})
-
-export interface ModelInput {
-  readonly id: string
-  readonly auth: AuthDefinition
-  readonly baseURL?: string
-  readonly headers?: Record<string, string>
-  readonly defaults?: ImageModelDefaults
-}
-
-const providerOptions = (request: ImageRequest): OpenAIImageOptions => ({
-  ...request.model.defaults?.providerOptions?.openai,
-  ...request.providerOptions?.openai,
-})
-
-const body = (request: ImageRequest): OpenAIImageBody => {
-  const options = providerOptions(request)
-  return {
-    model: request.model.id,
-    prompt: request.prompt,
-    n: request.count,
-    size: request.size === undefined ? undefined : `${request.size.width}x${request.size.height}`,
-    quality: options.quality,
-    background: options.background,
-    moderation: options.moderation,
-    output_format: options.outputFormat,
-    output_compression: options.outputCompression,
-  }
-}
-
-const invalidOutput = (message: string) =>
-  new LLMError({
-    module: ADAPTER,
-    method: "generate",
-    reason: new InvalidProviderOutputReason({ message, route: ADAPTER }),
-  })
-
-const applyQuery = (url: string, query: Record<string, string> | undefined) => {
-  if (!query) return url
-  const next = new URL(url)
-  Object.entries(query).forEach(([key, value]) => next.searchParams.set(key, value))
-  return next.toString()
-}
-
-const PROTOCOL_BODY_FIELDS = new Set([
-  "model",
-  "prompt",
-  "n",
-  "size",
-  "quality",
-  "background",
-  "moderation",
-  "output_format",
-  "output_compression",
-])
-
-const bodyWithOverlay = Effect.fn("OpenAIImages.bodyWithOverlay")(function* (
-  imageBody: OpenAIImageBody,
-  overlay: Record<string, unknown> | undefined,
-) {
-  if (!overlay) return imageBody
-  const reserved = Object.keys(overlay).filter((key) => PROTOCOL_BODY_FIELDS.has(key))
-  if (reserved.length > 0)
-    return yield* ProviderShared.invalidRequest(
-      `http.body cannot overlay protocol-owned field(s): ${reserved.join(", ")}`,
-    )
-  return mergeJsonRecords(imageBody, overlay) ?? imageBody
-})
-
-export const model = (input: ModelInput) => {
-  const route: ImageRoute = {
-    id: ADAPTER,
-    generate: Effect.fn("OpenAIImages.generate")(function* (request: ImageRequest, execute) {
-      if (request.aspectRatio !== undefined)
-        return yield* ProviderShared.invalidRequest("OpenAI Images does not support the common aspectRatio option")
-      if (request.seed !== undefined)
-        return yield* ProviderShared.invalidRequest("OpenAI Images does not support the common seed option")
-
-      const requestBody = yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(OpenAIImageBody))(body(request))
-      const http = mergeHttpOptions(request.model.defaults?.http, request.http)
-      const overlaidBody = yield* bodyWithOverlay(requestBody, http?.body)
-      const text = ProviderShared.encodeJson(overlaidBody)
-      const url = applyQuery(`${(input.baseURL ?? DEFAULT_BASE_URL).replace(/\/$/, "")}${PATH}`, http?.query)
-      const headers = yield* Auth.toEffect(input.auth)({
-        request,
-        method: "POST",
-        url,
-        body: text,
-        headers: Headers.fromInput({ ...input.headers, ...http?.headers }),
-      })
-      const response = yield* execute(
-        HttpClientRequest.post(url).pipe(
-          HttpClientRequest.setHeaders(headers),
-          HttpClientRequest.bodyText(text, "application/json"),
-        ),
-      )
-      const payload = yield* response.json.pipe(
-        Effect.mapError(() => invalidOutput("Failed to read the OpenAI Images response")),
-      )
-      const decoded = yield* Schema.decodeUnknownEffect(OpenAIImageResponse)(payload).pipe(
-        Effect.mapError(() => invalidOutput("OpenAI Images returned an invalid response")),
-      )
-      const format = decoded.output_format ?? providerOptions(request).outputFormat ?? "png"
-      const images = yield* Effect.forEach(decoded.data, (item, index) => {
-        if (item.b64_json)
-          return Effect.fromResult(Encoding.decodeBase64(item.b64_json)).pipe(
-            Effect.mapError(() => invalidOutput(`OpenAI Images result ${index} contains invalid base64 data`)),
-            Effect.map(
-              (data) =>
-                new GeneratedImage({
-                  mediaType: `image/${format}`,
-                  data,
-                  providerMetadata:
-                    item.revised_prompt === undefined ? undefined : { openai: { revisedPrompt: item.revised_prompt } },
-                }),
-            ),
-          )
-        if (item.url)
-          return Effect.succeed(
-            new GeneratedImage({
-              mediaType: `image/${format}`,
-              data: item.url,
-              providerMetadata:
-                item.revised_prompt === undefined ? undefined : { openai: { revisedPrompt: item.revised_prompt } },
-            }),
-          )
-        return Effect.fail(invalidOutput(`OpenAI Images result ${index} has neither image data nor a URL`))
-      })
-      if (images.length === 0) return yield* invalidOutput("OpenAI Images returned no images")
-      return new ImageResponse({
-        images,
-        usage:
-          decoded.usage === undefined
-            ? undefined
-            : new Usage({
-                inputTokens: decoded.usage.input_tokens,
-                outputTokens: decoded.usage.output_tokens,
-                totalTokens: decoded.usage.total_tokens,
-                providerMetadata: { openai: decoded.usage },
-              }),
-        providerMetadata: { openai: { outputFormat: format } },
-      })
-    }),
-  }
-  return ImageModel.make({ id: input.id, provider: "openai", route, defaults: input.defaults })
-}
-
-export const OpenAIImages = {
-  model,
-} as const

packages/ai/src/protocols/openai-responses.ts

@@ -1,4 +1,4 @@
-import { Effect, Encoding, Schema } from "effect"
+import { Effect, Schema } from "effect"
 import { Route } from "../route/client"
 import { Auth } from "../route/auth"
 import { Endpoint } from "../route/endpoint"
@@ -25,7 +25,6 @@ import { OpenAIOptions } from "./utils/openai-options"
 import { Lifecycle } from "./utils/lifecycle"
 import { ToolSchemaProjection } from "./utils/tool-schema"
 import { ToolStream } from "./utils/tool-stream"
-import { OpenAIImage } from "./utils/openai-image"
 
 const ADAPTER = "openai-responses"
 export const DEFAULT_BASE_URL = "https://api.openai.com/v1"
@@ -114,24 +113,11 @@ const OpenAIResponsesTool = Schema.Struct({
   parameters: JsonObject,
   strict: Schema.optional(Schema.Boolean),
 })
-const OpenAIResponsesImageGenerationTool = Schema.Struct({
-  type: Schema.tag("image_generation"),
-  action: Schema.optional(Schema.Literals(["auto", "generate", "edit"])),
-  background: Schema.optional(Schema.Literals(["auto", "opaque", "transparent"])),
-  input_fidelity: Schema.optional(Schema.Literals(["low", "high"])),
-  output_compression: Schema.optional(Schema.Int.check(Schema.isBetween({ minimum: 0, maximum: 100 }))),
-  output_format: Schema.optional(Schema.Literals(["png", "jpeg", "webp"])),
-  partial_images: Schema.optional(Schema.Int.check(Schema.isGreaterThanOrEqualTo(0))),
-  quality: Schema.optional(Schema.Literals(["auto", "low", "medium", "high"])),
-  size: Schema.optional(OpenAIImage.Size),
-})
-const OpenAIResponsesTools = Schema.Union([OpenAIResponsesTool, OpenAIResponsesImageGenerationTool])
-type OpenAIResponsesTool = Schema.Schema.Type<typeof OpenAIResponsesTools>
+type OpenAIResponsesTool = Schema.Schema.Type<typeof OpenAIResponsesTool>
 
 const OpenAIResponsesToolChoice = Schema.Union([
   Schema.Literals(["auto", "none", "required"]),
   Schema.Struct({ type: Schema.tag("function"), name: Schema.String }),
-  Schema.Struct({ type: Schema.tag("image_generation") }),
 ])
 
 // Fields shared between the HTTP body and the WebSocket `response.create`
@@ -142,7 +128,7 @@ const OpenAIResponsesCoreFields = {
   model: Schema.String,
   input: Schema.Array(OpenAIResponsesInputItem),
   instructions: Schema.optional(Schema.String),
-  tools: optionalArray(OpenAIResponsesTools),
+  tools: optionalArray(OpenAIResponsesTool),
   tool_choice: Schema.optional(OpenAIResponsesToolChoice),
   store: Schema.optional(Schema.Boolean),
   service_tier: Schema.optional(OpenAIOptions.OpenAIServiceTier),
@@ -208,8 +194,6 @@ const OpenAIResponsesStreamItem = Schema.Struct({
   outputs: Schema.optional(Schema.Unknown),
   server_label: Schema.optional(Schema.String),
   output: Schema.optional(Schema.Unknown),
-  result: Schema.optional(Schema.String),
-  output_format: Schema.optional(Schema.Literals(["png", "jpeg", "webp"])),
   error: Schema.optional(Schema.Unknown),
   encrypted_content: optionalNull(Schema.String),
 })
@@ -274,41 +258,21 @@ const invalid = ProviderShared.invalidRequest
 // =============================================================================
 // Request Lowering
 // =============================================================================
-const nativeImageToolInput = (tool: ToolDefinition) => {
-  const native = tool.native?.openai
-  return ProviderShared.isRecord(native) && native.type === "image_generation" ? native : undefined
-}
-
-const nativeImageTool = (tool: ToolDefinition) => {
-  const native = nativeImageToolInput(tool)
-  return Schema.is(OpenAIResponsesImageGenerationTool)(native) ? native : undefined
-}
-
-const lowerTool = Effect.fn("OpenAIResponses.lowerTool")(function* (tool: ToolDefinition, inputSchema: JsonSchema) {
-  const native = nativeImageToolInput(tool)
-  if (native !== undefined) {
-    if (Schema.is(OpenAIResponsesImageGenerationTool)(native)) return native
-    return yield* invalid("OpenAI Responses image generation tool options are invalid")
-  }
-  return {
-    type: "function" as const,
-    name: tool.name,
-    description: tool.description,
-    parameters: ToolSchemaProjection.openAI(inputSchema),
-    // TODO: Read this from OpenAI-specific tool options so direct LLM callers can opt into strict schemas.
-    strict: false,
-  }
+const lowerTool = (tool: ToolDefinition, inputSchema: JsonSchema): OpenAIResponsesTool => ({
+  type: "function",
+  name: tool.name,
+  description: tool.description,
+  parameters: ToolSchemaProjection.openAI(inputSchema),
+  // TODO: Read this from OpenAI-specific tool options so direct LLM callers can opt into strict schemas.
+  strict: false,
 })
 
-const lowerToolChoice = (toolChoice: NonNullable<LLMRequest["toolChoice"]>, tools: ReadonlyArray<ToolDefinition>) =>
+const lowerToolChoice = (toolChoice: NonNullable<LLMRequest["toolChoice"]>) =>
   ProviderShared.matchToolChoice("OpenAI Responses", toolChoice, {
     auto: () => "auto" as const,
     none: () => "none" as const,
     required: () => "required" as const,
-    tool: (name) =>
-      tools.some((tool) => tool.name === name && nativeImageTool(tool) !== undefined)
-        ? ({ type: "image_generation" } as const)
-        : { type: "function" as const, name },
+    tool: (name) => ({ type: "function" as const, name }),
   })
 
 const lowerToolCall = (part: ToolCallPart): OpenAIResponsesInputItem => ({
@@ -456,13 +420,6 @@ const lowerMessages = Effect.fn("OpenAIResponses.lowerMessages")(function* (requ
           const itemID = hostedToolItemID(part)
           if (store !== false && itemID && !hostedToolReferences.has(itemID))
             input.push({ type: "item_reference", id: itemID })
-          if (store === false && part.name === "image_generation" && part.result.type === "content") {
-            const content: ReadonlyArray<ToolContent> = part.result.value
-            input.push({
-              role: "user",
-              content: yield* Effect.forEach(content, lowerToolResultContentItem),
-            })
-          }
           if (itemID) hostedToolReferences.add(itemID)
           continue
         }
@@ -528,10 +485,10 @@ const fromRequest = Effect.fn("OpenAIResponses.fromRequest")(function* (request:
     tools:
       request.tools.length === 0
         ? undefined
-        : yield* Effect.forEach(request.tools, (tool) =>
+        : request.tools.map((tool) =>
             lowerTool(tool, ToolSchemaProjection.modelCompatibility(tool.inputSchema, toolSchemaCompatibility)),
           ),
-    tool_choice: request.toolChoice ? yield* lowerToolChoice(request.toolChoice, request.tools) : undefined,
+    tool_choice: request.toolChoice ? yield* lowerToolChoice(request.toolChoice) : undefined,
     stream: true as const,
     max_output_tokens: generation?.maxTokens,
     temperature: generation?.temperature,
@@ -617,29 +574,14 @@ const isReasoningItem = (
 
 // Round-trip the full item as the structured result so consumers can extract
 // outputs / sources / status without re-decoding.
-const hostedToolResult = Effect.fn("OpenAIResponses.hostedToolResult")(function* (item: OpenAIResponsesStreamItem) {
+const hostedToolResult = (item: OpenAIResponsesStreamItem) => {
   const isError = typeof item.error !== "undefined" && item.error !== null
-  if (item.type === "image_generation_call" && item.result) {
-    yield* Effect.fromResult(Encoding.decodeBase64(item.result)).pipe(
-      Effect.mapError(() => ProviderShared.eventError(ADAPTER, "OpenAI Responses returned invalid image base64")),
-    )
-    return {
-      type: "content" as const,
-      value: [
-        {
-          type: "file" as const,
-          uri: `data:image/${item.output_format ?? "png"};base64,${item.result}`,
-          mime: `image/${item.output_format ?? "png"}`,
-        },
-      ],
-    }
-  }
   return isError ? { type: "error" as const, value: item.error } : { type: "json" as const, value: item }
-})
+}
 
-const hostedToolEvents = Effect.fn("OpenAIResponses.hostedToolEvents")(function* (
+const hostedToolEvents = (
   item: OpenAIResponsesStreamItem & { type: HostedToolType; id: string },
-) {
+): ReadonlyArray<LLMEvent> => {
   const tool = HOSTED_TOOLS[item.type]
   const providerMetadata = openaiMetadata({ itemId: item.id })
   return [
@@ -653,12 +595,12 @@ const hostedToolEvents = Effect.fn("OpenAIResponses.hostedToolEvents")(function*
     LLMEvent.toolResult({
       id: item.id,
       name: tool.name,
-      result: yield* hostedToolResult(item),
+      result: hostedToolResult(item),
       providerExecuted: true,
       providerMetadata,
     }),
   ]
-})
+}
 
 type StepResult = readonly [ParserState, ReadonlyArray<LLMEvent>]
 
@@ -893,9 +835,7 @@ const onOutputItemDone = Effect.fn("OpenAIResponses.onOutputItemDone")(function*
       {
         ...state,
         lifecycle,
-        hasFunctionCall:
-          resultEvents.some((event) => LLMEvent.is.toolCall(event) || LLMEvent.is.toolInputError(event)) ||
-          state.hasFunctionCall,
+        hasFunctionCall: resultEvents.some(LLMEvent.is.toolCall) ? true : state.hasFunctionCall,
         tools: result.tools,
       },
       events,
@@ -905,7 +845,7 @@ const onOutputItemDone = Effect.fn("OpenAIResponses.onOutputItemDone")(function*
   if (isHostedToolItem(item)) {
     const events: LLMEvent[] = []
     const lifecycle = Lifecycle.stepStart(state.lifecycle, events)
-    events.push(...(yield* hostedToolEvents(item)))
+    events.push(...hostedToolEvents(item))
     return [{ ...state, lifecycle }, events] satisfies StepResult
   }
 

packages/ai/src/protocols/utils/lifecycle.ts

@@ -44,7 +44,7 @@ export const reasoningDelta = (
   providerMetadata?: ProviderMetadata,
 ): State => {
   const started = reasoningStart(state, events, id, providerMetadata)
-  events.push(LLMEvent.reasoningDelta({ id, text, providerMetadata }))
+  events.push(LLMEvent.reasoningDelta({ id, text }))
   return started
 }
 

packages/ai/src/protocols/utils/openai-image.ts

@@ -1,20 +0,0 @@
-import { Schema } from "effect"
-
-const dimensions = (value: string) => {
-  const match = /^(\d+)x(\d+)$/.exec(value)
-  if (!match) return undefined
-  return { width: Number(match[1]), height: Number(match[2]) }
-}
-
-export const Size = Schema.String.check(
-  Schema.makeFilter((value) => {
-    if (value === "auto") return undefined
-    const parsed = dimensions(value)
-    if (!parsed) return "image size must be `auto` or `{width}x{height}`"
-    return parsed.width > 0 && parsed.height > 0 ? undefined : "image dimensions must be positive integers"
-  }),
-)
-
-export const OpenAIImage = {
-  Size,
-} as const

packages/ai/src/protocols/utils/tool-stream.ts

@@ -1,5 +1,5 @@
 import { Effect } from "effect"
-import { LLMError, LLMEvent, type ProviderMetadata, type ToolCall, type ToolInputError } from "../../schema"
+import { LLMError, LLMEvent, type ProviderMetadata, type ToolCall } from "../../schema"
 import { eventError, parseToolInput, type ToolAccumulator } from "../shared"
 
 type StreamKey = string | number
@@ -53,7 +53,6 @@ const inputStart = (tool: PendingTool) =>
   LLMEvent.toolInputStart({
     id: tool.id,
     name: tool.name,
-    providerExecuted: tool.providerExecuted ? true : undefined,
     providerMetadata: tool.providerMetadata,
   })
 
@@ -64,36 +63,19 @@ const inputDelta = (tool: PendingTool, text: string) =>
     text,
   })
 
-const toolCall = (route: string, tool: PendingTool, inputOverride?: string) => {
-  const raw = inputOverride ?? tool.input
-  return parseToolInput(route, tool.name, raw).pipe(
-    Effect.map((input): ToolCall | ToolInputError =>
-      LLMEvent.toolCall({
-        id: tool.id,
-        name: tool.name,
-        input,
-        providerExecuted: tool.providerExecuted ? true : undefined,
-        providerMetadata: tool.providerMetadata,
-      }),
-    ),
-    Effect.catch((error) =>
-      tool.providerExecuted
-        ? Effect.fail(error)
-        : Effect.succeed(
-            LLMEvent.toolInputError({
-              id: tool.id,
-              name: tool.name,
-              raw,
-            }),
-          ),
+const toolCall = (route: string, tool: PendingTool, inputOverride?: string) =>
+  parseToolInput(route, tool.name, inputOverride ?? tool.input).pipe(
+    Effect.map(
+      (input): ToolCall =>
+        LLMEvent.toolCall({
+          id: tool.id,
+          name: tool.name,
+          input,
+          providerExecuted: tool.providerExecuted ? true : undefined,
+          providerMetadata: tool.providerMetadata,
+        }),
     ),
   )
-}
-
-const finishEvents = (tool: PendingTool, event: ToolCall | ToolInputError): ReadonlyArray<LLMEvent> =>
-  event.type === "tool-input-error"
-    ? [event]
-    : [LLMEvent.toolInputEnd({ id: tool.id, name: tool.name, providerMetadata: tool.providerMetadata }), event]
 
 /** Store the updated tool and produce the optional public delta event. */
 const appendTool = <K extends StreamKey>(
@@ -140,8 +122,8 @@ export const appendOrStart = <K extends StreamKey>(
   missingToolMessage: string,
 ): AppendOutcome<K> | LLMError => {
   const current = tools[key]
-  const id = current?.id ?? delta.id
-  const name = current?.name ?? delta.name
+  const id = delta.id ?? current?.id
+  const name = delta.name ?? current?.name
   if (!id || !name) return eventError(route, missingToolMessage)
 
   const tool = {
@@ -176,9 +158,8 @@ export const appendExisting = <K extends StreamKey>(
 
 /**
  * Finalize one pending tool call: parse the accumulated raw JSON, remove it
- * from state, and return either a call or a non-executable local input error.
- * Missing keys are a no-op because some providers emit stop events for
- * non-tool content blocks.
+ * from state, and return the optional public `tool-call` event. Missing keys are
+ * a no-op because some providers emit stop events for non-tool content blocks.
  */
 export const finish = <K extends StreamKey>(route: string, tools: State<K>, key: K) =>
   Effect.gen(function* () {
@@ -186,7 +167,10 @@ export const finish = <K extends StreamKey>(route: string, tools: State<K>, key:
     if (!tool) return { tools }
     return {
       tools: withoutTool(tools, key),
-      events: finishEvents(tool, yield* toolCall(route, tool)),
+      events: [
+        LLMEvent.toolInputEnd({ id: tool.id, name: tool.name, providerMetadata: tool.providerMetadata }),
+        yield* toolCall(route, tool),
+      ],
     }
   })
 
@@ -201,14 +185,17 @@ export const finishWithInput = <K extends StreamKey>(route: string, tools: State
     if (!tool) return { tools }
     return {
       tools: withoutTool(tools, key),
-      events: finishEvents(tool, yield* toolCall(route, tool, input)),
+      events: [
+        LLMEvent.toolInputEnd({ id: tool.id, name: tool.name, providerMetadata: tool.providerMetadata }),
+        yield* toolCall(route, tool, input),
+      ],
     }
   })
 
 /**
  * Finalize every pending tool call at once. OpenAI Chat has this shape: it does
- * not emit per-tool stop events, so all accumulated calls finish independently
- * when the choice receives a terminal `finish_reason`.
+ * not emit per-tool stop events, so all accumulated calls finish when the choice
+ * receives a terminal `finish_reason`.
  */
 export const finishAll = <K extends StreamKey>(route: string, tools: State<K>) =>
   Effect.gen(function* () {
@@ -218,7 +205,12 @@ export const finishAll = <K extends StreamKey>(route: string, tools: State<K>) =
     return {
       tools: empty<K>(),
       events: yield* Effect.forEach(pending, (tool) =>
-        toolCall(route, tool).pipe(Effect.map((event) => finishEvents(tool, event))),
+        toolCall(route, tool).pipe(
+          Effect.map((call) => [
+            LLMEvent.toolInputEnd({ id: tool.id, name: tool.name, providerMetadata: tool.providerMetadata }),
+            call,
+          ]),
+        ),
       ).pipe(Effect.map((events) => events.flat())),
     }
   })

packages/ai/src/provider-error.ts

@@ -16,17 +16,13 @@ import {
 
 const patterns = [
   /prompt is too long/i,
-  /request_too_large/i,
   /input is too long for requested model/i,
   /exceeds the context window/i,
-  /exceeds (?:the )?(?:model'?s )?maximum context length(?: of [\d,]+ tokens?|\s*\([\d,]+\))/i,
   /input token count.*exceeds the maximum/i,
   /tokens in request more than max tokens allowed/i,
   /maximum prompt length is \d+/i,
   /reduce the length of the messages/i,
   /maximum context length is \d+ tokens/i,
-  /exceeds (?:the )?maximum allowed input length of [\d,]+ tokens?/i,
-  /input \(\d+ tokens\) is longer than the model'?s context length \(\d+ tokens\)/i,
   /exceeds the limit of \d+/i,
   /exceeds the available context size/i,
   /greater than the context length/i,
@@ -38,17 +34,11 @@ const patterns = [
   /input length.*exceeds.*context length/i,
   /prompt too long; exceeded (?:max )?context length/i,
   /too large for model with \d+ maximum context length/i,
-  /prompt has [\d,]+ tokens?, but the configured context size is [\d,]+ tokens?/i,
   /model_context_window_exceeded/i,
-  /too many tokens/i,
-  /token limit exceeded/i,
 ]
 
-const exclusions = [/^(throttling error|service unavailable):/i, /rate limit/i, /too many requests/i]
-
 export const isContextOverflow = (message: string) =>
-  !exclusions.some((pattern) => pattern.test(message)) &&
-  (patterns.some((pattern) => pattern.test(message)) || /^4(00|13)\s*(status code)?\s*\(no body\)/i.test(message))
+  patterns.some((pattern) => pattern.test(message)) || /^4(00|13)\s*(status code)?\s*\(no body\)/i.test(message)
 
 export const isContextOverflowFailure = (failure: unknown) =>
   failure instanceof LLMError

packages/ai/src/providers/openai.ts

@@ -1,14 +1,12 @@
 import { AuthOptions, type ProviderAuthOption } from "../route/auth-options"
 import type { Route, RouteDefaultsInput } from "../route/client"
 import type { ProviderPackage } from "../provider-package"
-import { HttpOptions, ProviderID, ToolDefinition, mergeHttpOptions, type ModelID } from "../schema"
+import { ProviderID, type ModelID } from "../schema"
 import * as OpenAIChat from "../protocols/openai-chat"
 import * as OpenAIResponses from "../protocols/openai-responses"
 import { withOpenAIOptions, type OpenAIProviderOptionsInput } from "./openai-options"
-import { OpenAIImages, type OpenAIImageOptions } from "../protocols/openai-images"
 
 export type { OpenAIOptionsInput, OpenAIResponseIncludable } from "./openai-options"
-export type { OpenAIImageOptions } from "../protocols/openai-images"
 
 export const id = ProviderID.make("openai")
 
@@ -22,44 +20,8 @@ export type Config = RouteDefaultsInput &
     readonly baseURL?: string
     readonly queryParams?: Record<string, string>
     readonly providerOptions?: OpenAIProviderOptionsInput
-    readonly image?: ImageConfig
   }
 
-export interface ImageConfig {
-  readonly providerOptions?: OpenAIImageOptions
-}
-
-export interface ImageGenerationOptions {
-  readonly action?: "auto" | "generate" | "edit"
-  readonly background?: "auto" | "opaque" | "transparent"
-  readonly inputFidelity?: "low" | "high"
-  readonly outputCompression?: number
-  readonly outputFormat?: "png" | "jpeg" | "webp"
-  readonly partialImages?: number
-  readonly quality?: "auto" | "low" | "medium" | "high"
-  readonly size?: string
-}
-
-export const imageGeneration = (options: ImageGenerationOptions = {}) =>
-  ToolDefinition.make({
-    name: "image_generation",
-    description: "Generate or edit an image using OpenAI's hosted image generation tool.",
-    inputSchema: { type: "object", properties: {}, additionalProperties: false },
-    native: {
-      openai: {
-        type: "image_generation",
-        action: options.action,
-        background: options.background,
-        input_fidelity: options.inputFidelity,
-        output_compression: options.outputCompression,
-        output_format: options.outputFormat,
-        partial_images: options.partialImages,
-        quality: options.quality,
-        size: options.size,
-      },
-    },
-  })
-
 export interface Settings extends ProviderPackage.Settings {
   readonly apiKey?: string
   readonly baseURL?: string
@@ -73,7 +35,7 @@ export interface Settings extends ProviderPackage.Settings {
 const auth = (options: ProviderAuthOption<"optional">) => AuthOptions.bearer(options, "OPENAI_API_KEY")
 
 const defaults = (input: Config) => {
-  const { apiKey: _, auth: _auth, baseURL: _baseURL, queryParams: _queryParams, image: _image, ...rest } = input
+  const { apiKey: _, auth: _auth, baseURL: _baseURL, queryParams: _queryParams, ...rest } = input
   return rest
 }
 
@@ -93,21 +55,6 @@ export const configure = (input: Config = {}) => {
   const responsesWebSocket = (id: string | ModelID) =>
     responsesWebSocketRoute.with(withOpenAIOptions(id, modelDefaults, { textVerbosity: true })).model({ id })
   const chat = (id: string | ModelID) => chatRoute.with(withOpenAIOptions(id, modelDefaults)).model({ id })
-  const image = (modelID: string | ModelID) =>
-    OpenAIImages.model({
-      id: modelID,
-      auth: auth(input),
-      baseURL: input.baseURL,
-      headers: input.headers,
-      defaults: {
-        providerOptions:
-          input.image?.providerOptions === undefined ? undefined : { openai: { ...input.image.providerOptions } },
-        http: mergeHttpOptions(
-          input.http === undefined ? undefined : HttpOptions.make(input.http),
-          input.queryParams === undefined ? undefined : new HttpOptions({ query: input.queryParams }),
-        ),
-      },
-    })
 
   return {
     id,
@@ -115,7 +62,6 @@ export const configure = (input: Config = {}) => {
     responses,
     responsesWebSocket,
     chat,
-    image,
     configure,
   }
 }
@@ -151,4 +97,3 @@ export const chatModel: ProviderPackage.Definition<Settings>["model"] = (modelID
 export const responses = provider.responses
 export const responsesWebSocket = provider.responsesWebSocket
 export const chat = provider.chat
-export const image = provider.image

packages/ai/src/providers/openrouter.ts

@@ -41,31 +41,13 @@ export const protocol = Protocol.make({
     schema: OpenRouterBody,
     from: (request) =>
       OpenAIChat.protocol.body.from(request).pipe(
-        Effect.map((body) => {
-          const sourceAssistants = request.messages.filter((message) => message.role === "assistant")
-          let assistantIndex = 0
-          const messages = body.messages.map((message) => {
-            if (message.role !== "assistant") return message
-            const source = sourceAssistants[assistantIndex++]
-            const reasoning = source?.content
-              .filter((part) => part.type === "reasoning")
-              .map((part) => part.text)
-              .join("")
-            const reasoningDetails = Array.isArray(message.reasoning_details) ? message.reasoning_details : undefined
-            return {
-              ...message,
-              reasoning_content: undefined,
-              reasoning_text: undefined,
-              reasoning: reasoning && reasoningDetails && reasoningDetails.length > 0 ? reasoning : undefined,
-              reasoning_details: reasoningDetails,
-            }
-          })
-          return {
-            ...body,
-            messages,
-            ...bodyOptions(request.providerOptions?.openrouter),
-          } as OpenRouterBody
-        }),
+        Effect.map(
+          (body) =>
+            ({
+              ...body,
+              ...bodyOptions(request.providerOptions?.openrouter),
+            }) as OpenRouterBody,
+        ),
       ),
   },
   stream: OpenAIChat.protocol.stream,

packages/ai/src/route/auth.ts

@@ -1,6 +1,6 @@
 import { Config, Effect, Redacted } from "effect"
 import { Headers } from "effect/unstable/http"
-import { AuthenticationReason, InvalidRequestReason, LLMError, type HttpOptions } from "../schema"
+import { AuthenticationReason, InvalidRequestReason, LLMError, type LLMRequest } from "../schema"
 
 export class MissingCredentialError extends Error {
   readonly _tag = "MissingCredentialError"
@@ -15,7 +15,7 @@ export type AuthError = CredentialError | LLMError
 type Secret = string | Redacted.Redacted | Config.Config<string | Redacted.Redacted>
 
 export interface AuthInput {
-  readonly request: { readonly http?: HttpOptions }
+  readonly request: LLMRequest
   readonly method: "POST" | "GET"
   readonly url: string
   readonly body: string

packages/ai/src/schema/events.ts

@@ -129,7 +129,6 @@ export const ToolInputStart = Schema.Struct({
   type: Schema.tag("tool-input-start"),
   id: ToolCallID,
   name: Schema.String,
-  providerExecuted: Schema.optional(Schema.Boolean),
   providerMetadata: Schema.optional(ProviderMetadata),
 }).annotate({ identifier: "LLM.Event.ToolInputStart" })
 export type ToolInputStart = Schema.Schema.Type<typeof ToolInputStart>
@@ -150,15 +149,6 @@ export const ToolInputEnd = Schema.Struct({
 }).annotate({ identifier: "LLM.Event.ToolInputEnd" })
 export type ToolInputEnd = Schema.Schema.Type<typeof ToolInputEnd>
 
-/** A local tool call whose final input could not be decoded. */
-export const ToolInputError = Schema.Struct({
-  type: Schema.tag("tool-input-error"),
-  id: ToolCallID,
-  name: Schema.String,
-  raw: Schema.String,
-}).annotate({ identifier: "LLM.Event.ToolInputError" })
-export type ToolInputError = Schema.Schema.Type<typeof ToolInputError>
-
 export const ToolCall = Schema.Struct({
   type: Schema.tag("tool-call"),
   id: ToolCallID,
@@ -226,7 +216,6 @@ const llmEventTagged = Schema.Union([
   ToolInputStart,
   ToolInputDelta,
   ToolInputEnd,
-  ToolInputError,
   ToolCall,
   ToolResult,
   ToolError,
@@ -264,8 +253,6 @@ export const LLMEvent = Object.assign(llmEventTagged, {
   toolInputDelta: (input: WithID<ToolInputDelta, ToolCallID>) =>
     ToolInputDelta.make({ ...input, id: toolCallID(input.id) }),
   toolInputEnd: (input: WithID<ToolInputEnd, ToolCallID>) => ToolInputEnd.make({ ...input, id: toolCallID(input.id) }),
-  toolInputError: (input: WithID<ToolInputError, ToolCallID>) =>
-    ToolInputError.make({ ...input, id: toolCallID(input.id) }),
   toolCall: (input: WithID<ToolCall, ToolCallID>) => ToolCall.make({ ...input, id: toolCallID(input.id) }),
   toolResult: (input: WithID<ToolResult, ToolCallID>) =>
     ToolResult.make({
@@ -296,7 +283,6 @@ export const LLMEvent = Object.assign(llmEventTagged, {
     toolInputStart: llmEventTagged.guards["tool-input-start"],
     toolInputDelta: llmEventTagged.guards["tool-input-delta"],
     toolInputEnd: llmEventTagged.guards["tool-input-end"],
-    toolInputError: llmEventTagged.guards["tool-input-error"],
     toolCall: llmEventTagged.guards["tool-call"],
     toolResult: llmEventTagged.guards["tool-result"],
     toolError: llmEventTagged.guards["tool-error"],
@@ -562,10 +548,6 @@ const reduceResponseState = (state: ResponseState, event: LLMEvent): ResponseSta
       return reduceToolInputDelta(next, event)
     case "tool-input-end":
       return reduceToolInputEnd(next, event)
-    case "tool-input-error": {
-      const { [event.id]: _finished, ...toolInputs } = next.toolInputs
-      return { ...next, toolInputs }
-    }
     case "tool-call":
       return reduceToolCall(next, event)
     case "tool-result":

packages/ai/test/image.test.ts

@@ -1,95 +0,0 @@
-import { describe, expect } from "bun:test"
-import { Effect, Layer } from "effect"
-import { HttpClientRequest } from "effect/unstable/http"
-import { Image, ImageClient } from "../src"
-import { OpenAI } from "../src/providers"
-import { it } from "./lib/effect"
-import { dynamicResponse } from "./lib/http"
-
-describe("Image", () => {
-  it.effect("generates images through the OpenAI Images API", () =>
-    Effect.gen(function* () {
-      const response = yield* Image.generate({
-        model: OpenAI.configure({
-          apiKey: "test",
-          baseURL: "https://api.openai.test/v1",
-          queryParams: { "api-version": "v1" },
-          http: { body: { deployment: "test" }, headers: { "x-default": "yes" } },
-        }).image("gpt-image-2"),
-        prompt: "A robot tending a rooftop garden",
-        count: 2,
-        size: { width: 1024, height: 1024 },
-        providerOptions: {
-          openai: { quality: "high", outputFormat: "webp" },
-        },
-        http: {
-          body: { request_metadata: "value" },
-          headers: { "x-request": "yes" },
-          query: { trace: "1" },
-        },
-      })
-
-      expect(response.images).toHaveLength(2)
-      expect(response.image?.mediaType).toBe("image/webp")
-      expect(response.image?.data).toEqual(Uint8Array.from([1, 2, 3]))
-      expect(response.image?.providerMetadata).toEqual({ openai: { revisedPrompt: "A precise robot" } })
-      expect(response.usage?.totalTokens).toBe(12)
-    }).pipe(
-      Effect.provide(
-        ImageClient.layer.pipe(
-          Layer.provide(
-            dynamicResponse((input) =>
-              Effect.gen(function* () {
-                const request = yield* HttpClientRequest.toWeb(input.request).pipe(Effect.orDie)
-                expect(request.url).toBe("https://api.openai.test/v1/images/generations?api-version=v1&trace=1")
-                expect(request.headers.get("authorization")).toBe("Bearer test")
-                expect(request.headers.get("x-default")).toBe("yes")
-                expect(request.headers.get("x-request")).toBe("yes")
-                expect(JSON.parse(input.text)).toEqual({
-                  model: "gpt-image-2",
-                  prompt: "A robot tending a rooftop garden",
-                  n: 2,
-                  size: "1024x1024",
-                  quality: "high",
-                  output_format: "webp",
-                  deployment: "test",
-                  request_metadata: "value",
-                })
-                return input.respond(
-                  JSON.stringify({
-                    data: [{ b64_json: "AQID", revised_prompt: "A precise robot" }, { b64_json: "BAUG" }],
-                    output_format: "webp",
-                    usage: { input_tokens: 4, output_tokens: 8, total_tokens: 12 },
-                  }),
-                  { headers: { "content-type": "application/json" } },
-                )
-              }),
-            ),
-          ),
-        ),
-      ),
-    ),
-  )
-
-  it.effect("rejects invalid common and OpenAI image options locally", () =>
-    Image.generate({
-      model: OpenAI.configure({ apiKey: "test", baseURL: "https://api.openai.test/v1" }).image("gpt-image-2"),
-      prompt: "A robot tending a rooftop garden",
-      count: -1,
-      size: { width: -1, height: 0.5 },
-      providerOptions: { openai: { outputCompression: 101 } },
-    }).pipe(
-      Effect.flip,
-      Effect.tap((error) =>
-        Effect.sync(() => {
-          expect(error.reason._tag).toBe("InvalidRequest")
-        }),
-      ),
-      Effect.provide(
-        ImageClient.layer.pipe(
-          Layer.provide(dynamicResponse(() => Effect.die("invalid request should not reach the provider"))),
-        ),
-      ),
-    ),
-  )
-})

packages/ai/test/provider-error.test.ts

@@ -3,30 +3,8 @@ import { isContextOverflow } from "../src"
 import { classifyProviderFailure } from "../src/provider-error"
 
 describe("provider error classification", () => {
-  test("classifies provider token limit messages as context overflow", () => {
-    const messages = [
-      "tokens in request more than max tokens allowed",
-      '{"error":{"type":"request_too_large","message":"Request exceeds the maximum size"}}',
-      "Requested token count exceeds the model's maximum context length of 131072 tokens.",
-      "Input length (265330) exceeds model's maximum context length (262144).",
-      "Input length 131393 exceeds the maximum allowed input length of 131040 tokens.",
-      "The input (516368 tokens) is longer than the model's context length (262144 tokens).",
-      "Prompt has 5,958,968 tokens, but the configured context size is 256,000 tokens",
-      "Too many tokens",
-      "Token limit exceeded",
-    ]
-
-    expect(messages.every(isContextOverflow)).toBe(true)
-  })
-
-  test("does not classify rate limits as context overflow", () => {
-    const messages = [
-      "Throttling error: Too many tokens, please wait before trying again.",
-      "Rate limit exceeded, please retry after 30 seconds.",
-      "Too many requests. Please slow down.",
-    ]
-
-    expect(messages.some(isContextOverflow)).toBe(false)
+  test("classifies Z.AI GLM token limit messages as context overflow", () => {
+    expect(isContextOverflow("tokens in request more than max tokens allowed")).toBe(true)
   })
 
   test("classifies V1 plain-text rate limit fallbacks", () => {

packages/ai/test/provider/anthropic-messages.test.ts

@@ -484,30 +484,6 @@ describe("Anthropic Messages route", () => {
     }),
   )
 
-  it.effect("keeps malformed server tool input terminal", () =>
-    Effect.gen(function* () {
-      const body = sseEvents(
-        { type: "message_start", message: { usage: { input_tokens: 5 } } },
-        {
-          type: "content_block_start",
-          index: 0,
-          content_block: { type: "server_tool_use", id: "call_1", name: "web_search" },
-        },
-        {
-          type: "content_block_delta",
-          index: 0,
-          delta: { type: "input_json_delta", partial_json: '{"query":"partial' },
-        },
-        { type: "content_block_stop", index: 0 },
-      )
-
-      const error = yield* LLMClient.generate(request).pipe(Effect.provide(fixedResponse(body)), Effect.flip)
-
-      expect(error).toBeInstanceOf(LLMError)
-      expect(error.message).toContain("Invalid JSON input for anthropic-messages tool call web_search")
-    }),
-  )
-
   it.effect("fails with a typed provider error for stream error frames", () =>
     Effect.gen(function* () {
       const error = yield* LLMClient.generate(request).pipe(

packages/ai/test/provider/bedrock-converse.test.ts

@@ -303,32 +303,6 @@ describe("Bedrock Converse route", () => {
     }),
   )
 
-  it.effect("emits malformed tool input as an unexecuted tool error", () =>
-    Effect.gen(function* () {
-      const body = eventStreamBody(
-        ["messageStart", { role: "assistant" }],
-        [
-          "contentBlockStart",
-          {
-            contentBlockIndex: 0,
-            start: { toolUse: { toolUseId: "tool_1", name: "lookup" } },
-          },
-        ],
-        ["contentBlockDelta", { contentBlockIndex: 0, delta: { toolUse: { input: '{"query":"partial' } } }],
-        ["contentBlockStop", { contentBlockIndex: 0 }],
-        ["messageStop", { stopReason: "end_turn" }],
-      )
-      const response = yield* LLMClient.generate(baseRequest).pipe(Effect.provide(fixedBytes(body)))
-
-      expect(response.events.find((event) => event.type === "tool-input-error")).toMatchObject({
-        id: "tool_1",
-        name: "lookup",
-        raw: '{"query":"partial',
-      })
-      expect(response.finishReason).toBe("tool-calls")
-    }),
-  )
-
   it.effect("decodes reasoning deltas", () =>
     Effect.gen(function* () {
       const body = eventStreamBody(

packages/ai/test/provider/cloudflare.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect } from "bun:test"
 import { ConfigProvider, Effect, Schema } from "effect"
 import { HttpClientRequest } from "effect/unstable/http"
-import { LLM, LLMEvent } from "../../src"
+import { LLM } from "../../src"
 import { CloudflareAIGateway, CloudflareWorkersAI } from "../../src/providers/cloudflare"
 import { LLMClient } from "../../src/route"
 import { it } from "../lib/effect"
@@ -83,59 +83,6 @@ describe("Cloudflare", () => {
     }),
   )
 
-  it.effect("preserves reasoning details for AI Gateway continuation", () =>
-    Effect.gen(function* () {
-      const model = CloudflareAIGateway.configure({
-        accountId: "test-account",
-        gatewayId: "test-gateway",
-        apiKey: "test-token",
-      }).model("anthropic/claude-sonnet-4.6")
-      const details = [
-        { type: "reasoning.text", text: "Think", format: "anthropic-claude-v1", index: 0 },
-        { type: "reasoning.text", text: "ing", format: "anthropic-claude-v1", index: 0 },
-        { type: "reasoning.text", signature: "signed", format: "anthropic-claude-v1", index: 0 },
-      ]
-      const merged = [
-        {
-          type: "reasoning.text",
-          text: "Thinking",
-          signature: "signed",
-          format: "anthropic-claude-v1",
-          index: 0,
-        },
-      ]
-      const response = yield* LLM.generate(LLM.request({ model, prompt: "Say hello." })).pipe(
-        Effect.provide(
-          dynamicResponse((input) =>
-            Effect.succeed(
-              input.respond(
-                sseEvents(
-                  deltaChunk({ reasoning: "Think", reasoning_details: [details[0]] }),
-                  deltaChunk({ reasoning: "ing", reasoning_details: [details[1]] }),
-                  deltaChunk({ reasoning_details: [details[2]] }),
-                  deltaChunk({ content: "Hello" }),
-                  deltaChunk({}, "stop"),
-                ),
-                { headers: { "content-type": "text/event-stream" } },
-              ),
-            ),
-          ),
-        ),
-      )
-
-      expect(response.reasoning).toBe("Thinking")
-      expect(response.events.filter(LLMEvent.is.reasoningDelta)).toHaveLength(2)
-      expect(response.message.content.find((part) => part.type === "reasoning")?.providerMetadata).toEqual({
-        openai: { reasoningField: "reasoning", reasoningDetails: merged },
-      })
-
-      const replay = yield* LLMClient.prepare(LLM.request({ model, messages: [response.message] }))
-      expect(replay.body.messages).toEqual([
-        { role: "assistant", content: "Hello", reasoning: "Thinking", reasoning_details: merged },
-      ])
-    }),
-  )
-
   it.effect("defaults AI Gateway id to default when omitted or blank", () =>
     Effect.gen(function* () {
       expect(

packages/ai/test/provider/openai-chat-reasoning.recorded.test.ts

@@ -1,12 +1,10 @@
 import { describe, expect } from "bun:test"
 import { Effect } from "effect"
-import { LLM, LLMEvent, LLMResponse } from "../../src"
-import { OpenAIChat } from "../../src/protocols/openai-chat"
+import { LLM, LLMEvent } from "../../src"
 import * as OpenAICompatible from "../../src/providers/openai-compatible"
 import * as OpenRouter from "../../src/providers/openrouter"
 import { LLMClient } from "../../src/route"
 import { recordedTests } from "../recorded-test"
-import { expectWeatherToolLoop, goldenWeatherToolLoopRequest, runWeatherToolLoop } from "../recorded-scenarios"
 
 const cases = [
   {
@@ -17,7 +15,6 @@ const cases = [
     }).model("anthropic/claude-sonnet-4.6"),
     requires: ["OPENROUTER_API_KEY"],
     cassette: "openrouter-reasoning",
-    structured: true,
   },
   {
     name: "Vercel AI Gateway",
@@ -29,7 +26,6 @@ const cases = [
     }).model("anthropic/claude-sonnet-4.6"),
     requires: ["AI_GATEWAY_API_KEY"],
     cassette: "vercel-ai-gateway-reasoning",
-    structured: true,
   },
 ] as const
 
@@ -61,82 +57,11 @@ for (const item of cases) {
           expect(response.text.replaceAll(",", "").trim()).toBe("37887")
           expect(response.reasoning.length).toBeGreaterThan(0)
           expect(response.events.some(LLMEvent.is.reasoningDelta)).toBe(true)
-          const metadata = response.message.content.find((part) => part.type === "reasoning")?.providerMetadata
-          expect(metadata?.openai?.reasoningField).toBe(item.structured ? "reasoning" : "reasoning_content")
-          expect(Array.isArray(metadata?.openai?.reasoningDetails)).toBe(item.structured)
-          if (!item.structured) return
-          const details = metadata?.openai?.reasoningDetails
-          if (!Array.isArray(details)) return
-          expect(
-            details.some(
-              (detail) =>
-                typeof detail === "object" &&
-                detail !== null &&
-                "signature" in detail &&
-                typeof detail.signature === "string" &&
-                detail.signature.length > 0,
-            ),
-          ).toBe(true)
-
-          const replay = yield* LLMClient.prepare<OpenAIChat.OpenAIChatBody>(
-            LLM.request({ model: item.model, messages: [response.message] }),
-          )
-          expect(replay.body.messages).toMatchObject([
-            { role: "assistant", content: response.text, reasoning: response.reasoning },
-          ])
-          const replayDetails =
-            replay.body.messages[0]?.role === "assistant" ? replay.body.messages[0].reasoning_details : undefined
-          expect(Array.isArray(replayDetails)).toBe(true)
-          if (!Array.isArray(replayDetails)) return
-          expect(replayDetails).toEqual(details)
-          expect(replayDetails).toHaveLength(1)
-          expect(replayDetails[0]).toMatchObject({
-            type: "reasoning.text",
-            text: response.reasoning,
-            signature: expect.any(String),
+          expect(response.message.content.find((part) => part.type === "reasoning")?.providerMetadata).toEqual({
+            openai: { reasoningField: "reasoning" },
           })
         }),
       30_000,
     )
-
-    recorded.effect.with(
-      "continues signed reasoning through a tool loop",
-      { cassette: `${item.cassette}-tool-loop`, tags: ["continuation", "tool", "tool-loop"] },
-      () =>
-        Effect.gen(function* () {
-          const events = yield* runWeatherToolLoop(
-            goldenWeatherToolLoopRequest({
-              id: `${item.cassette}-tool-loop`,
-              model: item.model,
-              maxTokens: 1536,
-              temperature: false,
-            }),
-          )
-
-          expectWeatherToolLoop(events)
-          expect(
-            LLMResponse.text({
-              events: events.slice(events.findIndex(LLMEvent.is.stepFinish) + 1),
-            }).trim(),
-          ).toMatch(/^Paris is sunny\.?$/)
-          const details = events
-            .filter(LLMEvent.is.reasoningEnd)
-            .map((event) => event.providerMetadata?.openai?.reasoningDetails)
-            .find(Array.isArray)
-          expect(Array.isArray(details)).toBe(item.structured)
-          if (!item.structured || !Array.isArray(details)) return
-          expect(
-            details.some(
-              (detail) =>
-                typeof detail === "object" &&
-                detail !== null &&
-                "signature" in detail &&
-                typeof detail.signature === "string" &&
-                detail.signature.length > 0,
-            ),
-          ).toBe(true)
-        }),
-      60_000,
-    )
   })
 }

packages/ai/test/provider/openai-chat.test.ts

@@ -570,375 +570,6 @@ describe("OpenAI Chat route", () => {
     }),
   )
 
-  it.effect("preserves and replays reasoning details alongside scalar reasoning", () =>
-    Effect.gen(function* () {
-      const details = [
-        { type: "reasoning.text", text: "thinking", format: "anthropic-claude-v1", index: 0 },
-        { type: "reasoning.encrypted", data: "opaque", format: "anthropic-claude-v1", index: 1 },
-      ]
-      const response = yield* LLMClient.generate(
-        LLM.updateRequest(request, {
-          tools: [{ name: "lookup", description: "Lookup data", inputSchema: { type: "object" } }],
-        }),
-      ).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents(
-              { choices: [{ delta: { reasoning: "thinking", reasoning_details: [details[0]] } }] },
-              { choices: [{ delta: { reasoning_details: [details[1]] } }] },
-              {
-                choices: [
-                  {
-                    delta: {
-                      tool_calls: [
-                        { index: 0, id: "call_1", function: { name: "lookup", arguments: '{"query":"weather"}' } },
-                      ],
-                    },
-                    finish_reason: "tool_calls",
-                  },
-                ],
-              },
-            ),
-          ),
-        ),
-      )
-
-      expect(response.reasoning).toBe("thinking")
-      expect(response.message.content.find((part) => part.type === "reasoning")?.providerMetadata).toEqual({
-        openai: { reasoningField: "reasoning", reasoningDetails: details },
-      })
-
-      const replay = yield* LLMClient.prepare<OpenAIChat.OpenAIChatBody>(
-        LLM.request({ model, messages: [response.message] }),
-      )
-      expect(replay.body.messages).toEqual([
-        {
-          role: "assistant",
-          content: null,
-          reasoning: "thinking",
-          reasoning_details: details,
-          tool_calls: [
-            {
-              id: "call_1",
-              type: "function",
-              function: { name: "lookup", arguments: '{"query":"weather"}' },
-            },
-          ],
-        },
-      ])
-    }),
-  )
-
-  it.effect("uses reasoning details as display fallback without inventing a scalar replay field", () =>
-    Effect.gen(function* () {
-      const details = [
-        { type: "reasoning.summary", summary: "thinking", format: "openai-responses-v1", index: 0 },
-        { type: "reasoning.encrypted", data: "opaque", format: "openai-responses-v1", index: 1 },
-      ]
-      const response = yield* LLMClient.generate(request).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents(
-              { choices: [{ delta: { reasoning_details: [details[0]] } }] },
-              { choices: [{ delta: { reasoning_details: [details[1]] } }] },
-              { choices: [{ delta: { content: "Hello" } }] },
-              { choices: [{ delta: {}, finish_reason: "stop" }] },
-            ),
-          ),
-        ),
-      )
-
-      expect(response.reasoning).toBe("thinking")
-      expect(response.message.content.find((part) => part.type === "reasoning")?.providerMetadata).toEqual({
-        openai: { reasoningDetails: details },
-      })
-
-      const replay = yield* LLMClient.prepare<OpenAIChat.OpenAIChatBody>(
-        LLM.request({ model, messages: [response.message] }),
-      )
-      expect(replay.body.messages).toEqual([{ role: "assistant", content: "Hello", reasoning_details: details }])
-    }),
-  )
-
-  it.effect("preserves unknown reasoning details while using scalar display text", () =>
-    Effect.gen(function* () {
-      const details = [{ type: "reasoning.future", format: "provider-v2", state: { opaque: true } }]
-      const response = yield* LLMClient.generate(request).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents(
-              { choices: [{ delta: { reasoning: "thinking", reasoning_details: details } }] },
-              { choices: [{ delta: { content: "Hello" } }] },
-              { choices: [{ delta: {}, finish_reason: "stop" }] },
-            ),
-          ),
-        ),
-      )
-
-      expect(response.reasoning).toBe("thinking")
-      expect(response.message.content.find((part) => part.type === "reasoning")?.providerMetadata).toEqual({
-        openai: { reasoningField: "reasoning", reasoningDetails: details },
-      })
-
-      const replay = yield* LLMClient.prepare<OpenAIChat.OpenAIChatBody>(
-        LLM.request({ model, messages: [response.message] }),
-      )
-      expect(replay.body.messages).toEqual([
-        { role: "assistant", content: "Hello", reasoning: "thinking", reasoning_details: details },
-      ])
-    }),
-  )
-
-  it.effect("uses scalar display text for signature-only reasoning details", () =>
-    Effect.gen(function* () {
-      const details = [{ type: "reasoning.text", signature: "signed", format: "provider-v2", index: 0 }]
-      const response = yield* LLMClient.generate(request).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents(
-              { choices: [{ delta: { reasoning: "thinking", reasoning_details: details } }] },
-              { choices: [{ delta: { content: "Hello" } }] },
-              { choices: [{ delta: {}, finish_reason: "stop" }] },
-            ),
-          ),
-        ),
-      )
-
-      expect(response.reasoning).toBe("thinking")
-      expect(response.message.content.find((part) => part.type === "reasoning")?.providerMetadata).toEqual({
-        openai: { reasoningField: "reasoning", reasoningDetails: details },
-      })
-    }),
-  )
-
-  it.effect("ignores scalar reasoning after content starts", () =>
-    Effect.gen(function* () {
-      const details = [{ type: "reasoning.text", text: "detail", format: "unknown", index: 0 }]
-      const response = yield* LLMClient.generate(request).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents(
-              { choices: [{ delta: { reasoning_details: details } }] },
-              { choices: [{ delta: { content: "Hello" } }] },
-              { choices: [{ delta: { reasoning: "scalar" } }] },
-              { choices: [{ delta: {}, finish_reason: "stop" }] },
-            ),
-          ),
-        ),
-      )
-
-      expect(response.reasoning).toBe("detail")
-      expect(response.events.filter(LLMEvent.is.reasoningStart)).toHaveLength(1)
-      expect(response.events.filter(LLMEvent.is.reasoningEnd)).toHaveLength(1)
-      expect(response.message.content.find((part) => part.type === "reasoning")?.providerMetadata).toEqual({
-        openai: { reasoningDetails: details },
-      })
-    }),
-  )
-
-  it.effect("preserves an explicitly empty reasoning details array", () =>
-    Effect.gen(function* () {
-      const response = yield* LLMClient.generate(request).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents(
-              { choices: [{ delta: { reasoning_details: [] } }] },
-              { choices: [{ delta: { content: "Hello" } }] },
-              { choices: [{ delta: {}, finish_reason: "stop" }] },
-            ),
-          ),
-        ),
-      )
-
-      expect(response.reasoning).toBe("")
-      expect(response.message.content.find((part) => part.type === "reasoning")?.providerMetadata).toEqual({
-        openai: { reasoningDetails: [] },
-      })
-
-      const replay = yield* LLMClient.prepare<OpenAIChat.OpenAIChatBody>(
-        LLM.request({ model, messages: [response.message] }),
-      )
-      expect(replay.body.messages).toEqual([{ role: "assistant", content: "Hello", reasoning_details: [] }])
-    }),
-  )
-
-  it.effect("attaches signature-only details that arrive after content", () =>
-    Effect.gen(function* () {
-      const details = [
-        { type: "reasoning.text", text: "thinking", format: "anthropic-claude-v1", index: 0 },
-        { type: "reasoning.text", signature: "signed", format: "anthropic-claude-v1", index: 0 },
-      ]
-      const merged = [
-        {
-          type: "reasoning.text",
-          text: "thinking",
-          signature: "signed",
-          format: "anthropic-claude-v1",
-          index: 0,
-        },
-      ]
-      const response = yield* LLMClient.generate(request).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents(
-              { choices: [{ delta: { reasoning: "thinking", reasoning_details: [details[0]] } }] },
-              { choices: [{ delta: { content: "Hello" } }] },
-              { choices: [{ delta: { reasoning_details: [details[1]] } }] },
-              { choices: [{ delta: {}, finish_reason: "stop" }] },
-            ),
-          ),
-        ),
-      )
-
-      expect(response.reasoning).toBe("thinking")
-      expect(response.message.content.filter((part) => part.type === "reasoning")).toHaveLength(1)
-      expect(response.message.content.find((part) => part.type === "reasoning")?.providerMetadata).toEqual({
-        openai: { reasoningField: "reasoning", reasoningDetails: merged },
-      })
-      expect(response.events.filter(LLMEvent.is.reasoningStart)).toHaveLength(1)
-      expect(response.events.filter(LLMEvent.is.reasoningDelta)).toHaveLength(1)
-      expect(response.events.filter(LLMEvent.is.reasoningEnd)).toHaveLength(1)
-      expect(response.events.filter(LLMEvent.is.reasoningEnd).at(-1)?.providerMetadata).toEqual({
-        openai: { reasoningField: "reasoning", reasoningDetails: merged },
-      })
-      expect(response.events.findIndex(LLMEvent.is.reasoningEnd)).toBeLessThan(
-        response.events.findIndex(LLMEvent.is.textStart),
-      )
-
-      const replay = yield* LLMClient.prepare<OpenAIChat.OpenAIChatBody>(
-        LLM.request({ model, messages: [response.message] }),
-      )
-      expect(replay.body.messages).toEqual([
-        { role: "assistant", content: "Hello", reasoning: "thinking", reasoning_details: merged },
-      ])
-    }),
-  )
-
-  it.effect("preserves metadata-only reasoning when the stream ends", () =>
-    Effect.gen(function* () {
-      const details = [{ type: "reasoning.encrypted", data: "opaque", format: "openai-responses-v1", index: 0 }]
-      const response = yield* LLMClient.generate(request).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents(
-              { choices: [{ delta: { reasoning_details: details } }] },
-              { choices: [{ delta: {}, finish_reason: "stop" }] },
-            ),
-          ),
-        ),
-      )
-
-      expect(response.message.content).toEqual([
-        { type: "reasoning", text: "", providerMetadata: { openai: { reasoningDetails: details } } },
-      ])
-      expect(response.events.filter(LLMEvent.is.reasoningStart)).toHaveLength(1)
-      expect(response.events.filter(LLMEvent.is.reasoningEnd)).toHaveLength(1)
-
-      const replay = yield* LLMClient.prepare<OpenAIChat.OpenAIChatBody>(
-        LLM.request({ model, messages: [response.message] }),
-      )
-      expect(replay.body.messages).toEqual([{ role: "assistant", content: null, reasoning_details: details }])
-    }),
-  )
-
-  it.effect("flushes details-only display reasoning when the stream ends", () =>
-    Effect.gen(function* () {
-      const details = [{ type: "reasoning.summary", summary: "summary", format: "openai-responses-v1", index: 0 }]
-      const response = yield* LLMClient.generate(request).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents(
-              { choices: [{ delta: { reasoning_details: details } }] },
-              { choices: [{ delta: {}, finish_reason: "stop" }] },
-            ),
-          ),
-        ),
-      )
-
-      expect(response.reasoning).toBe("summary")
-      expect(response.message.content).toEqual([
-        { type: "reasoning", text: "summary", providerMetadata: { openai: { reasoningDetails: details } } },
-      ])
-    }),
-  )
-
-  it.effect("replays details from multiple reasoning parts in order", () =>
-    Effect.gen(function* () {
-      const first = { type: "reasoning.text", text: "first", signature: "signed-0", index: 0 }
-      const second = { type: "reasoning.text", text: "second", signature: "signed-1", index: 1 }
-      const replay = yield* LLMClient.prepare<OpenAIChat.OpenAIChatBody>(
-        LLM.request({
-          model,
-          messages: [
-            Message.assistant([
-              {
-                type: "reasoning",
-                text: "first",
-                providerMetadata: { openai: { reasoningDetails: [first] } },
-              },
-              {
-                type: "reasoning",
-                text: "second",
-                providerMetadata: { openai: { reasoningField: "reasoning", reasoningDetails: [second] } },
-              },
-            ]),
-          ],
-        }),
-      )
-
-      expect(replay.body.messages).toEqual([
-        { role: "assistant", content: null, reasoning: "firstsecond", reasoning_details: [first, second] },
-      ])
-    }),
-  )
-
-  it.effect("retains scalar replay for mixed structured reasoning parts", () =>
-    Effect.gen(function* () {
-      const detail = { type: "reasoning.encrypted", data: "opaque", index: 0 }
-      const replay = yield* LLMClient.prepare<OpenAIChat.OpenAIChatBody>(
-        LLM.request({
-          model,
-          messages: [
-            Message.assistant([
-              {
-                type: "reasoning",
-                text: "A",
-                providerMetadata: { openai: { reasoningDetails: [detail] } },
-              },
-              { type: "reasoning", text: "B" },
-            ]),
-          ],
-        }),
-      )
-
-      expect(replay.body.messages).toEqual([
-        { role: "assistant", content: null, reasoning_content: "AB", reasoning_details: [detail] },
-      ])
-    }),
-  )
-
-  it.effect("replays native scalar reasoning alongside native details", () =>
-    Effect.gen(function* () {
-      const details = [{ type: "reasoning.encrypted", data: "opaque", index: 0 }]
-      const replay = yield* LLMClient.prepare<OpenAIChat.OpenAIChatBody>(
-        LLM.request({
-          model,
-          messages: [
-            Message.make({
-              role: "assistant",
-              content: [{ type: "reasoning", text: "thinking" }],
-              native: { openaiCompatible: { reasoning_content: "thinking", reasoning_details: details } },
-            }),
-          ],
-        }),
-      )
-
-      expect(replay.body.messages).toEqual([
-        { role: "assistant", content: null, reasoning_content: "thinking", reasoning_details: details },
-      ])
-    }),
-  )
-
   it.effect("assembles streamed tool call input", () =>
     Effect.gen(function* () {
       const body = sseEvents(
@@ -975,67 +606,6 @@ describe("OpenAI Chat route", () => {
     }),
   )
 
-  it.effect("ignores empty identity fields on later tool call deltas", () =>
-    Effect.gen(function* () {
-      const body = sseEvents(
-        deltaChunk({
-          tool_calls: [{ index: 0, id: "call_1", function: { name: "lookup", arguments: "{" } }],
-        }),
-        deltaChunk({
-          tool_calls: [{ index: 0, id: "", function: { name: "", arguments: '\"query\":\"weather\"}' } }],
-        }),
-        deltaChunk({}, "tool_calls"),
-      )
-      const response = yield* LLMClient.generate(
-        LLM.updateRequest(request, {
-          tools: [{ name: "lookup", description: "Lookup data", inputSchema: { type: "object" } }],
-        }),
-      ).pipe(Effect.provide(fixedResponse(body)))
-
-      expect(response.toolCalls).toMatchObject([{ id: "call_1", name: "lookup", input: { query: "weather" } }])
-    }),
-  )
-
-  it.effect("buffers tool call deltas until the function name arrives", () =>
-    Effect.gen(function* () {
-      const body = sseEvents(
-        deltaChunk({
-          tool_calls: [{ index: 0, id: "call_1", function: { arguments: "{" } }],
-        }),
-        deltaChunk({
-          tool_calls: [{ index: 0, function: { name: "lookup", arguments: '\"query\":' } }],
-        }),
-        deltaChunk({ tool_calls: [{ index: 0, function: { arguments: '\"weather\"}' } }] }),
-        deltaChunk({}, "tool_calls"),
-      )
-      const response = yield* LLMClient.generate(
-        LLM.updateRequest(request, {
-          tools: [{ name: "lookup", description: "Lookup data", inputSchema: { type: "object" } }],
-        }),
-      ).pipe(Effect.provide(fixedResponse(body)))
-
-      expect(response.toolCalls).toMatchObject([{ id: "call_1", name: "lookup", input: { query: "weather" } }])
-    }),
-  )
-
-  it.effect("fails when a buffered tool call never receives a function name", () =>
-    Effect.gen(function* () {
-      const body = sseEvents(
-        deltaChunk({
-          tool_calls: [{ index: 0, id: "call_1", function: { arguments: "{}" } }],
-        }),
-        deltaChunk({}, "tool_calls"),
-      )
-      const error = yield* LLMClient.generate(
-        LLM.updateRequest(request, {
-          tools: [{ name: "lookup", description: "Lookup data", inputSchema: { type: "object" } }],
-        }),
-      ).pipe(Effect.provide(fixedResponse(body)), Effect.flip)
-
-      expect(error.message).toContain("OpenAI Chat tool call delta is missing id or name")
-    }),
-  )
-
   it.effect("fails a streamed tool call when the provider ends without a finish reason", () =>
     Effect.gen(function* () {
       const body = sseEvents(

packages/ai/test/provider/openai-images.recorded.test.ts

@@ -1,40 +0,0 @@
-import { describe, expect } from "bun:test"
-import { Effect } from "effect"
-import { Image } from "../../src"
-import { OpenAI } from "../../src/providers"
-import { recordedTests } from "../recorded-test"
-
-const model = OpenAI.configure({
-  apiKey: process.env.OPENAI_API_KEY ?? "fixture",
-  image: {
-    providerOptions: {
-      quality: "low",
-      outputFormat: "jpeg",
-      outputCompression: 10,
-    },
-  },
-}).image("gpt-image-1-mini")
-
-const recorded = recordedTests({
-  prefix: "openai-images",
-  provider: "openai",
-  protocol: "openai-images",
-  requires: ["OPENAI_API_KEY"],
-})
-
-describe("OpenAI Images recorded", () => {
-  recorded.effect("generates an image", () =>
-    Effect.gen(function* () {
-      const response = yield* Image.generate({
-        model,
-        prompt: "A simple flat black circle centered on a plain white background.",
-        size: { width: 1024, height: 1024 },
-      })
-
-      expect(response.images).toHaveLength(1)
-      expect(response.image?.mediaType).toBe("image/jpeg")
-      expect(response.image?.data).toBeInstanceOf(Uint8Array)
-      expect(response.image?.data.length).toBeGreaterThan(0)
-    }),
-  )
-})

packages/ai/test/provider/openai-responses-images.recorded.test.ts

@@ -1,66 +0,0 @@
-import { describe, expect } from "bun:test"
-import { Effect } from "effect"
-import { LLM, LLMEvent, Message } from "../../src"
-import { OpenAI } from "../../src/providers"
-import { recordedTests } from "../recorded-test"
-
-const openai = OpenAI.configure({
-  apiKey: process.env.OPENAI_API_KEY ?? "fixture",
-})
-
-const recorded = recordedTests({
-  prefix: "openai-responses-images",
-  provider: "openai",
-  protocol: "openai-responses",
-  requires: ["OPENAI_API_KEY"],
-})
-
-describe("OpenAI Responses image generation recorded", () => {
-  recorded.effect("generates and edits an image with the hosted tool", () =>
-    Effect.gen(function* () {
-      const initial = Message.user("Generate a simple flat black triangle centered on a plain white background.")
-      const tools = [
-        OpenAI.imageGeneration({
-          action: "auto",
-          quality: "low",
-          size: "1024x1024",
-          outputFormat: "jpeg",
-          outputCompression: 10,
-          partialImages: 0,
-        }),
-      ]
-      const response = yield* LLM.generate(
-        LLM.request({
-          model: openai.responses("gpt-5-mini"),
-          messages: [initial],
-          tools,
-          toolChoice: "image_generation",
-        }),
-      )
-
-      const result = response.events.find(LLMEvent.is.toolResult)
-      expect(result).toBeDefined()
-      expect(result?.providerExecuted).toBe(true)
-      expect(result?.result.type).toBe("content")
-      if (result?.result.type !== "content") return
-      expect(result.result.value).toHaveLength(1)
-      expect(result.result.value[0]?.type).toBe("file")
-      if (result.result.value[0]?.type !== "file") return
-      expect(result.result.value[0].mime).toBe("image/jpeg")
-      expect(result.result.value[0].uri.startsWith("data:image/jpeg;base64,")).toBe(true)
-
-      const edited = yield* LLM.generate(
-        LLM.request({
-          model: openai.responses("gpt-5-mini"),
-          messages: [initial, response.message, Message.user("Now make the triangle blue.")],
-          tools,
-          toolChoice: "image_generation",
-        }),
-      )
-      const editedResult = edited.events.find(LLMEvent.is.toolResult)
-      expect(editedResult?.result.type).toBe("content")
-      if (editedResult?.result.type !== "content") return
-      expect(editedResult.result.value[0]?.type).toBe("file")
-    }),
-  )
-})

packages/ai/test/provider/openai-responses.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect } from "bun:test"
 import { ConfigProvider, Effect, Layer, Stream } from "effect"
 import { Headers, HttpClientRequest } from "effect/unstable/http"
-import { LLM, LLMError, LLMEvent, Message, Model, ToolCallPart, ToolResultPart, Usage } from "../../src"
+import { LLM, LLMError, Message, Model, ToolCallPart, Usage } from "../../src"
 import { Auth, LLMClient, RequestExecutor, WebSocketExecutor } from "../../src/route"
 import * as Azure from "../../src/providers/azure"
 import * as OpenAI from "../../src/providers/openai"
@@ -58,39 +58,6 @@ describe("OpenAI Responses route", () => {
     }),
   )
 
-  it.effect("lowers the hosted OpenAI image generation tool", () =>
-    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare<OpenAIResponses.OpenAIResponsesBody>(
-        LLM.request({
-          model,
-          prompt: "Show me a rooftop garden.",
-          tools: [OpenAI.imageGeneration({ action: "generate", quality: "high", size: "1024x1024" })],
-          toolChoice: "image_generation",
-        }),
-      )
-
-      expect(prepared.body.tools).toEqual([
-        { type: "image_generation", action: "generate", quality: "high", size: "1024x1024" },
-      ])
-      expect(prepared.body.tool_choice).toEqual({ type: "image_generation" })
-    }),
-  )
-
-  it.effect("rejects invalid hosted image generation options locally", () =>
-    Effect.gen(function* () {
-      const error = yield* LLMClient.prepare(
-        LLM.request({
-          model,
-          prompt: "Show me a rooftop garden.",
-          tools: [OpenAI.imageGeneration({ outputCompression: -1, partialImages: 4, size: "bogus" })],
-        }),
-      ).pipe(Effect.flip)
-
-      expect(error.reason._tag).toBe("InvalidRequest")
-      expect(error.message).toContain("image generation tool options are invalid")
-    }),
-  )
-
   it.effect("lowers semantic service tier options", () =>
     Effect.gen(function* () {
       const input = LLM.updateRequest(request, { providerOptions: { openai: { serviceTier: "priority" } } })
@@ -1136,48 +1103,6 @@ describe("OpenAI Responses route", () => {
     }),
   )
 
-  it.effect("continues stateless hosted image generation with the generated image", () =>
-    Effect.gen(function* () {
-      const imageTool = OpenAI.imageGeneration({ action: "edit" })
-      const prepared = yield* LLMClient.prepare<OpenAIResponses.OpenAIResponsesBody>(
-        LLM.request({
-          model,
-          messages: [
-            Message.user("Generate a black triangle."),
-            Message.assistant([
-              ToolCallPart.make({
-                id: "ig_1",
-                name: "image_generation",
-                input: {},
-                providerExecuted: true,
-                providerMetadata: { openai: { itemId: "ig_1" } },
-              }),
-              ToolResultPart.make({
-                id: "ig_1",
-                name: "image_generation",
-                result: {
-                  type: "content",
-                  value: [{ type: "file", uri: "data:image/png;base64,AQID", mime: "image/png" }],
-                },
-                providerExecuted: true,
-                providerMetadata: { openai: { itemId: "ig_1" } },
-              }),
-            ]),
-            Message.user("Make it blue."),
-          ],
-          tools: [imageTool],
-        }),
-      )
-
-      expect(prepared.body.store).toBe(false)
-      expect(prepared.body.input).toEqual([
-        { role: "user", content: [{ type: "input_text", text: "Generate a black triangle." }] },
-        { role: "user", content: [{ type: "input_image", image_url: "data:image/png;base64,AQID" }] },
-        { role: "user", content: [{ type: "input_text", text: "Make it blue." }] },
-      ])
-    }),
-  )
-
   it.effect("joins streamed summary blocks into one continuation reasoning item", () =>
     Effect.gen(function* () {
       const prepared = yield* LLMClient.prepare<OpenAIResponses.OpenAIResponsesBody>(
@@ -1334,69 +1259,6 @@ describe("OpenAI Responses route", () => {
     }),
   )
 
-  it.effect("emits malformed final function arguments as an unexecuted tool error", () =>
-    Effect.gen(function* () {
-      const body = sseEvents(
-        {
-          type: "response.output_item.added",
-          item: { type: "function_call", id: "item_1", call_id: "call_1", name: "lookup", arguments: "" },
-        },
-        { type: "response.function_call_arguments.delta", item_id: "item_1", delta: '{"query":"streamed"}' },
-        {
-          type: "response.output_item.done",
-          item: {
-            type: "function_call",
-            id: "item_1",
-            call_id: "call_1",
-            name: "lookup",
-            arguments: '{"query":"partial',
-          },
-        },
-        { type: "response.completed", response: { usage: { input_tokens: 5, output_tokens: 1 } } },
-      )
-      const response = yield* LLMClient.generate(
-        LLM.updateRequest(request, {
-          tools: [{ name: "lookup", description: "Lookup data", inputSchema: { type: "object" } }],
-        }),
-      ).pipe(Effect.provide(fixedResponse(body)))
-
-      expect(response.events.find(LLMEvent.is.toolInputError)).toEqual({
-        type: "tool-input-error",
-        id: "call_1",
-        name: "lookup",
-        raw: '{"query":"partial',
-      })
-      expect(response.finishReason).toBe("tool-calls")
-      expect(response.events.some(LLMEvent.is.toolCall)).toBeFalse()
-    }),
-  )
-
-  it.effect("settles malformed function arguments when output_item.added is absent", () =>
-    Effect.gen(function* () {
-      const body = sseEvents(
-        {
-          type: "response.output_item.done",
-          item: {
-            type: "function_call",
-            id: "item_1",
-            call_id: "call_1",
-            name: "lookup",
-            arguments: '{"query":"partial',
-          },
-        },
-        { type: "response.completed", response: { usage: { input_tokens: 5, output_tokens: 1 } } },
-      )
-      const response = yield* LLMClient.generate(request).pipe(Effect.provide(fixedResponse(body)))
-
-      expect(response.events.find(LLMEvent.is.toolInputError)).toMatchObject({
-        id: "call_1",
-        name: "lookup",
-        raw: '{"query":"partial',
-      })
-      expect(response.finishReason).toBe("tool-calls")
-    }),
-  )
-
   it.effect("decodes web_search_call as provider-executed tool-call + tool-result", () =>
     Effect.gen(function* () {
       const item = {
@@ -1436,59 +1298,6 @@ describe("OpenAI Responses route", () => {
     }),
   )
 
-  it.effect("decodes image generation output as image content", () =>
-    Effect.gen(function* () {
-      const item = {
-        type: "image_generation_call",
-        id: "ig_1",
-        status: "completed",
-        result: "AQID",
-      }
-      const response = yield* LLMClient.generate(request).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents(
-              { type: "response.output_item.done", item },
-              { type: "response.completed", response: { usage: { input_tokens: 5, output_tokens: 1 } } },
-            ),
-          ),
-        ),
-      )
-
-      expect(response.events.find(LLMEvent.is.toolResult)).toMatchObject({
-        id: "ig_1",
-        name: "image_generation",
-        providerExecuted: true,
-        result: {
-          type: "content",
-          value: [{ type: "file", uri: "data:image/png;base64,AQID", mime: "image/png" }],
-        },
-      })
-    }),
-  )
-
-  it.effect("rejects malformed image generation base64", () =>
-    Effect.gen(function* () {
-      const error = yield* LLMClient.generate(request).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents(
-              {
-                type: "response.output_item.done",
-                item: { type: "image_generation_call", id: "ig_bad", status: "completed", result: "%%%" },
-              },
-              { type: "response.completed", response: {} },
-            ),
-          ),
-        ),
-        Effect.flip,
-      )
-
-      expect(error.reason._tag).toBe("InvalidProviderOutput")
-      expect(error.message).toContain("invalid image base64")
-    }),
-  )
-
   it.effect("decodes code_interpreter_call as provider-executed events with code input", () =>
     Effect.gen(function* () {
       const item = {

packages/ai/test/provider/openrouter.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect } from "bun:test"
 import { Effect } from "effect"
-import { LLM, Message } from "../../src"
+import { LLM } from "../../src"
 import { LLMClient } from "../../src/route"
 import * as OpenRouter from "../../src/providers/openrouter"
 import { it } from "../lib/effect"
@@ -53,102 +53,4 @@ describe("OpenRouter", () => {
       })
     }),
   )
-
-  it.effect("preserves manually supplied reasoning details", () =>
-    Effect.gen(function* () {
-      const details = [
-        { type: "reasoning.text", text: "Think", format: "anthropic-claude-v1", index: 0 },
-        { type: "reasoning.text", text: "ing", format: "anthropic-claude-v1", index: 0 },
-        { type: "reasoning.text", signature: "signed", format: "anthropic-claude-v1", index: 0 },
-        { type: "reasoning.encrypted", data: "opaque", format: "openai-responses-v1", index: 1 },
-      ]
-      const prepared = yield* LLMClient.prepare<OpenRouter.OpenRouterBody>(
-        LLM.request({
-          model: OpenRouter.configure({ apiKey: "test-key" }).model("anthropic/claude-sonnet-4.6"),
-          messages: [
-            Message.assistant([
-              {
-                type: "reasoning",
-                text: "Thinking",
-                providerMetadata: { openai: { reasoningField: "reasoning", reasoningDetails: details } },
-              },
-            ]),
-          ],
-        }),
-      )
-
-      expect(prepared.body.messages).toEqual([
-        {
-          role: "assistant",
-          content: null,
-          reasoning: "Thinking",
-          reasoning_details: details,
-        },
-      ])
-    }),
-  )
-
-  it.effect("preserves opaque and duplicate continuation details", () =>
-    Effect.gen(function* () {
-      const details = [
-        { type: "reasoning.future", format: "provider-v2", state: { opaque: true } },
-        { type: "reasoning.encrypted", id: "state", data: "opaque" },
-        { type: "reasoning.encrypted", id: "state", data: "opaque" },
-      ]
-      const prepared = yield* LLMClient.prepare<OpenRouter.OpenRouterBody>(
-        LLM.request({
-          model: OpenRouter.configure({ apiKey: "test-key" }).model("anthropic/claude-sonnet-4.6"),
-          messages: [
-            Message.assistant({
-              type: "reasoning",
-              text: "Thinking",
-              providerMetadata: { openai: { reasoningField: "reasoning", reasoningDetails: details } },
-            }),
-          ],
-        }),
-      )
-
-      expect(prepared.body.messages).toEqual([
-        { role: "assistant", content: null, reasoning: "Thinking", reasoning_details: details },
-      ])
-    }),
-  )
-
-  it.effect("does not merge distinct adjacent reasoning text blocks", () =>
-    Effect.gen(function* () {
-      const details = [
-        { type: "reasoning.text", id: "first", index: 0, text: "A", opaque: "first" },
-        { type: "reasoning.text", id: "second", index: 1, text: "B", opaque: "second" },
-      ]
-      const prepared = yield* LLMClient.prepare<OpenRouter.OpenRouterBody>(
-        LLM.request({
-          model: OpenRouter.configure({ apiKey: "test-key" }).model("anthropic/claude-sonnet-4.6"),
-          messages: [
-            Message.assistant({
-              type: "reasoning",
-              text: "AB",
-              providerMetadata: { openai: { reasoningField: "reasoning", reasoningDetails: details } },
-            }),
-          ],
-        }),
-      )
-
-      expect(prepared.body.messages).toEqual([
-        { role: "assistant", content: null, reasoning: "AB", reasoning_details: details },
-      ])
-    }),
-  )
-
-  it.effect("omits scalar reasoning without continuation details", () =>
-    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare<OpenRouter.OpenRouterBody>(
-        LLM.request({
-          model: OpenRouter.configure({ apiKey: "test-key" }).model("anthropic/claude-sonnet-4.6"),
-          messages: [Message.assistant({ type: "reasoning", text: "Thinking" })],
-        }),
-      )
-
-      expect(prepared.body.messages).toEqual([{ role: "assistant", content: null }])
-    }),
-  )
 })

packages/ai/test/recorded-scenarios.ts

@@ -120,8 +120,29 @@ export const runWeatherToolLoop = (request: LLMRequest) =>
     throw new Error("Weather tool loop exceeded 10 steps")
   })
 
-const assistantContent = (events: ReadonlyArray<LLMEvent>) =>
-  events.reduce(LLMResponse.reduce, LLMResponse.empty()).message.content
+const assistantContent = (events: ReadonlyArray<LLMEvent>) => {
+  const content: ContentPart[] = []
+  for (const event of events) {
+    if (event.type === "text-delta" || event.type === "reasoning-delta") {
+      const type = event.type === "text-delta" ? "text" : "reasoning"
+      const last = content.at(-1)
+      if (last?.type === type) {
+        content[content.length - 1] = { ...last, text: `${last.text}${event.text}` }
+      } else {
+        content.push({ type, text: event.text })
+      }
+      continue
+    }
+    if (event.type === "text-end" || event.type === "reasoning-end") {
+      const type = event.type === "text-end" ? "text" : "reasoning"
+      const last = content.at(-1)
+      if (last?.type === type) content[content.length - 1] = { ...last, providerMetadata: event.providerMetadata }
+      continue
+    }
+    if (event.type === "tool-call") content.push(event)
+  }
+  return content
+}
 
 export const expectFinish = (
   events: ReadonlyArray<LLMEvent>,

packages/ai/test/recorded-test.ts

@@ -3,8 +3,6 @@ import { Layer } from "effect"
 import * as path from "node:path"
 import { fileURLToPath } from "node:url"
 import { LLMClient, RequestExecutor, WebSocketExecutor } from "../src/route"
-import { ImageClient } from "../src/image-client"
-import type { Service as ImageClientService } from "../src/image-client"
 import type { Service as LLMClientService } from "../src/route/client"
 import type { Service as RequestExecutorService } from "../src/route/executor"
 import type { Service as WebSocketExecutorService } from "../src/route/transport/websocket"
@@ -17,7 +15,7 @@ import {
 const __dirname = path.dirname(fileURLToPath(import.meta.url))
 const FIXTURES_DIR = path.resolve(__dirname, "fixtures", "recordings")
 
-type RecordedEnv = RequestExecutorService | WebSocketExecutorService | LLMClientService | ImageClientService
+type RecordedEnv = RequestExecutorService | WebSocketExecutorService | LLMClientService
 
 type RecordedTestsOptions = RecordedGroupOptions & {
   readonly options?: HttpRecorder.RecorderOptions
@@ -83,10 +81,6 @@ export const recordedTests = (options: RecordedTestsOptions) =>
         ),
       )
       const deps = Layer.mergeAll(requestExecutor, WebSocketExecutor.layer)
-      return Layer.mergeAll(
-        deps,
-        LLMClient.layer.pipe(Layer.provide(deps)),
-        ImageClient.layer.pipe(Layer.provide(deps)),
-      )
+      return Layer.mergeAll(deps, LLMClient.layer.pipe(Layer.provide(deps)))
     },
   })

packages/ai/test/response.test.ts

@@ -95,19 +95,4 @@ describe("LLMResponse reducer", () => {
       { type: "tool-call", id: "call_1", name: "lookup", input: { query: "weather" } },
     ])
   })
-
-  test("clears malformed tool input without appending an executable call", () => {
-    const state = reduce([
-      LLMEvent.toolInputStart({ id: "call_1", name: "lookup" }),
-      LLMEvent.toolInputDelta({ id: "call_1", name: "lookup", text: '{"query":"partial' }),
-      LLMEvent.toolInputError({
-        id: "call_1",
-        name: "lookup",
-        raw: '{"query":"partial',
-      }),
-    ])
-
-    expect(state.toolInputs).toEqual({})
-    expect(state.message.content).toEqual([])
-  })
 })

packages/ai/test/tool-stream.test.ts

@@ -36,33 +36,6 @@ describe("ToolStream", () => {
     }),
   )
 
-  it.effect("keeps accumulated identity when later deltas contain empty strings", () =>
-    Effect.gen(function* () {
-      const first = ToolStream.appendOrStart(
-        ADAPTER,
-        ToolStream.empty<number>(),
-        0,
-        { id: "call_1", name: "lookup", text: '{"query"' },
-        "missing tool",
-      )
-      if (ToolStream.isError(first)) return yield* first
-      const second = ToolStream.appendOrStart(
-        ADAPTER,
-        first.tools,
-        0,
-        { id: "", name: "", text: ':"weather"}' },
-        "missing tool",
-      )
-      if (ToolStream.isError(second)) return yield* second
-      const finished = yield* ToolStream.finish(ADAPTER, second.tools, 0)
-
-      expect(finished.events).toEqual([
-        { type: "tool-input-end", id: "call_1", name: "lookup" },
-        { type: "tool-call", id: "call_1", name: "lookup", input: { query: "weather" } },
-      ])
-    }),
-  )
-
   it.effect("fails appendExisting when the provider skipped the tool start", () =>
     Effect.gen(function* () {
       const error = ToolStream.appendExisting(ADAPTER, ToolStream.empty<number>(), 0, "{}", "missing tool")
@@ -91,73 +64,6 @@ describe("ToolStream", () => {
     }),
   )
 
-  it.effect("finalizes malformed local input as a non-executable tool error", () =>
-    Effect.gen(function* () {
-      const tools = ToolStream.start(ToolStream.empty<string>(), "item_1", {
-        id: "call_1",
-        name: "lookup",
-        input: '{"query":"partial',
-      })
-      const finished = yield* ToolStream.finish(ADAPTER, tools, "item_1")
-
-      expect(finished).toEqual({
-        tools: {},
-        events: [
-          {
-            type: "tool-input-error",
-            id: "call_1",
-            name: "lookup",
-            raw: '{"query":"partial',
-          },
-        ],
-      })
-    }),
-  )
-
-  it.effect("preserves valid siblings when one parallel input is malformed", () =>
-    Effect.gen(function* () {
-      const valid = ToolStream.start(ToolStream.empty<number>(), 0, {
-        id: "call_valid",
-        name: "lookup",
-        input: '{"query":"weather"}',
-      })
-      const tools = ToolStream.start(valid, 1, {
-        id: "call_invalid",
-        name: "lookup",
-        input: '{"query":"partial',
-      })
-      const finished = yield* ToolStream.finishAll(ADAPTER, tools)
-
-      expect(finished).toEqual({
-        tools: {},
-        events: [
-          { type: "tool-input-end", id: "call_valid", name: "lookup" },
-          { type: "tool-call", id: "call_valid", name: "lookup", input: { query: "weather" } },
-          {
-            type: "tool-input-error",
-            id: "call_invalid",
-            name: "lookup",
-            raw: '{"query":"partial',
-          },
-        ],
-      })
-    }),
-  )
-
-  it.effect("keeps malformed provider-executed input terminal", () =>
-    Effect.gen(function* () {
-      const tools = ToolStream.start(ToolStream.empty<string>(), "item_1", {
-        id: "call_1",
-        name: "web_search",
-        input: '{"query":"partial',
-        providerExecuted: true,
-      })
-      const result = yield* Effect.exit(ToolStream.finish(ADAPTER, tools, "item_1"))
-
-      expect(result._tag).toBe("Failure")
-    }),
-  )
-
   it.effect("preserves providerExecuted and clears all tools", () =>
     Effect.gen(function* () {
       const first: ToolStream.State<number> = ToolStream.start(ToolStream.empty<number>(), 0, {

packages/cli/package.json

@@ -12,7 +12,16 @@
   ],
   "exports": {
     "./daemon": "./src/daemon.ts",
-    "./run": "./src/run/index.ts",
+    "./mini": "./src/mini/index.ts",
+    "./mini/footer.command": "./src/mini/footer.command.tsx",
+    "./mini/footer.menu": "./src/mini/footer.menu.tsx",
+    "./mini/footer.permission": "./src/mini/footer.permission.tsx",
+    "./mini/footer.prompt": "./src/mini/footer.prompt.tsx",
+    "./mini/footer.question": "./src/mini/footer.question.tsx",
+    "./mini/footer.subagent": "./src/mini/footer.subagent.tsx",
+    "./mini/footer.view": "./src/mini/footer.view.tsx",
+    "./mini/scrollback.writer": "./src/mini/scrollback.writer.tsx",
+    "./mini/*": "./src/mini/*.ts",
     "./server-process": "./src/server-process.ts"
   },
   "scripts": {
@@ -31,14 +40,18 @@
     "@opencode-ai/server": "workspace:*",
     "@opencode-ai/tui": "workspace:*",
     "@opentui/core": "catalog:",
+    "@opentui/keymap": "catalog:",
     "@opentui/solid": "catalog:",
     "@parcel/watcher": "2.5.1",
     "effect": "catalog:",
+    "fuzzysort": "catalog:",
     "immer": "11.1.4",
     "jsonc-parser": "3.3.1",
     "open": "10.1.2",
+    "opentui-spinner": "catalog:",
     "semver": "catalog:",
     "solid-js": "catalog:",
+    "strip-ansi": "7.1.2",
     "uqr": "0.1.3",
     "ws": "8.21.0"
   },

packages/cli/src/commands/commands.ts

@@ -12,6 +12,11 @@ const ServerParams = {
     Flag.withDescription("Connect to a server URL instead of the background service"),
     Flag.optional,
   ),
+  remote: Flag.string("remote").pipe(
+    Flag.withAlias("r"),
+    Flag.withDescription("Connect to a saved remote server"),
+    Flag.optional,
+  ),
 }
 
 export const Commands = Spec.make(typeof OPENCODE_CLI_NAME === "string" ? OPENCODE_CLI_NAME : "opencode", {
@@ -201,6 +206,27 @@ export const Commands = Spec.make(typeof OPENCODE_CLI_NAME === "string" ? OPENCO
         yolo: Flag.boolean("yolo").pipe(Flag.withDefault(false), Flag.withHidden),
       },
     }),
+    Spec.make("server", {
+      description: "Manage saved server connections",
+      commands: [
+        Spec.make("list", { description: "List saved server connections" }),
+        Spec.make("add", {
+          description: "Save a server connection (and OPENCODE_PASSWORD when set)",
+          params: {
+            name: Argument.string("name").pipe(Argument.withDescription("Name for the saved server")),
+            url: Argument.string("url").pipe(Argument.withDescription("Server URL")),
+            username: Flag.string("username").pipe(
+              Flag.withDescription("Basic authentication username"),
+              Flag.optional,
+            ),
+          },
+        }),
+        Spec.make("remove", {
+          description: "Remove a saved server connection",
+          params: { name: Argument.string("name").pipe(Argument.withDescription("Saved server name")) },
+        }),
+      ],
+    }),
     Spec.make("service", {
       description: "Manage the background server",
       commands: [

packages/cli/src/commands/handlers/api.ts

@@ -20,6 +20,7 @@ export default Runtime.handler(
   Effect.fn("cli.api")(function* (input) {
     const server = yield* ServerConnection.resolve({
       server: Option.getOrUndefined(input.server),
+      remote: Option.getOrUndefined(input.remote),
       standalone: input.standalone,
       mismatch: "ignore",
     })

packages/cli/src/commands/handlers/default.ts

@@ -20,6 +20,7 @@ export default Runtime.handler(Commands, (input) =>
     yield* Effect.addFinalizer(() => Effect.promise(() => preflight.close()))
     const server = yield* ServerConnection.resolve({
       server: Option.getOrUndefined(input.server),
+      remote: Option.getOrUndefined(input.remote),
       standalone: input.standalone,
       onStart: (reason, previousVersion) => {
         if (reason === "version-mismatch" && preflight.begin(previousVersion)) return

packages/cli/src/commands/handlers/mini.ts

@@ -1,27 +1,21 @@
-import { Context, Effect, FileSystem, Option } from "effect"
+import { Effect, Option } from "effect"
 import { Commands } from "../commands"
 import { Runtime } from "../../framework/runtime"
 import { ServerConnection } from "../../services/server-connection"
-import { Config } from "../../config"
-import { resolve } from "@opencode-ai/tui/config"
 
 export default Runtime.handler(Commands.commands.mini, (input) =>
   Effect.gen(function* () {
     const { runMini, validateMiniTerminal } = yield* Effect.promise(() => import("../../mini"))
     yield* Effect.promise(async () => validateMiniTerminal())
     const serverURL = Option.getOrUndefined(input.server)
-    const server = yield* ServerConnection.resolve({ server: serverURL, standalone: input.standalone })
-    const config = yield* Config.Service
-    const resolved = resolve(yield* config.get(), { terminalSuspend: process.platform !== "win32" })
-    const fileSystem = yield* FileSystem.FileSystem
-    const runServicePromise = Effect.runPromiseWith(Context.make(FileSystem.FileSystem, fileSystem))
-    const service = server.service
+    const server = yield* ServerConnection.resolve({
+      server: serverURL,
+      remote: Option.getOrUndefined(input.remote),
+      standalone: input.standalone,
+    })
     yield* Effect.promise(() =>
       runMini({
-        server: {
-          endpoint: server.endpoint,
-          reconnect: service ? (signal) => runServicePromise(service.reconnect(), { signal }) : undefined,
-        },
+        server,
         continue: input.continue,
         session: Option.getOrUndefined(input.session),
         fork: input.fork,
@@ -31,7 +25,6 @@ export default Runtime.handler(Commands.commands.mini, (input) =>
         replay: input.replay,
         replayLimit: Option.getOrUndefined(input.replayLimit),
         demo: input.demo,
-        tuiConfig: resolved,
       }),
     )
   }),

packages/cli/src/commands/handlers/run.ts

@@ -5,10 +5,11 @@ import { ServerConnection } from "../../services/server-connection"
 
 export default Runtime.handler(Commands.commands.run, (input) =>
   Effect.gen(function* () {
-    const { runNonInteractive } = yield* Effect.promise(() => import("../../run/run"))
+    const { runNonInteractive } = yield* Effect.promise(() => import("../../mini"))
     const separator = process.argv.indexOf("--", 2)
     const server = yield* ServerConnection.resolve({
       server: Option.getOrUndefined(input.server),
+      remote: Option.getOrUndefined(input.remote),
       standalone: input.standalone,
     })
     yield* Effect.promise(() =>

packages/cli/src/commands/handlers/server/add.ts

@@ -0,0 +1,23 @@
+import { Effect, Option, Redacted } from "effect"
+import { Commands } from "../../commands"
+import { Config } from "../../../config"
+import { Env } from "../../../env"
+import { Runtime } from "../../../framework/runtime"
+
+export default Runtime.handler(
+  Commands.commands.server.commands.add,
+  Effect.fn("cli.server.add")(function* (input) {
+    if (!URL.canParse(input.url)) return yield* Effect.fail(new Error(`Invalid server URL: ${input.url}`))
+    const config = yield* Config.Service
+    const password = yield* Env.password
+    yield* config.update((draft) => {
+      draft.servers ??= {}
+      draft.servers[input.name] = {
+        url: input.url,
+        username: Option.getOrUndefined(input.username),
+        password: password ? Redacted.value(password) : undefined,
+      }
+    })
+    process.stdout.write(`Saved server ${input.name}\n`)
+  }),
+)

packages/cli/src/commands/handlers/server/list.ts

@@ -0,0 +1,21 @@
+import { Effect } from "effect"
+import { Commands } from "../../commands"
+import { Config } from "../../../config"
+import { Runtime } from "../../../framework/runtime"
+
+export default Runtime.handler(
+  Commands.commands.server.commands.list,
+  Effect.fn("cli.server.list")(function* () {
+    const config = yield* Config.Service
+    const servers = Object.entries((yield* config.get()).servers ?? {})
+    if (!servers.length) {
+      process.stdout.write("No saved servers\n")
+      return
+    }
+    process.stdout.write(
+      servers
+        .map(([name, server]) => `${name}\t${server.url}${server.username ? `\t${server.username}` : ""}`)
+        .join("\n") + "\n",
+    )
+  }),
+)

packages/cli/src/commands/handlers/server/remove.ts

@@ -0,0 +1,19 @@
+import { Effect } from "effect"
+import { Commands } from "../../commands"
+import { Config } from "../../../config"
+import { Runtime } from "../../../framework/runtime"
+
+export default Runtime.handler(
+  Commands.commands.server.commands.remove,
+  Effect.fn("cli.server.remove")(function* (input) {
+    const config = yield* Config.Service
+    if ((yield* config.get()).servers?.[input.name] === undefined)
+      return yield* Effect.fail(new Error(`Saved server "${input.name}" not found`))
+    yield* config.update((draft) => {
+      if (!draft.servers) return
+      delete draft.servers[input.name]
+      if (!Object.keys(draft.servers).length) delete draft.servers
+    })
+    process.stdout.write(`Removed server ${input.name}\n`)
+  }),
+)

packages/cli/src/config/schema.ts

@@ -1,5 +1,15 @@
 import { Config } from "@opencode-ai/tui/config"
 import { Schema } from "effect"
 
-export const Info = Schema.Struct({ ...Config.Info.fields })
+export const Server = Schema.Struct({
+  url: Schema.String,
+  username: Schema.optional(Schema.String),
+  password: Schema.optional(Schema.String),
+})
+export type Server = Schema.Schema.Type<typeof Server>
+
+export const Info = Schema.Struct({
+  ...Config.Info.fields,
+  servers: Schema.optional(Schema.Record(Schema.String, Server)),
+})
 export type Info = Schema.Schema.Type<typeof Info>

packages/cli/src/index.ts

@@ -38,6 +38,11 @@ const Handlers = Runtime.handlers(Commands, {
   mini: () => import("./commands/handlers/mini"),
   run: () => import("./commands/handlers/run"),
   pair: () => import("./commands/handlers/pair"),
+  server: {
+    list: () => import("./commands/handlers/server/list"),
+    add: () => import("./commands/handlers/server/add"),
+    remove: () => import("./commands/handlers/server/remove"),
+  },
   service: {
     start: () => import("./commands/handlers/service/start"),
     restart: () => import("./commands/handlers/service/restart"),

packages/cli/src/mini-host.ts

@@ -1,176 +0,0 @@
-import type { MiniFrontendInput } from "@opencode-ai/tui/mini"
-import { createModelPreferenceRepository } from "@opencode-ai/tui/model-preference"
-import { Flag } from "@opencode-ai/core/flag/flag"
-import { Global } from "@opencode-ai/core/global"
-import fs from "node:fs"
-import { readFile } from "node:fs/promises"
-import path from "node:path"
-import { ReadStream } from "node:tty"
-
-export const INTERACTIVE_INPUT_ERROR = "opencode mini requires a controlling terminal for input"
-
-export type InteractiveStdin = {
-  stdin: NodeJS.ReadStream
-  cleanup(): void
-}
-
-type MiniHost = MiniFrontendInput["host"]
-
-function preferences(statePath: string): MiniHost["preferences"] {
-  const repository = createModelPreferenceRepository(path.join(statePath, "model.json"))
-  return {
-    async resolveVariant(model) {
-      if (!model) return
-      return repository.resolveVariant(model)
-    },
-    async saveVariant(model, variant) {
-      if (!model) return
-      await repository.saveVariant(model, variant).catch(() => undefined)
-    },
-  }
-}
-
-function signal(name: "SIGINT" | "SIGUSR2"): MiniHost["signals"]["sigint"] {
-  return {
-    subscribe(listener) {
-      let subscribed = true
-      process.on(name, listener)
-      return () => {
-        if (!subscribed) return
-        subscribed = false
-        process.off(name, listener)
-      }
-    },
-  }
-}
-
-function createTrace(
-  logPath: string,
-  diagnostics: { pid: number; cwd: string; argv: string[] },
-): MiniHost["diagnostics"]["trace"] {
-  if (!process.env.OPENCODE_DIRECT_TRACE) return
-  const stamp = new Date()
-    .toISOString()
-    .replace(/[-:]/g, "")
-    .replace(/\.\d+Z$/, "Z")
-  const target = path.join(logPath, "direct", `${stamp}-${diagnostics.pid}.jsonl`)
-  const text = (data: unknown) =>
-    JSON.stringify(data, (_key, value) => (typeof value === "bigint" ? String(value) : value), 0)
-  fs.mkdirSync(path.dirname(target), { recursive: true })
-  fs.writeFileSync(
-    path.join(logPath, "direct", "latest.json"),
-    text({
-      time: new Date().toISOString(),
-      ...diagnostics,
-      path: target,
-    }) + "\n",
-  )
-  const trace = {
-    write(type: string, data?: unknown) {
-      fs.appendFileSync(
-        target,
-        text({
-          time: new Date().toISOString(),
-          pid: diagnostics.pid,
-          type,
-          data,
-        }) + "\n",
-      )
-    },
-  }
-  trace.write("trace.start", {
-    argv: diagnostics.argv,
-    cwd: diagnostics.cwd,
-    path: target,
-  })
-  return trace
-}
-
-function openTerminalStdin(target: string): NodeJS.ReadStream {
-  return new ReadStream(fs.openSync(target, "r"))
-}
-
-export function resolveInteractiveStdin(
-  stdin: NodeJS.ReadStream = process.stdin,
-  open: (target: string) => NodeJS.ReadStream = openTerminalStdin,
-  platform: NodeJS.Platform = process.platform,
-): InteractiveStdin {
-  if (stdin.isTTY) return { stdin, cleanup() {} }
-  const target = platform === "win32" ? "CONIN$" : "/dev/tty"
-  try {
-    const source = open(target)
-    let cleaned = false
-    return {
-      stdin: source,
-      cleanup() {
-        if (cleaned) return
-        cleaned = true
-        source.destroy()
-      },
-    }
-  } catch (error) {
-    throw new Error(INTERACTIVE_INPUT_ERROR, { cause: error })
-  }
-}
-
-/** @internal Exported for owner-local resource cleanup tests. */
-export async function usingInteractiveStdin<T>(
-  run: (terminal: InteractiveStdin) => Promise<T>,
-  resolve: () => InteractiveStdin = resolveInteractiveStdin,
-) {
-  const terminal = resolve()
-  try {
-    return await run(terminal)
-  } finally {
-    terminal.cleanup()
-  }
-}
-
-/** @internal Exported for owner-local host capability tests. */
-export function createMiniHost(input: {
-  terminal: InteractiveStdin
-  directory: string
-  paths?: { home: string; state: string; log: string }
-}): MiniHost {
-  const paths = input.paths ?? {
-    home: Global.Path.home,
-    state: Global.Path.state,
-    log: Global.Path.log,
-  }
-  const diagnostics = {
-    pid: process.pid,
-    cwd: input.directory,
-    argv: process.argv.slice(2),
-  }
-  return {
-    terminal: { stdin: input.terminal.stdin },
-    platform: process.platform,
-    stdout: {
-      write(value) {
-        process.stdout.write(value)
-      },
-    },
-    files: {
-      readText: (url) => readFile(new URL(url), "utf8"),
-    },
-    editor: {
-      async open(options) {
-        const { openEditor } = await import("@opencode-ai/tui/editor")
-        return openEditor(options)
-      },
-    },
-    paths: { home: paths.home },
-    signals: {
-      sigint: signal("SIGINT"),
-      sigusr2: signal("SIGUSR2"),
-    },
-    startup: {
-      showTiming: Flag.OPENCODE_SHOW_TTFD,
-      now: () => performance.now(),
-    },
-    diagnostics: {
-      trace: createTrace(paths.log, diagnostics),
-    },
-    preferences: preferences(paths.state),
-  }
-}

packages/cli/src/mini.ts

@@ -1,277 +0,0 @@
-import { Service, type Endpoint } from "@opencode-ai/client/effect/service"
-import { ClientError, OpenCode, type OpenCodeClient } from "@opencode-ai/client/promise"
-import type { MiniFrontendInput } from "@opencode-ai/tui/mini"
-import { setTimeout } from "node:timers/promises"
-import { waitForCatalogReady } from "./services/catalog"
-import { readStdin } from "./util/io"
-import { createMiniHost, INTERACTIVE_INPUT_ERROR, usingInteractiveStdin } from "./mini-host"
-import { parseSessionTargetModel, resolveSessionTarget, type SessionTargetPreparation } from "./session-target"
-
-export type MiniCommandInput = {
-  server: {
-    endpoint: Endpoint
-    reconnect?: (signal: AbortSignal) => Promise<Endpoint>
-  }
-  continue?: boolean
-  session?: string
-  fork?: boolean
-  model?: string
-  agent?: string
-  prompt?: string
-  replay?: boolean
-  replayLimit?: number
-  demo?: boolean
-  tuiConfig?: MiniFrontendInput["tuiConfig"]
-}
-
-type Model = MiniFrontendInput["model"]
-
-class MiniInputError extends Error {}
-
-export async function runMini(input: MiniCommandInput) {
-  try {
-    validate(input)
-    const result = await usingInteractiveStdin(async (terminal) => {
-      const initialInput = mergeInput(process.stdin.isTTY ? undefined : await readStdin(), input.prompt)
-      const frontendTask = import("@opencode-ai/tui/mini")
-      const directory = localDirectory()
-      const connection = createMiniConnection(input.server)
-      const sdk = connection.sdk
-      const requested = parseModel(input.model)
-      const model = requested ? { providerID: requested.providerID, modelID: requested.id } : undefined
-      const prepare = prepareTarget(input.agent)
-      const resolveTarget = async (initial: OpenCodeClient, signal: AbortSignal) => {
-        const resolved = await resolveMiniTarget({
-          sdk: initial,
-          reconnect: connection.reconnect,
-          signal,
-          resolve: (client) =>
-            resolveSessionTarget({
-              client,
-              location: { directory },
-              continue: input.continue,
-              session: input.session,
-              fork: input.fork,
-              model: requested,
-              agent: input.agent,
-              prepare,
-              signal,
-            }).catch((error) => {
-              if (error instanceof Error && error.message === "Session not found")
-                throw new MiniInputError(error.message)
-              throw error
-            }),
-        })
-        const target = resolved.value
-        return {
-          sdk: resolved.sdk,
-          sessionID: target.session.id,
-          sessionTitle: target.session.title,
-          location: target.location,
-          model: target.model ? { providerID: target.model.providerID, modelID: target.model.id } : undefined,
-          variant: target.model?.variant,
-          agent: target.agent,
-          resume: target.resume,
-        }
-      }
-      const create = (
-        client: OpenCodeClient,
-        next: {
-          location: { directory: string; workspaceID?: string }
-          agent: string | undefined
-          model: Model
-          variant: string | undefined
-        },
-        signal?: AbortSignal,
-      ) =>
-        resolveSessionTarget({
-          client,
-          location: { directory: next.location.directory, workspace: next.location.workspaceID },
-          agent: next.agent,
-          model: next.model
-            ? { providerID: next.model.providerID, id: next.model.modelID, variant: next.variant }
-            : undefined,
-          prepare,
-          signal,
-        }).then((target) => ({
-          sessionID: target.session.id,
-          sessionTitle: target.session.title,
-          location: target.location,
-          model: target.model ? { providerID: target.model.providerID, modelID: target.model.id } : undefined,
-          variant: target.model?.variant,
-          agent: target.agent,
-          resume: false,
-        }))
-      const frontend = await frontendTask
-      return frontend.runMiniFrontend({
-        host: createMiniHost({ terminal, directory }),
-        sdk,
-        directory,
-        target: resolveTarget,
-        reconnect: connection.reconnect,
-        createSession: create,
-        agent: input.agent,
-        model,
-        variant: requested?.variant,
-        files: [],
-        initialInput,
-        replay: input.replay ?? true,
-        replayLimit: input.replayLimit,
-        demo: input.demo,
-        tuiConfig: input.tuiConfig,
-      })
-    })
-    if (result.exitCode !== 0) process.exit(result.exitCode)
-  } catch (error) {
-    if (error instanceof MiniInputError || (error instanceof Error && error.message === INTERACTIVE_INPUT_ERROR))
-      fail(error.message)
-    throw error
-  }
-}
-
-/** @internal Exported for CLI boundary tests. */
-export function createMiniConnection(input: MiniCommandInput["server"]) {
-  const make = (endpoint: Endpoint) =>
-    OpenCode.make({
-      baseUrl: endpoint.url,
-      headers: Service.headers(endpoint),
-    })
-  const reconnect = input.reconnect
-  return {
-    sdk: make(input.endpoint),
-    reconnect: reconnect
-      ? async (signal: AbortSignal) => {
-          const endpoint = await reconnect(signal)
-          return make(endpoint)
-        }
-      : undefined,
-  }
-}
-
-/** @internal Exported for reconnect lifecycle tests. */
-export async function resolveMiniTarget<A>(input: {
-  sdk: OpenCodeClient
-  reconnect?: (signal: AbortSignal) => Promise<OpenCodeClient>
-  signal: AbortSignal
-  resolve: (sdk: OpenCodeClient) => Promise<A>
-}) {
-  let sdk = input.sdk
-  while (true) {
-    try {
-      return { sdk, value: await input.resolve(sdk) }
-    } catch (error) {
-      if (!input.reconnect || !(error instanceof ClientError) || error.reason !== "Transport") throw error
-      while (true) {
-        try {
-          sdk = await input.reconnect(input.signal)
-          break
-        } catch (resolveError) {
-          if (input.signal.aborted) throw resolveError
-          await setTimeout(250, undefined, { signal: input.signal })
-        }
-      }
-    }
-  }
-}
-
-export function validateMiniTerminal() {
-  if (!process.stdout.isTTY) fail("opencode mini requires a TTY stdout")
-}
-
-/** @internal Exported for testing. */
-export function mergeInput(piped: string | undefined, prompt: string | undefined) {
-  if (!prompt) return piped || undefined
-  if (!piped) return prompt
-  return piped + "\n" + prompt
-}
-
-function validate(input: MiniCommandInput) {
-  validateMiniTerminal()
-  if (input.replayLimit !== undefined && (!Number.isInteger(input.replayLimit) || input.replayLimit <= 0)) {
-    fail("--replay-limit must be a positive integer")
-  }
-  if (input.fork && !input.continue && !input.session) fail("--fork requires --continue or --session")
-}
-
-function localDirectory(): string {
-  const root = process.env.PWD ?? process.cwd()
-  try {
-    process.chdir(root)
-    return process.cwd()
-  } catch {
-    throw new MiniInputError(`Failed to change directory to ${root}`)
-  }
-}
-
-function parseModel(value?: string) {
-  try {
-    return parseSessionTargetModel(value)
-  } catch {
-    throw new MiniInputError("--model must use the format provider/model[#variant]")
-  }
-}
-
-function prepareTarget(requestedAgent?: string): SessionTargetPreparation {
-  return async (input) => {
-    if (input.model)
-      await waitForCatalogReady({
-        sdk: input.client,
-        directory: input.location.directory,
-        workspace: input.location.workspaceID,
-        model: { providerID: input.model.providerID, modelID: input.model.id },
-        signal: input.signal,
-      })
-    return {
-      model: input.model,
-      agent: requestedAgent
-        ? await validateAgent(
-            input.client,
-            input.location.directory,
-            input.location.workspaceID,
-            requestedAgent,
-            input.signal,
-          )
-        : input.agent,
-    }
-  }
-}
-
-async function validateAgent(
-  sdk: OpenCodeClient,
-  directory: string,
-  workspace: string | undefined,
-  name?: string,
-  signal?: AbortSignal,
-) {
-  if (!name) return
-  const deadline = Date.now() + 5_000
-  let agents: Awaited<ReturnType<OpenCodeClient["agent"]["list"]>> | undefined
-  while (Date.now() < deadline && !signal?.aborted) {
-    agents = await sdk.agent.list({ location: { directory, workspace } }, { signal }).catch((error) => {
-      if (signal && error instanceof ClientError && error.reason === "Transport") throw error
-      return undefined
-    })
-    const agent = agents?.data.find((item) => item.id === name)
-    if (agent?.mode === "subagent") {
-      warning(`agent "${name}" is a subagent, not a primary agent. Falling back to default agent`)
-      return
-    }
-    if (agent) return name
-    await setTimeout(25, undefined, { signal }).catch(() => {})
-  }
-  if (signal?.aborted) return
-  if (!agents) {
-    warning("failed to list agents. Falling back to default agent")
-    return
-  }
-  warning(`agent "${name}" not found. Falling back to default agent`)
-}
-
-function warning(message: string) {
-  process.stderr.write(`\x1b[93m\x1b[1m!\x1b[0m ${message}\n`)
-}
-
-function fail(message: string): never {
-  process.stderr.write(`\x1b[91m\x1b[1mError: \x1b[0m${message}\n`)
-  process.exit(1)
-}

packages/cli/src/mini/catalog.shared.ts

@@ -0,0 +1,159 @@
+import type {
+  AgentListOutput,
+  CommandListOutput,
+  ModelListOutput,
+  OpenCodeClient,
+  ProviderListOutput,
+  SkillListOutput,
+} from "@opencode-ai/client/promise"
+import type { RunAgent, RunCommand, RunProvider, RunReference } from "./types"
+
+type CurrentAgent = AgentListOutput["data"][number]
+type CurrentCommand = CommandListOutput["data"][number]
+type CurrentSkill = SkillListOutput["data"][number]
+type CurrentProvider = ProviderListOutput["data"][number]
+type CurrentModel = ModelListOutput["data"][number]
+
+function location(directory: string, workspace?: string) {
+  return {
+    location: {
+      directory,
+      workspace,
+    },
+  }
+}
+
+function defaultCost(model: CurrentModel) {
+  const picked = model.cost.find((cost) => cost.tier === undefined) ?? model.cost[0]
+  if (!picked) {
+    return undefined
+  }
+
+  return {
+    ...picked,
+    input: model.cost.every((cost) => cost.input === 0) ? 0 : picked.input,
+  }
+}
+
+export function runAgent(input: CurrentAgent): RunAgent {
+  return {
+    id: input.id,
+    name: input.name,
+    description: input.description,
+    mode: input.mode,
+    hidden: input.hidden,
+  }
+}
+
+export function runCommand(input: CurrentCommand): RunCommand {
+  return {
+    name: input.name,
+    description: input.description,
+  }
+}
+
+export function runSkill(input: CurrentSkill): RunCommand {
+  return {
+    name: input.id,
+    description: input.description,
+    source: "skill",
+  }
+}
+
+export function runProviders(providers: CurrentProvider[], models: CurrentModel[]): RunProvider[] {
+  const grouped = new Map<string, RunProvider>()
+
+  for (const provider of providers) {
+    grouped.set(provider.id, {
+      id: provider.id,
+      name: provider.name,
+      models: {},
+    })
+  }
+
+  for (const model of models) {
+    const provider = grouped.get(model.providerID) ?? {
+      id: model.providerID,
+      name: model.providerID,
+      models: {},
+    }
+    provider.models[model.id] = {
+      id: model.id,
+      providerID: model.providerID,
+      name: model.name,
+      capabilities: model.capabilities,
+      cost: defaultCost(model),
+      limit: model.limit,
+      status: model.status,
+      variants: Object.fromEntries((model.variants ?? []).map((variant) => [variant.id, {}])),
+    }
+    grouped.set(provider.id, provider)
+  }
+
+  return [...grouped.values()]
+}
+
+// A location boots its plugins in a deferred background batch after the layer
+// is built, so first-turn model resolution can observe empty catalog state.
+// For explicit --model flows, wait for that exact ref to appear before prompt
+// admission. On timeout, return and let the real execution error surface.
+export async function waitForCatalogReady(input: {
+  sdk: OpenCodeClient
+  directory: string
+  workspace?: string
+  model: { providerID: string; modelID: string }
+  timeoutMs?: number
+}) {
+  const deadline = Date.now() + (input.timeoutMs ?? 5_000)
+  while (Date.now() < deadline) {
+    const models = await input.sdk.model
+      .list(location(input.directory, input.workspace))
+      .then((result) => result.data)
+      .catch(() => undefined)
+    if (models?.some((model) => model.providerID === input.model.providerID && model.id === input.model.modelID)) return
+    await new Promise((resolve) => setTimeout(resolve, 25))
+  }
+}
+
+export async function waitForDefaultModel(input: {
+  sdk: OpenCodeClient
+  directory: string
+  timeoutMs?: number
+  active?: () => boolean
+}): Promise<{ providerID: string; modelID: string } | undefined> {
+  const deadline = Date.now() + (input.timeoutMs ?? 5_000)
+  while (Date.now() < deadline && (input.active?.() ?? true)) {
+    const model = await input.sdk.model
+      .default(location(input.directory))
+      .then((result) => result.data)
+      .catch(() => undefined)
+    if (model) return { providerID: model.providerID, modelID: model.id }
+    await new Promise((resolve) => setTimeout(resolve, 25))
+  }
+}
+
+export async function loadRunAgents(sdk: OpenCodeClient, directory: string): Promise<RunAgent[]> {
+  const result = await sdk.agent.list(location(directory))
+  return result.data.map(runAgent)
+}
+
+export async function loadRunCommands(sdk: OpenCodeClient, directory: string): Promise<RunCommand[]> {
+  const [commands, skills] = await Promise.all([
+    sdk.command.list(location(directory)),
+    sdk.skill.list(location(directory)),
+  ])
+  return [...commands.data.map(runCommand), ...skills.data.filter((skill) => skill.slash !== false).map(runSkill)]
+}
+
+export async function loadRunReferences(sdk: OpenCodeClient, directory: string): Promise<RunReference[]> {
+  const result = await sdk.reference.list(location(directory))
+  return result.data.filter((reference) => !reference.hidden)
+}
+
+export async function loadRunProviders(sdk: OpenCodeClient, directory: string): Promise<RunProvider[]> {
+  const [providers, models] = await Promise.all([
+    sdk.provider.list(location(directory)),
+    sdk.model.list(location(directory)),
+  ])
+  return runProviders([...providers.data], [...models.data])
+}

packages/cli/src/mini/demo.ts

@@ -2,30 +2,28 @@
 //
 // Enabled with `--demo`. Intercepts prompt submissions and drives the same
 // presentation commits and footer actions as the live transport. This
-// lets you test scrollback formatting, permission UI, canonical Form UI, and tool
+// lets you test scrollback formatting, permission UI, question UI, and tool
 // snapshots without making actual model calls. Pass a demo slash command as
 // the initial interactive message to trigger a preview immediately.
 //
 // Slash commands:
 //   /permission [kind] → triggers a permission request variant
-//   /form [kind]       → triggers a canonical Form request variant
+//   /question [kind]   → triggers a question request variant
 //   /fmt <kind>   → emits a specific tool/text type (text, reasoning, shell,
-//                   write, edit, patch, subagent, question, error, mix)
+//                   write, edit, patch, task, question, error, mix)
 //
-// Demo mode handles permission and Form replies locally, completing or failing
-// the synthetic tool parts through the same callbacks used by the live footer.
+// Demo mode also handles permission and question replies locally, completing
+// or failing the synthetic tool parts as appropriate.
 import path from "path"
-import type { JsonValue, SessionMessageAssistantTool } from "@opencode-ai/client/promise"
+import type { PermissionV2Request, QuestionV2Request } from "@opencode-ai/client/promise"
 import { writeSessionOutput } from "./stream"
 import { toolCommit } from "./stream-v2.subagent"
 import type {
   FooterApi,
-  FooterView,
-  FormCancel,
-  FormReply,
-  MiniFormRequest,
-  MiniPermissionRequest,
+  MiniToolPart,
   PermissionReply,
+  QuestionReject,
+  QuestionReply,
   RunPrompt,
   StreamCommit,
 } from "./types"
@@ -39,25 +37,25 @@ const KINDS = [
   "write",
   "edit",
   "patch",
-  "subagent",
+  "task",
   "question",
   "error",
   "mix",
 ]
-const PERMISSIONS = ["edit", "shell", "read", "subagent", "external", "doom"] as const
-const FORMS = ["question", "external"] as const
+const PERMISSIONS = ["edit", "shell", "read", "task", "external", "doom"] as const
+const QUESTIONS = ["multi", "single", "checklist", "custom"] as const
 
 type PermissionKind = (typeof PERMISSIONS)[number]
-type FormKind = (typeof FORMS)[number]
+type QuestionKind = (typeof QUESTIONS)[number]
 
 function permissionKind(value: string | undefined): PermissionKind | undefined {
   const next = (value || "edit").toLowerCase()
   return PERMISSIONS.find((item) => item === next)
 }
 
-function formKind(value: string | undefined): FormKind | undefined {
-  const next = (value || "question").toLowerCase()
-  return FORMS.find((item) => item === next)
+function questionKind(value: string | undefined): QuestionKind | undefined {
+  const next = (value || "multi").toLowerCase()
+  return QUESTIONS.find((item) => item === next)
 }
 
 const SAMPLE_MARKDOWN = [
@@ -113,14 +111,12 @@ type Ref = {
   part: string
   call: string
   tool: string
-  input: Record<string, JsonValue>
+  input: Record<string, unknown>
   start: number
 }
 
-type FormRequest = {
+type Ask = {
   ref: Ref
-  kind: FormKind
-  request: MiniFormRequest
 }
 
 type Perm = {
@@ -128,7 +124,7 @@ type Perm = {
   done: {
     title: string
     output: string
-    metadata?: Record<string, JsonValue>
+    metadata?: Record<string, unknown>
   }
 }
 
@@ -136,7 +132,7 @@ type Permit = {
   ref: Ref
   permission: string
   patterns: string[]
-  metadata?: MiniPermissionRequest["metadata"]
+  metadata?: PermissionV2Request["metadata"]
   always: string[]
   done: Perm["done"]
 }
@@ -149,9 +145,9 @@ type State = {
   part: number
   call: number
   perm: number
-  form: number
+  ask: number
   perms: Map<string, Perm>
-  forms: Map<string, FormRequest>
+  asks: Map<string, Ask>
   started: Set<string>
 }
 
@@ -177,7 +173,7 @@ function clearSubagent(footer: FooterApi): void {
       tabs: [],
       details: {},
       permissions: [],
-      forms: [],
+      questions: [],
     },
   })
 }
@@ -186,10 +182,13 @@ function showSubagent(
   state: State,
   input: {
     sessionID: string
+    partID: string
+    callID: string
     label: string
     description: string
     status: "running" | "completed" | "cancelled" | "error"
     title?: string
+    toolCalls?: number
     commits: StreamCommit[]
   },
 ) {
@@ -199,20 +198,24 @@ function showSubagent(
       tabs: [
         {
           sessionID: input.sessionID,
+          partID: input.partID,
+          callID: input.callID,
           label: input.label,
           description: input.description,
           status: input.status,
           title: input.title,
+          toolCalls: input.toolCalls,
           lastUpdatedAt: Date.now(),
         },
       ],
       details: {
         [input.sessionID]: {
+          sessionID: input.sessionID,
           commits: input.commits,
         },
       },
       permissions: [],
-      forms: [],
+      questions: [],
     },
   })
 }
@@ -253,24 +256,21 @@ function split(text: string): string[] {
   return [text.slice(0, size), text.slice(size, size * 2), text.slice(size * 2)]
 }
 
-function take(state: State, key: "msg" | "part" | "call" | "perm", prefix: string): string {
+function take(state: State, key: "msg" | "part" | "call" | "perm" | "ask", prefix: string): string {
   state[key] += 1
   return `demo_${prefix}_${state[key]}`
 }
 
-function present(state: State, commits: StreamCommit[], view?: FooterView): void {
+function present(state: State, commits: StreamCommit[], view?: QuestionV2Request | PermissionV2Request): void {
   writeSessionOutput(
     { footer: state.footer },
     {
       commits,
-      updates: view
-        ? [
-            {
-              type: "stream.patch" as const,
-              patch: { status: view.type === "permission" ? "awaiting permission" : "awaiting form" },
-            },
-            { type: "stream.view" as const, view },
-          ]
+      footer: view
+        ? {
+            view: "action" in view ? { type: "permission", request: view } : { type: "question", request: view },
+            patch: { status: "action" in view ? "awaiting permission" : "awaiting answer" },
+          }
         : undefined,
     },
   )
@@ -279,13 +279,7 @@ function present(state: State, commits: StreamCommit[], view?: FooterView): void
 function clearBlocker(state: State): void {
   writeSessionOutput(
     { footer: state.footer },
-    {
-      commits: [],
-      updates: [
-        { type: "stream.patch", patch: { status: "" } },
-        { type: "stream.view", view: { type: "prompt" } },
-      ],
-    },
+    { commits: [], footer: { view: { type: "prompt" }, patch: { status: "" } } },
   )
 }
 
@@ -301,9 +295,7 @@ async function emitText(state: State, body: string, signal?: AbortSignal): Promi
       return
     }
 
-    present(state, [
-      { kind: "assistant", source: "assistant", text: item, phase: "progress", messageID: msg, partID: part },
-    ])
+    present(state, [{ kind: "assistant", source: "assistant", text: item, phase: "progress", messageID: msg, partID: part }])
     await wait(45, signal)
   }
 }
@@ -334,7 +326,7 @@ async function emitReasoning(state: State, body: string, signal?: AbortSignal):
   }
 }
 
-function make(state: State, tool: string, input: Record<string, JsonValue>): Ref {
+function make(state: State, tool: string, input: Record<string, unknown>): Ref {
   return {
     msg: open(state),
     part: take(state, "part", "part"),
@@ -345,21 +337,28 @@ function make(state: State, tool: string, input: Record<string, JsonValue>): Ref
   }
 }
 
-function startTool(state: State, ref: Ref, structured: Record<string, JsonValue> = {}): SessionMessageAssistantTool {
+function startTool(state: State, ref: Ref, metadata: Record<string, unknown> = {}): void {
   state.started.add(ref.part)
-  const part = {
-    type: "tool" as const,
-    id: ref.call,
-    name: ref.tool,
-    state: { status: "running" as const, input: ref.input, structured, content: [] },
-    time: { created: ref.start, ran: ref.start },
-  }
-  present(state, [toolCommit(part, ref.msg, "start")])
-  return part
+  present(
+    state,
+    [
+      toolCommit(
+        {
+          id: ref.part,
+          sessionID: state.id,
+          messageID: ref.msg,
+          callID: ref.call,
+          tool: ref.tool,
+          state: { status: "running", input: ref.input, metadata, time: { start: ref.start } },
+        },
+        "start",
+      ),
+    ],
+  )
 }
 
 function askPermission(state: State, item: Permit): void {
-  const tool = startTool(state, item.ref)
+  startTool(state, item.ref)
 
   const id = take(state, "perm", "perm")
   state.perms.set(id, {
@@ -368,17 +367,13 @@ function askPermission(state: State, item: Permit): void {
   })
 
   present(state, [], {
-    type: "permission",
-    request: {
-      id,
-      sessionID: state.id,
-      action: item.permission,
-      resources: item.patterns,
-      metadata: item.metadata ?? {},
-      save: item.always,
-      source: { type: "tool", messageID: item.ref.msg, callID: item.ref.call },
-      tool,
-    },
+    id,
+    sessionID: state.id,
+    action: item.permission,
+    resources: item.patterns,
+    metadata: item.metadata ?? {},
+    save: item.always,
+    source: { type: "tool", messageID: item.ref.msg, callID: item.ref.call },
   })
 }
 
@@ -388,46 +383,52 @@ function doneTool(
   output: {
     title: string
     output: string
-    metadata?: Record<string, JsonValue>
+    metadata?: Record<string, unknown>
   },
 ): void {
   if (!state.started.has(ref.part)) startTool(state, ref)
-  const part: SessionMessageAssistantTool = {
-    type: "tool",
-    id: ref.call,
-    name: ref.tool,
+  const part: MiniToolPart = {
+    id: ref.part,
+    sessionID: state.id,
+    messageID: ref.msg,
+    callID: ref.call,
+    tool: ref.tool,
     state: {
       status: "completed",
       input: ref.input,
-      content: output.output ? [{ type: "text", text: output.output }] : [],
-      structured: output.metadata ?? {},
+      output: output.output,
+      title: output.title,
+      metadata: output.metadata ?? {},
+      time: { start: ref.start, end: Date.now() },
     },
-    time: { created: ref.start, ran: ref.start, completed: Date.now() },
   }
-  present(state, [toolCommit(part, ref.msg, output.output ? "progress" : "final")])
+  present(state, [toolCommit(part, output.output ? "progress" : "final")])
 }
 
 function failTool(state: State, ref: Ref, error: string): void {
   if (!state.started.has(ref.part)) startTool(state, ref)
-  present(state, [
-    toolCommit(
-      {
-        type: "tool",
-        id: ref.call,
-        name: ref.tool,
-        state: {
-          status: "error",
-          input: ref.input,
-          error: { type: "unknown", message: error },
-          structured: {},
-          content: [],
+  present(
+    state,
+    [
+      toolCommit(
+        {
+          id: ref.part,
+          sessionID: state.id,
+          messageID: ref.msg,
+          callID: ref.call,
+          tool: ref.tool,
+          state: {
+            status: "error",
+            input: ref.input,
+            error,
+            metadata: {},
+            time: { start: ref.start, end: Date.now() },
+          },
         },
-        time: { created: ref.start, ran: ref.start, completed: Date.now() },
-      },
-      ref.msg,
-      "final",
-    ),
-  ])
+        "final",
+      ),
+    ],
+  )
 }
 
 function emitError(state: State, text: string): void {
@@ -446,7 +447,7 @@ async function emitBash(state: State, signal?: AbortSignal): Promise<void> {
     title: "git status",
     output: `${process.cwd()}\ngit status\nOn branch demo\nnothing to commit, working tree clean\n`,
     metadata: {
-      exit: 0,
+      exitCode: 0,
     },
   })
 }
@@ -454,7 +455,7 @@ async function emitBash(state: State, signal?: AbortSignal): Promise<void> {
 function emitWrite(state: State): void {
   const file = path.join(process.cwd(), "src", "demo-format.ts")
   const ref = make(state, "write", {
-    path: file,
+    filePath: file,
     content: "export const demo = 42\n",
   })
   doneTool(state, ref, {
@@ -467,19 +468,13 @@ function emitWrite(state: State): void {
 function emitEdit(state: State): void {
   const file = path.join(process.cwd(), "src", "demo-format.ts")
   const ref = make(state, "edit", {
-    path: file,
+    filePath: file,
   })
   doneTool(state, ref, {
     title: "edit",
     output: "",
     metadata: {
-      files: [
-        {
-          file,
-          status: "modified",
-          patch: "@@ -1 +1 @@\n-export const demo = 1\n+export const demo = 42\n",
-        },
-      ],
+      diff: "@@ -1 +1 @@\n-export const demo = 1\n+export const demo = 42\n",
     },
   })
 }
@@ -495,15 +490,17 @@ function emitPatch(state: State): void {
     metadata: {
       files: [
         {
-          status: "modified",
-          file,
-          patch: "@@ -1 +1 @@\n-export const demo = 1\n+export const demo = 42\n",
+          type: "update",
+          filePath: file,
+          relativePath: "src/demo-format.ts",
+          diff: "@@ -1 +1 @@\n-export const demo = 1\n+export const demo = 42\n",
           deletions: 1,
         },
         {
-          status: "added",
-          file: path.join(process.cwd(), "README-demo.md"),
-          patch: "@@ -0,0 +1,4 @@\n+# Demo\n+This is a generated preview file.\n",
+          type: "add",
+          filePath: path.join(process.cwd(), "README-demo.md"),
+          relativePath: "README-demo.md",
+          diff: "@@ -0,0 +1,4 @@\n+# Demo\n+This is a generated preview file.\n",
           deletions: 0,
         },
       ],
@@ -512,41 +509,46 @@ function emitPatch(state: State): void {
 }
 
 function emitTask(state: State): void {
-  const ref = make(state, "subagent", {
+  const ref = make(state, "task", {
     description: "Scan run/* for reducer touchpoints",
-    agent: "explore",
+    subagent_type: "explore",
   })
   doneTool(state, ref, {
     title: "Reducer touchpoints found",
     output: "",
     metadata: {
-      sessionID: "sub_demo_1",
-      status: "completed",
-      output: "",
+      toolcalls: 4,
+      sessionId: "sub_demo_1",
     },
   })
   const part = {
+    id: "sub_demo_tool_1",
     type: "tool",
-    id: "sub_demo_call_1",
-    name: "read",
+    sessionID: "sub_demo_1",
+    messageID: "sub_demo_msg_tool",
+    callID: "sub_demo_call_1",
+    tool: "read",
     state: {
       status: "running",
       input: {
-        path: "packages/tui/src/mini/stream.ts",
+        filePath: "packages/cli/src/mini/stream.ts",
         offset: 1,
         limit: 200,
       },
-      structured: {},
-      content: [],
+      time: {
+        start: Date.now(),
+      },
     },
-    time: { created: Date.now(), ran: Date.now() },
-  } satisfies SessionMessageAssistantTool
+  } satisfies MiniToolPart
   showSubagent(state, {
     sessionID: "sub_demo_1",
+    partID: ref.part,
+    callID: ref.call,
     label: "Explore",
     description: "Scan run/* for reducer touchpoints",
     status: "completed",
     title: "Reducer touchpoints found",
+    toolCalls: 4,
     commits: [
       {
         kind: "user",
@@ -595,7 +597,6 @@ function emitQuestionTool(state: State): void {
           { label: "Code", description: "Show code block" },
         ],
         multiple: false,
-        custom: false,
       },
       {
         header: "Extras",
@@ -638,7 +639,7 @@ function emitPermission(state: State, kind: PermissionKind = "edit"): void {
         title: "git status --short",
         output: `${root}\ngit status --short\n M src/demo-format.ts\n?? src/demo-permission.ts\n`,
         metadata: {
-          exit: 0,
+          exitCode: 0,
         },
       },
     })
@@ -648,7 +649,7 @@ function emitPermission(state: State, kind: PermissionKind = "edit"): void {
   if (kind === "read") {
     const target = path.join(root, "package.json")
     const ref = make(state, "read", {
-      path: target,
+      filePath: target,
       offset: 1,
       limit: 80,
     })
@@ -666,23 +667,22 @@ function emitPermission(state: State, kind: PermissionKind = "edit"): void {
     return
   }
 
-  if (kind === "subagent") {
-    const ref = make(state, "subagent", {
+  if (kind === "task") {
+    const ref = make(state, "task", {
       description: "Inspect footer spacing across direct-mode prompts",
-      agent: "explore",
+      subagent_type: "explore",
     })
     askPermission(state, {
       ref,
-      permission: "subagent",
+      permission: "task",
       patterns: ["explore"],
       always: ["*"],
       done: {
         title: "Footer spacing checked",
         output: "",
         metadata: {
-          sessionID: "sub_demo_perm_1",
-          status: "completed",
-          output: "",
+          toolcalls: 3,
+          sessionId: "sub_demo_perm_1",
         },
       },
     })
@@ -693,7 +693,7 @@ function emitPermission(state: State, kind: PermissionKind = "edit"): void {
     const dir = path.join(path.dirname(root), "demo-shared")
     const target = path.join(dir, "README.md")
     const ref = make(state, "read", {
-      path: target,
+      filePath: target,
       offset: 1,
       limit: 40,
     })
@@ -716,9 +716,9 @@ function emitPermission(state: State, kind: PermissionKind = "edit"): void {
   }
 
   if (kind === "doom") {
-    const ref = make(state, "subagent", {
+    const ref = make(state, "task", {
       description: "Retry the formatter after repeated failures",
-      agent: "general",
+      subagent_type: "general",
     })
     askPermission(state, {
       ref,
@@ -736,7 +736,9 @@ function emitPermission(state: State, kind: PermissionKind = "edit"): void {
 
   const diff = "@@ -1 +1 @@\n-export const demo = 1\n+export const demo = 42\n"
   const ref = make(state, "edit", {
-    path: file,
+    filePath: file,
+    filepath: file,
+    diff,
   })
   askPermission(state, {
     ref,
@@ -747,98 +749,96 @@ function emitPermission(state: State, kind: PermissionKind = "edit"): void {
       title: "edit",
       output: "",
       metadata: {
-        files: [{ file, status: "modified", patch: diff }],
+        diff,
       },
     },
   })
 }
 
-function demoForm(kind: FormKind): { title: string; fields: MiniFormRequest["fields"]; questions?: JsonValue[] } {
-  if (kind === "question") {
-    const questions: JsonValue[] = [
+function emitQuestion(state: State, kind: QuestionKind = "multi"): void {
+  const questions = (() => {
+    if (kind === "single") {
+      return [
+        {
+          header: "Mode",
+          question: "Which footer should be the reference for spacing checks?",
+          options: [
+            { label: "Permission", description: "Inspect the permission footer" },
+            { label: "Question", description: "Keep this question footer open" },
+            { label: "Prompt", description: "Return to the normal composer" },
+          ],
+          multiple: false,
+          custom: false,
+        },
+      ]
+    }
+
+    if (kind === "checklist") {
+      return [
+        {
+          header: "Checks",
+          question: "Select the direct-mode cases you want to inspect next",
+          options: [
+            { label: "Diff", description: "Show an edit diff in the footer" },
+            { label: "Task", description: "Show a structured task summary" },
+            { label: "Error", description: "Show an error transcript row" },
+          ],
+          multiple: true,
+          custom: false,
+        },
+      ]
+    }
+
+    if (kind === "custom") {
+      return [
+        {
+          header: "Reply",
+          question: "What custom answer should appear in the footer preview?",
+          options: [
+            { label: "Short note", description: "Keep the answer to one line" },
+            { label: "Wrapped note", description: "Use a longer answer to test wrapping" },
+          ],
+          multiple: false,
+          custom: true,
+        },
+      ]
+    }
+
+    return [
       {
         header: "Layout",
-        question: "Which footer view should be the reference for spacing checks?",
+        question: "Which footer view should stay active while testing?",
         options: [
-          { label: "Form", description: "Inspect the canonical Form footer" },
-          { label: "Prompt", description: "Return to the normal composer" },
+          { label: "Prompt", description: "Return to prompt" },
+          { label: "Question", description: "Keep question open" },
         ],
         multiple: false,
-        custom: true,
       },
       {
-        header: "Checks",
+        header: "Rows",
         question: "Pick formatting previews",
         options: [
-          { label: "Diff", description: "Emit an edit diff" },
-          { label: "Subagent", description: "Emit a subagent card" },
+          { label: "Diff", description: "Emit edit diff" },
+          { label: "Task", description: "Emit task card" },
         ],
         multiple: true,
         custom: true,
       },
     ]
-    return {
-      title: "Questions",
-      questions,
-      fields: [
-        {
-          key: "q0",
-          title: "Layout",
-          description: "Which footer view should be the reference for spacing checks?",
-          type: "string",
-          options: [
-            { value: "Form", label: "Form", description: "Inspect the canonical Form footer" },
-            { value: "Prompt", label: "Prompt", description: "Return to the normal composer" },
-          ],
-          custom: true,
-        },
-        {
-          key: "q1",
-          title: "Checks",
-          description: "Pick formatting previews",
-          type: "multiselect",
-          options: [
-            { value: "Diff", label: "Diff", description: "Emit an edit diff" },
-            { value: "Subagent", label: "Subagent", description: "Emit a subagent card" },
-          ],
-          custom: true,
-        },
-      ],
-    }
-  }
-  return {
-    title: "MCP authorization",
-    fields: [
-      {
-        key: "authorization",
-        type: "external",
-        url: "https://example.com/opencode-demo",
-        title: "Authorize demo MCP server",
-        description: "Complete authorization in your browser",
-      },
-    ],
-  }
-}
+  })()
 
-function emitForm(state: State, kind: FormKind = "question"): void {
-  const form = demoForm(kind)
-  const ref = make(state, kind === "question" ? "question" : "mcp_demo", {
-    ...(form.questions ? { questions: form.questions } : { form: kind }),
-  })
+  const ref = make(state, "question", { questions })
   startTool(state, ref)
-  state.form++
-  const request: MiniFormRequest = {
-    id: `frm_demo_${state.form}`,
+
+  const id = take(state, "ask", "ask")
+  state.asks.set(id, { ref })
+
+  present(state, [], {
+    id,
     sessionID: state.id,
-    title: form.title,
-    metadata:
-      kind === "question"
-        ? { kind: "question", tool: { messageID: ref.msg, callID: ref.call } }
-        : { kind: "mcp", message: `Synthetic ${kind} MCP elicitation` },
-    fields: form.fields,
-  }
-  state.forms.set(request.id, { ref, kind, request })
-  present(state, [], { type: "form", request })
+    questions,
+    tool: { messageID: ref.msg, callID: ref.call },
+  })
 }
 
 async function emitFmt(state: State, kind: string, body: string, signal?: AbortSignal): Promise<boolean> {
@@ -882,7 +882,7 @@ async function emitFmt(state: State, kind: string, body: string, signal?: AbortS
     return true
   }
 
-  if (kind === "subagent") {
+  if (kind === "task") {
     emitTask(state)
     return true
   }
@@ -921,12 +921,11 @@ function intro(state: State): void {
     [
       "Demo slash commands enabled for interactive mode.",
       `- /permission [kind] (${PERMISSIONS.join(", ")})`,
-      `- /form [kind] (${FORMS.join(", ")})`,
+      `- /question [kind] (${QUESTIONS.join(", ")})`,
       `- /fmt <kind> (${KINDS.join(", ")})`,
       "Examples:",
       "- /permission shell",
-      "- /form question",
-      "- /form external",
+      "- /question custom",
       "- /fmt markdown",
       "- /fmt table",
       "- /fmt text your custom text",
@@ -943,9 +942,9 @@ export function createRunDemo(input: Input) {
     part: 0,
     call: 0,
     perm: 0,
-    form: 0,
+    ask: 0,
     perms: new Map(),
-    forms: new Map(),
+    asks: new Map(),
     started: new Set(),
   }
 
@@ -976,14 +975,14 @@ export function createRunDemo(input: Input) {
       return true
     }
 
-    if (cmd === "/form") {
-      const kind = formKind(list[1])
+    if (cmd === "/question") {
+      const kind = questionKind(list[1])
       if (!kind) {
-        note(state.footer, `Pick a form kind: ${FORMS.join(", ")}`)
+        note(state.footer, `Pick a question kind: ${QUESTIONS.join(", ")}`)
         return true
       }
 
-      emitForm(state, kind)
+      emitQuestion(state, kind)
       return true
     }
 
@@ -1025,41 +1024,33 @@ export function createRunDemo(input: Input) {
     return true
   }
 
-  const formReply = (input: FormReply): boolean => {
-    const form = state.forms.get(input.formID)
-    if (!form || input.sessionID !== form.request.sessionID) return false
-    state.forms.delete(input.formID)
-    clearBlocker(state)
-    if (form.kind === "question") {
-      doneTool(state, form.ref, {
-        title: "question",
-        output: "",
-        metadata: {
-          answers: form.request.fields.map((field) => {
-            const value = input.answer[field.key]
-            if (value === undefined) return []
-            return Array.isArray(value) ? [...value] : [String(value)]
-          }),
-        },
-      })
-      return true
+  const questionReply = (input: QuestionReply): boolean => {
+    const ask = state.asks.get(input.requestID)
+    if (!ask || !input.answers) {
+      return false
     }
-    doneTool(state, form.ref, {
-      title: form.request.title,
-      output: `Form submitted: ${Object.entries(input.answer)
-        .map(([key, value]) => `${key}=${Array.isArray(value) ? value.join(", ") : String(value)}`)
-        .join("; ")}\n`,
-      metadata: { answer: input.answer },
+
+    state.asks.delete(input.requestID)
+    clearBlocker(state)
+    doneTool(state, ask.ref, {
+      title: "question",
+      output: "",
+      metadata: {
+        answers: input.answers,
+      },
     })
     return true
   }
 
-  const formCancel = (input: FormCancel): boolean => {
-    const form = state.forms.get(input.formID)
-    if (!form || input.sessionID !== form.request.sessionID) return false
-    state.forms.delete(input.formID)
+  const questionReject = (input: QuestionReject): boolean => {
+    const ask = state.asks.get(input.requestID)
+    if (!ask) {
+      return false
+    }
+
+    state.asks.delete(input.requestID)
     clearBlocker(state)
-    failTool(state, form.ref, "form cancelled")
+    failTool(state, ask.ref, "question rejected")
     return true
   }
 
@@ -1067,7 +1058,7 @@ export function createRunDemo(input: Input) {
     start,
     prompt,
     permission,
-    formReply,
-    formCancel,
+    questionReply,
+    questionReject,
   }
 }

packages/cli/src/mini/entry.body.ts

@@ -6,11 +6,11 @@ export type EntryFlags = {
   trailingNewline: boolean
 }
 
-const RUN_ENTRY_NONE: RunEntryBody = {
+export const RUN_ENTRY_NONE: RunEntryBody = {
   type: "none",
 }
 
-function cleanRunText(text: string): string {
+export function cleanRunText(text: string): string {
   return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n")
 }
 

packages/cli/src/mini/footer.command.tsx

@@ -48,6 +48,8 @@ type QueuedEntry = PanelEntry & {
   prompt: FooterQueuedPrompt
 }
 
+type MenuState = ReturnType<typeof createFooterMenuState>
+
 const PANEL_PAD = 2
 const PANEL_LIST_ROWS = 10
 const PANEL_FRAME_ROWS = 6
@@ -122,6 +124,72 @@ function subagentStatusLabel(status: FooterSubagentTab["status"]) {
   return "running"
 }
 
+function handleKey(input: {
+  event: KeyEvent
+  menu: MenuState
+  field: () => InputRenderable | undefined
+  setQuery: (value: string) => void
+  select: () => void
+  close: () => void
+}) {
+  const name = input.event.name.toLowerCase()
+  const ctrl = input.event.ctrl && !input.event.meta && !input.event.shift && !input.event.super
+
+  if (name === "escape" || (ctrl && name === "c")) {
+    input.event.preventDefault()
+    input.close()
+    return
+  }
+
+  if (name === "up" || (ctrl && name === "p")) {
+    input.event.preventDefault()
+    input.menu.move(-1)
+    return
+  }
+
+  if (name === "down" || (ctrl && name === "n")) {
+    input.event.preventDefault()
+    input.menu.move(1)
+    return
+  }
+
+  if (name === "pageup") {
+    input.event.preventDefault()
+    input.menu.reveal(input.menu.selected() - PANEL_PAGE)
+    return
+  }
+
+  if (name === "pagedown") {
+    input.event.preventDefault()
+    input.menu.reveal(input.menu.selected() + PANEL_PAGE)
+    return
+  }
+
+  if (name === "home") {
+    input.event.preventDefault()
+    input.menu.reveal(0)
+    return
+  }
+
+  if (name === "end") {
+    input.event.preventDefault()
+    input.menu.reveal(Number.POSITIVE_INFINITY)
+    return
+  }
+
+  if (name === "return") {
+    input.event.preventDefault()
+    input.select()
+    return
+  }
+
+  if (ctrl && name === "u") {
+    input.event.preventDefault()
+    input.setQuery("")
+    input.field()?.setText("")
+  }
+}
+
 function match<T extends PanelEntry>(query: string, entries: T[]) {
   const text = query.trim()
   if (!text) {
@@ -133,128 +201,6 @@ function match<T extends PanelEntry>(query: string, entries: T[]) {
     .map((item) => item.obj)
 }
 
-function createSearchablePanelController<T extends PanelEntry>(input: {
-  entries: Accessor<T[]>
-  limit: number
-  onClose: () => void
-  onSelect: (item: T) => void
-  isCurrent?: (item: T) => boolean
-  closeOnFirstUp?: boolean
-  onKey?: (event: KeyEvent, item: T | undefined) => boolean
-  onRows?: (rows: number) => void
-}) {
-  let field: InputRenderable | undefined
-  const [query, setQuery] = createSignal("")
-  const items = createMemo<T[]>(() => match(query(), input.entries()))
-  const menu = createFooterMenuState({ count: () => items().length, limit: input.limit })
-  const selected = () => items()[menu.selected()]
-
-  createEffect(() => {
-    query()
-    menu.reset()
-  })
-
-  createEffect(() => {
-    if (!input.isCurrent || query().trim()) {
-      return
-    }
-
-    const index = items().findIndex(input.isCurrent)
-    if (index !== -1) {
-      menu.reveal(index)
-    }
-  })
-
-  createEffect(() => {
-    input.onRows?.(menu.rows() + PANEL_FRAME_ROWS)
-  })
-
-  useKeyboard((event) => {
-    if (event.defaultPrevented) {
-      return
-    }
-
-    if (input.onKey?.(event, selected())) {
-      return
-    }
-
-    const name = event.name.toLowerCase()
-    if (input.closeOnFirstUp && name === "up" && menu.selected() === 0) {
-      event.preventDefault()
-      input.onClose()
-      return
-    }
-
-    const ctrl = event.ctrl && !event.meta && !event.shift && !event.super
-    if (name === "escape" || (ctrl && name === "c")) {
-      event.preventDefault()
-      input.onClose()
-      return
-    }
-
-    if (name === "up" || (ctrl && name === "p")) {
-      event.preventDefault()
-      menu.move(-1)
-      return
-    }
-
-    if (name === "down" || (ctrl && name === "n")) {
-      event.preventDefault()
-      menu.move(1)
-      return
-    }
-
-    if (name === "pageup") {
-      event.preventDefault()
-      menu.reveal(menu.selected() - PANEL_PAGE)
-      return
-    }
-
-    if (name === "pagedown") {
-      event.preventDefault()
-      menu.reveal(menu.selected() + PANEL_PAGE)
-      return
-    }
-
-    if (name === "home") {
-      event.preventDefault()
-      menu.reveal(0)
-      return
-    }
-
-    if (name === "end") {
-      event.preventDefault()
-      menu.reveal(Number.POSITIVE_INFINITY)
-      return
-    }
-
-    if (name === "return") {
-      event.preventDefault()
-      const item = selected()
-      if (item) {
-        input.onSelect(item)
-      }
-      return
-    }
-
-    if (ctrl && name === "u") {
-      event.preventDefault()
-      setQuery("")
-      field?.setText("")
-    }
-  })
-
-  return {
-    query,
-    setQuery,
-    items,
-    menu,
-    inputRef(input: InputRenderable) {
-      field = input
-    },
-  }
-}
-
 function PanelShell(props: {
   title: string
   countVisible?: boolean
@@ -404,6 +350,8 @@ export function RunCommandMenuBody(props: {
   onNew: () => void
   onExit: () => void
 }) {
+  let field: InputRenderable | undefined
+  const [query, setQuery] = createSignal("")
   const skills = createMemo(() => (props.commands() ?? []).filter((item) => item.source === "skill"))
   const activeSubagentCount = createMemo(() => props.subagents().filter((item) => item.status === "running").length)
   const entries = createMemo<CommandEntry[]>(() => {
@@ -518,6 +466,8 @@ export function RunCommandMenuBody(props: {
       { action: "exit", category: "System", display: "Exit", footer: "/exit", keywords: "/exit exit" },
     ]
   })
+  const items = createMemo<CommandEntry[]>(() => match(query(), entries()))
+  const menu = createFooterMenuState({ count: () => items().length, limit: PANEL_LIST_ROWS })
   const pick = (item: CommandEntry) => {
     if (item.action === "model") {
       props.onModel()
@@ -566,39 +516,56 @@ export function RunCommandMenuBody(props: {
 
     props.onCommand(item.name)
   }
-  const controller = createSearchablePanelController({
-    entries,
-    limit: PANEL_LIST_ROWS,
-    onClose: props.onClose,
-    onSelect: pick,
+  const select = () => {
+    const item = items()[menu.selected()]
+    if (!item) {
+      return
+    }
+
+    pick(item)
+  }
+
+  createEffect(() => {
+    query()
+    menu.reset()
+  })
+
+  useKeyboard((event) => {
+    if (event.defaultPrevented) {
+      return
+    }
+
+    handleKey({ event, menu, field: () => field, setQuery, select, close: props.onClose })
   })
 
   return (
     <PanelShell
       title="Commands"
       countVisible={false}
-      query={controller.query()}
-      count={controller.items().length}
+      query={query()}
+      count={items().length}
       total={entries().length}
       placeholder="Search"
       theme={props.theme}
-      inputRef={controller.inputRef}
-      onQuery={controller.setQuery}
+      inputRef={(input) => {
+        field = input
+      }}
+      onQuery={setQuery}
       dark
       chrome="minimal"
     >
       <RunFooterMenu
         theme={props.theme}
-        items={controller.items}
-        selected={controller.menu.selected}
-        offset={controller.menu.offset}
+        items={items}
+        selected={menu.selected}
+        offset={menu.offset}
         rows={() => PANEL_LIST_ROWS}
         limit={PANEL_LIST_ROWS}
         empty="No results found"
         border={false}
         paddingLeft={PANEL_PAD}
         paddingRight={PANEL_PAD}
-        grouped={!controller.query().trim()}
+        grouped={!query().trim()}
         background
         headerColor={props.theme().muted}
       />
@@ -614,6 +581,8 @@ export function RunSubagentSelectBody(props: {
   onSelect: (sessionID: string) => void
   onRows?: (rows: number) => void
 }) {
+  let field: InputRenderable | undefined
+  const [query, setQuery] = createSignal("")
   const entries = createMemo<SubagentEntry[]>(() =>
     props.tabs().map((item) => {
       const title = item.description || item.title || item.label
@@ -628,35 +597,72 @@ export function RunSubagentSelectBody(props: {
       }
     }),
   )
-  const controller = createSearchablePanelController({
-    entries,
-    limit: SUBAGENT_LIST_ROWS,
-    onClose: props.onClose,
-    onSelect: (item) => props.onSelect(item.sessionID),
-    isCurrent: (item) => item.current,
-    closeOnFirstUp: true,
-    onRows: props.onRows,
+  const items = createMemo<SubagentEntry[]>(() => match(query(), entries()))
+  const menu = createFooterMenuState({ count: () => items().length, limit: SUBAGENT_LIST_ROWS })
+  const select = () => {
+    const item = items()[menu.selected()]
+    if (!item) {
+      return
+    }
+
+    props.onSelect(item.sessionID)
+  }
+
+  createEffect(() => {
+    query()
+    menu.reset()
+  })
+
+  createEffect(() => {
+    if (query().trim()) {
+      return
+    }
+
+    const index = items().findIndex((item) => item.current)
+    if (index !== -1) {
+      menu.reveal(index)
+    }
+  })
+
+  createEffect(() => {
+    props.onRows?.(menu.rows() + PANEL_FRAME_ROWS)
+  })
+
+  useKeyboard((event) => {
+    if (event.defaultPrevented) {
+      return
+    }
+
+    if (event.name.toLowerCase() === "up" && menu.selected() === 0) {
+      event.preventDefault()
+      props.onClose()
+      return
+    }
+
+    handleKey({ event, menu, field: () => field, setQuery, select, close: props.onClose })
   })
 
   return (
     <PanelShell
       title="Select subagent"
-      query={controller.query()}
-      count={controller.items().length}
+      query={query()}
+      count={items().length}
       total={entries().length}
       placeholder="Search"
       theme={props.theme}
-      inputRef={controller.inputRef}
-      onQuery={controller.setQuery}
+      inputRef={(input) => {
+        field = input
+      }}
+      onQuery={setQuery}
       dark
       chrome="minimal"
     >
       <RunFooterMenu
         theme={props.theme}
-        items={controller.items}
-        selected={controller.menu.selected}
-        offset={controller.menu.offset}
-        rows={controller.menu.rows}
+        items={items}
+        selected={menu.selected}
+        offset={menu.offset}
+        rows={menu.rows}
         limit={SUBAGENT_LIST_ROWS}
         empty="No subagents found"
         border={false}
@@ -677,6 +683,8 @@ export function RunQueuedPromptSelectBody(props: {
   onDelete: (prompt: FooterQueuedPrompt) => void | Promise<void>
   onRows?: (rows: number) => void
 }) {
+  let field: InputRenderable | undefined
+  const [query, setQuery] = createSignal("")
   const entries = createMemo<QueuedEntry[]>(() =>
     props.prompts().map((prompt) => ({
       category: "",
@@ -686,49 +694,72 @@ export function RunQueuedPromptSelectBody(props: {
       prompt,
     })),
   )
-  const controller = createSearchablePanelController({
-    entries,
-    limit: SUBAGENT_LIST_ROWS,
-    onClose: props.onClose,
-    onSelect: (item) => props.onEdit(item.prompt),
-    onRows: props.onRows,
-    onKey: (event, item) => {
-      const ctrl = event.ctrl && !event.meta && !event.shift && !event.super
-      if (item && (event.name === "delete" || (ctrl && event.name === "d"))) {
-        event.preventDefault()
-        props.onDelete(item.prompt)
-        return true
-      }
+  const items = createMemo<QueuedEntry[]>(() => match(query(), entries()))
+  const menu = createFooterMenuState({ count: () => items().length, limit: SUBAGENT_LIST_ROWS })
+  const selected = () => items()[menu.selected()]
 
-      if (item && ctrl && event.name === "e") {
-        event.preventDefault()
-        props.onEdit(item.prompt)
-        return true
-      }
+  createEffect(() => {
+    query()
+    menu.reset()
+  })
 
-      return false
-    },
+  createEffect(() => {
+    props.onRows?.(menu.rows() + PANEL_FRAME_ROWS)
+  })
+
+  useKeyboard((event) => {
+    if (event.defaultPrevented) {
+      return
+    }
+
+    const item = selected()
+    const ctrl = event.ctrl && !event.meta && !event.shift && !event.super
+    if (item && (event.name === "delete" || (ctrl && event.name === "d"))) {
+      event.preventDefault()
+      props.onDelete(item.prompt)
+      return
+    }
+
+    if (item && ctrl && event.name === "e") {
+      event.preventDefault()
+      props.onEdit(item.prompt)
+      return
+    }
+
+    handleKey({
+      event,
+      menu,
+      field: () => field,
+      setQuery,
+      select: () => {
+        const item = selected()
+        if (item) props.onEdit(item.prompt)
+      },
+      close: props.onClose,
+    })
   })
 
   return (
     <PanelShell
       title="Queued prompts"
-      query={controller.query()}
-      count={controller.items().length}
+      query={query()}
+      count={items().length}
       total={entries().length}
       placeholder="Search"
       theme={props.theme}
-      inputRef={controller.inputRef}
-      onQuery={controller.setQuery}
+      inputRef={(input) => {
+        field = input
+      }}
+      onQuery={setQuery}
       dark
       chrome="minimal"
     >
       <RunFooterMenu
         theme={props.theme}
-        items={controller.items}
-        selected={controller.menu.selected}
-        offset={controller.menu.offset}
-        rows={controller.menu.rows}
+        items={items}
+        selected={menu.selected}
+        offset={menu.offset}
+        rows={menu.rows}
         limit={SUBAGENT_LIST_ROWS}
         empty="No queued prompts"
         border={false}
@@ -747,6 +778,8 @@ export function RunSkillSelectBody(props: {
   onClose: () => void
   onSelect: (name: string) => void
 }) {
+  let field: InputRenderable | undefined
+  const [query, setQuery] = createSignal("")
   const entries = createMemo<SkillEntry[]>(() =>
     (props.commands() ?? [])
       .filter((item) => item.source === "skill")
@@ -759,31 +792,50 @@ export function RunSkillSelectBody(props: {
       }))
       .sort((a, b) => a.display.localeCompare(b.display)),
   )
-  const controller = createSearchablePanelController({
-    entries,
-    limit: PANEL_LIST_ROWS,
-    onClose: props.onClose,
-    onSelect: (item) => props.onSelect(item.name),
+  const items = createMemo<SkillEntry[]>(() => match(query(), entries()))
+  const menu = createFooterMenuState({ count: () => items().length, limit: PANEL_LIST_ROWS })
+  const select = () => {
+    const item = items()[menu.selected()]
+    if (!item) {
+      return
+    }
+
+    props.onSelect(item.name)
+  }
+
+  createEffect(() => {
+    query()
+    menu.reset()
+  })
+
+  useKeyboard((event) => {
+    if (event.defaultPrevented) {
+      return
+    }
+
+    handleKey({ event, menu, field: () => field, setQuery, select, close: props.onClose })
   })
 
   return (
     <PanelShell
       title="Skills"
-      query={controller.query()}
-      count={controller.items().length}
+      query={query()}
+      count={items().length}
       total={entries().length}
       placeholder="Search"
       theme={props.theme}
-      inputRef={controller.inputRef}
-      onQuery={controller.setQuery}
+      inputRef={(input) => {
+        field = input
+      }}
+      onQuery={setQuery}
       dark
       chrome="minimal"
     >
       <RunFooterMenu
         theme={props.theme}
-        items={controller.items}
-        selected={controller.menu.selected}
-        offset={controller.menu.offset}
+        items={items}
+        selected={menu.selected}
+        offset={menu.offset}
         rows={() => PANEL_LIST_ROWS}
         limit={PANEL_LIST_ROWS}
         empty={props.commands() ? "No skills found" : "Skills loading"}
@@ -804,6 +856,8 @@ export function RunVariantSelectBody(props: {
   onClose: () => void
   onSelect: (variant: string | undefined) => void
 }) {
+  let field: InputRenderable | undefined
+  const [query, setQuery] = createSignal("")
   const entries = createMemo<VariantEntry[]>(() => [
     {
       category: "",
@@ -822,32 +876,64 @@ export function RunVariantSelectBody(props: {
       current: props.current() === variant,
     })),
   ])
-  const controller = createSearchablePanelController({
-    entries,
-    limit: PANEL_LIST_ROWS,
-    onClose: props.onClose,
-    onSelect: (item) => props.onSelect(item.variant),
-    isCurrent: (item) => item.current,
+  const items = createMemo<VariantEntry[]>(() => match(query(), entries()))
+  const menu = createFooterMenuState({ count: () => items().length, limit: PANEL_LIST_ROWS })
+  const pick = (item: VariantEntry) => {
+    props.onSelect(item.variant)
+  }
+  const select = () => {
+    const item = items()[menu.selected()]
+    if (!item) {
+      return
+    }
+
+    pick(item)
+  }
+
+  createEffect(() => {
+    query()
+    menu.reset()
+  })
+
+  createEffect(() => {
+    if (query().trim()) {
+      return
+    }
+
+    const index = items().findIndex((item) => item.current)
+    if (index !== -1) {
+      menu.reveal(index)
+    }
+  })
+
+  useKeyboard((event) => {
+    if (event.defaultPrevented) {
+      return
+    }
+
+    handleKey({ event, menu, field: () => field, setQuery, select, close: props.onClose })
   })
 
   return (
     <PanelShell
       title="Select variant"
-      query={controller.query()}
-      count={controller.items().length}
+      query={query()}
+      count={items().length}
       total={entries().length}
       placeholder="Search"
       theme={props.theme}
-      inputRef={controller.inputRef}
-      onQuery={controller.setQuery}
+      inputRef={(input) => {
+        field = input
+      }}
+      onQuery={setQuery}
       dark
       chrome="minimal"
     >
       <RunFooterMenu
         theme={props.theme}
-        items={controller.items}
-        selected={controller.menu.selected}
-        offset={controller.menu.offset}
+        items={items}
+        selected={menu.selected}
+        offset={menu.offset}
         rows={() => PANEL_LIST_ROWS}
         limit={PANEL_LIST_ROWS}
         empty="No results found"
@@ -868,6 +954,8 @@ export function RunModelSelectBody(props: {
   onClose: () => void
   onSelect: (model: NonNullable<RunInput["model"]>) => void
 }) {
+  let field: InputRenderable | undefined
+  const [query, setQuery] = createSignal("")
   const entries = createMemo<ModelEntry[]>(() =>
     (props.providers() ?? [])
       .flatMap((provider) =>
@@ -909,39 +997,71 @@ export function RunModelSelectBody(props: {
         return a.display.localeCompare(b.display)
       }),
   )
-  const controller = createSearchablePanelController({
-    entries,
-    limit: PANEL_LIST_ROWS,
-    onClose: props.onClose,
-    onSelect: (item) => props.onSelect({ providerID: item.providerID, modelID: item.modelID }),
-    isCurrent: (item) => item.current,
+  const items = createMemo<ModelEntry[]>(() => match(query(), entries()))
+  const menu = createFooterMenuState({ count: () => items().length, limit: PANEL_LIST_ROWS })
+  const pick = (item: ModelEntry) => {
+    props.onSelect({ providerID: item.providerID, modelID: item.modelID })
+  }
+  const select = () => {
+    const item = items()[menu.selected()]
+    if (!item) {
+      return
+    }
+
+    pick(item)
+  }
+
+  createEffect(() => {
+    query()
+    menu.reset()
+  })
+
+  createEffect(() => {
+    if (query().trim()) {
+      return
+    }
+
+    const index = items().findIndex((item) => item.current)
+    if (index !== -1) {
+      menu.reveal(index)
+    }
+  })
+
+  useKeyboard((event) => {
+    if (event.defaultPrevented) {
+      return
+    }
+
+    handleKey({ event, menu, field: () => field, setQuery, select, close: props.onClose })
   })
 
   return (
     <PanelShell
       title="Select model"
-      query={controller.query()}
-      count={controller.items().length}
+      query={query()}
+      count={items().length}
       total={entries().length}
       placeholder="Search"
       theme={props.theme}
-      inputRef={controller.inputRef}
-      onQuery={controller.setQuery}
+      inputRef={(input) => {
+        field = input
+      }}
+      onQuery={setQuery}
       dark
       chrome="minimal"
     >
       <RunFooterMenu
         theme={props.theme}
-        items={controller.items}
-        selected={controller.menu.selected}
-        offset={controller.menu.offset}
+        items={items}
+        selected={menu.selected}
+        offset={menu.offset}
         rows={() => PANEL_LIST_ROWS}
         limit={PANEL_LIST_ROWS}
         empty={props.providers() ? "No results found" : "Models loading"}
         border={false}
         paddingLeft={PANEL_PAD}
         paddingRight={PANEL_PAD}
-        grouped={!controller.query().trim()}
+        grouped={!query().trim()}
         background
         headerColor={props.theme().muted}
       />

packages/cli/src/mini/footer.menu.tsx

@@ -3,9 +3,8 @@ import { TextAttributes, type ColorInput } from "@opentui/core"
 import { useTerminalDimensions } from "@opentui/solid"
 import { createEffect, createMemo, createSignal, type Accessor } from "solid-js"
 import { transparent, type RunFooterTheme } from "./theme"
-import { Locale } from "../util/locale"
-import { stringWidth } from "../util/string-width"
-import { moveSelection, moveSelectionOffset, reconcileSelection, revealSelectionOffset } from "../ui/select-controller"
+import { Locale } from "@opencode-ai/tui/util/locale"
+import { stringWidth } from "@opencode-ai/tui/util/string-width"
 
 export const FOOTER_MENU_ROWS = 8
 
@@ -21,6 +20,41 @@ type RunFooterMenuRow =
   | { type: "item"; item: RunFooterMenuItem; index: number }
   | { type: "spacer" }
 
+function maxOffset(count: number, limit: number) {
+  return Math.max(0, count - limit)
+}
+
+function previewMargin(limit: number) {
+  return Math.max(0, Math.min(2, Math.floor((limit - 1) / 2)))
+}
+
+function revealOffset(value: number, input: { count: number; limit: number; selected: number }) {
+  const max = maxOffset(input.count, input.limit)
+  if (input.selected < value) {
+    return Math.min(max, input.selected)
+  }
+
+  if (input.selected >= value + input.limit) {
+    return Math.min(max, input.selected - input.limit + 1)
+  }
+
+  return Math.min(max, value)
+}
+
+function moveOffset(value: number, input: { count: number; limit: number; selected: number; dir: -1 | 1 }) {
+  const max = maxOffset(input.count, input.limit)
+  const margin = previewMargin(input.limit)
+  if (input.dir < 0 && input.selected < value + margin) {
+    return Math.max(0, Math.min(max, input.selected - margin))
+  }
+
+  if (input.dir > 0 && input.selected > value + input.limit - margin - 1) {
+    return Math.min(max, input.selected - input.limit + margin + 1)
+  }
+
+  return Math.min(max, value)
+}
+
 export function createFooterMenuState(input: { count: Accessor<number>; limit?: number }) {
   const [selected, setSelected] = createSignal(0)
   const [offset, setOffset] = createSignal(0)
@@ -29,9 +63,15 @@ export function createFooterMenuState(input: { count: Accessor<number>; limit?:
 
   const reveal = (index: number) => {
     const count = input.count()
-    const next = reconcileSelection(index, count)
+    if (count === 0) {
+      setSelected(0)
+      setOffset(0)
+      return
+    }
+
+    const next = Math.max(0, Math.min(count - 1, index))
     setSelected(next)
-    setOffset((value) => revealSelectionOffset(value, { count, limit: limit(), selected: next }))
+    setOffset((value) => revealOffset(value, { count, limit: limit(), selected: next }))
   }
 
   const reset = () => {
@@ -41,16 +81,28 @@ export function createFooterMenuState(input: { count: Accessor<number>; limit?:
 
   createEffect(() => {
     const count = input.count()
-    const next = reconcileSelection(selected(), count)
-    setSelected(next)
-    setOffset((value) => revealSelectionOffset(value, { count, limit: limit(), selected: next }))
+    if (count === 0) {
+      reset()
+      return
+    }
+
+    if (selected() >= count) {
+      setSelected(count - 1)
+    }
+
+    setOffset((value) => revealOffset(value, { count, limit: limit(), selected: selected() }))
   })
 
   const move = (dir: -1 | 1) => {
     const count = input.count()
-    const next = moveSelection(selected(), { count, delta: dir, policy: "clamp" })
+    if (count === 0) {
+      reset()
+      return
+    }
+
+    const next = Math.max(0, Math.min(count - 1, selected() + dir))
     setSelected(next)
-    setOffset((value) => moveSelectionOffset(value, { count, limit: limit(), selected: next, direction: dir }))
+    setOffset((value) => moveOffset(value, { count, limit: limit(), selected: next, dir }))
   }
 
   return {
@@ -117,8 +169,8 @@ export function RunFooterMenu(props: {
     const dir = props.selected() === previous + 1 ? 1 : props.selected() === previous - 1 ? -1 : undefined
     setGroupOffset((value) =>
       dir
-        ? moveSelectionOffset(value, { count: all.length, limit: limit(), selected, direction: dir })
-        : revealSelectionOffset(value, { count: all.length, limit: limit(), selected }),
+        ? moveOffset(value, { count: all.length, limit: limit(), selected, dir })
+        : revealOffset(value, { count: all.length, limit: limit(), selected }),
     )
     previous = props.selected()
   })

packages/cli/src/mini/footer.permission.tsx

@@ -14,6 +14,7 @@
 import type { TextareaRenderable } from "@opentui/core"
 import { useKeyboard, useTerminalDimensions } from "@opentui/solid"
 import { For, Match, Show, Switch, createEffect, createMemo, createSignal } from "solid-js"
+import type { PermissionV2Request } from "@opencode-ai/client/promise"
 import {
   createPermissionBodyState,
   permissionAlwaysLines,
@@ -31,7 +32,7 @@ import {
 import { footerWidthPolicy } from "./footer.width"
 import { toolFiletype } from "./tool"
 import { transparent, type RunBlockTheme, type RunFooterTheme } from "./theme"
-import type { MiniPermissionRequest, PermissionReply } from "./types"
+import type { PermissionReply, RunDiffStyle } from "./types"
 
 function buttons(
   list: PermissionOption[],
@@ -129,15 +130,15 @@ export function RejectField(props: {
 }
 
 export function RunPermissionBody(props: {
-  request: MiniPermissionRequest
-  directory?: () => string
+  request: PermissionV2Request
   theme: RunFooterTheme
   block: RunBlockTheme
+  diffStyle?: RunDiffStyle
   onReply: (input: PermissionReply) => void | Promise<void>
 }) {
   const dims = useTerminalDimensions()
-  const [state, setState] = createSignal(createPermissionBodyState(props.request))
-  const info = createMemo(() => permissionInfo(props.request, props.directory?.()))
+  const [state, setState] = createSignal(createPermissionBodyState(props.request.id))
+  const info = createMemo(() => permissionInfo(props.request))
   const ft = createMemo(() => toolFiletype(info().file))
   const narrow = createMemo(() => footerWidthPolicy(dims().width).dialog.narrow)
   const opts = createMemo(() =>
@@ -162,7 +163,7 @@ export function RunPermissionBody(props: {
       return
     }
 
-    setState(createPermissionBodyState(props.request))
+    setState(createPermissionBodyState(id))
   })
 
   const shift = (dir: -1 | 1) => {
@@ -360,42 +361,15 @@ export function RunPermissionBody(props: {
                   <Show
                     when={info().diff}
                     fallback={
-                      <Show
-                        when={info().patch}
-                        fallback={
-                          <box width="100%" flexDirection="column" gap={1} paddingLeft={1}>
-                            <For each={info().lines}>
-                              {(line) => (
-                                <text fg={props.theme.text} wrapMode="word">
-                                  {line}
-                                </text>
-                              )}
-                            </For>
-                          </box>
-                        }
-                      >
-                        {(patch) => (
-                          <Show
-                            when={props.block.syntax}
-                            fallback={
-                              <text fg={props.theme.muted} wrapMode="word">
-                                {patch()}
-                              </text>
-                            }
-                          >
-                            {(syntax) => (
-                              <code
-                                filetype="diff"
-                                drawUnstyledText={false}
-                                streaming={true}
-                                syntaxStyle={syntax()}
-                                content={patch()}
-                                fg={props.theme.muted}
-                              />
-                            )}
-                          </Show>
-                        )}
-                      </Show>
+                      <box width="100%" flexDirection="column" gap={1} paddingLeft={1}>
+                        <For each={info().lines}>
+                          {(line) => (
+                            <text fg={props.theme.text} wrapMode="word">
+                              {line}
+                            </text>
+                          )}
+                        </For>
+                      </box>
                     }
                   >
                     <diff
@@ -418,7 +392,7 @@ export function RunPermissionBody(props: {
                       removedLineNumberBg={props.block.diffRemovedLineNumberBg}
                     />
                   </Show>
-                  <Show when={!info().diff && !info().patch && info().lines.length === 0}>
+                  <Show when={!info().diff && info().lines.length === 0}>
                     <box paddingLeft={1}>
                       <text fg={props.theme.muted}>No diff provided</text>
                     </box>

packages/cli/src/mini/footer.prompt.tsx

@@ -7,13 +7,13 @@
 /** @jsxImportSource @opentui/solid */
 import { StyledText, fg, type ColorInput, type KeyEvent, type TextareaRenderable } from "@opentui/core"
 import { useRenderer } from "@opentui/solid"
-import { normalizePromptContent } from "../prompt/content"
+import { normalizePromptContent } from "@opencode-ai/tui/prompt/content"
 import fuzzysort from "fuzzysort"
 import path from "path"
 import { pathToFileURL } from "node:url"
 import { createEffect, createMemo, createResource, createSignal, onCleanup, onMount, type Accessor } from "solid-js"
-import { Locale } from "../util/locale"
-import { stringWidth } from "../util/string-width"
+import { Locale } from "@opencode-ai/tui/util/locale"
+import { stringWidth } from "@opencode-ai/tui/util/string-width"
 import {
   createPromptHistory,
   displayCharAt,
@@ -22,11 +22,9 @@ import {
   mentionTriggerIndex,
   isNewCommand,
   movePromptHistory,
-  promptCopy,
   pushPromptHistory,
 } from "./prompt.shared"
-import { parseFileLineRange, parseSlashHead, stripFileLineRange } from "../prompt/parse"
-import { Keymap } from "../context/keymap"
+import { Keymap } from "@opencode-ai/tui/context/keymap"
 import { realignEditorPromptParts, resolveEditorSlashValue } from "./prompt.editor"
 import { FOOTER_MENU_ROWS, createFooterMenuState, type RunFooterMenuItem } from "./footer.menu"
 import type { RunFooterTheme } from "./theme"
@@ -59,7 +57,7 @@ type PromptOption = Auto | SlashOption
 type MenuMode = false | "mention" | "slash"
 
 type PromptInput = {
-  directory: Accessor<string>
+  directory: string
   findFiles: (query: string) => Promise<string[]>
   agents: Accessor<RunAgent[]>
   references: Accessor<RunReference[]>
@@ -97,6 +95,7 @@ export type PromptState = {
   openEditor: (input?: { value?: string }) => Promise<void>
   onKeyDown: (event: KeyEvent) => void
   onContentChange: () => void
+  replaceDraft: (text: string) => void
   replacePrompt: (prompt: RunPrompt) => void
   bind: (area?: TextareaRenderable) => void
 }
@@ -105,12 +104,61 @@ function clamp(rows: number): number {
   return Math.max(TEXTAREA_MIN_ROWS, Math.min(TEXTAREA_MAX_ROWS, rows))
 }
 
+function clonePrompt(prompt: RunPrompt): RunPrompt {
+  return {
+    text: prompt.text,
+    parts: structuredClone(prompt.parts),
+    ...(prompt.mode ? { mode: prompt.mode } : {}),
+    ...(prompt.command ? { command: prompt.command } : {}),
+  }
+}
+
 function emptyPrompt(shell: boolean): RunPrompt {
   return shell ? { text: "", parts: [], mode: "shell" } : { text: "", parts: [] }
 }
 
+function removeLineRange(input: string) {
+  const hash = input.lastIndexOf("#")
+  return hash === -1 ? input : input.slice(0, hash)
+}
+
+function extractLineRange(input: string) {
+  const hash = input.lastIndexOf("#")
+  if (hash === -1) {
+    return { base: input }
+  }
+
+  const base = input.slice(0, hash)
+  const line = input.slice(hash + 1)
+  const match = line.match(/^(\d+)(?:-(\d*))?$/)
+  if (!match) {
+    return { base }
+  }
+
+  const start = Number(match[1])
+  const end = match[2] && start < Number(match[2]) ? Number(match[2]) : undefined
+  return { base, line: { start, end } }
+}
+
+function slashHead(text: string) {
+  if (!text.startsWith("/")) {
+    return
+  }
+
+  for (let i = 1; i < text.length; i++) {
+    switch (text[i]) {
+      case " ":
+      case "\t":
+      case "\n":
+        return { name: text.slice(1, i), arguments: text.slice(i + 1), end: i }
+    }
+  }
+
+  return { name: text.slice(1), arguments: "", end: text.length }
+}
+
 function slashQuery(text: string, cursor: number) {
-  const head = parseSlashHead(text.slice(0, cursor))
+  const head = slashHead(text.slice(0, cursor))
   if (!head || head.end !== cursor) {
     return
   }
@@ -119,7 +167,7 @@ function slashQuery(text: string, cursor: number) {
 }
 
 function parseSlashCommand(text: string, commands: RunCommand[] | undefined) {
-  const head = parseSlashHead(text)
+  const head = slashHead(text)
   if (!head || head.name.length === 0) {
     return { type: "none" as const }
   }
@@ -144,7 +192,7 @@ export function selectedCommand(text: string, command: RunPrompt["command"], com
     return
   }
 
-  const head = parseSlashHead(text)
+  const head = slashHead(text)
   if (!head || head.name !== command.name) {
     return
   }
@@ -328,16 +376,16 @@ export function createPromptState(input: PromptInput): PromptState {
         return []
       }
 
-      const next = parseFileLineRange(value)
+      const next = extractLineRange(value)
       const list = await input.findFiles(next.base)
       return list.map((item): Auto => {
-        const url = pathToFileURL(path.resolve(input.directory(), item))
+        const url = pathToFileURL(path.resolve(input.directory, item))
         let filename = item
-        if (next.lineRange && !item.endsWith("/")) {
-          filename = `${item}#${next.lineRange.startLine}${next.lineRange.endLine ? `-${next.lineRange.endLine}` : ""}`
-          url.searchParams.set("start", String(next.lineRange.startLine))
-          if (next.lineRange.endLine !== undefined) {
-            url.searchParams.set("end", String(next.lineRange.endLine))
+        if (next.line && !item.endsWith("/")) {
+          filename = `${item}#${next.line.start}${next.line.end ? `-${next.line.end}` : ""}`
+          url.searchParams.set("start", String(next.line.start))
+          if (next.line.end !== undefined) {
+            url.searchParams.set("end", String(next.line.end))
           }
         }
 
@@ -421,7 +469,7 @@ export function createPromptState(input: PromptInput): PromptState {
       return mixed
     }
 
-    const next = stripFileLineRange(query())
+    const next = removeLineRange(query())
     if (mode() === "mention") {
       return [
         ...fuzzysort.go(next, agents(), { keys: ["value", "display", "description"] }).map((item) => item.obj),
@@ -556,7 +604,7 @@ export function createPromptState(input: PromptInput): PromptState {
   }
 
   const restore = (value: RunPrompt, cursor = stringWidth(value.text)) => {
-    draft = promptCopy(value)
+    draft = clonePrompt(value)
     setShell(value.mode === "shell")
     if (!area || area.isDestroyed) {
       return
@@ -586,6 +634,21 @@ export function createPromptState(input: PromptInput): PromptState {
     area.focus()
   }
 
+  const replaceDraft = (text: string) => {
+    draft = shell() ? { text, parts: [], mode: "shell" } : { text, parts: [] }
+    if (!area || area.isDestroyed) {
+      return
+    }
+
+    hide()
+    area.setText(text)
+    clearParts()
+    draft = shell() ? { text: area.plainText, parts: [], mode: "shell" } : { text: area.plainText, parts: [] }
+    area.cursorOffset = Math.min(stringWidth(text), stringWidth(area.plainText))
+    scheduleRows()
+    area.focus()
+  }
+
   const refresh = () => {
     if (!area || area.isDestroyed) {
       return
@@ -695,7 +758,7 @@ export function createPromptState(input: PromptInput): PromptState {
     }
 
     if (history.index === null && dir === -1) {
-      stash = promptCopy(draft)
+      stash = clonePrompt(draft)
     }
 
     const next = movePromptHistory(history, dir, area.plainText, area.cursorOffset)
@@ -773,7 +836,7 @@ export function createPromptState(input: PromptInput): PromptState {
     syncDraft()
     hide()
 
-    const current = promptCopy(draft)
+    const current = clonePrompt(draft)
     try {
       const content = await input.onEditorOpen({
         value: inputValue?.value ?? current.text,
@@ -816,7 +879,7 @@ export function createPromptState(input: PromptInput): PromptState {
       }
 
       const cursor = area.cursorOffset
-      const head = parseSlashHead(area.plainText)
+      const head = slashHead(area.plainText)
       const local = !shell() && (next.name === "new" || next.name === "exit")
       const separator = !shell() && !local && head && /\s/.test(area.plainText[head.end] ?? "") ? "" : " "
       const text = `/${next.name}${separator}`
@@ -833,7 +896,7 @@ export function createPromptState(input: PromptInput): PromptState {
       hide()
       syncDraft()
       if (!shell()) {
-        submitPrompt(promptCopy(draft))
+        submitPrompt(clonePrompt(draft))
         return
       }
 
@@ -1096,7 +1159,7 @@ export function createPromptState(input: PromptInput): PromptState {
 
   const submitPrompt = (next: RunPrompt) => {
     if (!area || area.isDestroyed) {
-      draft = promptCopy(next)
+      draft = clonePrompt(next)
     }
 
     if (visible()) {
@@ -1152,7 +1215,7 @@ export function createPromptState(input: PromptInput): PromptState {
 
   const onSubmit = () => {
     syncDraft()
-    submitPrompt(promptCopy(draft))
+    submitPrompt(clonePrompt(draft))
   }
 
   const submitText = (text: string) => {
@@ -1233,6 +1296,7 @@ export function createPromptState(input: PromptInput): PromptState {
       refresh()
       scheduleRows()
     },
+    replaceDraft,
     replacePrompt: restore,
     bind,
   }

packages/cli/src/mini/footer.question.tsx

@@ -0,0 +1,573 @@
+// Question UI body for the direct-mode footer.
+//
+// Renders inside the footer when the reducer pushes a FooterView of type
+// "question". Supports single-question and multi-question flows:
+//
+//   Single question: options list with up/down selection, digit shortcuts,
+//   and optional custom text input.
+//
+//   Multi-question: tabbed interface where each question is a tab, plus a
+//   final "Confirm" tab that shows all answers for review. Tab/shift-tab
+//   or left/right to navigate between questions.
+//
+// All state logic lives in question.shared.ts as a pure state machine.
+// This component just renders it and dispatches keyboard events.
+/** @jsxImportSource @opentui/solid */
+import type { TextareaRenderable } from "@opentui/core"
+import { useKeyboard, useTerminalDimensions } from "@opentui/solid"
+import { For, Show, createEffect, createMemo, createSignal } from "solid-js"
+import type { QuestionV2Request } from "@opencode-ai/client/promise"
+import {
+  createQuestionBodyState,
+  questionConfirm,
+  questionCustom,
+  questionInfo,
+  questionInput,
+  questionMove,
+  questionOther,
+  questionPicked,
+  questionReject,
+  questionSave,
+  questionSelect,
+  questionSetEditing,
+  questionSetSelected,
+  questionSetSubmitting,
+  questionSetTab,
+  questionSingle,
+  questionStoreCustom,
+  questionSubmit,
+  questionSync,
+  questionTabs,
+  questionTotal,
+} from "./question.shared"
+import { footerWidthPolicy } from "./footer.width"
+import type { RunFooterTheme } from "./theme"
+import type { QuestionReject, QuestionReply } from "./types"
+
+export function RunQuestionBody(props: {
+  request: QuestionV2Request
+  theme: RunFooterTheme
+  onReply: (input: QuestionReply) => void | Promise<void>
+  onReject: (input: QuestionReject) => void | Promise<void>
+}) {
+  const dims = useTerminalDimensions()
+  const [state, setState] = createSignal(createQuestionBodyState(props.request.id))
+  const single = createMemo(() => questionSingle(props.request))
+  const confirm = createMemo(() => questionConfirm(props.request, state()))
+  const info = createMemo(() => questionInfo(props.request, state()))
+  const input = createMemo(() => questionInput(state()))
+  const other = createMemo(() => questionOther(props.request, state()))
+  const picked = createMemo(() => questionPicked(state()))
+  const disabled = createMemo(() => state().submitting)
+  const narrow = createMemo(() => footerWidthPolicy(dims().width).dialog.narrow)
+  const verb = createMemo(() => {
+    if (confirm()) {
+      return "submit"
+    }
+
+    if (info()?.multiple) {
+      return "toggle"
+    }
+
+    if (single()) {
+      return "submit"
+    }
+
+    return "confirm"
+  })
+  let area: TextareaRenderable | undefined
+
+  createEffect(() => {
+    setState((prev) => questionSync(prev, props.request.id))
+  })
+
+  const setTab = (tab: number) => {
+    setState((prev) => questionSetTab(prev, tab))
+  }
+
+  const move = (dir: -1 | 1) => {
+    setState((prev) => questionMove(prev, props.request, dir))
+  }
+
+  const beginReply = async (input: QuestionReply) => {
+    setState((prev) => questionSetSubmitting(prev, true))
+
+    try {
+      await props.onReply(input)
+    } catch {
+      setState((prev) => questionSetSubmitting(prev, false))
+    }
+  }
+
+  const beginReject = async (input: QuestionReject) => {
+    setState((prev) => questionSetSubmitting(prev, true))
+
+    try {
+      await props.onReject(input)
+    } catch {
+      setState((prev) => questionSetSubmitting(prev, false))
+    }
+  }
+
+  const saveCustom = () => {
+    const cur = state()
+    const next = questionSave(cur, props.request)
+    if (next.state !== cur) {
+      setState(next.state)
+    }
+
+    if (!next.reply) {
+      return
+    }
+
+    void beginReply(next.reply)
+  }
+
+  const choose = (selected: number) => {
+    const base = state()
+    const cur = questionSetSelected(base, selected)
+    const next = questionSelect(cur, props.request)
+    if (next.state !== base) {
+      setState(next.state)
+    }
+
+    if (!next.reply) {
+      return
+    }
+
+    void beginReply(next.reply)
+  }
+
+  const mark = (selected: number) => {
+    setState((prev) => questionSetSelected(prev, selected))
+  }
+
+  const select = () => {
+    const cur = state()
+    const next = questionSelect(cur, props.request)
+    if (next.state !== cur) {
+      setState(next.state)
+    }
+
+    if (!next.reply) {
+      return
+    }
+
+    void beginReply(next.reply)
+  }
+
+  const submit = () => {
+    void beginReply(questionSubmit(props.request, state()))
+  }
+
+  const reject = () => {
+    void beginReject(questionReject(props.request))
+  }
+
+  useKeyboard((event) => {
+    const cur = state()
+    if (cur.submitting) {
+      event.preventDefault()
+      return
+    }
+
+    if (cur.editing) {
+      if (event.name === "escape") {
+        setState((prev) => questionSetEditing(prev, false))
+        event.preventDefault()
+        return
+      }
+
+      return
+    }
+
+    if (!single() && (event.name === "left" || event.name === "h")) {
+      setTab((cur.tab - 1 + questionTabs(props.request)) % questionTabs(props.request))
+      event.preventDefault()
+      return
+    }
+
+    if (!single() && (event.name === "right" || event.name === "l")) {
+      setTab((cur.tab + 1) % questionTabs(props.request))
+      event.preventDefault()
+      return
+    }
+
+    if (!single() && event.name === "tab") {
+      const dir = event.shift ? -1 : 1
+      setTab((cur.tab + dir + questionTabs(props.request)) % questionTabs(props.request))
+      event.preventDefault()
+      return
+    }
+
+    if (questionConfirm(props.request, cur)) {
+      if (event.name === "return") {
+        submit()
+        event.preventDefault()
+        return
+      }
+
+      if (event.name === "escape") {
+        reject()
+        event.preventDefault()
+      }
+      return
+    }
+
+    const total = questionTotal(props.request, cur)
+    const max = Math.min(total, 9)
+    const digit = Number(event.name)
+    if (!Number.isNaN(digit) && digit >= 1 && digit <= max) {
+      choose(digit - 1)
+      event.preventDefault()
+      return
+    }
+
+    if (event.name === "up" || event.name === "k") {
+      move(-1)
+      event.preventDefault()
+      return
+    }
+
+    if (event.name === "down" || event.name === "j") {
+      move(1)
+      event.preventDefault()
+      return
+    }
+
+    if (event.name === "return") {
+      select()
+      event.preventDefault()
+      return
+    }
+
+    if (event.name === "escape") {
+      reject()
+      event.preventDefault()
+    }
+  })
+
+  createEffect(() => {
+    if (!state().editing || !area || area.isDestroyed) {
+      return
+    }
+
+    if (area.plainText !== input()) {
+      area.setText(input())
+      area.cursorOffset = input().length
+    }
+
+    queueMicrotask(() => {
+      if (!area || area.isDestroyed || !state().editing) {
+        return
+      }
+
+      area.focus()
+      area.cursorOffset = area.plainText.length
+    })
+  })
+
+  return (
+    <box width="100%" height="100%" flexDirection="column">
+      <box
+        flexDirection="column"
+        gap={1}
+        paddingLeft={1}
+        paddingRight={3}
+        paddingTop={1}
+        flexGrow={1}
+        flexShrink={1}
+        backgroundColor={props.theme.surface}
+      >
+        <Show when={!single()}>
+          <box flexDirection="row" gap={1} paddingLeft={1} flexShrink={0}>
+            <For each={props.request.questions}>
+              {(item, index) => {
+                const active = () => state().tab === index()
+                const answered = () => (state().answers[index()]?.length ?? 0) > 0
+                return (
+                  <box
+                    paddingLeft={1}
+                    paddingRight={1}
+                    backgroundColor={active() ? props.theme.highlight : props.theme.surface}
+                    onMouseUp={() => {
+                      if (!disabled()) setTab(index())
+                    }}
+                  >
+                    <text fg={active() ? props.theme.surface : answered() ? props.theme.text : props.theme.muted}>
+                      {item.header}
+                    </text>
+                  </box>
+                )
+              }}
+            </For>
+            <box
+              paddingLeft={1}
+              paddingRight={1}
+              backgroundColor={confirm() ? props.theme.highlight : props.theme.surface}
+              onMouseUp={() => {
+                if (!disabled()) setTab(props.request.questions.length)
+              }}
+            >
+              <text fg={confirm() ? props.theme.surface : props.theme.muted}>Confirm</text>
+            </box>
+          </box>
+        </Show>
+
+        <Show
+          when={!confirm()}
+          fallback={
+            <box width="100%" flexGrow={1} flexShrink={1} paddingLeft={1}>
+              <scrollbox
+                width="100%"
+                height="100%"
+                verticalScrollbarOptions={{
+                  trackOptions: {
+                    backgroundColor: props.theme.surface,
+                    foregroundColor: props.theme.line,
+                  },
+                }}
+              >
+                <box width="100%" flexDirection="column" gap={1}>
+                  <box paddingLeft={1}>
+                    <text fg={props.theme.text}>Review</text>
+                  </box>
+                  <For each={props.request.questions}>
+                    {(item, index) => {
+                      const value = () => state().answers[index()]?.join(", ") ?? ""
+                      const answered = () => Boolean(value())
+                      return (
+                        <box paddingLeft={1}>
+                          <text wrapMode="word">
+                            <span style={{ fg: props.theme.muted }}>{item.header}:</span>{" "}
+                            <span style={{ fg: answered() ? props.theme.text : props.theme.error }}>
+                              {answered() ? value() : "(not answered)"}
+                            </span>
+                          </text>
+                        </box>
+                      )
+                    }}
+                  </For>
+                </box>
+              </scrollbox>
+            </box>
+          }
+        >
+          <box width="100%" flexGrow={1} flexShrink={1} paddingLeft={1} gap={1}>
+            <box>
+              <text fg={props.theme.text} wrapMode="word">
+                {info()?.question}
+                {info()?.multiple ? " (select all that apply)" : ""}
+              </text>
+            </box>
+
+            <box flexGrow={1} flexShrink={1}>
+              <scrollbox
+                width="100%"
+                height="100%"
+                verticalScrollbarOptions={{
+                  trackOptions: {
+                    backgroundColor: props.theme.surface,
+                    foregroundColor: props.theme.line,
+                  },
+                }}
+              >
+                <box width="100%" flexDirection="column">
+                  <For each={info()?.options ?? []}>
+                    {(item, index) => {
+                      const active = () => state().selected === index()
+                      const hit = () => state().answers[state().tab]?.includes(item.label) ?? false
+                      return (
+                        <box
+                          flexDirection="column"
+                          gap={0}
+                          onMouseOver={() => {
+                            if (!disabled()) {
+                              mark(index())
+                            }
+                          }}
+                          onMouseDown={() => {
+                            if (!disabled()) {
+                              mark(index())
+                            }
+                          }}
+                          onMouseUp={() => {
+                            if (!disabled()) {
+                              choose(index())
+                            }
+                          }}
+                        >
+                          <box flexDirection="row">
+                            <box backgroundColor={active() ? props.theme.line : undefined} paddingRight={1}>
+                              <text fg={active() ? props.theme.highlight : props.theme.muted}>{`${index() + 1}.`}</text>
+                            </box>
+                            <box backgroundColor={active() ? props.theme.line : undefined}>
+                              <text
+                                fg={active() ? props.theme.highlight : hit() ? props.theme.success : props.theme.text}
+                              >
+                                {info()?.multiple ? `[${hit() ? "✓" : " "}] ${item.label}` : item.label}
+                              </text>
+                            </box>
+                            <Show when={!info()?.multiple}>
+                              <text fg={props.theme.success}>{hit() ? " ✓" : ""}</text>
+                            </Show>
+                          </box>
+                          <box paddingLeft={3}>
+                            <text fg={props.theme.muted} wrapMode="word">
+                              {item.description}
+                            </text>
+                          </box>
+                        </box>
+                      )
+                    }}
+                  </For>
+
+                  <Show when={questionCustom(props.request, state())}>
+                    <box
+                      flexDirection="column"
+                      gap={0}
+                      onMouseOver={() => {
+                        if (!disabled()) {
+                          mark(info()?.options.length ?? 0)
+                        }
+                      }}
+                      onMouseDown={() => {
+                        if (!disabled()) {
+                          mark(info()?.options.length ?? 0)
+                        }
+                      }}
+                      onMouseUp={() => {
+                        if (!disabled()) {
+                          choose(info()?.options.length ?? 0)
+                        }
+                      }}
+                    >
+                      <box flexDirection="row">
+                        <box backgroundColor={other() ? props.theme.line : undefined} paddingRight={1}>
+                          <text
+                            fg={other() ? props.theme.highlight : props.theme.muted}
+                          >{`${(info()?.options.length ?? 0) + 1}.`}</text>
+                        </box>
+                        <box backgroundColor={other() ? props.theme.line : undefined}>
+                          <text
+                            fg={other() ? props.theme.highlight : picked() ? props.theme.success : props.theme.text}
+                          >
+                            {info()?.multiple
+                              ? `[${picked() ? "✓" : " "}] Type your own answer`
+                              : "Type your own answer"}
+                          </text>
+                        </box>
+                        <Show when={!info()?.multiple}>
+                          <text fg={props.theme.success}>{picked() ? " ✓" : ""}</text>
+                        </Show>
+                      </box>
+                      <Show
+                        when={state().editing}
+                        fallback={
+                          <Show when={input()}>
+                            <box paddingLeft={3}>
+                              <text fg={props.theme.muted} wrapMode="word">
+                                {input()}
+                              </text>
+                            </box>
+                          </Show>
+                        }
+                      >
+                        <box paddingLeft={3}>
+                          <textarea
+                            width="100%"
+                            minHeight={1}
+                            maxHeight={4}
+                            wrapMode="word"
+                            placeholder="Type your own answer"
+                            placeholderColor={props.theme.muted}
+                            textColor={props.theme.text}
+                            focusedTextColor={props.theme.text}
+                            backgroundColor={props.theme.surface}
+                            focusedBackgroundColor={props.theme.surface}
+                            cursorColor={props.theme.text}
+                            focused={!disabled()}
+                            onSubmit={saveCustom}
+                            onContentChange={() => {
+                              if (!area || area.isDestroyed || disabled()) {
+                                return
+                              }
+
+                              const text = area.plainText
+                              setState((prev) => questionStoreCustom(prev, prev.tab, text))
+                            }}
+                            ref={(item) => {
+                              area = item
+                            }}
+                          />
+                        </box>
+                      </Show>
+                    </box>
+                  </Show>
+                </box>
+              </scrollbox>
+            </box>
+          </box>
+        </Show>
+      </box>
+
+      <box
+        flexDirection={narrow() ? "column" : "row"}
+        flexShrink={0}
+        gap={1}
+        paddingLeft={2}
+        paddingRight={3}
+        paddingBottom={1}
+        justifyContent={narrow() ? "flex-start" : "space-between"}
+        alignItems={narrow() ? "flex-start" : "center"}
+      >
+        <Show
+          when={!disabled()}
+          fallback={
+            <text fg={props.theme.muted} wrapMode="word">
+              Waiting for question event...
+            </text>
+          }
+        >
+          <box
+            flexDirection={narrow() ? "column" : "row"}
+            gap={narrow() ? 1 : 2}
+            flexShrink={0}
+            width={narrow() ? "100%" : undefined}
+          >
+            <Show
+              when={!state().editing}
+              fallback={
+                <>
+                  <text fg={props.theme.text}>
+                    enter <span style={{ fg: props.theme.muted }}>save</span>
+                  </text>
+                  <text fg={props.theme.text}>
+                    esc <span style={{ fg: props.theme.muted }}>cancel</span>
+                  </text>
+                </>
+              }
+            >
+              <Show when={!single()}>
+                <text fg={props.theme.text}>
+                  {"⇆"} <span style={{ fg: props.theme.muted }}>tab</span>
+                </text>
+              </Show>
+              <Show when={!confirm()}>
+                <text fg={props.theme.text}>
+                  {"↑↓"} <span style={{ fg: props.theme.muted }}>select</span>
+                </text>
+              </Show>
+              <text fg={props.theme.text}>
+                enter <span style={{ fg: props.theme.muted }}>{verb()}</span>
+              </text>
+              <text fg={props.theme.text}>
+                esc <span style={{ fg: props.theme.muted }}>dismiss</span>
+              </text>
+            </Show>
+          </box>
+        </Show>
+      </box>
+    </box>
+  )
+}

packages/cli/src/mini/footer.subagent.tsx

@@ -1,11 +1,11 @@
 /** @jsxImportSource @opentui/solid */
 import type { ScrollBoxRenderable } from "@opentui/core"
 import { useKeyboard } from "@opentui/solid"
-import { registerOpencodeSpinner } from "../component/register-spinner"
+import { registerOpencodeSpinner } from "@opencode-ai/tui/component/register-spinner"
 import { Show, createMemo, indexArray } from "solid-js"
-import { SPINNER_FRAMES } from "../component/spinner-frames"
+import { SPINNER_FRAMES } from "@opencode-ai/tui/component/spinner"
 import { RunEntryContent, separatorRows } from "./scrollback.writer"
-import type { FooterSubagentDetail, FooterSubagentTab } from "./types"
+import type { FooterSubagentDetail, FooterSubagentTab, RunDiffStyle } from "./types"
 import type { RunFooterTheme, RunTheme } from "./theme"
 
 registerOpencodeSpinner()
@@ -51,6 +51,8 @@ export function RunFooterSubagentBody(props: {
   index: () => number
   total: () => number
   detail: () => FooterSubagentDetail | undefined
+  width: () => number
+  diffStyle?: RunDiffStyle
   onCycle: (dir: -1 | 1) => void
   onClose: () => void
   // Formatted interrupt shortcut from the registered keymap binding; the
@@ -61,6 +63,7 @@ export function RunFooterSubagentBody(props: {
   const footer = createMemo(() => theme().footer)
   const tab = createMemo(() => props.tab())
   const commits = createMemo(() => props.detail()?.commits ?? [])
+  const opts = createMemo(() => ({ diffStyle: props.diffStyle }))
   const scrollbar = createMemo(() => ({
     trackOptions: {
       backgroundColor: footer().surface,
@@ -86,7 +89,7 @@ export function RunFooterSubagentBody(props: {
   const rows = indexArray(commits, (commit, index) => (
     <box flexDirection="column" gap={0} flexShrink={0}>
       {index > 0 && separatorRows(commits()[index - 1], commit()) > 0 ? <box height={1} flexShrink={0} /> : null}
-      <RunEntryContent commit={commit()} theme={theme()} />
+      <RunEntryContent commit={commit()} theme={theme()} opts={opts()} width={props.width()} />
     </box>
   ))
   let scroll: ScrollBoxRenderable | undefined

packages/cli/src/mini/footer.ts

@@ -10,7 +10,7 @@
 //   rebuilding the session model.
 //
 //   Footer: event() updates the SolidJS signal-backed FooterState, which
-//   drives the reactive footer view (prompt, status, permission, form).
+//   drives the reactive footer view (prompt, status, permission, question).
 //   present() swaps the active footer view and resizes the footer region.
 //
 // Lifecycle:
@@ -24,12 +24,11 @@
 // Ctrl-c clears a live prompt draft first; otherwise interrupt and exit use a
 // two-press pattern where the first press shows a hint and the second press
 // within 5 seconds actually fires the action.
-import { CliRenderEvents, type CliRenderer } from "@opentui/core"
+import { CliRenderEvents, type CliRenderer, type TreeSitterClient } from "@opentui/core"
 import { render } from "@opentui/solid"
 import { createComponent, createSignal, type Accessor, type Setter } from "solid-js"
 import { createStore, reconcile } from "solid-js/store"
-import { Keymap } from "../context/keymap"
-import { Locale } from "../util/locale"
+import { Keymap } from "@opencode-ai/tui/context/keymap"
 import { RUN_COMMAND_PANEL_ROWS, RUN_SUBAGENT_PANEL_ROWS } from "./footer.command"
 import { SUBAGENT_INSPECTOR_ROWS } from "./footer.subagent"
 import { PROMPT_MAX_ROWS, TEXTAREA_MIN_ROWS } from "./footer.prompt"
@@ -46,11 +45,12 @@ import type {
   FooterState,
   FooterSubagentState,
   FooterView,
-  FormCancel,
-  FormReply,
   PermissionReply,
+  QuestionReject,
+  QuestionReply,
   RunAgent,
   RunCommand,
+  RunDiffStyle,
   RunInput,
   RunPrompt,
   RunProvider,
@@ -67,10 +67,11 @@ type CycleResult = {
 }
 
 type RunFooterOptions = {
-  directory: () => string
+  directory: string
   findFiles: (query: string) => Promise<string[]>
   agents: RunAgent[]
   references: RunReference[]
+  commands?: RunCommand[]
   wrote?: boolean
   sessionID: () => string | undefined
   agentLabel: string
@@ -81,22 +82,24 @@ type RunFooterOptions = {
   history?: RunPrompt[]
   theme: RunTheme
   tuiConfig: RunTuiConfig
+  diffStyle: RunDiffStyle
   onPermissionReply: (input: PermissionReply) => void | Promise<void>
-  onFormReply: (input: FormReply) => void | Promise<void>
-  onFormCancel: (input: FormCancel) => void | Promise<void>
+  onQuestionReply: (input: QuestionReply) => void | Promise<void>
+  onQuestionReject: (input: QuestionReject) => void | Promise<void>
   onCycleVariant?: () => CycleResult | void
   onModelSelect?: (model: NonNullable<RunInput["model"]>) => CycleResult | void | Promise<CycleResult | void>
   onVariantSelect?: (variant: string | undefined) => CycleResult | void | Promise<CycleResult | void>
   onInterrupt?: () => void
   onBackground?: () => void
   onEditorOpen: (input: { value: string }) => Promise<string | undefined>
+  onExit?: () => void
   onSubagentSelect?: (sessionID: string | undefined) => void
   onSubagentInterrupt?: (sessionID: string) => void
-  subscribeThemeSignal: (listener: () => void) => () => void
+  treeSitterClient?: TreeSitterClient
 }
 
 const PERMISSION_ROWS = 12
-const FORM_ROWS = 14
+const QUESTION_ROWS = 14
 const COMMAND_ROWS = RUN_COMMAND_PANEL_ROWS
 const SKILL_ROWS = RUN_COMMAND_PANEL_ROWS
 const SUBAGENT_ROWS = RUN_SUBAGENT_PANEL_ROWS
@@ -110,7 +113,7 @@ function createEmptySubagentState(): FooterSubagentState {
     tabs: [],
     details: {},
     permissions: [],
-    forms: [],
+    questions: [],
   }
 }
 
@@ -137,6 +140,13 @@ function eventPatch(next: FooterEvent): FooterPatch | undefined {
     }
   }
 
+  if (next.type === "turn.wait") {
+    return {
+      phase: "running",
+      status: "waiting for assistant",
+    }
+  }
+
   if (next.type === "turn.idle") {
     return {
       phase: "idle",
@@ -194,6 +204,7 @@ export class RunFooter implements FooterApi {
   private setHistory: Setter<RunPrompt[]>
   private promptRoute: FooterPromptRoute = { type: "composer" }
   private subagentMenuRows = SUBAGENT_ROWS
+  private autocomplete = false
   private interruptTimeout: NodeJS.Timeout | undefined
   private exitTimeout: NodeJS.Timeout | undefined
   private noticeTimeout: NodeJS.Timeout | undefined
@@ -205,11 +216,13 @@ export class RunFooter implements FooterApi {
   private paletteRefreshRunning = false
   private paletteRefreshQueued = false
   private themeRefreshTimeouts: NodeJS.Timeout[] = []
-  private unsubscribeThemeSignal: () => void
 
   private createScrollback(wrote: boolean): RunScrollbackStream {
     return new RunScrollbackStream(this.renderer, this.theme(), {
+      diffStyle: this.options.diffStyle,
       wrote,
+      sessionID: this.options.sessionID,
+      treeSitterClient: this.options.treeSitterClient,
       onThemeRelease: (theme) => {
         void this.renderer
           .idle()
@@ -228,6 +241,7 @@ export class RunFooter implements FooterApi {
       status: "",
       queue: 0,
       model: options.modelLabel,
+      duration: "",
       usage: "",
       first: options.first,
       interrupt: 0,
@@ -244,7 +258,7 @@ export class RunFooter implements FooterApi {
     const [references, setReferences] = createSignal(options.references)
     this.references = references
     this.setReferences = setReferences
-    const [commands, setCommands] = createSignal<RunCommand[] | undefined>()
+    const [commands, setCommands] = createSignal<RunCommand[] | undefined>(options.commands)
     this.commands = commands
     this.setCommands = setCommands
     const [providers, setProviders] = createSignal<RunProvider[] | undefined>()
@@ -269,7 +283,7 @@ export class RunFooter implements FooterApi {
       setSubagent("tabs", reconcile(next.tabs, { key: "sessionID" }))
       setSubagent("details", reconcile(next.details))
       setSubagent("permissions", reconcile(next.permissions, { key: "id" }))
-      setSubagent("forms", reconcile(next.forms, { key: "id" }))
+      setSubagent("questions", reconcile(next.questions, { key: "id" }))
     }
     const [queuedPrompts, setQueuedPrompts] = createSignal<FooterQueuedPrompt[]>([])
     this.queuedPrompts = queuedPrompts
@@ -284,7 +298,7 @@ export class RunFooter implements FooterApi {
     this.renderer.on(CliRenderEvents.PALETTE, this.handlePalette)
     this.renderer.on(CliRenderEvents.THEME_MODE, this.handleThemeRefresh)
     this.renderer.prependInputHandler(this.handleThemeNotification)
-    this.unsubscribeThemeSignal = options.subscribeThemeSignal(this.handleThemeSignal)
+    process.on("SIGUSR2", this.handleThemeSignal)
 
     const footer = this
     void render(
@@ -307,12 +321,14 @@ export class RunFooter implements FooterApi {
               variants: footer.variants,
               currentVariant: footer.currentVariant,
               theme: footer.theme,
+              diffStyle: options.diffStyle,
               tuiConfig: options.tuiConfig,
               history: footer.history,
+              agent: options.agentLabel,
               onSubmit: footer.handlePrompt,
               onPermissionReply: footer.handlePermissionReply,
-              onFormReply: footer.handleFormReply,
-              onFormCancel: footer.handleFormCancel,
+              onQuestionReply: footer.handleQuestionReply,
+              onQuestionReject: footer.handleQuestionReject,
               onCycle: footer.handleCycle,
               onInterrupt: footer.handleInterrupt,
               onBackground: options.onBackground,
@@ -380,11 +396,6 @@ export class RunFooter implements FooterApi {
       return
     }
 
-    if (next.type === "agent") {
-      this.options.agentLabel = Locale.titlecase(next.agent ?? "build")
-      return
-    }
-
     if (next.type === "model") {
       this.setCurrentModel(next.selection)
     }
@@ -489,6 +500,7 @@ export class RunFooter implements FooterApi {
       status: typeof next.status === "string" ? next.status : prev.status,
       queue: typeof next.queue === "number" ? Math.max(0, next.queue) : prev.queue,
       model: typeof next.model === "string" ? next.model : prev.model,
+      duration: typeof next.duration === "string" ? next.duration : prev.duration,
       usage: typeof next.usage === "string" ? next.usage : prev.usage,
       first: typeof next.first === "boolean" ? next.first : prev.first,
       interrupt:
@@ -538,9 +550,19 @@ export class RunFooter implements FooterApi {
     }
 
     const last = this.queue.at(-1)
-    const merged = last ? coalesceProgressCommit(last, commit) : undefined
-    if (merged) this.queue[this.queue.length - 1] = merged
-    else this.queue.push(commit)
+    if (
+      last &&
+      last.phase === "progress" &&
+      commit.phase === "progress" &&
+      last.kind === commit.kind &&
+      last.source === commit.source &&
+      last.partID === commit.partID &&
+      last.tool === commit.tool
+    ) {
+      last.text += commit.text
+    } else {
+      this.queue.push(commit)
+    }
 
     if (this.pending) {
       return
@@ -680,15 +702,15 @@ export class RunFooter implements FooterApi {
     this.patch({ interrupt: 0, exit: 0 })
   }
 
-  // Resizes the footer to fit the current view. Permission and form views
+  // Resizes the footer to fit the current view. Permission and question views
   // get fixed extra rows; the prompt view scales with textarea line count.
   private applyHeight(): void {
     const type = this.view().type
     const height =
       type === "permission"
         ? this.base + PERMISSION_ROWS
-        : type === "form"
-          ? this.base + FORM_ROWS
+        : type === "question"
+          ? this.base + QUESTION_ROWS
           : this.promptRoute.type === "command"
             ? 1 + COMMAND_ROWS
             : this.promptRoute.type === "skill"
@@ -726,8 +748,9 @@ export class RunFooter implements FooterApi {
     }
   }
 
-  private syncLayout = (next: { route: FooterPromptRoute; subagentRows: number }): void => {
+  private syncLayout = (next: { route: FooterPromptRoute; autocomplete: boolean; subagentRows: number }): void => {
     this.promptRoute = next.route
+    this.autocomplete = next.autocomplete
     this.subagentMenuRows = next.subagentRows
     if (this.view().type === "prompt") {
       this.applyHeight()
@@ -763,14 +786,20 @@ export class RunFooter implements FooterApi {
     await this.options.onPermissionReply(input)
   }
 
-  private handleFormReply = async (input: FormReply): Promise<void> => {
-    if (this.isClosed) return
-    await this.options.onFormReply(input)
+  private handleQuestionReply = async (input: QuestionReply): Promise<void> => {
+    if (this.isClosed) {
+      return
+    }
+
+    await this.options.onQuestionReply(input)
   }
 
-  private handleFormCancel = async (input: FormCancel): Promise<void> => {
-    if (this.isClosed) return
-    await this.options.onFormCancel(input)
+  private handleQuestionReject = async (input: QuestionReject): Promise<void> => {
+    if (this.isClosed) {
+      return
+    }
+
+    await this.options.onQuestionReject(input)
   }
 
   private handleCycle = (): void => {
@@ -983,11 +1012,12 @@ export class RunFooter implements FooterApi {
     this.clearExitTimer()
     this.patch({ exit: 0, status: "exiting" })
     this.close()
+    this.options.onExit?.()
     return true
   }
 
   private handlePalette = (): void => {
-    void resolveRunTheme(this.renderer, this.options.tuiConfig.theme).then((theme) => {
+    void resolveRunTheme(this.renderer).then((theme) => {
       if (this.isGone) {
         theme.block.syntax?.destroy()
         return
@@ -1076,7 +1106,7 @@ export class RunFooter implements FooterApi {
     this.renderer.off(CliRenderEvents.PALETTE, this.handlePalette)
     this.renderer.off(CliRenderEvents.THEME_MODE, this.handleThemeRefresh)
     this.renderer.removeInputHandler(this.handleThemeNotification)
-    this.unsubscribeThemeSignal()
+    process.off("SIGUSR2", this.handleThemeSignal)
     for (const timeout of this.themeRefreshTimeouts) clearTimeout(timeout)
     this.themeRefreshTimeouts.length = 0
     this.prompts.clear()
@@ -1107,19 +1137,3 @@ export class RunFooter implements FooterApi {
       })
   }
 }
-
-/** @internal Exported for queue identity regression tests. */
-export function coalesceProgressCommit(previous: StreamCommit, current: StreamCommit): StreamCommit | undefined {
-  if (
-    previous.phase !== "progress" ||
-    current.phase !== "progress" ||
-    previous.kind !== current.kind ||
-    previous.source !== current.source ||
-    previous.messageID !== current.messageID ||
-    previous.partID !== current.partID ||
-    previous.tool !== current.tool ||
-    previous.toolState !== current.toolState
-  )
-    return
-  return { ...current, text: previous.text + current.text }
-}

packages/cli/src/mini/footer.view.tsx

@@ -10,8 +10,8 @@
 /** @jsxImportSource @opentui/solid */
 import { useTerminalDimensions } from "@opentui/solid"
 import { For, Match, Show, Switch, createEffect, createMemo, createSignal, onCleanup } from "solid-js"
-import { registerOpencodeSpinner } from "../component/register-spinner"
-import { createColors, createFrames } from "../ui/spinner"
+import { registerOpencodeSpinner } from "@opencode-ai/tui/component/register-spinner"
+import { createColors, createFrames } from "@opencode-ai/tui/ui/spinner"
 import {
   RUN_SUBAGENT_PANEL_ROWS,
   RunCommandMenuBody,
@@ -25,10 +25,9 @@ import { FOOTER_MENU_ROWS, RunFooterMenu } from "./footer.menu"
 import { RunFooterSubagentBody } from "./footer.subagent"
 import { RunPromptBody, createPromptState } from "./footer.prompt"
 import { RunPermissionBody } from "./footer.permission"
-import { RunFormBody } from "./footer.form"
-import { createFormBodyState, type FormBodyState } from "./form.shared"
+import { RunQuestionBody } from "./footer.question"
 import { footerWidthPolicy } from "./footer.width"
-import { Keymap } from "../context/keymap"
+import { Keymap } from "@opencode-ai/tui/context/keymap"
 
 import type {
   FooterPromptRoute,
@@ -36,11 +35,12 @@ import type {
   FooterState,
   FooterSubagentState,
   FooterView,
-  FormCancel,
-  FormReply,
   PermissionReply,
+  QuestionReject,
+  QuestionReply,
   RunAgent,
   RunCommand,
+  RunDiffStyle,
   RunInput,
   RunPrompt,
   RunProvider,
@@ -67,7 +67,7 @@ const EMPTY_BORDER = {
 }
 
 type RunFooterViewProps = {
-  directory: () => string
+  directory: string
   findFiles: (query: string) => Promise<string[]>
   agents: () => RunAgent[]
   references: () => RunReference[]
@@ -81,12 +81,14 @@ type RunFooterViewProps = {
   subagent?: () => FooterSubagentState
   queuedPrompts?: () => FooterQueuedPrompt[]
   theme: () => RunTheme
+  diffStyle?: RunDiffStyle
   tuiConfig: RunTuiConfig
   history?: () => RunPrompt[]
+  agent: string
   onSubmit: (input: RunPrompt) => boolean
   onPermissionReply: (input: PermissionReply) => void | Promise<void>
-  onFormReply: (input: FormReply) => void | Promise<void>
-  onFormCancel: (input: FormCancel) => void | Promise<void>
+  onQuestionReply: (input: QuestionReply) => void | Promise<void>
+  onQuestionReject: (input: QuestionReject) => void | Promise<void>
   onCycle: () => void
   onInterrupt: () => boolean
   onBackground?: () => void
@@ -98,13 +100,15 @@ type RunFooterViewProps = {
   onModelSelect: (model: NonNullable<RunInput["model"]>) => void
   onVariantSelect: (variant: string | undefined) => void
   onRows: (rows: number) => void
-  onLayout: (input: { route: FooterPromptRoute; subagentRows: number }) => void
+  onLayout: (input: { route: FooterPromptRoute; autocomplete: boolean; subagentRows: number }) => void
   onStatus: (text: string) => void
   onSubagentSelect?: (sessionID: string | undefined) => void
   onSubagentInterrupt?: (sessionID: string) => void
   onQueuedRemove: (messageID: string) => Promise<boolean>
 }
 
+export { TEXTAREA_MIN_ROWS, TEXTAREA_MAX_ROWS } from "./footer.prompt"
+
 export function RunFooterView(props: RunFooterViewProps) {
   const term = useTerminalDimensions()
   const width = createMemo(() => term().width)
@@ -116,7 +120,7 @@ export function RunFooterView(props: RunFooterViewProps) {
         tabs: [],
         details: {},
         permissions: [],
-        forms: [],
+        questions: [],
       }
     )
   })
@@ -135,7 +139,7 @@ export function RunFooterView(props: RunFooterViewProps) {
   const panel = createMemo(
     () =>
       active().type === "permission" ||
-      active().type === "form" ||
+      active().type === "question" ||
       selectingQueued() ||
       selectingSubagent() ||
       commanding() ||
@@ -161,7 +165,7 @@ export function RunFooterView(props: RunFooterViewProps) {
   const foregroundSubagents = createMemo(() => activeTabs().some((item) => !item.background))
   const model = createMemo(() => {
     const current = props.currentModel()
-    return current ? modelInfo(props.providers(), current).model : props.state().model
+    return current ? modelInfo(props.providers(), current) : { model: props.state().model, provider: undefined }
   })
   const detail = createMemo(() => {
     const current = route()
@@ -211,24 +215,9 @@ export function RunFooterView(props: RunFooterViewProps) {
     const view = active()
     return view.type === "permission" ? view : undefined
   })
-  const form = createMemo<Extract<FooterView, { type: "form" }> | undefined>(() => {
+  const question = createMemo<Extract<FooterView, { type: "question" }> | undefined>(() => {
     const view = active()
-    return view.type === "form" ? view : undefined
-  })
-  const formStates = new Map<string, FormBodyState>()
-  const settledForms = new Set<string>()
-  let formsAbsent = true
-
-  createEffect(() => {
-    const view = active()
-    if (view.type === "form") {
-      formsAbsent = false
-      return
-    }
-    if (view.type === "permission") return
-    formsAbsent = true
-    formStates.clear()
-    settledForms.clear()
+    return view.type === "question" ? view : undefined
   })
   const promptView = createMemo(() => {
     if (active().type !== "prompt") {
@@ -382,8 +371,10 @@ export function RunFooterView(props: RunFooterViewProps) {
     }
 
     return {
-      model: model(),
+      model: model().model,
       variant: props.currentVariant(),
+      provider: undefined,
+      // Prefer without provider, but keep it on the shared width policy if we add it back.
     }
   })
   const statusColor = createMemo(() => {
@@ -580,6 +571,7 @@ export function RunFooterView(props: RunFooterViewProps) {
   createEffect(() => {
     props.onLayout({
       route: route(),
+      autocomplete: menu(),
       subagentRows: subagentMenuRows(),
     })
   })
@@ -744,36 +736,19 @@ export function RunFooterView(props: RunFooterViewProps) {
                         <Match when={active().type === "permission"}>
                           <RunPermissionBody
                             request={permission()!.request}
-                            directory={props.directory}
                             theme={theme()}
                             block={block()}
+                            diffStyle={props.diffStyle}
                             onReply={props.onPermissionReply}
                           />
                         </Match>
-                        <Match when={active().type === "form"}>
-                          <For each={form() ? [form()!] : []}>
-                            {(value) => (
-                              <RunFormBody
-                                request={value.request}
-                                theme={theme()}
-                                state={formStates.get(value.request.id) ?? createFormBodyState(value.request)}
-                                onState={(state) => {
-                                  if (!formsAbsent && !settledForms.has(state.formID))
-                                    formStates.set(state.formID, state)
-                                }}
-                                onReply={async (input) => {
-                                  await props.onFormReply(input)
-                                  settledForms.add(input.formID)
-                                  formStates.delete(input.formID)
-                                }}
-                                onCancel={async (input) => {
-                                  await props.onFormCancel(input)
-                                  settledForms.add(input.formID)
-                                  formStates.delete(input.formID)
-                                }}
-                              />
-                            )}
-                          </For>
+                        <Match when={active().type === "question"}>
+                          <RunQuestionBody
+                            request={question()!.request}
+                            theme={theme()}
+                            onReply={props.onQuestionReply}
+                            onReject={props.onQuestionReject}
+                          />
                         </Match>
                       </Switch>
                     </box>
@@ -849,6 +824,9 @@ export function RunFooterView(props: RunFooterViewProps) {
                     <box paddingRight={1} backgroundColor="transparent" flexShrink={0}>
                       <text fg={theme().text} wrapMode="none">
                         {info().model}
+                        <Show when={info().provider}>
+                          {(provider) => <span style={{ fg: theme().muted }}> {provider()}</span>}
+                        </Show>
                         <Show when={info().variant}>
                           {(variant) => (
                             <>
@@ -911,6 +889,8 @@ export function RunFooterView(props: RunFooterViewProps) {
             index={selectedIndex}
             total={() => tabs().length}
             detail={detail}
+            width={width}
+            diffStyle={props.diffStyle}
             onCycle={cycleTab}
             onClose={closeTab}
             interrupt={() => subagentInterruptShortcut() || undefined}

packages/cli/src/mini/index.ts

@@ -0,0 +1,8 @@
+export { runMini, validateMiniTerminal, mergeInput as mergeInteractiveInput, type MiniCommandInput } from "./mini"
+export {
+  runNonInteractive,
+  mergeInput as mergeNonInteractiveInput,
+  pickRunModel,
+  parseRunModel,
+  type RunCommandInput,
+} from "./run"

packages/cli/src/mini/mini.ts

@@ -0,0 +1,175 @@
+import { Service } from "@opencode-ai/client/effect/service"
+import { OpenCode, type OpenCodeClient } from "@opencode-ai/client/promise"
+import { ServerConnection } from "../services/server-connection"
+import { waitForCatalogReady } from "./catalog.shared"
+import { INTERACTIVE_INPUT_ERROR, resolveInteractiveStdin } from "./runtime.stdin"
+import type { RunInput, RunTuiConfig } from "./types"
+import { readStdin } from "../util/io"
+import { setTimeout } from "node:timers/promises"
+
+export type MiniCommandInput = {
+  server: ServerConnection.Resolved
+  continue?: boolean
+  session?: string
+  fork?: boolean
+  model?: string
+  agent?: string
+  prompt?: string
+  replay?: boolean
+  replayLimit?: number
+  demo?: boolean
+  tuiConfig?: RunTuiConfig | Promise<RunTuiConfig>
+}
+
+type Session = Awaited<ReturnType<OpenCodeClient["session"]["get"]>>
+export async function runMini(input: MiniCommandInput) {
+  validate(input)
+  const initialInput = mergeInput(process.stdin.isTTY ? undefined : await readStdin(), input.prompt)
+  const runtimeTask = import("./runtime")
+  const directory = localDirectory()
+
+  try {
+    const sdk = OpenCode.make({
+      baseUrl: input.server.endpoint.url,
+      headers: Service.headers(input.server.endpoint),
+    })
+    const model = parseModel(input.model)
+    let agentTask: Promise<string | undefined> | undefined
+    const resolveAgent = () => {
+      agentTask ??= validateAgent(sdk, directory, input.agent)
+      return agentTask
+    }
+    const resolveSession = async () => {
+      const [agent, selected] = await Promise.all([resolveAgent(), selectSession(sdk, directory, input)])
+      const readyModel =
+        model ?? (selected?.model ? { providerID: selected.model.providerID, modelID: selected.model.id } : undefined)
+      if (readyModel) await waitForCatalogReady({ sdk, directory, model: readyModel })
+      const session = selected ?? (await createSession(sdk, directory, agent, model))
+      return { id: session.id, title: session.title, resume: selected !== undefined }
+    }
+    const create = (
+      _sdk: OpenCodeClient,
+      next: { agent: string | undefined; model: RunInput["model"]; variant: string | undefined },
+    ) => createSession(sdk, directory, next.agent, next.model, next.variant)
+    const runtime = await runtimeTask
+    await runtime.runInteractiveDeferredMode({
+      sdk,
+      directory,
+      resolveAgent,
+      session: resolveSession,
+      createSession: create,
+      agent: input.agent,
+      model,
+      variant: undefined,
+      files: [],
+      initialInput,
+      thinking: true,
+      replay: input.replay ?? true,
+      replayLimit: input.replayLimit,
+      demo: input.demo,
+      tuiConfig: input.tuiConfig,
+    })
+  } catch (error) {
+    if (error instanceof Error && error.message === INTERACTIVE_INPUT_ERROR) fail(error.message)
+    throw error
+  }
+}
+
+export function validateMiniTerminal() {
+  if (!process.stdout.isTTY) fail("opencode mini requires a TTY stdout")
+}
+
+/** @internal Exported for testing. */
+export function mergeInput(piped: string | undefined, prompt: string | undefined) {
+  if (!prompt) return piped || undefined
+  if (!piped) return prompt
+  return piped + "\n" + prompt
+}
+
+function validate(input: MiniCommandInput) {
+  validateMiniTerminal()
+  if (input.replayLimit !== undefined && (!Number.isInteger(input.replayLimit) || input.replayLimit <= 0)) {
+    fail("--replay-limit must be a positive integer")
+  }
+  if (input.fork && !input.continue && !input.session) fail("--fork requires --continue or --session")
+  resolveInteractiveStdin().cleanup?.()
+}
+
+function localDirectory(): string {
+  const root = process.env.PWD ?? process.cwd()
+  try {
+    process.chdir(root)
+    return process.cwd()
+  } catch {
+    fail(`Failed to change directory to ${root}`)
+  }
+}
+
+function parseModel(value?: string): RunInput["model"] {
+  if (!value) return
+  const [providerID, ...rest] = value.split("/")
+  const modelID = rest.join("/")
+  if (!providerID || !modelID) fail("--model must use the format provider/model")
+  return { providerID, modelID }
+}
+
+async function validateAgent(sdk: OpenCodeClient, directory: string, name?: string) {
+  if (!name) return
+  const deadline = Date.now() + 5_000
+  let agents: Awaited<ReturnType<OpenCodeClient["agent"]["list"]>> | undefined
+  while (Date.now() < deadline) {
+    agents = await sdk.agent.list({ location: { directory } }).catch(() => undefined)
+    const agent = agents?.data.find((item) => item.id === name)
+    if (agent?.mode === "subagent") {
+      warning(`agent "${name}" is a subagent, not a primary agent. Falling back to default agent`)
+      return
+    }
+    if (agent) return name
+    await setTimeout(25)
+  }
+  if (!agents) {
+    warning("failed to list agents. Falling back to default agent")
+    return
+  }
+  warning(`agent "${name}" not found. Falling back to default agent`)
+}
+
+async function selectSession(sdk: OpenCodeClient, directory: string, input: MiniCommandInput, preselected?: Session) {
+  const selected =
+    preselected ??
+    (input.session
+      ? await sdk.session.get({ sessionID: input.session }).catch(() => undefined)
+      : input.continue
+        ? await sdk.session
+            .list({ directory, parentID: null, limit: 1, order: "desc" })
+            .then((result) => result.data[0])
+        : undefined)
+  if (input.session && !selected) fail("Session not found")
+  if (!selected) return
+  if (!input.fork) return selected
+  return sdk.session.fork({ sessionID: selected.id })
+}
+
+async function createSession(
+  sdk: OpenCodeClient,
+  directory: string,
+  agent: string | undefined,
+  model: RunInput["model"],
+  variant?: string,
+): Promise<Session> {
+  if (model) await waitForCatalogReady({ sdk, directory, model })
+  return sdk.session.create({
+    agent,
+    model: model ? { providerID: model.providerID, id: model.modelID, variant } : undefined,
+    location: { directory },
+  })
+}
+
+function warning(message: string) {
+  process.stderr.write(`\x1b[93m\x1b[1m!\x1b[0m ${message}\n`)
+}
+
+function fail(message: string): never {
+  process.stderr.write(`\x1b[91m\x1b[1mError: \x1b[0m${message}\n`)
+  process.exit(1)
+}

packages/cli/src/mini/noninteractive.ts

@@ -1,16 +1,9 @@
-import type {
-  EventSubscribeOutput,
-  JsonValue,
-  LLMToolContent,
-  LocationRef,
-  OpenCodeClient,
-  SessionMessageAssistantTool,
-} from "@opencode-ai/client/promise"
+import type { EventSubscribeOutput, OpenCodeClient } from "@opencode-ai/client/promise"
 import { SessionMessage } from "@opencode-ai/schema/session-message"
 import { EOL } from "node:os"
 import { readFile } from "node:fs/promises"
-import { toolOutputText, type MiniToolPart } from "@opencode-ai/tui/mini/tool"
 import { UI } from "./ui"
+import type { MiniToolPart } from "./types"
 
 type Model = {
   providerID: string
@@ -26,7 +19,6 @@ type File = {
 type Input = {
   client: OpenCodeClient
   sessionID: string
-  location: LocationRef
   message: string
   files: File[]
   agent?: string
@@ -37,9 +29,8 @@ type Input = {
   auto: boolean
   /** True when the client is attached to a shared server rather than an exclusive in-process one. */
   attached: boolean
-  compatibility?: "v1"
-  renderTool: (part: SessionMessageAssistantTool) => Promise<void>
-  renderToolError: (part: SessionMessageAssistantTool) => Promise<void>
+  renderTool: (part: MiniToolPart) => Promise<void>
+  renderToolError: (part: MiniToolPart) => Promise<void>
 }
 
 type StartedPart = {
@@ -50,12 +41,9 @@ type StartedPart = {
 type ToolState = StartedPart & {
   assistantMessageID: string
   tool: string
-  input: Record<string, JsonValue>
+  input: Record<string, unknown>
   raw?: string
   provider?: unknown
-  providerState?: SessionMessageAssistantTool["providerState"]
-  structured: Record<string, JsonValue>
-  content: LLMToolContent[]
 }
 
 type V2Event = EventSubscribeOutput
@@ -78,12 +66,11 @@ export async function runNonInteractivePrompt(input: Input) {
   let submitted = false
   let promoted = false
   let emittedError = false
+  let questionRejected = false
   let permissionRejected = false
   let formCancelled = false
   let interrupted = false
-  let v1InvalidOutput = false
   let admission: AbortController | undefined
-  let pendingStep: { timestamp: number; part: Record<string, unknown>; label: string } | undefined
 
   const emit = (type: string, timestamp: number, data: Record<string, unknown>) => {
     if (input.format !== "json") return false
@@ -104,17 +91,6 @@ export async function runNonInteractivePrompt(input: Input) {
     UI.empty()
   }
 
-  const flushStep = () => {
-    if (!pendingStep) return
-    const value = pendingStep
-    pendingStep = undefined
-    if (!emit("step_start", value.timestamp, { part: value.part }) && input.format !== "json") {
-      UI.empty()
-      UI.println(value.label)
-      UI.empty()
-    }
-  }
-
   const replyPermission = async (request: { id: string; action: string; resources: ReadonlyArray<string> }) => {
     if (!input.auto) {
       permissionRejected = true
@@ -136,16 +112,14 @@ export async function runNonInteractivePrompt(input: Input) {
     }
   }
 
+  const rejectQuestion = async (request: { id: string }) => {
+    questionRejected = true
+    await input.client.question.reject({ sessionID: input.sessionID, requestID: request.id }).catch(() => {})
+  }
+
   const cancelForm = async (request: Pick<FormRequest, "id" | "sessionID">) => {
-    try {
-      await input.client.form.cancel(
-        { sessionID: request.sessionID, formID: request.id },
-        ...formRequestOptions(request.sessionID === GLOBAL_FORM_SESSION_ID ? input.location : undefined),
-      )
-    } catch (error) {
-      if (!formAlreadySettled(error)) throw error
-    }
     formCancelled = true
+    await input.client.form.cancel({ sessionID: request.sessionID, formID: request.id }).catch(() => {})
   }
 
   const consume = async () => {
@@ -164,13 +138,15 @@ export async function runNonInteractivePrompt(input: Input) {
         await replyPermission(event.data)
         continue
       }
+      if (event.type === "question.v2.asked" && submitted && event.data.sessionID === input.sessionID) {
+        await rejectQuestion(event.data)
+        continue
+      }
       if (
         event.type === "form.created" &&
         submitted &&
         (event.data.form.sessionID === input.sessionID ||
-          (!input.attached &&
-            event.data.form.sessionID === GLOBAL_FORM_SESSION_ID &&
-            sameLocation(event.location, input.location)))
+          (!input.attached && event.data.form.sessionID === GLOBAL_FORM_SESSION_ID))
       ) {
         await cancelForm(event.data.form)
         continue
@@ -187,7 +163,7 @@ export async function runNonInteractivePrompt(input: Input) {
       if (
         event.type === "session.execution.interrupted" &&
         event.data.reason === "user" &&
-        (interrupted || permissionRejected || formCancelled)
+        (interrupted || permissionRejected || questionRejected || formCancelled)
       ) {
         return
       }
@@ -201,14 +177,6 @@ export async function runNonInteractivePrompt(input: Input) {
           type: "step-start",
           snapshot: event.data.snapshot,
         }
-        if (input.compatibility === "v1") {
-          pendingStep = {
-            timestamp: time,
-            part,
-            label: `> ${event.data.agent} · ${event.data.model.id}`,
-          }
-          continue
-        }
         if (!emit("step_start", time, { part }) && input.format !== "json") {
           UI.empty()
           UI.println(`> ${event.data.agent} · ${event.data.model.id}`)
@@ -218,7 +186,6 @@ export async function runNonInteractivePrompt(input: Input) {
       }
 
       if (event.type === "session.text.started") {
-        flushStep()
         starts.set("text", { id: partID(event.id), timestamp: time })
         continue
       }
@@ -238,7 +205,6 @@ export async function runNonInteractivePrompt(input: Input) {
       }
 
       if (event.type === "session.reasoning.started") {
-        flushStep()
         starts.set("reasoning", { id: partID(event.id), timestamp: time })
         continue
       }
@@ -269,33 +235,23 @@ export async function runNonInteractivePrompt(input: Input) {
       }
 
       if (event.type === "session.tool.input.started") {
-        flushStep()
-        tools.set(toolKey(event.data.assistantMessageID, event.data.callID), {
+        tools.set(event.data.callID, {
           id: partID(event.id),
           timestamp: time,
           assistantMessageID: event.data.assistantMessageID,
           tool: event.data.name,
           input: {},
-          structured: {},
-          content: [],
         })
         continue
       }
       if (event.type === "session.tool.input.ended") {
-        const current = tools.get(toolKey(event.data.assistantMessageID, event.data.callID))
+        const current = tools.get(event.data.callID)
         if (current) current.raw = event.data.text
         continue
       }
-      if (event.type === "session.tool.input.delta") {
-        const current = tools.get(toolKey(event.data.assistantMessageID, event.data.callID))
-        if (current) current.raw = (current.raw ?? "") + event.data.delta
-        continue
-      }
       if (event.type === "session.tool.called") {
-        flushStep()
-        const key = toolKey(event.data.assistantMessageID, event.data.callID)
-        const current = tools.get(key)
-        tools.set(key, {
+        const current = tools.get(event.data.callID)
+        tools.set(event.data.callID, {
           id: current?.id ?? partID(event.id),
           timestamp: current?.timestamp ?? time,
           assistantMessageID: event.data.assistantMessageID,
@@ -303,39 +259,11 @@ export async function runNonInteractivePrompt(input: Input) {
           input: event.data.input,
           raw: current?.raw,
           provider: { executed: event.data.executed, state: event.data.state },
-          providerState: event.data.state,
-          structured: {},
-          content: [],
         })
         continue
       }
-      if (event.type === "session.tool.progress") {
-        const current = tools.get(toolKey(event.data.assistantMessageID, event.data.callID))
-        if (current) {
-          current.structured = event.data.structured
-          current.content = event.data.content
-        }
-        continue
-      }
       if (event.type === "session.tool.success") {
-        const key = toolKey(event.data.assistantMessageID, event.data.callID)
-        const current = tools.get(key) ?? fallbackTool(event)
-        const tool: SessionMessageAssistantTool = {
-          type: "tool",
-          id: event.data.callID,
-          name: current.tool,
-          executed: event.data.executed,
-          providerState: current.providerState,
-          providerResultState: event.data.resultState,
-          state: {
-            status: "completed",
-            input: current.input,
-            structured: event.data.structured,
-            content: event.data.content,
-            result: event.data.result,
-          },
-          time: { created: current.timestamp, ran: current.timestamp, completed: time },
-        }
+        const current = tools.get(event.data.callID) ?? fallbackTool(event)
         const part: MiniToolPart = {
           id: current.id,
           sessionID: input.sessionID,
@@ -346,7 +274,10 @@ export async function runNonInteractivePrompt(input: Input) {
           state: {
             status: "completed",
             input: current.input,
-            output: toolOutputText(current.tool, event.data.content),
+            output: event.data.content
+              .filter((item) => item.type === "text")
+              .map((item) => item.text)
+              .join("\n"),
             title: current.tool,
             metadata: {
               structured: event.data.structured,
@@ -359,31 +290,13 @@ export async function runNonInteractivePrompt(input: Input) {
             time: { start: current.timestamp, end: time },
           },
         }
-        tools.delete(key)
-        if (!emit("tool_use", time, { part })) await input.renderTool(tool)
+        tools.delete(event.data.callID)
+        if (!emit("tool_use", time, { part })) await input.renderTool(part)
         continue
       }
       if (event.type === "session.tool.failed") {
-        const key = toolKey(event.data.assistantMessageID, event.data.callID)
-        const current = tools.get(key) ?? fallbackTool(event)
+        const current = tools.get(event.data.callID) ?? fallbackTool(event)
         const error = event.data.error.message
-        const tool: SessionMessageAssistantTool = {
-          type: "tool",
-          id: event.data.callID,
-          name: current.tool,
-          executed: event.data.executed,
-          providerState: current.providerState,
-          providerResultState: event.data.resultState,
-          state: {
-            status: "error",
-            input: current.input,
-            structured: current.structured,
-            content: current.content,
-            error: event.data.error,
-            result: event.data.result,
-          },
-          time: { created: current.timestamp, ran: current.timestamp, completed: time },
-        }
         const part: MiniToolPart = {
           id: current.id,
           sessionID: input.sessionID,
@@ -404,28 +317,15 @@ export async function runNonInteractivePrompt(input: Input) {
             time: { start: current.timestamp, end: time },
           },
         }
-        tools.delete(key)
-        if (input.compatibility === "v1" && (permissionRejected || formCancelled)) continue
+        tools.delete(event.data.callID)
         if (!emit("tool_use", time, { part })) {
-          if (toolOutputText(current.tool, current.content).trim())
-            await input.renderTool({
-              ...tool,
-              state: {
-                status: "completed",
-                input: current.input,
-                structured: current.structured,
-                content: current.content,
-                result: event.data.result,
-              },
-            })
-          await input.renderToolError(tool)
+          await input.renderToolError(part)
           UI.error(error)
         }
         continue
       }
 
       if (event.type === "session.step.ended") {
-        flushStep()
         const part = {
           id: partID(event.id),
           sessionID: input.sessionID,
@@ -440,25 +340,14 @@ export async function runNonInteractivePrompt(input: Input) {
         continue
       }
       if (event.type === "session.step.failed") {
-        if (
-          input.compatibility === "v1" &&
-          event.data.error.message === "Provider stream ended without a terminal finish event"
-        ) {
-          pendingStep = undefined
-          v1InvalidOutput = true
-          continue
-        }
-        if (interrupted || permissionRejected || formCancelled) continue
-        flushStep()
+        if (interrupted || permissionRejected || questionRejected || formCancelled) continue
         emittedError = true
         process.exitCode = 1
         if (!emit("error", time, { error: event.data.error })) UI.error(event.data.error.message)
         continue
       }
       if (event.type === "session.execution.failed") {
-        if (input.compatibility === "v1" && (v1InvalidOutput || permissionRejected || formCancelled)) return
-        flushStep()
-        if (!emittedError && !formCancelled) {
+        if (!emittedError && !questionRejected && !formCancelled) {
           emittedError = true
           process.exitCode = 1
           if (!emit("error", time, { error: event.data.error })) UI.error(event.data.error.message)
@@ -466,7 +355,6 @@ export async function runNonInteractivePrompt(input: Input) {
         return
       }
       if (event.type === "session.execution.interrupted") {
-        if (input.compatibility === "v1" && (permissionRejected || formCancelled)) return
         if (event.data.reason === "user" && interrupted) process.exitCode = 130
         if (event.data.reason !== "user" && !emittedError) {
           emittedError = true
@@ -541,23 +429,19 @@ export async function runNonInteractivePrompt(input: Input) {
     if (!response) return
     if (interrupted) await input.client.session.interrupt({ sessionID: input.sessionID }).catch(() => {})
 
-    const [permissions, forms, globals] = await Promise.all([
+    const [permissions, questions, forms] = await Promise.all([
       input.client.permission.list({ sessionID: input.sessionID }).catch(() => undefined),
-      input.client.form.list({ sessionID: input.sessionID }).catch(() => undefined),
-      input.attached
-        ? Promise.resolve(undefined)
-        : input.client.form.request
-            .list({
-              location: { directory: input.location.directory, workspace: input.location.workspaceID },
-            })
-            .catch(() => undefined),
+      input.client.question.list({ sessionID: input.sessionID }).catch(() => undefined),
+      Promise.all(
+        (input.attached ? [input.sessionID] : [input.sessionID, GLOBAL_FORM_SESSION_ID]).map((sessionID) =>
+          input.client.form.list({ sessionID }).catch(() => undefined),
+        ),
+      ),
     ])
     await Promise.all([
       ...(permissions ?? []).map(replyPermission),
-      ...(forms ?? []).map(cancelForm),
-      ...(globals && sameLocation(globals.location, input.location)
-        ? globals.data.filter((form) => form.sessionID === GLOBAL_FORM_SESSION_ID).map(cancelForm)
-        : []),
+      ...(questions ?? []).map(rejectQuestion),
+      ...forms.flatMap((response) => response ?? []).map(cancelForm),
     ])
     await completed
   } finally {
@@ -567,34 +451,10 @@ export async function runNonInteractivePrompt(input: Input) {
   }
 }
 
-function sameLocation(left: LocationRef | undefined, right: LocationRef) {
-  return !!left && left.directory === right.directory && left.workspaceID === right.workspaceID
-}
-
-function formRequestOptions(location: LocationRef | undefined): [] | [{ headers: Record<string, string> }] {
-  if (!location) return []
-  return [
-    {
-      headers: {
-        "x-opencode-directory": encodeURIComponent(location.directory),
-        ...(location.workspaceID ? { "x-opencode-workspace": location.workspaceID } : {}),
-      },
-    },
-  ]
-}
-
-function formAlreadySettled(error: unknown) {
-  return !!error && typeof error === "object" && Reflect.get(error, "_tag") === "FormAlreadySettledError"
-}
-
 function partID(eventID: string) {
   return `prt_${eventID.replace(/^evt_/, "")}`
 }
 
-function toolKey(messageID: string, callID: string) {
-  return `${messageID}\u0000${callID}`
-}
-
 function fallbackTool(event: {
   id: string
   created: number
@@ -606,8 +466,6 @@ function fallbackTool(event: {
     assistantMessageID: event.data.assistantMessageID,
     tool: "tool",
     input: {},
-    structured: {},
-    content: [],
   }
 }
 
@@ -622,7 +480,7 @@ async function prepareFile(file: File) {
     const uri = file.url.startsWith("data:")
       ? file.url
       : `data:${file.mime};base64,${(await readFile(new URL(file.url))).toString("base64")}`
-    return { attachment: { uri, name: file.filename } }
+    return { attachment: { uri, mime: file.mime, name: file.filename } }
   }
   const content = file.url.startsWith("data:")
     ? Buffer.from(file.url.slice(file.url.indexOf(",") + 1), "base64").toString("utf8")

packages/cli/src/mini/permission.shared.ts

@@ -0,0 +1,260 @@
+// Pure state machine for the permission UI.
+//
+// Lives outside the JSX component so it can be tested independently. The
+// machine has three stages:
+//
+//   permission → initial view with Allow once / Always / Reject options
+//   always     → confirmation step (Confirm / Cancel)
+//   reject     → text input for rejection message
+//
+// permissionRun() is the main transition: given the current state and the
+// selected option, it returns a new state and optionally a PermissionReply
+// to send to the SDK. The component calls this on enter/click.
+//
+// permissionInfo() extracts display info (icon, title, lines, diff) from
+// the request, delegating to tool.ts for tool-specific formatting.
+import type { PermissionV2Request } from "@opencode-ai/client/promise"
+import type { PermissionReply } from "./types"
+import { toolPath, toolPermissionInfo } from "./tool"
+
+type Dict = Record<string, unknown>
+
+export type PermissionStage = "permission" | "always" | "reject"
+export type PermissionOption = "once" | "always" | "reject" | "confirm" | "cancel"
+
+export type PermissionBodyState = {
+  requestID: string
+  stage: PermissionStage
+  selected: PermissionOption
+  message: string
+  submitting: boolean
+}
+
+export type PermissionInfo = {
+  icon: string
+  title: string
+  lines: string[]
+  diff?: string
+  file?: string
+}
+
+export type PermissionStep = {
+  state: PermissionBodyState
+  reply?: PermissionReply
+}
+
+function dict(v: unknown): Dict {
+  if (!v || typeof v !== "object" || Array.isArray(v)) {
+    return {}
+  }
+
+  return { ...v }
+}
+
+function text(v: unknown): string {
+  return typeof v === "string" ? v : ""
+}
+
+function data(request: PermissionV2Request): Dict {
+  const meta = dict(request.metadata)
+  return {
+    ...meta,
+    ...dict(meta.input),
+  }
+}
+
+function patterns(request: PermissionV2Request): string[] {
+  return request.resources.filter((item): item is string => typeof item === "string")
+}
+
+export function createPermissionBodyState(requestID: string): PermissionBodyState {
+  return {
+    requestID,
+    stage: "permission",
+    selected: "once",
+    message: "",
+    submitting: false,
+  }
+}
+
+export function permissionOptions(stage: PermissionStage): PermissionOption[] {
+  if (stage === "permission") {
+    return ["once", "always", "reject"]
+  }
+
+  if (stage === "always") {
+    return ["confirm", "cancel"]
+  }
+
+  return []
+}
+
+export function permissionInfo(request: PermissionV2Request): PermissionInfo {
+  const pats = patterns(request)
+  const input = data(request)
+  const info = toolPermissionInfo(request.action, input, dict(request.metadata), pats)
+  if (info) {
+    return info
+  }
+
+  if (request.action === "external_directory") {
+    const meta = dict(request.metadata)
+    const raw = text(meta.parentDir) || text(meta.filepath) || pats[0] || ""
+    const dir = raw.includes("*") ? raw.slice(0, raw.indexOf("*")).replace(/[\\/]+$/, "") : raw
+    return {
+      icon: "←",
+      title: `Access external directory ${toolPath(dir, { home: true })}`,
+      lines: pats.map((item) => `- ${item}`),
+    }
+  }
+
+  if (request.action === "doom_loop") {
+    return {
+      icon: "⟳",
+      title: "Continue after repeated failures",
+      lines: ["This keeps the session running despite repeated failures."],
+    }
+  }
+
+  return {
+    icon: "⚙",
+    title: `Call tool ${request.action}`,
+    lines: [`Tool: ${request.action}`],
+  }
+}
+
+export function permissionAlwaysLines(request: PermissionV2Request): string[] {
+  const save = request.save ?? []
+  if (save.length === 1 && save[0] === "*") {
+    return [`This will allow ${request.action} until OpenCode is restarted.`]
+  }
+
+  return [
+    "This will allow the following patterns until OpenCode is restarted.",
+    ...save.map((item) => `- ${item}`),
+  ]
+}
+
+export function permissionLabel(option: PermissionOption): string {
+  if (option === "once") return "Allow once"
+  if (option === "always") return "Allow always"
+  if (option === "reject") return "Reject"
+  if (option === "confirm") return "Confirm"
+  return "Cancel"
+}
+
+export function permissionReply(requestID: string, reply: PermissionReply["reply"], message?: string): PermissionReply {
+  return {
+    requestID,
+    reply,
+    ...(message && message.trim() ? { message: message.trim() } : {}),
+  }
+}
+
+export function permissionShift(
+  state: PermissionBodyState,
+  dir: -1 | 1,
+  list = permissionOptions(state.stage),
+): PermissionBodyState {
+  if (list.length === 0) {
+    return state
+  }
+
+  const idx = Math.max(0, list.indexOf(state.selected))
+  const selected = list[(idx + dir + list.length) % list.length]
+  return {
+    ...state,
+    selected,
+  }
+}
+
+export function permissionHover(state: PermissionBodyState, option: PermissionOption): PermissionBodyState {
+  return {
+    ...state,
+    selected: option,
+  }
+}
+
+export function permissionRun(state: PermissionBodyState, requestID: string, option: PermissionOption): PermissionStep {
+  if (state.submitting) {
+    return { state }
+  }
+
+  if (state.stage === "permission") {
+    if (option === "always") {
+      return {
+        state: {
+          ...state,
+          stage: "always",
+          selected: "confirm",
+        },
+      }
+    }
+
+    if (option === "reject") {
+      return {
+        state: {
+          ...state,
+          stage: "reject",
+          selected: "reject",
+        },
+      }
+    }
+
+    return {
+      state,
+      reply: permissionReply(requestID, "once"),
+    }
+  }
+
+  if (state.stage !== "always") {
+    return { state }
+  }
+
+  if (option === "cancel") {
+    return {
+      state: {
+        ...state,
+        stage: "permission",
+        selected: "always",
+      },
+    }
+  }
+
+  return {
+    state,
+    reply: permissionReply(requestID, "always"),
+  }
+}
+
+export function permissionReject(state: PermissionBodyState, requestID: string): PermissionReply | undefined {
+  if (state.submitting) {
+    return undefined
+  }
+
+  return permissionReply(requestID, "reject", state.message)
+}
+
+export function permissionCancel(state: PermissionBodyState): PermissionBodyState {
+  return {
+    ...state,
+    stage: "permission",
+    selected: "reject",
+  }
+}
+
+export function permissionEscape(state: PermissionBodyState): PermissionBodyState {
+  if (state.stage === "always") {
+    return {
+      ...state,
+      stage: "permission",
+      selected: "always",
+    }
+  }
+
+  return {
+    ...state,
+    stage: "reject",
+    selected: "reject",
+  }
+}

packages/cli/src/mini/prompt.editor.ts

@@ -0,0 +1,157 @@
+import type { RunPromptPart } from "./types"
+
+type Mention = Extract<RunPromptPart, { type: "file" | "agent" }>
+
+export function resolveEditorSlashValue(text: string) {
+  const head = slashHead(text)
+  if (!head || head.name.toLowerCase() !== "editor") {
+    return text
+  }
+
+  return head.arguments
+}
+
+export function realignEditorPromptParts(content: string, parts: RunPromptPart[]): RunPromptPart[] {
+  const matches = new Map<number, Mention | undefined>()
+  const used: Array<{ start: number; end: number }> = []
+
+  for (const [index, part] of parts.entries()) {
+    if (part.type !== "file" && part.type !== "agent") {
+      continue
+    }
+
+    const text = promptPartText(part)
+    if (!text) {
+      continue
+    }
+
+    const start = findPromptPartIndex(content, text, used, promptPartStart(part))
+    if (start === -1) {
+      matches.set(index, undefined)
+      continue
+    }
+
+    const end = start + text.length
+    used.push({ start, end })
+    matches.set(index, updatePromptPart(part, start, end, text))
+  }
+
+  const next: RunPromptPart[] = []
+  for (const [index, part] of parts.entries()) {
+    if (part.type !== "file" && part.type !== "agent") {
+      next.push(part)
+      continue
+    }
+
+    if (!promptPartText(part)) {
+      next.push(part)
+      continue
+    }
+
+    const match = matches.get(index)
+    if (match) {
+      next.push(match)
+    }
+  }
+
+  return next
+}
+
+function slashHead(text: string) {
+  if (!text.startsWith("/")) {
+    return
+  }
+
+  for (let i = 1; i < text.length; i++) {
+    switch (text[i]) {
+      case " ":
+      case "\t":
+      case "\n":
+        return {
+          name: text.slice(1, i),
+          arguments: text.slice(i + 1),
+        }
+    }
+  }
+
+  return {
+    name: text.slice(1),
+    arguments: "",
+  }
+}
+
+function promptPartText(part: Mention) {
+  if (part.type === "agent") {
+    return part.source?.value
+  }
+
+  return part.source?.text.value
+}
+
+function promptPartStart(part: Mention) {
+  if (part.type === "agent") {
+    return part.source?.start ?? Number.POSITIVE_INFINITY
+  }
+
+  return part.source?.text.start ?? Number.POSITIVE_INFINITY
+}
+
+function findPromptPartIndex(content: string, text: string, used: Array<{ start: number; end: number }>, hint: number) {
+  let searchFrom = 0
+  let best = -1
+  let distance = Number.POSITIVE_INFINITY
+  const hinted = Number.isFinite(hint)
+
+  while (true) {
+    const start = content.indexOf(text, searchFrom)
+    if (start === -1) {
+      return best
+    }
+
+    const end = start + text.length
+    searchFrom = start + 1
+    if (used.some((range) => start < range.end && end > range.start)) {
+      continue
+    }
+
+    if (!hinted) {
+      return start
+    }
+
+    const nextDistance = Math.abs(start - hint)
+    if (nextDistance < distance) {
+      best = start
+      distance = nextDistance
+    }
+  }
+}
+
+function updatePromptPart(part: Mention, start: number, end: number, text: string): Mention {
+  if (part.type === "agent") {
+    return {
+      ...part,
+      source: {
+        start,
+        end,
+        value: text,
+      },
+    }
+  }
+
+  if (!part.source?.text) {
+    return part
+  }
+
+  return {
+    ...part,
+    source: {
+      ...part.source,
+      text: {
+        ...part.source.text,
+        start,
+        end,
+        value: text,
+      },
+    },
+  }
+}

packages/cli/src/mini/prompt.shared.ts

@@ -7,8 +7,8 @@
 // the current browse position. When the user arrows up at cursor offset 0,
 // the current draft is saved and history begins. Arrowing past the end
 // restores the draft.
-export { displayCharAt, displaySlice, mentionTriggerIndex } from "../prompt/display"
-import { stringWidth } from "../util/string-width"
+export { displayCharAt, displaySlice, mentionTriggerIndex } from "@opencode-ai/tui/prompt/display"
+import { stringWidth } from "@opencode-ai/tui/util/string-width"
 import type { RunPrompt } from "./types"
 
 const HISTORY_LIMIT = 200

packages/cli/src/mini/question.shared.ts

@@ -0,0 +1,340 @@
+// Pure state machine for the question UI.
+//
+// Supports both single-question and multi-question flows. Single questions
+// submit immediately on selection. Multi-question flows use tabs and a
+// final confirmation step.
+//
+// State transitions:
+//   questionSelect  → picks an option (single: submits, multi: toggles/advances)
+//   questionSave    → saves custom text input
+//   questionMove    → arrow key navigation through options
+//   questionSetTab  → tab navigation between questions
+//   questionSubmit  → builds the final QuestionReply with all answers
+//
+// Custom answers: if a question has custom=true, an extra "Type your own
+// answer" option appears. Selecting it enters editing mode with a text field.
+import type { QuestionV2Info, QuestionV2Request } from "@opencode-ai/client/promise"
+import type { QuestionReject, QuestionReply } from "./types"
+
+export type QuestionBodyState = {
+  requestID: string
+  tab: number
+  answers: string[][]
+  custom: string[]
+  selected: number
+  editing: boolean
+  submitting: boolean
+}
+
+export type QuestionStep = {
+  state: QuestionBodyState
+  reply?: QuestionReply
+}
+
+export function createQuestionBodyState(requestID: string): QuestionBodyState {
+  return {
+    requestID,
+    tab: 0,
+    answers: [],
+    custom: [],
+    selected: 0,
+    editing: false,
+    submitting: false,
+  }
+}
+
+export function questionSync(state: QuestionBodyState, requestID: string): QuestionBodyState {
+  if (state.requestID === requestID) {
+    return state
+  }
+
+  return createQuestionBodyState(requestID)
+}
+
+export function questionSingle(request: QuestionV2Request): boolean {
+  return request.questions.length === 1 && request.questions[0]?.multiple !== true
+}
+
+export function questionTabs(request: QuestionV2Request): number {
+  return questionSingle(request) ? 1 : request.questions.length + 1
+}
+
+export function questionConfirm(request: QuestionV2Request, state: QuestionBodyState): boolean {
+  return !questionSingle(request) && state.tab === request.questions.length
+}
+
+export function questionInfo(request: QuestionV2Request, state: QuestionBodyState): QuestionV2Info | undefined {
+  return request.questions[state.tab]
+}
+
+export function questionCustom(request: QuestionV2Request, state: QuestionBodyState): boolean {
+  return questionInfo(request, state)?.custom !== false
+}
+
+export function questionInput(state: QuestionBodyState): string {
+  return state.custom[state.tab] ?? ""
+}
+
+export function questionPicked(state: QuestionBodyState): boolean {
+  const value = questionInput(state)
+  if (!value) {
+    return false
+  }
+
+  return state.answers[state.tab]?.includes(value) ?? false
+}
+
+export function questionOther(request: QuestionV2Request, state: QuestionBodyState): boolean {
+  const info = questionInfo(request, state)
+  if (!info || info.custom === false) {
+    return false
+  }
+
+  return state.selected === info.options.length
+}
+
+export function questionTotal(request: QuestionV2Request, state: QuestionBodyState): number {
+  const info = questionInfo(request, state)
+  if (!info) {
+    return 0
+  }
+
+  return info.options.length + (questionCustom(request, state) ? 1 : 0)
+}
+
+export function questionAnswers(state: QuestionBodyState, count: number): string[][] {
+  return Array.from({ length: count }, (_, idx) => state.answers[idx] ?? [])
+}
+
+export function questionSetTab(state: QuestionBodyState, tab: number): QuestionBodyState {
+  return {
+    ...state,
+    tab,
+    selected: 0,
+    editing: false,
+  }
+}
+
+export function questionSetSelected(state: QuestionBodyState, selected: number): QuestionBodyState {
+  return {
+    ...state,
+    selected,
+  }
+}
+
+export function questionSetEditing(state: QuestionBodyState, editing: boolean): QuestionBodyState {
+  return {
+    ...state,
+    editing,
+  }
+}
+
+export function questionSetSubmitting(state: QuestionBodyState, submitting: boolean): QuestionBodyState {
+  return {
+    ...state,
+    submitting,
+  }
+}
+
+function storeAnswers(state: QuestionBodyState, tab: number, list: string[]): QuestionBodyState {
+  const answers = [...state.answers]
+  answers[tab] = list
+  return {
+    ...state,
+    answers,
+  }
+}
+
+export function questionStoreCustom(state: QuestionBodyState, tab: number, text: string): QuestionBodyState {
+  const custom = [...state.custom]
+  custom[tab] = text
+  return {
+    ...state,
+    custom,
+  }
+}
+
+function questionPick(
+  state: QuestionBodyState,
+  request: QuestionV2Request,
+  answer: string,
+  custom = false,
+): QuestionStep {
+  const answers = [...state.answers]
+  answers[state.tab] = [answer]
+  let next: QuestionBodyState = {
+    ...state,
+    answers,
+    editing: false,
+  }
+
+  if (custom) {
+    const list = [...state.custom]
+    list[state.tab] = answer
+    next = {
+      ...next,
+      custom: list,
+    }
+  }
+
+  if (questionSingle(request)) {
+    return {
+      state: next,
+      reply: {
+        requestID: request.id,
+        answers: [[answer]],
+      },
+    }
+  }
+
+  return {
+    state: questionSetTab(next, state.tab + 1),
+  }
+}
+
+function questionToggle(state: QuestionBodyState, answer: string): QuestionBodyState {
+  const list = [...(state.answers[state.tab] ?? [])]
+  const idx = list.indexOf(answer)
+  if (idx === -1) {
+    list.push(answer)
+  } else {
+    list.splice(idx, 1)
+  }
+
+  return storeAnswers(state, state.tab, list)
+}
+
+export function questionMove(state: QuestionBodyState, request: QuestionV2Request, dir: -1 | 1): QuestionBodyState {
+  const total = questionTotal(request, state)
+  if (total === 0) {
+    return state
+  }
+
+  return {
+    ...state,
+    selected: (state.selected + dir + total) % total,
+  }
+}
+
+export function questionSelect(state: QuestionBodyState, request: QuestionV2Request): QuestionStep {
+  const info = questionInfo(request, state)
+  if (!info) {
+    return { state }
+  }
+
+  if (questionOther(request, state)) {
+    if (!info.multiple) {
+      return {
+        state: questionSetEditing(state, true),
+      }
+    }
+
+    const value = questionInput(state)
+    if (value && questionPicked(state)) {
+      return {
+        state: questionToggle(state, value),
+      }
+    }
+
+    return {
+      state: questionSetEditing(state, true),
+    }
+  }
+
+  const option = info.options[state.selected]
+  if (!option) {
+    return { state }
+  }
+
+  if (info.multiple) {
+    return {
+      state: questionToggle(state, option.label),
+    }
+  }
+
+  return questionPick(state, request, option.label)
+}
+
+export function questionSave(state: QuestionBodyState, request: QuestionV2Request): QuestionStep {
+  const info = questionInfo(request, state)
+  if (!info) {
+    return { state }
+  }
+
+  const value = questionInput(state).trim()
+  const prev = state.custom[state.tab]
+  if (!value) {
+    if (!prev) {
+      return {
+        state: questionSetEditing(state, false),
+      }
+    }
+
+    const next = questionStoreCustom(state, state.tab, "")
+    return {
+      state: questionSetEditing(
+        storeAnswers(
+          next,
+          state.tab,
+          (state.answers[state.tab] ?? []).filter((item) => item !== prev),
+        ),
+        false,
+      ),
+    }
+  }
+
+  if (info.multiple) {
+    const answers = [...(state.answers[state.tab] ?? [])]
+    if (prev) {
+      const idx = answers.indexOf(prev)
+      if (idx !== -1) {
+        answers.splice(idx, 1)
+      }
+    }
+
+    if (!answers.includes(value)) {
+      answers.push(value)
+    }
+
+    const next = questionStoreCustom(state, state.tab, value)
+    return {
+      state: questionSetEditing(storeAnswers(next, state.tab, answers), false),
+    }
+  }
+
+  return questionPick(state, request, value, true)
+}
+
+export function questionSubmit(request: QuestionV2Request, state: QuestionBodyState): QuestionReply {
+  return {
+    requestID: request.id,
+    answers: questionAnswers(state, request.questions.length),
+  }
+}
+
+export function questionReject(request: QuestionV2Request): QuestionReject {
+  return {
+    requestID: request.id,
+  }
+}
+
+export function questionHint(request: QuestionV2Request, state: QuestionBodyState): string {
+  if (state.submitting) {
+    return "Waiting for question event..."
+  }
+
+  if (questionConfirm(request, state)) {
+    return "enter submit   esc dismiss"
+  }
+
+  if (state.editing) {
+    return "enter save   esc cancel"
+  }
+
+  const info = questionInfo(request, state)
+  if (questionSingle(request)) {
+    return `↑↓ select   enter ${info?.multiple ? "toggle" : "submit"}   esc dismiss`
+  }
+
+  return `⇆ tab   ↑↓ select   enter ${info?.multiple ? "toggle" : "confirm"}   esc dismiss`
+}

packages/cli/src/mini/run.ts

@@ -1,14 +1,15 @@
 import { Service, type Endpoint } from "@opencode-ai/client/effect/service"
-import { OpenCode, type OpenCodeClient, type SessionMessageAssistantTool } from "@opencode-ai/client/promise"
+import { OpenCode, type OpenCodeClient } from "@opencode-ai/client/promise"
 import { FSUtil } from "@opencode-ai/core/fs-util"
+import { Model } from "@opencode-ai/schema/model"
 import { open } from "node:fs/promises"
 import path from "node:path"
 import { readStdin } from "../util/io"
 import { ServerConnection } from "../services/server-connection"
-import { waitForCatalogReady } from "../services/catalog"
-import { parseSessionTargetModel, resolveSessionTarget } from "../session-target"
-import { toolInlineInfo } from "@opencode-ai/tui/mini/tool"
+import { loadRunAgents, waitForCatalogReady } from "./catalog.shared"
 import { runNonInteractivePrompt } from "./noninteractive"
+import { toolInlineInfo } from "./tool"
+import type { MiniToolPart } from "./types"
 import { UI } from "./ui"
 
 export type RunCommandInput = {
@@ -38,127 +39,78 @@ type Prepared = {
   files: FilePart[]
 }
 
-type ExecutionOptions = {
-  root?: string
-  directory?: string
-  useServerDirectory?: boolean
-  variant?: string
-  attached?: boolean
-  compatibility?: "v1"
-}
-
-class RunTargetError extends Error {
-  constructor(
-    message: string,
-    readonly sessionID?: string,
-  ) {
-    super(message)
-  }
-}
-
 const ATTACH_FILE_MAX_BYTES = 10 * 1024 * 1024
 
 export function runNonInteractive(input: RunCommandInput) {
-  return runNonInteractiveWithOptions(input, {})
+  return run(input).catch((error) => reportError(input, error instanceof Error ? error.message : String(error)))
 }
 
-/** @internal Used only by the V1 command boundary. */
-export function runNonInteractiveWithOptions(input: RunCommandInput, options: ExecutionOptions) {
-  return run(input, options).catch((error) => reportRunError(input, errorMessage(error)))
-}
-
-async function run(input: RunCommandInput, options: ExecutionOptions) {
+async function run(input: RunCommandInput) {
   if (input.fork && !input.continue && !input.session) fail("--fork requires --continue or --session")
-  const root = options.root ?? process.env.PWD ?? process.cwd()
-  const local = localDirectory(root)
-  const directory = options.useServerDirectory ? undefined : (options.directory ?? local)
+  const root = process.env.PWD ?? process.cwd()
+  const directory = localDirectory(root)
   const message = mergeInput(formatMessage(input.message), process.stdin.isTTY ? undefined : await readStdin())
   if (!message?.trim()) fail("You must provide a message")
-  const files = await Promise.all(input.file.map((file) => prepareFile(file, root, options)))
+  const files = await Promise.all(input.file.map((file) => prepareFile(file, root)))
   const prepared = { directory, message, files }
-  return execute(input, prepared, input.server.endpoint, options)
+  return execute(input, prepared, input.server.endpoint)
 }
 
-async function execute(input: RunCommandInput, prepared: Prepared, endpoint: Endpoint, options: ExecutionOptions) {
+async function execute(input: RunCommandInput, prepared: Prepared, endpoint: Endpoint) {
   const client = OpenCode.make({ baseUrl: endpoint.url, headers: Service.headers(endpoint) })
+  const requestedDirectory = prepared.directory ?? (await client.location.get()).directory
+  if (!requestedDirectory) fail("Failed to resolve server directory")
+  const session = await selectSession(client, requestedDirectory, input)
+  const cwd = session?.location.directory ?? requestedDirectory
+  const workspace = session?.location.workspaceID
   const explicit = parseRunModel(input.model)
-  const target = await resolveSessionTarget({
-    client,
-    location: prepared.directory ? { directory: prepared.directory } : undefined,
-    continue: input.continue,
-    session: input.session,
-    fork: input.fork,
-    model: explicit
-      ? { providerID: explicit.model.providerID, id: explicit.model.modelID, variant: explicit.variant }
-      : undefined,
-    agent: input.agent,
-    prepare: async (next) => {
-      const selected =
-        next.model ??
-        (await client.model
-          .default({ location: { directory: next.location.directory, workspace: next.location.workspaceID } })
-          .then((result) => result.data))
-      const model = selected
-        ? {
-            providerID: selected.providerID,
-            id: selected.id,
-            variant: options.variant ?? ("variant" in selected ? selected.variant : undefined),
-          }
-        : undefined
-      if ((options.variant ?? explicit?.variant) && !model)
-        throw new RunTargetError("Cannot select a variant before selecting a model", next.session?.id)
-      if (model) {
-        await waitForCatalogReady({
-          sdk: client,
-          directory: next.location.directory,
-          workspace: next.location.workspaceID,
-          model: { providerID: model.providerID, modelID: model.id },
-        })
-        const available = await client.model.list({
-          location: { directory: next.location.directory, workspace: next.location.workspaceID },
-        })
-        if (!available.data.some((item) => item.providerID === model.providerID && item.id === model.id))
-          throw new RunTargetError(`Model unavailable: ${model.providerID}/${model.id}`, next.session?.id)
-      }
-      return {
-        model,
-        agent: input.agent
-          ? await validateAgent(client, next.location.directory, next.location.workspaceID, input.agent)
-          : next.agent,
-      }
-    },
-  }).catch((error) => {
-    if (!(error instanceof RunTargetError)) throw error
-    reportRunError(input, error.message, error.sessionID)
-    return undefined
-  })
-  if (!target) return
-  const model = target.model ? { providerID: target.model.providerID, modelID: target.model.id } : undefined
-  const variant = target.model?.variant
-  if (!target.resume && input.title !== undefined) {
+  const explicitModel = explicit?.model
+  const variant = explicit?.variant
+  const sessionModel = session?.model ? { providerID: session.model.providerID, modelID: session.model.id } : undefined
+  const defaultModel =
+    !explicitModel && !sessionModel
+      ? await client.model
+          .default({ location: { directory: cwd, workspace } })
+          .then((result) => (result.data ? { providerID: result.data.providerID, modelID: result.data.id } : undefined))
+      : undefined
+  const model = pickRunModel(explicitModel, variant, sessionModel, defaultModel)
+  if (variant && !model) return reportError(input, "Cannot select a variant before selecting a model", session?.id)
+  if (model) {
+    await waitForCatalogReady({ sdk: client, directory: cwd, workspace, model })
+    const available = await client.model.list({ location: { directory: cwd, workspace } })
+    if (!available.data.some((item) => item.providerID === model.providerID && item.id === model.modelID))
+      return reportError(input, `Model unavailable: ${model.providerID}/${model.modelID}`, session?.id)
+  }
+  const agent = await validateAgent(client, cwd, input.agent)
+  const selected =
+    session ??
+    (await client.session.create({
+      agent,
+      model: model ? { providerID: model.providerID, id: model.modelID, variant } : undefined,
+      location: { directory: cwd },
+    }))
+  if (!session && input.title !== undefined) {
     await client.session.rename({
-      sessionID: target.session.id,
+      sessionID: selected.id,
       title: input.title || prepared.message.slice(0, 50) + (prepared.message.length > 50 ? "..." : ""),
     })
   }
 
   await runNonInteractivePrompt({
     client,
-    sessionID: target.session.id,
-    location: target.location,
+    sessionID: selected.id,
     message: prepared.message,
     files: prepared.files,
-    agent: target.agent,
+    agent,
     model,
     variant,
     thinking: input.thinking ?? false,
     format: input.format,
     auto: input.auto ?? false,
-    attached: options.attached ?? true,
-    compatibility: options.compatibility,
-    renderTool: (part) => renderTool(part, target.location.directory),
-    renderToolError: (part) => renderToolError(part, target.location.directory),
-  }).catch((error) => reportRunError(input, errorMessage(error), target.session.id))
+    attached: true,
+    renderTool,
+    renderToolError,
+  }).catch((error) => reportError(input, error instanceof Error ? error.message : String(error), selected.id))
 }
 
 export function mergeInput(message: string | undefined, piped: string | undefined) {
@@ -167,6 +119,17 @@ export function mergeInput(message: string | undefined, piped: string | undefine
   return message + "\n" + piped
 }
 
+export function pickRunModel(
+  explicit: { providerID: string; modelID: string } | undefined,
+  variant: string | undefined,
+  session: { providerID: string; modelID: string } | undefined,
+  fallback: { providerID: string; modelID: string } | undefined,
+) {
+  if (explicit) return explicit
+  if (!variant) return
+  return session ?? fallback
+}
+
 function formatMessage(message: string[]) {
   const value = message.map((part) => (part.includes(" ") ? `"${part.replace(/"/g, '\\"')}"` : part)).join(" ")
   return value || undefined
@@ -182,20 +145,17 @@ function localDirectory(root: string) {
 }
 
 export function parseRunModel(value?: string) {
-  const ref = parseSessionTargetModel(value)
-  if (!ref) return
+  if (!value) return
+  const ref = Model.Ref.parse(value)
   return {
     model: { providerID: ref.providerID, modelID: ref.id },
     variant: ref.variant,
   }
 }
 
-async function validateAgent(client: OpenCodeClient, directory: string, workspace: string | undefined, name?: string) {
+async function validateAgent(client: OpenCodeClient, directory: string, name?: string) {
   if (!name) return
-  const agents = await client.agent
-    .list({ location: { directory, workspace } })
-    .then((result) => result.data)
-    .catch(() => undefined)
+  const agents = await loadRunAgents(client, directory).catch(() => undefined)
   if (!agents) {
     warning("failed to list agents. Falling back to default agent")
     return
@@ -212,13 +172,24 @@ async function validateAgent(client: OpenCodeClient, directory: string, workspac
   return name
 }
 
-async function prepareFile(input: string, directory: string, options: ExecutionOptions): Promise<FilePart> {
+async function selectSession(client: OpenCodeClient, directory: string, input: RunCommandInput) {
+  const selected = input.session
+    ? await client.session.get({ sessionID: input.session }).catch(() => undefined)
+    : input.continue
+      ? await client.session
+          .list({ directory, parentID: null, limit: 1, order: "desc" })
+          .then((result) => result.data[0])
+      : undefined
+  if (input.session && !selected) fail("Session not found")
+  if (!selected || !input.fork) return selected
+  return client.session.fork({ sessionID: selected.id })
+}
+
+async function prepareFile(input: string, directory: string): Promise<FilePart> {
   const file = path.resolve(directory, input)
   const handle = await open(file, "r").catch(() => fail(`File not found: ${input}`))
   try {
     const stat = await handle.stat()
-    if (options.compatibility === "v1" && options.attached && stat.isDirectory())
-      fail(`Cannot attach local directory without a shared filesystem: ${input}`)
     if (!stat.isFile() || stat.size > ATTACH_FILE_MAX_BYTES)
       fail(`Cannot attach a directory, special file, or file larger than 10 MiB: ${input}`)
     const content = Buffer.alloc(Number(stat.size))
@@ -253,8 +224,8 @@ function isBinaryContent(bytes: Uint8Array) {
   return bytes.reduce((count, byte) => count + Number(byte < 9 || (byte > 13 && byte < 32)), 0) / bytes.length > 0.3
 }
 
-async function renderTool(part: SessionMessageAssistantTool, directory: string) {
-  const info = toolInlineInfo(part, directory)
+async function renderTool(part: MiniToolPart) {
+  const info = toolInlineInfo(part)
   if (info.mode === "block") {
     UI.empty()
     UI.println(UI.Style.TEXT_NORMAL + info.icon, UI.Style.TEXT_NORMAL + info.title)
@@ -269,8 +240,8 @@ async function renderTool(part: SessionMessageAssistantTool, directory: string)
   )
 }
 
-async function renderToolError(part: SessionMessageAssistantTool, directory: string) {
-  const info = toolInlineInfo(part, directory)
+async function renderToolError(part: MiniToolPart) {
+  const info = toolInlineInfo(part)
   UI.println(UI.Style.TEXT_NORMAL + "✗", UI.Style.TEXT_NORMAL + `${info.title} failed`)
 }
 
@@ -278,15 +249,7 @@ function warning(message: string) {
   UI.println(UI.Style.TEXT_WARNING_BOLD + "!", UI.Style.TEXT_NORMAL, message)
 }
 
-function errorMessage(error: unknown) {
-  if (error instanceof Error) return error.message
-  if (typeof error === "object" && error !== null && "message" in error && typeof error.message === "string")
-    return error.message
-  return String(error)
-}
-
-/** @internal Used by the V1 command boundary before a Session exists. */
-export function reportRunError(input: Pick<RunCommandInput, "format">, message: string, sessionID?: string) {
+function reportError(input: RunCommandInput, message: string, sessionID?: string) {
   process.exitCode = 1
   if (input.format === "json") {
     process.stdout.write(

packages/cli/src/mini/runtime.boot.ts

@@ -0,0 +1,166 @@
+// Boot-time resolution for direct interactive mode.
+//
+// These functions run concurrently at startup to gather everything the runtime
+// needs before the first frame: TUI keymap config, diff display style,
+// model variant list with context limits, and session history for the prompt
+// history ring. All are async because they read config or hit the SDK, but
+// none block each other.
+import { Context, Effect, Layer } from "effect"
+import { resolve } from "@opencode-ai/tui/config/v1"
+import { makeGlobalNode } from "@opencode-ai/core/effect/app-node"
+import { LayerNode } from "@opencode-ai/core/effect/layer-node"
+import { makeRuntime } from "@opencode-ai/core/effect/runtime"
+import { loadRunProviders } from "./catalog.shared"
+import { resolveCurrentSession, sessionHistory } from "./session.shared"
+import type { RunDiffStyle, RunInput, RunPrompt, RunProvider, RunTuiConfig } from "./types"
+import { pickVariant } from "./variant.shared"
+
+export type ModelInfo = {
+  providers: RunProvider[]
+  variants: string[]
+  limits: Record<string, number>
+}
+
+export type SessionInfo = {
+  first: boolean
+  history: RunPrompt[]
+  model?: NonNullable<RunInput["model"]>
+  variant: string | undefined
+}
+
+type BootService = {
+  readonly resolveModelInfo: (
+    sdk: RunInput["sdk"],
+    directory: string,
+    model: RunInput["model"],
+  ) => Effect.Effect<ModelInfo>
+  readonly resolveSessionInfo: (
+    sdk: RunInput["sdk"],
+    sessionID: string,
+    model: RunInput["model"],
+  ) => Effect.Effect<SessionInfo>
+}
+
+class Service extends Context.Service<Service, BootService>()("@opencode/RunBoot") {}
+
+function emptyModelInfo(): ModelInfo {
+  return {
+    providers: [],
+    variants: [],
+    limits: {},
+  }
+}
+
+function emptySessionInfo(): SessionInfo {
+  return {
+    first: true,
+    history: [],
+    variant: undefined,
+  }
+}
+
+function defaultRunTuiConfig(): RunTuiConfig {
+  return {
+    ...resolve({}, { terminalSuspend: process.platform !== "win32" }),
+    diff_style: "auto",
+  }
+}
+
+const layer = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    const resolveModelInfo = Effect.fn("RunBoot.resolveModelInfo")(function* (
+      sdk: RunInput["sdk"],
+      directory: string,
+      model: RunInput["model"],
+    ) {
+      const providers = yield* Effect.promise(() => loadRunProviders(sdk, directory))
+      const limits = Object.fromEntries(
+        providers.flatMap((provider) =>
+          Object.entries(provider.models ?? {}).flatMap(([modelID, info]) => {
+            const limit = info?.limit?.context
+            if (typeof limit !== "number" || limit <= 0) {
+              return []
+            }
+
+            return [[`${provider.id}/${modelID}`, limit] as const]
+          }),
+        ),
+      )
+
+      if (!model) {
+        return {
+          providers,
+          variants: [],
+          limits,
+        }
+      }
+
+      const info = providers.find((item) => item.id === model.providerID)?.models?.[model.modelID]
+      return {
+        providers,
+        variants: Object.keys(info?.variants ?? {}),
+        limits,
+      }
+    })
+
+    const resolveSessionInfo = Effect.fn("RunBoot.resolveSessionInfo")(function* (
+      sdk: RunInput["sdk"],
+      sessionID: string,
+      model: RunInput["model"],
+    ) {
+      const session = yield* Effect.promise(() => resolveCurrentSession(sdk, sessionID).catch(() => undefined))
+      if (!session) {
+        return emptySessionInfo()
+      }
+
+      return {
+        first: session.first,
+        history: sessionHistory(session),
+        model: session.model,
+        variant: pickVariant(model ?? session.model, session),
+      }
+    })
+
+    return Service.of({
+      resolveModelInfo,
+      resolveSessionInfo,
+    })
+  }),
+)
+
+const node = makeGlobalNode({ service: Service, layer, deps: [] })
+const runtime = makeRuntime(Service, LayerNode.compile(node))
+
+// Fetches available variants and context limits for every provider/model pair.
+export async function resolveModelInfo(
+  sdk: RunInput["sdk"],
+  directory: string,
+  model: RunInput["model"],
+): Promise<ModelInfo> {
+  return runtime.runPromise((svc) => svc.resolveModelInfo(sdk, directory, model)).catch(() => emptyModelInfo())
+}
+
+export function resolveModelInfoStrict(sdk: RunInput["sdk"], directory: string, model: RunInput["model"]) {
+  return runtime.runPromise((svc) => svc.resolveModelInfo(sdk, directory, model))
+}
+
+// Fetches session messages to determine if this is the first turn and build prompt history.
+export async function resolveSessionInfo(
+  sdk: RunInput["sdk"],
+  sessionID: string,
+  model: RunInput["model"],
+): Promise<SessionInfo> {
+  return runtime.runPromise((svc) => svc.resolveSessionInfo(sdk, sessionID, model)).catch(() => emptySessionInfo())
+}
+
+// Reads TUI config once for direct mode keymap setup and display preferences.
+export async function resolveRunTuiConfig(
+  config?: RunTuiConfig | Promise<RunTuiConfig>,
+): Promise<RunTuiConfig> {
+  return Promise.resolve(config).then((value) => value ?? defaultRunTuiConfig()).catch(() => defaultRunTuiConfig())
+}
+
+export async function resolveDiffStyle(config?: RunTuiConfig | Promise<RunTuiConfig>): Promise<RunDiffStyle> {
+  return resolveRunTuiConfig(config).then((value) => value.diff_style ?? "auto")
+}

packages/cli/src/mini/runtime.lifecycle.ts

@@ -0,0 +1,389 @@
+// Lifecycle management for the split-footer renderer.
+//
+// Creates the OpenTUI CliRenderer in split-footer mode, resolves the theme
+// from the terminal palette, writes the entry splash to scrollback, and
+// constructs the RunFooter. Returns a Lifecycle handle whose close() writes
+// the exit splash and tears everything down in the right order:
+// footer.close → footer.destroy → renderer shutdown.
+//
+// Also wires SIGINT so Ctrl-c clears a live prompt draft first, then falls
+// back to the usual two-press exit sequence through RunFooter.requestExit().
+import path from "path"
+import { CliRenderEvents, createCliRenderer, type CliRenderer, type ScrollbackWriter } from "@opentui/core"
+import { Global } from "@opencode-ai/core/global"
+import { isDefaultTitle } from "@opencode-ai/tui/util/session"
+import { Locale } from "@opencode-ai/tui/util/locale"
+import { resolveInteractiveStdin } from "./runtime.stdin"
+import { entrySplash, exitSplash, splashMeta } from "./splash"
+import { resolveRunTheme } from "./theme"
+import type {
+  FooterApi,
+  PermissionReply,
+  QuestionReject,
+  QuestionReply,
+  RunAgent,
+  RunInput,
+  RunPrompt,
+  RunReference,
+  RunTuiConfig,
+} from "./types"
+import { formatModelLabel } from "./variant.shared"
+
+const FOOTER_HEIGHT = 4
+
+type SplashState = {
+  entry: boolean
+  exit: boolean
+}
+
+type CycleResult = {
+  modelLabel?: string
+  status?: string
+  variant?: string | undefined
+  variants?: string[]
+}
+
+type FooterLabels = {
+  agentLabel: string
+  modelLabel: string
+}
+
+export type LifecycleInput = {
+  directory: string
+  findFiles: (query: string) => Promise<string[]>
+  agents: RunAgent[]
+  references: RunReference[]
+  sessionID: string
+  sessionTitle?: string
+  getSessionID?: () => string | undefined
+  first: boolean
+  history: RunPrompt[]
+  agent: string | undefined
+  model: RunInput["model"]
+  variant: string | undefined
+  tuiConfig: RunTuiConfig | Promise<RunTuiConfig>
+  onPermissionReply: (input: PermissionReply) => void | Promise<void>
+  onQuestionReply: (input: QuestionReply) => void | Promise<void>
+  onQuestionReject: (input: QuestionReject) => void | Promise<void>
+  onCycleVariant?: () => CycleResult | void
+  onModelSelect?: (model: NonNullable<RunInput["model"]>) => CycleResult | void | Promise<CycleResult | void>
+  onVariantSelect?: (variant: string | undefined) => CycleResult | void | Promise<CycleResult | void>
+  onInterrupt?: () => void
+  onBackground?: () => void
+  onSubagentSelect?: (sessionID: string | undefined) => void
+  onSubagentInterrupt?: (sessionID: string) => void
+}
+
+export type Lifecycle = {
+  footer: FooterApi
+  onResize(fn: () => void): () => void
+  refreshTheme(): void
+  resetForReplay(input: { sessionTitle?: string; sessionID?: string; history: RunPrompt[] }): Promise<void>
+  close(input: { showExit: boolean; sessionTitle?: string; sessionID?: string; history?: RunPrompt[] }): Promise<void>
+}
+
+// Gracefully tears down the renderer. Order matters: switch external output
+// back to passthrough before leaving split-footer mode, so pending stdout
+// doesn't get captured into the now-dead scrollback pipeline.
+function shutdown(renderer: CliRenderer): void {
+  if (renderer.isDestroyed) {
+    return
+  }
+
+  if (renderer.externalOutputMode === "capture-stdout") {
+    renderer.externalOutputMode = "passthrough"
+  }
+
+  if (renderer.screenMode === "split-footer") {
+    renderer.screenMode = "main-screen"
+  }
+
+  if (!renderer.isDestroyed) {
+    renderer.destroy()
+  }
+}
+
+function splashInfo(title: string | undefined, history: RunPrompt[]) {
+  if (title && !isDefaultTitle(title)) {
+    return {
+      title,
+      showSession: true,
+    }
+  }
+
+  const next = history.find((item) => item.text.trim().length > 0)
+  return {
+    title: next?.text ?? title,
+    showSession: !!next,
+  }
+}
+
+function footerLabels(input: Pick<RunInput, "agent" | "model" | "variant">): FooterLabels {
+  const agentLabel = Locale.titlecase(input.agent ?? "build")
+  return {
+    agentLabel,
+    modelLabel: input.model ? formatModelLabel(input.model, input.variant) : "",
+  }
+}
+
+function directoryLabel(directory: string) {
+  const resolved = path.resolve(directory)
+  const display =
+    resolved === Global.Path.home
+      ? "~"
+      : resolved.startsWith(`${Global.Path.home}${path.sep}`)
+        ? resolved.replace(Global.Path.home, "~")
+        : resolved
+  return display.replaceAll("\\", "/")
+}
+
+function queueSplash(
+  renderer: Pick<CliRenderer, "writeToScrollback" | "requestRender">,
+  state: SplashState,
+  phase: keyof SplashState,
+  write: ScrollbackWriter | undefined,
+): boolean {
+  if (state[phase]) {
+    return false
+  }
+
+  if (!write) {
+    return false
+  }
+
+  state[phase] = true
+  renderer.writeToScrollback(write)
+  renderer.requestRender()
+  return true
+}
+
+// Boots the split-footer renderer and constructs the RunFooter.
+//
+// The renderer starts in split-footer mode with captured stdout so that
+// scrollback commits and footer repaints happen in the same frame. After
+// the entry splash, RunFooter takes over the footer region.
+export async function createRuntimeLifecycle(input: LifecycleInput): Promise<Lifecycle> {
+  const source = resolveInteractiveStdin()
+  const footerTask = import("./footer")
+  try {
+    const renderer = await createCliRenderer({
+      stdin: source.stdin,
+      targetFps: 30,
+      maxFps: 60,
+      useMouse: false,
+      autoFocus: false,
+      openConsoleOnError: false,
+      exitOnCtrlC: false,
+      useKittyKeyboard: { events: process.platform === "win32" },
+      screenMode: "split-footer",
+      footerHeight: FOOTER_HEIGHT,
+      externalOutputMode: "capture-stdout",
+      consoleMode: "disabled",
+      clearOnShutdown: false,
+    })
+    const [theme, tuiConfig] = await Promise.all([resolveRunTheme(renderer), input.tuiConfig])
+    renderer.setBackgroundColor(theme.background)
+    const state: SplashState = {
+      entry: false,
+      exit: false,
+    }
+    const splash = splashInfo(input.sessionTitle, input.history)
+    const meta = splashMeta({
+      title: splash.title,
+      session_id: input.sessionID,
+    })
+    const labels = footerLabels({
+      agent: input.agent,
+      model: input.model,
+      variant: input.variant,
+    })
+    const wrote = queueSplash(
+      renderer,
+      state,
+      "entry",
+      entrySplash({
+        ...meta,
+        theme: theme.splash,
+        showSession: splash.showSession,
+        detail: directoryLabel(input.directory),
+      }),
+    )
+    await renderer.idle().catch(() => {})
+
+    const { RunFooter } = await footerTask
+    let closed = false
+    let sigintRegistered = false
+
+    const footer = new RunFooter(renderer, {
+      directory: input.directory,
+      findFiles: input.findFiles,
+      agents: input.agents,
+      references: input.references,
+      sessionID: input.getSessionID ?? (() => input.sessionID),
+      ...labels,
+      model: input.model,
+      variant: input.variant,
+      first: input.first,
+      history: input.history,
+      theme,
+      wrote,
+      tuiConfig,
+      diffStyle: tuiConfig.diff_style ?? "auto",
+      onPermissionReply: input.onPermissionReply,
+      onQuestionReply: input.onQuestionReply,
+      onQuestionReject: input.onQuestionReject,
+      onCycleVariant: input.onCycleVariant,
+      onModelSelect: input.onModelSelect,
+      onVariantSelect: input.onVariantSelect,
+      onInterrupt: input.onInterrupt,
+      onBackground: input.onBackground,
+      onEditorOpen: async ({ value }) => {
+        if (closed || renderer.isDestroyed) {
+          return
+        }
+
+        const { openEditor } = await import("@opencode-ai/tui/editor")
+        await renderer.idle().catch(() => {})
+        const ignore = () => {}
+        detachSigint()
+        process.on("SIGINT", ignore)
+        try {
+          return await openEditor({
+            value,
+            cwd: input.directory,
+            renderer,
+            stdin: source.stdin,
+          })
+        } finally {
+          process.off("SIGINT", ignore)
+          attachSigint()
+        }
+      },
+      onSubagentSelect: input.onSubagentSelect,
+      onSubagentInterrupt: input.onSubagentInterrupt,
+    })
+
+    const sigint = () => {
+      footer.requestExit()
+    }
+
+    const attachSigint = () => {
+      if (closed || sigintRegistered) {
+        return
+      }
+
+      process.on("SIGINT", sigint)
+      sigintRegistered = true
+    }
+
+    const detachSigint = () => {
+      if (!sigintRegistered) {
+        return
+      }
+
+      process.off("SIGINT", sigint)
+      sigintRegistered = false
+    }
+
+    attachSigint()
+
+    const close = async (next: {
+      showExit: boolean
+      sessionTitle?: string
+      sessionID?: string
+      history?: RunPrompt[]
+    }) => {
+      if (closed) {
+        return
+      }
+
+      closed = true
+      detachSigint()
+      let wroteExit = false
+
+      try {
+        await footer.idle().catch(() => {})
+
+        const show = renderer.isDestroyed ? false : next.showExit
+        if (!renderer.isDestroyed && show) {
+          const sessionID = next.sessionID || input.getSessionID?.() || input.sessionID
+          const splash = splashInfo(next.sessionTitle ?? input.sessionTitle, next.history ?? input.history)
+          wroteExit = queueSplash(
+            renderer,
+            state,
+            "exit",
+            exitSplash({
+              ...splashMeta({
+                title: splash.title,
+                session_id: sessionID,
+              }),
+              theme: footer.currentTheme().splash,
+            }),
+          )
+          await renderer.idle().catch(() => {})
+        }
+      } finally {
+        footer.close()
+        await footer.idle().catch(() => {})
+        footer.destroy()
+        shutdown(renderer)
+        if (!wroteExit) {
+          process.stdout.write("\n")
+        }
+        source.cleanup?.()
+      }
+    }
+
+    return {
+      footer,
+      refreshTheme() {
+        footer.refreshTheme()
+      },
+      onResize(fn) {
+        let width = renderer.terminalWidth
+        let height = renderer.terminalHeight
+        const resize = () => {
+          if (width === renderer.terminalWidth && height === renderer.terminalHeight) {
+            return
+          }
+
+          width = renderer.terminalWidth
+          height = renderer.terminalHeight
+          fn()
+        }
+        renderer.on(CliRenderEvents.RESIZE, resize)
+        return () => renderer.off(CliRenderEvents.RESIZE, resize)
+      },
+      async resetForReplay(next) {
+        if (closed || renderer.isDestroyed || footer.isClosed) {
+          throw new Error("runtime closed")
+        }
+
+        await footer.idle()
+        if (closed || renderer.isDestroyed || footer.isClosed) {
+          throw new Error("runtime closed")
+        }
+
+        footer.resetForReplay(true)
+        renderer.resetSplitFooterForReplay({ clearSavedLines: true })
+        const splash = splashInfo(next.sessionTitle ?? input.sessionTitle, next.history)
+        renderer.writeToScrollback(
+          entrySplash({
+            ...splashMeta({
+              title: splash.title,
+              session_id: next.sessionID ?? input.getSessionID?.() ?? input.sessionID,
+            }),
+            theme: footer.currentTheme().splash,
+            showSession: splash.showSession,
+            detail: directoryLabel(input.directory),
+          }),
+        )
+        renderer.requestRender()
+      },
+      close,
+    }
+  } catch (error) {
+    source.cleanup?.()
+    throw error
+  }
+}

packages/cli/src/mini/runtime.queue.ts

@@ -8,8 +8,9 @@
 // and tracks per-turn wall-clock duration for the footer status line.
 //
 // Resolves when the footer closes and all in-flight work finishes.
+import { ascending } from "@opencode-ai/schema/identifier"
 import { SessionMessage } from "@opencode-ai/schema/session-message"
-import { Locale } from "../util/locale"
+import { Locale } from "@opencode-ai/tui/util/locale"
 import { isExitCommand, isNewCommand } from "./prompt.shared"
 import type { FooterApi, FooterEvent, FooterQueuedPrompt, RunPrompt } from "./types"
 
@@ -286,6 +287,7 @@ export async function runPromptQueue(input: QueueInput): Promise<void> {
     ) {
       const queued: FooterQueuedPrompt = {
         messageID: SessionMessage.ID.create(),
+        partID: "prt_" + ascending(),
         prompt,
       }
       state.queued = [...state.queued, queued]

packages/cli/src/mini/runtime.shared.ts

@@ -0,0 +1,17 @@
+type PendingTask<T> = {
+  current?: Promise<T>
+}
+
+export function reusePendingTask<T>(slot: PendingTask<T>, run: () => Promise<T>) {
+  if (slot.current) {
+    return slot.current
+  }
+
+  const task = run().finally(() => {
+    if (slot.current === task) {
+      slot.current = undefined
+    }
+  })
+  slot.current = task
+  return task
+}

packages/cli/src/mini/runtime.stdin.ts

@@ -0,0 +1,37 @@
+import fs from "fs"
+import * as tty from "node:tty"
+
+export const INTERACTIVE_INPUT_ERROR = "opencode mini requires a controlling terminal for input"
+
+type InteractiveStdin = {
+  stdin: NodeJS.ReadStream
+  cleanup?: () => void
+}
+
+function openTerminalStdin(path: string): NodeJS.ReadStream {
+  return new tty.ReadStream(fs.openSync(path, "r"))
+}
+
+export function resolveInteractiveStdin(
+  stdin: NodeJS.ReadStream = process.stdin,
+  open: (path: string) => NodeJS.ReadStream = openTerminalStdin,
+  platform = process.platform,
+): InteractiveStdin {
+  if (stdin.isTTY) {
+    return { stdin }
+  }
+
+  const file = platform === "win32" ? "CONIN$" : "/dev/tty"
+
+  try {
+    const stream = open(file)
+    return {
+      stdin: stream,
+      cleanup: () => {
+        stream.destroy()
+      },
+    }
+  } catch (error) {
+    throw new Error(INTERACTIVE_INPUT_ERROR, { cause: error })
+  }
+}

packages/cli/src/mini/scrollback.shared.ts

@@ -10,7 +10,7 @@ export function entrySyntax(theme: RunTheme): SyntaxStyle {
   return syntax(theme.block.syntax)
 }
 
-function entryFailed(commit: StreamCommit): boolean {
+export function entryFailed(commit: StreamCommit): boolean {
   return commit.kind === "tool" && (commit.toolState === "error" || commit.part?.state.status === "error")
 }
 

packages/cli/src/mini/scrollback.surface.ts

@@ -18,7 +18,7 @@ import { entryColor, entryLook, entrySyntax } from "./scrollback.shared"
 import { turnSummaryCommit } from "./turn-summary"
 import { entryWriter, sameEntryGroup, separatorRows, spacerWriter, turnSummaryWriter } from "./scrollback.writer"
 import { type RunTheme } from "./theme"
-import type { RunEntryBody, StreamCommit } from "./types"
+import type { RunDiffStyle, RunEntryBody, StreamCommit } from "./types"
 
 type ActiveBody = Exclude<RunEntryBody, { type: "none" | "structured" }>
 
@@ -86,6 +86,8 @@ export class RunScrollbackStream {
   private tail: StreamCommit | undefined
   private rendered: StreamCommit | undefined
   private active: ActiveEntry | undefined
+  private diffStyle: RunDiffStyle | undefined
+  private sessionID?: () => string | undefined
   private treeSitterClient: TreeSitterClient | undefined
   private wrote: boolean
   private pendingThemes: RunTheme[] = []
@@ -95,10 +97,14 @@ export class RunScrollbackStream {
     private theme: RunTheme,
     options: {
       wrote?: boolean
+      diffStyle?: RunDiffStyle
+      sessionID?: () => string | undefined
       treeSitterClient?: TreeSitterClient
       onThemeRelease?: (theme: RunTheme) => void
     } = {},
   ) {
+    this.diffStyle = options.diffStyle
+    this.sessionID = options.sessionID
     this.treeSitterClient = options.treeSitterClient
     this.wrote = options.wrote ?? false
     this.onThemeRelease = options.onThemeRelease
@@ -389,6 +395,9 @@ export class RunScrollbackStream {
         commit,
         body: staticBody(commit, body, spaced),
         theme: this.theme,
+        opts: {
+          diffStyle: this.diffStyle,
+        },
       }),
     )
     this.markRendered(commit)

packages/cli/src/mini/scrollback.writer.tsx

@@ -12,12 +12,11 @@ export function entryGroupKey(commit: StreamCommit): string | undefined {
     return undefined
   }
 
-  const part = `${commit.messageID ?? ""}\u0000${commit.partID}`
   if (toolStructuredFinal(commit)) {
-    return `tool:${part}:final`
+    return `tool:${commit.partID}:final`
   }
 
-  return `${commit.kind}:${part}`
+  return `${commit.kind}:${commit.partID}`
 }
 
 export function sameEntryGroup(left: StreamCommit | undefined, right: StreamCommit): boolean {
@@ -48,6 +47,14 @@ export function entryLayout(commit: StreamCommit, body: RunEntryBody = entryBody
     return "inline"
   }
 
+  if (commit.kind === "reasoning") {
+    return "block"
+  }
+
+  if (commit.kind === "error") {
+    return "block"
+  }
+
   return "block"
 }
 
@@ -72,6 +79,7 @@ export function RunEntryContent(props: {
   body?: RunEntryBody
   theme?: RunTheme
   opts?: ScrollbackOptions
+  width?: number
 }) {
   const theme = createMemo(() => props.theme ?? RUN_THEME_FALLBACK)
   const body = createMemo(() => props.body ?? entryBody(props.commit))
@@ -255,12 +263,13 @@ export function entryWriter(input: {
   opts?: ScrollbackOptions
 }): ScrollbackWriter {
   return createScrollbackWriter(
-    () => (
+    (ctx) => (
       <RunEntryContent
         commit={input.commit}
         body={input.body}
         theme={input.theme}
         opts={{ ...input.opts, suppressBackgrounds: true }}
+        width={ctx.width}
       />
     ),
     entryFlags(input.commit),

packages/cli/src/mini/session-data.ts

@@ -0,0 +1,17 @@
+import type { PermissionV2Request, QuestionV2Request } from "@opencode-ai/client/promise"
+import type { FooterView } from "./types"
+
+export function pickBlockerView(input: {
+  permission?: PermissionV2Request
+  question?: QuestionV2Request
+}): FooterView {
+  if (input.permission) return { type: "permission", request: input.permission }
+  if (input.question) return { type: "question", request: input.question }
+  return { type: "prompt" }
+}
+
+export function blockerStatus(view: FooterView) {
+  if (view.type === "permission") return "awaiting permission"
+  if (view.type === "question") return "awaiting answer"
+  return ""
+}

packages/cli/src/mini/session.shared.ts

@@ -62,12 +62,11 @@ export function createSession(messages: SessionMessages): RunSession {
 export async function resolveCurrentSession(
   sdk: RunInput["sdk"],
   sessionID: string,
-  signal?: AbortSignal,
   limit = LIMIT,
 ): Promise<RunSession> {
   const [response, session] = await Promise.all([
-    sdk.message.list({ sessionID, limit, order: "desc" }, ...requestOptions(signal)),
-    sdk.session.get({ sessionID }, ...requestOptions(signal)),
+    sdk.message.list({ sessionID, limit, order: "desc" }),
+    sdk.session.get({ sessionID }),
   ])
   const current = createSession(response.data.toReversed())
   return {
@@ -85,10 +84,6 @@ export async function resolveCurrentSession(
   }
 }
 
-function requestOptions(signal?: AbortSignal): [] | [{ signal: AbortSignal }] {
-  return signal ? [{ signal }] : []
-}
-
 export function sessionHistory(session: RunSession, limit = LIMIT): RunPrompt[] {
   return session.turns
     .map((turn) => turn.prompt)

packages/cli/src/mini/splash.ts

@@ -17,12 +17,12 @@ import {
   type ScrollbackSnapshot,
   type ScrollbackWriter,
 } from "@opentui/core"
-import { Locale } from "../util/locale"
-import { go } from "../logo"
+import { Locale } from "@opencode-ai/tui/util/locale"
+import { go } from "@opencode-ai/tui/logo"
 import type { RunSplashTheme } from "./theme"
 
-const SPLASH_TITLE_LIMIT = 50
-const SPLASH_TITLE_FALLBACK = "Untitled session"
+export const SPLASH_TITLE_LIMIT = 50
+export const SPLASH_TITLE_FALLBACK = "Untitled session"
 
 type SplashInput = {
   title: string | undefined

packages/cli/src/mini/stream-v2.subagent.ts

@@ -0,0 +1,786 @@
+// Current-native subagent (child Session) tracking for the mini transport.
+//
+// Discovers child Sessions of the active parent from four current sources:
+//   1. projected subagent tool output (`structured.sessionID`) during hydration
+//   2. the current session list filtered by `parentID` during hydration
+//   3. the process-local active-session map during hydration
+//   4. live events from unknown sessions whose `parentID` matches the parent
+//
+// Tracks one footer tab per child and a detail transcript for the selected
+// child, reduced from the same current live event stream the parent uses.
+// Detail transcripts rebuild from projected messages on discovery, selection,
+// and reconnect, then continue from live deltas using the same
+// projected-prefix dedup the parent transport uses.
+//
+// Per-child interruption uses `v2.session.interrupt(childID)`. Per-child
+// backgrounding is intentionally absent: subagent jobs block the parent
+// session, so only whole-session `v2.session.background(parentID)` exists.
+import type {
+  EventSubscribeOutput,
+  OpenCodeClient,
+  SessionMessageAssistantTool,
+  SessionMessageInfo,
+} from "@opencode-ai/client/promise"
+import { Locale } from "@opencode-ai/tui/util/locale"
+import type { FooterSubagentDetail, FooterSubagentState, FooterSubagentTab, MiniToolPart, StreamCommit } from "./types"
+
+const CHILD_MESSAGE_LIMIT = 80
+const CHILD_FRAME_LIMIT = 80
+const CHILD_EVENT_BUFFER_LIMIT = 64
+const FAMILY_LIST_LIMIT = 100
+const FALLBACK_LABEL = "Subagent"
+
+type V2Event = EventSubscribeOutput
+
+export function outputText(content: ReadonlyArray<{ type: string; text?: string }>) {
+  return content.flatMap((item) => (item.type === "text" && item.text ? [item.text] : [])).join("\n")
+}
+
+export function miniTool(input: {
+  sessionID: string
+  messageID: string
+  tool: SessionMessageAssistantTool
+}): MiniToolPart {
+  const tool = input.tool
+  const providerCall =
+    tool.executed === undefined && tool.providerState === undefined
+      ? undefined
+      : { executed: tool.executed, state: tool.providerState }
+  const providerResult =
+    tool.executed === undefined && tool.providerResultState === undefined
+      ? undefined
+      : { executed: tool.executed, state: tool.providerResultState }
+  const base = {
+    id: `prt_${tool.id}`,
+    sessionID: input.sessionID,
+    messageID: input.messageID,
+    type: "tool" as const,
+    callID: tool.id,
+    tool: tool.name,
+  }
+  if (tool.state.status === "streaming") {
+    return {
+      ...base,
+      state: { status: "pending", input: {}, raw: tool.state.input },
+    }
+  }
+  if (tool.state.status === "running") {
+    return {
+      ...base,
+      state: {
+        status: "running",
+        input: tool.state.input,
+        title: tool.name,
+        metadata: { structured: tool.state.structured, content: tool.state.content, providerCall },
+        time: { start: tool.time.ran ?? tool.time.created },
+      },
+    }
+  }
+  if (tool.state.status === "completed") {
+    return {
+      ...base,
+      state: {
+        status: "completed",
+        input: tool.state.input,
+        output: outputText(tool.state.content),
+        title: tool.name,
+        metadata: {
+          structured: tool.state.structured,
+          content: tool.state.content,
+          result: tool.state.result,
+          providerCall,
+          providerResult,
+        },
+        time: { start: tool.time.ran ?? tool.time.created, end: tool.time.completed ?? tool.time.created },
+      },
+    }
+  }
+  return {
+    ...base,
+    state: {
+      status: "error",
+      input: tool.state.input,
+      error: tool.state.error.message,
+      metadata: {
+        structured: tool.state.structured,
+        content: tool.state.content,
+        result: tool.state.result,
+        providerCall,
+        providerResult,
+      },
+      time: { start: tool.time.ran ?? tool.time.created, end: tool.time.completed ?? tool.time.created },
+    },
+  }
+}
+
+export function toolCommit(part: MiniToolPart, phase: "start" | "progress" | "final"): StreamCommit {
+  const status = part.state.status
+  const text =
+    status === "running"
+      ? part.tool === "task"
+        ? "running task"
+        : `running ${part.tool}`
+      : status === "completed"
+        ? part.state.output
+        : status === "error"
+          ? part.state.error
+          : ""
+  return {
+    kind: "tool",
+    source: "tool",
+    text,
+    phase,
+    messageID: part.messageID,
+    partID: part.id,
+    tool: part.tool,
+    part,
+    toolState: status === "error" ? "error" : status === "completed" ? "completed" : "running",
+    toolError: status === "error" ? part.state.error : undefined,
+  }
+}
+
+type Frame = {
+  key: string
+  commit: StreamCommit
+}
+
+type ToolTrack = {
+  name: string
+  input: Record<string, unknown>
+  started: number
+  providerState?: Record<string, unknown>
+}
+
+type ChildState = {
+  sessionID: string
+  label: string
+  description: string
+  status: FooterSubagentTab["status"]
+  background: boolean
+  title?: string
+  callIDs: Set<string>
+  lastUpdatedAt: number
+  frames: Frame[]
+  text: Map<string, string>
+  projectedText: Map<string, string>
+  reasoning: Map<string, string>
+  projectedReasoning: Map<string, string>
+  tools: Map<string, ToolTrack>
+  finishedTools: Set<string>
+  messageIDs: Set<string>
+  prompts: Map<string, string>
+  hydrated: boolean
+}
+
+export type SubagentTrackerInput = {
+  sdk: OpenCodeClient
+  sessionID: string
+  thinking: boolean
+  emit: () => void
+}
+
+export type SubagentTracker = {
+  main(event: V2Event): void
+  foreign(sessionID: string, event: V2Event): void
+  hydrate(next: { messages: SessionMessageInfo[]; active: Record<string, unknown> }): Promise<void>
+  select(sessionID: string | undefined): void
+  snapshot(): FooterSubagentState
+}
+
+function record(value: unknown): Record<string, unknown> | undefined {
+  if (typeof value === "object" && value !== null && !Array.isArray(value)) return value as Record<string, unknown>
+  return undefined
+}
+
+function text(value: unknown): string | undefined {
+  if (typeof value !== "string") return undefined
+  const next = value.trim()
+  return next || undefined
+}
+
+function childSessionID(structured: Record<string, unknown> | undefined) {
+  const sessionID = text(structured?.sessionID)
+  if (!sessionID || !sessionID.startsWith("ses")) return undefined
+  const status = structured?.status
+  if (status !== "running" && status !== "completed") return undefined
+  return { sessionID, running: status === "running" }
+}
+
+function tab(child: ChildState): FooterSubagentTab {
+  return {
+    sessionID: child.sessionID,
+    partID: `subagent:${child.sessionID}`,
+    callID: `subagent:${child.sessionID}`,
+    label: child.label,
+    description: child.description || child.title || "",
+    status: child.status,
+    background: child.background ? true : undefined,
+    title: child.title,
+    toolCalls: child.callIDs.size > 0 ? child.callIDs.size : undefined,
+    lastUpdatedAt: child.lastUpdatedAt,
+  }
+}
+
+export function createSubagentTracker(input: SubagentTrackerInput): SubagentTracker {
+  const children = new Map<string, ChildState>()
+  // Live subagent tool calls in the parent, so tool.success structured output
+  // can be joined with the call's input metadata.
+  const pendingCalls = new Map<string, Record<string, unknown>>()
+  // Foreign sessions already resolved through session.get. Non-children stay
+  // cached so unrelated concurrent sessions are checked at most once.
+  const checked = new Set<string>()
+  // Foreign events buffered while a session.get discovery is in flight, so a
+  // fast child (including its settled event) is not lost mid-discovery.
+  const pendingEvents = new Map<string, V2Event[]>()
+  const hydrationEvents = new Map<string, V2Event[]>()
+  const hydrationOverflow = new Set<string>()
+  const hydrations = new Map<string, Promise<void>>()
+  let selected: string | undefined
+  const fragmentKey = (messageID: string, partID: string) => `${messageID}\u0000${partID}`
+
+  const ensureChild = (sessionID: string): ChildState => {
+    const existing = children.get(sessionID)
+    const child: ChildState = existing ?? {
+      sessionID,
+      label: FALLBACK_LABEL,
+      description: "",
+      status: "running",
+      background: false,
+      callIDs: new Set(),
+      lastUpdatedAt: Date.now(),
+      frames: [],
+      text: new Map(),
+      projectedText: new Map(),
+      reasoning: new Map(),
+      projectedReasoning: new Map(),
+      tools: new Map(),
+      finishedTools: new Set(),
+      messageIDs: new Set(),
+      prompts: new Map(),
+      hydrated: false,
+    }
+    if (!existing) children.set(sessionID, child)
+    // Adopting a child while its session.get discovery is still in flight:
+    // drain the buffered events now. They arrived before whatever the caller
+    // applies next, so replaying them first preserves bus order, and the
+    // resolved discovery can no longer replay stale events (e.g. step.started)
+    // after a terminal settled event was applied directly.
+    const buffered = pendingEvents.get(sessionID)
+    if (buffered) {
+      pendingEvents.delete(sessionID)
+      for (const event of buffered) reduce(child, event)
+    }
+    return child
+  }
+
+  const touch = (child: ChildState, timestamp?: number) => {
+    child.lastUpdatedAt = Math.max(child.lastUpdatedAt, timestamp ?? Date.now())
+  }
+
+  const notifyDetail = (child: ChildState) => {
+    if (child.sessionID === selected) input.emit()
+  }
+
+  const setFrame = (child: ChildState, key: string, commit: StreamCommit) => {
+    const index = child.frames.findIndex((item) => item.key === key)
+    if (index === -1) {
+      child.frames.push({ key, commit })
+      if (child.frames.length > CHILD_FRAME_LIMIT) child.frames.splice(0, child.frames.length - CHILD_FRAME_LIMIT)
+      return
+    }
+    child.frames[index] = { key, commit }
+  }
+
+  const applyMeta = (child: ChildState, meta: Record<string, unknown> | undefined) => {
+    if (!meta) return
+    const agent = text(meta.agent)
+    if (agent) child.label = Locale.titlecase(agent)
+    const description = text(meta.description)
+    if (description) child.description = description
+    if (meta.background === true) child.background = true
+  }
+
+  const userFrame = (child: ChildState, messageID: string, value: string) => {
+    if (child.messageIDs.has(messageID)) return false
+    child.messageIDs.add(messageID)
+    setFrame(child, `user:${messageID}`, {
+      kind: "user",
+      source: "system",
+      text: value,
+      phase: "start",
+      messageID,
+    })
+    return true
+  }
+
+  const childTool = (child: ChildState, item: SessionMessageAssistantTool, messageID: string) => {
+    const part = miniTool({
+      sessionID: child.sessionID,
+      messageID,
+      tool: item,
+    })
+    if (item.state.status === "streaming") return
+    child.callIDs.add(item.id)
+    if (item.state.status === "running") {
+      setFrame(child, `tool:${item.id}`, toolCommit(part, "start"))
+      return
+    }
+    child.finishedTools.add(item.id)
+    child.tools.delete(item.id)
+    setFrame(child, `tool:${item.id}`, toolCommit(part, "final"))
+  }
+
+  const rebuild = (child: ChildState, messages: SessionMessageInfo[]) => {
+    child.frames = []
+    child.text.clear()
+    child.projectedText.clear()
+    child.reasoning.clear()
+    child.projectedReasoning.clear()
+    child.finishedTools.clear()
+    child.messageIDs.clear()
+    child.callIDs.clear()
+    for (const message of messages) {
+      if (message.type === "user") {
+        child.prompts.delete(message.id)
+        userFrame(child, message.id, message.text)
+        continue
+      }
+      if (message.type !== "assistant") continue
+      child.messageIDs.add(message.id)
+      let textOrdinal = 0
+      let reasoningOrdinal = 0
+      for (const item of message.content) {
+        if (item.type === "text") {
+          const id = `text:${textOrdinal++}`
+          const key = fragmentKey(message.id, id)
+          child.text.set(key, item.text)
+          child.projectedText.set(key, item.text)
+          setFrame(child, key, {
+            kind: "assistant",
+            source: "assistant",
+            text: item.text,
+            phase: "progress",
+            messageID: message.id,
+            partID: id,
+          })
+          continue
+        }
+        if (item.type === "reasoning") {
+          const id = `reasoning:${reasoningOrdinal++}`
+          const key = fragmentKey(message.id, id)
+          child.reasoning.set(key, item.text)
+          child.projectedReasoning.set(key, item.text)
+          if (input.thinking)
+            setFrame(child, key, {
+              kind: "reasoning",
+              source: "reasoning",
+              text: `Thinking: ${item.text}`,
+              phase: "progress",
+              messageID: message.id,
+              partID: id,
+            })
+          continue
+        }
+        childTool(child, item, message.id)
+      }
+      if (message.error) {
+        setFrame(child, `error:${message.id}`, {
+          kind: "error",
+          source: "system",
+          text: message.error.message,
+          phase: "start",
+          messageID: message.id,
+        })
+      }
+    }
+  }
+
+  const hydrateChild = (child: ChildState): Promise<void> => {
+    const existing = hydrations.get(child.sessionID)
+    if (existing) return existing
+    const pendingPrompts = new Map(child.prompts)
+    const pendingTools = new Map(child.tools)
+    let retry = false
+    const task = input.sdk.message
+      .list({ sessionID: child.sessionID, limit: CHILD_MESSAGE_LIMIT, order: "desc" })
+      .then((response) => {
+        const buffered = hydrationEvents.get(child.sessionID) ?? []
+        hydrationEvents.delete(child.sessionID)
+        if (hydrationOverflow.delete(child.sessionID)) {
+          child.hydrated = false
+          retry = true
+          notifyDetail(child)
+          return
+        }
+        for (const [id, prompt] of pendingPrompts) {
+          if (!child.prompts.has(id)) child.prompts.set(id, prompt)
+        }
+        rebuild(child, structuredClone(response.data).toReversed() as SessionMessageInfo[])
+        for (const [id, tool] of pendingTools) {
+          if (!child.finishedTools.has(id) && !child.tools.has(id)) child.tools.set(id, tool)
+        }
+        for (const event of buffered) reduce(child, event)
+        child.hydrated = true
+        notifyDetail(child)
+      })
+      .catch(() => {
+        hydrationEvents.delete(child.sessionID)
+        hydrationOverflow.delete(child.sessionID)
+      })
+      .finally(() => {
+        hydrations.delete(child.sessionID)
+        if (retry) queueMicrotask(() => void hydrateChild(child))
+      })
+    hydrations.set(child.sessionID, task)
+    return task
+  }
+
+  const discover = (sessionID: string) => {
+    if (checked.has(sessionID) || children.has(sessionID) || sessionID === input.sessionID) return
+    checked.add(sessionID)
+    if (!pendingEvents.has(sessionID)) pendingEvents.set(sessionID, [])
+    void input.sdk.session
+      .get({ sessionID })
+      .then((session) => {
+        const buffered = pendingEvents.get(sessionID) ?? []
+        pendingEvents.delete(sessionID)
+        if (session.parentID !== input.sessionID) return
+        const child = ensureChild(sessionID)
+        if (session.agent) child.label = Locale.titlecase(session.agent)
+        child.title = session.title
+        for (const event of buffered) reduce(child, event)
+        touch(child)
+        input.emit()
+        void hydrateChild(child)
+      })
+      .catch(() => {
+        // Allow a later event to retry discovery after transient failures.
+        pendingEvents.delete(sessionID)
+        checked.delete(sessionID)
+      })
+  }
+
+  const reduce = (child: ChildState, event: V2Event) => {
+    if (event.type === "session.input.admitted") {
+      if (event.data.input.type === "user") child.prompts.set(event.data.inputID, event.data.input.data.text)
+      return
+    }
+    if (event.type === "session.input.promoted") {
+      const prompt = child.prompts.get(event.data.inputID)
+      if (prompt === undefined) return
+      child.prompts.delete(event.data.inputID)
+      if (userFrame(child, event.data.inputID, prompt)) {
+        touch(child, event.created)
+        notifyDetail(child)
+      }
+      return
+    }
+    if (event.type === "session.step.started") {
+      touch(child, event.created)
+      if (child.label === FALLBACK_LABEL && event.data.agent) child.label = Locale.titlecase(event.data.agent)
+      if (child.status !== "running") child.status = "running"
+      input.emit()
+      return
+    }
+    if (event.type === "session.text.started") {
+      return
+    }
+    if (event.type === "session.text.delta") {
+      const id = `text:${event.data.ordinal}`
+      const key = fragmentKey(event.data.assistantMessageID, id)
+      const projected = child.projectedText.get(key)
+      const covered = projected?.indexOf(event.data.delta) ?? -1
+      if (projected && covered >= 0) {
+        child.projectedText.set(key, projected.slice(covered + event.data.delta.length))
+        return
+      }
+      const next = (child.text.get(key) ?? "") + event.data.delta
+      child.text.set(key, next)
+      setFrame(child, key, {
+        kind: "assistant",
+        source: "assistant",
+        text: next,
+        phase: "progress",
+        messageID: event.data.assistantMessageID,
+        partID: id,
+      })
+      touch(child, event.created)
+      notifyDetail(child)
+      return
+    }
+    if (event.type === "session.text.ended") {
+      const id = `text:${event.data.ordinal}`
+      const key = fragmentKey(event.data.assistantMessageID, id)
+      child.text.set(key, event.data.text)
+      child.projectedText.delete(key)
+      setFrame(child, key, {
+        kind: "assistant",
+        source: "assistant",
+        text: event.data.text,
+        phase: "progress",
+        messageID: event.data.assistantMessageID,
+        partID: id,
+      })
+      touch(child, event.created)
+      notifyDetail(child)
+      return
+    }
+    if (event.type === "session.reasoning.started") {
+      return
+    }
+    if (event.type === "session.reasoning.delta") {
+      const id = `reasoning:${event.data.ordinal}`
+      const key = fragmentKey(event.data.assistantMessageID, id)
+      const projected = child.projectedReasoning.get(key)
+      const covered = projected?.indexOf(event.data.delta) ?? -1
+      if (projected && covered >= 0) {
+        child.projectedReasoning.set(key, projected.slice(covered + event.data.delta.length))
+        return
+      }
+      const next = (child.reasoning.get(key) ?? "") + event.data.delta
+      child.reasoning.set(key, next)
+      if (!input.thinking) return
+      setFrame(child, key, {
+        kind: "reasoning",
+        source: "reasoning",
+        text: `Thinking: ${next}`,
+        phase: "progress",
+        messageID: event.data.assistantMessageID,
+        partID: id,
+      })
+      notifyDetail(child)
+      return
+    }
+    if (event.type === "session.reasoning.ended") {
+      const id = `reasoning:${event.data.ordinal}`
+      const key = fragmentKey(event.data.assistantMessageID, id)
+      child.reasoning.set(key, event.data.text)
+      child.projectedReasoning.delete(key)
+      if (!input.thinking) return
+      setFrame(child, key, {
+        kind: "reasoning",
+        source: "reasoning",
+        text: `Thinking: ${event.data.text}`,
+        phase: "progress",
+        messageID: event.data.assistantMessageID,
+        partID: id,
+      })
+      notifyDetail(child)
+      return
+    }
+    if (event.type === "session.tool.input.started") {
+      if (child.finishedTools.has(event.data.callID)) return
+      child.tools.set(event.data.callID, { name: event.data.name, input: {}, started: event.created })
+      return
+    }
+    if (event.type === "session.tool.called") {
+      if (child.finishedTools.has(event.data.callID)) return
+      const current = child.tools.get(event.data.callID)
+      child.tools.set(event.data.callID, {
+        name: current?.name ?? "tool",
+        input: event.data.input,
+        started: current?.started ?? event.created,
+        providerState: event.data.state,
+      })
+      childTool(
+        child,
+        structuredClone({
+          type: "tool",
+          id: event.data.callID,
+          name: current?.name ?? "tool",
+          executed: event.data.executed,
+          providerState: event.data.state,
+          state: { status: "running", input: event.data.input, structured: {}, content: [] },
+          time: { created: current?.started ?? event.created, ran: event.created },
+        }) as SessionMessageAssistantTool,
+        event.data.assistantMessageID,
+      )
+      touch(child, event.created)
+      notifyDetail(child)
+      return
+    }
+    if (event.type === "session.tool.success" || event.type === "session.tool.failed") {
+      if (child.finishedTools.has(event.data.callID)) return
+      const current = child.tools.get(event.data.callID)
+      const failed = event.type === "session.tool.failed"
+      childTool(
+        child,
+        structuredClone({
+          type: "tool",
+          id: event.data.callID,
+          name: current?.name ?? "tool",
+          executed: event.data.executed,
+          providerState: current?.providerState,
+          providerResultState: event.data.resultState,
+          state: failed
+            ? {
+                status: "error",
+                input: current?.input ?? {},
+                structured: {},
+                content: [],
+                error: event.data.error,
+                result: event.data.result,
+              }
+            : {
+                status: "completed",
+                input: current?.input ?? {},
+                structured: event.data.structured,
+                content: event.data.content,
+                result: event.data.result,
+              },
+          time: {
+            created: current?.started ?? event.created,
+            ran: current?.started,
+            completed: event.created,
+          },
+        }) as SessionMessageAssistantTool,
+        event.data.assistantMessageID,
+      )
+      touch(child, event.created)
+      notifyDetail(child)
+      return
+    }
+    if (event.type === "session.step.ended") return
+    if (event.type === "session.step.failed") {
+      setFrame(child, `error:step:${event.data.assistantMessageID}`, {
+        kind: "error",
+        source: "system",
+        text: event.data.error.message,
+        phase: "start",
+        messageID: event.data.assistantMessageID,
+      })
+      touch(child, event.created)
+      notifyDetail(child)
+      return
+    }
+    if (event.type === "session.execution.started") {
+      child.status = "running"
+      touch(child, event.created)
+      input.emit()
+      return
+    }
+    if (
+      event.type === "session.execution.succeeded" ||
+      event.type === "session.execution.failed" ||
+      event.type === "session.execution.interrupted"
+    ) {
+      child.status =
+        event.type === "session.execution.succeeded"
+          ? "completed"
+          : event.type === "session.execution.interrupted"
+            ? "cancelled"
+            : "error"
+      touch(child, event.created)
+      input.emit()
+    }
+  }
+
+  const mainTool = (item: SessionMessageAssistantTool, active?: Record<string, unknown>) => {
+    if (item.name !== "subagent" || item.state.status !== "completed") return
+    const found = childSessionID(record(item.state.structured))
+    if (!found) return
+    const child = ensureChild(found.sessionID)
+    applyMeta(child, record(item.state.input))
+    if (found.running) child.background = true
+    if (child.status === "running") {
+      const running = found.running && (!active || found.sessionID in active)
+      child.status = running ? "running" : "completed"
+    }
+    touch(child, item.time.completed ?? item.time.created)
+  }
+
+  return {
+    main(event) {
+      if (event.type === "session.tool.input.started") {
+        if (event.data.name === "subagent") pendingCalls.set(event.data.callID, {})
+        return
+      }
+      if (event.type === "session.tool.called") {
+        if (pendingCalls.has(event.data.callID)) pendingCalls.set(event.data.callID, event.data.input)
+        return
+      }
+      if (event.type === "session.tool.failed") {
+        pendingCalls.delete(event.data.callID)
+        return
+      }
+      if (event.type !== "session.tool.success") return
+      const pending = pendingCalls.get(event.data.callID)
+      pendingCalls.delete(event.data.callID)
+      const found = childSessionID(record(event.data.structured))
+      if (!found) return
+      const child = ensureChild(found.sessionID)
+      applyMeta(child, pending)
+      if (found.running) {
+        child.background = true
+        child.status = "running"
+      }
+      if (!found.running && child.status === "running") child.status = "completed"
+      touch(child, event.created)
+      input.emit()
+      if (!child.hydrated) void hydrateChild(child)
+    },
+    foreign(sessionID, event) {
+      const child = children.get(sessionID)
+      if (child) {
+        if (hydrations.has(sessionID)) {
+          const buffered = hydrationEvents.get(sessionID) ?? []
+          if (buffered.length < CHILD_EVENT_BUFFER_LIMIT) buffered.push(event)
+          else hydrationOverflow.add(sessionID)
+          hydrationEvents.set(sessionID, buffered)
+        }
+        reduce(child, event)
+        return
+      }
+      discover(sessionID)
+      const buffered = pendingEvents.get(sessionID)
+      if (buffered && buffered.length < CHILD_EVENT_BUFFER_LIMIT) buffered.push(event)
+    },
+    async hydrate(next) {
+      for (const message of next.messages) {
+        if (message.type !== "assistant") continue
+        for (const item of message.content) {
+          if (item.type === "tool") mainTool(item, next.active)
+        }
+      }
+      // Family index: adopt children directly from the current session list so
+      // historical subagents beyond the projected message window still get tabs.
+      const family = await input.sdk.session
+        .list({ parentID: input.sessionID, limit: FAMILY_LIST_LIMIT, order: "desc" })
+        .then((response) => response.data)
+        .catch(() => [])
+      for (const session of family) {
+        const child = ensureChild(session.id)
+        if (session.agent && child.label === FALLBACK_LABEL) child.label = Locale.titlecase(session.agent)
+        if (!child.title) child.title = session.title
+        touch(child, session.time.updated)
+      }
+      for (const sessionID of Object.keys(next.active)) discover(sessionID)
+      for (const child of children.values()) {
+        // Reconnect can miss a child's settled event; the active map is the
+        // authoritative live signal for still-running children.
+        if (child.status === "running" && !(child.sessionID in next.active)) child.status = "completed"
+      }
+      const current = selected ? children.get(selected) : undefined
+      if (current) await hydrateChild(current)
+      if (children.size > 0) input.emit()
+    },
+    select(sessionID) {
+      selected = sessionID
+      const child = sessionID ? children.get(sessionID) : undefined
+      if (child && !child.hydrated) void hydrateChild(child)
+      input.emit()
+    },
+    snapshot() {
+      const tabs = [...children.values()].map(tab).toSorted((a, b) => {
+        const active = Number(b.status === "running") - Number(a.status === "running")
+        if (active !== 0) return active
+        return b.lastUpdatedAt - a.lastUpdatedAt
+      })
+      const child = selected ? children.get(selected) : undefined
+      const details: Record<string, FooterSubagentDetail> = child
+        ? { [child.sessionID]: { sessionID: child.sessionID, commits: child.frames.map((item) => item.commit) } }
+        : {}
+      return { tabs, details, permissions: [], questions: [] }
+    },
+  }
+}

packages/cli/src/mini/stream.ts

@@ -1,11 +1,11 @@
 // Thin bridge between transport output and the footer API.
 //
-// Transports produce immutable StreamCommit[] rows and typed mutable-footer
-// updates. This module forwards both to the footer API, adding trace writes
-// along the way. It also
+// Transports produce StreamCommit[] and an optional FooterOutput (patch +
+// view + subagent state). This module forwards them to footer.append() and
+// footer.event() respectively, adding trace writes along the way. It also
 // defaults status updates to phase "running" if the caller didn't set a
 // phase -- a convenience so transport code doesn't have to repeat that.
-import type { FooterApi, FooterEvent, FooterPatch, FooterSubagentState, StreamCommit } from "./types"
+import type { FooterApi, FooterOutput, FooterPatch, FooterSubagentState, StreamCommit } from "./types"
 
 type Trace = {
   write(type: string, data?: unknown): void
@@ -18,7 +18,7 @@ type OutputInput = {
 
 type StreamOutput = {
   commits: StreamCommit[]
-  updates?: Extract<FooterEvent, { type: "stream.patch" | "stream.view" | "stream.subagent" }>[]
+  footer?: FooterOutput
 }
 
 // Default to "running" phase when a status string arrives without an explicit phase.
@@ -71,15 +71,18 @@ function traceCommit(commit: StreamCommit) {
     part: commit.part
       ? {
           id: commit.part.id,
-          tool: commit.part.name,
+          sessionID: commit.part.sessionID,
+          messageID: commit.part.messageID,
+          callID: commit.part.callID,
+          tool: commit.part.tool,
           state: {
             status: commit.part.state.status,
-            input: summarize(commit.part.state.input),
-            structured: "structured" in commit.part.state ? summarize(commit.part.state.structured) : undefined,
-            content: "content" in commit.part.state ? summarize(commit.part.state.content) : undefined,
+            title: "title" in commit.part.state ? summarize(commit.part.state.title) : undefined,
             error: "error" in commit.part.state ? summarize(commit.part.state.error) : undefined,
+            time: "time" in commit.part.state ? summarize(commit.part.state.time) : undefined,
+            input: summarize(commit.part.state.input),
+            metadata: "metadata" in commit.part.state ? summarize(commit.part.state.metadata) : undefined,
           },
-          time: commit.part.time,
         }
       : undefined,
   }
@@ -103,30 +106,37 @@ export function traceSubagentState(state: FooterSubagentState) {
       action: item.action,
       resources: item.resources,
       source: item.source,
-      tool: item.tool
-        ? {
-            id: item.tool.id,
-            name: item.tool.name,
-            status: item.tool.state.status,
-            input: summarize(item.tool.state.input),
-          }
-        : undefined,
       metadata: item.metadata
         ? {
             keys: Object.keys(item.metadata),
+            input: summarize(item.metadata.input),
           }
         : undefined,
     })),
-    forms: state.forms.map((item) => ({
+    questions: state.questions.map((item) => ({
       id: item.id,
       sessionID: item.sessionID,
-      title: item.title,
-      fields: item.fields.map((field) => ({ key: field.key, type: field.type })),
-      location: item.location,
+      questions: item.questions.map((question) => ({
+        header: question.header,
+        question: question.question,
+        options: question.options.length,
+        multiple: question.multiple,
+      })),
     })),
   }
 }
 
+export function traceFooterOutput(footer?: FooterOutput) {
+  if (!footer?.subagent) {
+    return footer
+  }
+
+  return {
+    ...footer,
+    subagent: traceSubagentState(footer.subagent),
+  }
+}
+
 // Forwards transport output to the footer: commits go to scrollback, patches update the status bar.
 export function writeSessionOutput(input: OutputInput, out: StreamOutput): void {
   for (const commit of out.commits) {
@@ -134,19 +144,32 @@ export function writeSessionOutput(input: OutputInput, out: StreamOutput): void
     input.footer.append(commit)
   }
 
-  for (const update of out.updates ?? []) {
-    if (update.type === "stream.patch") {
-      const next = { ...update, patch: patch(update.patch) }
-      input.trace?.write("ui.patch", next.patch)
-      input.footer.event(next)
-      continue
-    }
-    if (update.type === "stream.subagent") {
-      input.trace?.write("ui.subagent", traceSubagentState(update.state))
-      input.footer.event(update)
-      continue
-    }
-    input.trace?.write("ui.patch", { view: update.view })
-    input.footer.event(update)
+  if (out.footer?.patch) {
+    const next = patch(out.footer.patch)
+    input.trace?.write("ui.patch", next)
+    input.footer.event({
+      type: "stream.patch",
+      patch: next,
+    })
   }
+
+  if (out.footer?.subagent) {
+    input.trace?.write("ui.subagent", traceSubagentState(out.footer.subagent))
+    input.footer.event({
+      type: "stream.subagent",
+      state: out.footer.subagent,
+    })
+  }
+
+  if (!out.footer?.view) {
+    return
+  }
+
+  input.trace?.write("ui.patch", {
+    view: out.footer.view,
+  })
+  input.footer.event({
+    type: "stream.view",
+    view: out.footer.view,
+  })
 }

packages/cli/src/mini/theme.ts

@@ -7,11 +7,7 @@
 // palette if detection fails.
 import { RGBA, SyntaxStyle, type CliRenderer, type ColorInput, type TerminalColors } from "@opentui/core"
 import type { TuiThemeCurrent } from "@opencode-ai/plugin/tui"
-import { ansiToRgba } from "../theme/color"
-import { resolveThemeColors } from "../theme/resolve"
-import { terminalMode } from "../theme/system"
-import type { ThemeJson } from "../theme/v1"
-import type { EntryKind, RunTuiConfig } from "./types"
+import type { EntryKind } from "./types"
 
 type Tone = {
   body: ColorInput
@@ -24,6 +20,7 @@ export type RunSplashTheme = {
   left: ColorInput
   right: ColorInput
   leftShadow: ColorInput
+  rightShadow: ColorInput
 }
 
 export type RunFooterTheme = {
@@ -31,6 +28,7 @@ export type RunFooterTheme = {
   selected: ColorInput
   selectedText: ColorInput
   warning: ColorInput
+  success: ColorInput
   error: ColorInput
   muted: ColorInput
   text: ColorInput
@@ -44,9 +42,12 @@ export type RunFooterTheme = {
 }
 
 export type RunBlockTheme = {
+  highlight: ColorInput
+  warning: ColorInput
   text: ColorInput
   muted: ColorInput
   syntax?: SyntaxStyle
+  diffAdded: ColorInput
   diffRemoved: ColorInput
   diffAddedBg: ColorInput
   diffRemovedBg: ColorInput
@@ -67,6 +68,21 @@ export type RunTheme = {
 }
 
 type ThemeColor = Exclude<keyof TuiThemeCurrent, "thinkingOpacity">
+type HexColor = `#${string}`
+type RefName = string
+type Variant = {
+  dark: HexColor | RefName
+  light: HexColor | RefName
+}
+type ColorValue = HexColor | RefName | Variant | RGBA | number
+type ThemeJson = {
+  defs?: Record<string, HexColor | RefName>
+  theme: Omit<Record<ThemeColor, ColorValue>, "selectedListItemText" | "backgroundMenu"> & {
+    selectedListItemText?: ColorValue
+    backgroundMenu?: ColorValue
+    thinkingOpacity?: number
+  }
+}
 
 type SharedSyntaxTheme = TuiThemeCurrent & {
   _hasSelectedListItemText: boolean
@@ -83,7 +99,7 @@ function rgba(hex: string, value?: number): RGBA {
   return value === undefined ? color : alpha(color, value)
 }
 
-function colorMode(bg: RGBA): "dark" | "light" {
+function mode(bg: RGBA): "dark" | "light" {
   return luminance(bg) > 0.5 ? "light" : "dark"
 }
 
@@ -107,6 +123,46 @@ function fade(color: RGBA, base: RGBA, fallback: number, scale: number, limit: n
   )
 }
 
+function ansiToRgba(code: number): RGBA {
+  if (code < 16) {
+    const ansi = [
+      "#000000",
+      "#800000",
+      "#008000",
+      "#808000",
+      "#000080",
+      "#800080",
+      "#008080",
+      "#c0c0c0",
+      "#808080",
+      "#ff0000",
+      "#00ff00",
+      "#ffff00",
+      "#0000ff",
+      "#ff00ff",
+      "#00ffff",
+      "#ffffff",
+    ]
+    return RGBA.fromHex(ansi[code] ?? "#000000")
+  }
+
+  if (code < 232) {
+    const index = code - 16
+    const b = index % 6
+    const g = Math.floor(index / 6) % 6
+    const r = Math.floor(index / 36)
+    const value = (x: number) => (x === 0 ? 0 : x * 40 + 55)
+    return RGBA.fromInts(value(r), value(g), value(b))
+  }
+
+  if (code < 256) {
+    const gray = (code - 232) * 10 + 8
+    return RGBA.fromInts(gray, gray, gray)
+  }
+
+  return RGBA.fromInts(0, 0, 0)
+}
+
 function tint(base: RGBA, overlay: RGBA, value: number): RGBA {
   return RGBA.fromInts(
     Math.round((base.r + (overlay.r - base.r) * value) * 255),
@@ -185,10 +241,54 @@ function splashShadow(indexed: RGBA[], base: RGBA, overlay: RGBA, value: number)
 }
 
 export function resolveTheme(theme: ThemeJson, pick: "dark" | "light"): TuiThemeCurrent {
-  const resolved = resolveThemeColors(theme, pick, (code) => RGBA.fromIndex(code, ansiToRgba(code)))
+  const defs = theme.defs ?? {}
+
+  const resolveColor = (value: ColorValue, chain: string[] = []): RGBA => {
+    if (value instanceof RGBA) return value
+
+    if (typeof value === "number") {
+      return RGBA.fromIndex(value, ansiToRgba(value))
+    }
+
+    if (typeof value !== "string") {
+      return resolveColor(value[pick], chain)
+    }
+
+    if (value === "transparent" || value === "none") {
+      return RGBA.fromInts(0, 0, 0, 0)
+    }
+
+    if (value.startsWith("#")) {
+      return RGBA.fromHex(value)
+    }
+
+    if (chain.includes(value)) {
+      throw new Error(`Circular color reference: ${[...chain, value].join(" -> ")}`)
+    }
+
+    const next = defs[value] ?? theme.theme[value as ThemeColor]
+    if (next === undefined) {
+      throw new Error(`Color reference "${value}" not found in defs or theme`)
+    }
+
+    return resolveColor(next, [...chain, value])
+  }
+
+  const resolved = Object.fromEntries(
+    Object.entries(theme.theme)
+      .filter(([key]) => key !== "selectedListItemText" && key !== "backgroundMenu" && key !== "thinkingOpacity")
+      .map(([key, value]) => [key, resolveColor(value as ColorValue)]),
+  ) as Partial<Record<ThemeColor, RGBA>>
+
   return {
-    ...resolved.theme,
-    thinkingOpacity: resolved.thinkingOpacity,
+    ...(resolved as Record<ThemeColor, RGBA>),
+    selectedListItemText:
+      theme.theme.selectedListItemText === undefined
+        ? resolved.background!
+        : resolveColor(theme.theme.selectedListItemText),
+    backgroundMenu:
+      theme.theme.backgroundMenu === undefined ? resolved.backgroundElement! : resolveColor(theme.theme.backgroundMenu),
+    thinkingOpacity: theme.theme.thinkingOpacity ?? 0.6,
   }
 }
 
@@ -360,6 +460,7 @@ function splashTheme(theme: TuiThemeCurrent, indexed: RGBA[]): RunSplashTheme {
     left,
     right,
     leftShadow: splashShadow(indexed, theme.background, left, 0.14),
+    rightShadow: splashShadow(indexed, theme.background, right, 0.14),
   }
 }
 
@@ -370,7 +471,7 @@ function map(
   syntax?: SyntaxStyle,
 ): RunTheme {
   const footerBackground = alpha(footerTheme.background, 1)
-  const footerMode = colorMode(footerBackground)
+  const footerMode = mode(footerBackground)
   const shade = fade(footerTheme.backgroundMenu, footerTheme.background, 0.12, 0.56, 0.72)
   const surface = fade(footerTheme.backgroundMenu, footerTheme.background, 0.18, 0.76, 0.9)
   const line = fade(footerTheme.backgroundMenu, footerTheme.background, 0.24, 0.9, 0.98)
@@ -389,6 +490,7 @@ function map(
       selected: footerTheme.backgroundElement,
       selectedText: footerTheme.selectedListItemText,
       warning: footerTheme.warning,
+      success: footerTheme.success,
       error: footerTheme.error,
       muted: footerTheme.textMuted,
       text: footerTheme.text,
@@ -423,9 +525,12 @@ function map(
     },
     splash,
     block: {
+      highlight: scrollbackTheme.primary,
+      warning: scrollbackTheme.warning,
       text: scrollbackTheme.text,
       muted: scrollbackTheme.textMuted,
       syntax,
+      diffAdded: scrollbackTheme.diffAdded,
       diffRemoved: scrollbackTheme.diffRemoved,
       diffAddedBg: transparent,
       diffRemovedBg: transparent,
@@ -467,6 +572,7 @@ export const RUN_THEME_FALLBACK: RunTheme = {
     selected: seed.text,
     selectedText: seed.panel,
     warning: seed.warning,
+    success: seed.success,
     error: seed.error,
     muted: seed.muted,
     text: seed.text,
@@ -490,10 +596,14 @@ export const RUN_THEME_FALLBACK: RunTheme = {
     left: fallbackSplashLeft,
     right: fallbackSplashRight,
     leftShadow: splashShadow(fallbackSplashIndexed, RGBA.fromValues(0, 0, 0, 0), fallbackSplashLeft, 0.14),
+    rightShadow: splashShadow(fallbackSplashIndexed, RGBA.fromValues(0, 0, 0, 0), fallbackSplashRight, 0.14),
   },
   block: {
+    highlight: seed.highlight,
+    warning: seed.warning,
     text: seed.text,
     muted: seed.muted,
+    diffAdded: seed.success,
     diffRemoved: seed.error,
     diffAddedBg: alpha(seed.success, 0.18),
     diffRemovedBg: alpha(seed.error, 0.18),
@@ -506,7 +616,7 @@ export const RUN_THEME_FALLBACK: RunTheme = {
   },
 }
 
-export async function resolveRunTheme(renderer: CliRenderer, config?: RunTuiConfig["theme"]): Promise<RunTheme> {
+export async function resolveRunTheme(renderer: CliRenderer): Promise<RunTheme> {
   try {
     const colors = await renderer.getPalette({
       size: 256,
@@ -518,19 +628,19 @@ export async function resolveRunTheme(renderer: CliRenderer, config?: RunTuiConf
 
     // Palette-only terminal reloads can leave renderer.themeMode stale, but
     // ANSI slot zero is not the terminal background when OSC 11 is absent.
-    const pick =
-      config?.mode === "dark" || config?.mode === "light"
-        ? config.mode
-        : (terminalMode(colors) ?? renderer.themeMode ?? colorMode(RGBA.fromHex(bg)))
-    const { generateSyntax } = await import("../theme")
-    const indexed = indexedPalette(colors, 256)
+    const pick = colors.defaultBackground
+      ? mode(RGBA.fromHex(colors.defaultBackground))
+      : (renderer.themeMode ?? mode(RGBA.fromHex(bg)))
     const footerTheme = resolveTheme(generateSystem(colors, pick), pick)
+    const indexed = indexedPalette(colors, 256)
     const scrollbackTheme = quantizeTheme(footerTheme, indexed)
+    const shared = await import("@opencode-ai/tui/context/theme")
     const syntaxTheme: SharedSyntaxTheme = {
       ...scrollbackTheme,
       _hasSelectedListItemText: true,
     }
-    return map(footerTheme, scrollbackTheme, splashTheme(scrollbackTheme, indexed), generateSyntax(syntaxTheme))
+    const syntax = shared.generateSyntax(syntaxTheme)
+    return map(footerTheme, scrollbackTheme, splashTheme(scrollbackTheme, indexed), syntax)
   } catch {
     return RUN_THEME_FALLBACK
   }

packages/cli/src/mini/trace.ts

@@ -0,0 +1,94 @@
+// Dev-only JSONL event trace for direct interactive mode.
+//
+// Enable with OPENCODE_DIRECT_TRACE=1. Writes one JSON line per event to
+// ~/.local/share/opencode/log/direct/<timestamp>-<pid>.jsonl. Also writes
+// a latest.json pointer so you can quickly find the most recent trace.
+//
+// The trace captures the full closed loop: outbound prompts, inbound SDK
+// events, reducer output, footer commits, and turn lifecycle markers.
+// Useful for debugging stream ordering, permission behavior, and
+// footer/transcript mismatches.
+//
+// Lazy-initialized: the first call to trace() decides whether tracing is
+// active based on the env var, and subsequent calls return the cached result.
+import fs from "fs"
+import path from "path"
+import { Global } from "@opencode-ai/core/global"
+
+export type Trace = {
+  write(type: string, data?: unknown): void
+}
+
+let state: Trace | false | undefined
+
+function stamp() {
+  return new Date()
+    .toISOString()
+    .replace(/[-:]/g, "")
+    .replace(/\.\d+Z$/, "Z")
+}
+
+function file() {
+  return path.join(Global.Path.log, "direct", `${stamp()}-${process.pid}.jsonl`)
+}
+
+function latest() {
+  return path.join(Global.Path.log, "direct", "latest.json")
+}
+
+function text(data: unknown) {
+  return JSON.stringify(
+    data,
+    (_key, value) => {
+      if (typeof value === "bigint") {
+        return String(value)
+      }
+
+      return value
+    },
+    0,
+  )
+}
+
+export function trace(): Trace | undefined {
+  if (state !== undefined) {
+    return state || undefined
+  }
+
+  if (!process.env.OPENCODE_DIRECT_TRACE) {
+    state = false
+    return undefined
+  }
+
+  const target = file()
+  fs.mkdirSync(path.dirname(target), { recursive: true })
+  fs.writeFileSync(
+    latest(),
+    text({
+      time: new Date().toISOString(),
+      pid: process.pid,
+      cwd: process.cwd(),
+      argv: process.argv.slice(2),
+      path: target,
+    }) + "\n",
+  )
+  state = {
+    write(type: string, data?: unknown) {
+      fs.appendFileSync(
+        target,
+        text({
+          time: new Date().toISOString(),
+          pid: process.pid,
+          type,
+          data,
+        }) + "\n",
+      )
+    },
+  }
+  state.write("trace.start", {
+    argv: process.argv.slice(2),
+    cwd: process.cwd(),
+    path: target,
+  })
+  return state
+}

packages/cli/src/mini/types.ts

@@ -2,27 +2,22 @@
 //
 // Direct mode uses a split-footer terminal layout: immutable scrollback for the
 // session transcript, and a mutable footer for prompt input, status, and
-// permission/form UI. Every module in run/* shares these types to stay
+// permission/question UI. Every module in run/* shares these types to stay
 // aligned on that two-lane model.
 //
 // Data flow through the system:
 //
-//   V2 events / demo actions → StreamCommit[] + FooterEvent[]
+//   V2 events / demo actions → StreamCommit[] + FooterOutput
 //     → stream.ts bridges to footer API
 //       → footer.ts queues commits and patches the footer view
 //         → OpenTUI split-footer renderer writes to terminal
 import type {
-  FormAnswer,
-  FormInfo,
   OpenCodeClient,
-  LocationGetOutput,
-  LocationRef,
   PermissionV2Request,
+  QuestionV2Request,
   ReferenceListOutput,
-  SessionMessageAssistantTool,
 } from "@opencode-ai/client/promise"
-import type { Config } from "../config"
-import type { CliRenderer } from "@opentui/core"
+import type { TuiConfig } from "@opencode-ai/tui/config/v1"
 
 export type RunFilePart = {
   type: "file"
@@ -51,25 +46,63 @@ export type RunCommand = {
   name: string
   description?: string
   source?: string
+  template?: string
+  hints?: unknown[]
+  agent?: string
+  model?: {
+    [key: string]: unknown
+  }
+  subtask?: boolean
 }
 
 export type RunProviderModel = {
+  id: string
+  providerID: string
+  api?: {
+    [key: string]: unknown
+  }
   name?: string
+  capabilities?: {
+    [key: string]: unknown
+  }
   cost?: {
     input: number
+    output?: number
+    cache?: {
+      read: number
+      write: number
+    }
+  }
+  limit?: {
+    context: number
+    input?: number
+    output?: number
   }
   status?: string
+  options?: {
+    [key: string]: unknown
+  }
+  headers?: {
+    [key: string]: string
+  }
+  release_date?: string
   variants?: Record<string, unknown>
 }
 
 export type RunProvider = {
   id: string
   name: string
+  source?: string
+  env?: string[]
+  options?: {
+    [key: string]: unknown
+  }
   models: Record<string, RunProviderModel>
 }
 
 export type RunPrompt = {
   messageID?: string
+  partID?: string
   text: string
   parts: RunPromptPart[]
   mode?: "shell"
@@ -83,12 +116,14 @@ export type RunPrompt = {
 
 export type FooterQueuedPrompt = {
   messageID: string
+  partID: string
   prompt: RunPrompt
 }
 
 export type RunAgent = {
   id: string
   name: string
+  description?: string
   mode: "subagent" | "primary" | "all"
   hidden: boolean
 }
@@ -97,59 +132,21 @@ export type RunReference = ReferenceListOutput["data"][number]
 
 export type RunInput = {
   sdk: OpenCodeClient
-  location: LocationGetOutput
+  directory: string
+  sessionID: string
+  sessionTitle?: string
+  resume?: boolean
+  replay?: boolean
+  replayLimit?: number
   agent: string | undefined
   model: PromptModel | undefined
   variant: string | undefined
   files: RunFilePart[]
+  initialInput?: string
+  thinking: boolean
   demo?: boolean
 }
 
-export type MiniHost = {
-  terminal: {
-    stdin: NodeJS.ReadStream
-  }
-  platform: NodeJS.Platform
-  stdout: {
-    write(value: string): void
-  }
-  files: {
-    readText(url: string): Promise<string>
-  }
-  editor: {
-    open(input: {
-      value: string
-      cwd: string
-      renderer: CliRenderer
-      stdin: NodeJS.ReadStream
-    }): Promise<string | undefined>
-  }
-  paths: {
-    home: string
-  }
-  signals: {
-    sigint: {
-      subscribe(listener: () => void): () => void
-    }
-    sigusr2: {
-      subscribe(listener: () => void): () => void
-    }
-  }
-  startup: {
-    showTiming: boolean
-    now(): number
-  }
-  diagnostics: {
-    trace?: {
-      write(type: string, data?: unknown): void
-    }
-  }
-  preferences: {
-    resolveVariant(model: RunInput["model"]): Promise<string | undefined>
-    saveVariant(model: RunInput["model"], variant: string | undefined): Promise<void>
-  }
-}
-
 // The semantic role of a scrollback entry. Maps 1:1 to theme colors.
 export type EntryKind = "system" | "user" | "assistant" | "reasoning" | "tool" | "error"
 
@@ -163,6 +160,7 @@ export type FooterState = {
   status: string
   queue: number
   model: string
+  duration: string
   usage: string
   first: boolean
   interrupt: number
@@ -172,6 +170,8 @@ export type FooterState = {
 // A partial update to FooterState. The footer merges this onto the current state.
 export type FooterPatch = Partial<FooterState>
 
+export type RunDiffStyle = "auto" | "stacked"
+
 export type TurnSummary = {
   agent: string
   model: string
@@ -179,6 +179,7 @@ export type TurnSummary = {
 }
 
 export type ScrollbackOptions = {
+  diffStyle?: RunDiffStyle
   suppressBackgrounds?: boolean
 }
 
@@ -242,8 +243,6 @@ export type MiniToolState =
       time: { start: number; end: number }
     }
 
-// Retained only for the noninteractive run JSON/V1 compatibility boundary.
-// Interactive Mini commits carry SessionMessageAssistantTool directly.
 export type MiniToolPart = {
   id: string
   sessionID: string
@@ -254,14 +253,6 @@ export type MiniToolPart = {
   state: MiniToolState
 }
 
-export type MiniPermissionRequest = PermissionV2Request & {
-  tool?: SessionMessageAssistantTool
-}
-
-export type MiniFormRequest = FormInfo & {
-  location?: LocationRef
-}
-
 export type EntryLayout = "inline" | "block"
 
 export type RunEntryBody =
@@ -277,8 +268,8 @@ export type RunEntryBody =
 // "prompt".
 export type FooterView =
   | { type: "prompt" }
-  | { type: "permission"; request: MiniPermissionRequest }
-  | { type: "form"; request: MiniFormRequest }
+  | { type: "permission"; request: PermissionV2Request }
+  | { type: "question"; request: QuestionV2Request }
 
 export type FooterPromptRoute =
   | { type: "composer" }
@@ -292,23 +283,34 @@ export type FooterPromptRoute =
 
 export type FooterSubagentTab = {
   sessionID: string
+  partID: string
+  callID: string
   label: string
   description: string
   status: "running" | "completed" | "cancelled" | "error"
   background?: boolean
   title?: string
+  toolCalls?: number
   lastUpdatedAt: number
 }
 
 export type FooterSubagentDetail = {
+  sessionID: string
   commits: StreamCommit[]
 }
 
 export type FooterSubagentState = {
   tabs: FooterSubagentTab[]
   details: Record<string, FooterSubagentDetail>
-  permissions: MiniPermissionRequest[]
-  forms: MiniFormRequest[]
+  permissions: PermissionV2Request[]
+  questions: QuestionV2Request[]
+}
+
+// The transport emits this alongside scrollback commits so the footer can update in the same frame.
+export type FooterOutput = {
+  patch?: FooterPatch
+  view?: FooterView
+  subagent?: FooterSubagentState
 }
 
 // Typed messages sent to RunFooter.event(). The prompt queue and stream
@@ -319,10 +321,6 @@ export type FooterEvent =
       type: "history"
       history: RunPrompt[]
     }
-  | {
-      type: "agent"
-      agent: string | undefined
-    }
   | {
       type: "catalog"
       agents: RunAgent[]
@@ -359,6 +357,9 @@ export type FooterEvent =
       type: "turn.send"
       queue: number
     }
+  | {
+      type: "turn.wait"
+    }
   | {
       type: "turn.idle"
       queue: number
@@ -380,22 +381,16 @@ export type FooterEvent =
       state: FooterSubagentState
     }
 
-export type PermissionReply = Parameters<OpenCodeClient["permission"]["reply"]>[0]
+export type PermissionReply = Omit<Parameters<OpenCodeClient["permission"]["reply"]>[0], "sessionID">
 
-export type FormReply = {
-  sessionID: string
-  formID: string
-  answer: FormAnswer
-  location?: LocationRef
+export type QuestionReply = {
+  requestID: string
+  answers: string[][]
 }
 
-export type FormCancel = {
-  sessionID: string
-  formID: string
-  location?: LocationRef
-}
+export type QuestionReject = Omit<Parameters<OpenCodeClient["question"]["reject"]>[0], "sessionID">
 
-export type RunTuiConfig = Pick<Config.Resolved, "keybinds" | "leader" | "theme" | "session">
+export type RunTuiConfig = Pick<TuiConfig.Resolved, "keybinds" | "leader_timeout" | "diff_style">
 
 // Lifecycle phase of a scrollback entry. "start" opens the entry, "progress"
 // appends content (coalesced in the footer queue), "final" closes it.
@@ -418,18 +413,29 @@ export type StreamCommit = {
   messageID?: string
   partID?: string
   tool?: string
-  directory?: string
-  part?: SessionMessageAssistantTool
+  part?: MiniToolPart
   interrupted?: boolean
   toolState?: StreamToolState
   toolError?: string
   shell?: {
+    callID: string
     command: string
   }
 }
 
+export type LocalReplayAnchor = {
+  kind: EntryKind
+  text: string
+  phase: StreamPhase
+  messageID?: string
+  partID?: string
+  toolState?: StreamToolState
+  visible?: string
+}
+
 export type LocalReplayRow = {
   commit: StreamCommit
+  after?: LocalReplayAnchor
 }
 
 // The public contract between the stream transport / prompt queue and

packages/cli/src/mini/variant.shared.ts

@@ -0,0 +1,220 @@
+// Model variant resolution and persistence.
+//
+// Variants are provider-specific reasoning effort levels (e.g., "high", "max").
+// Resolution priority: CLI --variant flag > saved preference > session history.
+//
+// The saved variant persists across sessions in ~/.local/state/opencode/model.json
+// so your last-used variant sticks. Cycling (ctrl+t) updates both the active
+// variant and the persisted file.
+import path from "path"
+import { FSUtil } from "@opencode-ai/core/fs-util"
+import { Context, Effect, Layer } from "effect"
+import { LayerNode } from "@opencode-ai/core/effect/layer-node"
+import { makeGlobalNode } from "@opencode-ai/core/effect/app-node"
+import { makeRuntime } from "@opencode-ai/core/effect/runtime"
+import { Global } from "@opencode-ai/core/global"
+import { createSession, sessionVariant, type RunSession, type SessionMessages } from "./session.shared"
+import type { RunInput, RunProvider } from "./types"
+
+const MODEL_FILE = path.join(Global.Path.state, "model.json")
+
+type ModelState = Record<string, unknown> & {
+  variant?: Record<string, string | undefined>
+}
+type VariantService = {
+  readonly resolveSavedVariant: (model: RunInput["model"]) => Effect.Effect<string | undefined>
+  readonly saveVariant: (model: RunInput["model"], variant: string | undefined) => Effect.Effect<void>
+}
+type VariantRuntime = {
+  resolveSavedVariant(model: RunInput["model"]): Promise<string | undefined>
+  saveVariant(model: RunInput["model"], variant: string | undefined): Promise<void>
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return !!value && typeof value === "object" && !Array.isArray(value)
+}
+
+class Service extends Context.Service<Service, VariantService>()("@opencode/RunVariant") {}
+
+function modelKey(provider: string, model: string): string {
+  return `${provider}/${model}`
+}
+
+function variantKey(model: NonNullable<RunInput["model"]>): string {
+  return modelKey(model.providerID, model.modelID)
+}
+
+export function modelInfo(providers: RunProvider[] | undefined, model: NonNullable<RunInput["model"]>) {
+  const provider = providers?.find((item) => item.id === model.providerID)
+  return {
+    provider: provider?.name ?? model.providerID,
+    model: provider?.models[model.modelID]?.name ?? model.modelID,
+  }
+}
+
+export function formatModelLabel(
+  model: NonNullable<RunInput["model"]>,
+  variant: string | undefined,
+  providers?: RunProvider[],
+): string {
+  const names = modelInfo(providers, model)
+  const label = variant ? ` · ${variant}` : ""
+  return `${names.model} · ${names.provider}${label}`
+}
+
+export function cycleVariant(current: string | undefined, variants: string[]): string | undefined {
+  if (variants.length === 0) {
+    return undefined
+  }
+
+  if (!current) {
+    return variants[0]
+  }
+
+  const idx = variants.indexOf(current)
+  if (idx === -1 || idx === variants.length - 1) {
+    return undefined
+  }
+
+  return variants[idx + 1]
+}
+
+export function pickVariant(model: RunInput["model"], input: RunSession | SessionMessages): string | undefined {
+  return sessionVariant(Array.isArray(input) ? createSession(input) : input, model)
+}
+
+function fitVariant(value: string | undefined, variants: string[]): string | undefined {
+  if (!value) {
+    return undefined
+  }
+
+  if (variants.length === 0 || variants.includes(value)) {
+    return value
+  }
+
+  return undefined
+}
+
+// Picks the active variant. CLI flag wins, then saved preference, then session
+// history. fitVariant() checks saved and session values against the available
+// variants list -- if the provider doesn't offer a variant, it drops.
+export function resolveVariant(
+  input: string | undefined,
+  session: string | undefined,
+  saved: string | undefined,
+  variants: string[],
+): string | undefined {
+  if (input !== undefined) {
+    return input
+  }
+
+  const fallback = fitVariant(saved, variants)
+  const current = fitVariant(session, variants)
+  if (current !== undefined) {
+    return current
+  }
+
+  return fallback
+}
+
+function state(value: unknown): ModelState {
+  if (!isRecord(value)) {
+    return {}
+  }
+
+  const variant = isRecord(value.variant)
+    ? Object.fromEntries(
+        Object.entries(value.variant).flatMap(([key, item]) => {
+          if (typeof item !== "string") {
+            return []
+          }
+
+          return [[key, item] as const]
+        }),
+      )
+    : undefined
+
+  return {
+    ...value,
+    variant,
+  }
+}
+
+const layer = Layer.fresh(
+  Layer.effect(
+    Service,
+    Effect.gen(function* () {
+      const file = yield* FSUtil.Service
+
+      const read = Effect.fn("RunVariant.read")(function* () {
+        return yield* file.readJson(MODEL_FILE).pipe(
+          Effect.map(state),
+          Effect.catchCause(() => Effect.succeed(state(undefined))),
+        )
+      })
+
+      const resolveSavedVariant = Effect.fn("RunVariant.resolveSavedVariant")(function* (model: RunInput["model"]) {
+        if (!model) {
+          return undefined
+        }
+
+        return (yield* read()).variant?.[variantKey(model)]
+      })
+
+      const saveVariant = Effect.fn("RunVariant.saveVariant")(function* (
+        model: RunInput["model"],
+        variant: string | undefined,
+      ) {
+        if (!model) {
+          return
+        }
+
+        const current = yield* read()
+        const next = {
+          ...current.variant,
+        }
+        const key = variantKey(model)
+        if (variant) {
+          next[key] = variant
+        }
+
+        if (!variant) {
+          delete next[key]
+        }
+
+        yield* file
+          .writeJson(MODEL_FILE, {
+            ...current,
+            variant: next,
+          })
+          .pipe(Effect.orElseSucceed(() => undefined))
+      })
+
+      return Service.of({
+        resolveSavedVariant,
+        saveVariant,
+      })
+    }),
+  ),
+)
+
+const node = makeGlobalNode({ service: Service, layer, deps: [FSUtil.node] })
+
+/** @internal Exported for testing. */
+export function createVariantRuntime(replacements?: readonly LayerNode.Replacement[]): VariantRuntime {
+  const runtime = makeRuntime(Service, LayerNode.compile(node, replacements))
+  return {
+    resolveSavedVariant: (model) => runtime.runPromise((svc) => svc.resolveSavedVariant(model)).catch(() => undefined),
+    saveVariant: (model, variant) => runtime.runPromise((svc) => svc.saveVariant(model, variant)).catch(() => {}),
+  }
+}
+
+const runtime = createVariantRuntime()
+
+export async function resolveSavedVariant(model: RunInput["model"]): Promise<string | undefined> {
+  return runtime.resolveSavedVariant(model)
+}
+
+export function saveVariant(model: RunInput["model"], variant: string | undefined): void {
+  void runtime.saveVariant(model, variant)
+}

packages/cli/src/run/index.ts

@@ -1,2 +0,0 @@
-export { runNonInteractive, type RunCommandInput } from "./run"
-export { runV1Bridge, type V1RunCommandInput } from "./v1"

packages/cli/src/run/v1.ts

@@ -1,85 +0,0 @@
-import type { Endpoint } from "@opencode-ai/client/effect/service"
-import { Effect } from "effect"
-import path from "node:path"
-import { Standalone } from "../services/standalone"
-import { reportRunError, runNonInteractiveWithOptions, type RunCommandInput } from "./run"
-
-export type V1RunCommandInput = {
-  message: string[]
-  continue?: boolean
-  session?: string
-  fork?: boolean
-  model?: string
-  agent?: string
-  format: "default" | "json"
-  file: string[]
-  title?: string
-  server?: string
-  password?: string
-  username?: string
-  directory?: string
-  variant?: string
-  thinking?: boolean
-  dangerouslySkipPermissions?: boolean
-  standaloneCommand?: ReadonlyArray<string>
-}
-
-export function runV1Bridge(input: V1RunCommandInput) {
-  const root = process.env.PWD ?? process.cwd()
-  const attached = input.server !== undefined
-  const local = !attached && input.directory ? path.resolve(root, input.directory) : root
-  try {
-    process.chdir(local)
-  } catch {
-    reportRunError(input, `Failed to change directory to ${local}`)
-    return Promise.resolve()
-  }
-
-  return Effect.runPromise(
-    Effect.scoped(
-      Effect.gen(function* () {
-        const endpoint = attached
-          ? explicitEndpoint(input)
-          : yield* Standalone.start({ command: input.standaloneCommand })
-        yield* Effect.promise(() =>
-          runNonInteractiveWithOptions(nativeInput(input, endpoint), {
-            root: local,
-            directory: attached ? input.directory : local,
-            useServerDirectory: attached && input.directory === undefined,
-            variant: input.variant,
-            attached,
-            compatibility: "v1",
-          }),
-        )
-      }),
-    ),
-  ).catch((error) => reportRunError(input, error instanceof Error ? error.message : String(error)))
-}
-
-function nativeInput(input: V1RunCommandInput, endpoint: Endpoint): RunCommandInput {
-  return {
-    server: { endpoint },
-    message: input.message,
-    continue: input.continue,
-    session: input.session,
-    fork: input.fork,
-    model: input.model,
-    agent: input.agent,
-    format: input.format,
-    file: input.file,
-    title: input.title,
-    thinking: input.thinking,
-    auto: input.dangerouslySkipPermissions,
-  }
-}
-
-function explicitEndpoint(input: V1RunCommandInput): Endpoint {
-  const url = input.server
-  if (!url) throw new Error("Missing V1 server URL")
-  return {
-    url,
-    auth: input.password
-      ? { type: "basic", username: input.username ?? "opencode", password: input.password }
-      : undefined,
-  }
-}

packages/cli/src/services/catalog.ts

@@ -1,43 +0,0 @@
-import { ClientError, type OpenCodeClient } from "@opencode-ai/client/promise"
-
-// Location plugins initialize asynchronously, so explicit model selection must
-// wait for that exact model before prompt admission. The execution path owns
-// the authoritative error if readiness times out.
-export async function waitForCatalogReady(input: {
-  sdk: OpenCodeClient
-  directory: string
-  workspace?: string
-  model: { providerID: string; modelID: string }
-  timeoutMs?: number
-  signal?: AbortSignal
-}) {
-  const deadline = Date.now() + (input.timeoutMs ?? 5_000)
-  while (Date.now() < deadline && !input.signal?.aborted) {
-    const models = await input.sdk.model
-      .list(
-        { location: { directory: input.directory, workspace: input.workspace } },
-        { signal: input.signal },
-      )
-      .then((result) => result.data)
-      .catch((error) => {
-        if (input.signal && error instanceof ClientError && error.reason === "Transport") throw error
-        return undefined
-      })
-    if (models?.some((model) => model.providerID === input.model.providerID && model.id === input.model.modelID)) return
-    await wait(25, input.signal)
-  }
-}
-
-function wait(delay: number, signal?: AbortSignal) {
-  if (!signal) return new Promise<void>((resolve) => setTimeout(resolve, delay))
-  if (signal.aborted) return Promise.resolve()
-  return new Promise<void>((resolve) => {
-    const timer = setTimeout(done, delay)
-    signal.addEventListener("abort", done, { once: true })
-    function done() {
-      clearTimeout(timer)
-      signal?.removeEventListener("abort", done)
-      resolve()
-    }
-  })
-}

packages/cli/src/services/server-connection.ts

@@ -2,12 +2,14 @@ import { Service, type Endpoint, type EnsureOptions } from "@opencode-ai/client/
 import { ClientError, isUnauthorizedError, OpenCode } from "@opencode-ai/client/promise"
 import { InstallationVersion } from "@opencode-ai/core/installation/version"
 import { Effect, Redacted } from "effect"
+import { Config } from "../config"
 import { Env } from "../env"
 import { ServiceConfig } from "./service-config"
 import { Standalone } from "./standalone"
 
 export type Args = {
   readonly server?: string
+  readonly remote?: string
   readonly standalone?: boolean
   readonly mismatch?: "replace" | "ignore" | "error"
   readonly onStart?: EnsureOptions["onStart"]
@@ -19,13 +21,28 @@ export type Resolved = {
 }
 
 export const resolve = Effect.fn("cli.server-connection.resolve")(function* (args: Args) {
-  if (args.server !== undefined && args.standalone)
-    return yield* Effect.fail(new Error("--server and --standalone cannot be combined"))
-  if (args.server !== undefined) {
-    const password = yield* Env.password
+  if (args.server !== undefined && args.remote !== undefined)
+    return yield* Effect.fail(new Error("--server and --remote cannot be combined"))
+  if ((args.server !== undefined || args.remote !== undefined) && args.standalone)
+    return yield* Effect.fail(new Error("--server, --remote, and --standalone cannot be combined"))
+  if (args.server !== undefined || args.remote !== undefined) {
+    const config = yield* Config.Service
+    const profile = args.remote === undefined ? undefined : (yield* config.get()).servers?.[args.remote]
+    if (args.remote !== undefined && profile === undefined)
+      return yield* Effect.fail(new Error(`Saved server "${args.remote}" not found`))
+    const environmentPassword = yield* Env.password
+    const password = environmentPassword ? Redacted.value(environmentPassword) : profile?.password
+    const url = profile?.url ?? args.server
+    if (url === undefined) return yield* Effect.fail(new Error("Missing server URL"))
     const endpoint = {
-      url: args.server,
-      auth: password ? { type: "basic" as const, username: "opencode", password: Redacted.value(password) } : undefined,
+      url,
+      auth: password
+        ? {
+            type: "basic" as const,
+            username: profile?.username ?? "opencode",
+            password,
+          }
+        : undefined,
     } satisfies Endpoint
     const client = OpenCode.make({ baseUrl: endpoint.url, headers: Service.headers(endpoint) })
     const health = yield* Effect.tryPromise({
@@ -56,7 +73,7 @@ function managedService(options: EnsureOptions) {
     restart: () =>
       Effect.gen(function* () {
         yield* Service.stop(options)
-        yield* Service.ensure(reconnectOptions)
+        yield* Service.ensure(options)
       }),
   }
 }

packages/cli/src/session-target.ts

@@ -1,166 +0,0 @@
-import type { LocationGetOutput, ModelRef, OpenCodeClient, SessionInfo } from "@opencode-ai/client/promise"
-import { Model } from "@opencode-ai/schema/model"
-
-const SESSION_PAGE_LIMIT = 50
-
-export type SessionTarget = {
-  session: SessionInfo
-  location: LocationGetOutput
-  model: ModelRef | undefined
-  agent: string | undefined
-  resume: boolean
-}
-
-export type SessionTargetPreparation = (input: {
-  client: OpenCodeClient
-  location: LocationGetOutput
-  session: SessionInfo | undefined
-  model: ModelRef | undefined
-  agent: string | undefined
-  signal?: AbortSignal
-}) => Promise<{ model: ModelRef | undefined; agent: string | undefined }>
-
-export class SessionTargetMutationError extends Error {
-  override readonly name = "SessionTargetMutationError"
-
-  constructor(cause: unknown) {
-    super(cause instanceof Error ? cause.message : "Session target mutation failed", { cause })
-  }
-}
-
-export async function resolveSessionTarget(input: {
-  client: OpenCodeClient
-  location?: { directory?: string; workspace?: string }
-  continue?: boolean
-  session?: string
-  fork?: boolean
-  model?: ModelRef
-  agent?: string
-  prepare: SessionTargetPreparation
-  signal?: AbortSignal
-}): Promise<SessionTarget> {
-  const selection = await selectSession(input)
-  const selected = selection.session
-  const location =
-    selection.location ??
-    (await resolveLocation(
-      input.client,
-      selected ? { directory: selected.location.directory, workspace: selected.location.workspaceID } : input.location,
-      input.signal,
-    ))
-  const prepared = await input.prepare({
-    client: input.client,
-    location,
-    session: selected,
-    model: input.model ?? selected?.model,
-    agent: input.agent ?? selected?.agent,
-    signal: input.signal,
-  })
-  const session =
-    selected ??
-    (await input.client.session
-      .create(
-        {
-          agent: prepared.agent,
-          model: prepared.model,
-          location: { directory: location.directory, workspaceID: location.workspaceID },
-        },
-        ...requestOptions(input.signal),
-      )
-      .catch((error) => {
-        throw new SessionTargetMutationError(error)
-      }))
-  return {
-    session,
-    location,
-    model: prepared.model,
-    agent: prepared.agent,
-    resume: selected !== undefined,
-  }
-}
-
-export function parseSessionTargetModel(value?: string): ModelRef | undefined {
-  if (!value) return
-  const model = Model.Ref.parse(value)
-  return { providerID: model.providerID, id: model.id, variant: model.variant }
-}
-
-async function selectSession(input: {
-  client: OpenCodeClient
-  location?: { directory?: string; workspace?: string }
-  continue?: boolean
-  session?: string
-  fork?: boolean
-  signal?: AbortSignal
-}) {
-  const explicit = input.session
-    ? await input.client.session.get({ sessionID: input.session }, ...requestOptions(input.signal)).catch((error) => {
-        if (error && typeof error === "object" && Reflect.get(error, "_tag") === "SessionNotFoundError")
-          return undefined
-        throw error
-      })
-    : undefined
-  if (input.session && !explicit) throw new Error("Session not found")
-  if (explicit)
-    return {
-      session: input.fork
-        ? await input.client.session
-            .fork({ sessionID: explicit.id }, ...requestOptions(input.signal))
-            .catch((error) => {
-              throw new SessionTargetMutationError(error)
-            })
-        : explicit,
-    }
-  if (!input.continue) return { session: undefined }
-
-  const location = await resolveLocation(input.client, input.location, input.signal)
-  const selected = await latestSession(input.client, location, undefined, input.signal)
-  if (!selected) return { session: undefined, location }
-  return {
-    session: input.fork
-      ? await input.client.session.fork({ sessionID: selected.id }, ...requestOptions(input.signal)).catch((error) => {
-          throw new SessionTargetMutationError(error)
-        })
-      : selected,
-  }
-}
-
-async function latestSession(
-  client: OpenCodeClient,
-  location: LocationGetOutput,
-  cursor?: string,
-  signal?: AbortSignal,
-): Promise<SessionInfo | undefined> {
-  const page = await client.session.list(
-    {
-      directory: location.directory,
-      workspace: location.workspaceID,
-      parentID: null,
-      limit: SESSION_PAGE_LIMIT,
-      order: "desc",
-      ...(cursor ? { cursor } : {}),
-    },
-    ...requestOptions(signal),
-  )
-  const selected = page.data.find(
-    (session) =>
-      session.location.directory === location.directory && session.location.workspaceID === location.workspaceID,
-  )
-  if (selected) return selected
-  if (!page.cursor.next || page.data.length === 0) return
-  return latestSession(client, location, page.cursor.next, signal)
-}
-
-function resolveLocation(
-  client: OpenCodeClient,
-  location?: { directory?: string; workspace?: string },
-  signal?: AbortSignal,
-) {
-  if (!location && !signal) return client.location.get()
-  if (!location) return client.location.get(undefined, { signal })
-  return client.location.get({ location }, ...requestOptions(signal))
-}
-
-function requestOptions(signal?: AbortSignal): [] | [{ signal: AbortSignal }] {
-  return signal ? [{ signal }] : []
-}

packages/cli/test/drive/mini-interactive.drive.mjs

@@ -1,281 +0,0 @@
-import { Effect } from "effect"
-import { defineScript, Llm } from "opencode-drive"
-import { mkdir } from "node:fs/promises"
-import path from "node:path"
-
-export default defineScript({
-  launch: "manual",
-  config: { autoupdate: false },
-  run: ({ artifacts, llm, server }) =>
-    Effect.gen(function* () {
-      yield* Effect.promise(() => configureServicePort(artifacts))
-      yield* server.launch()
-
-      const registration = yield* Effect.promise(() => serviceRegistration(artifacts))
-      const root = path.resolve(import.meta.dir, "../../../..")
-      const preload = Bun.resolveSync("@opentui/solid/preload", path.join(root, "packages/cli"))
-      const session = `mini-stage2-${process.pid}`
-      const snapshots = path.join(artifacts, "mini-stage2")
-      yield* Effect.promise(() => mkdir(snapshots, { recursive: true }))
-
-      yield* llm.queue(
-        Llm.toolCall({
-          index: 0,
-          id: "mini-shell",
-          name: "shell",
-          input: { command: "printf 'drive-mini-tool-output\\n'" },
-        }),
-        Llm.finish("tool-calls"),
-      )
-      yield* llm.queue(Llm.text("drive mini response complete", { delay: 5, chunkSize: 4 }))
-
-      const journey = Effect.gen(function* () {
-        yield* Effect.uninterruptible(
-          Effect.promise(() =>
-            tmux([
-              "new-session",
-              "-d",
-              "-s",
-              session,
-              "-x",
-              "140",
-              "-y",
-              "30",
-              "--",
-              "env",
-              `PWD=${path.join(artifacts, "files")}`,
-              `OPENCODE_PASSWORD=${registration.password}`,
-              `OPENCODE_CONFIG_DIR=${path.join(artifacts, "files/.opencode")}`,
-              `OPENCODE_TEST_HOME=${artifacts}`,
-              `XDG_CACHE_HOME=${path.join(artifacts, "home/.cache")}`,
-              `XDG_CONFIG_HOME=${path.join(artifacts, "home/.config")}`,
-              `XDG_DATA_HOME=${path.join(artifacts, "logs")}`,
-              `XDG_STATE_HOME=${path.join(artifacts, "home/.local/state")}`,
-              "OPENCODE_DISABLE_AUTOUPDATE=1",
-              "OPENCODE_DIRECT_TRACE=1",
-              process.execPath,
-              "--conditions=browser",
-              `--preload=${preload}`,
-              path.join(root, "packages/cli/src/index.ts"),
-              "mini",
-              "--server",
-              registration.url,
-              "--model",
-              "simulation/gpt-sim-model",
-            ]),
-          ),
-        )
-        yield* Effect.promise(() => tmux(["set-option", "-t", session, "remain-on-exit", "on"]))
-
-        const first = yield* Effect.promise(() => waitForPane(session, "OpenCode"))
-        yield* Effect.promise(() => Bun.write(path.join(snapshots, "01-first-paint.txt"), first))
-        if (first.includes("drive mini response complete"))
-          throw new Error("response rendered before prompt submission")
-
-        yield* Effect.promise(() => waitForPane(session, "Simulated Model", 15_000))
-        yield* Effect.promise(() => tmux(["send-keys", "-t", session, "-l", "exercise the mini frontend"]))
-        yield* Effect.sleep(100)
-        yield* Effect.promise(() => tmux(["send-keys", "-H", "-t", session, "0d"]))
-        const completed = yield* Effect.promise(() => waitForPane(session, "drive mini response complete", 20_000))
-        if (!completed.includes("drive-mini-tool-output")) throw new Error("shell tool output was not rendered")
-        yield* Effect.promise(() => Bun.write(path.join(snapshots, "02-tool-and-response.txt"), completed))
-
-        yield* Effect.sleep(500)
-        const resizeOutput = path.join(snapshots, "03-resize-output.ansi")
-        yield* Effect.promise(() => tmux(["pipe-pane", "-t", session, `cat > ${JSON.stringify(resizeOutput)}`]))
-        yield* Effect.promise(() => tmux(["resize-window", "-t", session, "-x", "72", "-y", "22"]))
-        yield* Effect.promise(() =>
-          waitForFile(
-            resizeOutput,
-            (value) => value.includes("drive mini response complete") && value.includes("drive-mini-tool-output"),
-          ),
-        )
-        yield* Effect.promise(() => tmux(["pipe-pane", "-t", session]))
-        const resized = yield* Effect.promise(() => captureVisiblePane(session))
-        if (!resized.includes("drive-mini-tool-output")) throw new Error("resize replay lost shell tool output")
-        yield* Effect.promise(() => Bun.write(path.join(snapshots, "03-resize-replay.txt"), resized))
-
-        yield* llm.queue(
-          Llm.toolCall({
-            index: 0,
-            id: "mini-question",
-            name: "question",
-            input: {
-              questions: [
-                {
-                  header: "Drive form",
-                  question: "Choose the Mini Form answer",
-                  options: [{ label: "Accepted", description: "Continue the run" }],
-                  multiple: false,
-                },
-              ],
-            },
-          }),
-          Llm.finish("tool-calls"),
-        )
-        yield* llm.queue(Llm.text("drive mini form complete"))
-        yield* Effect.promise(() => tmux(["send-keys", "-t", session, "-l", "exercise the form"]))
-        yield* Effect.promise(() => tmux(["send-keys", "-H", "-t", session, "0d"]))
-        yield* Effect.promise(() => waitForPane(session, "Choose the Mini Form answer", 20_000))
-        yield* Effect.promise(() => tmux(["send-keys", "-H", "-t", session, "0d"]))
-        yield* Effect.promise(() => waitForPane(session, "drive mini form complete", 20_000))
-
-        yield* llm.queue(
-          Llm.toolCall({
-            index: 0,
-            id: "mini-slow-shell",
-            name: "shell",
-            input: { command: "sleep 10" },
-          }),
-          Llm.finish("tool-calls"),
-        )
-        yield* Effect.promise(() => tmux(["send-keys", "-t", session, "-l", "interrupt this turn"]))
-        yield* Effect.sleep(100)
-        yield* Effect.promise(() => tmux(["send-keys", "-H", "-t", session, "0d"]))
-        yield* Effect.promise(() => waitForPane(session, "$ sleep 10"))
-        yield* Effect.promise(() => tmux(["send-keys", "-t", session, "Escape"]))
-        const armed = yield* Effect.promise(() => waitForPane(session, "again to interrupt"))
-        yield* Effect.promise(() => Bun.write(path.join(snapshots, "04-interrupt-armed.txt"), armed))
-        yield* Effect.promise(() => tmux(["send-keys", "-t", session, "Escape"]))
-        const interrupted = yield* Effect.promise(() => waitForPane(session, "Step interrupted", 10_000))
-        yield* Effect.promise(() => Bun.write(path.join(snapshots, "05-interrupted.txt"), interrupted))
-
-        yield* Effect.promise(async () => {
-          if (!(await paneAlive(session))) throw new Error("Mini exited while interrupting an active turn")
-        })
-        yield* Effect.promise(() => tmux(["send-keys", "-t", session, "C-c"]))
-        yield* Effect.promise(() => waitForPane(session, "Press ctrl+c again to exit"))
-        yield* Effect.promise(() => tmux(["send-keys", "-t", session, "C-c"]))
-        yield* Effect.promise(() => waitForDeadPane(session))
-        const status = yield* Effect.promise(() => paneDeadStatus(session))
-        if (status !== 0) throw new Error(`Mini exited with status ${status}`)
-        const exited = yield* Effect.promise(() => capturePane(session))
-        if (!exited.includes("Continue") || !exited.includes("opencode mini -s"))
-          throw new Error("Mini exit splash was not rendered before teardown")
-        yield* Effect.promise(() => Bun.write(path.join(snapshots, "06-exit-teardown.txt"), exited))
-      })
-
-      yield* journey.pipe(Effect.ensuring(Effect.promise(() => tmux(["kill-session", "-t", session], true))))
-    }),
-})
-
-/** @param {string[]} args */
-async function tmux(args, allowFailure = false) {
-  const child = Bun.spawn(["tmux", ...args], { stdout: "pipe", stderr: "pipe" })
-  let timedOut = false
-  const timeout = setTimeout(() => {
-    timedOut = true
-    child.kill("SIGKILL")
-  }, 5_000)
-  const [status, stdout, stderr] = await Promise.all([
-    child.exited,
-    new Response(child.stdout).text(),
-    new Response(child.stderr).text(),
-  ])
-  clearTimeout(timeout)
-  if (timedOut) throw new Error(`tmux ${args[0]} timed out`)
-  if (status !== 0 && !allowFailure) throw new Error(`tmux ${args[0]} failed: ${stderr || stdout}`)
-  return stdout
-}
-
-/** @param {string} session */
-function capturePane(session) {
-  return tmux(["capture-pane", "-p", "-t", session, "-S", "-"])
-}
-
-/** @param {string} session */
-function captureVisiblePane(session) {
-  return tmux(["capture-pane", "-p", "-t", session])
-}
-
-/** @param {string} session */
-async function paneAlive(session) {
-  return (await tmux(["display-message", "-p", "-t", session, "#{pane_dead}"], true)).trim() === "0"
-}
-
-/** @param {string} session */
-async function paneDeadStatus(session) {
-  return Number((await tmux(["display-message", "-p", "-t", session, "#{pane_dead_status}"])).trim())
-}
-
-/**
- * @param {string} session
- * @param {string} text
- * @param {number} [timeout]
- * @param {(() => Promise<void>) | undefined} [trigger]
- */
-async function waitForPane(session, text, timeout = 5_000, trigger) {
-  const deadline = Date.now() + timeout
-  let last = ""
-  while (Date.now() < deadline) {
-    await trigger?.()
-    last = await capturePane(session)
-    if (last.includes(text)) return last
-    if (!(await paneAlive(session))) throw new Error(`Mini exited before rendering ${JSON.stringify(text)}:\n${last}`)
-    await Bun.sleep(50)
-  }
-  throw new Error(`Timed out waiting for ${JSON.stringify(text)}:\n${last}`)
-}
-
-/** @param {string} session */
-async function waitForDeadPane(session) {
-  for (let attempt = 0; attempt < 100; attempt++) {
-    if (!(await paneAlive(session))) return
-    await Bun.sleep(50)
-  }
-  throw new Error("Mini did not tear down after the exit sequence")
-}
-
-/**
- * @param {string} file
- * @param {(value: string) => boolean} accept
- */
-async function waitForFile(file, accept) {
-  let value = ""
-  for (let attempt = 0; attempt < 100; attempt++) {
-    value = await Bun.file(file)
-      .text()
-      .catch(() => "")
-    if (accept(value)) return value
-    await Bun.sleep(50)
-  }
-  throw new Error("resize did not replay committed transcript output")
-}
-
-/** @param {string} artifacts */
-async function configureServicePort(artifacts) {
-  const probe = Bun.serve({ hostname: "127.0.0.1", port: 0, fetch: () => new Response() })
-  const port = probe.port
-  await probe.stop(true)
-  if (!port) throw new Error("Failed to allocate a Drive service port")
-  const file = path.join(artifacts, "files/.opencode/service-local.json")
-  await mkdir(path.dirname(file), { recursive: true })
-  await Bun.write(file, JSON.stringify({ port }))
-}
-
-/** @param {string} artifacts */
-async function serviceRegistration(artifacts) {
-  const directory = path.join(artifacts, "home/.local/state/opencode")
-  for (let attempt = 0; attempt < 200; attempt++) {
-    for (const name of ["service-local.json", "service.json"]) {
-      const value = await Bun.file(path.join(directory, name))
-        .json()
-        .catch(() => undefined)
-      if (isRegistration(value)) return value
-    }
-    await Bun.sleep(50)
-  }
-  throw new Error("Drive service registration was not written")
-}
-
-/** @param {unknown} value */
-function isRegistration(value) {
-  return (
-    typeof value === "object" &&
-    value !== null &&
-    "url" in value &&
-    typeof value.url === "string" &&
-    "password" in value &&
-    typeof value.password === "string"
-  )
-}

packages/cli/test/drive/run-smoke.drive.mjs

@@ -1,87 +0,0 @@
-import { defineScript } from "opencode-drive"
-import { mkdir } from "node:fs/promises"
-import path from "node:path"
-
-export default defineScript({
-  launch: "manual",
-  setup({ config }) {
-    config.autoupdate = false
-  },
-  async run({ artifacts, llm, server }) {
-    await configureServicePort(artifacts)
-    llm.queue(llm.text("drive noninteractive smoke ok"))
-    await server.launch()
-
-    const registration = await serviceRegistration(artifacts)
-    const root = path.resolve(import.meta.dir, "../../../..")
-    const directory = path.join(artifacts, "files")
-    const child = Bun.spawn(
-      [
-        process.execPath,
-        path.join(root, "packages/cli/src/index.ts"),
-        "run",
-        "--server",
-        registration.url,
-        "drive smoke",
-      ],
-      {
-        cwd: path.join(root, "packages/cli"),
-        env: {
-          ...process.env,
-          PWD: directory,
-          OPENCODE_PASSWORD: registration.password,
-          OPENCODE_CONFIG_DIR: path.join(directory, ".opencode"),
-          OPENCODE_DISABLE_AUTOUPDATE: "1",
-        },
-        stdin: "ignore",
-        stdout: "pipe",
-        stderr: "pipe",
-      },
-    )
-    const [exitCode, stdout, stderr] = await Promise.all([
-      child.exited,
-      new Response(child.stdout).text(),
-      new Response(child.stderr).text(),
-    ])
-    if (exitCode !== 0) throw new Error(`run exited ${exitCode}: ${stderr}`)
-    if (stdout !== "drive noninteractive smoke ok\n") throw new Error(`unexpected run output: ${stdout}`)
-  },
-})
-
-/** @param {string} artifacts */
-async function configureServicePort(artifacts) {
-  const probe = Bun.serve({ hostname: "127.0.0.1", port: 0, fetch: () => new Response() })
-  const port = probe.port
-  await probe.stop(true)
-  if (!port) throw new Error("Failed to allocate a Drive service port")
-  const file = path.join(artifacts, "files/.opencode/service-local.json")
-  await mkdir(path.dirname(file), { recursive: true })
-  await Bun.write(file, JSON.stringify({ port }))
-}
-
-/** @param {string} artifacts */
-async function serviceRegistration(artifacts) {
-  const directory = path.join(artifacts, "home/.local/state/opencode")
-  for (let attempt = 0; attempt < 200; attempt++) {
-    for (const name of ["service-local.json", "service.json"]) {
-      const value = await Bun.file(path.join(directory, name))
-        .json()
-        .catch(() => undefined)
-      if (isRegistration(value)) return value
-    }
-    await Bun.sleep(50)
-  }
-  throw new Error("Drive service registration was not written")
-}
-
-/** @param {unknown} value */
-function isRegistration(value) {
-  return (
-    typeof value === "object" &&
-    value !== null &&
-    "url" in value &&
-    typeof value.url === "string" &&
-    "password" in value &&
-    typeof value.password === "string"
-  )
-}