test(server): update instance fixture replacement syntax

Replace exposed layer graph assembly with opaque declarations, checked substitutions, and lifetime-aware compilation. Preserve deep replacement, ordered startup, and Effect-owned resource lifetimes; migrate callers and verify source and published package contracts.

nix/hashes.json

@@ -1,8 +1,8 @@
 {
   "nodeModules": {
-    "x86_64-linux": "sha256-fG6VYtNC0pce4VM9po7vVucPuJul42yuuijTjNSr7rk=",
-    "aarch64-linux": "sha256-3TznrmNqdt25cOxia6vcdi/5qKaeyLPIsNXGYBSJNrs=",
-    "aarch64-darwin": "sha256-8Kmagb5tfECSWZNsIJgrRP1d3X5tuEoWLEWkV3UENZo=",
-    "x86_64-darwin": "sha256-mIV+mDwIGD02BNYZVi37sY4ls1T01N6z76eBtH0sKiA="
+    "x86_64-linux": "sha256-JStMvgtXBA5GrhyBJ5FtdqD8LWkcaPA9NXef+c2xUzw=",
+    "aarch64-linux": "sha256-WQxF+yS0ZImW0KW620XnZUBsKAJDoJ1jLDOMBaXI2/E=",
+    "aarch64-darwin": "sha256-km7G6s45dfFdW3Z6lFrs4NohD+vmwN1vR8PmEL0WCto=",
+    "x86_64-darwin": "sha256-YFbkcHpuspgTp+B+th3IJ3cnu5C2gEUSiy3NDXpD8UA="
   }
 }

packages/ai/README.md

@@ -249,107 +249,6 @@ The published legacy `Service`, `layer`, `clientLayer`, and module-level control
 over the same implementation, including the legacy live `requests` array. New tests should use `Test` and
 `testLayer`.
 
