fix(core): adopt consolidated migration aliases

The V1-to-V2 consolidation replaced a shipped migration chain with a new ID, causing upgraded databases to replay already-applied schema changes. Treat the terminal pre-consolidation migration as an alias and record the canonical migration without rerunning its SQL.
2026-08-11 20:19:53 -04:00 · 2026-08-11 12:43:37 +00:00
45 changed files with 214 additions and 655 deletions
@@ -1,4 +1,4 @@
-import { Cause, Context, Effect, Layer, Option, Schema, Stream } from "effect"
+import { Cause, Context, Effect, Layer, Option, Schema } from "effect"
 import {
  FetchHttpClient,
  Headers,
@@ -16,17 +16,12 @@ import {
  TransportReason,
 } from "../schema"
 import { classifyProviderFailure } from "../provider-error"
-import { isRecord } from "../utils/record"

 export interface Interface {
  readonly execute: (
    request: HttpClientRequest.HttpClientRequest,
    middleware?: HttpMiddleware,
  ) => Effect.Effect<HttpClientResponse.HttpClientResponse, AIError>
-  readonly stream: (
-    request: HttpClientRequest.HttpClientRequest,
-    middleware?: HttpMiddleware,
-  ) => Stream.Stream<Uint8Array, AIError>
 }

 export type HttpHandler = (
@@ -302,51 +297,41 @@ export const classifyHttpFailure = (input: {
  })
 }

-type HttpOperation = "request" | "read"
-
-const httpError = (input: {
-  readonly error: unknown
-  readonly request: HttpClientRequest.HttpClientRequest
-  readonly operation: HttpOperation
-  readonly redactedNames: ReadonlyArray<string | RegExp>
-}) => {
-  const transportError = (failure: { readonly message: string; readonly code?: string | undefined }) =>
+const toHttpError = (redactedNames: ReadonlyArray<string | RegExp>) => (error: unknown) => {
+  const transportError = (input: {
+    readonly message: string
+    readonly kind?: string | undefined
+    readonly request?: HttpClientRequest.HttpClientRequest | undefined
+  }) =>
    new AIError({
      module: "RequestExecutor",
-      method: input.operation,
+      method: "execute",
      reason: new TransportReason({
-        message: failure.message,
-        transport: "http",
-        operation: input.operation,
-        code: failure.code,
-        url: redactUrl(input.request.url),
-        http: new HttpContext({ request: requestDetails(input.request, input.redactedNames) }),
+        message: input.message,
+        kind: input.kind,
+        url: input.request ? redactUrl(input.request.url) : undefined,
+        http: input.request ? new HttpContext({ request: requestDetails(input.request, redactedNames) }) : undefined,
      }),
    })

-  const source =
-    HttpClientError.isHttpClientError(input.error) && "cause" in input.error.reason
-      ? input.error.reason.cause
-      : input.error
-  const code = isRecord(source) && typeof source.code === "string" ? source.code : undefined
-  const request = HttpClientError.isHttpClientError(input.error) ? input.error.request : input.request
-  const raw = source instanceof Error ? source.message : input.error instanceof Error ? input.error.message : undefined
-  const detail = raw ? redactBody(raw, secretValues(request)) : undefined
-  const message = code && detail && !detail.includes(code) ? `${code}: ${detail}` : detail
-
-  if (Cause.isTimeoutError(input.error) || Cause.isTimeoutError(source))
-    return transportError({ message: message ?? "HTTP transport timed out", code: code ?? "Timeout" })
-  if (!HttpClientError.isHttpClientError(input.error))
-    return transportError({ message: message ?? "HTTP transport failed", code })
-  if (input.error.reason._tag === "TransportError") {
+  if (Cause.isTimeoutError(error)) {
+    return transportError({ message: error.message, kind: "Timeout" })
+  }
+  if (!HttpClientError.isHttpClientError(error)) {
+    return transportError({ message: error instanceof Error ? error.message : "HTTP transport failed" })
+  }
+  const request = "request" in error ? error.request : undefined
+  if (error.reason._tag === "TransportError") {
    return transportError({
-      message: message ?? input.error.reason.description ?? "HTTP transport failed",
-      code: code ?? input.error.reason._tag,
+      message: error.reason.description ?? "HTTP transport failed",
+      kind: error.reason._tag,
+      request,
    })
  }
  return transportError({
-    message: message ?? `HTTP transport failed: ${input.error.reason._tag}`,
-    code: code ?? input.error.reason._tag,
+    message: `HTTP transport failed: ${error.reason._tag}`,
+    kind: error.reason._tag,
+    request,
  })
 }

@@ -354,41 +339,23 @@ export const layer: Layer.Layer<Service, never, HttpClient.HttpClient> = Layer.e
  Service,
  Effect.gen(function* () {
    const http = yield* HttpClient.HttpClient
-    const execute = (
-      request: HttpClientRequest.HttpClientRequest,
-      middleware: HttpMiddleware | undefined,
-      redactedNames: ReadonlyArray<string | RegExp>,
-    ) =>
+    const executeOnce = (request: HttpClientRequest.HttpClientRequest, middleware?: HttpMiddleware) =>
      Effect.gen(function* () {
+        const redactedNames = yield* Headers.CurrentRedactedNames
        if (!middleware)
-          return yield* http.execute(request).pipe(
-            Effect.mapError((error) => httpError({ error, request, operation: "request", redactedNames })),
-            Effect.flatMap(statusError(request, redactedNames)),
-          )
+          return yield* http
+            .execute(request)
+            .pipe(Effect.mapError(toHttpError(redactedNames)), Effect.flatMap(statusError(request, redactedNames)))

        const response = yield* middleware(request, (input) =>
          http
            .execute(input)
            .pipe(Effect.mapError((cause) => (cause instanceof Error ? cause : new Error(String(cause))))),
-        ).pipe(Effect.mapError((error) => httpError({ error, request, operation: "request", redactedNames })))
+        ).pipe(Effect.mapError(toHttpError(redactedNames)))
        return yield* statusError(response.request, redactedNames)(response)
      })
-    const executeOnce = (request: HttpClientRequest.HttpClientRequest, middleware?: HttpMiddleware) =>
-      Effect.flatMap(Headers.CurrentRedactedNames, (redactedNames) => execute(request, middleware, redactedNames))
    return Service.of({
      execute: executeOnce,
-      stream: (request, middleware) =>
-        Stream.unwrap(
-          Effect.gen(function* () {
-            const redactedNames = yield* Headers.CurrentRedactedNames
-            const response = yield* execute(request, middleware, redactedNames)
-            return response.stream.pipe(
-              Stream.mapError((error) =>
-                httpError({ error, request: response.request, operation: "read", redactedNames }),
-              ),
-            )
-          }),
-        ),
    })
  }),
 )
@@ -1,4 +1,4 @@
-import { Effect } from "effect"
+import { Effect, Stream } from "effect"
 import { Headers, HttpClientRequest } from "effect/unstable/http"
 import { Auth } from "../auth"
 import { render as renderEndpoint } from "../endpoint"
@@ -86,8 +86,26 @@ export const httpJson = <Body, Frame>(input: HttpJsonInput<Body, Frame>): HttpJs
        middleware: prepareInput.middleware,
      }
    }),
