test(core): stabilize shell exit-order test

The sequential PowerShell spawn/remove loop can cross Bun’s default 5-second test timeout on Windows. Give this process-heavy test the same explicit 15-second budget used by adjacent shell lifecycle coverage.
2026-08-23 10:06:09 +00:00 · 2026-08-22 13:14:03 +00:00
219 changed files with 2603 additions and 5488 deletions
@@ -27,6 +27,7 @@ jobs:
        working-directory: packages/www
        run: bun run build
        env:
+          BLUME_ENV: ${{ github.ref_name == 'v2' && 'production' || 'dev' }}
          CLOUDFLARE_ENV: ${{ github.ref_name == 'v2' && 'production' || 'dev' }}

      - name: Deploy
@@ -91,7 +91,7 @@ jobs:

      - uses: ./.github/actions/setup-bun
        with:
-          bun-version: 1.4.0
+          bun-version: canary # Bun 1.4 until its stable release is published

      - name: Setup git committer
        id: committer
@@ -113,7 +113,7 @@ jobs:
        id: build
        run: ./packages/cli/script/build.ts ${{ (github.ref_name == 'beta' && '--sourcemaps') || '' }}
        env:
-          BUN_COMPILE_RELEASE: bun-v1.4.0
+          BUN_COMPILE_RELEASE: canary
          OPENCODE_VERSION: ${{ needs.version.outputs.version }}
          OPENCODE_RELEASE: ${{ needs.version.outputs.release }}
          GH_REPO: ${{ needs.version.outputs.repo }}
@@ -195,33 +195,9 @@ jobs:
          path: packages/cli/dist/cli-*
          if-no-files-found: error

-  build-node-app-archive:
-    needs: version
-    runs-on: blacksmith-4vcpu-ubuntu-2404
-    timeout-minutes: 30
-    if: github.repository == 'anomalyco/opencode'
-    steps:
-      - uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 # v3.6.0
-
-      - uses: ./.github/actions/setup-bun
-
-      - name: Build app archive
-        run: bun packages/cli/script/build-node.ts --app-archive-only --app-archive=.cache/app-archive.bin --skip-install
-        env:
-          OPENCODE_VERSION: ${{ needs.version.outputs.version }}
-          OPENCODE_RELEASE: ${{ needs.version.outputs.release }}
-
-      - uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
-        with:
-          name: opencode-node-app-archive
-          path: packages/cli/.cache/app-archive.bin
-          if-no-files-found: error
-
  build-node-cli:
-    needs:
-      - version
-      - build-node-app-archive
-    if: github.repository == 'anomalyco/opencode'
+    needs: version
+    if: github.repository == 'anomalyco/opencode' && false # Temporarily disabled
    strategy:
      fail-fast: false
      matrix:
@@ -251,13 +227,8 @@ jobs:
        with:
          node-version: "26.4.0"

-      - uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4.3.0
-        with:
-          name: opencode-node-app-archive
-          path: packages/cli/.cache
-
      - name: Build
-        run: bun packages/cli/script/build-node.ts --target=${{ matrix.settings.target }} --skip-install --outdir=dist/node --app-archive=.cache/app-archive.bin
+        run: bun packages/cli/script/build-node.ts --target=${{ matrix.settings.target }} --skip-install --outdir=dist/node
        env:
          OPENCODE_VERSION: ${{ needs.version.outputs.version }}
          OPENCODE_RELEASE: ${{ needs.version.outputs.release }}
@@ -572,7 +543,6 @@ jobs:
      - version
      - build-cli
      - sign-cli-macos
-      - build-node-app-archive
      - build-node-cli
      - sign-cli-windows
      - build-electron
@@ -1,8 +1,8 @@
 {
  "nodeModules": {
-    "x86_64-linux": "sha256-tdNjQEuCMADQJpeAK0BajPyQkt8X2pS9foyQYxj+vgg=",
-    "aarch64-linux": "sha256-RXvYaZXpgTyZzgPu74fat1bbT9zJUf+S0kpm9rXtr6k=",
-    "aarch64-darwin": "sha256-MDinXCNrEn5pH75nmK/dsl78hcS4gu913Sf2fxj40r0=",
-    "x86_64-darwin": "sha256-pn9t+1sNDjQh25nfPozD11aIJJsHgxhU9uB4tR0UnJk="
+    "x86_64-linux": "sha256-xRvq8FkSjn+1q+1wcab+jAmQJdo8lHF8OGnzU+xPLyI=",
+    "aarch64-linux": "sha256-uAwwtOz81LLimTqiDH6E1W65srSMLGk1QV0cUJYanj0=",
+    "aarch64-darwin": "sha256-F28kZvtYRb+ri5T8JoIG/VMK6J7ad5R3QivwJDLtmWA=",
+    "x86_64-darwin": "sha256-NWNoBjwQTTNAESdFWItT4UYc+fTLD1RIe/Ibbqtem7Q="
  }
 }
@@ -49,10 +49,10 @@
      "@octokit/rest": "22.0.0",
      "@hono/standard-validator": "0.2.0",
      "@hono/zod-validator": "0.4.2",
-      "@opentui/core": "0.5.7",
-      "@opentui/keymap": "0.5.7",
-      "@opentui/solid": "0.5.7",
-      "@tanstack/solid-virtual": "3.13.37",
+      "@opentui/core": "0.5.6",
+      "@opentui/keymap": "0.5.6",
+      "@opentui/solid": "0.5.6",
+      "@tanstack/solid-virtual": "3.13.32",
      "@shikijs/stream": "4.2.0",
      "@standard-schema/spec": "1.1.0",
      "ulid": "3.0.1",
@@ -174,7 +174,7 @@
    "@ai-sdk/google@3.0.73": "patches/@ai-sdk%2Fgoogle@3.0.73.patch",
    "@pierre/trees@1.0.0-beta.4": "patches/@pierre%2Ftrees@1.0.0-beta.4.patch",
    "@modelcontextprotocol/sdk@1.29.0": "patches/@modelcontextprotocol%2Fsdk@1.29.0.patch",
-    "@tanstack/virtual-core@3.17.8": "patches/@tanstack%2Fvirtual-core@3.17.8.patch",
+    "@tanstack/virtual-core@3.17.3": "patches/@tanstack%2Fvirtual-core@3.17.3.patch",
    "@ff-labs/fff-bun@0.10.5": "patches/@ff-labs%2Ffff-bun@0.10.5.patch"
  }
 }
@@ -8,4 +8,3 @@ export * as OpenAICompatibleResponses from "./openai-compatible-responses.js"
 export * as OpenAIResponses from "./openai-responses.js"
 export * as OpenResponses from "./open-responses.js"
 export * as OpenResponsesChannel from "./open-responses-channel.js"
-export * as XAIResponses from "./xai-responses.js"
@@ -10,7 +10,6 @@ import {
 } from "../route/transport/index.js"
 import * as ProviderShared from "./shared.js"
 import { OpenResponses } from "./open-responses.js"
-import { OpenResponsesContinuation } from "./open-responses-continuation.js"

 const WebSocketResponseCreate = Schema.StructWithRest(Schema.Struct({ type: Schema.tag("response.create") }), [
  Schema.Record(Schema.String, Schema.Unknown),
@@ -26,6 +25,11 @@ export interface Options {
  readonly enabled?: (url: string) => boolean
  readonly url?: (url: string) => string
  readonly headers?: (headers: Headers.Headers) => Headers.Headers
+  readonly driver?: (input: {
+    readonly request: Readonly<Record<string, unknown>>
+    readonly message: string
+    readonly base: WebSocketChannelDriver
+  }) => WebSocketChannelDriver
 }

 export interface Prepared {
@@ -154,13 +158,7 @@ export const transport = <Body>(options: Options): Transport<Body, Prepared, str
                  url: yield* WebSocketTransport.toWebSocketUrl(options.url?.(parts.url) ?? parts.url),
                  headers,
                  rotateAfterMs: options.rotateAfterMs,
-                  driver: OpenResponsesContinuation.driver({
-                    id: options.id,
-                    name: options.name,
-                    request: create.request,
-                    message: create.message,
-                    base,
-                  }),
+                  driver: options.driver?.({ request: create.request, message: create.message, base }) ?? base,
                }
              })
            : undefined