-## Provider compaction
-
-Compaction is opt-in. The package supports automatic compaction in OpenAI/Azure Responses and Anthropic Messages (including Claude on Vertex and Bedrock Messages), and explicit compaction calls in OpenAI/Azure/xAI Responses. Model and deployment support still depends on the provider.
-
-This is different from prompt caching, server-side history storage, or truncation. Compaction returns provider-owned context that must be replayed to continue the conversation.
-
-### Automatic compaction
-
-Inside an `Effect.gen`, enable OpenAI compaction with typed provider options:
-
-```ts
-import { LLM, LLMClient, LLMRequest, Message } from "@opencode-ai/ai"
-import { OpenAI } from "@opencode-ai/ai/providers"
-
-const request = LLM.request({
-  model: OpenAI.configure({ apiKey }).responses("gpt-5.3-codex"),
-  messages,
-  providerOptions: {
-    contextManagement: [{ type: "compaction", compactThreshold: 200_000 }],
-  },
-})
-const response = yield * LLMClient.generate(request)
-const next = LLMRequest.update(request, {
-  messages: [...request.messages, response.message, Message.user("Continue")],
-})
-```
-
-`store: false` remains the default. Keep the entire `response.message`, not just `response.text`. Compaction events become ordered `CompactionPart`s alongside text and reasoning. The conversation contains everything needed to continue; there is no separate replay object or hidden provider transcript.
-
-A compaction part has `provider` and exactly one representation: `encrypted` for Responses, or `text` for Anthropic. Responses also preserves the optional checkpoint `id`. These fields survive message serialization without becoming visible assistant text. Sending a checkpoint to another provider or an incompatible API fails rather than silently losing context.
-
-```ts
-import { CompactionPart, ProviderID } from "@opencode-ai/ai"
-
-CompactionPart.make({ provider: ProviderID.make("openai"), id: "cmp_123", encrypted: "..." })
-CompactionPart.make({ provider: ProviderID.make("anthropic"), text: "Summary of the conversation..." })
-```
-
-For Anthropic, use:
-
-```ts
-providerOptions: {
-  contextManagement: {
-    edits: [{
-      type: "compact_20260112",
-      trigger: { type: "input_tokens", value: 150_000 },
-      pauseAfterCompaction: true,
-      instructions: "Summarize the task and decisions. Do not call tools while summarizing.",
-    }],
-  },
-}
-```
-
-- The trigger is optional (provider default: 150,000 tokens), with a minimum of 50,000.
-- Custom instructions replace Anthropic's default summarization instructions.
-- The route adds `compact-2026-01-12` to existing beta headers, including when replaying a checkpoint without enabling new compactions.
-- A pause is exposed as `response.finishReason.raw === "compaction"`. The caller explicitly issues the next request; the package never automatically resumes.
-- Anthropic can return a compaction block with `content: null` when summarization fails. This becomes a compaction part with `text: null`, which is **not** a successful replacement for prior history. The package never prunes history automatically.
-- `Usage` totals include all reported Anthropic `usage.iterations`, including compaction. `contextTokens` separately reports the final message iteration's inclusive input size, when available. A compaction-only pause does not report a post-compaction context size. Raw iteration usage remains in `providerMetadata`.
-
-Bedrock's Converse API does not support this feature. Select the native Claude Messages route explicitly; the default `.model(...)` remains Converse:
-
-```ts
-import { AmazonBedrock } from "@opencode-ai/ai/providers"
-
-const model = AmazonBedrock.configure({ region: "us-east-1", credentials }).messages("us.anthropic.claude-opus-4-6-v1")
-```
-
-The corresponding package entrypoint is `@opencode-ai/ai/providers/amazon-bedrock/messages`. It uses InvokeModelWithResponseStream, AWS event-stream framing, bearer or SigV4 auth, and `anthropic_beta` in the request body.
-
-### Explicit compaction
-
-`LLMClient.compact(request)` performs exactly one HTTP call to `/responses/compact`, using the selected route's endpoint, credentials, query, and HTTP middleware. It returns a `CompactionResponse` containing replacement `messages` and usage, not a normal generation response.
-
-```ts
-const compacted = yield * LLMClient.compact(request)
-const next = LLMRequest.update(request, {
-  messages: [...compacted.messages, Message.user("Continue")],
-})
-const response = yield * LLMClient.generate(next)
-```
-
-Replace the prior window with `compacted.messages`. Do not append it to the original transcript or extract only the encrypted item: the provider may retain additional messages in its output. Retained user and assistant messages remain ordinary messages with typed text, media, or reasoning parts, in their original order. Provider-specific message IDs, status, and phase use `providerMetadata`, not a raw output array hidden in an assistant message. Unsupported returned item types fail explicitly. Generation-only body overlays such as `stream` and `store` are not sent to the compact endpoint.
-
-The input must still fit the model's context window. Explicit compaction is not an overflow-recovery operation. xAI supports this explicit path, not the automatic OpenAI option. Unsupported routes, including Bedrock Mantle, do not inherit an explicit compact endpoint simply because they use a Responses protocol.
-
-### Ownership and verification
-
-The AI package transports options and typed conversation parts. It does not schedule compaction, persist Session checkpoints, select history, switch providers, or replace Core's existing local compaction policy. Native compaction is not enabled for OpenCode Sessions by this feature; Session integration must persist these parts before enabling it. The AI SDK bridge rejects native compaction parts rather than dropping them. Provider-executed tool APIs and persistence changes are a separate follow-up.
-
-Tests cover serialized round trips, real local HTTP plus a tool loop, AWS binary frames and signing, provider errors, malformed blocks, and usage accounting. Live provider tests are gated by `RECORD=true` and the relevant API keys:
-
-```sh
-# Run from packages/ai. Only records the selected new cassette group.
-RECORD=true RECORDED_PREFIX=openai-compaction bun test test/provider/compaction.recorded.test.ts
-RECORD=true RECORDED_PREFIX=xai-compaction bun test test/provider/compaction.recorded.test.ts
-RECORD=true RECORDED_PREFIX=anthropic-compaction bun test test/provider/compaction.recorded.test.ts
-```
-
-Provider references: [OpenAI](https://developers.openai.com/api/docs/guides/compaction), [Azure](https://learn.microsoft.com/en-us/azure/foundry/openai/how-to/responses#server-side-compaction), [Anthropic](https://platform.claude.com/docs/en/build-with-claude/compaction), [Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/claude-messages-compaction.html), [xAI](https://docs.x.ai/developers/advanced-api-usage/context-compaction).
-
 ## Caching
 
 Prompt caching is **on by default**. Every `LLMRequest` resolves to `cache: "auto"` unless the caller opts out with `cache: "none"`. Each protocol translates `CacheHint`s to its wire format (`cache_control` on Anthropic, `cachePoint` on Bedrock; OpenAI and Gemini do implicit caching server-side and don't need inline markers — auto is a no-op there).

packages/ai/src/cache-policy.ts

@@ -40,7 +40,6 @@ const RESPECTS_INLINE_HINTS = new Set([
   "anthropic-messages",
   "google-vertex-messages",
   "bedrock-converse",
-  "bedrock-messages",
   "openrouter",
 ])
 

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

@@ -6,12 +6,8 @@ import { Auth } from "../route/auth.js"
 import { Endpoint } from "../route/endpoint.js"
 import { Framing } from "../route/framing.js"
 import { Protocol } from "../route/protocol.js"
-import { Headers } from "effect/unstable/http"
-import { HttpTransport } from "../route/transport/index.js"
 import {
   AIError,
-  HttpOptions,
-  LLMRequest,
   LLMEvent,
   mergeJsonRecords,
   Usage,
@@ -19,6 +15,7 @@ import {
   type FinishReasonDetails,
   type FinishReason,
   type JsonSchema,
+  type LLMRequest,
   type MediaPart,
   type ProviderMetadata,
   type ToolCallPart,
@@ -64,7 +61,6 @@ export type ThinkingInput =
     ))
 
 export interface OptionsInput {
-  readonly contextManagement?: ContextManagement
   readonly [key: string]: unknown
   readonly thinking?: ThinkingInput
   readonly effort?: string
@@ -93,23 +89,6 @@ export interface OptionsInput {
 
 export type ProviderOptionsInput = OptionsInput
 
-export const ContextManagement = Schema.Struct({
-  edits: Schema.Array(
-    Schema.Struct({
-      type: Schema.Literal("compact_20260112"),
-      trigger: Schema.optional(
-        Schema.Struct({
-          type: Schema.Literal("input_tokens"),
-          value: Schema.Int.check(Schema.isGreaterThanOrEqualTo(50000)),
-        }),
-      ),
-      pauseAfterCompaction: Schema.optional(Schema.Boolean),
-      instructions: Schema.optional(Schema.String),
-    }),
-  ),
-})
-export type ContextManagement = typeof ContextManagement.Type
-
 // =============================================================================
 // Request Body Schema
 // =============================================================================
@@ -257,12 +236,7 @@ const AnthropicUserBlock = Schema.Union([
   AnthropicToolResultBlock,
 ])
 type AnthropicUserBlock = Schema.Schema.Type<typeof AnthropicUserBlock>
-const AnthropicCompactionBlock = Schema.Struct({
-  type: Schema.Literal("compaction"),
-  content: Schema.NullOr(Schema.String),
-})
 const AnthropicAssistantBlock = Schema.Union([
-  AnthropicCompactionBlock,
   AnthropicTextBlock,
   AnthropicThinkingBlock,
   AnthropicRedactedThinkingBlock,
@@ -338,18 +312,6 @@ const AnthropicContainer = Schema.Union([
 ])
 
 const AnthropicBodyFields = {
-  context_management: Schema.optional(
-    Schema.Struct({
-      edits: Schema.Array(
-        Schema.Struct({
-          type: Schema.Literal("compact_20260112"),
-          trigger: ContextManagement.fields.edits.value.fields.trigger,
-          pause_after_compaction: Schema.optional(Schema.Boolean),
-          instructions: Schema.optional(Schema.String),
-        }),
-      ),
-    }),
-  ),
   model: Schema.String,
   system: optionalArray(AnthropicTextBlock),
   messages: Schema.Array(AnthropicMessage),
@@ -373,7 +335,7 @@ const AnthropicBodyFields = {
 export const AnthropicMessagesBody = Schema.Struct(AnthropicBodyFields)
 export type AnthropicMessagesBody = Schema.Schema.Type<typeof AnthropicMessagesBody>
 
-const AnthropicIterationUsage = Schema.StructWithRest(
+const AnthropicUsage = Schema.StructWithRest(
   Schema.Struct({
     input_tokens: optionalNull(Schema.Number),
     output_tokens: Schema.optional(Schema.Number),
@@ -392,13 +354,6 @@ const AnthropicIterationUsage = Schema.StructWithRest(
   }),
   [Schema.Record(Schema.String, Schema.Unknown)],
 )
-const AnthropicUsage = Schema.StructWithRest(
-  Schema.Struct({
-    ...AnthropicIterationUsage.schema.fields,
-    iterations: Schema.optional(Schema.Array(AnthropicIterationUsage)),
-  }),
-  [JsonObject],
-)
 type AnthropicUsage = Schema.Schema.Type<typeof AnthropicUsage>
 
 const AnthropicStreamBlock = Schema.Struct({
@@ -422,7 +377,6 @@ type AnthropicStreamBlock = Schema.Schema.Type<typeof AnthropicStreamBlock>
 const decodeAnthropicStreamBlock = Schema.decodeUnknownOption(AnthropicStreamBlock)
 
 const AnthropicStreamDelta = Schema.Struct({
-  content: optionalNull(Schema.String),
   type: Schema.optional(Schema.String),
   text: Schema.optional(Schema.String),
   thinking: Schema.optional(Schema.String),
@@ -452,8 +406,6 @@ const AnthropicEvent = Schema.Struct({
 type AnthropicEvent = Schema.Schema.Type<typeof AnthropicEvent>
 
 interface ParserState {
-  readonly provider: LLMRequest["model"]["provider"]
-  readonly compactions: Readonly<Record<number, string | null>>
   readonly providerMetadataKey: string
   readonly tools: ToolStream.State<number>
   readonly reasoningSignatures: Readonly<Record<number, string>>
@@ -896,12 +848,6 @@ const lowerMessages = Effect.fn("AnthropicMessages.lowerMessages")(function* (
     if (message.role === "assistant") {
       const content: AnthropicAssistantBlock[] = []
       for (const part of message.content) {
-        if (part.type === "compaction") {
-          if (part.provider !== request.model.provider || part.text === undefined)
-            return yield* invalid("Compaction state must be replayed to its originating provider and API")
-          content.push({ type: "compaction", content: part.text })
-          continue
-        }
         if (part.type === "text") {
           if (part.text.trim().length === 0) continue
           content.push({ type: "text", text: part.text, cache_control: cacheControl(breakpoints, part.cache) })
@@ -1057,9 +1003,6 @@ const resolveThinking = Effect.fn("AnthropicMessages.resolveThinking")(function*
 })
 
 const fromRequest = Effect.fn("AnthropicMessages.fromRequest")(function* (request: LLMRequest) {
-  const management = yield* ProviderShared.validateWith(
-    Schema.decodeUnknownEffect(Schema.UndefinedOr(ContextManagement)),
-  )(request.providerOptions?.contextManagement)
   const generation = request.generation
   const toolSchemaCompatibility = request.model.compatibility?.toolSchema
   // Allocate the 4-breakpoint budget in invalidation order: tools → system →
@@ -1094,7 +1037,7 @@ const fromRequest = Effect.fn("AnthropicMessages.fromRequest")(function* (reques
     )
   }
   const options = yield* resolveOptions(request)
-  const body = {
+  return {
     model: request.model.id,
     system,
     messages,
@@ -1115,18 +1058,6 @@ const fromRequest = Effect.fn("AnthropicMessages.fromRequest")(function* (reques
     metadata: options.metadata,
     service_tier: options.service_tier,
   }
-  if (!management) return body
-  return {
-    ...body,
-    context_management: {
-      edits: management.edits.map((edit) => ({
-        type: edit.type,
-        trigger: edit.trigger,
-        pause_after_compaction: edit.pauseAfterCompaction,
-        instructions: edit.instructions,
-      })),
-    },
-  }
 })
 
 // =============================================================================
@@ -1148,31 +1079,18 @@ const mapFinishReason = (reason: string | null | undefined): FinishReason => {
 // expose that subset through `output_tokens_details.thinking_tokens`.
 const mapUsage = (usage: AnthropicUsage | undefined, providerMetadataKey: string): Usage | undefined => {
   if (!usage) return undefined
-  const iterations = usage.iterations?.length ? usage.iterations : [usage]
-  const last = usage.iterations?.at(-1)
-  const nonCached = ProviderShared.sumTokens(...iterations.map((item) => item.input_tokens ?? undefined))
-  const cacheRead = ProviderShared.sumTokens(...iterations.map((item) => item.cache_read_input_tokens ?? undefined))
-  const cacheWrite = ProviderShared.sumTokens(
-    ...iterations.map((item) => item.cache_creation_input_tokens ?? undefined),
-  )
+  const nonCached = usage.input_tokens ?? undefined
+  const cacheRead = usage.cache_read_input_tokens ?? undefined
+  const cacheWrite = usage.cache_creation_input_tokens ?? undefined
   const inputTokens = ProviderShared.sumTokens(nonCached, cacheRead, cacheWrite)
-  const outputTokens = ProviderShared.sumTokens(...iterations.map((item) => item.output_tokens))
   return new Usage({
     inputTokens,
-    outputTokens,
-    contextTokens:
-      last?.type === "message"
-        ? ProviderShared.sumTokens(
-            last.input_tokens ?? undefined,
-            last.cache_read_input_tokens ?? undefined,
-            last.cache_creation_input_tokens ?? undefined,
-          )
-        : undefined,
+    outputTokens: usage.output_tokens,
     nonCachedInputTokens: nonCached,
     cacheReadInputTokens: cacheRead,
     cacheWriteInputTokens: cacheWrite,
-    reasoningTokens: ProviderShared.sumTokens(...iterations.map((item) => item.output_tokens_details?.thinking_tokens)),
-    totalTokens: ProviderShared.totalTokens(inputTokens, outputTokens, undefined),
+    reasoningTokens: usage.output_tokens_details?.thinking_tokens,
+    totalTokens: ProviderShared.totalTokens(inputTokens, usage.output_tokens, undefined),
     providerMetadata: { [providerMetadataKey]: usage },
   })
 }
@@ -1194,7 +1112,6 @@ const mergeUsage = (left: Usage | undefined, right: Usage | undefined, providerM
   return new Usage({
     inputTokens,
     outputTokens,
-    contextTokens: right.contextTokens ?? left.contextTokens,
     nonCachedInputTokens,
     cacheReadInputTokens,
     cacheWriteInputTokens,
@@ -1253,6 +1170,7 @@ const onContentBlockStart = (
   event: AnthropicEvent & { readonly content_block: AnthropicStreamBlock },
 ): StepResult => {
   const block = event.content_block
+  if (!block) return [state, NO_EVENTS]
 
   if (block.type === "tool_use" || block.type === "server_tool_use") {
     if (event.index === undefined || !block.id) return [state, NO_EVENTS]
@@ -1347,16 +1265,7 @@ const onContentBlockDelta = Effect.fn("AnthropicMessages.onContentBlockDelta")(f
 ) {
   const delta = event.delta
 
-  if (delta.type === "compaction_delta") {
-    if (event.index === undefined || !(event.index in state.compactions) || delta.content === undefined)
-      return yield* ProviderShared.eventError(ADAPTER, "Compaction delta is missing its block or content")
-    return [
-      { ...state, compactions: { ...state.compactions, [event.index]: delta.content } },
-      NO_EVENTS,
-    ] satisfies StepResult
-  }
-
-  if (delta.type === "text_delta" && delta.text) {
+  if (delta?.type === "text_delta" && delta.text) {
     if (!state.lifecycle.text.has(`text-${event.index ?? 0}`)) return [state, NO_EVENTS] satisfies StepResult
     const events: LLMEvent[] = []
     return [
@@ -1365,7 +1274,7 @@ const onContentBlockDelta = Effect.fn("AnthropicMessages.onContentBlockDelta")(f
     ] satisfies StepResult
   }
 
-  if (delta.type === "thinking_delta" && delta.thinking) {
+  if (delta?.type === "thinking_delta" && delta.thinking) {
     if (!state.lifecycle.reasoning.has(`reasoning-${event.index ?? 0}`)) return [state, NO_EVENTS] satisfies StepResult
     const events: LLMEvent[] = []
     return [
@@ -1377,7 +1286,7 @@ const onContentBlockDelta = Effect.fn("AnthropicMessages.onContentBlockDelta")(f
     ] satisfies StepResult
   }
 
-  if (delta.type === "signature_delta" && delta.signature) {
+  if (delta?.type === "signature_delta" && delta.signature) {
     const index = event.index ?? 0
     if (!state.lifecycle.reasoning.has(`reasoning-${index}`)) return [state, NO_EVENTS] satisfies StepResult
     return [
@@ -1389,7 +1298,7 @@ const onContentBlockDelta = Effect.fn("AnthropicMessages.onContentBlockDelta")(f
     ] satisfies StepResult
   }
 
-  if (delta.type === "input_json_delta" && event.index !== undefined) {
+  if (delta?.type === "input_json_delta" && event.index !== undefined) {
     if (!delta.partial_json) return [state, NO_EVENTS] satisfies StepResult
     if (!state.tools[event.index]) return [state, NO_EVENTS] satisfies StepResult
     const result = ToolStream.appendExisting(
@@ -1414,18 +1323,6 @@ const onContentBlockStop = Effect.fn("AnthropicMessages.onContentBlockStop")(fun
   event: AnthropicEvent,
 ) {
   if (event.index === undefined) return [state, NO_EVENTS] satisfies StepResult
-  if (event.index in state.compactions) {
-    const { [event.index]: content, ...compactions } = state.compactions
-    const events: LLMEvent[] = []
-    const lifecycle = Lifecycle.stepStart(state.lifecycle, events)
-    events.push(
-      LLMEvent.compaction({
-        provider: state.provider,
-        text: content,
-      }),
-    )
-    return [{ ...state, compactions, lifecycle }, events] satisfies StepResult
-  }
   const result = yield* ToolStream.finish(ADAPTER, state.tools, event.index)
   const events: LLMEvent[] = []
   const resultEvents = result.events ?? []
@@ -1477,8 +1374,6 @@ const onMessageDelta = (
 }
 
 const onMessageStop = Effect.fn("AnthropicMessages.onMessageStop")(function* (state: ParserState) {
-  if (Object.keys(state.compactions).length)
-    return yield* ProviderShared.eventError(ADAPTER, "Response ended with an incomplete compaction block")
   const result = yield* ToolStream.finishAll(ADAPTER, state.tools)
   const events: LLMEvent[] = []
   const lifecycle = result.events.length ? Lifecycle.stepStart(state.lifecycle, events) : state.lifecycle
@@ -1523,21 +1418,16 @@ const onError = (event: AnthropicEvent) => {
   )
 }
 
-const STREAM_BLOCK_TYPES = new Set([
-  "compaction",
-  "text",
-  "thinking",
-  "redacted_thinking",
-  "tool_use",
-  "server_tool_use",
-])
-const STREAM_DELTA_TYPES = new Set([
-  "compaction_delta",
-  "text_delta",
-  "thinking_delta",
-  "signature_delta",
-  "input_json_delta",
-])
+const isKnownStreamBlockType = (type: string) =>
+  type === "text" ||
+  type === "thinking" ||
+  type === "redacted_thinking" ||
+  type === "tool_use" ||
+  type === "server_tool_use" ||
+  isServerToolResultType(type)
+
+const isKnownStreamDeltaType = (type: string) =>
+  type === "text_delta" || type === "thinking_delta" || type === "signature_delta" || type === "input_json_delta"
 
 const invalidStreamEvent = (event: AnthropicEvent) =>
   Effect.fail(
@@ -1566,16 +1456,7 @@ const step = (state: ParserState, event: AnthropicEvent) => {
   if (event.type === "content_block_start") {
     if (!ProviderShared.isRecord(event.content_block) || typeof event.content_block.type !== "string")
       return invalidStreamEvent(event)
-    if (event.content_block.type === "compaction") {
-      const decoded = Schema.decodeUnknownOption(AnthropicCompactionBlock)(event.content_block)
-      if (event.index === undefined || Option.isNone(decoded)) return invalidStreamEvent(event)
-      return Effect.succeed<StepResult>([
-        { ...state, compactions: { ...state.compactions, [event.index]: decoded.value.content } },
-        NO_EVENTS,
-      ])
-    }
-    if (!STREAM_BLOCK_TYPES.has(event.content_block.type) && !isServerToolResultType(event.content_block.type))
-      return Effect.succeed<StepResult>([state, NO_EVENTS])
+    if (!isKnownStreamBlockType(event.content_block.type)) return Effect.succeed<StepResult>([state, NO_EVENTS])
     const decoded = decodeAnthropicStreamBlock(event.content_block)
     if (Option.isNone(decoded)) return invalidStreamEvent(event)
     const block = decoded.value
@@ -1589,7 +1470,7 @@ const step = (state: ParserState, event: AnthropicEvent) => {
   }
   if (event.type === "content_block_delta") {
     if (!ProviderShared.isRecord(event.delta)) return invalidStreamEvent(event)
-    if (typeof event.delta.type === "string" && !STREAM_DELTA_TYPES.has(event.delta.type))
+    if (typeof event.delta.type === "string" && !isKnownStreamDeltaType(event.delta.type))
       return Effect.succeed<StepResult>([state, NO_EVENTS])
     const decoded = decodeAnthropicStreamDelta(event.delta)
     if (Option.isNone(decoded)) return invalidStreamEvent(event)
@@ -1623,8 +1504,6 @@ export const protocol = Protocol.make({
   stream: {
     event: Protocol.jsonEvent(AnthropicEvent),
     initial: (request) => ({
-      provider: request.model.provider,
-      compactions: {},
       providerMetadataKey: request.model.route.providerMetadataKey ?? String(request.model.provider),
       tools: ToolStream.empty<number>(),
       reasoningSignatures: {},
@@ -1634,37 +1513,6 @@ export const protocol = Protocol.make({
   },
 })
 
-export const transport = <Body extends Pick<AnthropicMessagesBody, "messages" | "context_management">>() => {
-  const http = HttpTransport.httpJson<Body, string>({ framing })
-  return {
-    ...http,
-    prepare: (input: Parameters<typeof http.prepare>[0]) => {
-      if (
-        !input.body.context_management?.edits.length &&
-        !input.body.messages.some((message) => message.content.some((block) => block.type === "compaction"))
-      )
-        return http.prepare(input)
-      const headers = Headers.fromInput(input.request.http?.headers)
-      const betas = new Set(
-        (headers["anthropic-beta"] ?? "")
-          .split(",")
-          .map((item) => item.trim())
-          .filter(Boolean),
-      )
-      betas.add("compact-2026-01-12")
-      return http.prepare({
-        ...input,
-        request: LLMRequest.update(input.request, {
-          http: new HttpOptions({
-            ...input.request.http,
-            headers: { ...headers, "anthropic-beta": [...betas].join(",") },
-          }),
-        }),
-      })
-    },
-  }
-}
-
 export const route = Route.make({
   id: ADAPTER,
   provider: "anthropic",
@@ -1674,7 +1522,7 @@ export const route = Route.make({
     baseURL: DEFAULT_BASE_URL,
   }),
   auth: Auth.none,
-  transport: transport<AnthropicMessagesBody>(),
+  framing,
   headers: () => ({ "anthropic-version": "2023-06-01" }),
 })
 

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

@@ -510,9 +510,10 @@ interface ParserState {
   readonly tools: ToolStream.State<number>
   readonly finishedTools: ReadonlySet<number>
   // Bedrock splits the finish into `messageStop` (carries `stopReason`) and
-  // `metadata` (carries usage). Hold the terminal event in state so `onHalt`
-  // can emit exactly one finish after both chunks have had a chance to arrive.
-  readonly pendingFinish: { readonly reason: FinishReasonDetails; readonly usage?: Usage } | undefined
+  // `metadata` (carries usage). Hold both in state so `onHalt` can emit exactly
+  // one finish after both chunks have had a chance to arrive.
+  readonly finishReason: FinishReasonDetails | undefined
+  readonly usage: Usage | undefined
   readonly hasToolCalls: boolean
   readonly lifecycle: Lifecycle.State
   readonly reasoningSignatures: Readonly<Record<number, string>>
@@ -692,12 +693,9 @@ const step = (state: ParserState, event: BedrockEvent) =>
       return [
         {
           ...state,
-          pendingFinish: {
-            reason: {
-              normalized: mapFinishReason(event.messageStop.stopReason),
-              raw: event.messageStop.stopReason,
-            },
-            usage: state.pendingFinish?.usage,
+          finishReason: {
+            normalized: mapFinishReason(event.messageStop.stopReason),
+            raw: event.messageStop.stopReason,
           },
         },
         [],
@@ -705,14 +703,11 @@ const step = (state: ParserState, event: BedrockEvent) =>
     }
 
     if (event.metadata) {
-      const usage = mapUsage(event.metadata.usage, state.providerMetadataKey) ?? state.pendingFinish?.usage
+      const usage = mapUsage(event.metadata.usage, state.providerMetadataKey) ?? state.usage
       return [
         {
           ...state,
-          pendingFinish: {
-            reason: state.pendingFinish?.reason ?? { normalized: "stop" },
-            usage,
-          },
+          usage,
         },
         [],
       ] as const
@@ -736,18 +731,18 @@ const step = (state: ParserState, event: BedrockEvent) =>
 const framing = BedrockEventStream.framing(ADAPTER)
 
 const onHalt = (state: ParserState): ReadonlyArray<LLMEvent> => {
-  if (!state.pendingFinish) return []
+  if (!state.finishReason) return []
   const normalized = (() => {
-    if (state.pendingFinish.reason.normalized === "stop" && state.hasToolCalls) return "tool-calls"
-    return state.pendingFinish.reason.normalized
+    if (state.finishReason.normalized === "stop" && state.hasToolCalls) return "tool-calls"
+    return state.finishReason.normalized
   })()
   const events: LLMEvent[] = []
   Lifecycle.finish(state.lifecycle, events, {
     reason: {
-      ...state.pendingFinish.reason,
+      ...state.finishReason,
       normalized,
     },
-    usage: state.pendingFinish.usage,
+    usage: state.usage,
   })
   return events
 }
@@ -771,7 +766,8 @@ export const protocol = Protocol.make({
       providerMetadataKey: request.model.route.providerMetadataKey ?? String(request.model.provider),
       tools: ToolStream.empty<number>(),
       finishedTools: new Set<number>(),
-      pendingFinish: undefined,
+      finishReason: undefined,
+      usage: undefined,
       hasToolCalls: false,
       lifecycle: Lifecycle.initial(),
       reasoningSignatures: {},

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

@@ -1,96 +0,0 @@
-import { Effect, Encoding, Schema, Struct } from "effect"
-import { Headers } from "effect/unstable/http"
-import { AIError } from "../schema/index.js"
-import { Route } from "../route/client.js"
-import { Endpoint } from "../route/endpoint.js"
-import { Protocol } from "../route/protocol.js"
-import { classifyProviderFailure } from "../provider-error.js"
-import { AnthropicMessages } from "./anthropic-messages.js"
-import { BedrockEventStream } from "./bedrock-event-stream.js"
-import { BedrockAuth } from "./utils/bedrock-auth.js"
-import { JsonObject, ProviderShared } from "./shared.js"
-
-const ID = "bedrock-messages"
-const VERSION = "bedrock-2023-05-31"
-const Body = Schema.Struct({
-  ...Struct.omit(AnthropicMessages.AnthropicMessagesBody.fields, ["model", "stream"]),
-  anthropic_version: Schema.Literal(VERSION),
-  anthropic_beta: Schema.optional(Schema.Array(Schema.String)),
-})
-const Event = Schema.Struct({
-  chunk: Schema.optional(Schema.Struct({ bytes: Schema.String })),
-  exception: Schema.optional(
-    Schema.Struct({
-      type: Schema.String,
-      details: Schema.StructWithRest(
-        Schema.Struct({ message: Schema.optional(Schema.String), originalMessage: Schema.optional(Schema.String) }),
-        [JsonObject],
-      ),
-    }),
-  ),
-})
-
-export const protocol = Protocol.make({
-  id: ID,
-  body: {
-    schema: Body,
-    from: Effect.fn("BedrockMessages.fromRequest")(function* (request) {
-      const body = yield* AnthropicMessages.protocol.body.from(request)
-      const headers = Headers.fromInput(request.http?.headers)
-      const betas = new Set(
-        (headers["anthropic-beta"] ?? "")
-          .split(",")
-          .map((value) => value.trim())
-          .filter(Boolean),
-      )
-      if (
-        body.context_management?.edits.length ||
-        body.messages.some((message) => message.content.some((block) => block.type === "compaction"))
-      )
-        betas.add("compact-2026-01-12")
-      return {
-        ...Struct.omit(body, ["model", "stream"]),
-        anthropic_version: VERSION,
-        anthropic_beta: betas.size ? [...betas] : undefined,
-      } satisfies typeof Body.Type
-    }),
-  },
-  stream: {
-    event: Event,
-    initial: AnthropicMessages.protocol.stream.initial,
-    step: Effect.fn("BedrockMessages.step")(function* (state, event) {
-      if (event.exception)
-        return yield* new AIError({
-          reason: classifyProviderFailure({
-            message: event.exception.details.message ?? event.exception.details.originalMessage ?? event.exception.type,
-            rawBody: ProviderShared.encodeJson(event),
-          }),
-        })
-      if (!event.chunk) return yield* ProviderShared.eventError(ID, "Bedrock Messages event is missing its chunk")
-      const text = yield* Effect.fromResult(Encoding.decodeBase64String(event.chunk.bytes)).pipe(
-        Effect.mapError((cause) =>
-          ProviderShared.eventError(ID, "Invalid Bedrock Messages chunk encoding", undefined, cause),
-        ),
-      )
-      const decoded = yield* Schema.decodeUnknownEffect(AnthropicMessages.protocol.stream.event)(text).pipe(
-        Effect.mapError((cause) => ProviderShared.eventError(ID, "Invalid Bedrock Messages event", undefined, cause)),
-      )
-      return yield* AnthropicMessages.protocol.stream.step(state, decoded)
-    }),
-  },
-})
-
-export const route = Route.make({
-  id: ID,
-  provider: "amazon-bedrock",
-  providerMetadataKey: "anthropic",
-  protocol,
-  endpoint: Endpoint.path(
-    ({ request }) => `/model/${encodeURIComponent(request.model.id)}/invoke-with-response-stream`,
-    { baseURL: "https://bedrock-runtime.us-east-1.amazonaws.com" },
-  ),
-  auth: BedrockAuth.auth,
-  framing: BedrockEventStream.framing(ID),
-})
-
-export * as BedrockMessages from "./bedrock-messages.js"

packages/ai/src/protocols/gemini.ts

@@ -609,18 +609,27 @@ const finish = (state: ParserState): ReadonlyArray<LLMEvent> => {
 }
 
 const step = (state: ParserState, event: GeminiEvent) => {
-  if (ProviderShared.isRecord(event.error) && typeof event.error.message === "string") {
+  if (ProviderShared.isRecord(event.error)) {
     const body = ProviderShared.encodeJson(event)
     return Effect.fail(
       new AIError({
         reason: classifyProviderFailure({
-          message: event.error.message,
+          message:
+            typeof event.error.message === "string" && event.error.message.length > 0
+              ? event.error.message
+              : typeof event.error.status === "string" && event.error.status.length > 0
+                ? event.error.status
+                : "Gemini provider error",
           status: typeof event.error.code === "number" ? event.error.code : undefined,
           rawBody: body,
         }),
       }),
     )
   }
+  if ("error" in event)
+    return Effect.fail(
+      ProviderShared.eventError(state.route, `Invalid ${state.route} stream event`, ProviderShared.encodeJson(event)),
+    )
   const nextState = {
     ...state,
     promptFeedback: event.promptFeedback ?? state.promptFeedback,

packages/ai/src/protocols/index.ts

@@ -1,6 +1,5 @@
 export * as AnthropicMessages from "./anthropic-messages.js"
 export * as BedrockConverse from "./bedrock-converse.js"
-export { BedrockMessages } from "./bedrock-messages.js"
 export * as Gemini from "./gemini.js"
 export * as MistralChat from "./mistral-chat.js"
 export * as OpenAIChat from "./openai-chat.js"

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

@@ -32,14 +32,13 @@ export const PATH = "/responses"
 // =============================================================================
 // Request Body Schema
 // =============================================================================
-export const OpenResponsesInputText = Schema.Struct({
+const OpenResponsesInputText = Schema.Struct({
   type: Schema.tag("input_text"),
   text: Schema.String,
 })
-export const OpenResponsesInputImage = Schema.Struct({
+const OpenResponsesInputImage = Schema.Struct({
   type: Schema.tag("input_image"),
   image_url: Schema.String,
-  detail: Schema.optional(Schema.String),
 })
 const OpenResponsesInputFile = Schema.Struct({
   type: Schema.tag("input_file"),
@@ -55,7 +54,7 @@ const MediaInput = Schema.Union([OpenResponsesInputImage, OpenResponsesInputFile
 export type MediaInput = Schema.Schema.Type<typeof MediaInput>
 const OpenResponsesInputContent = Schema.Union([OpenResponsesInputText, MediaInput])
 
-export const OpenResponsesOutputText = Schema.Struct({
+const OpenResponsesOutputText = Schema.Struct({
   type: Schema.tag("output_text"),
   text: Schema.String,
 })
@@ -63,13 +62,6 @@ export const OpenResponsesOutputText = Schema.Struct({
 export const MessagePhase = Schema.NullOr(Schema.Literals(["commentary", "final_answer"]))
 type MessagePhase = Schema.Schema.Type<typeof MessagePhase>
 
-export const MessageMetadata = Schema.Struct({
-  itemId: Schema.optional(Schema.String),
-  type: Schema.optional(Schema.Literal("message")),
-  status: Schema.optional(Schema.String),
-  phase: Schema.optional(MessagePhase),
-})
-
 const messagePhase = (value: unknown): MessagePhase | undefined => {
   if (value === null || value === "commentary" || value === "final_answer") return value
   return undefined
@@ -80,7 +72,7 @@ const OpenResponsesReasoningSummaryText = Schema.Struct({
   text: Schema.String,
 })
 
-export const OpenResponsesReasoningItem = Schema.Struct({
+const OpenResponsesReasoningItem = Schema.Struct({
   type: Schema.tag("reasoning"),
   id: Schema.optionalKey(Schema.String),
   summary: Schema.Array(OpenResponsesReasoningSummaryText),
@@ -157,30 +149,16 @@ const OpenResponsesFunctionCallOutput = Schema.Union([
   Schema.Array(OpenResponsesFunctionCallOutputContent),
 ])
 
-export const CompactionItem = Schema.Struct({
-  type: Schema.Literal("compaction"),
-  id: optionalNull(Schema.String),
-  encrypted_content: Schema.String,
-})
-
 export const InputItem = Schema.Union([
-  CompactionItem,
   Schema.Struct({ role: Schema.tag("system"), content: Schema.String }),
   Schema.Struct({ role: Schema.tag("developer"), content: Schema.String }),
-  Schema.Struct({
-    role: Schema.tag("user"),
-    content: Schema.Array(OpenResponsesInputContent),
-    type: Schema.optional(Schema.Literal("message")),
-    id: Schema.optional(Schema.String),
-    status: Schema.optional(Schema.String),
-  }),
+  Schema.Struct({ role: Schema.tag("user"), content: Schema.Array(OpenResponsesInputContent) }),
   Schema.Struct({
     type: Schema.tag("message"),
     id: Schema.optionalKey(Schema.String),
     role: Schema.tag("assistant"),
     content: Schema.Array(OpenResponsesOutputText),
     phase: Schema.optionalKey(MessagePhase),
-    status: Schema.optional(Schema.String),
   }),
   OpenResponsesReasoningItem,
   Schema.Struct({
@@ -289,7 +267,7 @@ const OpenResponsesBody = Schema.Struct({
 })
 export type OpenResponsesBody = Schema.Schema.Type<typeof OpenResponsesBody>
 
-export const OpenResponsesUsage = Schema.Struct({
+const OpenResponsesUsage = Schema.Struct({
   input_tokens: Schema.optional(Schema.Number),
   input_tokens_details: optionalNull(
     Schema.Struct({
@@ -409,8 +387,6 @@ export interface Extension {
 const BASE: Extension = { id: ADAPTER, name: NAME }
 
 export interface ParserState {
-  readonly provider: LLMRequest["model"]["provider"]
-  readonly completedCompactions: ReadonlySet<string>
   readonly id: string
   readonly name: string
   readonly providerMetadataKey: string
@@ -525,13 +501,7 @@ const lowerMedia = Effect.fn("OpenResponses.lowerMedia")(function* (
       ...(url ? { file_url: url } : { file_data: media.dataUrl }),
     }
   }
-  return {
-    type: "input_image" as const,
-    image_url: url ?? media.dataUrl,
-    detail: yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(OpenResponsesInputImage.fields.detail))(
-      part.providerMetadata?.[request.model.route.providerMetadataKey ?? "openresponses"]?.detail,
-    ),
-  }
+  return { type: "input_image" as const, image_url: url ?? media.dataUrl }
 })
 
 const lowerUserContent = Effect.fnUntraced(function* (
@@ -598,9 +568,6 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (reques
   const providerMetadataKey = request.model.route.providerMetadataKey ?? "openresponses"
 
   for (const message of request.messages) {
-    const metadata = yield* ProviderShared.validateWith(
-      Schema.decodeUnknownEffect(Schema.UndefinedOr(MessageMetadata)),
-    )(message.providerMetadata?.[providerMetadataKey])
     if (message.role === "system") {
       input.push({
         role: "developer",
@@ -611,8 +578,7 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (reques
 
     if (message.role === "user") {
       const content = yield* Effect.forEach(message.content, (part) => lowerUserContent(part, request, extension))
-      if (content.length > 0)
-        input.push({ role: "user", content, type: metadata?.type, id: metadata?.itemId, status: metadata?.status })
+      if (content.length > 0) input.push({ role: "user", content })
       continue
     }
 
@@ -625,10 +591,9 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (reques
         const groups = content.reduce<
           Array<{ id: string | undefined; phase: MessagePhase | null | undefined; parts: TextPart[] }>
         >((groups, part) => {
-          const partMetadata = part.providerMetadata?.[providerMetadataKey]
-          const id = itemID(part.providerMetadata, providerMetadataKey) ?? metadata?.itemId
-          const partPhase = messagePhase(partMetadata?.phase)
-          const phase = partPhase === undefined ? metadata?.phase : partPhase
+          const metadata = part.providerMetadata?.[providerMetadataKey]
+          const id = itemID(part.providerMetadata, providerMetadataKey)
+          const phase = ProviderShared.isRecord(metadata) ? messagePhase(metadata.phase) : 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] })
@@ -639,7 +604,6 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (reques
             type: "message" as const,
             ...(group.id === undefined ? {} : { id: group.id }),
             role: "assistant" as const,
-            status: metadata?.status,
             content: group.parts.map((part) => ({ type: "output_text" as const, text: part.text })),
             ...(group.phase === undefined ? {} : { phase: group.phase }),
           })),
@@ -647,15 +611,6 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (reques
         content.splice(0, content.length)
       }
       for (const part of message.content) {
-        if (part.type === "compaction") {
-          flushText()
-          if (part.provider !== request.model.provider || part.encrypted === undefined)
-            return yield* ProviderShared.invalidRequest(
-              "Compaction state must be replayed to its originating provider and API",
-            )
-          input.push({ type: "compaction", id: part.id, encrypted_content: part.encrypted })
-          continue
-        }
         if (part.type === "text") {
           content.push(part)
           continue
@@ -734,30 +689,13 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (reques
   return input
 })
 
-export const lowerConversation = Effect.fn("OpenResponses.lowerConversation")(function* (
-  request: LLMRequest,
-  extension: Extension,
-) {
-  const instructions = ProviderShared.joinText(request.system)
-  return {
-    model: request.model.id,
-    input: yield* lowerMessages(request, extension),
-    ...(instructions ? { instructions } : {}),
-  }
-})
-
-export const lowerGeneration = (request: LLMRequest) => {
+const lowerOptions = (request: LLMRequest) => {
   const options = OpenResponsesOptions.resolve(request)
-  const generation = request.generation
+  const instructions = ProviderShared.joinText(request.system)
   const cacheKey = ProviderShared.promptCacheKey(request)
   const parallelToolCalls = resolveParallelToolCalls(request)
   return {
-    stream: true as const,
-    max_output_tokens: generation?.maxTokens,
-    temperature: generation?.temperature,
-    top_p: generation?.topP,
-    presence_penalty: generation?.presencePenalty,
-    frequency_penalty: generation?.frequencyPenalty,
+    ...(instructions ? { instructions } : {}),
     ...(options.store !== undefined ? { store: options.store } : {}),
     ...(options.metadata ? { metadata: options.metadata } : {}),
     ...(options.safetyIdentifier ? { safety_identifier: options.safetyIdentifier } : {}),
@@ -785,7 +723,7 @@ export const resolveParallelToolCalls = (request: LLMRequest) => {
   return disabled === undefined ? undefined : !disabled
 }
 
-export const allowedToolChoice = (request: LLMRequest) => {
+const allowedToolChoice = (request: LLMRequest) => {
   const allowed = OpenResponsesOptions.resolve(request).allowedTools
   if (!allowed) return undefined
   return {
@@ -799,10 +737,11 @@ export const fromRequestWithExtension = Effect.fn("OpenResponses.fromRequestWith
   request: LLMRequest,
   extension: Extension,
 ) {
+  const generation = request.generation
   const toolSchemaCompatibility = request.model.compatibility?.toolSchema
   return {
-    ...(yield* lowerConversation(request, extension)),
-    ...lowerGeneration(request),
+    model: request.model.id,
+    input: yield* lowerMessages(request, extension),
     tools:
       request.tools.length === 0
         ? undefined
@@ -816,6 +755,13 @@ export const fromRequestWithExtension = Effect.fn("OpenResponses.fromRequestWith
     tool_choice:
       allowedToolChoice(request) ??
       (request.toolChoice ? yield* lowerToolChoice(extension.name, request.toolChoice) : undefined),
+    stream: true as const,
+    max_output_tokens: generation?.maxTokens,
+    temperature: generation?.temperature,
+    top_p: generation?.topP,
+    presence_penalty: generation?.presencePenalty,
+    frequency_penalty: generation?.frequencyPenalty,
+    ...lowerOptions(request),
   }
 })
 
@@ -832,7 +778,7 @@ export const fromRequest = Effect.fn("OpenResponses.fromRequest")(function* (req
 // cached-read and cache-write subsets, and `output_tokens` (inclusive total)
 // with a `reasoning_tokens` subset. Pass the totals through and derive the
 // non-cached breakdown.
-export const mapUsage = (usage: OpenResponsesUsage | null | undefined, providerMetadataKey: string) => {
+const mapUsage = (usage: OpenResponsesUsage | null | undefined, providerMetadataKey: string) => {
   if (!usage) return undefined
   const cached = usage.input_tokens_details?.cached_tokens
   const cacheWrite = usage.input_tokens_details?.cache_write_tokens
@@ -1138,25 +1084,6 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
 ) {
   if (!item) return [state, NO_EVENTS] satisfies StepResult
 
-  if (item.type === "compaction") {
-    if (!item.id || typeof item.encrypted_content !== "string")
-      return yield* ProviderShared.eventError(state.id, "Compaction output is missing its id or encrypted content")
-    if (state.completedCompactions.has(item.id)) return [state, NO_EVENTS] satisfies StepResult
-    const events: LLMEvent[] = []
-    const lifecycle = Lifecycle.stepStart(state.lifecycle, events)
-    events.push(
-      LLMEvent.compaction({
-        provider: state.provider,
-        id: item.id,
-        encrypted: item.encrypted_content,
-      }),
-    )
-    return [
-      { ...state, lifecycle, completedCompactions: new Set([...state.completedCompactions, item.id]) },
-      events,
-    ] satisfies StepResult
-  }
-
   if (item.type === "message" && item.id !== undefined) {
     const message = state.message?.id === item.id ? state.message : undefined
     const itemPhase = messagePhase(item.phase)
@@ -1316,34 +1243,26 @@ const onResponseFinish = Effect.fn("OpenResponses.onResponseFinish")(function* (
   const events: LLMEvent[] = []
   if (event.type === "response.completed") {
     for (const item of event.response?.output ?? []) {
-      if (item.type !== "compaction" && item.type !== "function_call") continue
-      if (item.type === "compaction") {
-        // Terminal recovery cannot insert a checkpoint before already-emitted content.
-        if (state.lifecycle.stepStarted && !state.completedCompactions.has(item.id ?? ""))
-          return yield* ProviderShared.eventError(
-            state.id,
-            "Cannot recover a compaction checkpoint after output has been emitted",
-          )
-      }
-      if (item.type === "function_call" && !current.tools[item.id ?? item.call_id ?? ""]) continue
+      const id = item.id ?? (item.type === "function_call" ? item.call_id : undefined)
+      if (id === undefined) continue
+      if (item.type !== "function_call" || !current.tools[id]) continue
       const [next, emitted] = yield* onOutputItemDone(current, item)
       current = next
       events.push(...emitted)
     }
-    // Some compatible providers omit output_item.done even after completing the response.
-    const pending = yield* ToolStream.finishAll(current.id, current.tools)
-    current = {
-      ...current,
-      tools: pending.tools,
-      hasFunctionCall:
-        current.hasFunctionCall ||
-        pending.events.some((event) => LLMEvent.is.toolCall(event) || LLMEvent.is.toolInputError(event)),
-    }
-    events.push(...pending.events)
   }
+  // Some compatible providers omit output_item.done even after completing the response.
+  const pending =
+    event.type === "response.completed"
+      ? yield* ToolStream.finishAll(current.id, current.tools)
+      : { tools: current.tools, events: NO_EVENTS }
+  events.push(...pending.events)
+  const hasFunctionCall =
+    pending.events.some((event) => LLMEvent.is.toolCall(event) || LLMEvent.is.toolInputError(event)) ||
+    current.hasFunctionCall
   const lifecycle = Lifecycle.finish(current.lifecycle, events, {
     reason: {
-      normalized: mapFinishReason(event, current.hasFunctionCall),
+      normalized: mapFinishReason(event, hasFunctionCall),
       raw: event.response?.incomplete_details?.reason,
     },
     usage: mapUsage(event.response?.usage, current.providerMetadataKey),
@@ -1355,7 +1274,7 @@ const onResponseFinish = Effect.fn("OpenResponses.onResponseFinish")(function* (
           })
         : undefined,
   })
-  return [{ ...current, lifecycle }, events] satisfies StepResult
+  return [{ ...current, lifecycle, hasFunctionCall, tools: pending.tools }, events] satisfies StepResult
 })
 
 // Build the prettiest summary available from whatever the provider supplied.
@@ -1490,8 +1409,6 @@ export const step = (state: ParserState, input: Event) => {
  * implementations compose this baseline with their own tools and event variants.
  */
 export const initial = (request: LLMRequest, extension: Extension = BASE): ParserState => ({
-  provider: request.model.provider,
-  completedCompactions: new Set<string>(),
   id: extension.id,
   name: extension.name,
   providerMetadataKey: request.model.route.providerMetadataKey ?? "openresponses",

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

@@ -5,14 +5,13 @@ import { Auth } from "../route/auth.js"
 import { Endpoint } from "../route/endpoint.js"
 import { Protocol } from "../route/protocol.js"
 import { HttpTransport } from "../route/transport/index.js"
-import type { LLMRequest, JsonSchema, ToolDefinition } from "../schema/index.js"
+import { LLMRequest, type JsonSchema, type ToolDefinition } from "../schema/index.js"
 import { OpenResponses } from "./open-responses.js"
 import { JsonObject, optionalArray, optionalNull, ProviderShared } from "./shared.js"
 import { OpenAIImage } from "./utils/openai-image.js"
 import { ResponsesHostedTools } from "./utils/responses-hosted-tools.js"
 import { ToolSchemaProjection } from "./utils/tool-schema.js"
 import { OpenResponsesChannel } from "./open-responses-channel.js"
-import { ResponsesCompaction } from "./utils/responses-compaction.js"
 
 const ADAPTER = "openai-responses"
 const NAME = "OpenAI Responses"
@@ -21,14 +20,6 @@ const WEBSOCKET_ROTATE_AFTER_MS = 55 * 60 * 1000
 export const DEFAULT_BASE_URL = "https://api.openai.com/v1"
 export const PATH = OpenResponses.PATH
 
-export const ContextManagement = Schema.Array(
-  Schema.Struct({
-    type: Schema.Literal("compaction"),
-    compactThreshold: Schema.optional(Schema.Int.check(Schema.isGreaterThan(0))),
-  }),
-)
-export type ContextManagement = typeof ContextManagement.Type
-
 const OpenAIResponsesImageGenerationTool = Schema.Struct({
   type: Schema.tag("image_generation"),
   action: Schema.optional(Schema.Literals(["auto", "generate", "edit"])),
@@ -87,14 +78,6 @@ const OpenAIResponsesCoreFields = {
   input: Schema.Array(Schema.Union([OpenResponses.InputItem, OpenAIResponsesHostedToolItem])),
   tools: optionalArray(OpenAIResponsesTools),
   tool_choice: Schema.optional(OpenAIResponsesToolChoice),
-  context_management: Schema.optional(
-    Schema.Array(
-      Schema.Struct({
-        type: Schema.Literal("compaction"),
-        compact_threshold: Schema.optional(Schema.Int.check(Schema.isGreaterThan(0))),
-      }),
-    ),
-  ),
 }
 
 const OpenAIResponsesBody = Schema.Struct({
@@ -142,14 +125,15 @@ const lowerToolChoice = (toolChoice: NonNullable<LLMRequest["toolChoice"]>, tool
 const decodeBody = ProviderShared.validateWith(Schema.decodeUnknownEffect(OpenAIResponsesBody))
 
 const fromRequest = Effect.fn("OpenAIResponses.fromRequest")(function* (request: LLMRequest) {
-  const management = yield* ProviderShared.validateWith(
-    Schema.decodeUnknownEffect(Schema.UndefinedOr(ContextManagement)),
-  )(request.providerOptions?.contextManagement)
+  const body = yield* OpenResponses.fromRequestWithExtension(
+    LLMRequest.update(request, { tools: [], toolChoice: undefined }),
+    extension,
+  )
   const toolSchemaCompatibility = request.model.compatibility?.toolSchema
+  const parallelToolCalls = OpenResponses.resolveParallelToolCalls(request)
   return yield* decodeBody({
-    ...(yield* OpenResponses.lowerConversation(request, extension)),
-    ...OpenResponses.lowerGeneration(request),
-    context_management: management?.map((edit) => ({ type: edit.type, compact_threshold: edit.compactThreshold })),
+    ...body,
+    ...(parallelToolCalls === undefined ? {} : { parallel_tool_calls: parallelToolCalls }),
     tools:
       request.tools.length === 0
         ? undefined
@@ -157,8 +141,7 @@ const fromRequest = Effect.fn("OpenAIResponses.fromRequest")(function* (request:
             lowerTool(tool, ToolSchemaProjection.modelCompatibility(tool.inputSchema, toolSchemaCompatibility)),
           ),
     tool_choice:
-      OpenResponses.allowedToolChoice(request) ??
-      (request.toolChoice ? yield* lowerToolChoice(request.toolChoice, request.tools) : undefined),
+      body.tool_choice ?? (request.toolChoice ? yield* lowerToolChoice(request.toolChoice, request.tools) : undefined),
   })
 })
 
@@ -240,7 +223,6 @@ export const transport = channelTransport({
 })
 
 export const route = Route.make({
-  compact: ResponsesCompaction.make(extension),
   id: ADAPTER,
   provider: "openai",
   providerMetadataKey: "openai",

packages/ai/src/protocols/utils/responses-compaction.ts

@@ -1,152 +0,0 @@
-import { Effect, Schema, Stream } from "effect"
-import {
-  AIError,
-  InvalidProviderOutputError,
-  CompactionPart,
-  CompactionResponse,
-  HttpOptions,
-  LLMRequest,
-  Message,
-  type ContentPart,
-  mergeJsonRecords,
-} from "../../schema/index.js"
-import type { CompactOperation } from "../../route/client.js"
-import { Endpoint } from "../../route/endpoint.js"
-import { RequestExecutor } from "../../route/executor.js"
-import { HttpTransport } from "../../route/transport/index.js"
-import { OpenResponses } from "../open-responses.js"
-import { JsonObject, ProviderShared } from "../shared.js"
-
-const Body = Schema.Struct({
-  model: Schema.String,
-  input: Schema.Array(Schema.Unknown),
-  instructions: Schema.optional(Schema.String),
-  previous_response_id: Schema.optional(Schema.String),
-})
-
-const Text = Schema.Union([OpenResponses.OpenResponsesInputText, OpenResponses.OpenResponsesOutputText])
-const File = Schema.Union([
-  Schema.Struct({ type: Schema.Literal("input_file"), filename: Schema.String, file_url: Schema.String }),
-  Schema.Struct({ type: Schema.Literal("input_file"), filename: Schema.String, file_data: Schema.String }),
-])
-const MessageFields = {
-  type: Schema.Literal("message"),
-  id: Schema.optional(Schema.String),
-  status: Schema.optional(Schema.String),
-  phase: Schema.optional(OpenResponses.MessagePhase),
-}
-const Response = Schema.Struct({
-  object: Schema.Literal("response.compaction"),
-  output: Schema.Array(
-    Schema.Union([
-      OpenResponses.CompactionItem,
-      OpenResponses.OpenResponsesReasoningItem,
-      Schema.Struct({
-        ...MessageFields,
-        role: Schema.Literal("user"),
-        content: Schema.Array(Schema.Union([Text, OpenResponses.OpenResponsesInputImage, File])).check(
-          Schema.isMinLength(1),
-        ),
-      }),
-      Schema.Struct({
-        ...MessageFields,
-        role: Schema.Literal("assistant"),
-        content: Schema.Array(Text).check(Schema.isMinLength(1)),
-      }),
-    ]),
-  ),
-  usage: Schema.optional(Schema.StructWithRest(OpenResponses.OpenResponsesUsage, [JsonObject])),
-})
-
-export const make = (extension: OpenResponses.Extension): CompactOperation =>
-  Effect.fn("ResponsesCompaction.execute")(function* (request, executor, options) {
-    const route = request.model.route
-    const native = yield* OpenResponses.lowerConversation(request, extension)
-    const body = yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(Body))(
-      mergeJsonRecords(native, request.http?.body),
-    )
-    const url = Endpoint.render(route.endpoint, { request, body: native })
-    url.pathname = `${url.pathname.replace(/\/$/, "")}/compact`
-    const parts = yield* HttpTransport.jsonRequestParts({
-      request: LLMRequest.update(request, {
-        http: request.http === undefined ? undefined : new HttpOptions({ ...request.http, body: undefined }),
-      }),
-      body,
-      endpoint: Endpoint.path(url.toString()),
-      auth: route.auth,
-      encodeBody: Schema.encodeSync(Schema.fromJsonString(Body)),
-    })
-    const response = yield* executor.execute(
-      ProviderShared.jsonPost({ url: parts.url, body: parts.bodyText, headers: parts.headers }),
-      options?.http,
-    )
-    const text = yield* RequestExecutor.responseStream(response).pipe(
-      Stream.decodeText(),
-      Stream.runFold(
-        () => "",
-        (text, chunk) => text + chunk,
-      ),
-    )
-    const invalid = (message: string, cause?: unknown) =>
-      new AIError({
-        reason: new InvalidProviderOutputError({
-          route: route.id,
-          message,
-          body: text,
-          cause,
-          http: RequestExecutor.responseHttp(response),
-        }),
-      })
-    const result = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(Response))(text).pipe(
-      Effect.mapError((cause) => invalid("Invalid compaction response", cause)),
-    )
-    if (!result.output.some((item) => item.type === "compaction"))
-      return yield* invalid("Compaction response did not contain a checkpoint")
-    return new CompactionResponse({
-      messages: result.output.map((item) => toMessage(item, request.model)),
-      usage: OpenResponses.mapUsage(result.usage, route.providerMetadataKey ?? String(request.model.provider)),
-    })
-  })
-
-function toMessage(item: (typeof Response.Type.output)[number], model: LLMRequest["model"]): Message {
-  if (item.type === "compaction")
-    return Message.assistant(
-      CompactionPart.make({ provider: model.provider, id: item.id ?? undefined, encrypted: item.encrypted_content }),
-    )
-
-  const key = model.route.providerMetadataKey ?? String(model.provider)
-  if (item.type === "reasoning") {
-    const summary = item.summary.length ? item.summary : [{ text: "" }]
-    return Message.assistant(
-      summary.map((part) => ({
-        type: "reasoning" as const,
-        text: part.text,
-        providerMetadata: { [key]: { itemId: item.id, reasoningEncryptedContent: item.encrypted_content } },
-      })),
-    )
-  }
-
-  return Message.make({
-    role: item.role,
-    providerMetadata: { [key]: { itemId: item.id, type: item.type, status: item.status, phase: item.phase } },
-    content: item.content.map((part): ContentPart => {
-      if (part.type === "input_text" || part.type === "output_text") return { type: "text", text: part.text }
-      if (part.type === "input_image")
-        return {
-          type: "media",
-          data: part.image_url,
-          mediaType: /^data:([^;,]+)/.exec(part.image_url)?.[1] ?? "image/*",
-          providerMetadata: part.detail === undefined ? undefined : { [key]: { detail: part.detail } },
-        }
-      const data = "file_url" in part ? part.file_url : part.file_data
-      return {
-        type: "media",
-        data,
-        filename: part.filename,
-        mediaType: /^data:([^;,]+)/.exec(data)?.[1] ?? "application/octet-stream",
-      }
-    }),
-  })
-}
-
-export * as ResponsesCompaction from "./responses-compaction.js"

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

@@ -4,7 +4,6 @@ import type { LLMRequest } from "../schema/index.js"
 import { OpenResponses } from "./open-responses.js"
 import { JsonObject, optionalNull, ProviderShared } from "./shared.js"
 import { ResponsesHostedTools } from "./utils/responses-hosted-tools.js"
-import { ResponsesCompaction } from "./utils/responses-compaction.js"
 
 const ADAPTER = "xai-responses"
 const NAME = "xAI Responses"
@@ -45,10 +44,6 @@ const extension = {
 
 const decodeBody = ProviderShared.validateWith(Schema.decodeUnknownEffect(XAIResponsesBody))
 const fromRequest = Effect.fn("XAIResponses.fromRequest")(function* (request: LLMRequest) {
-  if (request.providerOptions?.contextManagement !== undefined)
-    return yield* ProviderShared.invalidRequest(
-      "xAI requires explicit compaction through LLMClient.compact; automatic context management is not supported",
-    )
   return yield* decodeBody(yield* OpenResponses.fromRequestWithExtension(request, extension))
 })
 
@@ -89,6 +84,4 @@ export const protocol = Protocol.make({
   },
 })
 
-export const compact = ResponsesCompaction.make(extension)
-
 export * as XAIResponses from "./xai-responses.js"

packages/ai/src/providers/amazon-bedrock.ts

@@ -1,11 +1,9 @@
-import type { Route, RouteDefaultsInput } from "../route/client.js"
+import type { RouteDefaultsInput } from "../route/client.js"
 import { Auth } from "../route/auth.js"
 import type { ProviderPackage } from "../provider-package.js"
 import { ProviderID, type ModelID } from "../schema/index.js"
 import * as BedrockConverse from "../protocols/bedrock-converse.js"
 import type { BedrockCredentials } from "../protocols/bedrock-converse.js"
-import { BedrockMessages } from "../protocols/bedrock-messages.js"
-import type { AnthropicMessages } from "../protocols/anthropic-messages.js"
 
 export const id = ProviderID.make("amazon-bedrock")
 
@@ -27,40 +25,38 @@ export interface Settings extends ProviderPackage.Settings {
   readonly region?: string
   readonly topP?: number
 }
-export const routes = [BedrockConverse.route, BedrockMessages.route]
+export const routes = [BedrockConverse.route]
 
 const bedrockBaseURL = (region: string) => `https://bedrock-runtime.${region}.amazonaws.com`
 
-const configuredRoute = <Body, Prepared>(route: Route<Body, Prepared>, input: Config) => {
+const configuredRoute = (input: Config) => {
   const { apiKey, credentials, region, baseURL, ...rest } = input
   const resolvedRegion = region ?? credentials?.region ?? "us-east-1"
-  return route.with({
+  return BedrockConverse.route.with({
     ...rest,
     provider: id,
-    providerMetadataKey: route.providerMetadataKey,
+    providerMetadataKey: "bedrock",
     endpoint: { baseURL: baseURL ?? bedrockBaseURL(resolvedRegion) },
     auth: apiKey === undefined ? BedrockConverse.sigV4Auth(credentials) : Auth.bearer(apiKey),
   })
 }
 
 export const configure = (input: Config = {}) => {
-  const route = configuredRoute(BedrockConverse.route, input)
-  const messages = configuredRoute(BedrockMessages.route, input)
+  const route = configuredRoute(input)
   return {
     id,
     model: (modelID: string | ModelID) => route.model({ id: modelID }),
-    messages: (modelID: string | ModelID) => messages.model<AnthropicMessages.ProviderOptionsInput>({ id: modelID }),
     configure,
   }
 }
 
 export const provider = configure()
-const config = (settings: Settings): Config => {
+export const model: ProviderPackage.Definition<Settings>["model"] = (modelID, settings) => {
   if (settings.auth === "bearer" && settings.apiKey === undefined)
     throw new Error("Amazon Bedrock bearer auth requires apiKey")
   if (settings.auth === "sigv4" && settings.apiKey !== undefined)
     throw new Error("Amazon Bedrock SigV4 auth does not accept apiKey")
-  return {
+  return configure({
     apiKey: settings.auth === "sigv4" ? undefined : settings.apiKey,
     baseURL: settings.baseURL,
     credentials: settings.credentials,
@@ -68,13 +64,5 @@ const config = (settings: Settings): Config => {
     headers: settings.headers === undefined ? undefined : { ...settings.headers },
     http: settings.body === undefined ? undefined : { body: { ...settings.body } },
     region: settings.region,
-  }
+  }).model(modelID)
 }
-
-export const model: ProviderPackage.Definition<Settings>["model"] = (modelID, settings) =>
-  configure(config(settings)).model(modelID)
-export const messagesModel: ProviderPackage.Definition<
-  Settings & { readonly providerOptions?: AnthropicMessages.ProviderOptionsInput },
-  AnthropicMessages.ProviderOptionsInput
->["model"] = (modelID, settings) =>
-  configure({ ...config(settings), providerOptions: settings.providerOptions }).messages(modelID)

packages/ai/src/providers/amazon-bedrock/messages.ts

@@ -1 +0,0 @@
-export { messagesModel as model } from "../amazon-bedrock.js"

packages/ai/src/providers/google-vertex-messages.ts

@@ -57,9 +57,7 @@ const route = Route.make({
   }),
   endpoint: Endpoint.path(({ request }) => `/${request.model.id}:streamRawPredict`),
   auth: Auth.none,
-  transport: AnthropicMessages.transport<
-    Omit<AnthropicMessages.AnthropicMessagesBody, "model"> & { readonly anthropic_version: typeof VERSION }
-  >(),
+  framing: AnthropicMessages.framing,
   headers: () => ({ "anthropic-version": HEADER_VERSION }),
 })
 

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

@@ -1,12 +1,10 @@
 import { mergeProviderOptions, type ProviderOptions } from "../schema/index.js"
 import type { OpenAIServiceTier } from "../protocols/utils/openai-options.js"
 import type { Options } from "../protocols/utils/open-responses-options.js"
-import type { ContextManagement } from "../protocols/openai-responses.js"
 
 export type { OpenAIResponseIncludable, OpenAIServiceTier } from "../protocols/utils/openai-options.js"
 
 export type OpenAIOptionsInput = Omit<Options, "serviceTier"> & {
-  readonly contextManagement?: ContextManagement
   readonly serviceTier?: OpenAIServiceTier
   readonly [key: string]: unknown
 }

packages/ai/src/providers/xai.ts

@@ -13,7 +13,7 @@ import type { ProviderPackage } from "../provider-package.js"
 
 export const id = ProviderID.make("xai")
 
-export type XAIProviderOptionsInput = OpenAIOptionsInput & { readonly contextManagement?: never }
+export type XAIProviderOptionsInput = OpenAIOptionsInput
 
 export type LanguageModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
   ProviderAuthOption<"optional"> & {
@@ -32,7 +32,6 @@ export type { XAIImageOptions } from "../protocols/xai-images.js"
 const RESPONSES_WEBSOCKET_ROTATE_AFTER_MS = 24 * 60 * 1000
 
 const responsesRoute = Route.make({
-  compact: XAIResponses.compact,
   id: "openai-responses",
   provider: id,
   providerMetadataKey: "xai",

packages/ai/src/route/client.ts

@@ -13,7 +13,6 @@ import * as ProviderShared from "../protocols/shared.js"
 import type { ProtocolID, ProviderOptions } from "../schema/index.js"
 import {
   AIError,
-  CompactionResponse,
   AIErrorReason,
   GenerationOptions,
   HttpOptions,
@@ -36,7 +35,6 @@ export interface RouteBody<Body> {
 }
 
 export interface Route<Body, Prepared = unknown> {
-  readonly compact?: CompactOperation
   readonly id: string
   readonly provider?: ProviderID
   /** ProviderMetadata namespace emitted and consumed by this route. */
@@ -44,8 +42,6 @@ export interface Route<Body, Prepared = unknown> {
   readonly protocol: ProtocolID
   readonly endpoint: Endpoint.Definition<Body>
   readonly auth: Auth.Definition
-  /** Deployment headers resolved once for every operation, before transport authentication. */
-  readonly headers?: (input: { readonly request: LLMRequest }) => Record<string, string>
   readonly transport: Transport<Body, Prepared, unknown>
   readonly defaults: RouteDefaults
   readonly body: RouteBody<Body>
@@ -154,10 +150,6 @@ export const httpOptions = (input: HttpOptionsInput | undefined) => {
 }
 
 export interface Interface {
-  readonly compact: (
-    request: LLMRequest,
-    options?: Pick<StreamOptions, "http">,
-  ) => Effect.Effect<CompactionResponse, AIError>
   readonly stream: StreamMethod
   readonly generate: GenerateMethod
 }
@@ -175,12 +167,6 @@ export interface GenerateMethod {
   (request: LLMRequest, options?: StreamOptions): Effect.Effect<LLMResponse, AIError>
 }
 
-export type CompactOperation = (
-  request: LLMRequest,
-  executor: RequestExecutor.Interface,
-  options?: Pick<StreamOptions, "http">,
-) => Effect.Effect<CompactionResponse, AIError>
-
 export class Service extends Context.Service<Service, Interface>()("@opencode/LLMClient") {}
 
 const resolveRequestOptions = (request: LLMRequest) => {
@@ -201,7 +187,6 @@ const resolveRequestOptions = (request: LLMRequest) => {
 }
 
 export interface MakeInput<Body, Frame, Event, State> {
-  readonly compact?: CompactOperation
   /** Route id used in diagnostics and prepared request metadata. */
   readonly id: string
   /** Provider identity for route-owned model construction. */
@@ -223,7 +208,6 @@ export interface MakeInput<Body, Frame, Event, State> {
 }
 
 export interface MakeTransportInput<Body, Prepared, Frame, Event, State> {
-  readonly compact?: CompactOperation
   /** Route id used in diagnostics and prepared request metadata. */
   readonly id: string
   /** Provider identity for route-owned model construction. */
@@ -299,14 +283,12 @@ function makeFromTransport<Body, Prepared, Frame, Event, State>(
 
   const build = (routeInput: BuiltRouteInput): Route<Body, Prepared> => {
     const route: Route<Body, Prepared> = {
-      compact: routeInput.compact,
       id: routeInput.id,
       provider: routeInput.provider === undefined ? undefined : ProviderID.make(routeInput.provider),
       providerMetadataKey: routeInput.providerMetadataKey,
       protocol: protocol.id,
       endpoint: routeInput.endpoint,
       auth: routeInput.auth ?? Auth.none,
-      headers: routeInput.headers,
       transport: routeInput.transport,
       defaults: routeInput.defaults ?? {},
       body: protocol.body,
@@ -336,6 +318,7 @@ function makeFromTransport<Body, Prepared, Frame, Event, State>(
           endpoint: routeInput.endpoint,
           auth: routeInput.auth ?? Auth.none,
           encodeBody,
+          headers: routeInput.headers,
           middleware: options?.http,
           webSocket: options?.webSocket,
         }),
@@ -452,7 +435,6 @@ export function make<Body, Prepared, Frame, Event, State>(
   if ("transport" in input) return makeFromTransport(input)
   const protocol = input.protocol
   return makeFromTransport({
-    compact: input.compact,
     id: input.id,
     provider: input.provider,
     providerMetadataKey: input.providerMetadataKey,
@@ -465,19 +447,11 @@ export function make<Body, Prepared, Frame, Event, State>(
   })
 }
 
-const prepareRequest = (request: LLMRequest) => {
+const compile = Effect.fn("LLM.compile")(function* (request: LLMRequest, options?: StreamOptions) {
   const original = applyCachePolicy(resolveRequestOptions(request))
   const sanitized = LLMRequest.update(original, sanitizeSurrogates({ ...LLMRequest.input(original), model: undefined }))
   const tools = [...new Map(sanitized.tools.map((tool) => [tool.name, tool])).values()]
   const resolved = tools.length === sanitized.tools.length ? sanitized : LLMRequest.update(sanitized, { tools })
-  const headers = resolved.model.route.headers?.({ request: resolved })
-  return headers === undefined
-    ? resolved
-    : LLMRequest.update(resolved, { http: mergeHttpOptions(new HttpOptions({ headers }), resolved.http) })
-}
-
-const compile = Effect.fn("LLM.compile")(function* (request: LLMRequest, options?: StreamOptions) {
-  const resolved = prepareRequest(request)
   const route = resolved.model.route
 
   const body = yield* route.body
@@ -536,15 +510,6 @@ export function generate(request: LLMRequest, options?: StreamOptions): Effect.E
   })
 }
 
-export const compact = (
-  request: LLMRequest,
-  options?: Pick<StreamOptions, "http">,
-): Effect.Effect<CompactionResponse, AIError, Service> =>
-  Effect.gen(function* () {
-    const client = yield* Service
-    return yield* client.compact(request, options)
-  })
-
 export const streamRequest = (request: LLMRequest, options?: StreamOptions) =>
   Stream.unwrap(
     Effect.gen(function* () {
@@ -555,28 +520,16 @@ export const streamRequest = (request: LLMRequest, options?: StreamOptions) =>
 export const layer: Layer.Layer<Service, never, RequestExecutor.Service> = Layer.effect(
   Service,
   Effect.gen(function* () {
-    const executor = yield* RequestExecutor.Service
-    const stream = streamRequestWith({ http: executor })
-    return Service.of({
-      stream,
-      generate: generateWith(stream),
-      compact: (request, options) =>
-        Effect.suspend(() => {
-          const operation = request.model.route.compact
-          if (!operation)
-            return ProviderShared.invalidRequest(
-              `${request.model.provider}/${request.model.route.id} does not support explicit compaction`,
-            )
-          return operation(prepareRequest(request), executor, options)
-        }),
+    const stream = streamRequestWith({
+      http: yield* RequestExecutor.Service,
     })
+    return Service.of({ stream, generate: generateWith(stream) })
   }),
 )
 
 export const Route = { make } as const
 
 export const LLMClient = {
-  compact,
   Service,
   layer,
   stream,

packages/ai/src/schema/events.ts

@@ -3,7 +3,6 @@ import { LLM } from "@opencode-ai/schema/llm"
 import { ContentBlockID, ToolCallID } from "./ids.js"
 import {
   Message,
-  CompactionPart,
   ProviderMetadata,
   ToolCallPart,
   ToolOutput,
@@ -63,8 +62,6 @@ export { ProviderMetadata } from "./messages.js"
  * Matches the same escape-hatch field on `LLMEvent`.
  */
 export class Usage extends Schema.Class<Usage>("AI.Usage")({
-  /** Effective input size of the final message iteration, when reported; not billed totals. */
-  contextTokens: Schema.optional(Schema.Number),
   inputTokens: Schema.optional(Schema.Number),
   outputTokens: Schema.optional(Schema.Number),
   nonCachedInputTokens: Schema.optional(Schema.Number),
@@ -75,7 +72,7 @@ export class Usage extends Schema.Class<Usage>("AI.Usage")({
   providerMetadata: Schema.optional(ProviderMetadata),
 }) {
   /**
-   * Non-reasoning output tokens (including compaction summaries) — `outputTokens` minus `reasoningTokens`, clamped
+   * Visible output tokens — `outputTokens` minus `reasoningTokens`, clamped
    * to zero. The one place subtraction happens in this contract; the clamp
    * means a provider reporting `reasoningTokens > outputTokens` produces a
    * harmless zero rather than a negative that crashes downstream schemas.
@@ -91,12 +88,6 @@ export class Usage extends Schema.Class<Usage>("AI.Usage")({
 
 export type UsageInput = Usage | ConstructorParameters<typeof Usage>[0]
 
-/** A replacement context window. Replace prior history with these messages. */
-export class CompactionResponse extends Schema.Class<CompactionResponse>("LLM.CompactionResponse")({
-  messages: Schema.Array(Message),
-  usage: Schema.optional(Usage),
-}) {}
-
 export const StepStart = Schema.Struct({
   type: Schema.tag("step-start"),
   index: Schema.Number,
@@ -250,7 +241,6 @@ export const ProviderErrorEvent = Schema.Struct({
 export type ProviderErrorEvent = Schema.Schema.Type<typeof ProviderErrorEvent>
 
 const llmEventTagged = Schema.Union([
-  CompactionPart,
   StepStart,
   TextStart,
   TextDelta,
@@ -284,7 +274,6 @@ const toolCallID = (value: ToolCallID | string) => ToolCallID.make(value)
  * `events.filter(LLMEvent.guards["tool-call"])`.
  */
 export const LLMEvent = Object.assign(llmEventTagged, {
-  compaction: CompactionPart.make,
   stepStart: StepStart.make,
   textStart: (input: WithID<TextStart, ContentBlockID>) => TextStart.make({ ...input, id: contentBlockID(input.id) }),
   textDelta: (input: WithID<TextDelta, ContentBlockID>) => TextDelta.make({ ...input, id: contentBlockID(input.id) }),
@@ -322,7 +311,6 @@ export const LLMEvent = Object.assign(llmEventTagged, {
     }),
   providerError: ProviderErrorEvent.make,
   is: {
-    compaction: llmEventTagged.guards.compaction,
     stepStart: llmEventTagged.guards["step-start"],
     textStart: llmEventTagged.guards["text-start"],
     textDelta: llmEventTagged.guards["text-delta"],
@@ -345,10 +333,10 @@ export const LLMEvent = Object.assign(llmEventTagged, {
 export type LLMEvent = Schema.Schema.Type<typeof llmEventTagged>
 
 /** Joins deltas per fragment, letting an authoritative end value replace that fragment's accumulated deltas. */
-const joinFragments = (
+const joinFragments = <Delta extends { id: string; text: string }, End extends { id: string; text?: string }>(
   events: ReadonlyArray<LLMEvent>,
-  isDelta: (event: LLMEvent) => event is LLMEvent & { id: string; text: string },
-  isEnd: (event: LLMEvent) => event is LLMEvent & { id: string; text?: string },
+  isDelta: (event: LLMEvent) => event is Extract<LLMEvent, Delta>,
+  isEnd: (event: LLMEvent) => event is Extract<LLMEvent, End>,
 ) => {
   const order: string[] = []
   const parts = new Map<string, string>()
@@ -575,8 +563,6 @@ const reduceToolCall = (state: ResponseState, event: ToolCall): ResponseState =>
 const reduceResponseState = (state: ResponseState, event: LLMEvent): ResponseState => {
   const next = appendEvent(state, event)
   switch (event.type) {
-    case "compaction":
-      return appendContent(next, event)
     case "text-start":
       return ensureText(next, event.id, event.providerMetadata)
     case "text-delta":

packages/ai/src/schema/messages.ts

@@ -9,7 +9,6 @@ import {
   LanguageModelSchema,
   ProviderOptions,
 } from "./options.js"
-import { ProviderID } from "./ids.js"
 
 export const MessageRole = Schema.Literals(["system", "user", "assistant", "tool"])
 export type MessageRole = Schema.Schema.Type<typeof MessageRole>
@@ -53,7 +52,6 @@ export const MediaPart = Schema.Struct({
   filename: Schema.optional(Schema.String),
   cache: Schema.optional(CacheHint),
   metadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
-  providerMetadata: Schema.optional(ProviderMetadata),
 }).annotate({ identifier: "LLM.Content.Media" })
 export type MediaPart = Schema.Schema.Type<typeof MediaPart>
 
@@ -187,40 +185,9 @@ export const ReasoningPart = Schema.Struct({
 }).annotate({ identifier: "LLM.Content.Reasoning" })
 export type ReasoningPart = Schema.Schema.Type<typeof ReasoningPart>
 
-/** A provider-generated context checkpoint, distinct from visible assistant text. */
-type CompactionContent =
-  | { readonly encrypted: string; readonly text?: never }
-  | { readonly text: string | null; readonly encrypted?: never }
-
-const compactionPartSchema = Schema.Struct({
-  type: Schema.Literal("compaction"),
-  provider: ProviderID,
-  id: Schema.optional(Schema.String),
-  encrypted: Schema.optional(Schema.String),
-  /** Null means the provider failed to produce a summary; prior history must be retained. */
-  text: Schema.optional(Schema.NullOr(Schema.String)),
-})
-  .pipe(
-    Schema.refine(
-      (part): part is typeof part & CompactionContent => (part.encrypted !== undefined) !== (part.text !== undefined),
-      { message: "Compaction requires either encrypted content or a summary" },
-    ),
-  )
-  .annotate({ identifier: "LLM.Content.Compaction" })
-export type CompactionPart = typeof compactionPartSchema.Type
-export const CompactionPart = Object.assign(compactionPartSchema, {
-  make: (input: Omit<CompactionPart, "type" | "encrypted" | "text"> & CompactionContent): CompactionPart =>
-    Schema.decodeUnknownSync(compactionPartSchema)({ type: "compaction", ...input }),
-})
-
-export const ContentPart = Schema.Union([
-  TextPart,
-  MediaPart,
-  ToolCallPart,
-  ToolResultPart,
-  ReasoningPart,
-  CompactionPart,
-]).pipe(Schema.toTaggedUnion("type"))
+export const ContentPart = Schema.Union([TextPart, MediaPart, ToolCallPart, ToolResultPart, ReasoningPart]).pipe(
+  Schema.toTaggedUnion("type"),
+)
 export type ContentPart = Schema.Schema.Type<typeof ContentPart>
 
 export class Message extends Schema.Class<Message>("LLM.Message")({
@@ -228,7 +195,6 @@ export class Message extends Schema.Class<Message>("LLM.Message")({
   role: MessageRole,
   content: Schema.Array(ContentPart),
   metadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
-  providerMetadata: Schema.optional(ProviderMetadata),
   native: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
 }) {}
 

packages/ai/src/schema/options.ts

@@ -267,7 +267,7 @@ export const CachePolicyObject = Schema.Struct({
     Schema.Union([
       Schema.Literal("latest-user-message"),
       Schema.Literal("latest-assistant"),
-      Schema.Struct({ tail: Schema.Number }),
+      Schema.Struct({ tail: Schema.Natural }),
     ]),
   ),
   ttlSeconds: Schema.optional(Schema.Number),

packages/ai/src/testing.ts

@@ -4,7 +4,6 @@ import { LLMClient } from "./route/client.js"
 import {
   LLMEvent,
   LLMResponse,
-  CompactionResponse,
   type FinishReasonDetails,
   type AIError,
   type LLMRequest,
@@ -134,16 +133,6 @@ const make = (options: LayerOptions) =>
         }
       })
     const test = Test.of({
-      compact: (request) =>
-        stream(request).pipe(
-          Stream.runFold(LLMResponse.empty, LLMResponse.reduce),
-          Effect.flatMap((state) => {
-            const response = LLMResponse.complete(state)
-            if (!response?.message.content.some((part) => part.type === "compaction"))
-              return Effect.die("TestLLM compaction response must contain a checkpoint and terminal finish event")
-            return Effect.succeed(new CompactionResponse({ messages: [response.message], usage: response.usage }))
-          }),
-        ),
       stream,
       generate: (request) =>
         stream(request).pipe(

packages/ai/src/tool-history.ts

@@ -56,7 +56,6 @@ function normalizeToolMessage(message: Message, pending: Map<string, ToolCallPar
     role: message.role,
     content,
     metadata: message.metadata,
-    providerMetadata: message.providerMetadata,
     native: message.native,
   })
 }

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

@@ -126,38 +126,6 @@ describe("applyCachePolicy", () => {
     }),
   )
 
-  for (const fixture of [
-    { name: "default", cache: undefined, control: { type: "ephemeral" } },
-    { name: "auto", cache: "auto", control: { type: "ephemeral" } },
-    {
-      name: "explicit one-hour",
-      cache: { tools: true, system: true, messages: { tail: 1 }, ttlSeconds: 3600 },
-      control: { type: "ephemeral", ttl: "1h" },
-    },
-    { name: "disabled", cache: "none", control: undefined },
-  ] as const) {
-    it.effect(`Bedrock Messages respects ${fixture.name} caching`, () =>
-      Effect.gen(function* () {
-        const prepared = yield* compileRequest(
-          LLM.request({
-            model: AmazonBedrock.configure({ apiKey: "test" }).messages("anthropic.claude-opus-4-6-v1"),
-            system: "Stable instructions",
-            tools: [
-              { name: "lookup", description: "Look up a value", inputSchema: { type: "object", properties: {} } },
-            ],
-            prompt: "hello",
-            cache: fixture.cache,
-          }),
-        )
-        expect(prepared.body).toMatchObject({
-          tools: [{ name: "lookup", cache_control: fixture.control }],
-          system: [{ type: "text", text: "Stable instructions", cache_control: fixture.control }],
-          messages: [{ role: "user", content: [{ type: "text", text: "hello", cache_control: fixture.control }] }],
-        })
-      }),
-    )
-  }
-
   it.effect("'auto' is a no-op on Gemini (out-of-band caching protocol)", () =>
     Effect.gen(function* () {
       const prepared = yield* compileRequest(

packages/ai/test/compaction-http.test.ts

@@ -1,97 +0,0 @@
-import { expect } from "bun:test"
-import { Effect } from "effect"
-import { FetchHttpClient } from "effect/unstable/http"
-import { LLM, LLMRequest, Message } from "../src/index.js"
-import { LLMClient } from "../src/route/client.js"
-import { OpenAI } from "../src/providers.js"
-import { testEffect } from "./lib/effect.js"
-import { runtimeLayer } from "./lib/http.js"
-import { sseEvents } from "./lib/sse.js"
-
-testEffect(runtimeLayer(FetchHttpClient.layer)).live("compaction and a tool loop work end to end over HTTP", () =>
-  Effect.gen(function* () {
-    const checkpoint = { type: "compaction", id: "cmp_local", encrypted_content: "opaque-local-state" }
-    const calls: string[] = []
-    const server = yield* Effect.acquireRelease(
-      Effect.sync(() =>
-        Bun.serve({
-          hostname: "127.0.0.1",
-          port: 0,
-          async fetch(request) {
-            const path = new URL(request.url).pathname
-            calls.push(path)
-            const body = await request.json()
-            expect(request.headers.get("authorization")).toBe("Bearer fixture")
-            if (path === "/v1/responses/compact") {
-              expect(body.stream).toBeUndefined()
-              return Response.json({
-                object: "response.compaction",
-                output: [checkpoint],
-                usage: { input_tokens: 100, output_tokens: 10, total_tokens: 110 },
-              })
-            }
-            expect(body.input[0]).toEqual(checkpoint)
-            expect(body.stream).toBe(true)
-            if (calls.length === 2)
-              return new Response(
-                sseEvents(
-                  {
-                    type: "response.output_item.done",
-                    item: { type: "function_call", id: "fc_1", call_id: "call_1", name: "lookup", arguments: "{}" },
-                  },
-                  { type: "response.completed", response: { id: "resp_1" } },
-                ),
-                { headers: { "content-type": "text/event-stream" } },
-              )
-            expect(body.input.at(-2)).toMatchObject({ type: "function_call", call_id: "call_1" })
-            expect(body.input.at(-1)).toEqual({ type: "function_call_output", call_id: "call_1", output: "42" })
-            const output = sseEvents(
-              { type: "response.output_item.added", item: { type: "message", id: "msg_1" } },
-              { type: "response.output_text.delta", item_id: "msg_1", delta: "The answer is 42." },
-              {
-                type: "response.output_item.done",
-                item: { type: "message", id: "msg_1", content: [{ type: "output_text", text: "The answer is 42." }] },
-              },
-              { type: "response.completed", response: { id: "resp_2" } },
-            )
-            return new Response(
-              new ReadableStream({
-                start(controller) {
-                  controller.enqueue(new TextEncoder().encode(output.slice(0, 37)))
-                  controller.enqueue(new TextEncoder().encode(output.slice(37)))
-                  controller.close()
-                },
-              }),
-              { headers: { "content-type": "text/event-stream" } },
-            )
-          },
-        }),
-      ),
-      (server) => Effect.sync(() => server.stop(true)),
-    )
-    const model = OpenAI.configure({ apiKey: "fixture", baseURL: `http://127.0.0.1:${server.port}/v1` }).responses(
-      "fixture",
-    )
-    const request = LLM.request({
-      model,
-      prompt: "original",
-      tools: [{ name: "lookup", description: "Lookup a number", inputSchema: { type: "object", properties: {} } }],
-    })
-    const compacted = yield* LLMClient.compact(request)
-    const messages = [...compacted.messages, Message.user("Look up the answer")]
-    const first = yield* LLMClient.generate(LLMRequest.update(request, { messages }))
-    expect(first.toolCalls).toHaveLength(1)
-    const call = first.toolCalls[0]!
-    const last = yield* LLMClient.generate(
-      LLMRequest.update(request, {
-        messages: [
-          ...messages,
-          first.message,
-          Message.tool({ id: call.id, name: call.name, result: "42", resultType: "text" }),
-        ],
-      }),
-    )
-    expect(last.text).toBe("The answer is 42.")
-    expect(calls).toEqual(["/v1/responses/compact", "/v1/responses", "/v1/responses"])
-  }),
-)

packages/ai/test/compaction.test.ts

@@ -1,49 +0,0 @@
-import { expect, test } from "bun:test"
-import { Schema } from "effect"
-import { CompactionPart, LLMEvent, LLMResponse, Message, ProviderID } from "../src/schema/index.js"
-
-test("compaction survives event assembly and message serialization without becoming text", () => {
-  const part = CompactionPart.make({
-    provider: ProviderID.make("openai"),
-    id: "cmp_1",
-    encrypted: "opaque",
-  })
-  const response = LLMResponse.fromEvents([
-    LLMEvent.textStart({ id: "before" }),
-    LLMEvent.textDelta({ id: "before", text: "Before" }),
-    LLMEvent.textEnd({ id: "before" }),
-    part,
-    LLMEvent.textStart({ id: "after" }),
-    LLMEvent.textDelta({ id: "after", text: "After" }),
-    LLMEvent.textEnd({ id: "after" }),
-    LLMEvent.finish({ reason: { normalized: "stop" } }),
-  ])!
-  expect(response.message.content.map((part) => part.type)).toEqual(["text", "compaction", "text"])
-  expect(response.text).toBe("BeforeAfter")
-  expect(response.reasoning).toBe("")
-  expect(response.events.filter(LLMEvent.is.compaction)).toEqual([part])
-  const codec = Schema.fromJsonString(Message)
-  expect(Schema.decodeSync(codec)(Schema.encodeSync(codec)(response.message))).toEqual(response.message)
-})
-
-test("compaction requires exactly one typed representation", () => {
-  const provider = ProviderID.make("anthropic")
-  expect(CompactionPart.make({ provider, text: null })).toEqual({ type: "compaction", provider, text: null })
-  const decode = Schema.decodeUnknownSync(CompactionPart)
-  expect(() => decode({ type: "compaction", provider })).toThrow()
-  expect(() => decode({ type: "compaction", provider, text: "summary", encrypted: "opaque" })).toThrow()
-})
-
-test("tagged content and event guards accept both checkpoint representations", () => {
-  for (const part of [
-    CompactionPart.make({ provider: ProviderID.make("openai"), encrypted: "opaque" }),
-    CompactionPart.make({ provider: ProviderID.make("anthropic"), text: "summary" }),
-    CompactionPart.make({ provider: ProviderID.make("anthropic"), text: null }),
-  ]) {
-    expect(LLMEvent.is.compaction(part)).toBe(true)
-    expect(LLMEvent.guards.compaction(part)).toBe(true)
-    const codec = Schema.fromJsonString(Message)
-    const message = Message.assistant(part)
-    expect(Schema.decodeSync(codec)(Schema.encodeSync(codec)(message))).toEqual(message)
-  }
-})

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

@@ -1,69 +0,0 @@
-import { Effect } from "effect"
-import { CompactionPart, LLM, LLMClient, LLMEvent, Message, ProviderID } from "../../src/index.js"
-import { OpenAI, Anthropic, AmazonBedrock } from "../../src/providers.js"
-
-const openai = OpenAI.configure({
-  apiKey: "test",
-  providerOptions: { contextManagement: [{ type: "compaction", compactThreshold: 100000 }] },
-}).responses("gpt-5.3-codex")
-LLMClient.compact(LLM.request({ model: openai, prompt: "hello" }))
-
-const checkpoint = CompactionPart.make({ provider: ProviderID.make("openai"), id: "cmp_1", encrypted: "opaque" })
-const provider = ProviderID.make("anthropic")
-CompactionPart.make({ provider, text: "summary" })
-CompactionPart.make({ provider, text: null })
-// @ts-expect-error A checkpoint must have a representation.
-CompactionPart.make({ provider })
-// @ts-expect-error Encrypted and summary representations are mutually exclusive.
-CompactionPart.make({ provider, encrypted: "opaque", text: "summary" })
-// @ts-expect-error A failed summary cannot also carry encrypted content.
-LLMEvent.compaction({ provider, encrypted: "opaque", text: null })
-// @ts-expect-error The canonical message type also enforces the invariant.
-Message.assistant({ type: "compaction", provider })
-if (checkpoint.encrypted !== undefined) {
-  checkpoint.encrypted satisfies string
-  checkpoint.text satisfies undefined
-}
-if (checkpoint.text !== undefined) {
-  checkpoint.text satisfies string | null
-  checkpoint.encrypted satisfies undefined
-}
-checkpoint.encrypted
-// @ts-expect-error Compaction parts do not contain a generic provider payload.
-checkpoint.value
-LLMClient.compact(LLM.request({ model: openai, prompt: "hello" })).pipe(
-  Effect.map((result) => {
-    result.messages
-    // @ts-expect-error Compaction returns replacement history, not a synthetic assistant message.
-    result.message
-  }),
-)
-LLM.request({
-  model: openai,
-  providerOptions: {
-    // @ts-expect-error A token threshold is numeric.
-    contextManagement: [{ type: "compaction", compactThreshold: "100000" }],
-  },
-})
-for (const model of [
-  Anthropic.configure().model("claude-opus-4-6"),
-  AmazonBedrock.configure().messages("anthropic.claude-opus-4-6-v1"),
-]) {
-  LLM.request({
-    model,
-    providerOptions: {
-      contextManagement: {
-        edits: [
-          { type: "compact_20260112", pauseAfterCompaction: true, instructions: "Summarize without using tools" },
-        ],
-      },
-    },
-  })
-  LLM.request({
-    model,
-    providerOptions: {
-      // @ts-expect-error A pause setting is boolean.
-      contextManagement: { edits: [{ type: "compact_20260112", pauseAfterCompaction: "yes" }] },
-    },
-  })
-}

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

@@ -1,170 +0,0 @@
-import { expect } from "bun:test"
-import { Effect, Schema } from "effect"
-import { LLM, LLMRequest, Message } from "../../src/index.js"
-import { LLMClient } from "../../src/route/client.js"
-import { Anthropic, GoogleVertexMessages } from "../../src/providers/index.js"
-import { testEffect } from "../lib/effect.js"
-import { dynamicResponse, fixedResponse } from "../lib/http.js"
-import { sseEvents } from "../lib/sse.js"
-
-for (const fixture of [
-  {
-    name: "empty iterations fall back to top-level usage",
-    usage: { input_tokens: 2, output_tokens: 3, cache_read_input_tokens: null, iterations: [] },
-    expected: { inputTokens: 2, outputTokens: 3, totalTokens: 5, contextTokens: undefined },
-  },
-  {
-    name: "compaction-only usage has no post-compaction context size",
-    usage: {
-      input_tokens: 0,
-      output_tokens: 0,
-      iterations: [{ type: "compaction", input_tokens: 7, cache_read_input_tokens: 3, output_tokens: 2 }],
-    },
-    expected: { inputTokens: 10, outputTokens: 2, totalTokens: 12, contextTokens: undefined },
-  },
-  {
-    name: "partially reported iterations preserve known totals",
-    usage: {
-      iterations: [
-        { type: "compaction", input_tokens: 7, cache_creation_input_tokens: 2 },
-        { type: "message", output_tokens: 3 },
-      ],
-    },
-    expected: { inputTokens: 9, outputTokens: 3, totalTokens: 12, contextTokens: undefined },
-  },
-  {
-    name: "missing counters remain unknown rather than zero",
-    usage: { iterations: [{ type: "message" }] },
-    expected: { inputTokens: undefined, outputTokens: undefined, totalTokens: undefined, contextTokens: undefined },
-  },
-]) {
-  testEffect(
-    fixedResponse(
-      sseEvents(
-        { type: "message_start", message: { usage: fixture.usage } },
-        { type: "message_delta", delta: { stop_reason: "end_turn" } },
-        { type: "message_stop" },
-      ),
-    ),
-  ).effect(fixture.name, () =>
-    Effect.gen(function* () {
-      const result = yield* LLMClient.generate(
-        LLM.request({
-          model: Anthropic.configure({ apiKey: "test" }).model("claude-opus-4-6"),
-          prompt: "hello",
-        }),
-      )
-      expect(result.usage).toMatchObject(fixture.expected)
-    }),
-  )
-}
-
-for (const model of [
-  Anthropic.configure({ apiKey: "test" }).model("claude-opus-4-6"),
-  GoogleVertexMessages.configure({ accessToken: "test", project: "test" }).model("claude-opus-4-6"),
-]) {
-  for (const summary of ["Summary of the conversation", null]) {
-    const block = { type: "compaction", content: summary }
-    testEffect(
-      dynamicResponse(({ request, text, respond }) =>
-        Effect.sync(() => {
-          const body = JSON.parse(text)
-          expect(request.headers["anthropic-beta"]).toBe("existing-beta,compact-2026-01-12")
-          if (body.messages.length === 1) {
-            expect(body.context_management.edits).toEqual([
-              {
-                type: "compact_20260112",
-                trigger: { type: "input_tokens", value: 50000 },
-                pause_after_compaction: true,
-              },
-            ])
-          }
-          if (body.messages.length > 1) {
-            expect(body.messages[1].content).toEqual([block])
-            expect(body.context_management).toBeUndefined()
-          }
-          return respond(
-            sseEvents(
-              { type: "message_start", message: { usage: { input_tokens: 50000, output_tokens: 0 } } },
-              { type: "content_block_start", index: 0, content_block: { type: "compaction", content: null } },
-              { type: "content_block_delta", index: 0, delta: { type: "compaction_delta", content: summary } },
-              { type: "content_block_stop", index: 0 },
-              {
-                type: "message_delta",
-                delta: { stop_reason: "compaction" },
-                usage: {
-                  input_tokens: 1000,
-                  output_tokens: 5,
-                  iterations: [
-                    { type: "compaction", input_tokens: 50000, output_tokens: 1000, cache_read_input_tokens: 10 },
-                    { type: "message", input_tokens: 1000, output_tokens: 5 },
-                  ],
-                },
-              },
-              { type: "message_stop" },
-            ),
-            { headers: { "content-type": "text/event-stream" } },
-          )
-        }),
-      ),
-    ).effect(
-      `${model.provider} replays ${summary === null ? "failed" : "successful"} compaction with billing and context usage`,
-      () =>
-        Effect.gen(function* () {
-          const request = LLM.request({
-            model,
-            prompt: "hello",
-            http: { headers: { "anthropic-beta": "existing-beta" } },
-            providerOptions: {
-              contextManagement: {
-                edits: [
-                  {
-                    type: "compact_20260112",
-                    trigger: { type: "input_tokens", value: 50000 },
-                    pauseAfterCompaction: true,
-                  },
-                ],
-              },
-            },
-          })
-          const first = yield* LLMClient.generate(request)
-          expect(first.finishReason.raw).toBe("compaction")
-          expect(first.message.content).toEqual([{ type: "compaction", provider: model.provider, text: summary }])
-          expect(first.text).toBe("")
-          expect(first.usage?.inputTokens).toBe(51010)
-          expect(first.usage?.outputTokens).toBe(1005)
-          expect(first.usage?.totalTokens).toBe(52015)
-          expect(first.usage?.contextTokens).toBe(1000)
-          const codec = Schema.fromJsonString(Message)
-          const message = Schema.decodeSync(codec)(Schema.encodeSync(codec)(first.message))
-          yield* LLMClient.generate(
-            LLMRequest.update(request, {
-              providerOptions: {},
-              messages: [...request.messages, message, Message.user("continue")],
-            }),
-          )
-        }),
-    )
-  }
-}
-
-for (const events of [
-  [{ type: "content_block_start", index: 0, content_block: { type: "compaction", content: 42 } }],
-  [{ type: "content_block_delta", index: 0, delta: { type: "compaction_delta", content: "no start" } }],
-  [
-    { type: "content_block_start", index: 0, content_block: { type: "compaction", content: null } },
-    { type: "message_stop" },
-  ],
-]) {
-  testEffect(fixedResponse(sseEvents(...events))).effect(
-    `rejects malformed compaction lifecycle: ${JSON.stringify(events)}`,
-    () =>
-      Effect.gen(function* () {
-        const error = yield* LLMClient.generate(
-          LLM.request({ model: Anthropic.configure({ apiKey: "test" }).model("claude-opus-4-6"), prompt: "hello" }),
-        ).pipe(Effect.flip)
-        expect(error.reason._tag).toBe("InvalidProviderOutput")
-        expect(error.reason.http?.status).toBe(200)
-      }),
-  )
-}

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

@@ -631,10 +631,45 @@ describe("Bedrock Converse route", () => {
       )
       const response = yield* LLMClient.generate(baseRequest).pipe(Effect.provide(fixedBytes(body)))
 
+      expect(response.events.filter((event) => event.type === "finish")).toHaveLength(1)
       expect(response.usage).toMatchObject({ inputTokens: 5, outputTokens: 2, totalTokens: 7 })
     }),
   )
 
+  it.effect("retains metadata usage that arrives before messageStop", () =>
+    Effect.gen(function* () {
+      const body = eventStreamBody(
+        ["metadata", { usage: { inputTokens: 5, outputTokens: 2, totalTokens: 7 } }],
+        ["messageStop", { stopReason: "end_turn" }],
+      )
+      const response = yield* LLMClient.generate(baseRequest).pipe(Effect.provide(fixedBytes(body)))
+
+      expect(response.events.filter((event) => event.type === "finish")).toHaveLength(1)
+      expect(response.finishReason).toEqual({ normalized: "stop", raw: "end_turn" })
+      expect(response.usage).toMatchObject({ inputTokens: 5, outputTokens: 2, totalTokens: 7 })
+    }),
+  )
+
+  it.effect("rejects metadata-only streams as incomplete with HTTP context", () =>
+    Effect.gen(function* () {
+      const error = yield* LLMClient.generate(baseRequest).pipe(
+        Effect.provide(
+          fixedBytes(eventStreamBody(["metadata", { usage: { inputTokens: 5, outputTokens: 2, totalTokens: 7 } }])),
+        ),
+        Effect.flip,
+      )
+
+      expect(error.reason).toMatchObject({
+        _tag: "InvalidProviderOutput",
+        classification: "incomplete-stream",
+        http: {
+          status: 200,
+          headers: { "content-type": "application/vnd.amazon.eventstream" },
+        },
+      })
+    }),
+  )
+
   it.effect("assembles streamed tool call input", () =>
     Effect.gen(function* () {
       const body = eventStreamBody(

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

@@ -1,89 +0,0 @@
-import { EventStreamCodec } from "@smithy/eventstream-codec"
-import { fromUtf8, toUtf8 } from "@smithy/util-utf8"
-import { expect } from "bun:test"
-import { Effect } from "effect"
-import { LLM, LLMRequest, Message } from "../../src/index.js"
-import { LLMClient } from "../../src/route/client.js"
-import { AmazonBedrock } from "../../src/providers/index.js"
-import { testEffect } from "../lib/effect.js"
-import { dynamicResponse, fixedResponse } from "../lib/http.js"
-
-const codec = new EventStreamCodec(toUtf8, fromUtf8)
-const frame = (event: object) =>
-  codec.encode({
-    headers: { ":message-type": { type: "string", value: "event" }, ":event-type": { type: "string", value: "chunk" } },
-    body: new TextEncoder().encode(JSON.stringify({ bytes: Buffer.from(JSON.stringify(event)).toString("base64") })),
-  })
-const response = Buffer.concat(
-  [
-    { type: "message_start", message: { usage: { input_tokens: 60000 } } },
-    { type: "content_block_start", index: 0, content_block: { type: "compaction", content: null } },
-    { type: "content_block_delta", index: 0, delta: { type: "compaction_delta", content: "Summary" } },
-    { type: "content_block_stop", index: 0 },
-    { type: "content_block_start", index: 1, content_block: { type: "text", text: "" } },
-    { type: "content_block_delta", index: 1, delta: { type: "text_delta", text: "Hello" } },
-    { type: "content_block_stop", index: 1 },
-    { type: "message_delta", delta: { stop_reason: "end_turn" }, usage: { output_tokens: 10 } },
-    { type: "message_stop" },
-  ].map(frame),
-)
-
-for (const auth of [
-  { apiKey: "test" },
-  { credentials: { accessKeyId: "test", secretAccessKey: "test", region: "us-west-2" } },
-]) {
-  testEffect(
-    dynamicResponse(({ request, text, respond }) =>
-      Effect.sync(() => {
-        expect(request.url).toBe(
-          "https://bedrock-runtime.us-west-2.amazonaws.com/model/anthropic.claude-opus-4-6-v1%3A0/invoke-with-response-stream",
-        )
-        expect(request.headers.authorization).toStartWith(auth.apiKey ? "Bearer test" : "AWS4-HMAC-SHA256")
-        const body = JSON.parse(text)
-        expect(body.model).toBeUndefined()
-        expect(body.stream).toBeUndefined()
-        expect(body.anthropic_version).toBe("bedrock-2023-05-31")
-        expect(body.anthropic_beta).toEqual(["compact-2026-01-12"])
-        expect(body.context_management.edits).toEqual([{ type: "compact_20260112" }])
-        if (body.messages.length > 1)
-          expect(body.messages[1].content[0]).toEqual({ type: "compaction", content: "Summary" })
-        return respond(response, { headers: { "content-type": "application/vnd.amazon.eventstream" } })
-      }),
-    ),
-  ).effect(`Bedrock Messages compaction round trip with ${auth.apiKey ? "bearer" : "SigV4"} authentication`, () =>
-    Effect.gen(function* () {
-      const model = AmazonBedrock.configure({ ...auth, region: "us-west-2" }).messages("anthropic.claude-opus-4-6-v1:0")
-      const request = LLM.request({
-        model,
-        prompt: "hello",
-        providerOptions: { contextManagement: { edits: [{ type: "compact_20260112" }] } },
-      })
-      const first = yield* LLMClient.generate(request)
-      expect(first.text).toBe("Hello")
-      expect(first.message.content.map((part) => part.type)).toEqual(["compaction", "text"])
-      yield* LLMClient.generate(
-        LLMRequest.update(request, { messages: [...request.messages, first.message, Message.user("continue")] }),
-      )
-    }),
-  )
-}
-
-testEffect(
-  fixedResponse(
-    codec.encode({
-      headers: {
-        ":message-type": { type: "string", value: "exception" },
-        ":exception-type": { type: "string", value: "throttlingException" },
-      },
-      body: new TextEncoder().encode(JSON.stringify({ message: "Too many requests", trace: "keep-original" })),
-    }),
-  ),
-).effect("Bedrock Messages retains the original exception frame", () =>
-  Effect.gen(function* () {
-    const error = yield* LLMClient.generate(
-      LLM.request({ model: AmazonBedrock.configure({ apiKey: "test" }).messages("claude"), prompt: "hello" }),
-    ).pipe(Effect.flip)
-    expect(error.reason.body).toContain("keep-original")
-    expect(error.reason.http?.status).toBe(200)
-  }),
-)

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

@@ -1,50 +0,0 @@
-import { expect } from "bun:test"
-import { Effect, Stream } from "effect"
-import { LLM, LLMRequest, Message } from "../../src/index.js"
-import { LLMClient, WebSocketTransport } from "../../src/route.js"
-import { OpenAI } from "../../src/providers.js"
-import { testEffect } from "../lib/effect.js"
-import { fixedResponse } from "../lib/http.js"
-
-testEffect(fixedResponse("unexpected HTTP fallback")).effect(
-  "WebSocket responses preserve compaction options and replay state",
-  () =>
-    Effect.gen(function* () {
-      const checkpoint = { type: "compaction", id: "cmp_ws", encrypted_content: "opaque" }
-      const sent: unknown[] = []
-      const webSocket = WebSocketTransport.makeDirect({
-        open: () =>
-          Effect.succeed({
-            sendText: (message) =>
-              Effect.sync(() => {
-                const body = JSON.parse(message)
-                expect(body.context_management).toEqual([{ type: "compaction", compact_threshold: 100000 }])
-                expect(body.stream).toBeUndefined()
-                if (sent.length) expect(body.input[1]).toEqual(checkpoint)
-                sent.push(body)
-              }),
-            messages: Stream.fromIterable(
-              [
-                { type: "response.created", response: { id: "resp_ws" } },
-                { type: "response.output_item.done", item: checkpoint },
-                { type: "response.completed", response: { id: "resp_ws", output: [checkpoint] } },
-              ].map((event) => JSON.stringify(event)),
-            ),
-            close: Effect.void,
-          }),
-      })
-      const request = LLM.request({
-        model: OpenAI.configure({ apiKey: "test" }).responses("gpt-5.3-codex"),
-        prompt: "hello",
-        providerOptions: { contextManagement: [{ type: "compaction", compactThreshold: 100000 }] },
-      })
-      const first = yield* LLMClient.generate(request, { webSocket })
-      expect(first.message.content).toHaveLength(1)
-      expect(first.message.content[0]?.type).toBe("compaction")
-      yield* LLMClient.generate(
-        LLMRequest.update(request, { messages: [...request.messages, first.message, Message.user("continue")] }),
-        { webSocket },
-      )
-      expect(sent).toHaveLength(2)
-    }),
-)

packages/ai/test/provider/compaction.recorded.test.ts

@@ -1,91 +0,0 @@
-import { expect } from "bun:test"
-import { Effect } from "effect"
-import { LLM, LLMRequest, Message } from "../../src/index.js"
-import { LLMClient } from "../../src/route/client.js"
-import { OpenAI, XAI, Anthropic } from "../../src/providers.js"
-import { recordedTests } from "../recorded-test.js"
-
-const history = [
-  Message.user("Remember the project codename COPPER-ORBIT-42."),
-  Message.assistant(
-    "The project codename is COPPER-ORBIT-42. " + "We reviewed the implementation and tests. ".repeat(1000),
-  ),
-]
-
-for (const provider of [
-  {
-    id: "openai",
-    key: "OPENAI_API_KEY",
-    model: OpenAI.configure({ apiKey: process.env.OPENAI_API_KEY ?? "fixture" }).responses("gpt-5.3-codex"),
-  },
-  {
-    id: "xai",
-    key: "XAI_API_KEY",
-    model: XAI.configure({ apiKey: process.env.XAI_API_KEY ?? "fixture" }).responses("grok-4.6"),
-  },
-]) {
-  recordedTests({ prefix: `${provider.id}-compaction`, provider: provider.id, requires: [provider.key] }).effect(
-    "compacts and continues with the provider checkpoint",
-    () =>
-      Effect.gen(function* () {
-        const request = LLM.request({ model: provider.model, messages: history, generation: { maxTokens: 1024 } })
-        const compacted = yield* LLMClient.compact(request)
-        const result = yield* LLMClient.generate(
-          LLMRequest.update(request, {
-            messages: [
-              ...compacted.messages,
-              Message.user("What is the project codename? Reply only with the codename."),
-            ],
-          }),
-        )
-        expect(result.text).toContain("COPPER-ORBIT-42")
-      }),
-    120000,
-  )
-}
-
-recordedTests({
-  prefix: "anthropic-compaction",
-  provider: "anthropic",
-  requires: ["ANTHROPIC_API_KEY"],
-  options: { redact: { allowRequestHeaders: ["anthropic-version", "anthropic-beta"] } },
-}).effect(
-  "automatically compacts and continues after a pause",
-  () =>
-    Effect.gen(function* () {
-      const model = Anthropic.configure({ apiKey: process.env.ANTHROPIC_API_KEY ?? "fixture" }).model(
-        "claude-sonnet-4-6",
-      )
-      const request = LLM.request({
-        model,
-        messages: [
-          Message.user(
-            "Remember the project codename COPPER-ORBIT-42. " +
-              "The implementation and tests were reviewed. ".repeat(10000),
-          ),
-        ],
-        generation: { maxTokens: 4096 },
-        providerOptions: {
-          contextManagement: {
-            edits: [
-              { type: "compact_20260112", trigger: { type: "input_tokens", value: 50000 }, pauseAfterCompaction: true },
-            ],
-          },
-        },
-      })
-      const first = yield* LLMClient.generate(request)
-      expect(first.finishReason.raw).toBe("compaction")
-      expect(first.message.content.some((part) => part.type === "compaction")).toBe(true)
-      const result = yield* LLMClient.generate(
-        LLMRequest.update(request, {
-          messages: [
-            ...request.messages,
-            first.message,
-            Message.user("What is the project codename? Reply only with the codename."),
-          ],
-        }),
-      )
-      expect(result.text).toContain("COPPER-ORBIT-42")
-    }),
-  120000,
-)

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

@@ -1,136 +0,0 @@
-import { expect } from "bun:test"
-import { Effect, Schema } from "effect"
-import { LLM, LLMRequest, Message } from "../../src/index.js"
-import { LLMClient } from "../../src/route/client.js"
-import { OpenAI, Azure, XAI } from "../../src/providers/index.js"
-import { testEffect } from "../lib/effect.js"
-import { dynamicResponse, fixedResponse } from "../lib/http.js"
-import { sseEvents } from "../lib/sse.js"
-
-const checkpoint = { type: "compaction", id: "cmp_1", encrypted_content: "opaque" }
-const response = sseEvents(
-  { type: "response.output_item.done", item: checkpoint },
-  {
-    type: "response.completed",
-    response: { id: "resp_1", output: [checkpoint], usage: { input_tokens: 10, output_tokens: 2, total_tokens: 12 } },
-  },
-)
-
-for (const model of [
-  OpenAI.configure({ apiKey: "test" }).responses("gpt-5.3-codex"),
-  Azure.configure({ apiKey: "test", resourceName: "test" }).responses("deployment"),
-]) {
-  testEffect(
-    dynamicResponse(({ text, respond }) =>
-      Effect.sync(() => {
-        const body = JSON.parse(text)
-        expect(body.context_management).toEqual([{ type: "compaction", compact_threshold: 100000 }])
-        expect(body.store).toBe(false)
-        if (body.input.length > 1) expect(body.input[1]).toEqual(checkpoint)
-        return respond(response, { headers: { "content-type": "text/event-stream" } })
-      }),
-    ),
-  ).effect(`${model.provider} compaction survives generation, serialization, and a second request`, () =>
-    Effect.gen(function* () {
-      const request = LLM.request({
-        model,
-        prompt: "hello",
-        providerOptions: { contextManagement: [{ type: "compaction", compactThreshold: 100000 }] },
-      })
-      const first = yield* LLMClient.generate(request)
-      expect(first.message.content).toHaveLength(1)
-      expect(first.message.content[0]?.type).toBe("compaction")
-      expect(first.text).toBe("")
-      const codec = Schema.fromJsonString(Message)
-      const message = Schema.decodeSync(codec)(Schema.encodeSync(codec)(first.message))
-      yield* LLMClient.generate(
-        LLMRequest.update(request, { messages: [...request.messages, message, Message.user("continue")] }),
-      )
-      const rejected = yield* LLMClient.generate(
-        LLMRequest.update(request, {
-          model: XAI.configure({ apiKey: "test" }).responses("grok-4.6"),
-          providerOptions: {},
-          messages: [message],
-        }),
-      ).pipe(Effect.flip)
-      expect(rejected.reason._tag).toBe("InvalidRequest")
-    }),
-  )
-}
-
-testEffect(fixedResponse(sseEvents({ type: "response.completed", response: { output: [checkpoint] } }))).effect(
-  "recovers compaction from the terminal output when item completion is absent",
-  () =>
-    Effect.gen(function* () {
-      const result = yield* LLMClient.generate(
-        LLM.request({ model: OpenAI.configure({ apiKey: "test" }).responses("gpt-5.3-codex"), prompt: "hello" }),
-      )
-      expect(result.message.content).toHaveLength(1)
-      expect(result.message.content[0]?.type).toBe("compaction")
-    }),
-)
-
-testEffect(
-  fixedResponse(sseEvents({ type: "response.output_item.done", item: { type: "compaction", id: "cmp_bad" } })),
-).effect("rejects incomplete compaction payloads without publishing a checkpoint", () =>
-  Effect.gen(function* () {
-    const error = yield* LLMClient.generate(
-      LLM.request({ model: OpenAI.configure({ apiKey: "test" }).responses("gpt-5.3-codex"), prompt: "hello" }),
-    ).pipe(Effect.flip)
-    expect(error.reason._tag).toBe("InvalidProviderOutput")
-    expect(error.reason.body).toContain("cmp_bad")
-  }),
-)
-
-const textItem = {
-  type: "message",
-  id: "msg_after",
-  role: "assistant",
-  content: [{ type: "output_text", text: "After checkpoint" }],
-}
-
-for (const completed of [false, true]) {
-  testEffect(
-    fixedResponse(
-      sseEvents(
-        { type: "response.output_item.added", output_index: 0, item: { type: "compaction", id: checkpoint.id } },
-        ...(completed ? [{ type: "response.output_item.done", output_index: 0, item: checkpoint }] : []),
-        { type: "response.output_item.added", output_index: 1, item: textItem },
-        { type: "response.output_text.delta", output_index: 1, item_id: textItem.id, delta: "After checkpoint" },
-        { type: "response.output_item.done", output_index: 1, item: textItem },
-        { type: "response.completed", response: { id: "resp_1", output: [checkpoint, textItem] } },
-      ),
-    ),
-  ).effect(completed ? "keeps streamed checkpoints before later text" : "rejects order-unsafe terminal recovery", () =>
-    Effect.gen(function* () {
-      const request = LLM.request({ model: OpenAI.configure({ apiKey: "test" }).responses("fixture"), prompt: "hello" })
-      if (completed) {
-        const response = yield* LLMClient.generate(request)
-        expect(response.message.content.map((part) => part.type)).toEqual(["compaction", "text"])
-        return
-      }
-      const error = yield* LLMClient.generate(request).pipe(Effect.flip)
-      expect(error.reason._tag).toBe("InvalidProviderOutput")
-      expect(error.message).toContain("Cannot recover a compaction checkpoint")
-      expect(error.reason.body).toContain("response.completed")
-      expect(error.reason.http?.status).toBe(200)
-    }),
-  )
-}
-
-testEffect(
-  fixedResponse(
-    sseEvents({
-      type: "response.completed",
-      response: { output: [{ type: "compaction", encrypted_content: "opaque" }] },
-    }),
-  ),
-).effect("rejects terminal checkpoints missing an id", () =>
-  Effect.gen(function* () {
-    const error = yield* LLMClient.generate(
-      LLM.request({ model: OpenAI.configure({ apiKey: "test" }).responses("fixture"), prompt: "hello" }),
-    ).pipe(Effect.flip)
-    expect(error.reason._tag).toBe("InvalidProviderOutput")
-    expect(error.message).toContain("missing its id")
-  }),
-)

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

@@ -62,6 +62,62 @@ describe("provider error retention", () => {
     )
   }
 
+  it.effect("classifies a message-less Gemini 429 and retains its event and HTTP context", () =>
+    Effect.gen(function* () {
+      const body = JSON.stringify({
+        error: { code: 429, status: "RESOURCE_EXHAUSTED", details: { opaque: [1, 2] } },
+        trace: { opaque: "outer" },
+      })
+      const error = yield* LLMClient.generate(
+        LLM.request({ model: Google.configure(options).model("gemini"), prompt: "hello" }),
+      ).pipe(
+        Effect.provide(
+          fixedResponse(sseEvents(body), {
+            headers: { "content-type": "text/event-stream", "x-provider-trace": "trace-1" },
+          }),
+        ),
+        Effect.flip,
+      )
+
+      expect(error.message).toBe("RESOURCE_EXHAUSTED")
+      expect(error.reason._tag).toBe("RateLimit")
+      expect(error.reason.body).toBe(body)
+      expect(error.reason.http).toMatchObject({ status: 200, headers: { "x-provider-trace": "trace-1" } })
+      expect(error.reason.http?.url).toStartWith("https://provider.test/")
+    }),
+  )
+
+  it.effect("rejects a malformed non-record Gemini error", () =>
+    Effect.gen(function* () {
+      const body = JSON.stringify({ error: "RESOURCE_EXHAUSTED", trace: { opaque: "outer" } })
+      const error = yield* LLMClient.generate(
+        LLM.request({ model: Google.configure(options).model("gemini"), prompt: "hello" }),
+      ).pipe(Effect.provide(fixedResponse(sseEvents(body))), Effect.flip)
+
+      expect(error.reason._tag).toBe("InvalidProviderOutput")
+      expect(error.message).toContain("Invalid google/gemini stream event")
+      expect(error.reason.body).toBe(body)
+      expect(error.reason.http?.status).toBe(200)
+    }),
+  )
+
+  it.effect("rejects and retains an explicit null Gemini error", () =>
+    Effect.gen(function* () {
+      const body = JSON.stringify({ error: null, trace: { opaque: "outer" } })
+      const error = yield* LLMClient.generate(
+        LLM.request({ model: Google.configure(options).model("gemini"), prompt: "hello" }),
+      ).pipe(
+        Effect.provide(fixedResponse(sseEvents(body), { headers: { "x-provider-trace": "trace-null" } })),
+        Effect.flip,
+      )
+
+      expect(error.reason._tag).toBe("InvalidProviderOutput")
+      expect(error.reason.body).toBe(body)
+      expect(error.reason.http).toMatchObject({ status: 200, headers: { "x-provider-trace": "trace-null" } })
+      expect(error.reason.http?.url).toStartWith("https://provider.test/")
+    }),
+  )
+
   it.effect("retains malformed provider frames and the original decode cause", () =>
     Effect.gen(function* () {
       const body = '{"type":"error","error":{"message":42,"opaque":{"nested":true}},"trace":"outer"}'

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

@@ -1,377 +0,0 @@
-import { expect } from "bun:test"
-import { Effect, Schema } from "effect"
-import { LLM, LLMRequest, Message } from "../../src/index.js"
-import { LLMClient, Route } from "../../src/route/client.js"
-import { Auth } from "../../src/route/auth.js"
-import { Endpoint } from "../../src/route/endpoint.js"
-import { OpenAIResponses } from "../../src/protocols/openai-responses.js"
-import { OpenAI, Azure, XAI, Anthropic, AmazonBedrockMantle } from "../../src/providers/index.js"
-import { testEffect } from "../lib/effect.js"
-import { dynamicResponse, fixedResponse } from "../lib/http.js"
-import { sseEvents } from "../lib/sse.js"
-
-const checkpoint = { type: "compaction", id: "cmp_1", encrypted_content: "opaque" }
-const retained = {
-  type: "message",
-  role: "user",
-  id: "msg_1",
-  status: "completed",
-  content: [{ type: "input_text", text: "retained" }],
-}
-const output = [retained, checkpoint]
-
-testEffect(
-  dynamicResponse(({ request, text, respond }) =>
-    Effect.sync(() => {
-      expect(request.headers["x-deployment"]).toBe("fixture")
-      expect(request.headers["x-override"]).toBe("request")
-      expect(request.headers["x-default"]).toBe("configured")
-      expect(request.headers.authorization).toBe("Bearer test")
-      expect(new URL(request.url).searchParams.get("api-version")).toBe("fixture")
-      expect(new URL(request.url).searchParams.get("trace")).toBe("request")
-      if (new URL(request.url).pathname.endsWith("/compact")) {
-        expect(JSON.parse(text)).toEqual({
-          model: "overlaid",
-          input: [{ role: "user", content: [{ type: "input_text", text: "hello" }] }],
-          instructions: "request instructions",
-          previous_response_id: "resp_previous",
-        })
-        return respond(JSON.stringify({ object: "response.compaction", output }))
-      }
-      return respond(sseEvents({ type: "response.completed", response: { id: "resp_1" } }))
-    }),
-  ),
-).effect("generation and compaction share deployment headers, defaults, auth, query, and middleware", () =>
-  Effect.gen(function* () {
-    const headers: string[] = []
-    const middleware: string[] = []
-    const route = Route.make({
-      id: "compaction-headers",
-      provider: "openai",
-      protocol: OpenAIResponses.protocol,
-      compact: OpenAIResponses.route.compact,
-      transport: OpenAIResponses.httpTransport,
-      endpoint: Endpoint.path(({ body }) => `/${body.model}/responses`, {
-        baseURL: "https://example.com",
-        query: { "api-version": "fixture" },
-      }),
-      auth: Auth.bearer("test"),
-      headers: ({ request }) => {
-        expect(request.providerOptions?.store).toBe(false)
-        headers.push(String(request.model.id))
-        return { "x-deployment": "fixture", "x-override": "route" }
-      },
-      defaults: {
-        headers: { "x-default": "configured", "x-override": "configured" },
-        providerOptions: { store: false },
-        http: { body: { instructions: "default instructions" } },
-      },
-    })
-    const request = LLM.request({
-      model: route.model({ id: "fixture" }),
-      prompt: "hello",
-      system: "system instructions",
-      http: {
-        headers: { "x-override": "request" },
-        query: { trace: "request" },
-        body: {
-          model: "overlaid",
-          instructions: "request instructions",
-          previous_response_id: "resp_previous",
-          store: false,
-          stream: true,
-        },
-      },
-    })
-    const options: Parameters<typeof LLMClient.compact>[1] = {
-      http: (request, next) => {
-        middleware.push(new URL(request.url).pathname)
-        return next(request)
-      },
-    }
-    yield* LLMClient.generate(request, options)
-    yield* LLMClient.compact(request, options)
-    expect(headers).toEqual(["fixture", "fixture"])
-    expect(middleware).toEqual(["/fixture/responses", "/fixture/responses/compact"])
-  }),
-)
-
-for (const model of [
-  OpenAI.configure({ apiKey: "test" }).responses("fixture"),
-  Azure.configure({ apiKey: "test", resourceName: "test" }).responses("fixture"),
-  XAI.configure({ apiKey: "test" }).responses("fixture"),
-]) {
-  const item = {
-    type: model.provider === "xai" ? "x_search_call" : "computer_call",
-    id: "hosted_1",
-    status: "completed",
-  }
-  testEffect(
-    dynamicResponse(({ request, text, respond }) =>
-      Effect.sync(() => {
-        expect(new URL(request.url).pathname).toEndWith("/responses/compact")
-        expect(JSON.parse(text)).toEqual({ model: "fixture", input: [item], instructions: "Keep the context" })
-        return respond(JSON.stringify({ object: "response.compaction", output: [checkpoint] }))
-      }),
-    ),
-  ).effect(`${model.provider} compacts provider-specific history without lowering generation settings`, () =>
-    Effect.gen(function* () {
-      const request = LLM.request({
-        model,
-        system: "Keep the context",
-        messages: [
-          Message.assistant({
-            type: "tool-result",
-            id: item.id,
-            name: item.type,
-            result: { type: "json", value: item },
-            providerExecuted: true,
-            providerMetadata: { [model.route.providerMetadataKey ?? model.provider]: { itemId: item.id } },
-          }),
-        ],
-      })
-      for (const candidate of [
-        LLMRequest.update(request, {
-          tools: [
-            { name: "unsupported", description: "Generation only", inputSchema: {}, native: { unsupported: {} } },
-          ],
-        }),
-        LLMRequest.update(request, { providerOptions: { contextManagement: "invalid-generation-option" } }),
-      ]) {
-        const error = yield* LLMClient.generate(candidate).pipe(Effect.flip)
-        expect(error.reason._tag).toBe("InvalidRequest")
-        const response = yield* LLMClient.compact(candidate)
-        expect(response.messages[0]?.content[0]?.type).toBe("compaction")
-      }
-    }),
-  )
-}
-
-const retainedItems = [
-  retained,
-  {
-    type: "message",
-    id: "msg_assistant",
-    role: "assistant",
-    status: "completed",
-    phase: "commentary",
-    content: [
-      { type: "output_text", text: "First" },
-      { type: "output_text", text: "Second" },
-    ],
-  },
-  {
-    type: "reasoning",
-    id: "rs_1",
-    summary: [
-      { type: "summary_text", text: "Thinking" },
-      { type: "summary_text", text: "More thinking" },
-    ],
-    encrypted_content: "reasoning-state",
-  },
-  { type: "reasoning", id: "rs_2", summary: [], encrypted_content: "hidden-reasoning" },
-  {
-    type: "message",
-    id: "msg_media",
-    role: "user",
-    content: [
-      { type: "input_image", image_url: "https://example.com/image.png" },
-      { type: "input_file", filename: "report.pdf", file_data: "data:application/pdf;base64,cGRm" },
-      { type: "input_file", filename: "other.pdf", file_url: "https://example.com/report.pdf" },
-    ],
-  },
-  checkpoint,
-]
-
-testEffect(
-  dynamicResponse(({ request, text, respond }) =>
-    Effect.sync(() => {
-      if (new URL(request.url).pathname.endsWith("/compact"))
-        return respond(JSON.stringify({ object: "response.compaction", output: retainedItems }))
-      expect(JSON.parse(text).input).toEqual(retainedItems)
-      return respond(sseEvents({ type: "response.completed", response: { id: "resp_1" } }), {
-        headers: { "content-type": "text/event-stream" },
-      })
-    }),
-  ),
-).effect("retained messages, reasoning, and media are ordinary typed conversation parts", () =>
-  Effect.gen(function* () {
-    const request = LLM.request({
-      model: OpenAI.configure({ apiKey: "test" }).responses("gpt-5.3-codex"),
-      prompt: "hello",
-    })
-    const compacted = yield* LLMClient.compact(request)
-    expect(compacted.messages.map((message) => message.role)).toEqual([
-      "user",
-      "assistant",
-      "assistant",
-      "assistant",
-      "user",
-      "assistant",
-    ])
-    expect(compacted.messages[1]?.content).toEqual([
-      { type: "text", text: "First" },
-      { type: "text", text: "Second" },
-    ])
-    expect(compacted.messages[2]?.content.map((part) => part.type)).toEqual(["reasoning", "reasoning"])
-    expect(compacted.messages[4]?.content.map((part) => part.type)).toEqual(["media", "media", "media"])
-    const codec = Schema.fromJsonString(Schema.Array(Message))
-    const messages = Schema.decodeSync(codec)(Schema.encodeSync(codec)(compacted.messages))
-    yield* LLMClient.generate(LLMRequest.update(request, { messages }))
-  }),
-)
-
-for (const item of [
-  { type: "unknown_provider_item", data: "do not hide in a compaction part" },
-  {
-    type: "message",
-    role: "user",
-    content: [{ type: "input_image", image_url: "https://example.com/image.png", detail: 42 }],
-  },
-  { type: "message", role: "user", content: [] },
-  {
-    type: "message",
-    role: "assistant",
-    content: [{ type: "input_image", image_url: "https://example.com/image.png" }],
-  },
-  { type: "message", role: "user", content: [{ type: "input_file", filename: "missing.pdf" }] },
-]) {
-  testEffect(fixedResponse(JSON.stringify({ object: "response.compaction", output: [item, checkpoint] }))).effect(
-    `rejects unsupported compact output: ${JSON.stringify(item)}`,
-    () =>
-      Effect.gen(function* () {
-        const error = yield* LLMClient.compact(
-          LLM.request({ model: OpenAI.configure({ apiKey: "test" }).responses("gpt-5.3-codex"), prompt: "hello" }),
-        ).pipe(Effect.flip)
-        expect(error.reason._tag).toBe("InvalidProviderOutput")
-        expect(error.reason.body).toContain(JSON.stringify(item))
-        expect(error.reason.http?.status).toBe(200)
-      }),
-  )
-}
-
-for (const model of [
-  OpenAI.configure({ apiKey: "test" }).responses("fixture"),
-  Azure.configure({ apiKey: "test", resourceName: "test" }).responses("fixture"),
-  XAI.configure({ apiKey: "test" }).responses("fixture"),
-]) {
-  const images = [undefined, "low", "high", "auto"].map((detail) => ({
-    type: "input_image",
-    image_url: "https://example.com/image.png",
-    ...(detail === undefined ? {} : { detail }),
-  }))
-  testEffect(
-    dynamicResponse(({ request, text, respond }) =>
-      Effect.sync(() => {
-        if (new URL(request.url).pathname.endsWith("/compact"))
-          return respond(
-            JSON.stringify({
-              object: "response.compaction",
-              output: [{ type: "message", role: "user", content: images }, checkpoint],
-            }),
-          )
-        expect(JSON.parse(text).input[0].content).toEqual(images)
-        return respond(sseEvents({ type: "response.completed", response: { id: "resp_1" } }))
-      }),
-    ),
-  ).effect(`${model.provider} preserves retained image detail through serialization and replay`, () =>
-    Effect.gen(function* () {
-      const request = LLM.request({ model, prompt: "hello" })
-      const compacted = yield* LLMClient.compact(request)
-      const codec = Schema.fromJsonString(Schema.Array(Message))
-      const messages = Schema.decodeSync(codec)(Schema.encodeSync(codec)(compacted.messages))
-      yield* LLMClient.generate(LLMRequest.update(request, { messages }))
-    }),
-  )
-}
-
-testEffect(fixedResponse("must not execute")).effect("xAI rejects automatic compaction options", () =>
-  Effect.gen(function* () {
-    const request = LLMRequest.update(
-      LLM.request({ model: XAI.configure({ apiKey: "test" }).responses("grok-4.6"), prompt: "hello" }),
-      { providerOptions: { contextManagement: [{ type: "compaction" }] } },
-    )
-    const error = yield* LLMClient.generate(request).pipe(Effect.flip)
-    expect(error.reason._tag).toBe("InvalidRequest")
-    expect(error.message).toContain("LLMClient.compact")
-  }),
-)
-
-for (const model of [
-  OpenAI.configure({ apiKey: "test" }).responses("gpt-5.3-codex"),
-  Azure.configure({ apiKey: "test", resourceName: "test" }).responses("deployment"),
-  XAI.configure({ apiKey: "test" }).responses("grok-4.6"),
-]) {
-  testEffect(
-    dynamicResponse(({ request, text, respond }) =>
-      Effect.sync(() => {
-        const body = JSON.parse(text)
-        expect(request.method).toBe("POST")
-        expect(request.headers[model.provider === "azure" ? "api-key" : "authorization"]).toBe(
-          model.provider === "azure" ? "test" : "Bearer test",
-        )
-        if (new URL(request.url).pathname.endsWith("/responses/compact")) {
-          expect(body).toEqual({
-            model: model.id,
-            input: [{ role: "user", content: [{ type: "input_text", text: "original" }] }],
-            instructions: "system",
-          })
-          return respond(
-            JSON.stringify({
-              object: "response.compaction",
-              output,
-              usage: { input_tokens: 1000, output_tokens: 10, total_tokens: 1010 },
-            }),
-            { headers: { "content-type": "application/json" } },
-          )
-        }
-        expect(new URL(request.url).pathname.endsWith("/responses")).toBe(true)
-        expect(body.input).toEqual([...output, { role: "user", content: [{ type: "input_text", text: "continue" }] }])
-        return respond(sseEvents({ type: "response.completed", response: { id: "resp_1", output: [] } }), {
-          headers: { "content-type": "text/event-stream" },
-        })
-      }),
-    ),
-  ).effect(`${model.provider} explicitly compacts and replays the entire canonical window`, () =>
-    Effect.gen(function* () {
-      const request = LLM.request({ model, prompt: "original", system: "system", http: { body: { store: false } } })
-      const compacted = yield* LLMClient.compact(request)
-      expect(compacted.usage?.totalTokens).toBe(1010)
-      expect(compacted.messages.map((message) => message.role)).toEqual(["user", "assistant"])
-      expect(compacted.messages[0]?.content).toEqual([{ type: "text", text: "retained" }])
-      expect(compacted.messages[1]?.content).toEqual([
-        { type: "compaction", provider: model.provider, id: "cmp_1", encrypted: "opaque" },
-      ])
-      const codec = Schema.fromJsonString(Schema.Array(Message))
-      const messages = Schema.decodeSync(codec)(Schema.encodeSync(codec)(compacted.messages))
-      yield* LLMClient.generate(LLMRequest.update(request, { messages: [...messages, Message.user("continue")] }))
-    }),
-  )
-}
-
-for (const model of [
-  Anthropic.configure({ apiKey: "test" }).model("claude-opus-4-6"),
-  AmazonBedrockMantle.configure({ apiKey: "test" }).responses("model"),
-]) {
-  testEffect(fixedResponse("must not execute")).effect(
-    `${model.route.id} does not inherit an unsupported compact endpoint`,
-    () =>
-      Effect.gen(function* () {
-        const error = yield* LLMClient.compact(LLM.request({ model, prompt: "hello" })).pipe(Effect.flip)
-        expect(error.reason._tag).toBe("InvalidRequest")
-      }),
-  )
-}
-
-testEffect(
-  fixedResponse(JSON.stringify({ object: "response.compaction", output: [retained], debug: "original payload" })),
-).effect("invalid explicit compaction preserves the original response and HTTP context", () =>
-  Effect.gen(function* () {
-    const error = yield* LLMClient.compact(
-      LLM.request({ model: OpenAI.configure({ apiKey: "test" }).responses("gpt-5.3-codex"), prompt: "hello" }),
-    ).pipe(Effect.flip)
-    expect(error.reason._tag).toBe("InvalidProviderOutput")
-    expect(error.reason.body).toContain("original payload")
-    expect(error.reason.http?.status).toBe(200)
-  }),
-)

packages/app/component-tests/timeline-virtualizer.spec.ts

@@ -8,6 +8,30 @@ story.beforeEach(async ({ mount }) => {
   await expect(component.getByRole("textbox", { name: "Prompt", exact: true })).toBeVisible()
 })
 
+story("spaces the first mobile message without changing desktop spacing", async ({ page }) => {
+  await page.setViewportSize({ width: 390, height: 844 })
+  await page.evaluate(async (fixture) => {
+    const { mountTimelineVirtualizer } = await import(fixture)
+    mountTimelineVirtualizer({ count: 1, rowHeight: 60, immediate: true })
+  }, fixture)
+  const root = page.getByTestId("timeline-virtualizer-fixture")
+  await root.getByRole("button", { name: "Complete Markdown", exact: true }).click()
+  const content = root.locator("[data-timeline-virtual-content]")
+  await expect(content).toHaveCSS("visibility", "visible")
+  const gap = () =>
+    root.locator('[data-timeline-key="user-message:message-0"]').evaluate((element) => {
+      const viewport = element.closest("[data-scrollable]")!
+      return element.getBoundingClientRect().top - viewport.getBoundingClientRect().top
+    })
+  await expect.poll(gap).toBe(16)
+  await root.evaluate((element) => element.setAttribute("dir", "rtl"))
+  await expect.poll(gap).toBe(16)
+  await page.setViewportSize({ width: 1280, height: 900 })
+  await expect.poll(gap).toBe(0)
+  await page.setViewportSize({ width: 390, height: 844 })
+  await expect.poll(gap).toBe(16)
+})
+
 story("bounds the cheap suffix and reveals only ready measured rows", async ({ page }) => {
   await page.evaluate(async (fixture) => {
     const { mountTimelineVirtualizer } = await import(fixture)

packages/app/e2e/regression/mobile-files.spec.ts

@@ -0,0 +1,110 @@
+import { expect, test } from "@playwright/test"
+import { fixture, pageMessages } from "../performance/timeline/session-timeline-stress.fixture"
+import { stressSessionHref } from "../performance/timeline/timeline-test-helpers"
+import { mockOpenCodeServer } from "../utils/mock-server"
+
+for (const direction of ["ltr", "rtl"] as const) {
+  test(`mobile files browse, search, switch, and close shared file tabs in ${direction}`, async ({ page }) => {
+    await page.setViewportSize({ width: 390, height: 844 })
+    await mockOpenCodeServer(page, {
+      directory: fixture.directory,
+      project: fixture.project,
+      sessions: fixture.sessions,
+      provider: fixture.provider,
+      pageMessages,
+      fileList: (path) =>
+        path
+          ? []
+          : ["first.ts", "second.ts"].map((name) => ({
+              name,
+              path: name,
+              absolute: `${fixture.directory}/${name}`,
+              type: "file",
+              ignored: false,
+            })),
+      fileContent: (path) => `contents:${path}`,
+      findFiles: ({ query }) => ["first.ts", "second.ts"].filter((path) => path.includes(query)),
+    })
+    await page.goto(stressSessionHref(fixture.targetID))
+    const navigation = page.getByRole("tablist", { name: "Session view", exact: true })
+    await navigation.getByRole("tab", { name: "Files", exact: true }).click()
+    const files = page.locator('[data-slot="session-mobile-files"]')
+    await expect(files.getByRole("button", { name: "first.ts", exact: true })).toBeVisible()
+    await page.evaluate((direction) => (document.documentElement.dir = direction), direction)
+    await expect(files.locator('[data-slot="session-mobile-files-header"]')).toHaveCSS("border-bottom-width", "0px")
+    await expect
+      .poll(() =>
+        files.getByRole("tablist", { name: "Open files", exact: true }).evaluate((element) => {
+          const header = element.closest('[data-slot="session-mobile-files-header"]')!
+          const separator = getComputedStyle(element, "::before")
+          return {
+            height: separator.height,
+            fullWidth: parseFloat(separator.width) === header.clientWidth,
+            start: separator.insetInlineStart,
+            bottom: separator.bottom,
+          }
+        }),
+      )
+      .toEqual({ height: "1px", fullWidth: true, start: "0px", bottom: "0px" })
+    await files.getByRole("button", { name: "first.ts", exact: true }).click()
+    await expect(files.getByText("contents:first.ts", { exact: true })).toBeVisible()
+    await files.locator('[data-column-number="1"]').click()
+    const editor = files.locator('[data-component="line-comment-v2"][data-variant="editor"]')
+    await expect(editor.getByRole("textbox")).toBeVisible()
+    for (const width of [390, 700]) {
+      await page.setViewportSize({ width, height: 844 })
+      await expect
+        .poll(async () => {
+          const panel = await files.boundingBox()
+          const comment = await editor.boundingBox()
+          if (!panel || !comment) return false
+          return Math.abs(comment.x - panel.x - 12) < 2 && Math.abs(comment.width - panel.width + 24) < 2
+        })
+        .toBe(true)
+    }
+    await editor.getByRole("textbox").fill("Full-width file comment")
+    await editor.getByRole("button", { name: "Comment", exact: true }).click()
+    const comment = files.locator('[data-component="line-comment-v2"][data-variant="display"]')
+    await expect(comment).toContainText("Full-width file comment")
+    await expect
+      .poll(async () => {
+        const panel = await files.boundingBox()
+        const card = await comment.boundingBox()
+        if (!panel || !card) return false
+        return Math.abs(card.x - panel.x - 12) < 2 && Math.abs(card.width - panel.width + 24) < 2
+      })
+      .toBe(true)
+    await page.setViewportSize({ width: 390, height: 844 })
+    await expect(files.getByRole("combobox", { name: "Filter files", exact: true })).toBeHidden()
+    await files.getByRole("button", { name: "All files", exact: true }).click()
+    await files.getByRole("combobox", { name: "Filter files", exact: true }).fill("second")
+    await files.getByRole("option", { name: "second.ts", exact: true }).click()
+    await expect(files.getByText("contents:second.ts", { exact: true })).toBeVisible()
+    const openTabs = files.getByRole("tablist", { name: "Open files", exact: true })
+    await expect(openTabs.getByRole("tab")).toHaveText(["first.ts", "second.ts"])
+    await expect
+      .poll(() =>
+        openTabs.getByRole("tab", { name: "second.ts", exact: true }).evaluate((element) => {
+          const tab = element.closest('[data-slot="tabs-v2-trigger-wrapper"]')!
+          const header = element.closest('[data-slot="session-mobile-files-header"]')!
+          return Math.abs(tab.getBoundingClientRect().bottom - header.getBoundingClientRect().bottom) < 1
+        }),
+      )
+      .toBe(true)
+    await openTabs.getByRole("tab", { name: "first.ts", exact: true }).click()
+    await expect(files.getByText("contents:first.ts", { exact: true })).toBeVisible()
+    await navigation.getByRole("tab", { name: "Session", exact: true }).click()
+    await navigation.getByRole("tab", { name: "Files", exact: true }).click()
+    await expect(files.getByText("contents:first.ts", { exact: true })).toBeVisible()
+    await files
+      .locator('[data-slot="tabs-v2-trigger-wrapper"]')
+      .filter({ has: page.getByRole("tab", { name: "first.ts", exact: true }) })
+      .getByRole("button", { name: "Close tab", exact: true })
+      .click()
+    await expect(openTabs.getByRole("tab")).toHaveText(["second.ts"])
+    await expect(files.getByText("contents:second.ts", { exact: true })).toBeVisible()
+    await files.getByRole("button", { name: "Close tab", exact: true }).click()
+    await expect(files.getByRole("combobox", { name: "Filter files", exact: true })).toBeVisible()
+    await expect(openTabs.getByRole("tab")).toHaveCount(0)
+  })
+}

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

@@ -0,0 +1,43 @@
+import { expect, test } from "@playwright/test"
+import { fixture, pageMessages } from "../performance/timeline/session-timeline-stress.fixture"
+import { stressSessionHref } from "../performance/timeline/timeline-test-helpers"
+import { mockOpenCodeServer } from "../utils/mock-server"
+
+test("opening changed files selects the requested tab before file loading completes", async ({ page }) => {
+  await page.setViewportSize({ width: 390, height: 844 })
+  const loading = Promise.withResolvers<void>()
+  await mockOpenCodeServer(page, {
+    directory: fixture.directory,
+    project: fixture.project,
+    sessions: fixture.sessions,
+    provider: fixture.provider,
+    pageMessages,
+    fileList: () => [],
+    fileContent: async (path) => {
+      if (path === "second.ts") await loading.promise
+      return `contents:${path}`
+    },
+    vcsDiff: ["first.ts", "second.ts"].map((file) => ({
+      file,
+      status: "modified",
+      additions: 1,
+      deletions: 1,
+      patch: `diff --git a/${file} b/${file}\n--- a/${file}\n+++ b/${file}\n@@ -1 +1 @@\n-before\n+after\n`,
+    })),
+  })
+  await page.goto(stressSessionHref(fixture.targetID))
+  const navigation = page.getByRole("tablist", { name: "Session view", exact: true })
+  const files = page.locator('[data-slot="session-mobile-files"]')
+  for (const file of ["first.ts", "second.ts", "first.ts", "second.ts"]) {
+    await navigation.getByRole("tab", { name: "Changes", exact: true }).click()
+    const diff = page.locator(`[data-component="session-review"] [data-file="${file}"]`)
+    const header = diff.getByRole("button", { name: file, exact: true })
+    await expect(header).toBeEnabled()
+    if ((await header.getAttribute("aria-expanded")) === "false") await header.click()
+    await diff.getByRole("button", { name: "Open file", exact: true }).click()
+    await expect(navigation.getByRole("tab", { name: "Files", exact: true })).toHaveAttribute("aria-selected", "true")
+    await expect(files.getByRole("tab", { name: file, exact: true })).toHaveAttribute("aria-selected", "true")
+    if (file === "second.ts") loading.resolve()
+    await expect(files.getByText(`contents:${file}`, { exact: true })).toBeVisible()
+  }
+})

packages/app/e2e/regression/mobile-review-summary.spec.ts

@@ -0,0 +1,138 @@
+import { expect, test } from "@playwright/test"
+import { fixture } from "../performance/timeline/session-timeline-stress.fixture"
+import { mockStressTimeline, stressSessionHref } from "../performance/timeline/timeline-test-helpers"
+
+for (const direction of ["ltr", "rtl"] as const) {
+  test(`mobile change summaries appear only for expanded diffs in ${direction}`, async ({ page }) => {
+    await page.setViewportSize({ width: 390, height: 844 })
+    await mockStressTimeline(page, {
+      vcsDiff: [
+        {
+          file: "added.ts",
+          status: "added",
+          additions: 1,
+          deletions: 0,
+          patch:
+            "diff --git a/added.ts b/added.ts\n--- /dev/null\n+++ b/added.ts\n@@ -0,0 +1 @@\n+export const added = 1\n",
+        },
+        {
+          file: "removed.ts",
+          status: "deleted",
+          additions: 0,
+          deletions: 1,
+          patch:
+            "diff --git a/removed.ts b/removed.ts\n--- a/removed.ts\n+++ /dev/null\n@@ -1 +0,0 @@\n-export const removed = 1\n",
+        },
+        {
+          file: "modified.ts",
+          status: "modified",
+          additions: 1,
+          deletions: 1,
+          patch: `diff --git a/modified.ts b/modified.ts\n--- a/modified.ts\n+++ b/modified.ts\n@@ -1 +1 @@\n-export const value = 1\n+export const value = "${"long content ".repeat(30)}"\n`,
+        },
+      ],
+    })
+    await page.goto(stressSessionHref(fixture.targetID))
+    await page.getByRole("tab", { name: "Changes", exact: true }).click()
+    const review = page.locator('[data-component="session-review"]')
+    await expect(review.getByRole("button", { name: "Expand all", exact: true })).toBeVisible()
+    await page.evaluate((direction) => (document.documentElement.dir = direction), direction)
+
+    await expect(review.locator('[data-file="added.ts"] [data-slot="accordion-trigger"]')).toHaveCSS(
+      "border-top-width",
+      "0px",
+    )
+    await expect(review.locator('[data-file="modified.ts"] [data-slot="accordion-trigger"]')).toHaveCSS(
+      "border-bottom-width",
+      "0px",
+    )
+
+    for (const change of [
+      { file: "added.ts", status: "Added", additions: "+1", deletions: "-0" },
+      { file: "removed.ts", status: "Removed", additions: "+0", deletions: "-1" },
+      { file: "modified.ts", status: undefined, additions: "+1", deletions: "-1" },
+    ]) {
+      const item = review.locator(`[data-file="${change.file}"]`)
+      const trigger = item.getByRole("button", { name: change.file, exact: true })
+      const summary = item.locator('[data-slot="session-review-change-summary"]')
+      await expect(trigger).toHaveAttribute("aria-expanded", "false")
+      await expect(trigger.locator('[data-component="diff-changes"]')).toHaveCount(0)
+      await expect(trigger.locator('[data-slot="session-review-change"]')).toHaveCount(0)
+      await expect(summary).toHaveCount(0)
+      await trigger.click()
+      await expect(trigger).toHaveAttribute("aria-expanded", "true")
+      if (change.file === "modified.ts") {
+        await expect(item.locator('[data-slot="accordion-content"]')).toHaveCSS("border-bottom-width", "0px")
+        await expect(trigger).not.toHaveCSS("border-bottom-width", "0px")
+      }
+      await expect(summary).toBeVisible()
+      await expect(summary.getByRole("button", { name: "Open file", exact: true })).toBeVisible()
+      await expect(summary.locator('[data-slot="diff-changes-additions"]')).toHaveText(change.additions)
+      await expect(summary.locator('[data-slot="diff-changes-deletions"]')).toHaveText(change.deletions)
+      if (change.status) await expect(summary.getByText(change.status, { exact: true })).toBeVisible()
+      await trigger.click()
+      await expect(trigger).toHaveAttribute("aria-expanded", "false")
+      await expect(summary).toHaveCount(0)
+    }
+    await expect(review.locator('[data-slot="session-review-view-button"]')).toHaveCount(0)
+    const modified = review.locator('[data-file="modified.ts"]')
+    await modified.getByRole("button", { name: "modified.ts", exact: true }).click()
+    await expect(modified.locator("[data-line-number-content]")).toHaveText(["1", "1"])
+    await expect(modified.locator("[data-diff]")).not.toHaveAttribute("data-disable-line-numbers")
+    await expect(modified.locator("[data-diff]")).toHaveAttribute("data-overflow", "wrap")
+    await expect(review.getByRole("button", { name: "Diff options", exact: true })).toHaveCount(0)
+    await page.keyboard.press("Control+,")
+    const settings = page.getByTestId("settings-screen")
+    const wrap = settings.getByRole("switch", { name: "Wrap lines", exact: true })
+    const wrapControl = settings.locator('[data-action="settings-mobile-diff-wrap"] [data-slot="switch-control"]')
+    await expect(wrap).toBeChecked()
+    await wrapControl.click()
+    await expect(wrap).not.toBeChecked()
+    await expect
+      .poll(() => page.evaluate(() => JSON.parse(localStorage.getItem("settings.v3") ?? "{}").general?.mobileDiffWrap))
+      .toBe(false)
+    await settings.getByRole("button", { name: "Back to app", exact: true }).click()
+    await expect(modified.locator("[data-diff]")).toHaveAttribute("data-overflow", "scroll")
+    await expect
+      .poll(() => modified.locator("[data-code]").evaluate((element) => element.scrollWidth > element.clientWidth))
+      .toBe(true)
+    await modified.locator("[data-code]").evaluate((element) => {
+      element.scrollLeft = 100
+    })
+    await expect
+      .poll(() => modified.locator("[data-code]").evaluate((element) => Math.abs(element.scrollLeft)))
+      .toBeGreaterThan(0)
+    const navigation = page.getByRole("tablist", { name: "Session view", exact: true })
+    await navigation.getByRole("tab", { name: "Session", exact: true }).click()
+    await navigation.getByRole("tab", { name: "Changes", exact: true }).click()
+    await expect(modified.locator("[data-diff]")).toHaveAttribute("data-overflow", "scroll")
+    await page.keyboard.press("Control+,")
+    await expect(wrap).not.toBeChecked()
+    await wrapControl.click()
+    await expect(wrap).toBeChecked()
+    await expect
+      .poll(() => page.evaluate(() => JSON.parse(localStorage.getItem("settings.v3") ?? "{}").general?.mobileDiffWrap))
+      .toBe(true)
+    await settings.getByRole("button", { name: "Back to app", exact: true }).click()
+    await expect(modified.locator("[data-diff]")).toHaveAttribute("data-overflow", "wrap")
+    const openFile = modified.getByRole("button", { name: "Open file", exact: true })
+    await expect(openFile).toBeVisible()
+    await expect
+      .poll(async () => {
+        const button = await openFile.boundingBox()
+        const summary = await modified.locator('[data-slot="session-review-change-summary"]').boundingBox()
+        if (!button || !summary) return false
+        return direction === "ltr"
+          ? button.x > summary.x + summary.width / 2
+          : button.x + button.width < summary.x + summary.width / 2
+      })
+      .toBe(true)
+    await openFile.click()
+    await expect(
+      page.getByRole("tablist", { name: "Session view", exact: true }).getByRole("tab", { name: "Files", exact: true }),
+    ).toHaveAttribute("aria-selected", "true")
+    const files = page.locator('[data-slot="session-mobile-files"]')
+    await expect(files.getByRole("tab", { name: "modified.ts", exact: true })).toHaveAttribute("aria-selected", "true")
+    await expect(files).toHaveAttribute("data-browsing", "false")
+  })
+}

packages/app/e2e/regression/mobile-session-views.spec.ts

@@ -0,0 +1,186 @@
+import { expect, test } from "@playwright/test"
+import { fixture, pageMessages } from "../performance/timeline/session-timeline-stress.fixture"
+import { installStressSessionTabs, stressSessionHref } from "../performance/timeline/timeline-test-helpers"
+import { mockOpenCodeServer } from "../utils/mock-server"
+
+for (const position of ["top", "bottom"] as const) {
+  test(`mobile session tabs switch views and keep the terminal cached with ${position} navigation`, async ({
+    page,
+  }) => {
+    await page.setViewportSize({ width: 390, height: 844 })
+    await mockOpenCodeServer(page, {
+      directory: fixture.directory,
+      project: fixture.project,
+      sessions: fixture.sessions,
+      provider: fixture.provider,
+      pageMessages,
+      fileList: () => [],
+    })
+    await installStressSessionTabs(page)
+    await page.addInitScript(
+      (position) =>
+        localStorage.setItem("settings.v3", JSON.stringify({ general: { mobileTitlebarPosition: position } })),
+      position,
+    )
+    await page.route("**/api/pty*", (route) =>
+      route.fulfill({
+        json: {
+          location: { directory: fixture.directory, project: { id: fixture.project.id, directory: fixture.directory } },
+          data: {
+            id: "pty_mobile_views",
+            title: "Terminal 1",
+            command: "sh",
+            args: [],
+            cwd: fixture.directory,
+            status: "running",
+            pid: 1,
+          },
+        },
+      }),
+    )
+    await page.routeWebSocket("**/api/pty/pty_mobile_views/connect", () => undefined)
+    await page.route("**/api/pty/pty_mobile_views/connect-token*", (route) =>
+      route.fulfill({
+        json: {
+          location: { directory: fixture.directory, project: { id: fixture.project.id, directory: fixture.directory } },
+          data: { ticket: "e2e-ticket", expires_in: 60 },
+        },
+      }),
+    )
+    await page.goto(stressSessionHref(fixture.targetID))
+
+    const tabs = page.getByRole("tablist", { name: "Session view", exact: true })
+    const navigation = page.locator('[data-slot="session-mobile-view-navigation"]')
+    const more = navigation.getByRole("button", { name: "More options", exact: true })
+    const picker = tabs.getByRole("tab", { selected: true })
+    const message = page.locator(
+      `[data-timeline-row="UserMessage"][data-message-id="${fixture.expected.targetMessageIDs.at(-1)}"]`,
+    )
+    const composer = page.getByRole("textbox", { name: "Prompt", exact: true })
+    await expect(picker).toHaveText("Session")
+    await expect(message).toBeVisible()
+    await expect(composer).toBeVisible()
+    await expect(tabs.getByRole("tab")).toHaveText(["Session", "Changes", "Files", "Terminal"])
+    await expect(tabs).toHaveCSS("padding-left", "0px")
+    await expect(tabs).toHaveCSS("padding-right", "0px")
+    await expect
+      .poll(async () => {
+        const bounds = await navigation.boundingBox()
+        return !!bounds && bounds.x >= 8 && bounds.x <= 9 && bounds.width >= 372 && bounds.width <= 374
+      })
+      .toBe(true)
+    await expect
+      .poll(async () => {
+        const bar = await tabs.boundingBox()
+        const input = await composer.boundingBox()
+        const panel = await page.locator('[data-slot="session-chat-panel"]').boundingBox()
+        return !!bar && !!input && !!panel && Math.abs(bar.y - panel.y) <= 1 && bar.y + bar.height <= input.y
+      })
+      .toBe(true)
+    await expect(page.locator("[data-session-title]")).toHaveCount(0)
+    await expect(page.locator('[data-slot="mobile-tabs-trigger"]')).toContainText(fixture.expected.targetTitle)
+    await page.getByRole("button", { name: "Tabs", exact: true }).click()
+    const drawer = page.getByRole("dialog", { name: "Tabs", exact: true })
+    await expect(drawer).toHaveAttribute("data-open", "")
+    await expect(drawer).not.toHaveAttribute("data-transitioning")
+    await expect(drawer.getByRole("button", { name: "Settings", exact: true })).toBeInViewport()
+    await drawer.getByRole("button", { name: "Settings", exact: true }).click()
+    await expect(page.getByTestId("settings-screen")).toBeVisible()
+    await page.getByRole("button", { name: "Back to app", exact: true }).click()
+    await page.getByRole("button", { name: "Tabs", exact: true }).click()
+    await expect(drawer).not.toHaveAttribute("data-transitioning")
+    await expect(drawer.getByRole("button", { name: "Settings", exact: true })).toBeInViewport()
+    await page.keyboard.press("Escape")
+    await expect(drawer).toBeHidden()
+
+    await more.click()
+    await page.getByRole("menuitem", { name: "Usage", exact: true }).click()
+    await expect(picker).toHaveCount(0)
+    await expect(page.getByText("Total Cost", { exact: true })).toBeVisible()
+    const usage = page.locator('[data-slot="session-usage-content"]')
+    await expect(usage).toHaveCSS("padding-top", "16px")
+    await expect(usage).toHaveCSS("padding-inline-start", "16px")
+    await expect(usage).toHaveCSS("padding-inline-end", "16px")
+    await expect(composer).toBeHidden()
+
+    await more.click()
+    await page.getByRole("menuitem", { name: "Status", exact: true }).click()
+    const status = page.getByRole("dialog", { name: "Status", exact: true })
+    await expect(status.getByRole("tab", { name: "MCP", exact: true })).toBeVisible()
+    await status.getByRole("tab", { name: "Plugins", exact: true }).click()
+    await expect(status.getByText("opencode.json", { exact: true })).toBeVisible()
+    await status.getByRole("button", { name: "Close", exact: true }).click()
+    await expect(status).toBeHidden()
+    await expect(more).toBeFocused()
+
+    await more.click()
+    await page.getByRole("menuitem", { name: "Session details", exact: true }).click()
+    const details = page.getByRole("dialog", { name: "Session details", exact: true })
+    await expect(details.getByText(fixture.project.name, { exact: true })).toBeVisible()
+    await expect(details.getByRole("button", { name: "No changes", exact: true })).toBeVisible()
+    await details.getByRole("button", { name: "Close", exact: true }).click()
+    await expect(details).toBeHidden()
+    await expect(more).toBeFocused()
+    await more.click()
+    await page.getByRole("menuitem", { name: "Session details", exact: true }).click()
+    await expect(details.getByRole("button", { name: "No changes", exact: true })).toBeVisible()
+    await expect(details).not.toHaveAttribute("data-transitioning")
+    await page.keyboard.press("Escape")
+    await expect(details).toBeHidden()
+    await expect(more).toBeFocused()
+    await more.click()
+    await page.getByRole("menuitem", { name: "Session details", exact: true }).click()
+    await details.getByRole("button", { name: "No changes", exact: true }).click()
+    await expect(details).toBeHidden()
+    await expect(picker).toHaveText("Changes")
+    await expect(page.getByText("No uncommitted changes yet", { exact: true })).toBeVisible()
+    await expect(page.locator('[data-slot="session-review-header"]')).toHaveCSS("height", "40px")
+    await expect(page.locator('[data-slot="session-review-header"]')).toHaveCSS("padding-left", "8px")
+    await expect(composer).toBeHidden()
+
+    await tabs.getByRole("tab", { name: "Files", exact: true }).click()
+    await expect(picker).toHaveText("Files")
+    await expect(page.getByRole("combobox", { name: "Filter files", exact: true })).toBeVisible()
+    await expect(composer).toBeHidden()
+
+    await tabs.getByRole("tab", { name: "Terminal", exact: true }).click()
+    const panel = page.locator("#terminal-panel")
+    await expect(panel).toHaveAttribute("data-opened", "true")
+    await expect(panel.getByRole("tab", { name: /Terminal 1/ })).toBeVisible()
+    await expect(panel.locator('[data-component="terminal"]')).toBeVisible()
+    await expect(panel.locator("textarea")).toBeEditable()
+    await expect(panel).toHaveCount(1)
+    await panel.evaluate((element) => element.setAttribute("data-cache-probe", "original"))
+    await expect(composer).toBeHidden()
+
+    await tabs.getByRole("tab", { name: "Session", exact: true }).click()
+    await expect(message).toBeVisible()
+    await expect(panel).toBeHidden()
+    await expect(panel).toHaveAttribute("inert", "")
+    await expect(panel).toHaveAttribute("data-cache-probe", "original")
+
+    await page.keyboard.press("Control+Backquote")
+    await expect(picker).toHaveText("Terminal")
+    await expect(panel).toBeVisible()
+    await expect(panel).toHaveAttribute("data-cache-probe", "original")
+    await page.keyboard.press("Control+Backquote")
+    await expect(picker).toHaveText("Session")
+
+    await page.keyboard.press("Control+Backquote")
+    await expect(picker).toHaveText("Terminal")
+    await panel.getByRole("button", { name: "Close terminal", exact: true }).click()
+    await expect(picker).toHaveText("Session")
+    await expect(panel).toBeHidden()
+
+    await more.click()
+    await page.getByRole("menuitem", { name: "Usage", exact: true }).click()
+    await expect(page.getByText("Total Cost", { exact: true })).toBeVisible()
+    await page.goto(stressSessionHref(fixture.sourceID))
+    await expect(picker).toHaveText("Session")
+    await expect(page.locator('[data-slot="mobile-tabs-trigger"]')).toContainText(fixture.expected.sourceTitle)
+
+    await page.setViewportSize({ width: 1280, height: 900 })
+    await expect(picker).toBeHidden()
+    await expect(page.locator("[data-session-title]")).toBeVisible()
+  })
+}

packages/app/e2e/regression/mobile-status-drawer.spec.ts

@@ -0,0 +1,37 @@
+import { expect, test } from "@playwright/test"
+import { fixture } from "../performance/timeline/session-timeline-stress.fixture"
+import { mockStressTimeline, stressSessionHref } from "../performance/timeline/timeline-test-helpers"
+
+test("status drawer dismisses and reopens after button, backdrop, Escape, and drag", async ({ page }) => {
+  await page.setViewportSize({ width: 390, height: 844 })
+  await mockStressTimeline(page)
+  await page.goto(stressSessionHref(fixture.targetID))
+  const more = page
+    .locator('[data-slot="session-mobile-view-navigation"]')
+    .getByRole("button", { name: "More options", exact: true })
+  const drawer = page.getByRole("dialog", { name: "Status", exact: true })
+  const overlay = page.locator('[data-slot="mobile-status-overlay"]')
+
+  for (const dismissal of ["button", "backdrop", "escape", "drag", "button"] as const) {
+    await more.click()
+    await page.getByRole("menuitem", { name: "Status", exact: true }).click()
+    await expect(drawer.getByRole("tab", { name: "MCP", exact: true })).toBeVisible()
+    await expect(drawer).not.toHaveAttribute("data-transitioning")
+    if (dismissal === "button") await drawer.getByRole("button", { name: "Close", exact: true }).click()
+    if (dismissal === "backdrop") await overlay.click({ position: { x: 10, y: 10 } })
+    if (dismissal === "escape") await page.keyboard.press("Escape")
+    if (dismissal === "drag") {
+      const handle = drawer.locator('[data-slot="mobile-status-drag-handle"]')
+      const bounds = await handle.boundingBox()
+      expect(bounds).not.toBeNull()
+      await page.mouse.move(bounds!.x + bounds!.width / 2, bounds!.y + bounds!.height / 2)
+      await page.mouse.down()
+      await page.mouse.move(bounds!.x + bounds!.width / 2, bounds!.y + bounds!.height / 2 + 1)
+      await page.mouse.move(bounds!.x + bounds!.width / 2, 843)
+      await page.mouse.up()
+    }
+    await expect(drawer, `dismissal: ${dismissal}`).toBeHidden()
+    await expect(overlay).toHaveCount(0)
+    await expect(more).toBeFocused()
+  }
+})

packages/app/e2e/regression/review-line-comment.spec.ts

@@ -89,7 +89,7 @@ async function openReview(page: Page) {
   )
   await changes.click()
   expect((await (await diffResponse).json()).data).toHaveLength(1)
-  await expect(page.getByRole("tab", { selected: true })).toHaveAccessibleName(/Files Changed/)
+  await expect(changes).toHaveAttribute("aria-selected", "true")
 
   const review = page.locator('[data-component="session-review"]')
   await expectAppVisible(review)

packages/app/e2e/utils/waits.ts

@@ -8,6 +8,12 @@ export async function expectAppVisible(locator: Locator) {
 }
 
 export async function expectSessionTitle(page: Page, title: string) {
+  if ((page.viewportSize()?.width ?? 1280) < 768) {
+    const trigger = page.locator('[data-slot="mobile-tabs-trigger"]')
+    await expectAppVisible(trigger)
+    await expect(trigger.locator('span[dir="auto"]')).toHaveText(title, { timeout: APP_READY_TIMEOUT })
+    return
+  }
   await expectAppVisible(page.getByRole("heading", { name: title }))
 }
 

packages/app/manifest.json

@@ -9,13 +9,13 @@
       "src": "/web-app-manifest-192x192.png",
       "sizes": "192x192",
       "type": "image/png",
-      "purpose": "any"
+      "purpose": "maskable"
     },
     {
       "src": "/web-app-manifest-512x512.png",
       "sizes": "512x512",
       "type": "image/png",
-      "purpose": "any"
+      "purpose": "maskable"
     }
   ],
   "theme_color": "#080808",

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

@@ -114,8 +114,10 @@ export function ComposerEditor(props: ComposerEditorProps) {
       <form
         data-component="composer"
         data-dock-border-underlay={props.borderUnderlay ? "true" : undefined}
-        class="group/composer relative min-h-[96px] w-full overflow-clip rounded-xl bg-v2-background-bg-base"
+        class="group/composer relative min-h-[96px] w-full overflow-clip rounded-xl"
         classList={{
+          "bg-v2-background-bg-layer-01": props.borderUnderlay,
+          "bg-v2-background-bg-base": !props.borderUnderlay,
           "shadow-[var(--v2-elevation-raised)]": !props.borderUnderlay,
           "border border-v2-icon-icon-info border-dashed": state.drag === "active",
         }}

packages/app/src/entry.tsx

@@ -6,6 +6,7 @@ import { AppBaseProviders, AppInterface } from "@/app"
 import { loadInitialLocale } from "@/runtime/i18n/language"
 import { PlatformProvider } from "@/runtime/platform/platform"
 import { createWebPlatform } from "@/runtime/platform/web"
+import { isStandalone, PwaRoutePersistence, restorePwaRoute } from "@/runtime/platform/pwa"
 import en from "@/runtime/i18n/en"
 import zh from "@/runtime/i18n/zh"
 import { authFromToken } from "@/runtime/server/api"
@@ -71,6 +72,8 @@ if (root instanceof HTMLElement && root.dataset.opencodeMounted === undefined) {
   void loadInitialLocale().then((locale) => {
     const auth = authFromToken(new URLSearchParams(location.search).get("auth_token"))
     clearAuthToken()
+    const standalone = isStandalone()
+    if (standalone) restorePwaRoute()
     const server: ServerConnection.Http = {
       type: "http",
       authToken: !!auth,
@@ -87,7 +90,9 @@ if (root instanceof HTMLElement && root.dataset.opencodeMounted === undefined) {
               defaultServer={ServerConnection.Key.make(web.defaultServerUrl)}
               canonicalLocalServer={ServerConnection.key(server)}
               servers={[server]}
-            />
+            >
+              {standalone && <PwaRoutePersistence />}
+            </AppInterface>
           </AppBaseProviders>
         </PlatformProvider>
       ),

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

@@ -660,6 +660,10 @@ export const dict = {
   "home.providerTip": "Connect to 75+ providers to use other models, including Claude, GPT, Gemini, etc",
 
   "session.tab.session": "Session",
+  "session.tab.files": "Files",
+  "session.files.openTabs": "Open files",
+  "session.tab.usage": "Usage",
+  "session.view.select": "Session view",
   "session.tab.review": "Review",
   "session.tab.context": "Context",
   "session.tab.unknown": "Unknown Session",
@@ -698,6 +702,7 @@ export const dict = {
   "session.review.change.one": "Change",
   "session.review.change.other": "Changes",
   "session.review.loadingChanges": "Loading changes...",
+  "session.review.wrapLines": "Wrap lines",
   "session.review.empty": "No changes in this session yet",
   "session.review.noVcs": "No Git Version Control System detected, changes not displayed",
   "session.review.noVcs.createGit.title": "Create a Git repository",
@@ -978,7 +983,9 @@ export const dict = {
   "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",
+    "Place the title bar at the bottom of the screen on mobile",
+  "settings.general.row.mobileDiffWrap.description":
+    "Wrap long lines in mobile diffs instead of scrolling horizontally",
   "settings.general.row.showCustomAgents.title": "Show agent",
   "settings.general.row.showCustomAgents.description":
     "Switch between agents in the composer. When hidden, defaults to Build agent.",

packages/app/src/runtime/platform/pwa.ts

@@ -0,0 +1,43 @@
+import { useLocation } from "@solidjs/router"
+import { createEffect } from "solid-js"
+
+const LAST_ROUTE_KEY = "opencode.pwa.last-route"
+
+export function isStandalone() {
+  return (
+    window.matchMedia("(display-mode: standalone)").matches ||
+    ("standalone" in navigator && navigator.standalone === true)
+  )
+}
+
+export function restorePwaRoute() {
+  if (location.pathname !== "/" || location.search || location.hash) return
+  try {
+    const value = localStorage.getItem(LAST_ROUTE_KEY)
+    if (!value) return
+    const url = new URL(value, location.origin)
+    if (url.origin !== location.origin || url.searchParams.has("auth_token")) return
+    if (
+      url.pathname !== "/" &&
+      url.pathname !== "/new-session" &&
+      !/^\/server\/[^/]+\/session\/[^/]+$/.test(url.pathname)
+    )
+      return
+    history.replaceState(history.state, "", url.pathname + url.search + url.hash)
+  } catch {
+    // Storage may be unavailable; keep the launch URL in that case.
+  }
+}
+
+export function PwaRoutePersistence() {
+  const location = useLocation()
+  createEffect(() => {
+    const value = location.pathname + location.search + location.hash
+    try {
+      localStorage.setItem(LAST_ROUTE_KEY, value)
+    } catch {
+      // Navigation must still work when storage is unavailable or full.
+    }
+  })
+  return null
+}

packages/app/src/session/composer/session-composer-region.tsx

@@ -11,14 +11,7 @@ type SessionComposerRegionState = Pick<
 
 export type SessionComposerRegionViewController = Pick<
   SessionComposerRegionController,
-  | "centered"
-  | "onResponseSubmit"
-  | "openParent"
-  | "setPromptRef"
-  | "setDockRef"
-  | "parentID"
-  | "child"
-  | "showComposer"
+  "centered" | "onResponseSubmit" | "openParent" | "setPromptRef" | "setDockRef" | "parentID" | "child" | "showComposer"
 > & { state: SessionComposerRegionState }
 
 export function SessionComposerRegion(props: {
@@ -68,10 +61,7 @@ export function SessionComposerRegion(props: {
               "relative z-[70]": true,
             }}
           >
-            <Show
-              when={controller.child()}
-              fallback={<Show when={!controller.state.blocked()}>{props.composer}</Show>}
-            >
+            <Show when={controller.child()} fallback={<Show when={!controller.state.blocked()}>{props.composer}</Show>}>
               <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"

packages/app/src/session/files/session-context-tab.tsx

@@ -271,7 +271,7 @@ export function SessionContextTab() {
       }}
       onScroll={handleScroll}
     >
-      <div class="px-6 pt-4 pb-10 flex flex-col gap-10">
+      <div data-slot="session-usage-content" class="px-4 pt-4 pb-6 flex flex-col gap-6 md:px-6 md:pb-10 md:gap-10">
         <div class="grid grid-cols-1 @[32rem]:grid-cols-2 gap-4">
           <For each={stats}>
             {(stat) => <Stat label={language.t(stat.label as Parameters<typeof language.t>[0])} value={stat.value()} />}

packages/app/src/session/files/session-file-browser-tab.tsx

@@ -1,4 +1,5 @@
-import { createMemo, createSignal, createUniqueId, Show } from "solid-js"
+import { createMemo, createUniqueId, Show } from "solid-js"
+import { createStore } from "solid-js/store"
 import { createQuery } from "@tanstack/solid-query"
 import { Icon } from "@opencode-ai/ui/icon"
 import { SessionFilePanelV2, SessionFilePanelV2Empty } from "@opencode-ai/session-ui/v2/session-file-panel-v2"
@@ -34,6 +35,7 @@ export function SessionFileBrowserTab(props: {
   onSelect: (path: string) => void
   onSelectPermanent: (path: string) => void
   filterRef?: (element: HTMLInputElement) => void
+  mobile?: boolean
 }) {
   const file = useFile()
   const language = useLanguage()
@@ -42,8 +44,10 @@ export function SessionFileBrowserTab(props: {
   const serverSDK = useServerSDK()
   const { workspaceKey } = useSessionLayout()
   const resultsID = `session-file-browser-results-${createUniqueId()}`
-  const [filter, setFilter] = createSignal("")
-  const [explicitHighlight, setExplicitHighlight] = createSignal<string>()
+  const [store, setStore] = createStore({ filter: "", explicitHighlight: undefined as string | undefined })
+  const filter = () => store.filter
+  const setFilter = (value: string) => setStore("filter", value)
+  const setExplicitHighlight = (value: string) => setStore("explicitHighlight", value)
   const sidebarOpened = () => props.placeholder || props.state.sidebarOpened()
   const query = createMemo(() => filter().trim())
   const search = createQuery(() => {
@@ -61,7 +65,7 @@ export function SessionFileBrowserTab(props: {
   const highlighted = createMemo(() => {
     const values = files()
     if (values.length === 0) return undefined
-    const explicit = explicitHighlight()
+    const explicit = store.explicitHighlight
     if (explicit && values.includes(explicit)) return explicit
     return values[0]
   })
@@ -105,13 +109,13 @@ export function SessionFileBrowserTab(props: {
           filter={filter()}
           onFilterChange={setFilter}
           onFilterKeyDown={onFilterKeyDown}
-          filterAutofocus={props.placeholder}
-          filterRef={props.filterRef}
+          filterAutofocus={props.placeholder && !props.mobile}
+          filterRef={(element) => props.filterRef?.(element)}
           filterControls={resultsID}
           filterActiveDescendant={highlighted() ? optionID(highlighted()!) : undefined}
           filterExpanded={query().length > 0 && files().length > 0}
           width={props.state.sidebarWidth()}
-          onWidthChange={props.state.resizeSidebar}
+          onWidthChange={props.mobile ? undefined : props.state.resizeSidebar}
         >
           <Show
             when={query()}
@@ -119,6 +123,7 @@ export function SessionFileBrowserTab(props: {
               <FileTreeV2
                 active={props.active}
                 kinds={props.kinds}
+                draggable={!props.mobile}
                 onFileClick={(node) => props.onSelect(node.path)}
                 onFileDoubleClick={(node) => props.onSelectPermanent(node.path)}
               />

packages/app/src/session/files/session-mobile-files.css

@@ -0,0 +1,35 @@
+[data-slot="session-mobile-files"]
+  [data-slot="session-mobile-files-header"]
+  [data-component="tabs-v2"][data-variant="normal"][data-orientation="horizontal"]
+  [data-slot="tabs-v2-list"] {
+  position: static;
+
+  &::before {
+    inset-inline-start: 0;
+    width: 100%;
+  }
+}
+
+[data-slot="session-mobile-files"] [data-component="line-comment-v2"] {
+  max-width: none;
+}
+
+[data-slot="session-mobile-files"][data-browsing="true"] {
+  [data-component="session-review-v2-sidebar-root"] {
+    width: 100%;
+  }
+
+  [data-slot="session-review-v2-sidebar"] {
+    width: 100% !important;
+    border-inline-end: 0;
+  }
+
+  [data-slot="session-review-v2-preview"] {
+    display: none;
+  }
+}
+
+[data-slot="session-mobile-files"] [data-slot="tabs-v2-trigger-close-button"] [data-slot="tabs-close-button"] {
+  width: 32px;
+  height: 36px;
+}

packages/app/src/session/files/session-mobile-files.tsx

@@ -0,0 +1,100 @@
+import { Button } from "@opencode-ai/ui/button"
+import { Tabs } from "@opencode-ai/ui/tabs"
+import { getFilename } from "@opencode-ai/util/path"
+import { createMemo, For } from "solid-js"
+import { createStore } from "solid-js/store"
+import { useLanguage } from "@/runtime/i18n/language"
+import { useSessionLayout } from "@/session/session-layout"
+import { createSessionTabs, SESSION_OPEN_FILE_TAB } from "@/session/helpers"
+import { useFile } from "@/workspaces/files/model"
+import { SessionFileBrowserTab } from "./session-file-browser-tab"
+import type { Kind } from "./file-tree-v2"
+import "./session-mobile-files.css"
+
+export function SessionMobileFiles() {
+  const file = useFile()
+  const language = useLanguage()
+  const layout = useSessionLayout()
+  const tabs = createSessionTabs({
+    tabs: layout.tabs,
+    pathFromTab: file.pathFromTab,
+    normalizeTab: file.tab,
+  })
+  const [store, setStore] = createStore({ browsing: !tabs.activeFileTab() })
+  const browsing = () => store.browsing || !tabs.activeFileTab()
+  const active = createMemo(() => file.pathFromTab(tabs.activeFileTab() ?? ""))
+  const kinds = new Map<string, Kind>()
+  const open = (path: string) => {
+    layout.tabs().open(file.tab(path))
+    void file.load(path)
+    setStore("browsing", false)
+  }
+
+  return (
+    <div data-slot="session-mobile-files" data-browsing={browsing()} class="flex h-full min-h-0 flex-col">
+      <div data-slot="session-mobile-files-header" class="relative flex h-10 shrink-0 items-center">
+        <Button
+          size="small"
+          variant="ghost"
+          class="shrink-0 mx-2"
+          onClick={() => setStore("browsing", true)}
+          aria-pressed={browsing()}
+        >
+          {language.t("session.files.all")}
+        </Button>
+        <Tabs
+          value={browsing() ? SESSION_OPEN_FILE_TAB : tabs.activeFileTab()}
+          onChange={(tab) => {
+            // Kobalte falls back to a file tab when the browse view has no trigger.
+            if (browsing()) return
+            const path = file.pathFromTab(tab)
+            if (path) open(path)
+          }}
+          variant="line"
+          class="min-w-0 flex-1 !h-auto"
+        >
+          <Tabs.List aria-label={language.t("session.files.openTabs")} class="!h-10 !px-0 overflow-x-auto">
+            <For each={tabs.openedTabs()}>
+              {(tab) => (
+                <Tabs.Trigger
+                  value={tab}
+                  onClick={() => open(file.pathFromTab(tab)!)}
+                  class="shrink-0 max-w-48"
+                  classes={{ button: "min-w-0" }}
+                  closeButton={
+                    <Tabs.CloseButton
+                      aria-label={language.t("common.closeTab")}
+                      onClick={() => layout.tabs().close(tab)}
+                    />
+                  }
+                >
+                  <span dir="ltr" class="truncate">
+                    {getFilename(file.pathFromTab(tab) ?? tab)}
+                  </span>
+                </Tabs.Trigger>
+              )}
+            </For>
+          </Tabs.List>
+        </Tabs>
+      </div>
+      <div class="min-h-0 flex-1">
+        <SessionFileBrowserTab
+          mobile
+          tab={tabs.activeFileTab() ?? SESSION_OPEN_FILE_TAB}
+          placeholder={browsing()}
+          active={active()}
+          kinds={kinds}
+          state={{
+            sidebarOpened: browsing,
+            sidebarWidth: () => 240,
+            sidebarTransition: () => false,
+            resizeSidebar: () => undefined,
+            toggleSidebar: () => setStore("browsing", !browsing()),
+          }}
+          onSelect={open}
+          onSelectPermanent={open}
+        />
+      </div>
+    </div>
+  )
+}

packages/app/src/session/header/session-header.tsx

@@ -19,7 +19,10 @@ export function SessionHeader() {
   const isDesktop = createMediaQuery("(min-width: 768px)")
 
   const actions = createMemo<SessionHeaderActionsState>(() => ({
-    status: status() ? { label: language.t("status.popover.trigger"), content: () => <StatusPopover /> } : undefined,
+    status:
+      isDesktop() && status()
+        ? { label: language.t("status.popover.trigger"), content: () => <StatusPopover /> }
+        : undefined,
     reviewLabel: language.t("command.review.toggle"),
     reviewKeybind: reviewTooltipKeybind(command),
     reviewVisible: isDesktop(),

packages/app/src/session/helpers.test.ts

@@ -36,6 +36,28 @@ describe("createOpenReviewFile", () => {
 
     expect(calls).toEqual(["show", "load:src/a.ts", "tab:src/a.ts", "open:file://src/a.ts", "active:file://src/a.ts"])
   })
+
+  test("selects immediately and does not steal focus when loading finishes", async () => {
+    const loading = Promise.withResolvers<void>()
+    const state = { active: "file://previous.ts", opened: [] as string[] }
+    const openReviewFile = createOpenReviewFile({
+      showAllFiles: () => undefined,
+      tabForPath: (path) => `file://${path}`,
+      openTab: (tab) => state.opened.push(tab),
+      setActive: (tab) => {
+        state.active = tab
+      },
+      loadFile: () => loading.promise,
+    })
+
+    openReviewFile("requested.ts")
+    expect(state.opened).toEqual(["file://requested.ts"])
+    expect(state.active).toBe("file://requested.ts")
+    state.active = "file://previous.ts"
+    loading.resolve()
+    await loading.promise
+    expect(state.active).toBe("file://previous.ts")
+  })
 })
 
 describe("createOpenSessionFileTab", () => {

packages/app/src/session/helpers.ts

@@ -124,14 +124,10 @@ export const createOpenReviewFile = (input: {
   return (path: string) => {
     batch(() => {
       input.showAllFiles()
-      const maybePromise = input.loadFile(path)
-      const open = () => {
-        const tab = input.tabForPath(path)
-        input.openTab(tab)
-        input.setActive(tab)
-      }
-      if (maybePromise instanceof Promise) void maybePromise.then(open)
-      else open()
+      input.loadFile(path)
+      const tab = input.tabForPath(path)
+      input.openTab(tab)
+      input.setActive(tab)
     })
   }
 }

packages/app/src/session/review/model.ts

@@ -38,7 +38,7 @@ export function createSessionReview(input: {
   const location = useWorkspaceLocation()
   const server = useServerSDK()
   const [state, setState] = createStore({
-    mobileTab: "session" as "session" | "changes",
+    mobileTab: "session" as "session" | "changes" | "files" | "usage",
     detailsOpen: false,
     scroll: undefined as HTMLDivElement | undefined,
     pendingFile: undefined as string | undefined,
@@ -66,7 +66,9 @@ export function createSessionReview(input: {
     }
     return list
   })
-  const mobileChanges = createMemo(() => !input.session.isDesktop() && state.mobileTab === "changes")
+  const mobileChanges = createMemo(
+    () => !input.session.isDesktop() && !input.screen.terminal.open() && state.mobileTab === "changes",
+  )
   const vcsMode = createMemo<VcsMode | undefined>(() => {
     const value = mode()
     return value === "git" || value === "branch" ? value : undefined
@@ -407,7 +409,7 @@ export function createSessionReview(input: {
     loadDiff,
     mobile: {
       changes: mobileChanges,
-      setTab: (tab: "session" | "changes") => setState("mobileTab", tab),
+      setTab: (tab: "session" | "changes" | "files" | "usage") => setState("mobileTab", tab),
       tab: () => state.mobileTab,
     },
     mode,

packages/app/src/session/review/review-tab.tsx

@@ -23,6 +23,9 @@ export interface SessionReviewTabProps {
   diffs: ReviewDiff[]
   view: ReturnType<ReturnType<typeof useLayout>["view"]>
   diffStyle: DiffStyle
+  changeSummary?: boolean
+  overflow?: "wrap" | "scroll"
+  disableLineNumbers?: boolean
   onDiffStyleChange?: (style: DiffStyle) => void
   onViewFile?: (file: string) => void
   onLineComment?: (comment: { file: string; selection: SelectedLineRange; comment: string; preview?: string }) => void
@@ -122,6 +125,7 @@ export function SessionReviewTab(props: SessionReviewTabProps) {
   createEffect(() => {
     props.diffs.length
     props.diffStyle
+    props.overflow
     if (!layout.ready()) return
     queueRestore()
   })
@@ -156,6 +160,9 @@ export function SessionReviewTab(props: SessionReviewTabProps) {
       }}
       diffs={props.diffs}
       diffStyle={props.diffStyle}
+      changeSummary={props.changeSummary}
+      overflow={props.overflow}
+      disableLineNumbers={props.disableLineNumbers}
       onDiffStyleChange={props.onDiffStyleChange}
       onViewFile={props.onViewFile}
       focusedFile={props.focusedFile}

packages/app/src/session/review/view.tsx

@@ -2,51 +2,137 @@ import { SessionReviewEmptyChangesV2 } from "@opencode-ai/session-ui/v2/session-
 import { SessionReviewV2SidebarToggle } from "@opencode-ai/session-ui/v2/session-review-v2"
 import { Select } from "@opencode-ai/ui/select"
 import { Tabs } from "@opencode-ai/ui/tabs"
-import { Match, Show, Suspense, Switch } from "solid-js"
+import { Icon } from "@opencode-ai/ui/icon"
+import { IconButton } from "@opencode-ai/ui/icon-button"
+import { Menu } from "@opencode-ai/ui/menu"
+import { For, Match, Show, Suspense, Switch, lazy, createEffect, onCleanup, type JSX } from "solid-js"
+import { createStore } from "solid-js/store"
 import { useLanguage } from "@/runtime/i18n/language"
+import { useSettings } from "@/settings/model"
 import { SessionSidePanel } from "../files/session-side-panel"
 import { ReviewPanel } from "./panel"
 import { SessionReviewTab } from "./review-tab"
 import type { ChangeMode, SessionReviewModel } from "./model"
 
-export function SessionMobileTabs(props: { review: SessionReviewModel; compact?: boolean; bottom?: boolean }) {
+const StatusDrawer = lazy(async () => {
+  const { StatusDrawer } = await import("@/shell/status/status-drawer")
+  return { default: StatusDrawer }
+})
+
+const MobilePanelDrawer = lazy(async () => {
+  const { MobilePanelDrawer } = await import("@/shell/mobile-panel-drawer")
+  return { default: MobilePanelDrawer }
+})
+
+export function SessionMobileViewTabs(props: {
+  current: "session" | "changes" | "files" | "usage" | "terminal"
+  onSelect: (view: "session" | "changes" | "files" | "usage" | "terminal") => void
+  details?: (close: () => void) => JSX.Element
+  onDetailsOpenChange?: (open: boolean) => void
+}) {
   const language = useLanguage()
+  const [store, setStore] = createStore({
+    menu: false,
+    status: false,
+    statusLoaded: false,
+    details: false,
+    detailsLoaded: false,
+    pending: undefined as "status" | "details" | undefined,
+  })
+  createEffect(() => props.onDetailsOpenChange?.(store.details))
+  onCleanup(() => props.onDetailsOpenChange?.(false))
+  let trigger: HTMLButtonElement | undefined
   return (
-    <Tabs value={props.review.mobile.tab()} class="h-auto">
-      <Tabs.List
-        classList={{
-          "!h-9": props.compact,
-          "[&::after]:!border-b-0 [&::after]:!border-t [&::after]:!border-border-weak-base": props.bottom,
-        }}
+    <div
+      class="relative flex shrink-0 items-center before:pointer-events-none before:absolute before:inset-x-0 before:bottom-0 before:h-px before:bg-v2-border-border-base before:content-['']"
+      data-slot="session-mobile-view-navigation"
+    >
+      <Tabs value={props.current} variant="line" class="!h-auto min-w-0 flex-1" data-slot="session-mobile-view-tabs">
+        <Tabs.List aria-label={language.t("session.view.select")} class="!h-9 !gap-0 !px-0 before:!hidden">
+          <For each={["session", "changes", "files", "terminal"] as const}>
+            {(view) => (
+              <Tabs.Trigger
+                value={view}
+                class="min-w-0 flex-1"
+                classes={{ button: "w-full justify-center" }}
+                onClick={() => props.onSelect(view)}
+              >
+                {view === "session"
+                  ? language.t("session.tab.session")
+                  : view === "changes"
+                    ? language.plural("session.review.change", 0)
+                    : view === "files"
+                      ? language.t("session.tab.files")
+                      : language.t("terminal.title")}
+              </Tabs.Trigger>
+            )}
+          </For>
+        </Tabs.List>
+      </Tabs>
+      <Menu
+        appearance="standard"
+        modal={false}
+        placement="bottom-end"
+        gutter={4}
+        open={store.menu}
+        onOpenChange={(open) => setStore("menu", open)}
       >
-        <Tabs.Trigger
-          value="session"
-          classes={{ button: props.compact ? "w-full !py-2" : "w-full" }}
-          classList={{
-            "!w-1/2 !max-w-none": true,
-            "!border-b-0 !border-t !border-border-weak-base [&:has([data-selected])]:!border-t-transparent":
-              props.bottom,
+        <Menu.Trigger
+          as={IconButton}
+          ref={(element: HTMLButtonElement) => {
+            trigger = element
           }}
-          onClick={() => props.review.mobile.setTab("session")}
-        >
-          {language.t("session.tab.session")}
-        </Tabs.Trigger>
-        <Tabs.Trigger
-          value="changes"
-          classes={{ button: props.compact ? "w-full !py-2" : "w-full" }}
-          classList={{
-            "!w-1/2 !max-w-none !border-r-0": true,
-            "!border-b-0 !border-t !border-border-weak-base [&:has([data-selected])]:!border-t-transparent":
-              props.bottom,
-          }}
-          onClick={() => props.review.mobile.setTab("changes")}
-        >
-          {props.review.hasChanges()
-            ? language.t("session.review.filesChanged", { count: props.review.count() })
-            : language.plural("session.review.change", 0)}
-        </Tabs.Trigger>
-      </Tabs.List>
-    </Tabs>
+          icon={<Icon name="menu" />}
+          variant="ghost-muted"
+          size="normal"
+          class="mx-1.5 shrink-0"
+          state={props.current === "usage" || store.menu ? "pressed" : undefined}
+          aria-label={language.t("common.moreOptions")}
+        />
+        <Menu.Portal>
+          <Menu.Content
+            onCloseAutoFocus={(event) => {
+              if (!store.pending) return
+              event.preventDefault()
+              if (store.pending === "status") setStore({ status: true, statusLoaded: true })
+              if (store.pending === "details") setStore({ details: true, detailsLoaded: true })
+              setStore("pending", undefined)
+            }}
+          >
+            <Menu.Item onSelect={() => props.onSelect("usage")}>{language.t("session.tab.usage")}</Menu.Item>
+            <Show when={props.details}>
+              <Menu.Item onSelect={() => setStore({ pending: "details", menu: false })}>
+                {language.t("session.summary.title")}
+              </Menu.Item>
+            </Show>
+            <Menu.Item onSelect={() => setStore({ pending: "status", menu: false })}>
+              {language.t("status.popover.trigger")}
+            </Menu.Item>
+          </Menu.Content>
+        </Menu.Portal>
+      </Menu>
+      <Show when={store.statusLoaded}>
+        <Suspense>
+          <StatusDrawer
+            open={store.status}
+            onOpenChange={(open) => setStore("status", open)}
+            returnFocus={() => trigger}
+          />
+        </Suspense>
+      </Show>
+      <Show when={store.detailsLoaded}>
+        <Suspense>
+          <MobilePanelDrawer
+            title={language.t("session.summary.title")}
+            open={store.details}
+            onOpenChange={(open) => setStore("details", open)}
+            returnFocus={() => trigger}
+          >
+            {props.details?.(() => setStore("details", false))}
+          </MobilePanelDrawer>
+        </Suspense>
+      </Show>
+    </div>
   )
 }
 
@@ -88,14 +174,22 @@ export function SessionDesktopReview(props: { review: SessionReviewModel; presen
 }
 
 function ReviewContent(props: { review: SessionReviewModel }) {
+  const settings = useSettings()
   return (
     <Show when={!props.review.deferRender()}>
       <SessionReviewTab
         title={<ReviewTitle review={props.review} />}
-        empty={<ReviewEmpty review={props.review} loadingClass="px-4 py-4 text-text-weak" />}
+        empty={<ReviewEmpty review={props.review} loadingClass="px-2 py-2 text-text-weak" />}
         diffs={props.review.diffs()}
         view={props.review.view()}
         diffStyle="unified"
+        changeSummary
+        disableLineNumbers={false}
+        overflow={settings.general.mobileDiffWrap() ? "wrap" : "scroll"}
+        onViewFile={(file) => {
+          props.review.openFile(file)
+          props.review.mobile.setTab("files")
+        }}
         onScrollRef={props.review.setScroll}
         focusedFile={props.review.activeFile()}
         onLineComment={props.review.comments.add}
@@ -106,11 +200,11 @@ function ReviewContent(props: { review: SessionReviewModel }) {
         comments={props.review.comments.all()}
         focusedComment={props.review.comments.focus()}
         onFocusedCommentChange={props.review.comments.setFocus}
-        onViewFile={props.review.openFile}
         classes={{
-          root: "pb-8 [&_[data-slot=session-review-list]]:pb-0",
-          header: "px-4 !h-16 !pb-4",
-          container: "px-4",
+          root: "[&_[data-slot=session-review-list]]:pb-0 [&_[data-slot=accordion-trigger]]:!rounded-none [&_[data-slot=accordion-trigger]]:!border-x-0 [&_[data-slot=accordion-item]:first-child_[data-slot=accordion-trigger]]:!border-t-0 [&_[data-slot=accordion-item]:last-child:not([data-expanded])_[data-slot=accordion-trigger]]:!border-b-0 [&_[data-slot=accordion-item]:last-child_[data-slot=accordion-content]]:!border-b-0 [&_[data-slot=accordion-item]:last-child_[data-slot=session-review-diff-placeholder]]:!border-b-0 [&_[data-slot=accordion-content]]:!rounded-none [&_[data-slot=accordion-content]]:!border-x-0 [&_[data-slot=session-review-diff-placeholder]]:!rounded-none [&_[data-slot=session-review-diff-placeholder]]:!border-x-0",
+          header:
+            "!px-2 !h-10 !pb-0 relative before:pointer-events-none before:absolute before:inset-x-0 before:bottom-0 before:h-px before:bg-v2-border-border-base before:content-['']",
+          container: "!px-0",
         }}
       />
     </Show>

packages/app/src/session/screen.tsx

@@ -1,11 +1,23 @@
-import { ErrorBoundary, Show, Match, Switch, createMemo, createEffect, createComputed, on } from "solid-js"
+import {
+  ErrorBoundary,
+  Show,
+  Match,
+  Switch,
+  Suspense,
+  lazy,
+  createMemo,
+  createEffect,
+  createComputed,
+  on,
+} from "solid-js"
 import { createStore } from "solid-js/store"
 import createPresence from "solid-presence"
 import { ResizeHandle } from "@opencode-ai/ui/resize-handle"
 import { SessionHeader } from "@/session/header/session-header"
 import { useLayout } from "@/shell/state/layout"
-import { useSettings } from "@/settings/model"
-import { MessageTimeline } from "@/session/timeline/message-timeline"
+import { MessageTimeline, SessionSummaryPanel } from "@/session/timeline/message-timeline"
+import { useServer } from "@/runtime/server/current"
+import { projectForSession } from "@/shell/layout/helpers"
 import type { SessionModel } from "@/session/model"
 import { SESSION_PANEL_WIDTH_MIN } from "@/session/session-panel-width"
 import { SessionPanelFrame } from "@/session/session-frame"
@@ -14,15 +26,25 @@ import { useUsageExceededDialogs } from "./usage-exceeded-dialogs"
 import { SessionErrorFallback } from "./route-error"
 import { createSessionScreenLayout } from "./screen-layout"
 import { createSessionReview } from "./review/model"
-import { SessionDesktopReview, SessionMobileReview, SessionMobileTabs } from "./review/view"
+import { SessionDesktopReview, SessionMobileReview, SessionMobileViewTabs } from "./review/view"
+import { SessionContextTab } from "./files/session-context-tab"
 import { createSessionTimelineInteraction } from "./timeline/interaction"
 import { ActiveSessionComposerRegion, createActiveSessionRegion } from "./composer/region"
 import { SessionIdentityHeader } from "./session-identity-header"
 
+const SessionMobileFiles = lazy(async () => {
+  const { SessionMobileFiles } = await import("./files/session-mobile-files")
+  return { default: SessionMobileFiles }
+})
+
 export function SessionScreen(props: { session: SessionModel }) {
   const session = props.session
   const layout = useLayout()
-  const settings = useSettings()
+  const server = useServer()
+  const detailsProject = createMemo(() => {
+    const info = session.data.info()
+    return info ? projectForSession(info, server.ctx.sync.data.project) : undefined
+  })
   const isDesktop = session.isDesktop
   const screen = createSessionScreenLayout(session)
   const timeline = createSessionTimelineInteraction(session)
@@ -34,6 +56,8 @@ export function SessionScreen(props: { session: SessionModel }) {
     sideRegionPresent: false,
     sideReviewPresent: false,
     sideTerminalPresent: false,
+    mobileTerminalCached: false,
+    mobileMoveDismissed: false,
   })
   const [elements, setElements] = createStore<{
     side?: HTMLDivElement
@@ -41,7 +65,7 @@ export function SessionScreen(props: { session: SessionModel }) {
   }>({})
   const sideVisible = createMemo(() => isDesktop() && screen.side.layout().visible)
   const sideTerminalVisible = createMemo(() => isDesktop() && screen.terminal.side() && screen.terminal.open())
-  const bottomTerminalVisible = createMemo(() => screen.terminal.open() && (!isDesktop() || screen.terminal.bottom()))
+  const bottomTerminalVisible = createMemo(() => isDesktop() && screen.terminal.open() && screen.terminal.bottom())
   const sidePresence = createPresence({
     show: sideVisible,
     element: () => elements.side ?? null,
@@ -67,6 +91,7 @@ export function SessionScreen(props: { session: SessionModel }) {
   createComputed((prev) => {
     const key = session.identity.sessionKey()
     if (key !== prev) {
+      setStore("mobileMoveDismissed", false)
       setStore("deferRender", true)
       const owner = session.ownership.capture()
       requestAnimationFrame(() => {
@@ -76,6 +101,11 @@ export function SessionScreen(props: { session: SessionModel }) {
     return key
   })
   const review = createSessionReview({ session, screen, deferRender: () => store.deferRender })
+  const mobileView = createMemo(() => (screen.terminal.open() ? "terminal" : review.mobile.tab()))
+  const conversationVisible = createMemo(() => isDesktop() || mobileView() === "session")
+  createEffect(() => {
+    if (!isDesktop() && screen.terminal.open()) setStore("mobileTerminalCached", true)
+  })
   const composer = createActiveSessionRegion({
     session,
     screen,
@@ -84,36 +114,102 @@ export function SessionScreen(props: { session: SessionModel }) {
 
   useUsageExceededDialogs()
 
-  const mobileTabsBottom = createMemo(() => !isDesktop() && settings.general.mobileTitlebarPosition() === "bottom")
-
   const sessionErrorFallback = (error: unknown, reset: () => void) => {
     createEffect(on(session.identity.sessionKey, reset, { defer: true }))
     return <SessionErrorFallback error={error} sessionID={session.identity.params.id} />
   }
 
+  const mobileTabs = () => (
+    <Show when={session.identity.sessionKey()} keyed>
+      {(_key) => (
+        <SessionMobileViewTabs
+          current={mobileView()}
+          onDetailsOpenChange={review.details.setOpen}
+          details={
+            !session.data.isChild() && detailsProject()
+              ? (close) => (
+                  <Show when={detailsProject()}>
+                    {(project) => (
+                      <SessionSummaryPanel
+                        mobile
+                        project={project()}
+                        directory={session.workspace.directory()}
+                        local={!session.workspace.current()}
+                        branch={
+                          session.shared.data.location.vcs.info({ directory: session.workspace.directory() })?.branch
+                            .current
+                        }
+                        baseBranch={
+                          session.shared.data.location.vcs.info({ directory: project().worktree })?.branch.current
+                        }
+                        diffs={project().vcs === "git" ? review.details.diffs() : []}
+                        sessionID={session.identity.params.id ?? ""}
+                        moveEligible={composer.workspaceMoveEligible()}
+                        moveDismissed={store.mobileMoveDismissed}
+                        onMoveDismiss={() => setStore("mobileMoveDismissed", true)}
+                        onReview={() => {
+                          close()
+                          review.mobile.setTab("changes")
+                          session.layout.view().terminal.close()
+                        }}
+                        backgroundTasks={composer.region.state.background.tasks()}
+                      />
+                    )}
+                  </Show>
+                )
+              : undefined
+          }
+          onSelect={(view) => {
+            if (view === "terminal") {
+              session.layout.view().terminal.open()
+              return
+            }
+            review.mobile.setTab(view)
+            session.layout.view().terminal.close()
+          }}
+        />
+      )}
+    </Show>
+  )
+
   const sessionPanelContent = () => (
     <>
-      <Show when={!isDesktop() && !!session.identity.params.id && !mobileTabsBottom()}>
-        <SessionMobileTabs review={review} compact />
-      </Show>
+      <Show when={!isDesktop() && !!session.identity.params.id}>{mobileTabs()}</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">
+      <div class="relative flex-1 min-h-0 overflow-hidden">
+        <Show when={!isDesktop() && store.mobileTerminalCached}>
+          <div class="absolute inset-0" classList={{ invisible: mobileView() !== "terminal" }}>
+            <TerminalPanel fill embedded present contentHeight="100%" />
+          </div>
+        </Show>
         <Switch>
+          <Match when={!isDesktop() && mobileView() === "terminal"}>
+            <></>
+          </Match>
+          <Match when={!isDesktop() && mobileView() === "usage"}>
+            <SessionContextTab />
+          </Match>
+          <Match when={!isDesktop() && mobileView() === "files"}>
+            <Suspense>
+              <SessionMobileFiles />
+            </Suspense>
+          </Match>
           <Match when={session.identity.params.id && review.mobile.changes()}>
             <SessionMobileReview review={review} />
           </Match>
           <Match when={session.identity.params.id}>
-            <Show when={!messagesReady()}>
+            <Show when={isDesktop() && !messagesReady()}>
               <SessionIdentityHeader sessionID={session.identity.params.id ?? ""} session={session.data.info()} />
             </Show>
             <Show when={messagesReady() ? session.identity.params.id : undefined} keyed>
               {(_id) => (
                 <MessageTimeline
+                  hideHeader={!isDesktop()}
                   session={session}
                   background={composer.region.state.background}
                   actions={composer.actions.timeline}
@@ -143,14 +239,11 @@ export function SessionScreen(props: { session: SessionModel }) {
         </Switch>
       </div>
 
-      <Show when={!review.mobile.changes() ? session.identity.params.id : undefined} keyed>
+      <Show when={conversationVisible() ? session.identity.params.id : undefined} keyed>
         {(_id) => (
           <ActiveSessionComposerRegion model={composer} session={session} onResponseSubmit={timeline.actions.resume} />
         )}
       </Show>
-      <Show when={!!session.identity.params.id && mobileTabsBottom()}>
-        <SessionMobileTabs review={review} compact bottom />
-      </Show>
     </>
   )
 
@@ -300,7 +393,7 @@ export function SessionScreen(props: { session: SessionModel }) {
           </Show>
         </div>
 
-        <Show when={bottomTerminalPresence.present() || store.bottomTerminalCached}>
+        <Show when={isDesktop() && (bottomTerminalPresence.present() || store.bottomTerminalCached)}>
           <div
             ref={(element) => setElements("bottomTerminal", element)}
             data-slot="terminal-panel-presence"

packages/app/src/session/terminal/panel.tsx

@@ -38,7 +38,14 @@ type CachedTerminalSurface = {
 }
 
 export function TerminalPanel(
-  props: { stacked?: boolean; fill?: boolean; framed?: boolean; present?: boolean; contentHeight?: string } = {},
+  props: {
+    stacked?: boolean
+    fill?: boolean
+    framed?: boolean
+    present?: boolean
+    contentHeight?: string
+    embedded?: boolean
+  } = {},
 ) {
   const layout = useLayout()
   const terminal = useTerminal()
@@ -223,6 +230,7 @@ export function TerminalPanel(
       opened={opened()}
       present={present()}
       framed={props.framed}
+      embedded={props.embedded}
       desktop={isDesktop()}
       stacked={stacked()}
       height={panelHeight()}

packages/app/src/session/terminal/surface.tsx

@@ -7,6 +7,7 @@ export function TerminalSurface(
     opened: boolean
     present?: boolean
     framed?: boolean
+    embedded?: boolean
     desktop: boolean
     stacked: boolean
     height: string
@@ -26,7 +27,7 @@ export function TerminalSurface(
       id="terminal-panel"
       data-component="terminal-panel"
       data-opened={props.opened}
-      data-size-animated={!props.resizing && (!props.desktop || props.stacked)}
+      data-size-animated={!props.embedded && !props.resizing && (!props.desktop || props.stacked)}
       role="region"
       aria-label={props.label}
       aria-hidden={!props.opened}
@@ -37,11 +38,14 @@ export function TerminalSurface(
         "min-w-0 h-full flex-1": props.desktop && (props.present ?? props.opened) && !props.stacked,
         "w-0 h-full pointer-events-none": props.desktop && !(props.present ?? props.opened),
         "rounded-[10px] shadow-[var(--v2-elevation-raised)]": props.desktop && (props.framed ?? true),
-        "will-change-[height]": !props.resizing && (!props.desktop || props.stacked),
+        "will-change-[height]": !props.embedded && !props.resizing && (!props.desktop || props.stacked),
       }}
       style={{ height: props.height, "--terminal-panel-height": props.contentHeight }}
     >
-      <div classList={{ "md:hidden": !props.stacked, hidden: props.stacked }} onPointerDown={props.onResizeStart}>
+      <div
+        classList={{ "md:hidden": !props.stacked, hidden: props.stacked || props.embedded }}
+        onPointerDown={props.onResizeStart}
+      >
         <ResizeHandle
           class="-top-1"
           direction="vertical"
@@ -57,7 +61,7 @@ export function TerminalSurface(
         data-slot="terminal-panel-content"
         class="absolute inset-x-0 top-0 flex flex-col overflow-hidden"
         classList={{
-          "border-t border-border-weak-base": props.opened && !props.desktop,
+          "border-t border-border-weak-base": props.opened && !props.desktop && !props.embedded,
           "pointer-events-none": !props.opened,
         }}
         style={{ height: props.contentHeight }}

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

@@ -69,7 +69,7 @@ export function BackgroundMoveHint(props: { keybind?: string[] }) {
   )
 }
 
-export function BackgroundWorkSummary(props: { tasks: BackgroundTask[] }) {
+export function BackgroundWorkSummary(props: { tasks: BackgroundTask[]; mobile?: boolean }) {
   const language = useLanguage()
   const [open, setOpen] = createSignal(false)
   const taskType = (task: BackgroundTask) => {
@@ -81,7 +81,7 @@ export function BackgroundWorkSummary(props: { tasks: BackgroundTask[] }) {
   return (
     <Popover
       open={open()}
-      placement={language.direction() === "rtl" ? "right-end" : "left-end"}
+      placement={props.mobile ? "top-end" : language.direction() === "rtl" ? "right-end" : "left-end"}
       gutter={4}
       onOpenChange={setOpen}
     >
@@ -126,6 +126,7 @@ export function BackgroundWorkSummary(props: { tasks: BackgroundTask[] }) {
 
 function WorkspaceMoveAction(props: {
   variant: "inline" | "panel"
+  mobile?: boolean
   eligible: boolean
   sessionID: string
   project: Project
@@ -150,9 +151,17 @@ function WorkspaceMoveAction(props: {
         sessionID={props.sessionID}
         project={props.project}
         directory={props.directory}
-        placement={inline() ? "bottom-end" : language.direction() === "rtl" ? "right-start" : "left-start"}
-        gutter={inline() ? 4 : -22}
-        contentClass={inline() ? undefined : "relative top-3.5"}
+        placement={
+          props.mobile
+            ? "top-end"
+            : inline()
+              ? "bottom-end"
+              : language.direction() === "rtl"
+                ? "right-start"
+                : "left-start"
+        }
+        gutter={props.mobile || inline() ? 4 : -22}
+        contentClass={props.mobile || inline() ? undefined : "relative top-3.5"}
         class={
           inline()
             ? "flex h-5 w-full items-center gap-1.5 rounded-[4px] pe-6 text-[13px] font-[440] leading-5 tracking-[-0.04px] text-v2-text-text-faint hover:bg-v2-overlay-simple-overlay-hover focus-visible:bg-v2-overlay-simple-overlay-hover focus-visible:outline-none data-[expanded]:bg-v2-overlay-simple-overlay-pressed"
@@ -181,7 +190,8 @@ function WorkspaceMoveAction(props: {
   )
 }
 
-function SessionSummaryPanel(props: {
+export function SessionSummaryPanel(props: {
+  mobile?: boolean
   project: Project
   avatar?: JSX.Element
   directory: string
@@ -207,7 +217,7 @@ function SessionSummaryPanel(props: {
     "flex h-7 w-full items-center gap-2 rounded-[4px] px-3 text-[13px] font-[440] leading-5 tracking-[-0.04px] text-v2-text-text-base"
 
   return (
-    <div data-component="session-summary-panel" class="w-[280px]">
+    <div data-component="session-summary-panel" class={props.mobile ? "w-full" : "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 ?? (
@@ -217,19 +227,23 @@ function SessionSummaryPanel(props: {
               variant={getProjectAvatarVariant(props.project.icon?.color)}
             />
           )}
-          <span class="min-w-0 flex-1 truncate text-v2-text-text-muted">{displayName(props.project)}</span>
+          <span dir="auto" class="min-w-0 flex-1 truncate text-v2-text-text-muted">
+            {displayName(props.project)}
+          </span>
         </div>
         <SessionWorkspaceMenu
           eligible={props.moveEligible}
           sessionID={props.sessionID}
           project={props.project}
           directory={props.directory}
-          placement={language.direction() === "rtl" ? "right-start" : "left-start"}
-          gutter={-22}
+          placement={props.mobile ? "top-end" : language.direction() === "rtl" ? "right-start" : "left-start"}
+          gutter={props.mobile ? 4 : -22}
           class={`${row} hover:bg-v2-overlay-simple-overlay-hover focus-visible:bg-v2-overlay-simple-overlay-hover focus-visible:outline-none data-[expanded]:bg-v2-overlay-simple-overlay-pressed`}
         >
           <Icon name={props.local ? "monitor" : "workspace-isolated"} class="shrink-0 text-v2-icon-icon-muted" />
-          <span class="min-w-0 flex-1 truncate text-start">{location()}</span>
+          <span dir="auto" class="min-w-0 flex-1 truncate text-start">
+            {location()}
+          </span>
           <Icon name="chevron-down" size="small" class="shrink-0 text-v2-icon-icon-muted" />
         </SessionWorkspaceMenu>
         <div class={row}>
@@ -252,7 +266,9 @@ function SessionSummaryPanel(props: {
               </span>
             }
           >
-            <span class="min-w-0 truncate">{branch()}</span>
+            <span dir="auto" class="min-w-0 truncate">
+              {branch()}
+            </span>
           </Show>
         </div>
         <button
@@ -272,12 +288,13 @@ function SessionSummaryPanel(props: {
           </Show>
         </button>
         <Show when={props.backgroundTasks.length > 0}>
-          <BackgroundWorkSummary tasks={props.backgroundTasks} />
+          <BackgroundWorkSummary tasks={props.backgroundTasks} mobile={props.mobile} />
         </Show>
       </div>
       <Show when={props.local && props.diffs && props.diffs.length > 0 && props.moveEligible}>
         <WorkspaceMoveAction
           variant="panel"
+          mobile={props.mobile}
           eligible={props.moveEligible}
           sessionID={props.sessionID}
           project={props.project}
@@ -291,6 +308,7 @@ function SessionSummaryPanel(props: {
 }
 
 type MessageTimelineProps = {
+  hideHeader?: boolean
   session: TimelineSessionSource
   background: SessionBackground
   actions?: SessionUserActions
@@ -393,7 +411,7 @@ function MessageTimelineView(
     }),
   )
   const turnPadding = () => "px-4 md:px-5"
-  const showHeader = createMemo(() => props.data.showHeader() || workspaceSession())
+  const showHeader = createMemo(() => !props.hideHeader && (props.data.showHeader() || workspaceSession()))
   const pinned = createMemo(() => props.pinned)
   const messageByID = projection.messageByID
   const virtualized = createTimelineVirtualizer({
@@ -556,198 +574,200 @@ function MessageTimelineView(
       }}
       renderRow={(row, onSizeChange) => <rowRenderer.Row row={row} onSizeChange={onSizeChange} />}
       header={
-        <SessionTitleHeader>
-          <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">
-                <Show
-                  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>
-                    </span>
-                  }
-                >
-                  <Tooltip
-                    placement="bottom-start"
-                    value={sessionDirectory()}
-                    contentClass="max-w-[calc(100vw-32px)] break-all"
-                  >
-                    <span
-                      tabIndex={0}
-                      aria-label={sessionDirectory()}
-                      classList={{
-                        "flex size-6 shrink-0 items-center justify-center": true,
-                        "text-v2-icon-icon-accent": !showProjectIcon(),
-                      }}
-                    >
-                      <Show when={showProjectIcon()} fallback={<Icon name="workspace-isolated" />}>
-                        {projectAvatar()}
-                      </Show>
-                    </span>
-                  </Tooltip>
-                </Show>
-                <Show when={parentID()}>
-                  <button
-                    type="button"
-                    data-slot="session-title-parent"
-                    class="min-w-0 max-w-[40%] truncate pl-2 text-[13px] font-[530] leading-4 tracking-[-0.04px] text-v2-text-text-faint transition-colors hover:text-v2-text-text-muted"
-                    onClick={props.action.navigateParent}
-                  >
-                    {parentTitle()}
-                  </button>
-                  <span
-                    data-slot="session-title-separator"
-                    class="-translate-y-[0.5px] pl-2 pr-1 text-[11px] font-medium text-v2-text-text-faint"
-                    aria-hidden="true"
-                  >
-                    /
-                  </span>
-                </Show>
-                <Show when={childTitle() || title.editing}>
+        <Show when={!props.hideHeader}>
+          <SessionTitleHeader>
+            <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">
                   <Show
-                    when={title.editing}
+                    when={workspaceSession()}
                     fallback={
-                      <h1
-                        data-slot="session-title-child"
-                        class="truncate text-[13px] font-[530] leading-4 tracking-[-0.04px] text-v2-text-text-base w-fit rounded-[6px] px-2 py-1 hover:bg-v2-overlay-simple-overlay-hover"
-                        onClick={openTitleEditor}
-                      >
-                        {childTitle()}
-                      </h1>
+                      <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>
+                      </span>
                     }
                   >
-                    <InlineInput
-                      ref={(el) => {
-                        titleRef = el
-                      }}
-                      data-slot="session-title-child"
-                      dir="auto"
-                      value={title.draft}
-                      disabled={props.pending.rename()}
-                      class="block text-[13px] font-[530] leading-4 tracking-[-0.04px] text-v2-text-text-base field-sizing-content self-start rounded-[6px] px-2 py-1"
-                      style={{
-                        "--inline-input-shadow": "none",
-                        "text-align": "start",
-                      }}
-                      onInput={(event) => setTitle("draft", event.currentTarget.value)}
-                      onKeyDown={(event) => {
-                        event.stopPropagation()
-                        if (event.isComposing || event.keyCode === 229) return
-                        if (event.key === "Enter") {
-                          event.preventDefault()
-                          void saveTitleEditor()
-                          return
-                        }
-                        if (event.key === "Escape") {
-                          event.preventDefault()
-                          closeTitleEditor()
-                        }
-                      }}
-                      onBlur={() => void saveTitleEditor()}
-                    />
-                  </Show>
-                </Show>
-              </div>
-            </div>
-            <Show when={sessionID()} keyed>
-              {(id) => (
-                <div class="shrink-0 flex items-center gap-2">
-                  <SessionContextUsage placement="bottom" />
-                  <Show when={!parentID() && project()}>
-                    {(project) => (
-                      <Popover open={summaryOpen()} placement="bottom-end" gutter={6} onOpenChange={setSummary}>
-                        <Popover.Trigger
-                          as={IconButton}
-                          icon={<Icon name="window-analytics" />}
-                          variant="ghost-muted"
-                          size="large"
-                          state={summaryOpen() ? "pressed" : undefined}
-                          aria-label={language.t("session.summary.title")}
-                          aria-expanded={summaryOpen()}
-                        />
-                        <Popover.Portal>
-                          <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}
-                              baseBranch={data.location.vcs.info({ directory: project().worktree })?.branch.current}
-                              diffs={sessionDiffs()}
-                              sessionID={id}
-                              moveEligible={props.workspaceMoveEligible}
-                              moveDismissed={workspaceSuggestionDismissed()}
-                              onMoveDismiss={() => setWorkspaceSuggestionDismissed(true)}
-                              onReview={() => {
-                                setSummary(false)
-                                props.onReview()
-                              }}
-                              backgroundTasks={props.background.tasks()}
-                            />
-                          </Popover.Content>
-                        </Popover.Portal>
-                      </Popover>
-                    )}
-                  </Show>
-                  <Show when={!parentID()}>
-                    <Menu
-                      gutter={6}
-                      placement="bottom-end"
-                      open={title.menuOpen}
-                      onOpenChange={(open) => {
-                        setTitle("menuOpen", open)
-                        if (open) return
-                      }}
+                    <Tooltip
+                      placement="bottom-start"
+                      value={sessionDirectory()}
+                      contentClass="max-w-[calc(100vw-32px)] break-all"
                     >
-                      <Menu.Trigger
-                        as={IconButton}
-                        icon={<Icon name="outline-dots" />}
-                        variant="ghost-muted"
-                        size="large"
-                        aria-label={language.t("common.moreOptions")}
-                        aria-expanded={title.menuOpen}
-                      />
-                      <Menu.Portal>
-                        <Menu.Content
-                          style={{ width: "120px", "min-width": "120px" }}
-                          onCloseAutoFocus={(event) => {
-                            if (title.pendingRename) {
-                              event.preventDefault()
-                              setTitle("pendingRename", false)
-                              openTitleEditor()
-                              return
-                            }
-                          }}
+                      <span
+                        tabIndex={0}
+                        aria-label={sessionDirectory()}
+                        classList={{
+                          "flex size-6 shrink-0 items-center justify-center": true,
+                          "text-v2-icon-icon-accent": !showProjectIcon(),
+                        }}
+                      >
+                        <Show when={showProjectIcon()} fallback={<Icon name="workspace-isolated" />}>
+                          {projectAvatar()}
+                        </Show>
+                      </span>
+                    </Tooltip>
+                  </Show>
+                  <Show when={parentID()}>
+                    <button
+                      type="button"
+                      data-slot="session-title-parent"
+                      class="min-w-0 max-w-[40%] truncate pl-2 text-[13px] font-[530] leading-4 tracking-[-0.04px] text-v2-text-text-faint transition-colors hover:text-v2-text-text-muted"
+                      onClick={props.action.navigateParent}
+                    >
+                      {parentTitle()}
+                    </button>
+                    <span
+                      data-slot="session-title-separator"
+                      class="-translate-y-[0.5px] pl-2 pr-1 text-[11px] font-medium text-v2-text-text-faint"
+                      aria-hidden="true"
+                    >
+                      /
+                    </span>
+                  </Show>
+                  <Show when={childTitle() || title.editing}>
+                    <Show
+                      when={title.editing}
+                      fallback={
+                        <h1
+                          data-slot="session-title-child"
+                          class="truncate text-[13px] font-[530] leading-4 tracking-[-0.04px] text-v2-text-text-base w-fit rounded-[6px] px-2 py-1 hover:bg-v2-overlay-simple-overlay-hover"
+                          onClick={openTitleEditor}
                         >
-                          <Menu.Item
-                            onSelect={() => {
-                              setTitle("pendingRename", true)
-                              setTitle("menuOpen", false)
-                            }}
-                          >
-                            {language.t("common.rename")}
-                          </Menu.Item>
-                          <Menu.Item onSelect={() => void props.action.export(id)}>
-                            {language.t("common.export")}...
-                          </Menu.Item>
-                          {/* TODO: Need a session archive API. */}
-                          <Menu.Separator />
-                          <Menu.Item onSelect={() => props.action.showDelete(id)}>
-                            {language.t("common.delete")}...
-                          </Menu.Item>
-                        </Menu.Content>
-                      </Menu.Portal>
-                    </Menu>
+                          {childTitle()}
+                        </h1>
+                      }
+                    >
+                      <InlineInput
+                        ref={(el) => {
+                          titleRef = el
+                        }}
+                        data-slot="session-title-child"
+                        dir="auto"
+                        value={title.draft}
+                        disabled={props.pending.rename()}
+                        class="block text-[13px] font-[530] leading-4 tracking-[-0.04px] text-v2-text-text-base field-sizing-content self-start rounded-[6px] px-2 py-1"
+                        style={{
+                          "--inline-input-shadow": "none",
+                          "text-align": "start",
+                        }}
+                        onInput={(event) => setTitle("draft", event.currentTarget.value)}
+                        onKeyDown={(event) => {
+                          event.stopPropagation()
+                          if (event.isComposing || event.keyCode === 229) return
+                          if (event.key === "Enter") {
+                            event.preventDefault()
+                            void saveTitleEditor()
+                            return
+                          }
+                          if (event.key === "Escape") {
+                            event.preventDefault()
+                            closeTitleEditor()
+                          }
+                        }}
+                        onBlur={() => void saveTitleEditor()}
+                      />
+                    </Show>
                   </Show>
                 </div>
-              )}
-            </Show>
-          </div>
-        </SessionTitleHeader>
+              </div>
+              <Show when={sessionID()} keyed>
+                {(id) => (
+                  <div class="shrink-0 flex items-center gap-2">
+                    <SessionContextUsage placement="bottom" />
+                    <Show when={!parentID() && project()}>
+                      {(project) => (
+                        <Popover open={summaryOpen()} placement="bottom-end" gutter={6} onOpenChange={setSummary}>
+                          <Popover.Trigger
+                            as={IconButton}
+                            icon={<Icon name="window-analytics" />}
+                            variant="ghost-muted"
+                            size="large"
+                            state={summaryOpen() ? "pressed" : undefined}
+                            aria-label={language.t("session.summary.title")}
+                            aria-expanded={summaryOpen()}
+                          />
+                          <Popover.Portal>
+                            <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}
+                                baseBranch={data.location.vcs.info({ directory: project().worktree })?.branch.current}
+                                diffs={sessionDiffs()}
+                                sessionID={id}
+                                moveEligible={props.workspaceMoveEligible}
+                                moveDismissed={workspaceSuggestionDismissed()}
+                                onMoveDismiss={() => setWorkspaceSuggestionDismissed(true)}
+                                onReview={() => {
+                                  setSummary(false)
+                                  props.onReview()
+                                }}
+                                backgroundTasks={props.background.tasks()}
+                              />
+                            </Popover.Content>
+                          </Popover.Portal>
+                        </Popover>
+                      )}
+                    </Show>
+                    <Show when={!parentID()}>
+                      <Menu
+                        gutter={6}
+                        placement="bottom-end"
+                        open={title.menuOpen}
+                        onOpenChange={(open) => {
+                          setTitle("menuOpen", open)
+                          if (open) return
+                        }}
+                      >
+                        <Menu.Trigger
+                          as={IconButton}
+                          icon={<Icon name="outline-dots" />}
+                          variant="ghost-muted"
+                          size="large"
+                          aria-label={language.t("common.moreOptions")}
+                          aria-expanded={title.menuOpen}
+                        />
+                        <Menu.Portal>
+                          <Menu.Content
+                            style={{ width: "120px", "min-width": "120px" }}
+                            onCloseAutoFocus={(event) => {
+                              if (title.pendingRename) {
+                                event.preventDefault()
+                                setTitle("pendingRename", false)
+                                openTitleEditor()
+                                return
+                              }
+                            }}
+                          >
+                            <Menu.Item
+                              onSelect={() => {
+                                setTitle("pendingRename", true)
+                                setTitle("menuOpen", false)
+                              }}
+                            >
+                              {language.t("common.rename")}
+                            </Menu.Item>
+                            <Menu.Item onSelect={() => void props.action.export(id)}>
+                              {language.t("common.export")}...
+                            </Menu.Item>
+                            {/* TODO: Need a session archive API. */}
+                            <Menu.Separator />
+                            <Menu.Item onSelect={() => props.action.showDelete(id)}>
+                              {language.t("common.delete")}...
+                            </Menu.Item>
+                          </Menu.Content>
+                        </Menu.Portal>
+                      </Menu>
+                    </Show>
+                  </div>
+                )}
+              </Show>
+            </div>
+          </SessionTitleHeader>
+        </Show>
       }
     />
   )

packages/app/src/session/timeline/virtualizer.tsx

@@ -22,6 +22,7 @@ import {
   type JSX,
 } from "solid-js"
 import { createStore } from "solid-js/store"
+import { createMediaQuery } from "@solid-primitives/media"
 import type { createTimelineProjection } from "./projection"
 import { observeElementOffsetReconnectAware } from "./observe-element-offset"
 import { filterVirtualIndexes } from "./virtual-items"
@@ -73,6 +74,8 @@ type ViewProps = {
 
 export function createTimelineVirtualizer(input: Input) {
   const language = useLanguage()
+  const isDesktop = createMediaQuery("(min-width: 768px)")
+  const topOffset = () => (input.showHeader() ? 64 : isDesktop() ? 0 : 16)
   const ownerSessionKey = input.sessionKey()
   const cached = cache.get(ownerSessionKey)
   const initialMeasurements = cached?.measurements
@@ -186,7 +189,7 @@ export function createTimelineVirtualizer(input: Input) {
     },
     scrollEndThreshold: 80,
     get scrollMargin() {
-      return input.showHeader() ? 64 : 0
+      return topOffset()
     },
     paddingEnd: 64,
     get rangeExtractor() {
@@ -446,7 +449,7 @@ export function createTimelineVirtualizer(input: Input) {
           data-timeline-key={rowProps.rowKey}
           style={{
             position: "absolute",
-            top: `${item().start - (input.showHeader() ? 64 : 0)}px`,
+            top: `${item().start - topOffset()}px`,
             left: "0",
             width: "100%",
             height: `${item().size}px`,
@@ -516,7 +519,9 @@ export function createTimelineVirtualizer(input: Input) {
           class="relative min-w-0 w-full h-full"
           style={{ "--sticky-accordion-top": input.showHeader() ? "48px" : "0px" }}
         >
-          <Show when={input.showHeader()}>{props.header}</Show>
+          <Show when={input.showHeader()} fallback={<div aria-hidden="true" class="h-4 md:hidden" />}>
+            {props.header}
+          </Show>
           <div
             data-timeline-virtual-content
             ref={(element) => {

packages/app/src/settings/general/general.tsx

@@ -362,6 +362,22 @@ export const SettingsGeneral: Component<{
 
         <ReasoningModeSetting />
 
+        <SettingsRow
+          title={language.t("session.review.wrapLines")}
+          description={language.t("settings.general.row.mobileDiffWrap.description")}
+        >
+          <div data-action="settings-mobile-diff-wrap">
+            <Switch
+              aria-label={language.t("session.review.wrapLines")}
+              checked={settings.general.mobileDiffWrap()}
+              onChange={settings.general.setMobileDiffWrap}
+              hideLabel
+            >
+              {language.t("session.review.wrapLines")}
+            </Switch>
+          </div>
+        </SettingsRow>
+
         <SettingsRow
           title={language.t("settings.general.row.shellToolPartsExpanded.title")}
           description={language.t("settings.general.row.shellToolPartsExpanded.description")}

packages/app/src/settings/model.tsx

@@ -41,6 +41,7 @@ export interface Settings {
     editToolPartsExpanded: boolean
     showCustomAgents: boolean
     mobileTitlebarPosition: "top" | "bottom"
+    mobileDiffWrap: boolean
     terminalPlacement: TerminalPlacement
     followUpBehavior: FollowUpBehavior
   }
@@ -130,6 +131,7 @@ const defaultSettings: Settings = {
     editToolPartsExpanded: false,
     showCustomAgents: false,
     mobileTitlebarPosition: "top",
+    mobileDiffWrap: true,
     terminalPlacement: "side",
     followUpBehavior: "steer",
   },
@@ -268,6 +270,10 @@ export const { use: useSettings, provider: SettingsProvider } = createSimpleCont
         setMobileTitlebarPosition(value: "top" | "bottom") {
           setStore("general", "mobileTitlebarPosition", value)
         },
+        mobileDiffWrap: withFallback(() => store.general?.mobileDiffWrap, defaultSettings.general.mobileDiffWrap),
+        setMobileDiffWrap(value: boolean) {
+          setStore("general", "mobileDiffWrap", value)
+        },
         terminalPlacement: withFallback(
           () => store.general?.terminalPlacement,
           defaultSettings.general.terminalPlacement,

packages/app/src/shell/mobile-panel-drawer.tsx

@@ -0,0 +1,44 @@
+import Drawer from "@corvu/drawer"
+import type { ParentProps } from "solid-js"
+import { useLanguage } from "@/runtime/i18n/language"
+import "./status/status-drawer.css"
+
+export function MobilePanelDrawer(
+  props: ParentProps<{
+    title: string
+    open: boolean
+    onOpenChange: (open: boolean) => void
+    returnFocus?: () => HTMLElement | undefined
+  }>,
+) {
+  const language = useLanguage()
+  return (
+    <Drawer
+      open={props.open}
+      onOpenChange={props.onOpenChange}
+      side="bottom"
+      finalFocusEl={props.returnFocus?.()}
+      // Menu focus handoff must not dismiss the drawer during its opening transition.
+      closeOnOutsideFocus={false}
+    >
+      {/* Preserve Corvu's content and dismissal lifecycle across reopenings. */}
+      <Drawer.Portal forceMount>
+        <Drawer.Overlay data-slot="mobile-status-overlay" />
+        <Drawer.Content forceMount data-slot="mobile-status-drawer" dir={language.direction()}>
+          <div data-slot="mobile-status-drag-handle" aria-hidden="true">
+            <span />
+          </div>
+          <div data-slot="mobile-status-header" data-corvu-no-drag>
+            <Drawer.Label>{props.title}</Drawer.Label>
+            <Drawer.Close data-slot="mobile-status-close" aria-label={language.t("common.close")}>
+              {language.t("common.close")}
+            </Drawer.Close>
+          </div>
+          <div data-slot="mobile-status-content" data-corvu-no-drag>
+            {props.children}
+          </div>
+        </Drawer.Content>
+      </Drawer.Portal>
+    </Drawer>
+  )
+}

packages/app/src/shell/status/body.tsx

@@ -20,7 +20,7 @@ const pluginEmptyMessage = (value: string, file: string): JSXElement => {
   )
 }
 
-export function StatusPopoverBody(props: { shown: boolean }) {
+export function StatusPopoverBody(props: { shown: boolean; embedded?: boolean }) {
   const data = useData()
   const sdk = useWorkspaceLocation()
   const serverSDK = useServerSDK()
@@ -42,7 +42,13 @@ export function StatusPopoverBody(props: { shown: boolean }) {
   const pluginEmpty = createMemo(() => pluginEmptyMessage(language.t("dialog.plugins.empty"), "opencode.json"))
 
   return (
-    <div class="flex items-center gap-1 w-[360px] rounded-xl shadow-[var(--shadow-lg-border-base)]">
+    <div
+      class="flex items-center gap-1 rounded-xl"
+      classList={{
+        "w-[360px] shadow-[var(--shadow-lg-border-base)]": !props.embedded,
+        "w-full min-w-0": props.embedded,
+      }}
+    >
       <Tabs
         aria-label={language.t("status.popover.ariaLabel")}
         class="tabs bg-background-strong rounded-xl overflow-hidden"

packages/app/src/shell/status/status-drawer.css

@@ -0,0 +1,145 @@
+[data-slot="mobile-status-overlay"] {
+  position: fixed;
+  inset: 0;
+  z-index: 50;
+  background: var(--v2-overlay-simple-overlay-scrim);
+  animation: mobile-status-backdrop-in 240ms ease-out;
+}
+
+[data-slot="mobile-status-overlay"]:is([data-closing], [data-closed]) {
+  animation: mobile-status-backdrop-out 200ms ease-in forwards;
+}
+
+[data-slot="mobile-status-drawer"] {
+  box-sizing: border-box;
+  position: fixed;
+  inset-inline: 0;
+  bottom: 0;
+  z-index: 51;
+  display: flex;
+  flex-direction: column;
+  max-height: min(75dvh, calc(100dvh - env(safe-area-inset-top, 0px) - 16px));
+  padding: 0 12px max(12px, env(safe-area-inset-bottom, 0px));
+  padding-left: max(12px, env(safe-area-inset-left, 0px));
+  padding-right: max(12px, env(safe-area-inset-right, 0px));
+  border-radius: 16px 16px 0 0;
+  background: var(--v2-background-bg-deep);
+  color: var(--v2-text-text-base);
+  box-shadow: var(--v2-elevation-overlay);
+  outline: none;
+  app-region: no-drag;
+}
+
+[data-slot="mobile-status-drawer"][data-transitioning] {
+  transition: transform 240ms cubic-bezier(0.2, 0.8, 0.2, 1);
+}
+
+[data-slot="mobile-status-drawer"][data-closing] {
+  transition-duration: 200ms;
+}
+
+[data-slot="mobile-status-drawer"][data-closed] {
+  visibility: hidden;
+  pointer-events: none;
+}
+
+[data-slot="mobile-status-drag-handle"] {
+  display: flex;
+  height: 28px;
+  flex-shrink: 0;
+  align-items: center;
+  justify-content: center;
+  touch-action: none;
+}
+
+[data-slot="mobile-status-drag-handle"] span {
+  width: 32px;
+  height: 4px;
+  border-radius: 999px;
+  background: var(--v2-border-border-strong);
+}
+
+[data-slot="mobile-status-header"] {
+  display: flex;
+  flex-shrink: 0;
+  align-items: center;
+  justify-content: space-between;
+  gap: 12px;
+  padding-inline-start: 8px;
+  padding-block-end: 8px;
+}
+
+[data-slot="mobile-status-header"] h2 {
+  margin: 0;
+  font-size: 14px;
+  font-weight: 530;
+  line-height: var(--line-height-base);
+}
+
+[data-slot="mobile-status-close"] {
+  min-height: 44px;
+  flex-shrink: 0;
+  padding-inline: 12px;
+  border-radius: 6px;
+  color: var(--v2-text-text-base);
+  font-size: 13px;
+  line-height: var(--line-height-compact);
+}
+
+@media (hover: hover) {
+  [data-slot="mobile-status-close"]:hover {
+    background: var(--v2-overlay-simple-overlay-hover);
+  }
+}
+
+[data-slot="mobile-status-close"]:focus-visible {
+  outline: 2px solid var(--v2-border-border-focus);
+  outline-offset: -2px;
+}
+
+[data-slot="mobile-status-content"] {
+  min-height: 0;
+  overflow-y: auto;
+  overscroll-behavior: contain;
+  touch-action: pan-y;
+}
+
+[data-slot="mobile-status-loading"] {
+  display: flex;
+  min-height: 56px;
+  align-items: center;
+  justify-content: center;
+  color: var(--v2-text-text-muted);
+  font-size: 13px;
+  line-height: var(--line-height-base);
+}
+
+@keyframes mobile-status-backdrop-in {
+  from {
+    opacity: 0;
+  }
+  to {
+    opacity: 1;
+  }
+}
+
+@keyframes mobile-status-backdrop-out {
+  from {
+    opacity: 1;
+  }
+  to {
+    opacity: 0;
+  }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  [data-slot="mobile-status-drawer"][data-transitioning],
+  [data-slot="mobile-status-drawer"][data-closing] {
+    transition: none;
+  }
+
+  [data-slot="mobile-status-overlay"],
+  [data-slot="mobile-status-overlay"]:is([data-closing], [data-closed]) {
+    animation: none;
+  }
+}

packages/app/src/shell/status/status-drawer.tsx

@@ -0,0 +1,35 @@
+import { lazy, Suspense } from "solid-js"
+import { useLanguage } from "@/runtime/i18n/language"
+import { MobilePanelDrawer } from "../mobile-panel-drawer"
+
+const Body = lazy(async () => {
+  const { StatusPopoverBody } = await import("./body")
+  return { default: StatusPopoverBody }
+})
+
+export function StatusDrawer(props: {
+  open: boolean
+  onOpenChange: (open: boolean) => void
+  returnFocus?: () => HTMLElement | undefined
+}) {
+  const language = useLanguage()
+
+  return (
+    <MobilePanelDrawer
+      title={language.t("status.popover.trigger")}
+      open={props.open}
+      onOpenChange={props.onOpenChange}
+      returnFocus={props.returnFocus}
+    >
+      <Suspense
+        fallback={
+          <div data-slot="mobile-status-loading" role="status">
+            {language.t("common.loading")}
+          </div>
+        }
+      >
+        <Body shown={props.open} embedded />
+      </Suspense>
+    </MobilePanelDrawer>
+  )
+}

packages/app/test-browser/pwa-route.test.ts

@@ -0,0 +1,79 @@
+import { afterEach, beforeEach, expect, test } from "bun:test"
+import { MemoryRouter, createMemoryHistory } from "@solidjs/router"
+import { createComponent, render } from "solid-js/web"
+import { isStandalone, PwaRoutePersistence, restorePwaRoute } from "../src/runtime/platform/pwa"
+
+const key = "opencode.pwa.last-route"
+const originalUrl = window.location.href
+
+beforeEach(() => {
+  window.location.href = "http://localhost/"
+})
+
+afterEach(() => {
+  localStorage.removeItem(key)
+  window.location.href = originalUrl
+})
+
+test("normal browser windows are not standalone", () => {
+  expect(isStandalone()).toBe(false)
+})
+
+test("restores the last PWA route including query and hash without adding history", () => {
+  window.history.replaceState({ retained: true }, "", "http://localhost/")
+  const length = window.history.length
+  localStorage.setItem(key, "/server/local/session/session-1?view=files#file")
+
+  restorePwaRoute()
+
+  expect(window.location.pathname + window.location.search + window.location.hash).toBe(
+    "/server/local/session/session-1?view=files#file",
+  )
+  expect(window.history.length).toBe(length)
+  expect(window.history.state).toEqual({ retained: true })
+})
+
+test("preserves explicit launch routes, queries, and hashes", () => {
+  localStorage.setItem(key, "/server/local/session/saved")
+  for (const route of ["/server/local/session/linked", "/new-session?draftId=123", "/?launch=1", "/#launch"]) {
+    window.history.replaceState(null, "", `http://localhost${route}`)
+    restorePwaRoute()
+    expect(window.location.pathname + window.location.search + window.location.hash).toBe(route)
+  }
+})
+
+test("ignores missing, invalid, external, and auth-bearing saved routes", () => {
+  window.history.replaceState(null, "", "http://localhost/")
+  restorePwaRoute()
+  expect(window.location.pathname).toBe("/")
+
+  for (const value of [
+    "/removed-route",
+    "https://example.com/new-session",
+    "//example.com/new-session",
+    "http://[",
+    "/new-session?auth_token=secret",
+  ]) {
+    localStorage.setItem(key, value)
+    restorePwaRoute()
+    expect(window.location.href).toBe("http://localhost/")
+  }
+})
+
+test("persists router navigation including returning home", async () => {
+  const host = document.createElement("div")
+  const history = createMemoryHistory()
+  history.set({ value: "/new-session?draftId=123", replace: true, scroll: false })
+  const dispose = render(() => createComponent(MemoryRouter, { history, root: PwaRoutePersistence }), host)
+  try {
+    expect(localStorage.getItem(key)).toBe("/new-session?draftId=123")
+    history.set({ value: "/server/local/session/next#file", scroll: false })
+    await new Promise((resolve) => setTimeout(resolve, 0))
+    expect(localStorage.getItem(key)).toBe("/server/local/session/next#file")
+    history.set({ value: "/", scroll: false })
+    await new Promise((resolve) => setTimeout(resolve, 0))
+    expect(localStorage.getItem(key)).toBe("/")
+  } finally {
+    dispose()
+  }
+})

packages/app/vite.icons.test.ts

@@ -59,6 +59,7 @@ test.each(["dev", "beta", "prod"])("serves %s app icons", async (channel) => {
 async function check(channel: string, read: (path: string) => Promise<Uint8Array>) {
   const html = new TextDecoder().decode(await read("/index.html"))
   const actual: typeof manifest = JSON.parse(new TextDecoder().decode(await read("/site.webmanifest")))
+  expect(actual.icons.every((icon) => icon.purpose === "maskable")).toBe(true)
   expect(actual).toEqual({
     ...manifest,
     icons: manifest.icons.map((icon) => ({ ...icon, src: `/icons/${channel}${icon.src}` })),

packages/cli/src/index.ts

@@ -98,12 +98,13 @@ Effect.gen(function* () {
   Effect.provide(Config.layer),
   Effect.provide(Updater.layer),
   Effect.provide(
-    LayerNode.compile(LayerNode.group([Global.node, AppProcess.node, Npm.node]), [
-      [
-        Global.node,
-        Global.layerWith(process.env.OPENCODE_CONFIG_DIR ? { config: process.env.OPENCODE_CONFIG_DIR } : {}),
+    LayerNode.compile(LayerNode.group([Global.node, AppProcess.node, Npm.node]), {
+      replacements: [
+        Global.node.replace(
+          Global.layerWith(process.env.OPENCODE_CONFIG_DIR ? { config: process.env.OPENCODE_CONFIG_DIR } : {}),
+        ),
       ],
-    ]),
+    }),
   ),
   Effect.provide(
     Observability.layer({

packages/cli/src/server-process.ts

@@ -30,12 +30,13 @@ export const run = Effect.fnUntraced(function* (options: Options) {
   return yield* processEffect(options).pipe(
     Effect.provide(Updater.layer),
     Effect.provide(
-      LayerNode.compile(LayerNode.group([Global.node, AppProcess.node]), [
-        [
-          Global.node,
-          Global.layerWith(process.env.OPENCODE_CONFIG_DIR ? { config: process.env.OPENCODE_CONFIG_DIR } : {}),
+      LayerNode.compile(LayerNode.group([Global.node, AppProcess.node]), {
+        replacements: [
+          Global.node.replace(
+            Global.layerWith(process.env.OPENCODE_CONFIG_DIR ? { config: process.env.OPENCODE_CONFIG_DIR } : {}),
+          ),
         ],
-      ]),
+      }),
     ),
     Effect.provide(NodeServices.layer),
   )

packages/client/src/shared-events.ts

@@ -3,7 +3,7 @@ export * as SharedEvents from "./shared-events.js"
 export function make<A extends { readonly type: string }>(connect: (signal: AbortSignal) => AsyncIterable<A>) {
   type Completion = { readonly error: unknown } | Record<string, never>
   type Subscriber = {
-    push: (value: A) => Promise<void>
+    push: (value: A) => void
     finish: (completion: Completion) => void
   }
   type Connection = {
@@ -13,7 +13,7 @@ export function make<A extends { readonly type: string }>(connect: (signal: Abor
   }
 
   let current: Connection | undefined
-  const delivered = Promise.resolve()
+  const capacity = 4_096
 
   function stop(connection: Connection) {
     connection.connected = undefined
@@ -31,7 +31,7 @@ export function make<A extends { readonly type: string }>(connect: (signal: Abor
         const item = await iterator.next()
         if (item.done || connection.controller.signal.aborted) break
         if (item.value.type === "server.connected") connection.connected = item.value
-        await Promise.all(Array.from(connection.subscribers, (subscriber) => subscriber.push(item.value)))
+        connection.subscribers.forEach((subscriber) => subscriber.push(item.value))
       }
     } catch (error) {
       completion = { error }
@@ -51,15 +51,14 @@ export function make<A extends { readonly type: string }>(connect: (signal: Abor
       return {
         [Symbol.asyncIterator]() {
           const pending: ReturnType<typeof Promise.withResolvers<IteratorResult<A>>>[] = []
+          const queued: A[] = []
           let started = false
           let completion: Completion | undefined
           let connection: Connection | undefined
-          let offered: { readonly value: A; readonly accepted: ReturnType<typeof Promise.withResolvers<void>> } | undefined
 
-          function finish(result: Completion) {
+          function finish(result: Completion, discard = true) {
             completion = result
-            offered?.accepted.resolve()
-            offered = undefined
+            if (discard) queued.length = 0
             options?.signal?.removeEventListener("abort", abort)
             if (connection?.subscribers.delete(subscriber) && !connection.subscribers.size) stop(connection)
             pending.splice(0).forEach((request) => {
@@ -73,17 +72,21 @@ export function make<A extends { readonly type: string }>(connect: (signal: Abor
           }
 
           const subscriber: Subscriber = {
-            finish,
+            finish(result) {
+              finish(result, false)
+            },
             push(value) {
-              if (completion) return delivered
+              if (completion) return
               const request = pending.shift()
               if (request) {
                 request.resolve({ done: false, value })
-                return delivered
+                return
               }
-              const accepted = Promise.withResolvers<void>()
-              offered = { value, accepted }
-              return accepted.promise
+              if (queued.length === capacity) {
+                finish({ error: new Error(`Event subscriber exceeded its ${capacity}-event capacity`) })
+                return
+              }
+              queued.push(value)
             },
           }
 
@@ -102,12 +105,8 @@ export function make<A extends { readonly type: string }>(connect: (signal: Abor
 
           return {
             next(): Promise<IteratorResult<A>> {
-              if (offered) {
-                const current = offered
-                offered = undefined
-                current.accepted.resolve()
-                return Promise.resolve({ done: false, value: current.value })
-              }
+              const value = queued.shift()
+              if (value) return Promise.resolve({ done: false, value })
               if (completion) {
                 if ("error" in completion) return Promise.reject(completion.error)
                 return Promise.resolve({ done: true, value: undefined })

packages/client/src/solid/data.ts

@@ -618,13 +618,17 @@ export function createData(config: CreateDataInput) {
           })
           .catch((error) => console.error("Failed to load projected model switch message", error))
         return
-      case "session.renamed":
+      case "session.renamed": {
         // Preserve the live title when it races the session's initial read.
-        void result.session.sync(event.data.sessionID).then(() => {
+        const family = sync.pending(`session.family:${event.data.sessionID}`)
+          ? result.session.sync(event.data.sessionID, { children: true })
+          : Promise.resolve()
+        void Promise.all([result.session.sync(event.data.sessionID), family]).then(() => {
           if (store.session.info[event.data.sessionID])
             setStore("session", "info", event.data.sessionID, "title", event.data.title)
         })
         return
+      }
       case "session.moved": {
         const current = store.session.info[event.data.sessionID]
         if (current) {

packages/client/test/shared-events.test.ts

@@ -97,7 +97,11 @@ test("multiple consumers share one source and receive live native and RPC events
   const first = shared.subscribe()[Symbol.asyncIterator]()
   const second = shared.subscribe()[Symbol.asyncIterator]()
 
-  for (const event of [{ type: "server.connected" }, { type: "session.updated" }, { type: "rpc.example.updated", value: 1 }]) {
+  for (const event of [
+    { type: "server.connected" },
+    { type: "session.updated" },
+    { type: "rpc.example.updated", value: 1 },
+  ]) {
     const reads = [first.next(), second.next()]
     events.connections[0].push(event)
     expect(await Promise.all(reads)).toEqual([
@@ -115,6 +119,60 @@ test("multiple consumers share one source and receive live native and RPC events
   await events.connections[0].closed
 })
 
+test("an idle consumer does not stall events for an active consumer", async () => {
+  const events = source()
+  const shared = SharedEvents.make(events.connect)
+  const idle = shared.subscribe()[Symbol.asyncIterator]()
+  const active = shared.subscribe()[Symbol.asyncIterator]()
+  const connected = [idle.next(), active.next()]
+  events.connections[0].push({ type: "server.connected" })
+  await Promise.all(connected)
+
+  for (const event of [
+    { type: "session.updated", value: 1 },
+    { type: "session.updated", value: 2 },
+  ]) {
+    const next = active.next()
+    events.connections[0].push(event)
+    expect(
+      await Promise.race([next, Bun.sleep(1_000).then(() => ({ done: true as const, value: { type: "timeout" } }))]),
+    ).toEqual({ done: false, value: event })
+  }
+
+  await idle.return!()
+  await active.return!()
+  await events.connections[0].closed
+})
+
+test("an idle consumer fails instead of buffering events without bound", async () => {
+  const events = source()
+  const idle = SharedEvents.make(events.connect).subscribe()[Symbol.asyncIterator]()
+  const connected = idle.next()
+  events.connections[0].push({ type: "server.connected" })
+  await connected
+
+  Array.from({ length: 4_097 }, (_, value) => events.connections[0].push({ type: "session.updated", value }))
+  await events.connections[0].closed
+  await expect(idle.next()).rejects.toThrow("Event subscriber exceeded its 4096-event capacity")
+})
+
+test("source completion preserves events already buffered for an idle consumer", async () => {
+  const events = source()
+  const idle = SharedEvents.make(events.connect).subscribe()[Symbol.asyncIterator]()
+  const connected = idle.next()
+  events.connections[0].push({ type: "server.connected" })
+  await connected
+  events.connections[0].push({ type: "session.updated", value: 1 })
+  events.connections[0].push({ type: "session.updated", value: 2 })
+  events.connections[0].close()
+  await events.connections[0].closed
+  await Bun.sleep(0)
+
+  expect(await idle.next()).toEqual({ done: false, value: { type: "session.updated", value: 1 } })
+  expect(await idle.next()).toEqual({ done: false, value: { type: "session.updated", value: 2 } })
+  expect(await idle.next()).toEqual({ done: true, value: undefined })
+})
+
 test("late consumers receive the latest connection marker but no business event replay", async () => {
   const events = source()
   const shared = SharedEvents.make(events.connect)

packages/client/test/solid-data.test.ts

@@ -73,6 +73,63 @@ test("revalidates after an event overtakes an active session read", async () =>
   }
 })
 
+test("preserves a live session rename across concurrent session and family reads", async () => {
+  const family = Promise.withResolvers<void>()
+  const renamed = Promise.withResolvers<void>()
+  const listeners = new Set<Parameters<CreateDataInput["event"]["listen"]>[0]>()
+  let requests = 0
+  const stale = { ...session(0), title: undefined }
+  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/${stale.id}`)) return Response.json({ data: [], cursor: {} })
+      requests++
+      await (requests === 1 ? family.promise : renamed.promise)
+      return Response.json({ data: stale })
+    },
+  })
+  const setup = createRoot((dispose) => ({
+    data: createData({
+      api: () => api,
+      directory: "/project",
+      event: {
+        on: () => () => {},
+        listen(handler) {
+          listeners.add(handler)
+          return () => listeners.delete(handler)
+        },
+      },
+    }),
+    dispose,
+  }))
+
+  try {
+    const initial = setup.data.session.sync(stale.id, { children: true })
+    await wait(() => requests === 1)
+    const event: OpenCodeEvent = {
+      id: "evt_renamed",
+      created: 1,
+      type: "session.renamed",
+      durable: { aggregateID: stale.id, seq: 1, version: 1 },
+      data: { sessionID: stale.id, title: "Generated title" },
+    }
+    listeners.forEach((listener) => listener({ name: event.type, details: event }))
+    await wait(() => requests === 2)
+    renamed.resolve()
+    await wait(() => setup.data.session.get(stale.id) !== undefined)
+    family.resolve()
+    await initial
+    await Bun.sleep(0)
+
+    expect(setup.data.session.get(stale.id)?.title).toBe("Generated title")
+  } finally {
+    family.resolve()
+    renamed.resolve()
+    setup.dispose()
+  }
+})
+
 test("updates authoritative cached project metadata from live events", async () => {
   const listeners = new Set<Parameters<CreateDataInput["event"]["listen"]>[0]>()
   const original: Project = {

packages/codemode/src/tool-schema.ts

@@ -180,7 +180,7 @@ export const toTypeScript = (schema: Schema.Top, decoded = false, pretty = false
 
 export const jsonSchemaToTypeScript = (schema: JsonSchema, pretty = false): string => {
   try {
-    return renderSchema(schema, { definitions: { ...(schema.definitions ?? {}), ...(schema.$defs ?? {}) }, pretty })
+    return renderSchema(schema, { definitions: {}, pretty })
   } catch {
     return "unknown"
   }

packages/codemode/test/signature.test.ts

@@ -216,6 +216,35 @@ describe("pretty signature rendering", () => {
   })
 })
 
+describe("JSON Schema definition scope", () => {
+  test.each(["definitions", "$defs"])("resolves root %s and lets $defs take precedence", (key) => {
+    const schema = { $ref: `#/${key}/Value`, [key]: { Value: { type: "string" } } }
+    expect(jsonSchemaToTypeScript(schema)).toBe("string")
+    expect(jsonSchemaToTypeScript(schema, true)).toBe("string")
+
+    const overridden = { ...schema, $defs: { Value: { type: "number" } } }
+    expect(jsonSchemaToTypeScript(overridden)).toBe("number")
+    expect(jsonSchemaToTypeScript(overridden, true)).toBe("number")
+  })
+
+  test.each(["definitions", "$defs"])("nested %s shadow inherited definitions without affecting siblings", (key) => {
+    const schema = {
+      type: "object",
+      definitions: { Inherited: { type: "string" } },
+      $defs: { Value: { type: "number" } },
+      properties: {
+        nested: { $ref: `#/${key}/Value`, [key]: { Value: { type: "boolean" } } },
+        inherited: { $ref: "#/definitions/Inherited" },
+        sibling: { $ref: "#/$defs/Value" },
+      },
+    }
+    expect(jsonSchemaToTypeScript(schema)).toBe("{ nested?: boolean; inherited?: string; sibling?: number }")
+    expect(jsonSchemaToTypeScript(schema, true)).toBe(
+      ["{", "  nested?: boolean,", "  inherited?: string,", "  sibling?: number,", "}"].join("\n"),
+    )
+  })
+})
+
 describe("non-identifier property names render as quoted keys", () => {
   // MCP-style schemas routinely carry property names that are not bare TS identifiers
   // (`foo-bar`, `@type`, dotted names); the rendered signature must quote them so the

packages/core/src/aisdk.ts

@@ -327,12 +327,7 @@ function modelFromLanguage(info: Info, language: LanguageModelV3) {
     },
     body: {
       schema: Schema.Unknown,
-      from: (request) =>
-        Effect.try({
-          try: () => callOptions(request, packageName, info.modelID ?? info.id, optionKey),
-          catch: (cause) =>
-            cause instanceof AIError ? cause : ProviderShared.invalidRequest("Invalid AI SDK request", cause),
-        }),
+      from: (request) => Effect.succeed(callOptions(request, packageName, info.modelID ?? info.id, optionKey)),
     },
     with: () => route,
     model: (input) =>
@@ -517,8 +512,6 @@ function userPart(part: ContentPart): UserContent {
 
 function assistantPart(part: ContentPart): AssistantContent {
   switch (part.type) {
-    case "compaction":
-      throw ProviderShared.invalidRequest("AI SDK routes cannot replay native provider compaction state")
     case "text":
       return [{ type: "text", text: part.text, providerOptions: metadataProviderOptions(part.providerMetadata) }]
     case "media":

packages/core/src/effect/app-node-builder.ts

@@ -1,20 +1,11 @@
 import { buildLocationServiceMap } from "../location-services.js"
 import { LocationServiceMap } from "../location-service-map.js"
 import { LayerNode } from "@opencode-ai/util/effect/layer-node"
-import { makeGlobalNode } from "@opencode-ai/util/effect/app-node"
 
-export function build<A, E>(root: LayerNode.Node<A, E, any>, replacements: LayerNode.Replacements = []) {
-  // Only build the location service map if it's actually needed
-  if (!LayerNode.hasUnbound(root, LocationServiceMap.node) || hasReplacement(replacements, LocationServiceMap.node))
-    return LayerNode.compile(root, replacements)
-
-  const locationMap = buildLocationServiceMap(replacements)
-  const locationMapNode = makeGlobalNode({ service: LocationServiceMap.Service, layer: locationMap, deps: [] })
-  return LayerNode.compile(root, replacements.concat([[LocationServiceMap.node, locationMapNode]]))
-}
-
-function hasReplacement(replacements: LayerNode.Replacements, node: LayerNode.Node<unknown, unknown, any>) {
-  return replacements.some(([source]) => source.name === node.name)
+export function build<A, E>(root: LayerNode.Graph<A, E>, replacements: LayerNode.Replacements = []) {
+  return LayerNode.compile(root, {
+    replacements: [LocationServiceMap.node.replace(buildLocationServiceMap(replacements)), ...replacements],
+  })
 }
 
 export * as AppNodeBuilder from "./app-node-builder.js"

packages/core/src/formatter.ts

@@ -54,9 +54,8 @@ const layer = Layer.effect(
     })
 
     const file = Effect.fn("Formatter.file")(function* (filepath: string) {
-      const matching = state
-        .get()
-        .formatters.filter((formatter) => formatter.extensions.includes(path.extname(filepath)))
+      const extension = path.extname(filepath)
+      const matching = state.get().formatters.filter((formatter) => formatter.extensions.includes(extension))
 
       for (const formatter of matching) {
         const enabled = yield* command(formatter)

packages/core/src/git.ts

@@ -14,6 +14,8 @@ export class Repository extends Schema.Class<Repository>("Git.Repository")({
   worktree: AbsolutePath,
   gitDirectory: AbsolutePath,
   commonDirectory: AbsolutePath,
+  /** Additional read-only object databases; index and worktree remain local. */
+  objectDirectories: Schema.optional(Schema.Array(AbsolutePath)),
 }) {}
 
 // Included from $GIT_DIR/config via include.path (git >= 1.7.10); OpenCode owns
@@ -50,6 +52,7 @@ export class OperationError extends Schema.TaggedError<OperationError>()("Git.Op
     "list_files",
     "diff",
     "restore",
+    "retain",
   ]),
   message: Schema.String,
   directory: Schema.optional(AbsolutePath),
@@ -132,6 +135,12 @@ export interface Interface {
     }) => Effect.Effect<ReadonlySet<RelativePath>, OperationError>
   }
   readonly tree: {
+    readonly exists: (repository: Repository, tree: TreeID) => Effect.Effect<boolean>
+    /** Retain a tree's borrowed objects in this repository, independent of its alternates. */
+    readonly retain: (input: {
+      repository: Repository
+      trees: readonly TreeID[]
+    }) => Effect.Effect<void, OperationError>
     readonly capture: (input: {
       repository: Repository
       scopes: readonly RelativePath[]
@@ -314,7 +323,16 @@ const layer = Layer.effect(
         .run(
           ChildProcess.make("git", repositoryArgs(repository, args), {
             cwd: repository.worktree,
-            env: options?.env,
+            env: {
+              ...(repository.objectDirectories?.length
+                ? {
+                    GIT_ALTERNATE_OBJECT_DIRECTORIES: repository.objectDirectories
+                      .map((directory) => JSON.stringify(directory))
+                      .join(path.delimiter),
+                  }
+                : {}),
+              ...options?.env,
+            },
             extendEnv: true,
           }),
           { stdin: options?.stdin },
@@ -477,6 +495,46 @@ const layer = Layer.effect(
       return TreeID.make((yield* repositoryOperation("write_tree", repository, ["write-tree"])).text.trim())
     })
 
+    const treeExists = Effect.fn("Git.tree.exists")((repository: Repository, tree: TreeID) =>
+      repositoryOperation("list_files", repository, ["cat-file", "-e", `${tree}^{tree}`]).pipe(
+        Effect.as(true),
+        Effect.orElseSucceed(() => false),
+      ),
+    )
+
+    const retain = Effect.fn("Git.tree.retain")((input: { repository: Repository; trees: readonly TreeID[] }) =>
+      locked(
+        input.repository,
+        Effect.gen(function* () {
+          const retained = (yield* repositoryOperation("retain", input.repository, [
+            "for-each-ref",
+            "--format=%(objectname)",
+            "refs/opencode/snapshots/",
+          ])).text
+            .trim()
+            .split("\n")
+            .filter(Boolean)
+          const missing = Array.from(new Set(input.trees)).filter((tree) => !retained.includes(tree))
+          if (!missing.length) return
+          // Only these refs certify locally retained objects. Ordinary refs or alternates do not.
+          yield* repositoryOperation(
+            "retain",
+            input.repository,
+            [
+              "pack-objects",
+              "--revs",
+              "--non-empty",
+              path.join(input.repository.gitDirectory, "objects", "pack", "pack"),
+            ],
+            { stdin: [...missing, ...retained.map((tree) => `^${tree}`)].join("\n") + "\n" },
+          )
+          yield* repositoryOperation("retain", input.repository, ["update-ref", "--stdin"], {
+            stdin: missing.map((tree) => `update refs/opencode/snapshots/${tree} ${tree}\n`).join(""),
+          })
+        }),
+      ),
+    )
+
     const captureTree = Effect.fn("Git.tree.capture")(
       (input: {
         repository: Repository
@@ -586,28 +644,59 @@ const layer = Layer.effect(
       (input: { repository: Repository; files: ReadonlyMap<RelativePath, TreeID> }) =>
         locked(
           input.repository,
-          Effect.forEach(
-            input.files,
-            ([file, tree]) =>
-              Effect.gen(function* () {
-                if (yield* hasEntry(input.repository, tree, file)) {
-                  yield* repositoryOperation("restore", input.repository, ["checkout", tree, "--", file])
-                  return
-                }
-                yield* fs.remove(path.join(input.repository.worktree, file), { recursive: true, force: true }).pipe(
-                  Effect.mapError(
-                    (cause) =>
-                      new OperationError({
-                        operation: "restore",
-                        directory: input.repository.worktree,
-                        message: `Failed to remove ${file}`,
-                        cause,
-                      }),
-                  ),
-                )
-              }),
-            { discard: true },
-          ),
+          Effect.gen(function* () {
+            const entries = yield* Effect.forEach(input.files, ([file, tree]) =>
+              hasEntry(input.repository, tree, file).pipe(
+                Effect.map((present) => ({ file, tree, present, depth: file.split("/").length })),
+              ),
+            )
+            // Remove descendants before any restoration can replace their ancestor with a symlink or file.
+            yield* Effect.forEach(
+              entries.toSorted(
+                (a, b) => Number(a.present) - Number(b.present) || (a.present ? a.depth - b.depth : b.depth - a.depth),
+              ),
+              ({ file, tree, present }) =>
+                Effect.gen(function* () {
+                  if (present) {
+                    yield* repositoryOperation("restore", input.repository, [
+                      "--literal-pathspecs",
+                      "restore",
+                      `--source=${tree}`,
+                      ...(input.repository.objectDirectories?.length ? [] : ["--staged"]),
+                      "--worktree",
+                      "--",
+                      file,
+                    ])
+                    // Re-index foreign content without alternates so future local captures can read it.
+                    if (input.repository.objectDirectories?.length)
+                      yield* repositoryOperation(
+                        "restore",
+                        new Repository({ ...input.repository, objectDirectories: undefined }),
+                        ["--literal-pathspecs", "add", "--force", "--sparse", "--", file],
+                      )
+                    return
+                  }
+                  yield* fs.remove(path.join(input.repository.worktree, file), { recursive: true, force: true }).pipe(
+                    Effect.mapError(
+                      (cause) =>
+                        new OperationError({
+                          operation: "restore",
+                          directory: input.repository.worktree,
+                          message: `Failed to remove ${file}`,
+                          cause,
+                        }),
+                    ),
+                  )
+                  yield* repositoryOperation("restore", input.repository, [
+                    "update-index",
+                    "--force-remove",
+                    "--",
+                    file,
+                  ])
+                }),
+              { discard: true },
+            )
+          }),
         ),
     )
 
@@ -690,6 +779,8 @@ const layer = Layer.effect(
       worktree: { create: worktreeCreate, remove: worktreeRemove, list: worktreeList },
       index: { refresh, ignored },
       tree: {
+        exists: treeExists,
+        retain,
         capture: captureTree,
         write: writeTree,
         files: treeFiles,

packages/core/src/instance.ts

@@ -55,6 +55,7 @@ import { ToolOutput } from "./tool-output.js"
 import { Vcs } from "./vcs.js"
 
 export * as Instance from "./instance.js"
+export { Service, byLocationNode, type Interface } from "./instance/service.js"
 
 const nodes = [
   Location.node,
@@ -110,9 +111,9 @@ const nodes = [
   Vcs.node,
   // Start repository watches only after boot-critical filesystem and Git work.
   LocationWatcher.node,
-] as const satisfies readonly Node.LocationNode<unknown, unknown>[]
+] as const satisfies readonly Node.LocationGraph<never, unknown>[]
 
-export const graph = LayerNode.group<typeof nodes>(nodes)
+export const graph = LayerNode.group(nodes)
 
 export type Services = LayerNode.Output<typeof graph>
 export type Error = LayerNode.Error<typeof graph>
@@ -141,29 +142,23 @@ export interface Options {
 // source still honors explicit plugin operations from wellknown and
 // host-injected config.
 const vanillaReplacements: LayerNode.Replacements = [
-  [Config.node, Config.configured({ project: false, global: false })],
-  [InstructionDiscovery.node, InstructionDiscovery.configured({ project: false, global: false })],
+  Config.node.replace(Config.configured({ project: false, global: false })),
+  InstructionDiscovery.node.replace(InstructionDiscovery.configured({ project: false, global: false })),
 ]
 
 // One instance is one compiled, fresh copy of the graph standing on a directory.
 export function layer(ref: Location.Ref, options: Options = {}) {
   const startedAt = performance.now()
   // Ordered: vanilla defaults, then caller replacements (which win over the
-  // defaults), then bound pairs (which win over everything).
-  const allReplacements: LayerNode.Replacements = [
+  // defaults), then instance bindings (which win over everything).
+  const replacements: LayerNode.Replacements = [
     ...(options.discovery === false ? vanillaReplacements : []),
     ...(options.replacements ?? []),
-    [Location.node, Location.boundNode(ref, { discovery: options.discovery })],
-    [InstancePlugins.node, InstancePlugins.bound(options.plugins ?? [])],
+    Location.node.replace(Location.boundNode(ref, { discovery: options.discovery })),
+    InstancePlugins.node.replace(InstancePlugins.bound(options.plugins ?? [])),
   ]
-  // Apply replacements during hoist, not afterward: replacements can
-  // introduce new tagged dependencies (Location.boundNode depends on
-  // Project), and the hoist walk is the only pass that can still slice
-  // those back out.
-  const location = LayerNode.hoist(graph, Node.tags.values.global, allReplacements)
 
-  return LayerNode.compile(location.node).pipe(
-    Layer.fresh,
+  return LayerNode.compile(graph, { replacements, shared: Node.tags.values.global }).pipe(
     Layer.tap(() =>
       Effect.logInfo("location services booted", {
         directory: ref.directory,
@@ -171,6 +166,5 @@ export function layer(ref: Location.Ref, options: Options = {}) {
         durationMs: Math.round(performance.now() - startedAt),
       }),
     ),
-    Layer.provide(LayerNode.compile(location.hoisted)),
   )
 }

packages/core/src/instance/service.ts

@@ -0,0 +1,42 @@
+export * as Instance from "./service.js"
+export type { Services } from "../instance.js"
+
+import { Context, Effect, Layer, Option, Scope } from "effect"
+import type { Session } from "@opencode-ai/schema/session"
+import { makeGlobalNode } from "@opencode-ai/util/effect/app-node"
+import type { Services } from "../instance.js"
+import { LocationServiceMap } from "../location-service-map.js"
+
+/** Selects Session capabilities; implementations own caching and lifetime. */
+export interface Interface {
+  readonly provide: (
+    session: Session.Info,
+  ) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, Services>>
+  /** Borrow a cached instance without initializing one when it is absent. */
+  readonly provideIfLoaded: (
+    session: Session.Info,
+  ) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<Option.Option<A>, E, Exclude<R, Services>>
+}
+
+export class Service extends Context.Service<Service, Interface>()("@opencode/Instance") {}
+
+const layer = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    const locations = yield* LocationServiceMap.Service
+    return Service.of({
+      provide: (session) => Effect.provide(locations.get(session.location)),
+      provideIfLoaded: (session) => (effect) =>
+        // Scope the borrowed reference without replacing the caller's Scope.
+        Effect.scopedWith((scope) =>
+          Effect.gen(function* () {
+            const context = yield* locations.contextEffectOption(session.location).pipe(Scope.provide(scope))
+            if (Option.isNone(context)) return Option.none()
+            return Option.some(yield* effect.pipe(Effect.provide(context.value)))
+          }),
+        ),
+    })
+  }),
+)
+
+export const byLocationNode = makeGlobalNode({ service: Service, layer, deps: [LocationServiceMap.node] })

packages/core/src/persistent-pty/index.ts

@@ -112,7 +112,7 @@ export interface Interface {
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/PersistentPty") {}
 
-export const configured = (options: Options = {}) =>
+const makeLayer = (options: Options = {}) =>
   Layer.effect(
     Service,
     Effect.gen(function* () {
@@ -361,8 +361,14 @@ export const configured = (options: Options = {}) =>
     }),
   )
 
-export const layer = configured()
-export const node = makeGlobalNode({ service: Service, layer, deps: [Bus.node, Global.node] })
+export const layer = makeLayer()
+export const configured = (options?: Options) =>
+  makeGlobalNode({
+    service: Service,
+    layer: options === undefined ? layer : makeLayer(options),
+    deps: [Bus.node, Global.node],
+  })
+export const node = configured()
 
 const request = (daemon: DaemonTransport, value: object, start = false) =>
   daemon.request(value, start).pipe(Effect.mapError(unavailable))

packages/core/src/plugin/host.ts

@@ -80,7 +80,8 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: Interface, p
   const response = <A, E, R>(effect: Effect.Effect<A, E, R>) =>
     effect.pipe(Effect.map((data) => ({ location: locationInfo(), data })))
 
-  return {
+  // Keep the instance graph's inferred types independent of Session handles.
+  const context: Plugin.Context = {
     app,
     location: locationInfo(),
     options: {},
@@ -206,7 +207,8 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: Interface, p
           .subscribe()
           .pipe(
             Stream.filter(
-              (event): event is EventManifest.ServerEvent | RpcEvent => EventManifest.isServer(event) || isRpcEvent(event),
+              (event): event is EventManifest.ServerEvent | RpcEvent =>
+                EventManifest.isServer(event) || isRpcEvent(event),
             ),
           ),
     },
@@ -449,7 +451,8 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: Interface, p
       wait: (input) => runtime.session.wait(input.sessionID),
       context: (input) => runtime.session.context(input.sessionID),
     },
-  } satisfies Plugin.Context
+  }
+  return context
 })
 
 export function storage(kv: KV.Interface, pluginID: string): Plugin.Context["storage"] {

packages/core/src/plugin/runtime.ts

@@ -62,7 +62,7 @@ const require = <A, E, R>(cell: Cell, f: (runtime: Interface) => Effect.Effect<A
 
 const defaultCell = makeCell()
 
-export const layerWithCell = (cell: Cell) =>
+export const layerWithCell = (cell: Cell): Layer.Layer<Service> =>
   Layer.succeed(
     Service,
     Service.of({

packages/core/src/plugin/skill/opencode.md

@@ -11,6 +11,9 @@ truth. Follow links from that page when the question needs more detail. Fetch
 <https://opencode.ai/v2/docs/> first when you need to discover the relevant
 documentation page.
 
+A machine-readable documentation index is available at
+<https://opencode.ai/v2/llms.txt>.
+
 ## Version policy
 
 Always answer for OpenCode V2 unless the user explicitly asks about V1,
@@ -152,6 +155,8 @@ before answering. Refer to this guide when the user wants to build a plugin. It
 covers hooks, transforms, tools, plugin context capabilities, and package
 entrypoints. Plugins can also extend the TUI; for those, fetch the
 [CLI plugin guide](https://opencode.ai/v2/docs/build/plugins/cli).
+For custom methods and events shared with other plugins or clients, fetch the
+[RPC guide](https://opencode.ai/v2/docs/build/plugins/rpc).
 
 ## [Service](https://opencode.ai/v2/docs/troubleshooting#check-the-background-service)
 
@@ -220,6 +225,16 @@ exposes typed Effects, Streams, and decoded OpenCode schema values. Its
 `Service` API can discover, start, stop, and authenticate with the local
 background service from a Node application.
 
+## [SDK](https://opencode.ai/v2/docs/build/sdk)
+
+For questions about embedding OpenCode directly in an application, fetch the
+full [SDK guide](https://opencode.ai/v2/docs/build/sdk) before answering. The SDK
+hosts OpenCode in the application without opening an HTTP listener.
+
+Use the [Effect SDK guide](https://opencode.ai/v2/docs/build/sdk/effect) for
+Effect applications. For Cloudflare Durable Objects, use the
+[Cloudflare SDK guide](https://opencode.ai/v2/docs/build/sdk/cloudflare).
+
 ## [Troubleshooting](https://opencode.ai/v2/docs/troubleshooting)
 
 OpenCode runs a client and a background server. Start by determining whether a

packages/core/src/session.ts

@@ -1,7 +1,7 @@
 export * as Session from "./session.js"
 export * from "./session/schema.js"
 
-import { Cause, Effect, Layer, Schema, Context, RcMap, Stream } from "effect"
+import { Cause, Effect, Layer, Schema, Context, Stream } from "effect"
 import { ListAnchor } from "@opencode-ai/schema/session"
 import { and, desc, eq } from "drizzle-orm"
 import { Project } from "./project.js"
@@ -10,6 +10,7 @@ import { Location } from "./location.js"
 import { SessionMessage } from "./session/message.js"
 import { PromptInput } from "@opencode-ai/schema/prompt-input"
 import { Bus } from "./bus.js"
+import { Instance } from "./instance/service.js"
 import { Database } from "./database/database.js"
 import { SessionProjector } from "./session/projector.js"
 import { SessionMessageTable } from "./session/sql.js"
@@ -238,20 +239,16 @@ const layer = Layer.effect(
     const global = yield* Global.Service
     const execution = yield* SessionExecution.Service
     const store = yield* SessionStore.Service
+    const instances = yield* Instance.Service
     const locations = yield* LocationServiceMap.Service
     const fs = yield* FSUtil.Service
     const jobs = yield* Job.Service
     const environments = yield* SessionEnvironment.Service
-    const sessions = yield* Session.make((ref) => locations.get(ref))
+    const sessions = yield* Session.make()
     const admission = yield* SessionInbox.Service
     const closeTransport = Effect.fn("Session.closeTransport")(function* (session: SessionSchema.Info) {
-      const location = Location.Ref.make({
-        directory: session.location.directory,
-        workspaceID: session.location.workspaceID,
-      })
-      if (!(yield* RcMap.has(locations.rcMap, location))) return
       yield* SessionModelTransport.Service.use((transport) => transport.close(session.id)).pipe(
-        Effect.provide(locations.get(location)),
+        instances.provideIfLoaded(session),
       )
     })
     const isDurableSessionEvent = Schema.is(SessionEvent.Durable)
@@ -403,7 +400,7 @@ const layer = Layer.effect(
       prompt: (input) => sessions.forSession(input.sessionID).prompt(input),
       generate: Effect.fn("Session.generate")(function* (input) {
         const session = yield* result.get(input.sessionID)
-        const generate = yield* SessionGenerate.Service.pipe(Effect.provide(locations.get(session.location)))
+        const generate = yield* SessionGenerate.Service.pipe(instances.provide(session))
         return yield* generate.generate(input)
       }),
       command: Effect.fn("Session.command")(function* (input) {
@@ -412,7 +409,7 @@ const layer = Layer.effect(
           const plugins = yield* PluginSupervisor.Service
           yield* plugins.flush
           return yield* Command.Service
-        }).pipe(Effect.provide(locations.get(session.location)))
+        }).pipe(instances.provide(session))
         const delivery = input.delivery ?? "steer"
         yield* commands.execute({
           name: input.command,
@@ -468,7 +465,8 @@ const layer = Layer.effect(
           Effect.gen(function* () {
             const latest = yield* result.get(input.sessionID)
             const source = yield* fs.stat(latest.location.directory).pipe(Effect.orElseSucceed(() => undefined))
-            if (!source || source.type !== "Directory") {
+            // Active runners must hand off at a step boundary to retain their continuation.
+            if ((!source || source.type !== "Directory") && !(yield* execution.isActive(input.sessionID))) {
               const cancellations = (yield* SessionInbox.moveIDs(db, input.sessionID)).map(
                 (item) => [SessionEvent.InboxCancelled, { sessionID: input.sessionID, inboxID: item.id }] as const,
               )
@@ -534,6 +532,7 @@ export const node = makeGlobalNode({
     Project.node,
     SessionExecution.node,
     SessionStore.node,
+    Instance.byLocationNode,
     SessionInbox.node,
     LocationServiceMap.node,
     SessionProjector.node,

packages/core/src/session/execution.ts

@@ -4,7 +4,7 @@ import { Cause, Context, Effect, Exit, Layer } from "effect"
 import { Bus } from "../bus.js"
 import { Database } from "../database/database.js"
 import { Job } from "../job.js"
-import { LocationServiceMap } from "../location-service-map.js"
+import { Instance } from "../instance/service.js"
 import { makeGlobalNode } from "@opencode-ai/util/effect/app-node"
 import { SessionEvent } from "./event.js"
 import { SessionRunCoordinator } from "./run-coordinator.js"
@@ -35,7 +35,7 @@ export interface Interface {
   readonly awaitIdle: (sessionID: SessionSchema.ID) => Effect.Effect<void>
 }
 
-/** Routes execution from a Session ID to the runner owned by that Session's Location. */
+/** Routes execution from a Session ID to its selected instance's runner. */
 export class Service extends Context.Service<Service, Interface>()("@opencode/SessionExecution") {}
 
 type InterruptReason = "user" | "shutdown"
@@ -48,12 +48,12 @@ export function terminal(exit: Exit.Exit<void, SessionRunner.RunError>, reason?:
   return { type: "failed" as const, error: toSessionError(failure) }
 }
 
-/** Process-local execution: drains run in this process, routed through the Session's Location graph. */
+/** Process-local execution: drains run in this process using the selected instance. */
 export const layer = Layer.effect(
   Service,
   Effect.gen(function* () {
     const store = yield* SessionStore.Service
-    const locations = yield* LocationServiceMap.Service
+    const instances = yield* Instance.Service
     const bus = yield* Bus.Service
     const jobs = yield* Job.Service
     const db = (yield* Database.Service).db
@@ -90,7 +90,7 @@ export const layer = Layer.effect(
       const result = yield* SessionRunner.Service.use((runner) =>
         runner.drain({ sessionID, force, continuation, promotable }),
       ).pipe(
-        Effect.provide(locations.get(session.location)),
+        instances.provide(session),
         Effect.tapCause((cause) =>
           Cause.hasInterruptsOnly(cause)
             ? Effect.void
@@ -173,7 +173,7 @@ export const layer = Layer.effect(
 export const node = makeGlobalNode({
   service: Service,
   layer,
-  deps: [SessionStore.node, LocationServiceMap.node, Bus.node, Database.node, Job.node],
+  deps: [SessionStore.node, Instance.byLocationNode, Bus.node, Database.node, Job.node],
 })
 
 /** Low-level compatibility layer for callers that only need durable Session recording. */

packages/core/src/session/session.ts

@@ -1,11 +1,11 @@
 export * as Session from "./session.js"
 
-import { DateTime, Effect, Fiber, Layer, Schema, Scope } from "effect"
+import { DateTime, Effect, Fiber, Schema, Scope } from "effect"
 import type { Agent } from "@opencode-ai/schema/agent"
 import type { Model } from "@opencode-ai/schema/model"
 import { Event } from "@opencode-ai/schema/event"
 import { Bus } from "../bus.js"
-import { Location } from "../location.js"
+import { Instance } from "../instance/service.js"
 import { PluginSupervisor } from "../plugin/supervisor-service.js"
 import { Shell } from "../shell.js"
 import { ShellResult } from "../shell/result.js"
@@ -33,26 +33,19 @@ import { SessionRevert } from "./revert.js"
 import { SessionSchema } from "./schema.js"
 import { SessionStore } from "./store.js"
 
-export type Services =
-  | PluginSupervisor.Service
-  | Reference.Service
-  | SessionPrompt.Service
-  | SessionRevert.Service
-  | Shell.Service
-  | Skill.Service
-
 type PromptRequest = SessionPrompt.Input & {
   id?: SessionMessage.ID
   resume?: boolean
 }
 
 /**
- * Build once in the host Scope: `const sessions = yield* Session.make(servicesFor)`.
+ * Build once in the host Scope: `const sessions = yield* Session.make()`.
  * Use `sessions.forSession(id)` for handles that share host services and reload current state.
  */
-export const make = Effect.fn("Session.make")(function* (servicesFor: (ref: Location.Ref) => Layer.Layer<Services>) {
+export const make = Effect.fn("Session.make")(function* () {
   const bus = yield* Bus.Service
   const store = yield* SessionStore.Service
+  const instances = yield* Instance.Service
   const execution = yield* SessionExecution.Service
   const admission = yield* SessionInbox.Service
   const scope = yield* Scope.Scope
@@ -174,7 +167,7 @@ export const make = Effect.fn("Session.make")(function* (servicesFor: (ref: Loca
               const preparation = yield* SessionPrompt.Service
               const references = yield* Reference.Service
               return { item: yield* preparation.prepare({ sessionID, messageID, input }), references }
-            }).pipe(Effect.provide(servicesFor(session.location))),
+            }).pipe(instances.provide(session)),
           )
           // Commit a staged revert only after preparation succeeds, before admitting new work.
           if (session.revert) yield* SessionRevert.commit(bus, session)
@@ -205,7 +198,7 @@ export const make = Effect.fn("Session.make")(function* (servicesFor: (ref: Loca
         const plugins = yield* PluginSupervisor.Service
         yield* plugins.flush
         return yield* Shell.Service
-      }).pipe(Effect.provide(servicesFor(session.location)))
+      }).pipe(instances.provide(session))
       const started = yield* shell
         .create({
           command: input.command,
@@ -256,7 +249,7 @@ export const make = Effect.fn("Session.make")(function* (servicesFor: (ref: Loca
     input: { id?: SessionMessage.ID; skill: Skill.ID; resume?: boolean },
   ) {
     const session = yield* get(sessionID)
-    const skills = yield* Skill.Service.pipe(Effect.provide(servicesFor(session.location)))
+    const skills = yield* Skill.Service.pipe(instances.provide(session))
     const skill = yield* skills.get(input.skill)
     if (!skill) return yield* new SkillNotFoundError({ skill: input.skill })
     yield* bus.publish(
@@ -355,14 +348,12 @@ export const make = Effect.fn("Session.make")(function* (servicesFor: (ref: Loca
     if (yield* execution.isActive(sessionID)) return yield* new BusyError({ sessionID })
     return yield* SessionRevert.Service.use((revert) =>
       revert.stage({ session, messageID: input.messageID, files: input.files }),
-    ).pipe(Effect.provide(servicesFor(session.location)))
+    ).pipe(instances.provide(session))
   })
   const clear = Effect.fn("Session.revert.clear")(function* (sessionID: SessionSchema.ID) {
     const session = yield* get(sessionID)
     if (yield* execution.isActive(sessionID)) return yield* new BusyError({ sessionID })
-    yield* SessionRevert.Service.use((revert) => revert.clear(session)).pipe(
-      Effect.provide(servicesFor(session.location)),
-    )
+    yield* SessionRevert.Service.use((revert) => revert.clear(session)).pipe(instances.provide(session))
     return yield* execution.wake(sessionID)
   })
   const commit = Effect.fn("Session.revert.commit")(function* (sessionID: SessionSchema.ID) {

packages/core/src/snapshot.ts

@@ -42,9 +42,9 @@ export type Draft = {
 
 export interface Interface extends State.Transformable<Draft> {
   /**
-   * Capture the current Location-scoped filesystem state as a content-addressed
-   * tree. Returns `undefined` when snapshots are disabled, unsupported, or the
-   * best-effort capture fails.
+   * Capture the current Location-scoped filesystem state as an opaque reference
+   * to a content-addressed tree and its storage. Returns `undefined` when
+   * snapshots are disabled, unsupported, or the best-effort capture fails.
    */
   readonly capture: () => Effect.Effect<ID | undefined>
 
@@ -100,7 +100,18 @@ const layer = Layer.effect(
           : yield* git.repo
               .create({ worktree, gitDirectory, seed: source })
               .pipe(Effect.mapError((cause) => failure("capture", cause)))
-        return { source, worktree, snapshotRepository }
+        return {
+          source,
+          worktree,
+          snapshotRepository,
+          foreignRepository: (directory: AbsolutePath) =>
+            new Git.Repository({
+              worktree,
+              gitDirectory: directory,
+              commonDirectory: directory,
+              objectDirectories: [AbsolutePath.make(path.join(source.commonDirectory, "objects"))],
+            }),
+        }
       }).pipe(Effect.forkIn(lifetime)),
     )
     const repository = repositoryFiber.pipe(Effect.uninterruptible, Effect.flatMap(Fiber.join))
@@ -114,18 +125,80 @@ const layer = Layer.effect(
 
     const enabled = () => location.vcs?.type === "git" && state.get().enabled
 
+    const resolved = new Map<ID, { directory: AbsolutePath; tree: Git.TreeID }>()
+    const resolve = Effect.fnUntraced(function* (id: ID) {
+      const cached = resolved.get(id)
+      if (cached) return cached
+      const qualified = /^snapshot:([a-zA-Z0-9_-]+)\/([a-f0-9]{40})\/([a-f0-9]{40}|[a-f0-9]{64})$/.exec(id)
+      if (qualified)
+        return {
+          directory: AbsolutePath.make(path.join(global.data, "snapshot", qualified[1], qualified[2])),
+          tree: Git.TreeID.make(qualified[3]),
+        }
+      if (!/^(?:[a-f0-9]{40}|[a-f0-9]{64})$/.test(id))
+        return yield* new Error({ operation: "restore", message: "Invalid snapshot reference" })
+      const repo = yield* repository
+      const tree = Git.TreeID.make(id)
+      if (yield* git.tree.exists(repo.snapshotRepository, tree))
+        return { directory: repo.snapshotRepository.gitDirectory, tree }
+      // Persisted hash-only IDs predate storage-qualified references. Search only on a local miss.
+      const root = path.join(global.data, "snapshot")
+      const projects = yield* fs.readDirectoryEntries(root).pipe(Effect.mapError((cause) => failure("restore", cause)))
+      for (const project of projects.filter(
+        (entry) => entry.type === "directory" && /^[a-zA-Z0-9_-]+$/.test(entry.name),
+      )) {
+        const stores = yield* fs
+          .readDirectoryEntries(path.join(root, project.name))
+          .pipe(Effect.mapError((cause) => failure("restore", cause)))
+        for (const store of stores.filter((entry) => entry.type === "directory" && /^[a-f0-9]{40}$/.test(entry.name))) {
+          const directory = AbsolutePath.make(path.join(root, project.name, store.name))
+          const candidate = repo.foreignRepository(directory)
+          if (!(yield* git.tree.exists(candidate, tree))) continue
+          // Identical legacy trees can exist in several stores; skip incomplete copies.
+          if (
+            !(yield* git.tree.retain({ repository: candidate, trees: [tree] }).pipe(
+              Effect.as(true),
+              Effect.orElseSucceed(() => false),
+            ))
+          )
+            continue
+          const result = { directory, tree }
+          resolved.set(id, result)
+          return result
+        }
+      }
+      return yield* new Error({ operation: "restore", message: `Snapshot tree not found: ${id}` })
+    })
+
+    const read = Effect.fnUntraced(function* (ids: readonly ID[]) {
+      const repo = yield* repository
+      const stores = new Map<AbsolutePath, Git.TreeID[]>()
+      for (const id of new Set(ids)) {
+        const ref = yield* resolve(id)
+        if (ref.directory === repo.snapshotRepository.gitDirectory) continue
+        stores.set(ref.directory, [...(stores.get(ref.directory) ?? []), ref.tree])
+      }
+      for (const [directory, trees] of stores) {
+        // A renamed checkout can supply the old store's borrowed objects at its new path.
+        yield* git.tree.retain({ repository: repo.foreignRepository(directory), trees })
+      }
+      return new Git.Repository({
+        ...repo.snapshotRepository,
+        objectDirectories: Array.from(stores.keys(), (directory) => AbsolutePath.make(path.join(directory, "objects"))),
+      })
+    })
+
     const capture = Effect.fn("Snapshot.capture")(function* () {
       if (!enabled()) return undefined
       return yield* Effect.gen(function* () {
         const repo = yield* repository
-        return ID.make(
-          yield* git.tree.capture({
-            repository: repo.snapshotRepository,
-            scopes: [yield* scope(repo.worktree)],
-            ignores: repo.source,
-            maximumUntrackedFileBytes: 2 * 1024 * 1024,
-          }),
-        )
+        const tree = yield* git.tree.capture({
+          repository: repo.snapshotRepository,
+          scopes: [yield* scope(repo.worktree)],
+          ignores: repo.source,
+          maximumUntrackedFileBytes: 2 * 1024 * 1024,
+        })
+        return ID.make(`snapshot:${location.project.id}/${Hash.fast(repo.worktree)}/${tree}`)
       }).pipe(
         Effect.catch((cause) => Effect.logWarning("failed to capture snapshot", { cause }).pipe(Effect.as(undefined))),
       )
@@ -133,10 +206,11 @@ const layer = Layer.effect(
 
     const compare = Effect.fnUntraced(function* (operation: "files" | "diff", input: CompareInput) {
       const repo = yield* repository.pipe(Effect.mapError((cause) => failure(operation, cause)))
+      const snapshots = yield* read([input.from, input.to]).pipe(Effect.mapError((cause) => failure(operation, cause)))
       const comparison = {
-        repository: repo.snapshotRepository,
-        from: Git.TreeID.make(input.from),
-        to: Git.TreeID.make(input.to),
+        repository: snapshots,
+        from: treeID(input.from),
+        to: treeID(input.to),
       }
       const files = yield* git.tree.files(comparison).pipe(Effect.mapError((cause) => failure(operation, cause)))
       const ignored = yield* git.index
@@ -171,7 +245,23 @@ const layer = Layer.effect(
         const absolute = path.resolve(worktree, file)
         if (!FSUtil.contains(worktree, absolute))
           return yield* new Error({ operation: "restore", message: `Path escapes the project: ${file}` })
-        files.set(file, Git.TreeID.make(snapshot))
+        // Check ancestors, not the leaf: removing a symlink itself must not follow its target.
+        for (let parent = path.dirname(absolute); parent !== worktree; parent = path.dirname(parent)) {
+          const canonical = yield* fs.realPath(parent).pipe(
+            Effect.catchReason("PlatformError", "NotFound", () => Effect.undefined),
+            Effect.catchReason("PlatformError", "BadResource", (reason, error) =>
+              Schema.is(Schema.Struct({ code: Schema.Literal("ENOTDIR") }))(reason.cause)
+                ? Effect.undefined
+                : Effect.fail(error),
+            ),
+            Effect.mapError((cause) => failure("restore", cause)),
+          )
+          if (canonical === undefined) continue
+          if (!FSUtil.contains(worktree, canonical))
+            return yield* new Error({ operation: "restore", message: `Path escapes the project: ${file}` })
+          break
+        }
+        files.set(file, treeID(snapshot))
       }
       return files
     })
@@ -179,8 +269,11 @@ const layer = Layer.effect(
     const restore = Effect.fn("Snapshot.restore")(function* (input: RestoreInput) {
       if (!enabled()) return yield* new Error({ operation: "restore", message: "Snapshots are disabled" })
       const repo = yield* repository.pipe(Effect.mapError((cause) => failure("restore", cause)))
+      const snapshots = yield* read(Array.from(input.files.values())).pipe(
+        Effect.mapError((cause) => failure("restore", cause)),
+      )
       yield* git.tree
-        .restore({ repository: repo.snapshotRepository, files: yield* plan(repo.worktree, input) })
+        .restore({ repository: snapshots, files: yield* plan(repo.worktree, input) })
         .pipe(Effect.mapError((cause) => failure("restore", cause)))
     })
 
@@ -206,6 +299,10 @@ export const noopLayer = Layer.succeed(
   }),
 )
 
+function treeID(id: ID) {
+  return Git.TreeID.make(id.slice(id.lastIndexOf("/") + 1))
+}
+
 function failure(operation: Error["operation"], cause: unknown) {
   if (cause instanceof Error && cause.operation === operation) return cause
   return new Error({

packages/core/src/tool/html-markdown.ts

@@ -95,7 +95,7 @@ export function convertHTMLToMarkdown(html: string) {
     const remaining = limit - outputBytes
     const next = bytes.byteLength <= remaining ? value : sliceBytes(value, remaining)
     output.push(next)
-    outputBytes += encoder.encode(next).byteLength
+    outputBytes += bytes.byteLength <= remaining ? bytes.byteLength : encoder.encode(next).byteLength
     last = next.at(-1) ?? last
   }
   const appendRaw = (value: string) => {

packages/core/test/agent.test.ts

@@ -22,8 +22,8 @@ const globalLayer = Layer.succeed(Global.Service, Global.Service.of(global))
 
 const it = testEffect(
   AppNodeBuilder.build(LayerNode.group([Agent.node, Bus.node, Location.node]), [
-    [Global.node, globalLayer],
-    [Location.node, locationLayer],
+    Global.node.replace(globalLayer),
+    Location.node.replace(locationLayer),
   ]) as unknown as Layer.Layer<unknown, never>,
 )
 

packages/core/test/aisdk.test.ts

@@ -10,8 +10,6 @@ import { Provider } from "@opencode-ai/core/provider"
 import {
   LLM,
   AIError,
-  CompactionPart,
-  ProviderID,
   HttpContext,
   LLMEvent,
   Message,
@@ -70,31 +68,6 @@ const client = LLMClient.layer.pipe(
   ),
 )
 
-it.effect("rejects native provider compaction rather than silently dropping replay state", () =>
-  Effect.gen(function* () {
-    const aisdk = yield* AISDK.Service
-    yield* aisdk.hook.sdk((event) => {
-      event.sdk = { languageModel: () => streamModel([]) }
-    })
-    const resolved = yield* aisdk.model(model("@ai-sdk/openai"))
-    const error = yield* compileRequest(
-      LLM.request({
-        model: resolved,
-        messages: [
-          Message.assistant(
-            CompactionPart.make({
-              provider: ProviderID.make("test-provider"),
-              encrypted: "opaque",
-            }),
-          ),
-        ],
-      }),
-    ).pipe(Effect.flip)
-    expect(error.reason._tag).toBe("InvalidRequest")
-    expect(error.message).toContain("cannot replay")
-  }),
-)
-
 it.effect("keys language models by package and flattened overlays", () =>
   Effect.gen(function* () {
     const aisdk = yield* AISDK.Service

packages/core/test/bus-session-routing.test.ts

@@ -21,7 +21,7 @@ import { testEffect } from "./lib/effect"
 
 const it = testEffect(
   AppNodeBuilder.build(LayerNode.group([Database.node, Bus.node, SessionProjector.node]), [
-    [Bus.node, Bus.configured({ persist: true })],
+    Bus.node.replace(Bus.configured({ persist: true })),
   ]),
 )
 const a = Location.Ref.make({ directory: AbsolutePath.make("/a") })

packages/core/test/bus.test.ts

@@ -100,12 +100,14 @@ const tail = (bus: Bus.Interface, input: { aggregateID: string; after?: number }
 
 const it = testEffect(
   AppNodeBuilder.build(LayerNode.group([Database.node, Bus.node, Location.node]), [
-    [Location.node, locationLayer],
-    [Bus.node, Bus.configured({ persist: true })],
+    Location.node.replace(locationLayer),
+    Bus.node.replace(Bus.configured({ persist: true })),
   ]),
 )
 const itWithoutLocation = testEffect(
-  AppNodeBuilder.build(LayerNode.group([Database.node, Bus.node]), [[Bus.node, Bus.configured({ persist: true })]]),
+  AppNodeBuilder.build(LayerNode.group([Database.node, Bus.node]), [
+    Bus.node.replace(Bus.configured({ persist: true })),
+  ]),
 )
 const itWithoutPersistence = testEffect(AppNodeBuilder.build(LayerNode.group([Database.node, Bus.node])))
 
@@ -631,8 +633,7 @@ describe("Bus", () => {
       const continueRead = yield* Deferred.make<void>()
       let pause = true
       const eventLayer = AppNodeBuilder.build(LayerNode.group([Database.node, Bus.node]), [
-        [
-          Bus.node,
+        Bus.node.replace(
           Bus.configured({
             persist: true,
             beforeAggregateRead: () =>
@@ -640,7 +641,7 @@ describe("Bus", () => {
                 ? Deferred.succeed(readStarted, undefined).pipe(Effect.andThen(Deferred.await(continueRead)))
                 : Effect.void,
           }),
-        ],
+        ),
       ])
 
       yield* Effect.gen(function* () {
@@ -1318,7 +1319,7 @@ describe("Bus", () => {
   it.effect("log replays across configured read pages", () =>
     Effect.gen(function* () {
       const eventLayer = AppNodeBuilder.build(LayerNode.group([Database.node, Bus.node]), [
-        [Bus.node, Bus.configured({ persist: true, logReadPageSize: 2 })],
+        Bus.node.replace(Bus.configured({ persist: true, logReadPageSize: 2 })),
       ])
 
       yield* Effect.gen(function* () {
@@ -1351,8 +1352,7 @@ describe("Bus", () => {
       const releaseRead = yield* Deferred.make<void>()
       const firstRead = yield* Ref.make(true)
       const eventLayer = AppNodeBuilder.build(LayerNode.group([Database.node, Bus.node]), [
-        [
-          Bus.node,
+        Bus.node.replace(
           Bus.configured({
             persist: true,
             beforeAggregateRead: () =>
@@ -1363,7 +1363,7 @@ describe("Bus", () => {
                 }),
               ),
           }),
-        ],
+        ),
       ])
 
       yield* Effect.gen(function* () {

packages/core/test/catalog.test.ts

@@ -25,7 +25,7 @@ const locationLayer = Layer.succeed(
 )
 const catalogLayer = AppNodeBuilder.build(
   LayerNode.group([Catalog.node, Bus.node, Credential.node, Integration.node]),
-  [[Location.node, locationLayer]],
+  [Location.node.replace(locationLayer)],
 )
 const it = testEffect(catalogLayer)
 
@@ -48,7 +48,7 @@ describe("Catalog", () => {
   it.effect("derives availability from active credentials without changing provider state", () => {
     const integrationID = Integration.ID.make("test")
     const localCatalogLayer = Layer.fresh(
-      AppNodeBuilder.build(LayerNode.group([Catalog.node, Credential.node]), [[Location.node, locationLayer]]),
+      AppNodeBuilder.build(LayerNode.group([Catalog.node, Credential.node]), [Location.node.replace(locationLayer)]),
     )
 
     return Effect.gen(function* () {
@@ -78,7 +78,7 @@ describe("Catalog", () => {
     const providerID = Provider.ID.make("remote")
     const localCatalogLayer = Layer.fresh(
       AppNodeBuilder.build(LayerNode.group([Catalog.node, Credential.node, Integration.node]), [
-        [Location.node, locationLayer],
+        Location.node.replace(locationLayer),
       ]),
     )
 
@@ -108,7 +108,7 @@ describe("Catalog", () => {
     const providerID = Provider.ID.make("remote")
     const localCatalogLayer = Layer.fresh(
       AppNodeBuilder.build(LayerNode.group([Catalog.node, Credential.node, Integration.node]), [
-        [Location.node, locationLayer],
+        Location.node.replace(locationLayer),
       ]),
     )