-  frames: (prepared, _request, runtime) =>
-    prepared.framing.frame(runtime.http.stream(prepared.request, prepared.middleware)),
+  frames: (prepared, request, runtime) =>
+    Stream.unwrap(
+      runtime.http
+        .execute(prepared.request, prepared.middleware)
+        .pipe(
+          Effect.map((response) =>
+            prepared.framing.frame(
+              response.stream.pipe(
+                Stream.mapError((error) =>
+                  ProviderShared.eventError(
+                    `${request.model.provider}/${request.model.route.id}`,
+                    `Failed to read ${request.model.provider}/${request.model.route.id} stream`,
+                    ProviderShared.errorText(error),
+                  ),
+                ),
+              ),
+            ),
+          ),
+        ),
+    ),
 })

 export const sseJson = {
@@ -1,6 +1,6 @@
 import { Cause, Context, Effect, Layer, Queue, Stream } from "effect"
 import { Headers } from "effect/unstable/http"
-import { AIError, TransportReason, type TransportOperation } from "../../schema"
+import { AIError, TransportReason } from "../../schema"
 import * as HttpTransport from "./http"
 import type { Transport } from "./index"

@@ -29,18 +29,12 @@ export class Service extends Context.Service<Service, Interface>()("@opencode/AI
 const transportError = (
  method: string,
  message: string,
-  input: { readonly operation: TransportOperation; readonly url?: string; readonly code?: string },
+  input: { readonly url?: string; readonly kind?: string } = {},
 ) =>
  new AIError({
    module: "WebSocketExecutor",
    method,
-    reason: new TransportReason({
-      message,
-      transport: "websocket",
-      operation: input.operation,
-      url: input.url,
-      code: input.code,
-    }),
+    reason: new TransportReason({ message, url: input.url, kind: input.kind }),
  })

 const eventMessage = (event: Event) => {
@@ -61,8 +55,7 @@ const waitOpen = (ws: globalThis.WebSocket, input: WebSocketRequest) => {
    return Effect.fail(
      transportError("open", `WebSocket closed before opening (state ${ws.readyState})`, {
        url: input.url,
-        operation: "request",
-        code: "closed",
+        kind: "open",
      }),
    )
  }
@@ -86,10 +79,7 @@ const waitOpen = (ws: globalThis.WebSocket, input: WebSocketRequest) => {
      cleanup()
      resume(
        Effect.fail(
-          transportError("open", `Failed to open WebSocket: ${eventMessage(event)}`, {
-            url: input.url,
-            operation: "request",
-          }),
+          transportError("open", `Failed to open WebSocket: ${eventMessage(event)}`, { url: input.url, kind: "open" }),
        ),
      )
    }
@@ -99,8 +89,7 @@ const waitOpen = (ws: globalThis.WebSocket, input: WebSocketRequest) => {
        Effect.fail(
          transportError("open", `WebSocket closed before opening with code ${event.code}`, {
            url: input.url,
-            operation: "request",
-            code: String(event.code),
+            kind: "open",
          }),
        ),
      )
@@ -129,8 +118,7 @@ const webSocketUrl = (value: string) =>
    catch: (error) =>
      transportError("prepare", error instanceof Error ? error.message : "Invalid WebSocket URL", {
        url: value,
-        operation: "request",
-        code: "invalid-url",
+        kind: "websocket",
      }),
  })

@@ -141,7 +129,7 @@ export const open = (input: WebSocketRequest) =>
    catch: (error) =>
      transportError("open", error instanceof Error ? error.message : "Failed to construct WebSocket", {
        url: input.url,
-        operation: "request",
+        kind: "open",
      }),
  }).pipe(Effect.flatMap((ws) => fromWebSocket(ws, input)))

@@ -162,10 +150,7 @@ export const fromWebSocket = (
      Queue.failCauseUnsafe(
        messages,
        Cause.fail(
-          transportError("message", "Unsupported WebSocket message payload", {
-            url: input.url,
-            operation: "read",
-          }),
+          transportError("message", "Unsupported WebSocket message payload", { url: input.url, kind: "message" }),
        ),
      )
    }
@@ -173,10 +158,7 @@ export const fromWebSocket = (
      Queue.failCauseUnsafe(
        messages,
        Cause.fail(
-          transportError("message", `WebSocket error: ${eventMessage(event)}`, {
-            url: input.url,
-            operation: "read",
-          }),
+          transportError("message", `WebSocket error: ${eventMessage(event)}`, { url: input.url, kind: "message" }),
        ),
      )
    }
@@ -185,11 +167,7 @@ export const fromWebSocket = (
      Queue.failCauseUnsafe(
        messages,
        Cause.fail(
-          transportError("message", `WebSocket closed with code ${event.code}`, {
-            url: input.url,
-            operation: "read",
-            code: String(event.code),
-          }),
+          transportError("message", `WebSocket closed with code ${event.code}`, { url: input.url, kind: "close" }),
        ),
      )
    }
@@ -210,7 +188,7 @@ export const fromWebSocket = (
          catch: (error) =>
            transportError("sendText", error instanceof Error ? error.message : "Failed to send WebSocket message", {
              url: input.url,
-              operation: "write",
+              kind: "write",
            }),
        }),
      messages: Stream.fromQueue(messages),
@@ -265,8 +243,7 @@ export const json = <Body, Message>(input: JsonInput<Body, Message>): JsonTransp
      return Stream.fail(
        transportError("json", "WebSocket JSON transport requires WebSocketExecutor.Service", {
          url: prepared.url,
-          operation: "request",
-          code: "unavailable",
+          kind: "websocket",
        }),
      )
    }
@@ -92,18 +92,10 @@ export class ProviderInternalReason extends Schema.Class<ProviderInternalReason>
  http: Schema.optional(HttpContext),
 }) {}

-export const TransportType = Schema.Literals(["http", "websocket"])
-export type TransportType = typeof TransportType.Type
-
-export const TransportOperation = Schema.Literals(["request", "read", "write"])
-export type TransportOperation = typeof TransportOperation.Type
-
 export class TransportReason extends Schema.Class<TransportReason>("AI.Error.Transport")({
  _tag: Schema.tag("Transport"),
  message: Schema.String,
-  transport: TransportType,
-  operation: TransportOperation,
-  code: Schema.optional(Schema.String),
+  kind: Schema.optional(Schema.String),
  url: Schema.optional(Schema.String),
  http: Schema.optional(HttpContext),
 }) {}
@@ -1,10 +1,10 @@
 import { describe, expect } from "bun:test"