@@ -42,12 +42,8 @@ const OpenResponsesInputImage = Schema.Struct({
 const OpenResponsesInputFile = Schema.Struct({
  type: Schema.tag("input_file"),
  filename: Schema.String,
-  file_data: Schema.optional(Schema.String),
-  file_url: Schema.optional(Schema.String),
-})
-const OpenResponsesInputVideo = Schema.Struct({
-  type: Schema.tag("input_video"),
-  video_url: Schema.String,
+  file_data: Schema.String,
+  mime_type: Schema.optional(Schema.String),
 })
 const MediaInput = Schema.Union([OpenResponsesInputImage, OpenResponsesInputFile])
 export type MediaInput = Schema.Schema.Type<typeof MediaInput>
@@ -58,14 +54,9 @@ const OpenResponsesOutputText = Schema.Struct({
  text: Schema.String,
 })

-export const MessagePhase = Schema.NullOr(Schema.Literals(["commentary", "final_answer"]))
+export const MessagePhase = Schema.Literals(["commentary", "final_answer"])
 type MessagePhase = Schema.Schema.Type<typeof MessagePhase>

-const messagePhase = (value: unknown): MessagePhase | undefined => {
-  if (value === null || value === "commentary" || value === "final_answer") return value
-  return undefined
-}
-
 const OpenResponsesReasoningSummaryText = Schema.Struct({
  type: Schema.tag("summary_text"),
  text: Schema.String,
@@ -90,7 +81,6 @@ const OpenResponsesFunctionCallOutputContent = Schema.Union([
  OpenResponsesInputText,
  OpenResponsesInputImage,
  OpenResponsesInputFile,
-  OpenResponsesInputVideo,
 ])

 const OpenResponsesFunctionCallOutput = Schema.Union([
@@ -247,7 +237,6 @@ const OpenResponsesErrorPayload = Schema.Struct({
  message: optionalNull(Schema.String),
  param: optionalNull(Schema.String),
 })
-type OpenResponsesErrorPayload = Schema.Schema.Type<typeof OpenResponsesErrorPayload>

 const WebSocketErrorHeader = Schema.Union([Schema.String, Schema.Number, Schema.Boolean])
 export const WebSocketErrorEvent = Schema.StructWithRest(
@@ -312,6 +301,20 @@ export const Event = Schema.StructWithRest(
 )
 export type Event = Schema.Schema.Type<typeof Event>

+const RefusalEvent = Schema.Union([
+  Schema.Struct({
+    type: Schema.tag("response.refusal.delta"),
+    item_id: Schema.String,
+    delta: Schema.String,
+  }),
+  Schema.Struct({
+    type: Schema.tag("response.refusal.done"),
+    item_id: Schema.String,
+    refusal: Schema.String,
+  }),
+])
+const isRefusalEvent = Schema.is(RefusalEvent)
+
 export interface Extension {
  readonly id: string
  readonly name: string
@@ -320,6 +323,7 @@ export interface Extension {
    readonly media: ProviderShared.NormalizedMedia
    readonly request: LLMRequest
  }) => MediaInput | undefined
+  readonly messagePhase?: (value: unknown) => MessagePhase | null | undefined
 }

 const BASE: Extension = { id: ADAPTER, name: NAME }
@@ -332,6 +336,7 @@ export interface ParserState {
  readonly hasFunctionCall: boolean
  readonly lifecycle: Lifecycle.State
  readonly messageItems: ReadonlySet<string>
+  readonly messagePhase: (value: unknown) => MessagePhase | null | undefined
  readonly messagePhases: Readonly<Record<string, MessagePhase | null>>
  readonly reasoningItems: Readonly<Record<string, ReasoningStreamItem>>
  readonly store: boolean | undefined
@@ -409,29 +414,26 @@ const lowerReasoning = (part: ReasoningPart, providerMetadataKey: string): OpenR
  }
 }

+const hostedToolItemID = (part: ToolResultPart, providerMetadataKey: string) => {
+  return itemID(part.providerMetadata, providerMetadataKey)
+}
+
 const lowerMedia = Effect.fn("OpenResponses.lowerMedia")(function* (
  part: MediaPart,
  request: LLMRequest,
  extension: Extension,
-  target: "message" | "tool-result",
 ) {
  const media = ProviderShared.normalizeMedia(part)
  const extended = extension.lowerMedia?.({ part, media, request })
  if (extended) return extended
-  const url =
-    typeof part.data === "string" && (part.data.startsWith("https://") || part.data.startsWith("http://"))
-      ? part.data
-      : undefined
  if (!media.mime.startsWith("image/")) {
-    if (target === "tool-result" && media.mime.startsWith("video/"))
-      return { type: "input_video" as const, video_url: url ?? media.dataUrl }
    return {
      type: "input_file" as const,
      filename: part.filename ?? (media.mime === "application/pdf" ? "document.pdf" : "file"),
-      ...(url ? { file_url: url } : { file_data: media.base64 }),
+      file_data: media.dataUrl,
    }
  }
-  return { type: "input_image" as const, image_url: url ?? media.dataUrl }
+  return { type: "input_image" as const, image_url: media.dataUrl }
 })

 const lowerUserContent = Effect.fnUntraced(function* (
@@ -440,17 +442,10 @@ const lowerUserContent = Effect.fnUntraced(function* (
  extension: Extension,
 ) {
  if (part.type === "text") return { type: "input_text" as const, text: part.text }
-  if (part.type === "media") return yield* lowerMessageMedia(part, request, extension)
+  if (part.type === "media") return yield* lowerMedia(part, request, extension)
  return yield* ProviderShared.unsupportedContent(extension.name, "user", ["text", "media"])
 })

-const lowerMessageMedia = Effect.fnUntraced(function* (part: MediaPart, request: LLMRequest, extension: Extension) {
-  const lowered = yield* lowerMedia(part, request, extension, "message")
-  if (lowered.type === "input_video")
-    return yield* ProviderShared.invalidRequest(`${extension.name} user messages do not support input_video`)
-  return lowered
-})
-
 // Tool results may carry structured text, images, and files. Keep media as provider-native
 // content instead of JSON-stringifying base64 into a prompt string.
 const lowerToolResultContentItem = Effect.fnUntraced(function* (
@@ -463,20 +458,6 @@ const lowerToolResultContentItem = Effect.fnUntraced(function* (
    { type: "media", mediaType: item.mime, data: item.uri, filename: item.name },
    request,
    extension,
-    "tool-result",
-  )
-})
-
-const lowerHostedToolResultContentItem = Effect.fnUntraced(function* (
-  item: Content,
-  request: LLMRequest,
-  extension: Extension,
-) {
-  if (item.type === "text") return { type: "input_text" as const, text: item.text }
-  return yield* lowerMessageMedia(
-    { type: "media", mediaType: item.mime, data: item.uri, filename: item.name },
-    request,
-    extension,
  )
 })

@@ -529,7 +510,7 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (reques
        >((groups, part) => {
          const metadata = part.providerMetadata?.[providerMetadataKey]
          const id = itemID(part.providerMetadata, providerMetadataKey)
-          const phase = ProviderShared.isRecord(metadata) ? messagePhase(metadata.phase) : undefined
+          const phase = ProviderShared.isRecord(metadata) ? messagePhase(metadata.phase, extension) : undefined
          const group = groups.at(-1)
          if (group && group.id === id && group.phase === phase) group.parts.push(part)
          else groups.push({ id, phase, parts: [part] })
@@ -579,19 +560,17 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (reques
        }
        if (part.type === "tool-result" && part.providerExecuted === true) {
          flushText()
-          const id = itemID(part.providerMetadata, providerMetadataKey)
-          if (store !== false && id && !hostedToolReferences.has(id))
-            input.push({ type: "item_reference", id })
+          const itemID = hostedToolItemID(part, providerMetadataKey)
+          if (store !== false && itemID && !hostedToolReferences.has(itemID))
+            input.push({ type: "item_reference", id: itemID })
          if (store === false && part.result.type === "content") {
            const content: ReadonlyArray<Content> = part.result.value
            input.push({
              role: "user",
-              content: yield* Effect.forEach(content, (item) =>
-                lowerHostedToolResultContentItem(item, request, extension),
-              ),
+              content: yield* Effect.forEach(content, (item) => lowerToolResultContentItem(item, request, extension)),
            })
          }
-          if (id) hostedToolReferences.add(id)
+          if (itemID) hostedToolReferences.add(itemID)
          continue
        }
        return yield* ProviderShared.unsupportedContent(extension.name, "assistant", [
@@ -803,17 +782,18 @@ const reasoningMetadata = (state: ParserState, item: StreamItem & { id: string }
 // best-effort, not guaranteed.
 const onOutputItemAdded = (state: ParserState, event: Event): StepResult => {
  const item = event.item
-  if (item?.type === "message" && item.id) {
-    const phase = messagePhase(item.phase)
+  if (item?.type === "message" && item.id)
    return [
      {
        ...state,
        messageItems: new Set([...state.messageItems, item.id]),
-        messagePhases: phase === undefined ? state.messagePhases : { ...state.messagePhases, [item.id]: phase },
+        messagePhases: (() => {
+          const phase = state.messagePhase(item.phase)
+          return phase === undefined ? state.messagePhases : { ...state.messagePhases, [item.id]: phase }
+        })(),
      },
      NO_EVENTS,
    ]
-  }
  if (item && isReasoningItem(item)) {
    const events: LLMEvent[] = []
    return [
@@ -971,7 +951,7 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
  if (!item) return [state, NO_EVENTS] satisfies StepResult

  if (item.type === "message" && item.id) {
-    const itemPhase = messagePhase(item.phase)
+    const itemPhase = state.messagePhase(item.phase)
    const phase = itemPhase === undefined ? state.messagePhases[item.id] : itemPhase
    const events: LLMEvent[] = []
    const messageItems = new Set(state.messageItems)
@@ -1079,26 +1059,22 @@ const onResponseFinish = Effect.fn("OpenResponses.onResponseFinish")(function* (
  return [{ ...state, lifecycle, hasFunctionCall, tools: pending.tools }, events] satisfies StepResult
 })

-// Build the prettiest summary available from whatever the provider supplied.
+// Build a single human-readable message from whatever the provider supplied.
 // When both code and message are present, prefix the code so consumers see
 // the failure mode (e.g. `rate_limit_exceeded: Slow down`) instead of just
 // the bare message — production rate limits and context-length failures used
-// to be indistinguishable from generic stream drops. Returns undefined when
-// the payload carries no usable summary.
-const providerErrorMessage = (event: Event, nested: OpenResponsesErrorPayload | undefined): string | undefined => {
+// to be indistinguishable from generic stream drops.
+const providerErrorMessage = (event: Event, fallback: string): string => {
+  const nested = event.error ?? event.response?.error ?? undefined
  const message = event.message || nested?.message || undefined
  const code = event.code || nested?.code || undefined
  if (message && code) return `${code}: ${message}`
-  return message || code
+  return message || code || fallback
 }

 export const providerFailure = (id: string, event: Event, fallback: string) => {
-  const nested = event.error ?? event.response?.error ?? undefined
-  const code = event.code || nested?.code || undefined
-  // Keep the full raw payload on the error even when the message is a summary.
-  const body = JSON.stringify(nested ?? event) ?? ""
-  const summary = providerErrorMessage(event, nested)
-  const message = summary ?? (body === "{}" ? fallback : body)
+  const code = event.code || event.error?.code || event.response?.error?.code || undefined
+  const message = providerErrorMessage(event, fallback)
  const status =
    typeof event.status === "number"
      ? event.status
@@ -1108,8 +1084,7 @@ export const providerFailure = (id: string, event: Event, fallback: string) => {
  return new AIError({
    module: id,
    method: "stream",
-    body,
-    reason: classifyProviderFailure({ message, code, status, rawBody: body }),
+    reason: classifyProviderFailure({ message, code, status }),
  })
 }

@@ -1125,18 +1100,21 @@ export const step = (state: ParserState, event: Event) => {
    )
  }
  if (event.type === "response.refusal.delta" || event.type === "response.refusal.done") {
-    const value = event.type === "response.refusal.delta" ? event.delta : event.refusal
-    if (!event.item_id || typeof value !== "string") return ProviderShared.eventError(state.id, `${event.type} is malformed`)
+    if (!isRefusalEvent(event)) return ProviderShared.eventError(state.id, `${event.type} is malformed`)
    return Effect.succeed(
      event.type === "response.refusal.delta"
        ? onOutputTextDelta(state, event, event.item_id)
-        : onOutputTextDone(state, { ...event, text: value }, event.item_id),
+        : onOutputTextDone(state, { ...event, text: event.refusal }, event.item_id),
    )
  }
  if (event.type === "response.reasoning.delta" || event.type === "response.reasoning_summary_text.delta") {
    if (!event.item_id) return ProviderShared.eventError(state.id, `${event.type} is missing item_id`)
    return Effect.succeed(onReasoningDelta(state, event, event.item_id))
  }
+  if (event.type === "response.reasoning.done" || event.type === "response.reasoning_summary_text.done") {
+    if (!event.item_id) return ProviderShared.eventError(state.id, `${event.type} is missing item_id`)
+    return Effect.succeed(onReasoningDone(state, event))
+  }
  if (event.type === "response.reasoning_summary_part.added")
    return event.item_id
      ? Effect.succeed(onReasoningSummaryPartAdded(state, event))
@@ -1181,11 +1159,17 @@ export const initial = (request: LLMRequest, extension: Extension = BASE): Parse
  tools: ToolStream.empty<string>(),
  lifecycle: Lifecycle.initial(),
  messageItems: new Set<string>(),
+  messagePhase: (value) => messagePhase(value, extension),
  messagePhases: {},
  reasoningItems: {},
  store: OpenResponsesOptions.resolve(request).store,
 })

+const messagePhase = (value: unknown, extension: Extension): MessagePhase | null | undefined => {
+  if (value === "commentary" || value === "final_answer") return value
+  return extension.messagePhase?.(value)
+}
+
 export const protocol = Protocol.make({
  id: ADAPTER,
  body: {
@@ -4,7 +4,7 @@ import { Effect, Option, Schema } from "effect"
 import * as ProviderShared from "./shared.js"
 import { OpenResponses } from "./open-responses.js"

-const PROTOCOL = "open-responses.websocket.v1"
+const PROTOCOL = "openai-responses.websocket.v1"
 const VERSION = 1
 const decodeEvent = Schema.decodeUnknownEffect(OpenResponses.protocol.stream.event)

@@ -161,4 +161,4 @@ export const driver = (input: DriverInput): WebSocketChannelDriver => {
  }
 }

-export const OpenResponsesContinuation = { driver } as const
+export const OpenAIResponsesChannel = { driver } as const
@@ -5,13 +5,14 @@ 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 { LLMRequest, type JsonSchema, type ToolDefinition } from "../schema/index.js"
+import { LLMEvent, LLMRequest, type JsonSchema, type ToolDefinition } from "../schema/index.js"
 import { OpenResponses } from "./open-responses.js"
 import { optionalArray, ProviderShared } from "./shared.js"
+import { Lifecycle } from "./utils/lifecycle.js"
 import { OpenAIImage } from "./utils/openai-image.js"
-import { ResponsesHostedTools } from "./utils/responses-hosted-tools.js"
 import { ToolSchemaProjection } from "./utils/tool-schema.js"
-import { OpenResponsesChannel } from "./open-responses-channel.js"
+import { OpenResponsesChannel, type Options } from "./open-responses-channel.js"
+import { OpenAIResponsesChannel } from "./openai-responses-channel.js"

 const ADAPTER = "openai-responses"
 const NAME = "OpenAI Responses"
@@ -39,8 +40,20 @@ const OpenAIResponsesToolChoice = Schema.Union([
  Schema.Struct({ type: Schema.tag("image_generation") }),
 ])

+const OpenAIResponsesInputItem = Schema.Union([
+  Schema.Struct({
+    type: Schema.tag("message"),
+    id: Schema.optionalKey(Schema.String),
+    role: Schema.tag("assistant"),
+    content: Schema.Array(Schema.Struct({ type: Schema.tag("output_text"), text: Schema.String })),
+    phase: Schema.optionalKey(Schema.NullOr(OpenResponses.MessagePhase)),
+  }),
+  OpenResponses.InputItem,
+])
+
 const OpenAIResponsesCoreFields = {
  ...OpenResponses.coreFields,
+  input: Schema.Array(OpenAIResponsesInputItem),
  tools: optionalArray(OpenAIResponsesTools),
  tool_choice: Schema.optional(OpenAIResponsesToolChoice),
 }
@@ -54,6 +67,16 @@ export type OpenAIResponsesBody = Schema.Schema.Type<typeof OpenAIResponsesBody>
 const extension = {
  id: ADAPTER,
  name: NAME,
+  messagePhase: (value: unknown) => (value === null ? null : undefined),
+  lowerMedia: ({ part, media, request }) => {
+    if (request.model.provider !== "xai" || media.mime !== "application/pdf") return undefined
+    return {
+      type: "input_file",
+      filename: part.filename ?? "document.pdf",
+      file_data: media.base64,
+      mime_type: media.mime,
+    }
+  },
 } satisfies OpenResponses.Extension

 const nativeImageToolInput = (tool: ToolDefinition) => {
@@ -105,7 +128,46 @@ const fromRequest = Effect.fn("OpenAIResponses.fromRequest")(function* (request:
  } satisfies OpenAIResponsesBody
 })

-const hostedToolResult = Effect.fn("OpenAIResponses.hostedToolResult")(function* (item: ResponsesHostedTools.Item) {
+type HostedToolData = OpenResponses.StreamItem & {
+  readonly id: string
+  readonly status?: string
+  readonly action?: unknown
+  readonly queries?: unknown
+  readonly results?: unknown
+  readonly code?: string
+  readonly container_id?: string
+  readonly outputs?: unknown
+  readonly server_label?: string
+  readonly output?: unknown
+  readonly result?: string
+  readonly output_format?: "png" | "jpeg" | "webp"
+  readonly error?: unknown
+}
+
+const HOSTED_TOOLS = {
+  web_search_call: { name: "web_search", input: (item) => item.action ?? {} },
+  web_search_preview_call: { name: "web_search_preview", input: (item) => item.action ?? {} },
+  file_search_call: { name: "file_search", input: (item) => ({ queries: item.queries ?? [] }) },
+  code_interpreter_call: {
+    name: "code_interpreter",
+    input: (item) => ({ code: item.code, container_id: item.container_id }),
+  },
+  computer_use_call: { name: "computer_use", input: (item) => item.action ?? {} },
+  image_generation_call: { name: "image_generation", input: () => ({}) },
+  mcp_call: {
+    name: "mcp",
+    input: (item) => ({ server_label: item.server_label, name: item.name, arguments: item.arguments }),
+  },
+  local_shell_call: { name: "local_shell", input: (item) => item.action ?? {} },
+} as const satisfies Record<string, { readonly name: string; readonly input: (item: HostedToolData) => unknown }>
+
+type HostedToolType = keyof typeof HOSTED_TOOLS
+type HostedToolItem = HostedToolData & { readonly type: HostedToolType }
+
+const isHostedToolItem = (item: OpenResponses.StreamItem): item is HostedToolItem =>
+  item.type in HOSTED_TOOLS && typeof item.id === "string" && item.id.length > 0
+
+const hostedToolResult = Effect.fn("OpenAIResponses.hostedToolResult")(function* (item: HostedToolItem) {
  const isError = item.error !== undefined && item.error !== null
  if (item.type === "image_generation_call" && item.result) {
    yield* Effect.fromResult(Encoding.decodeBase64(item.result)).pipe(
@@ -126,22 +188,32 @@ const hostedToolResult = Effect.fn("OpenAIResponses.hostedToolResult")(function*
  return isError ? { type: "error" as const, value: item.error } : { type: "json" as const, value: item }
 })

-const HOSTED_TOOLS = {
-  web_search_call: { name: "web_search", input: (item) => item.action ?? {} },
-  web_search_preview_call: { name: "web_search_preview", input: (item) => item.action ?? {} },
-  file_search_call: { name: "file_search", input: (item) => ({ queries: item.queries ?? [] }) },
-  code_interpreter_call: {
-    name: "code_interpreter",
-    input: (item) => ({ code: item.code, container_id: item.container_id }),
-  },
-  computer_use_call: { name: "computer_use", input: (item) => item.action ?? {} },
-  image_generation_call: { name: "image_generation", input: () => ({}), result: hostedToolResult },
-  mcp_call: {
-    name: "mcp",
-    input: (item) => ({ server_label: item.server_label, name: item.name, arguments: item.arguments }),
-  },
-  local_shell_call: { name: "local_shell", input: (item) => item.action ?? {} },
-} as const satisfies ResponsesHostedTools.Definitions
+const onHostedToolDone = Effect.fn("OpenAIResponses.onHostedToolDone")(function* (
+  state: OpenResponses.ParserState,
+  item: HostedToolItem,
+) {
+  const tool = HOSTED_TOOLS[item.type]
+  const providerMetadata = OpenResponses.providerMetadata(state, { itemId: item.id })
+  const events: LLMEvent[] = []
+  const lifecycle = Lifecycle.stepStart(state.lifecycle, events)
+  events.push(
+    LLMEvent.toolCall({
+      id: item.id,
+      name: tool.name,
+      input: tool.input(item),
+      providerExecuted: true,
+      providerMetadata,
+    }),
+    LLMEvent.toolResult({
+      id: item.id,
+      name: tool.name,
+      result: yield* hostedToolResult(item),
+      providerExecuted: true,
+      providerMetadata,
+    }),
+  )
+  return [{ ...state, lifecycle }, events] satisfies OpenResponses.StepResult
+})

 const step = (state: OpenResponses.ParserState, event: OpenResponses.Event) => {
  if (event.type === "response.reasoning_text.delta" || event.type === "response.reasoning_summary.delta")
@@ -152,8 +224,8 @@ const step = (state: OpenResponses.ParserState, event: OpenResponses.Event) => {
    return event.item_id
      ? Effect.succeed(OpenResponses.onReasoningDone(state, event))
      : ProviderShared.eventError(ADAPTER, `${event.type} is missing item_id`)
-  if (event.type === "response.output_item.done" && event.item && ResponsesHostedTools.isItem(event.item, HOSTED_TOOLS))
-    return ResponsesHostedTools.onDone(state, event.item, HOSTED_TOOLS)
+  if (event.type === "response.output_item.done" && event.item && isHostedToolItem(event.item))
+    return onHostedToolDone(state, event.item)
  return OpenResponses.step(state, event)
 }

@@ -175,7 +247,11 @@ const endpoint = Endpoint.path<OpenAIResponsesBody>(PATH, { baseURL: DEFAULT_BAS
 const auth = Auth.none

 export const httpTransport = HttpTransport.sseJson.with<OpenAIResponsesBody>()
-export const channelTransport = OpenResponsesChannel.transport<OpenAIResponsesBody>
+export const channelTransport = (options: Omit<Options, "driver">) =>
+  OpenResponsesChannel.transport<OpenAIResponsesBody>({
+    ...options,
+    driver: (input) => OpenAIResponsesChannel.driver({ id: options.id, name: options.name, ...input }),
+  })
 export const transport = channelTransport({
  id: ADAPTER,
  name: NAME,
@@ -1,70 +0,0 @@
-import { Effect } from "effect"
-import { LLMEvent, type AIError, type ToolResultPart } from "../../schema/index.js"
-import { OpenResponses } from "../open-responses.js"
-import { Lifecycle } from "./lifecycle.js"
-
-export type Item = OpenResponses.StreamItem & {
-  readonly id: string
-  readonly status?: string
-  readonly action?: unknown
-  readonly queries?: unknown
-  readonly results?: unknown
-  readonly code?: string
-  readonly container_id?: string
-  readonly outputs?: unknown
-  readonly server_label?: string
-  readonly output?: unknown
-  readonly result?: string
-  readonly output_format?: "png" | "jpeg" | "webp"
-  readonly error?: unknown
-}
-
-export interface Definition {
-  readonly name: string
-  readonly input: (item: Item) => unknown
-  readonly result?: (item: Item) => Effect.Effect<ToolResultPart["result"], AIError>
-}
-
-export type Definitions = Readonly<Record<string, Definition>>
-
-export const isItem = <Tools extends Definitions>(item: OpenResponses.StreamItem, tools: Tools): item is Item =>
-  item.type in tools && typeof item.id === "string" && item.id.length > 0
-
-export const onDone: (
-  state: OpenResponses.ParserState,
-  item: Item,
-  tools: Definitions,
-) => Effect.Effect<OpenResponses.StepResult, AIError> = Effect.fn("ResponsesHostedTools.onDone")(function* (
-  state,
-  item,
-  tools,
-) {
-  const tool = tools[item.type]
-  if (!tool) return [state, []] satisfies OpenResponses.StepResult
-  const providerMetadata = OpenResponses.providerMetadata(state, { itemId: item.id })
-  const events: LLMEvent[] = []
-  const lifecycle = Lifecycle.stepStart(state.lifecycle, events)
-  events.push(
-    LLMEvent.toolCall({
-      id: item.id,
-      name: tool.name,
-      input: tool.input(item),
-      providerExecuted: true,
-      providerMetadata,
-    }),
-    LLMEvent.toolResult({
-      id: item.id,
-      name: tool.name,
-      result: tool.result
-        ? yield* tool.result(item)
-        : item.error !== undefined && item.error !== null
-          ? { type: "error", value: item.error }
-          : { type: "json", value: item },
-      providerExecuted: true,
-      providerMetadata,
-    }),
-  )
-  return [{ ...state, lifecycle }, events] satisfies OpenResponses.StepResult
-})
-
-export * as ResponsesHostedTools from "./responses-hosted-tools.js"
@@ -1,55 +0,0 @@
-import { Effect } from "effect"
-import { Protocol } from "../route/protocol.js"
-import { OpenResponses } from "./open-responses.js"
-import { ProviderShared } from "./shared.js"
-import { ResponsesHostedTools } from "./utils/responses-hosted-tools.js"
-
-const ADAPTER = "xai-responses"
-const NAME = "xAI Responses"
-
-const extension = {
-  id: ADAPTER,
-  name: NAME,
-} satisfies OpenResponses.Extension
-
-const HOSTED_TOOLS = {
-  web_search_call: { name: "web_search", input: (item) => item.action ?? {} },
-  x_search_call: { name: "x_search", input: (item) => item.action ?? {} },
-  file_search_call: { name: "file_search", input: (item) => ({ queries: item.queries ?? [] }) },
-  code_interpreter_call: {
-    name: "code_interpreter",
-    input: (item) => ({ code: item.code, container_id: item.container_id }),
-  },
-  image_generation_call: { name: "image_generation", input: () => ({}) },
-  mcp_call: {
-    name: "mcp",
-    input: (item) => ({ server_label: item.server_label, name: item.name, arguments: item.arguments }),
-  },
-} as const satisfies ResponsesHostedTools.Definitions
-
-const step = (state: OpenResponses.ParserState, event: OpenResponses.Event) => {
-  if (event.type === "response.reasoning_text.delta" || event.type === "response.reasoning_summary.delta")
-    return event.item_id
-      ? Effect.succeed(OpenResponses.onReasoningDelta(state, event, event.item_id))
-      : ProviderShared.eventError(ADAPTER, `${event.type} is missing item_id`)
-  if (event.type === "response.reasoning_text.done" || event.type === "response.reasoning_summary.done")
-    return event.item_id
-      ? Effect.succeed(OpenResponses.onReasoningDone(state, event))
-      : ProviderShared.eventError(ADAPTER, `${event.type} is missing item_id`)
-  if (event.type === "response.output_item.done" && event.item && ResponsesHostedTools.isItem(event.item, HOSTED_TOOLS))
-    return ResponsesHostedTools.onDone(state, event.item, HOSTED_TOOLS)
-  return OpenResponses.step(state, event)
-}
-
-export const protocol = Protocol.make({
-  id: ADAPTER,
-  body: OpenResponses.protocol.body,
-  stream: {
-    event: OpenResponses.protocol.stream.event,
-    initial: (request) => OpenResponses.initial(request, extension),
-    step,
-    terminal: OpenResponses.terminal,
-  },
-})
-
-export * as XAIResponses from "./xai-responses.js"
@@ -80,9 +80,6 @@ export interface ProviderFailure {
  readonly message: string
  readonly status?: number | undefined
  readonly code?: string | undefined
-  // Raw wire payload, scanned for failure signals (codes, overflow phrases)
-  // that the summary message does not carry. Not shown to users.
-  readonly rawBody?: string | undefined
  readonly retryAfterMs?: number | undefined
  readonly rateLimit?: HttpRateLimitDetails | undefined
  readonly http?: HttpContext | undefined
@@ -92,13 +89,11 @@ export interface ProviderFailure {
 // Keep HTTP failures and provider-reported stream failures on one typed path so
 // session retry policy never needs provider-specific string matching.
 export function classifyProviderFailure(input: ProviderFailure): AIError["reason"] {
-  const body = input.http?.body ?? input.rawBody ?? ""
+  const body = input.http?.body ?? ""
  const codes = [input.code, ...providerCodes(body), ...providerCodes(input.message)]
    .filter((code): code is string => code !== undefined)
    .map((code) => code.toLowerCase())
-  // Scan the raw payload too so signals missing from the summary message
-  // (e.g. overflow phrases nested in a JSON error body) still classify.
-  const text = [input.message, body].filter((value) => value.length > 0).join("\n")
+  const text = body || input.message
  const common = { message: input.message, providerMetadata: input.providerMetadata, http: input.http }
  const clientScoped = input.status === undefined || (input.status >= 400 && input.status < 500)

@@ -5,8 +5,7 @@ import { HttpOptions, ProviderID, type ModelID } from "../schema/index.js"
 import * as OpenAICompatibleProfiles from "./openai-compatible-profile.js"
 import * as OpenAICompatibleChat from "../protocols/openai-compatible-chat.js"
 import * as OpenAIChat from "../protocols/openai-chat.js"
-import { OpenResponsesChannel } from "../protocols/open-responses-channel.js"
-import { XAIResponses } from "../protocols/xai-responses.js"
+import * as OpenAIResponses from "../protocols/openai-responses.js"
 import { XAIImages } from "../protocols/xai-images.js"
 import type { OpenAIOptionsInput } from "./openai-options.js"
 import type { ProviderPackage } from "../provider-package.js"
@@ -35,9 +34,9 @@ const responsesRoute = Route.make({
  id: "openai-responses",
  provider: id,
  providerMetadataKey: "xai",
-  protocol: XAIResponses.protocol,
+  protocol: OpenAIResponses.protocol,
  endpoint: Endpoint.path("/responses", { baseURL: OpenAICompatibleProfiles.profiles.xai.baseURL }),
-  transport: OpenResponsesChannel.transport({
+  transport: OpenAIResponses.channelTransport({
    id: "openai-responses",
    name: "xAI Responses",
    rotateAfterMs: RESPONSES_WEBSOCKET_ROTATE_AFTER_MS,
@@ -153,9 +153,6 @@ export class AIError extends Schema.TaggedError<AIError>()("AI.Error", {
  module: Schema.String,
  method: Schema.String,
  reason: AIErrorReason,
-  // Raw provider payload as a string, so classified failures never lose the
-  // original error detail even when the pretty message is a summary.
-  body: Schema.optional(Schema.String),
 }) {
  override readonly cause = this.reason

@@ -1,14 +1,7 @@
 {
  "version": 1,
  "metadata": {
-    "tags": [
-      "prefix:pdf",
-      "pdf",
-      "provider:openai",
-      "protocol:openai-responses",
-      "tool",
-      "tool-result"
-    ],
+    "tags": ["prefix:pdf", "pdf", "provider:openai", "protocol:openai-responses", "tool", "tool-result"],
    "name": "pdf/openai-tool-result",
    "recordedAt": "2026-07-22T18:15:36.438Z"
  },
@@ -21,7 +14,7 @@
        "headers": {
          "content-type": "application/json"
        },
-        "body": "{\"model\":\"gpt-4o-mini\",\"input\":[{\"role\":\"system\",\"content\":\"Read the PDF returned by the tool and follow the user's response format exactly.\"},{\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"Return only the verification code from the PDF.\"}]},{\"type\":\"function_call\",\"call_id\":\"call_pdf_1\",\"name\":\"read_pdf\",\"arguments\":\"{}\"},{\"type\":\"function_call_output\",\"call_id\":\"call_pdf_1\",\"output\":[{\"type\":\"input_text\",\"text\":\"PDF read successfully\"},{\"type\":\"input_file\",\"filename\":\"verification.pdf\",\"file_data\":\"JVBERi0xLjQKMSAwIG9iago8PCAvVHlwZSAvQ2F0YWxvZyAvUGFnZXMgMiAwIFIgPj4KZW5kb2JqCjIgMCBvYmoKPDwgL1R5cGUgL1BhZ2VzIC9LaWRzIFszIDAgUl0gL0NvdW50IDEgPj4KZW5kb2JqCjMgMCBvYmoKPDwgL1R5cGUgL1BhZ2UgL1BhcmVudCAyIDAgUiAvTWVkaWFCb3ggWzAgMCA2MTIgNzkyXSAvUmVzb3VyY2VzIDw8IC9Gb250IDw8IC9GMSA1IDAgUiA+PiA+PiAvQ29udGVudHMgNCAwIFIgPj4KZW5kb2JqCjQgMCBvYmoKPDwgL0xlbmd0aCA3NSA+PgpzdHJlYW0KQlQKL0YxIDE4IFRmCjcyIDcyMCBUZAooUERGIGNhc3NldHRlIHZlcmlmaWNhdGlvbiBjb2RlOiBPUkNISUQtNzM5MSkgVGoKRVQKZW5kc3RyZWFtCmVuZG9iago1IDAgb2JqCjw8IC9UeXBlIC9Gb250IC9TdWJ0eXBlIC9UeXBlMSAvQmFzZUZvbnQgL0hlbHZldGljYSA+PgplbmRvYmoKeHJlZgowIDYKMDAwMDAwMDAwMCA2NTUzNSBmIAowMDAwMDAwMDA5IDAwMDAwIG4gCjAwMDAwMDAwNTggMDAwMDAgbiAKMDAwMDAwMDExNSAwMDAwMCBuIAowMDAwMDAwMjQxIDAwMDAwIG4gCjAwMDAwMDAzNjUgMDAwMDAgbiAKdHJhaWxlcgo8PCAvU2l6ZSA2IC9Sb290IDEgMCBSID4+CnN0YXJ0eHJlZgo0MzUKJSVFT0YK\"}]}],\"tools\":[{\"type\":\"function\",\"name\":\"read_pdf\",\"description\":\"Read the attached PDF.\",\"parameters\":{\"type\":\"object\",\"properties\":{},\"additionalProperties\":false},\"strict\":false}],\"store\":false,\"max_output_tokens\":40,\"temperature\":0,\"stream\":true}"
+        "body": "{\"model\":\"gpt-4o-mini\",\"input\":[{\"role\":\"system\",\"content\":\"Read the PDF returned by the tool and follow the user's response format exactly.\"},{\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"Return only the verification code from the PDF.\"}]},{\"type\":\"function_call\",\"call_id\":\"call_pdf_1\",\"name\":\"read_pdf\",\"arguments\":\"{}\"},{\"type\":\"function_call_output\",\"call_id\":\"call_pdf_1\",\"output\":[{\"type\":\"input_text\",\"text\":\"PDF read successfully\"},{\"type\":\"input_file\",\"filename\":\"verification.pdf\",\"file_data\":\"data:application/pdf;base64,JVBERi0xLjQKMSAwIG9iago8PCAvVHlwZSAvQ2F0YWxvZyAvUGFnZXMgMiAwIFIgPj4KZW5kb2JqCjIgMCBvYmoKPDwgL1R5cGUgL1BhZ2VzIC9LaWRzIFszIDAgUl0gL0NvdW50IDEgPj4KZW5kb2JqCjMgMCBvYmoKPDwgL1R5cGUgL1BhZ2UgL1BhcmVudCAyIDAgUiAvTWVkaWFCb3ggWzAgMCA2MTIgNzkyXSAvUmVzb3VyY2VzIDw8IC9Gb250IDw8IC9GMSA1IDAgUiA+PiA+PiAvQ29udGVudHMgNCAwIFIgPj4KZW5kb2JqCjQgMCBvYmoKPDwgL0xlbmd0aCA3NSA+PgpzdHJlYW0KQlQKL0YxIDE4IFRmCjcyIDcyMCBUZAooUERGIGNhc3NldHRlIHZlcmlmaWNhdGlvbiBjb2RlOiBPUkNISUQtNzM5MSkgVGoKRVQKZW5kc3RyZWFtCmVuZG9iago1IDAgb2JqCjw8IC9UeXBlIC9Gb250IC9TdWJ0eXBlIC9UeXBlMSAvQmFzZUZvbnQgL0hlbHZldGljYSA+PgplbmRvYmoKeHJlZgowIDYKMDAwMDAwMDAwMCA2NTUzNSBmIAowMDAwMDAwMDA5IDAwMDAwIG4gCjAwMDAwMDAwNTggMDAwMDAgbiAKMDAwMDAwMDExNSAwMDAwMCBuIAowMDAwMDAwMjQxIDAwMDAwIG4gCjAwMDAwMDAzNjUgMDAwMDAgbiAKdHJhaWxlcgo8PCAvU2l6ZSA2IC9Sb290IDEgMCBSID4+CnN0YXJ0eHJlZgo0MzUKJSVFT0YK\"}]}],\"tools\":[{\"type\":\"function\",\"name\":\"read_pdf\",\"description\":\"Read the attached PDF.\",\"parameters\":{\"type\":\"object\",\"properties\":{},\"additionalProperties\":false},\"strict\":false}],\"store\":false,\"max_output_tokens\":40,\"temperature\":0,\"stream\":true}"
      },
      "response": {
        "status": 200,
@@ -1,13 +1,7 @@
 {
  "version": 1,
  "metadata": {
-    "tags": [
-      "prefix:pdf",
-      "pdf",
-      "provider:openai",
-      "protocol:openai-responses",
-      "user-input"
-    ],
+    "tags": ["prefix:pdf", "pdf", "provider:openai", "protocol:openai-responses", "user-input"],
    "name": "pdf/openai-user-input",
    "recordedAt": "2026-07-22T18:15:34.867Z"
  },
@@ -20,7 +14,7 @@
        "headers": {
          "content-type": "application/json"
        },
-        "body": "{\"model\":\"gpt-4o-mini\",\"input\":[{\"role\":\"user\",\"content\":[{\"type\":\"input_file\",\"filename\":\"verification.pdf\",\"file_data\":\"JVBERi0xLjQKMSAwIG9iago8PCAvVHlwZSAvQ2F0YWxvZyAvUGFnZXMgMiAwIFIgPj4KZW5kb2JqCjIgMCBvYmoKPDwgL1R5cGUgL1BhZ2VzIC9LaWRzIFszIDAgUl0gL0NvdW50IDEgPj4KZW5kb2JqCjMgMCBvYmoKPDwgL1R5cGUgL1BhZ2UgL1BhcmVudCAyIDAgUiAvTWVkaWFCb3ggWzAgMCA2MTIgNzkyXSAvUmVzb3VyY2VzIDw8IC9Gb250IDw8IC9GMSA1IDAgUiA+PiA+PiAvQ29udGVudHMgNCAwIFIgPj4KZW5kb2JqCjQgMCBvYmoKPDwgL0xlbmd0aCA3NSA+PgpzdHJlYW0KQlQKL0YxIDE4IFRmCjcyIDcyMCBUZAooUERGIGNhc3NldHRlIHZlcmlmaWNhdGlvbiBjb2RlOiBPUkNISUQtNzM5MSkgVGoKRVQKZW5kc3RyZWFtCmVuZG9iago1IDAgb2JqCjw8IC9UeXBlIC9Gb250IC9TdWJ0eXBlIC9UeXBlMSAvQmFzZUZvbnQgL0hlbHZldGljYSA+PgplbmRvYmoKeHJlZgowIDYKMDAwMDAwMDAwMCA2NTUzNSBmIAowMDAwMDAwMDA5IDAwMDAwIG4gCjAwMDAwMDAwNTggMDAwMDAgbiAKMDAwMDAwMDExNSAwMDAwMCBuIAowMDAwMDAwMjQxIDAwMDAwIG4gCjAwMDAwMDAzNjUgMDAwMDAgbiAKdHJhaWxlcgo8PCAvU2l6ZSA2IC9Sb290IDEgMCBSID4+CnN0YXJ0eHJlZgo0MzUKJSVFT0YK\"},{\"type\":\"input_text\",\"text\":\"Return only the verification code from the PDF.\"}]}],\"store\":false,\"max_output_tokens\":40,\"temperature\":0,\"stream\":true}"
+        "body": "{\"model\":\"gpt-4o-mini\",\"input\":[{\"role\":\"user\",\"content\":[{\"type\":\"input_file\",\"filename\":\"verification.pdf\",\"file_data\":\"data:application/pdf;base64,JVBERi0xLjQKMSAwIG9iago8PCAvVHlwZSAvQ2F0YWxvZyAvUGFnZXMgMiAwIFIgPj4KZW5kb2JqCjIgMCBvYmoKPDwgL1R5cGUgL1BhZ2VzIC9LaWRzIFszIDAgUl0gL0NvdW50IDEgPj4KZW5kb2JqCjMgMCBvYmoKPDwgL1R5cGUgL1BhZ2UgL1BhcmVudCAyIDAgUiAvTWVkaWFCb3ggWzAgMCA2MTIgNzkyXSAvUmVzb3VyY2VzIDw8IC9Gb250IDw8IC9GMSA1IDAgUiA+PiA+PiAvQ29udGVudHMgNCAwIFIgPj4KZW5kb2JqCjQgMCBvYmoKPDwgL0xlbmd0aCA3NSA+PgpzdHJlYW0KQlQKL0YxIDE4IFRmCjcyIDcyMCBUZAooUERGIGNhc3NldHRlIHZlcmlmaWNhdGlvbiBjb2RlOiBPUkNISUQtNzM5MSkgVGoKRVQKZW5kc3RyZWFtCmVuZG9iago1IDAgb2JqCjw8IC9UeXBlIC9Gb250IC9TdWJ0eXBlIC9UeXBlMSAvQmFzZUZvbnQgL0hlbHZldGljYSA+PgplbmRvYmoKeHJlZgowIDYKMDAwMDAwMDAwMCA2NTUzNSBmIAowMDAwMDAwMDA5IDAwMDAwIG4gCjAwMDAwMDAwNTggMDAwMDAgbiAKMDAwMDAwMDExNSAwMDAwMCBuIAowMDAwMDAwMjQxIDAwMDAwIG4gCjAwMDAwMDAzNjUgMDAwMDAgbiAKdHJhaWxlcgo8PCAvU2l6ZSA2IC9Sb290IDEgMCBSID4+CnN0YXJ0eHJlZgo0MzUKJSVFT0YK\"},{\"type\":\"input_text\",\"text\":\"Return only the verification code from the PDF.\"}]}],\"store\":false,\"max_output_tokens\":40,\"temperature\":0,\"stream\":true}"
      },
      "response": {
        "status": 200,
@@ -1,17 +1,9 @@
 {
  "version": 1,
  "metadata": {
-    "tags": [
-      "prefix:pdf",
-      "pdf",
-      "provider:xai",
-      "protocol:xai-responses",
-      "tool",
-      "tool-result"
-    ],
+    "tags": ["prefix:pdf", "pdf", "provider:xai", "protocol:openai-responses", "tool", "tool-result"],
    "name": "pdf/xai-tool-result",
-    "recordedAt": "2026-07-22T18:15:43.608Z",
-    "protocol": "xai-responses"
+    "recordedAt": "2026-07-22T18:15:43.608Z"
  },
  "interactions": [
    {
@@ -22,7 +14,7 @@
        "headers": {
          "content-type": "application/json"
        },
-        "body": "{\"model\":\"grok-4.5\",\"input\":[{\"role\":\"system\",\"content\":\"Read the PDF returned by the tool and follow the user's response format exactly.\"},{\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"Return only the verification code from the PDF.\"}]},{\"type\":\"function_call\",\"call_id\":\"call_pdf_1\",\"name\":\"read_pdf\",\"arguments\":\"{}\"},{\"type\":\"function_call_output\",\"call_id\":\"call_pdf_1\",\"output\":[{\"type\":\"input_text\",\"text\":\"PDF read successfully\"},{\"type\":\"input_file\",\"filename\":\"verification.pdf\",\"file_data\":\"JVBERi0xLjQKMSAwIG9iago8PCAvVHlwZSAvQ2F0YWxvZyAvUGFnZXMgMiAwIFIgPj4KZW5kb2JqCjIgMCBvYmoKPDwgL1R5cGUgL1BhZ2VzIC9LaWRzIFszIDAgUl0gL0NvdW50IDEgPj4KZW5kb2JqCjMgMCBvYmoKPDwgL1R5cGUgL1BhZ2UgL1BhcmVudCAyIDAgUiAvTWVkaWFCb3ggWzAgMCA2MTIgNzkyXSAvUmVzb3VyY2VzIDw8IC9Gb250IDw8IC9GMSA1IDAgUiA+PiA+PiAvQ29udGVudHMgNCAwIFIgPj4KZW5kb2JqCjQgMCBvYmoKPDwgL0xlbmd0aCA3NSA+PgpzdHJlYW0KQlQKL0YxIDE4IFRmCjcyIDcyMCBUZAooUERGIGNhc3NldHRlIHZlcmlmaWNhdGlvbiBjb2RlOiBPUkNISUQtNzM5MSkgVGoKRVQKZW5kc3RyZWFtCmVuZG9iago1IDAgb2JqCjw8IC9UeXBlIC9Gb250IC9TdWJ0eXBlIC9UeXBlMSAvQmFzZUZvbnQgL0hlbHZldGljYSA+PgplbmRvYmoKeHJlZgowIDYKMDAwMDAwMDAwMCA2NTUzNSBmIAowMDAwMDAwMDA5IDAwMDAwIG4gCjAwMDAwMDAwNTggMDAwMDAgbiAKMDAwMDAwMDExNSAwMDAwMCBuIAowMDAwMDAwMjQxIDAwMDAwIG4gCjAwMDAwMDAzNjUgMDAwMDAgbiAKdHJhaWxlcgo8PCAvU2l6ZSA2IC9Sb290IDEgMCBSID4+CnN0YXJ0eHJlZgo0MzUKJSVFT0YK\"}]}],\"tools\":[{\"type\":\"function\",\"name\":\"read_pdf\",\"description\":\"Read the attached PDF.\",\"parameters\":{\"type\":\"object\",\"properties\":{},\"additionalProperties\":false},\"strict\":false}],\"store\":false,\"max_output_tokens\":40,\"temperature\":0,\"stream\":true}"
+        "body": "{\"model\":\"grok-4.5\",\"input\":[{\"role\":\"system\",\"content\":\"Read the PDF returned by the tool and follow the user's response format exactly.\"},{\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"Return only the verification code from the PDF.\"}]},{\"type\":\"function_call\",\"call_id\":\"call_pdf_1\",\"name\":\"read_pdf\",\"arguments\":\"{}\"},{\"type\":\"function_call_output\",\"call_id\":\"call_pdf_1\",\"output\":[{\"type\":\"input_text\",\"text\":\"PDF read successfully\"},{\"type\":\"input_file\",\"filename\":\"verification.pdf\",\"file_data\":\"JVBERi0xLjQKMSAwIG9iago8PCAvVHlwZSAvQ2F0YWxvZyAvUGFnZXMgMiAwIFIgPj4KZW5kb2JqCjIgMCBvYmoKPDwgL1R5cGUgL1BhZ2VzIC9LaWRzIFszIDAgUl0gL0NvdW50IDEgPj4KZW5kb2JqCjMgMCBvYmoKPDwgL1R5cGUgL1BhZ2UgL1BhcmVudCAyIDAgUiAvTWVkaWFCb3ggWzAgMCA2MTIgNzkyXSAvUmVzb3VyY2VzIDw8IC9Gb250IDw8IC9GMSA1IDAgUiA+PiA+PiAvQ29udGVudHMgNCAwIFIgPj4KZW5kb2JqCjQgMCBvYmoKPDwgL0xlbmd0aCA3NSA+PgpzdHJlYW0KQlQKL0YxIDE4IFRmCjcyIDcyMCBUZAooUERGIGNhc3NldHRlIHZlcmlmaWNhdGlvbiBjb2RlOiBPUkNISUQtNzM5MSkgVGoKRVQKZW5kc3RyZWFtCmVuZG9iago1IDAgb2JqCjw8IC9UeXBlIC9Gb250IC9TdWJ0eXBlIC9UeXBlMSAvQmFzZUZvbnQgL0hlbHZldGljYSA+PgplbmRvYmoKeHJlZgowIDYKMDAwMDAwMDAwMCA2NTUzNSBmIAowMDAwMDAwMDA5IDAwMDAwIG4gCjAwMDAwMDAwNTggMDAwMDAgbiAKMDAwMDAwMDExNSAwMDAwMCBuIAowMDAwMDAwMjQxIDAwMDAwIG4gCjAwMDAwMDAzNjUgMDAwMDAgbiAKdHJhaWxlcgo8PCAvU2l6ZSA2IC9Sb290IDEgMCBSID4+CnN0YXJ0eHJlZgo0MzUKJSVFT0YK\",\"mime_type\":\"application/pdf\"}]}],\"tools\":[{\"type\":\"function\",\"name\":\"read_pdf\",\"description\":\"Read the attached PDF.\",\"parameters\":{\"type\":\"object\",\"properties\":{},\"additionalProperties\":false},\"strict\":false}],\"store\":false,\"max_output_tokens\":40,\"temperature\":0,\"stream\":true}"
      },
      "response": {
        "status": 200,
@@ -1,16 +1,9 @@
 {
  "version": 1,
  "metadata": {
-    "tags": [
-      "prefix:pdf",
-      "pdf",
-      "provider:xai",
-      "protocol:xai-responses",
-      "user-input"
-    ],
+    "tags": ["prefix:pdf", "pdf", "provider:xai", "protocol:openai-responses", "user-input"],
    "name": "pdf/xai-user-input",
-    "recordedAt": "2026-07-22T18:15:42.429Z",
-    "protocol": "xai-responses"
+    "recordedAt": "2026-07-22T18:15:42.429Z"
  },
  "interactions": [
    {
@@ -21,7 +14,7 @@
        "headers": {
          "content-type": "application/json"
        },
-        "body": "{\"model\":\"grok-4.5\",\"input\":[{\"role\":\"user\",\"content\":[{\"type\":\"input_file\",\"filename\":\"verification.pdf\",\"file_data\":\"JVBERi0xLjQKMSAwIG9iago8PCAvVHlwZSAvQ2F0YWxvZyAvUGFnZXMgMiAwIFIgPj4KZW5kb2JqCjIgMCBvYmoKPDwgL1R5cGUgL1BhZ2VzIC9LaWRzIFszIDAgUl0gL0NvdW50IDEgPj4KZW5kb2JqCjMgMCBvYmoKPDwgL1R5cGUgL1BhZ2UgL1BhcmVudCAyIDAgUiAvTWVkaWFCb3ggWzAgMCA2MTIgNzkyXSAvUmVzb3VyY2VzIDw8IC9Gb250IDw8IC9GMSA1IDAgUiA+PiA+PiAvQ29udGVudHMgNCAwIFIgPj4KZW5kb2JqCjQgMCBvYmoKPDwgL0xlbmd0aCA3NSA+PgpzdHJlYW0KQlQKL0YxIDE4IFRmCjcyIDcyMCBUZAooUERGIGNhc3NldHRlIHZlcmlmaWNhdGlvbiBjb2RlOiBPUkNISUQtNzM5MSkgVGoKRVQKZW5kc3RyZWFtCmVuZG9iago1IDAgb2JqCjw8IC9UeXBlIC9Gb250IC9TdWJ0eXBlIC9UeXBlMSAvQmFzZUZvbnQgL0hlbHZldGljYSA+PgplbmRvYmoKeHJlZgowIDYKMDAwMDAwMDAwMCA2NTUzNSBmIAowMDAwMDAwMDA5IDAwMDAwIG4gCjAwMDAwMDAwNTggMDAwMDAgbiAKMDAwMDAwMDExNSAwMDAwMCBuIAowMDAwMDAwMjQxIDAwMDAwIG4gCjAwMDAwMDAzNjUgMDAwMDAgbiAKdHJhaWxlcgo8PCAvU2l6ZSA2IC9Sb290IDEgMCBSID4+CnN0YXJ0eHJlZgo0MzUKJSVFT0YK\"},{\"type\":\"input_text\",\"text\":\"Return only the verification code from the PDF.\"}]}],\"store\":false,\"max_output_tokens\":40,\"temperature\":0,\"stream\":true}"
+        "body": "{\"model\":\"grok-4.5\",\"input\":[{\"role\":\"user\",\"content\":[{\"type\":\"input_file\",\"filename\":\"verification.pdf\",\"file_data\":\"JVBERi0xLjQKMSAwIG9iago8PCAvVHlwZSAvQ2F0YWxvZyAvUGFnZXMgMiAwIFIgPj4KZW5kb2JqCjIgMCBvYmoKPDwgL1R5cGUgL1BhZ2VzIC9LaWRzIFszIDAgUl0gL0NvdW50IDEgPj4KZW5kb2JqCjMgMCBvYmoKPDwgL1R5cGUgL1BhZ2UgL1BhcmVudCAyIDAgUiAvTWVkaWFCb3ggWzAgMCA2MTIgNzkyXSAvUmVzb3VyY2VzIDw8IC9Gb250IDw8IC9GMSA1IDAgUiA+PiA+PiAvQ29udGVudHMgNCAwIFIgPj4KZW5kb2JqCjQgMCBvYmoKPDwgL0xlbmd0aCA3NSA+PgpzdHJlYW0KQlQKL0YxIDE4IFRmCjcyIDcyMCBUZAooUERGIGNhc3NldHRlIHZlcmlmaWNhdGlvbiBjb2RlOiBPUkNISUQtNzM5MSkgVGoKRVQKZW5kc3RyZWFtCmVuZG9iago1IDAgb2JqCjw8IC9UeXBlIC9Gb250IC9TdWJ0eXBlIC9UeXBlMSAvQmFzZUZvbnQgL0hlbHZldGljYSA+PgplbmRvYmoKeHJlZgowIDYKMDAwMDAwMDAwMCA2NTUzNSBmIAowMDAwMDAwMDA5IDAwMDAwIG4gCjAwMDAwMDAwNTggMDAwMDAgbiAKMDAwMDAwMDExNSAwMDAwMCBuIAowMDAwMDAwMjQxIDAwMDAwIG4gCjAwMDAwMDAzNjUgMDAwMDAgbiAKdHJhaWxlcgo8PCAvU2l6ZSA2IC9Sb290IDEgMCBSID4+CnN0YXJ0eHJlZgo0MzUKJSVFT0YK\",\"mime_type\":\"application/pdf\"},{\"type\":\"input_text\",\"text\":\"Return only the verification code from the PDF.\"}]}],\"store\":false,\"max_output_tokens\":40,\"temperature\":0,\"stream\":true}"
      },
      "response": {
        "status": 200,
@@ -106,20 +106,3 @@ describe("provider error classification", () => {
    expect(classifyProviderFailure({ message: "not-json" })._tag).toBe("UnknownProvider")
  })
 })
-
-describe("provider error rawBody classification", () => {
-  test("classifies overflow signals buried in the raw payload when the summary is vague", () => {
-    const reason = classifyProviderFailure({
-      message: "Request failed",
-      rawBody: '{"error":{"message":"This model\'s maximum context length is 40960 tokens"}}',
-    })
-    expect(reason._tag).toBe("InvalidRequest")
-    expect(reason).toMatchObject({ classification: "context-overflow" })
-  })
-
-  test("extracts nested codes from the raw payload", () => {
-    expect(
-      classifyProviderFailure({ message: "Request failed", rawBody: '{"error":{"code":"insufficient_quota"}}' })._tag,
-    ).toBe("QuotaExceeded")
-  })
-})
@@ -93,7 +93,7 @@ describe("Open Responses-compatible route", () => {
    }),
  )

-  it.effect("preserves nullable phases in the forgiving Open Responses baseline", () =>
+  it.effect("omits OpenAI-only nullable phases from the Open Responses baseline", () =>
    Effect.gen(function* () {
      const model = configure({
        apiKey: "test-key",
@@ -113,9 +113,7 @@ describe("Open Responses-compatible route", () => {
      )

      expect(prepared.body).toMatchObject({
-        input: [
-          { type: "message", role: "assistant", content: [{ type: "output_text", text: "Unclassified." }], phase: null },
-        ],
+        input: [{ type: "message", role: "assistant", content: [{ type: "output_text", text: "Unclassified." }] }],
      })
    }),
  )
@@ -28,7 +28,7 @@ import * as Azure from "../../src/providers/azure.js"
 import * as OpenAI from "../../src/providers/openai.js"
 import * as XAI from "../../src/providers/xai.js"
 import * as OpenAIResponses from "../../src/protocols/openai-responses.js"
-import { OpenResponsesContinuation } from "../../src/protocols/open-responses-continuation.js"
+import { OpenAIResponsesChannel } from "../../src/protocols/openai-responses-channel.js"
 import * as ProviderShared from "../../src/protocols/shared.js"
 import { continuationRequest, nativeOpenAIResponsesContinuation } from "../continuation-scenarios.js"
 import { it } from "../lib/effect.js"
@@ -68,7 +68,7 @@ const baseChannelDriver = (message: string): WebSocketChannelDriver => ({

 const continuationDriver = (request: Readonly<Record<string, unknown>>) => {
  const message = ProviderShared.encodeJson(request)
-  return OpenResponsesContinuation.driver({
+  return OpenAIResponsesChannel.driver({
    id: "openai-responses",
    name: "OpenAI Responses",
    request,
@@ -1273,7 +1273,7 @@ describe("OpenAI Responses route", () => {
        {
          type: "input_file",
          filename: "report.pdf",
-          file_data: "JVBERi0xLjQ=",
+          file_data: "data:application/pdf;base64,JVBERi0xLjQ=",
        },
      ])
    }),
@@ -1300,12 +1300,12 @@ describe("OpenAI Responses route", () => {
      )

      expect(expectToolOutput(prepared.body).output).toEqual([
-        { type: "input_file", filename: "report.pdf", file_data: base64 },
+        { type: "input_file", filename: "report.pdf", file_data: dataUrl },
      ])
    }),
  )

-  it.effect("uses standard inline file encoding for xAI PDF tool results", () =>
+  it.effect("uses xAI inline file encoding for PDF tool results", () =>
    Effect.gen(function* () {
      const prepared = yield* compileRequest(
        LLM.request({
@@ -1334,6 +1334,7 @@ describe("OpenAI Responses route", () => {
          type: "input_file",
          filename: "report.pdf",
          file_data: "JVBERi0xLjQ=",
+          mime_type: "application/pdf",
        },
      ])
    }),
@@ -1358,61 +1359,7 @@ describe("OpenAI Responses route", () => {
      )

      expect(expectToolOutput(prepared.body).output).toEqual([
-        { type: "input_file", filename: "file", file_data: "AAECAw==" },
-      ])
-    }),
-  )
-
-  it.effect("lowers remote tool-result media URLs without base64 wrapping", () =>
-    Effect.gen(function* () {
-      const prepared = yield* compileRequest(
-        LLM.request({
-          model,
-          messages: [
-            Message.assistant([ToolCallPart.make({ id: "call_1", name: "fetch", input: {} })]),
-            Message.tool({
-              id: "call_1",
-              name: "fetch",
-              resultType: "content",
-              result: [
-                { type: "file", uri: "https://example.com/image.png", mime: "image/png" },
-                { type: "file", uri: "https://example.com/report.pdf", mime: "application/pdf", name: "report.pdf" },
-              ],
-            }),
-          ],
-        }),
-      )
-
-      expect(expectToolOutput(prepared.body).output).toEqual([
-        { type: "input_image", image_url: "https://example.com/image.png" },
-        { type: "input_file", filename: "report.pdf", file_url: "https://example.com/report.pdf" },
-      ])
-    }),
-  )
-
-  it.effect("lowers tool-result videos as input_video", () =>
-    Effect.gen(function* () {
-      const prepared = yield* compileRequest(
-        LLM.request({
-          model,
-          messages: [
-            Message.assistant([ToolCallPart.make({ id: "call_1", name: "record", input: {} })]),
-            Message.tool({
-              id: "call_1",
-              name: "record",
-              resultType: "content",
-              result: [
-                { type: "file", uri: "data:video/mp4;base64,AAECAw==", mime: "video/mp4" },
-                { type: "file", uri: "https://example.com/demo.mp4", mime: "video/mp4" },
-              ],
-            }),
-          ],
-        }),
-      )
-
-      expect(expectToolOutput(prepared.body).output).toEqual([
-        { type: "input_video", video_url: "data:video/mp4;base64,AAECAw==" },
-        { type: "input_video", video_url: "https://example.com/demo.mp4" },
+        { type: "input_file", filename: "file", file_data: "data:audio/mpeg;base64,AAECAw==" },
      ])
    }),
  )
@@ -2765,7 +2712,7 @@ describe("OpenAI Responses route", () => {
            {
              type: "input_file",
              filename: "report.pdf",
-              file_data: "JVBERi0xLjQ=",
+              file_data: "data:application/pdf;base64,JVBERi0xLjQ=",
            },
          ],
        },
@@ -2773,7 +2720,7 @@ describe("OpenAI Responses route", () => {
    }),
  )

-  it.effect("uses standard inline file encoding for xAI user PDFs", () =>
+  it.effect("uses xAI inline file encoding for user PDFs", () =>
    Effect.gen(function* () {
      const prepared = yield* compileRequest(
        LLM.request({
@@ -2797,6 +2744,7 @@ describe("OpenAI Responses route", () => {
              type: "input_file",
              filename: "report.pdf",
              file_data: "JVBERi0xLjQ=",
+              mime_type: "application/pdf",
            },
          ],
        },
@@ -2821,7 +2769,7 @@ describe("OpenAI Responses route", () => {
            {
              type: "input_file",
              filename: "file",
-              file_data: "AAECAw==",
+              file_data: "data:application/x-tar;base64,AAECAw==",
            },
          ],
        },
@@ -2829,37 +2777,6 @@ describe("OpenAI Responses route", () => {
    }),
  )

-  it.effect("lowers remote user media URLs without base64 wrapping", () =>
-    Effect.gen(function* () {
-      const prepared = yield* compileRequest(
-        LLM.request({
-          model,
-          messages: [
-            Message.user([
-              { type: "media", mediaType: "image/png", data: "https://example.com/image.png" },
-              {
-                type: "media",
-                mediaType: "application/pdf",
-                data: "https://example.com/report.pdf",
-                filename: "report.pdf",
-              },
-            ]),
-          ],
-        }),
-      )
-
-      expect(prepared.body.input).toEqual([
-        {
-          role: "user",
-          content: [
-            { type: "input_image", image_url: "https://example.com/image.png" },
-            { type: "input_file", filename: "report.pdf", file_url: "https://example.com/report.pdf" },
-          ],
-        },
-      ])
-    }),
-  )
-
  it.effect("fails with a typed rate limit for provider error frames", () =>
    Effect.gen(function* () {
      const error = yield* LLMClient.generate(request).pipe(
@@ -3016,42 +2933,36 @@ describe("OpenAI Responses route", () => {
    }),
  )

-  it.effect("falls back to the raw payload when error is null", () =>
+  it.effect("falls back to a stable default when error is null", () =>
    Effect.gen(function* () {
      const error = yield* LLMClient.generate(request).pipe(
        Effect.provide(fixedResponse(sseEvents({ type: "error", error: null }))),
        Effect.flip,
      )

-      expect(error.reason).toMatchObject({ _tag: "UnknownProvider" })
-      expect(error.reason.message).toContain('"error":null')
-      expect(error.body).toBe(error.reason.message)
+      expect(error.reason).toMatchObject({ _tag: "UnknownProvider", message: "OpenAI Responses stream error" })
    }),
  )

-  it.effect("falls back to the raw payload when both error and response are absent", () =>
+  it.effect("falls back to a stable default when both error and response are absent", () =>
    Effect.gen(function* () {
      const error = yield* LLMClient.generate(request).pipe(
        Effect.provide(fixedResponse(sseEvents({ type: "error" }))),
        Effect.flip,
      )

-      expect(error.reason).toMatchObject({ _tag: "UnknownProvider" })
-      expect(error.reason.message).toContain('"type":"error"')
-      expect(error.body).toBe(error.reason.message)
+      expect(error.reason).toMatchObject({ _tag: "UnknownProvider", message: "OpenAI Responses stream error" })
    }),
  )

-  it.effect("keeps the raw response payload when response.failed has no error payload", () =>
+  it.effect("falls back to a stable default when response.failed has no error payload", () =>
    Effect.gen(function* () {
      const error = yield* LLMClient.generate(request).pipe(
        Effect.provide(fixedResponse(sseEvents({ type: "response.failed", response: { id: "resp_failed_3" } }))),
        Effect.flip,
      )

-      expect(error.reason).toMatchObject({ _tag: "UnknownProvider" })
-      expect(error.reason.message).toContain('"resp_failed_3"')
-      expect(error.body).toBe(error.reason.message)
+      expect(error.reason).toMatchObject({ _tag: "UnknownProvider", message: "OpenAI Responses response failed" })
    }),
  )

@@ -64,7 +64,7 @@ const targets: ReadonlyArray<{
    id: "xai",
    name: "xAI Grok 4.5",
    provider: "xai",
-    protocol: "xai-responses",
+    protocol: "openai-responses",
    requires: "XAI_API_KEY",
    filename: "verification.pdf",
    maxTokens: 40,
@@ -1,77 +0,0 @@
-import { describe, expect } from "bun:test"
-import { Effect } from "effect"
-import { LLM, LLMEvent } from "../../src/index.js"
-import { XAI } from "../../src/providers.js"
-import { OpenResponses } from "../../src/protocols/open-responses.js"
-import { OpenAIResponses } from "../../src/protocols/openai-responses.js"
-import { XAIResponses } from "../../src/protocols/xai-responses.js"
-import { LLMClient } from "../../src/route.js"
-import { compileRequest } from "../../src/route/client.js"
-import { it } from "../lib/effect.js"
-import { fixedResponse } from "../lib/http.js"
-import { sseEvents } from "../lib/sse.js"
-
-const model = XAI.configure({ apiKey: "test", baseURL: "https://api.x.ai/v1" }).responses("grok-4.6")
-
-describe("xAI Responses route", () => {
-  it.effect("extends the Open Responses baseline directly", () =>
-    Effect.gen(function* () {
-      expect(XAIResponses.protocol.body).toBe(OpenResponses.protocol.body)
-      expect(XAIResponses.protocol.body).not.toBe(OpenAIResponses.protocol.body)
-
-      const prepared = yield* compileRequest(LLM.request({ model, prompt: "Hello" }))
-      expect(prepared.protocol).toBe("xai-responses")
-    }),
-  )
-
-  it.effect("parses xAI reasoning text events", () =>
-    Effect.gen(function* () {
-      const response = yield* LLMClient.generate(LLM.request({ model, prompt: "Think" })).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents(
-              { type: "response.reasoning_text.delta", item_id: "reasoning_1", delta: "Considering." },
-              { type: "response.reasoning_text.done", item_id: "reasoning_1" },
-              {
-                type: "response.output_item.done",
-                item: { type: "reasoning", id: "reasoning_1", encrypted_content: "opaque" },
-              },
-              { type: "response.completed", response: { id: "response_1" } },
-            ),
-          ),
-        ),
-      )
-
-      expect(response.message.content.find((part) => part.type === "reasoning")).toMatchObject({
-        type: "reasoning",
-        text: "Considering.",
-        providerMetadata: { xai: { itemId: "reasoning_1", reasoningEncryptedContent: "opaque" } },
-      })
-    }),
-  )
-
-  it.effect("parses xAI hosted tool items", () =>
-    Effect.gen(function* () {
-      const response = yield* LLMClient.generate(LLM.request({ model, prompt: "Search X" })).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents(
-              {
-                type: "response.output_item.done",
-                item: { type: "x_search_call", id: "x_search_1", status: "completed", action: { query: "news" } },
-              },
-              { type: "response.completed", response: { id: "response_1" } },
-            ),
-          ),
-        ),
-      )
-
-      expect(response.events.find(LLMEvent.is.toolCall)).toMatchObject({
-        id: "x_search_1",
-        name: "x_search",
-        input: { query: "news" },
-        providerExecuted: true,
-      })
-    }),
-  )
-})
@@ -19,12 +19,6 @@

 - Always prefer `createStore` over multiple `createSignal` calls

-## Typography
-
- Use `--line-height-compact` (`16px`) for `13px` compact UI text and `--line-height-base` (`20px`) for body text.
- Do not use `leading-none`, `line-height: 1`, or a `13px` line height for normal text. Inter descenders clip inside truncation and overflow containers.
- Keep control and row heights explicit. Fix font metrics directly rather than using transforms, negative margins, or clip-padding compensation.
-
 ## Localization

 - NEVER hardcode user-visible English strings in production code. ALWAYS use an i18n key for visible copy, placeholders, accessible labels, tooltips, menus, dialogs, toasts, empty states, and displayed errors.
@@ -259,22 +259,6 @@ export function event(
  return makeEvent(type, data)
 }

-export function compactionStarted(data: Extract<OpenCodeEvent, { type: "session.compaction.started" }>["data"]) {
-  return makeEvent("session.compaction.started", data)
-}
-
-export function compactionDelta(data: Extract<OpenCodeEvent, { type: "session.compaction.delta" }>["data"]) {
-  return makeEvent("session.compaction.delta", data)
-}
-
-export function compactionEnded(data: Extract<OpenCodeEvent, { type: "session.compaction.ended" }>["data"]) {
-  return makeEvent("session.compaction.ended", data)
-}
-
-export function compactionFailed(data: Extract<OpenCodeEvent, { type: "session.compaction.failed" }>["data"]) {
-  return makeEvent("session.compaction.failed", data)
-}
-
 export function toolInputStarted(data: Extract<OpenCodeEvent, { type: "session.tool.input.started" }>["data"]) {
  return makeEvent("session.tool.input.started", data)
 }
@@ -53,37 +53,6 @@ benchmark.describe("performance: first navigation paint", () => {
    expect(result.summary.unknownSamples).toBe(0)
  })

-  benchmark("opens a session from the new session page without a blank frame", async ({ page, report }) => {
-    await mockStressTimeline(page)
-    await installTimelineSettings(page)
-    await installStressSessionTabs(page, { draftID })
-    await page.goto("/")
-
-    const draftHref = stressDraftHref(draftID)
-    const draftTab = page.locator(`[data-slot="titlebar-tabs"] a[href="${draftHref}"]`)
-    await expect(draftTab).toHaveCount(1)
-    await draftTab.click()
-    await expect(page.locator('[data-component="new-session"]')).toBeVisible()
-
-    const href = stressSessionHref(fixture.targetID)
-    const sessionTab = page.locator(`[data-slot="titlebar-tabs"] a[href="${href}"]`)
-    await expect(sessionTab).toHaveCount(1)
-    const result = await measureFirstNavigation(page, {
-      href,
-      destinationPath: href,
-      sourceSelector: '[data-component="new-session"]',
-      destinationSelector: messageSelector(fixture.expected.targetMessageIDs.at(-1)!),
-      contentSelector,
-      navigate: async () => {
-        await sessionTab.click()
-        await expectSessionTitle(page, fixture.expected.targetTitle)
-      },
-    })
-    report(result)
-    expect(result.summary.blankSamples).toBe(0)
-    expect(result.summary.unknownSamples).toBe(0)
-  })
-
  benchmark("opens a child session without a blank frame", async ({ page, report }) => {
    await setup(page)
    const href = stressSessionHref(fixture.childID)
@@ -45,17 +45,21 @@ test("opens the comment editor for a line number range", async ({ page }) => {
  await expect(review.locator('[data-slot="line-comment-editor-label"]')).toHaveText("Commenting on lines 1-3")
 })

-test("shows a comment button when a diff line is hovered", async ({ page }) => {
+test("shows a comment button when a line number is hovered", async ({ page }) => {
  const review = page.locator('[data-component="session-review"]')
-  const line = review.getByText("export const first = 1", { exact: true })
-  await expectAppVisible(line)
+  const lineNumber = review.locator('[data-column-number="1"]').last()
+  await expectAppVisible(lineNumber)

-  const comment = review.getByRole("button", { name: "Comment", exact: true, includeHidden: true })
-  await expect(comment).toHaveCount(1)
-  await line.dispatchEvent("pointermove", { pointerType: "mouse", bubbles: true, composed: true })
-  await expect(comment).toBeVisible()
-  await expect(comment).toHaveCSS("pointer-events", "auto")
-  await comment.dispatchEvent("click")
+  const comment = review.getByRole("button", { name: "Comment", exact: true })
+  await expect(async () => {
+    await lineNumber.hover()
+    await expect(lineNumber).toHaveAttribute("data-hovered", "")
+    await expect(comment).toHaveCount(1)
+    await expect(comment).toHaveCSS("pointer-events", "auto")
+    await comment.focus()
+    await expect(comment).toBeFocused()
+  }).toPass({ timeout: 10_000 })
+  await comment.press("Enter")
  await expect(review.getByRole("textbox")).toBeVisible()
  await expect(review.locator('[data-slot="line-comment-editor-label"]')).toHaveText("Commenting on line 1")
 })
@@ -18,7 +18,7 @@ const branchDiffs = [
  ),
 ]

-test("uses side placement by default and supports the terminal across the bottom", async ({ page }) => {
+test("keeps the review tree and terminal sized when both panels are open", async ({ page }) => {
  test.setTimeout(120_000)
  await page.setViewportSize({ width: 1400, height: 900 })
  await mockOpenCodeServer(page, {
@@ -27,7 +27,7 @@ test("uses side placement by default and supports the terminal across the bottom
      id: projectID,
      worktree: directory,
      vcs: "git",
-      name: "review-terminal-bottom",
+      name: "review-terminal-stacked",
      time: { created: 1700000000000, updated: 1700000000000 },
      sandboxes: [],
    },
@@ -45,7 +45,7 @@ test("uses side placement by default and supports the terminal across the bottom
    sessions: [
      {
        id: sessionID,
-        slug: "review-terminal-bottom",
+        slug: "review-terminal-stacked",
        projectID,
        directory,
        title,
@@ -138,22 +138,7 @@ test("uses side placement by default and supports the terminal across the bottom
  await page.keyboard.press("Control+Backquote")
  await expect(page.locator("#terminal-panel")).toBeVisible()
  await expectTree(page, 2_773, "action.yml")
-  await expectSideGeometry(page)
-
-  await page.evaluate(() => {
-    const settings = JSON.parse(localStorage.getItem("settings.v3") ?? "{}")
-    localStorage.setItem(
-      "settings.v3",
-      JSON.stringify({ ...settings, general: { ...settings.general, terminalPlacement: "bottom" } }),
-    )
-  })
-  await page.reload()
-  await expectSessionReady(page, { server, sessionID, title })
-  await expect(page.locator("#review-panel")).toBeVisible()
-  await page.keyboard.press("Control+Backquote")
-  await expect(page.locator("#terminal-panel")).toBeVisible()
-  await expectTree(page, 2_773, "action.yml")
-  await expectBottomGeometry(page)
+  await expectStackGeometry(page)
 })

 async function expectTree(page: Page, total: number, file: string) {
@@ -178,51 +163,23 @@ async function expectMountedTree(page: Page, total: number) {
  expect(state.rows).toBeLessThanOrEqual(60)
 }

-async function expectSideGeometry(page: Page) {
-  const geometry = await page.evaluate(() => {
-    const review = document.querySelector<HTMLElement>("#review-panel")!.getBoundingClientRect()
-    const terminal = document.querySelector<HTMLElement>("#terminal-panel")!.getBoundingClientRect()
-    return {
-      reviewLeft: review.left,
-      reviewRight: review.right,
-      terminalLeft: terminal.left,
-      terminalRight: terminal.right,
-      terminalTop: terminal.top,
-      reviewTop: review.top,
-    }
-  })
-  expect(Math.abs(geometry.terminalLeft - geometry.reviewLeft)).toBeLessThanOrEqual(1)
-  expect(Math.abs(geometry.terminalRight - geometry.reviewRight)).toBeLessThanOrEqual(1)
-  expect(geometry.terminalTop).toBeGreaterThan(geometry.reviewTop)
-}
-
-async function expectBottomGeometry(page: Page) {
+async function expectStackGeometry(page: Page) {
  const geometry = await page.evaluate(() => {
    const review = document.querySelector<HTMLElement>("#review-panel")!
    const terminal = document.querySelector<HTMLElement>("#terminal-panel")!
-    const terminalRect = terminal.getBoundingClientRect()
    const reviewParent = review.parentElement!.getBoundingClientRect()
    const terminalParent = terminal.parentElement!.getBoundingClientRect()
    const sidebar = review.querySelector<HTMLElement>('[data-slot="session-review-v2-sidebar"]')!
    return {
      review: review.getBoundingClientRect().height,
-      reviewBottom: review.getBoundingClientRect().bottom,
      reviewParent: reviewParent.height,
-      terminal: terminalRect.height,
-      terminalLeft: terminalRect.left,
-      terminalRight: terminalRect.right,
-      terminalTop: terminalRect.top,
+      terminal: terminal.getBoundingClientRect().height,
      terminalParent: terminalParent.height,
      sidebar: sidebar.getBoundingClientRect().width,
-      viewport: window.innerWidth,
    }
  })
  expect(Math.abs(geometry.review - geometry.reviewParent)).toBeLessThanOrEqual(1)
  expect(Math.abs(geometry.terminal - geometry.terminalParent)).toBeLessThanOrEqual(1)
-  expect(geometry.terminalTop - geometry.reviewBottom).toBeGreaterThanOrEqual(7)
-  expect(geometry.terminalTop - geometry.reviewBottom).toBeLessThanOrEqual(9)
-  expect(geometry.terminalLeft).toBeLessThanOrEqual(9)
-  expect(geometry.terminalRight).toBeGreaterThanOrEqual(geometry.viewport - 9)
  expect(geometry.sidebar).toBeGreaterThanOrEqual(240)
 }

@@ -1,48 +0,0 @@
-import { expect, test, type Route } from "@playwright/test"
-
-const server = "http://127.0.0.1:4097"
-
-test("nested server dialog keeps focus inside the top layer", async ({ page }) => {
-  await page.addInitScript((server) => {
-    localStorage.setItem("opencode.global.dat:server", JSON.stringify({ list: [server] }))
-  }, server)
-  await page.route("**/*", async (route) => {
-    const url = new URL(route.request().url())
-    if (url.origin !== server) return route.fallback()
-    if (url.pathname === "/api/event") {
-      return route.fulfill({
-        status: 200,
-        contentType: "text/event-stream",
-        body: 'data: {"id":"evt_connected","type":"server.connected","data":{}}\n\n',
-      })
-    }
-    if (url.pathname === "/api/global/health" || url.pathname === "/api/health") {
-      return json(route, { healthy: true, version: "2.0.0" })
-    }
-    return json(route, {})
-  })
-
-  await page.goto("/")
-  await page.keyboard.press("Control+,")
-  const settings = page.locator(".settings-dialog")
-  await expect(settings).toBeVisible()
-  await settings.getByRole("tab", { name: "Servers" }).click()
-  await settings.getByRole("button", { name: "Add server" }).click()
-
-  const editor = page.getByRole("dialog", { name: "Add server" })
-  await expect(editor.getByPlaceholder("http://localhost:4096")).toBeFocused()
-  const username = editor.getByPlaceholder("username")
-  const password = editor.getByPlaceholder("password")
-  await username.click()
-  await expect(username).toBeFocused()
-  await username.fill("kit")
-  await expect(username).toHaveValue("kit")
-  await page.keyboard.press("Tab")
-  await expect(password).toBeFocused()
-  await password.fill("secret")
-  await expect(password).toHaveValue("secret")
-})
-
-function json(route: Route, body: unknown, status = 200) {
-  return route.fulfill({ status, contentType: "application/json", body: JSON.stringify(body) })
-}
@@ -99,7 +99,7 @@ test.describe("regression: session timeline local row state", () => {
    await wrapper.evaluate((element) => {
      ;(element as HTMLElement).dataset.regressionMarker = "before-stream"
    })
-    await wrapper.locator('[data-scope="apply-patch"] button').click()
+    await wrapper.locator('[data-slot="collapsible-trigger"]').first().click()
    await expectExpanded(wrapper, false)

    events.push(...textEvents())
@@ -139,7 +139,7 @@ test.describe("regression: session timeline local row state", () => {
    expect(siblingProbe).toEqual({
      fileMarker: "before",
      frameMarker: "before",
-      rowKey: `assistant-part:part:${assistantMessageID}:${editPartID}`,
+      rowKey: `assistant-part:${userMessageID}:part:${assistantMessageID}:${editPartID}`,
      rowMarker: "before",
      shadowRoots: 0,
      toolMarker: "before",
@@ -179,8 +179,8 @@ test.describe("regression: session timeline local row state", () => {
    await expectSessionTitle(page, title)

    const wrapper = page.locator(`[data-timeline-part-id="${editPartID}"]`).first()
-    const trigger = wrapper.locator('[data-component="sticky-accordion-header"]')
-    const diff = wrapper.locator('[data-component="apply-patch-file-diff"]').first()
+    const trigger = wrapper.locator('[data-slot="collapsible-trigger"]').first()
+    const diff = wrapper.locator('[data-component="edit-content"]').first()
    await expectAppVisible(diff)
    await expect.poll(() => wrapper.evaluate((element) => element.getBoundingClientRect().height)).toBeGreaterThan(500)
    const samples = await wrapper.evaluate(async (element) => {
@@ -190,8 +190,8 @@ test.describe("regression: session timeline local row state", () => {
      for (const offset of [0, 120, 240, 360, 480]) {
        root.scrollBy(0, offset - (result.at(-1)?.offset ?? 0))
        await new Promise(requestAnimationFrame)
-        const trigger = element.querySelector<HTMLElement>('[data-component="sticky-accordion-header"]')!
-        const diff = element.querySelector<HTMLElement>('[data-component="apply-patch-file-diff"]')!
+        const trigger = element.querySelector<HTMLElement>('[data-slot="collapsible-trigger"]')!
+        const diff = element.querySelector<HTMLElement>('[data-component="edit-content"]')!
        result.push({
          offset,
          trigger: trigger.getBoundingClientRect().y,
@@ -202,7 +202,7 @@ test.describe("regression: session timeline local row state", () => {
      return result
    })

-    expect(samples[0]!.trigger).toBeGreaterThanOrEqual(samples[0]!.diff)
+    expect(samples[0]!.trigger).toBeLessThan(samples[0]!.diff)
    expect(samples.every((sample) => Math.abs(sample.trigger - samples[0]!.trigger) <= 1)).toBe(true)
    expect(samples.every((sample) => sample.trigger < sample.bottom)).toBe(true)
  })
@@ -234,9 +234,7 @@ async function readToolState(page: Page) {
    .evaluate(
      (element, textPartID) => ({
        expanded: (() => {
-          const trigger =
-            element.querySelector('[data-scope="apply-patch"] button') ??
-            element.querySelector('[data-slot="collapsible-trigger"]')
+          const trigger = element.querySelector('[data-slot="collapsible-trigger"]')
          const aria = trigger?.getAttribute("aria-expanded")
          if (aria === "true") return true
          if (aria === "false") return false
@@ -411,9 +409,7 @@ function eventValue<Type extends OpenCodeEvent["type"]>(
 }

 function readExpanded(element: Element) {
-  const trigger =
-    element.querySelector('[data-scope="apply-patch"] button') ??
-    element.querySelector('[data-slot="collapsible-trigger"]')
+  const trigger = element.querySelector('[data-slot="collapsible-trigger"]')
  const aria = trigger?.getAttribute("aria-expanded")
  if (aria === "true") return true
  if (aria === "false") return false
@@ -1,12 +1,5 @@
 import { expect, test } from "@playwright/test"
-import { createTwoFilesPatch } from "diff"
-import {
-  assistantMessage,
-  setupTimeline,
-  toolPart,
-  userMessage,
-  userText,
-} from "../performance/timeline-stability/fixture"
+import { assistantMessage, setupTimeline, toolPart, userMessage } from "../performance/timeline-stability/fixture"

 test("renders completed write content", async ({ page }) => {
  const id = "prt_file_projection_write"
@@ -56,142 +49,8 @@ test("renders a completed single-file patch", async ({ page }) => {

  const wrapper = page.locator(`[data-timeline-part-id="${id}"]`)
  const file = wrapper.locator('[data-scope="apply-patch"]')
-  const scroller = page.locator(".scroll-view__viewport", { has: page.locator("[data-timeline-row]") })
  await expect(file.getByRole("button")).toHaveAttribute("aria-expanded", "false")
  await expect(wrapper.locator('[data-component="apply-patch-file-diff"]')).toHaveCount(0)
  await file.getByRole("button").click()
  await expect(wrapper.locator('[data-component="apply-patch-file-diff"]')).toBeVisible()
-  await expect
-    .poll(() => scroller.evaluate((element) => element.scrollHeight - element.clientHeight - element.scrollTop))
-    .toBeLessThanOrEqual(1)
-
-  await file.getByRole("button").click()
-  await expect(wrapper.locator('[data-component="apply-patch-file-diff"]')).toHaveCount(0)
-  await expect
-    .poll(() => scroller.evaluate((element) => element.scrollHeight - element.clientHeight - element.scrollTop))
-    .toBeLessThanOrEqual(1)
-
-  await file.getByRole("button").click()
-  await expect(wrapper.locator('[data-component="apply-patch-file-diff"]')).toBeVisible()
-  await expect
-    .poll(() => scroller.evaluate((element) => element.scrollHeight - element.clientHeight - element.scrollTop))
-    .toBeLessThanOrEqual(1)
-})
-
-test("keeps an expanded file diff header at the same viewport position", async ({ page }) => {
-  const id = "prt_file_projection_anchored_patch"
-  const before = Array.from({ length: 80 }, (_, index) => `export const value${index} = ${index}\n`).join("")
-  const after = before.replaceAll(" = ", " = compute(").replaceAll("\n", ")\n")
-  await setupTimeline(page, {
-    messages: [
-      userMessage([userText("Preceding context ".repeat(120))]),
-      assistantMessage([
-        toolPart(
-          id,
-          "patch",
-          "completed",
-          { patchText: "Update src/anchored.ts" },
-          {
-            metadata: {
-              files: [
-                {
-                  file: "src/anchored.ts",
-                  status: "modified",
-                  patch: createTwoFilesPatch("a/src/anchored.ts", "b/src/anchored.ts", before, after),
-                  additions: 80,
-                  deletions: 80,
-                },
-              ],
-            },
-          },
-        ),
-      ]),
-    ],
-    viewport: { width: 1200, height: 600 },
-  })
-
-  const scroller = page.locator(".scroll-view__viewport", { has: page.locator("[data-timeline-row]") })
-  const wrapper = page.locator(`[data-timeline-part-id="${id}"]`)
-  const row = page.locator("[data-timeline-key]", { has: wrapper })
-  const trigger = wrapper.getByRole("button")
-  await expect
-    .poll(() =>
-      row.evaluate((element) => {
-        const measured = element.querySelector<HTMLElement>("[data-index]")
-        return measured
-          ? Math.abs(element.getBoundingClientRect().height - measured.getBoundingClientRect().height)
-          : Number.POSITIVE_INFINITY
-      }),
-    )
-    .toBeLessThanOrEqual(1)
-  await expect
-    .poll(() => scroller.evaluate((element) => element.scrollHeight - element.clientHeight))
-    .toBeGreaterThan(1)
-  await scroller.evaluate((element) => {
-    element.scrollTop = element.scrollHeight - element.clientHeight - 0.25
-  })
-  await expect(trigger).toBeInViewport()
-  await expect
-    .poll(() => scroller.evaluate((element) => element.scrollHeight - element.clientHeight - element.scrollTop))
-    .toBeLessThanOrEqual(0.5)
-  const bottomScrollTop = await scroller.evaluate((element) => element.scrollTop)
-  await scroller.hover()
-  await page.mouse.wheel(0, -20)
-  await expect
-    .poll(() => scroller.evaluate((element, bottom) => bottom - element.scrollTop, bottomScrollTop))
-    .toBeGreaterThan(0)
-  const y = await trigger.evaluate((element) => element.getBoundingClientRect().y)
-  const collapsedHeight = await row.evaluate((element) => element.getBoundingClientRect().height)
-  await trigger.click()
-  await expect(wrapper.locator('[data-component="apply-patch-file-diff"]')).toBeVisible()
-  await expect
-    .poll(() =>
-      row.evaluate((element, collapsed) => {
-        const measured = element.querySelector<HTMLElement>("[data-index]")
-        const allocatedHeight = element.getBoundingClientRect().height
-        return {
-          grew: allocatedHeight > collapsed + 1,
-          measured: measured ? Math.abs(allocatedHeight - measured.getBoundingClientRect().height) <= 1 : false,
-        }
-      }, collapsedHeight),
-    )
-    .toEqual({ grew: true, measured: true })
-  await expect
-    .poll(() => trigger.evaluate((element, initialY) => Math.abs(element.getBoundingClientRect().y - initialY), y))
-    .toBeLessThanOrEqual(5)
-
-  const scrollTop = await scroller.evaluate((element) => element.scrollTop)
-  await scroller.hover()
-  await page.mouse.wheel(0, 200)
-  await expect
-    .poll(() => scroller.evaluate((element, initial) => element.scrollTop - initial, scrollTop))
-    .toBeGreaterThan(50)
-  const scrolled = await scroller.evaluate((element, initial) => element.scrollTop - initial, scrollTop)
-  expect(scrolled).toBeLessThan(400)
-
-  const expandedY = await trigger.evaluate((element) => element.getBoundingClientRect().y)
-  await trigger.click()
-  await expect(wrapper.locator('[data-component="apply-patch-file-diff"]')).toHaveCount(0)
-  await expect
-    .poll(() =>
-      scroller.evaluate((element) => Math.abs(element.scrollHeight - element.clientHeight - element.scrollTop)),
-    )
-    .toBeLessThanOrEqual(1)
-  await expect.poll(() => trigger.evaluate((element) => element.getBoundingClientRect().y)).toBeGreaterThan(expandedY)
-
-  await trigger.click()
-  await expect(wrapper.locator('[data-component="apply-patch-file-diff"]')).toBeVisible()
-  await expect
-    .poll(() =>
-      row.evaluate((element) => {
-        const measured = element.querySelector<HTMLElement>("[data-index]")
-        return measured
-          ? Math.abs(element.getBoundingClientRect().height - measured.getBoundingClientRect().height)
-          : Number.POSITIVE_INFINITY
-      }),
-    )
-    .toBeLessThanOrEqual(1)
-  await expect
-    .poll(() => scroller.evaluate((element) => element.scrollHeight - element.clientHeight - element.scrollTop))
-    .toBeLessThanOrEqual(1)
 })
@@ -17,7 +17,7 @@ import { mockOpenCodeServer } from "../utils/mock-server"
 import { installSseTransport } from "../utils/sse-transport"
 import { expectSessionTitle } from "../utils/waits"

-const messagePageSize = 20
+const messagePageSize = 200
 const server = `http://${process.env.PLAYWRIGHT_SERVER_HOST ?? "127.0.0.1"}:${process.env.PLAYWRIGHT_SERVER_PORT ?? "4096"}`
 const messages = Array.from({ length: messagePageSize / 2 + 1 }, (_, index) => {
  const id = `msg_${String(index + 1001).padStart(4, "0")}_history_root_user`
@@ -84,11 +84,11 @@ test("transitions a streaming shell from writing through command execution", asy
      executed: true,
    }),
  )
-  await expect(titleShimmer).toHaveAttribute("data-active", "true")
+  await expect(titleShimmer).toHaveAttribute("data-active", "false")
  await expect(subtitle).toHaveText(command)
 })

-test("shimmers and expands a running shell command", async ({ page }) => {
+test("shows and expands a running shell command without shimmering it", async ({ page }) => {
  const id = "prt_shell_running_command"
  const command = "sleep 10 && echo done"
  await setupTimeline(page, {
@@ -97,7 +97,7 @@ test("shimmers and expands a running shell command", async ({ page }) => {
  })

  const tool = page.locator(`[data-timeline-part-id="${id}"]`)
-  await expect(tool.locator('[data-component="text-shimmer"]')).toHaveAttribute("data-active", "true")
+  await expect(tool.locator('[data-component="text-shimmer"]')).toHaveAttribute("data-active", "false")
  await expect(tool).not.toContainText("Writing command...")
  await expect(tool.locator('[data-component="shell-submessage"]')).toHaveText(command)
  await expect(tool.locator('[data-component="shell-submessage"] [data-component="text-shimmer"]')).toHaveCount(0)
@@ -1,15 +1,6 @@
 import { expect, test } from "@playwright/test"
 import type { SessionMessageAssistant, SessionMessageInfo } from "@opencode-ai/client/promise"
-import {
-  compactionDelta,
-  compactionEnded,
-  compactionFailed,
-  compactionStarted,
-  event,
-  session,
-  sessionID,
-  setupTimeline,
-} from "../performance/timeline-stability/fixture"
+import { event, session, sessionID, setupTimeline, toolPart } from "../performance/timeline-stability/fixture"

 const user = { id: "msg_user", type: "user", text: "Run it", time: { created: 1 } } satisfies SessionMessageInfo

@@ -82,102 +73,23 @@ test("renders current protocol notices in CLI order", async ({ page }) => {
  expect(ownerWarnings).toEqual([])
 })

-test("renders a compaction summary while it streams and after completion", async ({ page }) => {
-  const timeline = await setupTimeline(page, { sessionMessages: [user, assistant(true)] })
-
-  await timeline.send(
-    compactionStarted({
-      sessionID,
-      reason: "manual",
-      recent: "",
-    }),
-  )
-
-  const compaction = page.locator('[data-component="session-compaction-message"]')
-  await expect(compaction.getByText("Session compacted", { exact: true })).toBeVisible()
-
-  await timeline.send(
-    compactionDelta({
-      sessionID,
-      text: "## Checkpoint\n\nStreamed implementation details.",
-    }),
-  )
-  await expect(compaction.getByRole("heading", { name: "Checkpoint" })).toBeVisible()
-  await expect(compaction).toContainText("Streamed implementation details.")
-
-  await timeline.send(
-    compactionEnded({
-      sessionID,
-      reason: "manual",
-      text: "## Checkpoint\n\nFinal implementation details.",
-      recent: "",
-    }),
-  )
-  await expect(compaction).toContainText("Final implementation details.")
-  await expect(compaction).not.toContainText("Streamed implementation details.")
-})
-
-test("updates running compactions to failed and cancelled boundaries", async ({ page }) => {
-  const timeline = await setupTimeline(page, { sessionMessages: [user, assistant(true)] })
-
-  await timeline.send(compactionStarted({ sessionID, reason: "auto", recent: "" }))
-  await timeline.send(compactionDelta({ sessionID, text: "Partial summary that should be discarded." }))
-  await timeline.send(
-    compactionFailed({
-      sessionID,
-      reason: "auto",
-      error: {
-        type: "compaction.failed",
-        message: 'Error: {"error":{"type":"ProviderError","message":"The provider rejected the summary."}}',
-      },
-    }),
-  )
-
-  const compactions = page.locator('[data-component="session-compaction-message"]')
-  const failed = compactions.filter({ hasText: "The provider rejected the summary." })
-  await expect(failed.getByText("Session compacted", { exact: true })).toBeVisible()
-  await expect(failed.getByText("ProviderError: The provider rejected the summary.", { exact: true })).toBeVisible()
-  await expect(failed).not.toContainText("Partial summary that should be discarded.")
-
-  await timeline.send(compactionStarted({ sessionID, reason: "manual", recent: "" }))
-  await timeline.send(
-    compactionFailed({
-      sessionID,
-      reason: "manual",
-      error: { type: "aborted", message: "Cancellation detail should stay hidden." },
-    }),
-  )
-
-  await expect(compactions).toHaveCount(2)
-  const cancelled = compactions.filter({ hasNotText: "The provider rejected the summary." })
-  await expect(cancelled.getByText("Session compacted", { exact: true })).toBeVisible()
-  await expect(cancelled).not.toContainText("Cancellation detail should stay hidden.")
-})
-
 test("shows a delegating row while subagent input streams", async ({ page }) => {
  await setupTimeline(page, {
    sessionMessages: [
      user,
      {
        ...assistant(false),
-        content: [
-          {
-            type: "tool",
-            id: "call_subagent",
-            name: "subagent",
-            state: { status: "streaming", input: "" },
-            time: { created: 2 },
-          },
-        ],
+        content: [toolPart("call_subagent", "subagent", "streaming", {})],
      },
    ],
  })

  const delegating = page.locator('[data-component="task-tool-delegating"]')
  await expect(delegating).toBeVisible()
-  const shimmer = delegating.locator('[data-component="text-shimmer"]')
-  await expect(shimmer).toHaveAttribute("aria-label", "Delegating agent...")
-  await expect(shimmer).toHaveCSS("line-height", "16px")
+  await expect(delegating.locator('[data-component="text-shimmer"]')).toHaveAttribute(
+    "aria-label",
+    "Delegating agent...",
+  )
  const icon = delegating.locator('[data-slot="icon-svg"]')
  await expect(icon.locator('use[href="#opencode-v2-icon-subagent"]')).toBeVisible()
  await expect(icon).toHaveCSS("color", "rgb(174, 174, 174)")
@@ -215,11 +127,11 @@ test("renders the moved location notice in its compact timeline style", async ({
  await expect(notice).toHaveCSS("padding-bottom", "4px")
  await expect(label).toHaveCSS("font-size", "13px")
  await expect(label).toHaveCSS("font-weight", "530")
-  await expect(label).toHaveCSS("line-height", "16px")
+  await expect(label).toHaveCSS("line-height", "13px")
  await expect(label).toHaveCSS("color", "rgb(128, 128, 128)")
  await expect(value).toHaveCSS("font-size", "13px")
  await expect(value).toHaveCSS("font-weight", "440")
-  await expect(value).toHaveCSS("line-height", "16px")
+  await expect(value).toHaveCSS("line-height", "13px")
  await expect(value).toHaveCSS("color", "rgb(128, 128, 128)")
  await expect(value).toHaveCSS("text-overflow", "ellipsis")
  await expect(value).toHaveCSS("white-space", "nowrap")
@@ -1,7 +1,6 @@
 import { expect, test } from "@playwright/test"
 import {
  assistantMessage,
-  partUpdated,
  setupTimeline,
  status,
  toolPart,
@@ -77,117 +76,34 @@ test.describe("session timeline projection", () => {
    await expect(patch.locator('[data-scope="apply-patch"] button[aria-expanded="false"]')).toHaveCount(1)
    await expect(patch.locator('[data-slot="message-part-title-filename"]')).toHaveCount(0)
    await expect(patch.locator('[data-slot="message-part-actions"]')).toHaveCount(0)
-    const edit = page.locator('[data-timeline-part-id="prt_edit"]')
-    await expect(edit.locator('[data-component="apply-patch-tool"]')).toBeVisible()
-    await expect(edit.locator('[data-slot="basic-tool-tool-title"]')).toContainText("Edit")
    await expect(page.locator('[data-timeline-part-id="prt_todo"]')).toHaveCount(0)
  })

-  test("combines adjacent patch calls and repeated files into one group", async ({ page }) => {
+  test("combines adjacent patch calls into one file group", async ({ page }) => {
    const first = "prt_patch_first"
    const second = "prt_patch_second"
-    const timeline = await setupTimeline(page, {
-      messages: [
-        userMessage(),
-        assistantMessage([
-          toolPart(
-            first,
-            "patch",
-            "completed",
-            { patchText: "Update src/first.ts" },
-            {
-              metadata: { files: [patchFile("src/first.ts", "modified")] },
-            },
-          ),
-        ]),
-      ],
-    })
-
-    const initial = page.locator(`[data-timeline-part-id="${first}"]`)
-    const initialFile = initial.locator('[data-scope="apply-patch"] [data-type="update"]')
-    await expect(initialFile).toBeVisible()
-    await initialFile.getByRole("button").click()
-    await expect(initialFile.getByRole("button")).toHaveAttribute("aria-expanded", "true")
-    await initial.evaluate((element) => {
-      const row = element.closest<HTMLElement>("[data-timeline-key]")
-      if (row) row.dataset.patchRow = "stable"
-    })
-
-    await timeline.send(
-      partUpdated(toolPart(second, "patch", "running", { patchText: "Update more files" }, { metadata: {} })),
-    )
-
-    const group = page.locator(`[data-timeline-part-ids="${first},${second}"]`)
-    await expect(group.locator("xpath=ancestor::*[@data-timeline-key]")).toHaveAttribute("data-patch-row", "stable")
-    await expect(group.locator('[data-slot="apply-patch-filename"]')).toHaveText(["first.ts"])
-    await expect(group.locator('[data-scope="apply-patch"] [data-type="update"] button')).toHaveAttribute(
-      "aria-expanded",
-      "true",
-    )
-
-    await timeline.send(
-      partUpdated(
-        toolPart(
-          second,
-          "patch",
-          "completed",
-          { patchText: "Update more files" },
-          {
-            metadata: {
-              files: [patchFile("src/first.ts", "modified"), patchFile("src/second.ts", "added")],
-            },
-          },
-        ),
-      ),
-    )
-
-    await expect(group.locator('[data-slot="apply-patch-filename"]')).toHaveText(["first.ts", "second.ts"])
-    await expect(group.locator('[data-scope="apply-patch"] [data-type="update"] button')).toHaveAttribute(
-      "aria-expanded",
-      "true",
-    )
-    await expect(group.locator('[data-scope="apply-patch"] [data-type="add"] button')).toHaveAttribute(
-      "aria-expanded",
-      "false",
-    )
-    await expect(page.locator(`[data-timeline-part-id="${first}"], [data-timeline-part-id="${second}"]`)).toHaveCount(0)
-  })
-
-  test("combines adjacent edit calls and repeated files into one group", async ({ page }) => {
-    const first = "prt_edit_first"
-    const second = "prt_edit_second"
    await setupTimeline(page, {
      messages: [
        userMessage(),
        assistantMessage([
-          toolPart(
-            first,
-            "edit",
-            "completed",
-            { path: "src/first.ts", oldString: "one", newString: "two" },
-            {
-              metadata: { files: [patchFile("src/first.ts", "modified")] },
-            },
-          ),
-          toolPart(
-            second,
-            "edit",
-            "completed",
-            { path: "src/first.ts", oldString: "two", newString: "three" },
-            {
-              metadata: { files: [patchFile("src/first.ts", "modified")] },
-            },
-          ),
+          toolPart(first, "patch", "completed", { patchText: "Update src/first.ts" }, {
+            metadata: { files: [patchFile("src/first.ts", "modified")] },
+          }),
+          toolPart(second, "patch", "completed", { patchText: "Update src/second.ts" }, {
+            metadata: { files: [patchFile("src/second.ts", "added")] },
+          }),
        ]),
      ],
-      settings: { editToolPartsExpanded: true },
    })

    const group = page.locator(`[data-timeline-part-ids="${first},${second}"]`)
-    await expect(group.locator('[data-slot="basic-tool-tool-title"]')).toContainText("Edit")
-    await expect(group.getByText("1 file", { exact: true })).toBeVisible()
-    await expect(group.locator('[data-slot="apply-patch-filename"]')).toHaveText(["first.ts"])
-    await expect(group.locator('[data-scope="apply-patch"] button')).toHaveAttribute("aria-expanded", "true")
+    await expect(group).toBeVisible()
+    await expect(group.locator('[data-component="apply-patch-tool"]')).toHaveCount(1)
+    await expect(group.getByRole("button", { name: "Patch 2 files" })).toHaveCount(0)
+    await expect(group.getByRole("button")).toHaveCount(2)
+    await expect(group.locator('[data-scope="apply-patch"] button[aria-expanded="false"]')).toHaveCount(2)
+    await expect(group.locator('[data-slot="apply-patch-filename"]')).toHaveText(["first.ts", "second.ts"])
+    await expect(page.locator(`[data-timeline-part-id="${first}"], [data-timeline-part-id="${second}"]`)).toHaveCount(0)
  })

  test("projects gaps, dividers, assistant parts, and errors together", async ({ page }) => {
@@ -98,9 +98,9 @@ test("labels completed searches with result counts", async ({ page }) => {

  const group = page.locator(`[data-timeline-part-ids="${glob},${grep}"]`)
  await group.locator('[data-slot="collapsible-trigger"]').click()
-  const rows = group.locator('[data-component="context-tool-group-list"] [data-component="tool-trigger"]')
-  await expect(rows.filter({ hasText: "Glob" })).toContainText("(1 match)")
-  await expect(rows.filter({ hasText: "Grep" })).toContainText("(12 matches)")
+  const rows = group.locator('[data-component="tool-trigger"]')
+  await expect(rows.nth(0)).toContainText("(1 match)")
+  await expect(rows.nth(1)).toContainText("(12 matches)")
 })

 test("labels read tools from their path input", async ({ page }) => {
@@ -111,11 +111,7 @@ test("labels read tools from their path input", async ({ page }) => {

  const group = page.locator(`[data-timeline-part-ids="${id}"]`)
  await group.locator('[data-slot="collapsible-trigger"]').click()
-  await expect(
-    group
-      .locator('[data-component="context-tool-group-list"] [data-component="tool-trigger"]')
-      .filter({ hasText: "Read" }),
-  ).toContainText("a.ts")
+  await expect(group.locator('[data-slot="basic-tool-tool-subtitle"]')).toHaveText("a.ts")
 })

 test("labels skill tools from IDs and result metadata", async ({ page }) => {
@@ -125,20 +121,19 @@ test("labels skill tools from IDs and result metadata", async ({ page }) => {
    messages: [
      userMessage(),
      assistantMessage([
-        toolPart(pending, "skill", "running", { id: "frontend-design" }),
+        toolPart(pending, "skill", "running", { id: "sample-skill" }),
        toolPart(completed, "skill", "completed", { id: "opencode" }, { metadata: { name: "OpenCode" } }),
      ]),
    ],
  })

  for (const [id, name] of [
-    [pending, "frontend-design"],
+    [pending, "sample-skill"],
    [completed, "OpenCode"],
  ] as const) {
    const skill = page.locator(`[data-timeline-part-id="${id}"]`)
    const loaded = skill.locator('[data-component="tool-loaded-item"]')
    await expect(loaded).toHaveAttribute("aria-label", `Loaded ${name} skill`)
-    await expect(loaded).toHaveCSS("line-height", "16px")
    await expect(loaded.locator('[data-slot="tool-loaded-label"]')).toHaveText("Loaded")
    await expect(loaded.locator('[data-slot="tool-loaded-kind"]')).toHaveText("skill")
    await expect(loaded.locator('[data-component="text-shimmer"]')).toHaveAttribute("aria-label", name)
@@ -9,12 +9,10 @@ const sessionID = "ses_terminal_composer_focus"
 const ptyID = "pty_terminal_composer_focus"
 const newPtyID = "pty_terminal_composer_focus_new"
 const server = `http://${process.env.PLAYWRIGHT_SERVER_HOST ?? "127.0.0.1"}:${process.env.PLAYWRIGHT_SERVER_PORT ?? "4096"}`
-const ptyInput: string[] = []

 test.use({ viewport: { width: 1440, height: 900 } })

 test.beforeEach(async ({ page }) => {
-  ptyInput.length = 0
  await mockOpenCodeServer(page, {
    directory,
    project: {
@@ -72,22 +70,7 @@ test.beforeEach(async ({ page }) => {
      body: JSON.stringify({ location: ptyLocation(), data: { ticket: "e2e-ticket", expires_in: 60 } }),
    }),
  )
-  await page.routeWebSocket(new RegExp(`/api/pty/${ptyID}/connect`), (ws) => {
-    ws.onMessage((message) => ptyInput.push(message.toString()))
-  })
-})
-
-test("clears the terminal line with Command+Delete", async ({ page }) => {
-  await page.goto(`/server/${base64Encode(server)}/session/${sessionID}`)
-  await expectSessionTitle(page, "Terminal composer focus")
-
-  const terminal = page.locator('[data-component="terminal"]')
-  await page.keyboard.press("Control+Backquote")
-  await expect(terminal.locator("textarea")).toHaveCount(1)
-
-  await page.keyboard.press("Meta+Backspace")
-
-  await expect.poll(() => ptyInput.join("")).toBe("\x15")
+  await page.routeWebSocket(new RegExp(`/api/pty/${ptyID}/connect`), () => undefined)
 })

 test("routes typing to the composer unless the open terminal is focused", async ({ page }) => {
@@ -48,7 +48,6 @@
    "typescript": "catalog:",
    "vite": "8.2.1",
    "vite-plugin-icons-spritesheet": "3.0.1",
-    "vite-plugin-pwa": "1.3.0",
    "vite-plugin-solid": "2.11.14"
  },
  "dependencies": {
@@ -15,14 +15,3 @@

 /*.css
  Content-Type: text/css
-
-/site.webmanifest
-  Content-Type: application/manifest+json
-
-/sw.js
-  Content-Type: application/javascript
-  Cache-Control: no-cache
-
-/registerSW.js
-  Content-Type: application/javascript
-  Cache-Control: no-cache
@@ -51,7 +51,6 @@ export type ComposerSession = {
    location: { command: Pick<Data["location"]["command"], "list"> }
    session: {
      prompt: (input: Parameters<Data["session"]["prompt"]>[0]) => Promise<unknown>
-      setStatus: Data["session"]["setStatus"]
    }
  }
  current: Accessor<{ agent?: string; model?: { id: string; providerID: string; variant?: string } } | undefined>
@@ -78,7 +77,7 @@ export type NewSessionComposerAdapter = ComposerAdapterBase & {
  start: (
    selection: ComposerSelection,
    submission: ReturnType<typeof createComposerSubmission>,
-  ) => Promise<{ session: ComposerSession; cleanupReady: Promise<void> } | undefined>
+  ) => Promise<ComposerSession | undefined>
 }

 export type ComposerAdapter = ActiveComposerAdapter | NewSessionComposerAdapter
@@ -29,7 +29,7 @@ export function Composer(props: {
        accentSubmit={props.accentSubmit}
        borderUnderlay={props.borderUnderlay}
        class={props.class}
-        modelControlsVisible={!props.model.model.loading}
+        variantControlVisible={!props.model.model.loading}
        attachKeybind={command.keybindParts("file.attach")}
        attachShortcut={command.keybind("file.attach")}
        modelControl={
@@ -42,7 +42,7 @@ export type ComposerEditorProps = {
  borderUnderlay?: boolean
  class?: string
  modelControl?: JSX.Element
-  modelControlsVisible?: boolean
+  variantControlVisible?: boolean
  attachKeybind?: string[]
  attachShortcut?: string
 }
@@ -233,19 +233,17 @@ export function ComposerEditor(props: ComposerEditorProps) {
                />
              )}
            </Show>
-            <Show when={props.modelControlsVisible ?? true}>
-              {props.modelControl}
-              <Show when={view.variant} keyed>
-                {(control) => (
-                  <Show when={control.options().length > 1}>
-                    <ComposerEditorConfiguredSelect
-                      title={i18n.t("ui.promptInput.chooseVariant")}
-                      keybind={["Shift", "Mod", "D"]}
-                      control={control}
-                    />
-                  </Show>
-                )}
-              </Show>
+            {props.modelControl}
+            <Show when={(props.variantControlVisible ?? true) && view.variant} keyed>
+              {(control) => (
+                <Show when={control.options().length > 1}>
+                  <ComposerEditorConfiguredSelect
+                    title={i18n.t("ui.promptInput.chooseVariant")}
+                    keybind={["Shift", "Mod", "D"]}
+                    control={control}
+                  />
+                </Show>
+              )}
            </Show>
          </div>
          <ComposerEditorSubmitButton
@@ -69,7 +69,6 @@ function submitInput(
 function session(input: {
  calls: string[]
  prompt: (value: Parameters<ComposerSession["data"]["session"]["prompt"]>[0]) => Promise<void>
-  statuses?: ("idle" | "running")[]
  current?: ComposerSession["current"]
  admitted?: (messageID: string) => boolean
  shell?: () => Promise<unknown>
@@ -93,7 +92,6 @@ function session(input: {
    data: {
      location: { command: { list: () => [] } },
      session: {
-        setStatus: (_sessionID, status) => input.statuses?.push(status),
        prompt: async (value) => {
          input.calls.push("prompt")
          await input.prompt(value)
@@ -142,12 +140,10 @@ describe("Composer submission", () => {

  test("starts and promotes a New Session once before admitting its first prompt", async () => {
    const draft = createMemoryComposerState({ prompt: "first prompt" }).capture()
-    const promoted = createMemoryComposerState({ prompt: "restored draft" }).capture()
+    const promoted = createMemoryComposerState().capture()
    const calls: string[] = []
-    const statuses: ("idle" | "running")[] = []
    const admitted = Promise.withResolvers<Parameters<ComposerSession["data"]["session"]["prompt"]>[0]>()
-    const cleanupReady = Promise.withResolvers<void>()
-    const target = session({ calls, statuses, prompt: async (value) => admitted.resolve(value) })
+    const target = session({ calls, prompt: async (value) => admitted.resolve(value) })
    const adapter: NewSessionComposerAdapter = {
      kind: "new-session",
      state: draft,
@@ -160,20 +156,14 @@ describe("Composer submission", () => {
      async start(_selection, submission) {
        calls.push("start")
        submission.retarget(promoted)
-        return { session: target, cleanupReady: cleanupReady.promise }
+        return target
      },
    }

-    const submitted = submitInput(adapter).submit(new Event("submit"))
+    await submitInput(adapter).submit(new Event("submit"))
    const request = await admitted.promise

-    expect(calls).toEqual(["start", "switch-agent", "switch-model", "prompt"])
-    expect(statuses).toEqual(["running"])
-    expect(promoted.current()).toMatchObject([{ type: "text", content: "restored draft" }])
-    cleanupReady.resolve()
-    await submitted
-
-    expect(calls).toEqual(["start", "switch-agent", "switch-model", "prompt", "submitted"])
+    expect(calls).toEqual(["start", "submitted", "switch-agent", "switch-model", "prompt"])
    expect(request.delivery).toBe("steer")
    expect(request.text).toBe("first prompt")
    expect(draft.current()).toEqual([{ type: "text", content: "", start: 0, end: 0 }])
@@ -243,7 +233,7 @@ describe("Composer submission", () => {
      submitted() {},
      async start(_selection, submission) {
        submission.retarget(promoted)
-        return { session: target, cleanupReady: Promise.resolve() }
+        return target
      },
    }

@@ -260,12 +250,10 @@ describe("Composer submission", () => {
  test("reuses the message ID when an unacknowledged admission is retried", async () => {
    const state = createMemoryComposerState({ prompt: "retry me" }).capture()
    const attempts: string[] = []
-    const statuses: ("idle" | "running")[] = []
    const first = Promise.withResolvers<void>()
    const second = Promise.withResolvers<void>()
    const target = session({
      calls: [],
-      statuses,
      prompt: async (value) => {
        attempts.push(value.id ?? "")
        throw new Error("network unavailable")
@@ -295,7 +283,6 @@ describe("Composer submission", () => {

    expect(attempts).toHaveLength(4)
    expect(new Set(attempts).size).toBe(1)
-    expect(statuses).toEqual(["running", "idle", "running", "idle"])
    expect(state.current()).toMatchObject([{ type: "text", content: "retry me" }])
  })

@@ -65,42 +65,15 @@ export function createComposerSubmit(input: ComposerSubmitInput) {
    const comments = input.comments.capture()

    try {
-      const started =
+      const session =
        input.adapter.kind === "active-session"
-          ? { session: input.adapter.session(), cleanupReady: Promise.resolve() }
+          ? input.adapter.session()
          : await input.adapter.start(value.selection, submission)
-      if (!started) return
-      const session = started.session
+      if (!session) return

      input.addToHistory(value.prompt, value.mode)
      input.resetHistory()
      const restore = () => restoreSubmission(input, submission, value, comments)
-
-      const command = value.mode === "normal" ? findCommand(session, value.text) : undefined
-      if (value.mode === "normal" && !command) {
-        const optimisticBusy = !input.adapter.working()
-        if (optimisticBusy) session.data.session.setStatus(session.id, "running")
-        const sending = sendPrompt(session, value).then(
-          () => ({ ok: true as const }),
-          (error) => ({ ok: false as const, error }),
-        )
-        await started.cleanupReady
-        input.adapter.submitted()
-        submission.context
-          .filter((item) => !!item.comment?.trim())
-          .forEach((item) => submission.target().context.remove(item.key))
-        input.comments.clear()
-        clearSubmission(input, submission)
-        void sending.then((result) => {
-          if (!result.ok)
-            failSubmission(input, session, "prompt", result.error, restore, value.id, () => {
-              if (optimisticBusy) session.data.session.setStatus(session.id, "idle")
-            })
-        })
-        return
-      }
-
-      await started.cleanupReady
      input.adapter.submitted()

      if (value.mode === "shell") {
@@ -109,6 +82,7 @@ export function createComposerSubmit(input: ComposerSubmitInput) {
        return
      }

+      const command = findCommand(session, value.text)
      if (command) {
        clearSubmission(input, submission)
        void sendCommand(session, value, command).catch((error) =>
@@ -117,6 +91,14 @@ export function createComposerSubmit(input: ComposerSubmitInput) {
        return
      }

+      submission.context
+        .filter((item) => !!item.comment?.trim())
+        .forEach((item) => submission.target().context.remove(item.key))
+      input.comments.clear()
+      clearSubmission(input, submission)
+      void sendPrompt(session, value).catch((error) =>
+        failSubmission(input, session, "prompt", error, restore, value.id),
+      )
    } finally {
      submitting.delete(input.adapter.state)
    }
@@ -331,10 +313,8 @@ function failSubmission(
  error: unknown,
  restore: () => boolean,
  messageID?: string,
-  rollback?: () => void,
 ) {
  if (messageID && session.admitted(messageID)) return
-  rollback?.()
  restore()
  input.notify.failed(kind, error)
 }
@@ -42,10 +42,6 @@ const clearAuthToken = () => {

 const web = createWebPlatform(pkg.version)

-if (import.meta.env.PROD && "serviceWorker" in navigator) {
-  window.addEventListener("load", () => void navigator.serviceWorker.register("/sw.js"), { once: true })
-}
-
 if (import.meta.env.VITE_SENTRY_DSN) {
  init({
    dsn: import.meta.env.VITE_SENTRY_DSN,
@@ -3,7 +3,7 @@ import { type HomeProjectSelection, useLayout } from "@/shell/state/layout"
 import { ServerConnection } from "@/runtime/server/registry"
 import { useTabs } from "@/shell/tabs/tabs"
 import { toggleHomeProjectSelection } from "@/shell/layout/helpers"
-import { createEffect, createMemo, startTransition } from "solid-js"
+import { createEffect, createMemo } from "solid-js"

 export function createHomeController() {
  const layout = useLayout()
@@ -50,8 +50,7 @@ export function createHomeController() {
    selection: {
      value: selection,
      set: setSelection,
-      focusServer: (conn: ServerConnection.Any) =>
-        void startTransition(() => setSelection({ server: ServerConnection.key(conn) })),
+      focusServer: (conn: ServerConnection.Any) => setSelection({ server: ServerConnection.key(conn) }),
    },
    server: {
      list: global.servers.list,
@@ -509,7 +509,7 @@ function HomeSessionsEmpty(props: { onNewSession?: () => void; language: ReturnT
    <div class="flex min-h-full flex-col items-center gap-4 px-6 pt-[52px] text-center">
      <div
        class={`
-          shrink-0 text-[13px] leading-text-compact tracking-[-0.04px]
+          shrink-0 text-[13px] leading-[13px] tracking-[-0.04px]
          text-v2-text-text-base [font-weight:530]
        `}
      >
@@ -53,32 +53,26 @@ export function createNewSessionComposerAdapter(props: {
      })
      if (!sessionDirectory) return

-      const created = data.session.create({
-        agent: selection.agent,
-        model: {
-          id: selection.model.modelID,
-          providerID: selection.model.providerID,
-          variant: selection.variant,
-        },
-        location: { directory: sessionDirectory },
-      })
-      const creation = created.request.then(
-        () => ({ ok: true as const }),
-        (error) => {
+      const created = await serverSDK.api.session
+        .create({
+          agent: selection.agent,
+          model: {
+            id: selection.model.modelID,
+            providerID: selection.model.providerID,
+            variant: selection.variant,
+          },
+          location: { directory: sessionDirectory },
+        })
+        .catch((error) => {
          showToast({
            title: language.t("prompt.toast.sessionCreateFailed.title"),
            description: errorMessage(language, error),
          })
-          return { ok: false as const, error }
-        },
-      )
-      const afterCreation = async <T,>(run: () => Promise<T>) => {
-        const result = await creation
-        if (!result.ok) throw result.error
-        return run()
-      }
+        })
+      if (!created) return

-      const cleanupReady = startTransition(() => {
+      data.session.remember(created)
+      await startTransition(() => {
        tabs.updateDraft(props.draftID, { worktree: undefined })
        if (permission.isAutoAcceptingDirectory(projectDirectory)) {
          permission.enableAutoAccept(created.id, sessionDirectory)
@@ -98,31 +92,13 @@ export function createNewSessionComposerAdapter(props: {
      })

      return {
-        cleanupReady,
-        session: {
-          id: created.id,
-          directory: sessionDirectory,
-          api: {
-            command: (input) => afterCreation(() => serverSDK.api.session.command(input)),
-            shell: (input) => afterCreation(() => serverSDK.api.session.shell(input)),
-            switchAgent: (input) => afterCreation(() => serverSDK.api.session.switchAgent(input)),
-            switchModel: (input) => afterCreation(() => serverSDK.api.session.switchModel(input)),
-          },
-          data: {
-            location: data.location,
-            session: {
-              setStatus: data.session.setStatus,
-              prompt: (input) =>
-                data.session.prompt({
-                  ...input,
-                  gate: Promise.all([input.gate, afterCreation(async () => undefined)]),
-                }),
-            },
-          },
-          current: () => data.session.get(created.id),
-          admitted: (messageID) =>
-            data.session.input.has(created.id, messageID) || !!data.session.message.get(created.id, messageID),
-        },
+        id: created.id,
+        directory: sessionDirectory,
+        api: serverSDK.api.session,
+        data,
+        current: () => data.session.get(created.id) ?? created,
+        admitted: (messageID) =>
+          data.session.input.has(created.id, messageID) || !!data.session.message.get(created.id, messageID),
      }
    },
  }
@@ -139,7 +139,7 @@ function ProviderTip() {
        >
          <button
            type="button"
-            class="flex h-6 min-w-0 items-center rounded-[4px] pl-1.5 text-[13px] leading-text-compact tracking-[-0.04px] text-v2-text-text-faint transition-[background-color,color] duration-150 ease-in-out hover:bg-v2-overlay-simple-overlay-hover hover:text-v2-text-text-muted focus-visible:bg-v2-overlay-simple-overlay-hover focus-visible:text-v2-text-text-muted focus-visible:outline-none"
+            class="flex h-6 min-w-0 items-center rounded-[4px] pl-1.5 text-[13px] leading-none tracking-[-0.04px] text-v2-text-text-faint transition-[background-color,color] duration-150 ease-in-out hover:bg-v2-overlay-simple-overlay-hover hover:text-v2-text-text-muted focus-visible:bg-v2-overlay-simple-overlay-hover focus-visible:text-v2-text-text-muted focus-visible:outline-none"
            onClick={openProviders}
          >
            <span class="truncate">{language.t("home.providerTip")}</span>
@@ -190,7 +190,7 @@ function ProviderPicker(props: { directory?: string; onSelect: (provider: string
            {(group) => (
              <Show when={group.items().length > 0}>
                <section class="flex flex-col">
-                  <div class="px-3 pb-2 text-[13px] font-[440] leading-text-compact tracking-[-0.04px] text-v2-text-text-muted">
+                  <div class="px-3 pb-2 text-[13px] font-[440] leading-none tracking-[-0.04px] text-v2-text-text-muted">
                    {group.title}
                  </div>
                  <For each={group.items()}>
@@ -198,7 +198,7 @@ function ProviderPicker(props: { directory?: string; onSelect: (provider: string
                      <button
                        type="button"
                        data-provider-id={provider.id}
-                        class="flex min-h-9 w-full items-center gap-2 rounded-md px-3 py-2.5 text-left text-[13px] leading-text-compact tracking-[-0.04px] hover:bg-v2-overlay-simple-overlay-hover focus:bg-v2-overlay-simple-overlay-hover focus:outline-none"
+                        class="flex min-h-9 w-full items-center gap-2 rounded-md px-3 py-2.5 text-left text-[13px] leading-none tracking-[-0.04px] hover:bg-v2-overlay-simple-overlay-hover focus:bg-v2-overlay-simple-overlay-hover focus:outline-none"
                        classList={{ "bg-v2-overlay-simple-overlay-hover": store.active === provider.id }}
                        onMouseEnter={() => setStore("active", provider.id)}
                        disabled={store.connecting !== undefined}
@@ -1,24 +1,44 @@
-import { type Accessor, createMemo } from "solid-js"
+import { type Accessor, createMemo, createResource } from "solid-js"
+import { createStore } from "solid-js/store"
 import { DateTime } from "luxon"
 import { filter, firstBy, flat, groupBy, mapValues, pipe, uniqueBy, values } from "remeda"
 import { createSimpleContext } from "@opencode-ai/ui/context"
 import { useProviders } from "@/providers/catalog/providers"
-import { useGlobal } from "@/runtime/server/runtime"
+import { Persist, persisted } from "@/runtime/persistence/storage"

 export type ModelKey = { providerID: string; modelID: string }

 type Visibility = "show" | "hide"
+type User = ModelKey & { visibility: Visibility; favorite?: boolean }
+type Store = {
+  user: User[]
+  recent: ModelKey[]
+  variant?: Record<string, string | undefined>
+}
+
 const RECENT_LIMIT = 5

 function modelKey(model: ModelKey) {
  return `${model.providerID}:${model.modelID}`
 }

+const createModelsPersistedState = () => {
+  const [store, setStore, _, ready] = persisted(
+    Persist.global("model"),
+    createStore<Store>({
+      user: [],
+      recent: [],
+      variant: {},
+    }),
+  )
+
+  return [store, setStore, ready] as const
+}
+
 const createModelsController = (directory: Accessor<string | undefined>) => {
  const providers = useProviders(() => directory())
-  const models = useGlobal().models
-  const store = models.store
-  const setStore = models.set
+
+  const [store, setStore, ready] = createModelsPersistedState()

  const available = createMemo(() =>
    providers.connected().flatMap((p) =>
@@ -128,14 +148,23 @@ const createModelsController = (directory: Accessor<string | undefined>) => {
    setStore("variant", key, value)
  }

+  const [recentModels] = createResource(
+    async () => {
+      const recent = store.recent
+      await ready.promise
+      return recent
+    },
+    (p) => p,
+    { initialValue: [] },
+  )
  return {
-    ready: models.ready,
+    ready,
    list,
    find,
    visible,
    setVisibility,
    recent: {
-      list: models.recent,
+      list: () => recentModels()!,
      push,
    },
    variant: {
@@ -922,10 +922,6 @@ export const dict = {
  "settings.general.row.shell.description": "Shell used by the terminal and agent tools",
  "settings.general.row.shell.autoDefault": "Auto (Default)",
  "settings.general.row.shell.terminalOnly": "terminal only",
-  "settings.general.row.terminalPlacement.title": "Terminal placement",
-  "settings.general.row.terminalPlacement.description": "Choose where the terminal opens in sessions",
-  "settings.general.row.terminalPlacement.side": "Side",
-  "settings.general.row.terminalPlacement.bottom": "Bottom",
  "settings.general.row.appearance.title": "Appearance",
  "settings.general.row.appearance.description": "Customise how OpenCode looks on your device",
  "settings.general.row.colorScheme.title": "Color scheme",
@@ -948,8 +944,6 @@ export const dict = {
  "settings.general.row.showTerminal.description": "Show the terminal button in the desktop title bar",
  "settings.general.row.showStatus.title": "Server status",
  "settings.general.row.showStatus.description": "Show the server status button in the title bar",
-  "settings.general.row.showProjectIcon.title": "Project icon",
-  "settings.general.row.showProjectIcon.description": "Show the project icon in the session header",
  "settings.general.row.mobileTitlebarBottom.title": "Bottom navigation",
  "settings.general.row.mobileTitlebarBottom.description":
    "Place the title bar and session tabs at the bottom of the screen on mobile",
@@ -1,5 +1,5 @@
 import { createSimpleContext } from "@opencode-ai/ui/context"
-import { Accessor, createEffect, createMemo, createResource, createRoot, getOwner } from "solid-js"
+import { Accessor, createEffect, createMemo, createRoot, getOwner } from "solid-js"
 import { createStore } from "solid-js/store"
 import { createServerProjects, RECENTLY_CLOSED_DISPLAY_LIMIT, ServerConnection, useServers } from "./registry"
 import { pathKey } from "@/workspaces/path-key"
@@ -10,7 +10,6 @@ import { createData } from "@opencode-ai/client/solid"
 import type { ServerScope } from "@/runtime/server/scope"
 import { createServerPermissionState } from "@/session/requests/server-permission"
 import { createServerNotificationState } from "@/shell/notifications/notification"
-import { Persist, persisted } from "@/runtime/persistence/storage"

 export const { use: useGlobal, provider: GlobalProvider } = createSimpleContext({
  name: "Global",
@@ -25,7 +24,6 @@ export const { use: useGlobal, provider: GlobalProvider } = createSimpleContext(
        serverKey: undefined as ServerConnection.Key | undefined,
      },
    })
-    const models = createGlobalModels()

    const settingsServer = createMemo(() => {
      const list = server.list
@@ -88,7 +86,6 @@ export const { use: useGlobal, provider: GlobalProvider } = createSimpleContext(
          },
        },
      },
-      models,
      ensureServerCtx(conn: ServerConnection.Any) {
        return ensureServerCtx(conn)
      },
@@ -96,37 +93,6 @@ export const { use: useGlobal, provider: GlobalProvider } = createSimpleContext(
  },
 })

-function createGlobalModels() {
-  const [store, setStore, _, ready] = persisted(
-    Persist.global("model"),
-    createStore<{
-      user: Array<{ providerID: string; modelID: string; visibility: "show" | "hide"; favorite?: boolean }>
-      recent: Array<{ providerID: string; modelID: string }>
-      variant?: Record<string, string | undefined>
-    }>({
-      user: [],
-      recent: [],
-      variant: {},
-    }),
-  )
-  const [recent] = createResource(
-    async () => {
-      const value = store.recent
-      await ready.promise
-      return value
-    },
-    (value) => value,
-    { initialValue: [] },
-  )
-
-  return {
-    store,
-    set: setStore,
-    ready,
-    recent: () => recent()!,
-  }
-}
-
 function createServerController(
  conn: ServerConnection.Any,
  scope: ServerScope,
@@ -386,7 +386,7 @@
  padding: 48px 24px;
  font-size: 13px;
  font-weight: 440;
-  line-height: var(--line-height-compact);
+  line-height: 1;
  color: var(--v2-text-text-muted);
  text-align: center;
 }
@@ -16,7 +16,6 @@ export function createActiveComposerAdapter(input: {
  if (!id) throw new Error("Active Composer requires a Session ID")

  const prompt = useComposerState()
-  prompt.current()
  const state = prompt.capture()
  const data = useData()
  const server = useServerSDK()
@@ -133,7 +133,7 @@ export function createActiveSessionRegion(input: {
      const scroller = input.timeline.scroller()
      if (!scroller || !isScrollKeyTarget(target ?? null, key)) return
      if (scrollKeyOwner(scroller, target ?? null, key) !== scroller) return
-      input.timeline.view.markUserScroll(scroller)
+      input.timeline.view.markGesture(scroller)
      return
    }
    if (event.key.length !== 1 || event.key === "Unidentified" || event.ctrlKey || event.metaKey) return
@@ -204,7 +204,9 @@ export function ActiveSessionComposerRegion(props: {
 }) {
  const region = createSessionComposerRegionController({
    state: props.model.region.state,
+    sessionKey: props.session.identity.sessionKey,
    sessionID: () => props.session.identity.params.id,
+    prompt: props.model.region.prompt,
    centered: props.model.region.centered,
    onResponseSubmit: props.onResponseSubmit,
    openParent: props.model.region.openParent,
@@ -1,10 +1,14 @@
-import { type Accessor, createMemo } from "solid-js"
+import { type Accessor, createEffect, createMemo, createResource } from "solid-js"
+import type { useComposerState } from "@/composer/persistence"
 import { useData } from "@/runtime/server/current"
+import { getSessionHandoff, setSessionHandoff } from "@/session/handoff"
 import type { SessionRequestModel } from "../requests/model"

 export function createSessionComposerRegionController(input: {
  state: SessionRequestModel
+  sessionKey: Accessor<string>
  sessionID: Accessor<string | undefined>
+  prompt: ReturnType<typeof useComposerState>
  centered: Accessor<boolean>
  onResponseSubmit: () => void
  openParent: () => void
@@ -12,10 +16,32 @@ export function createSessionComposerRegionController(input: {
  setDockRef: (el: HTMLDivElement) => void
 }) {
  const data = useData()
+  createEffect(() => {
+    if (!input.prompt.ready()) return
+    setSessionHandoff(input.sessionKey(), {
+      prompt: input.prompt
+        .current()
+        .map((part) => {
+          if (part.type === "file") return `[file:${part.path}]`
+          if (part.type === "agent") return `@${part.name}`
+          if (part.type === "image") return `[image:${part.filename}]`
+          return part.content
+        })
+        .join("")
+        .trim(),
+    })
+  })
+
  const parentID = createMemo(() => {
    const id = input.sessionID()
    return id ? data.session.get(id)?.parentID : undefined
  })
+  const ready = Promise.resolve()
+  const [promptReady] = createResource(
+    () => input.prompt.ready.promise ?? ready,
+    (promise) => promise.then(() => true),
+  )
+
  return {
    state: input.state,
    centered: input.centered,
@@ -26,6 +52,8 @@ export function createSessionComposerRegionController(input: {
    parentID,
    child: () => !!parentID(),
    showComposer: () => !input.state.blocked() || !!parentID(),
+    handoffPrompt: () => getSessionHandoff(input.sessionKey())?.prompt,
+    promptReady: () => input.prompt.ready() || promptReady(),
  }
 }

@@ -19,6 +19,8 @@ export type SessionComposerRegionViewController = Pick<
  | "parentID"
  | "child"
  | "showComposer"
+  | "handoffPrompt"
+  | "promptReady"
 > & { state: SessionComposerRegionState }

 export function SessionComposerRegion(props: {
@@ -63,32 +65,43 @@ export function SessionComposerRegion(props: {
        </Show>

        <Show when={controller.showComposer()}>
-          <div
-            classList={{
-              "relative z-[70]": true,
-            }}
+          <Show
+            when={controller.promptReady()}
+            fallback={
+              <>
+                <div class="w-full min-h-32 md:min-h-40 rounded-md border border-border-weak-base bg-background-base/50 px-4 py-3 text-text-weak whitespace-pre-wrap pointer-events-none">
+                  {controller.handoffPrompt() || language.t("prompt.loading")}
+                </div>
+              </>
+            }
          >
-            <Show
-              when={controller.child()}
-              fallback={<Show when={!controller.state.blocked()}>{props.composer}</Show>}
+            <div
+              classList={{
+                "relative z-[70]": true,
+              }}
            >
-              <div
-                ref={controller.setPromptRef}
-                class="w-full rounded-[12px] border border-border-weak-base bg-background-base p-3 text-16-regular text-text-weak"
+              <Show
+                when={controller.child()}
+                fallback={<Show when={!controller.state.blocked()}>{props.composer}</Show>}
              >
-                <span>{language.t("session.child.promptDisabled")} </span>
-                <Show when={controller.parentID()}>
-                  <button
-                    type="button"
-                    class="text-text-base transition-colors hover:text-text-strong"
-                    onClick={controller.openParent}
-                  >
-                    {language.t("session.child.backToParent")}
-                  </button>
-                </Show>
-              </div>
-            </Show>
-          </div>
+                <div
+                  ref={controller.setPromptRef}
+                  class="w-full rounded-[12px] border border-border-weak-base bg-background-base p-3 text-16-regular text-text-weak"
+                >
+                  <span>{language.t("session.child.promptDisabled")} </span>
+                  <Show when={controller.parentID()}>
+                    <button
+                      type="button"
+                      class="text-text-base transition-colors hover:text-text-strong"
+                      onClick={controller.openParent}
+                    >
+                      {language.t("session.child.backToParent")}
+                    </button>
+                  </Show>
+                </div>
+              </Show>
+            </div>
+          </Show>
        </Show>
      </div>
    </div>
@@ -1,6 +1,7 @@
 import type { SelectedLineRange } from "@/workspaces/files/model"

 type HandoffSession = {
+  prompt: string
  files: Record<string, SelectedLineRange | null>
 }

@@ -22,7 +23,7 @@ const touch = <K, V>(map: Map<K, V>, key: K, value: V) => {
 }

 export const setSessionHandoff = (key: string, patch: Partial<HandoffSession>) => {
-  const prev = store.session.get(key) ?? { files: {} }
+  const prev = store.session.get(key) ?? { prompt: "", files: {} }
  touch(store.session, key, { ...prev, ...patch })
 }

@@ -15,8 +15,7 @@ import { SessionUIProvider } from "@/shell/routes/session-ui-provider"
 import { useTabs } from "@/shell/tabs/tabs"
 import { requireServerKey } from "@/shell/routes/session"
 import { useSessionModel } from "./model"
-import { SessionPanelFrame } from "./session-frame"
-import { SessionIdentityHeader } from "./session-identity-header"
+import { SessionPanelFrame, SessionRouteFrame } from "./session-frame"
 import { IncompatibleServerPanel } from "./incompatible-server-panel"
 import { SessionErrorFallback } from "./route-error"
 import { createSessionResolution } from "./session-resolution"
@@ -32,7 +31,7 @@ export function TargetSessionRouteContent() {
      <MarkSessionNotificationsViewed sessionID={() => params.id} />
      <ModelsProvider directory={directory}>
        <TargetSessionSettingsCommand />
-        <SessionRouteErrorBoundary sessionID={params.id} serverKey={requireServerKey(params.serverKey)}>
+        <SessionRouteErrorBoundary sessionID={params.id} serverKey={requireServerKey(params.serverKey)} padded>
          <ResolvedTargetSessionRoute />
        </SessionRouteErrorBoundary>
      </ModelsProvider>
@@ -46,14 +45,16 @@ function TargetSessionSettingsCommand() {
 }

 function SessionRouteErrorBoundary(
-  props: ParentProps<{ sessionID?: string; serverKey?: ServerConnection.Key }>,
+  props: ParentProps<{ sessionID?: string; serverKey?: ServerConnection.Key; padded?: boolean }>,
 ) {
  return (
    <ErrorBoundary
      fallback={(error) => (
-        <SessionStatePanel>
-          <SessionErrorFallback error={error} sessionID={props.sessionID} serverKey={props.serverKey} />
-        </SessionStatePanel>
+        <SessionRouteFrame padded={props.padded}>
+          <SessionPanelFrame raised={!!props.sessionID}>
+            <SessionErrorFallback error={error} sessionID={props.sessionID} serverKey={props.serverKey} />
+          </SessionPanelFrame>
+        </SessionRouteFrame>
      )}
    >
      {props.children}
@@ -77,14 +78,16 @@ function ResolvedTargetSessionRoute() {
    <Show
      when={!server.health?.incompatible}
      fallback={
-        <SessionStatePanel>
-          <IncompatibleServerPanel
-            onClose={() => tabs.removeSessionTab({ server: server.key, sessionId: params.id })}
-          />
-        </SessionStatePanel>
+        <SessionRouteFrame padded>
+          <SessionPanelFrame raised>
+            <IncompatibleServerPanel
+              onClose={() => tabs.removeSessionTab({ server: server.key, sessionId: params.id })}
+            />
+          </SessionPanelFrame>
+        </SessionRouteFrame>
      }
    >
-      <Show when={directory()} fallback={<PendingSessionState sessionID={params.id} />}>
+      <Show when={directory()}>
        {(value) => (
          <LocationProvider directory={value()}>
            <SessionUIProvider directory={value()} server={server.key}>
@@ -97,22 +100,6 @@ function ResolvedTargetSessionRoute() {
  )
 }

-function PendingSessionState(props: { sessionID: string }) {
-  return (
-    <SessionStatePanel>
-      <SessionIdentityHeader sessionID={props.sessionID} />
-    </SessionStatePanel>
-  )
-}
-
-function SessionStatePanel(props: ParentProps) {
-  return (
-    <div class="flex min-h-0 flex-1 p-2">
-      <SessionPanelFrame raised>{props.children}</SessionPanelFrame>
-    </div>
-  )
-}
-
 function TargetSessionPage() {
  const location = useWorkspaceLocation()
  const server = useServerSDK()
@@ -15,10 +15,6 @@ export function createSessionScreenLayout(session: SessionModel, serverScope: st
  const reviewPanelOpen = createMemo(() => reviewOpen() && !!session.identity.params.id)
  const terminalOpen = createMemo(() => session.layout.view().terminal.opened())
  const desktopTerminalOpen = createMemo(() => session.isDesktop() && terminalOpen())
-  const sideTerminalOpen = createMemo(() => desktopTerminalOpen() && settings.general.terminalPlacement() === "side")
-  const bottomTerminalOpen = createMemo(
-    () => desktopTerminalOpen() && settings.general.terminalPlacement() === "bottom",
-  )
  const fileTreeOpen = createMemo(
    () =>
      session.isDesktop() &&
@@ -27,7 +23,7 @@ export function createSessionScreenLayout(session: SessionModel, serverScope: st
        opened: layout.fileTree.opened(),
      }),
  )
-  const resizable = createMemo(() => reviewPanelOpen() || sideTerminalOpen())
+  const resizable = createMemo(() => reviewPanelOpen() || desktopTerminalOpen())
  const sidePanelOpen = createMemo(() => resizable() || fileTreeOpen())
  const [rowWidth, setRowWidth] = createSignal<number>()
  let row: HTMLDivElement | undefined
@@ -61,7 +57,7 @@ export function createSessionScreenLayout(session: SessionModel, serverScope: st
  const panelLayout = createMemo(() =>
    sessionPanelLayout({
      review: reviewPanelOpen(),
-      terminal: sideTerminalOpen(),
+      terminal: desktopTerminalOpen(),
      files: fileTreeOpen(),
    }),
  )
@@ -101,11 +97,11 @@ export function createSessionScreenLayout(session: SessionModel, serverScope: st
      panelOpen: reviewPanelOpen,
      snap: reviewSnap,
    },
-    side: { layout: panelLayout },
+    side: { layout: panelLayout, open: sidePanelOpen },
    size,
    terminal: {
-      bottomOpen: bottomTerminalOpen,
-      inlineOnlyOpen: createMemo(() => sideTerminalOpen() && !reviewPanelOpen()),
+      desktopOpen: desktopTerminalOpen,
+      inlineOnlyOpen: createMemo(() => desktopTerminalOpen() && !reviewPanelOpen()),
      open: terminalOpen,
    },
  }
@@ -8,7 +8,7 @@ import { useSettings } from "@/settings/model"
 import { MessageTimeline } from "@/session/timeline/message-timeline"
 import type { SessionModel } from "@/session/model"
 import { SESSION_PANEL_WIDTH_MIN } from "@/session/session-panel-width"
-import { SessionPanelFrame } from "@/session/session-frame"
+import { SessionPanelFrame, SessionRouteFrame } from "@/session/session-frame"
 import { TerminalPanel } from "@/session/terminal/panel"
 import { useUsageExceededDialogs } from "./usage-exceeded-dialogs"
 import { SessionErrorFallback } from "./route-error"
@@ -17,7 +17,6 @@ import { createSessionReview } from "./review/model"
 import { SessionDesktopReview, SessionMobileReview, SessionMobileTabs } from "./review/view"
 import { createSessionTimelineInteraction } from "./timeline/interaction"
 import { ActiveSessionComposerRegion, createActiveSessionRegion } from "./composer/region"
-import { SessionIdentityHeader } from "./session-identity-header"

 export function SessionScreen(props: { session: SessionModel }) {
  const session = props.session
@@ -59,31 +58,17 @@ export function SessionScreen(props: { session: SessionModel }) {

  const sessionPanelContent = () => (
    <>
+      {timeline.resource() ?? ""}
      <Show when={!isDesktop() && !!session.identity.params.id && !mobileTabsBottom()}>
        <SessionMobileTabs review={review} compact />
      </Show>
-      {/* Surface query errors without suspending session metadata while messages load. */}
-      <Show when={timeline.resource.error}>
-        {(error) => {
-          throw error()
-        }}
-      </Show>
      <div class="flex-1 min-h-0 overflow-hidden">
        <Switch>
          <Match when={session.identity.params.id && review.mobile.changes()}>
            <SessionMobileReview review={review} />
          </Match>
          <Match when={session.identity.params.id}>
-            <Show when={!messagesReady()}>
-              <SessionIdentityHeader
-                sessionID={session.identity.params.id ?? ""}
-                session={session.data.info()}
-              />
-            </Show>
-            <Show
-              when={messagesReady() ? session.identity.params.id : undefined}
-              keyed
-            >
+            <Show when={messagesReady() ? session.identity.params.id : undefined} keyed>
              {(_id) => (
                <MessageTimeline
                  session={session}
@@ -93,18 +78,20 @@ export function SessionScreen(props: { session: SessionModel }) {
                  onResumeScroll={timeline.actions.resume}
                  setScrollRef={timeline.view.setScrollRef}
                  onScheduleScrollState={timeline.view.scheduleScrollState}
-                  onPin={timeline.view.pin}
-                  onUnpin={timeline.view.unpin}
+                  onAutoScrollHandleScroll={timeline.autoScroll.handleScroll}
+                  onMarkScrollGesture={timeline.view.markGesture}
+                  hasScrollGesture={timeline.view.hasGesture()}
                  onUserScroll={timeline.view.markUserScroll}
                  onHistoryScroll={timeline.view.onHistoryScroll}
-                  onSelectionInteraction={timeline.view.selectionInteraction}
-                  pinned={timeline.view.pinned()}
+                  onAutoScrollInteraction={timeline.autoScroll.handleInteraction}
+                  shouldAnchorBottom={timeline.view.shouldAnchorBottom()}
                  centered={screen.centered()}
                  setContentRef={timeline.view.setContentRef}
                  diffs={review.details.diffs}
                  onReview={review.open}
                  workspaceMoveEligible={composer.workspaceMoveEligible()}
                  onSummaryOpenChange={review.details.setOpen}
+                  setHistoryAnchor={timeline.view.setHistoryAnchor}
                  anchor={timeline.view.anchor}
                  setRevealMessage={timeline.view.setRevealMessage}
                  setScrollToEnd={timeline.view.setScrollToEnd}
@@ -132,90 +119,53 @@ export function SessionScreen(props: { session: SessionModel }) {
  )

  return (
-    <>
+    <SessionRouteFrame>
      <SessionHeader />
-      <div class="flex-1 min-h-0 flex flex-col gap-2 p-2">
-        <div ref={screen.panel.ref} class="flex-1 min-h-0 flex flex-col md:flex-row gap-2">
-          <div
-            classList={{
-              "@container relative shrink-0 flex flex-col min-h-0 h-full flex-1 md:flex-none transition-[width]": true,
-              "duration-[240ms] ease-[cubic-bezier(0.22,1,0.36,1)] will-change-[width] motion-reduce:transition-none":
-                !screen.size.active() && !screen.review.snap() && !screen.terminal.inlineOnlyOpen(),
-            }}
-            style={{
-              width: screen.panel.width(),
-            }}
-          >
-            <Show when={screen.panel.key()} keyed>
-              {(_) => (
-                <SessionPanelFrame raised={!!session.identity.params.id}>
-                  <ErrorBoundary fallback={sessionErrorFallback}>{sessionPanelContent()}</ErrorBoundary>
-                </SessionPanelFrame>
-              )}
-            </Show>
+      <div ref={screen.panel.ref} class="flex-1 min-h-0 flex flex-col md:flex-row gap-2 p-2">
+        <div
+          classList={{
+            "@container relative shrink-0 flex flex-col min-h-0 h-full flex-1 md:flex-none transition-[width]": true,
+            "duration-[240ms] ease-[cubic-bezier(0.22,1,0.36,1)] will-change-[width] motion-reduce:transition-none":
+              !screen.size.active() && !screen.review.snap() && !screen.terminal.inlineOnlyOpen(),
+          }}
+          style={{
+            width: screen.panel.width(),
+          }}
+        >
+          <Show when={screen.panel.key()} keyed>
+            {(_) => (
+              <SessionPanelFrame raised={!!session.identity.params.id}>
+                <ErrorBoundary fallback={sessionErrorFallback}>{sessionPanelContent()}</ErrorBoundary>
+              </SessionPanelFrame>
+            )}
+          </Show>

-            <Show when={screen.panel.resizable()}>
-              <div onPointerDown={() => screen.size.start()}>
-                <ResizeHandle
-                  class="-end-1"
-                  direction="horizontal"
-                  size={screen.panel.resizedWidth()}
-                  min={SESSION_PANEL_WIDTH_MIN}
-                  max={screen.panel.max()}
-                  onResize={(width) => {
-                    screen.size.touch()
-                    layout.session.resize(width)
-                  }}
-                />
-              </div>
-            </Show>
-          </div>
-
-          <Show when={isDesktop() && screen.side.layout().visible}>
-            <div class="min-w-0 h-full flex flex-1 flex-col">
-              <Show when={screen.review.panelOpen() || screen.files.open()}>
-                <div class="min-h-0 flex-1">
-                  <SessionDesktopReview review={review} />
-                </div>
-              </Show>
-              <Show when={screen.side.layout().stacked}>
-                <div class="relative h-2 shrink-0" onPointerDown={() => screen.size.start()}>
-                  <ResizeHandle
-                    class="!relative !inset-auto !h-full !w-full !transform-none"
-                    direction="vertical"
-                    size={layout.terminal.height()}
-                    min={100}
-                    max={typeof window === "undefined" ? 600 : window.innerHeight * 0.6}
-                    collapseThreshold={50}
-                    onResize={(height) => {
-                      screen.size.touch()
-                      layout.terminal.resize(height)
-                    }}
-                    onCollapse={() => session.layout.view().terminal.close()}
-                  />
-                </div>
-              </Show>
-              <Show when={screen.terminal.open() && !screen.terminal.bottomOpen()}>
-                <div
-                  classList={{
-                    "min-h-0 shrink-0": screen.side.layout().stacked,
-                    "min-h-0 flex-1": !screen.side.layout().stacked,
-                  }}
-                >
-                  <TerminalPanel stacked={screen.side.layout().stacked} />
-                </div>
-              </Show>
+          <Show when={screen.panel.resizable()}>
+            <div onPointerDown={() => screen.size.start()}>
+              <ResizeHandle
+                class="-end-1"
+                direction="horizontal"
+                size={screen.panel.resizedWidth()}
+                min={SESSION_PANEL_WIDTH_MIN}
+                max={screen.panel.max()}
+                onResize={(width) => {
+                  screen.size.touch()
+                  layout.session.resize(width)
+                }}
+              />
            </div>
          </Show>
        </div>

-        <Show when={screen.terminal.open() && (!isDesktop() || screen.terminal.bottomOpen())}>
-          <div classList={{ "relative min-h-0 shrink-0": isDesktop() }}>
-            <Show when={isDesktop()}>
-              <div
-                class="absolute z-10 -top-1 left-0 right-0 h-2"
-                onPointerDown={() => screen.size.start()}
-              >
+        <Show when={isDesktop() ? screen.side.layout().visible : screen.terminal.open()}>
+          <div class="min-w-0 h-full flex flex-1 flex-col">
+            <Show when={isDesktop() && (screen.review.panelOpen() || screen.files.open())}>
+              <div class="min-h-0 flex-1">
+                <SessionDesktopReview review={review} />
+              </div>
+            </Show>
+            <Show when={screen.side.layout().stacked}>
+              <div class="relative h-2 shrink-0" onPointerDown={() => screen.size.start()}>
                <ResizeHandle
                  class="!relative !inset-auto !h-full !w-full !transform-none"
                  direction="vertical"
@@ -231,10 +181,19 @@ export function SessionScreen(props: { session: SessionModel }) {
                />
              </div>
            </Show>
-            <TerminalPanel stacked={isDesktop()} />
+            <Show when={screen.terminal.open()}>
+              <div
+                classList={{
+                  "min-h-0 shrink-0": screen.side.layout().stacked,
+                  "min-h-0 flex-1": !screen.side.layout().stacked,
+                }}
+              >
+                <TerminalPanel stacked={screen.side.layout().stacked} />
+              </div>
+            </Show>
          </div>
        </Show>
      </div>
-    </>
+    </SessionRouteFrame>
  )
 }
@@ -1,88 +0,0 @@
-import type { SessionInfo } from "@opencode-ai/client/promise"
-import { Icon } from "@opencode-ai/ui/icon"
-import { ProjectAvatar } from "@opencode-ai/ui/project-avatar"
-import { createMemo, Show, type ParentProps } from "solid-js"
-import { useServer } from "@/runtime/server/current"
-import { displayName, getProjectAvatarSource, projectForSession } from "@/shell/layout/helpers"
-import { getProjectAvatarVariant } from "@/shell/state/layout"
-import { tabKey, useTabs } from "@/shell/tabs/tabs"
-import { useSettings } from "@/settings/model"
-import { pathKey } from "@/workspaces/path-key"
-import { isWorkspaceDirectory } from "@/workspaces/paths"
-import { sessionTitle } from "./title"
-
-export function SessionTitleHeader(props: ParentProps) {
-  return (
-    <div
-      data-session-title
-      class="sticky top-0 z-30 w-full bg-[linear-gradient(to_bottom,var(--v2-background-bg-base)_48px,transparent)] pb-4 pe-3 ps-2.5"
-    >
-      {props.children}
-    </div>
-  )
-}
-
-export function SessionIdentityHeader(props: { sessionID: string; session?: SessionInfo }) {
-  const server = useServer()
-  const tabs = useTabs()
-  const settings = useSettings()
-  const info = createMemo(
-    () => tabs.info[tabKey({ type: "session", server: server.key, sessionId: props.sessionID })],
-  )
-  const directory = createMemo(() => props.session?.location.directory ?? info()?.directory)
-  const title = createMemo(() => sessionTitle(props.session?.title ?? info()?.title))
-  const project = createMemo(() => {
-    const projects = server.ctx.projects.list()
-    if (props.session) return projectForSession(props.session, projects)
-    const value = directory()
-    if (!value) return undefined
-    const key = pathKey(value)
-    return projects.find(
-      (item) => pathKey(item.worktree) === key || item.sandboxes?.some((sandbox) => pathKey(sandbox) === key),
-    )
-  })
-  const showProjectIcon = () =>
-    import.meta.env.VITE_OPENCODE_CHANNEL !== "prod" && settings.general.showProjectIcon() && !!directory()
-  const workspaceSession = createMemo(() => isWorkspaceDirectory(project(), directory() ?? ""))
-
-  return (
-    <Show when={title() || showProjectIcon()}>
-      <SessionTitleHeader>
-        <div class="flex h-12 w-full items-center justify-between gap-2">
-          <div class="flex min-w-0 flex-1 items-center gap-1">
-            <div class="flex min-w-0 w-full flex-1 items-center">
-              <span
-                classList={{
-                  "flex size-6 shrink-0 items-center justify-center": true,
-                  "text-v2-icon-icon-accent": workspaceSession() && !showProjectIcon(),
-                  "text-v2-icon-icon-muted": !workspaceSession() && !showProjectIcon(),
-                }}
-              >
-                <Show
-                  when={showProjectIcon()}
-                  fallback={<Icon name={workspaceSession() ? "workspace-isolated" : "monitor"} />}
-                >
-                  <ProjectAvatar
-                    fallback={displayName(project() ?? { worktree: directory() ?? "" })}
-                    src={getProjectAvatarSource(project()?.id, project()?.icon)}
-                    variant={getProjectAvatarVariant(project()?.icon?.color)}
-                  />
-                </Show>
-              </span>
-              <Show when={title()}>
-                {(value) => (
-                  <h1
-                    dir="auto"
-                    class="w-fit truncate rounded-[6px] px-2 py-1 text-[13px] font-[530] leading-4 tracking-[-0.04px] text-v2-text-text-base"
-                  >
-                    {value()}
-                  </h1>
-                )}
-              </Show>
-            </div>
-          </div>
-        </div>
-      </SessionTitleHeader>
-    </Show>
-  )
-}
@@ -208,6 +208,8 @@ function SessionSurfaceState(props: SessionPreviewProps & { onReset: () => void
    parentID: () => props.child?.parentID,
    child: () => !!props.child,
    showComposer: () => true,
+    handoffPrompt: () => undefined,
+    promptReady: () => true,
  } satisfies SessionComposerRegionViewController

  return (
@@ -1,17 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { terminalKeyInput } from "./terminal-key-event"
-
-describe("terminalKeyInput", () => {
-  test("maps Command+Delete to the terminal line-clear control code", () => {
-    const event = new KeyboardEvent("keydown", { key: "Backspace", metaKey: true })
-
-    expect(terminalKeyInput(event)).toBe("\x15")
-  })
-
-  test("leaves other Backspace shortcuts to the terminal", () => {
-    expect(terminalKeyInput(new KeyboardEvent("keydown", { key: "Backspace" }))).toBeUndefined()
-    expect(
-      terminalKeyInput(new KeyboardEvent("keydown", { key: "Backspace", metaKey: true, shiftKey: true })),
-    ).toBeUndefined()
-  })
-})
@@ -1,5 +0,0 @@
-export function terminalKeyInput(event: KeyboardEvent) {
-  if (!event.metaKey || event.ctrlKey || event.altKey || event.shiftKey) return
-  if (event.key.toLowerCase() !== "backspace") return
-  return "\x15"
-}
@@ -15,7 +15,6 @@ import { useServerSDK } from "@/runtime/server/client"
 import { terminalFontFamily, useSettings } from "@/settings/model"
 import type { LocalPTY } from "@/session/terminal/context"
 import { disposeIfDisposable, getHoveredLinkText, setOptionIfSupported } from "@/session/terminal/runtime-adapters"
-import { terminalKeyInput } from "@/session/terminal/terminal-key-event"
 import { terminalWriter } from "@/session/terminal/writer"

 const TOGGLE_TERMINAL_ID = "terminal.toggle"
@@ -409,12 +408,6 @@ export const Terminal = (props: TerminalProps) => {
      t.attachCustomKeyEventHandler((event) => {
        const key = event.key.toLowerCase()

-        const input = terminalKeyInput(event)
-        if (input) {
-          t.input(input, true)
-          return true
-        }
-
        if (event.ctrlKey && event.shiftKey && !event.metaKey && key === "c") {
          document.execCommand("copy")
          return true
@@ -1,4 +1,5 @@
 import type { SessionMessageUser } from "@opencode-ai/client/promise"
+import { createAutoScroll } from "@opencode-ai/ui/hooks"
 import { createResizeObserver } from "@solid-primitives/resize-observer"
 import { useLocation } from "@solidjs/router"
 import { createEffect, on, onCleanup } from "solid-js"
@@ -15,31 +16,23 @@ export function createSessionTimelineInteraction(session: SessionModel) {
  const [state, setState] = createStore({
    messageID: undefined as string | undefined,
    pendingMessage: undefined as string | undefined,
+    gestureAt: 0,
    scroll: {
      overflow: false,
      jump: false,
    },
-    follow: {
-      sessionKey: session.identity.sessionKey(),
-      pinned: true,
-    },
    refs: {
      content: undefined as HTMLDivElement | undefined,
      dock: undefined as HTMLDivElement | undefined,
    },
  })
-  // The single source of truth for "follow the newest content". The virtualizer pins and unpins
-  // it from scroll geometry; everything else only expresses explicit intent.
-  const pinned = () => state.follow.sessionKey !== session.identity.sessionKey() || state.follow.pinned
-  const pin = () => setState("follow", { sessionKey: session.identity.sessionKey(), pinned: true })
-  const unpin = () => {
-    if (!scroller || scroller.scrollHeight - scroller.clientHeight <= 1) return
-    setState("follow", { sessionKey: session.identity.sessionKey(), pinned: false })
-  }
+  const autoScroll = createAutoScroll({ working: () => true, overflowAnchor: "none" })
  let scroller: HTMLDivElement | undefined
  let dockHeight = 0
  let revealMessage = (_id: string) => {}
  let scrollToEnd = () => {}
+  let captureHistoryAnchor = () => {}
+  let restoreHistoryAnchor = (_done: boolean) => {}
  let scrollMark = 0
  let messageMark = 0
  let scrollStateFrame: number | undefined
@@ -109,10 +102,10 @@ export function createSessionTimelineInteraction(session: SessionModel) {
    pendingMessage: () => state.pendingMessage,
    setPendingMessage: (value) => setState("pendingMessage", value),
    setActiveMessage,
-    follow: {
-      unpin,
-      toBottom: () => {
-        pin()
+    autoScroll: {
+      pause: autoScroll.pause,
+      forceScrollToBottom: () => {
+        autoScroll.resume()
        scrollToEnd()
      },
    },
@@ -124,7 +117,7 @@ export function createSessionTimelineInteraction(session: SessionModel) {
  })
  const resume = () => {
    setState("messageID", undefined)
-    pin()
+    autoScroll.resume()
    scrollToEnd()
    clearMessageHash()
    if (scroller) scheduleScrollState(scroller)
@@ -140,23 +133,21 @@ export function createSessionTimelineInteraction(session: SessionModel) {
      resume()
      return
    }
-    unpin()
+    autoScroll.pause()
    scrollToMessage(messages[target], "auto")
  }
-  // A gesture inside a nested scrollable region scrolls that region, not the timeline.
-  const markUserScroll = (target?: EventTarget | null) => {
+  const shouldAnchorBottom = () =>
+    !location.hash && !state.messageID && !state.pendingMessage && !autoScroll.userScrolled()
+  const markGesture = (target?: EventTarget | null) => {
    if (!scroller) return
    const element = target instanceof Element ? target : undefined
    const nested = element?.closest("[data-scrollable]")
    if (nested && nested !== scroller) return
-    scrollMark += 1
-  }
-  const selectionInteraction = () => {
-    const selection = window.getSelection()
-    if (selection && selection.toString().length > 0) unpin()
+    setState("gestureAt", Date.now())
  }
  const setScrollRef = (element: HTMLDivElement | undefined) => {
    scroller = element
+    autoScroll.scrollRef(element)
    if (!element) return
    scheduleScrollState(element)
    fill()
@@ -167,12 +158,15 @@ export function createSessionTimelineInteraction(session: SessionModel) {
    historyRequests.add(owner.key)
    const before = timeline.messages().length
    try {
-      await timeline.history.loadOlder()
+      await timeline.history.loadOlder({
+        before: () => owner.run(captureHistoryAnchor),
+        after: (done) => owner.run(() => restoreHistoryAnchor(done)),
+      })
    } finally {
      historyRequests.delete(owner.key)
    }
    if (!owner.current() || timeline.messages().length <= before) return
-    if (pinned() || !scroller || scroller.scrollTop >= 200 || !timeline.history.more()) return
+    if (!autoScroll.userScrolled() || !scroller || scroller.scrollTop >= 200 || !timeline.history.more()) return
    if (historyContinuationFrame !== undefined) cancelAnimationFrame(historyContinuationFrame)
    historyContinuationFrame = requestAnimationFrame(() => {
      historyContinuationFrame = undefined
@@ -183,7 +177,7 @@ export function createSessionTimelineInteraction(session: SessionModel) {
    if (
      historyRequests.has(session.ownership.key()) ||
      timeline.history.loading() ||
-      pinned() ||
+      !autoScroll.userScrolled() ||
      !scroller ||
      scroller.scrollTop >= 200
    )
@@ -195,7 +189,7 @@ export function createSessionTimelineInteraction(session: SessionModel) {
    fillFrame = requestAnimationFrame(() => {
      fillFrame = undefined
      if (!session.identity.params.id || !timeline.ready()) return
-      if (!pinned() || timeline.history.loading() || !scroller) return
+      if (autoScroll.userScrolled() || timeline.history.loading() || !scroller) return
      if (scroller.scrollHeight > scroller.clientHeight + 1 || !timeline.history.more()) return
      void loadOlder()
    })
@@ -213,10 +207,8 @@ export function createSessionTimelineInteraction(session: SessionModel) {
    on(
      session.identity.sessionKey,
      () => {
-        pin()
        setState("messageID", undefined)
        setState("pendingMessage", undefined)
-        setState("scroll", { overflow: false, jump: false })
      },
      { defer: true },
    ),
@@ -226,16 +218,15 @@ export function createSessionTimelineInteraction(session: SessionModel) {
      () => session.identity.params.id,
      (id, previous) => {
        if (!id || !previous || id === previous || state.messageID || state.pendingMessage || location.hash) return
-        pin()
-        scrollToEnd()
+        autoScroll.resume()
      },
    ),
  )
  createEffect(
    on(
-      pinned,
-      (value) => {
-        if (!value) return
+      autoScroll.userScrolled,
+      (scrolled) => {
+        if (scrolled) return
        setState("messageID", undefined)
        clearMessageHash()
      },
@@ -250,11 +241,11 @@ export function createSessionTimelineInteraction(session: SessionModel) {
          timeline.ready(),
          timeline.history.more(),
          timeline.history.loading(),
-          pinned(),
+          autoScroll.userScrolled(),
          visibleUserMessages().length,
        ] as const,
-      ([id, ready, more, loading, following]) => {
-        if (id && ready && more && !loading && following) fill()
+      ([id, ready, more, loading, scrolled]) => {
+        if (id && ready && more && !loading && !scrolled) fill()
      },
      { defer: true },
    ),
@@ -273,7 +264,8 @@ export function createSessionTimelineInteraction(session: SessionModel) {
      if (next === dockHeight) return
      const delta = next - dockHeight
      const stick = scroller
-        ? pinned() || scroller.scrollHeight - scroller.clientHeight - scroller.scrollTop < 10 + Math.max(0, delta)
+        ? !autoScroll.userScrolled() ||
+          scroller.scrollHeight - scroller.clientHeight - scroller.scrollTop < 10 + Math.max(0, delta)
        : false
      dockHeight = next
      if (stick) scrollToEnd()
@@ -293,6 +285,7 @@ export function createSessionTimelineInteraction(session: SessionModel) {
      resume,
      setActiveMessage,
    },
+    autoScroll,
    lastUserMessage: timeline.lastUserMessage,
    resource: timeline.resource,
    ready: timeline.ready,
@@ -300,19 +293,25 @@ export function createSessionTimelineInteraction(session: SessionModel) {
    scroller: () => scroller,
    view: {
      anchor,
-      markUserScroll,
+      hasGesture: () => Date.now() - state.gestureAt < 250,
+      markGesture,
+      markUserScroll: () => {
+        scrollMark += 1
+      },
      onHistoryScroll,
-      pin,
-      pinned,
-      selectionInteraction,
      scheduleScrollState,
      setContentRef: (element: HTMLDivElement | undefined) => {
        setState("refs", "content", element)
+        autoScroll.contentRef(element)
        if (scroller) scheduleScrollState(scroller)
      },
      setDockRef: (element: HTMLDivElement | undefined) => {
        setState("refs", "dock", element)
      },
+      setHistoryAnchor: (handlers: { capture: () => void; restore: (done: boolean) => void }) => {
+        captureHistoryAnchor = handlers.capture
+        restoreHistoryAnchor = handlers.restore
+      },
      setRevealMessage: (reveal: (id: string) => void) => {
        revealMessage = reveal
      },
@@ -320,7 +319,7 @@ export function createSessionTimelineInteraction(session: SessionModel) {
      setScrollToEnd: (scroll: () => void) => {
        scrollToEnd = scroll
      },
-      unpin,
+      shouldAnchorBottom,
    },
  }
 }
@@ -0,0 +1,30 @@
+import { expect, test } from "bun:test"
+import { scheduleConnectedMeasure } from "./measure"
+
+test("does not measure an element detached before the frame", async () => {
+  const element = document.createElement("div")
+  document.body.append(element)
+  let calls = 0
+
+  scheduleConnectedMeasure(element, () => {
+    calls += 1
+  })
+  element.remove()
+  await new Promise<void>((resolve) => requestAnimationFrame(() => resolve()))
+
+  expect(calls).toBe(0)
+})
+
+test("measures a connected element on the next frame", async () => {
+  const element = document.createElement("div")
+  document.body.append(element)
+  let calls = 0
+
+  scheduleConnectedMeasure(element, () => {
+    calls += 1
+  })
+  await new Promise<void>((resolve) => requestAnimationFrame(() => resolve()))
+
+  expect(calls).toBe(1)
+  element.remove()
+})
@@ -0,0 +1,5 @@
+export function scheduleConnectedMeasure<T extends HTMLElement>(element: T, measure: (element: T) => void) {
+  return requestAnimationFrame(() => {
+    if (element.isConnected) measure(element)
+  })
+}
@@ -1,4 +1,4 @@
-import { createEffect, createMemo, createSignal, For, on, Show, type Accessor, type JSX } from "solid-js"
+import { createEffect, createMemo, createSignal, For, on, Show, type Accessor } from "solid-js"
 import createPresence from "solid-presence"
 import { createStore } from "solid-js/store"
 import type { SessionUserActions } from "@opencode-ai/session-ui/actions"
@@ -17,7 +17,7 @@ import { getFilename } from "@opencode-ai/util/path"
 import { Popover } from "@kobalte/core/popover"
 import { SessionContextUsage } from "@/session/timeline/session-context-usage"
 import { useLanguage } from "@/runtime/i18n/language"
-import { useData, useServer } from "@/runtime/server/current"
+import { useData } from "@/runtime/server/current"
 import { useWorkspaceLocation } from "@/workspaces/location"
 import { Timeline, TimelineRow } from "@opencode-ai/session-ui/timeline/projection"
 import { createSessionTimelineRowRenderer } from "@opencode-ai/session-ui/timeline/row"
@@ -26,11 +26,9 @@ import { createTimelineVirtualizer } from "./virtualizer"
 import { containsDirectory, isWorkspaceDirectory, workspaceDirectories } from "@/workspaces/paths"
 import { SessionWorkspaceMenu } from "@/session/timeline/session-workspace-menu"
 import { getProjectAvatarVariant } from "@/shell/state/layout"
-import { displayName, getProjectAvatarSource, projectForSession } from "@/shell/layout/helpers"
+import { displayName, getProjectAvatarSource } from "@/shell/layout/helpers"
 import { parseCommentNote, readPromptPresentation } from "@/composer/comment-note"
 import { useCommand } from "@/shell/commands/command"
-import { useSettings } from "@/settings/model"
-import { SessionTitleHeader } from "../session-identity-header"

 type BackgroundTask = {
  id: string
@@ -56,7 +54,7 @@ export function BackgroundMoveHint(props: { keybind?: string[] }) {
  return (
    <div
      data-component="session-background-hint"
-      class="flex h-6 max-w-full items-center justify-center gap-[3px] overflow-hidden text-[13px] font-[440] leading-5 tracking-[-0.04px] text-v2-text-text-muted"
+      class="flex h-6 max-w-full items-center justify-center gap-[3px] overflow-hidden text-[13px] font-[530] leading-5 tracking-[-0.04px] text-v2-text-text-muted"
      aria-label={language.t("session.background.moveInline", { keybind: keybind() })}
    >
      <span data-slot="session-background-hint-prefix" class="shrink-0">
@@ -68,6 +66,37 @@ export function BackgroundMoveHint(props: { keybind?: string[] }) {
  )
 }

+function BackgroundMoveHintRow(props: { show: boolean; centered: boolean; padding: string }) {
+  const [ref, setRef] = createSignal<HTMLDivElement>()
+  const visibility = createMemo<{ show: boolean; animate: boolean }>(
+    (previous) => ({ show: props.show, animate: previous.animate || previous.show !== props.show }),
+    { show: props.show, animate: false },
+  )
+  const presence = createPresence({ show: () => visibility().show, element: () => ref() ?? null })
+  return (
+    <Show when={presence.present()}>
+      <div
+        classList={{
+          "min-w-0 w-full max-w-full": true,
+          "md:max-w-200 2xl:max-w-[1000px] md:mx-auto": props.centered,
+        }}
+      >
+        <div
+          ref={setRef}
+          class="duration-150 motion-reduce:animate-none"
+          classList={{
+            [`flex h-10 items-start pt-4 ${props.padding}`]: true,
+            "animate-in fade-in": visibility().animate && visibility().show,
+            "animate-out fade-out fill-mode-forwards": visibility().animate && !visibility().show,
+          }}
+        >
+          <BackgroundMoveHint />
+        </div>
+      </div>
+    </Show>
+  )
+}
+
 export function BackgroundWorkSummary(props: { tasks: BackgroundTask[] }) {
  const language = useLanguage()
  const [open, setOpen] = createSignal(false)
@@ -182,7 +211,6 @@ function WorkspaceMoveAction(props: {

 function SessionSummaryPanel(props: {
  project: Project
-  avatar?: JSX.Element
  directory: string
  local: boolean
  branch?: string
@@ -209,13 +237,11 @@ function SessionSummaryPanel(props: {
    <div data-component="session-summary-panel" class="w-[280px]">
      <div class="relative z-10 flex flex-col gap-1 overflow-hidden rounded-[6px] bg-v2-background-bg-base px-0.5 py-1.5 shadow-[var(--v2-elevation-raised)]">
        <div class={row}>
-          {props.avatar ?? (
-            <ProjectAvatar
-              fallback={displayName(props.project)}
-              src={getProjectAvatarSource(props.project.id, props.project.icon)}
-              variant={getProjectAvatarVariant(props.project.icon?.color)}
-            />
-          )}
+          <ProjectAvatar
+            fallback={displayName(props.project)}
+            src={getProjectAvatarSource(props.project.id, props.project.icon)}
+            variant={getProjectAvatarVariant(props.project.icon?.color)}
+          />
          <span class="min-w-0 flex-1 truncate text-v2-text-text-muted">{displayName(props.project)}</span>
        </div>
        <SessionWorkspaceMenu
@@ -297,12 +323,13 @@ type MessageTimelineProps = {
  onResumeScroll: () => void
  setScrollRef: (el: HTMLDivElement | undefined) => void
  onScheduleScrollState: (el: HTMLDivElement) => void
-  onPin: () => void
-  onUnpin: () => void
-  onUserScroll: (target?: EventTarget | null) => void
+  onAutoScrollHandleScroll: () => void
+  onMarkScrollGesture: (target?: EventTarget | null) => void
+  hasScrollGesture: boolean
+  onUserScroll: () => void
  onHistoryScroll: () => void
-  onSelectionInteraction: (event: MouseEvent) => void
-  pinned: boolean
+  onAutoScrollInteraction: (event: MouseEvent) => void
+  shouldAnchorBottom: boolean
  centered: boolean
  setContentRef: (el: HTMLDivElement) => void
  diffs: Accessor<{ additions: number; deletions: number }[] | undefined>
@@ -312,6 +339,7 @@ type MessageTimelineProps = {
  anchor: (id: string) => string
  setRevealMessage?: (fn: (id: string) => void) => void
  setScrollToEnd?: (fn: () => void) => void
+  setHistoryAnchor?: (handlers: { capture: () => void; restore: (done: boolean) => void }) => void
 }

 export function MessageTimeline(props: MessageTimelineProps) {
@@ -330,8 +358,6 @@ function MessageTimelineView(
 ) {
  const language = useLanguage()
  const data = useData()
-  const server = useServer()
-  const settings = useSettings()
  const sdk = useWorkspaceLocation()
  const sessionID = props.data.sessionID
  const sessionStatus = props.data.status
@@ -350,21 +376,6 @@ function MessageTimelineView(
    return { ...value, worktree: value.canonical, worktrees: [] }
  })
  const workspaceSession = createMemo(() => isWorkspaceDirectory(project(), sessionDirectory()))
-  const showProjectIcon = () =>
-    import.meta.env.VITE_OPENCODE_CHANNEL !== "prod" && settings.general.showProjectIcon()
-  const avatarProject = createMemo(() => {
-    if (!showProjectIcon()) return
-    const session = props.session.data.info()
-    if (!session) return
-    return projectForSession(session, server.ctx.projects.list())
-  })
-  const projectAvatar = () => (
-    <ProjectAvatar
-      fallback={displayName(avatarProject() ?? { worktree: sessionDirectory() })}
-      src={getProjectAvatarSource(avatarProject()?.id, avatarProject()?.icon)}
-      variant={getProjectAvatarVariant(avatarProject()?.icon?.color)}
-    />
-  )
  createEffect(() => {
    const directory = project()?.worktree
    if (!directory) return
@@ -385,25 +396,28 @@ function MessageTimelineView(
  )
  const turnPadding = () => "px-4 md:px-5"
  const showHeader = createMemo(() => props.data.showHeader() || workspaceSession())
-  const pinned = createMemo(() => props.pinned)
+  const shouldAnchorBottom = createMemo(() => props.shouldAnchorBottom)
+  const hasScrollGesture = createMemo(() => props.hasScrollGesture)
  const messageByID = projection.messageByID
  const virtualized = createTimelineVirtualizer({
    sessionKey: props.data.sessionKey,
    projection,
    showHeader,
-    pinned,
+    shouldAnchorBottom,
+    hasScrollGesture,
    scroll: () => props.scroll,
    onResumeScroll: props.onResumeScroll,
    setScrollRef: props.setScrollRef,
    setContentRef: props.setContentRef,
    onScheduleScrollState: props.onScheduleScrollState,
-    onPin: props.onPin,
-    onUnpin: props.onUnpin,
-    onSelectionInteraction: props.onSelectionInteraction,
+    onAutoScrollHandleScroll: props.onAutoScrollHandleScroll,
+    onAutoScrollInteraction: props.onAutoScrollInteraction,
+    onMarkScrollGesture: props.onMarkScrollGesture,
    onUserScroll: props.onUserScroll,
    onHistoryScroll: props.onHistoryScroll,
    setRevealMessage: props.setRevealMessage,
    setScrollToEnd: props.setScrollToEnd,
+    setHistoryAnchor: props.setHistoryAnchor,
  })
  const VirtualizedTimeline = virtualized.View
  const [title, setTitle] = createStore({
@@ -478,53 +492,28 @@ function MessageTimelineView(
    if (row?._tag !== "AssistantPart" || row.group.type !== "part") return
    return row.group.ref.partID
  })
-  const [backgroundHintRef, setBackgroundHintRef] = createSignal<HTMLDivElement>()
-  const backgroundHintVisibility = createMemo<{ show: boolean; animate: boolean }>(
-    (previous) => {
-      const show = backgroundHintPartID() !== undefined
-      return { show, animate: previous.animate || previous.show !== show }
-    },
-    { show: backgroundHintPartID() !== undefined, animate: false },
-  )
-  const backgroundHintPresence = createPresence({
-    show: () => backgroundHintVisibility().show,
-    element: () => backgroundHintRef() ?? null,
-  })
+  const backgroundHint = (row: TimelineRow.TimelineRow) =>
+    row._tag === "AssistantPart" && row.group.type === "part" && row.group.ref.partID === backgroundHintPartID()
+
  return (
    <VirtualizedTimeline
      workspaceSession={workspaceSession}
-      bottomSpacer={
-        <Show when={backgroundHintPresence.present()}>
-          <div
-            data-component="session-background-hint-row"
-            classList={{
-              "min-w-0 w-full max-w-full": true,
-              "md:max-w-200 2xl:max-w-[1000px] md:mx-auto": props.centered,
-            }}
-          >
-            <div
-              ref={setBackgroundHintRef}
-              class="duration-150 motion-reduce:animate-none"
-              classList={{
-                [`flex h-9 items-start pt-3 ${turnPadding()}`]: true,
-                "animate-in fade-in": backgroundHintVisibility().animate && backgroundHintVisibility().show,
-                "animate-out fade-out fill-mode-forwards":
-                  backgroundHintVisibility().animate && !backgroundHintVisibility().show,
-              }}
-            >
-              <BackgroundMoveHint />
-            </div>
-          </div>
-        </Show>
-      }
      deferred={(row) => {
        if (row._tag !== "AssistantPart" || row.group.type !== "part") return false
        const content = Timeline.resolveContent(messageByID().get(row.group.ref.messageID), row.group.ref.partID)
        return content?.type === "tool" && ["edit", "write"].includes(content.name)
      }}
-      renderRow={(row, onSizeChange) => <rowRenderer.Row row={row} onSizeChange={onSizeChange} />}
+      renderRow={(row, onSizeChange) => (
+        <>
+          <rowRenderer.Row row={row} onSizeChange={onSizeChange} />
+          <BackgroundMoveHintRow show={backgroundHint(row())} centered={props.centered} padding={turnPadding()} />
+        </>
+      )}
      header={
-        <SessionTitleHeader>
+        <div
+          data-session-title
+          class="sticky top-0 z-30 bg-[linear-gradient(to_bottom,var(--v2-background-bg-base)_48px,transparent)] w-full pb-4 pr-3 pl-2.5"
+        >
          <div class="h-12 w-full flex items-center justify-between gap-2">
            <div class="flex items-center gap-1 min-w-0 flex-1">
              <div class="flex items-center min-w-0 flex-1 w-full">
@@ -532,9 +521,7 @@ function MessageTimelineView(
                  when={workspaceSession()}
                  fallback={
                    <span class="flex size-6 shrink-0 items-center justify-center text-v2-icon-icon-muted">
-                      <Show when={showProjectIcon()} fallback={<Icon name="monitor" />}>
-                        {projectAvatar()}
-                      </Show>
+                      <Icon name="monitor" />
                    </span>
                  }
                >
@@ -546,14 +533,9 @@ function MessageTimelineView(
                    <span
                      tabIndex={0}
                      aria-label={sessionDirectory()}
-                      classList={{
-                        "flex size-6 shrink-0 items-center justify-center": true,
-                        "text-v2-icon-icon-accent": !showProjectIcon(),
-                      }}
+                      class="flex size-6 shrink-0 items-center justify-center text-v2-icon-icon-accent"
                    >
-                      <Show when={showProjectIcon()} fallback={<Icon name="workspace-isolated" />}>
-                        {projectAvatar()}
-                      </Show>
+                      <Icon name="workspace-isolated" />
                    </span>
                  </Tooltip>
                </Show>
@@ -639,7 +621,6 @@ function MessageTimelineView(
                          <Popover.Content class="z-50 border-0 bg-transparent p-0 outline-none">
                            <SessionSummaryPanel
                              project={project()}
-                              avatar={showProjectIcon() ? projectAvatar() : undefined}
                              directory={sessionDirectory()}
                              local={!workspaceSession()}
                              branch={data.location.vcs.info({ directory: sdk().directory })?.branch.current}
@@ -714,7 +695,7 @@ function MessageTimelineView(
              )}
            </Show>
          </div>
-        </SessionTitleHeader>
+        </div>
      }
    />
  )
@@ -1,12 +1,6 @@
 import { describe, expect, test } from "bun:test"
 import type { SessionMessageAssistant, SessionMessageInfo, SessionMessageUser } from "@opencode-ai/client/promise"
-import {
-  enrichLeadingTurn,
-  leadingTurnNeedsParent,
-  loadOlderTimeline,
-  selectUserMessages,
-  selectVisibleUserMessages,
-} from "./model"
+import { loadOlderTimeline, selectUserMessages, selectVisibleUserMessages } from "./model"

 const user = (id: string): SessionMessageUser => ({ id, type: "user", text: id, time: { created: 1 } })
 const assistant = (id: string): SessionMessageAssistant => ({
@@ -48,56 +42,6 @@ describe("timeline model", () => {
    expect(anchors).toEqual(["before", "after", true])
  })

-  test("recognizes a leading partial assistant turn", () => {
-    expect(leadingTurnNeedsParent([assistant("msg_assistant"), user("msg_next")])).toBe(true)
-    expect(leadingTurnNeedsParent([user("msg_user"), assistant("msg_assistant")])).toBe(false)
-    expect(leadingTurnNeedsParent([user("msg_user")])).toBe(false)
-  })
-
-  test("pauses between bounded history pages until the leading turn has its parent", async () => {
-    const pages: SessionMessageInfo[][] = [[assistant("msg_older")], [user("msg_parent")]]
-    const messages: SessionMessageInfo[] = [assistant("msg_latest"), user("msg_next")]
-    let pauses = 0
-    let loads = 0
-
-    await enrichLeadingTurn({
-      current: () => true,
-      messages: () => messages,
-      more: () => pages.length > 0,
-      loading: () => false,
-      loadMore: async () => {
-        messages.unshift(...pages.shift()!)
-        loads += 1
-      },
-      pause: async () => {
-        pauses += 1
-      },
-      maxPages: 3,
-    })
-
-    expect(loads).toBe(2)
-    expect(pauses).toBe(2)
-    expect(leadingTurnNeedsParent(messages)).toBe(false)
-  })
-
-  test("caps background pages when the parent remains outside the window", async () => {
-    let loads = 0
-
-    await enrichLeadingTurn({
-      current: () => true,
-      messages: () => [assistant("msg_latest")],
-      more: () => true,
-      loading: () => false,
-      loadMore: async () => {
-        loads += 1
-      },
-      pause: async () => undefined,
-      maxPages: 3,
-    })
-
-    expect(loads).toBe(3)
-  })
-
  test("does not restore an anchor after the session changes", async () => {
    let sessionID = "ses_old"
    let restore = 0
@@ -1,11 +1,7 @@
 import { createMemo, createResource, type Accessor } from "solid-js"
-import type { SessionMessageInfo } from "@opencode-ai/client/promise"
 import { useData } from "@/runtime/server/current"
 import type { SessionModel } from "../model"

-const leadingTurnPageDelay = 200
-const leadingTurnPageLimit = 3
-
 export {
  selectSessionUserMessages as selectUserMessages,
  selectVisibleSessionUserMessages as selectVisibleUserMessages,
@@ -13,32 +9,12 @@ export {

 export function createTimelineModel(input: { session: Pick<SessionModel, "identity" | "history"> }) {
  const data = useData()
-  const prepared = new Set<string>()

  const [resource] = createResource(
    () => input.session.identity.sessionID(),
-    async (id) => {
-      if (!id) return
-      const key = input.session.identity.sessionKey()
-      await Promise.all([data.session.message.sync(id), data.session.pending.sync(id)])
-      await enrichLeadingTurn({
-        current: () => input.session.identity.sessionKey() === key,
-        messages: () => data.session.message.list(id),
-        more: () => data.session.message.more(id),
-        loading: () => data.session.message.loading(id),
-        loadMore: () => data.session.message.loadMore(id),
-        pause: () => new Promise((resolve) => setTimeout(resolve, leadingTurnPageDelay)),
-        maxPages: leadingTurnPageLimit,
-      }).catch(() => undefined)
-      if (input.session.identity.sessionKey() === key) prepared.add(key)
-    },
+    (id) => (id ? Promise.all([data.session.message.sync(id), data.session.pending.sync(id)]) : undefined),
  )
-  const ready = createMemo(() => {
-    const id = input.session.identity.sessionID()
-    if (!id || prepared.has(input.session.identity.sessionKey()) || !resource.loading) return true
-    const messages = data.session.message.list(id)
-    return messages.length > 0 && !leadingTurnNeedsParent(messages)
-  })
+  const ready = createMemo(() => !input.session.identity.sessionID() || !resource.loading)
  const more = () => {
    const id = input.session.identity.sessionID()
    return id ? data.session.message.more(id) : false
@@ -52,7 +28,7 @@ export function createTimelineModel(input: { session: Pick<SessionModel, "identi
      sessionID: input.session.identity.sessionID,
      more,
      loading,
-      loadMore: (id) => data.session.message.loadMore(id),
+      loadMore: data.session.message.loadMore,
      before: options?.before,
      after: options?.after,
    })
@@ -68,34 +44,6 @@ export function createTimelineModel(input: { session: Pick<SessionModel, "identi
  }
 }

-export async function enrichLeadingTurn(input: {
-  current: Accessor<boolean>
-  messages: Accessor<SessionMessageInfo[]>
-  more: Accessor<boolean>
-  loading: Accessor<boolean>
-  loadMore: () => Promise<void>
-  pause: () => Promise<void>
-  maxPages: number
-}) {
-  const load = async (pages: number): Promise<void> => {
-    if (!input.current() || pages >= input.maxPages || !leadingTurnNeedsParent(input.messages()) || !input.more())
-      return
-    await input.pause()
-    if (!input.current() || !leadingTurnNeedsParent(input.messages()) || !input.more()) return
-    if (input.loading()) return load(pages)
-    await input.loadMore()
-    return load(pages + 1)
-  }
-  return load(0)
-}
-
-export function leadingTurnNeedsParent(messages: SessionMessageInfo[]) {
-  const assistant = messages.findIndex((message) => message.type === "assistant")
-  if (assistant === -1) return false
-  const boundary = messages.findIndex((message) => message.type === "user" || message.type === "shell")
-  return boundary === -1 || assistant < boundary
-}
-
 export async function loadOlderTimeline(input: {
  sessionID: Accessor<string | undefined>
  more: Accessor<boolean>
@@ -3,7 +3,6 @@ import { observeElementOffset, type Virtualizer } from "@tanstack/solid-virtual"
 export function observeElementOffsetReconnectAware<TScrollElement extends Element, TItemElement extends Element>(
  instance: Virtualizer<TScrollElement, TItemElement>,
  callback: (offset: number, isScrolling: boolean) => void,
-  onReconnect?: () => void,
 ) {
  let active = true
  const deliver = (offset: number, isScrolling: boolean) => {
@@ -55,7 +54,6 @@ export function observeElementOffsetReconnectAware<TScrollElement extends Elemen
      }
      if (!removed || !element.isConnected || !mutationNodesContainElement(record.addedNodes, element)) return
      removed = false
-      onReconnect?.()
      startCheck()
    })
  })
@@ -63,8 +63,7 @@ export function createTimelineProjection(input: {
    input.sessionMessages().forEach((message) => {
      if (message.type === "user") userID = message.id
      if (message.type === "shell") userID = undefined
-      if (message.type !== "assistant") return
-      if (!userID) userID = message.id
+      if (message.type !== "assistant" || !userID) return
      const messages = result.get(userID)
      if (messages) {
        messages.push(message)
@@ -1,6 +1,7 @@
 import { createVirtualizer, defaultRangeExtractor, elementScroll, type VirtualItem } from "@tanstack/solid-virtual"
 import { isScrollKeyTarget, scrollKey, scrollKeyOwner, ScrollView } from "@opencode-ai/ui/scroll-view"
 import { TimelineRow } from "@opencode-ai/session-ui/timeline/projection"
+import { normalizeWheelDelta, shouldMarkBoundaryGesture } from "@/session/message-gesture"
 import { useLanguage } from "@/runtime/i18n/language"
 import {
  createEffect,
@@ -16,15 +17,11 @@ import {
 } from "solid-js"
 import { createStore } from "solid-js/store"
 import type { createTimelineProjection } from "./projection"
+import { scheduleConnectedMeasure } from "./measure"
 import { observeElementOffsetReconnectAware } from "./observe-element-offset"
 import { filterVirtualIndexes } from "./virtual-items"

 const fallbackItemSize = 60
-const pendingMarkdown = '[data-component="markdown"]:not([data-markdown-ready])'
-// Distance from the bottom that counts as "at the end". Deliberately tight: a collapse clamps
-// exactly to the end, while a one-pixel nudge upward is a deliberate move away from it.
-const endEpsilon = 0.5
-const upwardKeys = new Set(["up", "page-up", "home"])
 const cache = new Map<string, { measurements: VirtualItem[]; toolOpen: Record<string, boolean | undefined> }>()

 type Projection = Pick<
@@ -36,25 +33,25 @@ type Input = {
  sessionKey: Accessor<string>
  projection: Projection
  showHeader: Accessor<boolean>
-  /** True while the timeline follows the newest content. Drives every anchoring decision. */
-  pinned: Accessor<boolean>
+  shouldAnchorBottom: Accessor<boolean>
+  hasScrollGesture: Accessor<boolean>
  scroll: Accessor<{ overflow: boolean; jump: boolean }>
  onResumeScroll: () => void
  setScrollRef: (element: HTMLDivElement | undefined) => void
  setContentRef: (element: HTMLDivElement) => void
  onScheduleScrollState: (element: HTMLDivElement) => void
-  onPin: () => void
-  onUnpin: () => void
-  onSelectionInteraction: (event: MouseEvent) => void
-  onUserScroll: (target?: EventTarget | null) => void
+  onAutoScrollHandleScroll: () => void
+  onAutoScrollInteraction: (event: MouseEvent) => void
+  onMarkScrollGesture: (target?: EventTarget | null) => void
+  onUserScroll: () => void
  onHistoryScroll: () => void
  setRevealMessage?: (fn: (id: string) => void) => void
  setScrollToEnd?: (fn: () => void) => void
+  setHistoryAnchor?: (handlers: { capture: () => void; restore: (done: boolean) => void }) => void
 }

 type ViewProps = {
  header: JSX.Element
-  bottomSpacer?: JSX.Element
  workspaceSession: Accessor<boolean>
  deferred: (row: TimelineRow.TimelineRow) => boolean
  renderRow: (row: Accessor<TimelineRow.TimelineRow>, onSizeChange?: () => void) => JSX.Element
@@ -65,31 +62,90 @@ export function createTimelineVirtualizer(input: Input) {
  const ownerSessionKey = input.sessionKey()
  const cached = cache.get(ownerSessionKey)
  const initialMeasurements = cached?.measurements
-  const coldBottomMount = !initialMeasurements?.length && input.pinned()
+  const coldBottomMount = !initialMeasurements?.length && input.shouldAnchorBottom()
  const [listRoot, setListRoot] = createSignal<HTMLDivElement>()
  const [toolOpen, setToolOpen] = createStore<Record<string, boolean | undefined>>(cached?.toolOpen ?? {})
  const [renderOverscan, setRenderOverscan] = createSignal(initialMeasurements?.length || coldBottomMount ? 6 : 20)
  const rows = input.projection.rows
  const rowByKey = input.projection.rowByKey
-  const knownKeys = new Set(rows().map(TimelineRow.key))
-  const addedKeys = new Set<string>()
-  let touchStart: number | undefined
-  let pointerHeld = false
-  let maxScroll = 0
+  let touchGesture: number | undefined
+  let prependAnchor: { key: string; offset: number } | undefined
+  let prependAnchorFrame: number | undefined
+  let prependLoading = false
+  let resizePinnedIndexes: number[] = []
+  let resizePinFrame: number | undefined
+  let gestureAnchorFrame: number | undefined
  let virtualContent: HTMLDivElement | undefined
  let scrollTop = 0

+  const clearPrependAnchor = () => {
+    prependLoading = false
+    prependAnchor = undefined
+    if (prependAnchorFrame === undefined) return
+    cancelAnimationFrame(prependAnchorFrame)
+    prependAnchorFrame = undefined
+  }
+
+  const capturePrependAnchor = () => {
+    prependLoading = true
+    updatePrependAnchor()
+  }
+
+  const updatePrependAnchor = () => {
+    const root = listRoot()
+    if (!root) return
+    const view = root.getBoundingClientRect()
+    const anchor = [...root.querySelectorAll<HTMLElement>("[data-timeline-key]")]
+      .map((element) => ({ element, rect: element.getBoundingClientRect() }))
+      .filter((item) => item.rect.bottom > view.top && item.rect.top < view.bottom)
+      .sort((a, b) => a.rect.top - b.rect.top)[0]
+    if (!anchor) return
+    if (!anchor.element.dataset.timelineKey) return
+    prependAnchor = { key: anchor.element.dataset.timelineKey, offset: anchor.rect.top - view.top }
+  }
+
+  const restorePrependAnchor = (done: boolean) => {
+    if (done) prependLoading = false
+    applyPrependAnchor()
+  }
+
+  const applyPrependAnchor = () => {
+    const root = listRoot()
+    if (!root || !prependAnchor) return
+    if (prependAnchorFrame !== undefined) cancelAnimationFrame(prependAnchorFrame)
+    let frames = 0
+    let stable = 0
+    const apply = () => {
+      prependAnchorFrame = undefined
+      const anchor = prependAnchor
+      if (!anchor) return
+      const element = root.querySelector<HTMLElement>(`[data-timeline-key="${CSS.escape(anchor.key)}"]`)
+      const delta = element
+        ? element.getBoundingClientRect().top - root.getBoundingClientRect().top - anchor.offset
+        : undefined
+      if (delta !== undefined && Math.abs(delta) > 0.5) {
+        root.scrollTop += delta
+        stable = 0
+      } else {
+        stable += 1
+      }
+      frames += 1
+      if (stable >= 30 || frames >= 180) {
+        if (!prependLoading) prependAnchor = undefined
+        return
+      }
+      prependAnchorFrame = requestAnimationFrame(apply)
+    }
+    prependAnchorFrame = requestAnimationFrame(apply)
+  }
+
  const virtualizer = createVirtualizer<HTMLDivElement, HTMLDivElement>({
    get count() {
      return rows().length
    },
    getScrollElement: () => listRoot() ?? null,
-    // Route navigation detaches and reattaches the scroll element, which drops its offset.
-    observeElementOffset: (instance, callback) =>
-      observeElementOffsetReconnectAware(instance, callback, () => {
-        if (input.pinned()) virtualizer.scrollToEnd()
-      }),
-    initialOffset: () => (input.pinned() ? Number.MAX_SAFE_INTEGER : 0),
+    observeElementOffset: observeElementOffsetReconnectAware,
+    initialOffset: () => (input.shouldAnchorBottom() ? Number.MAX_SAFE_INTEGER : 0),
    initialMeasurementsCache: initialMeasurements,
    estimateSize: () => fallbackItemSize,
    scrollToFn: (offset, options, instance) => {
@@ -98,66 +154,83 @@ export function createTimelineVirtualizer(input: Input) {
    },
    get getItemKey() {
      const items = rows()
-      items
-        .map(TimelineRow.key)
-        .filter((key) => !knownKeys.has(key))
-        .forEach((key) => {
-          knownKeys.add(key)
-          addedKeys.add(key)
-        })
      return (index: number) => {
        const row = items[index]
        if (!row) return `removed:${index}`
        return TimelineRow.key(row)
      }
    },
-    get anchorTo() {
-      return input.pinned() ? "end" : "start"
-    },
-    get followOnAppend() {
-      return input.pinned()
-    },
+    anchorTo: "end",
+    followOnAppend: true,
    scrollEndThreshold: 80,
    get scrollMargin() {
      return input.showHeader() ? 64 : 0
    },
+    overscan: 50,
    paddingEnd: 64,
    rangeExtractor: (range) => {
      const id = input.projection.activeMessageID()
      const active = id ? (input.projection.messageLastRowIndex().get(id) ?? -1) : -1
      const indexes = defaultRangeExtractor({ ...range, overscan: renderOverscan() })
      return filterVirtualIndexes(
-        [...new Set([...indexes, ...(active < 0 ? [] : [active])])].sort((a, b) => a - b),
+        [...new Set([...resizePinnedIndexes, ...indexes, ...(active < 0 ? [] : [active])])].sort((a, b) => a - b),
        range.count,
      )
    },
  })
  const resizeItem = virtualizer.resizeItem
  let resizeAnchorScheduled = false
-  // Rows measure asynchronously, so the last row can still hold its estimate when TanStack
-  // reconciles the end. Coalesce one correction per measurement batch, before paint.
+  const anchorAfterGesture = () => {
+    if (gestureAnchorFrame !== undefined) return
+    const apply = () => {
+      gestureAnchorFrame = undefined
+      if (input.hasScrollGesture()) {
+        gestureAnchorFrame = requestAnimationFrame(apply)
+        return
+      }
+      if (input.shouldAnchorBottom()) virtualizer.scrollToEnd()
+    }
+    gestureAnchorFrame = requestAnimationFrame(apply)
+  }
  const anchorResizedBottom = () => {
    if (resizeAnchorScheduled) return
    resizeAnchorScheduled = true
    queueMicrotask(() => {
      resizeAnchorScheduled = false
-      if (!input.pinned()) return
+      if (input.hasScrollGesture()) {
+        anchorAfterGesture()
+        return
+      }
+      if (!input.shouldAnchorBottom()) return
      virtualizer.scrollToEnd()
    })
  }
  virtualizer.resizeItem = (index, size) => {
+    const item = virtualizer.measurementsCache[index]
+    const previous = item ? (virtualizer.itemSizeCache.get(item.key) ?? item.size) : undefined
+    const root = listRoot()
+    if (root && previous !== undefined && Math.abs(size - previous) > root.clientHeight) {
+      const view = root.getBoundingClientRect()
+      resizePinnedIndexes = [...root.querySelectorAll<HTMLElement>("[data-index]")]
+        .filter((element) => {
+          const rect = element.getBoundingClientRect()
+          return rect.bottom > view.top && rect.top < view.bottom
+        })
+        .map((element) => Number(element.dataset.index))
+      if (resizePinFrame !== undefined) cancelAnimationFrame(resizePinFrame)
+      resizePinFrame = requestAnimationFrame(() => {
+        resizePinFrame = requestAnimationFrame(() => {
+          resizePinFrame = undefined
+          resizePinnedIndexes = []
+        })
+      })
+    }
    resizeItem(index, size)
-    if (listRoot() && input.pinned()) anchorResizedBottom()
+    if (root && input.shouldAnchorBottom()) anchorResizedBottom()
  }
-  virtualizer.shouldAdjustScrollPositionOnItemSizeChange = (item, _delta, instance) => {
-    // Prepended rows can resize more than once as deferred content mounts. Keep
-    // compensating while they remain entirely above the visible content fold.
-    if (addedKeys.has(String(item.key)))
-      return (
-        item.end <=
-        (instance.scrollOffset ?? 0) + instance.scrollAdjustments + instance.options.scrollMargin
-      )
-    const first = instance.range?.startIndex
+  virtualizer.shouldAdjustScrollPositionOnItemSizeChange = (item) => {
+    if (input.shouldAnchorBottom()) return false
+    const first = virtualizer.range?.startIndex
    return first !== undefined && item.index < first
  }
  const virtualItemByKey = createMemo(
@@ -171,110 +244,97 @@ export function createTimelineVirtualizer(input: Input) {
      if (index === undefined) return
      virtualizer.scrollToIndex(index, { align: "center" })
    })
-    input.setScrollToEnd?.(() => {
-      input.onPin()
-      virtualizer.scrollToEnd()
-    })
+    input.setScrollToEnd?.(() => virtualizer.scrollToEnd())
+    input.setHistoryAnchor?.({ capture: capturePrependAnchor, restore: restorePrependAnchor })
  })

  let overscanFrame: number | undefined
-  const pendingMeasurements = () =>
-    virtualizer.getVirtualItems().some((item) => !virtualizer.itemSizeCache.has(item.key))
-  const settleColdBottom = () => {
-    if (input.pinned()) virtualizer.scrollToEnd()
-    if (virtualContent?.querySelector(pendingMarkdown) || pendingMeasurements()) {
-      overscanFrame = requestAnimationFrame(settleColdBottom)
-      return
-    }
-    overscanFrame = requestAnimationFrame(() => {
-      if (input.pinned()) virtualizer.scrollToEnd()
-      if (virtualContent?.querySelector(pendingMarkdown) || pendingMeasurements()) {
-        settleColdBottom()
-        return
-      }
-      overscanFrame = undefined
-      const content = virtualContent
-      if (!content) return
-      if (window.matchMedia("(prefers-reduced-motion: reduce)").matches) {
-        content.style.removeProperty("visibility")
-        return
-      }
-      const animation = ["animate-in", "fade-in", "duration-150"]
-      const clearAnimation = (event: AnimationEvent) => {
-        if (event.target !== content) return
-        content.removeEventListener("animationend", clearAnimation)
-        content.removeEventListener("animationcancel", clearAnimation)
-        content.classList.remove(...animation)
-      }
-      content.addEventListener("animationend", clearAnimation)
-      content.addEventListener("animationcancel", clearAnimation)
-      content.classList.add(...animation)
-      content.style.removeProperty("visibility")
-    })
-  }
  onMount(() => {
    overscanFrame = requestAnimationFrame(() => {
-      if (renderOverscan() < 20) setRenderOverscan(20)
-      if (!coldBottomMount) {
+      if (input.shouldAnchorBottom()) virtualizer.scrollToEnd()
+      overscanFrame = requestAnimationFrame(() => {
        overscanFrame = undefined
-        return
-      }
-      settleColdBottom()
+        if (renderOverscan() < 20) setRenderOverscan(20)
+        if (input.shouldAnchorBottom()) virtualizer.scrollToEnd()
+      })
    })
  })

+  const maybeAnchorBottom = () => {
+    if (rows().length === 0) return
+    if (input.hasScrollGesture()) {
+      anchorAfterGesture()
+      return
+    }
+    if (!input.shouldAnchorBottom()) return
+    if (resizePinFrame !== undefined) cancelAnimationFrame(resizePinFrame)
+    clearPrependAnchor()
+    if (prependAnchorFrame !== undefined) cancelAnimationFrame(prependAnchorFrame)
+    virtualizer.scrollToEnd()
+  }
+
  let measuredSessionKey = input.sessionKey()
  createEffect(() => {
    const key = input.sessionKey()
+    rows().length
    if (measuredSessionKey !== key) {
      measuredSessionKey = key
      virtualizer.measure()
    }
+    maybeAnchorBottom()
  })

  const bindListRoot = (root: HTMLDivElement) => {
    if (root === listRoot()) return
    setListRoot(root)
-    // TanStack owns anchoring; browser scroll anchoring would fight its adjustments.
-    root.style.overflowAnchor = "none"
    scrollTop = root.scrollTop
-    maxScroll = root.scrollHeight - root.clientHeight
    input.setScrollRef(root)
  }

-  // Upward input is the one intent geometry cannot recover: nudging up while still a pixel from
-  // the end must stop following, even though the resulting position still looks like the end.
  const handleListWheel = (event: WheelEvent & { currentTarget: HTMLDivElement }) => {
-    input.onUserScroll(event.target)
-    if (event.deltaY < 0) input.onUnpin()
+    if (!prependLoading) clearPrependAnchor()
+    const root = event.currentTarget
+    const delta = normalizeWheelDelta({
+      deltaY: event.deltaY,
+      deltaMode: event.deltaMode,
+      rootHeight: root.clientHeight,
+    })
+    if (!delta) return
+    markBoundaryGesture({ root, target: event.target, delta, onMarkScrollGesture: input.onMarkScrollGesture })
  }

  const handleListTouchStart = (event: TouchEvent) => {
-    input.onUserScroll(event.target)
-    touchStart = event.touches[0]?.clientY
+    if (!prependLoading) clearPrependAnchor()
+    touchGesture = event.touches[0]?.clientY
  }

  const handleListTouchMove = (event: TouchEvent & { currentTarget: HTMLDivElement }) => {
-    const current = event.touches[0]?.clientY
-    if (current === undefined || touchStart === undefined) return
-    // Dragging the content downward reveals earlier messages.
-    if (current <= touchStart) return
-    touchStart = current
-    input.onUnpin()
+    const next = event.touches[0]?.clientY
+    const previous = touchGesture
+    touchGesture = next
+    if (next === undefined || previous === undefined) return
+    const delta = previous - next
+    if (!delta) return
+    markBoundaryGesture({
+      root: event.currentTarget,
+      target: event.target,
+      delta,
+      onMarkScrollGesture: input.onMarkScrollGesture,
+    })
+  }
+
+  const handleListTouchEnd = () => {
+    touchGesture = undefined
  }

-  // Drag-selecting past the edge and dragging the scrollbar both scroll without a wheel or key,
-  // so a held pointer is what separates those from the virtualizer's own measurement adjustments.
  const handleListPointerDown = (event: PointerEvent & { currentTarget: HTMLDivElement }) => {
-    input.onUserScroll(event.target)
-    pointerHeld = true
-    const release = () => {
-      pointerHeld = false
-      window.removeEventListener("pointerup", release)
-      window.removeEventListener("pointercancel", release)
-    }
-    window.addEventListener("pointerup", release)
-    window.addEventListener("pointercancel", release)
+    if (!prependLoading) clearPrependAnchor()
+    input.onMarkScrollGesture(event.target)
+  }
+
+  const handleListPointerMove = (event: PointerEvent) => {
+    if (event.buttons !== 1) return
+    input.onMarkScrollGesture(event.target)
  }

  const handleListKeyDown = (event: KeyboardEvent & { currentTarget: HTMLDivElement }) => {
@@ -282,25 +342,22 @@ export function createTimelineVirtualizer(input: Input) {
    if (!key) return
    if (!isScrollKeyTarget(event.target, key)) return
    if (scrollKeyOwner(event.currentTarget, event.target, key) !== event.currentTarget) return
-    input.onUserScroll(event.currentTarget)
-    if (upwardKeys.has(key)) input.onUnpin()
+    if (!prependLoading) clearPrependAnchor()
+    input.onMarkScrollGesture(event.currentTarget)
  }

-  // Following resumes by arriving at the end, either by scrolling there or by content shrinking
-  // under a viewport that was already there. Merely resting near the end is not enough, otherwise
-  // a later scroll would overwrite an upward intent expressed a pixel short of the bottom.
  const handleListScroll = (event: Event & { currentTarget: HTMLDivElement }) => {
    const root = event.currentTarget
-    const previousTop = scrollTop
-    const previousMaxScroll = maxScroll
+    const movedUp = root.scrollTop < scrollTop - 0.5
    scrollTop = root.scrollTop
-    maxScroll = root.scrollHeight - root.clientHeight
-    const atEnd = maxScroll - scrollTop <= endEpsilon
-    const arrived = scrollTop > previousTop + endEpsilon || maxScroll < previousMaxScroll
-    if (maxScroll <= 1 || (atEnd && arrived)) input.onPin()
-    else if (pointerHeld && scrollTop < previousTop - endEpsilon) input.onUnpin()
+    if (prependLoading) updatePrependAnchor()
    input.onScheduleScrollState(root)
    input.onHistoryScroll()
+    if (!input.hasScrollGesture()) return
+    if (!movedUp && root.scrollHeight - root.clientHeight - root.scrollTop >= 10) return
+    input.onUserScroll()
+    input.onAutoScrollHandleScroll()
+    input.onMarkScrollGesture(root)
  }

  function View(props: ViewProps) {
@@ -351,10 +408,7 @@ export function createTimelineVirtualizer(input: Input) {
            {props.renderRow(row, () => {
              setReady(true)
              if (contentMeasureFrame !== undefined) cancelAnimationFrame(contentMeasureFrame)
-              contentMeasureFrame = requestAnimationFrame(() => {
-                contentMeasureFrame = undefined
-                if (element.isConnected) virtualizer.measureElement(element)
-              })
+              contentMeasureFrame = scheduleConnectedMeasure(element, virtualizer.measureElement)
            })}
          </div>
        </div>
@@ -396,37 +450,33 @@ export function createTimelineVirtualizer(input: Input) {
          onWheel={handleListWheel}
          onTouchStart={handleListTouchStart}
          onTouchMove={handleListTouchMove}
+          onTouchEnd={handleListTouchEnd}
+          onTouchCancel={handleListTouchEnd}
          onPointerDown={handleListPointerDown}
+          onPointerMove={handleListPointerMove}
          onKeyDown={handleListKeyDown}
          onScroll={handleListScroll}
-          onClick={input.onSelectionInteraction}
+          onClick={input.onAutoScrollInteraction}
          class="relative min-w-0 w-full h-full"
          style={{ "--sticky-accordion-top": input.showHeader() ? "48px" : "0px" }}
        >
          <Show when={input.showHeader()}>{props.header}</Show>
          <div
            data-timeline-virtual-content
-            class="motion-reduce:animate-none"
            ref={(element) => {
              virtualContent = element
              input.setContentRef(element)
            }}
-            style={{
-              height: `${virtualizer.getTotalSize()}px`,
-              position: "relative",
-              width: "100%",
-              visibility: coldBottomMount ? "hidden" : undefined,
-            }}
+            style={{ height: `${virtualizer.getTotalSize()}px`, position: "relative", width: "100%" }}
          >
            <For each={virtualRowKeys()}>{(rowKey) => <VirtualRow rowKey={rowKey} />}</For>
            <Show when={rows().length > 0}>
              <div
                data-timeline-row="bottom-spacer"
+                aria-hidden="true"
                class="h-16 absolute top-0 left-0 w-full"
                style={{ transform: `translateY(${virtualizer.getTotalSize() - 64}px)` }}
-              >
-                {props.bottomSpacer}
-              </div>
+              />
            </Show>
          </div>
        </ScrollView>
@@ -435,13 +485,17 @@ export function createTimelineVirtualizer(input: Input) {
  }

  onCleanup(() => {
+    clearPrependAnchor()
    cache.delete(ownerSessionKey)
    cache.set(ownerSessionKey, { measurements: virtualizer.takeSnapshot(), toolOpen: { ...toolOpen } })
    while (cache.size > 16) cache.delete(cache.keys().next().value!)
+    if (resizePinFrame !== undefined) cancelAnimationFrame(resizePinFrame)
+    if (gestureAnchorFrame !== undefined) cancelAnimationFrame(gestureAnchorFrame)
    if (overscanFrame !== undefined) cancelAnimationFrame(overscanFrame)
    input.setScrollRef(undefined)
    input.setRevealMessage?.(() => {})
    input.setScrollToEnd?.(() => {})
+    input.setHistoryAnchor?.({ capture: () => {}, restore: () => {} })
  })

  return {
@@ -452,3 +506,30 @@ export function createTimelineVirtualizer(input: Input) {
    View,
  }
 }
+
+function boundaryTarget(root: HTMLElement, target: EventTarget | null) {
+  const current = target instanceof Element ? target : undefined
+  const nested = current?.closest("[data-scrollable]")
+  if (!(nested instanceof HTMLElement) || nested === root) return undefined
+  return nested
+}
+
+function markBoundaryGesture(input: {
+  root: HTMLElement
+  target: EventTarget | null
+  delta: number
+  onMarkScrollGesture: (target?: EventTarget | null) => void
+}) {
+  const target = boundaryTarget(input.root, input.target)
+  if (
+    target &&
+    !shouldMarkBoundaryGesture({
+      delta: input.delta,
+      scrollTop: target.scrollTop,
+      scrollHeight: target.scrollHeight,
+      clientHeight: target.clientHeight,
+    })
+  )
+    return
+  input.onMarkScrollGesture(input.root)
+}
@@ -15,7 +15,7 @@ export const useSessionHashScroll = (input: {
  pendingMessage: () => string | undefined
  setPendingMessage: (value: string | undefined) => void
  setActiveMessage: (message: SessionMessageUser | undefined) => void
-  follow: { unpin: () => void; toBottom: () => void }
+  autoScroll: { pause: () => void; forceScrollToBottom: () => void }
  scroller: () => HTMLDivElement | undefined
  anchor: (id: string) => string
  revealMessage?: (id: string) => void
@@ -101,7 +101,7 @@ export const useSessionHashScroll = (input: {
  const applyHash = (behavior: ScrollBehavior) => {
    const hash = location.hash.slice(1)
    if (!hash) {
-      input.follow.toBottom()
+      input.autoScroll.forceScrollToBottom()
      const el = input.scroller()
      if (el) input.scheduleScrollState(el)
      return
@@ -109,7 +109,7 @@ export const useSessionHashScroll = (input: {

    const messageId = messageIdFromHash(hash)
    if (messageId) {
-      input.follow.unpin()
+      input.autoScroll.pause()
      const msg = messageById().get(messageId)
      if (msg) {
        scrollToMessage(msg, behavior)
@@ -120,12 +120,12 @@ export const useSessionHashScroll = (input: {

    const target = document.getElementById(hash)
    if (target) {
-      input.follow.unpin()
+      input.autoScroll.pause()
      scrollToElement(target, behavior)
      return
    }

-    input.follow.toBottom()
+    input.autoScroll.forceScrollToBottom()
    const el = input.scroller()
    if (el) input.scheduleScrollState(el)
  }
@@ -166,7 +166,7 @@ export const useSessionHashScroll = (input: {
    if (pending) input.setPendingMessage(undefined)
    if (input.currentMessageId() === targetId && !pending) return

-    input.follow.unpin()
+    input.autoScroll.pause()
    cancel()
    queue(() => scrollToMessage(msg, "auto"))
  })
@@ -7,7 +7,7 @@ import { TextInput } from "@opencode-ai/ui/text-input"
 import { useLanguage } from "@/runtime/i18n/language"
 import { usePlatform } from "@/runtime/platform/platform"
 import { useUpdaterAction } from "@/shell/updates/action"
-import { type TerminalPlacement, type WorkspaceDefaultDestination, useSettings } from "@/settings/model"
+import { type WorkspaceDefaultDestination, useSettings } from "@/settings/model"
 import { ExternalLink } from "@/runtime/platform/external-link"
 import { SettingsList } from "@/settings/list"
 import { SettingsRow } from "@/settings/row"
@@ -123,33 +123,6 @@ const ShellSetting: Component<{ controller: ShellSettingsController }> = (props)
  )
 }

-const TerminalPlacementSetting: Component = () => {
-  const language = useLanguage()
-  const settings = useSettings()
-  const options = createMemo((): { value: TerminalPlacement; label: string }[] => [
-    { value: "side", label: language.t("settings.general.row.terminalPlacement.side") },
-    { value: "bottom", label: language.t("settings.general.row.terminalPlacement.bottom") },
-  ])
-
-  return (
-    <SettingsRow
-      title={language.t("settings.general.row.terminalPlacement.title")}
-      description={language.t("settings.general.row.terminalPlacement.description")}
-    >
-      <Select
-        data-action="settings-terminal-placement"
-        options={options()}
-        current={options().find((option) => option.value === settings.general.terminalPlacement())}
-        value={(option) => option.value}
-        label={(option) => option.label}
-        placement="bottom-end"
-        gutter={6}
-        onSelect={(option) => option && settings.general.setTerminalPlacement(option.value)}
-      />
-    </SettingsRow>
-  )
-}
-
 const AppearanceSection: Component<{ controller: AppearanceSettingsController }> = (props) => {
  const language = useLanguage()
  return (
@@ -300,7 +273,6 @@ export const SettingsGeneral: Component<{
        <PermissionScopeSetting controller={permissionScope} />

        <ShellSetting controller={shell} />
-        <TerminalPlacementSetting />

        <SettingsRow
          title={language.t("settings.general.row.reasoningSummaries.title")}
@@ -338,20 +310,6 @@ export const SettingsGeneral: Component<{
          </div>
        </SettingsRow>

-        <Show when={import.meta.env.VITE_OPENCODE_CHANNEL !== "prod"}>
-          <SettingsRow
-            title={language.t("settings.general.row.showProjectIcon.title")}
-            description={language.t("settings.general.row.showProjectIcon.description")}
-          >
-            <div data-action="settings-show-project-icon">
-              <Switch
-                checked={settings.general.showProjectIcon()}
-                onChange={(checked) => settings.general.setShowProjectIcon(checked)}
-              />
-            </div>
-          </SettingsRow>
-        </Show>
-
        <Show when={mobile() && import.meta.env.VITE_OPENCODE_CHANNEL !== "prod"}>
          <SettingsRow
            title={language.t("settings.general.row.mobileTitlebarBottom.title")}
@@ -6,7 +6,6 @@ import { ScopedKey, type ServerScope } from "@/runtime/server/scope"

 export type WorkspaceDefaultDestination = "last-used" | "local" | "new"
 export type WorkspaceLastUsed = "local" | "workspace"
-export type TerminalPlacement = "side" | "bottom"

 export interface NotificationSettings {
  agent: boolean
@@ -31,14 +30,12 @@ export interface Settings {
    showNavigation: boolean
    showSearch: boolean
    showStatus: boolean
-    showProjectIcon: boolean
    showTerminal: boolean
    showReasoningSummaries: boolean
    shellToolPartsExpanded: boolean
    editToolPartsExpanded: boolean
    showCustomAgents: boolean
    mobileTitlebarPosition: "top" | "bottom"
-    terminalPlacement: TerminalPlacement
  }
  appearance: {
    fontSize: number
@@ -118,14 +115,12 @@ const defaultSettings: Settings = {
    showNavigation: false,
    showSearch: false,
    showStatus: false,
-    showProjectIcon: false,
    showTerminal: false,
    showReasoningSummaries: false,
    shellToolPartsExpanded: false,
    editToolPartsExpanded: false,
    showCustomAgents: false,
    mobileTitlebarPosition: "top",
-    terminalPlacement: "side",
  },
  appearance: {
    fontSize: 14,
@@ -209,10 +204,6 @@ export const { use: useSettings, provider: SettingsProvider } = createSimpleCont
        setShowStatus(value: boolean) {
          setStore("general", "showStatus", value)
        },
-        showProjectIcon: withFallback(() => store.general?.showProjectIcon, defaultSettings.general.showProjectIcon),
-        setShowProjectIcon(value: boolean) {
-          setStore("general", "showProjectIcon", value)
-        },
        showTerminal: withFallback(() => store.general?.showTerminal, defaultSettings.general.showTerminal),
        setShowTerminal(value: boolean) {
          setStore("general", "showTerminal", value)
@@ -249,13 +240,6 @@ export const { use: useSettings, provider: SettingsProvider } = createSimpleCont
        setMobileTitlebarPosition(value: "top" | "bottom") {
          setStore("general", "mobileTitlebarPosition", value)
        },
-        terminalPlacement: withFallback(
-          () => store.general?.terminalPlacement,
-          defaultSettings.general.terminalPlacement,
-        ),
-        setTerminalPlacement(value: TerminalPlacement) {
-          setStore("general", "terminalPlacement", value)
-        },
      },
      visibility: {
        fileTree: showFileTree,
@@ -134,7 +134,7 @@
  font-style: normal;
  font-size: 13px;
  font-weight: 530;
-  line-height: var(--line-height-compact);
+  line-height: 1;
  letter-spacing: -0.04px;
  color: var(--v2-text-text-base);
  font-variation-settings: "slnt" 0;
@@ -281,7 +281,7 @@
  padding-block: 20px;
  font-size: 13px;
  font-weight: 440;
-  line-height: var(--line-height-compact);
+  line-height: 1;
  color: var(--v2-text-text-muted);
 }

@@ -289,7 +289,7 @@
  padding-inline-end: 12px;
  font-size: 13px;
  font-weight: 440;
-  line-height: var(--line-height-compact);
+  line-height: 1;
  color: var(--v2-text-text-muted);
  opacity: 0;
  transition: opacity 200ms ease;
@@ -307,7 +307,7 @@
  background: transparent;
  font-size: 13px;
  font-weight: 530;
-  line-height: var(--line-height-compact);
+  line-height: 1;
  color: var(--v2-text-text-accent);
  cursor: pointer;
  text-align: start;
@@ -329,7 +329,7 @@
  padding-bottom: 0;
  font-size: 13px;
  font-weight: 530;
-  line-height: var(--line-height-compact);
+  line-height: 1;
 }

 .settings-providers .settings-section-title + [data-component="settings-list"] {
@@ -478,7 +478,7 @@
  padding-block: 48px;
  font-size: 13px;
  font-weight: 440;
-  line-height: var(--line-height-compact);
+  line-height: 1;
  color: var(--v2-text-text-muted);
  text-align: center;
 }
@@ -495,7 +495,7 @@
  padding-bottom: 0;
  font-size: 13px;
  font-weight: 530;
-  line-height: var(--line-height-compact);
+  line-height: 1;
 }

 .settings-shortcuts [data-component="settings-list"] {
@@ -525,7 +525,7 @@
 .settings-shortcuts [data-component="settings-list"] > div > span {
  font-weight: 440;
  font-size: 13px;
-  line-height: var(--line-height-compact);
+  line-height: 1;
  letter-spacing: -0.04px;
  color: var(--v2-text-text-base);
  font-variation-settings: "slnt" 0;
@@ -577,7 +577,7 @@
  padding-block: 48px;
  font-size: 13px;
  font-weight: 440;
-  line-height: var(--line-height-compact);
+  line-height: 1;
  color: var(--v2-text-text-muted);
  text-align: center;
 }
@@ -654,7 +654,7 @@
 .settings-servers-name {
  font-size: 13px;
  font-weight: 530;
-  line-height: var(--line-height-compact);
+  line-height: 1;
  color: var(--v2-text-text-base);
 }

@@ -674,7 +674,7 @@
  padding-block: 48px;
  font-size: 13px;
  font-weight: 440;
-  line-height: var(--line-height-compact);
+  line-height: 1;
  color: var(--v2-text-text-muted);
  text-align: center;
 }
@@ -784,7 +784,7 @@
  font-family: inherit;
  font-size: 13px;
  font-weight: 530;
-  line-height: var(--line-height-compact);
+  line-height: 1;
  letter-spacing: -0.04px;
  text-overflow: ellipsis;
  white-space: nowrap;
@@ -796,7 +796,7 @@
 .settings-workspaces-meta {
  font-size: 13px;
  font-weight: 440;
-  line-height: var(--line-height-compact);
+  line-height: 1;
  color: var(--v2-text-text-faint);
 }

@@ -856,7 +856,7 @@
  padding-block: 48px;
  font-size: 13px;
  font-weight: 440;
-  line-height: var(--line-height-compact);
+  line-height: 1;
  color: var(--v2-text-text-muted);
 }

@@ -933,7 +933,7 @@
 .settings-server-dialog-label {
  font-size: 13px;
  font-weight: 530;
-  line-height: var(--line-height-compact);
+  line-height: 1;
  color: var(--v2-text-text-base);
 }

@@ -124,7 +124,7 @@
  color: var(--v2-text-text-base);
  font-size: 13px;
  font-weight: 530;
-  line-height: var(--line-height-compact);
+  line-height: 1;
 }

 .project-settings-extension-section-header > :last-child {
@@ -96,7 +96,7 @@ function ProjectSettingsDialog(props: { project: LocalProject; server: ServerCon
              </Field>

              <div class="flex w-full flex-col gap-2">
-                <div class="select-none text-[13px] font-[530] leading-text-compact tracking-[-0.04px] text-v2-text-text-base">
+                <div class="select-none text-[13px] font-[530] leading-none tracking-[-0.04px] text-v2-text-text-base">
                  {language.t("dialog.project.edit.icon")}
                </div>
                <div class="flex items-center gap-3">
@@ -150,7 +150,7 @@ function ProjectSettingsDialog(props: { project: LocalProject; server: ServerCon

              <Show when={!model.store.iconOverride}>
                <div class="flex w-full flex-col gap-2">
-                  <div class="select-none text-[13px] font-[530] leading-text-compact tracking-[-0.04px] text-v2-text-text-base">
+                  <div class="select-none text-[13px] font-[530] leading-none tracking-[-0.04px] text-v2-text-text-base">
                    {language.t("dialog.project.edit.color")}
                  </div>
                  <div class="-ml-1 flex gap-1.5">
@@ -88,9 +88,9 @@ function Cell(props: {
        </div>
        <div
          classList={{
-            "uppercase font-bold tabular-nums": true,
-            "text-[11px] leading-text-tight": !!props.inline,
-            "text-[13px] leading-text-compact sm:text-[14px]": !props.inline,
+            "uppercase leading-none font-bold tabular-nums": true,
+            "text-[11px]": !!props.inline,
+            "text-[13px] sm:text-[14px]": !props.inline,
            "text-text-on-critical-base": !!props.bad,
            "opacity-70": !!props.dim,
          }}
@@ -1,10 +1,9 @@
 import { Route, useParams } from "@solidjs/router"
-import { createMemo, lazy, Show, Suspense, type ParentProps } from "solid-js"
+import { createMemo, lazy, Show, type ParentProps } from "solid-js"
 import { Home } from "@/home/route"
 import { ServerProvider } from "@/runtime/server/current"
 import { useGlobal } from "@/runtime/server/runtime"
 import { ServerConnection } from "@/runtime/server/registry"
-import { SessionPanelFrame, SessionRouteFrame } from "@/session/session-frame"
 import { LayoutProvider } from "@/shell/state/layout"
 import Shell from "@/shell/shell"
 import { requireServerKey } from "./session"
@@ -32,19 +31,9 @@ export function AppRoutes() {
      <Route
        path="/server/:serverKey/session/:id"
        component={() => (
-          <SessionRouteFrame>
-            <Suspense
-              fallback={
-                <div class="flex min-h-0 flex-1 p-2">
-                  <SessionPanelFrame raised />
-                </div>
-              }
-            >
-              <TargetServerRoute>
-                <TargetSessionRouteContent />
-              </TargetServerRoute>
-            </Suspense>
-          </SessionRouteFrame>
+          <TargetServerRoute>
+            <TargetSessionRouteContent />
+          </TargetServerRoute>
        )}
      />
      <Route path="/new-session" component={DraftRoute} />
@@ -88,7 +88,7 @@
  [data-slot="server"] {
    font-weight: 440;
    font-size: 13px;
-    line-height: var(--line-height-compact);
+    line-height: 1;
    letter-spacing: -0.04px;
    color: var(--v2-text-text-muted);
    overflow: hidden;
@@ -27,68 +27,6 @@ test("end anchoring survives consecutive resizes when the first scroll write is
  expect(writes).toEqual([{ offset: 120, adjustments: 80 }])
 })

-test("start anchoring preserves a stable visible item across prepends", () => {
-  const root = document.createElement("div")
-  const writes: number[] = []
-  const options = (keys: string[]) => ({
-    count: keys.length,
-    estimateSize: () => 50,
-    initialOffset: 50,
-    initialRect: { width: 400, height: 100 },
-    anchorTo: "start" as const,
-    getItemKey: (index: number) => keys[index]!,
-    getScrollElement: () => root,
-    scrollToFn: (offset: number) => writes.push(offset),
-    observeElementRect: () => {},
-    observeElementOffset: (_element: HTMLDivElement, callback: (offset: number, isScrolling: boolean) => void) => {
-      callback(50, false)
-    },
-  })
-  const virtualizer = new Virtualizer<HTMLDivElement, HTMLDivElement>(options(["c", "d", "e"]))
-  virtualizer._willUpdate()
-  virtualizer.getVirtualItems()
-
-  virtualizer.setOptions(options(["a", "b", "c", "d", "e"]))
-  virtualizer._willUpdate()
-
-  expect(virtualizer.getScrollOffset()).toBe(150)
-  expect(writes.at(-1)).toBe(150)
-})
-
-// A pagination boundary can re-key the row at the viewport top when the truncated
-// leading turn regroups under its freshly loaded user message. The anchor must fall
-// back to the next surviving key instead of leaving the offset on the new content.
-test("prepend anchoring survives when the nearest keys are re-keyed", () => {
-  const root = document.createElement("div")
-  const writes: number[] = []
-  const options = (keys: string[]) => ({
-    count: keys.length,
-    estimateSize: () => 50,
-    initialOffset: 50,
-    initialRect: { width: 400, height: 100 },
-    anchorTo: "start" as const,
-    getItemKey: (index: number) => keys[index]!,
-    getScrollElement: () => root,
-    scrollToFn: (offset: number) => writes.push(offset),
-    observeElementRect: () => {},
-    observeElementOffset: (_element: HTMLDivElement, callback: (offset: number, isScrolling: boolean) => void) => {
-      callback(50, false)
-    },
-  })
-  // Viewport sits at offset 50: rows "orphan-c" (anchor) and "d" visible.
-  const virtualizer = new Virtualizer<HTMLDivElement, HTMLDivElement>(options(["orphan-c", "d", "e"]))
-  virtualizer._willUpdate()
-  virtualizer.getVirtualItems()
-
-  // Prepend re-keys the boundary row ("orphan-c" -> "c") while "d" and "e" survive.
-  virtualizer.setOptions(options(["a", "b", "c", "d", "e"]))
-  virtualizer._willUpdate()
-
-  // "d" was 50px below the anchor at old start 50; restored at new start 150 => offset 150.
-  expect(virtualizer.getScrollOffset()).toBe(150)
-  expect(writes.at(-1)).toBe(150)
-})
-
 test("reactive count updates preserve measured row sizes", () => {
  createRoot((dispose) => {
    const [count, setCount] = createSignal(2)
@@ -1,6 +1,5 @@
 import { sentryVitePlugin } from "@sentry/vite-plugin"
 import { defineConfig } from "vite"
-import { VitePWA } from "vite-plugin-pwa"
 import desktopPlugin from "./vite.js"

 const sentry =
@@ -21,48 +20,7 @@ const sentry =
    : false

 export default defineConfig({
-  plugins: [
-    desktopPlugin,
-    VitePWA({
-      strategies: "generateSW",
-      injectRegister: false,
-      manifest: false,
-      workbox: {
-        cleanupOutdatedCaches: true,
-        clientsClaim: true,
-        inlineWorkboxRuntime: true,
-        navigateFallback: "/index.html",
-        navigateFallbackDenylist: [/^\/api(?:\/|$)/],
-        globPatterns: [
-          "index.html",
-          "site.webmanifest",
-          "favicon*",
-          "apple-touch-icon*",
-          "web-app-manifest*",
-          "assets/index-*.{js,css}",
-          "assets/session-*.js",
-          "assets/Inter.ttf",
-          "assets/JetBrainsMonoNerdFontMono-Regular.woff2",
-        ],
-        runtimeCaching: [
-          {
-            urlPattern: ({ url }) => url.origin === self.location.origin && url.pathname.startsWith("/assets/"),
-            handler: "CacheFirst",
-            options: {
-              cacheName: "opencode-assets",
-              cacheableResponse: {
-                statuses: [200],
-              },
-              expiration: {
-                maxEntries: 1000,
-              },
-            },
-          },
-        ],
-      },
-    }),
-    sentry,
-  ] as any,
+  plugins: [desktopPlugin, sentry] as any,
  server: {
    host: "0.0.0.0",
    allowedHosts: true,
@@ -27,9 +27,6 @@ if (outdir === path.join(dir, "dist-node")) {
 const bundleOnly = process.argv.includes("--bundle-only")
 const single = process.argv.includes("--single")
 const skipInstall = process.argv.includes("--skip-install")
-const appArchiveOnly = process.argv.includes("--app-archive-only")
-const requestedArchive = process.argv.find((arg) => arg.startsWith("--app-archive="))?.slice("--app-archive=".length)
-const archivePath = requestedArchive ? path.resolve(dir, requestedArchive) : undefined
 const requested = process.argv.find((arg) => arg.startsWith("--target="))?.slice("--target=".length)
 const allTargets = [
  nodeTarget("linux", "arm64"),
@@ -44,14 +41,6 @@ const targets = requested
    ? [nodeTarget(process.platform, process.arch)]
    : allTargets

-process.chdir(dir)
-if (!skipInstall) run(process.execPath, ["install", "--os=*", "--cpu=*"])
-if (appArchiveOnly) {
-  if (!archivePath) throw new Error("--app-archive-only requires --app-archive=<path>")
-  await mkdir(path.dirname(archivePath), { recursive: true })
-  await writeFile(archivePath, await buildAppArchive(Script.channel))
-  process.exit(0)
-}
 if (targets.length === 0) {
  if (requested === "darwin-x64") throw new Error("Node 26.4 SEA does not support macOS x64")
  throw new Error(`Unknown Node target: ${requested}`)
@@ -59,12 +48,15 @@ if (targets.length === 0) {
 if (!bundleOnly && targets.some((target) => target.platform === "darwin" && target.arch === "x64")) {
  throw new Error("Node 26.4 SEA does not support macOS x64")
 }
-const appArchive = archivePath ? (await Bun.file(archivePath).text()).trim() : await buildAppArchive(Script.channel)
+
+process.chdir(dir)
+if (!skipInstall) run(process.execPath, ["install", "--os=*", "--cpu=*"])
 if (!bundleOnly) await rm(outdir, { recursive: true, force: true })
 const builder =
  !bundleOnly || targets.some((target) => target.platform === process.platform && target.arch === process.arch)
    ? await resolveHostNode()
    : undefined
+const appArchive = await buildAppArchive(Script.channel)

 // Vite silently rewrites text imports of known asset types (.txt) to asset
 // URL strings when the raw-text plugin doesn't intercept them first — the
@@ -32,19 +32,16 @@ function serveUI(request: HttpServerRequest.HttpServerRequest, url: URL, assets:
  if (request.method !== "GET" && request.method !== "HEAD")
    return Effect.succeed(HttpServerResponse.empty({ status: 405 }))
  const html = name === "index.html"
-  const revalidate = html || name === "sw.js" || name === "registerSW.js"
  const headers = {
    "content-type": FSUtil.mimeType(name),
-    "cache-control": revalidate ? "no-cache" : "public, max-age=31536000, immutable",
+    "cache-control": html ? "no-cache" : "public, max-age=31536000, immutable",
    "content-security-policy": html
      ? cspForHtml(typeof file === "string" ? file : Buffer.from(file).toString())
      : csp(),
    "x-content-type-options": "nosniff",
  }
  return Effect.succeed(
-    request.method === "HEAD"
-      ? HttpServerResponse.empty({ headers })
-      : HttpServerResponse.raw(file, { headers, contentType: headers["content-type"] }),
+    request.method === "HEAD" ? HttpServerResponse.empty({ headers }) : HttpServerResponse.raw(file, { headers }),
  )
 }

@@ -20,8 +20,6 @@ describe("web UI", () => {
    const assets = {
      "index.html": await Bun.file(index).text(),
      "app.js": await Bun.file(asset).text(),
-      "sw.js": "service worker",
-      "registerSW.js": "registration",
      "font.woff2": new Uint8Array([0, 1, 2, 255]),
    }

@@ -55,17 +53,8 @@ describe("web UI", () => {

          const script = yield* Effect.promise(() => fetch(`${origin}/app.js`))
          expect(yield* Effect.promise(() => script.text())).toBe("console.log('embedded')")
-          expect(script.headers.get("content-type")).toContain("javascript")
-          expect(script.headers.get("cache-control")).toBe("public, max-age=31536000, immutable")
-
-          const worker = yield* Effect.promise(() => fetch(`${origin}/sw.js`))
-          expect(worker.headers.get("cache-control")).toBe("no-cache")
-
-          const registration = yield* Effect.promise(() => fetch(`${origin}/registerSW.js`))
-          expect(registration.headers.get("cache-control")).toBe("no-cache")

          const font = yield* Effect.promise(() => fetch(`${origin}/font.woff2`))
-          expect(font.headers.get("content-type")).toBe("font/woff2")
          expect(new Uint8Array(yield* Effect.promise(() => font.arrayBuffer()))).toEqual(
            new Uint8Array([0, 1, 2, 255]),
          )
@@ -60,7 +60,6 @@ export type CreateDataInput = {
 }

 const messageIDFromEvent = (eventID: string) => eventID.replace(/^evt_/, "msg_")
-const messagePageLimit = 20

 // Global MCP elicitations temporarily use "global" instead of a real session ID, so the
 // server cannot recover their Location when settling them. Preserve the event Location
@@ -1102,9 +1101,6 @@ export function createData(config: CreateDataInput) {
      get(sessionID: string) {
        return store.session.info[sessionID]
      },
-      creating(sessionID: string) {
-        return creating.has(sessionID)
-      },
      remember(info: SessionInfo) {
        setStore("session", "info", info.id, reconcile(info))
        sync.complete(`session:${info.id}`)
@@ -1319,7 +1315,7 @@ export function createData(config: CreateDataInput) {
        },
        sync(sessionID: string) {
          return sync.run(`session.message:${sessionID}`, async () => {
-            const response = await api().message.list({ sessionID, limit: messagePageLimit, order: "desc" })
+            const response = await api().message.list({ sessionID, limit: 200, order: "desc" })
            const fetched = response.data.toReversed()
            // Same protection as the pending sync: a re-fetch racing an
            // admission must not wipe its local transcript row.
@@ -1349,7 +1345,7 @@ export function createData(config: CreateDataInput) {
          if (!cursor || store.session.messageLoading[sessionID]) return
          setStore("session", "messageLoading", sessionID, true)
          const response = await api()
-            .message.list({ sessionID, limit: messagePageLimit, cursor })
+            .message.list({ sessionID, limit: 200, cursor })
            .finally(() => setStore("session", "messageLoading", sessionID, false))
          const older = response.data.toReversed()
          const existing = store.session.message[sessionID] ?? []
@@ -1,4 +1,4 @@
-import { expect, test } from "bun:test"
+import { test } from "bun:test"
 import { createRoot } from "solid-js"
 import { createData, type CreateDataInput } from "../src/solid"
 import { OpenCode, type OpenCodeEvent, type SessionInfo } from "../src/promise"
@@ -72,69 +72,6 @@ test("revalidates after an event overtakes an active session read", async () =>
  }
 })

-test("reports optimistic sessions as creating until the request settles", async () => {
-  const release = Promise.withResolvers<void>()
-  const api = OpenCode.make({
-    baseUrl: "http://opencode.local",
-    fetch: async (input, init) => {
-      const request = input instanceof Request ? input : new Request(input, init)
-      if (!request.url.endsWith("/api/session")) throw new Error(`Unexpected request: ${request.url}`)
-      await release.promise
-      return Response.json({ data: session(0) })
-    },
-  })
-  const event: CreateDataInput["event"] = {
-    on: () => () => {},
-    listen: () => () => {},
-  }
-  const setup = createRoot((dispose) => ({
-    data: createData({ api: () => api, directory: "/project", event, connection: { status: () => "connected" } }),
-    dispose,
-  }))
-
-  try {
-    const created = setup.data.session.create({ id: "ses_refresh", location: { directory: "/project" } })
-    expect(setup.data.session.creating(created.id)).toBe(true)
-    release.resolve()
-    await created.request
-    expect(setup.data.session.creating(created.id)).toBe(false)
-  } finally {
-    setup.dispose()
-  }
-})
-
-test("loads bounded message pages", async () => {
-  const requests: URL[] = []
-  const api = OpenCode.make({
-    baseUrl: "http://opencode.local",
-    fetch: async (input, init) => {
-      const request = input instanceof Request ? input : new Request(input, init)
-      const url = new URL(request.url)
-      requests.push(url)
-      return Response.json({ data: [], cursor: requests.length === 1 ? { next: "next" } : {} })
-    },
-  })
-  const setup = createRoot((dispose) => ({
-    data: createData({
-      api: () => api,
-      directory: "/project",
-      event: { on: () => () => {}, listen: () => () => {} },
-    }),
-    dispose,
-  }))
-
-  try {
-    await setup.data.session.message.sync("ses_refresh")
-    await setup.data.session.message.loadMore("ses_refresh")
-
-    expect(requests).toHaveLength(2)
-    expect(Object.fromEntries(requests[0].searchParams)).toEqual({ limit: "20", order: "desc" })
-    expect(Object.fromEntries(requests[1].searchParams)).toEqual({ cursor: "next", limit: "20" })
-  } finally {
-    setup.dispose()
-  }
-})
-
 async function wait(check: () => boolean) {
  const started = Date.now()
  while (!check()) {
@@ -1,74 +0,0 @@
-export * as LocationActivity from "./location-activity.js"
-
-import { Clock, Context, Duration, Effect, Layer, RcMap, Schema } from "effect"
-import { Bus } from "./bus.js"
-import { Location } from "./location.js"
-import { LocationServiceMap } from "./location-service-map.js"
-import { SessionEvent } from "./session/event.js"
-import { makeGlobalNode } from "@opencode-ai/util/effect/app-node"
-
-const isSessionEvent = Schema.is(SessionEvent.Durable)
-
-export class Service extends Context.Service<Service, {}>()("@opencode/LocationActivity") {}
-
-export function layer(options: { readonly timeToLive?: Duration.Input; readonly sweepInterval?: Duration.Input } = {}) {
-  return Layer.effect(
-    Service,
-    Effect.gen(function* () {
-      const clock = yield* Clock.Clock
-      const bus = yield* Bus.Service
-      const locations = yield* LocationServiceMap.Service
-      const timeToLive = Duration.toMillis(options.timeToLive ?? "60 minutes")
-      const entries = new Map<string, { readonly ref: Location.Ref; expiresAt: number }>()
-      const key = (ref: Location.Ref) => `${ref.directory}\0${ref.workspaceID ?? ""}`
-      const touch = (ref: Location.Ref) =>
-        Effect.sync(() => {
-          entries.set(key(ref), { ref, expiresAt: clock.currentTimeMillisUnsafe() + timeToLive })
-        })
-
-      const unsubscribe = yield* bus.listen((event) => {
-        if (!isSessionEvent(event)) return Effect.void
-        const location = event.location
-        if (!location) return Effect.void
-        return RcMap.has(locations.rcMap, location).pipe(
-          Effect.flatMap((active) => (active ? touch(location) : Effect.void)),
-        )
-      })
-      yield* Effect.addFinalizer(() => unsubscribe)
-      yield* Effect.gen(function* () {
-        yield* Effect.sleep(options.sweepInterval ?? "1 minute")
-        const refs = Array.from(yield* RcMap.keys(locations.rcMap))
-        const cached = new Set(refs.map(key))
-        yield* Effect.forEach(
-          refs,
-          (ref) => (entries.has(key(ref)) ? Effect.void : touch(ref)),
-          { discard: true },
-        )
-        for (const id of entries.keys()) {
-          if (!cached.has(id)) entries.delete(id)
-        }
-        const now = clock.currentTimeMillisUnsafe()
-        const expired = Array.from(entries.values()).filter((entry) => entry.expiresAt <= now)
-        yield* Effect.forEach(
-          expired,
-          (entry) => {
-            entries.delete(key(entry.ref))
-            return Effect.logInfo("location services evicted", {
-              directory: entry.ref.directory,
-              workspaceID: entry.ref.workspaceID,
-            }).pipe(Effect.andThen(locations.invalidate(entry.ref)))
-          },
-          { discard: true },
-        )
-      }).pipe(Effect.forever, Effect.forkScoped)
-
-      return Service.of({})
-    }),
-  )
-}
-
-export const node = makeGlobalNode({
-  service: Service,
-  layer: layer(),
-  deps: [Bus.node, LocationServiceMap.node],
-})
@@ -1,4 +1,4 @@
-import { Duration, Effect, Layer, LayerMap } from "effect"
+import { Effect, Layer, LayerMap } from "effect"
 import { existsSync } from "fs"
 import path from "path"
 import { Agent } from "./agent.js"
@@ -147,7 +147,7 @@ export function buildLocationServiceMap(
            Layer.provide(LayerNode.compile(location.hoisted)),
          )
        },
-        { idleTimeToLive: (ref) => (existsSync(ref.directory) ? Duration.infinity : Duration.zero) },
+        { idleTimeToLive: (ref) => (existsSync(ref.directory) ? "60 minutes" : 0) },
      ),
      (inner) => ({
        ...inner,
@@ -541,9 +541,6 @@ const decodeCatalog = (text: string) =>
  Schema.decodeUnknownEffect(CatalogJson)(text).pipe(Effect.map((catalog) => catalog as Record<string, SourceProvider>))
 const Cache = Schema.Struct({
  updatedAt: Schema.Number,
-  // Digest of the raw body, persisted so refresh() can skip republishing a
-  // byte-identical catalog. Optional for entries written before it existed.
-  digest: Schema.optional(Schema.String),
  body: CatalogJson,
 })
 const defaultSource = "https://models.opencode.ai"
@@ -571,10 +568,6 @@ function cacheKey(source: string) {
  return `models-dev:catalog:${Hash.fast(source)}`
 }

-export function bodyDigest(text: string) {
-  return new Bun.CryptoHasher("sha256").update(text).digest("hex")
-}
-
 export const layer = (options?: Options) =>
  Layer.effect(
    Service,
@@ -607,11 +600,16 @@ export const layer = (options?: Options) =>
          return {
            catalog: cached.value.body as Record<string, SourceProvider>,
            updatedAt: cached.value.updatedAt,
-            digest: cached.value.digest,
          }
        if (value !== undefined) yield* kv.remove(key)
      })

+      const fresh = Effect.fnUntraced(function* () {
+        const cached = yield* loadFromCache()
+        if (!cached) return false
+        return Date.now() - cached.updatedAt < Duration.toMillis(ttl)
+      })
+
      const fetchApi = Effect.fn("ModelsDev.fetchApi")(function* () {
        return yield* HttpClientRequest.get(`${source}/api.json`).pipe(
          HttpClientRequest.setHeader("User-Agent", userAgent),
@@ -632,23 +630,19 @@ export const layer = (options?: Options) =>
      // periodic fetch below still refreshes on top.
      const loadSnapshot = options?.snapshot === false ? Effect.undefined : bundledSnapshot

-      // Best-effort: a cache-write failure must never kill catalog
-      // population. The payload has outgrown some KV backends' per-value
-      // limits (Durable Object SQLite caps values at 2 MB and api.json
-      // passed it in Aug 2026); a boot without a cache hit just refetches.
-      const writeCache = Effect.fn("ModelsDev.writeCache")(function* (text: string) {
-        yield* kv.set(key, { updatedAt: Date.now(), digest: bodyDigest(text), body: text }).pipe(
+      const fetchAndWrite = Effect.fn("ModelsDev.fetchAndWrite")(function* () {
+        const text = yield* fetchApi()
+        const catalog = yield* decodeCatalog(text)
+        // Best-effort: a cache-write failure must never kill catalog
+        // population. The payload has outgrown some KV backends' per-value
+        // limits (Durable Object SQLite caps values at 2 MB and api.json
+        // passed it in Aug 2026); a boot without a cache hit just refetches.
+        yield* kv.set(key, { updatedAt: Date.now(), body: text }).pipe(
          Effect.catchCauseIf(
            (cause) => !Cause.hasInterruptsOnly(cause),
            (cause) => Effect.logWarning("Failed to cache models.dev catalog", { cause }),
          ),
        )
-      })
-
-      const fetchAndWrite = Effect.fn("ModelsDev.fetchAndWrite")(function* () {
-        const text = yield* fetchApi()
-        const catalog = yield* decodeCatalog(text)
-        yield* writeCache(text)
        return catalog
      })

@@ -678,15 +672,8 @@ export const layer = (options?: Options) =>
        yield* lock
          .withPermit(
            Effect.gen(function* () {
-              const stored = yield* loadFromCache()
-              if (!force && stored && Date.now() - stored.updatedAt < Duration.toMillis(ttl)) return
-              const text = yield* fetchApi()
-              // models.dev rarely changes between polls; skip the cache write,
-              // invalidation, and Refreshed event for a byte-identical body so
-              // downstream catalog.updated listeners stay quiet.
-              if (!force && stored?.digest === bodyDigest(text)) return
-              yield* decodeCatalog(text)
-              yield* writeCache(text)
+              if (!force && (yield* fresh())) return
+              yield* fetchAndWrite()
              yield* invalidate
              yield* bus.publish(ModelsDev.Event.Refreshed, {})
            }),
@@ -130,7 +130,7 @@ secret into configuration.
 For any request to migrate OpenCode configuration, agents, commands, skills,
 plugins, integrations, or other behavior from V1 to V2, read the full
 [migration guide](https://opencode.ai/v2/docs/migrate-v1) before acting. In
-the repository, its source is `packages/www/src/docs/content/migrate-v1.mdx`.
+the repository, its source is `packages/www/content/docs/migrate-v1.mdx`.

 V1 config files and `.opencode/` definitions are intended to remain compatible.
 The only intentional breaking changes are the server API and plugin API. Native
@@ -3,16 +3,14 @@ import path from "path"
 import { describe, expect } from "bun:test"
 import { Config } from "@opencode-ai/schema/config"
 import { Money } from "@opencode-ai/schema/money"
-import { DateTime, Deferred, Duration, Effect, Equal, Fiber, Hash, Layer, LayerMap, RcMap, Schema, Stream } from "effect"
-import { TestClock } from "effect/testing"
+import { DateTime, Deferred, Effect, Equal, Fiber, Hash, RcMap, Schema, Stream } from "effect"
 import { Plugin as EffectPlugin } from "@opencode-ai/plugin/effect"
 import { Agent } from "@opencode-ai/core/agent"
 import { Catalog } from "@opencode-ai/core/catalog"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { LayerNode } from "@opencode-ai/util/effect/layer-node"
 import { Global } from "@opencode-ai/util/global"
-import { LocationServiceMap, type LocationServices } from "@opencode-ai/core/location-services"
-import { LocationActivity } from "@opencode-ai/core/location-activity"
+import { LocationServiceMap } from "@opencode-ai/core/location-services"
 import { Location } from "@opencode-ai/core/location"
 import { Plugin } from "@opencode-ai/core/plugin"
 import { SdkPlugins } from "@opencode-ai/core/plugin/sdk"
@@ -23,7 +21,6 @@ import { Project } from "@opencode-ai/core/project"
 import { Provider } from "@opencode-ai/core/provider"
 import { AbsolutePath } from "@opencode-ai/core/schema"
 import { Session } from "@opencode-ai/core/session"
-import { SessionEvent } from "@opencode-ai/core/session/event"
 import { SessionRunnerModel } from "@opencode-ai/core/session/runner/model"
 import { tmpdir } from "./fixture/tmpdir"
 import { tempGlobalLayer } from "./fixture/global"
@@ -44,55 +41,8 @@ const itWithSdk = testEffect(
    [Global.node, tempGlobalLayer],
  ]),
 )
-const activityLocations = Layer.effect(
-  LocationServiceMap.Service,
-  LayerMap.make(
-    (ref) =>
-      // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion
-      Layer.succeed(
-        Location.Service,
-        Location.Service.of({
-          directory: ref.directory,
-          workspaceID: ref.workspaceID,
-          project: { id: Project.ID.global, directory: ref.directory, canonical: ref.directory },
-        }),
-      ) as unknown as Layer.Layer<LocationServices>,
-    { idleTimeToLive: Duration.infinity },
-  ),
-)
-const itWithActivity = testEffect(
-  AppNodeBuilder.build(
-    LayerNode.group([Database.node, Bus.node, LocationServiceMap.node, LocationActivity.node]),
-    [[LocationServiceMap.node, activityLocations]],
-  ),
-)

 describe("LocationServiceMap", () => {
-  itWithActivity.effect("refreshes lifetime from Session events only", () =>
-    Effect.gen(function* () {
-      const locations = yield* LocationServiceMap.Service
-      const bus = yield* Bus.Service
-      const ref = Location.Ref.make({ directory: AbsolutePath.make("/project") })
-      const sessionID = Session.ID.make("ses_location_activity")
-      const read = Location.Service.pipe(Effect.provide(locations.get(ref)), Effect.scoped)
-
-      yield* read
-      yield* TestClock.adjust("59 minutes")
-      yield* bus.publish(Catalog.Event.Updated, {}, { location: ref })
-      yield* TestClock.adjust("2 minutes")
-      expect(Array.from(yield* RcMap.keys(locations.rcMap))).toEqual([])
-
-      yield* read
-      yield* bus.publish(SessionEvent.Execution.Started, { sessionID }, { location: ref })
-      yield* TestClock.adjust("59 minutes")
-      yield* bus.publish(SessionEvent.Execution.Succeeded, { sessionID }, { location: ref })
-      yield* TestClock.adjust("1 minute")
-      expect(Array.from(yield* RcMap.keys(locations.rcMap))).toEqual([ref])
-      yield* TestClock.adjust("59 minutes")
-      expect(Array.from(yield* RcMap.keys(locations.rcMap))).toEqual([])
-    }),
-  )
-
  it.live("retries a location after its missing directory is recreated", () =>
    Effect.acquireRelease(
      Effect.promise(() => tmpdir()),
@@ -1,14 +1,13 @@
 import { describe, expect, test } from "bun:test"
 import { Money } from "@opencode-ai/schema/money"
-import { Effect, Fiber, Layer, Ref, Scope, Stream } from "effect"
+import { Effect, Layer, Ref } from "effect"
 import { HttpClient, HttpClientResponse } from "effect/unstable/http"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { LayerNodePlatform } from "@opencode-ai/util/effect/app-node-platform"
 import { LayerNode } from "@opencode-ai/util/effect/layer-node"
-import { Bus } from "@opencode-ai/core/bus"
 import { KV } from "@opencode-ai/core/kv"
 import { Model } from "@opencode-ai/core/model"
-import { bodyDigest, ModelsDev } from "@opencode-ai/core/models-dev"
+import { ModelsDev } from "@opencode-ai/core/models-dev"
 import { Provider } from "@opencode-ai/core/provider"
 import { it } from "./lib/effect"

@@ -181,7 +180,7 @@ const buildLayer = (state: Ref.Ref<MockState>, cache: MockCache, options: Models
  // and Effect.provide uses a process-global MemoMap by default — without fresh,
  // every test would reuse the cachedInvalidateWithTTL state from the first run.
  Layer.fresh(
-    AppNodeBuilder.build(LayerNode.group([ModelsDev.node, Bus.node]), [
+    AppNodeBuilder.build(ModelsDev.node, [
      [ModelsDev.node, ModelsDev.configured(options)],
      [LayerNodePlatform.httpClient, Layer.succeed(HttpClient.HttpClient, makeMockClient(state))],
      [KV.node, makeMockKV(cache)],
@@ -200,16 +199,13 @@ const makeFailingWriteKV = (cache: MockCache) =>
 const makeCache = (): MockCache => ({ values: new Map() })

 const writeCacheText = (cache: MockCache, text: string, updatedAt = Date.now()) =>
-  cache.values.set(cacheKey, { updatedAt, digest: bodyDigest(text), body: text })
+  cache.values.set(cacheKey, { updatedAt, body: text })

 const writeCache = (cache: MockCache, data: object, updatedAt?: number) =>
  writeCacheText(cache, JSON.stringify(data), updatedAt)

-const provided = <A, E>(
-  state: Ref.Ref<MockState>,
-  cache: MockCache,
-  eff: Effect.Effect<A, E, ModelsDev.Service | Bus.Service | Scope.Scope>,
-) => eff.pipe(Effect.provide(buildLayer(state, cache)))
+const provided = <A, E>(state: Ref.Ref<MockState>, cache: MockCache, eff: Effect.Effect<A, E, ModelsDev.Service>) =>
+  eff.pipe(Effect.provide(buildLayer(state, cache)))

 const initialState: MockState = {
  body: JSON.stringify(fixture),
@@ -395,20 +391,7 @@ describe("ModelsDev Service", () => {
        cache,
        Effect.gen(function* () {
          const svc = yield* ModelsDev.Service
-          const bus = yield* Bus.Service
-          const refreshed = yield* bus.subscribe(ModelsDev.Event.Refreshed).pipe(
-            Stream.take(1),
-            Stream.runCollect,
-            Effect.forkScoped,
-            Effect.flatMap((fiber) =>
-              Effect.gen(function* () {
-                yield* Effect.yieldNow
-                yield* svc.refresh(false)
-                return yield* Fiber.join(fiber)
-              }),
-            ),
-          )
-          expect(refreshed.length).toBe(1)
+          yield* svc.refresh(false)
          return yield* svc.get()
        }),
      )
@@ -418,72 +401,6 @@ describe("ModelsDev Service", () => {
    }),
  )

-  it.live("refresh(false) stays quiet when the fetched body matches the cached digest", () =>
-    Effect.gen(function* () {
-      const cache = makeCache()
-      writeCache(cache, fixture, Date.now() - 10 * 60 * 1000)
-      const seeded = structuredClone(cache.values.get(cacheKey))
-      // The server serves a byte-identical body, so the refresh still hits
-      // the network but must not rewrite the cache or publish Refreshed.
-      const state = yield* Ref.make(initialState)
-      yield* provided(
-        state,
-        cache,
-        Effect.gen(function* () {
-          const svc = yield* ModelsDev.Service
-          const bus = yield* Bus.Service
-          const event = yield* bus.subscribe(ModelsDev.Event.Refreshed).pipe(
-            Stream.take(1),
-            Stream.runCollect,
-            Effect.forkScoped,
-            Effect.flatMap((fiber) =>
-              Effect.gen(function* () {
-                yield* Effect.yieldNow
-                yield* svc.refresh(false)
-                return yield* Fiber.join(fiber).pipe(Effect.timeoutOption("50 millis"))
-              }),
-            ),
-          )
-          expect(event._tag).toBe("None")
-        }),
-      )
-      const final = yield* Ref.get(state)
-      expect(final.calls.length).toBe(1)
-      expect(cache.values.get(cacheKey)).toEqual(seeded)
-    }),
-  )
-
-  it.live("refresh(false) republishes once for legacy cache entries without a digest", () =>
-    Effect.gen(function* () {
-      const cache = makeCache()
-      cache.values.set(cacheKey, { updatedAt: Date.now() - 10 * 60 * 1000, body: JSON.stringify(fixture) })
-      const state = yield* Ref.make(initialState)
-      yield* provided(
-        state,
-        cache,
-        Effect.gen(function* () {
-          const svc = yield* ModelsDev.Service
-          const bus = yield* Bus.Service
-          const refreshed = yield* bus.subscribe(ModelsDev.Event.Refreshed).pipe(
-            Stream.take(1),
-            Stream.runCollect,
-            Effect.forkScoped,
-            Effect.flatMap((fiber) =>
-              Effect.gen(function* () {
-                yield* Effect.yieldNow
-                yield* svc.refresh(false)
-                return yield* Fiber.join(fiber)
-              }),
-            ),
-          )
-          expect(refreshed.length).toBe(1)
-        }),
-      )
-      // The rewritten entry now carries a digest, so later identical bodies stay quiet.
-      expect(cache.values.get(cacheKey)).toMatchObject({ digest: bodyDigest(JSON.stringify(fixture)) })
-    }),
-  )
-
  it.live("refresh swallows HTTP errors and leaves cache intact", () =>
    Effect.gen(function* () {
      const cache = makeCache()
@@ -878,6 +878,7 @@ describe("ShellTool", () => {
        ),
      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]().then(() => undefined)),
    ),
+    { timeout: 15_000 },
  )

  if (!isWindows) {
--- a/Show More
+++ b/Show More