test(tui): await consecutive tab closes

packages/ai/src/cache-policy.ts

@@ -11,7 +11,7 @@
 // Manual `cache: CacheHint` placements on individual parts are preserved and
 // count against the four-breakpoint budget; auto only fills remaining slots.
 import { CacheHint, type CachePolicy, type CachePolicyObject } from "./schema/options.js"
-import { LLMRequest, Message, ToolDefinition, type ContentPart, type ToolEntry } from "./schema/messages.js"
+import { LLMRequest, Message, ToolDefinition, type ContentPart } from "./schema/messages.js"
 
 const AUTO: CachePolicyObject = {
   tools: true,
@@ -50,24 +50,18 @@ interface Budget {
   remaining: number
 }
 
-const markLastTool = (tools: ReadonlyArray<ToolEntry>, hint: CacheHint, budget: Budget): ReadonlyArray<ToolEntry> => {
-  const target = tools.at(-1)
-  if (target === undefined) return tools
-  if (target.type === "namespace") {
-    const nested = markLastTool(target.tools, hint, budget)
-    return nested === target.tools ? tools : [...tools.slice(0, -1), { ...target, tools: nested }]
-  }
-  if (target.cache || budget.remaining === 0) return tools
+const markLastTool = (
+  tools: ReadonlyArray<ToolDefinition>,
+  hint: CacheHint,
+  budget: Budget,
+): ReadonlyArray<ToolDefinition> => {
+  if (tools.length === 0) return tools
+  const last = tools.length - 1
+  if (tools[last]!.cache || budget.remaining === 0) return tools
   budget.remaining -= 1
-  return [...tools.slice(0, -1), new ToolDefinition({ ...target, cache: hint })]
+  return tools.map((tool, i) => (i === last ? new ToolDefinition({ ...tool, cache: hint }) : tool))
 }
 
-const countToolHints = (tools: ReadonlyArray<ToolEntry>): number =>
-  tools.reduce(
-    (count, tool) => count + (tool.type === "tool" ? (tool.cache === undefined ? 0 : 1) : countToolHints(tool.tools)),
-    0,
-  )
-
 const markSystemBoundaries = (system: LLMRequest["system"], hint: CacheHint, budget: Budget): LLMRequest["system"] => {
   if (system.length === 0) return system
   let changed = false
@@ -128,7 +122,7 @@ const markMessages = (
 }
 
 const countHints = (request: LLMRequest) =>
-  countToolHints(request.tools) +
+  request.tools.reduce((count, tool) => count + (tool.cache === undefined ? 0 : 1), 0) +
   request.system.reduce((count, part) => count + (part.cache === undefined ? 0 : 1), 0) +
   request.messages.reduce(
     (count, message) =>

packages/ai/src/llm.ts

@@ -12,10 +12,9 @@ import {
   LanguageModel,
   SystemPart,
   ToolChoice,
-  ToolEntry,
+  ToolDefinition,
   type ContentPart,
   type LanguageModelProviderOptions,
-  type ToolEntryInput,
 } from "./schema/index.js"
 import { make as makeTool, toDefinitions, type ToolSchema } from "./tool.js"
 
@@ -28,7 +27,7 @@ export type RequestInput<SelectedLanguageModel extends LanguageModel = LanguageM
   readonly system?: string | SystemPart | ReadonlyArray<SystemPart>
   readonly prompt?: string | ContentPart | ReadonlyArray<ContentPart>
   readonly messages?: ReadonlyArray<Message | Message.Input>
-  readonly tools?: ReadonlyArray<ToolEntryInput>
+  readonly tools?: ReadonlyArray<ToolDefinition.Input>
   readonly toolChoice?: ToolChoice.Input
   readonly generation?: GenerationOptions.Input
   readonly providerOptions?: NoInfer<LanguageModelProviderOptions<SelectedLanguageModel>>
@@ -57,7 +56,7 @@ export const request = <const SelectedLanguageModel extends LanguageModel>(
     ...rest,
     system: SystemPart.content(requestSystem),
     messages: [...(messages?.map(Message.make) ?? []), ...(prompt === undefined ? [] : [Message.user(prompt)])],
-    tools: tools?.map(ToolEntry.make) ?? [],
+    tools: tools?.map(ToolDefinition.make) ?? [],
     toolChoice: requestToolChoice ? ToolChoice.make(requestToolChoice) : undefined,
     generation: requestGeneration === undefined ? undefined : GenerationOptions.make(requestGeneration),
     providerOptions: requestProviderOptions,

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

@@ -1067,11 +1067,10 @@ const fromRequest = Effect.fn("AnthropicMessages.fromRequest")(function* (reques
   // messages. Tools live highest in the cache hierarchy, so when callers
   // over-mark we keep their tool hints and shed the message-tail ones first.
   const breakpoints = Cache.newBreakpoints(ANTHROPIC_BREAKPOINT_CAP)
-  const flattened = ProviderShared.flattenToolRequest(request)
   const tools =
-    flattened.tools.length === 0
+    request.tools.length === 0
       ? undefined
-      : flattened.tools.map((tool) =>
+      : request.tools.map((tool) =>
           lowerTool(
             breakpoints,
             tool,
@@ -1089,7 +1088,7 @@ const fromRequest = Effect.fn("AnthropicMessages.fromRequest")(function* (reques
           text: part.text,
           cache_control: cacheControl(breakpoints, part.cache),
         }))
-  const messages = yield* lowerMessages(flattened.request, breakpoints)
+  const messages = yield* lowerMessages(request, breakpoints)
   if (breakpoints.dropped > 0) {
     yield* Effect.logWarning(
       `Anthropic Messages: dropped ${breakpoints.dropped} cache breakpoint(s); the API allows at most ${ANTHROPIC_BREAKPOINT_CAP} per request.`,

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

@@ -427,22 +427,21 @@ const lowerSystem = (
 
 const fromRequest = Effect.fn("BedrockConverse.fromRequest")(function* (request: LLMRequest) {
   const toolChoice = request.toolChoice ? yield* lowerToolChoice(request.toolChoice) : undefined
-  const flattened = ProviderShared.flattenToolRequest(request)
   const generation = request.generation
   // Bedrock-Claude shares Anthropic's 4-breakpoint cap. Spend the budget in
   // tools → system → messages order to favour the highest-impact prefixes.
   const breakpoints = BedrockCache.breakpoints()
   const toolConfig = (() => {
-    if (flattened.tools.length === 0) return undefined
+    if (request.tools.length === 0) return undefined
     return {
-      tools: lowerTools(request.model.compatibility?.toolSchema, breakpoints, flattened.tools),
+      tools: lowerTools(request.model.compatibility?.toolSchema, breakpoints, request.tools),
       // Converse has no native "none". Keep definitions stable for prompt
       // caching and omit only the unsupported choice.
       toolChoice,
     }
   })()
   const system = lowerSystem(breakpoints, request.system)
-  const messages = yield* lowerMessages(flattened.request, breakpoints)
+  const messages = yield* lowerMessages(request, breakpoints)
   if (breakpoints.dropped > 0) {
     yield* Effect.logWarning(
       `Bedrock Converse: dropped ${breakpoints.dropped} cache breakpoint(s); the API allows at most ${BedrockCache.BEDROCK_BREAKPOINT_CAP} per request.`,
@@ -509,6 +508,7 @@ const mapUsage = (usage: BedrockUsageSchema | undefined, providerMetadataKey: st
 interface ParserState {
   readonly providerMetadataKey: string
   readonly tools: ToolStream.State<number>
+  readonly finishedTools: ReadonlySet<number>
   // Bedrock splits the finish into `messageStop` (carries `stopReason`) and
   // `metadata` (carries usage). Hold both in state so `onHalt` can emit exactly
   // one finish after both chunks have had a chance to arrive.
@@ -620,14 +620,16 @@ const step = (state: ParserState, event: BedrockEvent) =>
     }
 
     if (event.contentBlockDelta?.delta?.toolUse) {
-      // A delta for a block that is not open, whether it already stopped or never
-      // started, has nothing to attach to and is dropped.
-      const result = ToolStream.append(
+      const index = event.contentBlockDelta.contentBlockIndex
+      if (state.finishedTools.has(index)) return [state, []] as const
+      const result = ToolStream.appendExisting(
+        ADAPTER,
         state.tools,
-        event.contentBlockDelta.contentBlockIndex,
+        index,
         event.contentBlockDelta.delta.toolUse.input,
+        "Bedrock Converse tool delta is missing its tool call",
       )
-      if (!result) return [state, []] as const
+      if (ToolStream.isError(result)) return yield* result
       const events: LLMEvent[] = []
       const lifecycle = result.events.length ? Lifecycle.stepStart(state.lifecycle, events) : state.lifecycle
       events.push(...result.events)
@@ -666,6 +668,7 @@ const step = (state: ParserState, event: BedrockEvent) =>
             state.hasToolCalls,
           lifecycle,
           tools: result.tools,
+          finishedTools: resultEvents.length > 0 ? new Set([...state.finishedTools, index]) : state.finishedTools,
           reasoningSignatures: Object.fromEntries(
             Object.entries(state.reasoningSignatures).filter(([key]) => key !== String(index)),
           ),
@@ -762,6 +765,7 @@ export const protocol = Protocol.make({
     initial: (request) => ({
       providerMetadataKey: request.model.route.providerMetadataKey ?? String(request.model.provider),
       tools: ToolStream.empty<number>(),
+      finishedTools: new Set<number>(),
       finishReason: undefined,
       usage: undefined,
       hasToolCalls: false,

packages/ai/src/protocols/gemini.ts

@@ -465,8 +465,7 @@ function mapSafetySettings(value: unknown) {
 }
 
 const fromRequest = Effect.fn("Gemini.fromRequest")(function* (request: LLMRequest) {
-  const flattened = ProviderShared.flattenToolRequest(request)
-  const hasTools = flattened.tools.length > 0
+  const hasTools = request.tools.length > 0
   const generation = request.generation
   const options = resolveOptions(request)
   const toolSchemaCompatibility = request.model.compatibility?.toolSchema
@@ -484,7 +483,7 @@ const fromRequest = Effect.fn("Gemini.fromRequest")(function* (request: LLMReque
 
   return {
     cachedContent: options.cachedContent,
-    contents: yield* lowerMessages(flattened.request),
+    contents: yield* lowerMessages(request),
     safetySettings: options.safetySettings,
     serviceTier: options.serviceTier,
     systemInstruction:
@@ -492,7 +491,7 @@ const fromRequest = Effect.fn("Gemini.fromRequest")(function* (request: LLMReque
     tools: hasTools
       ? [
           {
-            functionDeclarations: flattened.tools.map((tool) =>
+            functionDeclarations: request.tools.map((tool) =>
               lowerTool(tool, ToolSchemaProjection.modelCompatibility(tool.inputSchema, toolSchemaCompatibility)),
             ),
           },

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

@@ -414,11 +414,10 @@ export const fromRequest = Effect.fn("MistralChat.fromRequest")(function* (reque
         tool: (name) => ({ type: "function" as const, function: { name } }),
       })
     : undefined
-  const flattened = ProviderShared.flattenToolRequest(request)
   return {
     model: request.model.id,
-    messages: yield* lowerMessages(flattened.request),
-    tools: flattened.tools.length > 0 ? flattened.tools.map(lowerTool) : undefined,
+    messages: yield* lowerMessages(request),
+    tools: request.tools.length > 0 ? request.tools.map(lowerTool) : undefined,
     tool_choice: toolChoice,
     stream: true as const,
     max_tokens: request.generation?.maxTokens,

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

@@ -189,7 +189,6 @@ export const InputItem = Schema.Union([
     id: Schema.optionalKey(Schema.String),
     call_id: Schema.String,
     name: Schema.String,
-    namespace: Schema.optional(Schema.String),
     arguments: Schema.String,
   }),
   Schema.Struct({
@@ -316,7 +315,6 @@ export const StreamItem = Schema.StructWithRest(
     id: Schema.optional(Schema.String),
     call_id: Schema.optional(Schema.String),
     name: Schema.optional(Schema.String),
-    namespace: Schema.optional(Schema.String),
     arguments: Schema.optional(Schema.String),
     encrypted_content: optionalNull(Schema.String),
   }),
@@ -425,16 +423,21 @@ export interface ParserState {
   readonly name: string
   readonly providerMetadataKey: string
   readonly tools: ToolStream.State<string>
+  // Item ids are response-scoped identities. Keep completed ids tombstoned so
+  // reconnect replay cannot reopen fragments already emitted downstream.
+  readonly completedTools: ReadonlySet<string>
   readonly hasFunctionCall: boolean
   readonly lifecycle: Lifecycle.State
   readonly outputItems: Readonly<Record<number, string>>
   readonly message: { readonly id: string; readonly phase: MessagePhase | null | undefined } | undefined
+  readonly completedMessages: ReadonlySet<string>
   readonly reasoningItems: Readonly<Record<string, ReasoningStreamItem>>
 }
 
 type ReasoningSummaryStatus = "active" | "can-conclude" | "concluded"
 
 interface ReasoningStreamItem {
+  readonly open: boolean
   readonly encryptedContent: string | null | undefined
   // Keyed by the wire protocol's numeric `summary_index`. JS object keys coerce to
   // strings, but typing the map as `Record<number, ...>` documents intent
@@ -490,7 +493,6 @@ const lowerToolCall = (part: ToolCallPart, providerMetadataKey: string): OpenRes
     ...(id === undefined ? {} : { id }),
     call_id: part.id,
     name: part.name,
-    namespace: part.namespace,
     arguments: ProviderShared.encodeJson(part.input),
   }
 }
@@ -810,15 +812,14 @@ export const fromRequestWithAdapter = Effect.fn("OpenResponses.fromRequestWithAd
   request: LLMRequest,
   adapter: ProviderAdapter,
 ) {
-  const projected = ProviderShared.flattenToolRequest(request)
   const toolSchemaCompatibility = request.model.compatibility?.toolSchema
   return {
-    ...(yield* lowerConversation(projected.request, adapter)),
+    ...(yield* lowerConversation(request, adapter)),
     ...lowerGeneration(request),
     tools:
-      projected.tools.length === 0
+      request.tools.length === 0
         ? undefined
-        : yield* Effect.forEach(projected.tools, (tool) =>
+        : yield* Effect.forEach(request.tools, (tool) =>
             lowerTool(
               adapter.name,
               tool,
@@ -953,7 +954,7 @@ export const normalize = (state: ParserState, input: Event): NormalizedEvent =>
 
 const startReasoningSummaryPart = (state: ParserState, itemID: string, index: number): StepResult => {
   const item = state.reasoningItems[itemID]
-  if (!item || index === 0 || item.summaryParts[index] !== undefined) return [state, NO_EVENTS]
+  if (!item?.open || index === 0 || item.summaryParts[index] !== undefined) return [state, NO_EVENTS]
 
   const events: LLMEvent[] = []
   const lifecycle = Object.entries(item.summaryParts)
@@ -993,7 +994,7 @@ const startReasoningSummaryPart = (state: ParserState, itemID: string, index: nu
 
 export const onReasoningDelta = (state: ParserState, event: Event, itemID: string): StepResult => {
   const item = state.reasoningItems[itemID]
-  if (!event.delta || !item) return [state, NO_EVENTS]
+  if (!event.delta || !item?.open) return [state, NO_EVENTS]
   const index = event.summary_index ?? 0
   if (item.summaryParts[index] === "concluded") return [state, NO_EVENTS]
   const [started, emitted] = startReasoningSummaryPart(state, itemID, index)
@@ -1018,7 +1019,7 @@ export const onReasoningDelta = (state: ParserState, event: Event, itemID: strin
 // as a single delta unless that summary index already streamed one.
 export const onReasoningDone = (state: ParserState, event: Event, itemID: string): StepResult => {
   const item = state.reasoningItems[itemID]
-  if (!item || typeof event.text !== "string") return [state, NO_EVENTS]
+  if (!item?.open || typeof event.text !== "string") return [state, NO_EVENTS]
   const index = event.summary_index ?? 0
   if (item.deltaIndexes.has(index)) return [state, NO_EVENTS]
   return onReasoningDelta(state, { ...event, delta: event.text }, itemID)
@@ -1041,12 +1042,16 @@ const onOutputItemAdded = (state: ParserState, event: NormalizedEvent): StepResu
   const item = event.item
   if (!item) return [state, NO_EVENTS]
   if (item.type === "message") {
+    if (state.completedMessages.has(item.id)) return [state, NO_EVENTS]
     const phase = messagePhase(item.phase)
+    const completedMessages = new Set(state.completedMessages)
+    if (state.message !== undefined && state.message.id !== item.id) completedMessages.add(state.message.id)
     // A new message closes earlier messages, including ones that never streamed.
     const events: LLMEvent[] = []
     const lifecycle = [...state.lifecycle.text]
       .filter((id) => id !== item.id)
       .reduce((lifecycle, id) => {
+        completedMessages.add(id)
         const openPhase = state.message?.id === id ? state.message.phase : undefined
         return Lifecycle.textEnd(
           lifecycle,
@@ -1059,6 +1064,7 @@ const onOutputItemAdded = (state: ParserState, event: NormalizedEvent): StepResu
       {
         ...state,
         lifecycle,
+        completedMessages,
         message: {
           id: item.id,
           phase: phase === undefined && state.message?.id === item.id ? state.message.phase : phase,
@@ -1077,6 +1083,7 @@ const onOutputItemAdded = (state: ParserState, event: NormalizedEvent): StepResu
         reasoningItems: {
           ...state.reasoningItems,
           [item.id]: {
+            open: true,
             encryptedContent: item.encrypted_content,
             summaryParts: { 0: "active" },
             deltaIndexes: new Set(),
@@ -1087,7 +1094,7 @@ const onOutputItemAdded = (state: ParserState, event: NormalizedEvent): StepResu
     ]
   }
   if (item.type !== "function_call" || !item.call_id) return [state, NO_EVENTS]
-  if (state.tools[item.id] !== undefined) return [state, NO_EVENTS]
+  if (state.tools[item.id] !== undefined || state.completedTools.has(item.id)) return [state, NO_EVENTS]
   const metadata = providerMetadata(state, { itemId: item.id })
   const events: LLMEvent[] = []
   const lifecycle = Lifecycle.stepStart(state.lifecycle, events)
@@ -1098,20 +1105,11 @@ const onOutputItemAdded = (state: ParserState, event: NormalizedEvent): StepResu
       tools: ToolStream.start(state.tools, item.id, {
         id: item.call_id,
         name: item.name ?? "",
-        namespace: item.namespace,
         input: item.arguments ?? "",
         providerMetadata: metadata,
       }),
     },
-    [
-      ...events,
-      LLMEvent.toolInputStart({
-        id: item.call_id,
-        name: item.name ?? "",
-        namespace: item.namespace,
-        providerMetadata: metadata,
-      }),
-    ],
+    [...events, LLMEvent.toolInputStart({ id: item.call_id, name: item.name ?? "", providerMetadata: metadata })],
   ]
 }
 
@@ -1123,7 +1121,7 @@ const onReasoningSummaryPartAdded = (state: ParserState, event: Event): StepResu
 const onReasoningSummaryPartDone = (state: ParserState, event: Event): StepResult => {
   if (event.item_id === undefined || event.summary_index === undefined) return [state, NO_EVENTS]
   const item = state.reasoningItems[event.item_id]
-  if (!item) return [state, NO_EVENTS]
+  if (!item?.open) return [state, NO_EVENTS]
   if (item.summaryParts[event.summary_index] !== "active") return [state, NO_EVENTS]
   return [
     {
@@ -1200,9 +1198,14 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
   }
 
   if (item.type === "message") {
-    const active = state.message?.id === item.id
+    if (state.completedMessages.has(item.id)) return [state, NO_EVENTS] satisfies StepResult
+    const completedMessages = new Set(state.completedMessages)
+    completedMessages.add(item.id)
+    if (state.message !== undefined && state.message.id !== item.id)
+      return [{ ...state, completedMessages }, NO_EVENTS] satisfies StepResult
+    const message = state.message
     const itemPhase = messagePhase(item.phase)
-    const phase = itemPhase === undefined && active ? state.message?.phase : itemPhase
+    const phase = itemPhase === undefined ? message?.phase : itemPhase
     const parts: ReadonlyArray<unknown> = Array.isArray(item.content) ? item.content : []
     const content: string[] = []
     for (const part of parts) {
@@ -1218,7 +1221,8 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
       {
         ...state,
         lifecycle: Lifecycle.textEnd(lifecycle, events, item.id, metadata, text),
-        message: active ? undefined : state.message,
+        completedMessages,
+        message: undefined,
       },
       events,
     ] satisfies StepResult
@@ -1226,16 +1230,12 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
 
   if (item.type === "function_call") {
     if (!item.call_id || !item.name) return [state, NO_EVENTS] satisfies StepResult
+    if (state.completedTools.has(item.id)) return [state, NO_EVENTS] satisfies StepResult
     const metadata = providerMetadata(state, { itemId: item.id })
     const registered = state.tools[item.id] !== undefined
     const tools = registered
       ? state.tools
-      : ToolStream.start(state.tools, item.id, {
-          id: item.call_id,
-          name: item.name,
-          namespace: item.namespace,
-          providerMetadata: metadata,
-        })
+      : ToolStream.start(state.tools, item.id, { id: item.call_id, name: item.name, providerMetadata: metadata })
     const result =
       item.arguments === undefined
         ? yield* ToolStream.finish(state.id, tools, item.id)
@@ -1246,15 +1246,7 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
     const resultEvents =
       registered || finished.length === 0
         ? finished
-        : [
-            LLMEvent.toolInputStart({
-              id: item.call_id,
-              name: item.name,
-              namespace: item.namespace,
-              providerMetadata: metadata,
-            }),
-            ...finished,
-          ]
+        : [LLMEvent.toolInputStart({ id: item.call_id, name: item.name, providerMetadata: metadata }), ...finished]
     const lifecycle = resultEvents.length ? Lifecycle.stepStart(state.lifecycle, events) : state.lifecycle
     events.push(...resultEvents)
     return [
@@ -1265,12 +1257,14 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
           resultEvents.some((event) => LLMEvent.is.toolCall(event) || LLMEvent.is.toolInputError(event)) ||
           state.hasFunctionCall,
         tools: result.tools,
+        completedTools: new Set([...state.completedTools, item.id]),
       },
       events,
     ] satisfies StepResult
   }
 
   if (item.type === "reasoning") {
+    if (state.reasoningItems[item.id]?.open === false) return [state, NO_EVENTS] satisfies StepResult
     const metadata = reasoningMetadata(state, item)
     const summaryParts: ReadonlyArray<unknown> = Array.isArray(item.summary) ? item.summary : []
     const summary: Array<string | undefined> = []
@@ -1297,14 +1291,53 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
         const finalText = fragments.length === 1 ? itemText : summary[Number(index)]
         lifecycle = Lifecycle.reasoningEnd(lifecycle, events, `${item.id}:${index}`, metadata, finalText || undefined)
       }
-      const reasoningItems = { ...state.reasoningItems }
-      delete reasoningItems[item.id]
-      return [{ ...state, lifecycle, reasoningItems }, events] satisfies StepResult
+      return [
+        {
+          ...state,
+          lifecycle,
+          reasoningItems: {
+            ...state.reasoningItems,
+            [item.id]: {
+              ...reasoningItem,
+              open: false,
+              encryptedContent: item.encrypted_content ?? reasoningItem.encryptedContent,
+            },
+          },
+        },
+        events,
+      ] satisfies StepResult
     }
-    const lifecycle = Lifecycle.stepStart(state.lifecycle, events)
-    events.push(LLMEvent.reasoningStart({ id: item.id, providerMetadata: metadata }))
-    events.push(LLMEvent.reasoningEnd({ id: item.id, providerMetadata: metadata, text: itemText }))
-    return [{ ...state, lifecycle }, events] satisfies StepResult
+    if (!state.lifecycle.reasoning.has(item.id)) {
+      const lifecycle = Lifecycle.stepStart(state.lifecycle, events)
+      events.push(LLMEvent.reasoningStart({ id: item.id, providerMetadata: metadata }))
+      events.push(
+        LLMEvent.reasoningEnd({
+          id: item.id,
+          providerMetadata: metadata,
+          text: itemText,
+        }),
+      )
+      return [
+        {
+          ...state,
+          lifecycle,
+          reasoningItems: {
+            ...state.reasoningItems,
+            [item.id]: {
+              open: false,
+              encryptedContent: item.encrypted_content,
+              summaryParts: { 0: "concluded" },
+              deltaIndexes: new Set(),
+            },
+          },
+        },
+        events,
+      ] satisfies StepResult
+    }
+    return [
+      { ...state, lifecycle: Lifecycle.reasoningEnd(state.lifecycle, events, item.id, metadata) },
+      events,
+    ] satisfies StepResult
   }
 
   return [state, NO_EVENTS] satisfies StepResult
@@ -1485,9 +1518,11 @@ export const initial = (request: LLMRequest, adapter: ProviderAdapter = BASE_ADA
   providerMetadataKey: metadataKey(request.model),
   hasFunctionCall: false,
   tools: ToolStream.empty<string>(),
+  completedTools: new Set<string>(),
   lifecycle: Lifecycle.initial(),
   outputItems: {},
   message: undefined,
+  completedMessages: new Set<string>(),
   reasoningItems: {},
 })
 

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

@@ -736,7 +736,6 @@ export const fromRequest = Effect.fn("OpenAIChat.fromRequest")(function* (
     )
   const generation = request.generation
   const toolSchemaCompatibility = request.model.compatibility?.toolSchema
-  const flattened = ProviderShared.flattenToolRequest(request)
   const provider = String(request.model.provider)
   const baseURL = request.model.route.endpoint.baseURL
   const detectedMaxTokensField = detectMaxTokensField(provider, baseURL)
@@ -749,16 +748,16 @@ export const fromRequest = Effect.fn("OpenAIChat.fromRequest")(function* (
   const zaiToolStream =
     request.model.compatibility?.zaiToolStream ?? detectZaiToolStream(provider, baseURL, request.model.id)
   const hasHistory = hasToolHistory(request.messages)
-  const hasActiveTools = flattened.tools.length > 0
+  const hasActiveTools = request.tools.length > 0
   return {
     model: request.model.id,
-    messages: yield* lowerMessages(flattened.request, options),
+    messages: yield* lowerMessages(request, options),
     tools:
-      flattened.tools.length === 0
+      request.tools.length === 0
         ? hasHistory
           ? []
           : undefined
-        : flattened.tools.map((tool) =>
+        : request.tools.map((tool) =>
             lowerTool(
               tool,
               ToolSchemaProjection.modelCompatibility(tool.inputSchema, toolSchemaCompatibility),

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

@@ -5,7 +5,7 @@ import { Auth } from "../route/auth.js"
 import { Endpoint } from "../route/endpoint.js"
 import { Protocol } from "../route/protocol.js"
 import { HttpTransport } from "../route/transport/index.js"
-import type { LLMRequest, JsonSchema, ToolDefinition, ToolEntry } from "../schema/index.js"
+import type { LLMRequest, JsonSchema, ToolDefinition } from "../schema/index.js"
 import { OpenResponses } from "./open-responses.js"
 import { JsonObject, optionalArray, optionalNull, ProviderShared } from "./shared.js"
 import { OpenAIImage } from "./utils/openai-image.js"
@@ -75,18 +75,7 @@ const OpenAIResponsesHostedToolItem = Schema.Union([
   ),
 ])
 
-const OpenAIResponsesNamespace = Schema.Struct({
-  type: Schema.tag("namespace"),
-  name: Schema.String,
-  description: Schema.String,
-  tools: Schema.Array(OpenResponses.Tool),
-})
-
-const OpenAIResponsesTools = Schema.Union([
-  OpenResponses.Tool,
-  OpenAIResponsesNamespace,
-  OpenAIResponsesImageGenerationTool,
-])
+const OpenAIResponsesTools = Schema.Union([OpenResponses.Tool, OpenAIResponsesImageGenerationTool])
 
 const OpenAIResponsesToolChoice = Schema.Union([
   OpenResponses.ToolChoice,
@@ -139,33 +128,13 @@ const lowerTool = Effect.fn("OpenAIResponses.lowerTool")(function* (tool: ToolDe
   return yield* OpenResponses.lowerTool(NAME, tool, inputSchema)
 })
 
-// Native namespaces hold only function tools, so deeper levels flatten into
-// the leaf names the same way non-native protocols flatten the whole tree.
-const lowerToolEntry = Effect.fn("OpenAIResponses.lowerToolEntry")(function* (
-  tool: ToolEntry,
-  compatibility: Parameters<typeof ToolSchemaProjection.modelCompatibility>[1],
-) {
-  if (tool.type === "tool")
-    return yield* lowerTool(tool, ToolSchemaProjection.modelCompatibility(tool.inputSchema, compatibility))
-  // OpenAI requires a namespace description; fall back to a generic one so a
-  // missing description never blocks the request.
-  return {
-    type: "namespace" as const,
-    name: tool.name,
-    description: tool.description ?? `Tools in the ${tool.name} namespace.`,
-    tools: yield* Effect.forEach(ProviderShared.flattenTools(tool.tools), (leaf) =>
-      OpenResponses.lowerTool(NAME, leaf, ToolSchemaProjection.modelCompatibility(leaf.inputSchema, compatibility)),
-    ),
-  }
-})
-
-const lowerToolChoice = (toolChoice: NonNullable<LLMRequest["toolChoice"]>, tools: ReadonlyArray<ToolEntry>) =>
+const lowerToolChoice = (toolChoice: NonNullable<LLMRequest["toolChoice"]>, tools: ReadonlyArray<ToolDefinition>) =>
   ProviderShared.matchToolChoice(NAME, toolChoice, {
     auto: () => "auto" as const,
     none: () => "none" as const,
     required: () => "required" as const,
     tool: (name) =>
-      tools.some((tool) => tool.type === "tool" && tool.name === name && nativeImageTool(tool) !== undefined)
+      tools.some((tool) => tool.name === name && nativeImageTool(tool) !== undefined)
         ? ({ type: "image_generation" } as const)
         : { type: "function" as const, name },
   })
@@ -184,7 +153,9 @@ const fromRequest = Effect.fn("OpenAIResponses.fromRequest")(function* (request:
     tools:
       request.tools.length === 0
         ? undefined
-        : yield* Effect.forEach(request.tools, (tool) => lowerToolEntry(tool, toolSchemaCompatibility)),
+        : yield* Effect.forEach(request.tools, (tool) =>
+            lowerTool(tool, ToolSchemaProjection.modelCompatibility(tool.inputSchema, toolSchemaCompatibility)),
+          ),
     tool_choice:
       OpenResponses.allowedToolChoice(request) ??
       (request.toolChoice ? yield* lowerToolChoice(request.toolChoice, request.tools) : undefined),

packages/ai/src/protocols/shared.ts

@@ -6,17 +6,12 @@ import { Headers, HttpClientRequest, HttpClientResponse } from "effect/unstable/
 import {
   InvalidProviderOutputError,
   InvalidRequestError,
-  UnsupportedOperationError,
   AIError,
   HttpContext,
-  LLMRequest,
-  Message,
-  ToolDefinition,
   type ContentPart,
+  type LLMRequest,
   type MediaPart,
-  type ProviderID,
   type TextPart,
-  type ToolEntry,
   type ToolResultPart,
 } from "../schema/index.js"
 import { isRecord } from "../utils/record.js"
@@ -49,7 +44,6 @@ export const promptCacheKey = (request: LLMRequest): string | undefined => {
 export interface ToolAccumulator {
   readonly id: string
   readonly name: string
-  readonly namespace?: string
   readonly input: string
 }
 
@@ -260,61 +254,6 @@ export const invalidRequest = (message: string, cause?: unknown) =>
     reason: new InvalidRequestError({ message, cause }),
   })
 
-/**
- * Canonical constructor for operations the selected route does not implement.
- * Prefer this over `invalidRequest` when the failure is a missing route
- * capability rather than a malformed caller input, so consumers can branch on
- * `reason._tag` plus `reason.operation` instead of matching message text.
- */
-export const unsupportedOperation = (input: {
-  readonly operation: string
-  readonly message: string
-  readonly provider?: ProviderID
-  readonly route?: string
-  readonly cause?: unknown
-}) =>
-  new AIError({
-    reason: new UnsupportedOperationError({
-      operation: input.operation,
-      message: input.message,
-      provider: input.provider,
-      route: input.route,
-      cause: input.cause,
-    }),
-  })
-
-/**
- * Lower namespaces to flat definitions for protocols without a native
- * namespace construct. Leaf names join their namespace path with `_` because
- * `.` is not broadly accepted in provider tool names.
- */
-export const flattenTools = (tools: ReadonlyArray<ToolEntry>, path: ReadonlyArray<string> = []) => {
-  const flat = tools.flatMap((tool): ReadonlyArray<ToolDefinition> => {
-    if (tool.type === "namespace") return flattenTools(tool.tools, [...path, tool.name])
-    if (path.length === 0) return [tool]
-    return [new ToolDefinition({ ...tool, name: [...path, tool.name].join("_") })]
-  })
-  return [...new Map(flat.map((tool) => [tool.name, tool])).values()]
-}
-
-export const flattenToolRequest = (request: LLMRequest) => {
-  const messages = request.messages.map((message) => {
-    const content = message.content.map((part) => {
-      if ((part.type !== "tool-call" && part.type !== "tool-result") || part.namespace === undefined) return part
-      return { ...part, name: `${part.namespace}_${part.name}`, namespace: undefined }
-    })
-    return content.every((part, index) => part === message.content[index])
-      ? message
-      : new Message({ ...message, content })
-  })
-  return {
-    tools: flattenTools(request.tools),
-    request: messages.every((message, index) => message === request.messages[index])
-      ? request
-      : LLMRequest.update(request, { messages }),
-  }
-}
-
 export const imageResponse = Effect.fn("ProviderShared.imageResponse")(function* (
   route: string,
   name: string,

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

@@ -55,7 +55,6 @@ const inputStart = (tool: PendingTool) =>
   LLMEvent.toolInputStart({
     id: tool.id,
     name: tool.name,
-    namespace: tool.namespace,
     providerExecuted: tool.providerExecuted ? true : undefined,
     providerMetadata: tool.providerMetadata,
   })
@@ -64,7 +63,6 @@ const inputDelta = (tool: PendingTool, text: string) =>
   LLMEvent.toolInputDelta({
     id: tool.id,
     name: tool.name,
-    namespace: tool.namespace,
     text,
     input: Option.getOrElse(parsePartialInput(tool.input), () => ({})),
   })
@@ -87,7 +85,6 @@ const toolCall = (route: string, tool: PendingTool, inputOverride?: string) => {
         LLMEvent.toolCall({
           id: tool.id,
           name: tool.name,
-          namespace: tool.namespace,
           input,
           providerExecuted: tool.providerExecuted ? true : undefined,
           providerMetadata: tool.providerMetadata,
@@ -97,12 +94,7 @@ const toolCall = (route: string, tool: PendingTool, inputOverride?: string) => {
 }
 
 const finishEvents = (tool: PendingTool, event: ToolCall): ReadonlyArray<LLMEvent> => [
-  LLMEvent.toolInputEnd({
-    id: tool.id,
-    name: tool.name,
-    namespace: tool.namespace,
-    providerMetadata: tool.providerMetadata,
-  }),
+  LLMEvent.toolInputEnd({ id: tool.id, name: tool.name, providerMetadata: tool.providerMetadata }),
   event,
 ]
 
@@ -158,7 +150,6 @@ export const appendOrStart = <K extends StreamKey>(
   const tool = {
     id,
     name,
-    namespace: current?.namespace,
     input: `${current?.input ?? ""}${delta.text}`,
     providerExecuted: current?.providerExecuted,
     providerMetadata: current?.providerMetadata,
@@ -168,17 +159,6 @@ export const appendOrStart = <K extends StreamKey>(
   return appendTool(tools, key, tool, delta.text)
 }
 
-/**
- * Append argument text to a started tool. Returns `undefined` when no tool is
- * open under `key`, for protocols that ignore deltas without a matching block.
- */
-export const append = <K extends StreamKey>(tools: State<K>, key: K, text: string): AppendOutcome<K> | undefined => {
-  const current = tools[key]
-  if (!current) return undefined
-  if (text.length === 0) return { tools, tool: current, events: [] }
-  return appendTool(tools, key, { ...current, input: `${current.input}${text}` }, text)
-}
-
 /**
  * Append argument text to a tool that must already have been started. This keeps
  * protocols honest when their stream grammar promises a start event before any
@@ -190,7 +170,12 @@ export const appendExisting = <K extends StreamKey>(
   key: K,
   text: string,
   missingToolMessage: string,
-): AppendOutcome<K> | AIError => append(tools, key, text) ?? eventError(route, missingToolMessage)
+): AppendOutcome<K> | AIError => {
+  const current = tools[key]
+  if (!current) return eventError(route, missingToolMessage)
+  if (text.length === 0) return { tools, tool: current, events: [] }
+  return appendTool(tools, key, { ...current, input: `${current.input}${text}` }, text)
+}
 
 /**
  * Finalize one pending tool call: parse the accumulated raw JSON, remove it

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

@@ -46,12 +46,9 @@ const adapter = {
 const decodeBody = ProviderShared.validateWith(Schema.decodeUnknownEffect(XAIResponsesBody))
 const fromRequest = Effect.fn("XAIResponses.fromRequest")(function* (request: LLMRequest) {
   if (request.providerOptions?.contextManagement !== undefined)
-    return yield* ProviderShared.unsupportedOperation({
-      operation: "in-band-compaction",
-      provider: request.model.provider,
-      route: request.model.route.id,
-      message: "xAI requires explicit compaction through LLMClient.compact; automatic context management is not supported",
-    })
+    return yield* ProviderShared.invalidRequest(
+      "xAI requires explicit compaction through LLMClient.compact; automatic context management is not supported",
+    )
   return yield* decodeBody(yield* OpenResponses.fromRequestWithAdapter(request, adapter))
 })
 

packages/ai/src/route/client.ts

@@ -487,14 +487,10 @@ export function make<Body, Prepared, Frame, Event, State>(
 }
 
 const prepareRequest = (request: LLMRequest) => {
-  const original = resolveRequestOptions(request)
+  const original = applyCachePolicy(resolveRequestOptions(request))
   const sanitized = LLMRequest.update(original, sanitizeSurrogates({ ...LLMRequest.input(original), model: undefined }))
-  // Deduplicate per sibling level; a tool and a namespace may share a name.
-  const dedupe = (tools: LLMRequest["tools"]): LLMRequest["tools"] =>
-    [...new Map(tools.map((tool) => [`${tool.type}:${tool.name}`, tool])).values()].map((tool) =>
-      tool.type === "tool" ? tool : { ...tool, tools: dedupe(tool.tools) },
-    )
-  const resolved = applyCachePolicy(LLMRequest.update(sanitized, { tools: dedupe(sanitized.tools) }))
+  const tools = [...new Map(sanitized.tools.map((tool) => [tool.name, tool])).values()]
+  const resolved = tools.length === sanitized.tools.length ? sanitized : LLMRequest.update(sanitized, { tools })
   const headers = resolved.model.route.headers?.({ request: resolved })
   return headers === undefined
     ? resolved
@@ -589,12 +585,9 @@ export const layer: Layer.Layer<Service, never, RequestExecutor.Service> = Layer
         Effect.suspend(() => {
           const operation = request.model.route.compact
           if (!operation)
-            return ProviderShared.unsupportedOperation({
-              operation: "compact",
-              provider: request.model.provider,
-              route: request.model.route.id,
-              message: `${request.model.provider}/${request.model.route.id} does not support explicit compaction`,
-            })
+            return ProviderShared.invalidRequest(
+              `${request.model.provider}/${request.model.route.id} does not support explicit compaction`,
+            )
           return operation(prepareRequest(request), executor, options)
         }),
     })

packages/ai/src/schema/errors.ts

@@ -35,21 +35,6 @@ export class InvalidRequestError extends Schema.TaggedError<InvalidRequestError>
   },
 ) {}
 
-/**
- * A caller-requested operation the selected route does not implement, such as
- * explicit compaction on a route without a compact endpoint. Detected locally
- * before any network I/O, so unlike transport or provider-output failures it
- * never carries HTTP context from a provider round-trip.
- */
-export class UnsupportedOperationError extends Schema.TaggedError<UnsupportedOperationError>(
-  "AI.Error.UnsupportedOperation",
-)("UnsupportedOperation", {
-  ...ReasonFields,
-  operation: Schema.String,
-  provider: Schema.optional(ProviderID),
-  route: Schema.optional(RouteID),
-}) {}
-
 export class NoRouteError extends Schema.TaggedError<NoRouteError>("AI.Error.NoRoute")("NoRoute", {
   ...ReasonFields,
   route: RouteID,
@@ -122,7 +107,6 @@ export class UnknownProviderError extends Schema.TaggedError<UnknownProviderErro
 
 export const AIErrorReason = Schema.Union([
   InvalidRequestError,
-  UnsupportedOperationError,
   NoRouteError,
   AuthenticationError,
   RateLimitError,

packages/ai/src/schema/events.ts

@@ -155,7 +155,6 @@ export const ToolInputStart = Schema.Struct({
   type: Schema.tag("tool-input-start"),
   id: ToolCallID,
   name: Schema.String,
-  namespace: Schema.optional(Schema.String),
   providerExecuted: Schema.optional(Schema.Boolean),
   providerMetadata: Schema.optional(ProviderMetadata),
 }).annotate({ identifier: "LLM.Event.ToolInputStart" })
@@ -165,7 +164,6 @@ export const ToolInputDelta = Schema.Struct({
   type: Schema.tag("tool-input-delta"),
   id: ToolCallID,
   name: Schema.String,
-  namespace: Schema.optional(Schema.String),
   text: Schema.String,
   /** Best-effort parse of all input fragments received through this delta. */
   input: Schema.optional(Schema.Unknown),
@@ -176,7 +174,6 @@ export const ToolInputEnd = Schema.Struct({
   type: Schema.tag("tool-input-end"),
   id: ToolCallID,
   name: Schema.String,
-  namespace: Schema.optional(Schema.String),
   providerMetadata: Schema.optional(ProviderMetadata),
 }).annotate({ identifier: "LLM.Event.ToolInputEnd" })
 export type ToolInputEnd = Schema.Schema.Type<typeof ToolInputEnd>
@@ -186,7 +183,6 @@ export const ToolInputError = Schema.Struct({
   type: Schema.tag("tool-input-error"),
   id: ToolCallID,
   name: Schema.String,
-  namespace: Schema.optional(Schema.String),
   raw: Schema.String,
 }).annotate({ identifier: "LLM.Event.ToolInputError" })
 export type ToolInputError = Schema.Schema.Type<typeof ToolInputError>
@@ -195,7 +191,6 @@ export const ToolCall = Schema.Struct({
   type: Schema.tag("tool-call"),
   id: ToolCallID,
   name: Schema.String,
-  namespace: Schema.optional(Schema.String),
   input: Schema.Unknown,
   providerExecuted: Schema.optional(Schema.Boolean),
   providerMetadata: Schema.optional(ProviderMetadata),
@@ -206,7 +201,6 @@ export const ToolResult = Schema.Struct({
   type: Schema.tag("tool-result"),
   id: ToolCallID,
   name: Schema.String,
-  namespace: Schema.optional(Schema.String),
   result: ToolResultValue,
   output: Schema.optional(ToolOutput),
   providerExecuted: Schema.optional(Schema.Boolean),
@@ -218,7 +212,6 @@ export const ToolError = Schema.Struct({
   type: Schema.tag("tool-error"),
   id: ToolCallID,
   name: Schema.String,
-  namespace: Schema.optional(Schema.String),
   message: Schema.String,
   error: Schema.optional(Schema.Defect()),
   providerMetadata: Schema.optional(ProviderMetadata),
@@ -392,7 +385,6 @@ interface ContentAssembly {
 
 interface ToolInputAssembly {
   readonly name: string
-  readonly namespace?: string
   readonly text: string
   readonly providerMetadata?: ProviderMetadata
 }
@@ -530,17 +522,12 @@ const reduceToolInputStart = (state: ResponseState, event: ToolInputStart): Resp
   ...state,
   toolInputs: {
     ...state.toolInputs,
-    [event.id]: {
-      name: event.name,
-      namespace: event.namespace,
-      text: "",
-      providerMetadata: event.providerMetadata,
-    },
+    [event.id]: { name: event.name, text: "", providerMetadata: event.providerMetadata },
   },
 })
 
 const reduceToolInputDelta = (state: ResponseState, event: ToolInputDelta): ResponseState => {
-  const current = state.toolInputs[event.id] ?? { name: event.name, namespace: event.namespace, text: "" }
+  const current = state.toolInputs[event.id] ?? { name: event.name, text: "" }
   return {
     ...state,
     toolInputs: { ...state.toolInputs, [event.id]: { ...current, text: current.text + event.text } },
@@ -548,7 +535,7 @@ const reduceToolInputDelta = (state: ResponseState, event: ToolInputDelta): Resp
 }
 
 const reduceToolInputEnd = (state: ResponseState, event: ToolInputEnd): ResponseState => {
-  const current = state.toolInputs[event.id] ?? { name: event.name, namespace: event.namespace, text: "" }
+  const current = state.toolInputs[event.id] ?? { name: event.name, text: "" }
   return {
     ...state,
     toolInputs: {
@@ -556,7 +543,6 @@ const reduceToolInputEnd = (state: ResponseState, event: ToolInputEnd): Response
       [event.id]: {
         ...current,
         name: event.name,
-        namespace: event.namespace,
         providerMetadata: event.providerMetadata ?? current.providerMetadata,
       },
     },
@@ -567,7 +553,6 @@ const toolCallContent = (event: ToolCall): ContentPart =>
   ToolCallPart.make({
     id: event.id,
     name: event.name,
-    namespace: event.namespace,
     input: event.input,
     ...(event.providerExecuted === undefined ? {} : { providerExecuted: event.providerExecuted }),
     ...(event.providerMetadata === undefined ? {} : { providerMetadata: event.providerMetadata }),
@@ -577,7 +562,6 @@ const toolResultContent = (event: ToolResult): ContentPart =>
   ToolResultPart.make({
     id: event.id,
     name: event.name,
-    namespace: event.namespace,
     result: event.result,
     ...(event.providerExecuted === undefined ? {} : { providerExecuted: event.providerExecuted }),
     ...(event.providerMetadata === undefined ? {} : { providerMetadata: event.providerMetadata }),

packages/ai/src/schema/messages.ts

@@ -135,7 +135,6 @@ export const ToolCallPart = Object.assign(
     type: Schema.Literal("tool-call"),
     id: Schema.String,
     name: Schema.String,
-    namespace: Schema.optional(Schema.String),
     input: Schema.Unknown,
     providerExecuted: Schema.optional(Schema.Boolean),
     cache: Schema.optional(CacheHint),
@@ -153,7 +152,6 @@ export const ToolResultPart = Object.assign(
     type: Schema.Literal("tool-result"),
     id: Schema.String,
     name: Schema.String,
-    namespace: Schema.optional(Schema.String),
     result: ToolResultValue,
     providerExecuted: Schema.optional(Schema.Boolean),
     cache: Schema.optional(CacheHint),
@@ -170,7 +168,6 @@ export const ToolResultPart = Object.assign(
       type: "tool-result",
       id: input.id,
       name: input.name,
-      namespace: input.namespace,
       result: ToolResultValue.make(input.result, input.resultType),
       providerExecuted: input.providerExecuted,
       cache: input.cache,
@@ -269,7 +266,7 @@ export namespace Message {
     make({ role: "tool", content: ["type" in result ? result : ToolResultPart.make(result)] })
 }
 
-const toolDefinitionFields = {
+export class ToolDefinition extends Schema.Class<ToolDefinition>("LLM.ToolDefinition")({
   name: Schema.String,
   description: Schema.String,
   inputSchema: JsonSchema,
@@ -277,71 +274,15 @@ const toolDefinitionFields = {
   cache: Schema.optional(CacheHint),
   metadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
   native: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
-}
-
-export type ToolDefinitionInput = Schema.Struct.Type<typeof toolDefinitionFields>
-
-export class ToolDefinition extends Schema.Class<ToolDefinition>("LLM.ToolDefinition")({
-  type: Schema.Literal("tool"),
-  ...toolDefinitionFields,
-}) {
-  constructor(input: ToolDefinitionInput) {
-    super({ ...input, type: "tool" })
-  }
-}
+}) {}
 
 export namespace ToolDefinition {
-  export type Input = ToolDefinition | ToolDefinitionInput
+  export type Input = ToolDefinition | ConstructorParameters<typeof ToolDefinition>[0]
 
   /** Normalize tool definition input into the canonical `ToolDefinition` class. */
   export const make = (input: Input) => (input instanceof ToolDefinition ? input : new ToolDefinition(input))
 }
 
-export type ToolNamespace = {
-  readonly type: "namespace"
-  readonly name: string
-  readonly description?: string
-  readonly tools: ReadonlyArray<ToolEntry>
-}
-
-export type ToolNamespaceInput = Omit<ToolNamespace, "type" | "tools"> & {
-  readonly tools: ReadonlyArray<ToolEntryInput>
-}
-export type ToolNamespaceEntryInput = ToolNamespaceInput & { readonly type: "namespace" }
-
-export const ToolNamespace: Schema.Codec<ToolNamespace> & {
-  readonly make: (input: ToolNamespace | ToolNamespaceInput) => ToolNamespace
-} = Object.assign(
-  Schema.Struct({
-    type: Schema.Literal("namespace"),
-    name: Schema.String,
-    description: Schema.optional(Schema.UndefinedOr(Schema.String)),
-    tools: Schema.Array(Schema.suspend((): Schema.Codec<ToolEntry> => ToolEntry)),
-  }).annotate({ identifier: "LLM.ToolNamespace" }),
-  {
-    make: (input: ToolNamespace | ToolNamespaceInput): ToolNamespace => ({
-      ...input,
-      type: "namespace",
-      tools: input.tools.map(ToolEntry.make),
-    }),
-  },
-)
-
-export type ToolEntry = ToolDefinition | ToolNamespace
-export type ToolEntryInput = ToolDefinition.Input | ToolNamespaceEntryInput
-export const ToolEntry: Schema.Codec<ToolEntry> & {
-  readonly make: (input: ToolEntryInput) => ToolEntry
-} = Object.assign(
-  Schema.Union([ToolDefinition, ToolNamespace]).pipe(
-    Schema.toTaggedUnion("type"),
-    Schema.annotate({ identifier: "LLM.ToolEntry" }),
-  ),
-  {
-    make: (input: ToolEntryInput): ToolEntry =>
-      "type" in input && input.type === "namespace" ? ToolNamespace.make(input) : ToolDefinition.make(input),
-  },
-)
-
 export class ToolChoice extends Schema.Class<ToolChoice>("LLM.ToolChoice")({
   type: Schema.Literals(["auto", "none", "required", "tool"]),
   name: Schema.optional(Schema.String),
@@ -371,7 +312,7 @@ const requestSchema = Schema.Struct({
   model: LanguageModelSchema,
   system: Schema.Array(SystemPart),
   messages: Schema.Array(Message),
-  tools: Schema.Array(ToolEntry),
+  tools: Schema.Array(ToolDefinition),
   toolChoice: Schema.optional(ToolChoice),
   generation: Schema.optional(GenerationOptions),
   providerOptions: Schema.optional(ProviderOptions),

packages/ai/src/tool-history.ts

@@ -37,13 +37,7 @@ function missingToolResults(calls: Iterable<ToolCallPart>) {
   return new Message({
     role: "tool",
     content: [...calls].map((call) =>
-      ToolResultPart.make({
-        id: call.id,
-        name: call.name,
-        namespace: call.namespace,
-        result: MISSING_TOOL_RESULT,
-        resultType: "error",
-      }),
+      ToolResultPart.make({ id: call.id, name: call.name, result: MISSING_TOOL_RESULT, resultType: "error" }),
     ),
   })
 }
@@ -53,7 +47,7 @@ function normalizeToolMessage(message: Message, pending: Map<string, ToolCallPar
     if (part.type !== "tool-result" || part.providerExecuted === true) return part
     const call = pending.get(part.id)
     if (call) pending.delete(part.id)
-    return normalizeToolResult(part, call)
+    return normalizeToolResult(part, call?.name ?? part.name)
   })
   if (content.length === 0) return undefined
   if (content.every((part, index) => part === message.content[index])) return message
@@ -67,11 +61,8 @@ function normalizeToolMessage(message: Message, pending: Map<string, ToolCallPar
   })
 }
 
-function normalizeToolResult(part: ToolResultPart, call: ToolCallPart | undefined): ToolResultPart {
-  const named =
-    call === undefined || (part.name === call.name && part.namespace === call.namespace)
-      ? part
-      : { ...part, name: call.name, namespace: call.namespace }
+function normalizeToolResult(part: ToolResultPart, name: string): ToolResultPart {
+  const named = part.name === name ? part : { ...part, name }
   if (named.result.type === "text" && named.result.value === "")
     return { ...named, result: { type: "text", value: EMPTY_TOOL_OUTPUT } }
   if (named.result.type === "error" && named.result.value === "")

packages/ai/src/tool-runtime.ts

@@ -21,11 +21,10 @@ export interface DispatchResult extends ToolSettlement {
 
 /** Execute one canonical tool call without owning provider IO or continuation. */
 export const dispatch = (tools: Tools, call: ToolCallPart): Effect.Effect<DispatchResult> => {
-  const name = call.namespace === undefined ? call.name : `${call.namespace}.${call.name}`
-  const tool = tools[name]
-  if (!tool) return Effect.succeed(result(call, { type: "error", value: `Unknown tool: ${name}` }))
+  const tool = tools[call.name]
+  if (!tool) return Effect.succeed(result(call, { type: "error", value: `Unknown tool: ${call.name}` }))
   if (!tool.execute)
-    return Effect.succeed(result(call, { type: "error", value: `Tool has no execute handler: ${name}` }))
+    return Effect.succeed(result(call, { type: "error", value: `Tool has no execute handler: ${call.name}` }))
 
   return decodeAndExecute(tool, call).pipe(
     Effect.map((value) => result(call, value)),
@@ -39,11 +38,7 @@ const decodeAndExecute = (tool: AnyTool, call: ToolCallPart): Effect.Effect<Tool
   tool._decode(call.input).pipe(
     Effect.mapError((error) => new ToolFailure({ message: `Invalid tool input: ${error.message}` })),
     Effect.flatMap((decoded) =>
-      tool.execute!(decoded, {
-        id: call.id,
-        name: call.name,
-        namespace: call.namespace,
-      }).pipe(
+      tool.execute!(decoded, { id: call.id, name: call.name }).pipe(
         Effect.flatMap((value) =>
           tool._encode(value).pipe(
             Effect.mapError(
@@ -76,7 +71,6 @@ const result = (call: ToolCallPart, value: ToolResultValueType | ToolSettlement,
             LLMEvent.toolError({
               id: call.id,
               name: call.name,
-              namespace: call.namespace,
               message: String(settlement.result.value),
               error,
               providerMetadata: call.providerMetadata,
@@ -84,7 +78,6 @@ const result = (call: ToolCallPart, value: ToolResultValueType | ToolSettlement,
             LLMEvent.toolResult({
               id: call.id,
               name: call.name,
-              namespace: call.namespace,
               result: settlement.result,
               providerMetadata: call.providerMetadata,
             }),
@@ -93,7 +86,6 @@ const result = (call: ToolCallPart, value: ToolResultValueType | ToolSettlement,
             LLMEvent.toolResult({
               id: call.id,
               name: call.name,
-              namespace: call.namespace,
               result: settlement.result,
               output: settlement.output,
               providerMetadata: call.providerMetadata,

packages/ai/src/tool.ts

@@ -16,7 +16,6 @@ export type ToolSchema<T> = Schema.Codec<T, any, never, never>
 export interface ToolExecuteContext {
   readonly id: ToolCallPart["id"]
   readonly name: ToolCallPart["name"]
-  readonly namespace?: ToolCallPart["namespace"]
 }
 
 export type ToolExecute<Parameters extends ToolSchema<any>, Success extends ToolSchema<any>> = (

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

@@ -215,35 +215,6 @@ describe("applyCachePolicy", () => {
     }),
   )
 
-  it.effect("deduplicates tools before counting cache hints", () =>
-    Effect.gen(function* () {
-      const manual = new CacheHint({ type: "ephemeral" })
-      const duplicate = (description: string) => ({
-        name: "lookup",
-        description,
-        inputSchema: { type: "object" },
-        cache: manual,
-      })
-      const prepared = yield* compileRequest(
-        LLM.request({
-          model: anthropicModel,
-          tools: [
-            duplicate("first"),
-            duplicate("second"),
-            duplicate("third"),
-            duplicate("fourth"),
-            { name: "lookup", description: "final", inputSchema: { type: "object" } },
-          ],
-          cache: { tools: true },
-        }),
-      )
-
-      expect(prepared.body.tools).toEqual([
-        expect.objectContaining({ name: "lookup", description: "final", cache_control: { type: "ephemeral" } }),
-      ])
-    }),
-  )
-
   it.effect("auto policy preserves manual CacheHints on other parts", () =>
     Effect.gen(function* () {
       const prepared = yield* compileRequest(
@@ -310,30 +281,6 @@ describe("applyCachePolicy", () => {
     }),
   )
 
-  test("marks the final leaf inside a tool namespace", () => {
-    const request = LLM.request({
-      model: anthropicModel,
-      tools: [
-        {
-          type: "namespace",
-          name: "crm",
-          tools: [
-            { name: "lookup", description: "lookup", inputSchema: {} },
-            { name: "orders", description: "orders", inputSchema: {} },
-          ],
-        },
-      ],
-      cache: { tools: true },
-    })
-    const applied = applyCachePolicy(request)
-    const namespace = applied.tools[0]
-
-    expect(namespace?.type).toBe("namespace")
-    if (namespace?.type !== "namespace") throw new Error("Expected namespace")
-    expect(namespace.tools[0]).not.toHaveProperty("cache")
-    expect(namespace.tools[1]).toHaveProperty("cache", { type: "ephemeral" })
-  })
-
   it.effect("ttlSeconds in the policy flows through to wire markers", () =>
     Effect.gen(function* () {
       const prepared = yield* compileRequest(

packages/ai/test/compaction.test.ts

@@ -1,10 +1,8 @@
 import { expect, test } from "bun:test"
-import { Effect, Schema } from "effect"
+import { Schema } from "effect"
 import { CompactionPart, CompactionResponse, LLMEvent, LLMResponse, Message, ProviderID } from "../src/schema/index.js"
 import { LLM, LLMClient, LLMRequest, LanguageModel } from "../src/index.js"
 import { OpenAI, Anthropic } from "../src/providers.js"
-import { testEffect } from "./lib/effect.js"
-import { fixedResponse } from "./lib/http.js"
 
 test("runtime capability checks follow model and route updates", () => {
   const supported = OpenAI.configure({ apiKey: "test" }).responses("fixture")
@@ -77,25 +75,3 @@ test("tagged content and event guards accept both checkpoint representations", (
     expect(Schema.decodeSync(codec)(Schema.encodeSync(codec)(message))).toEqual(message)
   }
 })
-
-testEffect(fixedResponse("")).effect(
-  "explicit compaction on a route without a compact endpoint fails with UnsupportedOperation",
-  () =>
-    Effect.gen(function* () {
-      const request = LLM.request({
-        model: Anthropic.configure({ apiKey: "test" }).model("fixture"),
-        prompt: "hello",
-      })
-      expect(LLMClient.canCompact(request)).toBe(false)
-      const error = yield* LLMClient.compact(
-        request as unknown as Parameters<typeof LLMClient.compact>[0],
-      ).pipe(Effect.flip)
-      expect(error.reason._tag).toBe("UnsupportedOperation")
-      expect(error.message).toContain("does not support explicit compaction")
-      if (error.reason._tag === "UnsupportedOperation") {
-        expect(error.reason.operation).toBe("compact")
-        expect(error.reason.provider).toBe("anthropic")
-        expect(error.reason.route).toBe("anthropic-messages")
-      }
-    }),
-)

packages/ai/test/compile.test.ts

@@ -1,16 +1,8 @@
 import { describe, expect, test } from "bun:test"
 import { Effect, Ref, Schema } from "effect"
 import { HttpClientRequest, HttpClientResponse } from "effect/unstable/http"
-import {
-  LLM,
-  LLMRequest,
-  Message,
-  ToolCallPart,
-  ToolDefinition,
-  ToolNamespace,
-  mergeProviderOptions,
-} from "../src/index.js"
-import { AnthropicMessages, OpenAIChat, OpenAIResponses } from "../src/protocols.js"
+import { LLM, LLMRequest, Message, ToolCallPart, ToolDefinition, mergeProviderOptions } from "../src/index.js"
+import { AnthropicMessages, OpenAIChat } from "../src/protocols.js"
 import { Auth, LLMClient } from "../src/route.js"
 import { compileRequest } from "../src/route/client.js"
 import { it } from "./lib/effect.js"
@@ -114,58 +106,6 @@ describe("request option precedence", () => {
     }),
   )
 
-  it.effect("deduplicates tools within each namespace", () =>
-    Effect.gen(function* () {
-      const prepared = yield* compileRequest(
-        LLM.request({
-          model: OpenAIResponses.route.model({ id: "gpt-5.4" }),
-          tools: [
-            ToolDefinition.make({ name: "crm", description: "Top-level CRM tool", inputSchema: {} }),
-            ToolNamespace.make({
-              name: "crm",
-              description: "CRM tools",
-              tools: [
-                ToolDefinition.make({ name: "lookup", description: "old", inputSchema: {} }),
-                ToolDefinition.make({ name: "search", description: "search", inputSchema: {} }),
-                ToolDefinition.make({ name: "lookup", description: "new", inputSchema: {} }),
-              ],
-            }),
-            ToolNamespace.make({
-              name: "support",
-              description: "Support tools",
-              tools: [ToolDefinition.make({ name: "lookup", description: "support", inputSchema: {} })],
-            }),
-          ],
-        }),
-      )
-
-      expect(prepared.body.tools).toEqual([
-        {
-          type: "function",
-          name: "crm",
-          description: "Top-level CRM tool",
-          parameters: {},
-          strict: false,
-        },
-        {
-          type: "namespace",
-          name: "crm",
-          description: "CRM tools",
-          tools: [
-            { type: "function", name: "lookup", description: "new", parameters: {}, strict: false },
-            { type: "function", name: "search", description: "search", parameters: {}, strict: false },
-          ],
-        },
-        {
-          type: "namespace",
-          name: "support",
-          description: "Support tools",
-          tools: [{ type: "function", name: "lookup", description: "support", parameters: {}, strict: false }],
-        },
-      ])
-    }),
-  )
-
   it.effect("normalizes tool history before protocol lowering", () =>
     Effect.gen(function* () {
       const prepared = yield* compileRequest(

packages/ai/test/llm.test.ts

@@ -1,6 +1,5 @@
 import { describe, expect, test } from "bun:test"
-import { Schema } from "effect"
-import { CacheHint, LLM, LLMResponse, ToolEntry, ToolNamespace } from "../src/index.js"
+import { CacheHint, LLM, LLMResponse } from "../src/index.js"
 import * as OpenAIChat from "../src/protocols/openai-chat.js"
 import * as OpenAIResponses from "../src/protocols/openai-responses.js"
 import {
@@ -18,52 +17,6 @@ const chatRoute = OpenAIChat.route
 const responsesRoute = OpenAIResponses.route
 
 describe("llm constructors", () => {
-  test("normalizes recursive tool namespaces", () => {
-    const request = LLM.request({
-      model: LanguageModel.make({ id: "fake-model", provider: "fake", route: responsesRoute }),
-      tools: [
-        {
-          type: "namespace",
-          name: "crm",
-          description: "Customer management",
-          tools: [
-            { name: "lookup", description: "Look up a customer", inputSchema: { type: "object" } },
-            {
-              type: "namespace",
-              name: "orders",
-              tools: [{ name: "list", description: "List orders", inputSchema: { type: "object" } }],
-            },
-          ],
-        },
-      ],
-    })
-
-    expect(request.tools[0]).toEqual({
-      type: "namespace",
-      name: "crm",
-      description: "Customer management",
-      tools: [
-        expect.objectContaining({ type: "tool", name: "lookup" }),
-        {
-          type: "namespace",
-          name: "orders",
-          description: undefined,
-          tools: [expect.objectContaining({ type: "tool", name: "list" })],
-        },
-      ],
-    })
-    expect(request.tools[0]).toEqual(
-      ToolNamespace.make({
-        name: "crm",
-        description: "Customer management",
-        tools: request.tools[0]!.type === "namespace" ? request.tools[0].tools : [],
-      }),
-    )
-    expect(Schema.decodeUnknownSync(ToolEntry)(Schema.encodeUnknownSync(ToolEntry)(request.tools[0]))).toEqual(
-      request.tools[0],
-    )
-  })
-
   test("builds canonical schema classes from ergonomic input", () => {
     const request = LLM.request({
       id: "req_1",

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

@@ -713,10 +713,9 @@ describe("Bedrock Converse route", () => {
     }),
   )
 
-  it.effect("ignores tool deltas without an open tool block", () =>
+  it.effect("ignores late tool deltas after contentBlockStop", () =>
     Effect.gen(function* () {
       const body = eventStreamBody(
-        ["contentBlockDelta", { contentBlockIndex: 5, delta: { toolUse: { input: "{}" } } }],
         [
           "contentBlockStart",
           {
@@ -746,6 +745,27 @@ describe("Bedrock Converse route", () => {
     }),
   )
 
+  it.effect("rejects tool deltas without contentBlockStart", () =>
+    Effect.gen(function* () {
+      const error = yield* LLMClient.generate(baseRequest).pipe(
+        Effect.provide(
+          fixedBytes(
+            eventStreamBody(
+              ["contentBlockDelta", { contentBlockIndex: 0, delta: { toolUse: { input: "{}" } } }],
+              ["messageStop", { stopReason: "tool_use" }],
+            ),
+          ),
+        ),
+        Effect.flip,
+      )
+
+      expect(error).toMatchObject({
+        reason: { _tag: "InvalidProviderOutput" },
+        message: "Bedrock Converse tool delta is missing its tool call",
+      })
+    }),
+  )
+
   it.effect("recovers incomplete tool input at finalization", () =>
     Effect.gen(function* () {
       const body = eventStreamBody(

packages/ai/test/provider/explicit-compaction.test.ts

@@ -1,6 +1,6 @@
 import { expect } from "bun:test"
 import { Effect, Schema } from "effect"
-import { LLM, LLMRequest, Message, ToolDefinition } from "../../src/index.js"
+import { LLM, LLMRequest, Message } from "../../src/index.js"
 import { LLMClient, Route } from "../../src/route/client.js"
 import { Auth } from "../../src/route/auth.js"
 import { Endpoint } from "../../src/route/endpoint.js"
@@ -130,27 +130,16 @@ for (const model of [
           }),
         ],
       })
-      for (const [candidate, tag] of [
-        [
-          LLMRequest.update(request, {
-            tools: [
-              ToolDefinition.make({
-                name: "unsupported",
-                description: "Generation only",
-                inputSchema: {},
-                native: { unsupported: {} },
-              }),
-            ],
-          }),
-          "InvalidRequest",
-        ],
-        [
-          LLMRequest.update(request, { providerOptions: { contextManagement: "invalid-generation-option" } }),
-          model.provider === "xai" ? "UnsupportedOperation" : "InvalidRequest",
-        ],
-      ] as const) {
+      for (const candidate of [
+        LLMRequest.update(request, {
+          tools: [
+            { name: "unsupported", description: "Generation only", inputSchema: {}, native: { unsupported: {} } },
+          ],
+        }),
+        LLMRequest.update(request, { providerOptions: { contextManagement: "invalid-generation-option" } }),
+      ]) {
         const error = yield* LLMClient.generate(candidate).pipe(Effect.flip)
-        expect(error.reason._tag).toBe(tag)
+        expect(error.reason._tag).toBe("InvalidRequest")
         const response = yield* LLMClient.compact(candidate)
         expect(response.replacement[0]?.content[0]?.type).toBe("compaction")
       }
@@ -372,9 +361,8 @@ testEffect(fixedResponse("must not execute")).effect("xAI rejects automatic comp
       { providerOptions: { contextManagement: [{ type: "compaction" }] } },
     )
     const error = yield* LLMClient.generate(request).pipe(Effect.flip)
-    expect(error.reason._tag).toBe("UnsupportedOperation")
+    expect(error.reason._tag).toBe("InvalidRequest")
     expect(error.message).toContain("LLMClient.compact")
-    if (error.reason._tag === "UnsupportedOperation") expect(error.reason.operation).toBe("in-band-compaction")
   }),
 )
 
@@ -440,9 +428,7 @@ for (const model of [
       Effect.gen(function* () {
         // @ts-expect-error Untyped callers must still receive the runtime capability error.
         const error = yield* LLMClient.compact(LLM.request({ model, prompt: "hello" })).pipe(Effect.flip)
-        expect(error.reason._tag).toBe("UnsupportedOperation")
-        expect(error.message).toContain("does not support explicit compaction")
-        if (error.reason._tag === "UnsupportedOperation") expect(error.reason.operation).toBe("compact")
+        expect(error.reason._tag).toBe("InvalidRequest")
       }),
   )
 }

packages/ai/test/provider/open-responses-finals.test.ts

@@ -82,6 +82,32 @@ describe("Open Responses completed item text", () => {
       expect(response.events.filter(LLMEvent.is.textStart)).toEqual([])
     }),
   )
+
+  it.effect("assembles a done-only message once across replayed item events", () =>
+    Effect.gen(function* () {
+      const item = {
+        type: "message",
+        id: "msg_1",
+        content: [{ type: "output_text", text: "Recovered" }],
+      }
+      const response = yield* generate(
+        { type: "response.output_text.delta", item_id: "msg_1", delta: "Ignored after resume" },
+        { type: "response.output_item.done", item },
+        { type: "response.output_item.added", item },
+        { type: "response.output_item.done", item },
+        completed,
+      )
+      expect(response.text).toBe("Recovered")
+      expect(response.message.content).toEqual([
+        {
+          type: "text",
+          text: "Recovered",
+          providerMetadata: { "openai-compatible": { itemId: "msg_1" } },
+        },
+      ])
+      expect(response.events.filter(LLMEvent.is.textEnd)).toHaveLength(1)
+    }),
+  )
 })
 
 describe("Open Responses completed item reasoning", () => {

packages/ai/test/provider/open-responses-lifecycle.test.ts

@@ -71,7 +71,7 @@ function expectLifecycle(events: ReadonlyArray<LLMEvent>, completed: boolean) {
 }
 
 describe("Open Responses basic-item lifecycles", () => {
-  it.effect("closes implicit summary boundaries", () =>
+  it.effect("closes implicit summary boundaries and ignores late events for completed reasoning", () =>
     Effect.gen(function* () {
       const item = { type: "reasoning", id: "rs_1", encrypted_content: "encrypted-state" }
       const events = yield* collect(
@@ -90,6 +90,12 @@ describe("Open Responses basic-item lifecycles", () => {
           delta: "Third",
         },
         { type: "response.output_item.done", item },
+        { type: "response.output_item.done", item },
+        { type: "response.output_item.added", item },
+        { type: "response.reasoning_summary_part.added", item_id: "rs_1", summary_index: 3 },
+        { type: "response.reasoning_summary_text.delta", item_id: "rs_1", summary_index: 3, delta: "late" },
+        { type: "response.reasoning_summary_text.done", item_id: "rs_1", summary_index: 2, text: "late final" },
+        { type: "response.reasoning_summary_part.done", item_id: "rs_1", summary_index: 3 },
         completed,
       )
 
@@ -123,7 +129,7 @@ describe("Open Responses basic-item lifecycles", () => {
     }),
   )
 
-  it.effect("preserves done-only reasoning text and encryption", () =>
+  it.effect("preserves done-only reasoning text and encryption without replaying late events", () =>
     Effect.gen(function* () {
       const item = {
         type: "reasoning",
@@ -133,6 +139,11 @@ describe("Open Responses basic-item lifecycles", () => {
       }
       const events = yield* collect(
         { type: "response.output_item.done", item },
+        { type: "response.output_item.done", item },
+        { type: "response.output_item.added", item },
+        { type: "response.reasoning_summary_text.delta", item_id: "rs_1", delta: "late" },
+        { type: "response.reasoning_summary_part.added", item_id: "rs_1", summary_index: 1 },
+        { type: "response.reasoning_summary_text.done", item_id: "rs_1", summary_index: 1, text: "late final" },
         completed,
         // Route termination must also prevent events after response completion.
         { type: "response.output_item.added", item: { type: "reasoning", id: "rs_after" } },
@@ -206,7 +217,7 @@ describe("Open Responses basic-item lifecycles", () => {
     }),
   )
 
-  it.effect("preserves non-empty done-only message content", () =>
+  it.effect("preserves non-empty done-only message content without replaying duplicates", () =>
     Effect.gen(function* () {
       const text = {
         type: "message",
@@ -219,11 +230,17 @@ describe("Open Responses basic-item lifecycles", () => {
         content: [{ type: "refusal", refusal: "Done-only refusal." }],
       }
       const events = yield* collect(
+        { type: "response.output_item.done", item: text },
         { type: "response.output_item.done", item: text },
         {
           type: "response.output_item.done",
           item: { type: "message", id: "msg_empty", content: [{ type: "output_text", text: "" }] },
         },
+        {
+          type: "response.output_item.done",
+          item: { type: "message", id: "msg_empty", content: [{ type: "output_text", text: "Late" }] },
+        },
+        { type: "response.output_item.done", item: refusal },
         { type: "response.output_item.done", item: refusal },
         completed,
       )
@@ -255,6 +272,63 @@ describe("Open Responses basic-item lifecycles", () => {
     }),
   )
 
+  it.effect("treats a repeated message lifecycle as replay", () =>
+    Effect.gen(function* () {
+      const events = yield* collect(
+        { type: "response.output_item.added", item: { type: "message", id: "msg_1", phase: "commentary" } },
+        { type: "response.output_text.delta", item_id: "msg_1", delta: "First" },
+        { type: "response.output_item.done", item: { type: "message", id: "msg_1" } },
+        { type: "response.output_item.added", item: { type: "message", id: "msg_1" } },
+        { type: "response.output_text.delta", item_id: "msg_1", delta: "Second" },
+        { type: "response.output_item.done", item: { type: "message", id: "msg_1" } },
+        completed,
+      )
+      expect(events.filter(LLMEvent.is.textEnd)).toEqual([
+        {
+          type: "text-end",
+          id: "msg_1",
+          providerMetadata: { "openai-compatible": { itemId: "msg_1", phase: "commentary" } },
+        },
+      ])
+      expect(events.filter(LLMEvent.is.textDelta).map((event) => event.text)).toEqual(["First"])
+    }),
+  )
+
+  it.effect("ignores a stale done-only message while another message is active", () =>
+    Effect.gen(function* () {
+      const events = yield* collect(
+        { type: "response.output_item.added", item: { type: "message", id: "msg_1", phase: "commentary" } },
+        { type: "response.output_text.delta", item_id: "msg_1", delta: "Draft" },
+        {
+          type: "response.output_item.done",
+          item: { type: "message", id: "msg_2", content: [{ type: "output_text", text: "Recovered" }] },
+        },
+        {
+          type: "response.output_item.done",
+          item: { type: "message", id: "msg_1", content: [{ type: "output_text", text: "Final" }] },
+        },
+        {
+          type: "response.output_item.done",
+          item: { type: "message", id: "msg_2", content: [{ type: "output_text", text: "Late" }] },
+        },
+        completed,
+      )
+      expect(events.filter((event) => event.type.startsWith("text-"))).toEqual([
+        {
+          type: "text-start",
+          id: "msg_1",
+          providerMetadata: { "openai-compatible": { itemId: "msg_1", phase: "commentary" } },
+        },
+        { type: "text-delta", id: "msg_1", text: "Draft" },
+        {
+          type: "text-end",
+          id: "msg_1",
+          text: "Final",
+          providerMetadata: { "openai-compatible": { itemId: "msg_1", phase: "commentary" } },
+        },
+      ])
+    }),
+  )
   // Captured from Bedrock Mantle (openai.gpt-oss-120b): the terminal function_call
   // items rename `id` to `item_id` and carry a stray `output_index`.
   it.effect("recovers a terminal function_call id from its output slot", () =>
@@ -326,6 +400,7 @@ describe("Open Responses basic-item lifecycles", () => {
       ])
     }),
   )
+
   it.effect("mints an id for a done-only tool that never had one", () =>
     Effect.gen(function* () {
       const events = yield* collect(
@@ -344,7 +419,7 @@ describe("Open Responses basic-item lifecycles", () => {
     }),
   )
 
-  it.effect("opens and closes a done-only tool", () =>
+  it.effect("opens and closes a done-only tool once", () =>
     Effect.gen(function* () {
       const item = {
         type: "function_call",
@@ -353,19 +428,17 @@ describe("Open Responses basic-item lifecycles", () => {
         name: "lookup",
         arguments: '{"query":"weather"}',
       }
-      const events = yield* collect({ type: "response.output_item.done", item }, completed)
+      const events = yield* collect(
+        { type: "response.output_item.done", item },
+        { type: "response.output_item.done", item },
+        { type: "response.output_item.added", item },
+        completed,
+      )
       const providerMetadata = { "openai-compatible": { itemId: "fc_1" } }
       expect(events.filter((event) => event.type.startsWith("tool-"))).toEqual([
-        { type: "tool-input-start", id: "call_1", name: "lookup", namespace: undefined, providerMetadata },
-        { type: "tool-input-end", id: "call_1", name: "lookup", namespace: undefined, providerMetadata },
-        {
-          type: "tool-call",
-          id: "call_1",
-          name: "lookup",
-          namespace: undefined,
-          input: { query: "weather" },
-          providerMetadata,
-        },
+        { type: "tool-input-start", id: "call_1", name: "lookup", providerMetadata },
+        { type: "tool-input-end", id: "call_1", name: "lookup", providerMetadata },
+        { type: "tool-call", id: "call_1", name: "lookup", input: { query: "weather" }, providerMetadata },
       ])
       expect(events.filter(LLMEvent.is.finish)).toEqual([
         {

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

@@ -171,66 +171,6 @@ describe("Open Responses-compatible route", () => {
     }),
   )
 
-  it.effect("flattens tool namespaces", () =>
-    Effect.gen(function* () {
-      const model = configure({ apiKey: "test-key", baseURL: "https://responses.example.test/v1" }).model(
-        "example-model",
-      )
-      const prepared = yield* compileRequest(
-        LLM.request({
-          model,
-          tools: [
-            {
-              type: "namespace",
-              name: "acme",
-              tools: [
-                {
-                  type: "namespace",
-                  name: "billing",
-                  tools: [ToolDefinition.make({ name: "lookup", description: "Lookup billing", inputSchema: {} })],
-                },
-                ToolDefinition.make({ name: "users", description: "Lookup users", inputSchema: {} }),
-              ],
-            },
-          ],
-        }),
-      )
-
-      expect(prepared.body.tools).toEqual([
-        {
-          type: "function",
-          name: "acme_billing_lookup",
-          description: "Lookup billing",
-          parameters: {},
-          strict: false,
-        },
-        { type: "function", name: "acme_users", description: "Lookup users", parameters: {}, strict: false },
-      ])
-    }),
-  )
-
-  it.effect("flattens tool namespaces in history", () =>
-    Effect.gen(function* () {
-      const model = configure({ apiKey: "test-key", baseURL: "https://responses.example.test/v1" }).model(
-        "example-model",
-      )
-      const prepared = yield* compileRequest(
-        LLM.request({
-          model,
-          messages: [
-            Message.assistant({ type: "tool-call", id: "call_1", name: "lookup", namespace: "crm", input: {} }),
-            Message.tool({ id: "call_1", name: "lookup", namespace: "crm", result: "done", resultType: "text" }),
-          ],
-        }),
-      )
-
-      expect(prepared.body.input).toEqual([
-        { type: "function_call", call_id: "call_1", name: "crm_lookup", namespace: undefined, arguments: "{}" },
-        { type: "function_call_output", call_id: "call_1", output: "done" },
-      ])
-    }),
-  )
-
   it.effect("lowers canonical parallel tool control", () =>
     Effect.gen(function* () {
       const model = configure({

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

@@ -12,7 +12,6 @@ import {
   LanguageModel,
   ToolCallPart,
   ToolDefinition,
-  ToolNamespace,
   ToolResultPart,
   TransportError,
   Usage,
@@ -144,94 +143,6 @@ describe("OpenAI Responses route", () => {
     }),
   )
 
-  it.effect("lowers tool namespaces without flattening leaf names", () =>
-    Effect.gen(function* () {
-      const prepared = yield* compileRequest(
-        LLM.request({
-          model,
-          prompt: "Find a customer and their orders.",
-          tools: [
-            ToolNamespace.make({
-              name: "crm",
-              description: "Customer management",
-              tools: [
-                ToolDefinition.make({ name: "lookup", description: "Look up a customer", inputSchema: {} }),
-                ToolDefinition.make({ name: "orders", description: "List customer orders", inputSchema: {} }),
-              ],
-            }),
-          ],
-        }),
-      )
-
-      expect(prepared.body.tools).toEqual([
-        {
-          type: "namespace",
-          name: "crm",
-          description: "Customer management",
-          tools: [
-            { type: "function", name: "lookup", description: "Look up a customer", parameters: {}, strict: false },
-            { type: "function", name: "orders", description: "List customer orders", parameters: {}, strict: false },
-          ],
-        },
-      ])
-    }),
-  )
-
-  it.effect("flattens nested levels within a native tool namespace", () =>
-    Effect.gen(function* () {
-      const prepared = yield* compileRequest(
-        LLM.request({
-          model,
-          tools: [
-            {
-              type: "namespace",
-              name: "crm",
-              description: "Customer management",
-              tools: [
-                {
-                  type: "namespace",
-                  name: "orders",
-                  description: "Order management",
-                  tools: [ToolDefinition.make({ name: "list", description: "List orders", inputSchema: {} })],
-                },
-              ],
-            },
-          ],
-        }),
-      )
-
-      expect(prepared.body.tools).toEqual([
-        {
-          type: "namespace",
-          name: "crm",
-          description: "Customer management",
-          tools: [{ type: "function", name: "orders_list", description: "List orders", parameters: {}, strict: false }],
-        },
-      ])
-    }),
-  )
-
-  it.effect("defaults tool namespace descriptions", () =>
-    Effect.gen(function* () {
-      const prepared = yield* compileRequest(
-        LLM.request({
-          model,
-          tools: [
-            {
-              type: "namespace",
-              name: "crm",
-              tools: [ToolDefinition.make({ name: "lookup", description: "Look up a customer", inputSchema: {} })],
-            },
-          ],
-        }),
-      )
-
-      expect(prepared.body.tools).toEqual([
-        expect.objectContaining({ type: "namespace", name: "crm", description: "Tools in the crm namespace." }),
-      ])
-    }),
-  )
-
   it.effect("rejects invalid hosted image generation options locally", () =>
     Effect.gen(function* () {
       const error = yield* compileRequest(
@@ -2219,71 +2130,6 @@ describe("OpenAI Responses route", () => {
     }),
   )
 
-  it.effect("preserves tool namespaces through streaming and history replay", () =>
-    Effect.gen(function* () {
-      const item = {
-        type: "function_call",
-        id: "fc_1",
-        call_id: "call_1",
-        namespace: "crm",
-        name: "lookup",
-        arguments: "",
-      }
-      const response = yield* LLMClient.generate(request).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents(
-              { type: "response.output_item.added", output_index: 0, item },
-              {
-                type: "response.function_call_arguments.delta",
-                output_index: 0,
-                item_id: "fc_1",
-                delta: '{"id":"123"}',
-              },
-              {
-                type: "response.output_item.done",
-                output_index: 0,
-                item: { ...item, arguments: '{"id":"123"}' },
-              },
-              { type: "response.completed", response: { id: "resp_1" } },
-            ),
-          ),
-        ),
-      )
-
-      const toolEvents = response.events.filter((event) => event.type.startsWith("tool-"))
-      expect(toolEvents).toEqual([
-        expect.objectContaining({ type: "tool-input-start", name: "lookup", namespace: "crm" }),
-        expect.objectContaining({ type: "tool-input-delta", name: "lookup", namespace: "crm" }),
-        expect.objectContaining({ type: "tool-input-end", name: "lookup", namespace: "crm" }),
-        expect.objectContaining({ type: "tool-call", name: "lookup", namespace: "crm", input: { id: "123" } }),
-      ])
-      expect(response.message.content).toEqual([
-        expect.objectContaining({ type: "tool-call", name: "lookup", namespace: "crm", input: { id: "123" } }),
-      ])
-
-      const prepared = yield* compileRequest(
-        LLM.request({
-          model,
-          messages: [
-            response.message,
-            Message.tool({ id: "call_1", name: "lookup", namespace: "crm", result: { customer: "Ada" } }),
-          ],
-        }),
-      )
-      expect(prepared.body.input).toEqual([
-        {
-          type: "function_call",
-          id: "fc_1",
-          call_id: "call_1",
-          namespace: "crm",
-          name: "lookup",
-          arguments: '{"id":"123"}',
-        },
-        { type: "function_call_output", call_id: "call_1", output: '{"customer":"Ada"}' },
-      ])
-    }),
-  )
   it.effect("routes reasoning summary events by output index", () =>
     Effect.gen(function* () {
       const response = yield* LLMClient.generate(request).pipe(
@@ -3004,7 +2850,7 @@ describe("OpenAI Responses route", () => {
     }),
   )
 
-  it.effect("ignores duplicate item start events", () =>
+  it.effect("ignores duplicate item boundary events", () =>
     Effect.gen(function* () {
       const response = yield* LLMClient.generate(request).pipe(
         Effect.provide(
@@ -3015,6 +2861,7 @@ describe("OpenAI Responses route", () => {
               { type: "response.output_item.added", item: { type: "reasoning", id: "rs_1" } },
               { type: "response.reasoning_summary_text.delta", item_id: "rs_1", summary_index: 0, delta: "Think" },
               { type: "response.output_item.done", item: { type: "reasoning", id: "rs_1" } },
+              { type: "response.output_item.done", item: { type: "reasoning", id: "rs_1" } },
               {
                 type: "response.output_item.added",
                 item: { type: "function_call", id: "fc_1", call_id: "call_1", name: "lookup", arguments: "" },
@@ -3034,6 +2881,21 @@ describe("OpenAI Responses route", () => {
                   arguments: '{"query":"weather"}',
                 },
               },
+              {
+                type: "response.output_item.done",
+                item: {
+                  type: "function_call",
+                  id: "fc_1",
+                  call_id: "call_1",
+                  name: "lookup",
+                  arguments: '{"query":"weather"}',
+                },
+              },
+              // A completed item that is re-added stays closed.
+              {
+                type: "response.output_item.added",
+                item: { type: "function_call", id: "fc_1", call_id: "call_1", name: "lookup", arguments: "" },
+              },
               { type: "response.completed", response: { id: "resp_1" } },
             ),
           ),

packages/ai/test/schema.test.ts

@@ -24,7 +24,6 @@ import {
   ToolResultValue,
   TransportError,
   UnknownProviderError,
-  UnsupportedOperationError,
   Usage,
 } from "../src/schema/index.js"
 import { ProviderShared } from "../src/protocols/shared.js"
@@ -277,12 +276,6 @@ test("AI errors serialize diagnostics only on their typed reason", () => {
 test("AI error reasons are tagged Errors with required messages", () => {
   const reasons = [
     new InvalidRequestError({ message: "Invalid request" }),
-    new UnsupportedOperationError({
-      message: "Unsupported operation",
-      operation: "compact",
-      provider: model.provider,
-      route: "fake-route",
-    }),
     new NoRouteError({
       message: "No route",
       route: RouteID.make("missing"),
@@ -300,7 +293,6 @@ test("AI error reasons are tagged Errors with required messages", () => {
   ]
   expect(reasons.map((reason) => reason._tag)).toEqual([
     "InvalidRequest",
-    "UnsupportedOperation",
     "NoRoute",
     "Authentication",
     "RateLimit",

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

@@ -15,7 +15,13 @@ describe("tool history normalization", () => {
       Message.assistant(toolCall("trailing")),
     ])
 
-    expect(normalized.map((message) => message.role)).toEqual(["assistant", "tool", "tool", "user", "assistant"])
+    expect(normalized.map((message) => message.role)).toEqual([
+      "assistant",
+      "tool",
+      "tool",
+      "user",
+      "assistant",
+    ])
     expect(normalized[1]?.content[0]).toMatchObject({ type: "tool-result", id: "first", name: "first" })
     expect(normalized[2]?.content).toEqual([
       { type: "tool-result", id: "second", name: "second", result: { type: "error", value: "Tool result missing" } },
@@ -68,13 +74,4 @@ describe("tool history normalization", () => {
 
     expect(normalizeToolHistory([orphan, hosted])).toEqual([orphan, hosted])
   })
-
-  test("uses a matching call as the complete tool identity", () => {
-    const normalized = normalizeToolHistory([
-      Message.assistant(ToolCallPart.make({ id: "call_1", name: "lookup", input: {} })),
-      Message.tool(ToolResultPart.make({ id: "call_1", name: "wrong", namespace: "stale", result: "done" })),
-    ])
-
-    expect(normalized[1]?.content[0]).toMatchObject({ name: "lookup", namespace: undefined })
-  })
 })

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

@@ -7,7 +7,6 @@ import {
   LLMEvent,
   LLMRequest,
   LLMResponse,
-  ToolCallPart,
   ToolChoice,
   ToolOutput,
   toDefinitions,
@@ -37,27 +36,6 @@ const baseRequest = LLM.request({
 })
 const weatherFailureCause = new Error("weather lookup denied")
 
-test("dispatches namespaced calls by qualified identity", async () => {
-  let context: ToolExecuteContext | undefined
-  const lookup = Tool.make({
-    description: "Look up a customer.",
-    parameters: Schema.Struct({}),
-    success: Schema.String,
-    execute: (_, value) => {
-      context = value
-      return Effect.succeed("customer")
-    },
-  })
-  const call = ToolCallPart.make({ id: "call_1", namespace: "crm", name: "lookup", input: {} })
-  const result = await Effect.runPromise(
-    ToolRuntime.dispatch({ "crm.lookup": lookup, lookup: schema_only_weather }, call),
-  )
-
-  expect(result.result).toEqual({ type: "text", value: "customer" })
-  expect(context).toEqual({ id: "call_1", namespace: "crm", name: "lookup" })
-  expect(result.events).toEqual([expect.objectContaining({ type: "tool-result", namespace: "crm", name: "lookup" })])
-})
-
 const get_weather = Tool.make({
   description: "Get current weather for a city.",
   parameters: Schema.Struct({ city: Schema.String }),

packages/app/component-tests/open-in-border.spec.ts

@@ -1,18 +0,0 @@
-import { expect, story } from "../../storybook/playwright/story"
-
-for (const theme of ["light", "dark"]) {
-  story(`keeps the Open in border visible without hovering (${theme})`, async ({ mount, page }, testInfo) => {
-    const component = await mount("ui-split-button--open-in", { globals: { theme } })
-    const control = component.locator('[data-component="split-button-v2"]')
-    await page.mouse.move(0, 0)
-    await expect(control).toBeVisible()
-    await expect(control).not.toHaveCSS("box-shadow", "none")
-    const border = await control.evaluate((element) => getComputedStyle(element).boxShadow)
-
-    await component.getByRole("button", { name: "Open options" }).hover()
-    await expect(control).toHaveCSS("box-shadow", border)
-    await page.mouse.move(0, 0)
-    await expect(control).toHaveCSS("box-shadow", border)
-    await control.screenshot({ path: testInfo.outputPath(`open-in-${theme}.png`) })
-  })
-}

packages/app/e2e/performance/command-palette-benchmark.spec.ts

@@ -1,47 +0,0 @@
-import { benchmark, expect } from "./benchmark"
-import { openCommandPalette } from "../utils/command-palette"
-
-benchmark.use({
-  viewport: { width: 1440, height: 900 },
-  serviceWorkers: "block",
-  traceScope: "interaction",
-  trace: "off",
-  video: "off",
-})
-
-for (const home of [false, true]) {
-  benchmark(`command lookup from ${home ? "home" : "session"}`, async ({ page, report }) => {
-    const { dialog, input } = await openCommandPalette(page, home)
-    const title = home ? "Open settings" : "Copy Session ID"
-    const query = home ? "open settings" : "copy session"
-    // Measure input-to-selected-result in the renderer, without assertion polling overhead.
-    await input.evaluate((element, title) => {
-      element.addEventListener(
-        "input",
-        () => {
-          performance.mark("palette-input")
-          const observer = new MutationObserver(() => {
-            if (document.querySelectorAll('[role="dialog"] [role="option"]').length !== 1) return
-            const selected = document.querySelector('[role="dialog"] [role="option"][aria-selected="true"]')
-            if (!selected?.textContent?.includes(title)) return
-            performance.measure("palette-result", "palette-input")
-            observer.disconnect()
-          })
-          observer.observe(document, { subtree: true, childList: true, attributes: true, characterData: true })
-        },
-        { once: true, capture: true },
-      )
-    }, title)
-    await input.fill(query)
-    await expect(dialog.getByRole("option")).toHaveCount(1)
-    await expect(dialog.getByRole("option", { name: new RegExp(`^${title}(?:$| )`) })).toHaveAttribute(
-      "aria-selected",
-      "true",
-    )
-    const result = await page.evaluate(() =>
-      performance.getEntriesByName("palette-result").map((entry) => entry.duration),
-    )
-    expect(result).toHaveLength(1)
-    report({ inputToResultMs: result[0] }, { home, query, data: "fixture; immediate server responses" })
-  })
-}

packages/app/e2e/regression/background-read-failure.spec.ts

@@ -1,50 +0,0 @@
-import { expect, test } from "@playwright/test"
-import { openCommandPalette, paletteSession } from "../utils/command-palette"
-
-test.use({ serviceWorkers: "block" })
-
-test("failed event-driven reads report an error and recover without an unhandled rejection", async ({ page }) => {
-  const errors: string[] = []
-  page.on("pageerror", (error) => errors.push(error.message))
-  const palette = await openCommandPalette(page)
-  const path = `**/api/session/${paletteSession.id}`
-  await page.route(path, (route) => route.abort("failed"))
-  const requested = page.waitForRequest(path)
-  await page.evaluate((sessionID) => {
-    const host = window as Window & { __mockServerStream?: { push: (events: unknown[]) => void } }
-    if (!host.__mockServerStream) throw new Error("Missing fixture event stream")
-    host.__mockServerStream.push([
-      {
-        id: "evt_failed_refresh",
-        created: 2,
-        type: "session.viewed",
-        durable: { aggregateID: sessionID, seq: 1, version: 1 },
-        data: { sessionID, idle: 2 },
-      },
-    ])
-  }, paletteSession.id)
-  await requested
-  await expect(page.getByText("Request failed", { exact: true })).toBeVisible()
-  await palette.input.fill("copy session")
-  await expect(palette.dialog.getByRole("option", { name: "Copy Session ID", exact: true })).toHaveAttribute(
-    "aria-selected",
-    "true",
-  )
-  await palette.input.press("Escape")
-  await page.unroute(path)
-  await page.evaluate((sessionID) => {
-    const host = window as Window & { __mockServerStream?: { push: (events: unknown[]) => void } }
-    if (!host.__mockServerStream) throw new Error("Missing fixture event stream")
-    host.__mockServerStream.push([
-      {
-        id: "evt_recovered_refresh",
-        created: 3,
-        type: "session.renamed",
-        durable: { aggregateID: sessionID, seq: 2, version: 1 },
-        data: { sessionID, title: "Recovered session" },
-      },
-    ])
-  }, paletteSession.id)
-  await expect(page.getByRole("heading", { name: "Recovered session", exact: true })).toBeVisible()
-  expect(errors).toEqual([])
-})

packages/app/e2e/regression/command-palette.spec.ts

@@ -1,102 +0,0 @@
-import { expect, test } from "@playwright/test"
-import { captureConsoleWarnings, openCommandPalette, paletteSession } from "../utils/command-palette"
-
-test.use({ serviceWorkers: "block", permissions: ["clipboard-read", "clipboard-write"] })
-
-test("copies the session ID while file and session searches are still pending", async ({ page }) => {
-  const warnings = captureConsoleWarnings(page)
-  const { dialog, input } = await openCommandPalette(page)
-  const release = Promise.withResolvers<void>()
-  await page.route(/\/api\/(session\?|fs\/find\?)/, async (route) => {
-    await release.promise
-    await route.fallback()
-  })
-  await input.pressSequentially("copy session")
-  const copy = dialog.getByRole("option", { name: "Copy Session ID", exact: true })
-  await expect(copy).toHaveAttribute("aria-selected", "true")
-  await input.press("Enter")
-  await expect(dialog).toHaveCount(0)
-  await expect.poll(() => page.evaluate(() => navigator.clipboard.readText())).toBe(paletteSession.id)
-  await expect(page.locator('[data-testid^="toast-v2-"] [data-slot="icon-svg"]')).toBeVisible()
-  expect(warnings).toEqual([])
-  release.resolve()
-})
-
-test("home commands do not wait for session search", async ({ page }) => {
-  const { dialog, input } = await openCommandPalette(page, true)
-  const release = Promise.withResolvers<void>()
-  await page.route("**/api/session?*", async (route) => {
-    await release.promise
-    await route.fallback()
-  })
-  await input.fill("open settings")
-  await expect(dialog.getByRole("option")).toHaveCount(1)
-  await expect(dialog.getByRole("option", { name: /^Open settings/ })).toHaveAttribute("aria-selected", "true")
-  await input.press("Enter")
-  await expect(page).toHaveURL("/settings")
-  await expect(page.getByTestId("settings-screen").getByRole("tab", { name: "Preferences", exact: true })).toBeVisible()
-  release.resolve()
-})
-
-test("appends search results without resetting the selected command", async ({ page }) => {
-  const { dialog, input } = await openCommandPalette(page)
-  const files = Promise.withResolvers<void>()
-  const sessions = Promise.withResolvers<void>()
-  await page.route("**/api/fs/find?*", async (route) => {
-    await files.promise
-    await route.fulfill({ json: { data: [{ path: "copy.txt", type: "file" }] } })
-  })
-  await page.route("**/api/session?*", async (route) => {
-    await sessions.promise
-    await route.fulfill({
-      json: {
-        data: [{ ...paletteSession, location: { directory: paletteSession.directory }, title: "Copy fixture" }],
-      },
-    })
-  })
-  await input.fill("copy")
-  const project = dialog.getByRole("option", { name: "Copy Project ID", exact: true })
-  await expect(project).toBeVisible()
-  // Select a non-first command with the keyboard before remote results arrive.
-  await input.press("ArrowDown")
-  await expect(project).toHaveAttribute("aria-selected", "true")
-  files.resolve()
-  await expect(dialog.getByRole("option", { name: "/ copy.txt", exact: true })).toBeVisible()
-  await expect(project).toHaveAttribute("aria-selected", "true")
-  // File results are usable even while sessions are still pending.
-  sessions.resolve()
-  await expect(dialog.getByRole("option", { name: /Copy fixture/ })).toBeVisible()
-  await expect(project).toHaveAttribute("aria-selected", "true")
-  await input.fill("copy session")
-  await expect(dialog.getByRole("option", { name: "Copy Session ID", exact: true })).toHaveAttribute(
-    "aria-selected",
-    "true",
-  )
-  await expect(dialog.getByRole("option", { name: "Copy Project ID", exact: true })).toHaveCount(0)
-})
-
-test("keeps the automatically selected file when session results arrive later", async ({ page }) => {
-  const { dialog, input } = await openCommandPalette(page)
-  const sessions = Promise.withResolvers<void>()
-  await page.route("**/api/fs/find?*", (route) =>
-    route.fulfill({ json: { data: [{ path: "README.md", type: "file" }] } }),
-  )
-  await page.route("**/api/session?*", async (route) => {
-    await sessions.promise
-    await route.fulfill({
-      json: {
-        data: [{ ...paletteSession, location: { directory: paletteSession.directory }, title: "README work" }],
-      },
-    })
-  })
-  await input.fill("README")
-  const file = dialog.getByRole("option", { name: "/ README.md", exact: true })
-  await expect(file).toHaveAttribute("aria-selected", "true")
-  sessions.resolve()
-  await expect(dialog.getByRole("option", { name: /README work/ })).toBeVisible()
-  await expect(file).toHaveAttribute("aria-selected", "true")
-  await input.press("Enter")
-  await expect(dialog).toHaveCount(0)
-  await expect(page.getByRole("tab", { name: "README.md", exact: true })).toBeVisible()
-  await expect(page.getByRole("heading", { name: paletteSession.title, exact: true })).toBeVisible()
-})

packages/app/e2e/regression/command-registration.spec.ts

@@ -1,77 +0,0 @@
-import { expect, test } from "@playwright/test"
-import { captureConsoleWarnings, openCommandPalette } from "../utils/command-palette"
-
-test.use({ serviceWorkers: "block", video: "off" })
-
-test("opening and closing files does not duplicate tab commands", async ({ page }) => {
-  const warnings = captureConsoleWarnings(page)
-  const palette = await openCommandPalette(page)
-  await page.route("**/api/fs/find?*", (route) =>
-    route.fulfill({
-      headers: { "access-control-allow-origin": "*" },
-      json: { data: [{ path: "fixture.txt", type: "file" }] },
-    }),
-  )
-  await palette.input.fill("fixture.txt")
-  await palette.dialog.getByRole("option", { name: /fixture\.txt/ }).click()
-  const file = page.getByRole("tab", { name: /fixture\.txt/ })
-  await expect(file).toBeVisible()
-  await expect(palette.dialog).toHaveCount(0)
-  await page
-    .getByRole("complementary", { name: "Review and files" })
-    .getByRole("button", { name: "Close tab", exact: true })
-    .click()
-  await expect(file).toHaveCount(0)
-  await expect(page.getByRole("heading", { name: "Palette fixture session", exact: true })).toBeVisible()
-  expect(warnings).toEqual([])
-})
-
-test("navigation replaces commands without retaining disposed owners", async ({ page }) => {
-  const warnings = captureConsoleWarnings(page)
-  const palette = await openCommandPalette(page, true)
-  await palette.input.press("Escape")
-  await expect(palette.dialog).toHaveCount(0)
-  await page
-    .getByRole("region", { name: "Recent sessions" })
-    .getByRole("button", { name: /Palette fixture session/ })
-    .click()
-  await expect(page.locator('[data-component="composer-editor"]')).toBeEditable()
-  await page.keyboard.press("ControlOrMeta+t")
-  await expect(page).toHaveURL(/\/new-session\?/)
-  await expect(page.locator('[data-component="composer-editor"]')).toBeEditable()
-  await page.locator('[data-component="composer-editor"]').blur()
-  await page.keyboard.press("Control+l")
-  await expect(page.locator('[data-component="composer-editor"]')).toBeFocused()
-  await page.keyboard.press("ControlOrMeta+Shift+P")
-  const dialog = page.getByRole("dialog")
-  await expect(dialog.getByRole("textbox")).toBeFocused()
-  await expect(dialog.getByRole("textbox")).toHaveAttribute("placeholder", "Search files, commands, and sessions")
-  await dialog.getByRole("textbox").fill("copy session")
-  await expect(dialog.getByRole("option", { name: "Copy Session ID", exact: true })).toHaveCount(0)
-  await dialog.getByRole("textbox").press("Escape")
-  await expect(dialog).toHaveCount(0)
-  await page.locator("[data-titlebar-tab-link]").filter({ hasText: "Palette fixture session" }).click()
-  await expect(page.getByRole("heading", { name: "Palette fixture session", exact: true })).toBeVisible()
-  for (const count of [3, 4]) {
-    await page.getByRole("button", { name: "New session", exact: true }).click()
-    await expect(page.locator("[data-titlebar-tab-link]")).toHaveCount(count)
-    await expect(page.locator('[data-component="composer-editor"]')).toBeEditable()
-  }
-  await page.setViewportSize({ width: 600, height: 800 })
-  await page.locator('[data-slot="mobile-tabs-trigger"]').click()
-  await expect(page.locator('[data-slot="mobile-tabs-drawer"] [data-titlebar-tab-link]')).toHaveCount(4)
-  await page.setViewportSize({ width: 1280, height: 800 })
-  await expect(page.locator('[data-slot="titlebar-tabs"] [data-titlebar-tab-link]')).toHaveCount(4)
-  await page.keyboard.press("ControlOrMeta+w")
-  await expect(page.locator("[data-titlebar-tab-link]")).toHaveCount(3)
-  await page.locator("[data-titlebar-tab-link]").filter({ hasText: "Palette fixture session" }).click()
-  await expect(page.getByRole("heading", { name: "Palette fixture session", exact: true })).toBeVisible()
-  await page.keyboard.press("ControlOrMeta+Shift+P")
-  await expect(dialog.getByRole("textbox")).toBeFocused()
-  await dialog.getByRole("textbox").fill("copy session")
-  await expect(dialog.getByRole("option", { name: "Copy Session ID", exact: true })).toHaveAttribute(
-    "aria-selected",
-    "true",
-  )
-  expect(warnings).toEqual([])
-})

packages/app/e2e/regression/new-session-workspace-pending.spec.ts

@@ -1,5 +1,4 @@
 import { expect, test, type Page } from "@playwright/test"
-import type { OpenCodeEvent } from "@opencode-ai/client/promise"
 import { base64Encode } from "@opencode-ai/util/encode"
 import { currentSession, mockOpenCodeServer } from "../utils/mock-server"
 import { expectAppVisible } from "../utils/waits"
@@ -26,53 +25,6 @@ for (const viewport of [
   { name: "desktop", width: 1280, height: 900 },
   { name: "mobile", width: 390, height: 844 },
 ]) {
-  test(`keeps Session in the tab until the generated title arrives on ${viewport.name}`, async ({ page }, testInfo) => {
-    await page.setViewportSize(viewport)
-    const mock = await openDraft(page, { untitled: true })
-    const label = page.locator(
-      viewport.name === "mobile"
-        ? '[data-slot="mobile-tab-title"]'
-        : '[data-titlebar-tab-slot][data-active="true"] [data-titlebar-tab-title]',
-    )
-    await expect(label).toHaveText("Session")
-    const pending = await submitPending(page, mock)
-    const spinner = page.locator(
-      viewport.name === "mobile"
-        ? '[data-slot="mobile-tabs-trigger"] [data-component="session-progress-indicator-v2"]'
-        : `[data-titlebar-tab-link][href="${sessionPath}${pending.sessionID}"] [data-component="session-progress-indicator-v2"]`,
-    )
-    await expect(spinner).toBeVisible()
-    await testInfo.attach("pending-tab-title", {
-      body: await page.screenshot(),
-      contentType: "image/png",
-    })
-    await expect(label).toHaveText("Session")
-
-    mock.worktree.resolve({ status: 200, json: { directory: workspace } })
-    await expect(pending.shimmer).toHaveCount(0)
-    await expect(page.locator('[data-action="composer-submit"]')).toBeEnabled()
-    await expect(label).toHaveText("Session")
-
-    if (viewport.name === "mobile") {
-      await label.click()
-      const drawer = page.locator('[data-slot="mobile-tabs-drawer"]')
-      const tab = drawer.locator(`[data-titlebar-tab-link][href="${sessionPath}${pending.sessionID}"]`)
-      await expect(tab.locator("[data-titlebar-tab-title]")).toHaveText("Session")
-      await tab.click()
-      await expect(drawer).toBeHidden()
-    }
-
-    mock.events.push({
-      id: "evt_generated_title",
-      type: "session.renamed",
-      created: Date.now(),
-      location: { directory: workspace },
-      durable: { aggregateID: pending.sessionID, seq: 1, version: 1 },
-      data: { sessionID: pending.sessionID, title: "Generated session title" },
-    })
-    await expect(label).toHaveText("Generated session title")
-  })
-
   test(`shows a pending workspace session immediately on ${viewport.name}`, async ({ page }, testInfo) => {
     await page.setViewportSize(viewport)
     const mock = await openDraft(page)
@@ -134,7 +86,7 @@ for (const viewport of [
       await expect(page).toHaveURL(pending.url)
       await expect(pending.message).toHaveAttribute("data-timeline-part-id", `${pending.messageID}:text:0`)
       await expect(pending.shimmer).toHaveAttribute("data-active", "true")
-      await expect(pending.title).toHaveText("Session")
+      await expect(pending.title).toHaveText("New session")
       await expect(editor).toHaveText(followUp)
       expect(mock.calls).toEqual(["worktree"])
 
@@ -238,7 +190,7 @@ for (const direction of ["ltr", "rtl"]) {
           !frame.message ||
           !frame.spinner ||
           frame.draft !== followUp ||
-          !["Session", "Created workspace session"].includes(frame.title ?? ""),
+          !["New session", "Created workspace session"].includes(frame.title ?? ""),
       ),
     ).toEqual([])
     const after = await title.boundingBox()
@@ -383,61 +335,6 @@ test("restores the draft after closing and revisiting a pending session that fai
   expect(mock.prompts).toEqual([])
 })
 
-test("executes a selected slash command after creating its worktree", async ({ page }, testInfo) => {
-  const events: OpenCodeEvent[] = []
-  const mock = await openDraft(page, { command: true, events: () => events.splice(0) })
-  const commands: { sessionID: string; body: Record<string, unknown> }[] = []
-  const expanded =
-    "Review the latest commit for correctness and regressions. Check the relevant tests and report actionable findings."
-  await page.route("**/api/session/*/command", async (route) => {
-    if (route.request().method() !== "POST") return route.fallback()
-    const sessionID = new URL(route.request().url()).pathname.split("/")[3]
-    commands.push({ sessionID, body: route.request().postDataJSON() })
-    // The server owns command expansion; the client receives the expanded inbox item.
-    events.push({
-      id: "evt_workspace_review",
-      type: "session.inbox.enqueued",
-      created: Date.now(),
-      durable: { aggregateID: sessionID, seq: 1, version: 1 },
-      data: {
-        sessionID,
-        inboxID: "msg_workspace_review",
-        item: { type: "user", payload: { text: expanded }, delivery: "steer" },
-      },
-    })
-    await route.fulfill({ status: 204, headers })
-  })
-  const editor = page.locator('[data-component="composer-editor"]')
-  await editor.fill("/review")
-  const suggestion = page.getByRole("button", { name: "/review Review changes", exact: true })
-  await expect(suggestion).toBeVisible()
-  await suggestion.click()
-  await expect(editor).toHaveText("/review")
-  const pending = await submitPending(page, mock, "/review latest commit")
-  await draftFollowUp(page)
-
-  mock.worktree.resolve({ status: 200, json: { directory: workspace } })
-
-  await expect
-    .poll(() => commands)
-    .toEqual([
-      {
-        sessionID: pending.sessionID,
-        body: { command: "review", text: "latest commit", files: [], agents: [], skills: [], delivery: "steer" },
-      },
-    ])
-  await expect(pending.shimmer).toHaveCount(0)
-  await expect(page.locator('[data-slot="user-message-text"]')).toHaveText(expanded)
-  await expect(editor).toHaveText(followUp)
-  await expect(page.locator('[data-action="composer-submit"]')).toBeEnabled()
-  expect(mock.creates).toEqual([expect.objectContaining({ id: pending.sessionID, location: { directory: workspace } })])
-  expect(mock.prompts).toEqual([])
-  await testInfo.attach("expanded-worktree-command", {
-    body: await page.screenshot({ path: testInfo.outputPath("expanded-worktree-command.png") }),
-    contentType: "image/png",
-  })
-})
-
 async function draftFollowUp(page: Page) {
   const editor = page.locator('[data-component="composer-editor"]')
   await editor.pressSequentially("!")
@@ -449,16 +346,12 @@ async function draftFollowUp(page: Page) {
   await expect(editor).toHaveText(followUp)
 }
 
-async function openDraft(
-  page: Page,
-  options?: { failSessionCreate?: boolean; untitled?: boolean; command?: boolean; events?: () => OpenCodeEvent[] },
-) {
+async function openDraft(page: Page, options?: { failSessionCreate?: boolean }) {
   const worktree = Promise.withResolvers<{ status: number; json: { directory?: string; message?: string } }>()
   const calls: string[] = []
   const worktreeRequests: Record<string, unknown>[] = []
   const creates: Record<string, unknown>[] = []
   const prompts: { sessionID: string; body: Record<string, unknown> }[] = []
-  const events: OpenCodeEvent[] = []
   const project = {
     id: projectID,
     worktree: directory,
@@ -485,7 +378,6 @@ async function openDraft(
     sessions,
     pageMessages: () => ({ items: [] }),
     onPrompt: (input) => prompts.push(input),
-    events: options?.events ?? (() => events.splice(0)),
   })
   page.on("request", (request) => {
     if (request.method() !== "POST") return
@@ -512,10 +404,7 @@ async function openDraft(
       return route.fulfill({ status: 500, json: { message: "Session creation failed in the fixture" }, headers })
     }
     if (typeof body.id !== "string") throw new Error("Session creation must use the client-reserved ID")
-    const session = currentSession(
-      { ...body, id: body.id, projectID, title: options?.untitled ? "" : "Created workspace session" },
-      workspace,
-    )
+    const session = currentSession({ ...body, id: body.id, projectID, title: "Created workspace session" }, workspace)
     sessions.push(session)
     return route.fulfill({ json: { data: session }, headers })
   })
@@ -547,17 +436,6 @@ async function openDraft(
       headers,
     }),
   )
-  if (options?.command) {
-    await page.route("**/api/command?**", (route) =>
-      route.fulfill({
-        json: {
-          location: { directory: new URL(route.request().url()).searchParams.get("location[directory]") ?? directory },
-          data: [{ name: "review", description: "Review changes" }],
-        },
-        headers,
-      }),
-    )
-  }
   await page.addInitScript(
     ({ directory, draftID, otherID, server }) => {
       localStorage.setItem(
@@ -583,11 +461,11 @@ async function openDraft(
   await page.getByRole("menuitem", { name: "New worktree", exact: true }).click()
   await expect(page.getByRole("button", { name: "New worktree", exact: true })).toBeVisible()
   await expect(page.locator('[data-component="composer-editor"]')).toBeEditable()
-  return { worktree, worktreeRequests, calls, creates, prompts, events }
+  return { worktree, worktreeRequests, calls, creates, prompts }
 }
 
-async function submitPending(page: Page, mock: Awaited<ReturnType<typeof openDraft>>, prompt = text) {
-  await page.locator('[data-component="composer-editor"]').fill(prompt)
+async function submitPending(page: Page, mock: Awaited<ReturnType<typeof openDraft>>) {
+  await page.locator('[data-component="composer-editor"]').fill(text)
   await expect(page.locator('[data-action="composer-submit"]')).toBeEnabled()
   await page.locator('[data-action="composer-submit"]').click()
   await expect(page).toHaveURL((url) => url.pathname.startsWith(sessionPath) && /\/ses_[^/]+$/.test(url.pathname))
@@ -598,12 +476,12 @@ async function submitPending(page: Page, mock: Awaited<ReturnType<typeof openDra
   const shimmer = preparing.getByRole("status").locator('[data-component="text-shimmer"]')
   const title = preparing.getByRole("heading", { level: 1 })
   await expect(preparing).toBeVisible()
-  await expect(title).toHaveText("Session")
+  await expect(title).toHaveText("New session")
   await expect(page.locator('[data-component="composer-editor"]')).toBeEditable()
   await expect(page.locator('[data-action="composer-submit"]')).toBeDisabled()
   await expect(preparing.locator('[data-component="user-message"]')).toHaveCount(1)
   await expect(message).toHaveCount(1)
-  await expect(message.locator('[data-slot="user-message-text"]')).toHaveText(prompt)
+  await expect(message.locator('[data-slot="user-message-text"]')).toHaveText(text)
   await expect(message).toHaveAttribute("data-timeline-part-id", /^.+:text:0$/)
   const messageID = (await message.getAttribute("data-timeline-part-id"))!.replace(/:text:0$/, "")
   await expect(shimmer).toBeVisible()

packages/app/e2e/regression/remote-tab-busy.spec.ts

@@ -1,7 +1,6 @@
-import { expect, test, type Page } from "@playwright/test"
+import { expect, test, type Page, type Route } from "@playwright/test"
 import { base64Encode } from "@opencode-ai/util/encode"
-import { createMockServerHandler } from "../utils/mock-server"
-import { installSseTransport } from "../utils/sse-transport"
+import { currentSession } from "../utils/mock-server"
 
 const serverA = `http://${process.env.PLAYWRIGHT_SERVER_HOST ?? "127.0.0.1"}:${process.env.PLAYWRIGHT_SERVER_PORT ?? "4096"}`
 const serverB = "http://127.0.0.1:4097"
@@ -9,8 +8,6 @@ const sessionA = session("ses_server_a", "C:/server-a", "Server A session")
 const sessionB = session("ses_server_b", "/home/server-b", "Server B session")
 const childB = { ...session("ses_server_b_child", sessionB.directory, "Server B subagent"), parentID: sessionB.id }
 
-test.use({ serviceWorkers: "block" })
-
 test("tab busy indicator reflects activity in the tab session family", async ({ page }, info) => {
   await mockServers(page)
   await page.addInitScript(
@@ -30,7 +27,7 @@ test("tab busy indicator reflects activity in the tab session family", async ({
   const hrefA = `/server/${base64Encode(serverA)}/session/${sessionA.id}`
   const hrefB = `/server/${base64Encode(serverB)}/session/${sessionB.id}`
   await page.goto(hrefB)
-  await expect(page.getByRole("heading", { name: sessionB.title, exact: true })).toBeVisible()
+  await expect(page.getByText(sessionB.title).first()).toBeVisible()
 
   // The parent is idle, but its tab remains active while the background child runs.
   const tabB = page.locator(`[data-titlebar-tab-slot]:has(a[href="${hrefB}"])`)
@@ -55,61 +52,65 @@ function session(id: string, directory: string, title: string) {
 }
 
 async function mockServers(page: Page) {
-  // Both servers stay connected while the client hydrates their active-session snapshots.
-  await installSseTransport(page, { server: serverA })
-  await installSseTransport(page, { server: serverB })
-  const servers = new Map(
-    [sessionA, sessionB].map(
-      (current) =>
-        [
-          current === sessionA ? serverA : serverB,
-          createMockServerHandler({
-            directory: current.directory,
-            project: {
-              id: current.projectID,
-              worktree: current.directory,
-              vcs: "git",
-              time: { created: 1, updated: 1 },
-              sandboxes: [],
-            },
-            sessions: current === sessionB ? [current, childB] : [current],
-            sessionStatus: current === sessionB ? { [childB.id]: { type: "running" } } : {},
-            provider: { all: [], connected: [], default: {} },
-            pageMessages: () => ({ items: [] }),
-          }),
-        ] as const,
-    ),
-  )
-  page.on("close", () => servers.forEach((server) => void server.dispose()))
   await page.route("**/api/**", async (route) => {
     const url = new URL(route.request().url())
-    const server = servers.get(url.origin)
-    if (!server) return route.fallback()
+    if (url.origin !== serverA && url.origin !== serverB) return route.fallback()
     const current = url.origin === serverA ? sessionA : sessionB
     const directory = url.searchParams.get("directory")
-    if (directory && directory !== current.directory)
-      return route.fulfill({
-        status: 500,
-        json: { name: "InvalidDirectory" },
-        headers: { "access-control-allow-origin": "*" },
+    if (directory && directory !== current.directory) return json(route, { name: "InvalidDirectory" }, 500)
+    if (url.pathname === "/api/event") return sse(route)
+    if (url.pathname === "/api/health") return json(route, { pid: 1 })
+    if (url.pathname === "/api/session/active")
+      return json(route, { data: url.origin === serverB ? { [childB.id]: { type: "running" } } : {} })
+    if (url.pathname === "/api/session")
+      return json(route, {
+        data: url.origin === serverB ? [currentSession(current), currentSession(childB)] : [currentSession(current)],
+        cursor: {},
       })
-    if (route.request().method() === "OPTIONS")
-      return route.fulfill({
-        status: 204,
-        headers: { "access-control-allow-origin": "*", "access-control-allow-headers": "*" },
+    if (url.pathname === `/api/session/${current.id}`) return json(route, { data: currentSession(current) })
+    if (url.pathname === `/api/session/${current.id}/message`) return json(route, { data: [], cursor: {} })
+    if (["/api/agent", "/api/provider", "/api/model", "/api/command", "/api/reference"].includes(url.pathname))
+      return json(route, { location: { directory: current.directory }, data: [] })
+    if (url.pathname === "/api/model/default")
+      return json(route, { location: { directory: current.directory }, data: null })
+    if (url.pathname === "/api/permission/request" || url.pathname === "/api/question/request")
+      return json(route, { location: { directory: current.directory }, data: [] })
+    if (url.pathname === "/api/mcp") return json(route, { location: { directory: current.directory }, data: [] })
+    if (url.pathname === "/api/mcp/resource")
+      return json(route, { location: { directory: current.directory }, data: { resources: [], templates: [] } })
+    if (url.pathname === "/api/project" || url.pathname === "/api/project/current") {
+      const project = {
+        id: current.projectID,
+        canonical: current.directory,
+        vcs: "git",
+        time: { created: 1, updated: 1 },
+        sandboxes: [],
+      }
+      return json(route, url.pathname === "/api/project" ? [project] : { id: project.id, directory: current.directory })
+    }
+    if (url.pathname === "/api/location") return json(route, { directory: current.directory })
+    if (url.pathname === "/api/vcs")
+      return json(route, {
+        location: { directory: current.directory },
+        data: { branch: "main", defaultBranch: "main" },
       })
-    const body = route.request().postDataBuffer()
-    const response = await server.handler(
-      new Request(url, {
-        method: route.request().method(),
-        headers: route.request().headers(),
-        body: body ? Uint8Array.from(body) : undefined,
-      }),
-    )
-    return route.fulfill({
-      status: response.status,
-      headers: { ...Object.fromEntries(response.headers), "access-control-allow-origin": "*" },
-      body: Buffer.from(await response.arrayBuffer()),
-    })
+    return json(route, {})
+  })
+}
+
+function json(route: Route, body: unknown, status = 200) {
+  return route.fulfill({
+    status,
+    contentType: "application/json",
+    headers: { "access-control-allow-origin": "*" },
+    body: JSON.stringify(body),
+  })
+}
+
+function sse(route: Route) {
+  return route.fulfill({
+    status: 200,
+    contentType: "text/event-stream",
+    body: 'data: {"id":"evt_connected","type":"server.connected","data":{}}\n\n',
   })
 }

packages/app/e2e/regression/review-open-file.spec.ts

@@ -92,16 +92,10 @@ test("opens and searches project files inline", async ({ page }) => {
   const contextButton = page.getByRole("button", { name: "View context usage" })
   await contextButton.click()
   await expect(panel.getByRole("tab", { name: "Context", selected: true })).toBeVisible()
-  await expect(panel.getByRole("button", { name: "Open file" }).locator("use")).toHaveAttribute(
-    "href",
-    "#opencode-v2-icon-plus",
-  )
   await panel.getByRole("button", { name: "Open file" }).click()
   const openFileTab = panel.getByRole("tab", { name: "Open file" })
   const openFileTabClose = openFileTab.locator("..").getByRole("button", { name: "Close tab" })
   await expect(openFileTab).toHaveAttribute("data-selected", "")
-  await expect(openFileTab.locator("..")).toHaveCSS("padding-inline-end", "4px")
-  await expect(openFileTab.locator("..")).toHaveCSS("gap", "8px")
   await expect(openFileTab.locator("use")).toHaveAttribute("href", "#opencode-v2-icon-file-tree")
   await expect(openFileTab.getByText("Open file", { exact: true }).locator("..")).not.toHaveClass(/italic/)
   await expect(openFileTabClose).toHaveAttribute("data-variant", "ghost-muted")
@@ -120,8 +114,6 @@ test("opens and searches project files inline", async ({ page }) => {
 
   await panel.getByRole("button", { name: "README.md" }).click()
   await expect(panel.getByRole("tab", { name: "README.md", selected: true })).toBeVisible()
-  await expect(panel.getByRole("tab", { name: "README.md" }).locator("..")).toHaveCSS("padding-inline-end", "4px")
-  await expect(panel.getByRole("tab", { name: "README.md" }).locator("..")).toHaveCSS("gap", "8px")
   await expect(sidebarToggle).toBeEnabled()
   await expect(panel.getByText("contents:README.md", { exact: true })).toBeVisible()
   await expect(sidebar).toHaveCount(0)
@@ -137,8 +129,6 @@ test("opens and searches project files inline", async ({ page }) => {
   await expect(filter).toHaveAttribute("aria-activedescendant", resultID!)
   await filter.press("Enter")
   await expect(panel.getByRole("tab", { name: "nested.ts", selected: true })).toBeVisible()
-  await expect(panel.getByRole("tab", { name: "nested.ts" }).locator("..")).toHaveCSS("padding-inline-end", "4px")
-  await expect(panel.getByRole("tab", { name: "nested.ts" }).locator("..")).toHaveCSS("gap", "8px")
   await expect(sidebarToggle).toBeEnabled()
   await expect(panel.getByText("contents:src/nested.ts", { exact: true })).toBeVisible()
   expect(searches).toContainEqual({ query: "nested", dirs: "file", limit: 200 })

packages/app/e2e/regression/review-toggle-position.spec.ts

@@ -1,189 +0,0 @@
-import { base64Encode } from "@opencode-ai/util/encode"
-import { expect, test, type Locator } from "@playwright/test"
-import { mockOpenCodeServer } from "../utils/mock-server"
-import { expectSessionTitle } from "../utils/waits"
-
-const directory = "C:/OpenCode/ReviewTogglePosition"
-const sessionID = "ses_review_toggle_position"
-const server = `http://${process.env.PLAYWRIGHT_SERVER_HOST ?? "127.0.0.1"}:${process.env.PLAYWRIGHT_SERVER_PORT ?? "4096"}`
-
-test.beforeEach(async ({ page }) => {
-  await mockOpenCodeServer(page, {
-    directory,
-    project: {
-      id: "proj_review_toggle_position",
-      worktree: directory,
-      vcs: "git",
-      name: "review-toggle-position",
-      time: { created: 1700000000000, updated: 1700000000000 },
-      sandboxes: [],
-    },
-    provider: { all: [], connected: [], default: {} },
-    sessions: [
-      {
-        id: sessionID,
-        slug: "review-toggle-position",
-        projectID: "proj_review_toggle_position",
-        directory,
-        title: "Review toggle position",
-        version: "dev",
-        time: { created: 1700000000000, updated: 1700000000000 },
-      },
-    ],
-    pageMessages: () => ({ items: [] }),
-  })
-})
-
-for (const width of [1000, 1440]) {
-  for (const direction of ["ltr", "rtl"] as const) {
-    test(`keeps the review toggle at the outer header edge (${width}px, ${direction})`, async ({ page }) => {
-      await page.setViewportSize({ width, height: 900 })
-      await page.goto(`/server/${base64Encode(server)}/session/${sessionID}`)
-      await expectSessionTitle(page, "Review toggle position")
-      await page.locator("html").evaluate((element, dir) => element.setAttribute("dir", dir), direction)
-
-      const toggle = page.getByRole("button", { name: "Toggle review", exact: true })
-      const header = page.locator("[data-session-title]")
-      const panel = page.locator("#review-panel")
-      await expect(toggle).toHaveAttribute("aria-expanded", "false")
-      const closed = await toggle.boundingBox()
-      if (!closed) throw new Error("Review toggle bounds are unavailable")
-      const headerBox = await header.boundingBox()
-      if (!headerBox) throw new Error("Session header bounds are unavailable")
-      expect(closed.y).toBeGreaterThanOrEqual(headerBox.y)
-      expect(closed.y + closed.height).toBeLessThanOrEqual(headerBox.y + headerBox.height)
-
-      await toggle.click()
-      await expect(toggle).toHaveAttribute("aria-expanded", "true")
-      await expect(panel).toHaveAttribute("aria-hidden", "false")
-      await expect(toggle).toHaveCount(1)
-      await expect.poll(() => toggle.boundingBox()).toEqual(closed)
-      await expect
-        .poll(async () => {
-          const box = await panel.boundingBox()
-          if (!box) return false
-          return (
-            closed.x >= box.x &&
-            closed.x + closed.width <= box.x + box.width &&
-            closed.y >= box.y &&
-            closed.y + closed.height <= box.y + 52
-          )
-        })
-        .toBe(true)
-
-      await expect
-        .poll(async () => {
-          const box = await panel.locator('[data-slot="session-side-panel-actions"]').boundingBox()
-          return box ? box.y + box.height / 2 : undefined
-        })
-        .toBe(closed.y + closed.height / 2)
-
-      await toggle.press("Enter")
-      await expect(toggle).toHaveAttribute("aria-expanded", "false")
-      await expect(toggle).toBeFocused()
-      await expect(toggle).toHaveCount(1)
-      await expect.poll(() => toggle.boundingBox()).toEqual(closed)
-    })
-
-    test(`keeps terminal controls clear of the review toggle (${width}px, ${direction})`, async ({ page }) => {
-      await page.setViewportSize({ width, height: 900 })
-      const ptys: { id: string; title: string }[] = []
-      const removed: string[] = []
-      await page.route("**/api/pty**", async (route) => {
-        const path = new URL(route.request().url()).pathname
-        const location = { directory, project: { id: "proj_review_toggle_position", directory } }
-        if (route.request().method() === "DELETE") {
-          removed.push(path.split("/").at(-1)!)
-          return route.fulfill({ status: 204 })
-        }
-        if (path.endsWith("/connect-token")) {
-          return route.fulfill({ json: { location, data: { ticket: "e2e-ticket", expires_in: 60 } } })
-        }
-        if (path === "/api/pty" && route.request().method() === "POST") {
-          const pty = { id: `pty_review_${ptys.length + 1}`, title: `Terminal ${ptys.length + 1}` }
-          ptys.push(pty)
-          return route.fulfill({ json: { location, data: pty } })
-        }
-        return route.fulfill({ json: { location, data: ptys.find((pty) => path.endsWith(pty.id)) ?? ptys } })
-      })
-      await page.routeWebSocket(/\/api\/pty\/pty_review_\d+\/connect/, () => undefined)
-      await page.goto(`/server/${base64Encode(server)}/session/${sessionID}`)
-      await expectSessionTitle(page, "Review toggle position")
-      await page.locator("html").evaluate((element, dir) => element.setAttribute("dir", dir), direction)
-
-      const toggle = page.getByRole("button", { name: "Toggle review", exact: true })
-      await expect(toggle).toHaveAttribute("aria-expanded", "false")
-      await page.keyboard.press("Control+Backquote")
-      const terminal = page.getByRole("region", { name: "Terminal", exact: true })
-      await expect(terminal.getByRole("tab", { name: "Terminal 1", exact: true })).toHaveAttribute(
-        "aria-selected",
-        "true",
-      )
-      for (const number of [2, 3, 4]) {
-        await terminal.getByRole("button", { name: "New terminal", exact: true }).click()
-        await expect(terminal.getByRole("tab", { name: `Terminal ${number}`, exact: true })).toHaveAttribute(
-          "aria-selected",
-          "true",
-        )
-      }
-
-      await expect
-        .poll(async () => {
-          const tabs = await terminal.getByRole("tablist").boundingBox()
-          const button = await toggle.boundingBox()
-          if (!tabs || !button) return false
-          return direction === "rtl" ? tabs.x >= button.x + button.width : tabs.x + tabs.width <= button.x
-        })
-        .toBe(true)
-      await expectTerminalControlsAligned(terminal, toggle)
-      const fourth = terminal.locator('[data-slot="tabs-trigger-wrapper"][data-value="pty_review_4"]')
-      await fourth.getByRole("button", { name: "Close terminal", exact: true }).click()
-      await expect(terminal.getByRole("tab")).toHaveText(["Terminal 1", "Terminal 2", "Terminal 3"])
-      expect(removed).toEqual(["pty_review_4"])
-      await expect(toggle).toHaveAttribute("aria-expanded", "false")
-
-      await terminal.getByRole("button", { name: "New terminal", exact: true }).click()
-      await expect(terminal.getByRole("tab", { name: "Terminal 5", exact: true })).toHaveAttribute(
-        "aria-selected",
-        "true",
-      )
-      await expect(toggle).toHaveAttribute("aria-expanded", "false")
-      const position = await toggle.boundingBox()
-      await toggle.click()
-      await expect(toggle).toHaveAttribute("aria-expanded", "true")
-      await expect(page.locator("#review-panel")).toHaveAttribute("aria-hidden", "false")
-      await expect.poll(() => toggle.boundingBox()).toEqual(position)
-      await expect
-        .poll(async () => {
-          const actions = await page.locator('[data-slot="session-side-panel-actions"]').boundingBox()
-          const button = await toggle.boundingBox()
-          if (!actions || !button) return undefined
-          return actions.y + actions.height / 2 - (button.y + button.height / 2)
-        })
-        .toBe(0)
-      await toggle.press("Enter")
-      await expect(toggle).toHaveAttribute("aria-expanded", "false")
-      await expect(toggle).toBeFocused()
-      await expect.poll(() => toggle.boundingBox()).toEqual(position)
-      await expectTerminalControlsAligned(terminal, toggle)
-    })
-  }
-}
-
-async function expectTerminalControlsAligned(terminal: Locator, toggle: Locator) {
-  await expect
-    .poll(async () => {
-      const centers = await Promise.all(
-        [terminal.getByRole("button", { name: "New terminal", exact: true }), toggle].map((button) =>
-          button.locator("svg").evaluate((element) => {
-            const svg = element as SVGSVGElement
-            const path = svg.getBBox()
-            return new DOMPoint(path.x + path.width / 2, path.y + path.height / 2).matrixTransform(svg.getScreenCTM()!)
-              .y
-          }),
-        ),
-      )
-      return centers[0]! - centers[1]!
-    })
-    .toBeCloseTo(0, 1)
-}

packages/app/e2e/regression/session-header-controls.spec.ts

@@ -23,8 +23,7 @@ for (const direction of ["ltr", "rtl"] as const) {
     await page.goto(stressSessionHref(fixture.targetID))
     const header = page.locator("[data-session-title]")
     const more = header.getByRole("button", { name: "More options", exact: true })
-    const project = header.getByRole("button", { name: fixture.project.name, exact: true })
-    const review = page.getByRole("button", { name: "Toggle review", exact: true })
+    const review = header.getByRole("button", { name: "Toggle review", exact: true })
     const details = header.getByRole("button", { name: "Session details", exact: true })
     await expect(header.getByRole("heading")).toHaveText(fixture.expected.targetTitle)
     await page.evaluate((direction) => document.documentElement.setAttribute("dir", direction), direction)
@@ -32,40 +31,22 @@ for (const direction of ["ltr", "rtl"] as const) {
     await expect(details).toBeVisible()
     const status = page.locator('[data-slot="titlebar-v2"]').getByRole("button", { name: "Status" })
     await expect(status).toBeVisible()
-    const titleBounds = await header.getByRole("heading").boundingBox()
-    expect(titleBounds).not.toBeNull()
-    for (const editing of [false, true]) {
-      if (editing) {
-        await header.getByRole("heading").click()
-        await expect(header.getByRole("textbox")).toHaveValue(fixture.expected.targetTitle)
-        await expect(header.getByRole("textbox")).toBeFocused()
-      }
-      await expect(header.locator('[data-slot="session-title-child"]')).toHaveCSS("padding-left", "4px")
-      await expect(header.locator('[data-slot="session-title-child"]')).toHaveCSS("padding-right", "4px")
-      await expect
-        .poll(async () => {
-          const boxes = await Promise.all(
-            [project, header.locator('[data-slot="session-title-child"]'), more, review, details].map((control) =>
-              control.boundingBox(),
-            ),
-          )
-          const [icon, title, menu, sidebar, summary] = boxes
-          if (!icon || !title || !menu || !sidebar || !summary || !titleBounds) return false
-          if (Math.abs(title.y - titleBounds.y) > 0.5 || Math.abs(title.height - titleBounds.height) > 0.5) return false
-          return direction === "ltr"
-            ? Math.abs(title.x - icon.x - icon.width - 2) <= 0.5 &&
-                Math.abs(menu.x - title.x - title.width - 2) <= 0.5 &&
-                menu.x + menu.width <= summary.x &&
-                summary.x + summary.width <= sidebar.x
-            : Math.abs(icon.x - title.x - title.width - 2) <= 0.5 &&
-                Math.abs(title.x - menu.x - menu.width - 2) <= 0.5 &&
-                sidebar.x + sidebar.width <= summary.x &&
-                summary.x + summary.width <= menu.x
-        })
-        .toBe(true)
-    }
-    await header.getByRole("textbox").press("Escape")
-    await expect(header.getByRole("heading")).toHaveText(fixture.expected.targetTitle)
+    await expect
+      .poll(async () => {
+        const boxes = await Promise.all(
+          [header.getByRole("heading"), more, review, details].map((button) => button.boundingBox()),
+        )
+        const [title, menu, sidebar, summary] = boxes
+        if (!title || !menu || !sidebar || !summary) return false
+        return direction === "ltr"
+          ? Math.abs(title.x + title.width - menu.x) <= 1 &&
+              menu.x + menu.width <= summary.x &&
+              summary.x + summary.width <= sidebar.x
+          : Math.abs(menu.x + menu.width - title.x) <= 1 &&
+              sidebar.x + sidebar.width <= summary.x &&
+              summary.x + summary.width <= menu.x
+      })
+      .toBe(true)
 
     await review.click()
     await expect(review).toHaveAttribute("aria-expanded", "true")
@@ -74,52 +55,6 @@ for (const direction of ["ltr", "rtl"] as const) {
     await expect(review).toHaveAttribute("aria-expanded", "false")
 
     await more.click()
-    const options = page.getByRole("menu")
-    await expect(options.getByRole("menuitem")).toHaveText(["Rename", "Export…", "Delete…"])
-    if (direction === "ltr") {
-      await expect
-        .poll(async () => {
-          const [button, menu] = await Promise.all([
-            header.getByRole("button", { name: "More options", exact: true, includeHidden: true }).boundingBox(),
-            options.boundingBox(),
-          ])
-          return button && menu ? Math.abs(button.x - menu.x) : Infinity
-        })
-        .toBeLessThanOrEqual(1)
-    }
-    await expect
-      .poll(() =>
-        options.evaluate((element) => {
-          const menu = element.getBoundingClientRect()
-          const rtl = getComputedStyle(element).direction === "rtl"
-          return Math.min(
-            ...Array.from(element.querySelectorAll('[data-slot="menu-v2-item-content"]'), (label) => {
-              const range = document.createRange()
-              range.selectNodeContents(label)
-              const text = range.getBoundingClientRect()
-              return rtl ? text.left - menu.left : menu.right - text.right
-            }),
-          )
-        }),
-      )
-      .toBeCloseTo(32, 0)
-    await expect
-      .poll(() =>
-        options.evaluate((element) => {
-          const menu = element.getBoundingClientRect()
-          const divider = element.querySelector('[data-slot="menu-v2-separator"]')?.getBoundingClientRect()
-          const rows = Array.from(element.querySelectorAll('[role="menuitem"]'), (row) => row.getBoundingClientRect())
-          return (
-            !!divider &&
-            Math.abs(divider.left - menu.left) <= 0.5 &&
-            Math.abs(divider.right - menu.right) <= 0.5 &&
-            rows.every(
-              (row) => Math.abs(row.left - menu.left - 2) <= 0.5 && Math.abs(menu.right - row.right - 2) <= 0.5,
-            )
-          )
-        }),
-      )
-      .toBe(true)
     await expect(page.getByRole("menuitem", { name: "Server status", exact: true })).toHaveCount(0)
     await page.keyboard.press("Escape")
     await status.click()

packages/app/e2e/regression/session-project-menu.spec.ts

@@ -1,327 +0,0 @@
-import { expect, test } from "@playwright/test"
-import { dict } from "../../src/runtime/i18n/ar"
-import en from "../../src/runtime/i18n/en"
-import { fixture, pageMessages } from "../performance/timeline/session-timeline-stress.fixture"
-import { installStressSessionTabs, stressSessionHref } from "../performance/timeline/timeline-test-helpers"
-import { mockOpenCodeServer } from "../utils/mock-server"
-
-test.use({ serviceWorkers: "block" })
-
-for (const direction of ["ltr", "rtl"] as const) {
-  for (const workspace of [false, true]) {
-    test(`session project menu for ${workspace ? "worktree" : "local"} in ${direction}`, async ({ page }) => {
-      const copy = direction === "rtl" ? dict : en
-      const directory = workspace
-        ? "C:/OpenCode/Worktrees/مشروع-42/long-folder-name-for-checking-wrapped-worktree-paths/another-long-folder-name-to-exercise-the-full-path-tooltip"
-        : fixture.directory
-      const project = {
-        ...fixture.project,
-        name: workspace
-          ? "مشروع Timeline 42 with a long project name that needs truncation and enough additional text to wrap inside the tooltip"
-          : "Timeline project",
-        sandboxes: workspace ? [directory] : [],
-        icon: {
-          url: `data:image/svg+xml,${encodeURIComponent('<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16"><circle cx="8" cy="8" r="7" fill="blue"/></svg>')}`,
-        },
-      }
-      await mockOpenCodeServer(page, {
-        directory,
-        project,
-        sessions: fixture.sessions.map((session) => ({ ...session, directory })),
-        provider: fixture.provider,
-        pageMessages,
-      })
-      await installStressSessionTabs(page)
-      await page.addInitScript((direction) => {
-        localStorage.setItem(
-          "opencode.global.dat:language",
-          JSON.stringify({ locale: direction === "rtl" ? "ar" : "en" }),
-        )
-        const settings = JSON.parse(localStorage.getItem("settings.v3") ?? "{}")
-        localStorage.setItem(
-          "settings.v3",
-          JSON.stringify({ ...settings, general: { ...settings.general, showProjectIcon: false } }),
-        )
-      }, direction)
-      await page.setViewportSize({ width: workspace ? 900 : 1440, height: 900 })
-      await page.goto(stressSessionHref(fixture.targetID))
-      const header = page.locator("[data-session-title]")
-      await expect(header.getByRole("heading")).toHaveText(fixture.expected.targetTitle)
-      await expect(page.locator("html")).toHaveAttribute("dir", direction)
-
-      const trigger = header.getByRole("button", { name: project.name, exact: true })
-      await expect(trigger).toBeEnabled()
-      await expect(trigger.locator("use")).toHaveAttribute(
-        "href",
-        `#opencode-v2-icon-${workspace ? "workspace-isolated" : "monitor"}`,
-      )
-      const background = await trigger.evaluate((element) => getComputedStyle(element).backgroundColor)
-      await trigger.hover()
-      await expect(trigger).not.toHaveCSS("background-color", background)
-      await expect(page.getByRole("tooltip")).toHaveText(project.name)
-      await trigger.click()
-
-      const menu = page.getByRole("menu", { name: project.name, exact: true })
-      const settings = menu.getByRole("menuitem", { name: "Edit project", exact: true })
-      const projectItem = menu.getByRole("menuitem", { name: project.name, exact: true })
-      await expect(trigger).toHaveAttribute("aria-expanded", "true")
-      await expect(page.getByRole("tooltip")).toBeHidden()
-      await expect(menu.getByText(project.name, { exact: true })).toBeVisible()
-      await expect(menu.locator('[data-slot="project-avatar-image"]')).toHaveAttribute("src", project.icon.url)
-      await expect(menu.getByText(directory, { exact: true })).toBeVisible()
-      await expect(menu.getByText(directory, { exact: true })).toHaveAttribute("dir", "ltr")
-      await expect(menu.locator('use[href="#opencode-v2-icon-folder"]')).toHaveCount(1)
-      await expect(menu).toHaveCSS("direction", direction)
-      await expect(menu.getByRole("menuitem")).toHaveText([project.name, directory, "Edit project"])
-      await expect(menu.getByRole("menuitem", { name: directory, exact: true })).toBeDisabled()
-      await expect(settings).toBeEnabled()
-      await expect
-        .poll(() => menu.evaluate((element) => element.getBoundingClientRect().width))
-        .toBeLessThanOrEqual(320)
-      for (const text of [project.name, directory]) {
-        const label = menu.getByText(text, { exact: true })
-        await expect(label).toHaveCSS("text-overflow", "ellipsis")
-        await expect(label).toHaveCSS("white-space", "nowrap")
-        if (workspace) {
-          await expect.poll(() => label.evaluate((element) => element.scrollWidth > element.clientWidth)).toBe(true)
-        }
-      }
-      await expect.poll(() => menu.evaluate((element) => element.scrollWidth <= element.clientWidth)).toBe(true)
-      const icons = menu.locator(
-        '[data-component="project-avatar-v2"], [data-slot="icon-svg"]:not([data-slot="session-project-open-icon"] *)',
-      )
-      await expect(icons).toHaveCount(3)
-      await expect
-        .poll(async () => {
-          const [button, centers] = await Promise.all([
-            trigger.boundingBox(),
-            icons.evaluateAll((elements) =>
-              elements.map((element) => {
-                const box = element.getBoundingClientRect()
-                return box.x + box.width / 2
-              }),
-            ),
-          ])
-          return !!button && centers.every((center) => Math.abs(center - button.x - button.width / 2) <= 1)
-        })
-        .toBe(true)
-
-      if (!workspace) await page.clock.install()
-      for (const text of [project.name, directory]) {
-        const label = menu.getByText(text, { exact: true })
-        const item = menu.getByRole("menuitem", { name: text, exact: true })
-        const anchor = item.locator("..")
-        const openIcon = item.locator('[data-slot="session-project-open-icon"]')
-        const content = item.locator(".session-project-link-content")
-        const width = await label.evaluate((element) => element.getBoundingClientRect().width)
-        await expect(openIcon).toHaveCount(text === directory ? 1 : 0)
-        await anchor.hover()
-        await expect(content).toHaveCSS("mask-image", "none")
-        await expect.poll(() => label.evaluate((element) => element.getBoundingClientRect().width)).toBe(width)
-        if (text === directory) {
-          await expect(openIcon).toHaveCSS("opacity", "0")
-          await expect(openIcon.locator("use")).toHaveAttribute("href", "#opencode-v2-icon-arrow-up-right")
-          await expect
-            .poll(() => openIcon.locator("svg").evaluate((element: SVGSVGElement) => element.getBBox().width))
-            .toBeGreaterThan(0)
-          await expect
-            .poll(async () => {
-              const [row, icon] = await Promise.all([item.boundingBox(), openIcon.boundingBox()])
-              if (!row || !icon) return false
-              return (
-                Math.abs(row.y + row.height / 2 - icon.y - icon.height / 2) <= 0.5 &&
-                Math.abs((direction === "rtl" ? icon.x - row.x : row.x + row.width - icon.x - icon.width) - 12) <= 0.5
-              )
-            })
-            .toBe(true)
-        }
-        await expect(label).toHaveCSS("cursor", "default")
-        await expect(anchor).toHaveCSS("cursor", "default")
-        const tooltip = page.getByRole("tooltip")
-        if (workspace) {
-          await expect(tooltip).toHaveText(text)
-          await expect(tooltip).toHaveCSS("white-space", "normal")
-          await expect
-            .poll(() => tooltip.evaluate((element) => element.getBoundingClientRect().width))
-            .toBeLessThanOrEqual(480)
-          await expect
-            .poll(() =>
-              tooltip
-                .getByText(text, { exact: true })
-                .evaluate(
-                  (element) =>
-                    element.getBoundingClientRect().height > Number.parseFloat(getComputedStyle(element).lineHeight),
-                ),
-            )
-            .toBe(true)
-          await expect
-            .poll(async () => {
-              const [row, tip] = await Promise.all([anchor.boundingBox(), tooltip.boundingBox()])
-              return !!row && !!tip && Math.abs(row.y - tip.y - tip.height - 2) <= 1
-            })
-            .toBe(true)
-        }
-        if (!workspace) {
-          await page.clock.runFor(500)
-          await expect(tooltip).toBeHidden()
-        }
-        await settings.hover()
-        await expect(tooltip).toBeHidden()
-        if (text === directory) await expect(openIcon).toHaveCSS("opacity", "0")
-        await expect(content).toHaveCSS("mask-image", "none")
-      }
-
-      await page.keyboard.press("Escape")
-      await expect(menu).toBeHidden()
-      await expect(trigger).toBeFocused()
-      await trigger.press("ArrowDown")
-      await expect(projectItem).toBeFocused()
-      await page.keyboard.press("ArrowDown")
-      const pathItem = menu.getByRole("menuitem", { name: directory, exact: true })
-      await expect(pathItem).toBeFocused()
-      if (workspace) await expect(page.getByRole("tooltip")).toHaveText(directory)
-      await page.keyboard.press("Enter")
-      await expect(menu).toBeVisible()
-      await expect(pathItem).toBeFocused()
-      await page.keyboard.press("Space")
-      await expect(menu).toBeVisible()
-      await expect(pathItem).toBeFocused()
-      await page.keyboard.press("Escape")
-      await expect(menu).toBeHidden()
-      await expect(trigger).toBeFocused()
-      await trigger.press("ArrowDown")
-      await expect(projectItem).toBeFocused()
-      await page.keyboard.press("ArrowDown")
-      await expect(pathItem).toBeFocused()
-      if (workspace) await expect(page.getByRole("tooltip")).toHaveText(directory)
-      await page.keyboard.press("ArrowDown")
-      await expect(settings).toBeFocused()
-      await expect(page.getByRole("tooltip")).toBeHidden()
-      await page.keyboard.press("Enter")
-      const dialog = page.getByRole("dialog")
-      await expect(dialog.getByRole("heading", { name: copy["dialog.project.edit.title"], exact: true })).toBeVisible()
-      await expect(dialog.getByRole("textbox", { name: copy["dialog.project.edit.name"], exact: true })).toHaveValue(
-        project.name,
-      )
-      await expect(menu).toBeHidden()
-      await dialog.getByRole("button", { name: copy["common.cancel"], exact: true }).click()
-      await expect(dialog).toBeHidden()
-      await expect(header.getByRole("heading")).toHaveText(fixture.expected.targetTitle)
-
-      await page.setViewportSize({ width: 1440, height: 900 })
-      for (const selected of [false, true]) {
-        if (selected) {
-          await page.locator(`[data-titlebar-tab-link][href="${stressSessionHref(fixture.targetID)}"]`).click()
-          await expect(header.getByRole("heading")).toHaveText(fixture.expected.targetTitle)
-        }
-        await trigger.click()
-        await expect(projectItem).toBeEnabled()
-        const background = await projectItem.evaluate((element) => getComputedStyle(element).backgroundColor)
-        await projectItem.hover()
-        await expect(projectItem).not.toHaveCSS("background-color", background)
-        await projectItem.click()
-        await expect(page).toHaveURL(new URL("/", page.url()).href)
-        await expect(menu).toBeHidden()
-        const projectRow = page.locator('[data-component="home-project-row"]').filter({ hasText: project.name })
-        await expect(projectRow).toBeVisible()
-        await expect(projectRow).toHaveAttribute("data-selected", "")
-        await expect(
-          page.locator(`[data-component="home-session-row-container"][data-session-id="${fixture.targetID}"]`),
-        ).toBeVisible()
-      }
-    })
-  }
-}
-
-for (const state of ["closed", "unopened"] as const) {
-  test(`session project menu restores ${state} projects before and after messages load`, async ({ page }) => {
-    const directory = "C:/OpenCode/Worktrees/project-menu-recovery"
-    const messages = Promise.withResolvers<void>()
-    await mockOpenCodeServer(page, {
-      directory,
-      project: { ...fixture.project, sandboxes: [directory] },
-      sessions: fixture.sessions.map((session) => ({ ...session, directory })),
-      provider: fixture.provider,
-      pageMessages,
-      beforeMessagesResponse: (input) => (input.sessionID === fixture.targetID ? messages.promise : Promise.resolve()),
-    })
-    await page.setViewportSize({ width: 1440, height: 900 })
-    if (state === "closed") {
-      await installStressSessionTabs(page)
-      await page.goto("/")
-      const projectRow = page.locator('[data-component="home-project-row"]').filter({ hasText: fixture.project.name })
-      await expect(projectRow).toBeEnabled()
-      await projectRow.locator("..").getByRole("button", { name: "More options", exact: true }).click()
-      await page.getByRole("menuitem", { name: "Close", exact: true }).click()
-      await expect(projectRow).toHaveCount(0)
-      await page.locator(`[data-titlebar-tab-link][href="${stressSessionHref(fixture.targetID)}"]`).click()
-    }
-    if (state === "unopened") await page.goto(stressSessionHref(fixture.targetID))
-
-    const header = page.locator("[data-session-title]")
-    const trigger = header.getByRole("button", { name: fixture.project.name, exact: true })
-    const menu = page.getByRole("menu", { name: fixture.project.name, exact: true })
-    await expect(header.getByRole("heading")).toHaveText(fixture.expected.targetTitle)
-    for (const loaded of [false, true]) {
-      if (loaded) {
-        messages.resolve()
-        await expect(header.getByRole("button", { name: "More options", exact: true })).toBeVisible()
-      }
-      await expect(trigger.locator("use")).toHaveAttribute("href", "#opencode-v2-icon-workspace-isolated")
-      await trigger.click()
-      await expect(menu.getByRole("menuitem", { name: fixture.project.name, exact: true })).toBeEnabled()
-      await expect(menu.getByRole("menuitem", { name: directory, exact: true })).toBeDisabled()
-      await menu.getByRole("menuitem", { name: "Edit project", exact: true }).click()
-      const dialog = page.getByRole("dialog")
-      await expect(dialog.getByRole("textbox", { name: en["dialog.project.edit.name"], exact: true })).toHaveValue(
-        fixture.project.name,
-      )
-      await dialog.getByRole("button", { name: en["common.cancel"], exact: true }).click()
-      await expect(dialog).toBeHidden()
-    }
-    await trigger.click()
-    await menu.getByRole("menuitem", { name: fixture.project.name, exact: true }).click()
-    await expect(page).toHaveURL(new URL("/", page.url()).href)
-    const projectRow = page.locator('[data-component="home-project-row"]').filter({ hasText: fixture.project.name })
-    await expect(projectRow).toBeVisible()
-    await expect(projectRow).toHaveAttribute("data-selected", "")
-    await expect(
-      page.locator(`[data-component="home-session-row-container"][data-session-id="${fixture.targetID}"]`),
-    ).toBeVisible()
-  })
-}
-
-test("path arrow has a glyph when the page has an older icon sprite", async ({ page }) => {
-  await mockOpenCodeServer(page, {
-    directory: fixture.directory,
-    project: fixture.project,
-    sessions: fixture.sessions,
-    provider: fixture.provider,
-    pageMessages,
-  })
-  await installStressSessionTabs(page)
-  await page.route(
-    (url) => url.pathname === stressSessionHref(fixture.targetID),
-    async (route) => {
-      const response = await route.fetch()
-      await route.fulfill({
-        response,
-        body: (await response.text()).replace(
-          '<div id="root"',
-          '<svg id="opencode-v2-icon-sprite" width="0" height="0" aria-hidden="true"><symbol id="opencode-v2-icon-monitor" viewBox="0 0 16 16"><path d="M1 1h14v14H1z"/></symbol></svg><div id="root"',
-        ),
-      })
-    },
-  )
-  await page.goto(stressSessionHref(fixture.targetID))
-  const header = page.locator("[data-session-title]")
-  await expect(header.getByRole("heading")).toHaveText(fixture.expected.targetTitle)
-  await header.getByRole("button", { name: fixture.project.name, exact: true }).click()
-  const path = page.getByRole("menu").getByRole("menuitem", { name: fixture.directory, exact: true })
-  const arrow = path.locator('[data-slot="session-project-open-icon"]')
-  await expect(arrow).toHaveCount(1)
-  await expect
-    .poll(() => arrow.locator("svg").evaluate((element: SVGSVGElement) => element.getBBox().width))
-    .toBeGreaterThan(0)
-  await expect(page.locator("#opencode-v2-icon-sprite")).toHaveCount(1)
-})

packages/app/e2e/regression/session-timeline-notices.spec.ts

@@ -78,7 +78,7 @@ test("renders current protocol notices in CLI order", async ({ page }) => {
 
   const notices = page.locator('[data-slot="session-timeline-notice"]')
   await expect(notices).toHaveCount(4)
-  await expect(notices.nth(0)).toHaveText(/^Agent changed\s*Explore$/)
+  await expect(notices.nth(0)).toContainText("Agent · explore")
   await expect(notices.nth(1)).toContainText("explore finished · Search code")
   await expect(notices.nth(2)).toContainText("Continuing after restart")
   await expect(notices.nth(3)).toContainText("Skill · Review")
@@ -182,15 +182,20 @@ test("moves blocking work to the background with Ctrl+B", async ({ page }) => {
   await expect(card).not.toContainText("(background)")
   await expect(page.getByText("Called `subagent`", { exact: false })).toHaveCount(0)
   await expect(page.locator('[data-component="background-tool-control"]')).toHaveCount(0)
-  const hint = page.getByRole("button", { name: /move running work to the background/i })
+  const hint = page.locator('[data-component="session-background-hint"]')
+  const hintPrefix = hint.locator('[data-slot="session-background-hint-prefix"]')
   await expect(hint).toBeVisible()
   await expect(page.locator('[data-timeline-row="Thinking"]')).toHaveCount(0)
   await expect
     .poll(async () => {
-      const [cardBox, hintBox] = await Promise.all([card.boundingBox(), hint.boundingBox()])
-      if (!cardBox || !hintBox) return undefined
+      const [cardBox, hintBox, prefixBox] = await Promise.all([
+        card.boundingBox(),
+        hint.boundingBox(),
+        hintPrefix.boundingBox(),
+      ])
+      if (!cardBox || !hintBox || !prefixBox) return undefined
       return {
-        aligned: Math.abs(cardBox.x - hintBox.x) < 2,
+        aligned: Math.abs(cardBox.x - prefixBox.x) < 2,
         ordered: cardBox.y < hintBox.y,
       }
     })
@@ -215,10 +220,10 @@ test("navigates from a running subagent card and hides background controls in th
     sessionStatus: { [sessionID]: { type: "busy" }, [childID]: { type: "busy" } },
   })
 
-  await expect(page.getByRole("button", { name: /move running work to the background/i })).toBeVisible()
+  await expect(page.getByText(/move running work to the background/i)).toBeVisible()
   await page.locator('[data-component="task-tool-card"]').click()
   await expect(page).toHaveURL(new RegExp(`/session/${childID}$`))
-  await expect(page.getByRole("button", { name: /move running work to the background/i })).toHaveCount(0)
+  await expect(page.getByText(/move running work to the background/i)).toHaveCount(0)
 })
 
 for (const name of ["shell", "subagent"] as const) {
@@ -262,7 +267,7 @@ for (const name of ["shell", "subagent"] as const) {
     const group = page.locator('[data-timeline-part-ids="call_read,call_running"]')
     await expect(group).toBeVisible()
     await expect(group.locator('[data-slot="collapsible-trigger"]')).toHaveAttribute("aria-expanded", "false")
-    await expect(page.getByRole("button", { name: /move running work to the background/i })).toBeVisible()
+    await expect(page.locator('[data-component="session-background-hint"]')).toBeVisible()
     const request = page.waitForRequest(
       (request) =>
         request.method() === "POST" && new URL(request.url()).pathname === `/api/session/${sessionID}/background`,
@@ -281,9 +286,9 @@ test("shows a badge for active background work", async ({ page }) => {
   })
 
   await page.getByRole("button", { name: "Session details" }).click()
-  const summary = page.getByRole("button", { name: "1 background task running", exact: true })
+  const summary = page.getByRole("button", { name: "1 item running in background" })
   await expect(summary).toContainText("1")
-  await expect(summary).toContainText("1 background task running")
+  await expect(summary).toContainText("Running work in background")
   await summary.click()
   await expect(
     page.locator('[data-component="session-background-list"]').getByText("Agent", { exact: true }),
@@ -382,7 +387,7 @@ test("separates blocking and already-backgrounded work into two rows", async ({
     },
   })
   const backgroundCard = page.locator('[data-timeline-part-id="call_backgrounded"]')
-  await expect(page.getByRole("button", { name: /move running work to the background/i })).toBeVisible()
+  await expect(page.getByText(/move running work to the background/i)).toBeVisible()
   const used = page
     .locator('[data-timeline-part-ids="call_backgrounded,call_shell_backgrounded,call_blocking"]')
     .locator(':scope > [data-component="collapsible"] > [data-slot="collapsible-trigger"]')
@@ -391,7 +396,7 @@ test("separates blocking and already-backgrounded work into two rows", async ({
   await used.click()
   await expect(used).toHaveAttribute("aria-expanded", "true")
   await page.getByRole("button", { name: "Session details" }).click()
-  const summary = page.getByRole("button", { name: "2 background tasks running", exact: true })
+  const summary = page.getByRole("button", { name: "2 items running in background" })
   await expect(summary).toContainText("2")
   await summary.click()
   const list = page.locator('[data-component="session-background-list"]')

packages/app/e2e/regression/session-timeline-reducer-projection.spec.ts

@@ -173,7 +173,7 @@ test("keeps failed search calls and their error cards inside the collapsed stack
   await expect(glob.locator('[data-component="tool-error-card-icon"]')).toBeVisible()
   await expect(glob.locator('[data-component="tool-error-card-icon"] use')).toHaveAttribute(
     "href",
-    "#opencode-v2-icon-outline-hexagonal-warning",
+    "#opencode-v2-icon-circle-exclamation",
   )
   await expect
     .poll(() =>

packages/app/e2e/regression/session-timeline-working.spec.ts

@@ -134,7 +134,7 @@ for (const name of ["read", "shell", "subagent"] as const) {
     await expect(trigger).toHaveAttribute("aria-expanded", "false")
     await expect(working).toBeInViewport()
     if (name !== "read") {
-      const hint = page.getByRole("button", { name: /move running work to the background/i })
+      const hint = page.locator('[data-component="session-background-hint"]')
       await expect(hint).toBeInViewport()
       await expect(page.locator('[data-component="session-background-hint-row"]')).toHaveCSS("height", "24px")
       await page.screenshot({ path: testInfo.outputPath(`working-grouped-${name}.png`) })

packages/app/e2e/regression/settings-loading.spec.ts

@@ -27,12 +27,6 @@ test.beforeEach(async ({ page }) => {
     })),
     pageMessages: () => ({ items: [] }),
   })
-  await page.addInitScript((directory) => {
-    localStorage.setItem(
-      "opencode.global.dat:server",
-      JSON.stringify({ projects: { local: [{ worktree: directory, expanded: true }] } }),
-    )
-  }, directory)
   await page.goto("/")
   await page.getByRole("button", { name: "Settings", exact: true }).click()
   await expect(page.getByTestId("settings-screen").getByRole("tab", { name: "Preferences" })).toBeVisible()
@@ -56,34 +50,6 @@ test("settings has its own route and returns through app history", async ({ page
   await expect(home).toHaveAttribute("aria-pressed", "true")
 })
 
-test("new session shortcut leaves settings and opens a new session screen", async ({ page }) => {
-  const settings = page.getByTestId("settings-screen")
-  await expect(settings).toBeFocused()
-  await page.keyboard.press("Control+t")
-
-  await expect(page).toHaveURL(/\/new-session\?draftId=.+$/)
-  await expect(settings).toBeHidden()
-  await expect(page.locator('[data-component="composer-editor"]')).toBeEditable()
-  await expect(page.locator('[data-titlebar-tab][data-active="true"]')).toHaveCount(1)
-})
-
-test("recording a new session shortcut stays in settings until recording finishes", async ({ page }) => {
-  const settings = page.getByTestId("settings-screen")
-  await settings.getByRole("tab", { name: "Shortcuts", exact: true }).click()
-  const binding = settings.locator('[data-keybind-id="tab.new"]')
-  await binding.click()
-  await expect(binding).toHaveText("Press keys")
-  await page.keyboard.press("Control+t")
-
-  await expect(binding).toHaveText("Ctrl+T")
-  await expect(page).toHaveURL("/settings")
-  await expect(page.locator("[data-titlebar-tab]")).toHaveCount(0)
-  await page.keyboard.press("Control+t")
-  await expect(page).toHaveURL(/\/new-session\?draftId=.+$/)
-  await expect(settings).toBeHidden()
-  await expect(page.locator('[data-component="composer-editor"]')).toBeEditable()
-})
-
 test("workspaces opens without waiting for inventory or sessions", async ({ page }) => {
   const inventory = Promise.withResolvers<void>()
   const sessions = Promise.withResolvers<void>()
@@ -139,79 +105,6 @@ test("extensions opens without waiting for MCPs", async ({ page }) => {
   await expect(settings.getByRole("switch", { name: "demo-mcp" })).toBeChecked()
 })
 
-test("about opens without waiting for contributors", async ({ page }) => {
-  const contributors = Promise.withResolvers<void>()
-  const url = "https://api.github.com/repos/anomalyco/opencode/contributors?anon=1&per_page=1"
-  await page.route(url, async (route) => {
-    await contributors.promise
-    await route.fulfill({
-      json: [],
-      headers: {
-        "access-control-allow-origin": "*",
-        "access-control-expose-headers": "Link",
-        Link: `<${url}&page=1004>; rel="last"`,
-      },
-    })
-  })
-  const settings = page.getByTestId("settings-screen")
-  const requested = page.waitForRequest(url)
-  await settings.getByRole("tab", { name: "About", exact: true }).click()
-  await requested
-  await expect(settings.getByRole("tab", { name: "About", exact: true })).toHaveAttribute("aria-selected", "true")
-  await expect(settings.getByText("Released under the MIT License", { exact: true })).toBeVisible()
-  await expect(settings.getByText(/^Version /)).toBeVisible()
-  await expect(settings.getByText("OpenCode Desktop", { exact: true })).toHaveCount(0)
-  await expect(settings.getByText(/^v\d+\./)).toHaveCount(0)
-  await expect(settings.getByRole("link", { name: "935 others", exact: true })).toBeVisible()
-  await expect(settings.getByRole("button", { name: "Back to app" })).toBeVisible()
-
-  await settings.getByRole("tab", { name: "Preferences", exact: true }).click()
-  await expect(settings.getByRole("tab", { name: "Preferences", exact: true })).toHaveAttribute("aria-selected", "true")
-  await settings.getByRole("tab", { name: "About", exact: true }).click()
-  await expect(settings.getByRole("link", { name: "935 others", exact: true })).toBeVisible()
-
-  const website = settings.getByRole("link", { name: "www.opencode.ai", exact: true })
-  await website.focus()
-  contributors.resolve()
-  await expect(settings.getByRole("link", { name: "988 others", exact: true })).toBeVisible()
-  await expect(website).toBeFocused()
-})
-
-test("about is available in the mobile settings menu", async ({ page }) => {
-  await page.route("https://api.github.com/repos/anomalyco/opencode/contributors?*", (route) => route.abort("failed"))
-  await page.setViewportSize({ width: 390, height: 844 })
-  const settings = page.getByTestId("settings-screen")
-  await settings.getByRole("button", { name: "Preferences", exact: true }).click()
-  await page.getByRole("menuitemradio", { name: "About", exact: true }).click()
-  await expect(settings.getByRole("button", { name: "About", exact: true })).toBeVisible()
-  await expect(settings.getByText("Released under the MIT License", { exact: true })).toBeVisible()
-  await expect(settings.getByRole("link", { name: "935 others", exact: true })).toBeVisible()
-  await expect(settings.getByText("OpenCode Desktop", { exact: true })).toHaveCount(0)
-  await settings.getByRole("button", { name: "About", exact: true }).click()
-  await expect(page.getByRole("menuitemradio", { name: "About", exact: true })).toBeChecked()
-})
-
-test("about keeps its fallback when the contributor request fails", async ({ page }) => {
-  const contributors = Promise.withResolvers<void>()
-  const url = "https://api.github.com/repos/anomalyco/opencode/contributors?anon=1&per_page=1"
-  await page.route(url, async (route) => {
-    await contributors.promise
-    await route.abort("failed")
-  })
-  const settings = page.getByTestId("settings-screen")
-  const requested = page.waitForRequest(url)
-  await settings.getByRole("tab", { name: "About", exact: true }).click()
-  await requested
-  await expect(settings.getByRole("link", { name: "935 others", exact: true })).toBeVisible()
-
-  const failed = page.waitForEvent("requestfailed", (request) => request.url() === url)
-  contributors.resolve()
-  await failed
-  await expect(settings.getByRole("link", { name: "935 others", exact: true })).toBeVisible()
-  await expect(settings.getByText("Released under the MIT License", { exact: true })).toBeVisible()
-  await expect(settings.getByRole("tab", { name: "About", exact: true })).toHaveAttribute("aria-selected", "true")
-})
-
 test("workspace inventory uses the settings panel scroll area", async ({ page }) => {
   const settings = page.getByTestId("settings-screen")
   await settings.getByRole("tab", { name: "Worktrees", exact: true }).click()

packages/app/e2e/regression/settings-padding.spec.ts

@@ -1,95 +0,0 @@
-import { expect, test } from "@playwright/test"
-import { mockOpenCodeServer } from "../utils/mock-server"
-
-const directory = "/tmp/settings-padding"
-
-test.beforeEach(async ({ page }) => {
-  await mockOpenCodeServer(page, {
-    directory,
-    project: {
-      id: "proj_settings_padding",
-      canonical: directory,
-      name: "Settings padding",
-      vcs: "git",
-      time: { created: 1700000000000, updated: 1700000000000 },
-    },
-    provider: { all: [], connected: [], default: {} },
-    sessions: [],
-    pageMessages: () => ({ items: [] }),
-  })
-  await page.route("https://api.github.com/repos/anomalyco/opencode/contributors?*", (route) =>
-    route.fulfill({ json: [] }),
-  )
-  await page.goto("/")
-  await page.getByRole("button", { name: "Settings", exact: true }).click()
-  await expect(page.getByTestId("settings-screen")).toBeFocused()
-})
-
-for (const viewport of [
-  { width: 1280, height: 720, bottom: false },
-  { width: 900, height: 600, bottom: false },
-  { width: 780, height: 600, bottom: false },
-  { width: 390, height: 844, bottom: false },
-  { width: 390, height: 844, bottom: true },
-]) {
-  test.describe(`${viewport.width}px, ${viewport.bottom ? "bottom" : "top"} navigation`, () => {
-    test.use({ viewport: { width: 1280, height: 720 }, contextOptions: { reducedMotion: "reduce" } })
-
-    test("every settings page leaves room below its final content", async ({ page }) => {
-      await page.setViewportSize(viewport)
-      const settings = page.getByTestId("settings-screen")
-      const panel = settings.locator(":scope > .settings > .settings-panel:visible")
-      if (viewport.bottom) {
-        const toggle = settings.locator('[data-action="settings-mobile-titlebar-bottom"]')
-        await toggle.locator('[data-slot="switch-control"]').click()
-        await expect(toggle.getByRole("switch")).toBeChecked()
-      }
-      let current = "Preferences"
-      for (const name of [
-        "Preferences",
-        "Appearance",
-        "Notifications",
-        "Shortcuts",
-        "Servers",
-        "Projects",
-        "Worktrees",
-        "Providers",
-        "Models",
-        "Extensions",
-        "Experimental",
-        "About",
-      ]) {
-        if (viewport.width >= 816) await settings.getByRole("tab", { name, exact: true }).click()
-        if (viewport.width < 816) {
-          await settings.getByRole("button", { name: current, exact: true }).click()
-          await page.getByRole("menuitemradio", { name, exact: true }).click()
-        }
-        current = name
-        if (name === "About") await expect(panel.getByText("Released under the MIT License")).toBeVisible()
-        if (name !== "About") {
-          await expect(
-            panel.getByRole("heading", { name: name === "Shortcuts" ? "Keyboard shortcuts" : name, exact: true }),
-          ).toBeVisible()
-        }
-        await panel.hover()
-        await page.mouse.wheel(0, 10000)
-        await expect
-          .poll(() => panel.evaluate((el) => el.scrollHeight - el.clientHeight - el.scrollTop))
-          .toBeLessThanOrEqual(1)
-        await expect
-          .poll(
-            () =>
-              panel.evaluate((el) => {
-                const body = el.querySelector(".settings-tab-body, .settings-about-content")!
-                return el.getBoundingClientRect().bottom - body.lastElementChild!.getBoundingClientRect().bottom
-              }),
-            { message: `${name} bottom clearance` },
-          )
-          .toBeGreaterThanOrEqual(viewport.bottom ? 119.5 : 79.5)
-        await expect
-          .poll(() => page.getByRole("main").evaluate((el) => el.scrollWidth - el.clientWidth))
-          .toBeLessThanOrEqual(1)
-      }
-    })
-  })
-}

packages/app/e2e/regression/settings-scroll.spec.ts

@@ -1,69 +0,0 @@
-import { expect, test } from "@playwright/test"
-import { mockOpenCodeServer } from "../utils/mock-server"
-
-test.use({ contextOptions: { reducedMotion: "reduce" }, colorScheme: "dark" })
-
-for (const viewport of [
-  { width: 1280, height: 720 },
-  { width: 900, height: 600 },
-  { width: 780, height: 600 },
-  { width: 390, height: 844 },
-]) {
-  test(`preferences scroll only inside the panel at ${viewport.width}x${viewport.height}`, async ({ page }) => {
-    const directory = "/tmp/settings-scroll"
-    await mockOpenCodeServer(page, {
-      directory,
-      project: {
-        id: "proj_settings_scroll",
-        canonical: directory,
-        name: "Settings scroll",
-        vcs: "git",
-        time: { created: 1700000000000, updated: 1700000000000 },
-      },
-      provider: { all: [], connected: [], default: {} },
-      sessions: [],
-      pageMessages: () => ({ items: [] }),
-    })
-    await page.goto("/")
-    await page.getByRole("button", { name: "Settings", exact: true }).click()
-
-    const settings = page.getByTestId("settings-screen")
-    const panel = settings.getByRole("tabpanel")
-    const main = page.getByRole("main")
-    const slider = settings.getByRole("slider", { name: "Timeline detail", exact: true })
-    await expect(settings).toBeFocused()
-    await page.setViewportSize(viewport)
-    await expect(slider).toHaveAccessibleDescription(/Choose how much activity appears in the timeline/)
-    await expect.poll(() => main.evaluate((el) => el.scrollHeight - el.clientHeight)).toBeLessThanOrEqual(1)
-
-    // Wheel over the outer gutter must not move the entire settings screen.
-    await main.hover({ position: { x: 1, y: 200 } })
-    await page.mouse.wheel(0, 10000)
-    await panel.hover()
-    await page.mouse.wheel(0, 10000)
-    await expect.poll(() => panel.evaluate((el) => el.scrollTop)).toBeGreaterThan(0)
-    await expect(main).toHaveJSProperty("scrollTop", 0)
-    await expect(settings.getByRole("heading", { name: "Preferences", exact: true })).toBeInViewport()
-
-    await slider.scrollIntoViewIfNeeded()
-    await slider.click()
-    await page.keyboard.press("Home")
-    await expect(slider).toHaveValue("0")
-    await page.keyboard.press("ArrowRight")
-    await expect(slider).toHaveValue("1")
-    await expect(slider).toBeFocused()
-
-    await settings.getByRole("button", { name: "Advanced", exact: true }).click()
-    await expect(
-      settings.getByRole("group", { name: "Set placement and details for each activity category.", exact: true }),
-    ).toBeVisible()
-    await panel.hover()
-    await page.mouse.wheel(0, 10000)
-    await expect
-      .poll(() => panel.evaluate((el) => el.scrollHeight - el.clientHeight - el.scrollTop))
-      .toBeLessThanOrEqual(1)
-    await expect(main).toHaveJSProperty("scrollTop", 0)
-    await expect.poll(() => main.evaluate((el) => el.scrollHeight - el.clientHeight)).toBeLessThanOrEqual(1)
-    await expect(settings.getByRole("heading", { name: "Preferences", exact: true })).toBeInViewport()
-  })
-}

packages/app/e2e/regression/tab-navigate-mousedown.spec.ts

@@ -1,6 +1,7 @@
 import { expect, test, type Page, type Route } from "@playwright/test"
 import { base64Encode } from "@opencode-ai/util/encode"
 import { currentSession } from "../utils/mock-server"
+import pkg from "../../package.json" with { type: "json" }
 
 const server = `http://${process.env.PLAYWRIGHT_SERVER_HOST ?? "127.0.0.1"}:${process.env.PLAYWRIGHT_SERVER_PORT ?? "4096"}`
 const sessionA = session("ses_tab_a", "Tab A session")
@@ -184,9 +185,7 @@ test("vertical tabs show project details, resize, and navigate", async ({ page }
   await expect(tabA).toContainText(sessionA.title)
   await expect(tabB).toContainText(sessionB.title)
   await expect(tabB.locator('[data-slot="tab-project"]')).toHaveText("tab-project")
-  await expect(
-    sidebar.getByRole("button", { name: "Home", exact: true }).getByText("Home", { exact: true }),
-  ).toBeVisible()
+  await expect(sidebar.getByRole("button", { name: "Home", exact: true })).toHaveText("Home")
   await expect(sidebar.getByRole("button", { name: "New session" })).toBeVisible()
   await expect(sidebar.locator('[data-slot="vertical-tabs-footer"]')).toBeVisible()
   const status = sidebar.getByRole("button", { name: "Status", exact: true })
@@ -232,163 +231,7 @@ test("vertical tabs show project details, resize, and navigate", async ({ page }
   await expect(tabB).toBeVisible()
 })
 
-for (const direction of ["ltr", "rtl"]) {
-  test(`vertical tabs keep Settings pinned while scrolling in ${direction}`, async ({ page }, testInfo) => {
-    await mockServer(page)
-    await page.addInitScript(
-      ({ server, sessionA, sessionB, directory }) => {
-        localStorage.setItem("settings.v3", JSON.stringify({ appearance: { tabLayout: "vertical" } }))
-        localStorage.setItem(
-          "opencode.window.browser.dat:tabs",
-          JSON.stringify([
-            { type: "session", server, sessionId: sessionA },
-            ...Array.from({ length: 24 }, (_, index) => ({
-              type: "draft",
-              server,
-              directory,
-              draftID: `draft_scroll_${index}`,
-            })),
-            { type: "session", server, sessionId: sessionB },
-          ]),
-        )
-      },
-      { server, sessionA: sessionA.id, sessionB: sessionB.id, directory: sessionA.directory },
-    )
-    await page.goto("/")
-
-    const sidebar = page.locator('[data-slot="vertical-tabs-sidebar"]')
-    const settings = sidebar.getByRole("button", { name: "Settings", exact: true })
-    const scroll = sidebar.locator('[data-slot="vertical-tabs-scroll"]')
-    const hrefB = `/server/${base64Encode(server)}/session/${sessionB.id}`
-    const tabB = sidebar.locator(`[data-titlebar-tab-link][href="${hrefB}"]`)
-    await expect(sidebar.locator("[data-titlebar-tab-slot]")).toHaveCount(26)
-    await expect(settings).toHaveText("Settings")
-    await page.evaluate((direction) => document.documentElement.setAttribute("dir", direction), direction)
-
-    for (const width of [1280, 800]) {
-      await page.setViewportSize({ width, height: 360 })
-      await expect(settings).toBeInViewport({ ratio: 1 })
-      await expect(sidebar).toHaveCSS("padding-inline-start", "10px")
-      await expect(sidebar).toHaveCSS("padding-bottom", "10px")
-      await expect(settings).toHaveCSS("margin-top", "8px")
-      await expect
-        .poll(() =>
-          sidebar.locator('[data-slot="vertical-tabs-footer"]').evaluate((element) => {
-            const content = Math.max(
-              0,
-              ...Array.from(element.children, (child) => child.getBoundingClientRect().height),
-            )
-            return element.getBoundingClientRect().height - content
-          }),
-        )
-        .toBe(0)
-      await expect(scroll).toHaveCSS("mask-image", /linear-gradient/)
-      await scroll.evaluate((element) => element.scrollTo(0, 0))
-      await expect(scroll).toHaveJSProperty("scrollTop", 0)
-      const pinned = await settings.boundingBox()
-      await scroll.hover()
-      await page.mouse.wheel(0, 200)
-      await expect.poll(() => scroll.evaluate((element) => element.scrollTop)).toBeGreaterThan(0)
-      await expect.poll(() => settings.boundingBox()).toEqual(pinned)
-      await testInfo.attach(`vertical-tabs-settings-${width}`, {
-        body: await sidebar.screenshot(),
-        contentType: "image/png",
-      })
-
-      await scroll.evaluate((element) => element.scrollTo(0, element.scrollHeight))
-      await expect(tabB).toBeInViewport({ ratio: 1 })
-      await expect
-        .poll(async () => {
-          const tab = await tabB.boundingBox()
-          const viewport = await scroll.boundingBox()
-          return !!tab && !!viewport && tab.y + tab.height <= viewport.y + viewport.height - 16
-        })
-        .toBe(true)
-      await expect.poll(() => settings.boundingBox()).toEqual(pinned)
-    }
-
-    await settings.click()
-    await expect(page.getByTestId("settings-screen")).toBeVisible()
-    await expect(settings).toHaveAttribute("aria-pressed", "true")
-    await sidebar.getByRole("button", { name: "Home", exact: true }).click()
-    await expect(page.getByTestId("settings-screen")).toBeHidden()
-    await settings.focus()
-    await settings.press("Enter")
-    await expect(page.getByTestId("settings-screen")).toBeVisible()
-  })
-}
-
-for (const profile of [
-  { locale: "en", direction: "ltr" },
-  { locale: "en", direction: "rtl" },
-  { locale: "ar", direction: "rtl" },
-]) {
-  test(`vertical shortcut hints align at the row end: ${profile.locale} ${profile.direction}`, async ({ page }) => {
-    await mockServer(page)
-    await page.addInitScript(
-      ({ server, sessionID, locale }) => {
-        localStorage.setItem("opencode.global.dat:language", JSON.stringify({ locale }))
-        localStorage.setItem(
-          "settings.v3",
-          JSON.stringify({
-            appearance: { tabLayout: "vertical" },
-            keybinds: { "home.toggle": "ctrl+alt+h", "tab.new": "ctrl+shift+n" },
-          }),
-        )
-        localStorage.setItem(
-          "opencode.window.browser.dat:tabs",
-          JSON.stringify([{ type: "session", server, sessionId: sessionID }]),
-        )
-      },
-      { server, sessionID: sessionA.id, locale: profile.locale },
-    )
-    await page.goto(`/server/${base64Encode(server)}/session/${sessionA.id}`)
-
-    const sidebar = page.locator('[data-slot="vertical-tabs-sidebar"]')
-    await expect(sidebar).toHaveCSS("width", "260px")
-    await page
-      .locator("html")
-      .evaluate((element, direction) => element.setAttribute("dir", direction), profile.direction)
-    await expect(sidebar).toHaveCSS("direction", profile.direction)
-
-    for (const row of [
-      { action: "home", shortcut: "Ctrl+Alt+H" },
-      { action: "new-session", shortcut: "Ctrl+Shift+N" },
-    ]) {
-      const button = sidebar.locator(`[data-action="vertical-tabs-${row.action}"]`)
-      const hint = button.locator('span[aria-hidden="true"]')
-      await expect(hint).toHaveText(row.shortcut)
-      await expect(hint.getByText(row.shortcut, { exact: true })).toHaveCSS("direction", "ltr")
-      await expect(hint).toHaveCSS("opacity", "0")
-      await button.hover()
-      await expect(hint).toHaveCSS("opacity", "1")
-      await expect
-        .poll(() =>
-          hint.evaluate((element) => {
-            const button = element.closest("button")!
-            const row = button.getBoundingClientRect()
-            const hint = element.getBoundingClientRect()
-            return getComputedStyle(button).direction === "rtl" ? hint.left - row.left : row.right - hint.right
-          }),
-        )
-        .toBeCloseTo(8, 1)
-      await page.getByRole("main").hover()
-      await expect(hint).toHaveCSS("opacity", "0")
-    }
-
-    const home = sidebar.locator('[data-action="vertical-tabs-home"]')
-    const newSession = sidebar.locator('[data-action="vertical-tabs-new-session"]')
-    await home.focus()
-    await page.keyboard.press("Tab")
-    await expect(newSession).toBeFocused()
-    await expect(newSession.locator('span[aria-hidden="true"]')).toHaveCSS("opacity", "1")
-    await page.keyboard.press("Shift+Tab")
-    await expect(home).toBeFocused()
-    await expect(home.locator('span[aria-hidden="true"]')).toHaveCSS("opacity", "1")
-  })
-}
-
-test("dedicated experimental settings control vertical tab details", async ({ page }) => {
+test("appearance experimental settings control vertical tab details", async ({ page }) => {
   await mockServer(page)
   await page.addInitScript(
     ({ server, sessionA }) => {
@@ -406,14 +249,11 @@ test("dedicated experimental settings control vertical tab details", async ({ pa
 
   const settings = page.getByTestId("settings-screen")
   await expect(settings).toBeVisible()
-  await expect(settings.getByRole("tablist").getByText("OpenCode Desktop", { exact: true })).toHaveCount(0)
-  await expect(settings.getByRole("tablist").getByText(/^v\d+\./)).toHaveCount(0)
+  const version = settings.getByRole("tablist").getByText(`v${pkg.version}`, { exact: true })
+  await expect(settings.getByRole("tablist").getByText("OpenCode Desktop", { exact: true })).toBeInViewport()
+  await expect(version).toBeInViewport()
   await settings.getByRole("tab", { name: "Appearance" }).click()
-  await expect(settings.getByRole("heading", { name: "Appearance", exact: true })).toBeVisible()
-  await expect(settings.locator('[data-action="settings-tab-layout"]')).toHaveCount(0)
-  await expect(settings.getByRole("switch", { name: "Show project names", exact: true })).toHaveCount(0)
-  await settings.getByRole("tab", { name: "Experimental", exact: true }).click()
-  await expect(settings.getByRole("heading", { name: "Experimental", level: 2, exact: true })).toBeVisible()
+  await expect(settings.getByRole("heading", { name: "Experimental" })).toBeVisible()
 
   const layout = settings.locator('[data-action="settings-tab-layout"]')
   await expect(layout).toContainText("Horizontal")
@@ -434,27 +274,19 @@ test("dedicated experimental settings control vertical tab details", async ({ pa
   await page.setViewportSize({ width: 920, height: 720 })
   await expect(page.locator('[data-slot="vertical-tabs-sidebar"]')).toHaveCSS("width", "260px")
   await expect(settings.getByRole("tablist")).toBeHidden()
-  await expect(settings.getByRole("button", { name: "Experimental", exact: true })).toBeVisible()
+  await expect(settings.getByRole("button", { name: "Appearance", exact: true })).toBeVisible()
 
   await page.setViewportSize({ width: 800, height: 720 })
   await expect(settings.getByRole("tablist")).toBeHidden()
-  await expect(settings.getByRole("button", { name: "Experimental", exact: true })).toBeVisible()
+  await expect(settings.getByRole("button", { name: "Appearance", exact: true })).toBeVisible()
 
   await page.setViewportSize({ width: 390, height: 720 })
-  await settings.getByRole("button", { name: "Experimental", exact: true }).click()
-  await page.getByRole("menuitemradio", { name: "Appearance", exact: true }).click()
-  await expect(settings.getByRole("heading", { name: "Appearance", exact: true })).toBeVisible()
-  await expect(layout).toHaveCount(0)
-  await settings.getByRole("button", { name: "Appearance", exact: true }).click()
-  await page.getByRole("menuitemradio", { name: "Experimental", exact: true }).click()
-  await expect(settings.getByRole("heading", { name: "Experimental", level: 2, exact: true })).toBeVisible()
-  await expect(layout).toContainText("Vertical")
-  await expect(projectNameSwitch).toBeChecked()
+  await expect(settings.getByRole("button", { name: "Appearance", exact: true })).toBeVisible()
   await settings.evaluate((element) => element.setAttribute("dir", "rtl"))
-  await expect(settings.getByRole("button", { name: "Experimental", exact: true })).toBeInViewport()
+  await expect(settings.getByRole("button", { name: "Appearance", exact: true })).toBeInViewport()
 
   await page.setViewportSize({ width: 390, height: 360 })
-  await expect(settings.getByRole("button", { name: "Experimental", exact: true })).toBeInViewport()
+  await expect(settings.getByRole("button", { name: "Appearance", exact: true })).toBeInViewport()
 
   // Reload the UI-selected preference without seeding settings storage.
   await page.reload()
@@ -478,7 +310,7 @@ test("dedicated experimental settings control vertical tab details", async ({ pa
   ).toBeVisible()
   await expect(page.locator('[data-slot="titlebar-tabs"]')).toHaveCount(0)
   await page.keyboard.press("Control+,")
-  await settings.getByRole("tab", { name: "Experimental", exact: true }).click()
+  await settings.getByRole("tab", { name: "Appearance" }).click()
   await expect(layout).toContainText("Vertical")
 })
 

packages/app/e2e/regression/workspace-accent.spec.ts

@@ -78,13 +78,9 @@ for (const theme of ["light", "dark"] as const) {
         await expectToken(
           message,
           "background-color",
-          scenario.accent ? "--v2-background-bg-accent" : theme === "light" ? "--v2-blue-100" : "--v2-blue-1200",
-        )
-        await expectToken(
-          message,
-          "color",
-          scenario.accent ? "--v2-text-text-contrast" : theme === "light" ? "--v2-blue-700" : "--v2-blue-300",
+          scenario.accent ? "--v2-background-bg-accent" : "--v2-state-bg-info",
         )
+        await expectToken(message, "color", scenario.accent ? "--v2-text-text-contrast" : "--v2-text-text-accent")
       })
     }
 

packages/app/e2e/utils/command-palette.ts

@@ -1,57 +0,0 @@
-import { expect, type Page } from "@playwright/test"
-import { base64Encode } from "@opencode-ai/util/encode"
-import { mockOpenCodeServer } from "./mock-server"
-import { APP_READY_TIMEOUT } from "./waits"
-
-export const paletteSession = {
-  id: "ses_command_palette",
-  projectID: "proj_command_palette",
-  directory: "C:/OpenCode/CommandPalette",
-  title: "Palette fixture session",
-  time: { created: 1700000000000, updated: 1700000000000 },
-}
-
-export function captureConsoleWarnings(page: Page) {
-  const warnings: string[] = []
-  page.on("console", (message) => {
-    if (message.type() !== "warning" && message.type() !== "error") return
-    // This message comes from test isolation, not application code.
-    if (message.text() === "Service Worker registration blocked by Playwright") return
-    warnings.push(message.text())
-  })
-  return warnings
-}
-
-export async function openCommandPalette(page: Page, home = false) {
-  await mockOpenCodeServer(page, {
-    directory: paletteSession.directory,
-    project: {
-      id: paletteSession.projectID,
-      worktree: paletteSession.directory,
-      vcs: "git",
-      name: "command-palette",
-      time: paletteSession.time,
-      sandboxes: [],
-    },
-    provider: { all: [], connected: [], default: {} },
-    sessions: [paletteSession],
-    pageMessages: () => ({ items: [] }),
-    findFiles: () => [],
-  })
-  const server = `http://${process.env.PLAYWRIGHT_SERVER_HOST ?? "127.0.0.1"}:${process.env.PLAYWRIGHT_SERVER_PORT ?? "4096"}`
-  await page.goto(home ? "/" : `/server/${base64Encode(server)}/session/${paletteSession.id}`)
-  if (home) {
-    await expect(
-      page.getByRole("region", { name: "Recent sessions" }).getByRole("button", { name: /Palette fixture session/ }),
-    ).toBeEnabled({ timeout: APP_READY_TIMEOUT })
-  }
-  if (!home) {
-    await expect(page.locator('[data-component="composer-editor"]')).toBeEditable({ timeout: APP_READY_TIMEOUT })
-  }
-  await page.keyboard.press("ControlOrMeta+Shift+P")
-  const dialog = page.getByRole("dialog")
-  const input = dialog.getByRole("textbox")
-  await expect(input).toBeFocused()
-  await expect(dialog.getByRole("option")).not.toHaveCount(0)
-  return { dialog, input }
-}

packages/app/src/composer/attachments/attachments.ts

@@ -1,4 +1,4 @@
-import { onCleanup, onMount } from "solid-js"
+import { onMount } from "solid-js"
 import { makeEventListener } from "@solid-primitives/event-listener"
 import type { ComposerAttachment, ComposerPrompt } from "../types"
 
@@ -78,7 +78,6 @@ export type ComposerAttachmentConfig = {
   onError: (error: unknown) => void
   readClipboardImage?: () => Promise<File | null>
   getPathForFile?: (file: File) => string
-  onDragCancel?: (callback: () => void) => () => void
   store?: (file: File) => Promise<{ id: string; url: string }>
 }
 
@@ -91,9 +90,6 @@ export function createComposerAttachments(
     setDraggingType: (type: "image" | "@mention" | null) => void
   },
 ) {
-  const clearDrag = () => {
-    input.setDraggingType(null)
-  }
   const capture = () => {
     const prompt = input.capture()
     const editor = input.editor()
@@ -182,7 +178,7 @@ export function createComposerAttachments(
   const handleDrop = async (event: DragEvent) => {
     if (input.isDialogActive()) return
     event.preventDefault()
-    clearDrag()
+    input.setDraggingType(null)
     const plainText = event.dataTransfer?.getData("text/plain")
     if (plainText?.startsWith("file:")) {
       const path = plainText.slice("file:".length)
@@ -195,8 +191,6 @@ export function createComposerAttachments(
   }
 
   onMount(() => {
-    const cancel = input.onDragCancel?.(clearDrag)
-    if (cancel) onCleanup(cancel)
     makeEventListener(document, "dragover", (event) => {
       if (input.isDialogActive()) return
       event.preventDefault()
@@ -204,10 +198,7 @@ export function createComposerAttachments(
       else if (event.dataTransfer?.types.includes("text/plain")) input.setDraggingType("@mention")
     })
     makeEventListener(document, "dragleave", (event) => {
-      if (!input.isDialogActive() && !event.relatedTarget) clearDrag()
-    })
-    makeEventListener(document, "keydown", (event) => {
-      if (event.key === "Escape") clearDrag()
+      if (!input.isDialogActive() && !event.relatedTarget) input.setDraggingType(null)
     })
     makeEventListener(document, "drop", handleDrop)
   })

packages/app/src/composer/composer.tsx

@@ -26,8 +26,7 @@ export function Composer(props: { class?: string; model: ComposerModel; borderUn
         modelControlsVisible={!props.model.model.loading}
         attachKeybind={command.keybindParts("file.attach")}
         attachShortcut={command.keybind("file.attach")}
-        alternateKeybind={[formatKeybind("mod", language.t), "↵"]}
-        exitShellKeybind={[formatKeybind("esc", language.t)]}
+        alternateKeybind={[formatKeybind("mod", language.t), formatKeybind("enter", language.t)]}
         modelControl={
           <ComposerModelControl
             loading={props.model.model.loading}

packages/app/src/composer/editor/editor.css

@@ -6,7 +6,3 @@
 [data-color-scheme="dark"] [data-component="new-session"] [data-component="composer"] {
   background: var(--v2-background-bg-layer-01);
 }
-
-[data-color-scheme="dark"] [data-component="composer-suggestions"] [data-active] {
-  background: var(--v2-alpha-light-10);
-}

packages/app/src/composer/editor/editor.tsx

@@ -47,7 +47,6 @@ export type ComposerEditorProps = {
   attachKeybind?: string[]
   attachShortcut?: string
   alternateKeybind?: string[]
-  exitShellKeybind?: string[]
 }
 
 export function ComposerEditor(props: ComposerEditorProps) {
@@ -118,6 +117,7 @@ export function ComposerEditor(props: ComposerEditorProps) {
         class="group/composer relative min-h-[96px] w-full overflow-clip rounded-xl bg-v2-background-bg-base"
         classList={{
           "shadow-[var(--v2-elevation-raised)]": !props.borderUnderlay,
+          "border border-v2-icon-icon-info border-dashed": state.drag === "active",
         }}
         onSubmit={(event) => {
           event.preventDefault()
@@ -128,6 +128,12 @@ export function ComposerEditor(props: ComposerEditorProps) {
         onDragLeave={props.controller.onDragLeave}
         onDrop={props.controller.onDrop}
       >
+        <Show when={state.drag === "active"}>
+          <div class="pointer-events-none absolute inset-0 z-20 grid place-items-center rounded-xl bg-v2-background-bg-base/90 text-v2-text-text-base">
+            {i18n.t("ui.promptInput.dropFiles")}
+          </div>
+        </Show>
+
         <Show when={state.mode === "normal"}>
           <ComposerAttachments
             attachments={props.controller.attachments()}
@@ -275,24 +281,6 @@ export function ComposerEditor(props: ComposerEditorProps) {
               keybind={props.alternateKeybind ?? ["Mod", "Enter"]}
             />
           </Show>
-          <Show when={state.mode === "shell"}>
-            <Button
-              data-action="composer-exit-shell"
-              type="button"
-              variant="ghost-faint"
-              size="small"
-              class="me-3 gap-1.5 px-1.5"
-              onClick={() => {
-                props.controller.dispatch({ type: "mode.normal" })
-                props.controller.restoreFocus()
-              }}
-            >
-              {i18n.t("ui.promptInput.exitShell")}
-              <span class="hidden sm:block">
-                <Keybind keys={props.exitShellKeybind ?? ["ESC"]} variant="neutral" />
-              </span>
-            </Button>
-          </Show>
           <ComposerEditorSubmitButton
             mode={state.mode}
             stopping={view.submit.stopping()}
@@ -568,7 +556,7 @@ export function ComposerEditorAddMenu(props: {
         />
         <Menu.Portal>
           <Menu.Content
-            class="[&_[data-slot=menu-v2-item-shortcut]]:w-5 [&_[data-slot=menu-v2-item-shortcut]]:justify-center"
+            class="[&_[data-slot=menu-v2-item-shortcut]]:w-8 [&_[data-slot=menu-v2-item-shortcut]]:justify-center"
             style={{ "min-width": "180px" }}
           >
             <Menu.Item onSelect={props.onAttach} shortcut={props.attachShortcut}>
@@ -685,7 +673,6 @@ export function ComposerEditorPopover(props: {
 }) {
   return (
     <div
-      data-component="composer-suggestions"
       class="absolute inset-x-0 -top-2 z-40 flex max-h-80 -translate-y-full flex-col overflow-auto rounded-xl bg-v2-background-bg-base p-2 shadow-[var(--v2-elevation-raised)] no-scrollbar"
       onMouseDown={(event) => event.preventDefault()}
     >
@@ -714,7 +701,6 @@ export function ComposerEditorPopover(props: {
             <button
               type="button"
               data-suggestion-id={item.id}
-              data-active={props.activeID === item.id ? "" : undefined}
               class="flex w-full items-center gap-2 rounded-md px-2 py-1 text-start hover:bg-v2-overlay-simple-overlay-hover"
               classList={{ "bg-v2-overlay-simple-overlay-hover": props.activeID === item.id }}
               onPointerMove={() => props.onActiveChange(item)}
@@ -763,9 +749,9 @@ function ComposerEditorAlternateDelivery(props: { controller: ComposerEditorMode
             ref={setButton}
             data-action="composer-alternate-delivery"
             type="button"
-            variant="ghost-faint"
+            variant="ghost-muted"
             size="small"
-            class="me-3 gap-1.5 px-1.5 ![font-weight:530] duration-150 motion-reduce:animate-none"
+            class="me-3 gap-1.5 px-1.5 text-v2-text-text-muted ![font-weight:530] duration-150 motion-reduce:animate-none"
             classList={{
               "animate-in fade-in": presence.animate() && presence.show(),
               "animate-out fade-out fill-mode-forwards": presence.animate() && !presence.show(),

packages/app/src/composer/model.ts

@@ -42,14 +42,9 @@ export function createComposerModel(adapter: ComposerAdapter, options?: { queue?
 
   const interaction = createComposerEditorState(prompt.mode.current())
   createEffect(
-    on(
-      () => (adapter.ready() ? prompt.mode.current() : undefined),
-      (mode) => {
-        if (!mode) return
-        // Project external draft changes without another mode write clearing restored retry metadata.
-        interaction[1](mode === "shell" ? { mode, popover: { type: "closed" } } : { mode })
-      },
-    ),
+    on(adapter.ready, (ready) => {
+      if (ready) interaction[1]("mode", prompt.mode.current())
+    }),
   )
   const mode = () => interaction[0].mode
   const history = createComposerHistory()
@@ -256,7 +251,6 @@ export function createComposerModel(adapter: ComposerAdapter, options?: { queue?
   const submission = createComposerSubmit({
     adapter,
     mode,
-    commands: () => data.location.command.list({ directory: sdk().directory }),
     editor: () => editor,
     queueScroll: () => requestAnimationFrame(() => editor?.scrollIntoView({ block: "nearest" })),
     addToHistory: (value, mode) => controller.addHistory(value, mode),
@@ -351,7 +345,6 @@ export function createComposerModel(adapter: ComposerAdapter, options?: { queue?
         }),
       readClipboardImage: platform.readClipboardImage,
       getPathForFile: platform.getPathForFile,
-      onDragCancel: platform.onDragCancel,
       store: platform.draftStore?.putBlob,
     },
     view: {

packages/app/src/composer/submit.test.ts

@@ -52,12 +52,10 @@ function submitInput(
   adapter: ActiveComposerAdapter | NewSessionComposerAdapter,
   notify = { missingSelection() {}, failed(_kind: "shell" | "command" | "prompt", _error: unknown) {} },
   mode: "normal" | "shell" = "normal",
-  commands: () => readonly { name: string }[] | undefined = () => [],
 ) {
   return createComposerSubmit({
     adapter,
     mode: () => mode,
-    commands,
     editor: () => undefined,
     queueScroll() {},
     addToHistory() {},
@@ -422,6 +420,7 @@ describe("Composer submission", () => {
       prompt: async () => undefined,
       command: async (value) => sent.resolve(value),
     })
+    target.data.location.command.list = () => [{ name: "review", description: "Review changes", template: "" }]
     const adapter: ActiveComposerAdapter = {
       kind: "active-session",
       state,
@@ -434,7 +433,7 @@ describe("Composer submission", () => {
       setEditor() {},
     }
 
-    await submitInput(adapter, undefined, "normal", () => [{ name: "review" }]).submit(new Event("submit"))
+    await submitInput(adapter).submit(new Event("submit"))
     const request = await sent.promise
 
     expect(request.files).toMatchObject([{ name: "app.ts", mention: { text: "@src/app.ts" } }])
@@ -443,51 +442,6 @@ describe("Composer submission", () => {
     expect(request.delivery).toBe("steer")
   })
 
-  test("captures commands before creating a session in a new worktree", async () => {
-    const state = createMemoryComposerState({ prompt: "/review https://github.com/example/repo/pull/1" }).capture()
-    const catalog = [{ name: "review" }]
-    const sent = Promise.withResolvers<"prompt" | "command">()
-    const requests: Parameters<ComposerSession["api"]["command"]>[0][] = []
-    const target = session({
-      calls: [],
-      prompt: async () => sent.resolve("prompt"),
-      command: async (value) => {
-        requests.push(value)
-        sent.resolve("command")
-      },
-    })
-    target.directory = "C:/new-worktree"
-    target.data.location.command.list = () => undefined
-    const adapter: NewSessionComposerAdapter = {
-      kind: "new-session",
-      state,
-      ready: () => true,
-      controls,
-      working: () => false,
-      submitted() {},
-      async start() {
-        // The destination catalog has not loaded, and the source composer is leaving.
-        catalog.splice(0)
-        return { session: target, cleanupReady: Promise.resolve() }
-      },
-    }
-
-    await submitInput(adapter, undefined, "normal", () => catalog).submit(new Event("submit"))
-
-    expect(await sent.promise).toBe("command")
-    expect(requests).toEqual([
-      {
-        sessionID: target.id,
-        command: "review",
-        text: "https://github.com/example/repo/pull/1",
-        files: [],
-        agents: [],
-        skills: [],
-        delivery: "steer",
-      },
-    ])
-  })
-
   test("does not run an empty shell command from hidden attachments", async () => {
     const state = createMemoryComposerState().capture()
     state.set([

packages/app/src/composer/submit.ts

@@ -27,7 +27,6 @@ type ComposerSubmission = {
 type ComposerSubmitInput = {
   adapter: ComposerAdapter
   mode: Accessor<"normal" | "shell">
-  commands: Accessor<readonly { name: string }[] | undefined>
   editor: () => HTMLDivElement | undefined
   queueScroll: () => void
   addToHistory: (prompt: Prompt, mode: "normal" | "shell") => void
@@ -66,8 +65,6 @@ export function createComposerSubmit(input: ComposerSubmitInput) {
     if (submitting.has(input.adapter.state)) return
     submitting.add(input.adapter.state)
     const comments = input.comments.capture()
-    // Capture command intent before starting a session in a worktree whose catalog has not loaded.
-    const command = value.mode === "normal" ? findCommand(input.commands(), value.text) : undefined
 
     try {
       const started =
@@ -81,6 +78,7 @@ export function createComposerSubmit(input: ComposerSubmitInput) {
       input.resetHistory()
       const restore = () => restoreSubmission(input, submission, value, comments)
 
+      const command = value.mode === "normal" ? findCommand(session, value.text) : undefined
       if (value.mode === "normal" && !command) {
         session.handoff?.set(handoffMessage(value))
         const optimisticBusy = !input.adapter.working()
@@ -279,11 +277,12 @@ async function sendShell(session: ComposerSession, value: ComposerSubmission) {
   await session.api.shell({ sessionID: session.id, id: Event.ID.create(), command: value.text })
 }
 
-function findCommand(commands: ReturnType<ComposerSubmitInput["commands"]>, text: string) {
+function findCommand(session: ComposerSession, text: string) {
   if (!text.startsWith("/")) return
   const [name, ...arguments_] = text.split(" ")
   const command = name.slice(1)
-  if (!commands?.some((item) => item.name === command)) return
+  if (!session.data.location.command.list({ directory: session.directory })?.some((item) => item.name === command))
+    return
   return { command, arguments: arguments_.join(" ") }
 }
 

packages/app/src/home/model.ts

@@ -3,8 +3,7 @@ import { type HomeProjectSelection, useLayout } from "@/shell/state/layout"
 import { ServerConnection, useServers } from "@/runtime/server/registry"
 import { useTabs } from "@/shell/tabs/tabs"
 import { toggleHomeProjectSelection } from "@/shell/layout/helpers"
-import { createEffect, createMemo, startTransition } from "solid-js"
-import type { SessionInfo } from "@opencode-ai/client/promise"
+import { createEffect, createMemo } from "solid-js"
 
 export function createHomeController() {
   const layout = useLayout()
@@ -46,18 +45,6 @@ export function createHomeController() {
     void tabs.newDraft({ server: ServerConnection.key(conn), directory })
   }
 
-  function openProjectSession(conn: ServerConnection.Any, directory: string, session: SessionInfo) {
-    const ctx = global.ensureServerCtx(conn)
-    void ctx.data.session.message.sync(session.id).catch(() => undefined)
-    void startTransition(() => {
-      const tab = tabs.addSessionTab({ server: ServerConnection.key(conn), sessionId: session.id })
-      tabs.select(tab)
-      ctx.data.session.remember(session)
-      ctx.projects.open(directory)
-      ctx.projects.touch(directory)
-    })
-  }
-
   return {
     selection: {
       value: selection,
@@ -118,7 +105,6 @@ export function createHomeController() {
         openProjectNewSession(conn, project.worktree)
       },
       openProjectNewSession,
-      openProjectSession,
     },
   }
 }

packages/app/src/home/projects/controller.tsx

@@ -14,7 +14,6 @@ import { Schema } from "effect"
 import { Persistence } from "@/runtime/persistence/schema"
 import type { HomeController } from "../model"
 import { useGlobal } from "@/runtime/server/runtime"
-import { SessionTransfer } from "@opencode-ai/schema/session-transfer"
 
 export const HomeServersSchema = Schema.Struct({
   collapsed: Persistence.record(Persistence.fallback(Schema.Boolean, () => false)),
@@ -80,35 +79,6 @@ export function createHomeProjectsController(home: HomeController) {
       select: home.project.select,
       add: home.project.add,
       openNewSession: home.project.openProjectNewSession,
-      canImportSession: !!platform.openAttachmentPickerDialog,
-      importSession: (conn: ServerConnection.Any, project: LocalProject) => {
-        if (!platform.openAttachmentPickerDialog) return
-        void platform
-          .openAttachmentPickerDialog(
-            {
-              title: language.t("command.session.import"),
-              accept: ["application/json"],
-              extensions: ["json"],
-            },
-            async (file) => {
-              const data = await Schema.decodeUnknownPromise(Schema.fromJsonString(SessionTransfer.Data))(
-                await file.text(),
-              )
-              const api = home.server.context(conn).sdk.api.session
-              const imported = await api.import({
-                ...Schema.encodeSync(SessionTransfer.Data)(data),
-                location: { directory: project.worktree },
-              } as Parameters<typeof api.import>[0])
-              home.project.openProjectSession(conn, project.worktree, imported)
-            },
-          )
-          .catch((cause: unknown) => {
-            showToast({
-              title: language.t("common.requestFailed"),
-              description: errorMessage(cause, language.t("common.requestFailed")),
-            })
-          })
-      },
       edit: (conn: ServerConnection.Any, project: LocalProject) => {
         void import("@/settings/workspaces/project-dialog").then(({ DialogEditProject }) => {
           void dialog.show(() => <DialogEditProject server={conn} project={project} />)

packages/app/src/home/projects/region.tsx

@@ -37,8 +37,6 @@ export function HomeProjects(props: {
       onSelectProject={props.projects.project.select}
       onAddProjects={props.projects.project.add}
       onOpenProjectNewSession={props.projects.project.openNewSession}
-      canImportSession={props.projects.project.canImportSession}
-      onImportSession={props.projects.project.importSession}
       onEditProject={props.projects.project.edit}
       onRevealProject={props.projects.project.reveal}
       onClearNotifications={props.projects.project.clearNotifications}

packages/app/src/home/projects/view.tsx

@@ -57,8 +57,6 @@ export type HomeProjectsViewProps = {
   onSelectProject: (server: ServerConnection.Any, directory: string) => void
   onAddProjects: (server: ServerConnection.Any, directories: string[]) => void
   onOpenProjectNewSession: (server: ServerConnection.Any, directory: string) => void
-  canImportSession: boolean
-  onImportSession: (server: ServerConnection.Any, project: LocalProject) => void
   onEditProject: (server: ServerConnection.Any, project: LocalProject) => void
   onRevealProject: (server: ServerConnection.Any, project: LocalProject) => void
   onClearNotifications: (server: ServerConnection.Any, project: LocalProject) => void
@@ -672,11 +670,6 @@ function HomeProjectRow(
               <Menu.Item onSelect={() => props.onOpenProjectNewSession(props.server, props.project.worktree)}>
                 {props.language.t("command.session.new")}
               </Menu.Item>
-              <Show when={props.canImportSession}>
-                <Menu.Item onSelect={() => props.onImportSession(props.server, props.project)}>
-                  {props.language.t("command.session.import")}
-                </Menu.Item>
-              </Show>
               <Menu.Item onSelect={() => props.onEditProject(props.server, props.project)}>
                 {props.language.t("dialog.project.edit.title")}
               </Menu.Item>

packages/app/src/home/sessions/command-palette.tsx

@@ -52,9 +52,10 @@ export function HomeCommandPalette(props: {
     }
     if (item.type === "session") props.onSelectSession(item)
   }
-  const items = (query: string) => {
+  const loadItems = async (text: string) => {
+    const query = text.trim()
     if (!query) return commandEntries().slice(0, 5)
-    return commandEntries().filter((entry) => matchesCommandPaletteEntry(entry, query))
+    return [...commandEntries().filter((entry) => matchesCommandPaletteEntry(entry, query)), ...(await sessions(query))]
   }
 
   onCleanup(() => {
@@ -65,8 +66,7 @@ export function HomeCommandPalette(props: {
   return (
     <CommandPaletteView
       placeholder={language.t("palette.search.placeholder.home")}
-      items={items}
-      sources={[sessions]}
+      loadItems={loadItems}
       highlight={highlight}
       select={select}
       close={() => dialog.close()}

packages/app/src/home/sessions/controller.tsx

@@ -21,8 +21,7 @@ import { errorMessage } from "@/shell/layout/helpers"
 import { useSessionTabAvatarState } from "@/shell/layout/project-avatar-state"
 import { removedSessionIDs } from "@/session/session-domain"
 import { pathKey } from "@/workspaces/path-key"
-import { fetchSessionExport, saveSessionExport, sessionExportFilename } from "@/session/commands/export"
-import { usePlatform } from "@/runtime/platform/platform"
+import { downloadSessionExport, fetchSessionExport, sessionExportFilename } from "@/session/commands/export"
 import { sessionLabel, sessionTitle } from "@/session/title"
 import { showToast } from "@/shell/notifications/toast"
 import { archiveHomeSession } from "./archive"
@@ -46,7 +45,6 @@ export function createHomeSessionsController(home: HomeController) {
   const command = useCommand()
   const dialog = useDialog()
   const language = useLanguage()
-  const platform = usePlatform()
   const queryClient = useQueryClient()
   const projectDirectories = createMemo(() => {
     const selected = home.selection.value().directory
@@ -174,7 +172,7 @@ export function createHomeSessionsController(home: HomeController) {
     try {
       const data = await fetchSessionExport({ sessionID: session.id, api: ctx.sdk.api })
       const filename = sessionExportFilename(data.info)
-      if (!(await saveSessionExport(filename, data, platform))) return
+      downloadSessionExport(filename, data)
       showToast({
         variant: "success",
         icon: "circle-check",

packages/app/src/index.css

@@ -319,69 +319,6 @@
     }
   }
 
-  @keyframes session-dropzone-enter {
-    from {
-      opacity: 0;
-    }
-  }
-
-  @keyframes session-dropzone-content-enter {
-    from {
-      opacity: 0;
-      transform: translateY(4px) scale(0.96);
-    }
-  }
-
-  @keyframes session-dropzone-upload-enter {
-    from {
-      opacity: 0;
-      transform: translateY(4px) scale(0.92);
-    }
-  }
-
-  @keyframes session-dropzone-stripes-drift {
-    to {
-      background-position: 33.941px 0;
-    }
-  }
-
-  [data-component="session-dropzone"][data-visible="true"] {
-    animation: session-dropzone-enter 200ms cubic-bezier(0.215, 0.61, 0.355, 1);
-  }
-
-  [data-component="session-dropzone"][data-visible="true"] [data-slot="session-dropzone-content"] {
-    animation: session-dropzone-content-enter 200ms cubic-bezier(0.215, 0.61, 0.355, 1);
-  }
-
-  [data-component="session-dropzone"][data-visible="true"] [data-slot="session-dropzone-upload"] {
-    animation: session-dropzone-upload-enter 240ms cubic-bezier(0.215, 0.61, 0.355, 1);
-  }
-
-  [data-component="session-dropzone"][data-visible="true"] [data-slot="session-dropzone-stripes"] {
-    animation: session-dropzone-stripes-drift 3s linear infinite;
-  }
-
-  [data-component="session-dropzone"] {
-    --session-dropzone-wash: 4%;
-    --session-dropzone-stripe: 7%;
-    --session-dropzone-card: var(--v2-background-bg-base);
-  }
-
-  [data-color-scheme="dark"] [data-component="session-dropzone"] {
-    --session-dropzone-wash: 6%;
-    --session-dropzone-stripe: 14%;
-    --session-dropzone-card: var(--v2-background-bg-layer-01);
-  }
-
-  @media (prefers-reduced-motion: reduce) {
-    [data-component="session-dropzone"][data-visible="true"],
-    [data-component="session-dropzone"][data-visible="true"] [data-slot="session-dropzone-content"],
-    [data-component="session-dropzone"][data-visible="true"] [data-slot="session-dropzone-upload"],
-    [data-component="session-dropzone"][data-visible="true"] [data-slot="session-dropzone-stripes"] {
-      animation: none;
-    }
-  }
-
   [data-slot="home-projects-scroll"] {
     timeline-scope: --home-projects-scroll;
   }

packages/app/src/runtime/i18n/am.ts

@@ -133,7 +133,6 @@ export const dict = {
   "command.language.cycle": "ሳይክል ቋንቋ",
   "command.language.set": "ቋንቋን ተጠቀም፡ {{language}}",
   "command.session.new": "አዲስ ክፍለ ጊዜ",
-  "command.session.import": "ክፍለ ጊዜ ማስመጣት",
   "command.file.open": "ክፍት ፋይል",
   "command.tab.close": "ትርፉን ዝጋ",
   "command.tab.reopenClosed": "የተዘጋውን ትር እንደገና ክፈት",

packages/app/src/runtime/i18n/ar.ts

@@ -139,7 +139,6 @@ export const dict = {
   "command.language.cycle": "تغيير اللغة",
   "command.language.set": "استخدام اللغة: {{language}}",
   "command.session.new": "جلسة جديدة",
-  "command.session.import": "استيراد جلسة",
   "command.file.open": "فتح ملف",
   "command.tab.close": "إغلاق علامة التبويب",
   "command.tab.reopenClosed": "إعادة فتح علامة التبويب المغلقة",

packages/app/src/runtime/i18n/az.ts

@@ -135,7 +135,6 @@ export const dict = {
   "command.language.cycle": "Dili dəyiş",
   "command.language.set": "Dildən istifadə et: {{language}}",
   "command.session.new": "Yeni sessiya",
-  "command.session.import": "Sessiyanı idxal et",
   "command.file.open": "Faylı aç",
   "command.tab.close": "Tabı bağla",
   "command.tab.reopenClosed": "Bağlanmış tabı yenidən aç",

packages/app/src/runtime/i18n/bg.ts

@@ -135,7 +135,6 @@ export const dict = {
   "command.language.cycle": "Цикличен език",
   "command.language.set": "Използвайте език: {{language}}",
   "command.session.new": "Нова сесия",
-  "command.session.import": "Импортиране на сесия",
   "command.file.open": "Отворете файла",
   "command.tab.close": "Затваряне на раздела",
   "command.tab.reopenClosed": "Повторно отваряне на затворен раздел",

packages/app/src/runtime/i18n/bn.ts

@@ -134,7 +134,6 @@ export const dict: Record<string, string> = {
   "command.language.cycle": "সাইকেল ভাষা",
   "command.language.set": "ভাষা ব্যবহার করুন: {{language}}",
   "command.session.new": "নতুন সেশন",
-  "command.session.import": "সেশন আমদানি করুন",
   "command.file.open": "ফাইল খুলুন",
   "command.tab.close": "ট্যাব বন্ধ করুন",
   "command.tab.reopenClosed": "বন্ধ ট্যাব আবার খুলুন",

packages/app/src/runtime/i18n/br.ts

@@ -141,7 +141,6 @@ export const dict = {
   "command.language.cycle": "Alternar idioma",
   "command.language.set": "Usar idioma: {{language}}",
   "command.session.new": "Nova sessão",
-  "command.session.import": "Importar sessão",
   "command.file.open": "Abrir arquivo",
   "command.tab.close": "Fechar aba",
   "command.tab.reopenClosed": "Reabrir aba fechada",

packages/app/src/runtime/i18n/bs.ts

@@ -147,7 +147,6 @@ export const dict = {
   "command.language.set": "Koristi jezik: {{language}}",
 
   "command.session.new": "Nova sesija",
-  "command.session.import": "Uvezi sesiju",
   "command.file.open": "Otvori datoteku",
   "command.tab.close": "Zatvori karticu",
   "command.tab.reopenClosed": "Ponovo otvori zatvorenu karticu",

packages/app/src/runtime/i18n/ca.ts

@@ -135,7 +135,6 @@ export const dict = {
   "command.language.cycle": "Llenguatge de cicle",
   "command.language.set": "Utilitza l'idioma: {{language}}",
   "command.session.new": "Nova sessió",
-  "command.session.import": "Importa la sessió",
   "command.file.open": "Obre el fitxer",
   "command.tab.close": "Tanca la pestanya",
   "command.tab.reopenClosed": "Torneu a obrir la pestanya tancada",

packages/app/src/runtime/i18n/cs.ts

@@ -133,7 +133,6 @@ export const dict = {
   "command.language.cycle": "Jazyk cyklu",
   "command.language.set": "Použít jazyk: {{language}}",
   "command.session.new": "Nová relace",
-  "command.session.import": "Importovat relaci",
   "command.file.open": "Otevřít soubor",
   "command.tab.close": "Zavřít kartu",
   "command.tab.reopenClosed": "Znovu otevřete zavřenou kartu",

packages/app/src/runtime/i18n/da.ts

@@ -46,7 +46,6 @@ export const dict = {
   "command.language.set": "Brug sprog: {{language}}",
 
   "command.session.new": "Ny session",
-  "command.session.import": "Importer session",
   "command.file.open": "Åbn fil",
   "command.tab.close": "Luk fane",
   "command.tab.reopenClosed": "Åbn lukket fane igen",

packages/app/src/runtime/i18n/de.ts

@@ -44,7 +44,6 @@ export const dict = {
   "command.language.cycle": "Sprache wechseln",
   "command.language.set": "Sprache verwenden: {{language}}",
   "command.session.new": "Neue Sitzung",
-  "command.session.import": "Sitzung importieren",
   "command.file.open": "Datei öffnen",
   "command.tab.close": "Tab schließen",
   "command.tab.reopenClosed": "Geschlossenen Tab wieder öffnen",

packages/app/src/runtime/i18n/dv.ts

@@ -136,7 +136,6 @@ export const dict = {
   "command.language.cycle": "ސައިކަލް ބަސް",
   "command.language.set": "ބަސް ބޭނުންކުރުން: {{language}}",
   "command.session.new": "އާ ޖަލްސާއެއް",
-  "command.session.import": "ޖަލްސާ އިމްޕޯޓް ކުރައްވާ",
   "command.file.open": "ފައިލް ހުޅުވާލާށެވެ",
   "command.tab.close": "ޓެބް ބަންދުކުރުން",
   "command.tab.reopenClosed": "ބަންދުކޮށްފައިވާ ޓެބް އަލުން ހުޅުވާލާށެވެ",

packages/app/src/runtime/i18n/dz.ts

@@ -136,7 +136,6 @@ export const dict: Record<string, string> = {
   "command.language.cycle": "འཁོར་བའི་སྐད་ཡིག།",
   "command.language.set": "སྐད་ཡིག་ལག་ལེན་འཐབ།: {{language}}",
   "command.session.new": "ལཱ་ཡུན་གསརཔ།",
-  "command.session.import": "ལཱ་ཡུན་ནང་འདྲེན།",
   "command.file.open": "ཡིག་སྣོད་ཁ་ཕྱེ།",
   "command.tab.close": "མཆོང་ལྡེ་ཁ་བསྡམས།",
   "command.tab.reopenClosed": "ཁ་བསྡམས་ཡོད་པའི་མཆོང་ལྡེ་ལོག་ཁ་ཕྱེ།",

packages/app/src/runtime/i18n/el.ts

@@ -134,7 +134,6 @@ export const dict = {
   "command.language.cycle": "Γλώσσα κύκλου",
   "command.language.set": "Γλώσσα χρήσης: {{language}}",
   "command.session.new": "Νέα συνεδρία",
-  "command.session.import": "Εισαγωγή συνεδρίας",
   "command.file.open": "Άνοιγμα αρχείου",
   "command.tab.close": "Κλείσιμο καρτέλας",
   "command.tab.reopenClosed": "Άνοιγμα ξανά κλειστής καρτέλας",

packages/app/src/runtime/i18n/en.ts

@@ -100,7 +100,6 @@ export const dict = {
   "command.session.fork.description": "Create a new session from a previous message",
   "command.session.export": "Export session",
   "command.session.export.description": "Export the full session transcript as JSON",
-  "command.session.import": "Import session",
   "command.session.copyID": "Copy Session ID",
 
   "palette.search.placeholder": "Search files, commands, and sessions",
@@ -676,14 +675,11 @@ export const dict = {
   "session.error.incompatible.description":
     "{{server}} is running OpenCode {{version}}, which isn't compatible with this app. Upgrade the server to OpenCode V2 to continue.",
   "session.background.moveTasks": "Move {{tasks}} to background",
-  "session.background.moveRunning": "Move running work to background",
   "session.background.inBackground": "Running {{tasks}} in background",
   "session.background.moveInline": "Press {{keybind}} to move running work to the background",
   "session.background.running": "Running work in background",
   "session.background.runningCount.one": "{{count}} item running in background",
   "session.background.runningCount.other": "{{count}} items running in background",
-  "session.background.tasksRunning.one": "{{count}} background task running",
-  "session.background.tasksRunning.other": "{{count}} background tasks running",
   "session.background.combine": "{{first}} and {{second}}",
   "session.background.shell.one": "{{count}} shell",
   "session.background.shell.other": "{{count}} shells",
@@ -812,10 +808,6 @@ export const dict = {
 
   "titlebar.update": "Update",
   "titlebar.tabs": "Tabs",
-  "titlebar.channel.local": "Local",
-  "titlebar.channel.dev": "Dev",
-  "titlebar.channel.beta": "Beta",
-  "titlebar.toggleDebugTools": "Toggle debug tools",
   "titlebar.updateVersion": "Update {{version}}",
 
   "common.closeTab": "Close tab",
@@ -912,25 +904,6 @@ export const dict = {
   "settings.tab.notifications": "Notifications",
   "settings.tab.projects": "Projects",
   "settings.tab.extensions": "Extensions",
-  "settings.tab.experimental": "Experimental",
-  "settings.experimental.description": "Try experimental features",
-  "settings.tab.about": "About",
-  "settings.about.version": "Version {{version}}",
-  "settings.about.devVersion": "development",
-  "settings.about.license": "Released under the MIT License",
-  "settings.about.writtenBy": "Written by",
-  "settings.about.illustratedBy": "Illustrated by",
-  "settings.about.and": "and",
-  "settings.about.otherContributor.one": "{{count}} other",
-  "settings.about.otherContributor.other": "{{count}} others",
-  "settings.about.firstPublished": "First published in Missouri, USA",
-  "settings.about.firstIllustrated": "First illustrated in London, England",
-  "settings.about.website": "www.opencode.ai",
-  "settings.about.description": "OpenCode, the open source coding agent",
-  "settings.about.trademark": "OpenCode is a registered trademark of Anomaly Innovations, Inc.",
-  "settings.about.typeset": "Typeset in Inter and IBM Plex Mono",
-  "settings.about.tagline": "AI can’t build great software, without you",
-  "settings.about.copyright": "© Anomaly Innovations, Inc.",
   "settings.preferences.description": "Customize preferences and theme and default behavior",
   "settings.appearance.description": "Customize theme and fonts",
   "settings.appearance.section.experimental": "Experimental",
@@ -958,7 +931,6 @@ export const dict = {
   "settings.desktop.wsl.title": "WSL integration",
   "settings.desktop.wsl.description": "Run the OpenCode server inside WSL on Windows.",
   "dialog.server.authenticate.title": "Authenticate",
-  "project.settings.title": "Edit project",
   "project.settings.general.description": "Manage project name and appearance",
   "project.settings.scripts": "Scripts",
   "project.settings.scripts.description": "Configure scripts for this project",

packages/app/src/runtime/i18n/es.ts

@@ -147,7 +147,6 @@ export const dict = {
   "command.language.set": "Usar idioma: {{language}}",
 
   "command.session.new": "Nueva sesión",
-  "command.session.import": "Importar sesión",
   "command.file.open": "Abrir archivo",
   "command.tab.close": "Cerrar pestaña",
   "command.tab.reopenClosed": "Reabrir pestaña cerrada",

packages/app/src/runtime/i18n/et.ts

@@ -133,7 +133,6 @@ export const dict = {
   "command.language.cycle": "Tsükli keel",
   "command.language.set": "Kasuta keelt: {{language}}",
   "command.session.new": "Uus seanss",
-  "command.session.import": "Impordi seanss",
   "command.file.open": "Ava fail",
   "command.tab.close": "Sule vahekaart",
   "command.tab.reopenClosed": "Ava suletud vaheleht uuesti",

packages/app/src/runtime/i18n/fa.ts

@@ -134,7 +134,6 @@ export const dict = {
   "command.language.cycle": "زبان چرخه",
   "command.language.set": "استفاده از زبان: {{language}}",
   "command.session.new": "جلسه جدید",
-  "command.session.import": "وارد کردن جلسه",
   "command.file.open": "باز کردن فایل",
   "command.tab.close": "بستن برگه",
   "command.tab.reopenClosed": "برگه بسته را دوباره باز کنید",

packages/app/src/runtime/i18n/fi.ts

@@ -40,7 +40,6 @@ export const dict = {
   "command.language.cycle": "Vaihda kieltä",
   "command.language.set": "Käytä kieltä: {{language}}",
   "command.session.new": "Uusi istunto",
-  "command.session.import": "Tuo istunto",
   "command.file.open": "Avaa tiedosto",
   "command.tab.close": "Sulje välilehti",
   "command.tab.reopenClosed": "Avaa suljettu välilehti uudelleen",

packages/app/src/runtime/i18n/fo.ts

@@ -133,7 +133,6 @@ export const dict = {
   "command.language.cycle": "Súkklumál",
   "command.language.set": "Brúka mál: {{language}}",
   "command.session.new": "Nýggj setan",
-  "command.session.import": "Innflyt setan",
   "command.file.open": "Opna fíluna",
   "command.tab.close": "Lat flipan aftur",
   "command.tab.reopenClosed": "Opna aftur stongdan flipan",

packages/app/src/runtime/i18n/fr.ts

@@ -141,7 +141,6 @@ export const dict = {
   "command.language.cycle": "Changer de langue",
   "command.language.set": "Utiliser la langue : {{language}}",
   "command.session.new": "Nouvelle session",
-  "command.session.import": "Importer une session",
   "command.file.open": "Ouvrir un fichier",
   "command.tab.close": "Fermer l'onglet",
   "command.tab.reopenClosed": "Rouvrir l'onglet fermé",

packages/app/src/runtime/i18n/he.ts

@@ -134,7 +134,6 @@ export const dict = {
   "command.language.cycle": "מעבר לשפה הבאה",
   "command.language.set": "השתמש בשפה: {{language}}",
   "command.session.new": "הפעלה חדשה",
-  "command.session.import": "ייבוא הפעלה",
   "command.file.open": "פתח את הקובץ",
   "command.tab.close": "סגור כרטיסייה",
   "command.tab.reopenClosed": "פתח מחדש את הכרטיסייה הסגורה",

packages/app/src/runtime/i18n/hi.ts

@@ -140,7 +140,6 @@ export const dict = {
   "command.language.cycle": "भाषा बदलें",
   "command.language.set": "भाषा का प्रयोग करें: {{language}}",
   "command.session.new": "नया सेशन",
-  "command.session.import": "सेशन आयात करें",
   "command.file.open": "फ़ाइल खोलें",
   "command.tab.close": "टैब बंद करें",
   "command.tab.reopenClosed": "बंद टैब पुनः खोलें",

packages/app/src/runtime/i18n/hr.ts

@@ -137,7 +137,6 @@ export const dict = {
   "command.language.cycle": "Promijeni jezik",
   "command.language.set": "Koristite jezik: {{language}}",
   "command.session.new": "Nova sesija",
-  "command.session.import": "Uvezi sesiju",
   "command.file.open": "Otvori datoteku",
   "command.tab.close": "Zatvori karticu",
   "command.tab.reopenClosed": "Ponovno otvori zatvorenu karticu",

packages/app/src/runtime/i18n/hu.ts

@@ -137,7 +137,6 @@ export const dict = {
   "command.language.cycle": "Nyelv váltása",
   "command.language.set": "Nyelv használata: {{language}}",
   "command.session.new": "Új munkamenet",
-  "command.session.import": "Munkamenet importálása",
   "command.file.open": "Nyissa meg a fájlt",
   "command.tab.close": "Lap bezárása",
   "command.tab.reopenClosed": "Nyissa meg újra a bezárt lapot",

packages/app/src/runtime/i18n/hy.ts

@@ -135,7 +135,6 @@ export const dict = {
   "command.language.cycle": "Ցիկլի լեզու",
   "command.language.set": "Օգտագործել լեզուն՝ {{language}}",
   "command.session.new": "Նոր նիստ",
-  "command.session.import": "Ներմուծել նիստը",
   "command.file.open": "Բացել ֆայլ",
   "command.tab.close": "Փակել ներդիրը",
   "command.tab.reopenClosed": "Վերաբացել փակ ներդիրը",

packages/app/src/runtime/i18n/id.ts

@@ -147,7 +147,6 @@ export const dict = {
   "command.language.set": "Gunakan bahasa: {{language}}",
 
   "command.session.new": "Sesi baru",
-  "command.session.import": "Impor sesi",
   "command.file.open": "Buka berkas",
   "command.tab.close": "Tutup tab",
   "command.tab.reopenClosed": "Buka kembali tab yang ditutup",

packages/app/src/runtime/i18n/is.ts

@@ -137,7 +137,6 @@ export const dict = {
   "command.language.cycle": "Skipta um tungumál",
   "command.language.set": "Notaðu tungumál: {{language}}",
   "command.session.new": "Ný seta",
-  "command.session.import": "Flytja inn setu",
   "command.file.open": "Opna skrá",
   "command.tab.close": "Loka flipa",
   "command.tab.reopenClosed": "Opnaðu aftur lokaðan flipa",

packages/app/src/runtime/i18n/it.ts

@@ -41,7 +41,6 @@ export const dict = {
   "command.language.cycle": "Cambia lingua",
   "command.language.set": "Usa la lingua: {{language}}",
   "command.session.new": "Nuova sessione",
-  "command.session.import": "Importa sessione",
   "command.file.open": "Apri file",
   "command.tab.close": "Chiudi scheda",
   "command.tab.reopenClosed": "Riapri la scheda chiusa",

packages/app/src/runtime/i18n/ja.ts

@@ -139,7 +139,6 @@ export const dict = {
   "command.language.cycle": "言語の切り替え",
   "command.language.set": "言語を使用: {{language}}",
   "command.session.new": "新しいセッション",
-  "command.session.import": "セッションをインポート",
   "command.file.open": "ファイルを開く",
   "command.tab.close": "タブを閉じる",
   "command.tab.reopenClosed": "閉じたタブを再度開く",

packages/app/src/runtime/i18n/ka.ts

@@ -133,7 +133,6 @@ export const dict = {
   "command.language.cycle": "ციკლის ენა",
   "command.language.set": "გამოიყენე ენა: {{language}}",
   "command.session.new": "ახალი სესია",
-  "command.session.import": "სესიის იმპორტი",
   "command.file.open": "გახსენით ფაილი",
   "command.tab.close": "ჩანართის დახურვა",
   "command.tab.reopenClosed": "დახურული ჩანართის ხელახლა გახსნა",

packages/app/src/runtime/i18n/km.ts

@@ -133,7 +133,6 @@ export const dict = {
   "command.language.cycle": "ភាសាវដ្ត",
   "command.language.set": "ប្រើភាសា៖ {{language}}",
   "command.session.new": "សម័យថ្មី។",
-  "command.session.import": "នាំចូលសម័យ",
   "command.file.open": "បើកឯកសារ",
   "command.tab.close": "បិទផ្ទាំង",
   "command.tab.reopenClosed": "បើកផ្ទាំងបិទឡើងវិញ",

packages/app/src/runtime/i18n/ko.ts

@@ -37,7 +37,6 @@ export const dict = {
   "command.language.cycle": "언어 순환",
   "command.language.set": "언어 사용: {{language}}",
   "command.session.new": "새 세션",
-  "command.session.import": "세션 가져오기",
   "command.file.open": "파일 열기",
   "command.tab.close": "탭 닫기",
   "command.context.addSelection": "선택 영역을 컨텍스트에 추가",