feat(plugin): expose session history reads

2026-08-20 16:46:23 +00:00 · 2026-08-20 03:17:28 +00:00
214 changed files with 3669 additions and 5205 deletions
@@ -1,8 +1,8 @@
 {
  "nodeModules": {
-    "x86_64-linux": "sha256-JEqi00PCle+o5OfBlJJaZtXd+4sYB3o+rvYiESlN4dY=",
-    "aarch64-linux": "sha256-zk3Uk1SQyeRrQ7BuFwlOnQAptUHIkq+oPdfd+sTEq5U=",
-    "aarch64-darwin": "sha256-3BOd3EcqimoG3rTI6lTHe91YVlCoEi8/68eT1lbOi0c=",
-    "x86_64-darwin": "sha256-X7wGmjiMloF5Zhuc20kAxLC+tl613YNXRgA+dQjP2WM="
+    "x86_64-linux": "sha256-9IJxoe/MdL6nmoeKvxZop+77HJ/b3HbmpytNUvLqYkc=",
+    "aarch64-linux": "sha256-KR1J102RDTRDZIkAD3jQfXeP1G2DN9Es7KkdKo+daec=",
+    "aarch64-darwin": "sha256-HCgSoq1W6XU6m73Ck3wV8gjB687caUTM3w/EO+V7wsE=",
+    "x86_64-darwin": "sha256-GrKTDvjg0XeDIWbOvayWQjj0SdJd8WPm2+q3IVS17Jg="
  }
 }
@@ -15,7 +15,6 @@
    "dev:stats": "bun sst shell --stage=production -- bun run --cwd packages/stats/app dev",
    "dev:www": "bun run --cwd packages/www dev",
    "dev:storybook": "bun --cwd packages/storybook storybook",
-    "bench:devex": "bun run --cwd packages/app test:bench:devex",
    "lint": "oxlint",
    "lint:effect-patterns": "ast-grep scan -c script/ast-grep/sgconfig.yml packages/util/src packages/core/src packages/server/src packages/protocol/src packages/cli/src",
    "test:lint-rules": "ast-grep test -c script/ast-grep/sgconfig.yml",