-import { Effect, Layer, Ref, Stream } from "effect"
+import { Effect, Layer, Ref } from "effect"
 import { Headers, HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http"
 import { LLM, AIError } from "../src"
 import { LLMClient, RequestExecutor } from "../src/route"
 import * as OpenAIChat from "../src/protocols/openai-chat"
-import { dynamicResponse, systemError } from "./lib/http"
+import { dynamicResponse } from "./lib/http"
 import { deltaChunk } from "./lib/openai-chunks"
 import { sseRaw } from "./lib/sse"
 import { it } from "./lib/effect"
@@ -67,35 +67,6 @@ const expectAIError = (error: unknown) => {
 const errorHttp = (error: AIError) => ("http" in error.reason ? error.reason.http : undefined)

 describe("RequestExecutor", () => {
-  it.effect("parses response body failures at the executor seam", () =>
-    Effect.gen(function* () {
-      const executor = yield* RequestExecutor.Service
-      const error = yield* executor.stream(secretRequest).pipe(Stream.runDrain, Effect.flip)
-
-      expectAIError(error)
-      expect(error.reason).toMatchObject({
-        _tag: "Transport",
-        message: "ECONNRESET: disconnected <redacted> <redacted>",
-        transport: "http",
-        operation: "read",
-        code: "ECONNRESET",
-        url: "https://provider.test/v1/chat?api_key=%3Credacted%3E&debug=1",
-      })
-    }).pipe(
-      Effect.provide(
-        responsesLayer([
-          new Response(
-            new ReadableStream({
-              start(controller) {
-                controller.error(systemError("ECONNRESET", "disconnected query-secret-123 header-secret-456"))
-              },
-            }),
-          ),
-        ]),
-      ),
-    ),
-  )
-
  it.effect("preserves middleware error messages", () =>
    Effect.gen(function* () {
      const executor = yield* RequestExecutor.Service
@@ -34,12 +34,6 @@ const handlerLayer = (handler: Handler): Layer.Layer<HttpClient.HttpClient> =>

 export type RuntimeEnv = RequestExecutorService | WebSocketExecutorService | LLMClientService

-export interface SystemError extends Error {
-  readonly code: string
-}
-
-export const systemError = (code: string, message: string): SystemError => Object.assign(new Error(message), { code })
-
 export const runtimeLayer = (layer: Layer.Layer<HttpClient.HttpClient>): Layer.Layer<RuntimeEnv> => {
  const requestExecutorLayer = RequestExecutor.layer.pipe(Layer.provide(layer))
  const deps = Layer.mergeAll(requestExecutorLayer, WebSocketExecutor.layer)
@@ -69,14 +63,14 @@ export const dynamicResponse = (handler: Handler) => runtimeLayer(handlerLayer(h
 * Layer that emits the supplied SSE chunks and then aborts mid-stream. Used to
 * exercise transport errors that surface during parsing.
 */
-export const truncatedStream = (chunks: ReadonlyArray<string>, error: Error = new Error("connection reset")) =>
+export const truncatedStream = (chunks: ReadonlyArray<string>) =>
  dynamicResponse((input) =>
    Effect.sync(() => {
      const encoder = new TextEncoder()
      const stream = new ReadableStream({
        start(controller) {
          for (const chunk of chunks) controller.enqueue(encoder.encode(chunk))
-          controller.error(error)
+          controller.error(new Error("connection reset"))
        },
      })
      return input.respond(stream, { headers: SSE_HEADERS })
@@ -22,7 +22,7 @@ import { ProviderShared } from "../../src/protocols/shared"
 import { Auth, LLMClient } from "../../src/route"
 import { compileRequest } from "../../src/route/client"
 import { it } from "../lib/effect"
-import { dynamicResponse, fixedResponse, systemError, truncatedStream } from "../lib/http"
+import { dynamicResponse, fixedResponse, truncatedStream } from "../lib/http"
 import { deltaChunk, usageChunk } from "../lib/openai-chunks"
 import { sseEvents } from "../lib/sse"

@@ -1221,20 +1221,12 @@ describe("OpenAI Chat route", () => {

  it.effect("surfaces transport errors that occur mid-stream", () =>
    Effect.gen(function* () {
-      const layer = truncatedStream(
-        [`data: ${JSON.stringify(deltaChunk({ role: "assistant", content: "Hello" }))}\n\n`],
-        systemError("ECONNRESET", "socket closed unexpectedly"),
-      )
+      const layer = truncatedStream([
+        `data: ${JSON.stringify(deltaChunk({ role: "assistant", content: "Hello" }))}\n\n`,
+      ])
      const error = yield* LLMClient.generate(request).pipe(Effect.provide(layer), Effect.flip)

-      expect(error.reason).toMatchObject({
-        _tag: "Transport",
-        message: "ECONNRESET: socket closed unexpectedly",
-        transport: "http",
-        operation: "read",
-        code: "ECONNRESET",
-        url: "https://api.openai.test/v1/chat/completions",
-      })
+      expect(error.message).toContain("Failed to read openai/openai-chat stream")
    }),
  )

@@ -243,7 +243,6 @@ describe("OpenAI Responses route", () => {
          RequestExecutor.Service,
          RequestExecutor.Service.of({
            execute: () => Effect.die("unexpected HTTP request"),
-            stream: () => Stream.die("unexpected HTTP request"),
          }),
        ),
        Layer.succeed(
@@ -69,63 +69,6 @@ describe("v2 session reducer", () => {
    })
  })

-  test("prefers durable selection predecessors and derives them for older events", () => {
-    const source: SessionMessageInfo[] = [
-      { id: "msg_previous_agent", type: "agent-switched", agent: "build", time: { created: 1 } },
-      {
-        id: "msg_previous_model",
-        type: "model-switched",
-        model: { id: "old", providerID: "provider" },
-        time: { created: 1 },
-      },
-    ]
-    const reducer = createV2SessionReducer()
-
-    const agent = reducer.reduce(
-      source,
-      event({
-        ...base,
-        id: "evt_agent",
-        type: "session.agent.selected",
-        data: { sessionID: "ses_1", agent: "plan", previous: "review" },
-      }),
-    )
-    const model = reducer.reduce(
-      source,
-      event({
-        ...base,
-        id: "evt_model",
-        type: "session.model.selected",
-        data: {
-          sessionID: "ses_1",
-          model: { id: "new", providerID: "provider" },
-          previous: { id: "durable", providerID: "provider" },
-        },
-      }),
-    )
-    const legacyAgent = reducer.reduce(
-      source,
-      event({
-        ...base,
-        id: "evt_legacy_agent",
-        type: "session.agent.selected",
-        data: { sessionID: "ses_1", agent: "plan" },
-      }),
-    )
-
-    expect(agent?.messages.at(-1)).toMatchObject({ type: "agent-switched", agent: "plan", previous: "review" })
-    expect(model?.messages.at(-1)).toMatchObject({
-      type: "model-switched",
-      model: { id: "new" },
-      previous: { id: "durable" },
-    })
-    expect(legacyAgent?.messages.at(-1)).toMatchObject({
-      type: "agent-switched",
-      agent: "plan",
-      previous: "build",
-    })
-  })
-
  test("folds tool, retry, and completion events", () => {
    const reducer = createV2SessionReducer()
    let messages: SessionMessageInfo[] = []
@@ -61,12 +61,6 @@ export function createV2SessionReducer() {
          type: "agent-switched",
          metadata: event.metadata,
          agent: event.data.agent,
-          previous:
-            event.data.previous ??
-            source.findLast(
-              (item): item is Extract<SessionMessageInfo, { type: "agent-switched" | "assistant" }> =>
-                item.type === "agent-switched" || item.type === "assistant",
-            )?.agent,
          time: { created: event.created },
        })
      case "session.model.selected":
@@ -75,12 +69,10 @@ export function createV2SessionReducer() {
          type: "model-switched",
          metadata: event.metadata,
          model: event.data.model,
-          previous:
-            event.data.previous ??
-            source.findLast(
-              (item): item is Extract<SessionMessageInfo, { type: "model-switched" | "assistant" }> =>
-                item.type === "model-switched" || item.type === "assistant",
-            )?.model,
+          previous: source.findLast(
+            (item): item is Extract<SessionMessageInfo, { type: "model-switched" | "assistant" }> =>
+              item.type === "model-switched" || item.type === "assistant",
+          )?.model,
          time: { created: event.created },
        })
      case "session.synthetic":
@@ -339,11 +339,7 @@ export type Endpoint5_31Output =
          readonly type: "session.agent.selected"
          readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
          readonly location?: Location.Ref | undefined
-          readonly data: {
-            readonly sessionID: Session.ID
-            readonly agent: Agent.ID
-            readonly previous?: Agent.ID | undefined
-          }
+          readonly data: { readonly sessionID: Session.ID; readonly agent: Agent.ID }
        }
      | {
          readonly id: Event.ID
@@ -352,11 +348,7 @@ export type Endpoint5_31Output =
          readonly type: "session.model.selected"
          readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
          readonly location?: Location.Ref | undefined
-          readonly data: {
-            readonly sessionID: Session.ID
-            readonly model: Model.Ref
-            readonly previous?: Model.Ref | undefined
-          }
+          readonly data: { readonly sessionID: Session.ID; readonly model: Model.Ref }
        }
      | {
          readonly id: Event.ID
@@ -436,7 +436,7 @@ export type SessionAgentSelected = {
  type: "session.agent.selected"
  durable: { aggregateID: string; seq: number; version: 1 }
  location?: LocationRef
-  data: { sessionID: string; agent: string; previous?: string }
+  data: { sessionID: string; agent: string }
 }

 export type SessionModelSelected = {
@@ -446,7 +446,7 @@ export type SessionModelSelected = {
  type: "session.model.selected"
  durable: { aggregateID: string; seq: number; version: 1 }
  location?: LocationRef
-  data: { sessionID: string; model: ModelRef; previous?: ModelRef }
+  data: { sessionID: string; model: ModelRef }
 }

 export type SessionMoved = {
@@ -194,10 +194,11 @@ async function formatTypescript(input: string) {

 function renderRegistry(names: string[]) {
  return `import type { DatabaseMigration } from "./migration"
-${names.map((name, index) => `import m${index.toString().padStart(2, "0")} from "./migration/${name}"`).join("\n")}

-export const migrations = [
-${names.map((_, index) => `  m${index.toString().padStart(2, "0")},`).join("\n")}
-] satisfies DatabaseMigration.Migration[]
+export const migrations: DatabaseMigration.Migration[] = (
+  await Promise.all([
+${names.map((name) => `    import("./migration/${name}"),`).join("\n")}
+  ])
+).map((module) => module.default)
 `
 }
@@ -763,9 +763,7 @@ function apiCallErrorReason(error: APICallError) {
  if (error.statusCode !== undefined || !error.isRetryable) return reason
  return new TransportReason({
    message: reason.message,
-    transport: "http",
-    operation: "request",
-    code: error.name,
+    kind: error.name,
    url: error.url,
    http: "http" in reason ? reason.http : undefined,
  })
@@ -153,12 +153,10 @@ const scan = Effect.fn("ConfigPluginSource.scan")(function* (
  })
 })

-const sourceDirectories = ["plugin", "plugins"] as const
-
 function discoverDirectory(fs: FSUtil.Interface, directory: string) {
  return Effect.gen(function* () {
    const files = yield* fs
-      .scan(`{${sourceDirectories.join(",")}}/*.{ts,js}`, {
+      .scan("{plugin,plugins}/*.{ts,js}", {
        cwd: directory,
        absolute: true,
        include: "file",
@@ -170,6 +168,8 @@ function discoverDirectory(fs: FSUtil.Interface, directory: string) {
  })
 }

+const sourceDirectories = ["plugin", "plugins"] as const
+
 function isPluginSource(entries: readonly Entry[], file: string) {
  return entries.some(
    (entry) =>
@@ -42,10 +42,10 @@ const databaseLayer = Layer.effect(
 export function layer(options: Options = { path: ":memory:" }) {
  return Layer.unwrap(
    Effect.gen(function* () {
+      const global = yield* Global.Service
      const provide = (filename: string) => databaseLayer.pipe(Layer.provide(sqliteLayer({ filename })))
      const filename = options.path ?? ":memory:"
      if (filename === ":memory:" || isAbsolute(filename)) return provide(filename)
-      const global = yield* Global.Service
      return provide(join(global.data, filename))
    }),
  )
@@ -1,86 +1,47 @@
 import type { DatabaseMigration } from "./migration"
-import m00 from "./migration/20260127222353_familiar_lady_ursula"
-import m01 from "./migration/20260211171708_add_project_commands"
-import m02 from "./migration/20260213144116_wakeful_the_professor"
-import m03 from "./migration/20260225215848_workspace"
-import m04 from "./migration/20260227213759_add_session_workspace_id"
-import m05 from "./migration/20260228203230_blue_harpoon"
-import m06 from "./migration/20260303231226_add_workspace_fields"
-import m07 from "./migration/20260309230000_move_org_to_state"
-import m08 from "./migration/20260312043431_session_message_cursor"
-import m09 from "./migration/20260323234822_events"
-import m10 from "./migration/20260410174513_workspace-name"
-import m11 from "./migration/20260413175956_chief_energizer"
-import m12 from "./migration/20260423070820_add_icon_url_override"
-import m13 from "./migration/20260427172553_slow_nightmare"
-import m14 from "./migration/20260428004200_add_session_path"
-import m15 from "./migration/20260501142318_next_venus"
-import m16 from "./migration/20260504145000_add_sync_owner"
-import m17 from "./migration/20260507164347_add_workspace_time"
-import m18 from "./migration/20260510033149_session_usage"
-import m19 from "./migration/20260511000411_data_migration_state"
-import m20 from "./migration/20260511173437_session-metadata"
-import m21 from "./migration/20260601010001_normalize_storage_paths"
-import m22 from "./migration/20260601202201_amazing_prowler"
-import m23 from "./migration/20260602002951_lowly_union_jack"
-import m24 from "./migration/20260602182828_add_project_directories"
-import m25 from "./migration/20260603001617_session_message_projection_indexes"
-import m26 from "./migration/20260603040000_session_message_projection_order"
-import m27 from "./migration/20260603141458_session_input_inbox"
-import m28 from "./migration/20260603160727_jittery_ezekiel_stane"
-import m29 from "./migration/20260604172448_event_sourced_session_input"
-import m30 from "./migration/20260605003541_add_session_context_snapshot"
-import m31 from "./migration/20260605042240_add_context_epoch_agent"
-import m32 from "./migration/20260611035744_credential"
-import m33 from "./migration/20260611192811_lush_chimera"
-import m34 from "./migration/20260612174303_project_dir_strategy"
-import m35 from "./migration/20260622142730_simplify_session_context_epoch"
-import m36 from "./migration/20260622170816_reset_v2_session_state"
-import m37 from "./migration/20260622202450_simplify_session_input"
-import m38 from "./migration/20260804233008_loose_psylocke"
-import m39 from "./migration/20260805200742_import_legacy_credentials"
-import m40 from "./migration/20260808023530_workspace_domain"

-export const migrations = [
-  m00,
-  m01,
-  m02,
-  m03,
-  m04,
-  m05,
-  m06,
-  m07,
-  m08,
-  m09,
-  m10,
-  m11,
-  m12,
-  m13,
-  m14,
-  m15,
-  m16,
-  m17,
-  m18,
-  m19,
-  m20,
-  m21,
-  m22,
-  m23,
-  m24,
-  m25,
-  m26,
-  m27,
-  m28,
-  m29,
-  m30,
-  m31,
-  m32,
-  m33,
-  m34,
-  m35,
-  m36,
-  m37,
-  m38,
-  m39,
-  m40,
-] satisfies DatabaseMigration.Migration[]
+export const migrations: DatabaseMigration.Migration[] = (
+  await Promise.all([
+    import("./migration/20260127222353_familiar_lady_ursula"),
+    import("./migration/20260211171708_add_project_commands"),
+    import("./migration/20260213144116_wakeful_the_professor"),
+    import("./migration/20260225215848_workspace"),
+    import("./migration/20260227213759_add_session_workspace_id"),
+    import("./migration/20260228203230_blue_harpoon"),
+    import("./migration/20260303231226_add_workspace_fields"),
+    import("./migration/20260309230000_move_org_to_state"),
+    import("./migration/20260312043431_session_message_cursor"),
+    import("./migration/20260323234822_events"),
+    import("./migration/20260410174513_workspace-name"),
+    import("./migration/20260413175956_chief_energizer"),
+    import("./migration/20260423070820_add_icon_url_override"),
+    import("./migration/20260427172553_slow_nightmare"),
+    import("./migration/20260428004200_add_session_path"),
+    import("./migration/20260501142318_next_venus"),
+    import("./migration/20260504145000_add_sync_owner"),
+    import("./migration/20260507164347_add_workspace_time"),
+    import("./migration/20260510033149_session_usage"),
+    import("./migration/20260511000411_data_migration_state"),
+    import("./migration/20260511173437_session-metadata"),
+    import("./migration/20260601010001_normalize_storage_paths"),
+    import("./migration/20260601202201_amazing_prowler"),
+    import("./migration/20260602002951_lowly_union_jack"),
+    import("./migration/20260602182828_add_project_directories"),
+    import("./migration/20260603001617_session_message_projection_indexes"),
+    import("./migration/20260603040000_session_message_projection_order"),
+    import("./migration/20260603141458_session_input_inbox"),
+    import("./migration/20260603160727_jittery_ezekiel_stane"),
+    import("./migration/20260604172448_event_sourced_session_input"),
+    import("./migration/20260605003541_add_session_context_snapshot"),
+    import("./migration/20260605042240_add_context_epoch_agent"),
+    import("./migration/20260611035744_credential"),
+    import("./migration/20260611192811_lush_chimera"),
+    import("./migration/20260612174303_project_dir_strategy"),
+    import("./migration/20260622142730_simplify_session_context_epoch"),
+    import("./migration/20260622170816_reset_v2_session_state"),
+    import("./migration/20260622202450_simplify_session_input"),
+    import("./migration/20260804233008_loose_psylocke"),
+    import("./migration/20260805200742_import_legacy_credentials"),
+    import("./migration/20260808023530_workspace_domain"),
+  ])
+).map((module) => module.default)
@@ -13,6 +13,7 @@ const lock = Semaphore.makeUnsafe(1)

 export type Migration = {
  id: string
+  aliases?: string[]
  foreignKeys?: boolean
  up: (tx: Transaction) => Effect.Effect<void, unknown, Global.Service>
 }
@@ -77,6 +78,14 @@ export function applyOnly(db: Database, input: Migration[]) {

    for (const migration of input) {
      if (completed.has(migration.id)) continue
+      const alias = migration.aliases?.find((id) => completed.has(id))
+      if (alias) {
+        yield* db.run(
+          sql`INSERT INTO ${sql.identifier("migration")} (id, time_completed) VALUES (${migration.id}, ${Date.now()})`,
+        )
+        yield* Effect.logInfo("database migration adopted", { migration: migration.id, alias })
+        continue
+      }
      const started = Date.now()
      yield* Effect.logInfo("database migration started", { migration: migration.id })
      const apply = db.transaction((tx) =>
@@ -3,6 +3,7 @@ import type { DatabaseMigration } from "../migration"

 const migration: DatabaseMigration.Migration = {
  id: "20260804233008_loose_psylocke",
+  aliases: ["20260730195856_optional_session_title"],
  up(tx) {
    return Effect.gen(function* () {
      yield* tx.run(`
@@ -7,7 +7,7 @@ import { SessionV1 } from "@opencode-ai/schema/session-v1"
 import { SessionMessage } from "../session/message"
 import { SessionSchema } from "../session/schema"
 import { KVTable } from "../kv/sql"
-import { EventSequenceTable } from "../event/sql"
+import { EventSequenceTable, EventTable } from "../event/sql"
 import { eq, sql } from "drizzle-orm"
 import { Global } from "@opencode-ai/util/global"
 import { existsSync } from "node:fs"
@@ -161,7 +161,6 @@ type NextMessage = {

 const lock = Semaphore.makeUnsafe(1)
 const MIGRATION_STATE_KEY = "migration.v1-v2"
-const EVENT_DELETE_BATCH_SIZE = 1_000
 const decodeJson = Schema.decodeUnknownOption(Schema.UnknownFromJsonString)
 const decodeMessage = Schema.decodeUnknownOption(SessionV1.Info)
 const decodePart = Schema.decodeUnknownOption(SessionV1.Part)
@@ -486,15 +485,7 @@ export function run(options: Options = {}): Effect.Effect<RunResult, never, Data
          yield* db
            .transaction((tx) =>
              Effect.gen(function* () {
-                while (true) {
-                  yield* tx.run(sql`
-                    DELETE FROM event
-                    WHERE rowid IN (SELECT rowid FROM event LIMIT ${EVENT_DELETE_BATCH_SIZE})
-                  `)
-                  const deleted = (yield* tx.get<{ value: number }>(sql`SELECT changes() AS value`))?.value ?? 0
-                  if (deleted < EVENT_DELETE_BATCH_SIZE) break
-                  yield* Effect.yieldNow
-                }
+                yield* tx.delete(EventTable).run()
                yield* tx
                  .insert(KVTable)
                  .values({ key: MIGRATION_STATE_KEY, value: { phase: "sessions" } })
@@ -1,4 +1,4 @@
-import { Cause, Context, Duration, Effect, Layer, Option, Schedule, Schema, Semaphore } from "effect"
+import { Context, Duration, Effect, Layer, Option, Schedule, Schema, Semaphore } from "effect"
 import { HttpClient, HttpClientRequest } from "effect/unstable/http"
 import { ModelsDev } from "@opencode-ai/schema/models-dev"
 import { Money } from "@opencode-ai/schema/money"
@@ -612,16 +612,7 @@ export const layer = (options?: Options) =>
      const fetchAndWrite = Effect.fn("ModelsDev.fetchAndWrite")(function* () {
        const text = yield* fetchApi()
        const catalog = (yield* Schema.decodeUnknownEffect(CatalogJson)(text)) as Record<string, SourceProvider>
-        // Best-effort: a cache-write failure must never kill catalog
-        // population. The payload has outgrown some KV backends' per-value
-        // limits (Durable Object SQLite caps values at 2 MB and api.json
-        // passed it in Aug 2026); a boot without a cache hit just refetches.
-        yield* kv.set(key, { updatedAt: Date.now(), body: text }).pipe(
-          Effect.catchCauseIf(
-            (cause) => !Cause.hasInterruptsOnly(cause),
-            (cause) => Effect.logWarning("Failed to cache models.dev catalog", { cause }),
-          ),
-        )
+        yield* kv.set(key, { updatedAt: Date.now(), body: text })
        return catalog
      })

@@ -36,7 +36,6 @@ export const ModelsDevPlugin = define({
          draft.integrationID = Integration.ID.make(provider.info.id)
        })
        for (const model of provider.models) {
-          if (model.status === "deprecated") continue
          catalog.model.update(provider.info.id, model.id, (draft) => Object.assign(draft, model))
        }
      }
@@ -716,11 +716,10 @@ const layer = Layer.effect(
            .pipe(Effect.ignore, Effect.forkIn(scope, { startImmediately: true }), Effect.asVoid)
      }),
      switchAgent: Effect.fn("Session.switchAgent")(function* (input) {
-        const session = yield* result.get(input.sessionID)
+        yield* result.get(input.sessionID)
        yield* bus.publish(SessionEvent.AgentSelected, {
          sessionID: input.sessionID,
          agent: input.agent,
-          previous: session.agent,
        })
      }),
      switchModel: Effect.fn("Session.switchModel")(function* (input) {
@@ -734,7 +733,6 @@ const layer = Layer.effect(
        yield* bus.publish(SessionEvent.ModelSelected, {
          sessionID: input.sessionID,
          model: input.model,
-          previous: session.model,
        })
      }),
      rename: Effect.fn("Session.rename")(function* (input) {
@@ -61,7 +61,7 @@ export function update(adapter: Adapter, event: SessionEvent.DurableEvent) {
      "session.usage.recorded": () => Effect.void,
      "session.agent.selected": (event) => {
        return Effect.gen(function* () {
-          const previous = event.data.previous ?? (yield* adapter.getAgent())
+          const previous = yield* adapter.getAgent()
          yield* adapter.appendMessage(
            SessionMessage.AgentSelected.make({
              id: SessionMessage.ID.fromEvent(event.id),
@@ -76,7 +76,7 @@ export function update(adapter: Adapter, event: SessionEvent.DurableEvent) {
      },
      "session.model.selected": (event) => {
        return Effect.gen(function* () {
-          const previous = event.data.previous ?? (yield* adapter.getModel())
+          const previous = yield* adapter.getModel()
          yield* adapter.appendMessage(
            SessionMessage.ModelSelected.make({
              id: SessionMessage.ID.fromEvent(event.id),
@@ -65,15 +65,15 @@ const userAttachmentContent = (files: readonly FileAttachment[]) => {
  )
  if (eligible.length < 2) return files.flatMap(attachmentContent)

-  const seen = new Map<string, Set<string>>()
+  const seen = new Map<string, string[]>()
  return files.flatMap((file) => {
    if (!imageMimes.has(file.mime) || file.source.type !== "inline" || !file.mention?.text)
      return attachmentContent(file)
    const metadata = JSON.stringify([file.mime, file.name ?? null, file.description ?? null, file.mention.text])
-    const payloads = seen.get(metadata) ?? new Set<string>()
-    if (payloads.has(file.data)) return []
-    payloads.add(file.data)
-    seen.set(metadata, payloads)
+    const matches = seen.get(metadata)
+    if (matches?.includes(file.data)) return []
+    if (matches) matches.push(file.data)
+    if (!matches) seen.set(metadata, [file.data])
    return attachmentContent(file)
  })
 }
@@ -21,7 +21,7 @@ Usage notes:
 - If you recommend a specific option, make that the first option in the list and add "(Recommended)" at the end of the label`

 export const Input = Schema.Struct({
-  questions: Schema.Array(Question.Prompt).check(Schema.isNonEmpty()).annotate({ description: "Questions to ask" }),
+  questions: Schema.NonEmptyArray(Question.Prompt).annotate({ description: "Questions to ask" }),
 })

 export const Output = Schema.Struct({
@@ -9,7 +9,7 @@ import { LLM, AIError, LLMEvent, Message, isContextOverflowFailure } from "@open
 import { LLMClient, RequestExecutor } from "@opencode-ai/ai/route"
 import { compileRequest } from "@opencode-ai/ai/route/client"
 import { expect } from "bun:test"
-import { Effect, Layer, Stream } from "effect"
+import { Effect, Layer } from "effect"
 import { testEffect } from "./lib/effect"

 const it = testEffect(AISDK.locationLayer)
@@ -49,10 +49,7 @@ const client = LLMClient.layer.pipe(
  Layer.provide(
    Layer.succeed(
      RequestExecutor.Service,
-      RequestExecutor.Service.of({
-        execute: () => Effect.die("Unexpected HTTP request"),
-        stream: () => Stream.die("Unexpected HTTP request"),
-      }),
+      RequestExecutor.Service.of({ execute: () => Effect.die("Unexpected HTTP request") }),
    ),
  ),
 )
@@ -545,12 +542,7 @@ it.effect("retries status-less AI SDK transport failures", () =>
        isRetryable: true,
      }),
    )
-    expect(error.reason).toMatchObject({
-      _tag: "Transport",
-      transport: "http",
-      operation: "request",
-      code: "AI_APICallError",
-    })
+    expect(error.reason).toMatchObject({ _tag: "Transport", kind: "AI_APICallError" })
    expect(SessionRunnerRetry.isRetryable(error)).toBeTrue()
    expect("http" in error.reason ? error.reason.http?.request.url : undefined).toBe("https://api.example.com/chat")
  }),
@@ -12,6 +12,7 @@ import { Database } from "@opencode-ai/core/database/database"
 import { tmpdir } from "./fixture/tmpdir"
 import type { SqlClient } from "effect/unstable/sql/SqlClient"
 import legacyCredentialsMigration from "@opencode-ai/core/database/migration/20260805200742_import_legacy_credentials"
+import consolidatedV2Migration from "@opencode-ai/core/database/migration/20260804233008_loose_psylocke"
 import { Global } from "@opencode-ai/util/global"

 const run = <A, E>(
@@ -114,6 +115,28 @@ describe("DatabaseMigration", () => {
    )
  })

+  test("adopts the consolidated V2 migration after the superseded chain", async () => {
+    await run(
+      Effect.gen(function* () {
+        const db = yield* makeDb
+        yield* db.run(sql`CREATE TABLE session (id text PRIMARY KEY)`)
+        yield* db.run(sql`CREATE TABLE event (id text PRIMARY KEY, created integer DEFAULT 0 NOT NULL)`)
+        yield* db.run(sql`CREATE TABLE migration (id text PRIMARY KEY, time_completed integer NOT NULL)`)
+        yield* db.run(sql`
+          INSERT INTO migration (id, time_completed)
+          VALUES ('20260730195856_optional_session_title', 1)
+        `)
+
+        yield* DatabaseMigration.applyOnly(db, [consolidatedV2Migration])
+
+        expect(yield* db.get(sql`SELECT id FROM migration WHERE id = ${consolidatedV2Migration.id}`)).toEqual({
+          id: consolidatedV2Migration.id,
+        })
+        expect(yield* db.get(sql`SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'kv'`)).toBeUndefined()
+      }),
+    )
+  })
+
  test("imports legacy JSON credentials without changing the source file or existing credentials", async () => {
    await using tmp = await tmpdir()
    const source = path.join(tmp.path, "auth.json")
@@ -185,15 +185,6 @@ const buildLayer = (state: Ref.Ref<MockState>, cache: MockCache, options: Models
    ]),
  )

-// Mirrors production KV backends whose writes die as defects (e.g. Durable
-// Object SQLite rejecting values over its 2 MB cap with EffectDrizzleQueryError).
-const makeFailingWriteKV = (cache: MockCache) =>
-  Layer.mock(KV.Service, {
-    get: (key) => Effect.sync(() => cache.values.get(key)),
-    set: () => Effect.die(new Error('Failed query: insert into "kv"')),
-    remove: (key) => Effect.sync(() => cache.values.delete(key)).pipe(Effect.asVoid),
-  })
-
 const makeCache = (): MockCache => ({ values: new Map() })

 const writeCacheText = (cache: MockCache, text: string, updatedAt = Date.now()) =>
@@ -257,25 +248,6 @@ describe("ModelsDev Service", () => {
    }),
  )

-  it.live("get() still populates the catalog when the KV cache write fails", () =>
-    Effect.gen(function* () {
-      const cache = makeCache()
-      const state = yield* Ref.make({ ...initialState, body: JSON.stringify(fixture2) })
-      const layer = Layer.fresh(
-        AppNodeBuilder.build(ModelsDev.node, [
-          [ModelsDev.node, ModelsDev.configured({ fetch: true })],
-          [LayerNodePlatform.httpClient, Layer.succeed(HttpClient.HttpClient, makeMockClient(state))],
-          [KV.node, makeFailingWriteKV(cache)],
-        ]),
-      )
-      const result = yield* ModelsDev.Service.use((s) => s.get()).pipe(Effect.provide(layer))
-      expect(result).toEqual(fixture2Snapshot)
-      expect(cache.values.has(cacheKey)).toBe(false)
-      const final = yield* Ref.get(state)
-      expect(final.calls.length).toBe(1)
-    }),
-  )
-
  it.live("uses the default models URL when the configured URL is empty", () =>
    Effect.gen(function* () {
      const cache = makeCache()
@@ -215,66 +215,6 @@ describe("ModelsDevPlugin", () => {
    }),
  )

-  it.effect("omits deprecated models from the catalog", () =>
-    Effect.gen(function* () {
-      const integrations = yield* Integration.Service
-      const catalog = yield* Catalog.Service
-      const providerID = Provider.ID.make("acme")
-      const activeID = Model.ID.make("current")
-      const deprecatedID = Model.ID.make("legacy")
-      const model = {
-        modelID: activeID,
-        providerID,
-        name: "Current",
-        capabilities: { tools: true, input: [], output: [] },
-        variants: [],
-        time: { released: Date.parse("2026-01-01") },
-        cost: [],
-        status: "active",
-        enabled: true,
-        limit: { context: 128_000, output: 32_000 },
-      } satisfies Omit<Model.Info, "id">
-      const snapshots = [
-        {
-          info: {
-            id: providerID,
-            name: "Acme",
-            package: Provider.aisdk("@ai-sdk/openai-compatible"),
-          },
-          environment: [],
-          models: [
-            { id: activeID, ...model },
-            {
-              id: deprecatedID,
-              ...model,
-              modelID: deprecatedID,
-              name: "Legacy",
-              status: "deprecated" as const,
-            },
-          ],
-        },
-      ] satisfies readonly ModelsDev.Snapshot[]
-
-      yield* ModelsDevPlugin.effect(
-        host({
-          catalog: catalogHost(catalog),
-          integration: integrationHost(integrations),
-        }),
-      ).pipe(
-        Effect.provideService(
-          ModelsDev.Service,
-          ModelsDev.Service.of({
-            get: () => Effect.succeed(snapshots),
-            refresh: () => Effect.void,
-          }),
-        ),
-      )
-
-      expect(yield* catalog.model.get(providerID, activeID)).toBeDefined()
-      expect(yield* catalog.model.get(providerID, deprecatedID)).toBeUndefined()
-    }),
-  )
-
  it.effect("registers key methods for providers with environment variables", () =>
    Effect.gen(function* () {
      const integrations = yield* Integration.Service
@@ -654,7 +654,7 @@ describe("Session.create", () => {
      expect(yield* session.get(created.id)).toMatchObject({ agent: "plan" })
      expect(
        Array.from(yield* logEvents(session, created.id, true).pipe(Stream.drop(1), Stream.take(1), Stream.runCollect)),
-      ).toMatchObject([{ type: "session.agent.selected", data: { agent: "plan", previous: "build" } }])
+      ).toMatchObject([{ type: "session.agent.selected", data: { agent: "plan" } }])
      expect(yield* session.messages({ sessionID: created.id, order: "asc" })).toMatchObject([
        { type: "agent-switched", agent: "plan", previous: "build" },
      ])
@@ -678,12 +678,7 @@ describe("Session.create", () => {
  it.effect("switches the selected model through the durable Session event", () =>
    Effect.gen(function* () {
      const session = yield* Session.Service
-      const previous = Model.Ref.make({
-        id: Model.ID.make("haiku"),
-        providerID: Provider.ID.anthropic,
-        variant: Model.VariantID.make("default"),
-      })
-      const created = yield* session.create({ location, model: previous })
+      const created = yield* session.create({ location })
      const model = Model.Ref.make({
        id: Model.ID.make("sonnet"),
        providerID: Provider.ID.anthropic,
@@ -697,10 +692,7 @@ describe("Session.create", () => {
        yield* logEvents(session, created.id, true).pipe(Stream.drop(1), Stream.take(1), Stream.runCollect),
      )
      expect(bus).toMatchObject([{ type: "session.model.selected" }])
-      expect(bus[0]?.data).toEqual({ sessionID: created.id, model, previous })
-      expect(yield* session.messages({ sessionID: created.id, order: "asc" })).toMatchObject([
-        { type: "model-switched", model, previous },
-      ])
+      expect(bus[0]?.data).toEqual({ sessionID: created.id, model })
    }),
  )

@@ -39,9 +39,7 @@ describe("toSessionError", () => {
    )
    expect(toSessionError(llm(new QuotaExceededReason({ message: "quota" }))).type).toBe("provider.quota")
    expect(toSessionError(llm(new ContentPolicyReason({ message: "blocked" }))).type).toBe("provider.content-filter")
-    expect(
-      toSessionError(llm(new TransportReason({ message: "transport", transport: "http", operation: "request" }))).type,
-    ).toBe("provider.transport")
+    expect(toSessionError(llm(new TransportReason({ message: "transport" }))).type).toBe("provider.transport")
    expect(toSessionError(llm(new ProviderInternalReason({ message: "internal", status: 500 }))).type).toBe(
      "provider.internal",
    )
@@ -113,7 +111,7 @@ describe("toSessionError", () => {
    const eligible = [
      llm(new RateLimitReason({ message: "rate" })),
      llm(new ProviderInternalReason({ message: "internal", status: 500 })),
-      llm(new TransportReason({ message: "transport", transport: "http", operation: "request" })),
+      llm(new TransportReason({ message: "transport" })),
    ]
    const ineligible = [
      llm(new AuthenticationReason({ message: "auth", kind: "invalid" })),
@@ -31,7 +31,7 @@ describe("SessionExecution lifecycle", () => {
          new AIError({
            module: "test",
            method: "stream",
-            reason: new TransportReason({ message: "Disconnected", transport: "http", operation: "request" }),
+            reason: new TransportReason({ message: "Disconnected" }),
          }),
        ),
      ),
@@ -515,11 +515,7 @@ const providerUnavailable = () =>
  new AIError({
    module: "test",
    method: "stream",
-    reason: new TransportReason({
-      message: "Provider unavailable",
-      transport: "http",
-      operation: "request",
-    }),
+    reason: new TransportReason({ message: "Provider unavailable" }),
  })

 const incompleteStream = () =>
@@ -89,30 +89,6 @@ const it = testEffect(
 )

 describe("QuestionTool", () => {
-  it.effect("emits one item schema for the nonempty questions array", () =>
-    Effect.gen(function* () {
-      captured = undefined
-      const registry = yield* Tool.Service
-      const definition = (yield* toolDefinitions(registry)).find((tool) => tool.name === QuestionTool.name)
-
-      expect(definition?.inputSchema).toHaveProperty("properties.questions.type", "array")
-      expect(definition?.inputSchema).toHaveProperty("properties.questions.minItems", 1)
-      expect(definition?.inputSchema).toHaveProperty("properties.questions.items")
-      expect(definition?.inputSchema).not.toHaveProperty("properties.questions.prefixItems")
-      expect(
-        yield* executeTool(registry, {
-          sessionID,
-          ...toolIdentity,
-          call: { type: "tool-call", id: "call-question-empty", name: QuestionTool.name, input: { questions: [] } },
-        }),
-      ).toMatchObject({
-        status: "error",
-        error: { type: "tool.execution", message: expect.stringContaining("Invalid tool input") },
-      })
-      expect(capturedInput()).toBeUndefined()
-    }),
-  )
-
  it.effect("omits a catalog-denied question and enforces its leaf permission", () =>
    Effect.gen(function* () {
      captured = undefined
@@ -11,7 +11,7 @@ import { Project } from "@opencode-ai/core/project"
 import { ProjectTable } from "@opencode-ai/core/project/sql"
 import { AbsolutePath } from "@opencode-ai/core/schema"
 import { Global } from "@opencode-ai/util/global"
-import { Effect, Fiber, Layer, Logger, Schedule, Schema, Scope } from "effect"
+import { Effect, Layer, Logger, Schedule, Schema, Scope } from "effect"
 import { eq, sql } from "drizzle-orm"
 import type { SqlClient } from "effect/unstable/sql/SqlClient"
 import { tmpdir } from "./fixture/tmpdir"
@@ -798,35 +798,6 @@ describe("V1Migration database workflow", () => {
    )
  })

-  test("yields while clearing stale events in batches", async () => {
-    await database(
-      Effect.gen(function* () {
-        const { db } = yield* Database.Service
-        yield* db.run(sql`INSERT INTO event_sequence (aggregate_id, seq) VALUES ('stale', 2500)`)
-        yield* db.run(sql`
-          WITH RECURSIVE rows(value) AS (
-            VALUES(1)
-            UNION ALL
-            SELECT value + 1 FROM rows WHERE value < 2500
-          )
-          INSERT INTO event (id, aggregate_id, seq, created, type, data)
-          SELECT printf('event_%04d', value), 'stale', value, 1, 'session.renamed.1', '{}'
-          FROM rows
-        `)
-        let yielded = false
-        const heartbeat = yield* Effect.yieldNow.pipe(
-          Effect.andThen(Effect.sync(() => (yielded = true))),
-          Effect.forkChild({ startImmediately: true }),
-        )
-
-        expect(yield* V1Migration.run()).toEqual({ status: "completed" })
-        expect(yielded).toBe(true)
-        yield* Fiber.join(heartbeat)
-        expect(yield* db.get<{ value: number }>(sql`SELECT COUNT(*) AS value FROM event`)).toEqual({ value: 0 })
-      }),
-    )
-  })
-
  test("imports previous V2 sessions and messages as part of the migration", async () => {
    await using tmp = await tmpdir()
    const filename = path.join(tmp.path, "opencode-next.db")
@@ -77,21 +77,20 @@ export function spatialPathSpans(points: readonly DiagramPoint[]): SpatialSpan[]
    .sort(([left], [right]) => left - right)
    .flatMap(([y, xs]) => {
      const sorted = [...xs].sort((left, right) => left - right)
-      const [first, ...rest] = sorted
-      if (first === undefined) return []
      const spans: SpatialSpan[] = []
-      let start = first
-      let end = first
-      for (const x of rest) {
-        if (x === end + 1) {
+      let start = sorted[0]
+      let end = start
+      if (start === undefined) return spans
+      for (const x of sorted.slice(1)) {
+        if (x === end! + 1) {
          end = x
          continue
        }
-        spans.push(normalizedSpan(y, start, end))
+        spans.push(normalizedSpan(y, start, end!))
        start = x
        end = x
      }
-      spans.push(normalizedSpan(y, start, end))
+      spans.push(normalizedSpan(y, start, end!))
      return spans
    })
 }
@@ -14373,9 +14373,6 @@
              },
              "agent": {
                "type": "string"
-              },
-              "previous": {
-                "type": "string"
              }
            },
            "required": ["sessionID", "agent"],
@@ -14444,9 +14441,6 @@
              },
              "model": {
                "$ref": "#/components/schemas/Model.Ref"
-              },
-              "previous": {
-                "$ref": "#/components/schemas/Model.Ref"
              }
            },
            "required": ["sessionID", "model"],
@@ -69,7 +69,6 @@ export const AgentSelected = Event.durable({
  schema: {
    ...Base,
    agent: Agent.ID,
-    previous: Agent.ID.pipe(optional),
  },
 })
 export type AgentSelected = typeof AgentSelected.Type
@@ -80,7 +79,6 @@ export const ModelSelected = Event.durable({
  schema: {
    ...Base,
    model: Model.Ref,
-    previous: Model.Ref.pipe(optional),
  },
 })
 export type ModelSelected = typeof ModelSelected.Type
@@ -12,19 +12,6 @@ export const ModelHandler = HttpApiBuilder.group(Api, "server.model", (handlers)
      .handle(
        "model.list",
        Effect.fn(function* () {
-          const plugins = yield* PluginSupervisor.Service
-          yield* plugins.flush.pipe(
-            Effect.timeoutOrElse({
-              duration: "5 seconds",
-              orElse: () =>
-                Effect.fail(
-                  new ServiceUnavailableError({
-                    message: "Model catalog initialization timed out",
-                    service: "model.catalog",
-                  }),
-                ),
-            }),
-          )
          const catalog = yield* Catalog.Service
          return yield* response(catalog.model.available())
        }),
@@ -1,57 +0,0 @@
-import fs from "node:fs/promises"
-import path from "node:path"
-import { expect } from "bun:test"
-import { Effect } from "effect"
-import { HttpServer } from "effect/unstable/http"
-import { tmpdir } from "../../core/test/fixture/tmpdir"
-import { it } from "../../core/test/lib/effect"
-import { ServerProcess } from "../src/process"
-
-it.live("waits for plugin initialization before listing models", () =>
-  Effect.acquireUseRelease(
-    Effect.promise(() => tmpdir("opencode-model-endpoint-")),
-    (tmp) =>
-      Effect.gen(function* () {
-        yield* Effect.promise(() =>
-          fs.writeFile(
-            path.join(tmp.path, "opencode.json"),
-            JSON.stringify({
-              providers: {
-                custom: {
-                  package: "aisdk:@ai-sdk/openai-compatible",
-                  settings: { apiKey: "secret" },
-                  models: { chat: {} },
-                },
-              },
-            }),
-          ),
-        )
-        const server = yield* ServerProcess.start<never, never>({
-          hostname: "127.0.0.1",
-          port: 0,
-          password: "secret",
-          app: { version: "test-version" },
-          database: { path: ":memory:" },
-          config: { directory: tmp.path },
-          fs: { filewatcher: false },
-        })
-        const url = new URL("/api/model", HttpServer.formatAddress(server.address))
-        url.searchParams.set("location[directory]", tmp.path)
-        const response = yield* Effect.promise(() =>
-          fetch(url, { headers: { authorization: `Basic ${btoa("opencode:secret")}` } }),
-        )
-
-        expect(response.status).toBe(200)
-        const body: unknown = yield* Effect.promise(() => response.json())
-        if (!isRecord(body) || !Array.isArray(body["data"])) throw new Error("Expected a model list response")
-        expect(
-          body["data"].some((model) => isRecord(model) && model["providerID"] === "custom" && model["id"] === "chat"),
-        ).toBeTrue()
-      }),
-    (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
-  ),
-)
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value)
-}
@@ -62,9 +62,13 @@ function createMarquee(hovered: () => string | undefined, animations: () => bool
  const leading = createAnimatable({ opacity: 0 }, { enabled: animations, transition: tween({ duration: 0.25 }) })

  createEffect(() => {
+    if (!hovered()) {
+      setOffset(0)
+      leading.jump({ opacity: 0 })
+      return
+    }
    setOffset(0)
    leading.jump({ opacity: 0 })
-    if (!hovered()) return
    let interval: ReturnType<typeof setInterval> | undefined
    const delay = setTimeout(() => {
      setOffset(1)
@@ -25,14 +25,14 @@ function deduplicateByIdentity<T>(
  items: readonly T[],
  identity: (item: T) => { metadata: string; payload: string } | undefined,
 ) {
-  const seen = new Map<string, Set<string>>()
+  const seen = new Map<string, string[]>()
  return items.filter((item) => {
    const key = identity(item)
    if (!key) return true
-    const payloads = seen.get(key.metadata) ?? new Set<string>()
-    if (payloads.has(key.payload)) return false
-    payloads.add(key.payload)
-    seen.set(key.metadata, payloads)
+    const matches = seen.get(key.metadata)
+    if (matches?.includes(key.payload)) return false
+    if (matches) matches.push(key.payload)
+    if (!matches) seen.set(key.metadata, [key.payload])
    return true
  })
 }
@@ -42,7 +42,7 @@ export function deduplicatePromptImages(files: readonly PromptFile[] | undefined
  return deduplicateByIdentity(files, (file) =>
    file.uri.startsWith("data:image/") && file.mention?.text
      ? {
-          metadata: JSON.stringify([file.name ?? null, file.description ?? null, file.mention.text]),
+          metadata: JSON.stringify([attachmentMetadata(file), file.mention.text]),
          payload: file.uri,
        }
      : undefined,
@@ -14373,9 +14373,6 @@
              },
              "agent": {
                "type": "string"
-              },
-              "previous": {
-                "type": "string"
              }
            },
            "required": ["sessionID", "agent"],
@@ -14444,9 +14441,6 @@
              },
              "model": {
                "$ref": "#/components/schemas/Model.Ref"
-              },
-              "previous": {
-                "$ref": "#/components/schemas/Model.Ref"
              }
            },
            "required": ["sessionID", "model"],
@@ -14373,9 +14373,6 @@
              },
              "agent": {
                "type": "string"
-              },
-              "previous": {
-                "type": "string"
              }
            },
            "required": ["sessionID", "agent"],
@@ -14444,9 +14441,6 @@
              },
              "model": {
                "$ref": "#/components/schemas/Model.Ref"
-              },
-              "previous": {
-                "$ref": "#/components/schemas/Model.Ref"
              }
            },
            "required": ["sessionID", "model"],