fix(app): use custom composer scrollbar

bun.lock

@@ -67,7 +67,6 @@
         "@opencode-ai/sdk": "file:vendor/opencode-ai-sdk-1.18.8-dev.tgz",
         "@opencode-ai/session-ui": "workspace:*",
         "@opencode-ai/ui": "workspace:*",
-        "@opencode-ai/util": "workspace:*",
         "@pierre/trees": "1.0.0-beta.4",
         "@sentry/solid": "catalog:",
         "@shikijs/transformers": "3.9.2",
@@ -521,7 +520,6 @@
         "@opencode-ai/core": "workspace:*",
         "@opencode-ai/session-ui": "workspace:*",
         "@opencode-ai/ui": "workspace:*",
-        "@opencode-ai/util": "workspace:*",
         "@pierre/diffs": "catalog:",
         "@solidjs/meta": "catalog:",
         "@solidjs/router": "catalog:",

packages/ai/example/tutorial.ts

@@ -33,10 +33,9 @@ const model = OpenAI.configure({
 //
 //   - `generation`: common controls such as max tokens, temperature, topP/topK,
 //     penalties, seed, and stop sequences.
-//   - `cache`: provider-neutral prompt caching behavior and cache affinity.
 //   - `providerOptions`: namespaced provider-native behavior. For example,
-//     OpenAI store behavior, Anthropic thinking, Gemini thinking config, or
-//     OpenRouter routing/reasoning.
+//     OpenAI cache keys and store behavior, Anthropic thinking, Gemini thinking
+//     config, or OpenRouter routing/reasoning.
 //   - `http`: last-resort serializable overlays for final request body, headers,
 //     and query params. Prefer typed `providerOptions` when a field is stable.
 //
@@ -46,7 +45,9 @@ const request = LLM.request({
   system: "You are concise and practical.",
   prompt: "Tell me a joke",
   generation: { maxTokens: 80, temperature: 0.7 },
-  cache: { mode: "auto", key: "tutorial-joke" },
+  providerOptions: {
+    openai: { promptCacheKey: "tutorial-joke" },
+  },
 })
 
 // 3. `generate` sends the request and collects the event stream into one

packages/ai/src/cache-policy.ts

@@ -10,16 +10,16 @@
 //
 // Manual `cache: CacheHint` placements on individual parts are preserved and
 // count against the four-breakpoint budget; auto only fills remaining slots.
-import { CacheHint, type CacheExplicit, type CachePolicy } from "./schema/options"
+import { CacheHint, type CachePolicy, type CachePolicyObject } from "./schema/options"
 import { LLMRequest, Message, ToolDefinition, type ContentPart } from "./schema/messages"
 
-const AUTO: Omit<CacheExplicit, "mode" | "key"> = {
+const AUTO: CachePolicyObject = {
   tools: true,
   system: true,
   messages: { tail: 1 },
 }
 
-const NONE: Omit<CacheExplicit, "mode" | "key"> = {}
+const NONE: CachePolicyObject = {}
 const BREAKPOINT_CAP = 4
 
 // Resolution rules:
@@ -29,8 +29,8 @@ const BREAKPOINT_CAP = 4
 //   - "auto"      → tools + first/last system + final message boundary.
 //   - "none"      → no auto placement; manual `CacheHint`s still flow.
 //   - object form → exactly what the caller asked for.
-const resolve = (policy: CachePolicy | undefined): Omit<CacheExplicit, "mode" | "key"> => {
-  if (policy === undefined || (policy !== "none" && policy.mode === "auto")) return AUTO
+const resolve = (policy: CachePolicy | undefined): CachePolicyObject => {
+  if (policy === undefined || policy === "auto") return AUTO
   if (policy === "none") return NONE
   return policy
 }
@@ -38,7 +38,7 @@ const resolve = (policy: CachePolicy | undefined): Omit<CacheExplicit, "mode" |
 // Protocols whose wire format ignores inline cache markers (OpenAI's implicit
 // prefix caching, Gemini's implicit + out-of-band CachedContent). Skip the
 // whole policy pass for these — emitting hints would be harmless but pointless.
-const RESPECTS_INLINE_HINTS = new Set(["anthropic-messages", "bedrock-converse", "openrouter"])
+const RESPECTS_INLINE_HINTS = new Set(["anthropic-messages", "bedrock-converse"])
 
 const makeHint = (ttlSeconds: number | undefined): CacheHint =>
   ttlSeconds !== undefined ? new CacheHint({ type: "ephemeral", ttlSeconds }) : new CacheHint({ type: "ephemeral" })
@@ -103,7 +103,7 @@ const markMessageAt = (
 
 const markMessages = (
   messages: ReadonlyArray<Message>,
-  strategy: NonNullable<CacheExplicit["messages"]>,
+  strategy: NonNullable<CachePolicyObject["messages"]>,
   hint: CacheHint,
   budget: Budget,
 ): ReadonlyArray<Message> => {
@@ -133,11 +133,6 @@ const countHints = (request: LLMRequest) =>
 
 export const applyCachePolicy = (request: LLMRequest): LLMRequest => {
   if (!RESPECTS_INLINE_HINTS.has(request.model.route.id)) return request
-  if (
-    request.model.route.id === "openrouter" &&
-    (request.cache === undefined || (request.cache !== "none" && request.cache.mode === "auto"))
-  )
-    return request
   const policy = resolve(request.cache)
   if (!policy.tools && !policy.system && !policy.messages) return request
 

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

@@ -3,7 +3,6 @@ import type { Content } from "@opencode-ai/schema/tool"
 import { HttpTransport } from "../route/transport"
 import { Protocol } from "../route/protocol"
 import {
-  cacheKey,
   LLMError,
   LLMEvent,
   Usage,
@@ -543,7 +542,7 @@ const lowerOptions = (request: LLMRequest) => {
   return {
     ...(options.instructions ? { instructions: options.instructions } : {}),
     ...(options.store !== undefined ? { store: options.store } : {}),
-    ...(cacheKey(request.cache) ? { prompt_cache_key: cacheKey(request.cache) } : {}),
+    ...(options.promptCacheKey ? { prompt_cache_key: options.promptCacheKey } : {}),
     ...(options.include ? { include: options.include } : {}),
     ...(options.reasoningEffort || options.reasoningSummary
       ? { reasoning: { effort: options.reasoningEffort, summary: options.reasoningSummary } }

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

@@ -11,7 +11,6 @@ import {
   Usage,
   type FinishReason,
   type FinishReasonDetails,
-  type CacheHint,
   type JsonSchema,
   type LLMRequest,
   type MediaPart,
@@ -39,11 +38,6 @@ export const PATH = "/chat/completions"
 // The body schema is the provider-native JSON body. `fromRequest` below builds
 // this shape from the common `LLMRequest`, then `Route.make` validates and
 // JSON-encodes it before transport.
-const OpenAIChatCacheControl = Schema.Struct({
-  type: Schema.Literal("ephemeral"),
-  ttl: Schema.optional(Schema.String),
-})
-
 const OpenAIChatFunction = Schema.Struct({
   name: Schema.String,
   description: Schema.String,
@@ -53,7 +47,6 @@ const OpenAIChatFunction = Schema.Struct({
 const OpenAIChatTool = Schema.Struct({
   type: Schema.tag("function"),
   function: OpenAIChatFunction,
-  cache_control: Schema.optional(OpenAIChatCacheControl),
 })
 type OpenAIChatTool = Schema.Schema.Type<typeof OpenAIChatTool>
 
@@ -68,11 +61,7 @@ const OpenAIChatAssistantToolCall = Schema.Struct({
 type OpenAIChatAssistantToolCall = Schema.Schema.Type<typeof OpenAIChatAssistantToolCall>
 
 const OpenAIChatUserContent = Schema.Union([
-  Schema.Struct({
-    type: Schema.Literal("text"),
-    text: Schema.String,
-    cache_control: Schema.optional(OpenAIChatCacheControl),
-  }),
+  Schema.Struct({ type: Schema.Literal("text"), text: Schema.String }),
   Schema.Struct({
     type: Schema.Literal("image_url"),
     image_url: Schema.Struct({ url: Schema.String }),
@@ -80,10 +69,7 @@ const OpenAIChatUserContent = Schema.Union([
 ])
 
 const OpenAIChatMessage = Schema.Union([
-  Schema.Struct({
-    role: Schema.Literal("system"),
-    content: Schema.Union([Schema.String, Schema.Array(OpenAIChatUserContent)]),
-  }),
+  Schema.Struct({ role: Schema.Literal("system"), content: Schema.String }),
   Schema.Struct({
     role: Schema.Literal("user"),
     content: Schema.Union([Schema.String, Schema.Array(OpenAIChatUserContent)]),
@@ -97,16 +83,10 @@ const OpenAIChatMessage = Schema.Union([
       reasoning: Schema.optional(Schema.String),
       reasoning_text: Schema.optional(Schema.String),
       reasoning_details: Schema.optional(Schema.Unknown),
-      cache_control: Schema.optional(OpenAIChatCacheControl),
     }),
     [Schema.Record(Schema.String, Schema.Unknown)],
   ),
-  Schema.Struct({
-    role: Schema.Literal("tool"),
-    tool_call_id: Schema.String,
-    content: Schema.String,
-    cache_control: Schema.optional(OpenAIChatCacheControl),
-  }),
+  Schema.Struct({ role: Schema.Literal("tool"), tool_call_id: Schema.String, content: Schema.String }),
 ]).pipe(Schema.toTaggedUnion("role"))
 type OpenAIChatMessage = Schema.Schema.Type<typeof OpenAIChatMessage>
 
@@ -127,7 +107,6 @@ export const bodyFields = {
   stream_options: Schema.optional(Schema.Struct({ include_usage: Schema.Boolean })),
   store: Schema.optional(Schema.Boolean),
   reasoning_effort: Schema.optional(OpenAIOptions.OpenAIReasoningEffort),
-  max_completion_tokens: Schema.optional(Schema.Number),
   max_tokens: Schema.optional(Schema.Number),
   temperature: Schema.optional(Schema.Number),
   top_p: Schema.optional(Schema.Number),
@@ -230,20 +209,13 @@ export interface ParserState {
 // Lowering is the only place that knows how common LLM messages map onto the
 // OpenAI Chat wire format. Keep provider quirks here instead of leaking native
 // fields into `LLMRequest`.
-interface LoweringOptions {
-  readonly cacheControl?: (
-    cache: CacheHint | undefined,
-  ) => Schema.Schema.Type<typeof OpenAIChatCacheControl> | undefined
-}
-
-const lowerTool = (tool: ToolDefinition, inputSchema: JsonSchema, options: LoweringOptions): OpenAIChatTool => ({
+const lowerTool = (tool: ToolDefinition, inputSchema: JsonSchema): OpenAIChatTool => ({
   type: "function",
   function: {
     name: tool.name,
     description: tool.description,
     parameters: ToolSchemaProjection.openAI(inputSchema),
   },
-  cache_control: options.cacheControl?.(tool.cache),
 })
 
 const lowerToolChoice = (toolChoice: NonNullable<LLMRequest["toolChoice"]>) =>
@@ -285,14 +257,11 @@ const reasoningDetails = (parts: ReadonlyArray<ReasoningPart>, native: unknown)
   if (isRecord(native) && Array.isArray(native.reasoning_details)) return native.reasoning_details
 }
 
-const lowerUserMessage = Effect.fn("OpenAIChat.lowerUserMessage")(function* (
-  message: OpenAIChatRequestMessage,
-  options: LoweringOptions,
-) {
+const lowerUserMessage = Effect.fn("OpenAIChat.lowerUserMessage")(function* (message: OpenAIChatRequestMessage) {
   const content: Array<Schema.Schema.Type<typeof OpenAIChatUserContent>> = []
   for (const part of message.content) {
     if (part.type === "text") {
-      content.push({ type: "text", text: part.text, cache_control: options.cacheControl?.(part.cache) })
+      content.push({ type: "text", text: part.text })
       continue
     }
     if (part.type === "media") {
@@ -301,18 +270,14 @@ const lowerUserMessage = Effect.fn("OpenAIChat.lowerUserMessage")(function* (
     }
     return yield* ProviderShared.unsupportedContent("OpenAI Chat", "user", ["text", "media"])
   }
-  if (content.every((part) => part.type === "text" && part.cache_control === undefined))
-    return {
-      role: "user" as const,
-      content: content.map((part) => (part.type === "text" ? part.text : "")).join(""),
-    }
+  if (content.every((part) => part.type === "text"))
+    return { role: "user" as const, content: content.map((part) => part.text).join("") }
   return { role: "user" as const, content }
 })
 
 const lowerAssistantMessage = Effect.fn("OpenAIChat.lowerAssistantMessage")(function* (
   message: OpenAIChatRequestMessage,
   configuredField?: string,
-  options: LoweringOptions = {},
 ) {
   const content: TextPart[] = []
   const reasoning: ReasoningPart[] = []
@@ -350,44 +315,29 @@ const lowerAssistantMessage = Effect.fn("OpenAIChat.lowerAssistantMessage")(func
     if (reasoning.length === 0) return nativeReasoning
     return text
   })()
-  const cached = message.content.findLast((part) => "cache" in part && part.cache !== undefined)
   const result = {
     role: "assistant" as const,
     content: content.length === 0 ? null : ProviderShared.joinText(content),
     tool_calls: toolCalls.length === 0 ? undefined : toolCalls,
     reasoning_details: details,
-    cache_control: options.cacheControl?.(cached && "cache" in cached ? cached.cache : undefined),
   }
   if (field === undefined || reasoningText === undefined) return result
   return { ...result, [field]: reasoningText }
 })
 
-const lowerToolMessages = Effect.fn("OpenAIChat.lowerToolMessages")(function* (
-  message: OpenAIChatRequestMessage,
-  options: LoweringOptions,
-) {
+const lowerToolMessages = Effect.fn("OpenAIChat.lowerToolMessages")(function* (message: OpenAIChatRequestMessage) {
   const messages: OpenAIChatMessage[] = []
   const images: Array<Schema.Schema.Type<typeof OpenAIChatUserContent>> = []
   for (const part of message.content) {
     if (!ProviderShared.supportsContent(part, ["tool-result"]))
       return yield* ProviderShared.unsupportedContent("OpenAI Chat", "tool", ["tool-result"])
     if (part.result.type !== "content") {
-      messages.push({
-        role: "tool",
-        tool_call_id: part.id,
-        content: ProviderShared.toolResultText(part),
-        cache_control: options.cacheControl?.(part.cache),
-      })
+      messages.push({ role: "tool", tool_call_id: part.id, content: ProviderShared.toolResultText(part) })
       continue
     }
     const content: ReadonlyArray<Tool.Content> = part.result.value
     const text = content.filter((item) => item.type === "text").map((item) => item.text)
-    messages.push({
-      role: "tool",
-      tool_call_id: part.id,
-      content: text.join("\n"),
-      cache_control: options.cacheControl?.(part.cache),
-    })
+    messages.push({ role: "tool", tool_call_id: part.id, content: text.join("\n") })
     const files = content.filter((item) => item.type === "file")
     images.push(
       ...(yield* Effect.forEach(files, (item) =>
@@ -401,29 +351,15 @@ const lowerToolMessages = Effect.fn("OpenAIChat.lowerToolMessages")(function* (
 const lowerMessage = Effect.fn("OpenAIChat.lowerMessage")(function* (
   message: OpenAIChatRequestMessage,
   reasoningField?: string,
-  options: LoweringOptions = {},
 ) {
-  if (message.role === "user") return [yield* lowerUserMessage(message, options)]
-  if (message.role === "assistant") return [yield* lowerAssistantMessage(message, reasoningField, options)]
-  return (yield* lowerToolMessages(message, options)).messages
+  if (message.role === "user") return [yield* lowerUserMessage(message)]
+  if (message.role === "assistant") return [yield* lowerAssistantMessage(message, reasoningField)]
+  return (yield* lowerToolMessages(message)).messages
 })
 
-const lowerMessages = Effect.fn("OpenAIChat.lowerMessages")(function* (request: LLMRequest, options: LoweringOptions) {
+const lowerMessages = Effect.fn("OpenAIChat.lowerMessages")(function* (request: LLMRequest) {
   const system: OpenAIChatMessage[] =
-    request.system.length === 0
-      ? []
-      : request.system.some((part) => part.cache !== undefined) && options.cacheControl !== undefined
-        ? [
-            {
-              role: "system",
-              content: request.system.map((part) => ({
-                type: "text",
-                text: part.text,
-                cache_control: options.cacheControl?.(part.cache),
-              })),
-            },
-          ]
-        : [{ role: "system", content: ProviderShared.joinText(request.system) }]
+    request.system.length === 0 ? [] : [{ role: "system", content: ProviderShared.joinText(request.system) }]
   const messages = [...system]
   const pendingImages: Array<Schema.Schema.Type<typeof OpenAIChatUserContent>> = []
   const flushImages = () => {
@@ -434,53 +370,28 @@ const lowerMessages = Effect.fn("OpenAIChat.lowerMessages")(function* (request:
     if (message.role === "system") {
       const part = yield* ProviderShared.wrappedSystemUpdate("OpenAI Chat", message)
       if (pendingImages.length > 0) {
-        messages.push({
-          role: "user",
-          content: [
-            ...pendingImages.splice(0),
-            { type: "text", text: part.text, cache_control: options.cacheControl?.(part.cache) },
-          ],
-        })
+        messages.push({ role: "user", content: [...pendingImages.splice(0), { type: "text", text: part.text }] })
         continue
       }
       const previous = messages.at(-1)
       if (previous?.role === "user" && typeof previous.content === "string")
-        messages[messages.length - 1] = options.cacheControl?.(part.cache)
-          ? {
-              role: "user",
-              content: [
-                { type: "text", text: previous.content },
-                { type: "text", text: part.text, cache_control: options.cacheControl(part.cache) },
-              ],
-            }
-          : { role: "user", content: `${previous.content}\n${part.text}` }
+        messages[messages.length - 1] = { role: "user", content: `${previous.content}\n${part.text}` }
       else if (previous?.role === "user" && Array.isArray(previous.content))
         messages[messages.length - 1] = {
           role: "user",
-          content: [
-            ...previous.content,
-            { type: "text", text: part.text, cache_control: options.cacheControl?.(part.cache) },
-          ],
+          content: [...previous.content, { type: "text", text: part.text }],
         }
-      else
-        messages.push(
-          options.cacheControl?.(part.cache)
-            ? {
-                role: "user",
-                content: [{ type: "text", text: part.text, cache_control: options.cacheControl(part.cache) }],
-              }
-            : { role: "user", content: part.text },
-        )
+      else messages.push({ role: "user", content: part.text })
       continue
     }
     if (message.role === "tool") {
-      const lowered = yield* lowerToolMessages(message, options)
+      const lowered = yield* lowerToolMessages(message)
       messages.push(...lowered.messages)
       pendingImages.push(...lowered.images)
       continue
     }
     flushImages()
-    messages.push(...(yield* lowerMessage(message, request.model.compatibility?.reasoningField, options)))
+    messages.push(...(yield* lowerMessage(message, request.model.compatibility?.reasoningField)))
   }
   flushImages()
   return messages
@@ -494,10 +405,7 @@ const lowerOptions = (request: LLMRequest) => {
   }
 }
 
-export const fromRequest = Effect.fn("OpenAIChat.fromRequest")(function* (
-  request: LLMRequest,
-  options: LoweringOptions = {},
-) {
+const fromRequest = Effect.fn("OpenAIChat.fromRequest")(function* (request: LLMRequest) {
   // `fromRequest` returns the provider body only. Endpoint, auth, framing,
   // validation, and HTTP execution are composed by `Route.make`.
   const reasoningField = request.model.compatibility?.reasoningField
@@ -507,26 +415,19 @@ export const fromRequest = Effect.fn("OpenAIChat.fromRequest")(function* (
     )
   const generation = request.generation
   const toolSchemaCompatibility = request.model.compatibility?.toolSchema
-  const maxTokensField = request.model.compatibility?.maxTokensField ?? "max_tokens"
   return {
     model: request.model.id,
-    messages: yield* lowerMessages(request, options),
+    messages: yield* lowerMessages(request),
     tools:
       request.tools.length === 0
         ? undefined
         : request.tools.map((tool) =>
-            lowerTool(
-              tool,
-              ToolSchemaProjection.modelCompatibility(tool.inputSchema, toolSchemaCompatibility),
-              options,
-            ),
+            lowerTool(tool, ToolSchemaProjection.modelCompatibility(tool.inputSchema, toolSchemaCompatibility)),
           ),
     tool_choice: request.toolChoice ? yield* lowerToolChoice(request.toolChoice) : undefined,
     stream: true as const,
     stream_options: { include_usage: true },
-    ...(maxTokensField === "max_completion_tokens"
-      ? { max_completion_tokens: generation?.maxTokens }
-      : { max_tokens: generation?.maxTokens }),
+    max_tokens: generation?.maxTokens,
     temperature: generation?.temperature,
     top_p: generation?.topP,
     frequency_penalty: generation?.frequencyPenalty,

packages/ai/src/protocols/utils/open-responses-options.ts

@@ -33,6 +33,7 @@ export const ServiceTierSchema = Schema.Literals(ServiceTiers)
 export interface Resolved {
   readonly instructions?: string
   readonly store?: boolean
+  readonly promptCacheKey?: string
   readonly reasoningEffort?: string
   readonly reasoningSummary?: "auto" | "concise" | "detailed"
   readonly include?: ReadonlyArray<ResponseIncludable>
@@ -49,6 +50,7 @@ export const resolve = (request: LLMRequest): Resolved => {
   return {
     instructions: typeof input?.instructions === "string" ? input.instructions : undefined,
     store: typeof input?.store === "boolean" ? input.store : undefined,
+    promptCacheKey: typeof input?.promptCacheKey === "string" ? input.promptCacheKey : undefined,
     reasoningEffort: typeof input?.reasoningEffort === "string" ? input.reasoningEffort : undefined,
     reasoningSummary:
       reasoningSummary === "auto" || reasoningSummary === "concise" || reasoningSummary === "detailed"

packages/ai/src/provider-package.ts

@@ -6,7 +6,6 @@ export interface Settings extends Readonly<Record<string, unknown>> {
   readonly body?: Readonly<Record<string, unknown>>
   readonly limits?: {
     readonly context: number
-    readonly input?: number
     readonly output: number
   }
 }

packages/ai/src/providers/open-responses-options.ts

@@ -5,6 +5,7 @@ export interface OpenResponsesOptionsInput {
   readonly [key: string]: unknown
   readonly instructions?: string
   readonly store?: boolean
+  readonly promptCacheKey?: string
   readonly reasoningEffort?: ReasoningEffort
   readonly reasoningSummary?: "auto" | "concise" | "detailed"
   readonly include?: ReadonlyArray<ResponseIncludable>

packages/ai/src/providers/openai-options.ts

@@ -17,6 +17,7 @@ const openAIProviderOptions = (options: OpenAIOptionsInput | undefined): Provide
   const openai = Object.fromEntries(
     definedEntries({
       store: options?.store,
+      promptCacheKey: options?.promptCacheKey,
       reasoningEffort: options?.reasoningEffort,
       reasoningSummary: options?.reasoningSummary,
       include: options?.include,

packages/ai/src/providers/openrouter.ts

@@ -4,71 +4,21 @@ import { Endpoint } from "../route/endpoint"
 import { Framing } from "../route/framing"
 import { Protocol } from "../route/protocol"
 import { AuthOptions, type ProviderAuthOption } from "../route/auth-options"
-import { cacheKey, ProviderID, type CacheHint, type ModelID, type ProviderOptions } from "../schema"
+import { ProviderID, type ModelID, type ProviderOptions } from "../schema"
 import type { ProviderPackage } from "../provider-package"
 import * as OpenAICompatibleProfiles from "./openai-compatible-profile"
 import * as OpenAIChat from "../protocols/openai-chat"
-import { newBreakpoints, ttlBucket } from "../protocols/utils/cache"
 import { isRecord } from "../protocols/shared"
 
 export const profile = OpenAICompatibleProfiles.profiles.openrouter
 export const id = ProviderID.make(profile.provider)
 const ADAPTER = "openrouter"
 
-type OpenRouterString<Known extends string> = Known | (string & {})
-
-export interface OpenRouterProviderRouting {
-  readonly [key: string]: unknown
-  readonly order?: ReadonlyArray<string>
-  readonly allow_fallbacks?: boolean
-  readonly require_parameters?: boolean
-  readonly data_collection?: OpenRouterString<"allow" | "deny">
-  readonly only?: ReadonlyArray<string>
-  readonly ignore?: ReadonlyArray<string>
-  readonly quantizations?: ReadonlyArray<string>
-  readonly sort?: OpenRouterString<"price" | "throughput" | "latency">
-  readonly max_price?: Readonly<{
-    prompt?: number | string
-    completion?: number | string
-    image?: number | string
-    audio?: number | string
-    request?: number | string
-  }>
-  readonly zdr?: boolean
-}
-
-export type OpenRouterPlugin =
-  | Readonly<{
-      id: "web"
-      max_results?: number
-      search_prompt?: string
-      engine?: OpenRouterString<"native" | "exa">
-    }>
-  | Readonly<{ id: "file-parser"; max_files?: number; pdf?: { engine?: string } }>
-  | Readonly<{ id: "moderation" }>
-  | Readonly<{ id: "response-healing" }>
-  | Readonly<{ id: "auto-router"; allowed_models?: ReadonlyArray<string> }>
-  | Readonly<{ id: string & {}; [key: string]: unknown }>
-
 export interface OpenRouterOptions {
   readonly [key: string]: unknown
-  readonly debug?: Readonly<{ echo_upstream_body?: boolean }>
-  readonly models?: ReadonlyArray<string>
-  readonly plugins?: ReadonlyArray<OpenRouterPlugin>
-  readonly provider?: OpenRouterProviderRouting
-  readonly reasoning?: Readonly<{
-    enabled?: boolean
-    exclude?: boolean
-    effort?: OpenRouterString<"none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max">
-    max_tokens?: number
-  }>
-  readonly usage?: boolean | Readonly<{ include: boolean }>
-  readonly user?: string
-  readonly web_search_options?: Readonly<{
-    max_results?: number
-    search_prompt?: string
-    engine?: OpenRouterString<"native" | "exa">
-  }>
+  readonly usage?: boolean | Record<string, unknown>
+  readonly reasoning?: Record<string, unknown>
+  readonly promptCacheKey?: string
 }
 
 export type OpenRouterProviderOptionsInput = ProviderOptions & {
@@ -97,7 +47,7 @@ export const protocol = Protocol.make({
   body: {
     schema: OpenRouterBody,
     from: (request) =>
-      OpenAIChat.fromRequest(request, { cacheControl: cacheControl() }).pipe(
+      OpenAIChat.protocol.body.from(request).pipe(
         Effect.map((body) => {
           const sourceAssistants = request.messages.filter((message) => message.role === "assistant")
           let assistantIndex = 0
@@ -121,7 +71,6 @@ export const protocol = Protocol.make({
             ...body,
             messages,
             ...bodyOptions(request.providerOptions?.openrouter),
-            ...(cacheKey(request.cache) ? { prompt_cache_key: cacheKey(request.cache) } : {}),
           } as OpenRouterBody
         }),
       ),
@@ -129,38 +78,16 @@ export const protocol = Protocol.make({
   stream: OpenAIChat.protocol.stream,
 })
 
-const cacheControl = () => {
-  const breakpoints = newBreakpoints(4)
-  return (cache: CacheHint | undefined) => {
-    if (cache === undefined || breakpoints.remaining === 0) return undefined
-    breakpoints.remaining -= 1
-    return {
-      type: "ephemeral" as const,
-      ...(ttlBucket(cache.ttlSeconds) === "1h" ? { ttl: "1h" } : {}),
-    }
-  }
-}
-
 const bodyOptions = (input: unknown) => {
   const openrouter = isRecord(input) ? input : {}
-  const { usage, models, provider, plugins, web_search_options, debug, user, reasoning, promptCacheKey, ...options } =
-    openrouter
   return {
-    ...options,
-    ...(usage === undefined || usage === true
+    ...(openrouter.usage === true
       ? { usage: { include: true } }
-      : usage === false
-        ? { usage: { include: false } }
-        : isRecord(usage)
-          ? { usage }
-          : {}),
-    ...(Array.isArray(models) ? { models } : {}),
-    ...(isRecord(provider) ? { provider } : {}),
-    ...(Array.isArray(plugins) ? { plugins } : {}),
-    ...(isRecord(web_search_options) ? { web_search_options } : {}),
-    ...(isRecord(debug) ? { debug } : {}),
-    ...(typeof user === "string" ? { user } : {}),
-    ...(isRecord(reasoning) ? { reasoning } : {}),
+      : isRecord(openrouter.usage)
+        ? { usage: openrouter.usage }
+        : {}),
+    ...(isRecord(openrouter.reasoning) ? { reasoning: openrouter.reasoning } : {}),
+    ...(typeof openrouter.promptCacheKey === "string" ? { prompt_cache_key: openrouter.promptCacheKey } : {}),
   }
 }
 

packages/ai/src/route/transport/http.ts

@@ -28,9 +28,57 @@ const applyQuery = (url: string, query: Record<string, string> | undefined) => {
   return next.toString()
 }
 
+const PROTOCOL_BODY_OVERLAY_DENYLIST = new Set([
+  "anthropic_version",
+  "content",
+  "contents",
+  "frequencyPenalty",
+  "frequency_penalty",
+  "generationConfig",
+  "inferenceConfig",
+  "input",
+  "maxTokens",
+  "max_tokens",
+  "messages",
+  "model",
+  "presencePenalty",
+  "presence_penalty",
+  "responseFormat",
+  "response_format",
+  "seed",
+  "stop",
+  "stopSequences",
+  "stop_sequences",
+  "stream",
+  "streamOptions",
+  "stream_options",
+  "system",
+  "systemInstruction",
+  "system_instruction",
+  "temperature",
+  "thinking",
+  "toolChoice",
+  "toolConfig",
+  "tool_choice",
+  "tool_config",
+  "tools",
+  "topK",
+  "topP",
+  "top_k",
+  "top_p",
+])
+
+const forbiddenBodyOverlayKeys = (body: Record<string, unknown>) =>
+  Object.keys(body).filter((key) => PROTOCOL_BODY_OVERLAY_DENYLIST.has(key))
+
 const bodyWithOverlay = <Body>(body: Body, request: LLMRequest, encodeBody: (body: Body) => string) =>
   Effect.gen(function* () {
     if (request.http?.body === undefined) return { jsonBody: body, bodyText: encodeBody(body) }
+    const forbiddenKeys = forbiddenBodyOverlayKeys(request.http.body)
+    if (forbiddenKeys.length > 0)
+      return yield* ProviderShared.invalidRequest(
+        `http.body cannot overlay protocol-owned field(s): ${forbiddenKeys.join(", ")}`,
+      )
     if (ProviderShared.isRecord(body)) {
       const overlaid = mergeJsonRecords(body, request.http.body) ?? {}
       return { jsonBody: overlaid, bodyText: ProviderShared.encodeJson(overlaid) }

packages/ai/src/schema/messages.ts

@@ -124,7 +124,6 @@ export const ToolCallPart = Object.assign(
     name: Schema.String,
     input: Schema.Unknown,
     providerExecuted: Schema.optional(Schema.Boolean),
-    cache: Schema.optional(CacheHint),
     metadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
     providerMetadata: Schema.optional(ProviderMetadata),
   }).annotate({ identifier: "LLM.Content.ToolCall" }),
@@ -169,7 +168,6 @@ export const ReasoningPart = Schema.Struct({
   type: Schema.Literal("reasoning"),
   text: Schema.String,
   encrypted: Schema.optional(Schema.String),
-  cache: Schema.optional(CacheHint),
   metadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
   providerMetadata: Schema.optional(ProviderMetadata),
 }).annotate({ identifier: "LLM.Content.Reasoning" })

packages/ai/src/schema/options.ts

@@ -123,7 +123,6 @@ export const mergeGenerationOptions = (...items: ReadonlyArray<GenerationOptions
 
 export class ModelLimits extends Schema.Class<ModelLimits>("LLM.ModelLimits")({
   context: Schema.optional(Schema.Number),
-  input: Schema.optional(Schema.Number),
   output: Schema.optional(Schema.Number),
 }) {}
 
@@ -167,13 +166,9 @@ export namespace ModelDefaults {
 export const ModelToolSchemaCompatibility = Schema.Literals(["gemini", "moonshot"])
 export type ModelToolSchemaCompatibility = Schema.Schema.Type<typeof ModelToolSchemaCompatibility>
 
-export const ModelMaxTokensFieldCompatibility = Schema.Literals(["max_completion_tokens", "max_tokens"])
-export type ModelMaxTokensFieldCompatibility = Schema.Schema.Type<typeof ModelMaxTokensFieldCompatibility>
-
 export class ModelCompatibility extends Schema.Class<ModelCompatibility>("LLM.ModelCompatibility")({
   toolSchema: Schema.optional(ModelToolSchemaCompatibility),
   reasoningField: Schema.optional(Schema.String),
-  maxTokensField: Schema.optional(ModelMaxTokensFieldCompatibility),
 }) {}
 
 export namespace ModelCompatibility {
@@ -256,17 +251,18 @@ export class CacheHint extends Schema.Class<CacheHint>("LLM.CacheHint")({
   ttlSeconds: Schema.optional(Schema.Number),
 }) {}
 
-const CacheKey = { key: Schema.optional(Schema.String) }
-
-export const CacheAuto = Schema.Struct({
-  mode: Schema.Literal("auto"),
-  ...CacheKey,
-})
-export type CacheAuto = Schema.Schema.Type<typeof CacheAuto>
-
-export const CacheExplicit = Schema.Struct({
-  mode: Schema.Literal("explicit"),
-  ...CacheKey,
+// Auto-placement policy for prompt caching. The protocol-neutral lowering step
+// reads this and injects `CacheHint`s at the configured boundaries; the
+// per-protocol body builders then translate those hints into wire markers as
+// usual. `"auto"` is the recommended default for agent loops — it places
+// breakpoints at the last tool definition, the first and last distinct system
+// parts, and the conversation tail. The rolling message breakpoint keeps a
+// prior cache entry within Anthropic/Bedrock's 20-block lookback during long
+// tool loops.
+//
+// Pass `"none"` to opt out entirely (the legacy behavior). Pass the granular
+// object form to override individual choices.
+export const CachePolicyObject = Schema.Struct({
   tools: Schema.optional(Schema.Boolean),
   system: Schema.optional(Schema.Boolean),
   messages: Schema.optional(
@@ -278,12 +274,7 @@ export const CacheExplicit = Schema.Struct({
   ),
   ttlSeconds: Schema.optional(Schema.Number),
 })
-export type CacheExplicit = Schema.Schema.Type<typeof CacheExplicit>
+export type CachePolicyObject = Schema.Schema.Type<typeof CachePolicyObject>
 
-// Omitted configuration uses automatic provider behavior and OpenCode's
-// automatic breakpoint placement where required. `"none"` sends no cache key
-// or explicit controls; providers may still cache implicitly.
-export const CachePolicy = Schema.Union([Schema.Literal("none"), CacheAuto, CacheExplicit])
+export const CachePolicy = Schema.Union([Schema.Literal("auto"), Schema.Literal("none"), CachePolicyObject])
 export type CachePolicy = Schema.Schema.Type<typeof CachePolicy>
-
-export const cacheKey = (cache: CachePolicy | undefined) => (cache && cache !== "none" ? cache.key : undefined)

packages/ai/test/cache-policy.test.ts

@@ -64,7 +64,7 @@ describe("applyCachePolicy", () => {
             Message.assistant("assistant reply"),
             Message.user("latest user message"),
           ],
-          cache: { mode: "auto" },
+          cache: "auto",
         }),
       )
 
@@ -93,7 +93,7 @@ describe("applyCachePolicy", () => {
           model: openaiModel,
           system: "Sys",
           prompt: "hi",
-          cache: { mode: "auto" },
+          cache: "auto",
         }),
       )
 
@@ -112,7 +112,7 @@ describe("applyCachePolicy", () => {
           model: geminiModel,
           system: "Sys",
           prompt: "hi",
-          cache: { mode: "auto" },
+          cache: "auto",
         }),
       )
 
@@ -133,7 +133,7 @@ describe("applyCachePolicy", () => {
           ],
           tools: [{ name: "t1", description: "t1", inputSchema: { type: "object", properties: {} } }],
           messages: [Message.user("first user"), Message.assistant("reply"), Message.user("latest user")],
-          cache: { mode: "auto" },
+          cache: "auto",
         }),
       )
 
@@ -183,7 +183,7 @@ describe("applyCachePolicy", () => {
           system: "Sys",
           tools: [{ name: "t1", description: "t1", inputSchema: { type: "object", properties: {} } }],
           prompt: "hi",
-          cache: { mode: "explicit", tools: true },
+          cache: { tools: true },
         }),
       )
 
@@ -204,7 +204,7 @@ describe("applyCachePolicy", () => {
             { type: "text", text: "last system" },
           ],
           prompt: "hi",
-          cache: { mode: "auto" },
+          cache: "auto",
         }),
       )
 
@@ -233,7 +233,7 @@ describe("applyCachePolicy", () => {
         ],
         tools: [{ name: "t1", description: "t1", inputSchema: { type: "object", properties: {} } }],
         prompt: "hi",
-          cache: { mode: "auto" },
+        cache: "auto",
       })
       const applied = applyCachePolicy(request)
       expect(applied.tools[0]?.cache).toBeDefined()
@@ -267,7 +267,7 @@ describe("applyCachePolicy", () => {
           model: anthropicModel,
           system: "Sys",
           prompt: "hi",
-          cache: { mode: "explicit", system: true, ttlSeconds: 3600 },
+          cache: { system: true, ttlSeconds: 3600 },
         }),
       )
 
@@ -283,7 +283,7 @@ describe("applyCachePolicy", () => {
         LLM.request({
           model: anthropicModel,
           messages: [Message.user("u1"), Message.assistant("a1"), Message.user("u2"), Message.assistant("a2")],
-          cache: { mode: "explicit", messages: { tail: 2 } },
+          cache: { messages: { tail: 2 } },
         }),
       )
 
@@ -301,7 +301,7 @@ describe("applyCachePolicy", () => {
         LLM.request({
           model: anthropicModel,
           messages: [Message.user("u1"), Message.assistant("a1"), Message.user("u2")],
-          cache: { mode: "explicit", messages: "latest-assistant" },
+          cache: { messages: "latest-assistant" },
         }),
       )
 

packages/ai/test/compile.test.ts

@@ -171,27 +171,24 @@ describe("request option precedence", () => {
     ),
   )
 
-  it.effect("applies raw body overlays after protocol lowering", () =>
-    LLMClient.generate(
-      LLM.request({
-        model: OpenAIChat.route
-          .with({ endpoint: { baseURL: "https://api.openai.test/v1/" }, auth: Auth.bearer("test") })
-          .model({ id: "gpt-4o-mini" }),
-        prompt: "Say hello.",
-        http: { body: { model: "gpt-5", messages: [], tools: [] } },
-      }),
-    ).pipe(
-      Effect.provide(
-        dynamicResponse((input) =>
-          Effect.gen(function* () {
-            expect(decodeJson(input.text)).toMatchObject({ model: "gpt-5", messages: [], tools: [] })
-            return input.respond(sseEvents(deltaChunk({}, "stop")), {
-              headers: { "content-type": "text/event-stream" },
-            })
-          }),
-        ),
-      ),
-    ),
+  it.effect("rejects raw body overlays for protocol-owned roots", () =>
+    Effect.gen(function* () {
+      const model = OpenAIChat.route
+        .with({ endpoint: { baseURL: "https://api.openai.test/v1/" }, auth: Auth.bearer("test") })
+        .model({ id: "gpt-4o-mini" })
+      const error = yield* compileRequest(
+        LLM.request({
+          model,
+          prompt: "Say hello.",
+          http: { body: { model: "gpt-5", messages: [], tools: [] } },
+        }),
+      ).pipe(Effect.flip)
+
+      expect(error.reason).toMatchObject({
+        _tag: "InvalidRequest",
+        message: "http.body cannot overlay protocol-owned field(s): model, messages, tools",
+      })
+    }),
   )
 
   it.effect("uses model output limits after route limits and before call maxTokens", () =>

packages/ai/test/provider-options/cloudflare.types.ts

@@ -3,11 +3,11 @@ import { CloudflareWorkersAI } from "../../src/providers"
 
 const model = CloudflareWorkersAI.configure({ accountId: "account", apiKey: "test" }).model("model")
 
-LLM.request({ model, prompt: "Hello", cache: { mode: "auto", key: "cache" } })
+LLM.request({ model, prompt: "Hello", providerOptions: { openai: { promptCacheKey: "cache" } } })
 
 LLM.request({
   model,
   prompt: "Hello",
-  // @ts-expect-error Prompt cache keys must be strings.
-  cache: { mode: "auto", key: 1 },
+  // @ts-expect-error Cloudflare's OpenAI-compatible prompt cache key must be a string.
+  providerOptions: { openai: { promptCacheKey: 1 } },
 })

packages/ai/test/provider-options/openrouter.types.ts

@@ -5,28 +5,6 @@ const model = OpenRouter.provider.model("anthropic/claude-sonnet-4.5")
 
 LLM.request({ model, prompt: "Hello", providerOptions: { openrouter: { usage: true } } })
 
-LLM.request({
-  model,
-  prompt: "Hello",
-  providerOptions: {
-    openrouter: {
-      models: ["google/gemini-3.1-pro"],
-      provider: {
-        order: ["anthropic"],
-        require_parameters: true,
-        data_collection: "future-policy",
-        sort: "future-sort",
-        max_price: { prompt: "0.50" },
-      },
-      reasoning: { effort: "future-effort", exclude: false },
-      plugins: [{ id: "future-plugin", enabled: true }],
-      web_search_options: { engine: "future-engine" },
-      debug: { echo_upstream_body: true },
-      user: "user_123",
-    },
-  },
-})
-
 LLM.request({
   model,
   prompt: "Hello",

packages/ai/test/provider/google-vertex.test.ts

@@ -181,6 +181,23 @@ describe("Google Vertex providers", () => {
     }),
   )
 
+  it.effect("protects the Vertex Messages API version from body overlays", () =>
+    Effect.gen(function* () {
+      const error = yield* compileRequest(
+        LLM.request({
+          model: GoogleVertexMessages.configure({
+            accessToken: "vertex-token",
+            http: { body: { anthropic_version: "wrong" } },
+            project: "vertex-project",
+          }).model("claude-sonnet-4-6"),
+          prompt: "Say hello.",
+        }),
+      ).pipe(Effect.flip)
+
+      expect(error.message).toContain("http.body cannot overlay protocol-owned field(s): anthropic_version")
+    }),
+  )
+
   it.effect("routes tuned Gemini models through their deployed endpoint", () =>
     Effect.gen(function* () {
       const response = yield* LLMClient.generate(

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

@@ -144,20 +144,6 @@ describe("OpenAI-compatible Chat route", () => {
     }),
   )
 
-  it.effect("configures the max tokens request field", () =>
-    Effect.gen(function* () {
-      const compatible = OpenAICompatibleChat.route
-        .with({ provider: "custom", endpoint: { baseURL: "https://api.custom.test/v1" } })
-        .model({ id: "custom-model", compatibility: { maxTokensField: "max_completion_tokens" } })
-      const prepared = yield* compileRequest(
-        LLM.request({ model: compatible, prompt: "Say hello.", generation: { maxTokens: 20 } }),
-      )
-
-      expect(prepared.body).toMatchObject({ max_completion_tokens: 20 })
-      expect(prepared.body).not.toHaveProperty("max_tokens")
-    }),
-  )
-
   it.effect("matches AI SDK compatible tool request body fixture", () =>
     Effect.gen(function* () {
       const prepared = yield* compileRequest(

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

@@ -20,7 +20,7 @@ const cacheRequest = LLM.request({
   system: LARGE_CACHEABLE_SYSTEM,
   prompt: "Say hi.",
   generation: { maxTokens: 16, temperature: 0 },
-  cache: { mode: "auto", key: "recorded-cache-test" },
+  providerOptions: { openai: { promptCacheKey: "recorded-cache-test" } },
 })
 
 const recorded = recordedTests({

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

@@ -680,9 +680,9 @@ describe("OpenAI Responses route", () => {
         LLM.request({
           model: OpenAI.configure({ baseURL: "https://api.openai.test/v1/", apiKey: "test" }).model("gpt-5.2"),
           prompt: "think",
-          cache: { mode: "auto", key: "session_123" },
           providerOptions: {
             openai: {
+              promptCacheKey: "session_123",
               reasoningEffort: "high",
               reasoningSummary: "auto",
               include: ["reasoning.encrypted_content"],
@@ -801,16 +801,17 @@ describe("OpenAI Responses route", () => {
     }),
   )
 
-  it.effect("maps the request prompt cache key", () =>
+  it.effect("request OpenAI provider options override route defaults", () =>
     Effect.gen(function* () {
       const prepared = yield* compileRequest(
         LLM.request({
           model: OpenAI.configure({
             baseURL: "https://api.openai.test/v1/",
             apiKey: "test",
+            providerOptions: { openai: { promptCacheKey: "model_cache" } },
           }).model("gpt-4.1-mini"),
           prompt: "no cache",
-          cache: { mode: "auto", key: "request_cache" },
+          providerOptions: { openai: { promptCacheKey: "request_cache" } },
         }),
       )
 

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

@@ -1,6 +1,6 @@
 import { describe, expect } from "bun:test"
 import { Effect } from "effect"
-import { CacheHint, LLM, Message } from "../../src"
+import { LLM, Message } from "../../src"
 import { LLMClient } from "../../src/route"
 import { compileRequest } from "../../src/route/client"
 import * as OpenRouter from "../../src/providers/openrouter"
@@ -27,131 +27,10 @@ describe("OpenRouter", () => {
         model: "openai/gpt-4o-mini",
         messages: [{ role: "user", content: "Say hello." }],
         stream: true,
-        usage: { include: true },
       })
     }),
   )
 
-  it.effect("lowers the native cache policy to OpenRouter cache controls", () =>
-    Effect.gen(function* () {
-      const prepared = yield* compileRequest(
-        LLM.request({
-          model: OpenRouter.configure({ apiKey: "test-key" }).model("anthropic/claude-sonnet-4.6"),
-          system: [
-            { type: "text", text: "Base agent", cache: new CacheHint({ type: "ephemeral", ttlSeconds: 3_600 }) },
-            { type: "text", text: "Project instructions" },
-          ],
-          tools: [{ name: "lookup", description: "Lookup", inputSchema: { type: "object", properties: {} } }],
-          prompt: "Hello",
-          cache: { mode: "explicit", tools: true, system: true, messages: { tail: 1 } },
-        }),
-      )
-
-      expect(prepared.body).toMatchObject({
-        tools: [{ cache_control: { type: "ephemeral" } }],
-        messages: [
-          {
-            role: "system",
-            content: [
-              { text: "Base agent", cache_control: { type: "ephemeral", ttl: "1h" } },
-              { text: "Project instructions", cache_control: { type: "ephemeral" } },
-            ],
-          },
-          {
-            role: "user",
-            content: [{ text: "Hello", cache_control: { type: "ephemeral" } }],
-          },
-        ],
-      })
-    }),
-  )
-
-  it.effect("lowers manual assistant and tool-result cache hints", () =>
-    Effect.gen(function* () {
-      const prepared = yield* compileRequest(
-        LLM.request({
-          model: OpenRouter.configure({ apiKey: "test-key" }).model("anthropic/claude-sonnet-4.6"),
-          cache: "none",
-          messages: [
-            Message.user("Call the tool"),
-            Message.assistant([
-              { type: "text", text: "Calling", cache: new CacheHint({ type: "ephemeral" }) },
-              { type: "tool-call", id: "call_1", name: "lookup", input: {} },
-            ]),
-            Message.tool({
-              id: "call_1",
-              name: "lookup",
-              result: "Done",
-              cache: new CacheHint({ type: "ephemeral", ttlSeconds: 3_600 }),
-            }),
-          ],
-        }),
-      )
-
-      expect(prepared.body.messages).toMatchObject([
-        { role: "user", content: "Call the tool" },
-        { role: "assistant", content: "Calling", cache_control: { type: "ephemeral" } },
-        { role: "tool", content: '"Done"', cache_control: { type: "ephemeral", ttl: "1h" } },
-      ])
-    }),
-  )
-
-  it.effect("caps manual cache controls at four breakpoints", () =>
-    Effect.gen(function* () {
-      const cache = new CacheHint({ type: "ephemeral" })
-      const prepared = yield* compileRequest(
-        LLM.request({
-          model: OpenRouter.configure({ apiKey: "test-key" }).model("anthropic/claude-sonnet-4.6"),
-          cache: "none",
-          system: [1, 2, 3, 4, 5].map((index) => ({ type: "text" as const, text: `System ${index}`, cache })),
-          prompt: "Hello",
-        }),
-      )
-
-      const system = prepared.body.messages[0]
-      expect(system?.role).toBe("system")
-      expect(
-        system && Array.isArray(system.content)
-          ? system.content.filter((part) => "cache_control" in part && part.cache_control !== undefined)
-          : [],
-      ).toHaveLength(4)
-    }),
-  )
-
-  it.effect("preserves cache policy hints on reasoning-only assistant messages", () =>
-    Effect.gen(function* () {
-      const prepared = yield* compileRequest(
-        LLM.request({
-          model: OpenRouter.configure({ apiKey: "test-key" }).model("anthropic/claude-sonnet-4.6"),
-          cache: { mode: "explicit", messages: "latest-assistant" },
-          messages: [Message.user("Think"), Message.assistant([{ type: "reasoning", text: "Reasoning" }])],
-        }),
-      )
-
-      expect(prepared.body.messages).toMatchObject([
-        { role: "user", content: "Think" },
-        { role: "assistant", cache_control: { type: "ephemeral" } },
-      ])
-    }),
-  )
-
-  it.effect("allows usage accounting to be disabled explicitly", () =>
-    Effect.gen(function* () {
-      const prepared = yield* compileRequest(
-        LLM.request({
-          model: OpenRouter.configure({
-            apiKey: "test-key",
-            providerOptions: { openrouter: { usage: false } },
-          }).model("openai/gpt-4o-mini"),
-          cache: "none",
-          prompt: "Hello",
-        }),
-      )
-
-      expect(prepared.body.usage).toEqual({ include: false })
-    }),
-  )
-
   it.effect("applies OpenRouter payload options from the model helper", () =>
     Effect.gen(function* () {
       const prepared = yield* compileRequest(
@@ -162,18 +41,11 @@ describe("OpenRouter", () => {
               openrouter: {
                 usage: true,
                 reasoning: { effort: "high" },
-                models: ["anthropic/claude-sonnet-4.6", "google/gemini-3.1-pro"],
-                provider: { order: ["anthropic", "google"], require_parameters: true },
-                plugins: [{ id: "response-healing" }],
-                web_search_options: { engine: "native", max_results: 3 },
-                debug: { echo_upstream_body: true },
-                user: "user_123",
-                future_option: { enabled: true },
+                promptCacheKey: "session_123",
               },
             },
           }).model("anthropic/claude-3.7-sonnet:thinking"),
           prompt: "Think briefly.",
-          cache: { mode: "auto", key: "session_123" },
         }),
       )
 
@@ -181,54 +53,10 @@ describe("OpenRouter", () => {
         usage: { include: true },
         reasoning: { effort: "high" },
         prompt_cache_key: "session_123",
-        models: ["anthropic/claude-sonnet-4.6", "google/gemini-3.1-pro"],
-        provider: { order: ["anthropic", "google"], require_parameters: true },
-        plugins: [{ id: "response-healing" }],
-        web_search_options: { engine: "native", max_results: 3 },
-        debug: { echo_upstream_body: true },
-        user: "user_123",
-        future_option: { enabled: true },
       })
     }),
   )
 
-  it.effect("filters invalid known OpenRouter options while preserving extensions", () =>
-    Effect.gen(function* () {
-      const invalid: Record<string, unknown> = {
-        usage: "yes",
-        models: "anthropic/claude-sonnet-4.6",
-        provider: [],
-        plugins: {},
-        web_search_options: [],
-        debug: [],
-        user: 123,
-        reasoning: [],
-        promptCacheKey: 123,
-        future_option: { enabled: true },
-      }
-      const prepared = yield* compileRequest(
-        LLM.request({
-          model: OpenRouter.configure({
-            apiKey: "test-key",
-            providerOptions: { openrouter: invalid },
-          }).model("openai/gpt-4o-mini"),
-          prompt: "Hello",
-        }),
-      )
-
-      expect(prepared.body).toMatchObject({ future_option: { enabled: true } })
-      expect(prepared.body).not.toHaveProperty("usage")
-      expect(prepared.body).not.toHaveProperty("models")
-      expect(prepared.body).not.toHaveProperty("provider")
-      expect(prepared.body).not.toHaveProperty("plugins")
-      expect(prepared.body).not.toHaveProperty("web_search_options")
-      expect(prepared.body).not.toHaveProperty("debug")
-      expect(prepared.body).not.toHaveProperty("user")
-      expect(prepared.body).not.toHaveProperty("reasoning")
-      expect(prepared.body).not.toHaveProperty("prompt_cache_key")
-    }),
-  )
-
   it.effect("preserves the upstream provider finish reason", () =>
     Effect.gen(function* () {
       const model = OpenRouter.configure({ apiKey: "test-key" }).model("anthropic/claude-sonnet-4.6")
@@ -276,7 +104,6 @@ describe("OpenRouter", () => {
       const prepared = yield* compileRequest(
         LLM.request({
           model: OpenRouter.configure({ apiKey: "test-key" }).model("anthropic/claude-sonnet-4.6"),
-          cache: "none",
           messages: [
             Message.assistant([
               {
@@ -310,7 +137,6 @@ describe("OpenRouter", () => {
       const prepared = yield* compileRequest(
         LLM.request({
           model: OpenRouter.configure({ apiKey: "test-key" }).model("anthropic/claude-sonnet-4.6"),
-          cache: "none",
           messages: [
             Message.assistant({
               type: "reasoning",
@@ -336,7 +162,6 @@ describe("OpenRouter", () => {
       const prepared = yield* compileRequest(
         LLM.request({
           model: OpenRouter.configure({ apiKey: "test-key" }).model("anthropic/claude-sonnet-4.6"),
-          cache: "none",
           messages: [
             Message.assistant({
               type: "reasoning",
@@ -358,7 +183,6 @@ describe("OpenRouter", () => {
       const prepared = yield* compileRequest(
         LLM.request({
           model: OpenRouter.configure({ apiKey: "test-key" }).model("anthropic/claude-sonnet-4.6"),
-          cache: "none",
           messages: [Message.assistant({ type: "reasoning", text: "Thinking" })],
         }),
       )

packages/app/package.json

@@ -59,7 +59,6 @@
     "@opencode-ai/sdk": "file:vendor/opencode-ai-sdk-1.18.8-dev.tgz",
     "@opencode-ai/session-ui": "workspace:*",
     "@opencode-ai/ui": "workspace:*",
-    "@opencode-ai/util": "workspace:*",
     "@pierre/trees": "1.0.0-beta.4",
     "@sentry/solid": "catalog:",
     "@shikijs/transformers": "3.9.2",

packages/app/src/components/titlebar-tab-nav.tsx

@@ -4,7 +4,6 @@ import { createResizeObserver } from "@solid-primitives/resize-observer"
 import { createMutation } from "@tanstack/solid-query"
 import { IconButtonV2 } from "@opencode-ai/ui/v2/icon-button-v2"
 import { Icon as IconV2 } from "@opencode-ai/ui/v2/icon"
-import { displayLabel } from "@opencode-ai/util/session-title-fallback"
 import { useGlobal } from "@/context/global"
 import { ServerConnection, serverName } from "@/context/server"
 import { displayName, projectForSession } from "@/pages/layout/helpers"
@@ -12,6 +11,7 @@ import { SessionTabAvatar } from "@/pages/layout/session-tab-avatar"
 import type { Session } from "@opencode-ai/sdk/v2"
 import { canOpenTabRename, forwardTabRef } from "./titlebar-tab-gesture"
 import { TabPreviewPopover } from "./titlebar-tab-popover"
+import { sessionTitle } from "@/utils/session-title"
 import "./titlebar-tab-nav.css"
 
 // MouseEvent.button uses 1 for the middle/wheel button.
@@ -57,7 +57,7 @@ export function TabNavItem(props: {
   })
   const title = createMemo(() => {
     const session = props.session()
-    return session ? displayLabel(session) : props.fallbackTitle
+    return session ? sessionTitle(session.title, session.parentID) : props.fallbackTitle
   })
 
   const projectName = createMemo(() => {

packages/app/src/pages/home/home-session-search-controller.ts

@@ -3,11 +3,11 @@ import { useLanguage } from "@/context/language"
 import { serverName } from "@/context/server"
 import { displayName } from "@/pages/layout/helpers"
 import { makeEventListener } from "@solid-primitives/event-listener"
-import { displayLabel } from "@opencode-ai/util/session-title-fallback"
 import { createMemo, onCleanup } from "solid-js"
 import { createStore } from "solid-js/store"
 import type { HomeController } from "./home-controller"
 import { homeSessionSearchKey, type HomeSessionRecord, type HomeSessionsController } from "./home-sessions-controller"
+import { sessionTitle } from "@/utils/session-title"
 
 type HomeSessionSearchSource = Pick<HomeSessionsController, "data" | "session">
 
@@ -24,7 +24,7 @@ export function createHomeSessionSearchController(home: HomeController, sessions
     if (!value) return []
     return sessions.data
       .searchRecords()
-      .filter((record) => `${displayLabel(record.session)} ${record.projectName}`.toLowerCase().includes(value))
+      .filter((record) => `${sessionTitle(record.session.title)} ${record.projectName}`.toLowerCase().includes(value))
   })
   const active = createMemo(() => {
     const records = results()

packages/app/src/pages/home/home-sessions-view.tsx

@@ -6,10 +6,10 @@ import { ButtonV2 } from "@opencode-ai/ui/v2/button-v2"
 import { Icon as IconV2 } from "@opencode-ai/ui/v2/icon"
 import { IconButtonV2 } from "@opencode-ai/ui/v2/icon-button-v2"
 import { TooltipV2 } from "@opencode-ai/ui/v2/tooltip-v2"
-import { displayLabel } from "@opencode-ai/util/session-title-fallback"
 import { useLanguage } from "@/context/language"
 import { ServerConnection } from "@/context/server"
 import { SessionTabAvatarView } from "@/pages/layout/session-tab-avatar"
+import { sessionTitle } from "@/utils/session-title"
 import { shouldOpenSessionInBackground } from "../home-session-open"
 import {
   HomeSessionStatusController,
@@ -344,7 +344,7 @@ function HomeSessionSearchResultRow(
     selected: boolean
   },
 ) {
-  const title = createMemo(() => displayLabel(props.record.session))
+  const title = createMemo(() => sessionTitle(props.record.session.title) || props.record.session.id)
   const showProjectName = () => props.showProjectName() && props.record.projectName
   const key = () => homeSessionSearchKey(props.record)
 
@@ -415,7 +415,7 @@ function HomeSessionGroupHeader(props: {
 }
 
 function HomeSessionRow(props: HomeSessionsViewProps & { record: HomeSessionRecord }) {
-  const title = createMemo(() => displayLabel(props.record.session))
+  const title = createMemo(() => sessionTitle(props.record.session.title) || props.record.session.id)
   const showProjectName = () => props.showProjectName() && props.record.projectName
 
   return (

packages/app/src/pages/layout/sidebar-items.tsx

@@ -5,7 +5,6 @@ import { Icon as IconV2 } from "@opencode-ai/ui/v2/icon"
 import { IconButton } from "@opencode-ai/ui/icon-button"
 import { Spinner } from "@opencode-ai/ui/spinner"
 import { Tooltip } from "@opencode-ai/ui/tooltip"
-import { displayLabel } from "@opencode-ai/util/session-title-fallback"
 import { getFilename } from "@opencode-ai/core/util/path"
 import { A, useParams } from "@solidjs/router"
 import { type Accessor, createMemo, For, type JSX, Match, Show, Switch } from "solid-js"
@@ -15,6 +14,7 @@ import { getAvatarColors, type LocalProject, useLayout } from "@/context/layout"
 import { useNotification } from "@/context/notification"
 import { usePermission } from "@/context/permission"
 import { messageAgentColor } from "@/utils/agent"
+import { sessionTitle } from "@/utils/session-title"
 import { sessionPermissionRequest } from "../session/composer/session-request-tree"
 import { childSessionOnPath, getProjectAvatarSource, hasProjectPermissions } from "./helpers"
 
@@ -104,7 +104,7 @@ const SessionRow = (props: {
   warmPress: () => void
   warmFocus: () => void
 }): JSX.Element => {
-  const title = () => displayLabel(props.session)
+  const title = () => sessionTitle(props.session.title, props.session.parentID)
 
   return (
     <A
@@ -229,7 +229,7 @@ export const SessionItem = (props: SessionItemProps): JSX.Element => {
               fallback={
                 <Tooltip
                   placement={props.mobile ? "bottom" : "right"}
-                  value={displayLabel(props.session)}
+                  value={sessionTitle(props.session.title, props.session.parentID)}
                   gutter={10}
                   class="min-w-0 w-full"
                 >

packages/app/src/pages/session/timeline/message-timeline.tsx

@@ -70,7 +70,7 @@ import { legacySessionHref, requireServerKey, sessionHref } from "@/utils/sessio
 import { useSDK } from "@/context/sdk"
 import { useSync } from "@/context/sync"
 import { notifySessionTabsRemoved } from "@/components/titlebar-session-events"
-import { displayLabel } from "@opencode-ai/util/session-title-fallback"
+import { sessionTitle } from "@/utils/session-title"
 import { scheduleConnectedMeasure } from "./measure"
 import { observeElementOffsetReconnectAware } from "./observe-element-offset"
 import { createTimelineProjection } from "./projection"
@@ -296,10 +296,11 @@ export function MessageTimeline(props: {
     if (!id) return
     return sync().session.get(id)
   })
+  const titleValue = createMemo(() => info()?.title)
   const titleLabel = createMemo(() => {
     const session = info()
     if (!session) return
-    return displayLabel(session)
+    return sessionTitle(titleValue(), session.parentID)
   })
   const shareUrl = createMemo(() => info()?.share?.url)
   const shareEnabled = createMemo(() => sync().data.config.share !== "disabled")
@@ -316,7 +317,7 @@ export function MessageTimeline(props: {
   })
   const parentTitle = createMemo(() => {
     const session = parent()
-    return session ? displayLabel(session) : language.t("command.session.new")
+    return session ? sessionTitle(session.title, session.parentID) : language.t("command.session.new")
   })
   const getMsgParts = (msgId: string) => sync().data.part[msgId] ?? emptyParts
   const getMsgPart = (messageID: string, partID: string) => getMsgParts(messageID).find((part) => part.id === partID)
@@ -920,7 +921,7 @@ export function MessageTimeline(props: {
   function DialogDeleteSession(props: { sessionID: string }) {
     const name = createMemo(() => {
       const session = sync().session.get(props.sessionID)
-      return session ? displayLabel(session) : language.t("command.session.new")
+      return session ? sessionTitle(session.title, session.parentID) : language.t("command.session.new")
     })
     const handleDelete = async () => {
       await deleteSession(props.sessionID)

packages/app/src/pages/session/timeline/observe-element-offset.test.ts

@@ -38,19 +38,17 @@ test("reports a divergent native offset once and ignores equal offsets and unrel
     instance.scrollOffset = offset
   })
 
+  document.body.append(unrelated)
+  unrelated.remove()
+  await frames(2)
+  expect(calls).toEqual([])
+
   route.remove()
   document.body.append(route)
   await new Promise((resolve) => setTimeout(resolve, 0))
   await frames(3)
   expect(calls).toEqual([[0, false]])
 
-  instance.scrollOffset = 79_400
-  document.body.append(unrelated)
-  unrelated.remove()
-  await frames(2)
-  expect(calls).toEqual([[0, false]])
-
-  instance.scrollOffset = 0
   route.remove()
   document.body.append(route)
   await new Promise((resolve) => setTimeout(resolve, 0))

packages/app/src/utils/session-title.test.ts

@@ -0,0 +1,11 @@
+import { describe, expect, test } from "bun:test"
+import { sessionTitle } from "./session-title"
+
+describe("sessionTitle", () => {
+  test("uses a display fallback without persisting it", () => {
+    expect(sessionTitle(undefined)).toBe("New session")
+    expect(sessionTitle(undefined, "ses_parent")).toBe("Child session")
+    expect(sessionTitle("New session - 2026-07-30T18:45:03.662Z")).toBe("New session")
+    expect(sessionTitle("Generated title")).toBe("Generated title")
+  })
+})

packages/app/src/utils/session-title.ts

@@ -0,0 +1,7 @@
+const pattern = /^(New session|Child session) - \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/
+
+export function sessionTitle(title?: string, parentID?: string) {
+  if (!title) return parentID ? "Child session" : "New session"
+  const match = title.match(pattern)
+  return match?.[1] ?? title
+}

packages/app/src/utils/session.ts

@@ -1,6 +1,5 @@
 import type { SessionApi, SessionInfo, SessionListInput } from "@opencode-ai/client/promise"
 import type { Session } from "@opencode-ai/sdk/v2/client"
-import { withTimestampedFallback } from "@opencode-ai/util/session-title-fallback"
 
 export function normalizeSessionInfo(input: SessionInfo | Session): Session {
   if (!("location" in input)) return input
@@ -14,7 +13,7 @@ export function normalizeSessionInfo(input: SessionInfo | Session): Session {
     parentID: input.parentID,
     cost: input.cost,
     tokens: input.tokens,
-    title: withTimestampedFallback(input),
+    title: input.title ?? `${input.parentID ? "Child" : "New"} session - ${new Date(input.time.created).toISOString()}`,
     agent: input.agent,
     model: input.model,
     version: "",

packages/cli/script/node-assets.ts

@@ -58,9 +58,8 @@ export async function collectNodeAssets(target: NodeTarget) {
         source: path.join(ptyRoot, relative),
       })),
   ]
-  const unique = [...new Map(assets.map((asset) => [asset.key, asset])).values()]
-  await Promise.all(unique.map((asset) => stat(asset.source)))
-  return unique
+  await Promise.all(assets.map((asset) => stat(asset.source)))
+  return assets
 }
 
 export async function hashNodeAssets(assets: readonly NodeAsset[]) {

packages/cli/src/acp/service.ts

@@ -8,7 +8,6 @@ import {
   type SessionMessageInfo,
   type SkillInfo,
 } from "@opencode-ai/client/promise"
-import { withTimestampedFallback } from "@opencode-ai/util/session-title-fallback"
 import type {
   AgentSideConnection,
   AuthenticateRequest,
@@ -214,7 +213,9 @@ export function make(input: { readonly client: OpenCodeClient; readonly connecti
         sessions: page.data.map((session) => ({
           sessionId: session.id,
           cwd: session.location.directory,
-          title: withTimestampedFallback(session),
+          title:
+            session.title ??
+            `${session.parentID ? "Child" : "New"} session - ${new Date(session.time.created).toISOString()}`,
           updatedAt: new Date(session.time.updated).toISOString(),
         })),
         ...(page.cursor.next ? { nextCursor: page.cursor.next } : {}),

packages/cli/test/node-assets.test.ts

@@ -1,17 +0,0 @@
-import { expect, test } from "bun:test"
-import { fileURLToPath } from "node:url"
-import { collectNodeAssets } from "../script/node-assets"
-import { nodeTarget, shellParserWasmAssets } from "../src/node/target"
-
-test("collects each SEA asset key once", async () => {
-  const assets = await collectNodeAssets(nodeTarget(process.platform, process.arch))
-  const keys = assets.map((asset) => asset.key)
-
-  expect(new Set(keys).size).toBe(keys.length)
-  expect(assets.filter((asset) => asset.key === shellParserWasmAssets.runtime)).toEqual([
-    {
-      key: shellParserWasmAssets.runtime,
-      source: fileURLToPath(import.meta.resolve(shellParserWasmAssets.runtime)),
-    },
-  ])
-})

packages/client/src/effect/api/api.ts

@@ -118,7 +118,6 @@ export type SessionListOperation<E = never> = (input?: Endpoint5_0Input) => Effe
 
 export type Endpoint5_1Input = {
   readonly id?: Session.ID | undefined
-  readonly title?: string | undefined
   readonly agent?: Agent.ID | undefined
   readonly model?: Model.Ref | undefined
   readonly location?: Location.Ref | undefined

packages/client/src/effect/generated/client.ts

@@ -299,13 +299,7 @@ const Endpoint5_0 = (raw: RawClient["server.session"]) => (input?: Endpoint5_0In
 const Endpoint5_1 = (raw: RawClient["server.session"]) => (input?: Endpoint5_1Input) =>
   preserveEffect<Endpoint5_1Output>()(
     raw["session.create"]({
-      payload: {
-        id: input?.["id"],
-        title: input?.["title"],
-        agent: input?.["agent"],
-        model: input?.["model"],
-        location: input?.["location"],
-      },
+      payload: { id: input?.["id"], agent: input?.["agent"], model: input?.["model"], location: input?.["location"] },
     }).pipe(
       Effect.mapError(mapClientError),
       Effect.map((value) => value.data),

packages/client/src/promise/generated/client.ts

@@ -462,7 +462,6 @@ export function make(options: ClientOptions) {
             path: `/api/session`,
             body: {
               id: input?.["id"],
-              title: input?.["title"],
               agent: input?.["agent"],
               model: input?.["model"],
               location: input?.["location"],

packages/client/src/promise/generated/types.ts

@@ -2662,35 +2662,24 @@ export type SessionListOutput = SessionsResponse
 export type SessionCreateInput = {
   readonly id?: {
     readonly id?: string | null
-    readonly title?: string | null
     readonly agent?: string | null
     readonly model?: { readonly id: string; readonly providerID: string; readonly variant?: string } | null
     readonly location?: { readonly directory: string; readonly workspaceID?: string } | null
   }["id"]
-  readonly title?: {
-    readonly id?: string | null
-    readonly title?: string | null
-    readonly agent?: string | null
-    readonly model?: { readonly id: string; readonly providerID: string; readonly variant?: string } | null
-    readonly location?: { readonly directory: string; readonly workspaceID?: string } | null
-  }["title"]
   readonly agent?: {
     readonly id?: string | null
-    readonly title?: string | null
     readonly agent?: string | null
     readonly model?: { readonly id: string; readonly providerID: string; readonly variant?: string } | null
     readonly location?: { readonly directory: string; readonly workspaceID?: string } | null
   }["agent"]
   readonly model?: {
     readonly id?: string | null
-    readonly title?: string | null
     readonly agent?: string | null
     readonly model?: { readonly id: string; readonly providerID: string; readonly variant?: string } | null
     readonly location?: { readonly directory: string; readonly workspaceID?: string } | null
   }["model"]
   readonly location?: {
     readonly id?: string | null
-    readonly title?: string | null
     readonly agent?: string | null
     readonly model?: { readonly id: string; readonly providerID: string; readonly variant?: string } | null
     readonly location?: { readonly directory: string; readonly workspaceID?: string } | null

packages/core/src/aisdk-native.ts

@@ -1,13 +1,10 @@
 export * as AISDKNative from "./aisdk-native"
 
 import { isRecord } from "@opencode-ai/ai/utils/record"
-import { Provider } from "./provider"
 
 export interface Mapping {
   readonly package: string
   readonly settings: Readonly<Record<string, unknown>>
-  readonly headers?: Readonly<Record<string, string>>
-  readonly body?: Readonly<Record<string, unknown>>
 }
 
 export function map(packageName: string | undefined, settings: Readonly<Record<string, unknown>>): Mapping | undefined {
@@ -23,7 +20,14 @@ export function map(packageName: string | undefined, settings: Readonly<Record<s
         },
       }
     case "@openrouter/ai-sdk-provider":
-      return mapOpenRouter(settings, baseSettings)
+      return {
+        package: "@opencode-ai/ai/providers/openrouter",
+        settings: {
+          ...baseSettings,
+          ...mapAPIKey(settings),
+          ...mapProviderOptions("openrouter", settings),
+        },
+      }
     case "@ai-sdk/xai":
       return {
         package: "@opencode-ai/ai/providers/xai",
@@ -65,67 +69,22 @@ function mapGoogleOptions(settings: Readonly<Record<string, unknown>>) {
   return { providerOptions: { gemini: options } }
 }
 
-function mapOpenRouter(
-  settings: Readonly<Record<string, unknown>>,
-  baseSettings: Readonly<Record<string, unknown>>,
-): Mapping {
-  const headers =
-    Provider.mergeHeaders(
-      {
-        ...(typeof settings.appName === "string" ? { "X-OpenRouter-Title": settings.appName } : {}),
-        ...(typeof settings.appUrl === "string" ? { "HTTP-Referer": settings.appUrl } : {}),
-        ...(isStringRecord(settings.api_keys) && Object.keys(settings.api_keys).length > 0
-          ? { "X-Provider-API-Keys": JSON.stringify(settings.api_keys) }
-          : {}),
-      },
-      isStringRecord(settings.headers) ? settings.headers : undefined,
-    ) ?? {}
-  return {
-    package: "@opencode-ai/ai/providers/openrouter",
-    settings: {
-      ...baseSettings,
-      ...mapAPIKey(settings),
-      ...mapOpenRouterOptions(settings),
-    },
-    ...(Object.keys(headers).length > 0 ? { headers } : {}),
-    ...(isRecord(settings.extraBody) ? { body: settings.extraBody } : {}),
-  }
-}
-
-function mapOpenRouterOptions(settings: Readonly<Record<string, unknown>>) {
-  const options = Object.fromEntries(
-    Object.entries(settings).filter(
-      ([key]) =>
-        ![
-          "apiKey",
-          "api_keys",
-          "appName",
-          "appUrl",
-          "authToken",
-          "baseURL",
-          "chunkTimeout",
-          "compatibility",
-          "extraBody",
-          "fetch",
-          "headers",
-          "promptCacheKey",
-          "timeout",
-        ].includes(key),
-    ),
-  )
-  if (Object.keys(options).length === 0) return {}
-  return { providerOptions: { openrouter: options } }
-}
-
-function isStringRecord(value: unknown): value is Readonly<Record<string, string>> {
-  return isRecord(value) && Object.values(value).every((item) => typeof item === "string")
-}
-
 function mapXAIOptions(settings: Readonly<Record<string, unknown>>) {
   const options = {
     ...(typeof settings.reasoningEffort === "string" ? { reasoningEffort: settings.reasoningEffort } : {}),
     ...(typeof settings.store === "boolean" ? { store: settings.store } : {}),
+    ...(typeof settings.promptCacheKey === "string" ? { promptCacheKey: settings.promptCacheKey } : {}),
   }
   if (Object.keys(options).length === 0) return {}
   return { providerOptions: { xai: options } }
 }
+
+function mapProviderOptions(namespace: string, settings: Readonly<Record<string, unknown>>) {
+  const values = Object.fromEntries(
+    Object.entries(settings).filter(
+      ([key]) => !["apiKey", "authToken", "baseURL", "chunkTimeout", "fetch", "timeout"].includes(key),
+    ),
+  )
+  if (Object.keys(values).length === 0) return {}
+  return { providerOptions: { [namespace]: values } }
+}

packages/core/src/aisdk.ts

@@ -299,6 +299,8 @@ export const locationLayer = Layer.effect(
   }),
 )
 
+export const defaultLayer = locationLayer
+
 function modelFromLanguage(info: Info, language: LanguageModelV3) {
   const packageName = Provider.packageName(info.package!)
   const projected = mapBodyToProviderOptions(info, packageName)
@@ -330,7 +332,7 @@ function modelFromLanguage(info: Info, language: LanguageModelV3) {
               body: projected.body === undefined ? undefined : { ...projected.body },
               headers: info.headers,
             },
-      limits: { context: info.limit.context, input: info.limit.input, output: info.limit.output },
+      limits: { context: info.limit.context, output: info.limit.output },
       providerOptions,
     },
     body: {

packages/core/src/config.ts

@@ -16,7 +16,7 @@ import { Global } from "@opencode-ai/util/global"
 import { Location } from "./location"
 import { AbsolutePath } from "./schema"
 import { ConfigAgent } from "./config/agent"
-import { ConfigMedia } from "./config/media"
+import { ConfigAttachments } from "./config/attachments"
 import { ConfigCompaction } from "./config/compaction"
 import { ConfigCommand } from "./config/command"
 import { ConfigExperimental } from "./config/experimental"
@@ -85,8 +85,8 @@ export class Info extends Schema.Class<Info>("Config.Info")({
   lsp: ConfigLSP.Info.pipe(Schema.optional).annotate({
     description: "Enable built-in language servers or configure server overrides",
   }),
-  media: ConfigMedia.Info.pipe(Schema.optional).annotate({
-    description: "Media processing configuration",
+  attachments: ConfigAttachments.Info.pipe(Schema.optional).annotate({
+    description: "Attachment processing configuration",
   }),
   tool_output: ConfigToolOutput.Info.pipe(Schema.optional).annotate({
     description: "Tool output truncation thresholds",

packages/core/src/config/attachments.ts

@@ -1,15 +1,15 @@
-export * as ConfigMedia from "./media"
+export * as ConfigAttachments from "./attachments"
 
 import { Schema } from "effect"
 import { PositiveInt } from "../schema"
 
-export class Image extends Schema.Class<Image>("Config.Media.Image")({
+export class Image extends Schema.Class<Image>("Config.Attachments.Image")({
   auto_resize: Schema.Boolean.pipe(Schema.optional),
   max_width: PositiveInt.pipe(Schema.optional),
   max_height: PositiveInt.pipe(Schema.optional),
   max_base64_bytes: PositiveInt.pipe(Schema.optional),
 }) {}
 
-export class Info extends Schema.Class<Info>("Config.Media")({
+export class Info extends Schema.Class<Info>("Config.Attachments")({
   image: Image.pipe(Schema.optional),
 }) {}

packages/core/src/github-copilot/responses/tool/image-generation.ts

@@ -1,3 +1,4 @@
+import { createProviderToolFactoryWithOutputSchema } from "@ai-sdk/provider-utils"
 import { z } from "zod/v4"
 
 export const imageGenerationArgsSchema = z
@@ -23,3 +24,91 @@ export const imageGenerationArgsSchema = z
 export const imageGenerationOutputSchema = z.object({
   result: z.string(),
 })
+
+type ImageGenerationArgs = {
+  /**
+   * Background type for the generated image. Default is 'auto'.
+   */
+  background?: "auto" | "opaque" | "transparent"
+
+  /**
+   * Input fidelity for the generated image. Default is 'low'.
+   */
+  inputFidelity?: "low" | "high"
+
+  /**
+   * Optional mask for inpainting.
+   * Contains image_url (string, optional) and file_id (string, optional).
+   */
+  inputImageMask?: {
+    /**
+     * File ID for the mask image.
+     */
+    fileId?: string
+
+    /**
+     * Base64-encoded mask image.
+     */
+    imageUrl?: string
+  }
+
+  /**
+   * The image generation model to use. Default: gpt-image-1.
+   */
+  model?: string
+
+  /**
+   * Moderation level for the generated image. Default: auto.
+   */
+  moderation?: "auto"
+
+  /**
+   * Compression level for the output image. Default: 100.
+   */
+  outputCompression?: number
+
+  /**
+   * The output format of the generated image. One of png, webp, or jpeg.
+   * Default: png
+   */
+  outputFormat?: "png" | "jpeg" | "webp"
+
+  /**
+   * Number of partial images to generate in streaming mode, from 0 (default value) to 3.
+   */
+  partialImages?: number
+
+  /**
+   * The quality of the generated image.
+   * One of low, medium, high, or auto. Default: auto.
+   */
+  quality?: "auto" | "low" | "medium" | "high"
+
+  /**
+   * The size of the generated image.
+   * One of 1024x1024, 1024x1536, 1536x1024, or auto.
+   * Default: auto.
+   */
+  size?: "auto" | "1024x1024" | "1024x1536" | "1536x1024"
+}
+
+const imageGenerationToolFactory = createProviderToolFactoryWithOutputSchema<
+  {},
+  {
+    /**
+     * The generated image encoded in base64.
+     */
+    result: string
+  },
+  ImageGenerationArgs
+>({
+  id: "openai.image_generation",
+  inputSchema: z.object({}),
+  outputSchema: imageGenerationOutputSchema,
+})
+
+export const imageGeneration = (
+  args: ImageGenerationArgs = {}, // default
+) => {
+  return imageGenerationToolFactory(args)
+}

packages/core/src/github-copilot/responses/tool/local-shell.ts

@@ -1,3 +1,4 @@
+import { createProviderToolFactoryWithOutputSchema } from "@ai-sdk/provider-utils"
 import { z } from "zod/v4"
 
 export const localShellInputSchema = z.object({
@@ -14,3 +15,50 @@ export const localShellInputSchema = z.object({
 export const localShellOutputSchema = z.object({
   output: z.string(),
 })
+
+export const localShell = createProviderToolFactoryWithOutputSchema<
+  {
+    /**
+     * Execute a shell command on the server.
+     */
+    action: {
+      type: "exec"
+
+      /**
+       * The command to run.
+       */
+      command: string[]
+
+      /**
+       * Optional timeout in milliseconds for the command.
+       */
+      timeoutMs?: number
+
+      /**
+       * Optional user to run the command as.
+       */
+      user?: string
+
+      /**
+       * Optional working directory to run the command in.
+       */
+      workingDirectory?: string
+
+      /**
+       * Environment variables to set for the command.
+       */
+      env?: Record<string, string>
+    }
+  },
+  {
+    /**
+     * The output of local shell tool call.
+     */
+    output: string
+  },
+  {}
+>({
+  id: "openai.local_shell",
+  inputSchema: localShellInputSchema,
+  outputSchema: localShellOutputSchema,
+})

packages/core/src/github-copilot/responses/tool/web-search-preview.ts

@@ -1,3 +1,4 @@
+import { createProviderToolFactory } from "@ai-sdk/provider-utils"
 import { z } from "zod/v4"
 
 // Args validation schema
@@ -38,3 +39,65 @@ export const webSearchPreviewArgsSchema = z.object({
     })
     .optional(),
 })
+
+export const webSearchPreview = createProviderToolFactory<
+  {
+    // Web search doesn't take input parameters - it's controlled by the prompt
+  },
+  {
+    /**
+     * Search context size to use for the web search.
+     * - high: Most comprehensive context, highest cost, slower response
+     * - medium: Balanced context, cost, and latency (default)
+     * - low: Least context, lowest cost, fastest response
+     */
+    searchContextSize?: "low" | "medium" | "high"
+
+    /**
+     * User location information to provide geographically relevant search results.
+     */
+    userLocation?: {
+      /**
+       * Type of location (always 'approximate')
+       */
+      type: "approximate"
+      /**
+       * Two-letter ISO country code (e.g., 'US', 'GB')
+       */
+      country?: string
+      /**
+       * City name (free text, e.g., 'Minneapolis')
+       */
+      city?: string
+      /**
+       * Region name (free text, e.g., 'Minnesota')
+       */
+      region?: string
+      /**
+       * IANA timezone (e.g., 'America/Chicago')
+       */
+      timezone?: string
+    }
+  }
+>({
+  id: "openai.web_search_preview",
+  inputSchema: z.object({
+    action: z
+      .discriminatedUnion("type", [
+        z.object({
+          type: z.literal("search"),
+          query: z.string().nullish(),
+        }),
+        z.object({
+          type: z.literal("open_page"),
+          url: z.string(),
+        }),
+        z.object({
+          type: z.literal("find"),
+          url: z.string(),
+          pattern: z.string(),
+        }),
+      ])
+      .nullish(),
+  }),
+})

packages/core/src/github-copilot/responses/tool/web-search.ts

@@ -1,3 +1,4 @@
+import { createProviderToolFactory } from "@ai-sdk/provider-utils"
 import { z } from "zod/v4"
 
 export const webSearchArgsSchema = z.object({
@@ -19,3 +20,83 @@ export const webSearchArgsSchema = z.object({
     })
     .optional(),
 })
+
+export const webSearchToolFactory = createProviderToolFactory<
+  {
+    // Web search doesn't take input parameters - it's controlled by the prompt
+  },
+  {
+    /**
+     * Filters for the search.
+     */
+    filters?: {
+      /**
+       * Allowed domains for the search.
+       * If not provided, all domains are allowed.
+       * Subdomains of the provided domains are allowed as well.
+       */
+      allowedDomains?: string[]
+    }
+
+    /**
+     * Search context size to use for the web search.
+     * - high: Most comprehensive context, highest cost, slower response
+     * - medium: Balanced context, cost, and latency (default)
+     * - low: Least context, lowest cost, fastest response
+     */
+    searchContextSize?: "low" | "medium" | "high"
+
+    /**
+     * User location information to provide geographically relevant search results.
+     */
+    userLocation?: {
+      /**
+       * Type of location (always 'approximate')
+       */
+      type: "approximate"
+      /**
+       * Two-letter ISO country code (e.g., 'US', 'GB')
+       */
+      country?: string
+      /**
+       * City name (free text, e.g., 'Minneapolis')
+       */
+      city?: string
+      /**
+       * Region name (free text, e.g., 'Minnesota')
+       */
+      region?: string
+      /**
+       * IANA timezone (e.g., 'America/Chicago')
+       */
+      timezone?: string
+    }
+  }
+>({
+  id: "openai.web_search",
+  inputSchema: z.object({
+    action: z
+      .discriminatedUnion("type", [
+        z.object({
+          type: z.literal("search"),
+          query: z.string().nullish(),
+        }),
+        z.object({
+          type: z.literal("open_page"),
+          url: z.string(),
+        }),
+        z.object({
+          type: z.literal("find"),
+          url: z.string(),
+          pattern: z.string(),
+        }),
+      ])
+      .nullish(),
+  }),
+})
+
+export const webSearch = (
+  args: Parameters<typeof webSearchToolFactory>[0] = {}, // default
+) => {
+  return webSearchToolFactory(args)
+}

packages/core/src/image.ts

@@ -61,7 +61,7 @@ const layer = Layer.effect(
       const image = Object.assign(
         {},
         ...(yield* config.entries()).flatMap((entry) =>
-          entry.type === "document" && entry.info.media?.image ? [entry.info.media.image] : [],
+          entry.type === "document" && entry.info.attachments?.image ? [entry.info.attachments.image] : [],
         ),
       )
       const normalize = yield* loadAdapter

packages/core/src/model-resolver.ts

@@ -81,7 +81,7 @@ const withDefaults = (model: Info, route: AnyRoute) =>
     headers: providerHeaders(model),
     providerOptions: providerOptions(model),
     http: model.body === undefined ? undefined : { body: model.body },
-    limits: { context: model.limit.context, input: model.limit.input, output: model.limit.output },
+    limits: { context: model.limit.context, output: model.limit.output },
   })
 
 const providerHeaders = (model: Info) => {
@@ -96,7 +96,9 @@ const providerHeaders = (model: Info) => {
   return Provider.mergeHeaders(generated.size === 0 ? undefined : Object.fromEntries(generated), model.headers)
 }
 
-const providerOptions = (model: Info): { readonly [key: string]: { readonly [key: string]: unknown } } | undefined => {
+const providerOptions = (
+  model: Info,
+): { readonly [key: string]: { readonly [key: string]: unknown } } | undefined => {
   if (!Provider.isAISDK(model.package) || model.settings === undefined) return undefined
   const { apiKey: _, baseURL: _baseURL, ...settings } = model.settings
   if (Object.keys(settings).length === 0) return undefined
@@ -200,9 +202,9 @@ export const fromCatalogModel = (
     const settings = {
       ...(credential ? withoutNativeAuthSettings(mapped) : mapped),
       ...nativeCredentialSettings(specifier, credential),
-      headers: Provider.mergeHeaders(mapping?.headers, resolved.headers),
-      body: Provider.mergeOverlay(mapping?.body, resolved.body),
-      limits: { context: resolved.limit.context, input: resolved.limit.input, output: resolved.limit.output },
+      headers: resolved.headers,
+      body: resolved.body,
+      limits: { context: resolved.limit.context, output: resolved.limit.output },
     }
     return yield* Effect.try({
       try: () => {
@@ -264,7 +266,10 @@ export const layer = Layer.effect(
     const integrations = yield* Integration.Service
     const npm = yield* Npm.Service
     const aisdk = yield* AISDK.Service
-    const load = Effect.fn("ModelResolver.resolveModel")(function* (selected: Info, variant?: VariantID) {
+    const load = Effect.fn("ModelResolver.resolveModel")(function* (
+      selected: Info,
+      variant?: VariantID,
+    ) {
       const provider = yield* catalog.provider.get(selected.providerID)
       const connection = yield* integrations.connection.active(
         provider?.integrationID ?? Integration.ID.make(selected.providerID),

packages/core/src/plugin/host.ts

@@ -341,7 +341,6 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: import("../p
       create: (input) =>
         runtime.session.create({
           id: input?.id,
-          title: input?.title,
           agent: input?.agent,
           model: input?.model,
           location:
@@ -351,10 +350,8 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: import("../p
       prompt: runtime.session.prompt,
       generate: (input) => runtime.session.generate(input).pipe(Effect.map((text) => ({ text }))),
       command: runtime.session.command,
-      rename: runtime.session.rename,
       synthetic: runtime.session.synthetic,
       interrupt: (input) => runtime.session.interrupt(input.sessionID),
-      wait: (input) => runtime.session.wait(input.sessionID),
     },
   } satisfies Plugin.Context
 })

packages/core/src/plugin/provider/openai.ts

@@ -220,8 +220,12 @@ export const OpenAIPlugin = define({
             return
           }
           draft.cost = []
-          // Match Codex CLI so context consumption and subscription usage stay consistent between clients.
-          draft.limit = { ...draft.limit, context: 272_000, input: 272_000 }
+          if (draft.id.includes("gpt-5.5")) {
+            draft.limit = { context: 400_000, input: 272_000, output: 128_000 }
+          }
+          if (draft.id.includes("gpt-5.6")) {
+            draft.limit = { context: 500_000, input: 372_000, output: 128_000 }
+          }
         })
       }
     })

packages/core/src/plugin/runtime.ts

@@ -11,17 +11,7 @@ import { Session } from "../session"
 export interface Interface {
   readonly session: Pick<
     Session.Interface,
-    | "get"
-    | "create"
-    | "messages"
-    | "prompt"
-    | "generate"
-    | "command"
-    | "rename"
-    | "resume"
-    | "interrupt"
-    | "synthetic"
-    | "wait"
+    "get" | "create" | "messages" | "prompt" | "generate" | "command" | "resume" | "interrupt" | "synthetic"
   >
   readonly job: Pick<Job.Interface, "start" | "wait" | "block" | "background" | "cancel">
   readonly location: {
@@ -62,11 +52,9 @@ export const layerWithCell = (cell: Cell) =>
         prompt: (input) => require(cell, (runtime) => runtime.session.prompt(input)),
         generate: (input) => require(cell, (runtime) => runtime.session.generate(input)),
         command: (input) => require(cell, (runtime) => runtime.session.command(input)),
-        rename: (input) => require(cell, (runtime) => runtime.session.rename(input)),
         resume: (sessionID) => require(cell, (runtime) => runtime.session.resume(sessionID)),
         interrupt: (sessionID) => require(cell, (runtime) => runtime.session.interrupt(sessionID)),
         synthetic: (input) => require(cell, (runtime) => runtime.session.synthetic(input)),
-        wait: (sessionID) => require(cell, (runtime) => runtime.session.wait(sessionID)),
       },
       job: {
         start: (input) => require(cell, (runtime) => runtime.job.start(input)),

packages/core/src/session.ts

@@ -938,7 +938,7 @@ const materializeAttachment = Effect.fn("Session.materializeAttachment")(functio
       : resolved.bytes
   const normalized = yield* normalizeImageAttachment(
     input,
-    Buffer.from(content).toString("base64"),
+    Base64.make(Buffer.from(content).toString("base64")),
     mime,
     image,
   )
@@ -954,11 +954,11 @@ const materializeAttachment = Effect.fn("Session.materializeAttachment")(functio
 
 const normalizeImageAttachment = Effect.fn("Session.normalizeImageAttachment")(function* (
   input: PromptInput.FileAttachment,
-  data: string,
+  data: Base64,
   mime: string,
   image: Effect.Effect<Image.Interface>,
 ) {
-  if (!mime.startsWith("image/")) return { data: Base64.make(data), mime }
+  if (!mime.startsWith("image/")) return { data, mime }
   const service = yield* image
   const label = input.name ?? (input.uri.startsWith("data:") ? "inline attachment" : input.uri)
   const content = { uri: label, content: data, encoding: "base64" as const, mime }

packages/core/src/session/compaction.ts

@@ -10,7 +10,6 @@ import { llmClient } from "../effect/app-node-platform"
 import { SessionEvent } from "./event"
 import type { SessionMessage } from "./message"
 import { SessionModelHeaders } from "./model-headers"
-import { SessionPromptCacheKey } from "./prompt-cache-key"
 import { App } from "../app"
 import { SessionRunnerModel } from "./runner/model"
 import { SessionSchema } from "./schema"
@@ -153,11 +152,14 @@ const settings = (documents: readonly Config.Entry[]) => {
   const configured = documents
     .filter((entry): entry is Config.Document => entry.type === "document")
     .flatMap((entry) => (entry.info.compaction ? [entry.info.compaction] : []))
-  return {
-    auto: configured.findLast((value) => value.auto !== undefined)?.auto ?? true,
-    buffer: configured.findLast((value) => value.buffer !== undefined)?.buffer ?? DEFAULT_BUFFER,
-    tokens: configured.findLast((value) => value.keep?.tokens !== undefined)?.keep?.tokens ?? DEFAULT_KEEP_TOKENS,
-  }
+  return configured.reduce<Settings>(
+    (result, current) => ({
+      auto: current.auto ?? result.auto,
+      buffer: current.buffer ?? result.buffer,
+      tokens: current.keep?.tokens ?? result.tokens,
+    }),
+    { auto: true, buffer: DEFAULT_BUFFER, tokens: DEFAULT_KEEP_TOKENS },
+  )
 }
 
 const select = (
@@ -258,7 +260,6 @@ const make = (dependencies: Dependencies) => {
       .stream(
         LLM.request({
           model: plan.model,
-          cache: { mode: "auto", key: SessionPromptCacheKey.make(plan.session.id) },
           http: { headers: SessionModelHeaders.make(plan.session, dependencies.app) },
           messages: [Message.user(plan.prompt)],
           tools: [],
@@ -349,16 +350,11 @@ const make = (dependencies: Dependencies) => {
         message.type === "assistant" && message.tokens !== undefined,
     )
     if (!last) return false
-    const limits = input.model.route.defaults.limits
-    const output = Math.min(limits?.output ?? 0, OUTPUT_TOKEN_MAX)
-    const promptCeiling = Math.min(
-      limits?.input === undefined ? Number.POSITIVE_INFINITY : limits.input - config.buffer,
-      context - Math.max(output, config.buffer),
-    )
+    const output = Math.min(input.model.route.defaults.limits?.output ?? 0, OUTPUT_TOKEN_MAX)
     const used =
       last.tokens.input + last.tokens.output + last.tokens.reasoning + last.tokens.cache.read + last.tokens.cache.write
     if (used <= 0) return false
-    return used >= promptCeiling
+    return used >= context - (output || config.buffer)
   }
   const compactManual = Effect.fn("SessionCompaction.compactManual")(function* (input: ManualInput) {
     const content = planContent(input.messages, config.tokens)

packages/core/src/session/generate-node.ts

@@ -11,7 +11,6 @@ import { SessionContext } from "./context"
 import { SessionGenerate } from "./generate"
 import { SessionHistory } from "./history"
 import { SessionModelHeaders } from "./model-headers"
-import { SessionPromptCacheKey } from "./prompt-cache-key"
 import { SessionRunnerModel } from "./runner/model"
 import PROMPT_DEFAULT from "./runner/prompt/base.txt"
 import { toLLMMessages } from "./runner/to-llm-message"
@@ -32,6 +31,9 @@ export const layer = Layer.effect(
         const model = yield* models.resolve(selection.session)
         const history = yield* SessionHistory.preview(database.db, selection.session.id, selection.instructions)
         const providerMetadataKey = model.model.route.providerMetadataKey ?? model.model.provider
+        const promptCacheKey = /^ses_[0-9a-f]{64}$/.test(selection.session.id)
+          ? selection.session.id.slice(4)
+          : selection.session.id
         const tools = selection.tools
         const toolDefinitions = tools.definitions
         const toolsByName = new Map(toolDefinitions.map((tool) => [tool.name, tool]))
@@ -69,7 +71,7 @@ export const layer = Layer.effect(
           LLM.request({
             model: model.model,
             http: { headers: SessionModelHeaders.make(selection.session, app) },
-            cache: { mode: "auto", key: SessionPromptCacheKey.make(selection.session.id) },
+            providerOptions: { openai: { promptCacheKey } },
             system: contextEvent.system,
             messages: contextEvent.messages,
             tools: hookedTools,

packages/core/src/session/model-request.ts

@@ -14,17 +14,11 @@ import { QuestionTool } from "../tool/plugin/question"
 import { Tool } from "../tool"
 import { SessionContext } from "./context"
 import { SessionModelHeaders } from "./model-headers"
-import { SessionPromptCacheKey } from "./prompt-cache-key"
 import { PromptCacheDiagnostics } from "./prompt-cache-diagnostics"
 import { MAX_STEPS_PROMPT } from "./runner/max-steps"
 import PROMPT_DEFAULT from "./runner/prompt/base.txt"
 import { toLLMMessages } from "./runner/to-llm-message"
 
-const IMAGE_BYTES_TRIGGER = 25 * 1024 * 1024 // 25 MiB
-const IMAGE_BYTES_TARGET = 15 * 1024 * 1024 // 15 MiB
-const IMAGE_REMOVED =
-  "[This image was removed to reduce the request size and is no longer visible. Do not make claims about its contents from memory. If needed, retrieve it again with an available tool or ask the user to attach it again.]"
-
 /** Failures a prepared execution can surface: infrastructure errors plus user declines resurfaced from the defect tunnel. */
 export type ExecuteError = Tool.Error | Permission.DeclinedError | QuestionTool.CancelledError
 
@@ -100,56 +94,6 @@ export const unsupportedParts = (messages: LLMRequest["messages"], capabilities:
     }),
   )
 
-export const boundImages = (messages: LLMRequest["messages"]) => {
-  const isImage = (mime: string) => mime.toLowerCase().startsWith("image/")
-  const size = (data: string | Uint8Array) =>
-    typeof data === "string" ? Buffer.byteLength(data) : Math.ceil(data.byteLength / 3) * 4
-  const imageBytes = messages.reduce(
-    (total, message) =>
-      total +
-      message.content.reduce((sum, part) => {
-        if (part.type === "media" && isImage(part.mediaType)) return sum + size(part.data)
-        if (part.type !== "tool-result" || part.result.type !== "content") return sum
-        return (
-          sum +
-          part.result.value.reduce(
-            (bytes: number, item: Content) =>
-              bytes + (item.type === "file" && isImage(item.mime) ? Buffer.byteLength(item.uri) : 0),
-            0,
-          )
-        )
-      }, 0),
-    0,
-  )
-  if (imageBytes <= IMAGE_BYTES_TRIGGER) return messages
-
-  let removed = 0
-  return messages.map((message) =>
-    Message.make({
-      ...message,
-      content: message.content.map((part) => {
-        if (part.type === "media" && isImage(part.mediaType) && imageBytes - removed > IMAGE_BYTES_TARGET) {
-          removed += size(part.data)
-          return Message.text(IMAGE_REMOVED)
-        }
-        if (part.type !== "tool-result" || part.result.type !== "content") return part
-        return {
-          ...part,
-          result: {
-            ...part.result,
-            value: part.result.value.map((item: Content) => {
-              if (item.type !== "file" || !isImage(item.mime) || imageBytes - removed <= IMAGE_BYTES_TARGET)
-                return item
-              removed += Buffer.byteLength(item.uri)
-              return { type: "text" as const, text: IMAGE_REMOVED }
-            }),
-          },
-        }
-      }),
-    }),
-  )
-}
-
 /**
  * Builds an outbound model request and captures the tool-call capability that
  * must remain paired with it. It does not execute the request or mutate
@@ -184,6 +128,7 @@ export const layer = Layer.effect(
       // The final Step keeps definitions available to protocols with native "none",
       // preserving their prompt cache prefix. Calls are still rejected at execution.
       const tools = input.context.tools
+      const promptCacheKey = /^ses_[0-9a-f]{64}$/.test(session.id) ? session.id.slice(4) : session.id
       const system = [agent.info.system ? agent.info.system : PROMPT_DEFAULT, input.context.initial]
         .filter((part) => part.length > 0)
         .map(SystemPart.make)
@@ -213,9 +158,9 @@ export const layer = Layer.effect(
         http: {
           headers: SessionModelHeaders.make(session, app),
         },
-        cache: { mode: "auto", key: SessionPromptCacheKey.make(session.id) },
+        providerOptions: { openai: { promptCacheKey } },
         system: contextEvent.system,
-        messages: boundImages(unsupportedParts(contextEvent.messages, resolved.capabilities)),
+        messages: unsupportedParts(contextEvent.messages, resolved.capabilities),
         tools: hookedTools,
         toolChoice: stepLimitReached ? "none" : undefined,
       })

packages/core/src/session/prompt-cache-key.ts

@@ -1,6 +0,0 @@
-export * as SessionPromptCacheKey from "./prompt-cache-key"
-
-import { SessionSchema } from "./schema"
-
-export const make = (sessionID: SessionSchema.ID) =>
-  /^ses_[0-9a-f]{64}$/.test(sessionID) ? sessionID.slice(4) : sessionID

packages/core/src/session/title.ts

@@ -6,13 +6,11 @@ import { Agent } from "../agent"
 import { Database } from "../database/database"
 import { Bus } from "../bus"
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
-import { isExactRootFallback } from "@opencode-ai/util/session-title-fallback"
 import { App } from "../app"
 import { llmClient } from "../effect/app-node-platform"
 import { SessionEvent } from "./event"
 import { SessionHistory } from "./history"
 import { SessionModelHeaders } from "./model-headers"
-import { SessionPromptCacheKey } from "./prompt-cache-key"
 import { SessionRunnerModel } from "./runner/model"
 import { SessionSchema } from "./schema"
 import { SessionUsage } from "./usage"
@@ -41,10 +39,7 @@ export class Service extends Context.Service<Service, Interface>()("@opencode/Se
 
 const truncate = (value: string) => (value.length <= MAX_LENGTH ? value : `${value.slice(0, MAX_LENGTH - 3)}...`)
 const isUntitled = (session: SessionSchema.Info) =>
-  isExactRootFallback({
-    title: session.title,
-    time: { created: DateTime.toEpochMillis(session.time.created) },
-  })
+  session.title === undefined || session.title === `New session - ${DateTime.formatIso(session.time.created)}`
 
 const make = (dependencies: Dependencies) => {
   const generateForFirstPrompt = Effect.fn("SessionTitle.generateForFirstPrompt")(function* (
@@ -81,7 +76,6 @@ const make = (dependencies: Dependencies) => {
       .stream(
         LLM.request({
           model: resolved.model,
-          cache: { mode: "auto", key: SessionPromptCacheKey.make(session.id) },
           http: { headers: SessionModelHeaders.make(session, dependencies.app) },
           system: agent.system,
           messages: [Message.user(firstUser.text)],

packages/core/src/util/module.ts

@@ -0,0 +1,10 @@
+import { createRequire } from "node:module"
+import path from "node:path"
+
+export namespace Module {
+  export function resolve(id: string, dir: string) {
+    try {
+      return createRequire(path.join(dir, "package.json")).resolve(id)
+    } catch {}
+  }
+}

packages/core/src/util/path.ts

@@ -12,6 +12,12 @@ export function getDirectory(path: string | undefined) {
   return parts.slice(0, parts.length - 1).join("/") + "/"
 }
 
+export function getFileExtension(path: string | undefined) {
+  if (!path) return ""
+  const parts = path.split(".")
+  return parts[parts.length - 1]
+}
+
 export function getFilenameTruncated(path: string | undefined, maxLength: number = 20) {
   const filename = getFilename(path)
   if (filename.length <= maxLength) return filename

packages/core/src/v1/config/migrate.ts

@@ -63,7 +63,7 @@ export function migrate(info: typeof ConfigV1.Info.Type) {
     watcher: info.watcher,
     formatter: info.formatter,
     lsp: info.lsp,
-    media: info.attachment,
+    attachments: info.attachment,
     tool_output: info.tool_output,
     mcp: mcp(info),
     compaction: info.compaction && {

packages/core/test/aisdk-native.test.ts

@@ -2,40 +2,6 @@ import { describe, expect, test } from "bun:test"
 import { AISDKNative } from "@opencode-ai/core/aisdk-native"
 
 describe("AISDKNative", () => {
-  test("maps OpenRouter settings to native destinations", () => {
-    expect(
-      AISDKNative.map("@openrouter/ai-sdk-provider", {
-        appName: "OpenCode",
-        appUrl: "https://opencode.ai",
-        headers: { "x-openrouter-title": "Configured", "x-provider-api-keys": "Configured BYOK" },
-        api_keys: { anthropic: "provider-key" },
-        extraBody: { transforms: ["middle-out"] },
-        models: ["anthropic/claude-sonnet-4.6"],
-        provider: { only: ["anthropic"], require_parameters: true },
-        reasoning: { effort: "high" },
-        future_option: { enabled: true },
-      }),
-    ).toEqual({
-      package: "@opencode-ai/ai/providers/openrouter",
-      settings: {
-        providerOptions: {
-          openrouter: {
-            models: ["anthropic/claude-sonnet-4.6"],
-            provider: { only: ["anthropic"], require_parameters: true },
-            reasoning: { effort: "high" },
-            future_option: { enabled: true },
-          },
-        },
-      },
-      headers: {
-        "x-openrouter-title": "Configured",
-        "HTTP-Referer": "https://opencode.ai",
-        "x-provider-api-keys": "Configured BYOK",
-      },
-      body: { transforms: ["middle-out"] },
-    })
-  })
-
   test("maps every Google thinking setting", () => {
     expect(
       AISDKNative.map("@ai-sdk/google", {
@@ -103,6 +69,7 @@ describe("AISDKNative", () => {
         baseURL: "https://xai.example/v1",
         reasoningEffort: "custom",
         store: true,
+        promptCacheKey: "cache-key",
       }),
     ).toEqual({
       package: "@opencode-ai/ai/providers/xai",
@@ -113,6 +80,7 @@ describe("AISDKNative", () => {
           xai: {
             reasoningEffort: "custom",
             store: true,
+            promptCacheKey: "cache-key",
           },
         },
       },

packages/core/test/config/config.test.ts

@@ -803,7 +803,7 @@ describe("Config", () => {
                   custom: { command: ["custom-fmt", "$FILE"], extensions: [".foo"] },
                 },
                 lsp: { typescript: { disabled: true }, custom: { command: ["custom-lsp"], extensions: [".foo"] } },
-                media: {
+                attachments: {
                   image: { auto_resize: false, max_width: 1200, max_height: 900, max_base64_bytes: 1048576 },
                 },
                 tool_output: { max_lines: 1000, max_bytes: 32768 },
@@ -890,7 +890,7 @@ describe("Config", () => {
               typescript: { disabled: true },
               custom: { command: ["custom-lsp"], extensions: [".foo"] },
             })
-            expect(documents[0]?.info.media).toEqual({
+            expect(documents[0]?.info.attachments).toEqual({
               image: { auto_resize: false, max_width: 1200, max_height: 900, max_base64_bytes: 1048576 },
             })
             expect(documents[0]?.info.tool_output).toEqual({ max_lines: 1000, max_bytes: 32768 })
@@ -1097,7 +1097,7 @@ describe("Config", () => {
             expect(documents[0]?.info.references).toEqual({
               docs: { path: "../docs", description: "Use for product documentation", hidden: true },
             })
-            expect(documents[0]?.info.media).toEqual({ image: { auto_resize: false, max_width: 1200 } })
+            expect(documents[0]?.info.attachments).toEqual({ image: { auto_resize: false, max_width: 1200 } })
             expect(documents[0]?.info.providers?.custom).toMatchObject({
               settings: { apiKey: "secret" },
               models: {

packages/core/test/model-resolver.test.ts

@@ -1,6 +1,5 @@
 import { describe, expect } from "bun:test"
 import { LLM, Model } from "@opencode-ai/ai"
-import { OpenAIChat } from "@opencode-ai/ai/protocols"
 import { compileRequest } from "@opencode-ai/ai/route/client"
 import { Effect } from "effect"
 import { Headers } from "effect/unstable/http"
@@ -18,7 +17,6 @@ interface ModelOptions {
   readonly headers?: Info["headers"]
   readonly body?: Info["body"]
   readonly variants?: Info["variants"]
-  readonly limit?: Info["limit"]
 }
 
 const model = (packageName: string | undefined, options: ModelOptions = {}) =>
@@ -38,7 +36,7 @@ const model = (packageName: string | undefined, options: ModelOptions = {}) =>
     cost: [],
     status: "active",
     enabled: true,
-    limit: options.limit ?? { context: 100, output: 20 },
+    limit: { context: 100, output: 20 },
   })
 
 describe("ModelResolver", () => {
@@ -46,7 +44,6 @@ describe("ModelResolver", () => {
     Effect.gen(function* () {
       const catalog = model(Provider.aisdk("@ai-sdk/openai"), {
         settings: { baseURL: "https://openai.example/v1" },
-        limit: { context: 100, input: 80, output: 20 },
       })
       const resolved = yield* ModelResolver.fromCatalogModel(catalog)
 
@@ -58,7 +55,7 @@ describe("ModelResolver", () => {
         endpoint: { baseURL: "https://openai.example/v1" },
         defaults: {
           headers: { "x-test": "header" },
-          limits: { context: 100, input: 80, output: 20 },
+          limits: { context: 100, output: 20 },
           http: { body: { custom_extension: { enabled: true } } },
         },
       })
@@ -547,37 +544,6 @@ describe("ModelResolver", () => {
     }),
   )
 
-  it.effect("merges mapped OpenRouter headers and body with catalog overlays", () =>
-    ModelResolver.fromCatalogModel(
-      model(Provider.aisdk("@openrouter/ai-sdk-provider"), {
-        settings: {
-          appName: "OpenCode",
-          appUrl: "https://opencode.ai",
-          extraBody: { transforms: ["middle-out"], provider: { sort: "price" } },
-        },
-        headers: { "X-OpenRouter-Title": "Custom" },
-        body: { provider: { only: ["anthropic"] } },
-      }),
-      undefined,
-      {
-        loadPackage: () =>
-          Effect.succeed({
-            model: (modelID, settings) => {
-              expect(settings.headers).toEqual({
-                "HTTP-Referer": "https://opencode.ai",
-                "X-OpenRouter-Title": "Custom",
-              })
-              expect(settings.body).toEqual({
-                transforms: ["middle-out"],
-                provider: { sort: "price", only: ["anthropic"] },
-              })
-              return Model.make({ id: modelID, provider: "openrouter", route: OpenAIChat.route })
-            },
-          }),
-      },
-    ),
-  )
-
   it.effect("loads supported AISDK catalog packages as native routes", () =>
     Effect.gen(function* () {
       const google = yield* ModelResolver.fromCatalogModel(

packages/core/test/plugin/host.ts

@@ -106,10 +106,8 @@ export function host(overrides: Overrides = {}): Plugin.Context {
       prompt: overrides.session?.prompt ?? (() => Effect.die("unused session.prompt")),
       generate: overrides.session?.generate ?? (() => Effect.die("unused session.generate")),
       command: overrides.session?.command ?? (() => Effect.die("unused session.command")),
-      rename: overrides.session?.rename ?? (() => Effect.die("unused session.rename")),
       synthetic: overrides.session?.synthetic ?? (() => Effect.die("unused session.synthetic")),
       interrupt: overrides.session?.interrupt ?? (() => Effect.die("unused session.interrupt")),
-      wait: overrides.session?.wait ?? (() => Effect.die("unused session.wait")),
     },
   }
 }

packages/core/test/plugin/provider-openai.test.ts

@@ -74,9 +74,6 @@ describe("OpenAIPlugin", () => {
           ]
         })
         catalog.model.update(item.id, Model.ID.make("gpt-5.5-pro"), () => {})
-        catalog.model.update(item.id, Model.ID.make("gpt-5.4"), (model) => {
-          model.limit = { context: 1_050_000, input: 922_000, output: 64_000 }
-        })
         catalog.model.update(item.id, Model.ID.make("gpt-5.4-pro"), (model) => {
           model.modelID = Model.ID.make("gpt-5.4")
           model.body = { reasoning: { mode: "pro" } }
@@ -140,7 +137,7 @@ describe("OpenAIPlugin", () => {
       const eligible = required(yield* catalog.model.get(Provider.ID.openai, Model.ID.make("gpt-5.5")))
       expect(eligible.package).toBe("@opencode-ai/ai/providers/openai")
       expect(eligible.cost).toEqual([])
-      expect(eligible.limit).toEqual({ context: 272_000, input: 272_000, output: 128_000 })
+      expect(eligible.limit).toEqual({ context: 400_000, input: 272_000, output: 128_000 })
       expect(eligible.enabled).toBe(true)
       expect(required(yield* catalog.model.get(Provider.ID.openai, Model.ID.make("gpt-5.5-pro"))).enabled).toBe(
         false,
@@ -148,15 +145,10 @@ describe("OpenAIPlugin", () => {
       expect(required(yield* catalog.model.get(Provider.ID.openai, Model.ID.make("gpt-5.4-pro"))).enabled).toBe(
         false,
       )
-      expect(required(yield* catalog.model.get(Provider.ID.openai, Model.ID.make("gpt-5.4"))).limit).toEqual({
-        context: 272_000,
-        input: 272_000,
-        output: 64_000,
-      })
       expect(required(yield* catalog.model.get(Provider.ID.openai, Model.ID.make("gpt-5.6"))).enabled).toBe(false)
       const gpt56 = required(yield* catalog.model.get(Provider.ID.openai, Model.ID.make("gpt-5.6-sol")))
       expect(gpt56.enabled).toBe(true)
-      expect(gpt56.limit).toEqual({ context: 272_000, input: 272_000, output: 128_000 })
+      expect(gpt56.limit).toEqual({ context: 500_000, input: 372_000, output: 128_000 })
       expect(required(yield* catalog.model.get(Provider.ID.openai, Model.ID.make("gpt-4.1"))).enabled).toBe(false)
     }),
   )

packages/core/test/session-compaction.test.ts

@@ -19,11 +19,9 @@ import { Session } from "@opencode-ai/core/session"
 import { Project } from "@opencode-ai/core/project"
 import { ProjectTable } from "@opencode-ai/core/project/sql"
 import { App } from "@opencode-ai/core/app"
-import { Agent } from "@opencode-ai/core/agent"
-import { Location } from "@opencode-ai/core/location"
 import { AbsolutePath } from "@opencode-ai/core/schema"
 import { Money } from "@opencode-ai/schema/money"
-import { DateTime, Effect, Fiber, Layer, Schema, Stream } from "effect"
+import { DateTime, Effect, Fiber, Layer, Stream } from "effect"
 import { asc, eq } from "drizzle-orm"
 import { testEffect } from "./lib/effect"
 
@@ -132,52 +130,6 @@ test("compaction prompt requires the checkpoint headings in order", () => {
   expect(prompt).toContain("Keep every section, even when empty.")
 })
 
-it.effect("auto compaction reserves a buffer below the prompt ceiling", () =>
-  Effect.gen(function* () {
-    const compaction = yield* SessionCompaction.Service
-    const session = Session.Info.make({
-      id: Session.ID.make("ses_input_limit"),
-      projectID: Project.ID.global,
-      cost: Money.USD.zero,
-      tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
-      time: { created: DateTime.makeUnsafe(0), updated: DateTime.makeUnsafe(0) },
-      location: Location.Ref.make({ directory: AbsolutePath.make("/tmp") }),
-    })
-    const input = (tokens: number, limits: { context: number; input?: number; output: number }) => ({
-      session,
-      model: Model.make({
-        id: "test-model",
-        provider: "test-provider",
-        route: OpenAIChat.route.with({ limits }),
-      }),
-      cost: [],
-      messages: [
-        Schema.decodeUnknownSync(SessionMessage.Assistant)({
-          id: SessionMessage.ID.make("msg_assistant"),
-          type: "assistant",
-          agent: Agent.defaultID,
-          model: { id: "test-model", providerID: "test-provider" },
-          content: [],
-          tokens: { input: tokens, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
-          time: { created: 0, completed: 0 },
-        }),
-      ],
-    })
-
-    const inputLimited = { context: 400_000, input: 272_000, output: 128_000 }
-    expect(compaction.required(input(251_999, inputLimited))).toBe(false)
-    expect(compaction.required(input(252_000, inputLimited))).toBe(true)
-
-    const contextLimited = { context: 100_000, output: 10_000 }
-    expect(compaction.required(input(79_999, contextLimited))).toBe(false)
-    expect(compaction.required(input(80_000, contextLimited))).toBe(true)
-
-    const outputLimited = { context: 100_000, output: 30_000 }
-    expect(compaction.required(input(69_999, outputLimited))).toBe(false)
-    expect(compaction.required(input(70_000, outputLimited))).toBe(true)
-  }),
-)
-
 it.effect("manual compaction summarizes short context instead of no-op", () =>
   Effect.gen(function* () {
     requests = []
@@ -235,7 +187,6 @@ it.effect("manual compaction summarizes short context instead of no-op", () =>
     expect(Array.from(yield* Fiber.join(delta)).map((event) => event.data.text)).toEqual(["manual summary"])
 
     expect(requests).toHaveLength(1)
-    expect(requests[0]?.cache).toEqual({ mode: "auto", key: sessionID })
     expect(requests[0]?.http?.headers).toEqual({
       "x-session-affinity": sessionID,
       "X-Session-Id": sessionID,

packages/core/test/session-generate.test.ts

@@ -287,7 +287,7 @@ it.effect("generates from fresh settled Session context without durable mutation
     expect(requests[0]?.system[0]?.text).toBe("Hooked system")
     expect(requests[0]?.system.map((part) => part.text)).toContain("Initial context")
     expect(requests[0]?.http?.headers).toMatchObject({ "X-Session-Id": sessionID })
-    expect(requests[0]?.cache).toEqual({ mode: "auto", key: sessionID })
+    expect(requests[0]?.providerOptions).toMatchObject({ openai: { promptCacheKey: sessionID } })
     const instructionUpdates = requests[0]?.messages.flatMap((message) =>
       message.role === "system"
         ? message.content.flatMap((content) => (content.type === "text" ? [content.text] : []))

packages/core/test/session-model-request.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test } from "bun:test"
 import { Message, ToolResultPart } from "@opencode-ai/ai"
-import { boundImages, unsupportedParts } from "@opencode-ai/core/session/model-request"
+import { unsupportedParts } from "@opencode-ai/core/session/model-request"
 
 const capabilities = (input: string[]) => ({ tools: true, input, output: ["text"] })
 
@@ -62,51 +62,3 @@ describe("SessionModelRequest.unsupportedParts", () => {
     expect(unsupportedParts([message], capabilities(["text", "image"]))[0]?.content).toEqual(message.content)
   })
 })
-
-describe("SessionModelRequest.boundImages", () => {
-  test("preserves images below the trigger", () => {
-    const messages = [Message.user({ type: "media", mediaType: "image/png", data: "aGVsbG8=" })]
-    expect(boundImages(messages)).toBe(messages)
-  })
-
-  test("replaces oldest images until the retained payload reaches the target", () => {
-    const image = "a".repeat(9 * 1024 * 1024)
-    const messages = [
-      Message.user({ type: "media", mediaType: "image/png", data: image, filename: "first.png" }),
-      Message.user({ type: "media", mediaType: "image/png", data: image, filename: "second.png" }),
-      Message.user({ type: "media", mediaType: "image/png", data: image, filename: "third.png" }),
-    ]
-    const result = boundImages(messages)
-
-    expect(result[0]?.content[0]).toMatchObject({ type: "text" })
-    expect(result[1]?.content[0]).toMatchObject({ type: "text" })
-    expect(result[2]?.content[0]).toMatchObject({ type: "media", filename: "third.png" })
-  })
-
-  test("replaces images nested in tool results", () => {
-    const image = "a".repeat(13 * 1024 * 1024)
-    const result = boundImages([
-      Message.tool(
-        ToolResultPart.make({
-          id: "call_1",
-          name: "read",
-          result: {
-            type: "content",
-            value: [
-              { type: "file", uri: `data:image/png;base64,${image}`, mime: "image/png", name: "first.png" },
-              { type: "file", uri: `data:image/png;base64,${image}`, mime: "image/png", name: "second.png" },
-            ],
-          },
-        }),
-      ),
-    ])
-
-    expect(result[0]?.content[0]).toMatchObject({
-      type: "tool-result",
-      result: {
-        type: "content",
-        value: [{ type: "text" }, { type: "file", name: "second.png" }],
-      },
-    })
-  })
-})

packages/core/test/session-prompt.test.ts

@@ -26,8 +26,8 @@ import { SessionPendingTable, SessionMessageTable, SessionTable } from "@opencod
 import { SessionStore } from "@opencode-ai/core/session/store"
 import { LocationServiceMap } from "@opencode-ai/core/location-service-map"
 import type { LocationServices } from "@opencode-ai/core/location-services"
-import { Image } from "@opencode-ai/core/image"
 import { testEffect } from "./lib/effect"
+import { imagePassthrough } from "./lib/image"
 
 const executionCalls: Session.ID[] = []
 const interruptCalls: Session.ID[] = []
@@ -58,10 +58,7 @@ const locations = Layer.effect(
     () =>
       // Attachment admission only needs the location-scoped Image service.
       // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion
-      Layer.mock(Image.Service, {
-        normalize: (_resource, content) =>
-          Effect.succeed(content.content.length > 5 * 1024 * 1024 ? { ...content, content: "AA==" } : content),
-      }) as unknown as Layer.Layer<LocationServices>,
+      imagePassthrough as unknown as Layer.Layer<LocationServices>,
   ),
 )
 const it = testEffect(
@@ -389,35 +386,6 @@ describe("Session.prompt", () => {
     }),
   )
 
-  it.effect("normalizes large image content before validating persisted Base64", () =>
-    Effect.gen(function* () {
-      yield* setup
-      const session = yield* Session.Service
-      const pixel = Buffer.from(
-        "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+A8AAQUBAScY42YAAAAASUVORK5CYII=",
-        "base64",
-      )
-      const bytes = Buffer.concat([pixel, Buffer.alloc(4_323_030 - pixel.length)])
-      const data = bytes.toString("base64")
-      expect(data).toHaveLength(5_764_040)
-
-      const message = yield* session.prompt({
-        sessionID,
-        text: "Inspect this image",
-        files: [{ uri: `data:image/png;base64,${data}` }],
-        resume: false,
-      })
-
-      expect(message.data.files).toEqual([
-        {
-          data: "AA==",
-          mime: "image/png",
-          source: { type: "inline" },
-        },
-      ])
-    }),
-  )
-
   it.effect("sniffs data URL content instead of trusting its declared MIME", () =>
     Effect.gen(function* () {
       yield* setup

packages/core/test/session-runner.test.ts

@@ -3210,7 +3210,7 @@ describe("SessionRunnerLLM", () => {
       yield* stream.started
 
       expect(requests).toHaveLength(2)
-      expect(requests.map((request) => (request.cache !== "none" ? request.cache?.key : undefined))).toEqual([
+      expect(requests.map((request) => request.providerOptions?.openai?.promptCacheKey)).toEqual([
         sessionID,
         otherSessionID,
       ])
@@ -3241,7 +3241,7 @@ describe("SessionRunnerLLM", () => {
       yield* session.resume(longSessionID)
       yield* session.resume(otherLongSessionID)
 
-      const keys = requests.map((request) => (request.cache !== "none" ? request.cache?.key : undefined))
+      const keys = requests.map((request) => request.providerOptions?.openai?.promptCacheKey)
       expect(keys).toEqual([longSessionID.slice(4), otherLongSessionID.slice(4)])
       expect(keys.every((key) => typeof key === "string" && key.length === 64)).toBe(true)
       expect(keys[0]).not.toBe(keys[1])

packages/core/test/session-title.test.ts

@@ -153,7 +153,6 @@ it.effect("generates a title from the sole user message and renames the session"
     yield* title.generateForFirstPrompt(sessionID)
 
     expect(requests).toHaveLength(1)
-    expect(requests[0]?.cache).toEqual({ mode: "auto", key: sessionID })
     expect(requests[0]?.http?.headers).toEqual({
       "x-session-affinity": sessionID,
       "X-Session-Id": sessionID,

packages/core/test/tool-read.test.ts

@@ -2,7 +2,7 @@ import { beforeEach, describe, expect } from "bun:test"
 import path from "path"
 import { Effect, Exit, Layer, PlatformError, Stream } from "effect"
 import { Config } from "@opencode-ai/core/config"
-import { ConfigMedia } from "@opencode-ai/core/config/media"
+import { ConfigAttachments } from "@opencode-ai/core/config/attachments"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { LayerNode } from "@opencode-ai/util/effect/layer-node"
 import { FileSystem } from "@opencode-ai/core/filesystem"
@@ -432,8 +432,8 @@ describe("ReadTool", () => {
         new Config.Document({
           type: "document",
           info: new Config.Info({
-            media: new ConfigMedia.Info({
-              image: new ConfigMedia.Image({ auto_resize: false, max_width: 4 }),
+            attachments: new ConfigAttachments.Info({
+              image: new ConfigAttachments.Image({ auto_resize: false, max_width: 4 }),
             }),
           }),
         }),
@@ -475,7 +475,7 @@ describe("ReadTool", () => {
         new Config.Document({
           type: "document",
           info: new Config.Info({
-            media: new ConfigMedia.Info({ image: new ConfigMedia.Image({ max_width: 4 }) }),
+            attachments: new ConfigAttachments.Info({ image: new ConfigAttachments.Image({ max_width: 4 }) }),
           }),
         }),
       ])
@@ -514,8 +514,8 @@ describe("ReadTool", () => {
         new Config.Document({
           type: "document",
           info: new Config.Info({
-            media: new ConfigMedia.Info({
-              image: new ConfigMedia.Image({ max_base64_bytes: 1 }),
+            attachments: new ConfigAttachments.Info({
+              image: new ConfigAttachments.Image({ max_base64_bytes: 1 }),
             }),
           }),
         }),

packages/enterprise/package.json

@@ -16,7 +16,6 @@
     "@opencode-ai/core": "workspace:*",
     "@opencode-ai/session-ui": "workspace:*",
     "@opencode-ai/ui": "workspace:*",
-    "@opencode-ai/util": "workspace:*",
     "aws4fetch": "^1.0.20",
     "@pierre/diffs": "catalog:",
     "@solidjs/router": "catalog:",

packages/enterprise/src/routes/share/[shareID].tsx

@@ -4,7 +4,6 @@ import { SessionReview } from "@opencode-ai/session-ui/session-review"
 import { DataProvider } from "@opencode-ai/session-ui/context"
 import { FileComponentProvider } from "@opencode-ai/ui/context/file"
 import { WorkerPoolProvider } from "@opencode-ai/ui/context/worker-pool"
-import { withTimestampedFallback } from "@opencode-ai/util/session-title-fallback"
 import { createAsync, query, useParams } from "@solidjs/router"
 import { createMemo, createSignal, ErrorBoundary, For, Match, Show, Switch } from "solid-js"
 import { Share } from "~/core/share"
@@ -159,7 +158,11 @@ export default function () {
           const match = createMemo(() => Binary.search(data().session, data().sessionID, (s) => s.id))
           if (!match().found) throw new Error(`Session ${data().sessionID} not found`)
           const info = createMemo(() => data().session[match().index])
-          const title = createMemo(() => withTimestampedFallback(info()))
+          const title = createMemo(
+            () =>
+              info().title ??
+              `${info().parentID ? "Child" : "New"} session - ${new Date(info().time.created).toISOString()}`,
+          )
           const ogImage = createMemo(() => {
             const models = new Set<string>()
             const messages = data().message[data().sessionID] ?? []

packages/plugin/src/effect/session.ts

@@ -29,7 +29,7 @@ export interface SessionHooks {
 
 export type SessionDomain = Pick<
   SessionApi<unknown>,
-  "create" | "get" | "prompt" | "generate" | "command" | "synthetic" | "interrupt" | "rename" | "wait"
+  "create" | "get" | "prompt" | "generate" | "command" | "synthetic" | "interrupt"
 > & {
   readonly hook: Hooks<SessionHooks>
 }

packages/plugin/src/tui/context.ts

@@ -26,27 +26,12 @@ import type { JSX } from "@opentui/solid"
 import type { Store } from "solid-js/store"
 
 export interface Storage {
-  /**
-   * Durable JSON state: persisted to disk, survives hot reloads and TUI
-   * restarts, and stays live-synced across running TUI instances.
-   */
   store<Value extends object>(
     key: string,
     options: {
       readonly initial: Value
     },
   ): readonly [Store<Value>, (mutation: (draft: Value) => void) => Promise<void>]
-  /**
-   * Ephemeral in-memory state: survives plugin hot reloads (old and new
-   * generations share the same live store) and is gone when the TUI exits.
-   * Updates are synchronous and values need not be JSON-serializable.
-   */
-  memory<Value extends object>(
-    key: string,
-    options: {
-      readonly initial: Value
-    },
-  ): readonly [Store<Value>, (mutation: (draft: Value) => void) => void]
 }
 
 interface LocationCollection<Value> {
@@ -151,9 +136,6 @@ export interface SlotMap {
     readonly sessionID?: string
     readonly mode: "normal" | "shell"
   }
-  readonly "session.composer.top": {
-    readonly sessionID: string
-  }
   readonly "sidebar.content": {
     readonly sessionID: string
   }

packages/protocol/src/groups/session.ts

@@ -149,7 +149,6 @@ export const makeSessionGroup = <I extends HttpApiMiddleware.AnyId, S>(sessionLo
       HttpApiEndpoint.post("session.create", "/api/session", {
         payload: Schema.Struct({
           id: Session.ID.pipe(Schema.optional),
-          title: Schema.String.pipe(Schema.optional),
           agent: Agent.ID.pipe(Schema.optional),
           model: Model.Ref.pipe(Schema.optional),
           location: Location.Ref.pipe(Schema.optional),

packages/server/src/handlers/session.ts

@@ -77,7 +77,6 @@ export const SessionHandler = HttpApiBuilder.group(Api, "server.session", (handl
             data: yield* session
               .create({
                 id: ctx.payload.id,
-                title: ctx.payload.title,
                 agent: ctx.payload.agent,
                 model: ctx.payload.model,
                 location: ctx.payload.location ?? { directory: AbsolutePath.make(process.cwd()) },

packages/session-ui/src/v2/components/prompt-input/index.tsx

@@ -3,6 +3,7 @@ import { FileIcon } from "@opencode-ai/ui/file-icon"
 import { Icon } from "@opencode-ai/ui/icon"
 import { IconButton } from "@opencode-ai/ui/icon-button"
 import { ProviderIcon } from "@opencode-ai/ui/provider-icon"
+import { ScrollView } from "@opencode-ai/ui/scroll-view"
 import { ButtonV2 } from "@opencode-ai/ui/v2/button-v2"
 import { Icon as IconV2 } from "@opencode-ai/ui/v2/icon"
 import { IconButtonV2 } from "@opencode-ai/ui/v2/icon-button-v2"
@@ -140,44 +141,46 @@ export function PromptInputV2(props: PromptInputV2Props) {
         </Show>
 
         <div class="relative min-h-[60px]">
-          <div
-            ref={(element) => {
-              editor = element
-              props.controller.setEditor(element)
-              renderPromptInputV2Editor(element, props.controller.parts())
-            }}
-            data-component="prompt-input"
-            role="textbox"
-            aria-multiline="true"
-            aria-label="Prompt"
-            contenteditable={!props.disabled && !props.readOnly}
-            autocapitalize={state.mode === "normal" ? "sentences" : "off"}
-            autocorrect={state.mode === "normal" ? "on" : "off"}
-            spellcheck={state.mode === "normal"}
-            // @ts-expect-error
-            autocomplete="off"
-            class="relative z-10 block min-h-[60px] max-h-[180px] w-full overflow-y-auto whitespace-pre-wrap bg-transparent px-4 pt-4 pb-2 text-[13px] font-[440] leading-5 text-v2-text-text-base focus:outline-none empty:before:content-['\200B'] [&_[data-mention=file]]:text-syntax-property [&_[data-mention=agent]]:text-syntax-type [&_[data-mention=reference]]:text-syntax-keyword"
-            classList={{ "font-mono!": state.mode === "shell", "opacity-50": props.disabled }}
-            onInput={(event) => {
-              const cursor = promptInputV2Cursor(event.currentTarget)
-              const prompt = parsePromptInputV2Editor(event.currentTarget)
-              const images = props.controller.parts().filter((part) => part.type === "image")
-              localInput = true
-              props.controller.onInput(prompt.map((part) => part.content).join(""), [...prompt, ...images], cursor)
-            }}
-            onKeyDown={(event) => {
-              if (props.controller.onKeyDown(event)) return
-              if (event.key === "Enter" && !event.shiftKey && !event.isComposing) {
-                event.preventDefault()
-                if (event.repeat) return
-                props.controller.submit()
-              }
-            }}
-            onKeyUp={updateCursor}
-            onPointerUp={updateCursor}
-            onPaste={props.controller.onPaste}
-            onFocus={() => props.controller.dispatch({ type: "focus.editor" })}
-          />
+          <ScrollView class="min-h-[60px] max-h-[180px]">
+            <div
+              ref={(element) => {
+                editor = element
+                props.controller.setEditor(element)
+                renderPromptInputV2Editor(element, props.controller.parts())
+              }}
+              data-component="prompt-input"
+              role="textbox"
+              aria-multiline="true"
+              aria-label="Prompt"
+              contenteditable={!props.disabled && !props.readOnly}
+              autocapitalize={state.mode === "normal" ? "sentences" : "off"}
+              autocorrect={state.mode === "normal" ? "on" : "off"}
+              spellcheck={state.mode === "normal"}
+              // @ts-expect-error
+              autocomplete="off"
+              class="relative z-10 block min-h-[60px] w-full whitespace-pre-wrap bg-transparent px-4 pt-4 pb-2 text-[13px] font-[440] leading-5 text-v2-text-text-base focus:outline-none empty:before:content-['\200B'] [&_[data-mention=file]]:text-syntax-property [&_[data-mention=agent]]:text-syntax-type [&_[data-mention=reference]]:text-syntax-keyword"
+              classList={{ "font-mono!": state.mode === "shell", "opacity-50": props.disabled }}
+              onInput={(event) => {
+                const cursor = promptInputV2Cursor(event.currentTarget)
+                const prompt = parsePromptInputV2Editor(event.currentTarget)
+                const images = props.controller.parts().filter((part) => part.type === "image")
+                localInput = true
+                props.controller.onInput(prompt.map((part) => part.content).join(""), [...prompt, ...images], cursor)
+              }}
+              onKeyDown={(event) => {
+                if (props.controller.onKeyDown(event)) return
+                if (event.key === "Enter" && !event.shiftKey && !event.isComposing) {
+                  event.preventDefault()
+                  if (event.repeat) return
+                  props.controller.submit()
+                }
+              }}
+              onKeyUp={updateCursor}
+              onPointerUp={updateCursor}
+              onPaste={props.controller.onPaste}
+              onFocus={() => props.controller.dispatch({ type: "focus.editor" })}
+            />
+          </ScrollView>
           <Show when={!props.controller.value()}>
             <div
               class="pointer-events-none absolute inset-x-0 top-0 px-4 pt-4 text-[13px] font-[440] leading-5 text-v2-text-text-faint"

packages/tui/src/app.tsx

@@ -76,14 +76,13 @@ import { PromptHistoryProvider } from "./component/prompt/history"
 import { FrecencyProvider } from "./component/prompt/frecency"
 import { PromptStashProvider } from "./component/prompt/stash"
 import { Toast, ToastProvider, useToast } from "./ui/toast"
-import { isFallbackTitle } from "@opencode-ai/util/session-title-fallback"
+import { isDefaultTitle } from "./util/session"
 import * as Model from "./util/model"
 import { ArgsProvider, useArgs, type Args } from "./context/args"
 import open from "open"
 import { PromptRefProvider, usePromptRef } from "./context/prompt"
 import { Config, ConfigProvider, useConfig } from "./config"
-import { PluginProvider, usePlugin, type PackageResolver } from "./plugin/context"
-import { PluginRoute, PluginSlot } from "./plugin/render"
+import { PluginProvider, PluginRoute, PluginSlot, usePlugin, type PackageResolver } from "./plugin/context"
 import { CommandPaletteDialog } from "./component/command-palette"
 import { COMMAND_PALETTE_COMMAND, Keymap, type KeymapCommand } from "./context/keymap"
 
@@ -538,7 +537,7 @@ function App(props: { pair?: DialogPairCredentials }) {
 
     if (route.data.type === "session") {
       const title = session?.title
-      if (!title || isFallbackTitle(title)) {
+      if (!title || isDefaultTitle(title)) {
         renderer.setTerminalTitle("OpenCode")
         return
       }
@@ -647,10 +646,7 @@ function App(props: { pair?: DialogPairCredentials }) {
         run: () => {
           route.navigate({
             type: "home",
-            location:
-              route.data.type === "session"
-                ? (data.session.get(route.data.sessionID)?.location ?? location.ref)
-                : undefined,
+            location: route.data.type === "session" ? data.session.get(route.data.sessionID)?.location : undefined,
           })
           dialog.clear()
         },

packages/tui/src/component/dialog-config.tsx

@@ -105,7 +105,7 @@ export const settings: Setting[] = [
     title: "Scope",
     category: "Tabs",
     path: ["tabs", "scope"],
-    default: "global",
+    default: "cwd",
     values: ["cwd", "global"],
     labels: ["current directory", "global"],
   },

packages/tui/src/component/dialog-move-session.tsx

@@ -2,8 +2,8 @@ import { useTerminalDimensions } from "@opentui/solid"
 import { TextAttributes } from "@opentui/core"
 import { createMemo, createResource, createSignal, onMount, Show } from "solid-js"
 import path from "path"
-import { DialogSelect, dialogSelectContentWidth, type DialogSelectOption } from "../ui/dialog-select"
-import { dialogWidth, useDialog } from "../ui/dialog"
+import { DialogSelect, type DialogSelectOption } from "../ui/dialog-select"
+import { useDialog } from "../ui/dialog"
 import { useClient } from "../context/client"
 import { Keymap } from "../context/keymap"
 import { useTheme } from "../context/theme"
@@ -159,10 +159,7 @@ export function DialogMoveSession(props: DialogMoveSessionProps) {
       if (b.location === b.root.directory) return 1
       return a.location.localeCompare(b.location)
     })
-    const titleWidth = Math.max(
-      1,
-      dialogSelectContentWidth(Math.min(dialogWidth("xlarge"), dimensions().width - 2)),
-    )
+    const titleWidth = Math.max(1, Math.min(116, dimensions().width - 2) - 12)
 
     return list.map((item) => {
       const title = abbreviateHome(item.location, paths.home)

packages/tui/src/component/dialog-open.tsx

@@ -2,8 +2,8 @@ import path from "path"
 import { createMemo, createResource, createSignal, onMount } from "solid-js"
 import type { SessionInfo } from "@opencode-ai/client"
 import { useTerminalDimensions } from "@opentui/solid"
-import { dialogWidth, useDialog } from "../ui/dialog"
-import { DialogSelect, dialogSelectContentWidth } from "../ui/dialog-select"
+import { useDialog } from "../ui/dialog"
+import { DialogSelect } from "../ui/dialog-select"
 import { useRoute } from "../context/route"
 import { useData } from "../context/data"
 import { useClient } from "../context/client"
@@ -16,7 +16,7 @@ import { abbreviateHome } from "../runtime"
 import { useTuiPaths } from "../context/runtime"
 import { truncateFilePath } from "../ui/file-path"
 import { stringWidth } from "../util/string-width"
-import { withTimestampedFallback } from "@opencode-ai/util/session-title-fallback"
+import { sessionTitle } from "../util/session"
 import { Spinner } from "./spinner"
 
 const RECENT_LIMIT = 8
@@ -37,8 +37,8 @@ export function DialogOpen() {
   const dimensions = useTerminalDimensions()
   const shortcuts = Keymap.useShortcuts()
   const [filter, setFilter] = createSignal("")
-  const [selectionMoved, setSelectionMoved] = createSignal(false)
 
+  data.project.invalidate()
   void data.project.sync().catch(() => {})
 
   // One background fetch fills in recent sessions from other projects; the menu renders
@@ -52,12 +52,8 @@ export function DialogOpen() {
     { initialValue: [] },
   )
 
-  const openTabs = createMemo(
-    () => new Set(sessionTabs.enabled() ? sessionTabs.tabs().map((tab) => tab.sessionID) : []),
-  )
-  const currentSessionID = createMemo(() =>
-    route.data.type === "session" ? data.session.root(route.data.sessionID) : undefined,
-  )
+  const openTabs = createMemo(() => new Set(sessionTabs.tabs().map((tab) => tab.sessionID)))
+  const currentSessionID = createMemo(() => (route.data.type === "session" ? route.data.sessionID : undefined))
   const sessions = createMemo(() => {
     const seen = new Set<string>()
     return [...data.session.list(), ...fetched()]
@@ -73,7 +69,7 @@ export function DialogOpen() {
     const tabs = openTabs()
     // With an empty query the menu shows what is not already one keystroke away: open tabs are
     // visible in the strip, so recents exclude them. Typing widens the pool to every session so
-    // matching a loaded tab by name still switches to it.
+    // matching a tab by name still switches to it.
     const recent = filter().trim()
       ? sessions()
       : sessions()
@@ -82,15 +78,12 @@ export function DialogOpen() {
     const sessionOptions = recent.map((session) => {
       const project = data.project.get(session.projectID)
       const name = project?.canonical === "/" ? undefined : project?.name || path.basename(project?.canonical ?? "")
-      const running =
-        data.session.status(session.id) === "running" ||
-        data.session.family(session.id).some((id) => data.session.status(id) === "running")
+      const running = data.session.family(session.id).some((id) => data.session.status(id) === "running")
       return {
-        title: withTimestampedFallback(session),
+        title: sessionTitle(session),
         value: { type: "session", sessionID: session.id } as OpenTarget,
         category: "Sessions",
         footer: `${name ? `${Locale.truncate(name, 20)} · ` : ""}${timeAgo(session.time.updated)}`,
-        onSelect: () => location.set(session.location),
         gutter: running
           ? () => <Spinner />
           : tabs.has(session.id)
@@ -104,25 +97,21 @@ export function DialogOpen() {
     const projectOptions = data.project
       .list()
       .filter((project) => {
-        if (project.canonical === "/" || seen.has(project.canonical)) return false
+        if (project.canonical === "/" || project.id === current?.id || seen.has(project.canonical)) return false
         seen.add(project.canonical)
         return true
       })
       .map((project) => {
         const title = project.name ?? path.basename(project.canonical)
         const footer = abbreviateHome(project.canonical, paths.home)
-        const width =
-          dialogSelectContentWidth(Math.min(dialogWidth("large"), dimensions().width - 2)) - stringWidth(title)
+        // Dialog padding, the gutter column, title padding, and the separating space use nine columns.
+        const width = Math.min(60, dimensions().width - 2) - 9 - stringWidth(title)
         return {
           title,
           footer: truncateFilePath(footer, width),
           searchText: footer,
           value: { type: "project", directory: project.canonical } as OpenTarget,
           category: "Projects",
-          gutter:
-            project.canonical === current?.canonical
-              ? () => <text fg={theme.text.formfield.selected}>●</text>
-              : undefined,
         }
       })
 
@@ -138,8 +127,6 @@ export function DialogOpen() {
       options={options()}
       current={currentSessionID() ? ({ type: "session", sessionID: currentSessionID()! } as OpenTarget) : undefined}
       focusCurrent={false}
-      preserveSelection={selectionMoved()}
-      onMove={() => setSelectionMoved(true)}
       onFilter={setFilter}
       noMatchView={
         <box paddingLeft={4} paddingRight={4}>

packages/tui/src/component/dialog-session-list.tsx

@@ -18,8 +18,7 @@ import { Spinner } from "./spinner"
 import { errorMessage } from "../util/error"
 import { useSessionTabs } from "../context/session-tabs"
 import { useStorage } from "../context/storage"
-import { useConfig } from "../config"
-import { withTimestampedFallback } from "@opencode-ai/util/session-title-fallback"
+import { sessionTitle } from "../util/session"
 
 export function DialogSessionList() {
   const dialog = useDialog()
@@ -31,15 +30,12 @@ export function DialogSessionList() {
   const client = useClient()
   const local = useLocal()
   const sessionTabs = useSessionTabs()
-  const config = useConfig().data
   const toast = useToast()
   const [filter, setFilter] = createSignal("")
   const shortcuts = Keymap.useShortcuts()
   const [search, setSearch] = createDebouncedSignal("", 150)
   const [toDelete, setToDelete] = createSignal<string>()
-  const [prefs, updatePrefs] = useStorage().store("session-list", {
-    initial: { allProjects: config.tabs?.scope !== "cwd" },
-  })
+  const [prefs, updatePrefs] = useStorage().store("session-list", { initial: { allProjects: false } })
   const allProjects = () => prefs.allProjects
 
   const [searchResults, { mutate: setSearchResults }] = createResource(
@@ -82,15 +78,12 @@ export function DialogSessionList() {
           (session.projectID === current?.project.id && session.location.directory === current.directory),
       )
     if (!query) return sessions
-    return sessions.filter(
-      (session) => !session.parentID && withTimestampedFallback(session).toLowerCase().includes(query),
-    )
+    return sessions.filter((session) => !session.parentID && sessionTitle(session).toLowerCase().includes(query))
   })
   const sessions = createMemo(() => {
     const query = filter().trim()
     const local = localSessions()
-    if (query !== search().trim()) return searchResults.latest?.sessions ?? local
-    if (searchResults.loading) return searchResults.latest?.sessions ?? []
+    if (query !== search().trim() || searchResults.loading) return searchResults.latest?.sessions ?? local
     const result = searchResults()
     if (result?.query !== query || result.allProjects !== allProjects() || result.error) return local
     return result.sessions
@@ -147,21 +140,17 @@ export function DialogSessionList() {
       const slot = sessionTabs.enabled() ? undefined : slotByID.get(session.id)
       const deleting = toDelete() === session.id
       return {
-        title: deleting
-          ? `Press ${shortcuts.get("session.delete")} again to confirm`
-          : withTimestampedFallback(session),
+        title: deleting ? `Press ${shortcuts.get("session.delete")} again to confirm` : sessionTitle(session),
         value: session.id,
         category,
         footer,
         bg: deleting ? theme.background.action.destructive.focused : undefined,
         fg: deleting ? theme.text.action.destructive.focused : undefined,
-        gutter:
-          data.session.status(session.id) === "running" ||
-          data.session.family(session.id).some((id) => data.session.status(id) === "running")
-            ? () => <Spinner />
-            : slot === undefined
-              ? undefined
-              : () => <text fg={theme.hue.accent[mode() === "light" ? 800 : 200]}>{slot}</text>,
+        gutter: data.session.family(session.id).some((id) => data.session.status(id) === "running")
+          ? () => <Spinner />
+          : slot === undefined
+            ? undefined
+            : () => <text fg={theme.hue.accent[mode() === "light" ? 800 : 200]}>{slot}</text>,
       }
     }
 
@@ -247,9 +236,7 @@ export function DialogSessionList() {
               .remove({ sessionID: option.value })
               .then(() => {
                 setSearchResults((result) =>
-                  result
-                    ? { ...result, sessions: result.sessions.filter((session) => session.id !== option.value) }
-                    : result,
+                  result ? { ...result, sessions: result.sessions.filter((session) => session.id !== option.value) } : result,
                 )
               })
               .catch((error) => {

packages/tui/src/component/logo.tsx

@@ -1,13 +1,11 @@
 import { RGBA, TextAttributes } from "@opentui/core"
 import { For, type JSX } from "solid-js"
-import { useTerminalDimensions } from "@opentui/solid"
 import { useTheme } from "../context/theme"
 import { tint } from "../theme/color"
-import { go, logo } from "../logo"
+import { logo } from "../logo"
 
 export function Logo() {
   const theme = useTheme()
-  const dimensions = useTerminalDimensions()
 
   const renderLine = (line: string, fg: RGBA, bold: boolean): JSX.Element[] => {
     const shadow = tint(theme.background.default, fg, 0.25)
@@ -51,29 +49,14 @@ export function Logo() {
 
   return (
     <box>
-      {dimensions().height < 12 ? null : dimensions().width < 22 ? (
-        <For each={go.right.slice(1)}>
-          {(line) => <box flexDirection="row">{renderLine(line, theme.text.default, true)}</box>}
-        </For>
-      ) : dimensions().width < 44 ? (
-        <>
-          <For each={logo.left.slice(1)}>
-            {(line) => <box flexDirection="row">{renderLine(line, theme.text.subdued, false)}</box>}
-          </For>
-          <For each={logo.right}>
-            {(line) => <box flexDirection="row">{renderLine(line, theme.text.default, true)}</box>}
-          </For>
-        </>
-      ) : (
-        <For each={logo.left}>
-          {(line, index) => (
-            <box flexDirection="row" gap={1}>
-              <box flexDirection="row">{renderLine(line, theme.text.subdued, false)}</box>
-              <box flexDirection="row">{renderLine(logo.right[index()], theme.text.default, true)}</box>
-            </box>
-          )}
-        </For>
-      )}
+      <For each={logo.left}>
+        {(line, index) => (
+          <box flexDirection="row" gap={1}>
+            <box flexDirection="row">{renderLine(line, theme.text.subdued, false)}</box>
+            <box flexDirection="row">{renderLine(logo.right[index()], theme.text.default, true)}</box>
+          </box>
+        )}
+      </For>
     </box>
   )
 }

packages/tui/src/component/patch-diff.tsx

@@ -1,83 +0,0 @@
-/** @jsxImportSource @opentui/solid */
-import { DiffRenderable, LineNumberRenderable, type ColorInput } from "@opentui/core"
-import type { JSX } from "@opentui/solid"
-import { createMemo, For, Show, splitProps } from "solid-js"
-import { splitPatchHunks } from "../util/diff"
-import { stringWidth } from "../util/string-width"
-
-export interface PatchDiffRef {
-  readonly hunks: () => readonly DiffRenderable[]
-}
-
-type Props = Omit<JSX.IntrinsicElements["diff"], "diff" | "lineNumberBg" | "ref"> & {
-  diff: string
-  hunkFg: ColorInput
-  lineNumberBg: ColorInput
-  ref?: (value: PatchDiffRef) => void
-}
-
-export function PatchDiff(props: Props) {
-  const [local, diffProps] = splitProps(props, ["diff", "hunkFg", "lineNumberBg", "ref"])
-  const hunks = createMemo(() => splitPatchHunks(local.diff))
-  const nodes = new Map<number, DiffRenderable>()
-  local.ref?.({
-    hunks: () =>
-      [...nodes.entries()]
-        .sort(([left], [right]) => left - right)
-        .map(([, node]) => node)
-        .filter((node) => !node.isDestroyed),
-  })
-  const syncGutters = (attempt = 0) => {
-    requestAnimationFrame(() => {
-      const sides = [...nodes.values()]
-        .filter((item) => !item.isDestroyed)
-        .flatMap((item) => item.getChildren().filter((side) => side instanceof LineNumberRenderable))
-      const lineNumbers = sides.map((side) => new Map([...side.getLineNumbers()].filter(([line]) => line >= 0)))
-      const digits = lineNumbers.map((numbers) => Math.max(0, ...numbers.values()).toString().length)
-      const after = sides.map((side) =>
-        Math.max(
-          0,
-          ...[...side.getLineSigns()].filter(([line]) => line >= 0).map(([, sign]) => stringWidth(sign.after ?? "")),
-        ),
-      )
-      const maxDigits = Math.max(...digits)
-      const maxAfter = Math.max(...after)
-      if (!maxDigits && attempt < 2) return syncGutters(attempt + 1)
-      if (!maxDigits) return
-      sides.forEach((side) => {
-        const index = sides.indexOf(side)
-        const signs = new Map([...side.getLineSigns()].filter(([line]) => line >= 0))
-        signs.set(-1, { after: " ".repeat(maxAfter + maxDigits - digits[index]) })
-        side.setLineNumbers(lineNumbers[index])
-        side.setLineSigns(signs)
-      })
-    })
-  }
-  const register = (index: number, node: DiffRenderable) => {
-    nodes.set(index, node)
-    syncGutters()
-  }
-
-  return (
-    <For each={hunks()}>
-      {(hunk, index) => (
-        <>
-          <Show when={index() > 0}>
-            <box width="100%" height={1} backgroundColor={local.lineNumberBg}>
-              <text fg={local.hunkFg} bg={local.lineNumberBg}>
-                {` ${hunk.header ?? ""}`}
-              </text>
-            </box>
-          </Show>
-          <diff
-            {...diffProps}
-            ref={(node: DiffRenderable) => register(index(), node)}
-            diff={hunk.patch}
-            minHeight={hunk.rows}
-            lineNumberBg={local.lineNumberBg}
-          />
-        </>
-      )}
-    </For>
-  )
-}

packages/tui/src/component/prompt/index.tsx

@@ -53,7 +53,7 @@ import { useData } from "../../context/data"
 import { useLocation } from "../../context/location"
 import { Keymap, type KeymapCommand } from "../../context/keymap"
 import { abbreviateHome } from "../../runtime"
-import { PluginSlot } from "../../plugin/render"
+import { PluginSlot } from "../../plugin/context"
 
 registerOpencodeSpinner()
 
@@ -1168,19 +1168,6 @@ export function Prompt(props: PromptProps) {
     )
   }
 
-  function expandPastedText(extmarkId: number) {
-    const extmark = input.extmarks.get(extmarkId)
-    const ref = store.extmarkToPart.get(extmarkId)
-    if (!extmark || ref?.type !== "pasted") return false
-    const part = store.prompt.pasted[ref.index]
-    if (!part) return false
-
-    input.extmarks.delete(extmarkId)
-    input.setSelection(extmark.start, extmark.end)
-    input.insertText(part.text)
-    return true
-  }
-
   async function pasteInputText(text: string) {
     const normalizedText = text.replace(/\r\n/g, "\n").replace(/\r/g, "\n")
     const pastedContent = normalizedText.trim()
@@ -1204,15 +1191,6 @@ export function Prompt(props: PromptProps) {
 
     const lineCount = (pastedContent.match(/\n/g)?.length ?? 0) + 1
     if ((lineCount >= 3 || pastedContent.length > 150) && config.prompt?.paste !== "full") {
-      const extmark = input.extmarks.getAllForTypeId(promptPartTypeId).find((extmark) => {
-        const ref = store.extmarkToPart.get(extmark.id)
-        return (
-          (extmark.end === input.cursorOffset || extmark.end + 1 === input.cursorOffset) &&
-          ref?.type === "pasted" &&
-          store.prompt.pasted[ref.index]?.text === pastedContent
-        )
-      })
-      if (extmark && expandPastedText(extmark.id)) return
       pasteText(pastedContent, `[Pasted ~${lineCount} lines]`)
       return
     }
@@ -1314,20 +1292,13 @@ export function Prompt(props: PromptProps) {
 
   const placeholderText = createMemo(() => {
     if (props.showPlaceholder === false) return undefined
-    const value = (() => {
-      if (store.mode === "shell") {
-        if (!shell().length) return undefined
-        return `Run a command... "${shell()[store.placeholder % shell().length]}"`
-      }
-      if (!list().length) return undefined
-      return `Ask anything... "${list()[store.placeholder % list().length]}"`
-    })()
-    if (!value) return undefined
-    const width =
-      dimensions().width < 44
-        ? dimensions().width - 5
-        : Math.min(75, dimensions().width - 4) - 5
-    return Locale.takeWidth(value, Math.max(1, width)).trimEnd()
+    if (store.mode === "shell") {
+      if (!shell().length) return undefined
+      const example = shell()[store.placeholder % shell().length]
+      return `Run a command... "${example}"`
+    }
+    if (!list().length) return undefined
+    return `Ask anything... "${list()[store.placeholder % list().length]}"`
   })
   const locationLabel = createMemo(() => {
     if (!props.sessionID) {
@@ -1377,8 +1348,8 @@ export function Prompt(props: PromptProps) {
           }}
         >
           <box
-            paddingLeft={dimensions().width < 44 ? 1 : 2}
-            paddingRight={dimensions().width < 44 ? 1 : 2}
+            paddingLeft={2}
+            paddingRight={2}
             paddingTop={1}
             flexShrink={0}
             backgroundColor={promptBg()}
@@ -1454,48 +1425,33 @@ export function Prompt(props: PromptProps) {
                 }, 0)
               }}
               onMouseDown={(r: MouseEvent) => {
-                if (props.disabled || r.button !== 0) return
+                if (props.disabled) return
                 r.target?.focus()
-                const extmark = input.extmarks
-                  .getAtOffset(input.cursorOffset)
-                  .find((item) => store.extmarkToPart.get(item.id)?.type === "pasted")
-                if (!extmark || !expandPastedText(extmark.id)) return
-                r.preventDefault()
-                r.stopPropagation()
               }}
               focusedBackgroundColor="transparent"
               cursorColor={props.disabled ? theme.background.surface.offset : theme.text.default}
               syntaxStyle={syntax()}
             />
             <box flexDirection="row" flexShrink={0} paddingTop={1} gap={1} justifyContent="space-between">
-              <box flexDirection="row" gap={1} flexGrow={1} flexShrink={1} minWidth={0}>
+              <box flexDirection="row" gap={1}>
                 <Show when={agentLabel()} fallback={<box height={1} />}>
                   {(label) => (
                     <>
                       <text fg={fadeColor(highlight(), agentMetaAlpha())}>{label()}</text>
-                      <Show
-                        when={store.mode === "normal" && local.permission.mode === "auto" && dimensions().width >= 44}
-                      >
+                      <Show when={store.mode === "normal" && local.permission.mode === "auto"}>
                         <text fg={fadeColor(theme.text.subdued, agentMetaAlpha())}>auto</text>
                       </Show>
-                      <Show when={store.mode === "normal" && dimensions().width >= 28}>
-                        <box flexDirection="row" gap={1} flexGrow={1} flexShrink={1} minWidth={0}>
+                      <Show when={store.mode === "normal"}>
+                        <box flexDirection="row" gap={1}>
                           <text fg={fadeColor(theme.text.subdued, modelMetaAlpha())}>·</text>
                           <text
-                            flexShrink={1}
-                            minWidth={0}
-                            wrapMode="none"
-                            truncate
+                            flexShrink={0}
                             fg={fadeColor(leader() ? theme.text.subdued : theme.text.default, modelMetaAlpha())}
                           >
                             {local.model.parsed().model}
                           </text>
-                          <Show when={dimensions().width >= 50}>
-                            <text flexShrink={0} fg={fadeColor(theme.text.subdued, modelMetaAlpha())}>
-                              {currentProviderLabel()}
-                            </text>
-                          </Show>
-                          <Show when={showVariant() && dimensions().width >= 70}>
+                          <text fg={fadeColor(theme.text.subdued, modelMetaAlpha())}>{currentProviderLabel()}</text>
+                          <Show when={showVariant()}>
                             <text fg={fadeColor(theme.text.subdued, variantMetaAlpha())}>·</text>
                             <text>
                               <span

packages/tui/src/context/data.tsx

@@ -45,7 +45,6 @@ const messageIDFromEvent = (eventID: string) => eventID.replace(/^evt_/, "msg_")
 // server cannot recover their Location when settling them. Preserve the event Location
 // until MCP elicitations carry session ownership.
 export type FormWithLocation = FormInfo & { readonly location?: LocationRef }
-type ShellWithLocation = ShellInfo & { readonly location: LocationRef }
 
 type LocationData = {
   info?: LocationGetOutput
@@ -62,7 +61,7 @@ type LocationData = {
   websearch?: WebSearchProvider[]
   // Currently running shell commands for this location, keyed by shell id. Entries are removed
   // once the command exits or is deleted, so this only ever holds in-flight shells.
-  shell?: Record<string, ShellWithLocation>
+  shell?: Record<string, ShellInfo>
   skill?: SkillInfo[]
 }
 
@@ -375,11 +374,8 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
             .catch((error) => console.error("Failed to load projected model switch message", error))
           break
         case "session.renamed":
-          // Preserve the live title when it races the session's initial read.
-          void result.session.sync(event.data.sessionID).then(() => {
-            if (store.session.info[event.data.sessionID])
-              setStore("session", "info", event.data.sessionID, "title", event.data.title)
-          })
+          if (store.session.info[event.data.sessionID])
+            setStore("session", "info", event.data.sessionID, "title", event.data.title)
           break
         case "session.moved":
           if (store.session.info[event.data.sessionID]) {
@@ -855,10 +851,7 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
         case "shell.created":
           setStore("location", locationKey(event.location ?? defaultLocation()), (data) => ({
             ...data,
-            shell: {
-              ...data?.shell,
-              [event.data.info.id]: { ...event.data.info, location: event.location ?? defaultLocation() },
-            },
+            shell: { ...data?.shell, [event.data.info.id]: event.data.info },
           }))
           break
         case "shell.exited":
@@ -1113,18 +1106,7 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
             const key = locationKey(response.location)
             setStore("location", key, {
               ...store.location[key],
-              shell: Object.fromEntries(
-                response.data.map((info) => [
-                  info.id,
-                  {
-                    ...info,
-                    location: {
-                      directory: response.location.directory,
-                      workspaceID: response.location.workspaceID,
-                    },
-                  },
-                ]),
-              ),
+              shell: Object.fromEntries(response.data.map((info) => [info.id, info])),
             })
           })
         },

packages/tui/src/context/session-tabs.tsx

@@ -3,7 +3,7 @@ import { isDeepEqual } from "remeda"
 import { createSimpleContext } from "./helper"
 import { useClient } from "./client"
 import { useData } from "./data"
-import { withTimestampedFallback } from "@opencode-ai/util/session-title-fallback"
+import { sessionTitle } from "../util/session"
 import { useEvent } from "./event"
 import { useRoute } from "./route"
 import { useConfig } from "../config"
@@ -66,33 +66,18 @@ export const { use: useSessionTabs, provider: SessionTabsProvider } = createSimp
     let closedTabs: ClosedSessionTab[] = []
 
     function state() {
-      if (config.tabs?.scope === "cwd") return store.cwd[paths.cwd] ?? fallback
-      return store.global
+      if (config.tabs?.scope === "global") return store.global
+      return store.cwd[paths.cwd] ?? fallback
     }
 
     function update(mutation: (draft: TabsState) => void) {
-      const scope = config.tabs?.scope ?? "global"
+      const scope = config.tabs?.scope ?? "cwd"
       void updateStore((draft) => mutation(scope === "cwd" ? (draft.cwd[paths.cwd] ??= empty()) : draft.global)).catch(
         () => {},
       )
     }
 
     const root = (sessionID: string) => data.session.root(sessionID)
-    const title = (sessionID: string, persisted?: string, fallback?: string) => {
-      const session = data.session.get(sessionID)
-      return session?.title ?? persisted ?? fallback ?? (session ? withTimestampedFallback(session) : undefined)
-    }
-    const normalize = (value: TabsState) => ({
-      tabs: value.tabs.reduce<SessionTab[]>((tabs, tab) => {
-        const sessionID = root(tab.sessionID)
-        return openSessionTab(tabs, { sessionID, title: title(sessionID, tab.title) })
-      }, []),
-      unread: Object.entries(value.unread).reduce<Record<string, SessionTabUnread>>((result, entry) => {
-        const sessionID = root(entry[0])
-        result[sessionID] = result[sessionID] === "error" ? "error" : entry[1]
-        return result
-      }, {}),
-    })
     const current = () => (route.data.type === "session" ? root(route.data.sessionID) : undefined)
     const newTab = createMemo((open = false) => {
       if (route.data.type === "home") return true
@@ -130,29 +115,32 @@ export const { use: useSessionTabs, provider: SessionTabsProvider } = createSimp
       if (route.data.type !== "session" || route.data.sessionID === "dummy") return
       const sessionID = root(route.data.sessionID)
       history = recordSessionTabHistory(history, sessionID)
-      const fallback = newTab() ? NEW_SESSION_TAB_TITLE : undefined
-      const tabs = openSessionTab(state().tabs, {
-        sessionID,
-        title: title(sessionID, state().tabs.find((tab) => tab.sessionID === sessionID)?.title, fallback),
-      })
+      const session = data.session.get(sessionID)
+      const title = session?.title ?? (newTab() ? NEW_SESSION_TAB_TITLE : session ? sessionTitle(session) : undefined)
+      const tabs = openSessionTab(state().tabs, { sessionID, title })
       if (tabs === state().tabs && !state().unread[sessionID]) return
       update((draft) => {
-        draft.tabs = openSessionTab(draft.tabs, {
-          sessionID,
-          title: title(sessionID, draft.tabs.find((tab) => tab.sessionID === sessionID)?.title, fallback),
-        })
+        draft.tabs = openSessionTab(draft.tabs, { sessionID, title })
         delete draft.unread[sessionID]
       })
     })
 
     createEffect(() => {
       if (!enabled()) return
-      const next = normalize(state())
-      if (isDeepEqual(next, state())) return
+      const next = state().tabs.reduce<SessionTab[]>((tabs, tab) => {
+        const sessionID = root(tab.sessionID)
+        const session = data.session.get(sessionID)
+        return openSessionTab(tabs, { sessionID, title: session ? sessionTitle(session) : tab.title })
+      }, [])
+      const unread = Object.entries(state().unread).reduce<Record<string, SessionTabUnread>>((result, entry) => {
+        const sessionID = root(entry[0])
+        result[sessionID] = result[sessionID] === "error" ? "error" : entry[1]
+        return result
+      }, {})
+      if (isDeepEqual(next, state().tabs) && isDeepEqual(unread, state().unread)) return
       update((draft) => {
-        const next = normalize(draft)
-        draft.tabs = next.tabs
-        draft.unread = next.unread
+        draft.tabs = next
+        draft.unread = unread
       })
     })
 

packages/tui/src/context/storage.tsx

@@ -1,5 +1,5 @@
 import { batch, createContext, onCleanup, useContext, type ParentProps } from "solid-js"
-import { createStore, produce, reconcile, type Store } from "solid-js/store"
+import { createStore, reconcile, type Store } from "solid-js/store"
 import path from "path"
 import { mkdirSync, readFileSync, watch } from "fs"
 import { Flock } from "@opencode-ai/util/flock"
@@ -13,20 +13,12 @@ type Options<Value extends object> = {
 }
 
 type Entry<Value extends object> = readonly [Store<Value>, (mutation: (draft: Value) => void) => Promise<void>]
-type MemoryEntry<Value extends object> = readonly [Store<Value>, (mutation: (draft: Value) => void) => void]
 
 export interface Storage {
   store<Value extends object>(
     key: string,
     options: Options<Value>,
   ): readonly [Store<Value>, (mutation: (draft: Value) => void) => Promise<void>]
-  /**
-   * Ephemeral in-process state. Entries are memoized here, above consumer
-   * lifecycles, so the same live store survives plugin hot reloads; it is
-   * gone when the TUI exits. Updates are synchronous and values need not be
-   * JSON-serializable.
-   */
-  memory<Value extends object>(key: string, options: { readonly initial: Value }): MemoryEntry<Value>
 }
 
 function clone<Value extends object>(value: Value) {
@@ -45,7 +37,6 @@ function segment(value: string) {
 
 function createStorage(root: string, channel: string) {
   const entries = new Map<string, { readonly value: Entry<object>; readonly reload: () => void }>()
-  const memories = new Map<string, MemoryEntry<object>>()
   const directory = path.join(root, segment(channel), "tui")
   const locks = path.join(root, segment(channel), "locks")
   mkdirSync(directory, { recursive: true })
@@ -82,14 +73,6 @@ function createStorage(root: string, channel: string) {
       entries.set(file, { value: entry as Entry<object>, reload })
       return entry
     },
-    memory<Value extends object>(key: string, options: { readonly initial: Value }) {
-      const existing = memories.get(key)
-      if (existing) return existing as MemoryEntry<Value>
-      const [store, setStore] = createStore(options.initial)
-      const entry = [store, (mutation: (draft: Value) => void) => setStore(produce(mutation))] as const
-      memories.set(key, entry as MemoryEntry<object>)
-      return entry
-    },
   }
 
   const watcher = watch(directory, () => entries.forEach((entry) => entry.reload()))

packages/tui/src/feature-plugins/home/footer.tsx

@@ -1,6 +1,23 @@
 import { Plugin } from "@opencode-ai/plugin/tui"
 import { createMemo, Match, Show, Switch } from "solid-js"
 import { useTerminalDimensions } from "@opentui/solid"
+import { stringWidth } from "../../util/string-width"
+import { FadeFilePath } from "../../ui/fade-file-path"
+
+function Directory(props: { context: Plugin.Context; maxWidth: number }) {
+  const directory = createMemo(() =>
+    props.context.location ? props.context.ui.format.path(props.context.location.directory) : undefined,
+  )
+
+  return (
+    <FadeFilePath
+      value={directory()}
+      maxWidth={props.maxWidth}
+      fg={props.context.theme.text.subdued}
+      bg={props.context.theme.background.default}
+    />
+  )
+}
 
 function Mcp(props: { context: Plugin.Context }) {
   const list = createMemo(() => props.context.data.location.mcp.server.list(props.context.location) ?? [])
@@ -36,26 +53,34 @@ function Mcp(props: { context: Plugin.Context }) {
 
 function View(props: { context: Plugin.Context }) {
   const dimensions = useTerminalDimensions()
+  const mcpWidth = createMemo(() => {
+    const list = props.context.data.location.mcp.server.list(props.context.location) ?? []
+    if (list.length === 0) return 0
+    const count = list.filter((item) => item.status.status === "connected").length
+    return stringWidth(`⊙ ${count} MCP /status`) + 2
+  })
 
   return (
-    <Show when={dimensions().height >= 12 && dimensions().width >= 44}>
-      <box
-        width="100%"
-        paddingTop={dimensions().height < 16 ? 0 : 1}
-        paddingBottom={dimensions().height < 16 ? 0 : 1}
-        paddingLeft={2}
-        paddingRight={2}
-        flexDirection="row"
-        flexShrink={0}
-        gap={2}
-      >
-        <Mcp context={props.context} />
-        <box flexGrow={1} />
-        <box flexShrink={0}>
-          <text fg={props.context.theme.text.subdued}>{props.context.app.version}</text>
-        </box>
+    <box
+      width="100%"
+      paddingTop={1}
+      paddingBottom={1}
+      paddingLeft={2}
+      paddingRight={2}
+      flexDirection="row"
+      flexShrink={0}
+      gap={2}
+    >
+      <Directory
+        context={props.context}
+        maxWidth={Math.max(2, dimensions().width - 8 - stringWidth(props.context.app.version) - mcpWidth())}
+      />
+      <Mcp context={props.context} />
+      <box flexGrow={1} />
+      <box flexShrink={0}>
+        <text fg={props.context.theme.text.subdued}>{props.context.app.version}</text>
       </box>
-    </Show>
+    </box>
   )
 }
 

packages/tui/src/feature-plugins/prompt/footer.tsx

@@ -1,7 +1,6 @@
 import { Plugin } from "@opencode-ai/plugin/tui"
 import { createMemo, Match, Show, Switch } from "solid-js"
 import { contextUsage, formatContextUsage } from "../../util/session"
-import { useTerminalDimensions } from "@opentui/solid"
 
 const money = new Intl.NumberFormat("en-US", {
   style: "currency",
@@ -9,7 +8,6 @@ const money = new Intl.NumberFormat("en-US", {
 })
 
 export function PromptFooter(props: { context: Plugin.Context; sessionID?: string; mode: "normal" | "shell" }) {
-  const dimensions = useTerminalDimensions()
   const activeSubagents = createMemo(() => {
     if (!props.sessionID) return 0
     return props.context.data.session
@@ -62,24 +60,19 @@ export function PromptFooter(props: { context: Plugin.Context; sessionID?: strin
               <Show when={status().length > 0}>{status().join(" · ")}</Show>
             </text>
           </Match>
-          <Match when={dimensions().width >= 44}>
+          <Match when={true}>
             <text fg={props.context.theme.text.default} flexShrink={0}>
               {shortcut("agent.cycle")} <span style={{ fg: props.context.theme.text.subdued }}>agents</span>
             </text>
           </Match>
         </Switch>
-        <Show when={dimensions().width >= 44}>
-          <text fg={props.context.theme.text.default} flexShrink={0}>
-            {shortcut("command.palette.show")} <span style={{ fg: props.context.theme.text.subdued }}>commands</span>
-          </text>
-        </Show>
+        <text fg={props.context.theme.text.default} flexShrink={0}>
+          {shortcut("command.palette.show")} <span style={{ fg: props.context.theme.text.subdued }}>commands</span>
+        </text>
       </Match>
       <Match when={props.mode === "shell"}>
         <text fg={props.context.theme.text.default} flexShrink={0}>
-          esc{" "}
-          <span style={{ fg: props.context.theme.text.subdued }}>
-            {dimensions().width < 44 ? "shell" : "exit shell mode"}
-          </span>
+          esc <span style={{ fg: props.context.theme.text.subdued }}>exit shell mode</span>
         </text>
       </Match>
     </Switch>

packages/tui/src/feature-plugins/system/diff-viewer.tsx

@@ -2,7 +2,13 @@
 import type { FileDiffInfo } from "@opencode-ai/client"
 import { Plugin } from "@opencode-ai/plugin/tui"
 import type { KeymapCommand, Route } from "@opencode-ai/plugin/tui/context"
-import { TextAttributes, type BorderSides, type BoxRenderable, type ScrollBoxRenderable } from "@opentui/core"
+import {
+  TextAttributes,
+  type BorderSides,
+  type BoxRenderable,
+  type DiffRenderable,
+  type ScrollBoxRenderable,
+} from "@opentui/core"
 import { LANGUAGE_EXTENSIONS } from "../../util/filetype"
 import { useTerminalDimensions } from "@opentui/solid"
 import path from "path"
@@ -13,7 +19,6 @@ import { DialogSelect } from "../../ui/dialog-select"
 import { getScrollAcceleration } from "../../util/scroll"
 import { useConfig } from "../../config"
 import { useThemes } from "../../context/theme"
-import { PatchDiff, type PatchDiffRef } from "../../component/patch-diff"
 import {
   allExpandedFileTreeDirectories,
   buildFileTree,
@@ -149,7 +154,7 @@ function DiffViewer(props: { context: Plugin.Context }) {
   const helpShortcut = shortcut("diff.help")
   let scroll: ScrollBoxRenderable | undefined
   const patchNodeByFileIndex = new Map<number, BoxRenderable>()
-  const patchDiffByFileIndex = new Map<number, PatchDiffRef>()
+  const diffNodeByFileIndex = new Map<number, DiffRenderable>()
   const [selectedHunk, setSelectedHunk] = createSignal<SelectedHunk | undefined>()
   const [pendingPatchScrollFileIndex, setPendingPatchScrollFileIndex] = createSignal<number | undefined>()
   const [patchFillerHeight, setPatchFillerHeight] = createSignal(0)
@@ -265,16 +270,17 @@ function DiffViewer(props: { context: Plugin.Context }) {
     if (!patchScroll) return
     const hunks = visiblePatchFiles()
       .flatMap((entry) => {
-        return (
-          patchDiffByFileIndex
-            .get(entry.fileIndex)
-            ?.hunks()
-            .map((node, hunkIndex) => ({
-              fileIndex: entry.fileIndex,
-              hunkIndex,
-              contentY: patchScroll.scrollTop + node.y - patchScroll.viewport.y - (hunkIndex > 0 ? 1 : 0),
-            })) ?? []
-        )
+        const node = diffNodeByFileIndex.get(entry.fileIndex)
+        if (!node || node.isDestroyed) return []
+        const contentY = patchScroll.scrollTop + node.y - patchScroll.viewport.y
+        return node.diff
+          .split("\n")
+          .flatMap((line, row) => (line.startsWith("@@") ? [row] : []))
+          .map((row, hunkIndex) => ({
+            fileIndex: entry.fileIndex,
+            hunkIndex,
+            contentY: contentY + row,
+          }))
       })
       .sort((left, right) => left.contentY - right.contentY)
     const selected = selectedHunk()
@@ -825,10 +831,9 @@ function DiffViewer(props: { context: Plugin.Context }) {
                             >
                               {(patch) => (
                                 <box border={patchLeftBorder()} borderColor={theme.border.default}>
-                                  <PatchDiff
-                                    ref={(component) => patchDiffByFileIndex.set(entry.fileIndex, component)}
+                                  <diff
+                                    ref={(element: DiffRenderable) => diffNodeByFileIndex.set(entry.fileIndex, element)}
                                     diff={patch()}
-                                    hunkFg={reviewed() ? theme.text.subdued : theme.diff.text.hunkHeader}
                                     view={view()}
                                     filetype={reviewed() ? PLAIN_TEXT_FILETYPE : filetype(entry.file.file)}
                                     syntaxStyle={currentSyntax()}
@@ -842,15 +847,9 @@ function DiffViewer(props: { context: Plugin.Context }) {
                                     removedBg={
                                       reviewed() ? theme.background.surface.overlay : theme.diff.background.removed
                                     }
-                                    contextBg={
-                                      reviewed() ? theme.background.surface.overlay : theme.diff.background.context
-                                    }
                                     addedSignColor={reviewed() ? theme.text.subdued : theme.diff.highlight.added}
                                     removedSignColor={reviewed() ? theme.text.subdued : theme.diff.highlight.removed}
                                     lineNumberFg={theme.diff.lineNumber.text}
-                                    lineNumberBg={
-                                      reviewed() ? theme.background.surface.overlay : theme.diff.background.context
-                                    }
                                     addedLineNumberBg={
                                       reviewed()
                                         ? theme.background.surface.overlay

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

@@ -32,7 +32,6 @@ import { footerWidthPolicy } from "./footer.width"
 import { toolFiletype } from "./tool"
 import { transparent, type RunBlockTheme, type RunFooterTheme } from "./theme"
 import type { MiniPermissionRequest, PermissionReply } from "./types"
-import { PatchDiff } from "../component/patch-diff"
 
 function buttons(
   list: PermissionOption[],
@@ -406,9 +405,8 @@ export function RunPermissionBody(props: {
                       </Show>
                     }
                   >
-                    <PatchDiff
+                    <diff
                       diff={info().diff!}
-                      hunkFg={props.block.diffLineNumber}
                       view="unified"
                       filetype={ft()}
                       syntaxStyle={props.block.syntax}

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

@@ -10,7 +10,7 @@
 // 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 { isFallbackTitle } from "@opencode-ai/util/session-title-fallback"
+import { isDefaultTitle } from "../util/session"
 import { monoSnapshot } from "./mono"
 import { entrySplash, exitSplash, splashMeta } from "./splash"
 import { resolveRunTheme } from "./theme"
@@ -105,7 +105,7 @@ function shutdown(renderer: CliRenderer): void {
 }
 
 function splashInfo(title: string | undefined, history: RunPrompt[]) {
-  if (title && !isFallbackTitle(title)) {
+  if (title && !isDefaultTitle(title)) {
     return {
       title,
       showSession: true,
@@ -176,7 +176,7 @@ export async function createRuntimeLifecycle(input: LifecycleInput): Promise<Lif
   if (mono) renderer.on(CliRenderEvents.EXTERNAL_OUTPUT, monoSnapshot)
   const setTitle = (title?: string) => {
     if (input.host.platform !== "linux") return
-    if (!title || isFallbackTitle(title)) return renderer.setTerminalTitle("OpenCode")
+    if (!title || isDefaultTitle(title)) return renderer.setTerminalTitle("OpenCode")
     renderer.setTerminalTitle(`OC | ${title.length > 40 ? title.slice(0, 37) + "..." : title}`)
   }
   setTitle(input.sessionTitle)

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

@@ -13,7 +13,6 @@ import { entryColor, entryLook, entrySyntax } from "./scrollback.shared"
 import { toolFiletype, toolStructuredFinal } from "./tool"
 import { RUN_THEME_FALLBACK, transparent, type RunTheme } from "./theme"
 import type { EntryLayout, RunEntryBody, ScrollbackOptions, StreamCommit, TurnSummary } from "./types"
-import { PatchDiff } from "../component/patch-diff"
 
 export function entryGroupKey(commit: StreamCommit): string | undefined {
   if (!commit.partID) {
@@ -179,9 +178,8 @@ export function RunEntryContent(props: {
               </text>
               {item.diff.trim() ? (
                 <box width="100%" paddingLeft={1}>
-                  <PatchDiff
+                  <diff
                     diff={item.diff}
-                    hunkFg={theme().block.diffLineNumber}
                     view="unified"
                     filetype={toolFiletype(item.file)}
                     syntaxStyle={syntax()}

packages/tui/src/plugin/api.tsx

@@ -1,274 +0,0 @@
-import { PluginContextProvider } from "@opencode-ai/plugin/tui"
-import type { JSX } from "solid-js"
-import type { Context, Dialog, Page, Slot, SlotMap, Toast } from "@opencode-ai/plugin/tui/context"
-import { useRenderer } from "@opentui/solid"
-import { useClient } from "../context/client"
-import { useData } from "../context/data"
-import { Keymap } from "../context/keymap"
-import { useRoute } from "../context/route"
-import { useTuiApp, useTuiPaths } from "../context/runtime"
-import { useLocation } from "../context/location"
-import { useThemes } from "../context/theme"
-import { DialogAlert } from "../ui/dialog-alert"
-import { DialogConfirm } from "../ui/dialog-confirm"
-import { DialogPrompt } from "../ui/dialog-prompt"
-import { DialogSelect } from "../ui/dialog-select"
-import { useDialog } from "../ui/dialog"
-import { useToast } from "../ui/toast"
-import { useAttention } from "../context/attention"
-import { useStorage } from "../context/storage"
-import { useSessionTabs } from "../context/session-tabs"
-import { abbreviateHome } from "../util/path-format"
-
-export type Dispose = () => Promise<void>
-
-// The provider's registration store, narrowed to what a plugin context needs:
-// route/slot registration lands there, but ordering and lifecycle stay owned
-// by the provider.
-export type Registry = {
-  has(kind: "routes" | "slots", name: string): boolean
-  set(kind: "routes", name: string, page: Page): void
-  set(kind: "slots", name: string, slot: Slot): void
-  remove(kind: "routes" | "slots", name: string): void
-  active(): boolean
-}
-
-// The host services a plugin context adapts. Collected once by the provider
-// (hooks must run during component setup) and shared by every activation.
-export function usePluginHost() {
-  return {
-    renderer: useRenderer(),
-    client: useClient(),
-    data: useData(),
-    route: useRoute(),
-    keymap: Keymap.use(),
-    shortcuts: Keymap.useShortcuts(),
-    keymapState: Keymap.useState(),
-    app: useTuiApp(),
-    paths: useTuiPaths(),
-    location: useLocation(),
-    themes: useThemes(),
-    dialog: useDialog(),
-    toast: useToast(),
-    attention: useAttention(),
-    storage: useStorage(),
-    sessionTabs: useSessionTabs(),
-  }
-}
-
-// Build the API surface handed to one plugin activation: host services
-// adapted to the plugin contract, with everything registered through it
-// unwinding via `owned` when the activation is disposed.
-export function createPluginContext(input: {
-  host: ReturnType<typeof usePluginHost>
-  id: string
-  options: Readonly<Record<string, any>> | undefined
-  owned: Dispose[]
-  registry: Registry
-}): Context {
-  const host = input.host
-  let context: Context
-  // Every dialog and registered render is wrapped so plugin components can
-  // reach their own context through usePlugin().
-  const provide = (render: () => JSX.Element) => (
-    <PluginContextProvider value={context}>{render()}</PluginContextProvider>
-  )
-  const dialogApi = createDialogApi(host.dialog, provide)
-  const toastApi: Toast = {
-    show(options) {
-      host.toast.show({ ...options, variant: options.variant ?? "info" })
-    },
-  }
-  // Unregistering after deactivation is a no-op: deactivate already resets
-  // the registration's routes and slots wholesale.
-  const registration = (kind: "routes" | "slots", name: string) => {
-    let registered = true
-    const unregister = () => {
-      if (!registered) return
-      registered = false
-      if (!input.registry.active()) return
-      input.registry.remove(kind, name)
-    }
-    input.owned.push(async () => unregister())
-    return unregister
-  }
-  context = {
-    options: input.options ?? {},
-    get location() {
-      return host.location.current
-    },
-    app: { version: host.app.version, channel: host.app.channel },
-    renderer: host.renderer,
-    client: host.client.api,
-    data: host.data,
-    attention: host.attention,
-    get theme() {
-      return host.themes.currentTokens()
-    },
-    keymap: {
-      layer: Keymap.createLayer,
-      dispatch: host.keymap.dispatch,
-      shortcuts: host.shortcuts.list,
-      commands: host.keymapState.commands,
-      pending: host.keymapState.pending,
-      active: host.keymapState.active,
-      mode: host.keymap.mode,
-    },
-    storage: {
-      store: (key, options) => host.storage.store(`plugin.${input.id}.${key}`, options),
-      memory: (key, options) => host.storage.memory(`plugin.${input.id}.${key}`, options),
-    },
-    ui: {
-      dialog: dialogApi,
-      toast: toastApi,
-      format: {
-        path: (value) => abbreviateHome(value, host.paths.home),
-      },
-      router: {
-        register(page) {
-          if (input.registry.has("routes", page.name)) throw new Error(`Route already registered: ${page.name}`)
-          input.registry.set("routes", page.name, {
-            ...page,
-            render: (data) => provide(() => page.render(data)),
-          })
-          return registration("routes", page.name)
-        },
-        navigate(destination) {
-          if (destination.type === "plugin") {
-            host.route.navigate({ ...destination, id: "id" in destination ? destination.id : input.id })
-            return
-          }
-          host.route.navigate(destination)
-        },
-        current() {
-          return host.route.data
-        },
-      },
-      tabs: {
-        enabled: host.sessionTabs.enabled,
-        list: () =>
-          host.sessionTabs.tabs().map((tab) => ({
-            ...tab,
-            active: host.sessionTabs.current() === tab.sessionID,
-            ...host.sessionTabs.status(tab.sessionID),
-          })),
-        open(sessionID) {
-          if (!host.sessionTabs.enabled()) return false
-          host.sessionTabs.select(sessionID)
-          return true
-        },
-        focus(sessionID) {
-          if (!host.sessionTabs.enabled()) return false
-          if (!host.sessionTabs.tabs().some((tab) => tab.sessionID === sessionID)) return false
-          host.sessionTabs.select(sessionID)
-          return true
-        },
-        close(sessionID) {
-          if (!host.sessionTabs.enabled()) return false
-          const target = sessionID ?? host.sessionTabs.current()
-          if (!target || !host.sessionTabs.tabs().some((tab) => tab.sessionID === target)) return false
-          host.sessionTabs.close(target)
-          return true
-        },
-      },
-      slot(name, render) {
-        if (input.registry.has("slots", name)) throw new Error(`Slot already registered: ${name}`)
-        // The registration map erases the slot-specific input type.
-        input.registry.set("slots", name, ((slotInput: SlotMap[typeof name]) =>
-          provide(() => render(slotInput))) as Slot)
-        return registration("slots", name)
-      },
-    },
-  }
-  return context
-}
-
-// A dialog promise must settle exactly once even when confirm and close
-// callbacks both fire.
-function settle<T>(resolve: (value: T) => void) {
-  let settled = false
-  return (value: T) => {
-    if (settled) return
-    settled = true
-    resolve(value)
-  }
-}
-
-function createDialogApi(dialog: ReturnType<typeof useDialog>, provide: (render: () => JSX.Element) => JSX.Element) {
-  const api: Dialog = {
-    show(render, onClose) {
-      dialog.replace(() => provide(render), onClose)
-    },
-    set(options) {
-      dialog.setSize(options.size ?? "medium")
-      dialog.setCentered(options.centered ?? false)
-    },
-    clear() {
-      dialog.clear()
-    },
-    alert(options) {
-      return new Promise<void>((resolve) => {
-        const done = settle(resolve)
-        api.show(() => <DialogAlert title={options.title} message={options.message} onConfirm={done} />, done)
-      })
-    },
-    confirm(options) {
-      return new Promise<boolean | undefined>((resolve) => {
-        const done = settle(resolve)
-        api.show(
-          () => (
-            <DialogConfirm
-              title={options.title}
-              message={options.message}
-              label={options.label}
-              onConfirm={() => done(true)}
-              onCancel={() => done(false)}
-            />
-          ),
-          () => done(undefined),
-        )
-      })
-    },
-    prompt(options) {
-      return new Promise<string | undefined>((resolve) => {
-        const done = settle(resolve)
-        api.show(
-          () => (
-            <DialogPrompt
-              title={options.title}
-              description={options.description ? () => <text>{options.description}</text> : undefined}
-              placeholder={options.placeholder}
-              value={options.value}
-              onConfirm={(value) => {
-                done(value)
-                api.clear()
-              }}
-            />
-          ),
-          () => done(undefined),
-        )
-      })
-    },
-    select(options) {
-      return new Promise((resolve) => {
-        const done = settle<(typeof options.options)[number]["value"] | undefined>(resolve)
-        api.show(
-          () => (
-            <DialogSelect
-              title={options.title}
-              placeholder={options.placeholder}
-              options={options.options.map((option) => ({ ...option }))}
-              current={options.current}
-              onSelect={(option) => {
-                done(option.value)
-                api.clear()
-              }}
-            />
-          ),
-          () => done(undefined),
-        )
-      })
-    },
-  }
-  return api
-}

packages/tui/src/plugin/context.tsx

@@ -1,25 +1,51 @@
-import type { Plugin } from "@opencode-ai/plugin/tui"
-import { batch, createContext, createEffect, on, onCleanup, onMount, useContext, type ParentProps } from "solid-js"
+import { PluginContextProvider, type Plugin } from "@opencode-ai/plugin/tui"
+import {
+  batch,
+  createContext,
+  createEffect,
+  createMemo,
+  For,
+  on,
+  onCleanup,
+  onMount,
+  useContext,
+  type JSX,
+  type ParentProps,
+} from "solid-js"
 import path from "path"
 import { stat } from "fs/promises"
 import { fileURLToPath, pathToFileURL } from "url"
-import type { Page, Slot, SlotName } from "@opencode-ai/plugin/tui/context"
+import type { Context, Dialog, Page, Slot, SlotMap, SlotName, Toast } from "@opencode-ai/plugin/tui/context"
 import { createStore, produce, reconcile as reconcileStore } from "solid-js/store"
-import { isDeepEqual } from "remeda"
+import { useRenderer } from "@opentui/solid"
 import "#runtime-plugin-support"
 import { useConfig } from "../config"
-import { useTuiLifecycle } from "../context/runtime"
-import { errorMessage } from "../util/error"
+import { useClient } from "../context/client"
+import { useData } from "../context/data"
+import { Keymap } from "../context/keymap"
+import { useRoute } from "../context/route"
+import { useTuiApp, useTuiLifecycle, useTuiPaths } from "../context/runtime"
+import { useLocation } from "../context/location"
+import { useThemes } from "../context/theme"
+import { DialogAlert } from "../ui/dialog-alert"
+import { DialogConfirm } from "../ui/dialog-confirm"
+import { DialogPrompt } from "../ui/dialog-prompt"
+import { DialogSelect } from "../ui/dialog-select"
+import { useDialog } from "../ui/dialog"
+import { useToast } from "../ui/toast"
+import { useAttention } from "../context/attention"
+import { useStorage } from "../context/storage"
+import { useSessionTabs } from "../context/session-tabs"
+import { abbreviateHome } from "../util/path-format"
 import { builtins } from "./builtins"
-import { createPluginContext, usePluginHost, type Dispose } from "./api"
-import { createSourceWatcher } from "./watch"
-import { discoverTuiPlugins, freshSpecifier, localSource, tuiPluginDirectory } from "./discovery"
+import { discoverTuiPlugins } from "./discovery"
 
 export interface PackageResolver {
   readonly resolve: (spec: string) => Promise<string | undefined>
 }
 
 type State =
+  | { readonly target: string; readonly status: "loading" }
   | { readonly target: string; readonly id: string; readonly status: "active" | "inactive" }
   | { readonly target: string; readonly status: "unsupported" }
   | { readonly target: string; readonly status: "failed"; readonly error: string }
@@ -35,16 +61,15 @@ type Value = {
   readonly list: () => ReadonlyArray<State>
   readonly registered: () => ReadonlyArray<RegisteredPlugin>
   readonly route: (id: string, name: string) => Page["render"] | undefined
-  readonly slot: <Name extends SlotName>(name: Name) => ReadonlyArray<{ readonly id: string; readonly render: Slot<Name> }>
+  readonly slot: <Name extends SlotName>(name: Name) => ReadonlyArray<Slot<Name>>
   readonly activate: (id: string) => Promise<boolean>
   readonly deactivate: (id: string) => Promise<boolean>
 }
 
+type Dispose = () => Promise<void>
 type Registration = {
   plugin: Plugin.Definition
   source: RegisteredPlugin["source"]
-  target?: string
-  version: string
   options?: Readonly<Record<string, any>>
   active: boolean
   routes: Record<string, Page>
@@ -52,15 +77,27 @@ type Registration = {
   cleanups: Dispose[]
 }
 
-// One entry of the desired plugin generation produced by the resolve phase.
-type Desired = Pick<Registration, "plugin" | "source" | "target" | "version" | "options"> & { enabled: boolean }
-
 const PluginContext = createContext<Value>()
 
 export function PluginProvider(props: ParentProps<{ packages: PackageResolver }>) {
-  const host = usePluginHost()
+  const renderer = useRenderer()
+  const client = useClient()
+  const data = useData()
+  const route = useRoute()
   const config = useConfig()
+  const keymap = Keymap.use()
+  const shortcuts = Keymap.useShortcuts()
+  const keymapState = Keymap.useState()
   const lifecycle = useTuiLifecycle()
+  const app = useTuiApp()
+  const paths = useTuiPaths()
+  const location = useLocation()
+  const themes = useThemes()
+  const dialog = useDialog()
+  const toast = useToast()
+  const attention = useAttention()
+  const storage = useStorage()
+  const sessionTabs = useSessionTabs()
   const directory = config.path ? path.dirname(config.path) : process.cwd()
   const [store, setStore] = createStore({
     ready: false,
@@ -78,26 +115,223 @@ export function PluginProvider(props: ParentProps<{ packages: PackageResolver }>
       setStore("registrations", id, "cleanups", [])
     })
     const owned: Dispose[] = []
-    const context = createPluginContext({
-      host,
-      id,
-      options: item.options,
-      owned,
-      registry: {
-        has: (kind, name) => Boolean(store.registrations[id]?.[kind][name]),
-        set: (kind: "routes" | "slots", name: string, value: Page | Slot) =>
-          setStore("registrations", id, kind, name, () => value),
-        remove: (kind, name) =>
-          setStore(
-            "registrations",
-            produce((registrations) => {
-              if (!registrations[id]) return
-              delete registrations[id][kind][name]
-            }),
-          ),
-        active: () => Boolean(store.registrations[id]?.active),
+    let context: Context
+    const dialogApi: Dialog = {
+      show(render, onClose) {
+        dialog.replace(() => <PluginContextProvider value={context}>{render()}</PluginContextProvider>, onClose)
       },
-    })
+      set(options) {
+        dialog.setSize(options.size ?? "medium")
+        dialog.setCentered(options.centered ?? false)
+      },
+      clear() {
+        dialog.clear()
+      },
+      alert(options) {
+        return new Promise<void>((resolve) => {
+          let settled = false
+          const done = () => {
+            if (settled) return
+            settled = true
+            resolve()
+          }
+          dialogApi.show(() => <DialogAlert title={options.title} message={options.message} onConfirm={done} />, done)
+        })
+      },
+      confirm(options) {
+        return new Promise<boolean | undefined>((resolve) => {
+          let settled = false
+          const done = (result: boolean | undefined) => {
+            if (settled) return
+            settled = true
+            resolve(result)
+          }
+          dialogApi.show(
+            () => (
+              <DialogConfirm
+                title={options.title}
+                message={options.message}
+                label={options.label}
+                onConfirm={() => done(true)}
+                onCancel={() => done(false)}
+              />
+            ),
+            () => done(undefined),
+          )
+        })
+      },
+      prompt(options) {
+        return new Promise<string | undefined>((resolve) => {
+          let settled = false
+          const done = (result: string | undefined) => {
+            if (settled) return
+            settled = true
+            resolve(result)
+          }
+          dialogApi.show(
+            () => (
+              <DialogPrompt
+                title={options.title}
+                description={options.description ? () => <text>{options.description}</text> : undefined}
+                placeholder={options.placeholder}
+                value={options.value}
+                onConfirm={(value) => {
+                  done(value)
+                  dialogApi.clear()
+                }}
+              />
+            ),
+            () => done(undefined),
+          )
+        })
+      },
+      select(options) {
+        return new Promise((resolve) => {
+          let settled = false
+          const done = (result: (typeof options.options)[number]["value"] | undefined) => {
+            if (settled) return
+            settled = true
+            resolve(result)
+          }
+          dialogApi.show(
+            () => (
+              <DialogSelect
+                title={options.title}
+                placeholder={options.placeholder}
+                options={options.options.map((option) => ({ ...option }))}
+                current={options.current}
+                onSelect={(option) => {
+                  done(option.value)
+                  dialogApi.clear()
+                }}
+              />
+            ),
+            () => done(undefined),
+          )
+        })
+      },
+    }
+    const toastApi: Toast = {
+      show(options) {
+        toast.show({ ...options, variant: options.variant ?? "info" })
+      },
+    }
+    context = {
+      options: item.options ?? {},
+      get location() {
+        return location.current
+      },
+      app: { version: app.version, channel: app.channel },
+      renderer,
+      client: client.api,
+      data,
+      attention,
+      get theme() {
+        return themes.currentTokens()
+      },
+      keymap: {
+        layer: Keymap.createLayer,
+        dispatch: keymap.dispatch,
+        shortcuts: shortcuts.list,
+        commands: keymapState.commands,
+        pending: keymapState.pending,
+        active: keymapState.active,
+        mode: keymap.mode,
+      },
+      storage: {
+        store: (key, options) => storage.store(`plugin.${item.plugin.id}.${key}`, options),
+      },
+      ui: {
+        dialog: dialogApi,
+        toast: toastApi,
+        format: {
+          path: (value) => abbreviateHome(value, paths.home),
+        },
+        router: {
+          register(page) {
+            if (store.registrations[item.plugin.id]?.routes[page.name])
+              throw new Error(`Route already registered: ${page.name}`)
+            setStore("registrations", item.plugin.id, "routes", page.name, {
+              ...page,
+              render: (input) => <PluginContextProvider value={context}>{page.render(input)}</PluginContextProvider>,
+            })
+            let registered = true
+            const unregister = () => {
+              if (!registered) return
+              registered = false
+              if (!store.registrations[item.plugin.id]?.active) return
+              setStore(
+                "registrations",
+                produce((registrations) => {
+                  if (!registrations[item.plugin.id]) return
+                  delete registrations[item.plugin.id].routes[page.name]
+                }),
+              )
+            }
+            owned.push(async () => unregister())
+            return unregister
+          },
+          navigate(destination) {
+            if (destination.type === "plugin") {
+              route.navigate({ ...destination, id: "id" in destination ? destination.id : item.plugin.id })
+              return
+            }
+            route.navigate(destination)
+          },
+          current() {
+            return route.data
+          },
+        },
+        tabs: {
+          enabled: sessionTabs.enabled,
+          list: () =>
+            sessionTabs.tabs().map((tab) => ({
+              ...tab,
+              active: sessionTabs.current() === tab.sessionID,
+              ...sessionTabs.status(tab.sessionID),
+            })),
+          open(sessionID) {
+            if (!sessionTabs.enabled()) return false
+            sessionTabs.select(sessionID)
+            return true
+          },
+          focus(sessionID) {
+            if (!sessionTabs.enabled()) return false
+            if (!sessionTabs.tabs().some((tab) => tab.sessionID === sessionID)) return false
+            sessionTabs.select(sessionID)
+            return true
+          },
+          close(sessionID) {
+            if (!sessionTabs.enabled()) return false
+            const target = sessionID ?? sessionTabs.current()
+            if (!target || !sessionTabs.tabs().some((tab) => tab.sessionID === target)) return false
+            sessionTabs.close(target)
+            return true
+          },
+        },
+        slot(name, render) {
+          if (store.registrations[item.plugin.id]?.slots[name]) throw new Error(`Slot already registered: ${name}`)
+          setStore("registrations", item.plugin.id, "slots", name, () => (input: SlotMap[typeof name]) => (
+            <PluginContextProvider value={context}>{render(input)}</PluginContextProvider>
+          ))
+          let registered = true
+          const unregister = () => {
+            if (!registered) return
+            registered = false
+            if (!store.registrations[item.plugin.id]?.active) return
+            setStore(
+              "registrations",
+              produce((registrations) => {
+                if (!registrations[item.plugin.id]) return
+                delete registrations[item.plugin.id].slots[name]
+              }),
+            )
+          }
+          owned.push(async () => unregister())
+          return unregister
+        },
+      },
+    }
     const cleanup = await setup(item.plugin, context, owned).catch((error) => {
       setStore("registrations", id, "routes", reconcileStore({}))
       setStore("registrations", id, "slots", reconcileStore({}))
@@ -140,219 +374,94 @@ export function PluginProvider(props: ParentProps<{ packages: PackageResolver }>
     return true
   }
 
-  // Cleanup failures must not stop a swap or teardown, but they should not
-  // vanish either: the old generation may still own listeners or intervals.
-  const deactivateNoisily = (id: string) =>
-    deactivate(id).catch((error) =>
-      host.toast.show({ variant: "error", title: "Plugin", message: `${id}: cleanup failed: ${errorMessage(error)}` }),
+  const reconcile = async (configured = config.data.plugins ?? []) => {
+    await Promise.all(
+      Object.entries(store.registrations)
+        .filter(([, registration]) => registration.active)
+        .map(([id]) => deactivate(id)),
     )
+    const entries = [...(await discoverTuiPlugins(paths.cwd)), ...configured]
+    batch(() => {
+      setStore("registrations", reconcileStore({}))
+      setStore("states", [])
+    })
 
-  // Every lifecycle mutation — reconciles, manual dialog toggles, shutdown —
-  // is serialized through one chain so generations can never interleave.
-  let loading = Promise.resolve()
-  const enqueue = <T,>(task: () => Promise<T>) => {
-    const result = loading.catch(() => undefined).then(task)
-    loading = result.then(
-      () => undefined,
-      () => undefined,
-    )
-    return result
-  }
+    for (const plugin of builtins) {
+      setStore("registrations", plugin.id, {
+        plugin,
+        source: "builtin",
+        active: false,
+        routes: {},
+        slots: {},
+        cleanups: [],
+      })
+      await activate(plugin.id)
+    }
 
-  // Hot-reload local plugin sources: watch the discovery directory and any
-  // local entrypoints (see watch.ts for the mechanics), debounced into a
-  // serialized reconcile so bursts of events rebuild the generation once.
-  let pending: ReturnType<typeof setTimeout> | undefined
-  const watcher = createSourceWatcher(() => {
-    clearTimeout(pending)
-    pending = setTimeout(() => {
-      // Observe failures immediately: a plugin cleanup that throws would
-      // otherwise surface as an unhandled rejection until the next trigger.
-      void enqueue(reconcile).catch(() => undefined)
-    }, 100)
-  })
-  onCleanup(() => {
-    clearTimeout(pending)
-    watcher.dispose()
-  })
-
-  // Rebuild the plugin generation as resolve → compare → swap, mirroring the
-  // core plugin registry: fold the ordered entries into a desired end state
-  // (importing only new or changed sources, before anything running is
-  // touched), no-op when the generation is unchanged, and restart only the
-  // plugins that differ. Membership or order changes rebuild the whole
-  // generation to preserve slot-order semantics.
-  // Package resolution failures would otherwise retry a full npm install on
-  // every watch event; remember them until the configuration changes.
-  const npmFailures = new Map<string, string>()
-  const reconcile = async () => {
-    const entries = [...(await discoverTuiPlugins(host.paths.cwd)), ...(config.data.plugins ?? [])]
-    watcher.add(tuiPluginDirectory(host.paths.cwd))
-
-    // Resolve: fold entries into one desired generation. A source that fails
-    // to import keeps its running previous version and only reports failure.
-    const desired = new Map<string, Desired>()
-    for (const plugin of builtins) desired.set(plugin.id, { plugin, source: "builtin", version: "builtin", enabled: true })
-    const failures: State[] = []
     for (const entry of entries) {
       const target = typeof entry === "string" ? entry : entry.package
       if (target.startsWith("-")) {
-        for (const item of desired.values()) if (matches(target.slice(1), item.plugin.id)) item.enabled = false
+        for (const id of Object.keys(store.registrations).filter((id) => matches(target.slice(1), id)))
+          await deactivate(id)
         continue
       }
 
-      const selected = [...desired.values()].filter((item) => matches(target, item.plugin.id))
+      const selected = Object.keys(store.registrations).filter((id) => matches(target, id))
       if (selected.length || target === "*" || target.endsWith(".*") || target.startsWith("opencode.")) {
-        for (const item of selected) item.enabled = true
+        for (const id of selected) await activate(id)
         continue
       }
 
       const options = typeof entry === "string" ? undefined : entry.options
-      // Watch even when the resolve below fails so fixing a broken plugin reloads it.
-      const local = localSource(target, directory)
-      if (local) watcher.add(fileURLToPath(local))
-      const previous = Object.values(store.registrations).find((registration) => registration.target === target)
-      const memo = local ? undefined : npmFailures.get(target)
-      const resolved = memo
-        ? { status: "failed" as const, error: memo }
-        : await resolvePlugin(target, local, options, previous, props.packages).catch((error) => ({
-            status: "failed" as const,
-            error: errorMessage(error),
-          }))
-      if (resolved.status === "unsupported") {
-        failures.push({ target, status: "unsupported" })
-        continue
-      }
-      if (resolved.status === "failed") {
-        if (!local && !previous) npmFailures.set(target, resolved.error)
-        failures.push({
-          target,
-          status: "failed",
-          error: previous?.active ? `${resolved.error} (previous version still active)` : resolved.error,
-        })
-        if (previous)
-          desired.set(previous.plugin.id, {
-            plugin: previous.plugin,
-            source: previous.source,
-            target,
-            version: previous.version,
-            options: previous.options,
-            enabled: previous.active,
-          })
-        continue
-      }
-      desired.set(resolved.plugin.id, {
-        plugin: resolved.plugin,
-        source: "external",
-        target,
-        version: resolved.version,
-        options,
-        enabled: true,
+      setStore("states", (items) => [...items, { target, status: "loading" }])
+      const plugin = await loadPlugin(target, directory, props.packages).catch((error) => {
+        setStore("states", (items) =>
+          items.map((state) =>
+            state.target === target
+              ? { target, status: "failed", error: error instanceof Error ? error.message : String(error) }
+              : state,
+          ),
+        )
+        return undefined
       })
-    }
-
-    // Compare: unchanged plugins are never touched, and a fully unchanged
-    // generation is a no-op, so spurious watch events cost nothing.
-    const currentIds = Object.keys(store.registrations)
-    const desiredIds = [...desired.keys()]
-    const structural = currentIds.length !== desiredIds.length || currentIds.some((id, index) => desiredIds[index] !== id)
-    if (structural) {
-      await Promise.all(
-        Object.entries(store.registrations)
-          .filter(([, registration]) => registration.active)
-          .map(([id]) => deactivateNoisily(id)),
-      )
-      setStore("registrations", reconcileStore({}))
-    }
-    const changed = structural
-      ? desiredIds
-      : desiredIds.filter((id) => {
-          const registration = store.registrations[id]!
-          const item = desired.get(id)!
-          // enabled derives from config directives alone, so config wins over
-          // manual dialog toggles on every reconcile — the same semantics
-          // config saves had before hot reload existed, just more frequent.
-          return (
-            registration.version !== item.version ||
-            !sameOptions(registration.options, item.options) ||
-            registration.active !== item.enabled
-          )
-        })
-
-    // Swap: cleanup failures surface as a toast, never propagate, so one
-    // broken plugin cannot take the rest of the generation down.
-    const errors = new Map<string, string>()
-    for (const id of changed) {
-      const item = desired.get(id)!
-      const registration = store.registrations[id]
-      const replaced =
-        !registration || registration.version !== item.version || !sameOptions(registration.options, item.options)
-      // Snapshot the running version before it is overwritten: an import
-      // failure keeps last-good in the resolve phase, and a setup failure
-      // must not cost the previous version either.
-      const fallback: Desired | undefined =
-        replaced && registration
-          ? {
-              plugin: registration.plugin,
-              source: registration.source,
-              target: registration.target,
-              version: registration.version,
-              options: registration.options,
-              enabled: registration.active,
-            }
-          : undefined
-      if (replaced) {
-        if (registration) await deactivateNoisily(id)
-        // In-place replacement keeps the registration's key position, which
-        // slot ordering (mode "replace" takes the last one) depends on.
-        setStore("registrations", id, toRegistration(item))
-      }
-      if (!item.enabled) {
-        await deactivateNoisily(id)
+      if (!plugin) {
+        setStore("states", (items) =>
+          items.map((state) =>
+            state.target === target && state.status !== "failed" ? { target, status: "unsupported" } : state,
+          ),
+        )
         continue
       }
-      const error = await activate(id).then(() => undefined, errorMessage)
-      if (!error) continue
-      errors.set(id, error)
-      if (!fallback) continue
-      setStore("registrations", id, toRegistration(fallback))
-      if (!fallback.enabled) continue
-      const restored = await activate(id).then(
-        () => true,
-        () => false,
-      )
-      if (restored) errors.set(id, `${error} (previous version still active)`)
-    }
 
-    const failedTargets = new Set(failures.map((failure) => failure.target))
-    const states: State[] = [
-      ...[...desired.values()].flatMap((item): State[] => {
-        if (item.target === undefined) return []
-        // A failed reload keeps this item running; the failure entry covers it.
-        if (failedTargets.has(item.target)) return []
-        const error = errors.get(item.plugin.id)
-        if (error) return [{ target: item.target, status: "failed", error }]
-        const status = store.registrations[item.plugin.id]?.active ? "active" : "inactive"
-        return [{ target: item.target, id: item.plugin.id, status }]
-      }),
-      ...failures,
-    ]
-    // Surface newly failing plugins; repeated reconciles stay silent.
-    for (const state of states)
-      if (
-        state.status === "failed" &&
-        !store.states.some((prev) => prev.status === "failed" && prev.target === state.target && prev.error === state.error)
+      setStore("registrations", plugin.id, {
+        plugin,
+        source: "external",
+        options,
+        active: false,
+        routes: {},
+        slots: {},
+        cleanups: [],
+      })
+      const error = await activate(plugin.id).then(
+        () => undefined,
+        (error) => (error instanceof Error ? error.message : String(error)),
       )
-        host.toast.show({ variant: "error", title: "Plugin", message: `${state.target}: ${state.error}` })
-    setStore("states", reconcileStore(states))
+      setStore("states", (items) => [
+        ...items.filter((state) => state.target !== target && (!("id" in state) || state.id !== plugin.id)),
+        error
+          ? { target, status: "failed", error }
+          : { target, id: plugin.id, status: "active" },
+      ])
+    }
   }
-  const slotItems = new WeakMap<Slot, { readonly id: string; readonly render: Slot }>()
+  let loading = Promise.resolve()
   createEffect(
     on(
       () => JSON.stringify(config.data.plugins ?? []),
       () => {
-        npmFailures.clear()
-        void enqueue(reconcile).then(
+        const configured = config.data.plugins ?? []
+        loading = loading.catch(() => undefined).then(() => reconcile(configured))
+        void loading.then(
           () => setStore("ready", true),
           () => setStore("ready", true),
         )
@@ -369,7 +478,7 @@ export function PluginProvider(props: ParentProps<{ packages: PackageResolver }>
           Promise.all(
             Object.entries(store.registrations)
               .filter(([, registration]) => registration.active)
-              .map(([id]) => deactivate(id).catch(() => undefined)),
+              .map(([id]) => deactivate(id)),
           ),
         )
         .then(() => setStore("registrations", reconcileStore({})))
@@ -391,22 +500,11 @@ export function PluginProvider(props: ParentProps<{ packages: PackageResolver }>
           Object.entries(store.registrations).map(([id, plugin]) => ({ id, source: plugin.source, active: plugin.active })),
         route: (id, name) => store.registrations[id]?.routes[name]?.render,
         slot: (name) =>
-          Object.entries(store.registrations).flatMap(([id, registration]) => {
-            const render = registration.active ? registration.slots[name] : undefined
-            if (!render) return []
-            // <For> diffs rows by reference; a stable wrapper per render
-            // function keeps untouched plugins' slot rows (and their state)
-            // alive across other plugins' reloads.
-            const cached = slotItems.get(render)
-            if (cached) return [cached]
-            const item = { id, render }
-            slotItems.set(render, item)
-            return [item]
-          }),
-        // Manual dialog toggles join the same chain as reconciles so a
-        // toggle mid-reload cannot mix registrations across generations.
-        activate: (id) => enqueue(() => activate(id)),
-        deactivate: (id) => enqueue(() => deactivate(id)),
+          Object.values(store.registrations).flatMap((registration) =>
+            registration.active && registration.slots[name] ? [registration.slots[name]] : [],
+          ),
+        activate,
+        deactivate,
       }}
     >
       {props.children}
@@ -433,45 +531,17 @@ function matches(selector: string, id: string) {
   return selector === "*" || selector === id || (selector.endsWith(".*") && id.startsWith(selector.slice(0, -1)))
 }
 
-async function resolvePlugin(
-  spec: string,
-  local: URL | undefined,
-  options: Readonly<Record<string, any>> | undefined,
-  previous: Registration | undefined,
-  packages: PackageResolver,
-) {
-  // Package entrypoints never change within a session, so a loaded previous
-  // version needs no re-resolution (which could otherwise hit npm).
-  if (!local && previous && sameOptions(previous.options, options))
-    return { status: "unchanged" as const, plugin: previous.plugin, version: previous.version }
+async function loadPlugin(spec: string, directory: string, packages: PackageResolver) {
+  const local = spec.startsWith("file://")
+    ? new URL(spec)
+    : spec.startsWith("./") || spec.startsWith("../") || path.isAbsolute(spec)
+      ? pathToFileURL(path.resolve(directory, spec))
+      : undefined
   const entrypoint = local ? await resolveLocal(local) : await packages.resolve(spec)
-  if (!entrypoint) return { status: "unsupported" as const }
-  // The cache-busted specifier doubles as the version: unique per entrypoint
-  // and mtime, so equal versions mean an identical module.
-  const version = local ? freshSpecifier(entrypoint, (await stat(new URL(entrypoint))).mtimeMs) : entrypoint
-  if (previous && previous.version === version && sameOptions(previous.options, options))
-    return { status: "unchanged" as const, plugin: previous.plugin, version }
-  const mod: { readonly default?: unknown } = await import(version)
+  if (!entrypoint) return
+  const mod: { readonly default?: unknown } = await import(entrypoint)
   if (!isPlugin(mod.default)) throw new Error(`Invalid V2 TUI plugin module: ${spec}`)
-  return { status: "loaded" as const, plugin: mod.default, version }
-}
-
-function toRegistration(item: Desired): Registration {
-  return {
-    plugin: item.plugin,
-    source: item.source,
-    target: item.target,
-    version: item.version,
-    options: item.options,
-    active: false,
-    routes: {},
-    slots: {},
-    cleanups: [],
-  }
-}
-
-function sameOptions(a: Registration["options"], b: Registration["options"]) {
-  return isDeepEqual(a ?? null, b ?? null)
+  return mod.default
 }
 
 async function resolveLocal(url: URL) {
@@ -506,3 +576,29 @@ export function usePlugin() {
   if (!value) throw new Error("PluginProvider is missing")
   return value
 }
+
+export function PluginRoute(props: { readonly fallback: (id: string, name: string) => JSX.Element }) {
+  const plugins = usePlugin()
+  const route = useRoute()
+  const content = createMemo(() => {
+    if (route.data.type !== "plugin") return
+    const render = plugins.route(route.data.id, route.data.name)
+    if (!render) return props.fallback(route.data.id, route.data.name)
+    return render({ data: route.data.data })
+  })
+  return <>{content()}</>
+}
+
+export function PluginSlot<Name extends SlotName>(props: {
+  readonly name: Name
+  readonly input: SlotMap[Name]
+  readonly mode: "all" | "replace"
+}) {
+  const plugins = usePlugin()
+  const renderers = createMemo(() => {
+    const items = plugins.slot(props.name)
+    if (props.mode === "replace") return items.slice(-1)
+    return items
+  })
+  return <For each={renderers()}>{(render) => render(props.input)}</For>
+}

packages/tui/src/plugin/discovery.ts

@@ -1,15 +1,10 @@
 import { readdir } from "node:fs/promises"
 import path from "node:path"
-import { fileURLToPath, pathToFileURL } from "node:url"
 
 const extensions = new Set([".cjs", ".cts", ".js", ".jsx", ".mjs", ".mts", ".ts", ".tsx"])
 
-export function tuiPluginDirectory(cwd: string) {
-  return path.join(cwd, ".opencode", "plugins", "tui")
-}
-
 export async function discoverTuiPlugins(cwd: string) {
-  const directory = tuiPluginDirectory(cwd)
+  const directory = path.join(cwd, ".opencode", "plugins", "tui")
   const entries = await readdir(directory, { withFileTypes: true }).catch((error: unknown) => {
     if (error && typeof error === "object" && Reflect.get(error, "code") === "ENOENT") return []
     return Promise.reject(error)
@@ -19,19 +14,3 @@ export async function discoverTuiPlugins(cwd: string) {
     .map((entry) => path.join(directory, entry.name))
     .sort()
 }
-
-export function localSource(spec: string, directory: string) {
-  if (spec.startsWith("file://")) return new URL(spec)
-  if (spec.startsWith("./") || spec.startsWith("../") || path.isAbsolute(spec))
-    return pathToFileURL(path.resolve(directory, spec))
-  return undefined
-}
-
-// Key local plugin imports by mtime so edited sources re-import fresh instead
-// of hitting the ESM cache. Bun ignores query params when caching file:// URL
-// imports, so bust with a plain path there; Node keys its cache on the full
-// URL. Mirrors the core plugin supervisor's loader.
-export function freshSpecifier(entrypoint: string, mtime: number) {
-  if (typeof Bun !== "undefined") return `${fileURLToPath(entrypoint).replaceAll("\\", "/")}?mtime=${mtime}`
-  return `${entrypoint}?mtime=${mtime}`
-}