@@ -38,10 +37,10 @@
      "packages/slack"
    ],
    "catalog": {
-      "@effect/opentelemetry": "4.0.0-rc.110",
-      "@effect/platform-node": "4.0.0-rc.110",
-      "@effect/platform-node-shared": "4.0.0-rc.110",
-      "@effect/sql-sqlite-bun": "4.0.0-rc.110",
+      "@effect/opentelemetry": "4.0.0-beta.107",
+      "@effect/platform-node": "4.0.0-beta.107",
+      "@effect/platform-node-shared": "4.0.0-beta.107",
+      "@effect/sql-sqlite-bun": "4.0.0-beta.107",
      "@npmcli/arborist": "9.4.0",
      "@types/bun": "1.3.13",
      "@types/cross-spawn": "6.0.6",
@@ -72,7 +71,7 @@
      "dompurify": "3.3.1",
      "drizzle-kit": "1.0.0-rc.2",
      "drizzle-orm": "1.0.0-rc.2",
-      "effect": "4.0.0-rc.110",
+      "effect": "4.0.0-beta.107",
      "ai": "6.0.168",
      "cross-spawn": "7.0.6",
      "hono": "4.10.7",
@@ -309,7 +309,7 @@ Included providers: OpenAI, Anthropic, Google (Gemini), Google Vertex Gemini and

 ### Package-like entrypoints

-Native catalog integrations load provider behavior through package-like entrypoints. These are export paths from the same `@opencode-ai/ai` npm package, not independently published packages. Each entrypoint exports the same `model(modelID, settings)` contract, and `settings` contains serializable provider configuration plus common `headers` and `body` overlays.
+Native catalog integrations load provider behavior through package-like entrypoints. These are export paths from the same `@opencode-ai/ai` npm package, not independently published packages. Each entrypoint exports the same `model(modelID, settings)` contract, and `settings` contains serializable provider configuration plus common `headers`, `body`, and `limits` overlays.

 ```ts
 import { model } from "@opencode-ai/ai/providers/openai/responses"
@@ -317,6 +317,7 @@ import { model } from "@opencode-ai/ai/providers/openai/responses"
 const selected = model("gpt-5", {
  apiKey: process.env.OPENAI_API_KEY,
  headers: { "x-application": "opencode" },
+  limits: { context: 200_000, output: 64_000 },
 })
 ```

@@ -31,7 +31,6 @@ import { ToolStream } from "./utils/tool-stream.js"
 const ADAPTER = "anthropic-messages"
 export const DEFAULT_BASE_URL = "https://api.anthropic.com/v1"
 export const PATH = "/messages"
-export const DEFAULT_MAX_TOKENS = 32_000

 export type ThinkingInput =
  | {
@@ -625,6 +624,7 @@ const resolveThinking = Effect.fn("AnthropicMessages.resolveThinking")(function*
 const fromRequest = Effect.fn("AnthropicMessages.fromRequest")(function* (request: LLMRequest) {
  const generation = request.generation
  const toolSchemaCompatibility = request.model.compatibility?.toolSchema
+  const outputLimit = request.model.defaults?.limits?.output ?? request.model.route.defaults.limits?.output ?? 4096
  // Allocate the 4-breakpoint budget in invalidation order: tools → system →
  // messages. Tools live highest in the cache hierarchy, so when callers
  // over-mark we keep their tool hints and shed the message-tail ones first.
@@ -663,7 +663,7 @@ const fromRequest = Effect.fn("AnthropicMessages.fromRequest")(function* (reques
    tools,
    tool_choice: toolChoice,
    stream: true as const,
-    max_tokens: generation?.maxTokens ?? DEFAULT_MAX_TOKENS,
+    max_tokens: generation?.maxTokens ?? outputLimit,
    temperature: generation?.temperature,
    top_p: generation?.topP,
    top_k: generation?.topK,
@@ -289,9 +289,7 @@ const lowerMessages = Effect.fn("Gemini.lowerMessages")(function* (request: LLMR
    if (message.role === "system") {
      const part = yield* ProviderShared.wrappedSystemUpdate("Gemini", message)
      const previous = contents.at(-1)
-      // Gemini rejects a continuation whose function-response turn carries extra
-      // parts, so an update after a tool result starts its own user turn.
-      if (previous?.role === "user" && !previous.parts.some((item) => "functionResponse" in item))
+      if (previous?.role === "user")
        contents[contents.length - 1] = { role: "user", parts: [...previous.parts, { text: part.text }] }
      else contents.push({ role: "user", parts: [{ text: part.text }] })
      continue
@@ -93,8 +93,6 @@ export const InputItem = Schema.Union([
  Schema.Struct({ role: Schema.tag("developer"), content: 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),
@@ -103,7 +101,6 @@ export const InputItem = Schema.Union([
  OpenResponsesItemReference,
  Schema.Struct({
    type: Schema.tag("function_call"),
-    id: Schema.optionalKey(Schema.String),
    call_id: Schema.String,
    name: Schema.String,
    arguments: Schema.String,
@@ -118,8 +115,6 @@ type OpenResponsesInputItem = Schema.Schema.Type<typeof InputItem>
 type LoweredInputItem =
  | OpenResponsesInputItem
  | {
-      readonly type: "message"
-      readonly id?: string
      readonly role: "assistant"
      readonly content: ReadonlyArray<{ readonly type: "output_text"; readonly text: string }>
      readonly phase?: MessagePhase | null
@@ -133,6 +128,8 @@ type OpenResponsesReasoningInput = {
  summary: Array<{ type: "summary_text"; text: string }>
  encrypted_content?: string | null
 }
+type OpenResponsesReasoningReplay = Omit<OpenResponsesReasoningInput, "id">
+
 export const Tool = Schema.Struct({
  type: Schema.tag("function"),
  name: Schema.String,
@@ -162,14 +159,6 @@ export const coreFields = {
  tools: optionalArray(Tool),
  tool_choice: Schema.optional(ToolChoice),
  store: Schema.optional(Schema.Boolean),
-  metadata: Schema.optional(Schema.Record(Schema.String, Schema.String)),
-  safety_identifier: Schema.optional(Schema.String),
-  stream_options: Schema.optional(
-    Schema.Struct({
-      include_obfuscation: Schema.optional(Schema.Boolean),
-    }),
-  ),
-  top_logprobs: Schema.optional(Schema.Int.check(Schema.isBetween({ minimum: 0, maximum: 20 }))),
  truncation: Schema.optional(OpenResponsesOptions.TruncationSchema),
  service_tier: Schema.optional(OpenResponsesOptions.ServiceTierSchema),
  prompt_cache_key: Schema.optional(Schema.String),
@@ -190,8 +179,6 @@ export const coreFields = {
  parallel_tool_calls: Schema.optional(Schema.Boolean),
  temperature: Schema.optional(Schema.Number),
  top_p: Schema.optional(Schema.Number),
-  presence_penalty: Schema.optional(Schema.Number),
-  frequency_penalty: Schema.optional(Schema.Number),
 }

 const OpenResponsesBody = Schema.Struct({
@@ -301,20 +288,6 @@ export const Event = Schema.StructWithRest(
 )
 export type Event = Schema.Schema.Type<typeof Event>

-const RefusalEvent = Schema.Union([
-  Schema.Struct({
-    type: Schema.tag("response.refusal.delta"),
-    item_id: Schema.String,
-    delta: Schema.String,
-  }),
-  Schema.Struct({
-    type: Schema.tag("response.refusal.done"),
-    item_id: Schema.String,
-    refusal: Schema.String,
-  }),
-])
-const isRefusalEvent = Schema.is(RefusalEvent)
-
 export interface Extension {
  readonly id: string
  readonly name: string
@@ -380,42 +353,34 @@ export const lowerToolChoice = (protocolName: string, toolChoice: NonNullable<LL
    tool: (toolName) => ({ type: "function" as const, name: toolName }),
  })

-const itemID = (providerMetadata: ProviderMetadata | undefined, providerMetadataKey: string) => {
-  const metadata = providerMetadata?.[providerMetadataKey]
-  return ProviderShared.isRecord(metadata) && typeof metadata.itemId === "string" && metadata.itemId.length > 0
-    ? metadata.itemId
-    : undefined
-}
-
-const lowerToolCall = (part: ToolCallPart, providerMetadataKey: string): OpenResponsesInputItem => {
-  const id = itemID(part.providerMetadata, providerMetadataKey)
-  return {
-    type: "function_call",
-    ...(id ? { id } : {}),
-    call_id: part.id,
-    name: part.name,
-    arguments: ProviderShared.encodeJson(part.input),
-  }
-}
+const lowerToolCall = (part: ToolCallPart): OpenResponsesInputItem => ({
+  type: "function_call",
+  call_id: part.id,
+  name: part.name,
+  arguments: ProviderShared.encodeJson(part.input),
+})

 const lowerReasoning = (part: ReasoningPart, providerMetadataKey: string): OpenResponsesReasoningInput | undefined => {
  const metadata = part.providerMetadata?.[providerMetadataKey]
-  const id = itemID(part.providerMetadata, providerMetadataKey)
-  if (!ProviderShared.isRecord(metadata) || !id) return undefined
+  if (!ProviderShared.isRecord(metadata) || typeof metadata.itemId !== "string" || metadata.itemId.length === 0)
+    return undefined
  const encryptedContent =
    typeof metadata.reasoningEncryptedContent === "string" || metadata.reasoningEncryptedContent === null
      ? metadata.reasoningEncryptedContent
      : undefined
  return {
    type: "reasoning",
-    id,
+    id: metadata.itemId,
    summary: part.text.length > 0 ? [{ type: "summary_text", text: part.text }] : [],
    encrypted_content: encryptedContent,
  }
 }

 const hostedToolItemID = (part: ToolResultPart, providerMetadataKey: string) => {
-  return itemID(part.providerMetadata, providerMetadataKey)
+  const metadata = part.providerMetadata?.[providerMetadataKey]
+  return ProviderShared.isRecord(metadata) && typeof metadata.itemId === "string" && metadata.itemId.length > 0
+    ? metadata.itemId
+    : undefined
 }

 const lowerMedia = Effect.fn("OpenResponses.lowerMedia")(function* (
@@ -500,26 +465,24 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (reques

    if (message.role === "assistant") {
      const content: TextPart[] = []
-      const reasoningItems: Record<string, OpenResponsesReasoningInput> = {}
+      const reasoningItems: Record<string, OpenResponsesReasoningReplay> = {}
      const reasoningReferences = new Set<string>()
      const hostedToolReferences = new Set<string>()
      const flushText = () => {
        if (content.length === 0) return
-        const groups = content.reduce<
-          Array<{ id: string | undefined; phase: MessagePhase | null | undefined; parts: TextPart[] }>
-        >((groups, part) => {
-          const metadata = part.providerMetadata?.[providerMetadataKey]
-          const id = itemID(part.providerMetadata, providerMetadataKey)
-          const phase = ProviderShared.isRecord(metadata) ? messagePhase(metadata.phase, extension) : undefined
-          const group = groups.at(-1)
-          if (group && group.id === id && group.phase === phase) group.parts.push(part)
-          else groups.push({ id, phase, parts: [part] })
-          return groups
-        }, [])
+        const groups = content.reduce<Array<{ phase: MessagePhase | null | undefined; parts: TextPart[] }>>(
+          (groups, part) => {
+            const metadata = part.providerMetadata?.[providerMetadataKey]
+            const phase = ProviderShared.isRecord(metadata) ? messagePhase(metadata.phase, extension) : undefined
+            const group = groups.at(-1)
+            if (group && group.phase === phase) group.parts.push(part)
+            else groups.push({ phase, parts: [part] })
+            return groups
+          },
+          [],
+        )
        input.push(
          ...groups.map((group) => ({
-            type: "message" as const,
-            ...(group.id === undefined ? {} : { id: group.id }),
            role: "assistant" as const,
            content: group.parts.map((part) => ({ type: "output_text" as const, text: part.text })),
            ...(group.phase === undefined ? {} : { phase: group.phase }),
@@ -548,14 +511,19 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (reques
              existing.encrypted_content = reasoning.encrypted_content
            continue
          }
-          reasoningItems[reasoning.id] = reasoning
-          input.push(reasoning)
+          const replay = {
+            type: reasoning.type,
+            summary: reasoning.summary,
+            encrypted_content: reasoning.encrypted_content,
+          }
+          reasoningItems[reasoning.id] = replay
+          input.push(replay)
          continue
        }
        if (part.type === "tool-call") {
          flushText()
          if (part.providerExecuted === true) continue
-          input.push(lowerToolCall(part, providerMetadataKey))
+          input.push(lowerToolCall(part))
          continue
        }
        if (part.type === "tool-result" && part.providerExecuted === true) {
@@ -610,12 +578,6 @@ const lowerOptions = (request: LLMRequest) => {
  return {
    ...(options.instructions ? { instructions: options.instructions } : {}),
    ...(options.store !== undefined ? { store: options.store } : {}),
-    ...(options.metadata ? { metadata: options.metadata } : {}),
-    ...(options.safetyIdentifier ? { safety_identifier: options.safetyIdentifier } : {}),
-    ...(options.streamOptions?.includeObfuscation !== undefined
-      ? { stream_options: { include_obfuscation: options.streamOptions.includeObfuscation } }
-      : {}),
-    ...(options.topLogprobs !== undefined ? { top_logprobs: options.topLogprobs } : {}),
    ...(request.promptCacheKey ? { prompt_cache_key: request.promptCacheKey } : {}),
    ...(options.include ? { include: options.include } : {}),
    ...(options.reasoningEffort || options.reasoningSummary
@@ -665,8 +627,6 @@ export const fromRequestWithExtension = Effect.fn("OpenResponses.fromRequestWith
    max_output_tokens: generation?.maxTokens,
    temperature: generation?.temperature,
    top_p: generation?.topP,
-    presence_penalty: generation?.presencePenalty,
-    frequency_penalty: generation?.frequencyPenalty,
    ...lowerOptions(request),
  }
 })
@@ -735,7 +695,7 @@ const onOutputTextDelta = (state: ParserState, event: Event, id: string): StepRe
  if (!event.delta) return [state, NO_EVENTS]
  const events: LLMEvent[] = []
  const phase = state.messagePhases[id]
-  const metadata = providerMetadata(state, { itemId: id, ...(phase === undefined ? {} : { phase }) })
+  const metadata = phase === undefined ? undefined : providerMetadata(state, { phase })
  const lifecycle = Lifecycle.textStart(state.lifecycle, events, id, metadata)
  return [{ ...state, lifecycle: Lifecycle.textDelta(lifecycle, events, id, event.delta) }, events]
 }
@@ -964,7 +924,7 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
          state.lifecycle,
          events,
          item.id,
-          providerMetadata(state, { itemId: item.id, ...(phase === undefined ? {} : { phase }) }),
+          phase === undefined ? undefined : providerMetadata(state, { phase }),
        ),
        messageItems,
        messagePhases,
@@ -977,11 +937,7 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
    if (!item.id || !item.call_id || !item.name) return [state, NO_EVENTS] satisfies StepResult
    const tools = state.tools[item.id]
      ? state.tools
-      : ToolStream.start(state.tools, item.id, {
-          id: item.call_id,
-          name: item.name,
-          providerMetadata: providerMetadata(state, { itemId: item.id }),
-        })
+      : ToolStream.start(state.tools, item.id, { id: item.call_id, name: item.name })
    const result =
      item.arguments === undefined
        ? yield* ToolStream.finish(state.id, tools, item.id)
@@ -1032,19 +988,11 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
  return [state, NO_EVENTS] satisfies StepResult
 })

-const onResponseFinish = Effect.fn("OpenResponses.onResponseFinish")(function* (state: ParserState, event: Event) {
-  // Some compatible providers omit output_item.done even after completing the response.
-  const pending =
-    event.type === "response.completed"
-      ? yield* ToolStream.finishAll(state.id, state.tools)
-      : { tools: state.tools, events: NO_EVENTS }
-  const events: LLMEvent[] = [...pending.events]
-  const hasFunctionCall =
-    pending.events.some((event) => LLMEvent.is.toolCall(event) || LLMEvent.is.toolInputError(event)) ||
-    state.hasFunctionCall
+const onResponseFinish = (state: ParserState, event: Event): StepResult => {
+  const events: LLMEvent[] = []
  const lifecycle = Lifecycle.finish(state.lifecycle, events, {
    reason: {
-      normalized: mapFinishReason(event, hasFunctionCall),
+      normalized: mapFinishReason(event, state.hasFunctionCall),
      raw: event.response?.incomplete_details?.reason,
    },
    usage: mapUsage(event.response?.usage, state.providerMetadataKey),
@@ -1056,8 +1004,8 @@ const onResponseFinish = Effect.fn("OpenResponses.onResponseFinish")(function* (
          })
        : undefined,
  })
-  return [{ ...state, lifecycle, hasFunctionCall, tools: pending.tools }, events] satisfies StepResult
-})
+  return [{ ...state, lifecycle }, events]
+}

 // Build a single human-readable message from whatever the provider supplied.
 // When both code and message are present, prefix the code so consumers see
@@ -1099,14 +1047,6 @@ export const step = (state: ParserState, event: Event) => {
        : onOutputTextDone(state, event, event.item_id),
    )
  }
-  if (event.type === "response.refusal.delta" || event.type === "response.refusal.done") {
-    if (!isRefusalEvent(event)) return ProviderShared.eventError(state.id, `${event.type} is malformed`)
-    return Effect.succeed(
-      event.type === "response.refusal.delta"
-        ? onOutputTextDelta(state, event, event.item_id)
-        : onOutputTextDone(state, { ...event, text: event.refusal }, event.item_id),
-    )
-  }
  if (event.type === "response.reasoning.delta" || event.type === "response.reasoning_summary_text.delta") {
    if (!event.item_id) return ProviderShared.eventError(state.id, `${event.type} is missing item_id`)
    return Effect.succeed(onReasoningDelta(state, event, event.item_id))
@@ -1134,7 +1074,8 @@ export const step = (state: ParserState, event: Event) => {
      return ProviderShared.eventError(state.id, `${event.type} message is missing id`)
    return onOutputItemDone(state, event)
  }
-  if (event.type === "response.completed" || event.type === "response.incomplete") return onResponseFinish(state, event)
+  if (event.type === "response.completed" || event.type === "response.incomplete")
+    return Effect.succeed(onResponseFinish(state, event))
  if (event.type === "response.failed") return providerError(state, event, `${state.name} response failed`)
  if (event.type === "error")
    return decodeKnownErrorEvent(event).pipe(
@@ -28,7 +28,7 @@ import { ToolSchemaProjection } from "./utils/tool-schema.js"
 import { ToolStream } from "./utils/tool-stream.js"

 const ADAPTER = "openai-chat"
-const RESERVED_REASONING_FIELDS = new Set(["role", "content", "refusal", "tool_calls"])
+const RESERVED_REASONING_FIELDS = new Set(["role", "content", "tool_calls"])
 export const DEFAULT_BASE_URL = "https://api.openai.com/v1"
 export const PATH = "/chat/completions"

@@ -194,7 +194,6 @@ type OpenAIChatToolCallDelta = Schema.Schema.Type<typeof OpenAIChatToolCallDelta
 const OpenAIChatDelta = Schema.StructWithRest(
  Schema.Struct({
    content: optionalNull(Schema.String),
-    refusal: optionalNull(Schema.String),
    reasoning_content: optionalNull(Schema.String),
    reasoning: optionalNull(Schema.String),
    reasoning_text: optionalNull(Schema.String),
@@ -710,7 +709,6 @@ const step = (state: ParserState, event: OpenAIChatEvent) =>
    const reasoning = reasoningDelta(delta, state.reasoningField)
    const hasLateContent =
      Boolean(delta?.content) ||
-      Boolean(delta?.refusal) ||
      reasoning !== undefined ||
      (Array.isArray(delta?.reasoning_details) && delta.reasoning_details.length > 0) ||
      toolDeltas.some((tool) => Boolean(tool.id) || Boolean(tool.function?.name) || Boolean(tool.function?.arguments))
@@ -730,7 +728,7 @@ const step = (state: ParserState, event: OpenAIChatEvent) =>
    else if (
      reasoningDetailsObserved &&
      !lifecycle.reasoning.has("reasoning-0") &&
-      (Boolean(delta?.content) || Boolean(delta?.refusal) || toolDeltas.length > 0)
+      (Boolean(delta?.content) || toolDeltas.length > 0)
    )
      lifecycle = Lifecycle.reasoningStart(lifecycle, events, "reasoning-0", deltaMetadata)
    const reasoningEmitted = state.reasoningEmitted || lifecycle.reasoning.has("reasoning-0")
@@ -745,16 +743,6 @@ const step = (state: ParserState, event: OpenAIChatEvent) =>
      lifecycle = Lifecycle.textDelta(lifecycle, events, "text-0", delta.content)
    }

-    if (delta?.refusal) {
-      lifecycle = Lifecycle.reasoningEnd(
-        lifecycle,
-        events,
-        "reasoning-0",
-        reasoningMetadata(reasoningField, reasoningDetailsObserved ? state.reasoningDetails : undefined),
-      )
-      lifecycle = Lifecycle.textDelta(lifecycle, events, "text-0", delta.refusal)
-    }
-
    // Compatible providers may omit indexes. Prefer durable identity, then use
    // batch position for parallel deltas or the latest call for sparse chunks.
    for (const [position, tool] of toolDeltas.entries()) {
@@ -42,8 +42,6 @@ const OpenAIResponsesToolChoice = Schema.Union([

 const OpenAIResponsesInputItem = Schema.Union([
  Schema.Struct({
-    type: Schema.tag("message"),
-    id: Schema.optionalKey(Schema.String),
    role: Schema.tag("assistant"),
    content: Schema.Array(Schema.Struct({ type: Schema.tag("output_text"), text: Schema.String })),
    phase: Schema.optionalKey(Schema.NullOr(OpenResponses.MessagePhase)),
@@ -47,17 +47,9 @@ export const AllowedTools = Schema.Struct({
 })
 export type AllowedTools = typeof AllowedTools.Type

-export const StreamOptions = Schema.Struct({
-  includeObfuscation: Schema.optional(Schema.Boolean),
-})
-
 export const Options = Schema.Struct({
  instructions: Schema.optional(Schema.String),
  store: Schema.optional(Schema.Boolean),
-  metadata: Schema.optional(Schema.Record(Schema.String, Schema.String)),
-  safetyIdentifier: Schema.optional(Schema.String),
-  streamOptions: Schema.optional(StreamOptions),
-  topLogprobs: Schema.optional(Schema.Int.check(Schema.isBetween({ minimum: 0, maximum: 20 }))),
  reasoningEffort: Schema.optional(ReasoningEffort),
  reasoningSummary: Schema.optional(Schema.Literals(["auto", "concise", "detailed"])),
  include: Schema.optional(Schema.Array(ResponseIncludableSchema)),
@@ -4,6 +4,11 @@ export interface Settings extends Readonly<Record<string, unknown>> {
  readonly baseURL?: string
  readonly headers?: Readonly<Record<string, string>>
  readonly body?: Readonly<Record<string, unknown>>
+  readonly limits?: {
+    readonly context: number
+    readonly input?: number
+    readonly output: number
+  }
 }

 export interface Definition<
@@ -90,6 +90,7 @@ const config = (settings: Settings): Config => {
    credentials: settings.credentials,
    headers: settings.headers === undefined ? undefined : { ...settings.headers },
    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+    limits: settings.limits,
    providerOptions: settings.providerOptions,
    region: settings.region,
  }
@@ -62,6 +62,7 @@ export const model: ProviderPackage.Definition<Settings>["model"] = (modelID, se
    generation: settings.topP === undefined ? undefined : { topP: settings.topP },
    headers: settings.headers === undefined ? undefined : { ...settings.headers },
    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+    limits: settings.limits,
    region: settings.region,
  }).model(modelID)
 }
@@ -68,6 +68,7 @@ export const model: ProviderPackage.Definition<Settings, AnthropicMessages.Provi
    baseURL: settings.baseURL,
    headers: settings.headers === undefined ? undefined : { ...settings.headers },
    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+    limits: settings.limits,
    provider: settings.provider,
    providerOptions: settings.providerOptions,
  }).model(modelID)
@@ -63,6 +63,7 @@ export const model: ProviderPackage.Definition<Settings, AnthropicMessages.Provi
    baseURL: settings.baseURL,
    headers: settings.headers === undefined ? undefined : { ...settings.headers },
    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+    limits: settings.limits,
    providerOptions: settings.providerOptions,
  }).model(modelID)
 }
@@ -126,6 +126,7 @@ const config = (settings: Settings): Config => {
    apiVersion: settings.apiVersion,
    headers: settings.headers === undefined ? undefined : { ...settings.headers },
    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+    limits: settings.limits,
    providerOptions: settings.providerOptions,
    queryParams: settings.queryParams === undefined ? undefined : { ...settings.queryParams },
    useDeploymentBasedUrls: settings.useDeploymentBasedUrls,
@@ -75,6 +75,7 @@ export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsIn
    baseURL: settings.baseURL,
    headers: settings.headers === undefined ? undefined : { ...settings.headers },
    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+    limits: settings.limits,
    location: settings.location,
    project: settings.project,
    providerOptions: settings.providerOptions,
@@ -110,6 +110,7 @@ export const model: ProviderPackage.Definition<Settings, AnthropicMessages.Provi
    baseURL: settings.baseURL,
    headers: settings.headers === undefined ? undefined : { ...settings.headers },
    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+    limits: settings.limits,
    location: settings.location,
    project: settings.project,
    providerOptions: settings.providerOptions,
@@ -80,6 +80,7 @@ export const model: ProviderPackage.Definition<Settings, OpenResponsesProviderOp
    baseURL: settings.baseURL,
    headers: settings.headers === undefined ? undefined : { ...settings.headers },
    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+    limits: settings.limits,
    location: settings.location,
    project: settings.project,
    providerOptions: settings.providerOptions,
@@ -119,6 +119,7 @@ export const model: ProviderPackage.Definition<Settings, GeminiProviderOptionsIn
    baseURL: settings.baseURL,
    headers: settings.headers === undefined ? undefined : { ...settings.headers },
    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+    limits: settings.limits,
    location: settings.location,
    project: settings.project,
    providerOptions: settings.providerOptions,
@@ -63,6 +63,7 @@ export const model: ProviderPackage.Definition<Settings, Gemini.ProviderOptionsI
    baseURL: settings.baseURL,
    headers: settings.headers === undefined ? undefined : { ...settings.headers },
    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+    limits: settings.limits,
    providerOptions: settings.providerOptions,
  }).model(modelID)

@@ -55,6 +55,7 @@ export const model: ProviderPackage.Definition<Settings, OpenResponsesProviderOp
    baseURL: settings.baseURL,
    headers: settings.headers === undefined ? undefined : { ...settings.headers },
    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+    limits: settings.limits,
    provider: settings.provider,
    providerOptions: settings.providerOptions,
  }).model(modelID)
@@ -74,6 +74,7 @@ export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsIn
    baseURL: settings.baseURL,
    headers: settings.headers === undefined ? undefined : { ...settings.headers },
    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+    limits: settings.limits,
    provider: settings.provider,
    providerOptions: settings.providerOptions,
  }).model(modelID)
@@ -124,6 +124,7 @@ const config = (settings: Settings): Config => {
    baseURL: settings.baseURL,
    headers: Object.keys(headers).length === 0 ? undefined : headers,
    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+    limits: settings.limits,
    providerOptions: settings.providerOptions,
    queryParams: settings.queryParams === undefined ? undefined : { ...settings.queryParams },
  }
@@ -200,5 +200,6 @@ export const model: ProviderPackage.Definition<Settings, OpenRouterProviderOptio
    baseURL: settings.baseURL,
    headers: settings.headers,
    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+    limits: settings.limits,
    providerOptions: settings.providerOptions,
  }).model(modelID)
@@ -101,6 +101,7 @@ export const model: ProviderPackage.Definition<Settings, XAIProviderOptionsInput
    baseURL: settings.baseURL,
    headers: settings.headers,
    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+    limits: settings.limits,
    providerOptions: settings.providerOptions,
  }).model(modelID)
 export const responses = provider.responses
@@ -16,6 +16,7 @@ import {
  LLMRequest,
  LLMResponse,
  LanguageModel,
+  LanguageModelLimits,
  LLMEvent,
  InvalidProviderOutputReason,
  ProviderID,
@@ -73,6 +74,7 @@ export type RouteRoutedLanguageModelInput = Omit<LanguageModel.Input, "route">

 export interface RouteDefaults {
  readonly headers?: Record<string, string>
+  readonly limits?: LanguageModelLimits
  readonly generation?: GenerationOptions
  readonly providerOptions?: ProviderOptions
  readonly http?: HttpOptions
@@ -80,6 +82,7 @@ export interface RouteDefaults {

 export interface RouteDefaultsInput {
  readonly headers?: Record<string, string>
+  readonly limits?: LanguageModelLimits.Input
  readonly generation?: GenerationOptions.Input
  readonly providerOptions?: ProviderOptions
  readonly http?: HttpOptions.Input
@@ -116,6 +119,7 @@ const mergeRouteDefaults = (base: RouteDefaults | undefined, patch: RouteDefault
    ...base,
    ...patch,
    headers,
+    limits: patch.limits === undefined ? base?.limits : LanguageModelLimits.make(patch.limits),
    generation: mergeGenerationOptions(generationOptions(base?.generation), generationOptions(patch.generation)),
    providerOptions: mergeProviderOptions(base?.providerOptions, patch.providerOptions),
    http: mergeHttpOptions(
@@ -114,7 +114,22 @@ export const mergeGenerationOptions = (...items: ReadonlyArray<GenerationOptions
  return Object.values(result).some((value) => value !== undefined) ? result : undefined
 }

+export class LanguageModelLimits extends Schema.Class<LanguageModelLimits>("LLM.LanguageModelLimits")({
+  context: Schema.optional(Schema.Number),
+  input: Schema.optional(Schema.Number),
+  output: Schema.optional(Schema.Number),
+}) {}
+
+export namespace LanguageModelLimits {
+  export type Input = LanguageModelLimits | ConstructorParameters<typeof LanguageModelLimits>[0]
+
+  /** Normalize model limit input into the canonical `LanguageModelLimits` class. */
+  export const make = (input: Input | undefined) =>
+    input instanceof LanguageModelLimits ? input : new LanguageModelLimits(input ?? {})
+}
+
 export class LanguageModelDefaults extends Schema.Class<LanguageModelDefaults>("LLM.LanguageModelDefaults")({
+  limits: Schema.optional(LanguageModelLimits),
  generation: Schema.optional(GenerationOptions),
  providerOptions: Schema.optional(ProviderOptions),
  http: Schema.optional(HttpOptions),
@@ -124,6 +139,7 @@ export namespace LanguageModelDefaults {
  export type Input =
    | LanguageModelDefaults
    | {
+        readonly limits?: LanguageModelLimits.Input
        readonly generation?: GenerationOptions.Input
        readonly providerOptions?: ProviderOptions
        readonly http?: HttpOptions.Input
@@ -133,6 +149,7 @@ export namespace LanguageModelDefaults {
  export const make = (input: Input) => {
    if (input instanceof LanguageModelDefaults) return input
    return new LanguageModelDefaults({
+      limits: input.limits === undefined ? undefined : LanguageModelLimits.make(input.limits),
      generation: input.generation === undefined ? undefined : GenerationOptions.make(input.generation),
      providerOptions: input.providerOptions,
      http: input.http === undefined ? undefined : HttpOptions.make(input.http),
@@ -270,20 +270,21 @@ describe("request option precedence", () => {
    ),
  )

-  it.effect("uses the Anthropic default before call maxTokens", () =>
+  it.effect("uses model output limits after route limits and before call maxTokens", () =>
    Effect.gen(function* () {
      const route = AnthropicMessages.route.with({
        endpoint: { baseURL: "https://api.anthropic.test/v1/" },
        auth: Auth.header("x-api-key", "test"),
+        limits: { output: 128 },
      })
-      const model = route.model({ id: "claude-sonnet-4-5" })
+      const model = route.model({ id: "claude-sonnet-4-5", defaults: { limits: { output: 64 } } })
      const withoutMaxTokens = yield* compileRequest(LLM.request({ model, prompt: "Say hello.", cache: "none" }))
      const withMaxTokens = yield* compileRequest(
-        LLM.request({ model, prompt: "Say hello.", cache: "none", generation: { maxTokens: 8_000 } }),
+        LLM.request({ model, prompt: "Say hello.", cache: "none", generation: { maxTokens: 32 } }),
      )

-      expect(withoutMaxTokens.body.max_tokens).toBe(32_000)
-      expect(withMaxTokens.body.max_tokens).toBe(8_000)
+      expect(withoutMaxTokens.body.max_tokens).toBe(64)
+      expect(withMaxTokens.body.max_tokens).toBe(32)
    }),
  )
 })
@@ -121,6 +121,7 @@ describe("llm constructors", () => {
    const model = chatRoute.model({
      id: "kimi-k2",
      defaults: {
+        limits: { context: 128_000, output: 8_192 },
        generation: { maxTokens: 1_024, stop: ["END"] },
        providerOptions: { parallelToolCalls: false },
        http: { body: { extra_body: true } },
@@ -129,6 +130,7 @@ describe("llm constructors", () => {
    })
    const request = LLM.request({ model, prompt: "Say hello." })

+    expect(request.model.defaults?.limits).toEqual({ context: 128_000, output: 8_192 })
    expect(request.model.defaults?.generation).toEqual({ maxTokens: 1_024, stop: ["END"] })
    expect(request.model.defaults?.providerOptions).toEqual({ parallelToolCalls: false })
    expect(request.model.defaults?.http).toEqual({ body: { extra_body: true } })
@@ -43,6 +43,7 @@ describe("provider package entrypoints", () => {
      baseURL: "https://provider.example.test/v1",
      headers: { "x-application": "opencode" },
      body: { service_tier: "priority" },
+      limits: { context: 200_000, output: 64_000 },
    }
    const openrouter = OpenRouter.model("anthropic/claude-sonnet-4", {
      ...settings,
@@ -57,6 +58,7 @@ describe("provider package entrypoints", () => {
      expect(selected.route.endpoint.baseURL).toBe(settings.baseURL)
      expect(selected.route.defaults.headers).toEqual(settings.headers)
      expect(selected.route.defaults.http?.body).toEqual(settings.body)
+      expect(selected.route.defaults.limits).toEqual(settings.limits)
    }
    expect(openrouter.route.defaults.providerOptions).toEqual({ usage: true })
    expect(xai.route.defaults.providerOptions).toMatchObject({ reasoningEffort: "high", store: false })
@@ -68,12 +70,14 @@ describe("provider package entrypoints", () => {
      baseURL: "https://api.openai.test/v1",
      headers: { "x-application": "opencode" },
      body: { service_tier: "priority" },
+      limits: { context: 200_000, output: 64_000 },
      unrelatedInheritedSetting: true,
    })

    expect(selected.route.id).toBe("openai-responses")
    expect(selected.route.defaults.headers).toEqual({ "x-application": "opencode" })
    expect(selected.route.defaults.http?.body).toEqual({ service_tier: "priority" })
+    expect(selected.route.defaults.limits).toEqual({ context: 200_000, output: 64_000 })
  })

  test("maps OpenAI-compatible Responses settings onto the executable model", async () => {
@@ -84,6 +88,7 @@ describe("provider package entrypoints", () => {
      provider: "example",
      headers: { "x-application": "opencode" },
      body: { service_tier: "priority" },
+      limits: { context: 200_000, output: 64_000 },
      providerOptions: { reasoningEffort: "low", store: true },
    })

@@ -95,6 +100,7 @@ describe("provider package entrypoints", () => {
    })
    expect(selected.route.defaults.headers).toEqual({ "x-application": "opencode" })
    expect(selected.route.defaults.http?.body).toEqual({ service_tier: "priority" })
+    expect(selected.route.defaults.limits).toEqual({ context: 200_000, output: 64_000 })
    expect(selected.route.defaults.providerOptions).toEqual({ reasoningEffort: "low", store: true })
  })

@@ -106,6 +112,7 @@ describe("provider package entrypoints", () => {
      provider: "example",
      headers: { "x-application": "opencode" },
      body: { metadata: { user_id: "user_1" } },
+      limits: { context: 200_000, output: 64_000 },
      providerOptions: { effort: "low" },
    })

@@ -117,6 +124,7 @@ describe("provider package entrypoints", () => {
    })
    expect(selected.route.defaults.headers).toEqual({ "x-application": "opencode" })
    expect(selected.route.defaults.http?.body).toEqual({ metadata: { user_id: "user_1" } })
+    expect(selected.route.defaults.limits).toEqual({ context: 200_000, output: 64_000 })
    expect(selected.route.defaults.providerOptions).toEqual({ effort: "low" })
  })

@@ -177,6 +185,7 @@ describe("provider package entrypoints", () => {
      resourceName: "opencode-test",
      headers: { "x-application": "opencode" },
      body: { service_tier: "priority" },
+      limits: { context: 200_000, output: 64_000 },
    }

    const responses = AzureResponses.model("deployment", settings)
@@ -187,6 +196,7 @@ describe("provider package entrypoints", () => {
    expect(responses.route.endpoint.baseURL).toBe("https://opencode-test.openai.azure.com/openai/v1")
    expect(responses.route.defaults.headers).toEqual({ "x-application": "opencode" })
    expect(responses.route.defaults.http?.body).toEqual({ service_tier: "priority" })
+    expect(responses.route.defaults.limits).toEqual({ context: 200_000, output: 64_000 })
    expect(chat.route.id).toBe("azure-openai-chat")
  })

@@ -218,6 +228,7 @@ describe("provider package entrypoints", () => {
      baseURL: "https://generativelanguage.test/v1beta",
      headers: { "x-application": "opencode" },
      body: { safetySettings: [] },
+      limits: { context: 1_000_000, output: 65_536 },
      providerOptions: { thinkingConfig: { thinkingBudget: 1_024 } },
    })

@@ -225,6 +236,7 @@ describe("provider package entrypoints", () => {
    expect(selected.route.endpoint.baseURL).toBe("https://generativelanguage.test/v1beta")
    expect(selected.route.defaults.headers).toEqual({ "x-application": "opencode" })
    expect(selected.route.defaults.http?.body).toEqual({ safetySettings: [] })
+    expect(selected.route.defaults.limits).toEqual({ context: 1_000_000, output: 65_536 })
    expect(selected.route.defaults.providerOptions).toEqual({ thinkingConfig: { thinkingBudget: 1_024 } })
  })

@@ -238,6 +250,7 @@ describe("provider package entrypoints", () => {
      apiKey: "fixture",
      headers: { "x-application": "opencode" },
      body: { safetySettings: [] },
+      limits: { context: 1_000_000, output: 65_536 },
    })
    const messages = GoogleVertexMessages.model("claude-sonnet-4-6", {
      accessToken: "fixture",
@@ -261,6 +274,7 @@ describe("provider package entrypoints", () => {
    expect(gemini.route.endpoint.baseURL).toBe("https://aiplatform.googleapis.com/v1/publishers/google")
    expect(gemini.route.defaults.headers).toEqual({ "x-application": "opencode" })
    expect(gemini.route.defaults.http?.body).toEqual({ safetySettings: [] })
+    expect(gemini.route.defaults.limits).toEqual({ context: 1_000_000, output: 65_536 })
    expect(
      GoogleVertex.model("gemini-3.5-flash", {
        accessToken: "fixture",
@@ -322,7 +322,7 @@ describe("Anthropic Messages route", () => {
          { role: "user", content: [{ type: "tool_result", tool_use_id: "call_1", content: '{"forecast":"sunny"}' }] },
        ],
        stream: true,
-        max_tokens: 32_000,
+        max_tokens: 4096,
      })
    }),
  )
@@ -139,48 +139,6 @@ describe("Gemini route", () => {
    }),
  )

-  it.effect("keeps system updates separate from function responses", () =>
-    Effect.gen(function* () {
-      const prepared = yield* compileRequest(
-        LLM.request({
-          model,
-          messages: [
-            Message.assistant([ToolCallPart.make({ id: "call_1", name: "lookup", input: { query: "weather" } })]),
-            Message.tool({ id: "call_1", name: "lookup", result: "done", resultType: "text" }),
-            Message.system("Update."),
-            Message.system("Later update."),
-          ],
-        }),
-      )
-
-      expect(prepared.body.contents).toEqual([
-        {
-          role: "model",
-          parts: [{ functionCall: { id: undefined, name: "lookup", args: { query: "weather" } } }],
-        },
-        {
-          role: "user",
-          parts: [
-            {
-              functionResponse: {
-                id: undefined,
-                name: "lookup",
-                response: { name: "lookup", content: "done" },
-              },
-            },
-          ],
-        },
-        {
-          role: "user",
-          parts: [
-            { text: "<system-update>\nUpdate.\n</system-update>" },
-            { text: "<system-update>\nLater update.\n</system-update>" },
-          ],
-        },
-      ])
-    }),
-  )
-
  it.effect("prepares multimodal user input and tool history", () =>
    Effect.gen(function* () {
      const prepared = yield* compileRequest(
@@ -664,74 +664,6 @@ describe("OpenAI Chat route", () => {
    }),
  )

-  it.effect("preserves streamed refusals as ordinary assistant text", () =>
-    Effect.gen(function* () {
-      const response = yield* LLMClient.generate(request).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents(
-              deltaChunk({ role: "assistant", refusal: "I can't" }),
-              deltaChunk({ refusal: " help with that." }),
-              deltaChunk({}, "stop"),
-            ),
-          ),
-        ),
-      )
-
-      expect(response.text).toBe("I can't help with that.")
-      expect(response.finishReason).toEqual({ normalized: "stop", raw: "stop" })
-      expect(response.message.content).toEqual([{ type: "text", text: "I can't help with that." }])
-
-      const replay = yield* compileRequest(LLM.request({ model, messages: [response.message] }))
-      expect(replay.body.messages).toEqual([{ role: "assistant", content: "I can't help with that." }])
-    }),
-  )
-
-  it.effect("orders metadata-only reasoning before refusal output", () =>
-    Effect.gen(function* () {
-      const response = yield* LLMClient.generate(request).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents(
-              { choices: [{ delta: { reasoning_details: [] } }] },
-              deltaChunk({ refusal: "I can't help with that." }),
-              deltaChunk({}, "stop"),
-            ),
-          ),
-        ),
-      )
-
-      expect(response.message.content).toEqual([
-        { type: "reasoning", text: "", providerMetadata: { openai: { reasoningDetails: [] } } },
-        {
-          type: "text",
-          text: "I can't help with that.",
-        },
-      ])
-    }),
-  )
-
-  it.effect("joins content and refusal deltas into ordinary assistant text", () =>
-    Effect.gen(function* () {
-      const response = yield* LLMClient.generate(request).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents(
-              deltaChunk({ refusal: "No." }),
-              deltaChunk({ content: " Alternative." }),
-              deltaChunk({ refusal: " Still no." }),
-              deltaChunk({}, "stop"),
-            ),
-          ),
-        ),
-      )
-
-      expect(response.text).toBe("No. Alternative. Still no.")
-      expect(response.events.filter(LLMEvent.is.textStart).map((event) => event.id)).toEqual(["text-0"])
-      expect(response.events.filter(LLMEvent.is.textEnd).map((event) => event.id)).toEqual(["text-0"])
-    }),
-  )
-
  it.effect("parses and replays OpenAI-compatible reasoning fields", () =>
    Effect.gen(function* () {
      const fields = ["reasoning_content", "reasoning", "reasoning_text"] as const
@@ -73,7 +73,7 @@ describe("Open Responses-compatible route", () => {
      expect(prepared.body.input).toEqual([
        { role: "user", content: [{ type: "input_text", text: "Before." }] },
        { role: "developer", content: "Operator update." },
-        { type: "message", role: "assistant", content: [{ type: "output_text", text: "After." }] },
+        { role: "assistant", content: [{ type: "output_text", text: "After." }] },
      ])
    }),
  )
@@ -113,67 +113,11 @@ describe("Open Responses-compatible route", () => {
      )

      expect(prepared.body).toMatchObject({
-        input: [{ type: "message", role: "assistant", content: [{ type: "output_text", text: "Unclassified." }] }],
+        input: [{ role: "assistant", content: [{ type: "output_text", text: "Unclassified." }] }],
      })
    }),
  )

-  it.effect("preserves standard refusal content as ordinary assistant text", () =>
-    Effect.gen(function* () {
-      const model = configure({
-        apiKey: "test-key",
-        baseURL: "https://responses.example.test/v1",
-        provider: "example",
-      }).model("example-model")
-      const response = yield* LLMClient.generate(LLM.request({ model, prompt: "Unsafe request" })).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents(
-              {
-                type: "response.output_item.added",
-                output_index: 0,
-                item: { type: "message", id: "msg_refusal", content: [] },
-              },
-              {
-                type: "response.refusal.done",
-                item_id: "msg_refusal",
-                refusal: "I can't help with that.",
-              },
-              {
-                type: "response.output_item.done",
-                output_index: 0,
-                item: {
-                  type: "message",
-                  id: "msg_refusal",
-                  content: [{ type: "refusal", refusal: "I can't help with that." }],
-                },
-              },
-              { type: "response.completed", response: { id: "resp_1" } },
-            ),
-          ),
-        ),
-      )
-
-      expect(response.message.content).toEqual([
-        {
-          type: "text",
-          text: "I can't help with that.",
-          providerMetadata: { openresponses: { itemId: "msg_refusal" } },
-        },
-      ])
-
-      const prepared = yield* compileRequest(LLM.request({ model, messages: [response.message] }))
-      expect(prepared.body.input).toEqual([
-        {
-          type: "message",
-          id: "msg_refusal",
-          role: "assistant",
-          content: [{ type: "output_text", text: "I can't help with that." }],
-        },
-      ])
-    }),
-  )
-
  it.effect("reads standard Open Responses options", () =>
    Effect.gen(function* () {
      const model = configure({
@@ -182,10 +126,6 @@ describe("Open Responses-compatible route", () => {
        providerOptions: {
          reasoningEffort: "low",
          store: true,
-          metadata: { environment: "test" },
-          safetyIdentifier: "user_123",
-          streamOptions: { includeObfuscation: false },
-          topLogprobs: 3,
          truncation: "auto",
          allowedTools: { toolNames: ["lookup"] },
          maxToolCalls: 2,
@@ -196,7 +136,6 @@ describe("Open Responses-compatible route", () => {
        LLM.request({
          model,
          prompt: "Think.",
-          generation: { presencePenalty: 0.2, frequencyPenalty: -0.1 },
          tools: [ToolDefinition.make({ name: "lookup", description: "Lookup data", inputSchema: { type: "object" } })],
        }),
      )
@@ -204,12 +143,6 @@ describe("Open Responses-compatible route", () => {
      expect(prepared.body).toMatchObject({
        reasoning: { effort: "low" },
        store: true,
-        metadata: { environment: "test" },
-        safety_identifier: "user_123",
-        stream_options: { include_obfuscation: false },
-        top_logprobs: 3,
-        presence_penalty: 0.2,
-        frequency_penalty: -0.1,
        truncation: "auto",
        tool_choice: {
          type: "allowed_tools",
@@ -263,7 +263,7 @@ describe("OpenAI Responses route", () => {
      expect(prepared.body.input).toEqual([
        { role: "user", content: [{ type: "input_text", text: "Before." }] },
        { role: "developer", content: "Operator update." },
-        { type: "message", role: "assistant", content: [{ type: "output_text", text: "After." }] },
+        { role: "assistant", content: [{ type: "output_text", text: "After." }] },
      ])
    }),
  )
@@ -485,7 +485,7 @@ describe("OpenAI Responses route", () => {
    }),
  )

-  it.effect("continues store-false reasoning while retaining the output item ID", () =>
+  it.effect("continues store-false reasoning without replaying the output-only item ID", () =>
    Effect.gen(function* () {
      const firstInput = [{ role: "user", content: [{ type: "input_text", text: "Think" }] }]
      const request = { type: "response.create", model: "gpt-5.2", store: false, input: firstInput }
@@ -515,7 +515,6 @@ describe("OpenAI Responses route", () => {
          ...firstInput,
          {
            type: "reasoning",
-            id: "rs_1",
            summary: [{ type: "summary_text", text: "Thought" }],
            encrypted_content: "encrypted",
          },
@@ -1285,7 +1284,6 @@ describe("OpenAI Responses route", () => {
          model: OpenAI.configure({ baseURL: "https://api.openai.test/v1/", apiKey: "test" }).model("gpt-5.2"),
          prompt: "think",
          promptCacheKey: "session_123",
-          generation: { presencePenalty: 0.25, frequencyPenalty: -0.25 },
          tools: [
            ToolDefinition.make({ name: "read", description: "Read a file", inputSchema: { type: "object" } }),
            ToolDefinition.make({ name: "grep", description: "Search files", inputSchema: { type: "object" } }),
@@ -1295,10 +1293,6 @@ describe("OpenAI Responses route", () => {
            reasoningEffort: "high",
            reasoningSummary: "auto",
            include: ["reasoning.encrypted_content"],
-            metadata: { environment: "test", tenant: "acme" },
-            safetyIdentifier: "user_123",
-            streamOptions: { includeObfuscation: false },
-            topLogprobs: 5,
            truncation: "disabled",
            allowedTools: { toolNames: ["read", "grep"], mode: "required" },
            maxToolCalls: 4,
@@ -1312,12 +1306,6 @@ describe("OpenAI Responses route", () => {
      expect(prepared.body.include).toEqual(["reasoning.encrypted_content"])
      expect(prepared.body.reasoning).toEqual({ effort: "high", summary: "auto" })
      expect(prepared.body.text).toEqual({ verbosity: "low" })
-      expect(prepared.body.metadata).toEqual({ environment: "test", tenant: "acme" })
-      expect(prepared.body.safety_identifier).toBe("user_123")
-      expect(prepared.body.stream_options).toEqual({ include_obfuscation: false })
-      expect(prepared.body.top_logprobs).toBe(5)
-      expect(prepared.body.presence_penalty).toBe(0.25)
-      expect(prepared.body.frequency_penalty).toBe(-0.25)
      expect(prepared.body.truncation).toBe("disabled")
      expect(prepared.body.tool_choice).toEqual({
        type: "allowed_tools",
@@ -1485,7 +1473,7 @@ describe("OpenAI Responses route", () => {
      expect(response.text).toBe("Hello!")
      expect(response.events).toEqual([
        { type: "step-start", index: 0 },
-        { type: "text-start", id: "msg_1", providerMetadata: { openai: { itemId: "msg_1" } } },
+        { type: "text-start", id: "msg_1" },
        { type: "text-delta", id: "msg_1", text: "Hello" },
        { type: "text-delta", id: "msg_1", text: "!" },
        { type: "text-end", id: "msg_1" },
@@ -1506,108 +1494,6 @@ describe("OpenAI Responses route", () => {
    }),
  )

-  it.effect("preserves standard refusal content as ordinary assistant text", () =>
-    Effect.gen(function* () {
-      const response = yield* LLMClient.generate(request).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents(
-              {
-                type: "response.output_item.added",
-                output_index: 0,
-                item: { type: "message", id: "msg_refusal", content: [] },
-              },
-              {
-                type: "response.content_part.added",
-                item_id: "msg_refusal",
-                output_index: 0,
-                content_index: 0,
-                part: { type: "refusal", refusal: "" },
-              },
-              {
-                type: "response.refusal.delta",
-                item_id: "msg_refusal",
-                output_index: 0,
-                content_index: 0,
-                delta: "I can't",
-              },
-              {
-                type: "response.refusal.delta",
-                item_id: "msg_refusal",
-                output_index: 0,
-                content_index: 0,
-                delta: " help with that.",
-              },
-              {
-                type: "response.refusal.done",
-                item_id: "msg_refusal",
-                output_index: 0,
-                content_index: 0,
-                refusal: "I can't help with that.",
-              },
-              {
-                type: "response.content_part.done",
-                item_id: "msg_refusal",
-                output_index: 0,
-                content_index: 0,
-                part: { type: "refusal", refusal: "I can't help with that." },
-              },
-              {
-                type: "response.output_item.done",
-                output_index: 0,
-                item: {
-                  type: "message",
-                  id: "msg_refusal",
-                  phase: "final_answer",
-                  content: [{ type: "refusal", refusal: "I can't help with that." }],
-                },
-              },
-              { type: "response.completed", response: { id: "resp_1" } },
-            ),
-          ),
-        ),
-      )
-
-      expect(response.text).toBe("I can't help with that.")
-      expect(response.finishReason).toEqual({ normalized: "stop", raw: undefined })
-      expect(response.message.content).toEqual([
-        {
-          type: "text",
-          text: "I can't help with that.",
-          providerMetadata: { openai: { itemId: "msg_refusal", phase: "final_answer" } },
-        },
-      ])
-
-      const prepared = yield* compileRequest(LLM.request({ model, messages: [response.message] }))
-      expect(prepared.body.input).toEqual([
-        {
-          type: "message",
-          id: "msg_refusal",
-          role: "assistant",
-          content: [{ type: "output_text", text: "I can't help with that." }],
-          phase: "final_answer",
-        },
-      ])
-    }),
-  )
-
-  it.effect("rejects malformed refusal events", () =>
-    Effect.gen(function* () {
-      const events = [
-        { type: "response.refusal.delta", output_index: 0, content_index: 0, delta: "missing item" },
-        { type: "response.refusal.delta", item_id: "msg_1", output_index: 0, content_index: 0 },
-        { type: "response.refusal.done", item_id: "msg_1", output_index: 0, content_index: 0 },
-      ]
-      for (const event of events) {
-        const error = yield* LLMClient.generate(request).pipe(
-          Effect.provide(fixedResponse(sseEvents(event))),
-          Effect.flip,
-        )
-        expect(error.reason._tag).toBe("InvalidProviderOutput")
-      }
-    }),
-  )
-
  it.effect("preserves and replays assistant message phases", () =>
    Effect.gen(function* () {
      const response = yield* LLMClient.generate(request).pipe(
@@ -1646,39 +1532,33 @@ describe("OpenAI Responses route", () => {
        {
          type: "text",
          text: "Checking.",
-          providerMetadata: { openai: { itemId: "msg_commentary", phase: "commentary" } },
+          providerMetadata: { openai: { phase: "commentary" } },
        },
        {
          type: "text",
          text: "Finished.",
-          providerMetadata: { openai: { itemId: "msg_final", phase: "final_answer" } },
+          providerMetadata: { openai: { phase: "final_answer" } },
        },
        {
          type: "text",
          text: "Unclassified.",
-          providerMetadata: { openai: { itemId: "msg_null", phase: null } },
+          providerMetadata: { openai: { phase: null } },
        },
      ])

      const prepared = yield* compileRequest(LLM.request({ model, messages: [response.message] }))
      expect(prepared.body.input).toEqual([
        {
-          type: "message",
-          id: "msg_commentary",
          role: "assistant",
          content: [{ type: "output_text", text: "Checking." }],
          phase: "commentary",
        },
        {
-          type: "message",
-          id: "msg_final",
          role: "assistant",
          content: [{ type: "output_text", text: "Finished." }],
          phase: "final_answer",
        },
        {
-          type: "message",
-          id: "msg_null",
          role: "assistant",
          content: [{ type: "output_text", text: "Unclassified." }],
          phase: null,
@@ -1772,12 +1652,12 @@ describe("OpenAI Responses route", () => {
      )

      expect(response.events.filter((event) => event.type.startsWith("text-"))).toEqual([
-        { type: "text-start", id: "msg_1", providerMetadata: { openai: { itemId: "msg_1" } } },
+        { type: "text-start", id: "msg_1" },
        { type: "text-delta", id: "msg_1", text: "First" },
-        { type: "text-end", id: "msg_1", providerMetadata: undefined },
-        { type: "text-start", id: "msg_2", providerMetadata: { openai: { itemId: "msg_2" } } },
+        { type: "text-end", id: "msg_1" },
+        { type: "text-start", id: "msg_2" },
        { type: "text-delta", id: "msg_2", text: "Second" },
-        { type: "text-end", id: "msg_2", providerMetadata: { openai: { itemId: "msg_2" } } },
+        { type: "text-end", id: "msg_2" },
      ])
    }),
  )
@@ -1809,7 +1689,7 @@ describe("OpenAI Responses route", () => {
      expect(response.events.filter((event) => event.type === "finish")).toHaveLength(1)
      expect(response.message.content).toEqual([
        { type: "reasoning", text: "thinking" },
-        { type: "text", text: "Hello", providerMetadata: { openai: { itemId: "msg_1" } } },
+        { type: "text", text: "Hello" },
      ])
    }),
  )
@@ -1970,7 +1850,6 @@ describe("OpenAI Responses route", () => {
                  { role: "user", content: [{ type: "input_text", text: "What changed?" }] },
                  {
                    type: "reasoning",
-                    id: "rs_1",
                    encrypted_content: "encrypted-state",
                    summary: [{ type: "summary_text", text: "Checked the previous diff." }],
                  },
@@ -1978,6 +1857,7 @@ describe("OpenAI Responses route", () => {
                  { role: "user", content: [{ type: "input_text", text: "Summarize it." }] },
                ],
              })
+              expect(body.input[1]).not.toHaveProperty("id")
              return input.respond(
                sseEvents(
                  { type: "response.output_text.delta", item_id: "msg_1", delta: "Parser now round-trips reasoning." },
@@ -2021,14 +1901,13 @@ describe("OpenAI Responses route", () => {
      )

      expect(prepared.body.input).toEqual([
-        { type: "message", role: "assistant", content: [{ type: "output_text", text: "Before." }] },
+        { role: "assistant", content: [{ type: "output_text", text: "Before." }] },
        {
          type: "reasoning",
-          id: "rs_1",
          encrypted_content: "encrypted-state",
          summary: [{ type: "summary_text", text: "Checked order." }],
        },
-        { type: "message", role: "assistant", content: [{ type: "output_text", text: "After." }] },
+        { role: "assistant", content: [{ type: "output_text", text: "After." }] },
      ])
    }),
  )
@@ -2160,7 +2039,6 @@ describe("OpenAI Responses route", () => {
      expect(prepared.body.input).toEqual([
        {
          type: "reasoning",
-          id: "rs_1",
          encrypted_content: "encrypted-state",
          summary: [
            { type: "summary_text", text: "First" },
@@ -2293,50 +2171,6 @@ describe("OpenAI Responses route", () => {
          usage,
        },
      ])
-
-      const prepared = yield* compileRequest(LLM.request({ model, messages: [response.message] }))
-      expect(prepared.body.input).toEqual([
-        {
-          type: "function_call",
-          id: "item_1",
-          call_id: "call_1",
-          name: "lookup",
-          arguments: '{"query":"weather"}',
-        },
-      ])
-    }),
-  )
-
-  it.effect("finalizes a pending function call at response completion", () =>
-    Effect.gen(function* () {
-      const body = sseEvents(
-        {
-          type: "response.output_item.added",
-          item: { type: "function_call", id: "item_1", call_id: "call_1", name: "lookup", arguments: "" },
-        },
-        { type: "response.completed", response: { usage: { input_tokens: 5, output_tokens: 1 } } },
-      )
-      const response = yield* LLMClient.generate(request).pipe(Effect.provide(fixedResponse(body)))
-
-      expect(response.events.filter((event) => LLMEvent.is.toolInputEnd(event) || LLMEvent.is.toolCall(event))).toEqual(
-        [
-          {
-            type: "tool-input-end",
-            id: "call_1",
-            name: "lookup",
-            providerMetadata: { openai: { itemId: "item_1" } },
-          },
-          {
-            type: "tool-call",
-            id: "call_1",
-            name: "lookup",
-            input: {},
-            providerExecuted: undefined,
-            providerMetadata: { openai: { itemId: "item_1" } },
-          },
-        ],
-      )
-      expect(response.finishReason.normalized).toBe("tool-calls")
    }),
  )

@@ -2403,35 +2237,6 @@ describe("OpenAI Responses route", () => {
    }),
  )

-  it.effect("retains function call item metadata when output_item.added is absent", () =>
-    Effect.gen(function* () {
-      const response = yield* LLMClient.generate(request).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents(
-              {
-                type: "response.output_item.done",
-                item: {
-                  type: "function_call",
-                  id: "item_1",
-                  call_id: "call_1",
-                  name: "lookup",
-                  arguments: '{"query":"weather"}',
-                },
-              },
-              { type: "response.completed", response: { id: "resp_1" } },
-            ),
-          ),
-        ),
-      )
-
-      expect(response.events.find(LLMEvent.is.toolCall)).toMatchObject({
-        id: "call_1",
-        providerMetadata: { openai: { itemId: "item_1" } },
-      })
-    }),
-  )
-
  it.effect("decodes web_search_call as provider-executed tool-call + tool-result", () =>
    Effect.gen(function* () {
      const item = {
@@ -2,34 +2,12 @@

 The app's high-volume performance diagnostics live under `packages/app/e2e/performance` and are excluded from normal local and CI Playwright discovery. The benchmark config builds the app and serves the production bundle before running scenarios serially.

-The `devex` category is the explicit exception to the production-build rule. It measures development commands from submission through a user-visible ready state and has its own Playwright configuration.
-
 Run the suite explicitly from `packages/app`:

 ```sh
 bun run test:bench
 ```

-Run the desktop development startup benchmark from the repository root:
-
-```sh
-bun run bench:devex
-```
-
-It runs five serial samples of the exact `bun dev:desktop` command. Each sample uses a fresh desktop profile, database, service configuration, service registration, and service process; the desktop selects an isolated ephemeral loopback endpoint. It removes desktop build output and the desktop Vite cache before every run; dependencies, Bun's package cache, and Electron remain installed. The harness stops only that sample's service; it does not stop or change the elected global OpenCode service. The measured endpoint is a visible Home page whose empty-state controls pass Playwright actionability checks. The command's Electron installation check remains inside the measured interval.
-
-Set `DESKTOP_STARTUP_RUNS` only for focused diagnostics:
-
-```sh
-DESKTOP_STARTUP_RUNS=1 bun run bench:devex
-```
-
-Set `OPENCODE_PERFORMANCE_TRACE_DIR` to capture the renderer's CDP trace from attachment through actionable Home:
-
-```sh
-DESKTOP_STARTUP_RUNS=1 OPENCODE_PERFORMANCE_TRACE_DIR=/tmp/opencode-desktop-traces bun run bench:devex
-```
-
 PowerShell:

 ```powershell
@@ -18,9 +18,9 @@ const categories = [
  "disabled-by-default-v8.cpu_profiler",
 ]

-export async function startChromeTrace(page: Page, name: string): Promise<undefined | (() => Promise<string>)> {
+export async function startChromeTrace(page: Page, name: string) {
  const directory = process.env.OPENCODE_PERFORMANCE_TRACE_DIR
-  if (!directory) return undefined
+  if (!directory) return

  const selectors = process.env.OPENCODE_PERFORMANCE_SELECTOR_TRACE === "1"
  const file = await prepareChromeTrace(directory, name, selectors)
@@ -1,26 +0,0 @@
-import { benchmark } from "../benchmark"
-import {
-  desktopBenchmarkContext,
-  runDesktopStartup,
-  summarizeDesktopStartup,
-  type DesktopStartupSample,
-} from "./desktop-startup"
-
-benchmark.describe("devex: desktop startup", () => {
-  benchmark("opens a cold desktop on Home", async ({ report }, testInfo) => {
-    benchmark.setTimeout(15 * 60_000)
-    const runs = Number(process.env.DESKTOP_STARTUP_RUNS ?? 5)
-    if (!Number.isSafeInteger(runs) || runs < 1) throw new Error("DESKTOP_STARTUP_RUNS must be a positive integer")
-
-    const samples: DesktopStartupSample[] = []
-    const context = await desktopBenchmarkContext(runs)
-    for (let run = 1; run <= runs; run++) {
-      const sample = await runDesktopStartup(run, testInfo).catch((error) => {
-        report(samples.length ? { samples, summary: summarizeDesktopStartup(samples) } : { samples }, context)
-        throw error
-      })
-      samples.push(sample)
-    }
-    report({ samples, summary: summarizeDesktopStartup(samples) }, context)
-  })
-})
@@ -1,526 +0,0 @@
-import { Service } from "@opencode-ai/client/service"
-import { chromium, expect, type Browser, type Page, type TestInfo } from "@playwright/test"
-import { spawn, spawnSync, type ChildProcess } from "node:child_process"
-import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises"
-import { tmpdir } from "node:os"
-import { join, resolve } from "node:path"
-import { startChromeTrace } from "../chrome-trace"
-
-const repository = resolve(import.meta.dirname, "../../../../..")
-const milestones = [
-  "bunRootScript",
-  "bunDesktopScript",
-  "desktopPrepared",
-  "mainBundleReady",
-  "preloadBundleReady",
-  "rendererDevServerReady",
-  "electronSpawnStarted",
-  "debugEndpointReady",
-  "electronStarted",
-  "serviceEnsureStarted",
-  "serviceSpawnRequested",
-  "serviceReady",
-  "backgroundLoadingReady",
-  "rendererViteConnected",
-  "rendererInitializationStarted",
-  "rendererInitializationReady",
-  "windowVisible",
-  "homeReady",
-] as const
-const phases = [
-  "desktopPreparation",
-  "viteMainBundle",
-  "vitePreloadBundle",
-  "rendererServerStartup",
-  "electronStartup",
-  "serviceSpawnWait",
-  "serviceProcessStartup",
-  "rendererStartup",
-  "visibleWindowToHome",
-] as const
-
-type Milestone = (typeof milestones)[number]
-type Phase = (typeof phases)[number]
-type ServiceInfo = { id: string; version: string; url: string; pid: number }
-
-export type DesktopStartupSample = {
-  run: number
-  commandToHomeReadyMs: number
-  milestonesMs: Record<Milestone, number>
-  phasesMs: Record<Phase, number>
-  service: Omit<ServiceInfo, "id">
-}
-
-export async function runDesktopStartup(run: number, testInfo: TestInfo) {
-  const profile = await createColdProfile()
-  const desktop = await Promise.resolve()
-    .then(() => startDesktop(profile))
-    .catch(async (error) => {
-      await rm(profile.root, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 })
-      throw error
-    })
-  try {
-    const page = await desktop.open()
-    const stopTrace = await startChromeTrace(page, `desktop-startup-${run}`)
-    try {
-      await startThemeObservation(page)
-      await waitForHome(page, desktop.mark)
-      await requireStableTheme(page)
-      return await desktop.result(run)
-    } finally {
-      await stopTrace?.()
-    }
-  } finally {
-    await desktop.close(testInfo, run)
-  }
-}
-
-export async function desktopBenchmarkContext(runs: number) {
-  const pkg = JSON.parse(await readFile(join(repository, "packages/desktop/package.json"), "utf8"))
-  const revision = spawnSync("git", ["rev-parse", "HEAD"], { cwd: repository })
-  if (revision.status !== 0) throw new Error("Failed to read the benchmark Git revision")
-  const status = spawnSync("git", ["status", "--porcelain"], { cwd: repository })
-  if (status.status !== 0) throw new Error("Failed to read the benchmark Git status")
-  const bun = spawnSync("bun", ["--version"], { cwd: repository })
-  if (bun.status !== 0) throw new Error("Failed to read the benchmark Bun version")
-  return {
-    arch: process.arch,
-    command: "bun dev:desktop",
-    runs,
-    profile: "fresh",
-    service: "isolated-cold",
-    install: "complete",
-    viteCache: "cold",
-    electronInstall: "present",
-    bunVersion: bun.stdout.toString().trim(),
-    electronVersion: pkg.devDependencies.electron,
-    electronViteVersionRange: pkg.devDependencies["electron-vite"],
-    gitCommit: revision.stdout.toString().trim(),
-    gitDirty: status.stdout.length > 0,
-    trace: Boolean(process.env.OPENCODE_PERFORMANCE_TRACE_DIR),
-  }
-}
-
-export function summarizeDesktopStartup(samples: DesktopStartupSample[]) {
-  return {
-    commandToHomeReadyMs: statistics(samples.map((sample) => sample.commandToHomeReadyMs)),
-    milestonesMs: Object.fromEntries(
-      milestones.map((name) => [name, statistics(samples.map((sample) => sample.milestonesMs[name]))]),
-    ),
-    phasesMs: Object.fromEntries(
-      phases.map((name) => [name, statistics(samples.map((sample) => sample.phasesMs[name]))]),
-    ),
-  }
-}
-
-export function milestoneForLine(line: string): Milestone | undefined {
-  const text = stripAnsi(line)
-  return milestonePatterns.find((item) => text.includes(item.text))?.name
-}
-
-const milestonePatterns: ReadonlyArray<{ name: Milestone; text: string }> = [
-  { name: "bunRootScript", text: "$ bun --cwd packages/desktop dev" },
-  { name: "bunDesktopScript", text: "$ bun ./scripts/dev.ts" },
-  { name: "desktopPrepared", text: "Copied dev icons from" },
-  { name: "mainBundleReady", text: "electron main process built successfully" },
-  { name: "preloadBundleReady", text: "electron preload scripts built successfully" },
-  { name: "rendererDevServerReady", text: "dev server running for the electron renderer process at:" },
-  { name: "electronSpawnStarted", text: "starting electron app..." },
-  { name: "debugEndpointReady", text: "DevTools listening on ws://" },
-  { name: "electronStarted", text: "app starting" },
-  { name: "serviceEnsureStarted", text: "starting v2 background service" },
-  { name: "serviceSpawnRequested", text: "v2 CLI background service starting" },
-  { name: "serviceReady", text: "v2 CLI background service ready" },
-  { name: "backgroundLoadingReady", text: "loading task finished" },
-  { name: "rendererViteConnected", text: "[vite] connected." },
-  { name: "rendererInitializationStarted", text: "awaiting server ready" },
-  { name: "rendererInitializationReady", text: "server ready" },
-  { name: "windowVisible", text: "main window visible" },
-]
-
-async function createColdProfile() {
-  await Promise.all(
-    ["packages/desktop/node_modules/.vite", "packages/desktop/out"].map((path) =>
-      rm(join(repository, path), { recursive: true, force: true }),
-    ),
-  )
-  const root = await mkdtemp(join(tmpdir(), "opencode-desktop-startup-"))
-  return initializeColdProfile(root).catch(async (error) => {
-    await rm(root, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 })
-    throw error
-  })
-}
-
-async function initializeColdProfile(root: string) {
-  await Promise.all(
-    ["data", "config", "cache", "state", "desktop", "session", "home"].map((dir) =>
-      mkdir(join(root, dir), { recursive: true }),
-    ),
-  )
-  await Promise.all([
-    writeFile(
-      join(root, "desktop", "opencode.settings"),
-      JSON.stringify({ firstLaunchOnboardingComplete: true }),
-    ),
-    writeFile(join(root, "desktop", "opencode.global.dat"), JSON.stringify({ language: '{"locale":"en"}' })),
-  ])
-  const registration = join(root, "desktop", "opencode", "service-local.json")
-  await Service.stop({ file: registration })
-  return { root, registration }
-}
-
-function startDesktop(profile: Awaited<ReturnType<typeof createColdProfile>>) {
-  const started = performance.now()
-  const child = spawn("bun", ["dev:desktop"], {
-    cwd: repository,
-    detached: process.platform !== "win32",
-    env: {
-      ...process.env,
-      OPENCODE_CONFIG_DIR: join(profile.root, "config"),
-      OPENCODE_DB: join(profile.root, "data", "opencode.db"),
-      OPENCODE_TEST_HOME: join(profile.root, "home"),
-      OPENCODE_TEST_ONBOARDING: "0",
-      OPENCODE_DESKTOP_TEST_ROOT: profile.root,
-      OPENCODE_DESKTOP_REMOTE_DEBUGGING_PORT: "0",
-      OPENCODE_DESKTOP_DISABLE_PROTOCOL_REGISTRATION: "1",
-    },
-    stdio: ["ignore", "pipe", "pipe"],
-  })
-  if (!child.pid || !child.stdout || !child.stderr) throw new Error("Failed to start the desktop command")
-  const exited = childExit(child)
-  const observed: Partial<Record<Milestone, number>> = {}
-  const endpoint = Promise.withResolvers<string>()
-  const pageErrors: string[] = []
-  let browser: Browser | undefined
-  let service: ServiceInfo | undefined
-  const mark = (name: Milestone) => {
-    observed[name] ??= elapsed(started)
-  }
-  const record = (line: string) => {
-    const milestone = milestoneForLine(line)
-    if (milestone) mark(milestone)
-    const match = stripAnsi(line).match(/DevTools listening on (ws:\/\/\S+)/)
-    if (match?.[1]) endpoint.resolve(match[1])
-  }
-  const stdout = observeOutput(child.stdout, record)
-  const stderr = observeOutput(child.stderr, record)
-
-  return {
-    mark,
-    async open() {
-      const url = await Promise.race([
-        endpoint.promise,
-        exited.then((code) => {
-          throw new Error(`Desktop command exited with code ${code} before opening its debug endpoint`)
-        }),
-        sleep(120_000).then(() => {
-          throw new Error("Timed out waiting for the desktop debug endpoint")
-        }),
-      ])
-      browser = await chromium.connectOverCDP(url, { timeout: 120_000 })
-      const context = browser.contexts()[0]
-      if (!context) throw new Error("Electron did not expose a browser context")
-      await expect.poll(() => context.pages().length, { timeout: 120_000 }).toBeGreaterThan(0)
-      const page = context.pages()[0]
-      if (!page) throw new Error("Electron did not expose a renderer page")
-      page.on("pageerror", (error) => pageErrors.push(error.stack ?? error.message))
-      return page
-    },
-    async result(run: number): Promise<DesktopStartupSample> {
-      if (pageErrors.length) throw new Error(`Desktop renderer reported errors:\n\n${pageErrors.join("\n\n")}`)
-      service = await readService(profile)
-      const milestonesMs = requireMilestones(observed)
-      return {
-        run,
-        commandToHomeReadyMs: milestonesMs.homeReady,
-        milestonesMs,
-        phasesMs: calculatePhases(milestonesMs),
-        service: {
-          version: service.version,
-          url: service.url,
-          pid: service.pid,
-        },
-      }
-    },
-    async close(testInfo: TestInfo, run: number) {
-      const errors: unknown[] = []
-      await browser?.close().catch(() => undefined)
-      await stopProcessTree(child, exited).catch((error) => {
-        errors.push(error)
-        child.stdout?.destroy()
-        child.stderr?.destroy()
-      })
-      const [stdoutText, stderrText] = await Promise.all([stdout, stderr]).catch((error) => {
-        errors.push(error)
-        return ["", ""]
-      })
-      await Promise.all([
-        testInfo.attach(`desktop-startup-${run}-stdout`, { body: stdoutText, contentType: "text/plain" }),
-        testInfo.attach(`desktop-startup-${run}-stderr`, { body: stderrText, contentType: "text/plain" }),
-        pageErrors.length
-          ? testInfo.attach(`desktop-startup-${run}-page-errors`, {
-              body: pageErrors.join("\n\n"),
-              contentType: "text/plain",
-            })
-          : Promise.resolve(),
-      ]).catch((error) => errors.push(error))
-      await Service.stop({ file: profile.registration }).catch((error) => errors.push(error))
-      if (service && processAlive(service.pid))
-        errors.push(new Error(`Desktop service process ${service.pid} did not stop`))
-      await rm(profile.root, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 }).catch((error) =>
-        errors.push(error),
-      )
-      if (errors.length) throw new AggregateError(errors, "Desktop benchmark cleanup failed")
-    },
-  }
-}
-
-async function waitForHome(page: Page, mark: (name: Milestone) => void) {
-  await expect.poll(() => page.evaluate(() => document.visibilityState), { timeout: 120_000 }).toBe("visible")
-
-  const projects = page.getByRole("complementary", { name: "Projects", exact: true })
-  const sessions = page.getByRole("region", { name: "Recent sessions", exact: true })
-  const search = page.getByRole("textbox", { name: "Search sessions", exact: true })
-  const addProject = projects.locator('button[data-action="home-add-project-row"]')
-  await expect(projects).toBeVisible({ timeout: 120_000 })
-  await expect(sessions).toBeVisible()
-  await expect(search).toBeEditable()
-  await expect(sessions.getByText("Nothing here yet", { exact: true })).toBeVisible()
-  await expect(addProject).toHaveCount(1)
-  await addProject.click({ trial: true })
-  mark("homeReady")
-}
-
-type ThemeWindow = Window & {
-  __OPENCODE_THEME_STATES__?: string[]
-  __OPENCODE_THEME_OBSERVER__?: MutationObserver
-}
-
-async function startThemeObservation(page: Page) {
-  await page.addInitScript(installThemeObservation)
-  await page.evaluate(installThemeObservation)
-}
-
-async function requireStableTheme(page: Page) {
-  const states = await page.evaluate(() => {
-    const target = window as ThemeWindow
-    target.__OPENCODE_THEME_OBSERVER__?.disconnect()
-    return target.__OPENCODE_THEME_STATES__ ?? []
-  })
-  if (states.length !== 1) throw new Error(`Desktop theme changed during startup: ${states.join(" -> ")}`)
-}
-
-function installThemeObservation() {
-  const target = window as ThemeWindow
-  const observeRoot = () => {
-    const root = document.documentElement
-    if (!root) return false
-    const state = () => {
-      const theme = root.dataset.theme
-      const scheme = root.dataset.colorScheme
-      return theme && scheme ? `${theme}:${scheme}` : undefined
-    }
-    const initial = state()
-    target.__OPENCODE_THEME_STATES__ = initial ? [initial] : []
-    target.__OPENCODE_THEME_OBSERVER__ = new MutationObserver(() => {
-      const next = state()
-      if (!next) return
-      if (target.__OPENCODE_THEME_STATES__?.at(-1) !== next) target.__OPENCODE_THEME_STATES__?.push(next)
-    })
-    target.__OPENCODE_THEME_OBSERVER__.observe(root, {
-      attributes: true,
-      attributeFilter: ["data-theme", "data-color-scheme"],
-    })
-    return true
-  }
-  if (observeRoot()) return
-  const documentObserver = new MutationObserver(() => {
-    if (!observeRoot()) return
-    documentObserver.disconnect()
-  })
-  target.__OPENCODE_THEME_OBSERVER__ = documentObserver
-  documentObserver.observe(document, { childList: true })
-}
-
-async function observeOutput(stream: NodeJS.ReadableStream, record: (line: string) => void) {
-  const decoder = new TextDecoder()
-  const output: string[] = []
-  let pending = ""
-  for await (const chunk of stream) {
-    const text = typeof chunk === "string" ? chunk : decoder.decode(chunk, { stream: true })
-    output.push(text)
-    pending += text
-    const lines = pending.split(/\r?\n/)
-    pending = lines.pop() ?? ""
-    lines.forEach(record)
-  }
-  const final = decoder.decode()
-  output.push(final)
-  pending += final
-  if (pending) record(pending)
-  return output.join("")
-}
-
-async function readService(profile: Awaited<ReturnType<typeof createColdProfile>>) {
-  const value: unknown = JSON.parse(await readFile(profile.registration, "utf8"))
-  if (!isServiceInfo(value)) throw new Error("Desktop service registration is invalid")
-  const url = new URL(value.url)
-  const port = Number(url.port)
-  if (url.hostname !== "127.0.0.1" || !Number.isInteger(port) || port <= 0)
-    throw new Error(`Desktop service used unexpected endpoint ${value.url}`)
-  if (!value.version.startsWith("2.0.0-local-"))
-    throw new Error(`Desktop service used unexpected version ${value.version}`)
-  return value
-}
-
-function isServiceInfo(value: unknown): value is ServiceInfo {
-  return (
-    typeof value === "object" &&
-    value !== null &&
-    "id" in value &&
-    typeof value.id === "string" &&
-    "version" in value &&
-    typeof value.version === "string" &&
-    "url" in value &&
-    typeof value.url === "string" &&
-    "pid" in value &&
-    typeof value.pid === "number"
-  )
-}
-
-function requireMilestones(observed: Partial<Record<Milestone, number>>) {
-  const get = (name: Milestone) => {
-    const value = observed[name]
-    if (value === undefined) throw new Error(`Desktop startup did not report milestone: ${name}`)
-    return round(value)
-  }
-  return {
-    bunRootScript: get("bunRootScript"),
-    bunDesktopScript: get("bunDesktopScript"),
-    desktopPrepared: get("desktopPrepared"),
-    mainBundleReady: get("mainBundleReady"),
-    preloadBundleReady: get("preloadBundleReady"),
-    rendererDevServerReady: get("rendererDevServerReady"),
-    electronSpawnStarted: get("electronSpawnStarted"),
-    debugEndpointReady: get("debugEndpointReady"),
-    electronStarted: get("electronStarted"),
-    serviceEnsureStarted: get("serviceEnsureStarted"),
-    serviceSpawnRequested: get("serviceSpawnRequested"),
-    serviceReady: get("serviceReady"),
-    backgroundLoadingReady: get("backgroundLoadingReady"),
-    rendererViteConnected: get("rendererViteConnected"),
-    rendererInitializationStarted: get("rendererInitializationStarted"),
-    rendererInitializationReady: get("rendererInitializationReady"),
-    windowVisible: get("windowVisible"),
-    homeReady: get("homeReady"),
-  }
-}
-
-function calculatePhases(value: Record<Milestone, number>): Record<Phase, number> {
-  return {
-    desktopPreparation: value.desktopPrepared,
-    viteMainBundle: round(value.mainBundleReady - value.desktopPrepared),
-    vitePreloadBundle: round(value.preloadBundleReady - value.mainBundleReady),
-    rendererServerStartup: round(value.rendererDevServerReady - value.preloadBundleReady),
-    electronStartup: round(value.electronStarted - value.electronSpawnStarted),
-    serviceSpawnWait: round(value.serviceSpawnRequested - value.serviceEnsureStarted),
-    serviceProcessStartup: round(value.serviceReady - value.serviceSpawnRequested),
-    rendererStartup: round(value.homeReady - value.rendererViteConnected),
-    visibleWindowToHome: round(value.homeReady - value.windowVisible),
-  }
-}
-
-function statistics(values: number[]) {
-  if (!values.length) throw new Error("Cannot summarize an empty benchmark")
-  const sorted = values.toSorted((left, right) => left - right)
-  const median = medianOf(sorted)
-  return {
-    min: round(sorted[0]),
-    median: round(median),
-    max: round(sorted.at(-1)!),
-    medianAbsoluteDeviation: round(medianOf(sorted.map((value) => Math.abs(value - median)).toSorted((a, b) => a - b))),
-  }
-}
-
-function medianOf(sorted: number[]) {
-  const middle = Math.floor(sorted.length / 2)
-  if (sorted.length % 2) return sorted[middle]
-  return (sorted[middle - 1] + sorted[middle]) / 2
-}
-
-async function stopProcessTree(child: ChildProcess, exited: Promise<number | null>) {
-  if (!child.pid) throw new Error("Desktop command has no process ID")
-  if (process.platform !== "win32") return stopProcessGroup(child.pid, exited)
-  if (child.exitCode !== null || (await exitsWithin(child, exited, 2_000))) return
-  const kill = spawn("taskkill.exe", ["/PID", String(child.pid), "/T", "/F"], {
-    stdio: "ignore",
-  })
-  await childExit(kill)
-  if (await exitsWithin(child, exited, 10_000)) return
-  if (!(await exitsWithin(child, exited, 5_000))) throw new Error(`Desktop command process ${child.pid} did not stop`)
-}
-
-async function stopProcessGroup(pid: number, exited: Promise<number | null>) {
-  await Promise.race([exited, sleep(2_000)])
-  if (!processGroupAlive(pid)) return
-  process.kill(-pid, "SIGTERM")
-  if (await processGroupStopsWithin(pid, 10_000)) return
-  process.kill(-pid, "SIGKILL")
-  if (!(await processGroupStopsWithin(pid, 5_000))) throw new Error(`Desktop command process group ${pid} did not stop`)
-}
-
-async function processGroupStopsWithin(pid: number, timeout: number) {
-  const deadline = Date.now() + timeout
-  while (Date.now() < deadline) {
-    if (!processGroupAlive(pid)) return true
-    await sleep(50)
-  }
-  return !processGroupAlive(pid)
-}
-
-function processGroupAlive(pid: number) {
-  try {
-    process.kill(-pid, 0)
-    return true
-  } catch {
-    return false
-  }
-}
-
-async function exitsWithin(child: ChildProcess, exited: Promise<number | null>, timeout: number) {
-  if (child.exitCode !== null) return true
-  const result = await Promise.race([exited.then(() => true), sleep(timeout).then(() => false)])
-  return result
-}
-
-function childExit(child: ChildProcess) {
-  return new Promise<number | null>((resolve, reject) => {
-    child.once("error", reject)
-    child.once("exit", (code) => resolve(code))
-  })
-}
-
-function sleep(milliseconds: number) {
-  return new Promise<void>((resolve) => setTimeout(resolve, milliseconds))
-}
-
-function processAlive(pid: number) {
-  try {
-    process.kill(pid, 0)
-    return true
-  } catch {
-    return false
-  }
-}
-
-function stripAnsi(value: string) {
-  return value.replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "")
-}
-
-function elapsed(started: number) {
-  return round(performance.now() - started)
-}
-
-function round(value: number) {
-  return Math.round(value * 100) / 100
-}
@@ -1,17 +0,0 @@
-import { defineConfig } from "@playwright/test"
-
-process.env.OPENCODE_PERFORMANCE_RUN_ID ??= `${new Date().toISOString().replace(/[:.]/g, "-")}-${process.pid}`
-
-export default defineConfig({
-  testDir: ".",
-  testMatch: "desktop-startup-benchmark.spec.ts",
-  outputDir: "../../test-results/performance-devex",
-  timeout: 15 * 60_000,
-  expect: {
-    timeout: 120_000,
-  },
-  fullyParallel: false,
-  workers: 1,
-  reporter: [["html", { outputFolder: "../../playwright-report/performance-devex", open: "never" }], ["line"]],
-  projects: [{ name: "desktop" }],
-})
@@ -7,7 +7,7 @@ process.env.OPENCODE_PERFORMANCE_RUN_ID ??= `${new Date().toISOString().replace(
 export default {
  ...config,
  testDir: ".",
-  testIgnore: ["unit/**", "devex/**"],
+  testIgnore: "unit/**",
  outputDir: "../test-results/performance",
  fullyParallel: false,
  workers: 1,
@@ -1,88 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { inlineThemePreload } from "../../../vite.js"
-import { milestoneForLine, summarizeDesktopStartup, type DesktopStartupSample } from "../devex/desktop-startup"
-
-describe("desktop startup benchmark", () => {
-  test.each(["/oc-theme-preload.js", "./oc-theme-preload.js"])("inlines %s before the renderer runs", (path) => {
-    const html = inlineThemePreload(`<script id="oc-theme-preload-script" src="${path}"></script>`)
-    expect(html).not.toContain(" src=")
-    expect(html).toContain("opencode-color-scheme")
-  })
-
-  test("recognizes startup milestones in colored output", () => {
-    const cases = [
-      ["bunRootScript", "$ bun --cwd packages/desktop dev"],
-      ["bunDesktopScript", "$ bun ./scripts/dev.ts"],
-      ["desktopPrepared", "Copied dev icons from"],
-      ["mainBundleReady", "electron main process built successfully"],
-      ["preloadBundleReady", "electron preload scripts built successfully"],
-      ["rendererDevServerReady", "dev server running for the electron renderer process at:"],
-      ["electronSpawnStarted", "starting electron app..."],
-      ["debugEndpointReady", "DevTools listening on ws://"],
-      ["electronStarted", "app starting"],
-      ["serviceEnsureStarted", "starting v2 background service"],
-      ["serviceSpawnRequested", "v2 CLI background service starting"],
-      ["serviceReady", "v2 CLI background service ready"],
-      ["backgroundLoadingReady", "loading task finished"],
-      ["rendererViteConnected", "[vite] connected."],
-      ["rendererInitializationStarted", "awaiting server ready"],
-      ["rendererInitializationReady", "server ready"],
-      ["windowVisible", "main window visible"],
-    ] as const
-    cases.forEach(([milestone, line]) => {
-      expect(milestoneForLine(`\u001b[32m${line}\u001b[39m`)).toBe(milestone)
-    })
-    expect(milestoneForLine("12:30:00.000 › v2 CLI background service ready {")).toBe("serviceReady")
-    expect(milestoneForLine("unrelated output")).toBeUndefined()
-  })
-
-  test("keeps raw samples and reports median absolute deviation", () => {
-    const samples = [24, 20, 22, 28, 26].map((commandToHomeReadyMs, index) => sample(index + 1, commandToHomeReadyMs))
-    expect(summarizeDesktopStartup(samples).commandToHomeReadyMs).toEqual({
-      min: 20,
-      median: 24,
-      max: 28,
-      medianAbsoluteDeviation: 2,
-    })
-  })
-})
-
-function sample(run: number, commandToHomeReadyMs: number): DesktopStartupSample {
-  const milestonesMs = {
-    bunRootScript: 1,
-    bunDesktopScript: 2,
-    desktopPrepared: 3,
-    mainBundleReady: 4,
-    preloadBundleReady: 5,
-    rendererDevServerReady: 6,
-    electronSpawnStarted: 7,
-    debugEndpointReady: 8,
-    electronStarted: 9,
-    serviceEnsureStarted: 10,
-    serviceSpawnRequested: 11,
-    serviceReady: 12,
-    backgroundLoadingReady: 13,
-    rendererViteConnected: 14,
-    rendererInitializationStarted: 15,
-    rendererInitializationReady: 16,
-    windowVisible: 17,
-    homeReady: commandToHomeReadyMs,
-  }
-  return {
-    run,
-    commandToHomeReadyMs,
-    milestonesMs,
-    phasesMs: {
-      desktopPreparation: 3,
-      viteMainBundle: 1,
-      vitePreloadBundle: 1,
-      rendererServerStartup: 1,
-      electronStartup: 2,
-      serviceSpawnWait: 1,
-      serviceProcessStartup: 1,
-      rendererStartup: commandToHomeReadyMs - 14,
-      visibleWindowToHome: commandToHomeReadyMs - 17,
-    },
-    service: { version: "2.0.0-local-test", url: "http://127.0.0.1:3000", pid: run },
-  }
-}
@@ -36,9 +36,6 @@ test("preserves the draft when a populated command menu triggers a built-in", as
  await page.goto(`/server/${base64Encode(server)}/session/${sessionID}`)
  const composer = page.locator('[data-component="prompt-input-v2"]')
  const input = composer.locator('[data-component="prompt-input"]')
-  await expect.poll(() => input.evaluate((element) => getComputedStyle(element, "::before").content)).toBe(
-    `"${String.fromCodePoint(0x200b)}"`,
-  )
  await expectAppVisible(composer)

  await input.fill("keep me")
@@ -19,7 +19,7 @@ test("session settings use the remote server context", async ({ page }) => {
  await configureServers(page)

  await page.goto(`/server/${base64Encode(serverB)}/session/${sessionB.id}`)
-  await expect(page.getByRole("heading", { name: sessionB.title, exact: true })).toBeVisible()
+  await expect(page.getByText(sessionB.title).first()).toBeVisible()
  await page.keyboard.press("Control+,")

  const dialog = page.locator(".settings-v2-dialog")
@@ -61,7 +61,7 @@ test("auto-accept responds for an unfocused server session", async ({ page }) =>

  const hrefB = `/server/${base64Encode(serverB)}/session/${sessionB.id}`
  await page.goto(`/server/${base64Encode(serverA)}/session/${sessionA.id}`)
-  await expect(page.getByRole("heading", { name: sessionA.title, exact: true })).toBeVisible()
+  await expect(page.getByText(sessionA.title).first()).toBeVisible()
  await page.keyboard.press("Control+,")
  const autoAccept = page.locator(".settings-v2-dialog").locator('[data-action="settings-auto-accept-permissions"]')
  await autoAccept.locator('[data-slot="switch-control"]').click()
@@ -78,7 +78,7 @@ test("auto-accept responds for an unfocused server session", async ({ page }) =>

  await page.locator(`[data-titlebar-tab-slot]:has(a[href="${hrefB}"])`).click()
  await expect(page).toHaveURL(new RegExp(`${hrefB.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}$`))
-  await expect(page.getByRole("heading", { name: sessionB.title, exact: true })).toBeVisible()
+  await expect(page.getByText(sessionB.title).first()).toBeVisible()
  await transport.waitForConnection()

  await transport.send({
@@ -208,7 +208,7 @@ async function mockServers(page: Page, permissionRequests: string[], permissionR
      return json(route, [
        {
          id: remote ? sessionB.projectID : "project-server-a",
-          canonical: directory,
+          worktree: directory,
          vcs: "git",
          time: { created: 1, updated: 1 },
          sandboxes: [],
@@ -216,7 +216,7 @@ async function mockServers(page: Page, permissionRequests: string[], permissionR
      ])
    }
    if (url.pathname === "/api/project/current")
-      return json(route, { id: remote ? sessionB.projectID : "project-server-a", directory, canonical: directory })
+      return json(route, { id: remote ? sessionB.projectID : "project-server-a", directory })
    if (url.pathname === "/api/session")
      return json(route, { data: sessions.map((session) => currentSession(session)), cursor: {} })
    if (url.pathname === "/api/session/active") return json(route, { data: {} })
@@ -237,7 +237,7 @@ function session(id: string, directory: string, title: string) {
    id,
    slug: id,
    projectID: `project-${id}`,
-    location: { directory },
+    directory,
    title,
    version: "dev",
    time: { created: 1, updated: 1 },
@@ -5,7 +5,6 @@
  "type": "module",
  "exports": {
    ".": "./src/index.ts",
-    "./desktop": "./src/desktop.ts",
    "./desktop-menu": "./src/desktop-menu.ts",
    "./i18n/desktop-native": "./src/i18n/desktop-native.ts",
    "./updater": "./src/updater.ts",
@@ -29,15 +28,14 @@
    "test:e2e:ui": "playwright test --ui",
    "test:e2e:report": "playwright show-report e2e/playwright-report",
    "test:stability": "bun test ./e2e/performance/unit/visual-stability.test.ts && playwright test --config e2e/performance/timeline-stability/playwright.config.ts",
-    "test:bench": "bun test ./e2e/performance/unit && playwright test --config e2e/performance/playwright.config.ts",
-    "test:bench:devex": "bun test ./e2e/performance/unit/desktop-startup.test.ts && playwright test --config e2e/performance/devex/playwright.config.ts"
+    "test:bench": "bun test ./e2e/performance/unit && playwright test --config e2e/performance/playwright.config.ts"
  },
  "license": "MIT",
  "devDependencies": {
    "@happy-dom/global-registrator": "20.0.11",
    "@playwright/test": "catalog:",
    "@sentry/vite-plugin": "catalog:",
-    "@tailwindcss/vite": "4.3.3",
+    "@tailwindcss/vite": "catalog:",
    "@tsconfig/bun": "1.0.9",
    "@types/bun": "catalog:",
    "@types/luxon": "catalog:",
@@ -46,9 +44,9 @@
    "happy-dom": "20.11.1",
    "tw-animate-css": "1.4.0",
    "typescript": "catalog:",
-    "vite": "8.2.1",
+    "vite": "catalog:",
    "vite-plugin-icons-spritesheet": "3.0.1",
-    "vite-plugin-solid": "2.11.14"
+    "vite-plugin-solid": "catalog:"
  },
  "dependencies": {
    "@corvu/drawer": "catalog:",
@@ -87,6 +85,6 @@
    "solid-js": "catalog:",
    "solid-list": "catalog:",
    "solid-presence": "0.2.0",
-    "tailwindcss": "4.3.3"
+    "tailwindcss": "catalog:"
  }
 }
@@ -1,10 +1,12 @@
 import "@/index.css"
+import * as Sentry from "@sentry/solid"
 import { DialogProvider } from "@opencode-ai/ui/context/dialog"
 import { FileComponentProvider } from "@opencode-ai/ui/context/file"
+import { File } from "@opencode-ai/session-ui/file"
 import { Font } from "@opencode-ai/ui/font"
 import { ThemeProvider } from "@opencode-ai/ui/theme/context"
 import { MetaProvider } from "@solidjs/meta"
-import { type BaseRouterProps, Route, Router, useParams } from "@solidjs/router"
+import { type BaseRouterProps, Navigate, Route, Router, useParams, useSearchParams } from "@solidjs/router"
 import { QueryClient, QueryClientProvider } from "@tanstack/solid-query"
 import {
  type Component,
@@ -18,37 +20,30 @@ import {
 } from "solid-js"
 import { Dynamic } from "solid-js/web"
 import { CommandProvider, useCommand, type CommandOption } from "@/context/command"
+import { CommentsProvider } from "@/context/comments"
+import { FileProvider } from "@/context/file"
 import { GlobalProvider, useGlobal } from "@/context/global"
 import { HighlightsProvider } from "@/context/highlights"
 import { LanguageProvider, UiI18nBridge, type Locale, useLanguage } from "@/context/language"
 import { LayoutProvider } from "@/context/layout"
+import { ModelsProvider } from "@/context/models"
 import { usePlatform } from "@/context/platform"
+import { PromptProvider } from "@/context/prompt"
 import { ServerConnection, ServersProvider } from "@/context/servers"
 import { SettingsProvider } from "@/context/settings"
-import { TabsProvider } from "@/context/tabs"
+import { TabsProvider, useTabs, type DraftTab } from "@/context/tabs"
+import { LocationProvider } from "@/context/location"
 import { WslServersProvider } from "@/wsl/context"
+import { SessionUIProvider } from "@/pages/directory-layout"
 import Layout from "@/pages/layout"
 import { ErrorPage } from "./pages/error"
 import { requireServerKey } from "./utils/session-route"

+import { TargetSessionRouteContent } from "@/pages/session"
 import { Home } from "@/pages/home"
 import { ServerProvider } from "./context/server"

-const File = lazy(() => import("@opencode-ai/session-ui/file").then((module) => ({ default: module.File })))
-const loadDraftRoute = () => Promise.all([import("@/pages/draft-route"), File.preload()]).then(([module]) => module)
-const loadSessionRoute = () => Promise.all([import("@/pages/session"), File.preload()]).then(([module]) => module)
-const DraftRoute = lazy(() => loadDraftRoute().then((module) => ({ default: module.DraftRoute })))
-const TargetSessionRouteContent = lazy(() =>
-  loadSessionRoute().then((module) => ({ default: module.TargetSessionRouteContent })),
-)
-
-export function preloadRoute(url: string) {
-  const pathname = url.split(/[?#]/, 1)[0]
-  if (pathname === "/new-session") return DraftRoute.preload().then(() => undefined)
-  if (/^\/server\/[^/]+\/session\/[^/]+$/.test(pathname))
-    return TargetSessionRouteContent.preload().then(() => undefined)
-  return Promise.resolve()
-}
+const NewSession = lazy(() => import("@/pages/new-session"))

 function TargetServerRoute(props: ParentProps) {
  const params = useParams<{ serverKey: string }>()
@@ -65,6 +60,45 @@ function TargetServerRoute(props: ParentProps) {
  )
 }

+function DraftRoute() {
+  const [search] = useSearchParams<{ draftId?: string }>()
+  const tabs = useTabs()
+  return (
+    <Show
+      when={tabs.store.find((tab): tab is DraftTab => tab.type === "draft" && tab.draftID === search.draftId)}
+      keyed
+      fallback={tabs.ready() && <Navigate href="/" />}
+    >
+      {(draft) => <ResolvedDraftRoute draft={draft} />}
+    </Show>
+  )
+}
+
+function ResolvedDraftRoute(props: { draft: DraftTab }) {
+  const global = useGlobal()
+  const conn = createMemo(() => global.servers.list().find((item) => ServerConnection.key(item) === props.draft.server))
+
+  return (
+    <Show when={`${props.draft.server}\0${props.draft.directory}`} keyed>
+      <Show when={conn()} keyed>
+        {(conn) => (
+          <ServerProvider conn={conn}>
+            <ModelsProvider directory={props.draft.directory}>
+              <LocationProvider directory={props.draft.directory}>
+                <SessionUIProvider directory={props.draft.directory} server={props.draft.server}>
+                  <DraftProviders>
+                    <NewSession draftId={props.draft.draftID} />
+                  </DraftProviders>
+                </SessionUIProvider>
+              </LocationProvider>
+            </ModelsProvider>
+          </ServerProvider>
+        )}
+      </Show>
+    </Show>
+  )
+}
+
 declare global {
  interface Window {
    __OPENCODE__?: {
@@ -133,11 +167,22 @@ function AppLayout(props: ParentProps) {
  )
 }

+// The draft page only renders the prompt composer, so it drops TerminalProvider.
+// FileProvider and CommentsProvider stay because PromptInput uses file search and comment context.
+function DraftProviders(props: ParentProps) {
+  return (
+    <FileProvider>
+      <PromptProvider>
+        <CommentsProvider>{props.children}</CommentsProvider>
+      </PromptProvider>
+    </FileProvider>
+  )
+}
+
 export function AppBaseProviders(
  props: ParentProps<{
    locale?: Locale
    onNativeTranslations?: Parameters<typeof LanguageProvider>[0]["onNativeTranslations"]
-    onThemeApplied?: () => void
  }>,
 ) {
  return (
@@ -146,14 +191,13 @@ export function AppBaseProviders(
      <ThemeProvider
        onThemeApplied={(_, mode, scheme) => {
          void window.api?.setTitlebar?.({ mode, scheme })
-          props.onThemeApplied?.()
        }}
      >
        <LanguageProvider locale={props.locale} onNativeTranslations={props.onNativeTranslations}>
          <UiI18nBridge>
            <ErrorBoundary
              fallback={(error) => {
-                void import("@sentry/solid").then(({ captureException }) => captureException(error))
+                Sentry.captureException(error)
                return <ErrorPage error={error} />
              }}
            >
@@ -241,11 +241,7 @@ export function Titlebar(props: { update?: TitlebarUpdate; debugTools?: { visibl
                    sessionId: activeSession.id,
                  }
                  const model = tabs.stateValue<PromptSession>(sessionTab, "prompt")?.model.current()
-                  void tabs.newDraft(
-                    { server: sessionTab.server, directory: activeSession.location.directory },
-                    "",
-                    model,
-                  )
+                  tabs.newDraft({ server: sessionTab.server, directory: activeSession.location.directory }, "", model)
                  return
                }
                case "draft": {
@@ -253,7 +249,7 @@ export function Titlebar(props: { update?: TitlebarUpdate; debugTools?: { visibl
                  if (activeTab?.type !== "draft") return

                  const model = tabs.stateValue<PromptSession>(activeTab, "prompt")?.model.current()
-                  void tabs.newDraft({ server: activeTab.server, directory: activeTab.directory }, "", model)
+                  tabs.newDraft({ server: activeTab.server, directory: activeTab.directory }, "", model)
                  return
                }
                case "home": {
@@ -267,7 +263,7 @@ export function Titlebar(props: { update?: TitlebarUpdate; debugTools?: { visibl
                    projects?.list().find((item) => item.worktree === projects.last()) ??
                    projects?.list()[0]
                  if (conn && project) {
-                    void tabs.newDraft({ server: ServerConnection.key(conn), directory: project.worktree }, "")
+                    tabs.newDraft({ server: ServerConnection.key(conn), directory: project.worktree }, "")
                    return
                  }
                }
@@ -471,14 +467,11 @@ function ChannelIndicator(props: { debugTools?: { visible: boolean; toggle: () =
    )
  }

-  const label = channel && ["local", "beta", "dev"].includes(channel) ? channel.toUpperCase() : undefined
  return (
-    <Show when={label}>
-      {(value) => (
-        <div class="bg-icon-interactive-base text-[#FFF] font-medium px-2 rounded-sm uppercase font-mono">
-          {value()}
-        </div>
-      )}
+    <Show when={["local", "beta", "dev"].includes(channel)}>
+      <div class="bg-icon-interactive-base text-[#FFF] font-medium px-2 rounded-sm uppercase font-mono">
+        {channel.toUpperCase()}
+      </div>
    </Show>
  )
 }
@@ -1,9 +0,0 @@
-export { AppBaseProviders, AppInterface, preloadRoute } from "./app"
-export { ACCEPTED_FILE_EXTENSIONS } from "./constants/file-picker"
-export { useCommand } from "./context/command"
-export { loadLocaleDict, normalizeLocale, type Locale, useLanguage } from "./context/language"
-export { type Platform, PlatformProvider } from "./context/platform"
-export { ServerConnection, useServers } from "./context/servers"
-export { useTabs } from "./context/tabs"
-export { createDraftStore } from "./utils/draft-store"
-export { useWslServers } from "./wsl/context"
@@ -1,4 +1,4 @@
-export { AppBaseProviders, AppInterface, preloadRoute } from "./app"
+export { AppBaseProviders, AppInterface } from "./app"
 export { useLayout } from "./context/layout"
 export { useServerSDK } from "./context/server-sdk"
 export { useServers as useServers } from "./context/servers"
@@ -1,64 +0,0 @@
-import { Navigate, useSearchParams } from "@solidjs/router"
-import { createMemo, Show, type ParentProps } from "solid-js"
-import { CommentsProvider } from "@/context/comments"
-import { FileProvider } from "@/context/file"
-import { useGlobal } from "@/context/global"
-import { LocationProvider } from "@/context/location"
-import { ModelsProvider } from "@/context/models"
-import { PromptProvider } from "@/context/prompt"
-import { ServerProvider } from "@/context/server"
-import { ServerConnection } from "@/context/servers"
-import { useTabs, type DraftTab } from "@/context/tabs"
-import { SessionUIProvider } from "@/pages/directory-layout"
-import NewSession from "@/pages/new-session"
-
-export function DraftRoute() {
-  const [search] = useSearchParams<{ draftId?: string }>()
-  const tabs = useTabs()
-  return (
-    <Show
-      when={tabs.store.find((tab): tab is DraftTab => tab.type === "draft" && tab.draftID === search.draftId)}
-      keyed
-      fallback={tabs.ready() && <Navigate href="/" />}
-    >
-      {(draft) => <ResolvedDraftRoute draft={draft} />}
-    </Show>
-  )
-}
-
-function ResolvedDraftRoute(props: { draft: DraftTab }) {
-  const global = useGlobal()
-  const conn = createMemo(() => global.servers.list().find((item) => ServerConnection.key(item) === props.draft.server))
-
-  return (
-    <Show when={`${props.draft.server}\0${props.draft.directory}`} keyed>
-      <Show when={conn()} keyed>
-        {(conn) => (
-          <ServerProvider conn={conn}>
-            <ModelsProvider directory={props.draft.directory}>
-              <LocationProvider directory={props.draft.directory}>
-                <SessionUIProvider directory={props.draft.directory} server={props.draft.server}>
-                  <DraftProviders>
-                    <NewSession draftId={props.draft.draftID} />
-                  </DraftProviders>
-                </SessionUIProvider>
-              </LocationProvider>
-            </ModelsProvider>
-          </ServerProvider>
-        )}
-      </Show>
-    </Show>
-  )
-}
-
-// The draft page only renders the prompt composer, so it drops TerminalProvider.
-// FileProvider and CommentsProvider stay because PromptInput uses file search and comment context.
-function DraftProviders(props: ParentProps) {
-  return (
-    <FileProvider>
-      <PromptProvider>
-        <CommentsProvider>{props.children}</CommentsProvider>
-      </PromptProvider>
-    </FileProvider>
-  )
-}
@@ -1,8 +1,10 @@
 import { useDirectoryPicker } from "@/components/directory-picker"
 import { useServerActionsController } from "@/components/server/server-management-controller"
 import { useSettingsCommand } from "@/components/settings-dialog"
+import { DialogServerV2 } from "@/components/settings-v2/dialog-server-v2"
 import { type LocalProject } from "@/context/layout"
 import { useLanguage } from "@/context/language"
+import { useNotification } from "@/context/notification"
 import { usePlatform } from "@/context/platform"
 import { ServerConnection } from "@/context/servers"
 import { closeHomeProject, errorMessage, homeProjectDirectories } from "@/pages/layout/helpers"
@@ -61,11 +63,7 @@ export function createHomeProjectsController(home: HomeController) {
        serverManagement.defaults.set(conn ? ServerConnection.key(conn) : null),
      canRemove: (conn: ServerConnection.Any) => serverManagement.connection.canRemove(ServerConnection.key(conn)),
      remove: (conn: ServerConnection.Any) => serverManagement.connection.remove(ServerConnection.key(conn)),
-      edit: (conn: ServerConnection.Http) => {
-        void import("@/components/settings-v2/dialog-server-v2").then(({ DialogServerV2 }) => {
-          void dialog.show(() => <DialogServerV2 mode="edit" server={conn} />)
-        })
-      },
+      edit: (conn: ServerConnection.Http) => dialog.show(() => <DialogServerV2 mode="edit" server={conn} />),
      focus: home.selection.focusServer,
    },
    project: {
@@ -1,14 +1,13 @@
-import { lazy, Show, Suspense, type ParentProps } from "solid-js"
+import { Show, Suspense, type ParentProps } from "solid-js"
 import { createStore } from "solid-js/store"
+import { DebugBar } from "@/components/debug-bar"
 import { Titlebar, type TitlebarUpdate } from "@/components/titlebar"
 import { usePlatform } from "@/context/platform"
 import { ToastRegion } from "@/utils/toast"

-const DebugBar = lazy(() => import("@/components/debug-bar").then((module) => ({ default: module.DebugBar })))
-
 export default function Layout(props: ParentProps) {
  const platform = usePlatform()
-  const [state, setState] = createStore({ debugTools: false })
+  const [state, setState] = createStore({ debugTools: true })

  const update: TitlebarUpdate = {
    get version() {
@@ -42,9 +41,7 @@ export default function Layout(props: ParentProps) {
        <Suspense>{props.children}</Suspense>
      </main>
      <Show when={import.meta.env.DEV && state.debugTools}>
-        <Suspense>
-          <DebugBar inline />
-        </Suspense>
+        <DebugBar inline />
      </Show>
      <ToastRegion />
    </div>
@@ -39,20 +39,14 @@ describe("new session workspace selection", () => {
    expect(normalizeNewSessionWorktree("main", "C:\\Repo\\", "c:/repo")).toBe("main")
  })

-  test("resolves the branch from the active location", () => {
+  test("falls back to the local branch for main, create, and unknown worktrees", () => {
    const branch = (worktree: string) => (worktree === "/project/feature" ? "feature" : undefined)
-    expect(resolveNewSessionBranch({ worktree: "main", directory: "/project/feature", worktreeBranch: branch })).toBe(
+    expect(resolveNewSessionBranch({ worktree: "main", local: "dev", worktreeBranch: branch })).toBe("dev")
+    expect(resolveNewSessionBranch({ worktree: "create", local: "dev", worktreeBranch: branch })).toBe("dev")
+    expect(resolveNewSessionBranch({ worktree: "/project/feature", local: "dev", worktreeBranch: branch })).toBe(
      "feature",
    )
-    expect(
-      resolveNewSessionBranch({ worktree: "create", directory: "/project/feature", worktreeBranch: branch }),
-    ).toBe("feature")
-    expect(
-      resolveNewSessionBranch({ worktree: "/project/feature", directory: "/project", worktreeBranch: branch }),
-    ).toBe("feature")
-    expect(resolveNewSessionBranch({ worktree: "/missing", directory: "/project/feature", worktreeBranch: branch })).toBe(
-      undefined,
-    )
+    expect(resolveNewSessionBranch({ worktree: "/missing", local: "dev", worktreeBranch: branch })).toBe("dev")
  })

  test("uses location VCS state when the project inventory is stale", () => {
@@ -32,11 +32,11 @@ export function normalizeNewSessionWorktree(value: string, directory: string, pr

 export function resolveNewSessionBranch(input: {
  worktree: string
-  directory: string
+  local?: string
  worktreeBranch: (worktree: string) => string | undefined
 }) {
-  const directory = input.worktree === "main" || input.worktree === "create" ? input.directory : input.worktree
-  return input.worktreeBranch(directory)
+  if (input.worktree === "main" || input.worktree === "create") return input.local
+  return input.worktreeBranch(input.worktree) ?? input.local
 }

 export function resolveNewSessionGit(input: { projectVcs?: string; branch?: string }) {
@@ -95,10 +95,11 @@ export function createNewSessionWorkspaceController(input: {
    const directories = project ? [project.worktree, ...workspaceDirectories(project)] : [sdk().directory]
    directories.forEach((directory) => void data.location.vcs.sync({ directory }).catch(() => undefined))
  })
+  const localBranch = createMemo(() => data.location.vcs.info({ directory: projectRoot() })?.branch.current)
  const branch = createMemo(() =>
    resolveNewSessionBranch({
      worktree: value(),
-      directory: sdk().directory,
+      local: localBranch(),
      worktreeBranch: (worktree) => data.location.vcs.info({ directory: worktree })?.branch.current,
    }),
  )
@@ -3,56 +3,22 @@ import { beforeEach, describe, expect, test } from "bun:test"
 const src = await Bun.file(new URL("../public/oc-theme-preload.js", import.meta.url)).text()

 const run = () => Function(src)()
-const setSystemDark = (matches: boolean) =>
-  Object.defineProperty(window, "matchMedia", {
-    value: () => ({ matches }) as MediaQueryList,
-    configurable: true,
-  })

 beforeEach(() => {
  document.head.innerHTML = ""
  document.documentElement.removeAttribute("data-theme")
  document.documentElement.removeAttribute("data-color-scheme")
-  document.documentElement.style.removeProperty("background-color")
  localStorage.clear()
-  setSystemDark(false)
+  Object.defineProperty(window, "matchMedia", {
+    value: () =>
+      ({
+        matches: false,
+      }) as MediaQueryList,
+    configurable: true,
+  })
 })

 describe("theme preload", () => {
-  test("uses default theme and system light mode when settings are absent", () => {
-    run()
-
-    expect(document.documentElement.dataset.theme).toBe("oc-2")
-    expect(document.documentElement.dataset.colorScheme).toBe("light")
-    expect(document.documentElement.style.backgroundColor).toBe("#fafafa")
-  })
-
-  test("restores explicit dark mode on a light system", () => {
-    localStorage.setItem("opencode-color-scheme", "dark")
-    run()
-
-    expect(document.documentElement.dataset.colorScheme).toBe("dark")
-    expect(document.documentElement.style.backgroundColor).toBe("#080808")
-  })
-
-  test("restores explicit light mode on a dark system", () => {
-    setSystemDark(true)
-    localStorage.setItem("opencode-color-scheme", "light")
-    run()
-
-    expect(document.documentElement.dataset.colorScheme).toBe("light")
-    expect(document.documentElement.style.backgroundColor).toBe("#fafafa")
-  })
-
-  test("resolves persisted system mode before paint", () => {
-    setSystemDark(true)
-    localStorage.setItem("opencode-color-scheme", "system")
-    run()
-
-    expect(document.documentElement.dataset.colorScheme).toBe("dark")
-    expect(document.documentElement.style.backgroundColor).toBe("#080808")
-  })
-
  test("keeps cached css for non-default themes", () => {
    localStorage.setItem("opencode-theme-id", "nightowl")
    localStorage.setItem("opencode-theme-css-light", "--background-base:#fff;")
@@ -62,15 +28,4 @@ describe("theme preload", () => {
    expect(document.documentElement.dataset.theme).toBe("nightowl")
    expect(document.getElementById("oc-theme-preload")?.textContent).toContain("--background-base:#fff;")
  })
-
-  test("restores the cached variant for a persisted custom dark theme", () => {
-    localStorage.setItem("opencode-theme-id", "nightowl")
-    localStorage.setItem("opencode-color-scheme", "dark")
-    localStorage.setItem("opencode-theme-css-dark", "--background-base:#010203;")
-    run()
-
-    expect(document.documentElement.dataset.theme).toBe("nightowl")
-    expect(document.documentElement.dataset.colorScheme).toBe("dark")
-    expect(document.getElementById("oc-theme-preload")?.textContent).toContain("--background-base:#010203;")
-  })
 })
@@ -1,6 +1,6 @@
 import { sentryVitePlugin } from "@sentry/vite-plugin"
 import { defineConfig } from "vite"
-import desktopPlugin from "./vite.js"
+import desktopPlugin from "./vite"

 const sentry =
  process.env.SENTRY_AUTH_TOKEN && process.env.SENTRY_ORG && process.env.SENTRY_PROJECT
@@ -4,18 +4,6 @@ import tailwindcss from "@tailwindcss/vite"
 import { fileURLToPath } from "url"

 const theme = fileURLToPath(new URL("./public/oc-theme-preload.js", import.meta.url))
-const themeScript = readFileSync(theme, "utf8")
-const tailwind = tailwindcss()
-const tailwindGenerate = tailwind.find((plugin) => plugin.name === "@tailwindcss/vite:generate:serve")
-const tailwindHotUpdate = tailwindGenerate?.hotUpdate
-
-// Tailwind 4.3.3 expects a server that Vite's bundled dev hook does not provide.
-if (tailwindGenerate && typeof tailwindHotUpdate === "function") {
-  tailwindGenerate.hotUpdate = function (context) {
-    if (!context.server) return
-    return tailwindHotUpdate.call(this, context)
-  }
-}

 const channel = (() => {
  const raw = process.env.OPENCODE_CHANNEL
@@ -52,18 +40,13 @@ export default [
  },
  {
    name: "opencode-desktop:theme-preload",
-    transformIndexHtml: {
-      order: "pre",
-      handler: inlineThemePreload,
+    transformIndexHtml(html) {
+      return html.replace(
+        '<script id="oc-theme-preload-script" src="/oc-theme-preload.js"></script>',
+        `<script id="oc-theme-preload-script">${readFileSync(theme, "utf8")}</script>`,
+      )
    },
  },
-  ...tailwind,
+  tailwindcss(),
  solidPlugin(),
 ]
-
-export function inlineThemePreload(html) {
-  return html.replace(
-    /<script id="oc-theme-preload-script" src="(?:\.\/|\/)oc-theme-preload\.js"><\/script>/,
-    `<script id="oc-theme-preload-script">${themeScript}</script>`,
-  )
-}
@@ -187,28 +187,6 @@ const Root = Spec.make(typeof OPENCODE_CLI_NAME === "string" ? OPENCODE_CLI_NAME
      description: "List all available models",
      params: ServerParams,
    }),
-    Spec.make("stats", {
-      description: "Show shareable usage statistics",
-      params: {
-        ...ServerParams,
-        days: Flag.integer("days").pipe(Flag.withDescription("Show the last N days; 0 means today"), Flag.optional),
-        year: Flag.integer("year").pipe(Flag.withDescription("Show a calendar year"), Flag.optional),
-        all: Flag.boolean("all").pipe(Flag.withDescription("Show lifetime statistics"), Flag.withDefault(false)),
-        project: Flag.string("project").pipe(
-          Flag.withDescription('Filter by project ID, or use "." for the current project'),
-          Flag.optional,
-        ),
-        models: Flag.boolean("models").pipe(Flag.withDescription("Show model usage"), Flag.withDefault(false)),
-        tools: Flag.boolean("tools").pipe(Flag.withDescription("Show tool reliability"), Flag.withDefault(false)),
-        cost: Flag.boolean("cost").pipe(Flag.withDescription("Show cost and token details"), Flag.withDefault(false)),
-        full: Flag.boolean("full").pipe(Flag.withDescription("Show every detailed section"), Flag.withDefault(false)),
-        limit: Flag.integer("limit").pipe(
-          Flag.withDescription("Number of rows in detailed sections"),
-          Flag.withDefault(5),
-        ),
-        json: Flag.boolean("json").pipe(Flag.withDescription("Output statistics as JSON"), Flag.withDefault(false)),
-      },
-    }),
    Spec.make("export", {
      description: "Export session data as JSON",
      params: {
@@ -1,322 +0,0 @@
-import { OpenCode, type SessionStatsInfo } from "@opencode-ai/client"
-import { Service } from "@opencode-ai/client/effect/service"
-import { Effect, Option } from "effect"
-import { EOL } from "node:os"
-import { Commands } from "../commands"
-import { Runtime } from "../../framework/runtime"
-import { ServerConnection } from "../../services/server-connection"
-
-export default Runtime.handler(
-  Commands.commands.stats,
-  Effect.fn("cli.stats")(function* (input) {
-    const days = Option.getOrUndefined(input.days)
-    const year = Option.getOrUndefined(input.year)
-    const project = Option.getOrUndefined(input.project)
-    if ([days !== undefined, year !== undefined, input.all].filter(Boolean).length > 1)
-      yield* Effect.fail(new Error("--days, --year, and --all cannot be combined"))
-    if (days !== undefined && days < 0) yield* Effect.fail(new Error("--days must be zero or greater"))
-    if (year !== undefined && (year < 1970 || year > 9_999))
-      yield* Effect.fail(new Error("--year must be between 1970 and 9999"))
-    if (input.limit < 1) yield* Effect.fail(new Error("--limit must be greater than zero"))
-
-    const server = yield* ServerConnection.resolve({
-      server: Option.getOrUndefined(input.server),
-      standalone: input.standalone,
-    })
-    const client = OpenCode.make({ baseUrl: server.endpoint.url, headers: Service.headers(server.endpoint) })
-    const range = statsRange({ days, year, all: input.all })
-    const projectID =
-      project === "."
-        ? yield* Effect.promise(() =>
-            client.location.get({ location: { directory: process.cwd() } }).then((location) => location.project.id),
-          )
-        : project
-    const stats = yield* Effect.promise(() =>
-      client.session.stats({
-        from: range.from,
-        to: range.to,
-        project: projectID,
-        timezone: Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC",
-      }),
-    )
-    const output = input.json
-      ? JSON.stringify(stats, null, 2)
-      : renderStats(stats, {
-          label: range.label,
-          models: input.models || input.full,
-          tools: input.tools || input.full,
-          cost: input.cost || input.full,
-          limit: input.limit,
-          color: process.stdout.isTTY && process.env.NO_COLOR === undefined,
-        })
-    process.stdout.write(output + EOL)
-  }),
-)
-
-type RenderOptions = {
-  label: string
-  models: boolean
-  tools: boolean
-  cost: boolean
-  limit: number
-  color: boolean
-}
-
-const colors = terminalPalette()
-
-export function renderStats(stats: SessionStatsInfo, options: RenderOptions) {
-  const totalTokens = tokenTotal(stats.tokens)
-  const terminalTools = stats.tools.succeeded + stats.tools.failed
-  const toolRate = terminalTools === 0 ? undefined : (stats.tools.succeeded / terminalTools) * 100
-  const primary = `1;${colors.primary}`
-  const sessionLine = [
-    metricCount(stats.sessions, "session", options.color),
-    stats.subagents > 0 ? metricCount(stats.subagents, "subagent", options.color) : undefined,
-  ]
-    .filter((value) => value !== undefined)
-    .join(" · ")
-  const toolSummary =
-    toolRate === undefined ? "no tool calls" : `${style(formatPercent(toolRate), primary, options.color)} tools`
-  const details = options.models || options.tools || options.cost
-  const lines = details
-    ? []
-    : [
-        `${style("opencode stats", primary, options.color)} ${style(`· ${options.label}`, "2", options.color)}`,
-        "",
-        ...renderActivity(stats.activity, stats.range.from, stats.range.to, options.color),
-        "",
-        sessionLine,
-        `${metricCount(stats.prompts, "prompt", options.color)} · ${metricCount(stats.steps, "step", options.color)} · ${metricCount(totalTokens, "token", options.color)}`,
-        `${toolSummary} · ${metricCount(stats.activeDays, "active day", options.color)} · best streak ${style(stats.streak.toString(), primary, options.color)} day${stats.streak === 1 ? "" : "s"}`,
-        "",
-        style("opencode.ai", "2", options.color),
-      ]
-
-  if (options.cost) lines.push(...renderCost(stats))
-  if (options.models) lines.push(...(lines.length > 0 ? [""] : []), ...renderModels(stats, options.limit))
-  if (options.tools) lines.push(...(lines.length > 0 ? [""] : []), ...renderTools(stats, options.limit))
-  return lines.join(EOL)
-}
-
-function statsRange(input: { days?: number; year?: number; all: boolean }) {
-  const now = new Date()
-  const to = now.getTime() + 1
-  if (input.all) return { from: undefined, to, label: "all time" }
-  if (input.days !== undefined) {
-    const from = new Date(now.getFullYear(), now.getMonth(), now.getDate())
-    from.setDate(from.getDate() - Math.max(0, input.days - 1))
-    return {
-      from: from.getTime(),
-      to,
-      label: input.days === 0 || input.days === 1 ? "today" : `last ${input.days} days`,
-    }
-  }
-  const year = input.year ?? now.getFullYear()
-  return {
-    from: new Date(year, 0, 1).getTime(),
-    to: year === now.getFullYear() ? to : new Date(year + 1, 0, 1).getTime(),
-    label: year === now.getFullYear() ? `${year} so far` : year.toString(),
-  }
-}
-
-function renderActivity(activity: SessionStatsInfo["activity"], from: number, to: number, color: boolean) {
-  const values = new Map(activity.map((day) => [day.date, day.steps]))
-  const end = new Date(to - 1)
-  end.setHours(12, 0, 0, 0)
-  end.setDate(end.getDate() + (7 - mondayIndex(end) - 1))
-  const start = new Date(from)
-  start.setHours(12, 0, 0, 0)
-  start.setDate(start.getDate() - mondayIndex(start))
-  const latest = new Date(end)
-  latest.setDate(latest.getDate() - 52 * 7)
-  if (start < latest) start.setTime(latest.getTime())
-
-  const active = [...values.values()].filter((value) => value > 0)
-  const levels = [...new Set(active)].sort((a, b) => a - b)
-  const weekStarts = Array.from({ length: Math.floor((dateOrdinal(end) - dateOrdinal(start)) / 7) + 1 }, (_, week) => {
-    const date = new Date(start)
-    date.setDate(date.getDate() + week * 7)
-    return date
-  })
-  const weeks = weekStarts.map((week) =>
-    Array.from({ length: 7 }, (_, day) => {
-      const date = new Date(week)
-      date.setDate(date.getDate() + day)
-      return activityGlyph(values.get(dateKey(date)) ?? 0, levels, color)
-    }),
-  )
-  const weekdays = ["Mo", "Tu", "We", "Th", "Fr", "Sa", "Su"]
-  return [
-    style("activity", `1;${colors.primary}`, color),
-    `   ${style(monthLabels(weekStarts), "2", color)}`,
-    ...weekdays.flatMap((label, day) => [
-      `${style(label, "2", color)} ${weeks.map((week) => week[day]).join("")}`,
-      ...(day === weekdays.length - 1 ? [] : [""]),
-    ]),
-    "",
-    `   ${style("less", "2", color)} ${[0, 1, 2, 3, 4].map((level) => paintActivity(level, color)).join("")} ${style("more", "2", color)}`,
-  ]
-}
-
-function renderCost(stats: SessionStatsInfo) {
-  const input = stats.tokens.input + stats.tokens.cache.read
-  const cached = input === 0 ? 0 : (stats.tokens.cache.read / input) * 100
-  return [
-    "COST & TOKENS",
-    row("cost", `$${stats.cost.toFixed(2)}`),
-    row("input", formatNumber(stats.tokens.input)),
-    row("output", formatNumber(stats.tokens.output)),
-    row("reasoning", formatNumber(stats.tokens.reasoning)),
-    row("cache read", formatNumber(stats.tokens.cache.read)),
-    row("cache write", formatNumber(stats.tokens.cache.write)),
-    row("cached input", formatPercent(cached)),
-  ]
-}
-
-function renderModels(stats: SessionStatsInfo, limit: number) {
-  if (stats.models.length === 0) return ["MODELS", "  no model usage"]
-  return [
-    "MODELS",
-    tableHeader("model", "tokens", "steps", "cost"),
-    ...stats.models
-      .slice(0, limit)
-      .map((item) =>
-        tableRow(
-          `${item.model.providerID}/${item.model.id}${item.model.variant ? `#${item.model.variant}` : ""}`,
-          formatNumber(tokenTotal(item.tokens)),
-          formatNumber(item.steps),
-          `$${item.cost.toFixed(2)}`,
-        ),
-      ),
-  ]
-}
-
-function renderTools(stats: SessionStatsInfo, limit: number) {
-  if (stats.toolUsage.length === 0) return ["TOOL RELIABILITY", "  no tool calls"]
-  return [
-    "TOOL RELIABILITY",
-    tableHeader("tool", "calls", "error", "p50"),
-    ...stats.toolUsage.slice(0, limit).map((tool) => {
-      const terminal = tool.succeeded + tool.failed
-      return tableRow(
-        tool.name,
-        formatNumber(tool.calls),
-        terminal === 0 ? "-" : formatPercent((tool.failed / terminal) * 100),
-        tool.durationP50 === undefined ? "-" : formatDuration(tool.durationP50),
-      )
-    }),
-    "",
-    `${formatNumber(stats.tools.succeeded + stats.tools.failed)} terminal calls · ${formatNumber(stats.tools.unfinished)} unfinished`,
-  ]
-}
-
-function row(label: string, value: string) {
-  return `  ${label.padEnd(20)}${value}`
-}
-
-function tableHeader(label: string, second: string, third: string, fourth: string) {
-  return tableRow(label, second, third, fourth)
-}
-
-function tableRow(label: string, second: string, third: string, fourth: string) {
-  return `${truncate(label, 34).padEnd(34)}${second.padStart(10)}${third.padStart(12)}${fourth.padStart(12)}`
-}
-
-function truncate(value: string, width: number) {
-  return value.length <= width ? value : value.slice(0, width - 1) + "…"
-}
-
-function tokenTotal(tokens: SessionStatsInfo["tokens"]) {
-  return tokens.input + tokens.output + tokens.reasoning + tokens.cache.read + tokens.cache.write
-}
-
-function formatNumber(value: number) {
-  if (value >= 1_000_000_000) return `${trimDecimal(value / 1_000_000_000)}b`
-  if (value >= 1_000_000) return `${trimDecimal(value / 1_000_000)}m`
-  if (value >= 1_000) return `${trimDecimal(value / 1_000)}k`
-  return Math.round(value).toLocaleString("en-US")
-}
-
-function trimDecimal(value: number) {
-  return value.toFixed(1).replace(/\.0$/, "")
-}
-
-function formatPercent(value: number) {
-  return `${value.toFixed(value >= 10 ? 1 : 2)}%`
-}
-
-function formatDuration(value: number) {
-  if (value < 1_000) return `${Math.round(value)}ms`
-  return `${trimDecimal(value / 1_000)}s`
-}
-
-function metricCount(value: number, noun: string, color: boolean) {
-  return `${style(formatNumber(value), `1;${colors.primary}`, color)} ${noun}${value === 1 ? "" : "s"}`
-}
-
-function style(value: string, code: string, color: boolean) {
-  return color ? `\x1b[${code}m${value}\x1b[0m` : value
-}
-
-function activityGlyph(value: number, levels: number[], color: boolean) {
-  if (value === 0) return paintActivity(0, color)
-  const index = levels.indexOf(value)
-  const level = Math.max(1, Math.ceil(((index + 1) / levels.length) * 4))
-  return paintActivity(level, color)
-}
-
-function paintActivity(level: number, color: boolean) {
-  const glyph = ["·", "░", "▒", "▓", "█"][level]
-  if (!color) return glyph
-  if (level === 0) return `\x1b[2m${glyph}\x1b[22m`
-  return `\x1b[${colors.activity[level - 1]}m${glyph}\x1b[39m`
-}
-
-function terminalPalette() {
-  const background = Number(process.env.COLORFGBG?.split(";").at(-1))
-  if (Number.isFinite(background) && background >= 7)
-    return {
-      primary: "38;2;59;125;216",
-      activity: ["38;2;153;169;192", "38;2;122;155;200", "38;2;90;140;208", "38;2;59;125;216"],
-    }
-  return {
-    primary: "38;2;250;178;131",
-    activity: ["38;2;117;99;87", "38;2;161;125;102", "38;2;206;152;116", "38;2;250;178;131"],
-  }
-}
-
-function monthLabels(weeks: Date[]) {
-  const line: string[] = []
-  weeks.reduce((previous, week, index) => {
-    const middle = new Date(week)
-    middle.setDate(middle.getDate() + 3)
-    const month = middle.getMonth()
-    if (month === previous) return previous
-    Intl.DateTimeFormat("en-US", { month: "short" })
-      .format(middle)
-      .split("")
-      .forEach((character, offset) => {
-        line[index + offset] = character
-      })
-    return month
-  }, -1)
-  return Array.from({ length: Math.max(weeks.length, line.length) }, (_, index) => line[index] ?? " ")
-    .join("")
-    .trimEnd()
-}
-
-function mondayIndex(date: Date) {
-  return (date.getDay() + 6) % 7
-}
-
-function dateKey(date: Date) {
-  return [
-    date.getFullYear(),
-    String(date.getMonth() + 1).padStart(2, "0"),
-    String(date.getDate()).padStart(2, "0"),
-  ].join("-")
-}
-
-function dateOrdinal(date: Date) {
-  return Math.floor(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()) / 86_400_000)
-}
@@ -43,7 +43,6 @@ const Handlers = Runtime.handlers(Commands, {
    remove: () => import("./commands/handlers/plugin/remove"),
  },
  models: () => import("./commands/handlers/models"),
-  stats: () => import("./commands/handlers/stats"),
  export: () => import("./commands/handlers/export"),
  import: () => import("./commands/handlers/import"),
  mini: () => import("./commands/handlers/mini"),
@@ -1,74 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import type { SessionStatsInfo } from "@opencode-ai/client"
-import { renderStats } from "../src/commands/handlers/stats"
-
-const stats: SessionStatsInfo = {
-  range: { from: Date.UTC(2026, 0, 1), to: Date.UTC(2026, 0, 8) },
-  sessions: 2,
-  subagents: 1,
-  prompts: 4,
-  steps: 6,
-  tokens: { input: 10_000, output: 2_000, reasoning: 1_000, cache: { read: 5_000, write: 500 } },
-  cost: 12.34,
-  tools: { calls: 10, succeeded: 8, failed: 2, unfinished: 0 },
-  activeDays: 2,
-  streak: 2,
-  activity: [
-    { date: "2026-01-02", steps: 2 },
-    { date: "2026-01-03", steps: 4 },
-  ],
-  models: [
-    {
-      model: { providerID: "anthropic", id: "sonnet" },
-      steps: 6,
-      tokens: { input: 10_000, output: 2_000, reasoning: 1_000, cache: { read: 5_000, write: 500 } },
-      cost: 12.34,
-    },
-  ],
-  toolUsage: [{ name: "private_tool", calls: 10, succeeded: 8, failed: 2, unfinished: 0, durationP50: 250 }],
-}
-
-describe("stats rendering", () => {
-  test("keeps the default card shareable", () => {
-    const output = renderStats(stats, options())
-    expect(output).toContain("opencode stats · 2026 so far")
-    expect(output).toContain("activity")
-    expect(output).toContain("Mo ··")
-    expect(output).toMatch(/Mo .*\n\nTu/)
-    expect(output).toMatch(/Su .*\n\n   less/)
-    expect(output).toContain("less ·░▒▓█ more")
-    expect(output).toContain("2 sessions · 1 subagent")
-    expect(output).toContain("80.0% tools · 2 active days · best streak 2 days")
-    expect(output).not.toContain("private_tool")
-    expect(output).not.toContain("$12.34")
-  })
-
-  test("renders only requested detail tables", () => {
-    const output = renderStats(stats, options({ tools: true, cost: true }))
-    expect(output).toContain("COST & TOKENS")
-    expect(output).toContain("TOOL RELIABILITY")
-    expect(output).toContain("private_tool")
-    expect(output).toContain("tool")
-    expect(output).toContain("calls")
-    expect(output).not.toContain("opencode stats")
-    expect(output).not.toContain("activity")
-  })
-
-  test("uses the OpenCode palette in color mode", () => {
-    const output = renderStats(stats, options({ color: true }))
-    expect(output).toContain("\x1b[1;38;2;")
-    expect(output).not.toContain("38;5;45")
-  })
-})
-
-function options(input: Partial<Parameters<typeof renderStats>[1]> = {}): Parameters<typeof renderStats>[1] {
-  return {
-    label: "2026 so far",
-    models: false,
-    tools: false,
-    cost: false,
-    limit: 5,
-    color: false,
-    ...input,
-  }
-}
@@ -37,7 +37,7 @@
    "@opencode-ai/protocol": "workspace:*"
  },
  "peerDependencies": {
-    "effect": "4.0.0-rc.110",
+    "effect": "4.0.0-beta.107",
    "solid-js": ">=1.9.0"
  },
  "peerDependenciesMeta": {
@@ -10,7 +10,6 @@ import type { Project } from "@opencode-ai/schema/project"
 import type { RelativePath } from "@opencode-ai/schema/schema"
 import type { Brand } from "effect"
 import type { Model } from "@opencode-ai/schema/model"
-import type { DateTime } from "effect"
 import type { SessionMessage } from "@opencode-ai/schema/session-message"
 import type { SessionInbox } from "@opencode-ai/schema/session-inbox"
 import type { PromptInput } from "@opencode-ai/schema/prompt-input"
@@ -112,114 +111,64 @@ export type Endpoint5_0Output = {
 export type SessionListOperation<E = never> = (input?: Endpoint5_0Input) => Effect.Effect<Endpoint5_0Output, E>

 export type Endpoint5_1Input = {
-  readonly from?: number | undefined
-  readonly to?: number | undefined
-  readonly project?: Project.ID | undefined
-  readonly timezone?: string | undefined
-}
-export type Endpoint5_1Output = {
-  readonly range: { readonly from: DateTime.Utc; readonly to: DateTime.Utc }
-  readonly sessions: number
-  readonly subagents: number
-  readonly prompts: number
-  readonly steps: number
-  readonly tokens: {
-    readonly input: number
-    readonly output: number
-    readonly reasoning: number
-    readonly cache: { readonly read: number; readonly write: number }
-  }
-  readonly cost: number & Brand.Brand<"Money.USD">
-  readonly tools: {
-    readonly calls: number
-    readonly succeeded: number
-    readonly failed: number
-    readonly unfinished: number
-  }
-  readonly activeDays: number
-  readonly streak: number
-  readonly activity: ReadonlyArray<{ readonly date: string; readonly steps: number }>
-  readonly models: ReadonlyArray<{
-    readonly model: Model.Ref
-    readonly steps: number
-    readonly tokens: {
-      readonly input: number
-      readonly output: number
-      readonly reasoning: number
-      readonly cache: { readonly read: number; readonly write: number }
-    }
-    readonly cost: number & Brand.Brand<"Money.USD">
-  }>
-  readonly toolUsage: ReadonlyArray<{
-    readonly name: string
-    readonly calls: number
-    readonly succeeded: number
-    readonly failed: number
-    readonly unfinished: number
-    readonly durationP50?: number | undefined
-  }>
-}
-export type SessionStatsOperation<E = never> = (input?: Endpoint5_1Input) => Effect.Effect<Endpoint5_1Output, E>
-
-export type Endpoint5_2Input = {
  readonly id?: Session.ID | undefined
  readonly title?: string | undefined
  readonly agent?: Agent.ID | undefined
  readonly model?: Model.Ref | undefined
  readonly location?: Location.Ref | undefined
 }
-export type Endpoint5_2Output = Session.Info
-export type SessionCreateOperation<E = never> = (input?: Endpoint5_2Input) => Effect.Effect<Endpoint5_2Output, E>
+export type Endpoint5_1Output = Session.Info
+export type SessionCreateOperation<E = never> = (input?: Endpoint5_1Input) => Effect.Effect<Endpoint5_1Output, E>

-export type Endpoint5_3Input = {
+export type Endpoint5_2Input = {
  readonly info: Session.Info
  readonly messages: ReadonlyArray<SessionMessage.Info>
  readonly location?: Location.Ref | undefined
 }
-export type Endpoint5_3Output = Session.Info
-export type SessionImportOperation<E = never> = (input: Endpoint5_3Input) => Effect.Effect<Endpoint5_3Output, E>
+export type Endpoint5_2Output = Session.Info
+export type SessionImportOperation<E = never> = (input: Endpoint5_2Input) => Effect.Effect<Endpoint5_2Output, E>

-export type Endpoint5_4Input = { readonly sessionID: Session.ID; readonly sanitize?: boolean | undefined }
-export type Endpoint5_4Output = { readonly info: Session.Info; readonly messages: ReadonlyArray<SessionMessage.Info> }
-export type SessionExportOperation<E = never> = (input: Endpoint5_4Input) => Effect.Effect<Endpoint5_4Output, E>
+export type Endpoint5_3Input = { readonly sessionID: Session.ID; readonly sanitize?: boolean | undefined }
+export type Endpoint5_3Output = { readonly info: Session.Info; readonly messages: ReadonlyArray<SessionMessage.Info> }
+export type SessionExportOperation<E = never> = (input: Endpoint5_3Input) => Effect.Effect<Endpoint5_3Output, E>

-export type Endpoint5_5Output = { readonly [x: Session.ID]: { readonly type: "running" } }
-export type SessionActiveOperation<E = never> = () => Effect.Effect<Endpoint5_5Output, E>
+export type Endpoint5_4Output = { readonly [x: Session.ID]: { readonly type: "running" } }
+export type SessionActiveOperation<E = never> = () => Effect.Effect<Endpoint5_4Output, E>
+
+export type Endpoint5_5Input = { readonly sessionID: Session.ID }
+export type Endpoint5_5Output = Session.Info
+export type SessionGetOperation<E = never> = (input: Endpoint5_5Input) => Effect.Effect<Endpoint5_5Output, E>

 export type Endpoint5_6Input = { readonly sessionID: Session.ID }
-export type Endpoint5_6Output = Session.Info
-export type SessionGetOperation<E = never> = (input: Endpoint5_6Input) => Effect.Effect<Endpoint5_6Output, E>
+export type Endpoint5_6Output = void
+export type SessionRemoveOperation<E = never> = (input: Endpoint5_6Input) => Effect.Effect<Endpoint5_6Output, E>

-export type Endpoint5_7Input = { readonly sessionID: Session.ID }
-export type Endpoint5_7Output = void
-export type SessionRemoveOperation<E = never> = (input: Endpoint5_7Input) => Effect.Effect<Endpoint5_7Output, E>
+export type Endpoint5_7Input = { readonly sessionID: Session.ID; readonly boundary: Session.ForkRequestBoundary }
+export type Endpoint5_7Output = Session.Info
+export type SessionForkOperation<E = never> = (input: Endpoint5_7Input) => Effect.Effect<Endpoint5_7Output, E>

-export type Endpoint5_8Input = { readonly sessionID: Session.ID; readonly boundary: Session.ForkRequestBoundary }
-export type Endpoint5_8Output = Session.Info
-export type SessionForkOperation<E = never> = (input: Endpoint5_8Input) => Effect.Effect<Endpoint5_8Output, E>
+export type Endpoint5_8Input = { readonly sessionID: Session.ID; readonly agent: Agent.ID }
+export type Endpoint5_8Output = void
+export type SessionSwitchAgentOperation<E = never> = (input: Endpoint5_8Input) => Effect.Effect<Endpoint5_8Output, E>

-export type Endpoint5_9Input = { readonly sessionID: Session.ID; readonly agent: Agent.ID }
+export type Endpoint5_9Input = { readonly sessionID: Session.ID; readonly model: Model.Ref }
 export type Endpoint5_9Output = void
-export type SessionSwitchAgentOperation<E = never> = (input: Endpoint5_9Input) => Effect.Effect<Endpoint5_9Output, E>
+export type SessionSwitchModelOperation<E = never> = (input: Endpoint5_9Input) => Effect.Effect<Endpoint5_9Output, E>

-export type Endpoint5_10Input = { readonly sessionID: Session.ID; readonly model: Model.Ref }
+export type Endpoint5_10Input = { readonly sessionID: Session.ID; readonly title: string }
 export type Endpoint5_10Output = void
-export type SessionSwitchModelOperation<E = never> = (input: Endpoint5_10Input) => Effect.Effect<Endpoint5_10Output, E>
+export type SessionRenameOperation<E = never> = (input: Endpoint5_10Input) => Effect.Effect<Endpoint5_10Output, E>

-export type Endpoint5_11Input = { readonly sessionID: Session.ID; readonly title: string }
-export type Endpoint5_11Output = void
-export type SessionRenameOperation<E = never> = (input: Endpoint5_11Input) => Effect.Effect<Endpoint5_11Output, E>
-
-export type Endpoint5_12Input = {
+export type Endpoint5_11Input = {
  readonly sessionID: Session.ID
  readonly directory: AbsolutePath
  readonly workspaceID?: Workspace.ID | undefined
  readonly delivery?: SessionInbox.Delivery | undefined
 }
-export type Endpoint5_12Output = void
-export type SessionMoveOperation<E = never> = (input: Endpoint5_12Input) => Effect.Effect<Endpoint5_12Output, E>
+export type Endpoint5_11Output = void
+export type SessionMoveOperation<E = never> = (input: Endpoint5_11Input) => Effect.Effect<Endpoint5_11Output, E>

-export type Endpoint5_13Input = {
+export type Endpoint5_12Input = {
  readonly sessionID: Session.ID
  readonly id?: SessionMessage.ID | undefined
  readonly text: string
@@ -230,10 +179,10 @@ export type Endpoint5_13Input = {
  readonly delivery?: SessionInbox.Delivery | undefined
  readonly resume?: boolean | undefined
 }
-export type Endpoint5_13Output = SessionInbox.User
-export type SessionPromptOperation<E = never> = (input: Endpoint5_13Input) => Effect.Effect<Endpoint5_13Output, E>
+export type Endpoint5_12Output = SessionInbox.User
+export type SessionPromptOperation<E = never> = (input: Endpoint5_12Input) => Effect.Effect<Endpoint5_12Output, E>

-export type Endpoint5_14Input = {
+export type Endpoint5_13Input = {
  readonly sessionID: Session.ID
  readonly id?: SessionMessage.ID | undefined
  readonly command: string
@@ -246,19 +195,19 @@ export type Endpoint5_14Input = {
  readonly delivery?: SessionInbox.Delivery | undefined
  readonly resume?: boolean | undefined
 }
-export type Endpoint5_14Output = SessionInbox.User
-export type SessionCommandOperation<E = never> = (input: Endpoint5_14Input) => Effect.Effect<Endpoint5_14Output, E>
+export type Endpoint5_13Output = SessionInbox.User
+export type SessionCommandOperation<E = never> = (input: Endpoint5_13Input) => Effect.Effect<Endpoint5_13Output, E>

-export type Endpoint5_15Input = {
+export type Endpoint5_14Input = {
  readonly sessionID: Session.ID
  readonly id?: SessionMessage.ID | undefined
  readonly skill: Skill.ID
  readonly resume?: boolean | undefined
 }
-export type Endpoint5_15Output = void
-export type SessionSkillOperation<E = never> = (input: Endpoint5_15Input) => Effect.Effect<Endpoint5_15Output, E>
+export type Endpoint5_14Output = void
+export type SessionSkillOperation<E = never> = (input: Endpoint5_14Input) => Effect.Effect<Endpoint5_14Output, E>

-export type Endpoint5_16Input = {
+export type Endpoint5_15Input = {
  readonly sessionID: Session.ID
  readonly id?: SessionMessage.ID | undefined
  readonly text: string
@@ -267,97 +216,97 @@ export type Endpoint5_16Input = {
  readonly delivery?: SessionInbox.Delivery | undefined
  readonly resume?: boolean | undefined
 }
-export type Endpoint5_16Output = SessionInbox.Synthetic
-export type SessionSyntheticOperation<E = never> = (input: Endpoint5_16Input) => Effect.Effect<Endpoint5_16Output, E>
+export type Endpoint5_15Output = SessionInbox.Synthetic
+export type SessionSyntheticOperation<E = never> = (input: Endpoint5_15Input) => Effect.Effect<Endpoint5_15Output, E>

-export type Endpoint5_17Input = {
+export type Endpoint5_16Input = {
  readonly sessionID: Session.ID
  readonly id?: Event.ID | undefined
  readonly command: string
 }
-export type Endpoint5_17Output = void
-export type SessionShellOperation<E = never> = (input: Endpoint5_17Input) => Effect.Effect<Endpoint5_17Output, E>
+export type Endpoint5_16Output = void
+export type SessionShellOperation<E = never> = (input: Endpoint5_16Input) => Effect.Effect<Endpoint5_16Output, E>

-export type Endpoint5_18Input = {
+export type Endpoint5_17Input = {
  readonly sessionID: Session.ID
  readonly id?: SessionMessage.ID | undefined
  readonly delivery?: SessionInbox.Delivery | undefined
 }
-export type Endpoint5_18Output = SessionInbox.Compaction
-export type SessionCompactOperation<E = never> = (input: Endpoint5_18Input) => Effect.Effect<Endpoint5_18Output, E>
+export type Endpoint5_17Output = SessionInbox.Compaction
+export type SessionCompactOperation<E = never> = (input: Endpoint5_17Input) => Effect.Effect<Endpoint5_17Output, E>

-export type Endpoint5_19Input = { readonly sessionID: Session.ID }
-export type Endpoint5_19Output = void
-export type SessionWaitOperation<E = never> = (input: Endpoint5_19Input) => Effect.Effect<Endpoint5_19Output, E>
+export type Endpoint5_18Input = { readonly sessionID: Session.ID }
+export type Endpoint5_18Output = void
+export type SessionWaitOperation<E = never> = (input: Endpoint5_18Input) => Effect.Effect<Endpoint5_18Output, E>

-export type Endpoint5_20Input = {
+export type Endpoint5_19Input = {
  readonly sessionID: Session.ID
  readonly messageID: SessionMessage.ID
  readonly files?: boolean | undefined
 }
-export type Endpoint5_20Output = Session.Revert
-export type SessionRevertStageOperation<E = never> = (input: Endpoint5_20Input) => Effect.Effect<Endpoint5_20Output, E>
+export type Endpoint5_19Output = Session.Revert
+export type SessionRevertStageOperation<E = never> = (input: Endpoint5_19Input) => Effect.Effect<Endpoint5_19Output, E>
+
+export type Endpoint5_20Input = { readonly sessionID: Session.ID }
+export type Endpoint5_20Output = void
+export type SessionRevertClearOperation<E = never> = (input: Endpoint5_20Input) => Effect.Effect<Endpoint5_20Output, E>

 export type Endpoint5_21Input = { readonly sessionID: Session.ID }
 export type Endpoint5_21Output = void
-export type SessionRevertClearOperation<E = never> = (input: Endpoint5_21Input) => Effect.Effect<Endpoint5_21Output, E>
+export type SessionRevertCommitOperation<E = never> = (input: Endpoint5_21Input) => Effect.Effect<Endpoint5_21Output, E>

 export type Endpoint5_22Input = { readonly sessionID: Session.ID }
-export type Endpoint5_22Output = void
-export type SessionRevertCommitOperation<E = never> = (input: Endpoint5_22Input) => Effect.Effect<Endpoint5_22Output, E>
+export type Endpoint5_22Output = ReadonlyArray<SessionMessage.Info>
+export type SessionContextOperation<E = never> = (input: Endpoint5_22Input) => Effect.Effect<Endpoint5_22Output, E>

 export type Endpoint5_23Input = { readonly sessionID: Session.ID }
-export type Endpoint5_23Output = ReadonlyArray<SessionMessage.Info>
-export type SessionContextOperation<E = never> = (input: Endpoint5_23Input) => Effect.Effect<Endpoint5_23Output, E>
+export type Endpoint5_23Output = ReadonlyArray<SessionInbox.Info>
+export type SessionInboxListOperation<E = never> = (input: Endpoint5_23Input) => Effect.Effect<Endpoint5_23Output, E>

-export type Endpoint5_24Input = { readonly sessionID: Session.ID }
-export type Endpoint5_24Output = ReadonlyArray<SessionInbox.Info>
-export type SessionInboxListOperation<E = never> = (input: Endpoint5_24Input) => Effect.Effect<Endpoint5_24Output, E>
+export type Endpoint5_24Input = { readonly sessionID: Session.ID; readonly inboxID: SessionMessage.ID }
+export type Endpoint5_24Output = void
+export type SessionInboxCancelOperation<E = never> = (input: Endpoint5_24Input) => Effect.Effect<Endpoint5_24Output, E>

 export type Endpoint5_25Input = { readonly sessionID: Session.ID; readonly inboxID: SessionMessage.ID }
 export type Endpoint5_25Output = void
-export type SessionInboxCancelOperation<E = never> = (input: Endpoint5_25Input) => Effect.Effect<Endpoint5_25Output, E>
+export type SessionInboxSteerOperation<E = never> = (input: Endpoint5_25Input) => Effect.Effect<Endpoint5_25Output, E>

 export type Endpoint5_26Input = { readonly sessionID: Session.ID; readonly inboxID: SessionMessage.ID }
 export type Endpoint5_26Output = void
-export type SessionInboxSteerOperation<E = never> = (input: Endpoint5_26Input) => Effect.Effect<Endpoint5_26Output, E>
+export type SessionInboxQueueOperation<E = never> = (input: Endpoint5_26Input) => Effect.Effect<Endpoint5_26Output, E>

-export type Endpoint5_27Input = { readonly sessionID: Session.ID; readonly inboxID: SessionMessage.ID }
-export type Endpoint5_27Output = void
-export type SessionInboxQueueOperation<E = never> = (input: Endpoint5_27Input) => Effect.Effect<Endpoint5_27Output, E>
-
-export type Endpoint5_28Input = { readonly sessionID: Session.ID }
-export type Endpoint5_28Output = ReadonlyArray<InstructionEntry.Info>
+export type Endpoint5_27Input = { readonly sessionID: Session.ID }
+export type Endpoint5_27Output = ReadonlyArray<InstructionEntry.Info>
 export type SessionInstructionsEntryListOperation<E = never> = (
-  input: Endpoint5_28Input,
-) => Effect.Effect<Endpoint5_28Output, E>
+  input: Endpoint5_27Input,
+) => Effect.Effect<Endpoint5_27Output, E>

-export type Endpoint5_29Input = {
+export type Endpoint5_28Input = {
  readonly sessionID: Session.ID
  readonly key: InstructionEntry.Key
  readonly value: Schema.Json
 }
-export type Endpoint5_29Output = void
+export type Endpoint5_28Output = void
 export type SessionInstructionsEntryPutOperation<E = never> = (
+  input: Endpoint5_28Input,
+) => Effect.Effect<Endpoint5_28Output, E>
+
+export type Endpoint5_29Input = { readonly sessionID: Session.ID; readonly key: InstructionEntry.Key }
+export type Endpoint5_29Output = void
+export type SessionInstructionsEntryRemoveOperation<E = never> = (
  input: Endpoint5_29Input,
 ) => Effect.Effect<Endpoint5_29Output, E>

-export type Endpoint5_30Input = { readonly sessionID: Session.ID; readonly key: InstructionEntry.Key }
-export type Endpoint5_30Output = void
-export type SessionInstructionsEntryRemoveOperation<E = never> = (
-  input: Endpoint5_30Input,
-) => Effect.Effect<Endpoint5_30Output, E>
+export type Endpoint5_30Input = { readonly sessionID: Session.ID; readonly prompt: string }
+export type Endpoint5_30Output = { readonly text: string }
+export type SessionGenerateOperation<E = never> = (input: Endpoint5_30Input) => Effect.Effect<Endpoint5_30Output, E>

-export type Endpoint5_31Input = { readonly sessionID: Session.ID; readonly prompt: string }
-export type Endpoint5_31Output = { readonly text: string }
-export type SessionGenerateOperation<E = never> = (input: Endpoint5_31Input) => Effect.Effect<Endpoint5_31Output, E>
-
-export type Endpoint5_32Input = {
+export type Endpoint5_31Input = {
  readonly sessionID: Session.ID
  readonly after?: Event.Seq | undefined
  readonly follow?: boolean | undefined
 }
-export type Endpoint5_32Output =
+export type Endpoint5_31Output =
  | (
      | {
          readonly id: Event.ID
@@ -951,27 +900,26 @@ export type Endpoint5_32Output =
        }
    )
  | EventLog.Synced
-export type SessionLogOperation<E = never> = (input: Endpoint5_32Input) => Stream.Stream<Endpoint5_32Output, E>
+export type SessionLogOperation<E = never> = (input: Endpoint5_31Input) => Stream.Stream<Endpoint5_31Output, E>

-export type Endpoint5_33Input = { readonly sessionID: Session.ID; readonly continue?: boolean | undefined }
+export type Endpoint5_32Input = { readonly sessionID: Session.ID; readonly continue?: boolean | undefined }
+export type Endpoint5_32Output = void
+export type SessionInterruptOperation<E = never> = (input: Endpoint5_32Input) => Effect.Effect<Endpoint5_32Output, E>
+
+export type Endpoint5_33Input = { readonly sessionID: Session.ID }
 export type Endpoint5_33Output = void
-export type SessionInterruptOperation<E = never> = (input: Endpoint5_33Input) => Effect.Effect<Endpoint5_33Output, E>
+export type SessionBackgroundOperation<E = never> = (input: Endpoint5_33Input) => Effect.Effect<Endpoint5_33Output, E>

-export type Endpoint5_34Input = { readonly sessionID: Session.ID }
-export type Endpoint5_34Output = void
-export type SessionBackgroundOperation<E = never> = (input: Endpoint5_34Input) => Effect.Effect<Endpoint5_34Output, E>
+export type Endpoint5_34Input = { readonly sessionID: Session.ID; readonly messageID: SessionMessage.ID }
+export type Endpoint5_34Output = SessionMessage.Info
+export type SessionMessageOperation<E = never> = (input: Endpoint5_34Input) => Effect.Effect<Endpoint5_34Output, E>

-export type Endpoint5_35Input = { readonly sessionID: Session.ID; readonly messageID: SessionMessage.ID }
-export type Endpoint5_35Output = SessionMessage.Info
-export type SessionMessageOperation<E = never> = (input: Endpoint5_35Input) => Effect.Effect<Endpoint5_35Output, E>
-
-export type Endpoint5_36Input = { readonly sessionID: Session.ID; readonly variables: { readonly [x: string]: string } }
-export type Endpoint5_36Output = void
-export type SessionEnvironmentOperation<E = never> = (input: Endpoint5_36Input) => Effect.Effect<Endpoint5_36Output, E>
+export type Endpoint5_35Input = { readonly sessionID: Session.ID; readonly variables: { readonly [x: string]: string } }
+export type Endpoint5_35Output = void
+export type SessionEnvironmentOperation<E = never> = (input: Endpoint5_35Input) => Effect.Effect<Endpoint5_35Output, E>

 export interface SessionApi<E = never> {
  readonly list: SessionListOperation<E>
-  readonly stats: SessionStatsOperation<E>
  readonly create: SessionCreateOperation<E>
  readonly import: SessionImportOperation<E>
  readonly export: SessionExportOperation<E>
@@ -23,8 +23,8 @@ import type {
  Endpoint5_2Output,
  Endpoint5_3Input,
  Endpoint5_3Output,
-  Endpoint5_4Input,
  Endpoint5_4Output,
+  Endpoint5_5Input,
  Endpoint5_5Output,
  Endpoint5_6Input,
  Endpoint5_6Output,
@@ -86,8 +86,6 @@ import type {
  Endpoint5_34Output,
  Endpoint5_35Input,
  Endpoint5_35Output,
-  Endpoint5_36Input,
-  Endpoint5_36Output,
  Endpoint6_0Input,
  Endpoint6_0Output,
  Endpoint7_0Input,
@@ -302,16 +300,6 @@ const Endpoint5_0 = (raw: RawClient["server.session"]) => (input?: Endpoint5_0In

 const Endpoint5_1 = (raw: RawClient["server.session"]) => (input?: Endpoint5_1Input) =>
  preserveEffect<Endpoint5_1Output>()(
-    raw["session.stats"]({
-      query: { from: input?.["from"], to: input?.["to"], project: input?.["project"], timezone: input?.["timezone"] },
-    }).pipe(
-      Effect.mapError(mapClientError),
-      Effect.map((value) => value.data),
-    ),
-  )
-
-const Endpoint5_2 = (raw: RawClient["server.session"]) => (input?: Endpoint5_2Input) =>
-  preserveEffect<Endpoint5_2Output>()(
    raw["session.create"]({
      payload: {
        id: input?.["id"],
@@ -326,8 +314,8 @@ const Endpoint5_2 = (raw: RawClient["server.session"]) => (input?: Endpoint5_2In
    ),
  )

-const Endpoint5_3 = (raw: RawClient["server.session"]) => (input: Endpoint5_3Input) =>
-  preserveEffect<Endpoint5_3Output>()(
+const Endpoint5_2 = (raw: RawClient["server.session"]) => (input: Endpoint5_2Input) =>
+  preserveEffect<Endpoint5_2Output>()(
    raw["session.import"]({
      payload: { info: input["info"], messages: input["messages"], location: input["location"] },
    }).pipe(
@@ -336,74 +324,74 @@ const Endpoint5_3 = (raw: RawClient["server.session"]) => (input: Endpoint5_3Inp
    ),
  )

-const Endpoint5_4 = (raw: RawClient["server.session"]) => (input: Endpoint5_4Input) =>
-  preserveEffect<Endpoint5_4Output>()(
+const Endpoint5_3 = (raw: RawClient["server.session"]) => (input: Endpoint5_3Input) =>
+  preserveEffect<Endpoint5_3Output>()(
    raw["session.export"]({ params: { sessionID: input["sessionID"] }, query: { sanitize: input["sanitize"] } }).pipe(
      Effect.mapError(mapClientError),
      Effect.map((value) => value.data),
    ),
  )

-const Endpoint5_5 = (raw: RawClient["server.session"]) => () =>
-  preserveEffect<Endpoint5_5Output>()(
+const Endpoint5_4 = (raw: RawClient["server.session"]) => () =>
+  preserveEffect<Endpoint5_4Output>()(
    raw["session.active"]({}).pipe(
      Effect.mapError(mapClientError),
      Effect.map((value) => value.data),
    ),
  )

+const Endpoint5_5 = (raw: RawClient["server.session"]) => (input: Endpoint5_5Input) =>
+  preserveEffect<Endpoint5_5Output>()(
+    raw["session.get"]({ params: { sessionID: input["sessionID"] } }).pipe(
+      Effect.mapError(mapClientError),
+      Effect.map((value) => value.data),
+    ),
+  )
+
 const Endpoint5_6 = (raw: RawClient["server.session"]) => (input: Endpoint5_6Input) =>
  preserveEffect<Endpoint5_6Output>()(
-    raw["session.get"]({ params: { sessionID: input["sessionID"] } }).pipe(
-      Effect.mapError(mapClientError),
-      Effect.map((value) => value.data),
-    ),
+    raw["session.remove"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError)),
  )

 const Endpoint5_7 = (raw: RawClient["server.session"]) => (input: Endpoint5_7Input) =>
  preserveEffect<Endpoint5_7Output>()(
-    raw["session.remove"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError)),
-  )
-
-const Endpoint5_8 = (raw: RawClient["server.session"]) => (input: Endpoint5_8Input) =>
-  preserveEffect<Endpoint5_8Output>()(
    raw["session.fork"]({ params: { sessionID: input["sessionID"] }, payload: { boundary: input["boundary"] } }).pipe(
      Effect.mapError(mapClientError),
      Effect.map((value) => value.data),
    ),
  )

+const Endpoint5_8 = (raw: RawClient["server.session"]) => (input: Endpoint5_8Input) =>
+  preserveEffect<Endpoint5_8Output>()(
+    raw["session.switchAgent"]({ params: { sessionID: input["sessionID"] }, payload: { agent: input["agent"] } }).pipe(
+      Effect.mapError(mapClientError),
+    ),
+  )
+
 const Endpoint5_9 = (raw: RawClient["server.session"]) => (input: Endpoint5_9Input) =>
  preserveEffect<Endpoint5_9Output>()(
-    raw["session.switchAgent"]({ params: { sessionID: input["sessionID"] }, payload: { agent: input["agent"] } }).pipe(
+    raw["session.switchModel"]({ params: { sessionID: input["sessionID"] }, payload: { model: input["model"] } }).pipe(
      Effect.mapError(mapClientError),
    ),
  )

 const Endpoint5_10 = (raw: RawClient["server.session"]) => (input: Endpoint5_10Input) =>
  preserveEffect<Endpoint5_10Output>()(
-    raw["session.switchModel"]({ params: { sessionID: input["sessionID"] }, payload: { model: input["model"] } }).pipe(
+    raw["session.rename"]({ params: { sessionID: input["sessionID"] }, payload: { title: input["title"] } }).pipe(
      Effect.mapError(mapClientError),
    ),
  )

 const Endpoint5_11 = (raw: RawClient["server.session"]) => (input: Endpoint5_11Input) =>
  preserveEffect<Endpoint5_11Output>()(
-    raw["session.rename"]({ params: { sessionID: input["sessionID"] }, payload: { title: input["title"] } }).pipe(
-      Effect.mapError(mapClientError),
-    ),
-  )
-
-const Endpoint5_12 = (raw: RawClient["server.session"]) => (input: Endpoint5_12Input) =>
-  preserveEffect<Endpoint5_12Output>()(
    raw["session.move"]({
      params: { sessionID: input["sessionID"] },
      payload: { directory: input["directory"], workspaceID: input["workspaceID"], delivery: input["delivery"] },
    }).pipe(Effect.mapError(mapClientError)),
  )

-const Endpoint5_13 = (raw: RawClient["server.session"]) => (input: Endpoint5_13Input) =>
-  preserveEffect<Endpoint5_13Output>()(
+const Endpoint5_12 = (raw: RawClient["server.session"]) => (input: Endpoint5_12Input) =>
+  preserveEffect<Endpoint5_12Output>()(
    raw["session.prompt"]({
      params: { sessionID: input["sessionID"] },
      payload: {
@@ -422,8 +410,8 @@ const Endpoint5_13 = (raw: RawClient["server.session"]) => (input: Endpoint5_13I
    ),
  )

-const Endpoint5_14 = (raw: RawClient["server.session"]) => (input: Endpoint5_14Input) =>
-  preserveEffect<Endpoint5_14Output>()(
+const Endpoint5_13 = (raw: RawClient["server.session"]) => (input: Endpoint5_13Input) =>
+  preserveEffect<Endpoint5_13Output>()(
    raw["session.command"]({
      params: { sessionID: input["sessionID"] },
      payload: {
@@ -444,16 +432,16 @@ const Endpoint5_14 = (raw: RawClient["server.session"]) => (input: Endpoint5_14I
    ),
  )

-const Endpoint5_15 = (raw: RawClient["server.session"]) => (input: Endpoint5_15Input) =>
-  preserveEffect<Endpoint5_15Output>()(
+const Endpoint5_14 = (raw: RawClient["server.session"]) => (input: Endpoint5_14Input) =>
+  preserveEffect<Endpoint5_14Output>()(
    raw["session.skill"]({
      params: { sessionID: input["sessionID"] },
      payload: { id: input["id"], skill: input["skill"], resume: input["resume"] },
    }).pipe(Effect.mapError(mapClientError)),
  )

-const Endpoint5_16 = (raw: RawClient["server.session"]) => (input: Endpoint5_16Input) =>
-  preserveEffect<Endpoint5_16Output>()(
+const Endpoint5_15 = (raw: RawClient["server.session"]) => (input: Endpoint5_15Input) =>
+  preserveEffect<Endpoint5_15Output>()(
    raw["session.synthetic"]({
      params: { sessionID: input["sessionID"] },
      payload: {
@@ -470,16 +458,16 @@ const Endpoint5_16 = (raw: RawClient["server.session"]) => (input: Endpoint5_16I
    ),
  )

-const Endpoint5_17 = (raw: RawClient["server.session"]) => (input: Endpoint5_17Input) =>
-  preserveEffect<Endpoint5_17Output>()(
+const Endpoint5_16 = (raw: RawClient["server.session"]) => (input: Endpoint5_16Input) =>
+  preserveEffect<Endpoint5_16Output>()(
    raw["session.shell"]({
      params: { sessionID: input["sessionID"] },
      payload: { id: input["id"], command: input["command"] },
    }).pipe(Effect.mapError(mapClientError)),
  )

-const Endpoint5_18 = (raw: RawClient["server.session"]) => (input: Endpoint5_18Input) =>
-  preserveEffect<Endpoint5_18Output>()(
+const Endpoint5_17 = (raw: RawClient["server.session"]) => (input: Endpoint5_17Input) =>
+  preserveEffect<Endpoint5_17Output>()(
    raw["session.compact"]({
      params: { sessionID: input["sessionID"] },
      payload: { id: input["id"], delivery: input["delivery"] },
@@ -489,13 +477,13 @@ const Endpoint5_18 = (raw: RawClient["server.session"]) => (input: Endpoint5_18I
    ),
  )

-const Endpoint5_19 = (raw: RawClient["server.session"]) => (input: Endpoint5_19Input) =>
-  preserveEffect<Endpoint5_19Output>()(
+const Endpoint5_18 = (raw: RawClient["server.session"]) => (input: Endpoint5_18Input) =>
+  preserveEffect<Endpoint5_18Output>()(
    raw["session.wait"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError)),
  )

-const Endpoint5_20 = (raw: RawClient["server.session"]) => (input: Endpoint5_20Input) =>
-  preserveEffect<Endpoint5_20Output>()(
+const Endpoint5_19 = (raw: RawClient["server.session"]) => (input: Endpoint5_19Input) =>
+  preserveEffect<Endpoint5_19Output>()(
    raw["session.revert.stage"]({
      params: { sessionID: input["sessionID"] },
      payload: { messageID: input["messageID"], files: input["files"] },
@@ -505,19 +493,27 @@ const Endpoint5_20 = (raw: RawClient["server.session"]) => (input: Endpoint5_20I
    ),
  )

+const Endpoint5_20 = (raw: RawClient["server.session"]) => (input: Endpoint5_20Input) =>
+  preserveEffect<Endpoint5_20Output>()(
+    raw["session.revert.clear"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError)),
+  )
+
 const Endpoint5_21 = (raw: RawClient["server.session"]) => (input: Endpoint5_21Input) =>
  preserveEffect<Endpoint5_21Output>()(
-    raw["session.revert.clear"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError)),
+    raw["session.revert.commit"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError)),
  )

 const Endpoint5_22 = (raw: RawClient["server.session"]) => (input: Endpoint5_22Input) =>
  preserveEffect<Endpoint5_22Output>()(
-    raw["session.revert.commit"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError)),
+    raw["session.context"]({ params: { sessionID: input["sessionID"] } }).pipe(
+      Effect.mapError(mapClientError),
+      Effect.map((value) => value.data),
+    ),
  )

 const Endpoint5_23 = (raw: RawClient["server.session"]) => (input: Endpoint5_23Input) =>
  preserveEffect<Endpoint5_23Output>()(
-    raw["session.context"]({ params: { sessionID: input["sessionID"] } }).pipe(
+    raw["session.inbox.list"]({ params: { sessionID: input["sessionID"] } }).pipe(
      Effect.mapError(mapClientError),
      Effect.map((value) => value.data),
    ),
@@ -525,66 +521,58 @@ const Endpoint5_23 = (raw: RawClient["server.session"]) => (input: Endpoint5_23I

 const Endpoint5_24 = (raw: RawClient["server.session"]) => (input: Endpoint5_24Input) =>
  preserveEffect<Endpoint5_24Output>()(
-    raw["session.inbox.list"]({ params: { sessionID: input["sessionID"] } }).pipe(
+    raw["session.inbox.cancel"]({ params: { sessionID: input["sessionID"], inboxID: input["inboxID"] } }).pipe(
      Effect.mapError(mapClientError),
-      Effect.map((value) => value.data),
    ),
  )

 const Endpoint5_25 = (raw: RawClient["server.session"]) => (input: Endpoint5_25Input) =>
  preserveEffect<Endpoint5_25Output>()(
-    raw["session.inbox.cancel"]({ params: { sessionID: input["sessionID"], inboxID: input["inboxID"] } }).pipe(
+    raw["session.inbox.steer"]({ params: { sessionID: input["sessionID"], inboxID: input["inboxID"] } }).pipe(
      Effect.mapError(mapClientError),
    ),
  )

 const Endpoint5_26 = (raw: RawClient["server.session"]) => (input: Endpoint5_26Input) =>
  preserveEffect<Endpoint5_26Output>()(
-    raw["session.inbox.steer"]({ params: { sessionID: input["sessionID"], inboxID: input["inboxID"] } }).pipe(
+    raw["session.inbox.queue"]({ params: { sessionID: input["sessionID"], inboxID: input["inboxID"] } }).pipe(
      Effect.mapError(mapClientError),
    ),
  )

 const Endpoint5_27 = (raw: RawClient["server.session"]) => (input: Endpoint5_27Input) =>
  preserveEffect<Endpoint5_27Output>()(
-    raw["session.inbox.queue"]({ params: { sessionID: input["sessionID"], inboxID: input["inboxID"] } }).pipe(
-      Effect.mapError(mapClientError),
-    ),
-  )
-
-const Endpoint5_28 = (raw: RawClient["server.session"]) => (input: Endpoint5_28Input) =>
-  preserveEffect<Endpoint5_28Output>()(
    raw["session.instructions.entry.list"]({ params: { sessionID: input["sessionID"] } }).pipe(
      Effect.mapError(mapClientError),
      Effect.map((value) => value.data),
    ),
  )

-const Endpoint5_29 = (raw: RawClient["server.session"]) => (input: Endpoint5_29Input) =>
-  preserveEffect<Endpoint5_29Output>()(
+const Endpoint5_28 = (raw: RawClient["server.session"]) => (input: Endpoint5_28Input) =>
+  preserveEffect<Endpoint5_28Output>()(
    raw["session.instructions.entry.put"]({
      params: { sessionID: input["sessionID"], key: input["key"] },
      payload: { value: input["value"] },
    }).pipe(Effect.mapError(mapClientError)),
  )

-const Endpoint5_30 = (raw: RawClient["server.session"]) => (input: Endpoint5_30Input) =>
-  preserveEffect<Endpoint5_30Output>()(
+const Endpoint5_29 = (raw: RawClient["server.session"]) => (input: Endpoint5_29Input) =>
+  preserveEffect<Endpoint5_29Output>()(
    raw["session.instructions.entry.remove"]({ params: { sessionID: input["sessionID"], key: input["key"] } }).pipe(
      Effect.mapError(mapClientError),
    ),
  )

-const Endpoint5_31 = (raw: RawClient["server.session"]) => (input: Endpoint5_31Input) =>
-  preserveEffect<Endpoint5_31Output>()(
+const Endpoint5_30 = (raw: RawClient["server.session"]) => (input: Endpoint5_30Input) =>
+  preserveEffect<Endpoint5_30Output>()(
    raw["session.generate"]({ params: { sessionID: input["sessionID"] }, payload: { prompt: input["prompt"] } }).pipe(
      Effect.mapError(mapClientError),
      Effect.map((value) => value.data),
    ),
  )

-const Endpoint5_32 = (raw: RawClient["server.session"]) => (input: Endpoint5_32Input) =>
-  preserveStream<Endpoint5_32Output>()(
+const Endpoint5_31 = (raw: RawClient["server.session"]) => (input: Endpoint5_31Input) =>
+  preserveStream<Endpoint5_31Output>()(
    Stream.unwrap(
      raw["session.log"]({
        params: { sessionID: input["sessionID"] },
@@ -596,29 +584,29 @@ const Endpoint5_32 = (raw: RawClient["server.session"]) => (input: Endpoint5_32I
    ),
  )

-const Endpoint5_33 = (raw: RawClient["server.session"]) => (input: Endpoint5_33Input) =>
-  preserveEffect<Endpoint5_33Output>()(
+const Endpoint5_32 = (raw: RawClient["server.session"]) => (input: Endpoint5_32Input) =>
+  preserveEffect<Endpoint5_32Output>()(
    raw["session.interrupt"]({
      params: { sessionID: input["sessionID"] },
      query: { continue: input["continue"] },
    }).pipe(Effect.mapError(mapClientError)),
  )

-const Endpoint5_34 = (raw: RawClient["server.session"]) => (input: Endpoint5_34Input) =>
-  preserveEffect<Endpoint5_34Output>()(
+const Endpoint5_33 = (raw: RawClient["server.session"]) => (input: Endpoint5_33Input) =>
+  preserveEffect<Endpoint5_33Output>()(
    raw["session.background"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError)),
  )

-const Endpoint5_35 = (raw: RawClient["server.session"]) => (input: Endpoint5_35Input) =>
-  preserveEffect<Endpoint5_35Output>()(
+const Endpoint5_34 = (raw: RawClient["server.session"]) => (input: Endpoint5_34Input) =>
+  preserveEffect<Endpoint5_34Output>()(
    raw["session.message"]({ params: { sessionID: input["sessionID"], messageID: input["messageID"] } }).pipe(
      Effect.mapError(mapClientError),
      Effect.map((value) => value.data),
    ),
  )

-const Endpoint5_36 = (raw: RawClient["server.session"]) => (input: Endpoint5_36Input) =>
-  preserveEffect<Endpoint5_36Output>()(
+const Endpoint5_35 = (raw: RawClient["server.session"]) => (input: Endpoint5_35Input) =>
+  preserveEffect<Endpoint5_35Output>()(
    raw["session.environment"]({
      params: { sessionID: input["sessionID"] },
      payload: { variables: input["variables"] },
@@ -627,35 +615,34 @@ const Endpoint5_36 = (raw: RawClient["server.session"]) => (input: Endpoint5_36I

 const adaptGroup5 = (raw: RawClient["server.session"]) => ({
  list: Endpoint5_0(raw),
-  stats: Endpoint5_1(raw),
-  create: Endpoint5_2(raw),
-  import: Endpoint5_3(raw),
-  export: Endpoint5_4(raw),
-  active: Endpoint5_5(raw),
-  get: Endpoint5_6(raw),
-  remove: Endpoint5_7(raw),
-  fork: Endpoint5_8(raw),
-  switchAgent: Endpoint5_9(raw),
-  switchModel: Endpoint5_10(raw),
-  rename: Endpoint5_11(raw),
-  move: Endpoint5_12(raw),
-  prompt: Endpoint5_13(raw),
-  command: Endpoint5_14(raw),
-  skill: Endpoint5_15(raw),
-  synthetic: Endpoint5_16(raw),
-  shell: Endpoint5_17(raw),
-  compact: Endpoint5_18(raw),
-  wait: Endpoint5_19(raw),
-  revert: { stage: Endpoint5_20(raw), clear: Endpoint5_21(raw), commit: Endpoint5_22(raw) },
-  context: Endpoint5_23(raw),
-  inbox: { list: Endpoint5_24(raw), cancel: Endpoint5_25(raw), steer: Endpoint5_26(raw), queue: Endpoint5_27(raw) },
-  instructions: { entry: { list: Endpoint5_28(raw), put: Endpoint5_29(raw), remove: Endpoint5_30(raw) } },
-  generate: Endpoint5_31(raw),
-  log: Endpoint5_32(raw),
-  interrupt: Endpoint5_33(raw),
-  background: Endpoint5_34(raw),
-  message: Endpoint5_35(raw),
-  environment: Endpoint5_36(raw),
+  create: Endpoint5_1(raw),
+  import: Endpoint5_2(raw),
+  export: Endpoint5_3(raw),
+  active: Endpoint5_4(raw),
+  get: Endpoint5_5(raw),
+  remove: Endpoint5_6(raw),
+  fork: Endpoint5_7(raw),
+  switchAgent: Endpoint5_8(raw),
+  switchModel: Endpoint5_9(raw),
+  rename: Endpoint5_10(raw),
+  move: Endpoint5_11(raw),
+  prompt: Endpoint5_12(raw),
+  command: Endpoint5_13(raw),
+  skill: Endpoint5_14(raw),
+  synthetic: Endpoint5_15(raw),
+  shell: Endpoint5_16(raw),
+  compact: Endpoint5_17(raw),
+  wait: Endpoint5_18(raw),
+  revert: { stage: Endpoint5_19(raw), clear: Endpoint5_20(raw), commit: Endpoint5_21(raw) },
+  context: Endpoint5_22(raw),
+  inbox: { list: Endpoint5_23(raw), cancel: Endpoint5_24(raw), steer: Endpoint5_25(raw), queue: Endpoint5_26(raw) },
+  instructions: { entry: { list: Endpoint5_27(raw), put: Endpoint5_28(raw), remove: Endpoint5_29(raw) } },
+  generate: Endpoint5_30(raw),
+  log: Endpoint5_31(raw),
+  interrupt: Endpoint5_32(raw),
+  background: Endpoint5_33(raw),
+  message: Endpoint5_34(raw),
+  environment: Endpoint5_35(raw),
 })

 const Endpoint6_0 = (raw: RawClient["server.message"]) => (input: Endpoint6_0Input) =>
@@ -6,6 +6,7 @@ export type ConfigApi = Client["config"]
 export type EventApi = Client["event"]
 export type IntegrationApi = Client["integration"]
 export type McpApi = Client["mcp"]
+export type MessageApi = Client["message"]
 export type ModelApi = Client["model"]
 export type PluginApi = Client["plugin"]
 export type ProviderApi = Client["provider"]
@@ -11,8 +11,6 @@ import type {
  PluginListOutput,
  SessionListInput,
  SessionListOutput,
-  SessionStatsInput,
-  SessionStatsOutput,
  SessionCreateInput,
  SessionCreateOutput,
  SessionImportInput,
@@ -452,23 +450,6 @@ export function make(options: ClientOptions) {
          },
          requestOptions,
        ),
-      stats: (input?: SessionStatsInput, requestOptions?: RequestOptions) =>
-        request<{ readonly data: SessionStatsOutput }>(
-          {
-            method: "GET",
-            path: `/api/session/stats`,
-            query: {
-              from: input?.["from"],
-              to: input?.["to"],
-              project: input?.["project"],
-              timezone: input?.["timezone"],
-            },
-            successStatus: 200,
-            declaredStatuses: [400, 401],
-            empty: false,
-          },
-          requestOptions,
-        ).then((value) => value.data),
      create: (input?: SessionCreateInput, requestOptions?: RequestOptions) =>
        request<{ readonly data: SessionCreateOutput }>(
          {
@@ -30,17 +30,6 @@ export type FileDiffInfo = {
  status: "added" | "deleted" | "modified"
 }

-export type SessionStatsActivity = { date: string; steps: number }
-
-export type SessionStatsToolUsage = {
-  name: string
-  calls: number
-  succeeded: number
-  failed: number
-  unfinished: number
-  durationP50?: number
-}
-
 export type PromptBase64 = string

 export type PromptFileSource = { type: "inline" } | { type: "uri"; uri: string }
@@ -1108,8 +1097,6 @@ export type VcsInfo = { branch: VcsBranch }

 export type PermissionRuleset = Array<PermissionRule>

-export type SessionStatsModelUsage = { model: ModelRef; steps: number; tokens: TokenUsageInfo; cost: MoneyUSD }
-
 export type SessionStepEnded = {
  id: string
  created: number
@@ -1661,22 +1648,6 @@ export type ConfigEntry =
  | { type: "agents"; path: string }
  | { type: "claude"; path: string }

-export type SessionStatsInfo = {
-  range: { from: number; to: number }
-  sessions: number
-  subagents: number
-  prompts: number
-  steps: number
-  tokens: TokenUsageInfo
-  cost: MoneyUSD
-  tools: { calls: number; succeeded: number; failed: number; unfinished: number }
-  activeDays: number
-  streak: number
-  activity: Array<SessionStatsActivity>
-  models: Array<SessionStatsModelUsage>
-  toolUsage: Array<SessionStatsToolUsage>
-}
-
 export type SessionInfo = {
  id: string
  parentID?: string
@@ -2467,35 +2438,6 @@ export type SessionListInput = {

 export type SessionListOutput = SessionsResponse

-export type SessionStatsInput = {
-  readonly from?: {
-    readonly from?: number | undefined
-    readonly to?: number | undefined
-    readonly project?: string | undefined
-    readonly timezone?: string | undefined
-  }["from"]
-  readonly to?: {
-    readonly from?: number | undefined
-    readonly to?: number | undefined
-    readonly project?: string | undefined
-    readonly timezone?: string | undefined
-  }["to"]
-  readonly project?: {
-    readonly from?: number | undefined
-    readonly to?: number | undefined
-    readonly project?: string | undefined
-    readonly timezone?: string | undefined
-  }["project"]
-  readonly timezone?: {
-    readonly from?: number | undefined
-    readonly to?: number | undefined
-    readonly project?: string | undefined
-    readonly timezone?: string | undefined
-  }["timezone"]
-}
-
-export type SessionStatsOutput = { data: SessionStatsInfo }["data"]
-
 export type SessionCreateInput = {
  readonly id?: {
    readonly id?: string | null
@@ -12,8 +12,8 @@ export type EnsureTiming = {
 const timings = new WeakMap<object, EnsureTiming>()

 export const defaultEnsureTiming: EnsureTiming = {
-  pollInterval: 100,
-  attempts: 1_200,
+  pollInterval: 1_000,
+  attempts: 120,
  requestTimeout: 2_000,
  spawnDelay: 5_000,
  maxSpawnDelay: 30_000,
@@ -111,7 +111,7 @@ test("event.subscribe exposes and decodes the native Effect event stream", async
  expect(Array.from(events).map((event) => event.type)).toEqual(["server.connected", "session.model.selected"])
  const durable = events[1]
  if (durable?.type !== "session.model.selected") throw new Error("Expected model event")
-  expect(durable.created).toBe(1_717_171_717_000)
+  expect(DateTime.toEpochMillis(durable.created)).toBe(1_717_171_717_000)
  expect(durable.durable).toEqual({ aggregateID: "ses_test", seq: 1, version: 1 })
 })

@@ -219,7 +219,9 @@ test("session methods retain decoded Effect inputs and outputs", async () => {
  expect(logQueries[0]).toEqual({ after: "0" })
  const logged = Array.from(result.log)
  expect(logged.map((item) => item.type)).toEqual(["session.model.selected", "log.synced"])
-  expect(logged[0]?.type === "session.model.selected" && logged[0].created).toBe(1_717_171_717_000)
+  expect(logged[0]?.type === "session.model.selected" && DateTime.toEpochMillis(logged[0].created)).toBe(
+    1_717_171_717_000,
+  )
  expect(logged.at(-1)).toEqual(synced)
  expect(result.message).toEqual(expect.objectContaining({ id: "msg_model", type: "model-switched" }))
 })
@@ -2,7 +2,6 @@ import { withEnsureTiming } from "../../src/service-timing"

 const timing = {
  pollInterval: 20,
-  attempts: 120,
  requestTimeout: 100,
  spawnDelay: 200,
  maxSpawnDelay: 1_200,
@@ -328,6 +328,7 @@ function modelFromLanguage(info: Info, language: LanguageModelV3) {
              body: projected.body === undefined ? undefined : { ...projected.body },
              headers: info.headers,
            },
+      limits: { context: info.limit.context, input: info.limit.input, output: info.limit.output },
      providerOptions: projected.settings,
    },
    body: {
@@ -164,6 +164,7 @@ const resolveCatalogModel = Effect.fn("ModelResolver.resolveCatalogModel")(funct
    ...nativeCredentialSettings(specifier, credential),
    headers: Provider.mergeHeaders(mapping?.headers, resolved.headers),
    body: Provider.mergeOverlay(mapping?.body, resolved.body),
+    limits: { context: resolved.limit.context, input: resolved.limit.input, output: resolved.limit.output },
  }
  return yield* Effect.try({
    try: () => {
@@ -6,7 +6,7 @@ import type { CredentialOAuth } from "@opencode-ai/sdk/v2/types"
 import { EventManifest } from "@opencode-ai/schema/event-manifest"
 import { Mcp } from "@opencode-ai/schema/mcp"
 import { App } from "../app.js"
-import { Effect, Schema, Stream } from "effect"
+import { DateTime, Effect, Schema, Stream } from "effect"
 import { Agent } from "../agent.js"
 import { AISDK } from "../aisdk.js"
 import { Catalog } from "../catalog.js"
@@ -27,8 +27,19 @@ import { Tool } from "../tool.js"
 import { Workspace } from "../workspace.js"
 import { WebSearch } from "../websearch.js"
 import { PluginHooks } from "./hooks.js"
+import { Session } from "../session.js"
+import { SessionMessage } from "../session/message.js"

 const mutable = <T>(value: T) => value as DeepMutable<T>
+type SessionListInput = Exclude<Parameters<Plugin.Context["session"]["list"]>[0], undefined>
+type SessionListCursor = Exclude<SessionListInput["cursor"], undefined>
+
+const MessageCursor = Schema.Struct({
+  id: SessionMessage.ID,
+  order: Schema.Literals(["asc", "desc"]),
+  direction: Schema.Literals(["previous", "next"]),
+})
+
 export const make = Effect.fn("PluginHost.make")(function* (
  plugin: import("../plugin.js").Interface,
  pluginID: string = "test",
@@ -67,6 +78,57 @@ export const make = Effect.fn("PluginHost.make")(function* (
    ref.directory === location.directory && ref.workspaceID === location.workspaceID
  const response = <A, E, R>(effect: Effect.Effect<A, E, R>) =>
    effect.pipe(Effect.map((data) => ({ location: locationInfo(), data })))
+  const sessionList = (input?: SessionListInput, parentID?: Session.ID) =>
+    Effect.gen(function* () {
+      const decoded = input?.cursor === undefined ? sessionListQuery(input) : yield* decodeSessionCursor(input.cursor)
+      const query = parentID === undefined ? decoded : { ...decoded, parentID }
+      const page = yield* runtime.session.list({ ...query, limit: input?.limit ?? 50 })
+      const first = page.data[0]
+      const last = page.data.at(-1)
+      return {
+        data: page.data,
+        cursor: {
+          previous:
+            first === undefined
+              ? undefined
+              : encodeSessionCursor(query, {
+                  id: first.id,
+                  time: DateTime.toEpochMillis(first.time.updated),
+                  direction: "previous",
+                }),
+          next:
+            last === undefined
+              ? undefined
+              : encodeSessionCursor(query, {
+                  id: last.id,
+                  time: DateTime.toEpochMillis(last.time.updated),
+                  direction: "next",
+                }),
+        },
+      }
+    })
+  const sessionMessages = (input: Parameters<Plugin.Context["session"]["messages"]>[0]) =>
+    Effect.gen(function* () {
+      if (input.cursor !== undefined && input.order !== undefined)
+        return yield* Effect.fail(new Error("Invalid cursor"))
+      const decoded = input.cursor === undefined ? undefined : yield* decodeMessageCursor(input.cursor)
+      const order = decoded?.order ?? input.order ?? "desc"
+      const messages = yield* runtime.session.messages({
+        sessionID: input.sessionID,
+        limit: input.limit ?? 50,
+        order,
+        cursor: decoded === undefined ? undefined : { id: decoded.id, direction: decoded.direction },
+      })
+      const first = messages[0]
+      const last = messages.at(-1)
+      return {
+        data: messages,
+        cursor: {
+          previous: first === undefined ? undefined : encodeMessageCursor(first, order, "previous"),
+          next: last === undefined ? undefined : encodeMessageCursor(last, order, "next"),
+        },
+      }
+    })

  return {
    app,
@@ -391,6 +453,9 @@ export const make = Effect.fn("PluginHost.make")(function* (
    },
    session: {
      hook: (name, callback, options) => hooks.register("session", name, callback, options),
+      list: sessionList,
+      children: (input) => sessionList({ cursor: input.cursor, limit: input.limit }, input.sessionID),
+      messages: sessionMessages,
      create: (input) =>
        runtime.session.create({
          id: input?.id,
@@ -412,6 +477,61 @@ export const make = Effect.fn("PluginHost.make")(function* (
  } satisfies Plugin.Context
 })

+function sessionListQuery(input?: SessionListInput): Session.ListInput {
+  const common = {
+    workspaceID: input?.workspace,
+    search: input?.search,
+    order: input?.order,
+    parentID: input?.parentID,
+  }
+  if (input?.directory !== undefined) return { ...common, directory: input.directory }
+  if (input?.project !== undefined) return { ...common, project: input.project, subpath: input.subpath }
+  return common
+}
+
+function encodeSessionCursor(query: Session.ListInput, anchor: Session.ListAnchor): SessionListCursor {
+  const value = {
+    workspace: query.workspaceID,
+    search: query.search,
+    order: query.order,
+    parentID: query.parentID,
+    anchor,
+    ...("directory" in query ? { directory: query.directory } : {}),
+    ...("project" in query ? { project: query.project, subpath: query.subpath } : {}),
+  }
+  return Buffer.from(JSON.stringify(value)).toString("base64url") as SessionListCursor
+}
+
+function decodeSessionCursor(input: string) {
+  return Effect.try({
+    try: () => JSON.parse(Buffer.from(input, "base64url").toString("utf8")),
+    catch: () => new Error("Invalid cursor"),
+  }).pipe(
+    Effect.flatMap((value) => {
+      if (typeof value !== "object" || value === null) return Effect.fail(new Error("Invalid cursor"))
+      return Schema.decodeUnknownEffect(Session.ListInput)({
+        ...value,
+        workspaceID: "workspace" in value ? value.workspace : undefined,
+      })
+    }),
+    Effect.mapError(() => new Error("Invalid cursor")),
+  )
+}
+
+function encodeMessageCursor(message: SessionMessage.Info, order: "asc" | "desc", direction: "previous" | "next") {
+  return Buffer.from(JSON.stringify({ id: message.id, order, direction })).toString("base64url")
+}
+
+function decodeMessageCursor(input: string) {
+  return Effect.try({
+    try: () => JSON.parse(Buffer.from(input, "base64url").toString("utf8")),
+    catch: () => new Error("Invalid cursor"),
+  }).pipe(
+    Effect.flatMap(Schema.decodeUnknownEffect(MessageCursor)),
+    Effect.mapError(() => new Error("Invalid cursor")),
+  )
+}
+
 export function storage(kv: KV.Interface, pluginID: string): Plugin.Context["storage"] {
  const namespace = `plugin:${pluginID
    .split("")
@@ -70,11 +70,13 @@ export function make(origin = "http://127.0.0.1:1234", interval: Duration.Input
              input: ["text", ...(item.capabilities?.vision ? ["image"] : [])],
              output: ["text"],
            }
-            const context =
-              item.loaded_instances.length === 0
-                ? item.max_context_length
-                : Math.min(...item.loaded_instances.map((instance) => instance.config.context_length))
-            if (context > 0) model.limit.context = context
+            model.limit = {
+              context:
+                item.loaded_instances.length === 0
+                  ? item.max_context_length
+                  : Math.min(...item.loaded_instances.map((instance) => instance.config.context_length)),
+              output: 0,
+            }
          })
        }
      })
@@ -96,10 +96,13 @@ export function make(origin = "http://127.0.0.1:11434", interval: Duration.Input
              input: ["text", ...(item.show.capabilities?.includes("vision") ? ["image"] : [])],
              output: ["text"],
            }
-            const context = Object.entries(item.show.model_info ?? {}).flatMap(([key, value]) =>
-              key.endsWith(".context_length") && typeof value === "number" && value > 0 ? [value] : [],
-            )[0]
-            if (context !== undefined) model.limit.context = context
+            model.limit = {
+              context:
+                Object.entries(item.show.model_info ?? {}).flatMap(([key, value]) =>
+                  key.endsWith(".context_length") && typeof value === "number" && value > 0 ? [value] : [],
+                )[0] ?? 0,
+              output: 0,
+            }
          })
        }
      })
@@ -55,8 +55,7 @@ export function make(origin = "http://127.0.0.1:8000", interval: Duration.Input
            model.name = item.id
            // Tool calling depends on vLLM server flags and parsers that model discovery does not report.
            model.capabilities = { tools: false, input: ["text"], output: ["text"] }
-            if (typeof item.max_model_len === "number" && item.max_model_len > 0)
-              model.limit.context = item.max_model_len
+            model.limit = { context: item.max_model_len ?? 0, output: 0 }
          })
        }
      })
@@ -13,6 +13,7 @@ import { Session } from "../session.js"
 export interface Interface {
  readonly session: Pick<
    Session.Interface,
+    | "list"
    | "get"
    | "create"
    | "messages"
@@ -69,6 +70,7 @@ export const layerWithCell = (cell: Cell) =>
    Service,
    Service.of({
      session: {
+        list: (input) => require(cell, (runtime) => runtime.session.list(input)),
        get: (sessionID) => require(cell, (runtime) => runtime.session.get(sessionID)),
        create: (input) => require(cell, (runtime) => runtime.session.create(input)),
        messages: (input) => require(cell, (runtime) => runtime.session.messages(input)),
@@ -21,11 +21,7 @@ export interface Interface {
  readonly resume: (sessionID: SessionSchema.ID) => Effect.Effect<void, SessionRunner.RunError>
  /** Registers newly recorded work. Repeated wakeups may coalesce. */
  readonly wake: (sessionID: SessionSchema.ID) => Effect.Effect<void>
-  /**
-   * Interrupt active work owned by this process. Idle interruption is a no-op. Resolves once
-   * the interruption is accepted; cleanup settles asynchronously in the execution fiber.
-   * Compose with `awaitIdle` when settlement matters.
-   */
+  /** Interrupt active work owned by this process. Idle interruption is a no-op. */
  readonly interrupt: (sessionID: SessionSchema.ID, options?: { readonly continue?: boolean }) => Effect.Effect<void>
  /** Resolves once this process owns no active execution for the Session. Returns immediately when idle and never starts work. */
  readonly awaitIdle: (sessionID: SessionSchema.ID) => Effect.Effect<void>
@@ -145,11 +141,6 @@ export const layer = Layer.effect(
          // Resume steering input and between-turn control work from the interrupted
          // intent. Queued next-turn prompts stay parked: a steer-scoped drain never
          // promotes them, and a control item behind a queued prompt waits its turn.
-          // Interruption acknowledges before cleanup settles, so this wake usually lands
-          // on the stopping execution's doorbell and starts the successor at settle.
-          // Reading the inbox concurrently with the dying drain is safe: delivery consumes
-          // rows inside uninterruptible publications, so a steer row is either still
-          // promotable here or was fully delivered and needs no resumption.
          const next = yield* SessionInbox.nextPromotable(db, sessionID, "input")
          if (next === undefined) return
          if (next.delivery === "steer" || next.type === "compaction" || next.type === "move")
@@ -11,11 +11,7 @@ export interface Coordinator<Key, E, Reason = never> {
  readonly run: (key: Key) => Effect.Effect<void, E>
  /** Rings the doorbell: an idle key starts an execution; an active one drains again before settling. */
  readonly wake: (key: Key, scope?: Promotable) => Effect.Effect<void>
-  /**
-   * Stops the active execution and clears its doorbell. No-op when idle. Resolves once the
-   * interruption is accepted, not when cleanup settles: the execution fiber finishes its
-   * finalizers and settled hook on its own time. Compose with `awaitIdle` for settlement.
-   */
+  /** Stops the active execution, clears its doorbell, and waits for cleanup. No-op when idle. */
  readonly interrupt: (key: Key, reason?: Reason) => Effect.Effect<void>
  /** Resolves once no execution is active for the key. Returns immediately when already idle and never starts work. */
  readonly awaitIdle: (key: Key) => Effect.Effect<void>
@@ -30,13 +26,7 @@ export interface Coordinator<Key, E, Reason = never> {
 * with this execution's exit.
 */
 type Execution<E, Reason> = {
-  /**
-   * Resolves with the execution's exit as a success value. Success-valued on purpose:
-   * completing a Deferred with an interrupted exit interrupts suspended waiters as it
-   * resumes them, and can starve later waiters of their resume entirely
-   * (Effect-TS/effect#7364). Joiners flatten the exit; idleness waiters just await.
-   */
-  readonly done: Deferred.Deferred<Exit.Exit<void, E>>
+  readonly done: Deferred.Deferred<void, E>
  owner?: Fiber.Fiber<void>
  scope: Promotable
  pendingWake?: Promotable
@@ -84,7 +74,7 @@ export const make = <Key, E, Reason = never>(options: {

    const start = (key: Key, force: boolean, scope: Promotable) => {
      const execution: Execution<E, Reason> = {
-        done: Deferred.makeUnsafe<Exit.Exit<void, E>>(),
+        done: Deferred.makeUnsafe<void, E>(),
        scope,
        stopping: false,
      }
@@ -114,7 +104,7 @@ export const make = <Key, E, Reason = never>(options: {
    const settle = (key: Key, execution: Execution<E, Reason>, exit: Exit.Exit<void, E>) => {
      if (execution.pendingWake) start(key, false, execution.pendingWake)
      else executions.delete(key)
-      Deferred.doneUnsafe(execution.done, Exit.succeed(exit))
+      Deferred.doneUnsafe(execution.done, exit)
    }

    const run = (key: Key): Effect.Effect<void, E> =>
@@ -123,9 +113,9 @@ export const make = <Key, E, Reason = never>(options: {
        if (execution !== undefined) {
          // A stopping execution refuses joiners: wait out its cleanup, then run fresh.
          if (execution.stopping) return Deferred.await(execution.done).pipe(Effect.andThen(run(key)))
-          return Deferred.await(execution.done).pipe(Effect.flatten)
+          return Deferred.await(execution.done)
        }
-        return Deferred.await(start(key, true, "input").done).pipe(Effect.flatten)
+        return Deferred.await(start(key, true, "input").done)
      })

    const wake = (key: Key, scope: Promotable = "input") =>
@@ -142,23 +132,13 @@ export const make = <Key, E, Reason = never>(options: {
    const interrupt = (key: Key, reason?: Reason): Effect.Effect<void> =>
      Effect.suspend(() => {
        const execution = executions.get(key)
-        if (execution === undefined || execution.stopping) return Effect.void
-        if (execution.owner === undefined) {
-          // Settlement window: the owner exited but the settled hook has not finished. The
-          // terminal outcome is already decided, so no reason attaches — but the interrupt
-          // still claims the recorded wakes so settle does not start a dead-intent successor.
-          execution.pendingWake = undefined
-          return Effect.void
-        }
+        if (execution?.owner === undefined || execution.stopping) return Effect.void
        execution.stopping = true
        // Wakes recorded so far belong to the interrupted intent; the interrupt claims them.
        // Wakes arriving during cleanup are new admissions and restart normally at settle.
        execution.pendingWake = undefined
        execution.interruptionReason = reason
-        // Fire and forget: nobody benefits from waiting out cleanup here, and callers like
-        // the interrupt endpoint must acknowledge immediately even when finalizers are slow.
-        fork(Fiber.interrupt(execution.owner))
-        return Effect.void
+        return Fiber.interrupt(execution.owner)
      })

    // One execution's `done` already spans coalesced continuations; re-check after it
@@ -167,7 +147,7 @@ export const make = <Key, E, Reason = never>(options: {
      Effect.suspend(() => {
        const execution = executions.get(key)
        if (execution === undefined) return Effect.void
-        return Deferred.await(execution.done).pipe(Effect.andThen(awaitIdle(key)))
+        return Deferred.await(execution.done).pipe(Effect.exit, Effect.andThen(awaitIdle(key)))
      })

    return { active: Effect.sync(() => new Set(executions.keys())), run, wake, interrupt, awaitIdle }
@@ -1,261 +0,0 @@
-export * as SessionStats from "./stats.js"
-
-import { DateTime, Effect, Option, Schema } from "effect"
-import { and, eq, gte, inArray, lt } from "drizzle-orm"
-import { Money } from "@opencode-ai/schema/money"
-import { Project } from "@opencode-ai/schema/project"
-import { SessionEvent } from "@opencode-ai/schema/session-event"
-import { SessionMessage } from "@opencode-ai/schema/session-message"
-import { Database } from "../database/database.js"
-import { EventTable } from "../event/sql.js"
-import { SessionMessageTable, SessionTable } from "./sql.js"
-
-type Input = {
-  readonly from?: number
-  readonly to?: number
-  readonly projectID?: Project.ID
-  readonly timezone?: string
-}
-
-type Tokens = {
-  input: number
-  output: number
-  reasoning: number
-  cache: { read: number; write: number }
-}
-
-type ModelAggregate = {
-  model: SessionMessage.Assistant["model"]
-  steps: number
-  tokens: Tokens
-  cost: number
-}
-
-type ToolAggregate = {
-  name: string
-  calls: number
-  succeeded: number
-  failed: number
-  unfinished: number
-  durations: number[]
-}
-
-const decodeMessage = Schema.decodeUnknownOption(SessionMessage.Info)
-const decodeUsage = Schema.decodeUnknownOption(SessionEvent.UsageRecorded.data)
-
-export const get = Effect.fn("SessionStats.get")(function* (input: Input = {}) {
-  const db = (yield* Database.Service).db
-  const rows = yield* db
-    .select({
-      id: SessionMessageTable.id,
-      sessionID: SessionMessageTable.session_id,
-      parentID: SessionTable.parent_id,
-      type: SessionMessageTable.type,
-      data: SessionMessageTable.data,
-      timeCreated: SessionMessageTable.time_created,
-    })
-    .from(SessionMessageTable)
-    .innerJoin(SessionTable, eq(SessionMessageTable.session_id, SessionTable.id))
-    .where(
-      and(
-        inArray(SessionMessageTable.type, ["user", "assistant"]),
-        input.from === undefined ? undefined : gte(SessionMessageTable.time_created, input.from),
-        input.to === undefined ? undefined : lt(SessionMessageTable.time_created, input.to),
-        input.projectID === undefined ? undefined : eq(SessionTable.project_id, input.projectID),
-      ),
-    )
-    .all()
-    .pipe(Effect.orDie)
-  const sessionIDs = [...new Set(rows.map((row) => row.sessionID))]
-  const events = (yield* Effect.forEach(
-    Array.from({ length: Math.ceil(sessionIDs.length / 500) }, (_, index) =>
-      sessionIDs.slice(index * 500, (index + 1) * 500),
-    ),
-    (batch) =>
-      db
-        .select({
-          created: EventTable.created,
-          data: EventTable.data,
-        })
-        .from(EventTable)
-        .where(
-          and(
-            inArray(EventTable.aggregate_id, batch),
-            eq(EventTable.type, SessionEvent.UsageRecorded.type),
-            input.from === undefined ? undefined : gte(EventTable.created, input.from),
-            input.to === undefined ? undefined : lt(EventTable.created, input.to),
-          ),
-        )
-        .all()
-        .pipe(Effect.orDie),
-    { concurrency: 4 },
-  )).flat()
-
-  const sessions = new Set<string>()
-  const subagents = new Set<string>()
-  const activity = new Map<string, number>()
-  const models = new Map<string, ModelAggregate>()
-  const tools = new Map<string, ToolAggregate>()
-  const totals = {
-    prompts: 0,
-    steps: 0,
-    tokens: emptyTokens(),
-    cost: 0,
-    tools: { calls: 0, succeeded: 0, failed: 0, unfinished: 0 },
-  }
-  const dateKey = makeDateKey(input.timezone)
-
-  rows.forEach((row) => {
-    const decoded = decodeMessage({ ...row.data, id: row.id, type: row.type })
-    if (Option.isNone(decoded)) return
-    const message = decoded.value
-    if (row.parentID) subagents.add(row.sessionID)
-    else sessions.add(row.sessionID)
-
-    if (message.type === "user") {
-      if (!row.parentID) totals.prompts++
-      return
-    }
-    if (message.type !== "assistant") return
-
-    totals.steps++
-    const tokens = message.tokens ?? emptyTokens()
-    const cost = message.cost ?? 0
-    addTokens(totals.tokens, tokens)
-    totals.cost += cost
-    const day = dateKey(DateTime.toEpochMillis(message.time.created))
-    activity.set(day, (activity.get(day) ?? 0) + 1)
-
-    const modelKey = `${message.model.providerID}/${message.model.id}#${message.model.variant ?? ""}`
-    const model = models.get(modelKey) ?? { model: message.model, steps: 0, tokens: emptyTokens(), cost: 0 }
-    models.set(modelKey, model)
-    model.steps++
-    model.cost += cost
-    addTokens(model.tokens, tokens)
-
-    message.content
-      .filter((content): content is SessionMessage.AssistantTool => content.type === "tool")
-      .forEach((content) => {
-        const tool = tools.get(content.name) ?? {
-          name: content.name,
-          calls: 0,
-          succeeded: 0,
-          failed: 0,
-          unfinished: 0,
-          durations: [],
-        }
-        tools.set(content.name, tool)
-        tool.calls++
-        totals.tools.calls++
-        if (content.state.status === "completed") {
-          tool.succeeded++
-          totals.tools.succeeded++
-        } else if (content.state.status === "error") {
-          tool.failed++
-          totals.tools.failed++
-        } else {
-          tool.unfinished++
-          totals.tools.unfinished++
-        }
-        if (content.time.completed === undefined) return
-        tool.durations.push(
-          DateTime.toEpochMillis(content.time.completed) -
-            DateTime.toEpochMillis(content.time.ran ?? content.time.created),
-        )
-      })
-  })
-
-  events.forEach((row) => {
-    const decoded = decodeUsage(row.data)
-    if (Option.isNone(decoded)) return
-    addTokens(totals.tokens, decoded.value.tokens)
-    totals.cost += decoded.value.cost
-  })
-
-  const days = [...activity.entries()].sort(([a], [b]) => a.localeCompare(b))
-  const now = Date.now()
-  const fallback = input.to ?? now
-  const earliestMessage = rows.reduce((earliest, row) => Math.min(earliest, row.timeCreated), fallback)
-  const earliest = events.reduce((value, event) => Math.min(value, event.created), earliestMessage)
-  const from = input.from ?? earliest
-  const to = input.to ?? now
-
-  return {
-    range: { from: DateTime.makeUnsafe(from), to: DateTime.makeUnsafe(to) },
-    sessions: sessions.size,
-    subagents: subagents.size,
-    prompts: totals.prompts,
-    steps: totals.steps,
-    tokens: totals.tokens,
-    cost: Money.USD.make(totals.cost),
-    tools: totals.tools,
-    activeDays: days.length,
-    streak: longestStreak(days.map(([date]) => date)),
-    activity: days.map(([date, steps]) => ({ date, steps })),
-    models: [...models.values()]
-      .sort((a, b) => tokenTotal(b.tokens) - tokenTotal(a.tokens))
-      .map((model) => ({ ...model, cost: Money.USD.make(model.cost) })),
-    toolUsage: [...tools.values()]
-      .sort((a, b) => b.calls - a.calls)
-      .map((tool) => ({
-        name: tool.name,
-        calls: tool.calls,
-        succeeded: tool.succeeded,
-        failed: tool.failed,
-        unfinished: tool.unfinished,
-        durationP50: median(tool.durations),
-      })),
-  }
-})
-
-function emptyTokens(): Tokens {
-  return { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } }
-}
-
-function addTokens(target: Tokens, source: Tokens) {
-  target.input += source.input
-  target.output += source.output
-  target.reasoning += source.reasoning
-  target.cache.read += source.cache.read
-  target.cache.write += source.cache.write
-}
-
-function tokenTotal(tokens: Tokens) {
-  return tokens.input + tokens.output + tokens.reasoning + tokens.cache.read + tokens.cache.write
-}
-
-function makeDateKey(timezone = "UTC") {
-  const formatter = new Intl.DateTimeFormat("en-US", {
-    timeZone: timezone,
-    year: "numeric",
-    month: "2-digit",
-    day: "2-digit",
-  })
-  return (time: number) => {
-    const parts = Object.fromEntries(formatter.formatToParts(time).map((part) => [part.type, part.value]))
-    return `${parts.year}-${parts.month}-${parts.day}`
-  }
-}
-
-function longestStreak(days: string[]) {
-  return days.reduce(
-    (result, day, index) => {
-      const previous = days[index - 1]
-      const current = previous && dayOrdinal(day) - dayOrdinal(previous) === 1 ? result.current + 1 : 1
-      return { current, longest: Math.max(result.longest, current) }
-    },
-    { current: 0, longest: 0 },
-  ).longest
-}
-
-function dayOrdinal(value: string) {
-  const [year, month, day] = value.split("-").map(Number)
-  return Math.floor(Date.UTC(year, month - 1, day) / 86_400_000)
-}
-
-function median(values: number[]) {
-  if (values.length === 0) return undefined
-  const sorted = values.toSorted((a, b) => a - b)
-  const middle = Math.floor(sorted.length / 2)
-  return sorted.length % 2 === 0 ? (sorted[middle - 1] + sorted[middle]) / 2 : sorted[middle]
-}
@@ -236,6 +236,7 @@ describe("ModelResolver", () => {
        endpoint: { baseURL: "https://openai.example/v1" },
        defaults: {
          headers: { "x-test": "header" },
+          limits: { context: 100, input: 80, output: 20 },
          http: { body: { custom_extension: { enabled: true } } },
        },
      })
@@ -784,6 +785,7 @@ describe("ModelResolver", () => {
                  region: "test",
                  headers: { "x-package": "header" },
                  body: { custom: true },
+                  limits: { context: 100, output: 20 },
                })
                return LanguageModel.make({ id: modelID, provider: "package-provider", route: native.route })
              },
@@ -911,6 +913,7 @@ describe("ModelResolver", () => {
                    baseURL: "https://provider.example/v1",
                    headers: { "x-provider": "header" },
                    body: { custom: true },
+                    limits: { context: 100, output: 20 },
                    providerOptions,
                  })
                  return LanguageModel.make({ id: modelID, provider: "native-provider", route: native.route })
@@ -1,6 +1,6 @@
 import { describe, expect } from "bun:test"
 import { ToolFailure } from "@opencode-ai/ai"
-import { Context, Effect, Exit, Fiber, Schema, Stream } from "effect"
+import { Context, DateTime, Effect, Exit, Fiber, Schema, Stream } from "effect"
 import { Plugin as EffectPlugin } from "@opencode-ai/plugin/effect"
 import { Config as ConfigSchema } from "@opencode-ai/schema/config"
 import { Agent } from "@opencode-ai/core/agent"
@@ -14,6 +14,7 @@ import { AbsolutePath } from "@opencode-ai/core/schema"
 import { Session } from "@opencode-ai/core/session"
 import { SessionMessage } from "@opencode-ai/core/session/message"
 import { Tool } from "@opencode-ai/core/tool"
+import { Money } from "@opencode-ai/schema/money"
 import { testEffect } from "./lib/effect"
 import { PluginTestLayer } from "./plugin/fixture"

@@ -24,6 +25,57 @@ class Secret extends Context.Service<Secret, string>()("@opencode/test/PluginSec
 const versioned = <R>(plugin: EffectPlugin.Plugin<R>, version = "1") => ({ ...plugin, version })

 describe("Plugin", () => {
+  it.effect("exposes paginated session history reads", () =>
+    Effect.gen(function* () {
+      const plugins = yield* Plugin.Service
+      const runtime = yield* PluginRuntime.Service
+      const location = yield* Location.Service
+      const parentID = Session.ID.make("ses_parent")
+      const child = (id: string, updated: number) =>
+        Session.Info.make({
+          id: Session.ID.make(id),
+          parentID,
+          projectID: location.project.id,
+          cost: Money.USD.make(0),
+          tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+          time: { created: DateTime.makeUnsafe(updated), updated: DateTime.makeUnsafe(updated) },
+          location: Location.Ref.make({ directory: location.directory }),
+        })
+      const firstChild = child("ses_first", 1)
+      const secondChild = child("ses_second", 2)
+      const seen: unknown[] = []
+      const host = yield* PluginHost.make(plugins).pipe(
+        Effect.provideService(
+          PluginRuntime.Service,
+          PluginRuntime.Service.of({
+            ...runtime,
+            session: {
+              ...runtime.session,
+              list: (input) => {
+                seen.push(input)
+                return Effect.succeed({ data: [input?.anchor === undefined ? firstChild : secondChild] })
+              },
+              messages: (input) => {
+                seen.push(input)
+                return Effect.succeed([])
+              },
+            },
+          }),
+        ),
+      )
+
+      const first = yield* host.session.children({ sessionID: parentID, limit: 1 })
+      const second = yield* host.session.children({ sessionID: parentID, limit: 1, cursor: first.cursor.next })
+      const messages = yield* host.session.messages({ sessionID: parentID })
+
+      expect(first.data).toHaveLength(1)
+      expect(second.data).toHaveLength(1)
+      expect(second.data[0]?.id).not.toBe(first.data[0]?.id)
+      expect(messages.data).toEqual([])
+      expect(seen).toHaveLength(3)
+    }),
+  )
+
  it.live("exposes public events through the plugin context", () =>
    Effect.gen(function* () {
      const plugins = yield* Plugin.Service
@@ -115,6 +115,9 @@ export function host(overrides: Overrides = {}): Plugin.Context {
    },
    session: {
      hook: overrides.session?.hook ?? (() => Effect.die("unused session.hook")),
+      list: overrides.session?.list ?? (() => Effect.die("unused session.list")),
+      children: overrides.session?.children ?? (() => Effect.die("unused session.children")),
+      messages: overrides.session?.messages ?? (() => Effect.die("unused session.messages")),
      create: overrides.session?.create ?? (() => Effect.die("unused session.create")),
      get: overrides.session?.get ?? (() => Effect.die("unused session.get")),
      prompt: overrides.session?.prompt ?? (() => Effect.die("unused session.prompt")),
@@ -100,6 +100,41 @@ describe("fromPromise", () => {
    }),
  )

+  it.effect("adapts session history reads through the protocol schema", () =>
+    Effect.gen(function* () {
+      const seen: unknown[] = []
+      const host = testHost({
+        session: {
+          list: (input) => {
+            seen.push(input)
+            return Effect.succeed({ data: [], cursor: {} })
+          },
+          messages: (input) => {
+            seen.push(input)
+            return Effect.succeed({ data: [], cursor: {} })
+          },
+        },
+      })
+
+      yield* PluginPromise.fromPromise(
+        define({
+          id: "promise-session-history",
+          setup: async (ctx) => {
+            await ctx.session.list({ parentID: null, limit: 2 })
+            await ctx.session.children({ sessionID: Session.ID.make("ses_parent"), limit: 3 })
+            await ctx.session.messages({ sessionID: Session.ID.make("ses_parent"), limit: 4, order: "asc" })
+          },
+        }),
+      ).effect(host)
+
+      expect(seen).toEqual([
+        { parentID: null, limit: 2 },
+        { parentID: "ses_parent", limit: 3 },
+        { sessionID: "ses_parent", limit: 4, order: "asc" },
+      ])
+    }),
+  )
+
  it.effect("forwards transient session generation", () =>
    Effect.gen(function* () {
      const host = testHost({
@@ -71,13 +71,6 @@ describe("LMStudioPlugin", () => {
                  max_context_length: 131_072,
                  capabilities: { vision: false, trained_for_tool_use: false },
                },
-                {
-                  type: "llm",
-                  key: "unknown-context",
-                  display_name: "Unknown Context",
-                  loaded_instances: [],
-                  max_context_length: 0,
-                },
                {
                  type: "embedding",
                  key: "nomic-embed",
@@ -111,14 +104,11 @@ describe("LMStudioPlugin", () => {
            family: "gemma4",
            name: "Gemma 4 26B A4B",
            capabilities: { tools: true, input: ["text", "image"], output: ["text"] },
-            limit: { context: 16_384, output: 32_000 },
+            limit: { context: 16_384, output: 0 },
          })
          expect(yield* catalog.model.get(providerID, Model.ID.make("deepseek-r1"))).toMatchObject({
            capabilities: { tools: false, input: ["text"], output: ["text"] },
-            limit: { context: 131_072, output: 32_000 },
-          })
-          expect(yield* catalog.model.get(providerID, Model.ID.make("unknown-context"))).toMatchObject({
-            limit: { context: 200_000, output: 32_000 },
+            limit: { context: 131_072, output: 0 },
          })
          expect(yield* catalog.model.get(providerID, Model.ID.make("nomic-embed"))).toBeUndefined()
        }),
@@ -54,7 +54,6 @@ describe("OllamaPlugin", () => {
                return Response.json({
                  models: [
                    summary("gemma3:4b", "gemma-digest", "gemma3"),
-                    summary("unknown-context", "unknown-digest"),
                    summary("nomic-embed", "embed-digest"),
                    summary("removed-model", "removed-digest"),
                  ],
@@ -69,8 +68,6 @@ describe("OllamaPlugin", () => {
                      capabilities: ["completion", "tools", "vision"],
                      model_info: { "gemma3.context_length": 131_072 },
                    }
-                  : body.model === "unknown-context"
-                    ? show({ family: "unknown", capabilities: ["completion"], context: 0 })
                  : show({ family: "nomic-bert", capabilities: ["embedding"], context: 8192 }),
              )
            },
@@ -101,10 +98,7 @@ describe("OllamaPlugin", () => {
            name: "gemma3:4b",
            family: "gemma3",
            capabilities: { tools: true, input: ["text", "image"], output: ["text"] },
-            limit: { context: 131_072, output: 32_000 },
-          })
-          expect(yield* catalog.model.get(providerID, Model.ID.make("unknown-context"))).toMatchObject({
-            limit: { context: 200_000, output: 32_000 },
+            limit: { context: 131_072, output: 0 },
          })
          expect(yield* catalog.model.get(providerID, Model.ID.make("nomic-embed"))).toBeUndefined()
          expect(requests).toContainEqual({ method: "GET", path: "/api/tags" })
@@ -63,11 +63,7 @@ describe("VLLMPlugin", () => {
              state.models++
              return Response.json({
                object: "list",
-                data: [
-                  remoteModel("Qwen/Qwen3-Coder", 65_536),
-                  remoteModel("unknown-limit", 0),
-                  remoteModel("foreign-model", 4096, "other"),
-                ],
+                data: [remoteModel("Qwen/Qwen3-Coder", 65_536), remoteModel("foreign-model", 4096, "other")],
              })
            },
          }),
@@ -101,10 +97,7 @@ describe("VLLMPlugin", () => {
            modelID: "Qwen/Qwen3-Coder",
            name: "Qwen/Qwen3-Coder",
            capabilities: { tools: false, input: ["text"], output: ["text"] },
-            limit: { context: 65_536, output: 32_000 },
-          })
-          expect(yield* catalog.model.get(providerID, Model.ID.make("unknown-limit"))).toMatchObject({
-            limit: { context: 200_000, output: 32_000 },
+            limit: { context: 65_536, output: 0 },
          })
          expect(yield* catalog.model.get(providerID, Model.ID.make("foreign-model"))).toBeUndefined()
        }),
@@ -28,7 +28,7 @@ const location = Location.Ref.make({ directory: AbsolutePath.make("/project") })
 const model = LanguageModel.make({
  id: "summary-model",
  provider: "test",
-  route: OpenAIChat.route,
+  route: OpenAIChat.route.with({ limits: { context: 10_000, output: 1_000 } }),
 })
 let requests: LLMRequest[] = []
 const client = Layer.mock(LLMClient.Service)({
@@ -30,7 +30,7 @@ let requests: LLMRequest[] = []
 const model = LanguageModel.make({
  id: "summary-model",
  provider: "test",
-  route: OpenAIChat.route,
+  route: OpenAIChat.route.with({ limits: { context: 10_000, output: 1_000 } }),
 })
 const cost = [
  {
@@ -622,7 +622,6 @@ describe("SessionRunCoordinator", () => {
        yield* coordinator.wake("session")
        yield* Deferred.await(started)
        yield* coordinator.interrupt("session")
-        yield* coordinator.awaitIdle("session")

        expect(settled).toHaveLength(1)
        expect(settled[0] !== undefined && Exit.isFailure(settled[0]) && Cause.hasInterrupts(settled[0].cause)).toBe(
@@ -633,69 +632,6 @@ describe("SessionRunCoordinator", () => {
    ),
  )

-  it.effect("acknowledges interruption before cleanup settles", () =>
-    Effect.scoped(
-      Effect.gen(function* () {
-        const started = yield* Deferred.make<void>()
-        const cleanupStarted = yield* Deferred.make<void>()
-        const cleanupGate = yield* Deferred.make<void>()
-        const settled: Array<string | undefined> = []
-        const coordinator = yield* SessionRunCoordinator.make<string, never, string>({
-          drain: () =>
-            Deferred.succeed(started, undefined).pipe(
-              Effect.andThen(Effect.never),
-              Effect.onInterrupt(() =>
-                Deferred.succeed(cleanupStarted, undefined).pipe(Effect.andThen(Deferred.await(cleanupGate))),
-              ),
-            ),
-          settled: (_key, _exit, reason) => Effect.sync(() => void settled.push(reason)),
-        })
-
-        yield* coordinator.wake("session")
-        yield* Deferred.await(started)
-        // Interrupt resolves while the cleanup gate is still closed: acceptance, not settlement.
-        yield* coordinator.interrupt("session", "user")
-        expect(settled).toHaveLength(0)
-        expect(Array.from(yield* coordinator.active)).toEqual(["session"])
-        // Repeating the interrupt during cleanup stays an immediate no-op.
-        yield* coordinator.interrupt("session", "user")
-
-        yield* Deferred.await(cleanupStarted)
-        yield* Deferred.succeed(cleanupGate, undefined)
-        yield* coordinator.awaitIdle("session")
-
-        expect(settled).toEqual(["user"])
-        expect(yield* coordinator.active).toEqual(new Set())
-      }),
-    ),
-  )
-
-  it.effect("an interrupt during terminal settlement claims the recorded wake", () =>
-    Effect.scoped(
-      Effect.gen(function* () {
-        const settling = yield* Deferred.make<void>()
-        const release = yield* Deferred.make<void>()
-        let drains = 0
-        const coordinator = yield* SessionRunCoordinator.make({
-          drain: () => Effect.sync(() => void drains++),
-          settled: () => Deferred.succeed(settling, undefined).pipe(Effect.andThen(Deferred.await(release))),
-        })
-
-        yield* coordinator.wake("session")
-        yield* Deferred.await(settling)
-        // The owner has exited; this wake lands on the settling execution's doorbell.
-        yield* coordinator.wake("session")
-        // The interrupt claims it: settle must not start a successor for the dead intent.
-        yield* coordinator.interrupt("session")
-        yield* Deferred.succeed(release, undefined)
-        yield* coordinator.awaitIdle("session")
-
-        expect(drains).toBe(1)
-        expect(yield* coordinator.active).toEqual(new Set())
-      }),
-    ),
-  )
-
  it.effect("trampolines synchronous self-waking execution", () =>
    Effect.scoped(
      Effect.gen(function* () {
@@ -2857,17 +2857,11 @@ describe("SessionRunnerLLM", () => {

      yield* TestLLM.push(
        TestLLM.stop(
-          LLMEvent.textStart({
-            id: "commentary",
-            providerMetadata: { openai: { itemId: "msg_commentary", phase: "commentary" } },
-          }),
+          LLMEvent.textStart({ id: "commentary", providerMetadata: { openai: { phase: "commentary" } } }),
          LLMEvent.textDelta({ id: "commentary", text: "Checking." }),
          LLMEvent.textEnd({
            id: "commentary",
-            providerMetadata: {
-              openai: { itemId: "msg_commentary", phase: "commentary" },
-              anthropic: { ignored: true },
-            },
+            providerMetadata: { openai: { phase: "commentary" }, anthropic: { ignored: true } },
          }),
        ),
      )
@@ -2878,7 +2872,7 @@ describe("SessionRunnerLLM", () => {
        { type: "user", text: "Check first" },
        {
          type: "assistant",
-          content: [{ type: "text", text: "Checking.", state: { itemId: "msg_commentary", phase: "commentary" } }],
+          content: [{ type: "text", text: "Checking.", state: { phase: "commentary" } }],
        },
      ])

@@ -2890,7 +2884,7 @@ describe("SessionRunnerLLM", () => {
        {
          type: "text",
          text: "Checking.",
-          providerMetadata: { openai: { itemId: "msg_commentary", phase: "commentary" } },
+          providerMetadata: { openai: { phase: "commentary" } },
        },
      ])
    }),
@@ -1,185 +0,0 @@
-import { describe, expect } from "bun:test"
-import { Agent } from "@opencode-ai/schema/agent"
-import { Event } from "@opencode-ai/schema/event"
-import { Model } from "@opencode-ai/schema/model"
-import { Money } from "@opencode-ai/schema/money"
-import { Project } from "@opencode-ai/schema/project"
-import { Provider } from "@opencode-ai/schema/provider"
-import { Session } from "@opencode-ai/schema/session"
-import { SessionEvent } from "@opencode-ai/schema/session-event"
-import { SessionMessage } from "@opencode-ai/schema/session-message"
-import { AbsolutePath } from "@opencode-ai/core/schema"
-import { Database } from "@opencode-ai/core/database/database"
-import { EventSequenceTable, EventTable } from "@opencode-ai/core/event/sql"
-import { ProjectTable } from "@opencode-ai/core/project/sql"
-import { SessionMessageTable, SessionTable } from "@opencode-ai/core/session/sql"
-import { SessionStats } from "@opencode-ai/core/session/stats"
-import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
-import { DateTime, Effect, Schema } from "effect"
-import { testEffect } from "./lib/effect"
-
-const it = testEffect(AppNodeBuilder.build(Database.node))
-const projectID = Project.ID.make("stats-project")
-const sessionID = Session.ID.make("ses_stats_root")
-const childID = Session.ID.make("ses_stats_child")
-const encodeMessage = Schema.encodeSync(SessionMessage.Info)
-const encodeUsage = Schema.encodeSync(SessionEvent.UsageRecorded.data)
-
-describe("SessionStats", () => {
-  it.effect("aggregates activity and tool reliability without reading message payloads outside the range", () =>
-    Effect.gen(function* () {
-      const db = (yield* Database.Service).db
-      yield* db
-        .insert(ProjectTable)
-        .values({ id: projectID, worktree: AbsolutePath.make("/stats"), name: "stats", sandboxes: [] })
-        .run()
-        .pipe(Effect.orDie)
-      yield* db
-        .insert(SessionTable)
-        .values([
-          { id: sessionID, project_id: projectID, slug: "root", directory: "/stats", version: "test" },
-          {
-            id: childID,
-            project_id: projectID,
-            parent_id: sessionID,
-            slug: "child",
-            directory: "/stats",
-            version: "test",
-          },
-        ])
-        .run()
-        .pipe(Effect.orDie)
-      yield* db
-        .insert(SessionMessageTable)
-        .values([
-          messageRow(
-            sessionID,
-            1,
-            SessionMessage.User.make({
-              id: SessionMessage.ID.make("msg_stats_user"),
-              type: "user",
-              text: "hello",
-              time: { created: DateTime.makeUnsafe(Date.UTC(2026, 0, 2, 9)) },
-            }),
-          ),
-          messageRow(
-            sessionID,
-            2,
-            assistant("msg_stats_assistant", Date.UTC(2026, 0, 2, 10), [
-              SessionMessage.AssistantTool.make({
-                type: "tool",
-                id: "call_read",
-                name: "read",
-                state: SessionMessage.ToolStateCompleted.make({
-                  status: "completed",
-                  input: {},
-                  content: [{ type: "text", text: "ok" }],
-                }),
-                time: {
-                  created: DateTime.makeUnsafe(Date.UTC(2026, 0, 2, 10)),
-                  ran: DateTime.makeUnsafe(Date.UTC(2026, 0, 2, 10, 0, 1)),
-                  completed: DateTime.makeUnsafe(Date.UTC(2026, 0, 2, 10, 0, 1, 250)),
-                },
-              }),
-              SessionMessage.AssistantTool.make({
-                type: "tool",
-                id: "call_edit",
-                name: "edit",
-                state: SessionMessage.ToolStateError.make({
-                  status: "error",
-                  input: {},
-                  error: { type: "tool", message: "failed" },
-                }),
-                time: {
-                  created: DateTime.makeUnsafe(Date.UTC(2026, 0, 2, 10)),
-                  completed: DateTime.makeUnsafe(Date.UTC(2026, 0, 2, 10, 0, 2)),
-                },
-              }),
-            ]),
-          ),
-          messageRow(childID, 1, assistant("msg_stats_child", Date.UTC(2026, 0, 3, 10), [], "large", 2)),
-          messageRow(sessionID, 3, assistant("msg_stats_outside", Date.UTC(2025, 11, 31, 10), [])),
-        ])
-        .run()
-        .pipe(Effect.orDie)
-      yield* db
-        .insert(EventSequenceTable)
-        .values([
-          { aggregate_id: sessionID, seq: 0 },
-          { aggregate_id: childID, seq: 0 },
-        ])
-        .run()
-        .pipe(Effect.orDie)
-      yield* db
-        .insert(EventTable)
-        .values({
-          id: Event.ID.make("evt_stats_usage"),
-          aggregate_id: sessionID,
-          seq: 0,
-          created: Date.UTC(2026, 0, 2, 10, 0, 3),
-          type: SessionEvent.UsageRecorded.type,
-          data: encodeUsage({
-            sessionID,
-            source: "title",
-            cost: Money.USD.make(0.5),
-            tokens: { input: 1, output: 1, reasoning: 1, cache: { read: 1, write: 1 } },
-          }),
-        })
-        .run()
-        .pipe(Effect.orDie)
-
-      const stats = yield* SessionStats.get({
-        from: Date.UTC(2026, 0, 1),
-        to: Date.UTC(2026, 1, 1),
-        timezone: "UTC",
-      })
-
-      expect(stats.sessions).toBe(1)
-      expect(stats.subagents).toBe(1)
-      expect(stats.prompts).toBe(1)
-      expect(stats.steps).toBe(2)
-      expect(stats.tokens).toEqual({ input: 31, output: 16, reasoning: 7, cache: { read: 13, write: 4 } })
-      expect(stats.cost).toBe(Money.USD.make(5))
-      expect(stats.tools).toEqual({ calls: 2, succeeded: 1, failed: 1, unfinished: 0 })
-      expect(stats.activity).toEqual([
-        { date: "2026-01-02", steps: 1 },
-        { date: "2026-01-03", steps: 1 },
-      ])
-      expect(stats.streak).toBe(2)
-      expect(stats.models.map((model) => String(model.model.id))).toEqual(["large", "sonnet"])
-      expect(stats.toolUsage).toMatchObject([
-        { name: "read", calls: 1, succeeded: 1, failed: 0, durationP50: 250 },
-        { name: "edit", calls: 1, succeeded: 0, failed: 1, durationP50: 2_000 },
-      ])
-    }),
-  )
-})
-
-function assistant(
-  id: string,
-  created: number,
-  content: SessionMessage.AssistantContent[],
-  model = "sonnet",
-  scale = 1,
-) {
-  return SessionMessage.Assistant.make({
-    id: SessionMessage.ID.make(id),
-    type: "assistant",
-    agent: Agent.ID.make("build"),
-    model: { id: Model.ID.make(model), providerID: Provider.ID.make("anthropic") },
-    content,
-    cost: Money.USD.make(1.5 * scale),
-    tokens: { input: 10 * scale, output: 5 * scale, reasoning: 2 * scale, cache: { read: 4 * scale, write: scale } },
-    time: { created: DateTime.makeUnsafe(created), completed: DateTime.makeUnsafe(created + 2_000) },
-  })
-}
-
-function messageRow(
-  sessionID: Session.ID,
-  seq: number,
-  message: SessionMessage.Info,
-): typeof SessionMessageTable.$inferInsert {
-  const encoded = encodeMessage(message)
-  const { id, type, ...data } = encoded
-  return { id: SessionMessage.ID.make(id), session_id: sessionID, type, seq, time_created: encoded.time.created, data }
-}
@@ -27,7 +27,7 @@ let requests: LLMRequest[] = []
 const model = LanguageModel.make({
  id: "title-model",
  provider: "test",
-  route: OpenAIChat.route,
+  route: OpenAIChat.route.with({ limits: { context: 10_000, output: 1_000 } }),
 })
 const cost = [
  {
@@ -1,4 +1,6 @@
+import { sentryVitePlugin } from "@sentry/vite-plugin"
 import { defineConfig } from "electron-vite"
+import appPlugin from "@opencode-ai/app/vite"

 const channel = (() => {
  const raw = process.env.OPENCODE_CHANNEL
@@ -9,10 +11,9 @@ const channel = (() => {

 const nodePtyPkg = `@lydell/node-pty-${process.platform}-${process.arch}`

-const appPlugin = (await import("@opencode-ai/app/vite")).default
 const sentry =
  process.env.SENTRY_AUTH_TOKEN && process.env.SENTRY_ORG && process.env.SENTRY_PROJECT
-    ? (await import("@sentry/vite-plugin")).sentryVitePlugin({
+    ? sentryVitePlugin({
        authToken: process.env.SENTRY_AUTH_TOKEN,
        org: process.env.SENTRY_ORG,
        project: process.env.SENTRY_PROJECT,
@@ -33,12 +34,11 @@ export default defineConfig({
      "import.meta.env.OPENCODE_CHANNEL": JSON.stringify(channel),
    },
    build: {
-      rolldownOptions: {
+      rollupOptions: {
        input: { index: "src/main/index.ts" },
        // Keep this identical to electron-vite's Node 20.11+ shim. Its regex insertion can
-        // corrupt bundled TypeScript, while an output banner places the shim safely.
+        // corrupt bundled TypeScript, while a Rollup banner places the shim safely.
        output: {
-          format: "es",
          banner: `
 // -- CommonJS Shims --
 import __cjs_mod__ from 'node:module';
@@ -56,14 +56,13 @@ const require = __cjs_mod__.createRequire(import.meta.url);
        enforce: "pre",
        resolveId(s) {
          if (s === "@lydell/node-pty") return nodePtyPkg
-          return undefined
        },
      },
    ],
  },
  preload: {
    build: {
-      rolldownOptions: {
+      rollupOptions: {
        input: { index: "src/preload/index.ts" },
        output: {
          format: "cjs",
@@ -73,9 +72,6 @@ const require = __cjs_mod__.createRequire(import.meta.url);
    },
  },
  renderer: {
-    experimental: {
-      bundledDev: true,
-    },
    define: {
      "import.meta.env.OPENCODE_VERSION": JSON.stringify(process.env.OPENCODE_VERSION),
      "import.meta.env.VITE_OPENCODE_CHANNEL": JSON.stringify(channel),
@@ -85,7 +81,7 @@ const require = __cjs_mod__.createRequire(import.meta.url);
    root: "src/renderer",
    build: {
      sourcemap: true,
-      rolldownOptions: {
+      rollupOptions: {
        input: {
          main: "src/renderer/index.html",
        },
@@ -40,6 +40,7 @@
    "@opencode-ai/ui": "workspace:*",
    "@sentry/solid": "catalog:",
    "@sentry/vite-plugin": "catalog:",
+    "@solid-primitives/i18n": "2.2.1",
    "@solid-primitives/storage": "catalog:",
    "@solidjs/meta": "catalog:",
    "@solidjs/router": "0.15.4",
@@ -49,11 +50,11 @@
    "@valibot/to-json-schema": "1.6.0",
    "electron": "42.3.3",
    "electron-builder": "26.15.2",
-    "electron-vite": "6.0.0-beta.1",
+    "electron-vite": "^5",
    "solid-js": "catalog:",
    "sury": "11.0.0-alpha.4",
    "typescript": "~5.6.2",
-    "vite": "8.2.1",
+    "vite": "catalog:",
    "zod-openapi": "5.4.6"
  },
  "optionalDependencies": {
@@ -11,17 +11,14 @@ async function main() {
  process.env.OPENCODE_DISABLE_CHANNEL_DB = "0"
  const options = selectOptions()
  if (options.server.type === "build") process.env.OPENCODE_DESKTOP_SERVER_CHANNEL = "local"
-  process.env.OPENCODE_DESKTOP_ISOLATED_SERVER = "1"
  await prepareDesktop()
  await prepareServer(options.server)
  await startDesktop(options.electron)
 }

 async function prepareDesktop() {
-  await Promise.all([
-    $`bun run install-electron`,
-    $`bun ./scripts/copy-icons.ts ${process.env.OPENCODE_CHANNEL ?? "dev"}`,
-  ])
+  await $`bun run install-electron`
+  await $`bun ./scripts/copy-icons.ts ${process.env.OPENCODE_CHANNEL ?? "dev"}`
 }

 function selectOptions(): DevOptions {
@@ -49,6 +46,7 @@ async function prepareServer(source: ServerSource) {
 }

 async function startDesktop(args: string[]) {
+  process.env.OPENCODE_DESKTOP_ISOLATED_SERVER = "1"
  await $`electron-vite dev ${args}`
 }

--- a/Show More
+++ b/Show More