refactor(core): restore dedicated Merge native mapping

Buffer bulk history privately and publish once with a bounded head window. Preserve pending anchor compensation while ensuring newer navigation cancels obsolete Home work. Add atomic-loading and real-App navigation regressions.

.changeset/directory-page-heading.md

@@ -0,0 +1,5 @@
+---
+"@opencode-ai/core": patch
+---
+
+Correct directory page headings when the read offset is zero.

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

@@ -1000,33 +1000,12 @@ const step = (state: ParserState, event: OpenAIChatEvent) =>
       lifecycle = Lifecycle.reasoningStart(lifecycle, events, "reasoning-0", deltaMetadata)
     const reasoningEmitted = state.reasoningEmitted || lifecycle.reasoning.has("reasoning-0")
 
-    if (delta?.content) {
-      lifecycle = Lifecycle.reasoningEnd(
-        lifecycle,
-        events,
-        "reasoning-0",
-        reasoningMetadata(
-          state.providerMetadataKey,
-          reasoningField,
-          reasoningDetailsObserved ? state.reasoningDetails : undefined,
-        ),
-      )
-      lifecycle = Lifecycle.textDelta(lifecycle, events, "text-0", delta.content)
-    }
+    // Reasoning is one response-wide channel: it stays open alongside text and
+    // refusal output so late reasoning deltas and details join the same block,
+    // and `finishEvents` closes it once with the complete metadata.
+    if (delta?.content) lifecycle = Lifecycle.textDelta(lifecycle, events, "text-0", delta.content)
 
-    if (delta?.refusal) {
-      lifecycle = Lifecycle.reasoningEnd(
-        lifecycle,
-        events,
-        "reasoning-0",
-        reasoningMetadata(
-          state.providerMetadataKey,
-          reasoningField,
-          reasoningDetailsObserved ? state.reasoningDetails : undefined,
-        ),
-      )
-      lifecycle = Lifecycle.textDelta(lifecycle, events, "text-0", delta.refusal)
-    }
+    if (delta?.refusal) 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.
@@ -1132,10 +1111,12 @@ const finishEvents = Effect.fn("OpenAIChat.finishEvents")(function* (state: Pars
           state.finishReason.normalized === "stop" && hasToolCalls ? "tool-calls" : state.finishReason.normalized,
       }
     : { normalized: hasToolCalls ? ("tool-calls" as const) : ("stop" as const) }
+  // Snapshot details at publish time so the emitted event never observes later
+  // mutation of the accumulated `reasoningDetails` array.
   const metadata = reasoningMetadata(
     state.providerMetadataKey,
     state.reasoningField,
-    state.reasoningDetailsObserved ? state.reasoningDetails : undefined,
+    state.reasoningDetailsObserved ? [...state.reasoningDetails] : undefined,
   )
   const started =
     state.reasoningDetailsObserved && !state.reasoningEmitted

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

@@ -7,6 +7,7 @@ import {
   AIError,
   LLMEvent,
   LLMRequest,
+  LLMResponse,
   Message,
   LanguageModel,
   ToolCallPart,
@@ -1149,7 +1150,7 @@ describe("OpenAI Chat route", () => {
     }),
   )
 
-  it.effect("preserves scalar reasoning after content starts", () =>
+  it.effect("preserves scalar reasoning after content starts in one lifecycle", () =>
     Effect.gen(function* () {
       const details = [{ type: "reasoning.text", text: "detail", format: "unknown", index: 0 }]
       const response = yield* LLMClient.generate(request).pipe(
@@ -1166,8 +1167,35 @@ describe("OpenAI Chat route", () => {
       )
 
       expect(response.reasoning).toBe("detailscalar")
-      expect(response.events.filter(LLMEvent.is.reasoningStart)).toHaveLength(2)
-      expect(response.events.filter(LLMEvent.is.reasoningEnd)).toHaveLength(2)
+      expect(response.events.filter(LLMEvent.is.reasoningStart)).toHaveLength(1)
+      expect(response.events.filter(LLMEvent.is.reasoningEnd)).toHaveLength(1)
+      expect(response.message.content.filter((part) => part.type === "reasoning")).toHaveLength(1)
+      expect(response.message.content.find((part) => part.type === "reasoning")?.providerMetadata).toEqual({
+        openai: { reasoningField: "reasoning", reasoningDetails: details },
+      })
+    }),
+  )
+
+  it.effect("keeps one reasoning lifecycle across many content chunks", () =>
+    Effect.gen(function* () {
+      const details = [{ type: "reasoning.text", text: "thinking", format: "anthropic-claude-v1", index: 0 }]
+      const response = yield* LLMClient.generate(request).pipe(
+        Effect.provide(
+          fixedResponse(
+            sseEvents(
+              { choices: [{ delta: { reasoning: "thinking", reasoning_details: details } }] },
+              ...Array.from({ length: 25 }, (_, index) => deltaChunk({ content: `chunk-${index} ` })),
+              deltaChunk({}, "stop"),
+            ),
+          ),
+        ),
+      )
+
+      expect(response.reasoning).toBe("thinking")
+      expect(response.text).toBe(Array.from({ length: 25 }, (_, index) => `chunk-${index} `).join(""))
+      expect(response.events.filter(LLMEvent.is.reasoningStart)).toHaveLength(1)
+      expect(response.events.filter(LLMEvent.is.reasoningEnd)).toHaveLength(1)
+      expect(response.message.content.filter((part) => part.type === "reasoning")).toHaveLength(1)
       expect(response.message.content.find((part) => part.type === "reasoning")?.providerMetadata).toEqual({
         openai: { reasoningField: "reasoning", reasoningDetails: details },
       })
@@ -1213,7 +1241,18 @@ describe("OpenAI Chat route", () => {
           index: 0,
         },
       ]
-      const response = yield* LLMClient.generate(request).pipe(
+      // Snapshot reasoning-end metadata as each event is published so the
+      // assertion cannot pass through later mutation of a shared array.
+      const publishedEndMetadata: unknown[] = []
+      const response = yield* LLMClient.stream(request).pipe(
+        Stream.tap((event) =>
+          Effect.sync(() => {
+            if (LLMEvent.is.reasoningEnd(event))
+              publishedEndMetadata.push(decodeJson(encodeJson(event.providerMetadata)))
+          }),
+        ),
+        Stream.runFold(LLMResponse.empty, LLMResponse.reduce),
+        Effect.map((state) => LLMResponse.complete(state)!),
         Effect.provide(
           fixedResponse(
             sseEvents(
@@ -1234,10 +1273,12 @@ describe("OpenAI Chat route", () => {
       expect(response.events.filter(LLMEvent.is.reasoningStart)).toHaveLength(1)
       expect(response.events.filter(LLMEvent.is.reasoningDelta)).toHaveLength(1)
       expect(response.events.filter(LLMEvent.is.reasoningEnd)).toHaveLength(1)
-      expect(response.events.filter(LLMEvent.is.reasoningEnd).at(-1)?.providerMetadata).toEqual({
-        openai: { reasoningField: "reasoning", reasoningDetails: merged },
-      })
-      expect(response.events.findIndex(LLMEvent.is.reasoningEnd)).toBeLessThan(
+      expect(publishedEndMetadata).toEqual([{ openai: { reasoningField: "reasoning", reasoningDetails: merged } }])
+      expect(response.events.findIndex(LLMEvent.is.reasoningStart)).toBeLessThan(
+        response.events.findIndex(LLMEvent.is.textStart),
+      )
+      // Reasoning stays open alongside text and closes once during finalization.
+      expect(response.events.findIndex(LLMEvent.is.reasoningEnd)).toBeGreaterThan(
         response.events.findIndex(LLMEvent.is.textStart),
       )
 

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

@@ -80,8 +80,8 @@ export function createSessionRequestModel() {
         if (message.type !== "synthetic") return []
         if (message.metadata?.source === "subagent" && typeof message.metadata.childID === "string")
           return [message.metadata.childID]
-        if (message.metadata?.source === "shell" && typeof message.metadata.jobID === "string")
-          return [message.metadata.jobID]
+        if (message.metadata?.source === "shell")
+          return [message.metadata.shellID, message.metadata.jobID].filter((id): id is string => typeof id === "string")
         return []
       }),
     )
@@ -121,6 +121,7 @@ export function createSessionRequestModel() {
         if (part.type !== "tool" || part.name !== "shell" || completed.has(part.id)) return []
         if (part.state.status !== "completed" || part.state.metadata?.status !== "running") return []
         const shellID = part.state.metadata.shellID
+        if (typeof shellID === "string" && completed.has(shellID)) return []
         const command = part.state.input.command
         return [
           {

packages/client/src/solid/data.ts

@@ -29,6 +29,7 @@ import type {
   SessionMessageAssistantTool,
   SessionInfo,
   SessionInboxInfo,
+  SessionInboxCompaction,
   ShellInfo,
   SkillInfo,
   VcsInfo,
@@ -284,12 +285,11 @@ export function createData(config: CreateDataInput) {
     setStore("session", "pending", sessionID, index, { ...item, delivery })
   }
 
-  // Inbox IDs of optimistic prompt admissions still awaiting their durable
-  // echo. This is the one deliberate piece of in-flight bookkeeping in this
-  // layer: it exists so a rejection only rolls back rows the server never
-  // acknowledged, and so a concurrent pending re-fetch cannot wipe a row the
-  // server does not know about yet. Entries clear on the enqueued echo or on
-  // rollback — not on POST success, which typically precedes the echo.
+  // Inbox IDs of optimistic admissions awaiting acknowledgement, so rejection
+  // only rolls back unacknowledged rows and a pending re-fetch cannot wipe a
+  // row the server does not know about yet. Prompts clear on their durable
+  // echo, positive pending read, or rollback; compactions also reconcile the
+  // POST's canonical ID.
   const outbox = new Set<string>()
 
   // Session IDs of optimistic create admissions still awaiting acknowledgement
@@ -303,11 +303,13 @@ export function createData(config: CreateDataInput) {
   // to exist server-side instead of failing with "not found".
   const creating = new Map<string, Promise<unknown>>()
 
-  // Per-session send chain: prompts must be admitted in submission order,
-  // and HTTP gives no ordering across concurrent POSTs. Each prompt waits
-  // for the previous prompt's POST (settled, so one failure does not block
-  // the next) before sending its own.
+  // Per-session send chain: prompts and compactions must be admitted in
+  // submission order. Each waits for the previous POST to settle, so one
+  // failure does not block the next.
   const sending = new Map<string, Promise<unknown>>()
+  const messageLoads = new Map<string, Promise<unknown>>()
+  const compacting = new Map<string, { id: string; observed: Set<string>; request: Promise<SessionInboxCompaction> }>()
+  onCleanup(() => compacting.clear())
 
   // Register `promise` under `key` until it settles. A later registration
   // replaces an earlier one; settlement only clears its own entry.
@@ -319,9 +321,24 @@ export function createData(config: CreateDataInput) {
     void promise.then(settle, settle)
   }
 
+  // Capture creation before settlement clears its entry, so dependent RPCs still see a failed create.
+  function sendAdmission<Value>(sessionID: string, send: () => Promise<Value>, gate?: Promise<unknown>) {
+    const created = creating.get(sessionID)
+    const previous = sending.get(sessionID)
+    const request = Promise.resolve()
+      .then(() => Promise.all([gate, created, previous]))
+      .then(send)
+    track(
+      sending,
+      sessionID,
+      request.catch(() => undefined),
+    )
+    return request
+  }
+
   // Upsert an admitted inbox item into pending, input, and (for user and
   // synthetic items) the visible transcript. Used by the inbox.enqueued
-  // handler and by optimistic prompt admission; the upsert is what reconciles
+  // handler and by optimistic admission; the upsert is what reconciles
   // the durable echo with an optimistic placeholder — the durable payload and
   // times replace the client's guess.
   function admitLocal(item: SessionInboxInfo) {
@@ -334,6 +351,7 @@ export function createData(config: CreateDataInput) {
         item.sessionID,
         at < 0 ? [...pending, item] : pending.map((entry, index) => (index === at ? item : entry)),
       )
+      if (item.type === "compaction") return
       const input = store.session.input[item.sessionID] ?? []
       if (!input.includes(item.id)) setStore("session", "input", item.sessionID, [...input, item.id])
       materializeInboxMessage(item)
@@ -668,6 +686,7 @@ export function createData(config: CreateDataInput) {
           draft.push(existing)
           message.reindex(draft, index, position)
         })
+        compacting.get(event.data.sessionID)?.observed.add(event.data.inboxID)
         return
       }
       case "session.inbox.delivery.changed":
@@ -675,6 +694,7 @@ export function createData(config: CreateDataInput) {
         return
       case "session.inbox.cancelled": {
         retractLocal(event.data.sessionID, event.data.inboxID)
+        compacting.get(event.data.sessionID)?.observed.add(event.data.inboxID)
         return
       }
       case "session.inbox.enqueued": {
@@ -685,6 +705,12 @@ export function createData(config: CreateDataInput) {
           timeCreated: event.created,
           ...event.data.item,
         })
+        if (event.data.item.type === "compaction") {
+          const active = compacting.get(event.data.sessionID)
+          active?.observed.add(event.data.inboxID)
+          if (active && active.id !== event.data.inboxID && outbox.delete(active.id))
+            removePending(event.data.sessionID, active.id)
+        }
         return
       }
       case "session.instructions.updated":
@@ -983,6 +1009,7 @@ export function createData(config: CreateDataInput) {
             time: { created: event.created },
           })
         })
+        if (event.data.inputID) compacting.get(event.data.sessionID)?.observed.add(event.data.inputID)
         return
       case "session.execution.succeeded":
       case "session.execution.failed":
@@ -1080,6 +1107,7 @@ export function createData(config: CreateDataInput) {
           }
           message.append(draft, index, failed)
         })
+        if (event.data.inputID) compacting.get(event.data.sessionID)?.observed.add(event.data.inputID)
         return
       case "permission.asked":
         if (store.session.permission[event.data.sessionID]?.some((request) => request.id === event.data.id)) return
@@ -1266,12 +1294,17 @@ export function createData(config: CreateDataInput) {
         sync(sessionID: string) {
           return sync.run(`session.pending:${sessionID}`, async () => {
             const pending = await api().session.inbox.list({ sessionID })
+            // A positive read acknowledges admission even when its SSE echo is delayed.
+            pending.forEach((item) => outbox.delete(item.id))
+            // Compactions also coalesce by Session, not just by the proposed ID.
+            if (pending.some((item) => item.type === "compaction"))
+              store.session.pending[sessionID]
+                ?.filter((item) => item.type === "compaction")
+                .forEach((item) => outbox.delete(item.id))
             // Keep optimistic rows still awaiting their echo: this fetch may
             // have raced ahead of an in-flight admission the server does not
             // know about yet.
-            const inflight = (store.session.pending[sessionID] ?? []).filter(
-              (item) => outbox.has(item.id) && !pending.some((row) => row.id === item.id),
-            )
+            const inflight = (store.session.pending[sessionID] ?? []).filter((item) => outbox.has(item.id))
             const merged = inflight.length === 0 ? pending : [...pending, ...inflight]
             batch(() => {
               setStore("session", "pending", sessionID, reconcile(merged))
@@ -1345,13 +1378,56 @@ export function createData(config: CreateDataInput) {
         if (fresh) track(creating, id, request)
         return { id, request }
       },
+      compact(input: { sessionID: string; model?: ModelRef }) {
+        const active = compacting.get(input.sessionID)
+        if (active) return active.request
+        // A known pending control ID may be consumed while setup waits. Propose
+        // a fresh ID and let the server coalesce, without duplicating its row.
+        const id = SessionMessage.ID.create()
+        if (!store.session.pending[input.sessionID]?.some((item) => item.type === "compaction")) {
+          outbox.add(id)
+          admitLocal({
+            id,
+            sessionID: input.sessionID,
+            timeCreated: Date.now(),
+            type: "compaction",
+            delivery: "steer",
+            payload: {},
+          })
+        }
+        // Compaction admission can coalesce onto a different ID. Retire the
+        // speculative row on an echo, and remember consumed IDs until the POST
+        // settles so its older response cannot resurrect a queued row.
+        const observed = new Set<string>()
+        const request = sendAdmission(input.sessionID, async () => {
+          if (input.model) await api().session.switchModel({ sessionID: input.sessionID, model: input.model })
+          return api().session.compact({ sessionID: input.sessionID, id })
+        })
+          .then((item) => {
+            batch(() => {
+              outbox.delete(id)
+              if (item.id !== id) removePending(input.sessionID, id)
+              if (!observed.has(item.id) && !messageIndex.get(input.sessionID)?.has(item.id)) admitLocal(item)
+            })
+            return item
+          })
+          .catch((error) => {
+            if (outbox.delete(id)) removePending(input.sessionID, id)
+            throw error
+          })
+          .finally(() => {
+            if (compacting.get(input.sessionID)?.request === request) compacting.delete(input.sessionID)
+          })
+        compacting.set(input.sessionID, { id, observed, request })
+        return request
+      },
       // Optimistic prompt admission: render the prompt immediately under a
       // client-minted ID, send it, and let the durable inbox.enqueued echo
       // upsert that same ID with the server's payload. Server admission is
       // idempotent per ID, so retrying with the identical payload cannot
       // double-admit.
-      prompt(input: SessionPromptInput & { gate?: Promise<unknown> }) {
-        const { gate, ...request } = input
+      prompt(input: SessionPromptInput & { gate?: Promise<unknown>; prepare?: () => Promise<unknown> }) {
+        const { gate, prepare, ...request } = input
         const id = request.id ?? SessionMessage.ID.create()
         // A retry may reuse an ID that is already rendered — and possibly
         // already durable. Admit optimistically only for new IDs so a failed
@@ -1377,25 +1453,15 @@ export function createData(config: CreateDataInput) {
             },
           })
         }
-        // Wrapped so even a synchronous client failure reaches the rollback.
-        // The POST additionally waits for the caller's gate, for any
-        // in-flight optimistic create of this session, and for the previous
-        // prompt's POST: the row renders now, the send happens once the
-        // session exists server-side and earlier prompts are admitted.
-        const previous = sending.get(request.sessionID)
-        const send = Promise.resolve()
-          .then(() => Promise.all([gate, creating.get(request.sessionID), previous]))
-          .then(() => api().session.prompt({ ...request, id }))
-        track(
-          sending,
+        return sendAdmission(
           request.sessionID,
-          send.then(
-            () => undefined,
-            () => undefined,
-          ),
-        )
-        return send.catch((error) => {
-          // Roll back only rows this call admitted and the echo has not
+          async () => {
+            await prepare?.()
+            return api().session.prompt({ ...request, id })
+          },
+          gate,
+        ).catch((error) => {
+          // Roll back only rows this call admitted and the server has not
           // acknowledged: anything else is server state.
           if (fresh && outbox.delete(id)) retractLocal(request.sessionID, id)
           throw error
@@ -1464,20 +1530,70 @@ export function createData(config: CreateDataInput) {
         loading(sessionID: string) {
           return store.session.messageLoading[sessionID] ?? false
         },
-        async loadMore(sessionID: string) {
+        async loadMore(
+          sessionID: string,
+          options?: {
+            all?: boolean
+            signal?: AbortSignal
+            /** Runs synchronously inside the store-publication batch. */
+            beforePublish?: () => void
+          },
+        ) {
+          const signal = options?.signal
+          if (signal?.aborted) return
+          while (messageLoads.has(sessionID)) {
+            const published = await (() => {
+              const pending = messageLoads.get(sessionID)
+              if (!signal) return pending
+              const aborted = Promise.withResolvers<void>()
+              const cancel = () => aborted.resolve()
+              signal.addEventListener("abort", cancel, { once: true })
+              return Promise.race([pending, aborted.promise])
+                .catch((error) => {
+                  if (!signal.aborted) throw error
+                })
+                .finally(() => signal.removeEventListener("abort", cancel))
+            })()
+            if ((!options?.all && published) || signal?.aborted) return
+          }
           const cursor = store.session.messageCursor[sessionID]
-          if (!cursor || store.session.messageLoading[sessionID]) return
+          if (!cursor || signal?.aborted) return
           setStore("session", "messageLoading", sessionID, true)
-          const response = await api()
-            .message.list({ sessionID, limit: messagePageLimit, cursor })
+          const request = (async () => {
+            const fetched: SessionMessageInfo[] = []
+            let next: string | undefined = cursor
+            do {
+              const response = await api().message.list(
+                {
+                  sessionID,
+                  limit: options?.all ? 200 : messagePageLimit,
+                  cursor: next,
+                },
+                { signal },
+              )
+              if (signal?.aborted) return
+              fetched.push(...response.data)
+              next = response.cursor.next ?? undefined
+              if (!options?.all) break
+            } while (next)
+            // A jump through history publishes once, not once per page of offscreen messages.
+            const existing = store.session.message[sessionID] ?? []
+            const ids = new Set(existing.map((item) => item.id))
+            const messages = [...fetched.reverse().filter((item) => !ids.has(item.id)), ...existing]
+            batch(() => {
+              options?.beforePublish?.()
+              messageIndex.set(sessionID, new Map(messages.map((item, position) => [item.id, position])))
+              setStore("session", "message", sessionID, reconcile(messages))
+              setStore("session", "messageCursor", sessionID, next)
+            })
+            return true
+          })()
+            .catch((error) => {
+              if (!signal?.aborted) throw error
+            })
             .finally(() => setStore("session", "messageLoading", sessionID, false))
-          const older = response.data.toReversed()
-          const existing = store.session.message[sessionID] ?? []
-          const ids = new Set(existing.map((item) => item.id))
-          const messages = [...older.filter((item) => !ids.has(item.id)), ...existing]
-          messageIndex.set(sessionID, new Map(messages.map((item, position) => [item.id, position])))
-          setStore("session", "message", sessionID, reconcile(messages))
-          setStore("session", "messageCursor", sessionID, response.cursor.next ?? undefined)
+          track(messageLoads, sessionID, request)
+          await request
         },
         invalidate(sessionID: string) {
           sync.invalidate(`session.message:${sessionID}`)

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

@@ -0,0 +1,400 @@
+import { expect, test } from "bun:test"
+import { createRoot } from "solid-js"
+import { createData, type CreateDataInput } from "../src/solid"
+import { OpenCode, type OpenCodeEvent, type SessionInboxCompaction, type SessionInboxInfo } from "../src/promise"
+
+test("admits compaction before model setup and serializes the following prompt", async () => {
+  using fixture = setup()
+  const compact = fixture.data.session.compact({ sessionID, model: { providerID: "demo", id: "model" } })
+  const proposed = fixture.data.session.pending.list(sessionID)[0]
+  expect(proposed).toMatchObject({ type: "compaction", sessionID })
+  expect(fixture.calls).toEqual([])
+  expect(fixture.data.session.message.list(sessionID)).toEqual([])
+  expect(fixture.data.session.status(sessionID)).toBe("idle")
+
+  const prompt = fixture.data.session.prompt({ sessionID, text: "Follow up" })
+  expect(fixture.data.session.message.list(sessionID)).toMatchObject([{ type: "user", text: "Follow up" }])
+  await wait(() => fixture.calls.length === 1)
+  expect(fixture.calls).toEqual(["model"])
+  fixture.model.resolve()
+  await wait(() => fixture.calls.length === 2)
+  expect(fixture.calls).toEqual(["model", "compact"])
+  fixture.response.resolve(Response.json({ data: item(proposed.id) }))
+  await Promise.all([compact, prompt])
+  expect(fixture.calls).toEqual(["model", "compact", "prompt"])
+  expect(fixture.proposals).toEqual([proposed.id])
+})
+
+test("coalesces duplicate gestures until the admission request settles", async () => {
+  using fixture = setup()
+  const first = fixture.data.session.compact({ sessionID })
+  expect(fixture.data.session.compact({ sessionID })).toBe(first)
+  expect(fixture.data.session.pending.list(sessionID)).toHaveLength(1)
+  await wait(() => fixture.calls.length === 1)
+  fixture.response.resolve(Response.json({ data: item("msg_canonical") }))
+  await first
+  expect(fixture.calls).toEqual(["compact"])
+  const next = fixture.data.session.compact({ sessionID })
+  expect(next).not.toBe(first)
+  await next
+  expect(fixture.calls).toEqual(["compact", "compact"])
+  expect(new Set(fixture.proposals).size).toBe(2)
+  expect(fixture.proposals).not.toContain("msg_canonical")
+})
+
+test("substitutes the canonical response ID and reconciles its later echo", async () => {
+  using fixture = setup()
+  const request = fixture.data.session.compact({ sessionID })
+  const proposed = fixture.data.session.pending.list(sessionID)[0].id
+  await fixture.data.session.pending.sync(sessionID)
+  expect(fixture.data.session.pending.list(sessionID).map((row) => row.id)).toEqual([proposed])
+  fixture.response.resolve(Response.json({ data: item("msg_canonical") }))
+  await request
+  expect(fixture.data.session.pending.list(sessionID)).toEqual([item("msg_canonical")])
+  fixture.enqueue("msg_canonical", 20)
+  expect(fixture.data.session.pending.list(sessionID)).toEqual([item("msg_canonical", 20)])
+  expect(fixture.data.session.input.list(sessionID)).toEqual([])
+})
+
+test.each(["proposed", "canonical"])("adopts the %s echo before the response without duplicating it", async (kind) => {
+  using fixture = setup()
+  const request = fixture.data.session.compact({ sessionID })
+  const id = kind === "proposed" ? fixture.data.session.pending.list(sessionID)[0].id : "msg_canonical"
+  fixture.enqueue(id, 20)
+  expect(fixture.data.session.pending.list(sessionID)).toEqual([item(id, 20)])
+  fixture.response.resolve(Response.json({ data: item(id) }))
+  await request
+  expect(fixture.data.session.pending.list(sessionID)).toEqual([item(id, 20)])
+})
+
+test.each(["started", "cancelled", "failed"])(
+  "does not resurrect a canonical item already %s before the response",
+  async (kind) => {
+    using fixture = setup()
+    const request = fixture.data.session.compact({ sessionID })
+    fixture.enqueue("msg_canonical")
+    if (kind === "started")
+      fixture.emit({
+        ...event,
+        type: "session.compaction.started",
+        data: { sessionID, inputID: "msg_canonical", reason: "manual" },
+      })
+    if (kind === "cancelled")
+      fixture.emit({ ...event, type: "session.inbox.cancelled", data: { sessionID, inboxID: "msg_canonical" } })
+    if (kind === "failed")
+      fixture.emit({
+        ...event,
+        type: "session.compaction.failed",
+        data: {
+          sessionID,
+          inputID: "msg_canonical",
+          reason: "manual",
+          error: { type: "aborted", message: "Cancelled" },
+        },
+      })
+    expect(fixture.data.session.pending.list(sessionID)).toEqual([])
+    fixture.response.resolve(Response.json({ data: item("msg_canonical") }))
+    await request
+    expect(fixture.data.session.pending.list(sessionID)).toEqual([])
+    if (kind === "started") {
+      expect(fixture.data.session.message.list(sessionID)).toMatchObject([{ type: "compaction", status: "running" }])
+      fixture.emit({
+        ...event,
+        type: "session.compaction.ended",
+        data: { sessionID, reason: "manual", text: "Summary", recent: "Recent" },
+      })
+      expect(fixture.data.session.message.list(sessionID)).toMatchObject([
+        { type: "compaction", status: "completed", summary: "Summary" },
+      ])
+    }
+  },
+)
+
+test.each(["model", "compact"])("rolls back a rejected %s RPC and releases the following prompt", async (rpc) => {
+  using fixture = setup()
+  const request = fixture.data.session.compact({ sessionID, model: { providerID: "demo", id: "model" } })
+  const failed = request.catch((error: unknown) => error)
+  const prompt = fixture.data.session.prompt({ sessionID, text: "Follow up" })
+  if (rpc === "model") fixture.model.reject(new Error("Model setup failed"))
+  if (rpc === "compact") {
+    fixture.model.resolve()
+    fixture.response.resolve(new Response("Admission failed", { status: 500 }))
+  }
+  expect(await failed).toBeInstanceOf(Error)
+  await prompt
+  expect(fixture.data.session.pending.list(sessionID).map((row) => row.type)).toEqual(["user"])
+  expect(fixture.data.session.message.list(sessionID)).toMatchObject([{ type: "user", text: "Follow up" }])
+})
+
+test.each(["proposed", "canonical", "existing"])(
+  "preserves acknowledged %s compaction after an HTTP error",
+  async (kind) => {
+    using fixture = setup()
+    if (kind === "existing") fixture.enqueue("msg_canonical")
+    const request = fixture.data.session.compact({ sessionID })
+    const failed = request.catch((error: unknown) => error)
+    const id = kind === "proposed" ? fixture.data.session.pending.list(sessionID)[0].id : "msg_canonical"
+    if (kind !== "existing") fixture.enqueue(id)
+    expect(fixture.data.session.pending.list(sessionID)).toEqual([item(id)])
+    fixture.response.resolve(new Response("Lost response", { status: 500 }))
+    expect(await failed).toBeInstanceOf(Error)
+    expect(fixture.data.session.pending.list(sessionID)).toEqual([item(id)])
+    expect(fixture.listeners.size).toBe(1)
+  },
+)
+
+test("uses a fresh control ID when the known pending compaction starts during model setup", async () => {
+  const proposed = Promise.withResolvers<string>()
+  using fixture = setup(async (request) => {
+    if (!request.url.endsWith("/compact")) return undefined
+    const body = await request.json()
+    proposed.resolve(body.id)
+    if (body.id === "msg_existing") return Response.json({ message: "Control ID already consumed" }, { status: 409 })
+    return Response.json({ data: item(body.id) })
+  })
+  fixture.enqueue("msg_existing")
+  const request = fixture.data.session.compact({ sessionID, model: { providerID: "demo", id: "model" } })
+  const result = request.catch((error: unknown) => error)
+  expect(fixture.data.session.pending.list(sessionID)).toEqual([item("msg_existing")])
+  await wait(() => fixture.calls.includes("model"))
+  fixture.emit({
+    ...event,
+    type: "session.compaction.started",
+    data: { sessionID, inputID: "msg_existing", reason: "manual" },
+  })
+  fixture.model.resolve()
+  expect(await proposed.promise).not.toBe("msg_existing")
+  expect(await result).toEqual(item(await proposed.promise))
+  expect(fixture.data.session.pending.list(sessionID)).toEqual([item(await proposed.promise)])
+  expect(fixture.data.session.message.list(sessionID)).toMatchObject([
+    { id: "msg_existing", type: "compaction", status: "running" },
+  ])
+})
+
+test.each(["compaction", "canonical compaction", "user"])(
+  "preserves a fetched durable %s when SSE is delayed and HTTP fails",
+  async (type) => {
+    using fixture = setup(async (request) => {
+      if (request.url.endsWith("/prompt")) return fixture.response.promise
+      return undefined
+    })
+    const request =
+      type === "user"
+        ? fixture.data.session.prompt({ sessionID, text: "Follow up" })
+        : fixture.data.session.compact({ sessionID })
+    const result = request.catch((error: unknown) => error)
+    const id = type === "canonical compaction" ? "msg_canonical" : fixture.data.session.pending.list(sessionID)[0].id
+    const durable: SessionInboxInfo =
+      type === "user" ? { ...item(id, 20), type: "user", payload: { text: "Follow up" } } : item(id, 20)
+    fixture.pending.push(durable)
+    await fixture.data.session.pending.sync(sessionID)
+    expect(fixture.data.session.pending.list(sessionID)).toEqual([durable])
+    fixture.response.resolve(new Response("Lost response", { status: 500 }))
+    expect(await result).toBeInstanceOf(Error)
+    expect(fixture.data.session.pending.list(sessionID)).toEqual([durable])
+    if (type === "user")
+      expect(fixture.data.session.message.list(sessionID)).toMatchObject([{ id, type: "user", text: "Follow up" }])
+  },
+)
+
+test("keeps one event listener and removes it when the data owner is disposed during a gate", async () => {
+  using fixture = setup()
+  const gate = Promise.withResolvers<void>()
+  const first = fixture.data.session.prompt({ sessionID, text: "First", gate: gate.promise })
+  const compact = fixture.data.session.compact({ sessionID })
+  expect(fixture.listeners.size).toBe(1)
+  fixture.dispose()
+  expect(fixture.listeners.size).toBe(0)
+  gate.resolve()
+  fixture.response.resolve(Response.json({ data: item("msg_canonical") }))
+  await Promise.all([first, compact])
+  expect(fixture.listeners.size).toBe(0)
+})
+
+test("routes concurrent compaction observations by session through one listener", async () => {
+  const firstResponse = Promise.withResolvers<Response>()
+  const secondResponse = Promise.withResolvers<Response>()
+  using fixture = setup(async (request) => {
+    if (!request.url.endsWith("/compact")) return undefined
+    return request.url.includes(`/session/${sessionID}/`) ? firstResponse.promise : secondResponse.promise
+  })
+  const first = fixture.data.session.compact({ sessionID })
+  const second = fixture.data.session.compact({ sessionID: "ses_other" })
+  const firstID = fixture.data.session.pending.list(sessionID)[0].id
+  const secondID = fixture.data.session.pending.list("ses_other")[0].id
+  expect(fixture.listeners.size).toBe(1)
+  fixture.emit({ ...event, type: "session.inbox.cancelled", data: { sessionID, inboxID: firstID } })
+  expect(fixture.data.session.pending.list(sessionID)).toEqual([])
+  expect(fixture.data.session.pending.list("ses_other").map((row) => row.id)).toEqual([secondID])
+
+  firstResponse.resolve(Response.json({ data: item(firstID) }))
+  secondResponse.resolve(Response.json({ data: { ...item(secondID), sessionID: "ses_other" } }))
+  await Promise.all([first, second])
+  expect(fixture.data.session.pending.list(sessionID)).toEqual([])
+  expect(fixture.data.session.pending.list("ses_other")).toEqual([{ ...item(secondID), sessionID: "ses_other" }])
+  expect(fixture.listeners.size).toBe(1)
+})
+
+test.each(["gate", "prepare"])(
+  "a preceding prompt's failed %s does not block compaction or following model preparation",
+  async (kind) => {
+    using fixture = setup()
+    const gate = Promise.withResolvers<void>()
+    const prepared: string[] = []
+    const first = fixture.data.session
+      .prompt({
+        sessionID,
+        id: "msg_first",
+        text: "First",
+        gate: kind === "gate" ? gate.promise : undefined,
+        prepare: () => {
+          prepared.push("first")
+          return gate.promise
+        },
+      })
+      .catch((error: unknown) => error)
+    const compact = fixture.data.session.compact({ sessionID, model: { providerID: "demo", id: "first" } })
+    const following = fixture.data.session.prompt({
+      sessionID,
+      text: "Follow up",
+      prepare: () => {
+        prepared.push("following")
+        return fixture.api.session.switchModel({ sessionID, model: { providerID: "demo", id: "second" } })
+      },
+    })
+    if (kind === "prepare") await wait(() => prepared.includes("first"))
+    gate.reject(new Error("Preparation failed"))
+    expect(await first).toBeInstanceOf(Error)
+    await wait(() => fixture.calls.includes("model"))
+    expect(prepared).toEqual(kind === "prepare" ? ["first"] : [])
+    fixture.model.resolve()
+    fixture.response.resolve(Response.json({ data: item("msg_canonical") }))
+    await Promise.all([compact, following])
+    expect(fixture.calls).toEqual(["model", "compact", "model", "prompt"])
+    expect(prepared.at(-1)).toBe("following")
+    expect(fixture.data.session.message.list(sessionID)).toMatchObject([{ type: "user", text: "Follow up" }])
+  },
+)
+
+test("creation failure rejects gated prompt, compaction, and following preparation without sending their RPCs", async () => {
+  const creation = Promise.withResolvers<Response>()
+  const requested = Promise.withResolvers<void>()
+  using fixture = setup(async (request) => {
+    if (!request.url.endsWith("/api/session")) return undefined
+    requested.resolve()
+    return creation.promise
+  })
+  const gate = Promise.withResolvers<void>()
+  const prepared: string[] = []
+  const created = fixture.data.session.create({ id: sessionID })
+  const first = fixture.data.session.prompt({ sessionID, text: "First", gate: gate.promise })
+  const compact = fixture.data.session.compact({ sessionID, model: { providerID: "demo", id: "model" } })
+  const following = fixture.data.session.prompt({
+    sessionID,
+    text: "Follow up",
+    prepare: async () => {
+      prepared.push("following")
+    },
+  })
+  const results = Promise.allSettled([created.request, first, compact, following])
+  await requested.promise
+  creation.resolve(new Response("Creation failed", { status: 500 }))
+  expect((await results).map((result) => result.status)).toEqual(["rejected", "rejected", "rejected", "rejected"])
+  expect(fixture.calls).toEqual([])
+  expect(prepared).toEqual([])
+  expect(fixture.data.session.get(sessionID)).toBeUndefined()
+  expect(fixture.data.session.pending.list(sessionID)).toEqual([])
+  expect(fixture.listeners.size).toBe(1)
+  gate.resolve()
+})
+
+const sessionID = "ses_compact"
+const event = { id: "evt_compact", created: 10, durable: { aggregateID: sessionID, seq: 1, version: 1 } }
+const item = (id: string, timeCreated = 10): SessionInboxCompaction => ({
+  id,
+  sessionID,
+  timeCreated,
+  type: "compaction",
+  delivery: "steer",
+  payload: {},
+})
+
+function setup(override?: (request: Request) => Promise<Response | undefined>) {
+  const model = Promise.withResolvers<void>()
+  const response = Promise.withResolvers<Response>()
+  const calls: string[] = []
+  const proposals: string[] = []
+  const pending: SessionInboxInfo[] = []
+  const listeners = new Set<Parameters<CreateDataInput["event"]["listen"]>[0]>()
+  const api = OpenCode.make({
+    baseUrl: "http://opencode.local",
+    fetch: async (input, init) => {
+      const request = input instanceof Request ? input : new Request(input, init)
+      const overridden = await override?.(request)
+      if (overridden) return overridden
+      const rpc = new URL(request.url).pathname.split("/").at(-1)
+      if (rpc === "inbox") return Response.json({ data: pending })
+      if (rpc === "model") {
+        calls.push(rpc)
+        await model.promise
+        return new Response(null, { status: 204 })
+      }
+      if (rpc === "compact") {
+        calls.push(rpc)
+        proposals.push((await request.json()).id)
+        return (await response.promise).clone()
+      }
+      if (rpc === "prompt") {
+        calls.push(rpc)
+        return Response.json({
+          data: { ...item((await request.json()).id), type: "user", payload: { text: "Follow up" } },
+        })
+      }
+      throw new Error(`Unexpected request: ${request.url}`)
+    },
+  })
+  const root = createRoot((dispose) => ({
+    data: createData({
+      api: () => api,
+      directory: "/project",
+      event: {
+        on: () => () => {},
+        listen(handler) {
+          listeners.add(handler)
+          return () => listeners.delete(handler)
+        },
+      },
+    }),
+    dispose,
+  }))
+  const emit = (details: OpenCodeEvent) => listeners.forEach((listener) => listener({ name: details.type, details }))
+  return {
+    data: root.data,
+    api,
+    dispose: root.dispose,
+    [Symbol.dispose]: root.dispose,
+    model,
+    response,
+    calls,
+    proposals,
+    pending,
+    listeners,
+    emit,
+    enqueue(id: string, created = 10) {
+      emit({
+        ...event,
+        created,
+        type: "session.inbox.enqueued",
+        data: { sessionID, inboxID: id, item: { type: "compaction", delivery: "steer", payload: {} } },
+      })
+    },
+  }
+}
+
+async function wait(predicate: () => boolean) {
+  for (let attempt = 0; attempt < 100; attempt++) {
+    if (predicate()) return
+    await Bun.sleep(5)
+  }
+  throw new Error("Timed out waiting for request")
+}

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

@@ -1,4 +1,5 @@
 import { expect, test } from "bun:test"
+import { getEventListeners } from "node:events"
 import { createRoot } from "solid-js"
 import { createData, type CreateDataInput } from "../src/solid"
 import { OpenCode, type OpenCodeEvent, type Project, type SessionInfo } from "../src/promise"
@@ -414,6 +415,120 @@ test("loads bounded message pages", async () => {
   }
 })
 
+test.each(["success", "failure", "cancel", "cancel-retry", "cancel-page", "join-cancel", "join-failure"])(
+  "bulk history (%s)",
+  async (mode) => {
+    const messages = [1, 2, 3].map((index) => ({
+      id: `msg_${index}`,
+      type: "user",
+      text: `Message ${index}`,
+      time: { created: index },
+    }))
+    const release = Promise.withResolvers<void>()
+    const controller = new AbortController()
+    const requests: URL[] = []
+    const publications: string[][] = []
+    const api = OpenCode.make({
+      baseUrl: "http://opencode.local",
+      fetch: async (input, init) => {
+        const url = new URL(input instanceof Request ? input.url : String(input))
+        requests.push(url)
+        const cursor = url.searchParams.get("cursor")
+        if (!cursor) return Response.json({ data: [messages[2]], cursor: { next: "recent" } })
+        if (cursor === "recent") {
+          if (mode.startsWith("join")) await release.promise
+          if (mode === "join-failure") return Response.json({ message: "offline" }, { status: 503 })
+          return Response.json({ data: [messages[2], messages[1]], cursor: { next: "oldest" } })
+        }
+        if (cursor === "oldest") return Response.json({ data: [messages[0]], cursor: { next: "empty" } })
+        expect(init?.signal).toBe(requests.length === 4 ? controller.signal : undefined)
+        await release.promise
+        if (mode === "failure") return Response.json({ message: "offline" }, { status: 503 })
+        return Response.json({ data: [], cursor: {} })
+      },
+    })
+    const setup = createRoot((dispose) => {
+      const data = createData({
+        api: () => api,
+        directory: "/project",
+        event: { on: () => () => {}, listen: () => () => {} },
+      })
+      return { data, dispose }
+    })
+
+    try {
+      await setup.data.session.message.sync("ses_refresh")
+      const newest = setup.data.session.message.get("ses_refresh", "msg_3")
+      const load = setup.data.session.message.loadMore(
+        "ses_refresh",
+        mode.startsWith("join")
+          ? undefined
+          : {
+              all: true,
+              signal: controller.signal,
+              beforePublish: () => {
+                publications.push(setup.data.session.message.list("ses_refresh").map((message) => message.id))
+                expect(setup.data.session.message.get("ses_refresh", "msg_3")).toBe(newest)
+              },
+            },
+      )
+      const joined = setup.data.session.message.loadMore("ses_refresh", { all: true, signal: controller.signal })
+      const settled = Promise.allSettled([load, joined])
+      if (mode.startsWith("join")) {
+        await wait(() => requests.length === 2)
+        expect(getEventListeners(controller.signal, "abort")).toHaveLength(1)
+        controller.abort()
+        let cancelled = false
+        void joined.then(() => {
+          cancelled = true
+        })
+        await wait(() => cancelled)
+        expect(setup.data.session.message.loading("ses_refresh")).toBe(true)
+        expect(getEventListeners(controller.signal, "abort")).toHaveLength(0)
+        release.resolve()
+        expect((await settled).map((result) => result.status)).toEqual(
+          mode === "join-failure" ? ["rejected", "fulfilled"] : ["fulfilled", "fulfilled"],
+        )
+        expect(requests.at(-1)?.searchParams.get("limit")).toBe("20")
+        expect(requests).toHaveLength(2)
+        expect(setup.data.session.message.more("ses_refresh")).toBe(true)
+        expect(setup.data.session.message.list("ses_refresh").map((message) => message.id)).toEqual(
+          mode === "join-failure" ? ["msg_3"] : ["msg_2", "msg_3"],
+        )
+        return
+      }
+      await wait(() => requests.length === 4)
+      expect(setup.data.session.message.loading("ses_refresh")).toBe(true)
+      expect(setup.data.session.message.list("ses_refresh").map((message) => message.id)).toEqual(["msg_3"])
+      expect(requests.slice(1).map((url) => url.searchParams.get("limit"))).toEqual(["200", "200", "200"])
+      if (mode.startsWith("cancel")) controller.abort()
+      const retry =
+        mode === "cancel-retry" || mode === "cancel-page"
+          ? setup.data.session.message.loadMore("ses_refresh", mode === "cancel-retry" ? { all: true } : undefined)
+          : undefined
+      release.resolve()
+      expect((await settled).map((result) => result.status)).toEqual(
+        mode === "failure" ? ["rejected", "rejected"] : ["fulfilled", "fulfilled"],
+      )
+      await retry
+      const success = mode === "success" || mode === "cancel-retry"
+      expect(setup.data.session.message.loading("ses_refresh")).toBe(false)
+      expect(setup.data.session.message.more("ses_refresh")).toBe(!success)
+      expect(setup.data.session.message.list("ses_refresh").map((message) => message.id)).toEqual(
+        success ? ["msg_1", "msg_2", "msg_3"] : mode === "cancel-page" ? ["msg_2", "msg_3"] : ["msg_3"],
+      )
+      expect(setup.data.session.message.get("ses_refresh", "msg_3")).toBe(newest)
+      expect(requests).toHaveLength(mode === "cancel-retry" ? 7 : mode === "cancel-page" ? 5 : 4)
+      if (mode === "cancel-page") expect(requests.at(-1)?.searchParams.get("limit")).toBe("20")
+      expect(publications).toEqual(mode === "success" ? [["msg_3"]] : [])
+      expect(getEventListeners(controller.signal, "abort")).toHaveLength(0)
+    } finally {
+      release.resolve()
+      setup.dispose()
+    }
+  },
+)
+
 test("preserves assistant content replacement events across an active message read", async () => {
   const listeners = new Set<Parameters<CreateDataInput["event"]["listen"]>[0]>()
   const release = Promise.withResolvers<void>()

packages/core/src/aisdk-native.ts

@@ -84,10 +84,7 @@ export function map(input: MapInput): Mapping | undefined {
           ...mapAPIKey(input.settings),
           ...(typeof input.settings.location === "string" ? { location: input.settings.location } : {}),
           ...(typeof input.settings.project === "string" ? { project: input.settings.project } : {}),
-          ...mapGoogleOptions(
-            input.settings,
-            isStringRecord(input.settings.labels) ? { labels: input.settings.labels } : {},
-          ),
+          ...mapGoogleOptions(input.settings),
         },
         ...(isStringRecord(input.settings.headers) ? { headers: input.settings.headers } : {}),
       }
@@ -122,6 +119,17 @@ export function map(input: MapInput): Mapping | undefined {
           ...mapProviderOptions(input.settings, ["apiKey", "baseURL", "organization", "project", "queryParams"]),
         },
       }
+    case "merge-gateway-ai-sdk-provider":
+      return {
+        package: "@opencode-ai/ai/providers/openai-compatible",
+        settings: {
+          baseURL: "https://api-gateway.merge.dev/v1/ai-sdk",
+          ...baseSettings,
+          ...mapAPIKey(input.settings),
+          provider: input.providerID,
+          ...mapProviderOptions(input.settings, ["apiKey", "baseURL"]),
+        },
+      }
     case "@ai-sdk/openai-compatible":
       if (typeof input.settings.baseURL !== "string") return
       return {
@@ -296,7 +304,7 @@ function mapAPIKey(settings: Readonly<Record<string, unknown>>) {
   return typeof settings.apiKey === "string" ? { apiKey: settings.apiKey } : {}
 }
 
-function mapGoogleOptions(settings: Readonly<Record<string, unknown>>, extra: Readonly<Record<string, unknown>> = {}) {
+function mapGoogleOptions(settings: Readonly<Record<string, unknown>>) {
   const input = settings.thinkingConfig
   const thinkingConfig = {
     ...(isRecord(input) && typeof input.thinkingBudget === "number" ? { thinkingBudget: input.thinkingBudget } : {}),
@@ -311,7 +319,6 @@ function mapGoogleOptions(settings: Readonly<Record<string, unknown>>, extra: Re
     ...(Array.isArray(settings.safetySettings) ? { safetySettings: settings.safetySettings } : {}),
     ...(typeof settings.serviceTier === "string" ? { serviceTier: settings.serviceTier } : {}),
     ...(Object.keys(thinkingConfig).length > 0 ? { thinkingConfig } : {}),
-    ...extra,
   }
   if (Object.keys(options).length === 0) return {}
   return { providerOptions: options }
@@ -345,28 +352,21 @@ function mapOpenRouter(
 }
 
 function mapOpenRouterOptions(settings: Readonly<Record<string, unknown>>) {
-  const options = Object.fromEntries(
-    Object.entries(settings).filter(
-      ([key]) =>
-        ![
-          "apiKey",
-          "api_keys",
-          "appName",
-          "appUrl",
-          "authToken",
-          "baseURL",
-          "chunkTimeout",
-          "compatibility",
-          "extraBody",
-          "fetch",
-          "headers",
-          "promptCacheKey",
-          "timeout",
-        ].includes(key),
-    ),
-  )
-  if (Object.keys(options).length === 0) return {}
-  return { providerOptions: options }
+  return mapProviderOptions(settings, [
+    "apiKey",
+    "api_keys",
+    "appName",
+    "appUrl",
+    "authToken",
+    "baseURL",
+    "chunkTimeout",
+    "compatibility",
+    "extraBody",
+    "fetch",
+    "headers",
+    "promptCacheKey",
+    "timeout",
+  ])
 }
 
 function isStringRecord(value: unknown): value is Readonly<Record<string, string>> {

packages/core/src/aisdk.ts

@@ -482,8 +482,7 @@ function toolMessage(input: LLMRequest["messages"][number]) {
     const value = part.result.value.filter((item) => {
       if (item.type !== "file") return true
       if (!item.mime.startsWith("image/") && item.mime !== "application/pdf") return true
-      const data = /^data:[^;,]+(?:;[^,]*)*;base64,(.*)$/s.exec(item.uri)?.[1] ?? item.uri
-      media.push({ type: "file", mediaType: item.mime, data, filename: item.name })
+      media.push({ type: "file", mediaType: item.mime, data: fileData(item.uri), filename: item.name })
       return false
     })
     return toolResultPart({
@@ -507,7 +506,7 @@ function text(part: ContentPart) {
 function userPart(part: ContentPart): UserContent {
   if (part.type === "text") return [{ type: "text", text: part.text }]
   if (part.type === "media")
-    return [{ type: "file", mediaType: part.mediaType, data: part.data, filename: part.filename }]
+    return [{ type: "file", mediaType: part.mediaType, data: fileData(part.data), filename: part.filename }]
   return []
 }
 
@@ -516,7 +515,7 @@ function assistantPart(part: ContentPart): AssistantContent {
     case "text":
       return [{ type: "text", text: part.text, providerOptions: metadataProviderOptions(part.providerMetadata) }]
     case "media":
-      return [{ type: "file", mediaType: part.mediaType, data: part.data, filename: part.filename }]
+      return [{ type: "file", mediaType: part.mediaType, data: fileData(part.data), filename: part.filename }]
     case "reasoning":
       return [{ type: "reasoning", text: part.text, providerOptions: metadataProviderOptions(part.providerMetadata) }]
     case "tool-call":
@@ -535,6 +534,15 @@ function assistantPart(part: ContentPart): AssistantContent {
   }
 }
 
+function fileData(data: Extract<ContentPart, { type: "media" }>["data"]) {
+  if (typeof data !== "string") return data
+  const base64 = /^data:[^;,]+(?:;[^,]*)*;base64,(.*)$/s.exec(data)?.[1]
+  if (base64 !== undefined) return base64
+  if (!URL.canParse(data)) return data
+  const url = new URL(data)
+  return url.protocol === "http:" || url.protocol === "https:" ? url : data
+}
+
 function toolResultPart(part: ContentPart): ToolResultContent[] {
   if (part.type !== "tool-result") return []
   return [

packages/core/src/bus.ts

@@ -294,162 +294,156 @@ export function configured(options?: Options) {
         ) {
           return Effect.gen(function* () {
             const durable = definition.durable
-            if (durable) {
-              const aggregateID = (event.data as Record<string, unknown>)[durable.aggregate]
-              if (typeof aggregateID !== "string") {
-                yield* Effect.die(
-                  new InvalidDurableEventError({
-                    type: event.type,
-                    message: `Expected string aggregate field ${durable.aggregate}`,
-                  }),
-                )
-              } else {
-                if (input && input.aggregateID !== aggregateID) {
-                  yield* Effect.die(
-                    new InvalidDurableEventError({
-                      type: event.type,
-                      message: `Aggregate mismatch: expected ${input.aggregateID}, got ${aggregateID}`,
-                    }),
-                  )
-                }
-                const list = projectors.get(versionedType(definition.type, durable.version)) ?? []
-                return yield* Effect.uninterruptible(
-                  Effect.gen(function* () {
-                    const committed = yield* db
-                      .transaction(
-                        () =>
-                          Effect.gen(function* () {
-                            const row = yield* db
-                              .select({ seq: EventSequenceTable.seq, ownerID: EventSequenceTable.owner_id })
-                              .from(EventSequenceTable)
-                              .where(eq(EventSequenceTable.aggregate_id, aggregateID))
-                              .get()
-                              .pipe(Effect.orDie)
-                            const latest = row?.seq ?? -1
-                            const encoded = Schema.encodeUnknownSync(definition.data)(event.data) as Record<
-                              string,
-                              unknown
-                            >
-                            if (input?.strictOwner && row?.ownerID && row.ownerID !== input.ownerID) {
-                              yield* Effect.die(
-                                new InvalidDurableEventError({
-                                  type: event.type,
-                                  message: `Replay owner mismatch for aggregate ${aggregateID}: expected ${row.ownerID}, got ${input.ownerID ?? "none"}`,
-                                }),
-                              )
-                            }
-                            if (input && input.seq <= latest) {
-                              if (!persist) return
-                              const stored = yield* db
-                                .select()
-                                .from(EventTable)
-                                .where(and(eq(EventTable.aggregate_id, aggregateID), eq(EventTable.seq, input.seq)))
-                                .get()
-                                .pipe(Effect.orDie)
-                              if (
-                                stored?.id === event.id &&
-                                stored.type === versionedType(definition.type, durable.version) &&
-                                stored.created === (event.created ?? 0) &&
-                                isDeepStrictEqual(stored.data, encoded)
-                              ) {
-                                if (input.ownerID && row?.ownerID == null) {
-                                  yield* db
-                                    .update(EventSequenceTable)
-                                    .set({ owner_id: input.ownerID })
-                                    .where(eq(EventSequenceTable.aggregate_id, aggregateID))
-                                    .run()
-                                    .pipe(Effect.orDie)
-                                }
-                                return
-                              }
-                              yield* Effect.die(
-                                new InvalidDurableEventError({
-                                  type: event.type,
-                                  message: `Replay diverged at aggregate ${aggregateID} sequence ${input.seq}`,
-                                }),
-                              )
-                            }
-                            if (input && row?.ownerID && row.ownerID !== input.ownerID) {
-                              return
-                            }
-                            const seq = input?.seq ?? latest + 1
-                            if (input && seq !== latest + 1) {
-                              yield* Effect.die(
-                                new InvalidDurableEventError({
-                                  type: event.type,
-                                  message: `Sequence mismatch for aggregate ${aggregateID}: expected ${latest + 1}, got ${seq}`,
-                                }),
-                              )
-                            }
-                            if (persist) {
-                              const stored = yield* db
-                                .select({ aggregateID: EventTable.aggregate_id, seq: EventTable.seq })
-                                .from(EventTable)
-                                .where(eq(EventTable.id, event.id))
-                                .get()
-                                .pipe(Effect.orDie)
-                              if (stored)
-                                yield* Effect.die(
-                                  new InvalidDurableEventError({
-                                    type: event.type,
-                                    message: `Event ${event.id} already exists at aggregate ${stored.aggregateID} sequence ${stored.seq}`,
-                                  }),
-                                )
-                            }
-                            const committed = {
-                              ...event,
-                              durable: { aggregateID, seq, version: durable.version },
-                            } as Event.Payload
-                            const route = yield* prepareRoutes([committed])
-                            for (const projector of list) {
-                              yield* projector(committed)
-                            }
-                            if (commit) yield* commit(seq)
-                            yield* db
-                              .insert(EventSequenceTable)
-                              .values([{ aggregate_id: aggregateID, seq, owner_id: input?.ownerID }])
-                              .onConflictDoUpdate({
-                                target: EventSequenceTable.aggregate_id,
-                                set: {
-                                  seq: sql`max(${EventSequenceTable.seq}, ${seq})`,
-                                  ...(input?.ownerID && row?.ownerID == null ? { owner_id: input.ownerID } : {}),
-                                },
-                              })
-                              .run()
-                              .pipe(Effect.orDie)
-                            if (persist)
+            if (!durable) return yield* Effect.void
+            const aggregateID = (event.data as Record<string, unknown>)[durable.aggregate]
+            if (typeof aggregateID !== "string")
+              return yield* Effect.die(
+                new InvalidDurableEventError({
+                  type: event.type,
+                  message: `Expected string aggregate field ${durable.aggregate}`,
+                }),
+              )
+            if (input && input.aggregateID !== aggregateID) {
+              yield* Effect.die(
+                new InvalidDurableEventError({
+                  type: event.type,
+                  message: `Aggregate mismatch: expected ${input.aggregateID}, got ${aggregateID}`,
+                }),
+              )
+            }
+            const list = projectors.get(versionedType(definition.type, durable.version)) ?? []
+            return yield* Effect.uninterruptible(
+              Effect.gen(function* () {
+                const committed = yield* db
+                  .transaction(
+                    () =>
+                      Effect.gen(function* () {
+                        const row = yield* db
+                          .select({ seq: EventSequenceTable.seq, ownerID: EventSequenceTable.owner_id })
+                          .from(EventSequenceTable)
+                          .where(eq(EventSequenceTable.aggregate_id, aggregateID))
+                          .get()
+                          .pipe(Effect.orDie)
+                        const latest = row?.seq ?? -1
+                        const encoded = Schema.encodeUnknownSync(definition.data)(event.data) as Record<string, unknown>
+                        if (input?.strictOwner && row?.ownerID && row.ownerID !== input.ownerID) {
+                          yield* Effect.die(
+                            new InvalidDurableEventError({
+                              type: event.type,
+                              message: `Replay owner mismatch for aggregate ${aggregateID}: expected ${row.ownerID}, got ${input.ownerID ?? "none"}`,
+                            }),
+                          )
+                        }
+                        if (input && input.seq <= latest) {
+                          if (!persist) return
+                          const stored = yield* db
+                            .select()
+                            .from(EventTable)
+                            .where(and(eq(EventTable.aggregate_id, aggregateID), eq(EventTable.seq, input.seq)))
+                            .get()
+                            .pipe(Effect.orDie)
+                          if (
+                            stored?.id === event.id &&
+                            stored.type === versionedType(definition.type, durable.version) &&
+                            stored.created === (event.created ?? 0) &&
+                            isDeepStrictEqual(stored.data, encoded)
+                          ) {
+                            if (input.ownerID && row?.ownerID == null) {
                               yield* db
-                                .insert(EventTable)
-                                .values([
-                                  {
-                                    id: event.id,
-                                    aggregate_id: aggregateID,
-                                    seq,
-                                    created: event.created ?? 0,
-                                    type: versionedType(definition.type, durable.version),
-                                    data: encoded,
-                                  },
-                                ])
+                                .update(EventSequenceTable)
+                                .set({ owner_id: input.ownerID })
+                                .where(eq(EventSequenceTable.aggregate_id, aggregateID))
                                 .run()
                                 .pipe(Effect.orDie)
-                            return { aggregateID, seq, event: committed, route }
-                          }),
-                        { behavior: "immediate" },
-                      )
-                      .pipe(Effect.orDie)
-                    if (committed) {
-                      committed.route()
-                      yield* Effect.forEach(
-                        pubsub.durable.get(committed.aggregateID) ?? [],
-                        (wake) => PubSub.publish(wake, undefined),
-                        { discard: true },
-                      )
-                    }
-                    return committed
-                  }),
-                )
-              }
-            }
+                            }
+                            return
+                          }
+                          yield* Effect.die(
+                            new InvalidDurableEventError({
+                              type: event.type,
+                              message: `Replay diverged at aggregate ${aggregateID} sequence ${input.seq}`,
+                            }),
+                          )
+                        }
+                        if (input && row?.ownerID && row.ownerID !== input.ownerID) {
+                          return
+                        }
+                        const seq = input?.seq ?? latest + 1
+                        if (input && seq !== latest + 1) {
+                          yield* Effect.die(
+                            new InvalidDurableEventError({
+                              type: event.type,
+                              message: `Sequence mismatch for aggregate ${aggregateID}: expected ${latest + 1}, got ${seq}`,
+                            }),
+                          )
+                        }
+                        if (persist) {
+                          const stored = yield* db
+                            .select({ aggregateID: EventTable.aggregate_id, seq: EventTable.seq })
+                            .from(EventTable)
+                            .where(eq(EventTable.id, event.id))
+                            .get()
+                            .pipe(Effect.orDie)
+                          if (stored)
+                            yield* Effect.die(
+                              new InvalidDurableEventError({
+                                type: event.type,
+                                message: `Event ${event.id} already exists at aggregate ${stored.aggregateID} sequence ${stored.seq}`,
+                              }),
+                            )
+                        }
+                        const committed = {
+                          ...event,
+                          durable: { aggregateID, seq, version: durable.version },
+                        } as Event.Payload
+                        const route = yield* prepareRoutes([committed])
+                        for (const projector of list) {
+                          yield* projector(committed)
+                        }
+                        if (commit) yield* commit(seq)
+                        yield* db
+                          .insert(EventSequenceTable)
+                          .values([{ aggregate_id: aggregateID, seq, owner_id: input?.ownerID }])
+                          .onConflictDoUpdate({
+                            target: EventSequenceTable.aggregate_id,
+                            set: {
+                              seq: sql`max(${EventSequenceTable.seq}, ${seq})`,
+                              ...(input?.ownerID && row?.ownerID == null ? { owner_id: input.ownerID } : {}),
+                            },
+                          })
+                          .run()
+                          .pipe(Effect.orDie)
+                        if (persist)
+                          yield* db
+                            .insert(EventTable)
+                            .values([
+                              {
+                                id: event.id,
+                                aggregate_id: aggregateID,
+                                seq,
+                                created: event.created ?? 0,
+                                type: versionedType(definition.type, durable.version),
+                                data: encoded,
+                              },
+                            ])
+                            .run()
+                            .pipe(Effect.orDie)
+                        return { aggregateID, seq, event: committed, route }
+                      }),
+                    { behavior: "immediate" },
+                  )
+                  .pipe(Effect.orDie)
+                if (committed) {
+                  committed.route()
+                  yield* Effect.forEach(
+                    pubsub.durable.get(committed.aggregateID) ?? [],
+                    (wake) => PubSub.publish(wake, undefined),
+                    { discard: true },
+                  )
+                }
+                return committed
+              }),
+            )
           })
         }
 

packages/core/src/config/file.ts

@@ -1,150 +0,0 @@
-export * as ConfigFile from "./file.js"
-
-import { isDeepStrictEqual } from "node:util"
-import { isRecord } from "@opencode-ai/ai/utils/record"
-import { FSUtil } from "@opencode-ai/util/fs-util"
-import { Effect, Schema, Semaphore } from "effect"
-import {
-  applyEdits,
-  createScanner,
-  findNodeAtLocation,
-  modify,
-  parseTree,
-  type Node,
-  type ParseError,
-} from "jsonc-parser"
-
-export class UpdateError extends Schema.TaggedError<UpdateError>()("ConfigFile.UpdateError", {
-  message: Schema.String,
-  cause: Schema.optional(Schema.Defect()),
-}) {}
-
-const isJson = Schema.is(Schema.MutableJson)
-const isDocument = (value: unknown): value is Schema.MutableJsonObject => isRecord(value) && isJson(value)
-const lock = Semaphore.makeUnsafe(1)
-
-/**
- * Edits an existing JSON(C) file using raw source values, not resolved Config.Info.
- * The synchronous callback mutates a source clone; its return value is ignored.
- * Validates JSON only; normalization and substitution remain the reader's job.
- * Does not discover files, start watchers, or refresh Config state.
- * Read-modify-write calls are serialized within this process.
- */
-export const update = Effect.fn("ConfigFile.update")(
-  function* (
-    filepath: string,
-    mutate: (draft: Schema.MutableJsonObject) => void,
-  ): Effect.fn.Return<Schema.JsonObject, UpdateError, FSUtil.Service> {
-    const fs = yield* FSUtil.Service
-    const text = yield* fs
-      .readFileString(filepath)
-      .pipe(Effect.mapError((cause) => new UpdateError({ message: `Failed to read config: ${filepath}`, cause })))
-    const errors: ParseError[] = []
-    const current = parseSource(text, errors)
-    if (errors.length || !isDocument(current))
-      return yield* Effect.fail(new UpdateError({ message: `Invalid config file: ${filepath}` }))
-
-    const next = yield* Effect.try({
-      try: () => {
-        const draft = structuredClone(current)
-        mutate(draft)
-        return draft
-      },
-      catch: (cause) => new UpdateError({ message: "Config update failed", cause }),
-    })
-    if (!isDocument(next))
-      return yield* Effect.fail(new UpdateError({ message: `Config update must produce a JSON object: ${filepath}` }))
-
-    const edits = changes(current, next)
-    if (!edits.length) return next
-    const updated = yield* Effect.try({
-      try: () => edits.reduce(patch, text),
-      catch: (cause) => new UpdateError({ message: `Failed to patch config: ${filepath}`, cause }),
-    })
-    // Duplicate keys can make parse choose the last value while modify edits the first.
-    const written = parseSource(updated, errors)
-    if (errors.length || !isDeepStrictEqual(written, next))
-      return yield* Effect.fail(
-        new UpdateError({ message: `Config patch does not match the requested update: ${filepath}` }),
-      )
-    const temporary = filepath + ".tmp"
-    yield* fs.writeFileString(temporary, updated.endsWith("\n") ? updated : updated + "\n").pipe(
-      Effect.andThen(fs.rename(temporary, filepath)),
-      Effect.mapError((cause) => new UpdateError({ message: `Failed to write config: ${filepath}`, cause })),
-    )
-    return next
-  },
-  (effect) => lock.withPermit(effect),
-)
-
-type Edit = { readonly path: (string | number)[]; readonly value: unknown }
-
-function parseSource(text: string, errors: ParseError[]) {
-  const root = parseTree(text, errors, { allowTrailingComma: true })
-  if (!root || errors.length) return undefined
-  // parse() assigns onto {}, invoking the __proto__ setter instead of retaining
-  // an own JSON key. Construct object entries from the AST without those setters.
-  const value = (node: Node): unknown => {
-    if (node.type === "array") return (node.children ?? []).map(value)
-    if (node.type === "object")
-      return Object.fromEntries(
-        (node.children ?? []).map((property) => {
-          const child = property.children?.[1]
-          return [property.children?.[0]?.value, child && value(child)]
-        }),
-      )
-    return node.value
-  }
-  return value(root)
-}
-
-function patch(text: string, edit: Edit) {
-  if (edit.value !== undefined)
-    return applyEdits(
-      text,
-      modify(text, edit.path, edit.value, { formattingOptions: { tabSize: 2, insertSpaces: true } }),
-    )
-
-  const tree = parseTree(text)
-  const node = tree && findNodeAtLocation(tree, edit.path)
-  if (!node) return text
-  // jsonc-parser removes adjacent comments along with the separator. Remove only
-  // the property/element itself and one comma, leaving surrounding comments intact.
-  const target = node.parent?.type === "property" ? node.parent : node
-  const siblings = target.parent?.children ?? []
-  const previous = siblings[siblings.indexOf(target) - 1]
-  const scanner = createScanner(text, true)
-  scanner.setPosition(target.offset + target.length)
-  scanner.scan()
-  const following = text[scanner.getTokenOffset()] === ","
-  if (!following && previous) {
-    scanner.setPosition(previous.offset + previous.length)
-    scanner.scan()
-  }
-  return applyEdits(text, [
-    { offset: target.offset, length: target.length, content: "" },
-    ...(following || previous ? [{ offset: scanner.getTokenOffset(), length: 1, content: "" }] : []),
-  ])
-}
-
-function changes(before: unknown, after: unknown, path: (string | number)[] = []): Edit[] {
-  if (isDeepStrictEqual(before, after)) return []
-  if (Array.isArray(before) && Array.isArray(after)) {
-    return [
-      ...after.flatMap((value, index) => changes(before[index], value, [...path, index])),
-      // Remove from the end so earlier deletions cannot shift later paths.
-      ...before
-        .slice(after.length)
-        .map((_, index) => ({ path: [...path, after.length + index], value: undefined }))
-        .toReversed(),
-    ]
-  }
-  if (isRecord(before) && isRecord(after)) {
-    return [...new Set([...Object.keys(before), ...Object.keys(after)])].flatMap((key) => {
-      if (!Object.hasOwn(after, key)) return [{ path: [...path, key], value: undefined }]
-      if (!Object.hasOwn(before, key)) return [{ path: [...path, key], value: after[key] }]
-      return changes(before[key], after[key], [...path, key])
-    })
-  }
-  return [{ path, value: after }]
-}

packages/core/src/config/plugin/command.ts

@@ -87,7 +87,6 @@ export const Plugin = define({
                   ...input.prompt,
                   sessionID: input.sessionID,
                   text: yield* evaluateTemplate(command.template, input.prompt.text, {
-                    config,
                     location,
                     processes,
                     shell,
@@ -152,7 +151,6 @@ function evaluateTemplate(
   template: string,
   input: string,
   services: {
-    readonly config: Config.Interface
     readonly location: Location.Info
     readonly processes: AppProcess.Interface
     readonly shell: ShellSelect.Interface

packages/core/src/config/plugin/reference.ts

@@ -20,14 +20,13 @@ export const Plugin = define({
     const global = yield* Global.Service
     const loaded = yield* ConfigEntryObserver.observe(config, ctx.event, ctx.reference.reload())
     yield* ctx.reference.transform((draft) => {
-      const entries = new Map<string, Reference.Source>()
       for (const doc of loaded.entries.filter((entry): entry is Document => entry.type === "document")) {
         const directory = doc.path ? path.dirname(doc.path) : location.directory
         for (const [name, entry] of Object.entries(doc.info.references ?? {})) {
           if (!validAlias(name)) continue
           const description = typeof entry === "string" ? undefined : entry.description
           const hidden = typeof entry === "string" ? undefined : entry.hidden
-          entries.set(
+          draft.add(
             name,
             local(entry)
               ? Reference.LocalSource.make({
@@ -48,7 +47,6 @@ export const Plugin = define({
           )
         }
       }
-      for (const [name, source] of entries) draft.add(name, source)
     })
   }),
 })

packages/core/src/database/sqlite.workerd.ts

@@ -212,7 +212,7 @@ const nativeLayer = (config: Config) =>
     : Layer.effect(
         Sqlite.Native,
         Effect.die(
-          "workerd sqlite cannot open a database from a path; use Database.layerWith(sqliteLayer({ storage }))",
+          "workerd sqlite cannot open a database from a path; use Database.layerFromClient.pipe(Layer.provide(sqliteLayer({ storage })))",
         ),
       )
 

packages/core/src/database/v1-migration.bun.ts

@@ -275,22 +275,22 @@ export function transformSession(input: TransformInput): TransformResult {
       if (paired.has(item.row.id)) return []
       const owned = byMessage.get(item.row.id)?.map((part) => part.value) ?? []
       if (item.value.role === "user") {
-        const compaction = owned.find((part) => part.type === "compaction")
-        if (compaction?.type === "compaction") {
+        const compaction = owned.find((part): part is SessionV1.CompactionPart => part.type === "compaction")
+        if (compaction) {
           const pairedSummary = messages.find(
-            (candidate) =>
+            (candidate): candidate is (typeof messages)[number] & { value: SessionV1.Assistant } =>
               candidate.value.role === "assistant" &&
               candidate.value.parentID === item.row.id &&
-              candidate.value.summary,
+              candidate.value.summary === true,
           )
-          if (!pairedSummary || pairedSummary.value.role !== "assistant") return []
+          if (!pairedSummary) return []
           paired.add(pairedSummary.row.id)
           if (pairedSummary.value.error || pairedSummary.value.time.completed === undefined) return []
           const summary = pairedSummary
           const summaryText = (byMessage.get(summary.row.id) ?? [])
             .map((part) => part.value)
-            .filter((part) => part.type === "text" && part.text.length > 0)
-            .map((part) => (part.type === "text" ? part.text : ""))
+            .filter((part): part is SessionV1.TextPart => part.type === "text" && part.text.length > 0)
+            .map((part) => part.text)
             .join("\n\n")
           const tailIndex = compaction.tail_start_id
             ? messages.findIndex((candidate) => candidate.row.id === compaction.tail_start_id)
@@ -313,16 +313,14 @@ export function transformSession(input: TransformInput): TransformResult {
           ]
         }
         const subtasks = owned.filter((part) => part.type === "subtask")
-        const visible = owned.filter((part) => part.type === "text" && !part.ignored)
-        const files = owned.filter((part) => part.type === "file")
-        const agents = owned.filter((part) => part.type === "agent")
+        const visible = owned.filter((part): part is SessionV1.TextPart => part.type === "text" && !part.ignored)
+        const files = owned.filter((part): part is SessionV1.FilePart => part.type === "file")
+        const agents = owned.filter((part): part is SessionV1.AgentPart => part.type === "agent")
         if (subtasks.length > 0 && visible.length === 0 && files.length === 0 && agents.length === 0) return []
-        const ordinary = visible.filter((part) => part.type === "text" && !part.synthetic)
-        const synthetic = visible.filter((part) => part.type === "text" && part.synthetic)
-        const attachments = files.flatMap((part) => (part.type === "file" ? migrateFile(part) : []))
-        const unavailable = files.flatMap((part) =>
-          part.type === "file" && !part.url.startsWith("data:") ? [unavailableFile(part)] : [],
-        )
+        const ordinary = visible.filter((part) => !part.synthetic)
+        const synthetic = visible.filter((part) => part.synthetic)
+        const attachments = files.flatMap((part) => migrateFile(part))
+        const unavailable = files.flatMap((part) => (!part.url.startsWith("data:") ? [unavailableFile(part)] : []))
         const text = owned
           .flatMap((part) => {
             if (part.type === "text" && !part.ignored && !part.synthetic) return [part.text]
@@ -330,16 +328,12 @@ export function transformSession(input: TransformInput): TransformResult {
             return []
           })
           .join("\n\n")
-        const agentAttachments = agents.map((part) =>
-          part.type === "agent"
-            ? {
-                name: part.name,
-                ...(part.source
-                  ? { mention: { text: part.source.value, start: part.source.start, end: part.source.end } }
-                  : {}),
-              }
-            : { name: "" },
-        )
+        const agentAttachments = agents.map((part) => ({
+          name: part.name,
+          ...(part.source
+            ? { mention: { text: part.source.value, start: part.source.start, end: part.source.end } }
+            : {}),
+        }))
         if (
           ordinary.length === 0 &&
           unavailable.length === 0 &&
@@ -351,7 +345,7 @@ export function transformSession(input: TransformInput): TransformResult {
             row(item.row, {
               id: item.row.id,
               type: "synthetic",
-              text: synthetic.map((part) => (part.type === "text" ? part.text : "")).join("\n\n"),
+              text: synthetic.map((part) => part.text).join("\n\n"),
               time: { created: item.row.time_created },
             }),
           ]
@@ -369,7 +363,7 @@ export function transformSession(input: TransformInput): TransformResult {
           row(item.row, {
             id: syntheticID(item.row.id, used),
             type: "synthetic",
-            text: synthetic.map((part) => (part.type === "text" ? part.text : "")).join("\n\n"),
+            text: synthetic.map((part) => part.text).join("\n\n"),
             time: { created: item.row.time_created },
           }),
         ]
@@ -443,7 +437,6 @@ export function transformSession(input: TransformInput): TransformResult {
     })
     .map((item, seq) => ({ ...item, seq }))
   const assistants = messages
-    .filter((item) => item.value.role === "assistant")
     .map((item) => item.value)
     .filter((item): item is SessionV1.Assistant => item.role === "assistant")
   const latestUser = messages.findLast((item) => {
@@ -488,7 +481,7 @@ export function status(): Effect.Effect<Status, never, Database.Service> {
     if (runtimeState.status === "error") return runtimeState
     if (state?.phase === "completed") return { status: "completed" as const }
     return { status: "required" as const }
-  }).pipe(Effect.orDie)
+  })
 }
 
 export const layer = Layer.effectDiscard(
@@ -528,76 +521,75 @@ export function run(options: Options = {}): Effect.Effect<RunResult, never, Data
       const state = yield* readState(db)
       if (state?.phase === "completed") return { status: "completed" as const }
       if (!(yield* hasLegacySessions(db))) return { status: "completed" as const }
-      const migrate = Effect.gen(function* () {
-        const now = Date.now()
-        yield* db.run(sql`
+      const now = Date.now()
+      yield* db.run(sql`
           INSERT OR IGNORE INTO project (id, worktree, time_created, time_updated, sandboxes)
           VALUES (${Project.ID.global}, ${path.parse(global.data).root}, ${now}, ${now}, '[]')
         `)
-        if (state === undefined)
-          yield* db
-            .transaction((tx) =>
-              Effect.gen(function* () {
-                while (true) {
-                  yield* tx.run(sql`
+      if (state === undefined)
+        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
-                  .insert(KVTable)
-                  .values({ key: MIGRATION_STATE_KEY, value: { phase: "sessions" } })
-                  .run()
-              }),
-            )
-            .pipe(Effect.orDie)
-        const sourceTotal = yield* countNextSessions(nextPath(options, global.data))
-        const legacyTotal = (yield* db.get<{ value: number }>(sql`SELECT COUNT(*) AS value FROM session`))?.value ?? 0
-        const cursor = state?.phase === "sessions" ? state.cursor : undefined
-        const migrated =
-          cursor !== undefined
-            ? ((yield* db.get<{ value: number }>(sql`SELECT COUNT(*) AS value FROM session WHERE id >= ${cursor}`))
-                ?.value ?? 0)
-            : 0
-        const denominator = sourceTotal + legacyTotal
-        updateProgress({ label: "Migrating sessions", numerator: migrated, denominator })
-        yield* importNextDatabase(db, nextPath(options, global.data), (completed) => {
-          updateProgress({ label: "Migrating sessions", numerator: migrated + completed, denominator })
-        })
-        updateProgress({ label: "Migrating sessions", numerator: migrated + sourceTotal, denominator })
-        const projects = new Set(
-          (yield* db.all<{ id: string }>(sql`SELECT id FROM project`)).map((project) => project.id),
-        )
-        while (true) {
-          const state = yield* readState(db)
-          const cursorValue = state?.phase === "sessions" ? state.cursor : undefined
-          const nextID = yield* db.get<{ id: string; project_id: string }>(
-            cursorValue === undefined
-              ? sql`SELECT id, project_id FROM session ORDER BY id DESC LIMIT 1`
-              : sql`SELECT id, project_id FROM session WHERE id < ${cursorValue} ORDER BY id DESC LIMIT 1`,
+                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
+                .insert(KVTable)
+                .values({ key: MIGRATION_STATE_KEY, value: { phase: "sessions" } })
+                .run()
+            }),
           )
-          if (!nextID) break
-          yield* db
-            .transaction((tx) =>
-              Effect.gen(function* () {
-                yield* tx
-                  .insert(KVTable)
-                  .values({ key: MIGRATION_STATE_KEY, value: { phase: "sessions", cursor: nextID.id } })
-                  .onConflictDoUpdate({
-                    target: KVTable.key,
-                    set: { value: { phase: "sessions", cursor: nextID.id }, time_updated: Date.now() },
-                  })
-                  .run()
-                const projectID = projects.has(nextID.project_id) ? nextID.project_id : Project.ID.global
-                if (projectID !== nextID.project_id)
-                  yield* Effect.logWarning("Reassigned V1 session with missing project", {
-                    sessionID: nextID.id,
-                    projectID: nextID.project_id,
-                  })
-                yield* tx.run(sql`
+          .pipe(Effect.orDie)
+      const sourceTotal = yield* countNextSessions(nextPath(options, global.data))
+      const legacyTotal = (yield* db.get<{ value: number }>(sql`SELECT COUNT(*) AS value FROM session`))?.value ?? 0
+      const cursor = state?.phase === "sessions" ? state.cursor : undefined
+      const migrated =
+        cursor !== undefined
+          ? ((yield* db.get<{ value: number }>(sql`SELECT COUNT(*) AS value FROM session WHERE id >= ${cursor}`))
+              ?.value ?? 0)
+          : 0
+      const denominator = sourceTotal + legacyTotal
+      updateProgress({ label: "Migrating sessions", numerator: migrated, denominator })
+      yield* importNextDatabase(db, nextPath(options, global.data), (completed) => {
+        updateProgress({ label: "Migrating sessions", numerator: migrated + completed, denominator })
+      })
+      updateProgress({ label: "Migrating sessions", numerator: migrated + sourceTotal, denominator })
+      const projects = new Set(
+        (yield* db.all<{ id: string }>(sql`SELECT id FROM project`)).map((project) => project.id),
+      )
+      while (true) {
+        const state = yield* readState(db)
+        const cursorValue = state?.phase === "sessions" ? state.cursor : undefined
+        const nextID = yield* db.get<{ id: string; project_id: string }>(
+          cursorValue === undefined
+            ? sql`SELECT id, project_id FROM session ORDER BY id DESC LIMIT 1`
+            : sql`SELECT id, project_id FROM session WHERE id < ${cursorValue} ORDER BY id DESC LIMIT 1`,
+        )
+        if (!nextID) break
+        yield* db
+          .transaction((tx) =>
+            Effect.gen(function* () {
+              yield* tx
+                .insert(KVTable)
+                .values({ key: MIGRATION_STATE_KEY, value: { phase: "sessions", cursor: nextID.id } })
+                .onConflictDoUpdate({
+                  target: KVTable.key,
+                  set: { value: { phase: "sessions", cursor: nextID.id }, time_updated: Date.now() },
+                })
+                .run()
+              const projectID = projects.has(nextID.project_id) ? nextID.project_id : Project.ID.global
+              if (projectID !== nextID.project_id)
+                yield* Effect.logWarning("Reassigned V1 session with missing project", {
+                  sessionID: nextID.id,
+                  projectID: nextID.project_id,
+                })
+              yield* tx.run(sql`
                   INSERT OR IGNORE INTO session_v2 (
                     id, project_id, workspace_id, parent_id, slug, directory, path, title, version, share_url,
                     summary_additions, summary_deletions, summary_files, summary_diffs, metadata, cost,
@@ -612,81 +604,79 @@ export function run(options: Options = {}): Effect.Effect<RunResult, never, Data
                   FROM session
                   WHERE id = ${nextID.id}
                 `)
-                const next = yield* tx
-                  .select()
-                  .from(SessionTable)
-                  .where(eq(SessionTable.id, SessionSchema.ID.make(nextID.id)))
-                  .get()
-                if (!next) return yield* Effect.die(new Error(`Failed to copy V1 session ${nextID.id}`))
-                const sourceMessages = yield* tx.all<SourceMessage>(
-                  sql`SELECT id, session_id, time_created, time_updated, data FROM message WHERE session_id = ${next.id}`,
-                )
-                const sourceParts = yield* tx.all<SourcePart>(
-                  sql`SELECT id, message_id, session_id, time_created, time_updated, data FROM part WHERE session_id = ${next.id}`,
-                )
-                const transformed = transformSession({ session: next, messages: sourceMessages, parts: sourceParts })
-                yield* Effect.forEach(transformed.warnings, (warning) =>
-                  Effect.logWarning("Skipped V1 migration row", warning),
-                )
-                yield* tx.delete(SessionMessageTable).where(eq(SessionMessageTable.session_id, next.id)).run()
-                yield* Effect.forEach(transformed.messages, (message) =>
-                  tx
-                    .insert(SessionMessageTable)
-                    .values({
-                      id: SessionMessage.ID.make(message.id),
-                      session_id: SessionSchema.ID.make(message.session_id),
-                      type: message.type,
-                      seq: message.seq,
-                      time_created: message.time_created,
-                      time_updated: message.time_updated,
-                      data: sql`${JSON.stringify(message.data)}`,
-                    })
-                    .run(),
-                )
-                yield* tx
-                  .update(SessionTable)
-                  .set({ ...transformed.session, time_updated: next.time_updated })
-                  .where(eq(SessionTable.id, next.id))
-                  .run()
-                yield* tx
-                  .insert(EventSequenceTable)
-                  .values({ aggregate_id: next.id, seq: transformed.watermark })
-                  .onConflictDoUpdate({
-                    target: EventSequenceTable.aggregate_id,
-                    set: { seq: transformed.watermark, owner_id: null },
+              const next = yield* tx
+                .select()
+                .from(SessionTable)
+                .where(eq(SessionTable.id, SessionSchema.ID.make(nextID.id)))
+                .get()
+              if (!next) return yield* Effect.die(new Error(`Failed to copy V1 session ${nextID.id}`))
+              const sourceMessages = yield* tx.all<SourceMessage>(
+                sql`SELECT id, session_id, time_created, time_updated, data FROM message WHERE session_id = ${next.id}`,
+              )
+              const sourceParts = yield* tx.all<SourcePart>(
+                sql`SELECT id, message_id, session_id, time_created, time_updated, data FROM part WHERE session_id = ${next.id}`,
+              )
+              const transformed = transformSession({ session: next, messages: sourceMessages, parts: sourceParts })
+              yield* Effect.forEach(transformed.warnings, (warning) =>
+                Effect.logWarning("Skipped V1 migration row", warning),
+              )
+              yield* tx.delete(SessionMessageTable).where(eq(SessionMessageTable.session_id, next.id)).run()
+              yield* Effect.forEach(transformed.messages, (message) =>
+                tx
+                  .insert(SessionMessageTable)
+                  .values({
+                    id: SessionMessage.ID.make(message.id),
+                    session_id: SessionSchema.ID.make(message.session_id),
+                    type: message.type,
+                    seq: message.seq,
+                    time_created: message.time_created,
+                    time_updated: message.time_updated,
+                    data: sql`${JSON.stringify(message.data)}`,
                   })
-                  .run()
-              }),
-            )
-            .pipe(Effect.orDie)
-          if (runtimeState.status === "running")
-            runtimeState = {
-              status: "running",
-              progress: {
-                label: "Migrating sessions",
-                numerator: (runtimeState.progress.numerator ?? 0) + 1,
-                denominator,
-              },
-            }
-          yield* Effect.yieldNow
-        }
-        yield* db
-          .transaction((tx) =>
-            Effect.gen(function* () {
+                  .run(),
+              )
               yield* tx
-                .insert(KVTable)
-                .values({ key: MIGRATION_STATE_KEY, value: { phase: "completed" } })
+                .update(SessionTable)
+                .set({ ...transformed.session, time_updated: next.time_updated })
+                .where(eq(SessionTable.id, next.id))
+                .run()
+              yield* tx
+                .insert(EventSequenceTable)
+                .values({ aggregate_id: next.id, seq: transformed.watermark })
                 .onConflictDoUpdate({
-                  target: KVTable.key,
-                  set: { value: { phase: "completed" }, time_updated: Date.now() },
+                  target: EventSequenceTable.aggregate_id,
+                  set: { seq: transformed.watermark, owner_id: null },
                 })
                 .run()
             }),
           )
           .pipe(Effect.orDie)
-        return { status: "completed" as const }
-      })
-      return yield* migrate
+        if (runtimeState.status === "running")
+          runtimeState = {
+            status: "running",
+            progress: {
+              label: "Migrating sessions",
+              numerator: (runtimeState.progress.numerator ?? 0) + 1,
+              denominator,
+            },
+          }
+        yield* Effect.yieldNow
+      }
+      yield* db
+        .transaction((tx) =>
+          Effect.gen(function* () {
+            yield* tx
+              .insert(KVTable)
+              .values({ key: MIGRATION_STATE_KEY, value: { phase: "completed" } })
+              .onConflictDoUpdate({
+                target: KVTable.key,
+                set: { value: { phase: "completed" }, time_updated: Date.now() },
+              })
+              .run()
+          }),
+        )
+        .pipe(Effect.orDie)
+      return { status: "completed" as const }
     }).pipe(Effect.orDie),
   )
 }
@@ -715,7 +705,7 @@ function countNextSessions(sourcePath: string | undefined) {
       if (!isNextDatabase(source)) return 0
       return source.query<{ value: number }, []>("SELECT COUNT(*) AS value FROM session").get()?.value ?? 0
     }),
-  ).pipe(Effect.orElseSucceed(() => 0))
+  )
 }
 
 function importNextDatabase(

packages/core/src/environment/memory.ts

@@ -61,21 +61,23 @@ export const makeMemoryDriver = (): MemoryDriver => {
   }
   const failed = (value: string, cause: unknown) => new Failed({ path: value, cause })
   const overrides: FilesImpl = {
-    stat: (value) => {
-      const node = lookup(value)
-      return node ? Effect.succeed(info(node)) : Effect.fail(new NotFound({ path: value }))
-    },
-    read: (value, range) => {
-      const original = lookup(value)
-      if (!original) return Effect.fail(new NotFound({ path: value }))
-      if (original.type === "directory") return Effect.fail(new WrongKind({ path: value, actual: "directory" }))
-      const resolved = resolveKey(value, true)
-      const node = resolved === undefined ? undefined : nodes.get(resolved)
-      if (!node) return Effect.fail(new NotFound({ path: value }))
-      if (node.type !== "file") return Effect.fail(new WrongKind({ path: value, actual: node.type }))
-      const bytes = range === undefined ? node.bytes : node.bytes.subarray(range.offset, range.offset + range.length)
-      return Effect.succeed({ info: info(node), bytes: bytes.slice() })
-    },
+    stat: (value) =>
+      Effect.suspend(() => {
+        const node = lookup(value)
+        return node ? Effect.succeed(info(node)) : Effect.fail(new NotFound({ path: value }))
+      }),
+    read: (value, range) =>
+      Effect.gen(function* () {
+        const original = lookup(value)
+        if (!original) return yield* new NotFound({ path: value })
+        if (original.type === "directory") return yield* new WrongKind({ path: value, actual: "directory" })
+        const resolved = resolveKey(value, true)
+        const node = resolved === undefined ? undefined : nodes.get(resolved)
+        if (!node) return yield* new NotFound({ path: value })
+        if (node.type !== "file") return yield* new WrongKind({ path: value, actual: node.type })
+        const bytes = range === undefined ? node.bytes : node.bytes.subarray(range.offset, range.offset + range.length)
+        return { info: info(node), bytes: bytes.slice() }
+      }),
     write: (value, bytes) =>
       Effect.try({
         try: () => {
@@ -89,17 +91,17 @@ export const makeMemoryDriver = (): MemoryDriver => {
         },
         catch: (cause) => failed(value, cause),
       }),
-    list: (value) => {
-      const target = resolveKey(value, true) ?? key(value)
-      const node = nodes.get(target)
-      if (!node) return Effect.fail(new NotFound({ path: value }))
-      if (node.type !== "directory") return Effect.fail(new WrongKind({ path: value, actual: node.type }))
-      const entries = [...nodes.entries()]
-        .filter(([entry]) => entry !== target && path.posix.dirname(entry) === target)
-        .map(([entry, child]) => ({ name: path.posix.basename(entry), type: child.type satisfies FileType }))
-        .sort((a, b) => a.name.localeCompare(b.name))
-      return Effect.succeed(entries)
-    },
+    list: (value) =>
+      Effect.gen(function* () {
+        const target = resolveKey(value, true) ?? key(value)
+        const node = nodes.get(target)
+        if (!node) return yield* new NotFound({ path: value })
+        if (node.type !== "directory") return yield* new WrongKind({ path: value, actual: node.type })
+        return [...nodes.entries()]
+          .filter(([entry]) => entry !== target && path.posix.dirname(entry) === target)
+          .map(([entry, child]) => ({ name: path.posix.basename(entry), type: child.type satisfies FileType }))
+          .sort((a, b) => a.name.localeCompare(b.name))
+      }),
     remove: (value) =>
       Effect.sync(() => {
         const target = resolveKey(value, false) ?? key(value)
@@ -107,32 +109,33 @@ export const makeMemoryDriver = (): MemoryDriver => {
           if (entry === target || entry.startsWith(`${target}/`)) nodes.delete(entry)
         }
       }),
-    move: (from, to) => {
-      const source = resolveKey(from, false) ?? key(from)
-      const node = nodes.get(source)
-      if (!node) return Effect.fail(new NotFound({ path: from }))
-      return Effect.try({
-        try: () => {
-          const requested = resolveKey(to, false) ?? key(to)
-          const destination =
-            nodes.get(requested)?.type === "directory"
-              ? path.posix.join(requested, path.posix.basename(source))
-              : requested
-          if (node.type === "directory" && destination.startsWith(`${source}/`)) {
-            throw new Error(`Cannot move a directory into itself: ${from}`)
-          }
-          const existing = nodes.get(destination)
-          if (node.type === "directory" && existing && existing.type !== "directory") {
-            throw new Error(`Cannot overwrite a non-directory with a directory: ${to}`)
-          }
-          requireParent(destination)
-          const moved = [...nodes.entries()].filter(([entry]) => entry === source || entry.startsWith(`${source}/`))
-          for (const [entry] of moved) nodes.delete(entry)
-          for (const [entry, child] of moved) nodes.set(`${destination}${entry.slice(source.length)}`, child)
-        },
-        catch: (cause) => failed(from, cause),
-      })
-    },
+    move: (from, to) =>
+      Effect.gen(function* () {
+        const source = resolveKey(from, false) ?? key(from)
+        const node = nodes.get(source)
+        if (!node) return yield* new NotFound({ path: from })
+        yield* Effect.try({
+          try: () => {
+            const requested = resolveKey(to, false) ?? key(to)
+            const destination =
+              nodes.get(requested)?.type === "directory"
+                ? path.posix.join(requested, path.posix.basename(source))
+                : requested
+            if (node.type === "directory" && destination.startsWith(`${source}/`)) {
+              throw new Error(`Cannot move a directory into itself: ${from}`)
+            }
+            const existing = nodes.get(destination)
+            if (node.type === "directory" && existing && existing.type !== "directory") {
+              throw new Error(`Cannot overwrite a non-directory with a directory: ${to}`)
+            }
+            requireParent(destination)
+            const moved = [...nodes.entries()].filter(([entry]) => entry === source || entry.startsWith(`${source}/`))
+            for (const [entry] of moved) nodes.delete(entry)
+            for (const [entry, child] of moved) nodes.set(`${destination}${entry.slice(source.length)}`, child)
+          },
+          catch: (cause) => failed(from, cause),
+        })
+      }),
     mkdir: (value) => Effect.try({ try: () => mkdirSync(value), catch: (cause) => failed(value, cause) }),
   }
 

packages/core/src/file-mutation.ts

@@ -62,9 +62,8 @@ export const syncTextBom = Effect.fn("FileMutation.syncTextBom")(function* (
 const transactionLocks = KeyedMutex.makeUnsafe<string>()
 
 /**
- * Serialize file changes by absolute target. Conditional writes compare and
- * write under the same process-local lock so cooperating OpenCode mutations do
- * not overwrite changes made from the same stale content.
+ * Mutation locking is process-local and serializes cooperating OpenCode
+ * changes; external writes can still race.
  */
 const layer = Layer.effect(
   Service,
@@ -129,7 +128,6 @@ export const node = makeLocationNode({ service: Service, layer, deps: [Environme
 /**
  * Deferred until the corresponding integrations exist.
  */
-// TODO: Add formatter integration after formatter runtime exists.
 // TODO: Publish watcher/file-edit events after watcher integration exists.
 // TODO: Add snapshots / undo after snapshot design exists.
 // TODO: Notify LSP and collect diagnostics after LSP runtime exists.

packages/core/src/filesystem/search.ts

@@ -135,7 +135,7 @@ export const fffLayer = Layer.effect(
         find: () => Effect.succeed([]),
       })
     }
-    yield* Effect.addFinalizer(() => Effect.sync(() => result.value.destroy()).pipe(Effect.ignore))
+    yield* Effect.addFinalizer(() => Effect.sync(() => result.value.destroy()))
     return Service.of({
       find: (input) =>
         Effect.sync(() => {

packages/core/src/image/photon.ts

@@ -3,7 +3,7 @@ import { Effect } from "effect"
 import path from "node:path"
 import { fileURLToPath } from "node:url"
 import { FileSystem } from "../filesystem.js"
-import { DecodeError, ResizerUnavailableError, SizeError } from "../image.js"
+import { DecodeError, ResizerUnavailableError, SizeError, type Limits } from "../image.js"
 
 const JPEG_QUALITIES = [80, 85, 70, 55, 40]
 
@@ -33,12 +33,7 @@ export const make = Effect.gen(function* () {
   return Effect.fn("Image.Photon.normalize")(function* (
     resource: string,
     content: FileSystem.Content & { readonly encoding: "base64" },
-    limits: {
-      readonly autoResize: boolean
-      readonly maxWidth: number
-      readonly maxHeight: number
-      readonly maxBase64Bytes: number
-    },
+    limits: Readonly<Limits>,
   ) {
     const photon = yield* loadPhoton
     const decoded = yield* Effect.try({

packages/core/src/job.ts

@@ -213,7 +213,7 @@ export const make = Effect.gen(function* () {
         return [{ info: snapshot(next), done: job.done, scope: job.scope }, new Map(jobs).set(id, next)]
       }),
     )
-    if (result.info && result.done) yield* Deferred.succeed(result.done, result.info).pipe(Effect.ignore)
+    if (result.info && result.done) yield* Deferred.succeed(result.done, result.info)
     if (result.scope) {
       yield* Scope.close(result.scope, Exit.void).pipe(Effect.forkIn(state.scope, { startImmediately: true }))
     }
@@ -346,8 +346,7 @@ export const make = Effect.gen(function* () {
         return [{ info: snapshot(next), backgrounded: job.backgrounded }, new Map(jobs).set(id, next)]
       }),
     )
-    if (result.info && result.backgrounded)
-      yield* Deferred.succeed(result.backgrounded, result.info).pipe(Effect.ignore)
+    if (result.info && result.backgrounded) yield* Deferred.succeed(result.backgrounded, result.info)
     return result.info
   })
 
@@ -396,7 +395,7 @@ export const make = Effect.gen(function* () {
         return [{ info: snapshot(next), done: job.done, scope: job.scope }, new Map(jobs).set(id, next)]
       }),
     )
-    if (result.info && result.done) yield* Deferred.succeed(result.done, result.info).pipe(Effect.ignore)
+    if (result.info && result.done) yield* Deferred.succeed(result.done, result.info)
     if (result.scope) yield* Scope.close(result.scope, Exit.void)
     return result.info
   })

packages/core/src/mcp/client.ts

@@ -10,17 +10,14 @@ import {
   CallToolResultSchema,
   ElicitationCompleteNotificationSchema,
   ElicitRequestSchema,
-  GetPromptResultSchema,
   type Implementation,
   type ElicitRequestFormParams,
   type ElicitRequestParams,
   type ElicitRequestURLParams,
   type ElicitResult,
-  ListPromptsResultSchema,
   ListRootsRequestSchema,
   ListToolsResultSchema,
   PromptListChangedNotificationSchema,
-  PromptSchema,
   ResourceListChangedNotificationSchema,
   type LoggingMessageNotification,
   LoggingMessageNotificationSchema,
@@ -41,10 +38,6 @@ const toError = (error: unknown) => (error instanceof Error ? error : new Error(
 const TolerantListToolsResult = ListToolsResultSchema.extend({
   tools: ToolSchema.omit({ outputSchema: true }).array(),
 })
-const TolerantListPromptsResult = ListPromptsResultSchema.extend({
-  prompts: PromptSchema.array(),
-})
-
 export class NeedsAuthError extends Schema.TaggedError<NeedsAuthError>()("MCP.NeedsAuthError", {
   server: Schema.String,
 }) {
@@ -301,12 +294,8 @@ export const connect = Effect.fnUntraced(function* (
           const prompts = yield* Effect.tryPromise({
             try: () =>
               paginate(
-                async (cursor) => {
-                  const params = cursor === undefined ? undefined : { cursor }
-                  return client.request({ method: "prompts/list", params }, TolerantListPromptsResult, {
-                    timeout: catalogTimeout,
-                  })
-                },
+                (cursor) =>
+                  client.listPrompts(cursor === undefined ? undefined : { cursor }, { timeout: catalogTimeout }),
                 (result) => result.prompts,
               ),
             catch: toError,
@@ -396,11 +385,7 @@ export const connect = Effect.fnUntraced(function* (
       prompt: (input) =>
         Effect.tryPromise({
           try: (signal) =>
-            client.request(
-              { method: "prompts/get", params: { name: input.name, arguments: input.args ?? {} } },
-              GetPromptResultSchema,
-              { signal, timeout: executionTimeout },
-            ),
+            client.getPrompt({ name: input.name, arguments: input.args ?? {} }, { signal, timeout: executionTimeout }),
           catch: toError,
         }).pipe(
           Effect.map((result) => ({

packages/core/src/mcp/index.ts

@@ -473,11 +473,11 @@ export const layer = (options?: Options) =>
             Effect.gen(function* () {
               entry.status = { status: "failed", error: "Connection closed" }
               yield* stopServer(name, entry)
-              yield* bus.publish(McpEvent.StatusChanged, { server: name }).pipe(Effect.ignore)
+              yield* bus.publish(McpEvent.StatusChanged, { server: name })
             }),
           ),
         )
-        connection.onLog((message) => fork(serverLog(name, message).pipe(Effect.ignore)))
+        connection.onLog((message) => fork(serverLog(name, message)))
         connection.onToolsChanged(() =>
           live(
             refreshTools(name, entry, connection).pipe(
@@ -512,7 +512,7 @@ export const layer = (options?: Options) =>
           // Announce the handshake so connect() and credential reconnects don't show a stale
           // disabled/failed status for the duration of the connection attempt.
           entry.status = { status: "pending" }
-          yield* bus.publish(McpEvent.StatusChanged, { server: name }).pipe(Effect.ignore)
+          yield* bus.publish(McpEvent.StatusChanged, { server: name })
           const scope = yield* Scope.fork(root)
           entry.scope = scope
           const authProvider = yield* connectProvider(entry)
@@ -543,9 +543,9 @@ export const layer = (options?: Options) =>
             // Announce the new tool set so the tool registry registers it. A server that finishes connecting
             // after the initial registration sweep and emits no list-changed notification would otherwise
             // stay invisible to the model.
-            yield* bus.publish(McpEvent.ToolsChanged, { server: name }).pipe(Effect.ignore)
-            yield* bus.publish(McpEvent.ResourcesChanged, { server: name }).pipe(Effect.ignore)
-            yield* bus.publish(McpEvent.StatusChanged, { server: name }).pipe(Effect.ignore)
+            yield* bus.publish(McpEvent.ToolsChanged, { server: name })
+            yield* bus.publish(McpEvent.ResourcesChanged, { server: name })
+            yield* bus.publish(McpEvent.StatusChanged, { server: name })
             whenLive(name, entry, result.value.connection)(refreshPrompts(name, entry, result.value.connection))
             return
           }
@@ -557,7 +557,7 @@ export const layer = (options?: Options) =>
               ? { status: "needs_auth" }
               : { status: "failed", error: error instanceof Error ? error.message : String(error) }
           yield* Effect.logWarning("mcp connect failed", { server: name, status: entry.status })
-          yield* bus.publish(McpEvent.StatusChanged, { server: name }).pipe(Effect.ignore)
+          yield* bus.publish(McpEvent.StatusChanged, { server: name })
         }).pipe(Effect.ensuring(entry.startup.open))
 
       const stopServer = Effect.fnUntraced(function* (name: ServerName, entry: ServerEntry) {
@@ -568,9 +568,9 @@ export const layer = (options?: Options) =>
         entry.tools = undefined
         entry.prompts = undefined
         yield* Scope.close(scope, Exit.void)
-        yield* bus.publish(McpEvent.ToolsChanged, { server: name }).pipe(Effect.ignore)
-        yield* bus.publish(McpEvent.ResourcesChanged, { server: name }).pipe(Effect.ignore)
-        yield* bus.publish(PromptsChanged, { server: name }).pipe(Effect.ignore)
+        yield* bus.publish(McpEvent.ToolsChanged, { server: name })
+        yield* bus.publish(McpEvent.ResourcesChanged, { server: name })
+        yield* bus.publish(PromptsChanged, { server: name })
       })
 
       const disposeServer = Effect.fnUntraced(function* (name: ServerName, entry: ServerEntry) {
@@ -592,7 +592,7 @@ export const layer = (options?: Options) =>
           yield* register(name, entry)
           if (serverConfig.disabled) {
             entry.status = { status: "disabled" }
-            yield* bus.publish(McpEvent.StatusChanged, { server: name }).pipe(Effect.ignore)
+            yield* bus.publish(McpEvent.StatusChanged, { server: name })
             return
           }
           yield* startServer(name, entry)
@@ -608,7 +608,7 @@ export const layer = (options?: Options) =>
         yield* disposeServer(name, entry)
         // Credentials are keyed by name + URL and intentionally survive removal for a later re-add.
         entries.delete(name)
-        yield* bus.publish(McpEvent.StatusChanged, { server: name }).pipe(Effect.ignore)
+        yield* bus.publish(McpEvent.StatusChanged, { server: name })
       })
 
       let applied: Map<ServerName, Mcp.ServerConfig> | undefined
@@ -631,7 +631,7 @@ export const layer = (options?: Options) =>
             if (entry.config.disabled) {
               entry.status = { status: "disabled" }
               entry.startup.openUnsafe()
-              yield* bus.publish(McpEvent.StatusChanged, { server: name }).pipe(Effect.ignore)
+              yield* bus.publish(McpEvent.StatusChanged, { server: name })
               continue
             }
             fork(startServer(name, entry).pipe(locks.withLock(name)))
@@ -673,7 +673,6 @@ export const layer = (options?: Options) =>
         bus.subscribe(Credential.Event.Switched).pipe(
           Stream.filter((event) => owned.has(event.data.integrationID)),
           Stream.runForEach((event) => Effect.sync(() => fork(reconnect(event.data.integrationID)))),
-          Effect.ignore,
         ),
       )
       const state = State.create<Data, Draft>({
@@ -738,7 +737,7 @@ export const layer = (options?: Options) =>
             const target = yield* requireServer(name)
             yield* stopServer(name, target.entry)
             target.entry.status = { status: "disabled" }
-            yield* bus.publish(McpEvent.StatusChanged, { server: name }).pipe(Effect.ignore)
+            yield* bus.publish(McpEvent.StatusChanged, { server: name })
           }).pipe(locks.withLock(name))
         }),
         remove: Effect.fn("MCP.remove")(function* (server) {

packages/core/src/mcp/oauth.ts

@@ -213,20 +213,11 @@ export const authorize = (input: {
       return toCredential({ methodID: input.methodID, serverUrl: input.config.url, tokens, client })
     })
 
-    const result = yield* Effect.tryPromise({
+    yield* Effect.tryPromise({
       try: () => auth(oauthProvider, { serverUrl: input.config.url, scope: oauth?.scope }),
       catch: (error) => (error instanceof Error ? error : new Error(String(error))),
     })
 
-    // The provider may already hold valid tokens (e.g. a re-auth), in which case there is no browser step.
-    if (result === "AUTHORIZED") {
-      return {
-        url: input.config.url,
-        instructions: `Connected to ${input.name}.`,
-        mode: "auto" as const,
-        callback: finalize,
-      }
-    }
     if (!authorizationUrl)
       return yield* Effect.fail(new Error(`MCP server "${input.name}" did not provide an authorization URL`))
 

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

@@ -4,7 +4,7 @@ import os from "node:os"
 import path from "node:path"
 import { Context, Effect, Layer, Schema } from "effect"
 import { makeGlobalNode } from "@opencode-ai/util/effect/app-node"
-import { Added, Handoff, ReadLines, Removed, type ReadResult } from "@opencode-ai/schema/persistent-pty"
+import { Added, Handoff, PersistentPty, ReadLines, Removed, type ReadResult } from "@opencode-ai/schema/persistent-pty"
 import { Session } from "@opencode-ai/schema/session"
 import { Bus } from "../bus.js"
 import { Pty } from "@opencode-ai/schema/pty"
@@ -26,19 +26,9 @@ export { Handoff } from "@opencode-ai/schema/persistent-pty"
 export const Options = Schema.Struct({ handoff: Schema.optional(Handoff) })
 export type Options = typeof Options.Type
 
-export type Info = Pty.Info & {
-  readonly sessionID: Session.ID
-  readonly foregroundProcess: string | null
-  readonly size: { readonly cols: number; readonly rows: number }
-  readonly output: { readonly head: number; readonly tail: number }
-}
+export type Info = PersistentPty.Info
 
-export type Snapshot = {
-  readonly info: Info
-  readonly text: string
-  readonly checkpoint: Uint8Array
-  readonly cursor: { readonly x: number; readonly y: number }
-}
+export type Snapshot = PersistentPty.Snapshot
 
 export type Attachment = {
   readonly info: Info
@@ -161,15 +151,7 @@ export const configured = (options: Options = {}) =>
 
       const create = Effect.fn("PersistentPty.create")(function* (
         sessionID: Session.ID,
-        input: {
-          readonly command?: string
-          readonly args: readonly string[]
-          readonly cwd?: string
-          readonly title: string
-          readonly env: Readonly<Record<string, string>>
-          readonly cols?: number
-          readonly rows?: number
-        },
+        input: Parameters<Interface["create"]>[1],
       ) {
         const response = yield* request(
           daemon,
@@ -338,14 +320,7 @@ export const configured = (options: Options = {}) =>
 
       const attach = Effect.fn("PersistentPty.attach")(function* (
         id: Pty.ID,
-        input: {
-          readonly cursor: number
-          readonly attachmentID: string
-          readonly role: Role
-          readonly takeover?: boolean
-          readonly onEvent: (event: StreamEvent) => void
-          readonly onEnd: () => void
-        },
+        input: Parameters<Interface["attach"]>[1],
       ) {
         yield* get(id)
         const attachment = yield* daemon

packages/core/src/plugin.ts

@@ -111,7 +111,7 @@ const layer = Layer.effect(
               for (const definition of definitions) {
                 const previous = active.get(definition.id)
                 active.delete(definition.id)
-                if (previous) yield* Scope.close(previous.scope, Exit.void).pipe(Effect.ignore)
+                if (previous) yield* Scope.close(previous.scope, Exit.void)
 
                 const loaded = yield* load(definition)
                 if (loaded.scope !== undefined) {
@@ -142,7 +142,7 @@ const layer = Layer.effect(
                 .filter(([id]) => !ids.has(id))
                 .toReversed()
               removed.forEach(([id]) => active.delete(id))
-              yield* Effect.forEach(removed, ([, entry]) => Scope.close(entry.scope, Exit.void).pipe(Effect.ignore), {
+              yield* Effect.forEach(removed, ([, entry]) => Scope.close(entry.scope, Exit.void), {
                 discard: true,
               })
               inventory = [...nextInventory, ...failures]

packages/core/src/plugin/host.ts

@@ -98,7 +98,7 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: Interface, p
       list: (input) => {
         const ref = locationRef(input)
         if (ref && !isCurrentLocation(ref)) return runtime.location.agent.list(ref)
-        return agents.list().pipe(Effect.map((data) => ({ location: locationInfo(), data })))
+        return response(agents.list())
       },
       reload: agents.reload,
       transform: (callback) =>

packages/core/src/plugin/provider.ts

@@ -14,6 +14,7 @@ import { GoogleVertexPlugin } from "./provider/google-vertex.js"
 import { KiloPlugin } from "./provider/kilo.js"
 import { LLMGatewayPlugin } from "./provider/llmgateway.js"
 import { LMStudioPlugin } from "./provider/lmstudio.js"
+import { MergeGatewayPlugin } from "./provider/merge-gateway.js"
 import { MistralPlugin } from "./provider/mistral.js"
 import { NvidiaPlugin } from "./provider/nvidia.js"
 import { OllamaPlugin } from "./provider/ollama.js"
@@ -47,6 +48,7 @@ export const ProviderPlugins: PluginInternal.InternalPlugin[] = [
   KiloPlugin,
   LLMGatewayPlugin,
   LMStudioPlugin,
+  MergeGatewayPlugin,
   MistralPlugin,
   NvidiaPlugin,
   OllamaPlugin,

packages/core/src/plugin/provider/amazon-bedrock.ts

@@ -4,7 +4,6 @@ import { define } from "@opencode-ai/plugin/effect/plugin"
 import { Provider } from "../../provider.js"
 
 type MantleSDK = {
-  languageModel: (modelID: string) => LanguageModelV3
   chat: (modelID: string) => LanguageModelV3
   responses: (modelID: string) => LanguageModelV3
 }

packages/core/src/plugin/provider/cloudflare-ai-gateway.ts

@@ -58,10 +58,8 @@ export const CloudflareAIGatewayPlugin = define({
         const config = gatewayConfig(evt.options)
         if (!config) return
         const metadata = gatewayMetadata(evt.options)
-        const { createAiGateway } = yield* Effect.promise(() => import("ai-gateway-provider")).pipe(Effect.orDie)
-        const { createUnified } = yield* Effect.promise(() => import("ai-gateway-provider/providers/unified")).pipe(
-          Effect.orDie,
-        )
+        const { createAiGateway } = yield* Effect.promise(() => import("ai-gateway-provider"))
+        const { createUnified } = yield* Effect.promise(() => import("ai-gateway-provider/providers/unified"))
         const gateway = createAiGateway({
           accountId: config.accountId,
           gateway: config.gatewayId,

packages/core/src/plugin/provider/dynamic.ts

@@ -1,8 +1,7 @@
 import { Effect } from "effect"
-import { pathToFileURL } from "url"
 import { define } from "@opencode-ai/plugin/effect/plugin"
 import { Npm } from "@opencode-ai/util/npm"
-import { importModule } from "@opencode-ai/util/runtime-import"
+import { loadSDKFactory } from "./sdk-factory.js"
 
 export const DynamicProviderPlugin = define({
   id: "opencode.provider.dynamic",
@@ -13,18 +12,7 @@ export const DynamicProviderPlugin = define({
       Effect.fn(function* (evt) {
         if (evt.sdk) return
 
-        const installedPath = evt.package.startsWith("file://")
-          ? evt.package
-          : (yield* npm.add(evt.package).pipe(Effect.orDie)).entrypoint
-        if (!installedPath) throw new Error(`Package ${evt.package} has no import entrypoint`)
-
-        const mod = (yield* Effect.promise(() =>
-          importModule(installedPath.startsWith("file://") ? installedPath : pathToFileURL(installedPath).href),
-        ).pipe(Effect.orDie)) as Record<string, (options: any) => any>
-        const match = Object.keys(mod).find((name) => name.startsWith("create"))
-        if (!match) throw new Error(`Package ${evt.package} has no provider factory export`)
-
-        evt.sdk = mod[match](evt.options)
+        evt.sdk = ((yield* loadSDKFactory(npm, evt.package)) as (options: any) => any)(evt.options)
       }),
     )
   }),

packages/core/src/plugin/provider/gitlab.ts

@@ -40,7 +40,7 @@ export const GitLabPlugin = define({
           typeof evt.options.featureFlags === "object" && evt.options.featureFlags ? evt.options.featureFlags : {}
         const id = evt.model.modelID ?? evt.model.id
         if (id.startsWith("duo-workflow-")) {
-          const gitlab = yield* Effect.promise(() => import("gitlab-ai-provider")).pipe(Effect.orDie)
+          const gitlab = yield* Effect.promise(() => import("gitlab-ai-provider"))
           const workflowRef =
             typeof evt.model.settings?.workflowRef === "string" ? evt.model.settings.workflowRef : undefined
           const workflowDefinition =

packages/core/src/plugin/provider/merge-gateway.ts

@@ -0,0 +1,26 @@
+import { Effect } from "effect"
+import { define } from "@opencode-ai/plugin/effect/plugin"
+import { Provider } from "../../provider.js"
+
+export const MergeGatewayPlugin = define({
+  id: "opencode.provider.merge-gateway",
+  effect: Effect.fn(function* (ctx) {
+    yield* ctx.catalog.transform((evt) => {
+      for (const item of evt.provider.list()) {
+        for (const model of item.models.values()) {
+          if (Provider.packageName(model.package ?? item.provider.package) !== "merge-gateway-ai-sdk-provider") continue
+          evt.model.update(model.providerID, model.id, (model) => {
+            // Merge uses `thinking` instead of the usual OpenAI-compatible reasoning fields.
+            // models.dev tracks upstream models, not these gateway-specific compatibility defaults.
+            model.compatibility = {
+              ...model.compatibility,
+              reasoningField: "thinking",
+              maxTokensField: "max_tokens",
+              requireReasoning: false,
+            }
+          })
+        }
+      }
+    })
+  }),
+})

packages/core/src/plugin/provider/sap-ai-core.ts

@@ -1,9 +1,8 @@
 import { Effect } from "effect"
-import { pathToFileURL } from "url"
 import { define } from "@opencode-ai/plugin/effect/plugin"
 import { Npm } from "@opencode-ai/util/npm"
 import { Provider } from "../../provider.js"
-import { importModule } from "@opencode-ai/util/runtime-import"
+import { loadSDKFactory } from "./sdk-factory.js"
 
 export const SapAICorePlugin = define({
   id: "opencode.provider.sap.ai.core",
@@ -18,17 +17,7 @@ export const SapAICorePlugin = define({
           (typeof evt.options.serviceKey === "string" ? evt.options.serviceKey : undefined)
         if (serviceKey && !process.env.AICORE_SERVICE_KEY) process.env.AICORE_SERVICE_KEY = serviceKey
 
-        const installedPath = evt.package.startsWith("file://")
-          ? evt.package
-          : (yield* npm.add(evt.package).pipe(Effect.orDie)).entrypoint
-        if (!installedPath) return yield* Effect.die(new Error(`Package ${evt.package} has no import entrypoint`))
-
-        const mod = (yield* Effect.promise(() =>
-          importModule(installedPath.startsWith("file://") ? installedPath : pathToFileURL(installedPath).href),
-        )) as Record<string, unknown>
-        const match = Object.keys(mod).find((name) => name.startsWith("create"))
-        if (!match) return yield* Effect.die(new Error(`Package ${evt.package} has no provider factory export`))
-        const factory = mod[match]
+        const factory = yield* loadSDKFactory(npm, evt.package)
         if (typeof factory !== "function")
           return yield* Effect.die(new Error(`Package ${evt.package} provider factory export is not callable`))
 

packages/core/src/plugin/provider/sdk-factory.ts

@@ -0,0 +1,18 @@
+import { Effect } from "effect"
+import { pathToFileURL } from "url"
+import { Npm } from "@opencode-ai/util/npm"
+import { importModule } from "@opencode-ai/util/runtime-import"
+
+export const loadSDKFactory = Effect.fnUntraced(function* (npm: Npm.Interface, packageName: string) {
+  const installedPath = packageName.startsWith("file://")
+    ? packageName
+    : (yield* npm.add(packageName).pipe(Effect.orDie)).entrypoint
+  if (!installedPath) return yield* Effect.die(new Error(`Package ${packageName} has no import entrypoint`))
+
+  const mod = (yield* Effect.promise(() =>
+    importModule(installedPath.startsWith("file://") ? installedPath : pathToFileURL(installedPath).href),
+  )) as Record<string, unknown>
+  const match = Object.keys(mod).find((name) => name.startsWith("create"))
+  if (!match) return yield* Effect.die(new Error(`Package ${packageName} has no provider factory export`))
+  return mod[match]
+})

packages/core/src/plugin/skill.ts

@@ -50,7 +50,7 @@ export const Plugin = define({
 const reportContentWithDiagnostics = Effect.fn("SkillPlugin.reportContentWithDiagnostics")(function* (
   app: Context["app"],
 ) {
-  const plugins = yield* configuredPlugins().pipe(Effect.orElseSucceed(() => ["Unavailable: failed to inspect config"]))
+  const plugins = yield* configuredPlugins()
   return [
     ReportContent,
     "",

packages/core/src/project.ts

@@ -137,11 +137,10 @@ const layer = Layer.effect(
           strategy: project.vcs.type === "git" ? "git" : undefined,
         })
       // A missing directory row means this directory's resolution is a new durable
-      // fact (copy.ts registers copy directories directly; those never strand
-      // sessions and never announce). The row insert commits atomically with the
-      // event, so a crash between checks retries on the next resolve instead of
-      // stranding the announcement. The in-flight set keeps concurrent resolves
-      // from publishing the same fact twice.
+      // fact. The row insert commits atomically with the event, so a crash between
+      // checks retries on the next resolve instead of stranding the announcement.
+      // The in-flight set keeps concurrent resolves from publishing the same fact
+      // twice.
       for (const item of directories) {
         const key = item.projectID + "\u0000" + item.directory
         if (announcing.has(key)) continue

packages/core/src/session.ts

@@ -5,8 +5,8 @@ import { Cause, Effect, Layer, Schema, Context, RcMap, Stream, Scope } from "eff
 import { ListAnchor } from "@opencode-ai/schema/session"
 import { and, asc, desc, eq, gt, isNull, like, lt, or, type SQL } from "drizzle-orm"
 import { Project } from "./project.js"
-import { Workspace } from "./workspace.js"
-import { Model } from "./model.js"
+import { Workspace } from "@opencode-ai/schema/workspace"
+import { Model } from "@opencode-ai/schema/model"
 import { Location } from "./location.js"
 import { SessionMessage } from "./session/message.js"
 import { Base64, FileAttachment, Prompt } from "@opencode-ai/schema/prompt"
@@ -17,7 +17,7 @@ import { SessionProjector } from "./session/projector.js"
 import { SessionMessageTable, SessionTable } from "./session/sql.js"
 import { SessionSchema } from "./session/schema.js"
 import { AbsolutePath, PositiveInt, RelativePath } from "./schema.js"
-import { Agent } from "./agent.js"
+import { Agent } from "@opencode-ai/schema/agent"
 import { Money } from "@opencode-ai/schema/money"
 import { App } from "./app.js"
 import { Slug } from "./util/slug.js"

packages/core/src/session/compaction.ts

@@ -393,26 +393,27 @@ export const layer = Layer.effect(
           error: { type: "compaction.unavailable", message: "Nothing to compact yet" },
           inputID: input.inputID,
         })
-      const resolved = yield* input.resolveModel(input.session).pipe(
-        Effect.catch((cause) =>
-          failed({
-            sessionID: input.session.id,
-            reason: "manual",
-            error: toSessionError(cause),
-            inputID: input.inputID,
-          }),
-        ),
+      return yield* input.resolveModel(input.session).pipe(
+        Effect.matchEffect({
+          onFailure: (cause) =>
+            failed({
+              sessionID: input.session.id,
+              reason: "manual",
+              error: toSessionError(cause),
+              inputID: input.inputID,
+            }),
+          onSuccess: (resolved) =>
+            execute({
+              session: input.session,
+              resolved,
+              prepare: input.prepare,
+              reason: "manual",
+              inputID: input.inputID,
+              started: input.started,
+              ...content,
+            }),
+        }),
       )
-      if ("status" in resolved) return resolved
-      return yield* execute({
-        session: input.session,
-        resolved,
-        prepare: input.prepare,
-        reason: "manual",
-        inputID: input.inputID,
-        started: input.started,
-        ...content,
-      })
     })
     return Service.of({
       transform: state.transform,

packages/core/src/session/execution/restart.ts

@@ -204,7 +204,6 @@ export const layer = (options?: Options) =>
         yield* jobs.background(background.id)
         yield* jobs.wait({ id: background.id }).pipe(
           Effect.flatMap((result) => (result.info ? notify(result.info) : Effect.void)),
-          Effect.ignore,
           Effect.forkIn(scope),
         )
       })

packages/core/src/session/info.ts

@@ -1,13 +1,13 @@
 import { DateTime, Schema } from "effect"
-import { Agent } from "../agent.js"
-import { Location } from "../location.js"
-import { Model } from "../model.js"
-import { Project } from "../project.js"
-import { Provider } from "../provider.js"
+import { Agent } from "@opencode-ai/schema/agent"
+import { Location } from "@opencode-ai/schema/location"
+import { Model } from "@opencode-ai/schema/model"
+import { Project } from "@opencode-ai/schema/project"
+import { Provider } from "@opencode-ai/schema/provider"
 import { AbsolutePath, RelativePath } from "../schema.js"
-import { Workspace } from "../workspace.js"
+import { Workspace } from "@opencode-ai/schema/workspace"
 import { SessionSchema } from "./schema.js"
-import { SessionTable } from "./sql.js"
+import type { SessionTable } from "./sql.js"
 import { PersistedRevert } from "@opencode-ai/schema/session-revert"
 import { Money } from "@opencode-ai/schema/money"
 

packages/core/src/session/instruction-entry.ts

@@ -131,11 +131,7 @@ const layer = Layer.effect(
       return (yield* rows(sessionID, false)).map((row) => ({ key: row.key, value: row.value }))
     })
 
-    const put = Effect.fn("InstructionEntry.put")(function* (input: {
-      readonly sessionID: SessionSchema.ID
-      readonly key: Key
-      readonly value: Schema.Json
-    }) {
+    const put = Effect.fn("InstructionEntry.put")(function* (input: Parameters<Interface["put"]>[0]) {
       const actualBytes = Buffer.byteLength(JSON.stringify(input.value), "utf8")
       if (actualBytes > MaxValueBytes)
         yield* new ValueTooLargeError({
@@ -159,10 +155,7 @@ const layer = Layer.effect(
         .pipe(Effect.orDie)
     })
 
-    const remove = Effect.fn("InstructionEntry.remove")(function* (input: {
-      readonly sessionID: SessionSchema.ID
-      readonly key: Key
-    }) {
+    const remove = Effect.fn("InstructionEntry.remove")(function* (input: Parameters<Interface["remove"]>[0]) {
       yield* db
         .update(InstructionEntryTable)
         .set({ value: null, removed: true, time_updated: Date.now() })

packages/core/src/session/instruction-state.ts

@@ -42,8 +42,8 @@ export const commit = Effect.fn("InstructionState.commit")(function* (
   observation: Observation,
 ) {
   if (!observation.initial && Object.keys(observation.delta).length === 0) return
-  // The rendered text is frozen into the durable event: replaying it later would
-  // require the Location-scoped registry that produced it.
+  // The rendered text is frozen into the durable event because re-rendering it
+  // later would require the original Location-scoped instruction sources.
   const text = observation.initial ? "" : yield* renderUpdateText(db, instructions, observation)
   yield* bus.publish(
     SessionEvent.InstructionsUpdated,

packages/core/src/session/instructions.ts

@@ -43,10 +43,7 @@ const layer = Layer.effect(
     // are re-discovered and re-injected instead of staying silently lost.
     const inFlight = yield* Ref.make<Map<SessionSchema.ID, Set<string>>>(new Map())
 
-    const load = Effect.fn("SessionInstructions.load")(function* (input: {
-      readonly sessionID: SessionSchema.ID
-      readonly paths: ReadonlyArray<string>
-    }) {
+    const load = Effect.fn("SessionInstructions.load")(function* (input: Parameters<Interface["load"]>[0]) {
       const claimed = yield* Ref.modify(inFlight, (map) => {
         const existing = map.get(input.sessionID) ?? new Set<string>()
         const newlyClaimed = input.paths.filter((path) => !existing.has(path))

packages/core/src/session/message-updater.ts

@@ -4,21 +4,17 @@ import { SessionEvent } from "./event.js"
 import { SessionMessage } from "./message.js"
 
 export interface Adapter {
-  readonly getAgent: () => Effect.Effect<SessionMessage.AgentSelected["agent"] | undefined, never, never>
-  readonly getModel: () => Effect.Effect<SessionMessage.ModelSelected["model"] | undefined, never, never>
-  readonly getLocation: () => Effect.Effect<SessionMessage.LocationSwitched["previous"], never, never>
-  readonly getCurrentAssistant: () => Effect.Effect<SessionMessage.Assistant | undefined, never, never>
-  readonly getAssistant: (
-    messageID: SessionMessage.ID,
-  ) => Effect.Effect<SessionMessage.Assistant | undefined, never, never>
-  readonly getShell: (
-    shellID: SessionMessage.Shell["shellID"],
-  ) => Effect.Effect<SessionMessage.Shell | undefined, never, never>
-  readonly getCompaction: () => Effect.Effect<SessionMessage.Compaction | undefined, never, never>
-  readonly updateAssistant: (assistant: SessionMessage.Assistant) => Effect.Effect<void, never, never>
-  readonly updateShell: (shell: SessionMessage.Shell) => Effect.Effect<void, never, never>
-  readonly updateCompaction: (compaction: SessionMessage.Compaction) => Effect.Effect<void, never, never>
-  readonly appendMessage: (message: SessionMessage.Info) => Effect.Effect<void, never, never>
+  readonly getAgent: () => Effect.Effect<SessionMessage.AgentSelected["agent"] | undefined>
+  readonly getModel: () => Effect.Effect<SessionMessage.ModelSelected["model"] | undefined>
+  readonly getLocation: () => Effect.Effect<SessionMessage.LocationSwitched["previous"]>
+  readonly getCurrentAssistant: () => Effect.Effect<SessionMessage.Assistant | undefined>
+  readonly getAssistant: (messageID: SessionMessage.ID) => Effect.Effect<SessionMessage.Assistant | undefined>
+  readonly getShell: (shellID: SessionMessage.Shell["shellID"]) => Effect.Effect<SessionMessage.Shell | undefined>
+  readonly getCompaction: () => Effect.Effect<SessionMessage.Compaction | undefined>
+  readonly updateAssistant: (assistant: SessionMessage.Assistant) => Effect.Effect<void>
+  readonly updateShell: (shell: SessionMessage.Shell) => Effect.Effect<void>
+  readonly updateCompaction: (compaction: SessionMessage.Compaction) => Effect.Effect<void>
+  readonly appendMessage: (message: SessionMessage.Info) => Effect.Effect<void>
 }
 
 type DraftAssistant = WritableDraft<SessionMessage.Assistant>
@@ -38,16 +34,14 @@ export function update(adapter: Adapter, event: SessionEvent.DurableEvent) {
   type DraftReasoning = WritableDraft<SessionMessage.AssistantReasoning>
   const created = DateTime.makeUnsafe(event.created)
 
-  const latestTool = (assistant: DraftAssistant | undefined, id?: string) =>
-    assistant?.content.findLast(
-      (item): item is DraftTool => item.type === "tool" && (id === undefined || item.id === id),
-    )
+  const latestTool = (assistant: DraftAssistant, id: string) =>
+    assistant.content.findLast((item): item is DraftTool => item.type === "tool" && item.id === id)
 
-  const latestText = (assistant: DraftAssistant | undefined) =>
-    assistant?.content.findLast((item): item is DraftText => item.type === "text")
+  const latestText = (assistant: DraftAssistant) =>
+    assistant.content.findLast((item): item is DraftText => item.type === "text")
 
-  const latestReasoning = (assistant: DraftAssistant | undefined) =>
-    assistant?.content.findLast((item): item is DraftReasoning => item.type === "reasoning" && !item.time?.completed)
+  const latestReasoning = (assistant: DraftAssistant) =>
+    assistant.content.findLast((item): item is DraftReasoning => item.type === "reasoning" && !item.time?.completed)
 
   const updateOwnedAssistant = (messageID: SessionMessage.ID, recipe: (draft: DraftAssistant) => void) =>
     Effect.gen(function* () {

packages/core/src/session/projector.ts

@@ -6,13 +6,13 @@ import path from "path"
 import { Database } from "../database/database.js"
 import { Bus } from "../bus.js"
 import { makeGlobalNode } from "@opencode-ai/util/effect/app-node"
-import { Agent } from "../agent.js"
-import { Model } from "../model.js"
+import { Agent } from "@opencode-ai/schema/agent"
+import { Model } from "@opencode-ai/schema/model"
 import { SessionEvent } from "./event.js"
 import { SessionMessage } from "./message.js"
 import { SessionMessageUpdater } from "./message-updater.js"
 import { SessionInbox } from "./inbox.js"
-import { Workspace } from "../workspace.js"
+import { Workspace } from "@opencode-ai/schema/workspace"
 import { InstructionState } from "./instruction-state.js"
 import { SessionInboxTable, SessionMessageTable, SessionTable } from "./sql.js"
 import { InstructionEntry } from "./instruction-entry.js"
@@ -26,8 +26,10 @@ import type { SessionSchema } from "./schema.js"
 import { ProjectTable } from "../project/sql.js"
 
 type DatabaseService = Database.Interface["db"]
-type CurrentDurableEvent = Extract<SessionEvent.Event, { readonly durable: object }>
-type MessageEvent = Exclude<CurrentDurableEvent, typeof SessionEvent.Forked.Type | typeof SessionEvent.Deleted.Type>
+type MessageEvent = Exclude<
+  SessionEvent.DurableEvent,
+  typeof SessionEvent.Forked.Type | typeof SessionEvent.Deleted.Type
+>
 
 const decodeMessage = Schema.decodeUnknownSync(SessionMessage.Info)
 const encodeMessage = Schema.encodeSync(SessionMessage.Info)
@@ -53,16 +55,16 @@ const forkTitle = (value?: string) => {
   return `${value} (fork #1)`
 }
 
-function applyUsage(db: DatabaseService, sessionID: SessionSchema.ID, value: Usage, sign = 1) {
+function applyUsage(db: DatabaseService, sessionID: SessionSchema.ID, value: Usage) {
   return db
     .update(SessionTable)
     .set({
-      cost: sql`${SessionTable.cost} + ${value.cost * sign}`,
-      tokens_input: sql`${SessionTable.tokens_input} + ${value.tokens.input * sign}`,
-      tokens_output: sql`${SessionTable.tokens_output} + ${value.tokens.output * sign}`,
-      tokens_reasoning: sql`${SessionTable.tokens_reasoning} + ${value.tokens.reasoning * sign}`,
-      tokens_cache_read: sql`${SessionTable.tokens_cache_read} + ${value.tokens.cache.read * sign}`,
-      tokens_cache_write: sql`${SessionTable.tokens_cache_write} + ${value.tokens.cache.write * sign}`,
+      cost: sql`${SessionTable.cost} + ${value.cost}`,
+      tokens_input: sql`${SessionTable.tokens_input} + ${value.tokens.input}`,
+      tokens_output: sql`${SessionTable.tokens_output} + ${value.tokens.output}`,
+      tokens_reasoning: sql`${SessionTable.tokens_reasoning} + ${value.tokens.reasoning}`,
+      tokens_cache_read: sql`${SessionTable.tokens_cache_read} + ${value.tokens.cache.read}`,
+      tokens_cache_write: sql`${SessionTable.tokens_cache_write} + ${value.tokens.cache.write}`,
       time_updated: sql`${SessionTable.time_updated}`,
     })
     .where(eq(SessionTable.id, sessionID))
@@ -73,7 +75,7 @@ function applyUsage(db: DatabaseService, sessionID: SessionSchema.ID, value: Usa
 const publishSessionUsage = Effect.fn("SessionProjector.publishUsage")(function* (
   db: DatabaseService,
   bus: Bus.Interface,
-  sessionID: (typeof SessionEvent.Step.Ended.Type)["data"]["sessionID"],
+  sessionID: SessionSchema.ID,
 ) {
   const row = yield* db
     .select({

packages/core/src/session/runner/llm.ts

@@ -15,7 +15,7 @@ import { SessionMessage } from "../message.js"
 import { SessionSchema } from "../schema.js"
 import { SessionStore } from "../store.js"
 import { SessionTitle } from "../title.js"
-import { DrainResult, Service, type Continuation } from "./index.js"
+import { DrainResult, Service, type Interface } from "./index.js"
 import { Snapshot } from "../../snapshot.js"
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
 import { llmClient } from "../../effect/app-node-platform.js"
@@ -44,12 +44,7 @@ const layer = Layer.effect(
     // Title generation starts once input is visible and must not delay model execution.
     const titles = yield* FiberMap.make<SessionSchema.ID, void, never>()
 
-    const drain = Effect.fn("SessionRunner.drain")(function* (input: {
-      readonly sessionID: SessionSchema.ID
-      readonly force: boolean
-      readonly continuation?: Continuation
-      readonly promotable?: SessionInbox.Promotable
-    }) {
+    const drain = Effect.fn("SessionRunner.drain")(function* (input: Parameters<Interface["drain"]>[0]) {
       const sessionID = input.sessionID
       let force = input.force
       let continuing = input.continuation !== undefined
@@ -143,7 +138,7 @@ const layer = Layer.effect(
                     entering && !continuing ? promotable : "steer",
                   )
                   if (promoted > 0 && !selected.session.parentID && SessionTitle.isUntitled(selected.session))
-                    yield* FiberMap.run(titles, sessionID, title.generate(sessionID).pipe(Effect.ignore), {
+                    yield* FiberMap.run(titles, sessionID, title.generate(sessionID), {
                       onlyIfMissing: true,
                     })
                   if (promoted > 0) step = 1

packages/core/src/session/runner/step.ts

@@ -221,10 +221,15 @@ export const make = Effect.gen(function* () {
             })
         }
 
+        // After durable output, recovery continues instead of replaying: the
+        // partial assistant message is already persisted history. Any failure
+        // the pre-output gate would retry is continued here, plus interrupted
+        // streams, whose read failures may carry delivery states the retry
+        // policy rejects for full resends.
         if (
           llmFailure &&
           llmError &&
-          isInterruptedStream(llmFailure) &&
+          (isInterruptedStream(llmFailure) || SessionRunnerRetry.isRetryable(llmFailure)) &&
           record.outputStarted &&
           tools.declines.length === 0 &&
           !tools.interrupted

packages/core/src/session/sql.ts

@@ -5,10 +5,10 @@ import { ProjectTable } from "../project/sql.js"
 import type { SessionMessage } from "./message.js"
 import type { SessionInbox } from "./inbox.js"
 import type { FileDiff } from "@opencode-ai/schema/file-diff"
-import { PermissionV1 } from "../v1/permission.js"
-import { Project } from "../project.js"
+import type { PermissionV1 } from "@opencode-ai/schema/permission-v1"
+import type { Project } from "@opencode-ai/schema/project"
 import type { SessionSchema } from "./schema.js"
-import { Workspace } from "../workspace.js"
+import type { Workspace } from "@opencode-ai/schema/workspace"
 import { Timestamps } from "../database/schema.sql.js"
 import type { Instruction } from "@opencode-ai/schema/instruction"
 import type { Session } from "@opencode-ai/schema/session"

packages/core/src/session/stats.ts

@@ -255,7 +255,7 @@ export const get = Effect.fn("SessionStats.get")(function* (input: Input = {}) {
             Effect.tap((rows) =>
               Effect.sync(() => {
                 rows.forEach((row) => {
-                  addToolStatus(toolTotals, row.status, 1)
+                  addToolStatus(toolTotals, row.status)
                   if (!row.name) return
                   const tool = tools.get(row.name) ?? {
                     name: row.name,
@@ -266,7 +266,7 @@ export const get = Effect.fn("SessionStats.get")(function* (input: Input = {}) {
                     durations: [],
                   }
                   tools.set(row.name, tool)
-                  addToolStatus(tool, row.status, 1)
+                  addToolStatus(tool, row.status)
                   if (row.duration !== null) tool.durations.push(row.duration)
                 })
               }),
@@ -385,18 +385,17 @@ function tokenTotal(tokens: Tokens) {
 function addToolStatus(
   target: { calls: number; succeeded: number; failed: number; unfinished: number },
   status: string | null,
-  count: number,
 ) {
-  target.calls += count
+  target.calls++
   if (status === "completed") {
-    target.succeeded += count
+    target.succeeded++
     return
   }
   if (status === "error") {
-    target.failed += count
+    target.failed++
     return
   }
-  target.unfinished += count
+  target.unfinished++
 }
 
 function makeDateKey(timezone = "UTC") {

packages/core/src/session/usage.ts

@@ -3,7 +3,7 @@ export * as SessionUsage from "./usage.js"
 import type { Usage } from "@opencode-ai/ai"
 import { Money } from "@opencode-ai/schema/money"
 import type { TokenUsage } from "@opencode-ai/schema/token-usage"
-import type { Model } from "../model.js"
+import type { Model } from "@opencode-ai/schema/model"
 
 const finite = (value: number) => (Number.isFinite(value) ? value : 0)
 const safe = (value: number | undefined) => Math.max(0, finite(value ?? 0))

packages/core/src/shell.ts

@@ -122,8 +122,8 @@ const layer = () =>
       const environments = yield* SessionEnvironment.Service
       const context = yield* Effect.context()
       const runFork = Effect.runForkWith(context)
-      const sessions = new Map<string, Active>()
-      const exitOrder: string[] = []
+      const commands = new Map<Shell.ID, Active>()
+      const exitOrder: Shell.ID[] = []
 
       const outputDir = path.join(global.data, DIRECTORY, location.project.id)
       const { mkdir, unlink } = yield* Effect.promise(() => import("fs/promises"))
@@ -132,44 +132,44 @@ const layer = () =>
 
       yield* Effect.addFinalizer(() =>
         Effect.gen(function* () {
-          for (const session of sessions.values()) {
-            if (session.timeoutFiber) yield* Fiber.interrupt(session.timeoutFiber)
+          for (const command of commands.values()) {
+            if (command.timeoutFiber) yield* Fiber.interrupt(command.timeoutFiber)
             // Teardown interrupts pending commands; it is not a terminal command failure.
-            yield* Deferred.interrupt(session.done)
+            yield* Deferred.interrupt(command.done)
           }
-          sessions.clear()
+          commands.clear()
           exitOrder.length = 0
         }),
       )
 
       const require = Effect.fnUntraced(function* (id: Shell.ID) {
-        const session = sessions.get(id)
-        if (!session) return yield* new NotFoundError({ id })
-        return session
+        const command = commands.get(id)
+        if (!command) return yield* new NotFoundError({ id })
+        return command
       })
 
-      const removeSession = Effect.fnUntraced(function* (id: Shell.ID) {
-        const session = sessions.get(id)
+      const removeCommand = Effect.fnUntraced(function* (id: Shell.ID) {
+        const command = commands.get(id)
         const index = exitOrder.indexOf(id)
         if (index !== -1) exitOrder.splice(index, 1)
-        if (!session) return
-        sessions.delete(id)
-        if (session.timeoutFiber) yield* Fiber.interrupt(session.timeoutFiber)
+        if (!command) return
+        commands.delete(id)
+        if (command.timeoutFiber) yield* Fiber.interrupt(command.timeoutFiber)
         // Unblock any wait still pending when the command is removed before it terminated.
-        yield* Deferred.fail(session.done, new NotFoundError({ id }))
-        yield* Effect.promise(() => unlink(session.file).catch(() => {}))
+        yield* Deferred.fail(command.done, new NotFoundError({ id }))
+        yield* Effect.promise(() => unlink(command.file).catch(() => {}))
         yield* bus.publish(Shell.Event.Deleted, { id })
       })
 
       const remove = Effect.fn("Shell.remove")(function* (id: Shell.ID) {
         yield* require(id)
-        yield* removeSession(id)
+        yield* removeCommand(id)
       })
 
       const list = Effect.fn("Shell.list")(function* () {
-        return Array.from(sessions.values())
-          .filter((session) => session.info.status === "running")
-          .map((session) => session.info)
+        return Array.from(commands.values())
+          .filter((command) => command.info.status === "running")
+          .map((command) => command.info)
       })
 
       const get = Effect.fn("Shell.get")(function* (id: Shell.ID) {
@@ -181,24 +181,24 @@ const layer = () =>
       })
 
       const timeout = Effect.fn("Shell.timeout")(function* (id: Shell.ID, duration: number) {
-        const session = yield* require(id)
-        if (session.info.status !== "running" || !session.timeout) return session.info
-        yield* session.timeout(duration)
-        return session.info
+        const command = yield* require(id)
+        if (command.info.status !== "running" || !command.timeout) return command.info
+        yield* command.timeout(duration)
+        return command.info
       })
 
       const output = Effect.fnUntraced(function* (id: Shell.ID, input?: Shell.OutputInput) {
-        const session = yield* require(id)
+        const command = yield* require(id)
         const cursor = input?.cursor ?? 0
         const limit = input?.limit ?? 65536
-        if (cursor >= session.size) return { output: "", cursor: session.size, size: session.size, truncated: false }
+        if (cursor >= command.size) return { output: "", cursor: command.size, size: command.size, truncated: false }
         const start = Math.max(0, cursor)
-        const length = Math.min(limit, session.size - start)
+        const length = Math.min(limit, command.size - start)
         const buffer = Buffer.alloc(length)
         const bytesRead = yield* Effect.promise(
           () =>
             new Promise<number>((resolve) => {
-              const stream = createReadStream(session.file, { start, end: start + length - 1 })
+              const stream = createReadStream(command.file, { start, end: start + length - 1 })
               let offset = 0
               stream.on("data", (chunk: string | Buffer) => {
                 const bytes = Buffer.from(chunk)
@@ -212,7 +212,7 @@ const layer = () =>
         return {
           output: buffer.subarray(0, bytesRead).toString("utf8"),
           cursor: start + bytesRead,
-          size: session.size,
+          size: command.size,
           truncated: false,
         }
       })
@@ -257,7 +257,7 @@ const layer = () =>
 
         // Spawn through the Environment and stream combined output to the file. The handle is scope-bound, so
         // the managing fiber keeps its scope open until the command terminates (it awaits `done` at the
-        // end). `create` returns once `ready` resolves with the registered session.
+        // end). `create` returns once `ready` resolves with the registered command.
         const ready = Deferred.makeUnsafe<Active, AppProcess.AppProcessError>()
         runFork(
           Effect.scoped(
@@ -275,7 +275,7 @@ const layer = () =>
                 .pipe(
                   Effect.mapError((cause) => new AppProcess.AppProcessError({ command: invocation.command, cause })),
                 )
-              const session: Active = {
+              const command: Active = {
                 info: produce(info, (draft) => {
                   draft.pid = handle.pid
                 }),
@@ -283,7 +283,7 @@ const layer = () =>
                 size: 0,
                 done: Deferred.makeUnsafe<Info, NotFoundError>(),
               }
-              sessions.set(id, session)
+              commands.set(id, command)
 
               const stream = createWriteStream(file)
               const outputDone = Latch.makeUnsafe()
@@ -291,7 +291,7 @@ const layer = () =>
                 Stream.runForEach((chunk: Uint8Array) =>
                   Effect.sync(() => {
                     stream.write(chunk)
-                    session.size += chunk.length
+                    command.size += chunk.length
                   }),
                 ),
               )
@@ -305,7 +305,7 @@ const layer = () =>
                       }),
                   )
                   yield* outputDone.open
-                }).pipe(Effect.catch(() => outputDone.open)),
+                }),
               )
               yield* Effect.promise(
                 () =>
@@ -317,8 +317,8 @@ const layer = () =>
 
               const finish = (status: Info["status"], exit?: number, beforeWait = Effect.void) =>
                 Effect.gen(function* () {
-                  if (session.info.status !== "running") return
-                  session.info = produce(session.info, (draft) => {
+                  if (command.info.status !== "running") return
+                  command.info = produce(command.info, (draft) => {
                     draft.status = status
                     if (exit !== undefined) draft.exit = exit
                     draft.time.completed = Date.now()
@@ -326,10 +326,10 @@ const layer = () =>
                   yield* beforeWait
                   yield* outputDone.await
                   // Resolve waiters with the terminal Info before any retention eviction, so an evicted
-                  // session still reports success rather than the removal NotFoundError. This runs before
+                  // command still reports success rather than the removal NotFoundError. This runs before
                   // the timeout-fiber interrupt below, which on the timeout path would otherwise cancel
                   // this very fiber (finish is invoked by the timeout fiber) before waiters are resolved.
-                  yield* Deferred.succeed(session.done, session.info)
+                  yield* Deferred.succeed(command.done, command.info)
                   yield* bus.publish(Shell.Event.Exited, {
                     id,
                     ...(exit !== undefined ? { exit } : {}),
@@ -339,29 +339,28 @@ const layer = () =>
                   while (exitOrder.length > EXITED_LIMIT) {
                     const oldest = exitOrder[0]
                     if (!oldest) break
-                    yield* removeSession(Shell.ID.make(oldest))
+                    yield* removeCommand(oldest)
                   }
                   // Cancel a pending timeout once the command exits on its own. Interrupting last avoids
                   // aborting finish when finish itself runs on the timeout fiber.
-                  if (session.timeoutFiber) yield* Fiber.interrupt(session.timeoutFiber)
+                  if (command.timeoutFiber) yield* Fiber.interrupt(command.timeoutFiber)
                 })
 
-              session.timeout = (duration) =>
+              command.timeout = (duration) =>
                 Effect.gen(function* () {
-                  if (session.timeoutFiber) yield* Fiber.interrupt(session.timeoutFiber)
-                  session.timeoutFiber = undefined
-                  if (duration === 0 || session.info.status !== "running") return
-                  session.timeoutFiber = runFork(
+                  if (command.timeoutFiber) yield* Fiber.interrupt(command.timeoutFiber)
+                  command.timeoutFiber = undefined
+                  if (duration === 0 || command.info.status !== "running") return
+                  command.timeoutFiber = runFork(
                     Effect.sleep(Duration.millis(duration)).pipe(
                       Effect.flatMap(() =>
                         finish("timeout", undefined, handle.kill().pipe(Effect.catch(() => Effect.void))),
                       ),
-                      Effect.catch(() => Effect.void),
                     ),
                   )
                 })
 
-              yield* session.timeout(invocation.timeout)
+              yield* command.timeout(invocation.timeout)
 
               runFork(
                 handle.exitCode.pipe(
@@ -371,16 +370,16 @@ const layer = () =>
               )
 
               yield* bus.publish(Shell.Event.Created, { info })
-              yield* Deferred.succeed(ready, session)
+              yield* Deferred.succeed(ready, command)
               // Hold the handle's scope open until the command terminates; closing it earlier would
               // release (kill) the process before its exit is observed.
-              yield* Deferred.await(session.done).pipe(Effect.catch(() => Effect.void))
+              yield* Deferred.await(command.done).pipe(Effect.catch(() => Effect.void))
             }),
           ).pipe(Effect.catchTag("AppProcessError", (error) => Deferred.fail(ready, error))),
         )
 
-        const session = yield* Deferred.await(ready)
-        return session.info
+        const command = yield* Deferred.await(ready)
+        return command.info
       })
 
       return Service.of({ create, list, get, wait, timeout, output, remove })

packages/core/src/shell/parse.ts

@@ -7,6 +7,7 @@ import path from "path"
 import type { Node } from "web-tree-sitter"
 import { shellParserWasm } from "#shell-parser-wasm"
 import { ShellSelect } from "./select.js"
+import { lazy } from "../util/lazy.js"
 import { Wildcard } from "../util/wildcard.js"
 
 type Part = { type: string; text: string }
@@ -355,10 +356,7 @@ function resolve(asset: string) {
   return fileURLToPath(new URL(asset, import.meta.url))
 }
 
-const load = (() => {
-  let loading: ReturnType<typeof initialize> | undefined
-  return () => (loading ??= initialize())
-})()
+const load = lazy(initialize)
 
 async function initialize() {
   const { Parser, Language } = await import("web-tree-sitter")

packages/core/src/snapshot.ts

@@ -133,36 +133,34 @@ const layer = Layer.effect(
 
     const compare = Effect.fnUntraced(function* (operation: "files" | "diff", input: CompareInput) {
       const repo = yield* repository.pipe(Effect.mapError((cause) => failure(operation, cause)))
+      const comparison = {
+        repository: repo.snapshotRepository,
+        from: Git.TreeID.make(input.from),
+        to: Git.TreeID.make(input.to),
+      }
+      const files = yield* git.tree.files(comparison).pipe(Effect.mapError((cause) => failure(operation, cause)))
+      const ignored = yield* git.index
+        .ignored({ repository: repo.source, paths: files })
+        .pipe(Effect.mapError((cause) => failure(operation, cause)))
       return {
-        source: repo.source,
-        input: {
-          repository: repo.snapshotRepository,
-          from: Git.TreeID.make(input.from),
-          to: Git.TreeID.make(input.to),
-        },
+        input: comparison,
+        files,
+        ignored,
       }
     })
 
     const files = Effect.fn("Snapshot.files")(function* (input: CompareInput) {
       const comparison = yield* compare("files", input)
-      const files = yield* git.tree.files(comparison.input).pipe(Effect.mapError((cause) => failure("files", cause)))
-      const ignored = yield* git.index
-        .ignored({ repository: comparison.source, paths: files })
-        .pipe(Effect.mapError((cause) => failure("files", cause)))
-      return files.filter((file) => !ignored.has(file))
+      return comparison.files.filter((file) => !comparison.ignored.has(file))
     })
 
     const diff = Effect.fn("Snapshot.diff")(function* (input: DiffInput) {
       const comparison = yield* compare("diff", input)
-      const files = yield* git.tree.files(comparison.input).pipe(Effect.mapError((cause) => failure("diff", cause)))
-      const ignored = yield* git.index
-        .ignored({ repository: comparison.source, paths: files })
-        .pipe(Effect.mapError((cause) => failure("diff", cause)))
       return yield* git.tree
         .diff({
           ...comparison.input,
           context: input.context,
-          paths: (input.paths ?? files).filter((file) => !ignored.has(file)),
+          paths: (input.paths ?? comparison.files).filter((file) => !comparison.ignored.has(file)),
         })
         .pipe(Effect.mapError((cause) => failure("diff", cause)))
     })

packages/core/src/tool/AGENTS.md

@@ -7,7 +7,7 @@
 - Plugin authors get schema-derived input types at the `ToolDraft.add` boundary through `Tool`.
 - The heterogeneous Core registry deliberately erases registered definitions to `Tool.Info`. Use `any` at this internal boundary; do not replace it with `unknown`, JSON-value plumbing, casts, or compiled wrapper types solely to preserve type safety after registration.
 - Executors return model content and metadata alongside declared machine output. Shipped built-ins and plugin tools use the same runtime shape after registration.
-- `src/tool.ts` stores canonical Location registrations, derives LLM definitions, executes tools, and applies generic output bounding.
+- `src/tool.ts` stores canonical Location registrations, derives LLM definitions, executes tools, and normalizes model content and images.
 - Built-in tool plugins live in `tool/plugin`.
 
 Do not add a second executable entry type, registry-owned executor, authorization callback, output-path callback, or legacy normalization path.
@@ -53,9 +53,9 @@ Tool filtering is catalog visibility, not execution authorization. A call still
 
 ## Output
 
-Built-ins return complete tool responses. `Tool.Snapshot.execute` is the local execution boundary.
+Built-ins return complete tool responses. `Tool.Snapshot.execute` is the local execution boundary. Generic output bounding is applied by the Session runner after execution.
 
-Producer capture limits remain local to producers. For example, Bash keeps `AppProcess.maxOutputBytes` and accurately reports stdout/stderr capture loss.
+Producer capture remains local to producers. Shell stores combined process output in its backing file and returns a bounded tail with the full-output path when truncated.
 
 ## Current Gaps
 

packages/core/src/tool/plugin/edit.ts

@@ -6,7 +6,7 @@
  */
 export * as EditTool from "./edit.js"
 
-import type { Context as PluginContext } from "@opencode-ai/plugin/effect/plugin"
+import type { Context } from "@opencode-ai/plugin/effect/plugin"
 import { ToolFailure } from "@opencode-ai/ai"
 import { FileDiff } from "@opencode-ai/schema/file-diff"
 import { Bom } from "@opencode-ai/util/bom"
@@ -108,7 +108,7 @@ const findLineOccurrences = (content: string, search: string) => {
 
 export const Plugin = {
   id: "opencode.tool.edit",
-  effect: Effect.fn("EditTool.Plugin")(function* (ctx: PluginContext) {
+  effect: Effect.fn("EditTool.Plugin")(function* (ctx: Context) {
     const mutation = yield* LocationMutation.Service
     const fileMutation = yield* FileMutation.Service
     const environment = yield* Environment.Service

packages/core/src/tool/plugin/glob.ts

@@ -1,7 +1,7 @@
 export * as GlobTool from "./glob.js"
 
 import { ToolFailure } from "@opencode-ai/ai"
-import type { Context as PluginContext } from "@opencode-ai/plugin/effect/plugin"
+import type { Context } from "@opencode-ai/plugin/effect/plugin"
 import { Effect, Schema } from "effect"
 import path from "path"
 import { Environment } from "../../environment/index.js"
@@ -41,7 +41,7 @@ export const toModelContent = (entries: EncodedOutput, truncated = false) => {
 /** Glob leaf that defaults its filesystem root to the active Location. */
 export const Plugin = {
   id: "opencode.tool.glob",
-  effect: Effect.fn("GlobTool.Plugin")(function* (ctx: PluginContext) {
+  effect: Effect.fn("GlobTool.Plugin")(function* (ctx: Context) {
     const environment = yield* Environment.Service
     const ripgrep = yield* Ripgrep.Service
     const location = yield* Location.Service

packages/core/src/tool/plugin/grep.ts

@@ -1,6 +1,6 @@
 export * as GrepTool from "./grep.js"
 
-import type { Context as PluginContext } from "@opencode-ai/plugin/effect/plugin"
+import type { Context } from "@opencode-ai/plugin/effect/plugin"
 import { ToolFailure } from "@opencode-ai/ai"
 import { Effect, Schema } from "effect"
 import path from "path"
@@ -57,7 +57,7 @@ export const toModelContent = (matches: EncodedOutput, truncated = false) => {
 /** Grep leaf that defaults its filesystem root to the active Location. */
 export const Plugin = {
   id: "opencode.tool.grep",
-  effect: Effect.fn("GrepTool.Plugin")(function* (ctx: PluginContext) {
+  effect: Effect.fn("GrepTool.Plugin")(function* (ctx: Context) {
     const environment = yield* Environment.Service
     const ripgrep = yield* Ripgrep.Service
     const location = yield* Location.Service

packages/core/src/tool/plugin/patch.ts

@@ -1,6 +1,6 @@
 export * as PatchTool from "./patch.js"
 
-import type { Context as PluginContext } from "@opencode-ai/plugin/effect/plugin"
+import type { Context } from "@opencode-ai/plugin/effect/plugin"
 import { ToolFailure } from "@opencode-ai/ai"
 import { FileDiff } from "@opencode-ai/schema/file-diff"
 import { Effect, Result, Schema } from "effect"
@@ -65,7 +65,7 @@ type Prepared =
 
 export const Plugin = {
   id: "opencode.tool.patch",
-  effect: Effect.fn("PatchTool.Plugin")(function* (ctx: PluginContext) {
+  effect: Effect.fn("PatchTool.Plugin")(function* (ctx: Context) {
     const environment = yield* Environment.Service
     const mutation = yield* LocationMutation.Service
     const fileMutation = yield* FileMutation.Service

packages/core/src/tool/plugin/question.ts

@@ -1,6 +1,6 @@
 export * as QuestionTool from "./question.js"
 
-import type { Context as PluginContext } from "@opencode-ai/plugin/effect/plugin"
+import type { Context } from "@opencode-ai/plugin/effect/plugin"
 import { ToolFailure } from "@opencode-ai/ai"
 import { Effect, Schema } from "effect"
 import { Form } from "../../form.js"
@@ -47,7 +47,7 @@ export const toModelContent = (questions: ReadonlyArray<Question.Prompt>, answer
 
 export const Plugin = {
   id: "opencode.tool.question",
-  effect: Effect.fn("QuestionTool.Plugin")(function* (ctx: PluginContext) {
+  effect: Effect.fn("QuestionTool.Plugin")(function* (ctx: Context) {
     const forms = yield* Form.Service
     const permission = yield* Permission.Service
 

packages/core/src/tool/plugin/read.ts

@@ -1,6 +1,6 @@
 export * as ReadTool from "./read.js"
 
-import type { Context as PluginContext } from "@opencode-ai/plugin/effect/plugin"
+import type { Context } from "@opencode-ai/plugin/effect/plugin"
 import { basename, dirname, join } from "path"
 import { ToolFailure } from "@opencode-ai/ai"
 import { Effect, Schema } from "effect"
@@ -29,7 +29,7 @@ const Output = Schema.Union([ReadToolFileSystem.FileContent, ReadToolFileSystem.
 
 export const Plugin = {
   id: "opencode.tool.read",
-  effect: Effect.fn("ReadTool.Plugin")(function* (ctx: PluginContext) {
+  effect: Effect.fn("ReadTool.Plugin")(function* (ctx: Context) {
     const reader = yield* ReadToolFileSystem.Service
     const mutation = yield* LocationMutation.Service
     const permission = yield* Permission.Service
@@ -169,7 +169,7 @@ export const toModelContent = (path: string, offset: number | undefined, output:
     ] as const
 
   if (output.type === "list-page") {
-    const start = offset ?? 1
+    const start = offset || 1
     const content = [
       output.entries.length === 0
         ? `Read directory ${path}, 0 entries`

packages/core/src/tool/plugin/shell.ts

@@ -1,7 +1,7 @@
 export * as ShellTool from "./shell.js"
 
 import { ToolFailure } from "@opencode-ai/ai"
-import type { Context as PluginContext } from "@opencode-ai/plugin/effect/plugin"
+import type { Context } from "@opencode-ai/plugin/effect/plugin"
 import { Deferred, Effect, Schema, Scope } from "effect"
 import { Config } from "../../config.js"
 import { Environment } from "../../environment/index.js"
@@ -102,7 +102,7 @@ const backgroundResult = (shellID: string, file: string) => ({
 
 export const Plugin = {
   id: "opencode.tool.shell",
-  effect: Effect.fn("ShellTool.Plugin")(function* (ctx: PluginContext) {
+  effect: Effect.fn("ShellTool.Plugin")(function* (ctx: Context) {
     const runtime = yield* PluginRuntime.Service
     const scope = yield* Scope.Scope
     const environment = yield* Environment.Service
@@ -280,7 +280,8 @@ export const Plugin = {
                 Effect.onInterrupt(() => shell.remove(info.id).pipe(Effect.ignore)),
               )
               const job = yield* runtime.job.start({
-                id: context.id,
+                // CodeMode children share a tool-call ID, but each shell must own its job.
+                id: info.id,
                 type: name,
                 title: info.command,
                 metadata: { sessionID: context.sessionID, shellID: info.id },
@@ -295,7 +296,7 @@ export const Plugin = {
 
               if (input.background === true) {
                 yield* runtime.job.background(job.id)
-                yield* notifyWhenDone(context.sessionID, context.id, info.id, info.command, settled)
+                yield* notifyWhenDone(context.sessionID, job.id, info.id, info.command, settled)
                 return backgroundResult(info.id, info.file)
               }
 
@@ -304,7 +305,7 @@ export const Plugin = {
                 .pipe(Effect.onInterrupt(() => runtime.job.cancel(job.id).pipe(Effect.ignore)))
               if (result?.type === "backgrounded") {
                 yield* shell.timeout(info.id, 0)
-                yield* notifyWhenDone(context.sessionID, context.id, info.id, info.command, settled)
+                yield* notifyWhenDone(context.sessionID, job.id, info.id, info.command, settled)
                 return backgroundResult(info.id, info.file)
               }
               if (result?.info.status === "error")

packages/core/src/tool/plugin/skill.ts

@@ -1,6 +1,6 @@
 export * as SkillTool from "./skill.js"
 
-import type { Context as PluginContext } from "@opencode-ai/plugin/effect/plugin"
+import type { Context } from "@opencode-ai/plugin/effect/plugin"
 import { ToolFailure } from "@opencode-ai/ai"
 import { Effect, Schema } from "effect"
 import { FSUtil } from "@opencode-ai/util/fs-util"
@@ -31,7 +31,7 @@ const unableToLoad = (name: string, error?: unknown) =>
 
 export const Plugin = {
   id: "opencode.tool.skill",
-  effect: Effect.fn("SkillTool.Plugin")(function* (ctx: PluginContext) {
+  effect: Effect.fn("SkillTool.Plugin")(function* (ctx: Context) {
     const fs = yield* FSUtil.Service
     const skills = yield* Skill.Service
     const permission = yield* Permission.Service

packages/core/src/tool/plugin/subagent.ts

@@ -1,7 +1,7 @@
 export * as SubagentTool from "./subagent.js"
 
 import { ToolFailure } from "@opencode-ai/ai"
-import type { Context as PluginContext } from "@opencode-ai/plugin/effect/plugin"
+import type { Context } from "@opencode-ai/plugin/effect/plugin"
 import { Effect, Schema, Scope } from "effect"
 import { Agent } from "../../agent.js"
 import { Config } from "../../config.js"
@@ -52,7 +52,7 @@ export const description = [
 
 export const Plugin = {
   id: "opencode.tool.subagent",
-  effect: Effect.fn("SubagentTool.Plugin")(function* (ctx: PluginContext) {
+  effect: Effect.fn("SubagentTool.Plugin")(function* (ctx: Context) {
     const runtime = yield* PluginRuntime.Service
     const agents = yield* Agent.Service
     const config = yield* Config.Service

packages/core/src/tool/plugin/webfetch.ts

@@ -1,6 +1,6 @@
 export * as WebFetchTool from "./webfetch.js"
 
-import type { Context as PluginContext } from "@opencode-ai/plugin/effect/plugin"
+import type { Context } from "@opencode-ai/plugin/effect/plugin"
 import { ToolFailure } from "@opencode-ai/ai"
 import { Duration, Effect, Schema } from "effect"
 import { HttpClient, type HttpClientError, HttpClientRequest, HttpClientResponse } from "effect/unstable/http"
@@ -102,7 +102,7 @@ const convert = (content: string, contentType: string, format: Format) => {
 
 export const Plugin = {
   id: "opencode.tool.webfetch",
-  effect: Effect.fn("WebFetchTool.Plugin")(function* (ctx: PluginContext) {
+  effect: Effect.fn("WebFetchTool.Plugin")(function* (ctx: Context) {
     const http = yield* HttpClient.HttpClient
     const permission = yield* Permission.Service
 

packages/core/src/tool/plugin/websearch.ts

@@ -1,6 +1,6 @@
 export * as WebSearchTool from "./websearch.js"
 
-import type { Context as PluginContext } from "@opencode-ai/plugin/effect/plugin"
+import type { Context } from "@opencode-ai/plugin/effect/plugin"
 import { ToolFailure } from "@opencode-ai/ai"
 import { Effect, Schema, Semaphore } from "effect"
 import { HttpClientError } from "effect/unstable/http"
@@ -26,7 +26,7 @@ const Output = Schema.Struct({
 })
 export const Plugin = {
   id: "opencode.tool.websearch",
-  effect: Effect.fn("WebSearchTool.Plugin")(function* (ctx: PluginContext) {
+  effect: Effect.fn("WebSearchTool.Plugin")(function* (ctx: Context) {
     const permission = yield* Permission.Service
     const forms = yield* Form.Service
     const websearch = yield* WebSearch.Service

packages/core/src/tool/plugin/write.ts

@@ -6,7 +6,7 @@
  */
 export * as WriteTool from "./write.js"
 
-import type { Context as PluginContext } from "@opencode-ai/plugin/effect/plugin"
+import type { Context } from "@opencode-ai/plugin/effect/plugin"
 import { ToolFailure } from "@opencode-ai/ai"
 import { Effect, Schema } from "effect"
 import { Bom } from "@opencode-ai/util/bom"
@@ -45,7 +45,7 @@ export const toModelContent = (output: Output) =>
 
 export const Plugin = {
   id: "opencode.tool.write",
-  effect: Effect.fn("WriteTool.Plugin")(function* (ctx: PluginContext) {
+  effect: Effect.fn("WriteTool.Plugin")(function* (ctx: Context) {
     const mutation = yield* LocationMutation.Service
     const fileMutation = yield* FileMutation.Service
     const environment = yield* Environment.Service

packages/core/src/util/error.ts

@@ -5,9 +5,7 @@ export abstract class NamedError extends Error {
   abstract toObject(): { name: string; data: unknown }
 
   static hasName(error: unknown, name: string): boolean {
-    return (
-      typeof error === "object" && error !== null && "name" in error && (error as Record<string, unknown>).name === name
-    )
+    return typeof error === "object" && error !== null && "name" in error && error.name === name
   }
 
   static create<Name extends string, Fields extends Schema.Struct.Fields>(

packages/core/test/aisdk-native.test.ts

@@ -5,6 +5,31 @@ const map = (packageName: string, settings: Readonly<Record<string, unknown>>, m
   AISDKNative.map({ packageName, settings, modelID, providerID: "test-provider" })
 
 describe("AISDKNative", () => {
+  test("maps Merge Gateway to the native compatible provider with its default endpoint", () => {
+    expect(map("merge-gateway-ai-sdk-provider", {})).toEqual({
+      package: "@opencode-ai/ai/providers/openai-compatible",
+      settings: {
+        baseURL: "https://api-gateway.merge.dev/v1/ai-sdk",
+        provider: "test-provider",
+      },
+    })
+    expect(
+      map("merge-gateway-ai-sdk-provider", {
+        apiKey: "test-key",
+        baseURL: "https://custom.example/v1",
+        reasoningEffort: "high",
+      }),
+    ).toEqual({
+      package: "@opencode-ai/ai/providers/openai-compatible",
+      settings: {
+        apiKey: "test-key",
+        baseURL: "https://custom.example/v1",
+        provider: "test-provider",
+        providerOptions: { reasoningEffort: "high" },
+      },
+    })
+  })
+
   test("maps OpenAI-family packages and request options to native providers", () => {
     expect(
       map("@ai-sdk/openai", {

packages/core/test/aisdk.test.ts

@@ -375,7 +375,100 @@ it.effect("projects replay metadata onto AI SDK prompt parts", () =>
   }),
 )
 
-it.effect("moves a tool image through the real Mistral provider as a user message", () =>
+it.effect("normalizes file data across AI SDK prompt parts", () =>
+  Effect.gen(function* () {
+    const aisdk = yield* AISDK.Service
+    yield* aisdk.hook.sdk((event) => {
+      event.sdk = { languageModel: () => ({ provider: event.model.providerID }) }
+    })
+
+    const resolved = yield* aisdk.model(model("opaque-provider"))
+    const bytes = new Uint8Array([0, 1, 2, 3])
+    const prepared = yield* compileRequest(
+      LLM.request({
+        model: resolved,
+        messages: [
+          Message.user([
+            { type: "media", mediaType: "image/png", data: bytes, filename: "bytes.png" },
+            { type: "media", mediaType: "image/png", data: "AAAA", filename: "base64.png" },
+            {
+              type: "media",
+              mediaType: "image/png",
+              data: "data:image/png;charset=utf-8;base64,AQID",
+              filename: "inline.png",
+            },
+            { type: "media", mediaType: "image/png", data: "https://example.com/image.png" },
+            { type: "media", mediaType: "image/png", data: "s3://bucket/image.png" },
+          ]),
+          Message.assistant({
+            type: "media",
+            mediaType: "application/pdf",
+            data: "http://example.com/document.pdf",
+            filename: "document.pdf",
+          }),
+          Message.tool({
+            id: "call_1",
+            name: "screenshot",
+            result: {
+              type: "content",
+              value: [{ type: "file", uri: "data:image/png;base64,BAUG", mime: "image/png", name: "tool.png" }],
+            },
+          }),
+        ],
+      }),
+    )
+
+    expect(prepared.body.prompt).toEqual([
+      {
+        role: "user",
+        content: [
+          { type: "file", mediaType: "image/png", data: bytes, filename: "bytes.png" },
+          { type: "file", mediaType: "image/png", data: "AAAA", filename: "base64.png" },
+          { type: "file", mediaType: "image/png", data: "AQID", filename: "inline.png" },
+          {
+            type: "file",
+            mediaType: "image/png",
+            data: new URL("https://example.com/image.png"),
+            filename: undefined,
+          },
+          { type: "file", mediaType: "image/png", data: "s3://bucket/image.png", filename: undefined },
+        ],
+      },
+      {
+        role: "assistant",
+        content: [
+          {
+            type: "file",
+            mediaType: "application/pdf",
+            data: new URL("http://example.com/document.pdf"),
+            filename: "document.pdf",
+          },
+        ],
+      },
+      {
+        role: "tool",
+        content: [
+          {
+            type: "tool-result",
+            toolCallId: "call_1",
+            toolName: "screenshot",
+            output: { type: "text", value: "Media attached in the following user message." },
+            providerOptions: undefined,
+          },
+        ],
+      },
+      {
+        role: "user",
+        content: [
+          { type: "text", text: "Attached media from tool result:" },
+          { type: "file", mediaType: "image/png", data: "BAUG", filename: "tool.png" },
+        ],
+      },
+    ])
+  }),
+)
+
+it.effect("normalizes user and tool media through the real Mistral provider", () =>
   Effect.gen(function* () {
     const aisdk = yield* AISDK.Service
     let body: { messages?: unknown[] } | undefined
@@ -415,7 +508,14 @@ it.effect("moves a tool image through the real Mistral provider as a user messag
       LLM.request({
         model: resolved,
         messages: [
-          Message.user("Inspect the screenshot."),
+          Message.user([
+            { type: "text", text: "Inspect the attachments." },
+            { type: "media", mediaType: "image/png", data: new Uint8Array([0, 1, 2, 3]) },
+            { type: "media", mediaType: "image/png", data: "AQID" },
+            { type: "media", mediaType: "image/png", data: "data:image/png;base64,BAUG" },
+            { type: "media", mediaType: "image/png", data: "http://example.com/image.png" },
+            { type: "media", mediaType: "application/pdf", data: "https://example.com/document.pdf" },
+          ]),
           Message.assistant({ type: "tool-call", id: "call_1", name: "screenshot", input: {} }),
           Message.tool({
             type: "tool-result",
@@ -426,6 +526,12 @@ it.effect("moves a tool image through the real Mistral provider as a user messag
               value: [
                 { type: "text", text: "Screenshot captured" },
                 { type: "file", uri: "data:image/png;base64,AAAA", mime: "image/png", name: "screen.png" },
+                {
+                  type: "file",
+                  uri: "https://example.com/tool-document.pdf",
+                  mime: "application/pdf",
+                  name: "tool-document.pdf",
+                },
               ],
             },
           }),
@@ -434,7 +540,17 @@ it.effect("moves a tool image through the real Mistral provider as a user messag
     ).pipe(Effect.provide(client))
 
     expect(body?.messages).toEqual([
-      { role: "user", content: [{ type: "text", text: "Inspect the screenshot." }] },
+      {
+        role: "user",
+        content: [
+          { type: "text", text: "Inspect the attachments." },
+          { type: "image_url", image_url: "data:image/png;base64,AAECAw==" },
+          { type: "image_url", image_url: "data:image/png;base64,AQID" },
+          { type: "image_url", image_url: "data:image/png;base64,BAUG" },
+          { type: "image_url", image_url: "http://example.com/image.png" },
+          { type: "document_url", document_url: "https://example.com/document.pdf" },
+        ],
+      },
       {
         role: "assistant",
         content: "",
@@ -457,6 +573,7 @@ it.effect("moves a tool image through the real Mistral provider as a user messag
         content: [
           { type: "text", text: "Attached media from tool result:" },
           { type: "image_url", image_url: "data:image/png;base64,AAAA" },
+          { type: "document_url", document_url: "https://example.com/tool-document.pdf" },
         ],
       },
     ])

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

@@ -85,8 +85,8 @@ describe("Bus Session routing", () => {
         projectID: Project.ID.global,
       })
       const done = yield* bus.publish(Done, {})
-      expect(Array.from(yield* Fiber.join(first))).toEqual([moved, done])
-      expect(Array.from(yield* Fiber.join(second))).toEqual([moved, after, same, done])
+      expect(yield* Fiber.join(first)).toEqual([moved, done])
+      expect(yield* Fiber.join(second)).toEqual([moved, after, same, done])
       expect(moved.location).toEqual(a)
     }),
   )
@@ -130,8 +130,8 @@ describe("Bus Session routing", () => {
             )
           const after = yield* bus.publish(SessionEvent.Execution.Succeeded, { sessionID: child })
           const done = yield* bus.publish(Done, {})
-          expect(Array.from(yield* Fiber.join(first)).map((event) => event.id)).toEqual([eventID, after.id, done.id])
-          expect(Array.from(yield* Fiber.join(second))).toEqual([done])
+          expect((yield* Fiber.join(first)).map((event) => event.id)).toEqual([eventID, after.id, done.id])
+          expect(yield* Fiber.join(second)).toEqual([done])
         }),
       )
     }),
@@ -158,19 +158,17 @@ describe("Bus Session routing", () => {
       const explicit = yield* bus.publish(SessionEvent.Execution.Succeeded, { sessionID: id }, { location: b })
       const done = yield* bus.publish(Done, {})
 
-      expect(Array.from(yield* Fiber.join(first))).toEqual([renamed, text, broadcast, done])
-      expect(Array.from(yield* Fiber.join(second))).toEqual([broadcast, explicit, done])
-      expect(Array.from(yield* Fiber.join(workspace))).toEqual([broadcast, done])
-      expect(Array.from(yield* Fiber.join(global))).toEqual([renamed, text, broadcast, explicit, done])
+      expect(yield* Fiber.join(first)).toEqual([renamed, text, broadcast, done])
+      expect(yield* Fiber.join(second)).toEqual([broadcast, explicit, done])
+      expect(yield* Fiber.join(workspace)).toEqual([broadcast, done])
+      expect(yield* Fiber.join(global)).toEqual([renamed, text, broadcast, explicit, done])
       expect(listened).toEqual([renamed, text, broadcast, explicit, done])
       expect(renamed).not.toHaveProperty("location")
       expect(text).not.toHaveProperty("location")
       expect(JSON.parse(JSON.stringify(renamed))).not.toHaveProperty("location")
       const history = yield* bus.log({ aggregateID: id }).pipe(Stream.runCollect)
       expect(
-        Array.from(history)
-          .filter((event): event is Event.Payload => !Bus.isSynced(event))
-          .every((event) => !event.location),
+        history.filter((event): event is Event.Payload => !Bus.isSynced(event)).every((event) => !event.location),
       ).toBe(true)
     }),
   )
@@ -197,8 +195,8 @@ describe("Bus Session routing", () => {
       yield* bus.publish(SessionEvent.Moved, { sessionID: id, location: b, projectID: Project.ID.global })
       const expected = yield* bus.publish(SessionEvent.Renamed, { sessionID: id, title: "destination" })
       const done = yield* bus.publish(Done, {})
-      expect(Array.from(yield* Fiber.join(typed))).toEqual([expected])
-      expect(Array.from(yield* Fiber.join(multiple))).toEqual([expected, done])
+      expect(yield* Fiber.join(typed)).toEqual([expected])
+      expect(yield* Fiber.join(multiple)).toEqual([expected, done])
     }),
   )
 
@@ -226,8 +224,8 @@ describe("Bus Session routing", () => {
       const done = yield* bus.publish(Done, {})
       yield* Deferred.succeed(gate, undefined)
 
-      expect(Array.from(yield* Fiber.join(first))).toEqual([created, before, moved, done])
-      expect(Array.from(yield* Fiber.join(second))).toEqual([moved, after, done])
+      expect(yield* Fiber.join(first)).toEqual([created, before, moved, done])
+      expect(yield* Fiber.join(second)).toEqual([moved, after, done])
       expect(moved).not.toHaveProperty("location")
     }),
   )
@@ -245,9 +243,9 @@ describe("Bus Session routing", () => {
 
       const database = yield* Database.Service
       expect(yield* database.db.select().from(SessionTable).where(eq(SessionTable.id, id)).get()).toBeUndefined()
-      expect(Array.from(yield* Fiber.join(first))).toEqual([deleted, done])
-      expect(Array.from(yield* Fiber.join(second))).toEqual([done])
-      expect(Array.from(yield* Fiber.join(global))).toEqual([deleted, missing, done])
+      expect(yield* Fiber.join(first)).toEqual([deleted, done])
+      expect(yield* Fiber.join(second)).toEqual([done])
+      expect(yield* Fiber.join(global)).toEqual([deleted, missing, done])
     }),
   )
 
@@ -266,8 +264,8 @@ describe("Bus Session routing", () => {
       ])
       const done = yield* bus.publish(Done, {})
       yield* Deferred.succeed(gate, undefined)
-      expect(Array.from(yield* Fiber.join(first))).toEqual([events[0], events[1], done])
-      expect(Array.from(yield* Fiber.join(second))).toEqual([events[1], events[2], events[3], done])
+      expect(yield* Fiber.join(first)).toEqual([events[0], events[1], done])
+      expect(yield* Fiber.join(second)).toEqual([events[1], events[2], events[3], done])
     }),
   )
 
@@ -295,8 +293,8 @@ describe("Bus Session routing", () => {
       const done = yield* bus.publish(Done, {})
       expect(Exit.isFailure(single)).toBe(true)
       expect(Exit.isFailure(batch)).toBe(true)
-      expect(Array.from(yield* Fiber.join(first))).toEqual([before, after, done])
-      expect(Array.from(yield* Fiber.join(second))).toEqual([done])
+      expect(yield* Fiber.join(first)).toEqual([before, after, done])
+      expect(yield* Fiber.join(second)).toEqual([done])
     }),
   )
 
@@ -327,8 +325,8 @@ describe("Bus Session routing", () => {
         { publish: true },
       )
       const done = yield* bus.publish(Done, {})
-      expect(Array.from(yield* Fiber.join(first))).toEqual([done])
-      const received = Array.from(yield* Fiber.join(second))
+      expect(yield* Fiber.join(first)).toEqual([done])
+      const received = yield* Fiber.join(second)
       expect(received.map((event) => event.id)).toEqual([after.id, replayID, done.id])
       expect(received[1]).not.toHaveProperty("location")
     }),

packages/core/test/bus.test.ts

@@ -123,7 +123,7 @@ describe("Bus", () => {
       yield* bus.publish(Message, { text: "hello" })
       yield* bus.publish(CountMessage, { count: 2 })
 
-      const received = Array.from(yield* Fiber.join(fiber)).map((event) =>
+      const received = (yield* Fiber.join(fiber)).map((event) =>
         event.type === "test.message" ? event.data.text : event.data.count,
       )
       expect(received).toEqual(["hello", 2])
@@ -136,7 +136,7 @@ describe("Bus", () => {
       const fiber = yield* bus.subscribe(Message).pipe(Stream.take(1), Stream.runCollect, Effect.forkScoped)
       yield* Effect.yieldNow
       const event = yield* bus.publish(Message, { text: "hello" })
-      const received = Array.from(yield* Fiber.join(fiber))
+      const received = yield* Fiber.join(fiber)
 
       expect(received).toEqual([event])
       expect(event.type).toBe("test.message")
@@ -212,8 +212,8 @@ describe("Bus", () => {
       yield* Effect.yieldNow
       const event = yield* bus.publish(Message, { text: "hello" })
 
-      expect(Array.from(yield* Fiber.join(typed))).toEqual([event])
-      expect(Array.from(yield* Fiber.join(wildcard))).toEqual([event])
+      expect(yield* Fiber.join(typed)).toEqual([event])
+      expect(yield* Fiber.join(wildcard)).toEqual([event])
     }),
   )
 
@@ -602,7 +602,7 @@ describe("Bus", () => {
 
       yield* bus.publish(DurableMessage, durableData(aggregateID, "two"))
 
-      expect(Array.from(yield* Fiber.join(fiber)).map((event) => [event.durable?.seq, event.data])).toEqual([
+      expect((yield* Fiber.join(fiber)).map((event) => [event.durable?.seq, event.data])).toEqual([
         [1, durableData(aggregateID, "one")],
         [2, durableData(aggregateID, "two")],
       ])
@@ -618,7 +618,7 @@ describe("Bus", () => {
 
       yield* bus.publish(DurableMessage, durableData(aggregateID, "one"))
 
-      expect(Array.from(yield* Fiber.join(fiber)).map((event) => [event.durable?.seq, event.data])).toEqual([
+      expect((yield* Fiber.join(fiber)).map((event) => [event.durable?.seq, event.data])).toEqual([
         [0, durableData(aggregateID, "zero")],
         [1, durableData(aggregateID, "one")],
       ])
@@ -653,7 +653,7 @@ describe("Bus", () => {
         yield* bus.publish(DurableMessage, durableData(aggregateID, "during handoff"))
         yield* Deferred.succeed(continueRead, undefined)
 
-        expect(Array.from(yield* Fiber.join(fiber)).map((event) => [event.durable?.seq, event.data])).toEqual([
+        expect((yield* Fiber.join(fiber)).map((event) => [event.durable?.seq, event.data])).toEqual([
           [0, durableData(aggregateID, "during handoff")],
         ])
       }).pipe(Effect.provide(eventLayer))
@@ -672,7 +672,7 @@ describe("Bus", () => {
         yield* bus.publish(DurableMessage, durableData(aggregateID, String(index)))
       }
 
-      expect(Array.from(yield* Fiber.join(fiber)).map((event) => [event.durable?.seq, event.data])).toEqual(
+      expect((yield* Fiber.join(fiber)).map((event) => [event.durable?.seq, event.data])).toEqual(
         Array.from({ length: count }, (_, index) => [index, durableData(aggregateID, String(index))]),
       )
     }),
@@ -688,7 +688,7 @@ describe("Bus", () => {
       yield* bus.publish(Message, { text: "live only" })
       yield* bus.publish(DurableMessage, durableData(aggregateID, "durable"))
 
-      expect(Array.from(yield* Fiber.join(fiber)).map((event) => event.type)).toEqual([DurableMessage.type])
+      expect((yield* Fiber.join(fiber)).map((event) => event.type)).toEqual([DurableMessage.type])
     }),
   )
 
@@ -1268,7 +1268,7 @@ describe("Bus", () => {
       yield* bus.publish(DurableMessage, durableData(aggregateID, "zero"))
       yield* bus.publish(DurableMessage, durableData(aggregateID, "one"))
 
-      const items = Array.from(yield* Stream.runCollect(bus.log({ aggregateID })))
+      const items = yield* Stream.runCollect(bus.log({ aggregateID }))
 
       expect(items.map((item) => (Bus.isSynced(item) ? item.type : item.durable?.seq))).toEqual([
         Event.Seq.make(0),
@@ -1284,9 +1284,9 @@ describe("Bus", () => {
       const bus = yield* Bus.Service
       const aggregateID = Session.ID.create()
 
-      const empty = Array.from(yield* Stream.runCollect(bus.log({ aggregateID })))
+      const empty = yield* Stream.runCollect(bus.log({ aggregateID }))
       yield* bus.publish(DurableMessage, durableData(aggregateID, "zero"))
-      const drained = Array.from(yield* Stream.runCollect(bus.log({ aggregateID, after: 0 })))
+      const drained = yield* Stream.runCollect(bus.log({ aggregateID, after: 0 }))
 
       expect(empty).toEqual([{ type: "log.synced", aggregateID }])
       expect(empty[0]).not.toHaveProperty("seq")
@@ -1306,7 +1306,7 @@ describe("Bus", () => {
 
       yield* bus.publish(DurableMessage, durableData(aggregateID, "one"))
 
-      const items = Array.from(yield* Fiber.join(fiber))
+      const items = yield* Fiber.join(fiber)
       expect(items.map((item) => (Bus.isSynced(item) ? item : item.durable?.seq))).toEqual([
         Event.Seq.make(0),
         { type: "log.synced", aggregateID, seq: Event.Seq.make(0) },
@@ -1330,7 +1330,7 @@ describe("Bus", () => {
         yield* bus.publish(DurableMessage, durableData(aggregateID, "three"))
         yield* bus.publish(DurableMessage, durableData(aggregateID, "four"))
 
-        const items = Array.from(yield* Stream.runCollect(bus.log({ aggregateID })))
+        const items = yield* Stream.runCollect(bus.log({ aggregateID }))
 
         expect(items.map((item) => (Bus.isSynced(item) ? item.type : item.durable?.seq))).toEqual([
           Event.Seq.make(0),
@@ -1378,7 +1378,7 @@ describe("Bus", () => {
         yield* bus.publish(DurableMessage, durableData(aggregateID, "one"))
         yield* Deferred.succeed(releaseRead, undefined)
 
-        const items = Array.from(yield* Fiber.join(fiber))
+        const items = yield* Fiber.join(fiber)
         expect(items.map((item) => (Bus.isSynced(item) ? item : item.durable?.seq))).toEqual([
           Event.Seq.make(0),
           { type: "log.synced", aggregateID, seq: Event.Seq.make(0) },

packages/core/test/config/file.test.ts

@@ -1,411 +0,0 @@
-import path from "path"
-import { describe, expect } from "bun:test"
-import { Effect } from "effect"
-import { parse } from "jsonc-parser"
-import { isRecord } from "@opencode-ai/ai/utils/record"
-import { ConfigFile } from "@opencode-ai/core/config/file"
-import { FSUtil } from "@opencode-ai/util/fs-util"
-import { LayerNode } from "@opencode-ai/util/effect/layer-node"
-import { withTempDir } from "../fixture/tmpdir"
-import { testEffect } from "../lib/effect"
-
-// No Config, Location, Watcher, Credential, or WellKnown services are provided.
-const it = testEffect(LayerNode.compile(FSUtil.node))
-
-describe("ConfigFile", () => {
-  it.live("edits the explicit target and preserves comments and unrelated fields", () =>
-    withTempDir((tmp) =>
-      Effect.gen(function* () {
-        const fs = yield* FSUtil.Service
-        const global = path.join(tmp.path, "global", "opencode.jsonc")
-        const target = path.join(tmp.path, "project", "custom.jsonc")
-        const text = '{\n  // Keep this comment.\n  "shell": "project",\n  "custom": { "value": 1 },\n}\n'
-        yield* fs.writeWithDirs(global, '{ "shell": "global" }')
-        yield* fs.writeWithDirs(target, text)
-
-        const updated = yield* ConfigFile.update(target, (draft) => {
-          draft.shell = "updated"
-        })
-
-        expect(updated).toEqual({ shell: "updated", custom: { value: 1 } })
-        expect(yield* fs.readFileString(target)).toBe(text.replace('"project"', '"updated"'))
-        expect(yield* fs.readFileString(global)).toBe('{ "shell": "global" }')
-      }),
-    ),
-  )
-
-  it.live("leaves raw substitutions, model shorthand, and legacy shapes unresolved", () =>
-    withTempDir((tmp) =>
-      Effect.gen(function* () {
-        const fs = yield* FSUtil.Service
-        const target = path.join(tmp.path, "opencode.jsonc")
-        const text = `{
-  "model": "{env:OPENCODE_TEST_CONFIG_MODEL}",
-  "shell": "{file:missing-shell.txt}",
-  "skills": { "paths": ["./skills"] },
-  "agent": { "review": { "model": "acme/reasoner" } },
-  "username": "before"
-}
-`
-        yield* fs.writeFileString(target, text)
-        yield* ConfigFile.update(target, (draft) => {
-          expect(draft.model).toBe("{env:OPENCODE_TEST_CONFIG_MODEL}")
-          expect(draft.shell).toBe("{file:missing-shell.txt}")
-          expect(draft.skills).toEqual({ paths: ["./skills"] })
-          draft.username = "after"
-        })
-
-        expect(yield* fs.readFileString(target)).toBe(text.replace('"before"', '"after"'))
-      }),
-    ),
-  )
-
-  it.live("patches nested source fields and deletes legacy keys without migrating them", () =>
-    withTempDir((tmp) =>
-      Effect.gen(function* () {
-        const fs = yield* FSUtil.Service
-        const target = path.join(tmp.path, "opencode.jsonc")
-        yield* fs.writeFileString(
-          target,
-          `{
-  "agent": {
-    "review": { "description": "before", "hidden": true },
-    // Keep the other definition.
-    "build": { "description": "unchanged" }
-  },
-  "snapshot": true
-}
-`,
-        )
-        const updated = yield* ConfigFile.update(target, (draft) => {
-          const agent: unknown = draft.agent
-          if (!isRecord(agent) || !isRecord(agent.review)) throw new Error("Missing fixture agent")
-          agent.review.description = "after"
-          agent.review.color = "blue"
-          delete agent.review.hidden
-          delete draft.snapshot
-        })
-
-        expect(updated).toEqual({
-          agent: { review: { description: "after", color: "blue" }, build: { description: "unchanged" } },
-        })
-        expect(parse(yield* fs.readFileString(target))).toEqual(updated)
-        expect(yield* fs.readFileString(target)).toContain("// Keep the other definition.")
-      }),
-    ),
-  )
-
-  it.live("patches array elements without rewriting untouched comments", () =>
-    withTempDir((tmp) =>
-      Effect.gen(function* () {
-        const fs = yield* FSUtil.Service
-        const target = path.join(tmp.path, "opencode.jsonc")
-        const text = `{
-  "plugins": [
-    // Keep the first plugin.
-    "first",
-    "second",
-    // Keep the third plugin.
-    "third",
-    "fourth"
-  ]
-}
-`
-        yield* fs.writeFileString(target, text)
-        yield* ConfigFile.update(target, (draft) => {
-          if (!Array.isArray(draft.plugins)) throw new Error("Missing fixture plugins")
-          draft.plugins[1] = "updated"
-        })
-        expect(yield* fs.readFileString(target)).toBe(text.replace('"second"', '"updated"'))
-
-        const shortened = yield* ConfigFile.update(target, (draft) => {
-          if (!Array.isArray(draft.plugins)) throw new Error("Missing fixture plugins")
-          draft.plugins.splice(1, 3)
-        })
-        expect(shortened.plugins).toEqual(["first"])
-        expect(parse(yield* fs.readFileString(target))).toEqual(shortened)
-
-        const extended = yield* ConfigFile.update(target, (draft) => {
-          if (!Array.isArray(draft.plugins)) throw new Error("Missing fixture plugins")
-          draft.plugins.push("added", "last")
-        })
-        expect(extended.plugins).toEqual(["first", "added", "last"])
-        expect(parse(yield* fs.readFileString(target))).toEqual(extended)
-        expect(yield* fs.readFileString(target)).toContain("// Keep the first plugin.")
-      }),
-    ),
-  )
-
-  it.live("preserves adjacent comments when deleting properties and array elements", () =>
-    withTempDir((tmp) =>
-      Effect.gen(function* () {
-        const fs = yield* FSUtil.Service
-        const target = path.join(tmp.path, "opencode.jsonc")
-        yield* fs.writeFileString(
-          target,
-          `{
-  "shell": "remove",
-  // Keep the model explanation.
-  "model": "acme/reasoner",
-  "plugins": ["first", "second", /* Keep the plugin explanation. */ "third"],
-  "skills": [/* Keep the source explanation. */ "remove",],
-}
-`,
-        )
-        const updated = yield* ConfigFile.update(target, (draft) => {
-          delete draft.shell
-          if (!Array.isArray(draft.plugins)) throw new Error("Missing fixture plugins")
-          draft.plugins.splice(1, 1)
-          draft.skills = []
-        })
-
-        expect(parse(yield* fs.readFileString(target))).toEqual(updated)
-        expect(updated).toEqual({ model: "acme/reasoner", plugins: ["first", "third"], skills: [] })
-        expect(yield* fs.readFileString(target)).toContain("// Keep the model explanation.")
-        expect(yield* fs.readFileString(target)).toContain("/* Keep the plugin explanation. */")
-        expect(yield* fs.readFileString(target)).toContain("/* Keep the source explanation. */")
-      }),
-    ),
-  )
-
-  it.live("deletes own JSON keys that also exist on Object.prototype", () =>
-    withTempDir((tmp) =>
-      Effect.gen(function* () {
-        const fs = yield* FSUtil.Service
-        const target = path.join(tmp.path, "opencode.json")
-        yield* fs.writeFileString(
-          target,
-          '{ "\\u005f_proto__": "remove", "constructor": "remove", "toString": "remove", "shell": "keep" }',
-        )
-        const updated = yield* ConfigFile.update(target, (draft) => {
-          ;["__proto__", "constructor", "toString"].forEach((key) => {
-            delete draft[key]
-          })
-        })
-
-        expect(updated).toEqual({ shell: "keep" })
-        expect(yield* fs.readJson(target)).toEqual(updated)
-      }),
-    ),
-  )
-
-  it.live("preserves and edits object-valued __proto__ source keys", () =>
-    withTempDir((tmp) =>
-      Effect.gen(function* () {
-        const fs = yield* FSUtil.Service
-        const target = path.join(tmp.path, "opencode.json")
-        yield* fs.writeFileString(target, '{ "__proto__": { "value": "before" }, "shell": "keep" }')
-        const updated = yield* ConfigFile.update(target, (draft) => {
-          expect(Object.hasOwn(draft, "__proto__")).toBe(true)
-          const entry: unknown = draft["__proto__"]
-          if (!isRecord(entry)) throw new Error("Missing fixture entry")
-          entry.value = "after"
-        })
-
-        expect(updated).toEqual({ ["__proto__"]: { value: "after" }, shell: "keep" })
-        expect(yield* fs.readJson(target)).toEqual(updated)
-        expect(Object.getPrototypeOf(updated)).toBe(Object.prototype)
-      }),
-    ),
-  )
-
-  it.live("rejects a duplicate-key patch that would not change the effective value", () =>
-    withTempDir((tmp) =>
-      Effect.gen(function* () {
-        const fs = yield* FSUtil.Service
-        const target = path.join(tmp.path, "opencode.json")
-        const text = '{ "shell": "first", "shell": "second" }'
-        yield* fs.writeFileString(target, text)
-        const error = yield* ConfigFile.update(target, (draft) => {
-          draft.shell = "after"
-        }).pipe(Effect.flip)
-
-        expect(error).toBeInstanceOf(ConfigFile.UpdateError)
-        expect(error.message).toBe(`Config patch does not match the requested update: ${target}`)
-        expect(yield* fs.readFileString(target)).toBe(text)
-        expect(yield* fs.exists(target + ".tmp")).toBe(false)
-      }),
-    ),
-  )
-
-  it.live("rereads the selected file for consecutive edits without a watcher", () =>
-    withTempDir((tmp) =>
-      Effect.gen(function* () {
-        const fs = yield* FSUtil.Service
-        const target = path.join(tmp.path, "opencode.json")
-        yield* fs.writeFileString(target, '{ "shell": "first" }')
-        yield* ConfigFile.update(target, (draft) => {
-          draft.shell = "second"
-        })
-        yield* ConfigFile.update(target, (draft) => {
-          expect(draft.shell).toBe("second")
-          draft.username = "added"
-        })
-        expect(yield* fs.readJson(target)).toEqual({ shell: "second", username: "added" })
-
-        yield* fs.writeFileString(target, '{ "shell": "external", "username": "added" }')
-        const updated = yield* ConfigFile.update(target, (draft) => {
-          expect(draft.shell).toBe("external")
-          draft.snapshots = false
-        })
-        expect(yield* fs.readJson(target)).toEqual(updated)
-        expect(updated).toEqual({ shell: "external", username: "added", snapshots: false })
-      }),
-    ),
-  )
-
-  it.live("serializes concurrent read-modify-write calls", () =>
-    withTempDir((tmp) =>
-      Effect.gen(function* () {
-        const fs = yield* FSUtil.Service
-        const target = path.join(tmp.path, "opencode.json")
-        yield* fs.writeFileString(target, '{ "count": 0 }')
-        const increment = ConfigFile.update(target, (draft) => {
-          if (typeof draft.count !== "number") throw new Error("Missing fixture count")
-          draft.count++
-        })
-        yield* Effect.all([increment, increment, increment], { concurrency: "unbounded" })
-
-        expect(yield* fs.readJson(target)).toEqual({ count: 3 })
-      }),
-    ),
-  )
-
-  it.live("does not rewrite no-op or structurally equal edits", () =>
-    withTempDir((tmp) =>
-      Effect.gen(function* () {
-        const fs = yield* FSUtil.Service
-        const target = path.join(tmp.path, "opencode.json")
-        const text = '{\r\n  "plugins": ["first"]\r\n}'
-        yield* fs.writeFileString(target, text)
-        const before = yield* fs.stat(target)
-        yield* ConfigFile.update(target, () => {})
-        yield* ConfigFile.update(target, (draft) => {
-          draft.plugins = ["first"]
-        })
-
-        expect(yield* fs.readFileString(target)).toBe(text)
-        expect((yield* fs.stat(target)).ino).toEqual(before.ino)
-        expect((yield* fs.stat(target)).mtime).toEqual(before.mtime)
-        expect(yield* fs.exists(target + ".tmp")).toBe(false)
-      }),
-    ),
-  )
-
-  it.live("leaves the file unchanged when a callback throws and permits a later edit", () =>
-    withTempDir((tmp) =>
-      Effect.gen(function* () {
-        const fs = yield* FSUtil.Service
-        const target = path.join(tmp.path, "opencode.json")
-        const text = '{ "shell": "before" }'
-        yield* fs.writeFileString(target, text)
-        const cause = new Error("Rejected config update")
-        const error = yield* ConfigFile.update(target, (draft) => {
-          draft.shell = "discarded"
-          throw cause
-        }).pipe(Effect.flip)
-
-        expect(error).toBeInstanceOf(ConfigFile.UpdateError)
-        expect(error.message).toBe("Config update failed")
-        expect(error.cause).toBe(cause)
-        expect(yield* fs.readFileString(target)).toBe(text)
-        expect(yield* fs.exists(target + ".tmp")).toBe(false)
-
-        yield* ConfigFile.update(target, (draft) => {
-          draft.shell = "recovered"
-        })
-        expect(yield* fs.readJson(target)).toEqual({ shell: "recovered" })
-      }),
-    ),
-  )
-
-  it.live("ignores callback return values instead of replacing the document", () =>
-    withTempDir((tmp) =>
-      Effect.gen(function* () {
-        const fs = yield* FSUtil.Service
-        const target = path.join(tmp.path, "opencode.json")
-        yield* fs.writeFileString(target, "{}")
-
-        expect(yield* ConfigFile.update(target, () => new Date(0))).toEqual({})
-        expect(yield* fs.readFileString(target)).toBe("{}")
-
-        const updated = yield* ConfigFile.update(target, (draft) => (draft.shell = "updated"))
-        expect(updated).toEqual({ shell: "updated" })
-        expect(yield* fs.readJson(target)).toEqual(updated)
-      }),
-    ),
-  )
-
-  it.live("rejects non-JSON mutations before writing", () =>
-    withTempDir((tmp) =>
-      Effect.gen(function* () {
-        const fs = yield* FSUtil.Service
-        const target = path.join(tmp.path, "opencode.json")
-        const text = '{ "shell": "before" }'
-        yield* fs.writeFileString(target, text)
-        const error = yield* ConfigFile.update(target, (draft) => {
-          draft.invalid = Number.NaN
-        }).pipe(Effect.flip)
-
-        expect(error).toBeInstanceOf(ConfigFile.UpdateError)
-        expect(error.message).toBe(`Config update must produce a JSON object: ${target}`)
-        expect(yield* fs.readFileString(target)).toBe(text)
-        expect(yield* fs.exists(target + ".tmp")).toBe(false)
-      }),
-    ),
-  )
-  ;["", "{", "[]", "null"].forEach((text) => {
-    it.live(`rejects invalid or non-object source ${JSON.stringify(text)}`, () =>
-      withTempDir((tmp) =>
-        Effect.gen(function* () {
-          const fs = yield* FSUtil.Service
-          const target = path.join(tmp.path, "opencode.json")
-          yield* fs.writeFileString(target, text)
-          const error = yield* ConfigFile.update(target, () => {
-            throw new Error("Callback must not run")
-          }).pipe(Effect.flip)
-
-          expect(error).toBeInstanceOf(ConfigFile.UpdateError)
-          expect(error.message).toBe(`Invalid config file: ${target}`)
-          expect(yield* fs.readFileString(target)).toBe(text)
-          expect(yield* fs.exists(target + ".tmp")).toBe(false)
-        }),
-      ),
-    )
-  })
-
-  it.live("reports a missing target without creating it", () =>
-    withTempDir((tmp) =>
-      Effect.gen(function* () {
-        const fs = yield* FSUtil.Service
-        const target = path.join(tmp.path, "missing.json")
-        const error = yield* ConfigFile.update(target, () => {}).pipe(Effect.flip)
-
-        expect(error).toBeInstanceOf(ConfigFile.UpdateError)
-        expect(error.message).toBe(`Failed to read config: ${target}`)
-        expect(error.cause).toBeDefined()
-        expect(yield* fs.exists(target)).toBe(false)
-      }),
-    ),
-  )
-
-  it.live("reports write failures without replacing the target", () =>
-    withTempDir((tmp) =>
-      Effect.gen(function* () {
-        const fs = yield* FSUtil.Service
-        const target = path.join(tmp.path, "opencode.json")
-        const text = '{ "shell": "before" }'
-        yield* fs.writeFileString(target, text)
-        yield* fs.makeDirectory(target + ".tmp")
-        const error = yield* ConfigFile.update(target, (draft) => {
-          draft.shell = "discarded"
-        }).pipe(Effect.flip)
-
-        expect(error).toBeInstanceOf(ConfigFile.UpdateError)
-        expect(error.message).toBe(`Failed to write config: ${target}`)
-        expect(error.cause).toBeDefined()
-        expect(yield* fs.readFileString(target)).toBe(text)
-      }),
-    ),
-  )
-})

packages/core/test/config/provider.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect } from "bun:test"
 import { Money } from "@opencode-ai/schema/money"
 import { Document, Info, type Entry } from "@opencode-ai/schema/config"
-import { Effect, Schema, Stream } from "effect"
+import { Effect, Schema } from "effect"
 import { Catalog } from "@opencode-ai/core/catalog"
 import { Config } from "@opencode-ai/core/config"
 import { ConfigProviderPlugin } from "@opencode-ai/core/config/plugin/provider"
@@ -12,6 +12,7 @@ import { ModelResolver } from "@opencode-ai/core/model-resolver"
 import { Plugin } from "@opencode-ai/core/plugin"
 import { PluginHost } from "@opencode-ai/core/plugin/host"
 import { Provider } from "@opencode-ai/core/provider"
+import { withEnv } from "../fixture/env"
 import { testEffect } from "../lib/effect"
 import { PluginTestLayer } from "../plugin/fixture"
 
@@ -28,27 +29,6 @@ function required<T>(value: T | undefined): T {
   return value
 }
 
-function withEnv<A, E, R>(vars: Record<string, string | undefined>, effect: () => Effect.Effect<A, E, R>) {
-  return Effect.acquireUseRelease(
-    Effect.sync(() => {
-      const previous = Object.fromEntries(Object.keys(vars).map((key) => [key, process.env[key]]))
-      Object.entries(vars).forEach(([key, value]) => {
-        if (value === undefined) delete process.env[key]
-        else process.env[key] = value
-      })
-      return previous
-    }),
-    effect,
-    (previous) =>
-      Effect.sync(() =>
-        Object.entries(previous).forEach(([key, value]) => {
-          if (value === undefined) delete process.env[key]
-          else process.env[key] = value
-        }),
-      ),
-  )
-}
-
 const decode = Schema.decodeUnknownSync(Info)
 
 describe("ConfigProviderPlugin.Plugin", () => {

packages/core/test/config/reload.test.ts

@@ -34,6 +34,41 @@ const decode = Schema.decodeUnknownSync(Info)
 const document = path.join(import.meta.dir, "opencode.json")
 
 describe("config plugin reloads", () => {
+  it.effect("preserves reference precedence and insertion order across documents", () =>
+    Effect.gen(function* () {
+      const plugins = yield* Plugin.Service
+      const references = yield* Reference.Service
+      const host = yield* PluginHost.make(plugins)
+      yield* references.transform((draft) =>
+        draft.add(
+          "external",
+          Reference.LocalSource.make({ type: "local", path: AbsolutePath.make("/references/external") }),
+        ),
+      )
+      yield* ConfigReferencePlugin.Plugin.effect(host)
+
+      const result = yield* references.list()
+      expect(result.map((reference) => reference.name)).toEqual(["external", "shared", "first", "second"])
+      expect(result.find((reference) => reference.name === "shared")?.path).toBe(
+        AbsolutePath.make(path.resolve("/config/second/shared")),
+      )
+    }).pipe(
+      Effect.provide(
+        Config.testLayer([
+          referenceConfig("/config/first/opencode.json", {
+            shared: "./shared",
+            first: "./first",
+          }),
+          referenceConfig("/config/second/opencode.json", {
+            shared: "./shared",
+            second: "./second",
+          }),
+        ]),
+      ),
+      Effect.provideService(Global.Service, Global.Service.of(Global.make())),
+    ),
+  )
+
   it.live("reloads config-backed domains without reloading external plugins", () =>
     Effect.gen(function* () {
       const agents = yield* Agent.Service
@@ -102,6 +137,14 @@ function config(name: string) {
   })
 }
 
+function referenceConfig(file: string, references: Record<string, string>) {
+  return new Document({
+    type: "document",
+    path: AbsolutePath.make(file),
+    info: decode({ references }),
+  })
+}
+
 function title(value: string) {
   return value.charAt(0).toUpperCase() + value.slice(1)
 }

packages/core/test/effect/cross-spawn-spawner.test.ts

@@ -16,18 +16,7 @@ function js(code: string, opts?: ChildProcess.CommandOptions) {
 }
 
 function decodeByteStream(stream: Stream.Stream<Uint8Array, PlatformError.PlatformError>) {
-  return Stream.runCollect(stream).pipe(
-    Effect.map((chunks) => {
-      const total = chunks.reduce((acc, x) => acc + x.length, 0)
-      const out = new Uint8Array(total)
-      let off = 0
-      for (const chunk of chunks) {
-        out.set(chunk, off)
-        off += chunk.length
-      }
-      return new TextDecoder("utf-8").decode(out).trim()
-    }),
-  )
+  return Stream.mkUint8Array(stream).pipe(Effect.map((bytes) => new TextDecoder("utf-8").decode(bytes).trim()))
 }
 
 function alive(pid: number) {

packages/core/test/fixture/env.ts

@@ -0,0 +1,22 @@
+import { Effect } from "effect"
+
+export function withEnv<A, E, R>(variables: Record<string, string | undefined>, effect: () => Effect.Effect<A, E, R>) {
+  return Effect.acquireUseRelease(
+    Effect.sync(() => {
+      const previous = Object.fromEntries(Object.keys(variables).map((key) => [key, process.env[key]]))
+      Object.entries(variables).forEach(([key, value]) => {
+        if (value === undefined) delete process.env[key]
+        else process.env[key] = value
+      })
+      return previous
+    }),
+    effect,
+    (previous) =>
+      Effect.sync(() => {
+        Object.entries(previous).forEach(([key, value]) => {
+          if (value === undefined) delete process.env[key]
+          else process.env[key] = value
+        })
+      }),
+  )
+}

packages/core/test/fixture/git.ts

@@ -1,9 +1,12 @@
+import { $ } from "bun"
 import { execFile } from "child_process"
 import fs from "fs/promises"
 import path from "path"
 import { promisify } from "util"
 import { pathToFileURL } from "url"
 import { Repository } from "@opencode-ai/core/repository"
+import { Effect } from "effect"
+import { tmpdir } from "./tmpdir"
 
 const exec = promisify(execFile)
 
@@ -29,6 +32,30 @@ export async function gitRemote(root: string) {
   }
 }
 
+export function withRemote<A, E, R>(body: (fixture: Awaited<ReturnType<typeof gitRemote>>) => Effect.Effect<A, E, R>) {
+  return Effect.acquireUseRelease(
+    Effect.promise(async () => {
+      const root = await tmpdir()
+      return { root, fixture: await gitRemote(root.path) }
+    }),
+    (input) => body(input.fixture),
+    (input) => Effect.promise(() => input.root[Symbol.asyncDispose]()),
+  )
+}
+
+export function read(file: string) {
+  return Effect.promise(() => fs.readFile(file, "utf8")).pipe(Effect.map((content) => content.replace(/\r\n/g, "\n")))
+}
+
+export async function initRepo(directory: string) {
+  await $`git init`.cwd(directory).quiet()
+  await $`git config core.fsmonitor false`.cwd(directory).quiet()
+  await $`git config commit.gpgsign false`.cwd(directory).quiet()
+  await $`git config user.email test@opencode.test`.cwd(directory).quiet()
+  await $`git config user.name Test`.cwd(directory).quiet()
+  await $`git commit --allow-empty -m root`.cwd(directory).quiet()
+}
+
 export async function commit(source: string, content: string, message: string) {
   await fs.writeFile(path.join(source, "README.md"), content)
   await git(source, "add", "README.md")

packages/core/test/fixture/lock-worker.ts

@@ -0,0 +1,53 @@
+import { spawn } from "child_process"
+import path from "path"
+
+const root = path.join(import.meta.dir, "../..")
+
+export function runLockWorker(entrypoint: string, payload: unknown) {
+  return new Promise<{ code: number; stdout: Buffer; stderr: Buffer }>((resolve) => {
+    const proc = spawn(process.execPath, [entrypoint, JSON.stringify(payload)], { cwd: root })
+    const stdout: Buffer[] = []
+    const stderr: Buffer[] = []
+    proc.stdout?.on("data", (data) => stdout.push(Buffer.from(data)))
+    proc.stderr?.on("data", (data) => stderr.push(Buffer.from(data)))
+    proc.on("close", (code) => {
+      resolve({ code: code ?? 1, stdout: Buffer.concat(stdout), stderr: Buffer.concat(stderr) })
+    })
+  })
+}
+
+export function spawnLockWorker(entrypoint: string, payload: unknown) {
+  return spawn(process.execPath, [entrypoint, JSON.stringify(payload)], {
+    cwd: root,
+    stdio: ["ignore", "pipe", "pipe"],
+  })
+}
+
+export async function stopLockWorker(proc: ReturnType<typeof spawnLockWorker>) {
+  if (proc.exitCode !== null || proc.signalCode !== null) return
+
+  const closed = new Promise<void>((resolve) => proc.once("close", () => resolve()))
+  if (process.platform !== "win32" || !proc.pid) {
+    proc.kill()
+    await closed
+    return
+  }
+
+  await new Promise<void>((resolve) => {
+    const killProc = spawn("taskkill", ["/pid", String(proc.pid), "/T", "/F"])
+    killProc.on("close", () => {
+      proc.kill()
+      resolve()
+    })
+  })
+  await closed
+}
+
+export async function waitForFile(file: string, timeout = 3_000) {
+  const stop = Date.now() + timeout
+  while (Date.now() < stop) {
+    if (await Bun.file(file).exists()) return
+    await Bun.sleep(20)
+  }
+  throw new Error(`Timed out waiting for file: ${file}`)
+}

packages/core/test/fixture/mcp-prompts.ts

@@ -0,0 +1,30 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js"
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
+import { GetPromptRequestSchema, ListPromptsRequestSchema } from "@modelcontextprotocol/sdk/types.js"
+
+const server = new Server({ name: "prompts", version: "1.0.0" }, { capabilities: { prompts: {} } })
+
+server.setRequestHandler(ListPromptsRequestSchema, ({ params }) =>
+  Promise.resolve(
+    params?.cursor === "page-2"
+      ? { prompts: [{ name: "second", description: "Second prompt" }] }
+      : {
+          prompts: [
+            {
+              name: "first",
+              description: "First prompt",
+              arguments: [{ name: "topic", description: "Topic to explain", required: true }],
+            },
+          ],
+          nextCursor: "page-2",
+        },
+  ),
+)
+
+server.setRequestHandler(GetPromptRequestSchema, ({ params }) =>
+  Promise.resolve({
+    messages: [{ role: "user", content: { type: "text", text: params.arguments?.topic ?? "missing" } }],
+  }),
+)
+
+await server.connect(new StdioServerTransport())

packages/core/test/git.test.ts

@@ -6,7 +6,7 @@ import { Effect } from "effect"
 import { LayerNode } from "@opencode-ai/util/effect/layer-node"
 import { Git } from "@opencode-ai/core/git"
 import { AbsolutePath, RelativePath } from "@opencode-ai/core/schema"
-import { branch, commit, gitRemote } from "./fixture/git"
+import { branch, commit, initRepo, read, withRemote } from "./fixture/git"
 import { tmpdir } from "./fixture/tmpdir"
 import { testEffect } from "./lib/effect"
 
@@ -75,30 +75,6 @@ describe("Git", () => {
   )
 })
 
-function withRemote<A, E, R>(body: (fixture: Awaited<ReturnType<typeof gitRemote>>) => Effect.Effect<A, E, R>) {
-  return Effect.acquireUseRelease(
-    Effect.promise(async () => {
-      const root = await tmpdir()
-      return { root, fixture: await gitRemote(root.path) }
-    }),
-    (input) => body(input.fixture),
-    (input) => Effect.promise(() => input.root[Symbol.asyncDispose]()),
-  )
-}
-
-function read(file: string) {
-  return Effect.promise(() => fs.readFile(file, "utf8")).pipe(Effect.map((content) => content.replace(/\r\n/g, "\n")))
-}
-
-async function initRepo(directory: string) {
-  await $`git init`.cwd(directory).quiet()
-  await $`git config core.fsmonitor false`.cwd(directory).quiet()
-  await $`git config commit.gpgsign false`.cwd(directory).quiet()
-  await $`git config user.email test@opencode.test`.cwd(directory).quiet()
-  await $`git config user.name Test`.cwd(directory).quiet()
-  await $`git commit --allow-empty -m root`.cwd(directory).quiet()
-}
-
 describe("Git worktrees", () => {
   it.live("creates, lists, and removes linked worktrees", () =>
     Effect.gen(function* () {
@@ -109,9 +85,7 @@ describe("Git worktrees", () => {
       yield* Effect.promise(() => initRepo(root.path))
       const directory = AbsolutePath.make(yield* Effect.promise(() => fs.realpath(root.path)))
       const worktree = AbsolutePath.make(`${root.path}-git-worktree`)
-      yield* Effect.addFinalizer(() =>
-        Effect.promise(() => fs.rm(worktree, { recursive: true, force: true })).pipe(Effect.ignore),
-      )
+      yield* Effect.addFinalizer(() => Effect.promise(() => fs.rm(worktree, { recursive: true, force: true })))
       const git = yield* Git.Service
       const repo = yield* git.repo.discover(directory)
       if (!repo) throw new Error("Repository not found")

packages/core/test/github-copilot/convert-to-copilot-messages.test.ts

@@ -1,9 +1,9 @@
-import { convertToOpenAICompatibleChatMessages as convertToCopilotMessages } from "@opencode-ai/core/github-copilot/chat/convert-to-openai-compatible-chat-messages"
+import { convertToOpenAICompatibleChatMessages } from "@opencode-ai/core/github-copilot/chat/convert-to-openai-compatible-chat-messages"
 import { describe, test, expect } from "bun:test"
 
 describe("system messages", () => {
   test("should convert system message content to string", () => {
-    const result = convertToCopilotMessages([
+    const result = convertToOpenAICompatibleChatMessages([
       {
         role: "system",
         content: "You are a helpful assistant with AGENTS.md instructions.",
@@ -21,7 +21,7 @@ describe("system messages", () => {
 
 describe("user messages", () => {
   test("should convert messages with only a text part to a string content", () => {
-    const result = convertToCopilotMessages([
+    const result = convertToOpenAICompatibleChatMessages([
       {
         role: "user",
         content: [{ type: "text", text: "Hello" }],
@@ -32,7 +32,7 @@ describe("user messages", () => {
   })
 
   test("should convert messages with image parts", () => {
-    const result = convertToCopilotMessages([
+    const result = convertToOpenAICompatibleChatMessages([
       {
         role: "user",
         content: [
@@ -61,7 +61,7 @@ describe("user messages", () => {
   })
 
   test("should convert messages with image parts from Uint8Array", () => {
-    const result = convertToCopilotMessages([
+    const result = convertToOpenAICompatibleChatMessages([
       {
         role: "user",
         content: [
@@ -90,7 +90,7 @@ describe("user messages", () => {
   })
 
   test("should handle URL-based images", () => {
-    const result = convertToCopilotMessages([
+    const result = convertToOpenAICompatibleChatMessages([
       {
         role: "user",
         content: [
@@ -117,7 +117,7 @@ describe("user messages", () => {
   })
 
   test("should handle multiple text parts without flattening", () => {
-    const result = convertToCopilotMessages([
+    const result = convertToOpenAICompatibleChatMessages([
       {
         role: "user",
         content: [
@@ -141,7 +141,7 @@ describe("user messages", () => {
 
 describe("assistant messages", () => {
   test("should convert assistant text messages", () => {
-    const result = convertToCopilotMessages([
+    const result = convertToOpenAICompatibleChatMessages([
       {
         role: "assistant",
         content: [{ type: "text", text: "Hello back!" }],
@@ -160,7 +160,7 @@ describe("assistant messages", () => {
   })
 
   test("should handle assistant message with null content when only tool calls", () => {
-    const result = convertToCopilotMessages([
+    const result = convertToOpenAICompatibleChatMessages([
       {
         role: "assistant",
         content: [
@@ -195,7 +195,7 @@ describe("assistant messages", () => {
   })
 
   test("should concatenate multiple text parts", () => {
-    const result = convertToCopilotMessages([
+    const result = convertToOpenAICompatibleChatMessages([
       {
         role: "assistant",
         content: [
@@ -211,7 +211,7 @@ describe("assistant messages", () => {
 
 describe("tool calls", () => {
   test("should stringify arguments to tool calls", () => {
-    const result = convertToCopilotMessages([
+    const result = convertToOpenAICompatibleChatMessages([
       {
         role: "assistant",
         content: [
@@ -262,7 +262,7 @@ describe("tool calls", () => {
   })
 
   test("should handle text output type in tool results", () => {
-    const result = convertToCopilotMessages([
+    const result = convertToOpenAICompatibleChatMessages([
       {
         role: "tool",
         content: [
@@ -286,7 +286,7 @@ describe("tool calls", () => {
   })
 
   test("should handle multiple tool results as separate messages", () => {
-    const result = convertToCopilotMessages([
+    const result = convertToOpenAICompatibleChatMessages([
       {
         role: "tool",
         content: [
@@ -320,7 +320,7 @@ describe("tool calls", () => {
   })
 
   test("should handle text plus multiple tool calls", () => {
-    const result = convertToCopilotMessages([
+    const result = convertToOpenAICompatibleChatMessages([
       {
         role: "assistant",
         content: [
@@ -373,7 +373,7 @@ describe("tool calls", () => {
 
 describe("reasoning (copilot-specific)", () => {
   test("should omit reasoning_text without reasoning_opaque", () => {
-    const result = convertToCopilotMessages([
+    const result = convertToOpenAICompatibleChatMessages([
       {
         role: "assistant",
         content: [
@@ -395,7 +395,7 @@ describe("reasoning (copilot-specific)", () => {
   })
 
   test("should include reasoning_opaque from providerOptions", () => {
-    const result = convertToCopilotMessages([
+    const result = convertToOpenAICompatibleChatMessages([
       {
         role: "assistant",
         content: [
@@ -423,7 +423,7 @@ describe("reasoning (copilot-specific)", () => {
   })
 
   test("should include reasoning_opaque from text part providerOptions", () => {
-    const result = convertToCopilotMessages([
+    const result = convertToOpenAICompatibleChatMessages([
       {
         role: "assistant",
         content: [
@@ -450,7 +450,7 @@ describe("reasoning (copilot-specific)", () => {
   })
 
   test("should handle reasoning-only assistant message", () => {
-    const result = convertToCopilotMessages([
+    const result = convertToOpenAICompatibleChatMessages([
       {
         role: "assistant",
         content: [
@@ -479,7 +479,7 @@ describe("reasoning (copilot-specific)", () => {
 
 describe("full conversation", () => {
   test("should convert a multi-turn conversation with reasoning", () => {
-    const result = convertToCopilotMessages([
+    const result = convertToOpenAICompatibleChatMessages([
       {
         role: "system",
         content: "You are a helpful assistant.",

packages/core/test/integration.test.ts

@@ -186,7 +186,7 @@ describe("Integration", () => {
           value: Credential.Key.make({ type: "key", key: "secret", configuration: { accountId: "account" } }),
         }),
       ])
-      expect(Array.from(yield* Fiber.join(created), (event) => ({ type: event.type, data: event.data }))).toEqual([
+      expect((yield* Fiber.join(created)).map((event) => ({ type: event.type, data: event.data }))).toEqual([
         { type: Credential.Event.Updated.type, data: {} },
         { type: Credential.Event.Switched.type, data: { credentialID: stored[0]?.id, integrationID } },
       ])

packages/core/test/lib/environment-conformance.ts

@@ -49,6 +49,29 @@ export const environmentConformance = <E>(
       }),
     )
 
+    check("observes filesystem state when an operation executes", (harness) =>
+      Effect.gen(function* () {
+        const target = `${harness.root}/deferred.txt`
+        const source = `${harness.root}/source.txt`
+        const destination = `${harness.root}/destination.txt`
+        const read = harness.files.read(target)
+        const stat = harness.files.stat(target)
+        const list = harness.files.list(harness.root)
+        const move = harness.files.move(source, destination)
+
+        yield* harness.files.write(target, bytes("first"))
+        yield* harness.files.write(source, bytes("moved"))
+        expect(text((yield* read).bytes)).toBe("first")
+        expect((yield* stat).size).toBe(5)
+        expect(yield* list).toContainEqual({ name: "deferred.txt", type: "file" })
+        yield* move
+        expect(text((yield* harness.files.read(destination)).bytes)).toBe("moved")
+
+        yield* harness.files.write(target, bytes("second"))
+        expect(text((yield* read).bytes)).toBe("second")
+      }),
+    )
+
     check("reports missing paths", (harness) =>
       Effect.gen(function* () {
         const target = `${harness.root}/missing`

packages/core/test/location-layer.test.ts

@@ -42,7 +42,7 @@ import { SessionRunnerModel } from "@opencode-ai/core/session/runner/model"
 import { tmpdir } from "./fixture/tmpdir"
 import { tempGlobalLayer } from "./fixture/global"
 import { testEffect } from "./lib/effect"
-import { toolDefinitions, waitForTool } from "./lib/tool"
+import { toolDefinitions } from "./lib/tool"
 import { Database } from "../src/database/database"
 import { Bus } from "../src/bus"
 import { Reference } from "../src/reference"
@@ -701,25 +701,9 @@ describe("LocationServiceMap", () => {
               yield* Reference.Service
               const catalog = yield* Catalog.Service
               yield* catalog.transform((editor) => editor.provider.update(providerID, () => {}))
+              const supervisor = yield* PluginSupervisor.Service
+              yield* supervisor.flush
               const registry = yield* Tool.Service
-              // Tool plugins register during the forked PluginSupervisor boot; wait for
-              // every expected tool rather than relying on batch ordering.
-              yield* Effect.forEach(
-                [
-                  "edit",
-                  "glob",
-                  "grep",
-                  "question",
-                  "read",
-                  "shell",
-                  "skill",
-                  "subagent",
-                  "webfetch",
-                  "websearch",
-                  "write",
-                ],
-                (name) => waitForTool(registry, name),
-              )
               return {
                 providers: yield* catalog.provider.all(),
                 tools: yield* toolDefinitions(registry),

packages/core/test/mcp-oauth.test.ts

@@ -1,6 +1,7 @@
 import { afterAll, describe, expect, test } from "bun:test"
-import { refreshAuthorization } from "@modelcontextprotocol/sdk/client/auth.js"
+import { auth, refreshAuthorization } from "@modelcontextprotocol/sdk/client/auth.js"
 import { ConfigMCP } from "@opencode-ai/schema/config/mcp"
+import { Credential } from "@opencode-ai/schema/credential"
 import { Integration } from "@opencode-ai/core/integration"
 import { McpOAuth } from "@opencode-ai/core/mcp/oauth"
 import { Effect } from "effect"
@@ -27,6 +28,96 @@ const authorize = (redirect_uri?: string) =>
   )
 
 describe("MCP OAuth", () => {
+  test("completes interactive authorization through the loopback callback", async () => {
+    const tokenRequests: URLSearchParams[] = []
+    const server = Bun.serve({
+      port: 0,
+      async fetch(request) {
+        const url = new URL(request.url)
+        if (request.method !== "POST" || url.pathname !== "/token") return new Response(null, { status: 404 })
+        tokenRequests.push(new URLSearchParams(await request.text()))
+        return Response.json({
+          access_token: "access",
+          token_type: "Bearer",
+          refresh_token: "refresh",
+          expires_in: 3600,
+        })
+      },
+    })
+
+    const credential = await Effect.runPromise(
+      Effect.scoped(
+        Effect.gen(function* () {
+          const authorization = yield* McpOAuth.authorize({
+            name: "test",
+            config: new ConfigMCP.Remote({
+              type: "remote",
+              url: server.url.href,
+              oauth: { client_id: "client" },
+            }),
+            methodID: Integration.MethodID.make("oauth"),
+          })
+          const authorizationUrl = new URL(authorization.url)
+          const redirectValue = authorizationUrl.searchParams.get("redirect_uri")
+          const state = authorizationUrl.searchParams.get("state")
+          if (!redirectValue || !state) throw new Error("Missing OAuth redirect parameters")
+          const redirect = new URL(redirectValue)
+          redirect.searchParams.set("code", "accepted")
+          redirect.searchParams.set("state", state)
+          expect((yield* Effect.promise(() => fetch(redirect))).status).toBe(200)
+          return yield* authorization.callback
+        }),
+      ),
+    ).finally(() => server.stop(true))
+
+    expect(credential.access).toBe("access")
+    expect(credential.refresh).toBe("refresh")
+    expect(tokenRequests).toHaveLength(1)
+    expect(tokenRequests[0]?.get("grant_type")).toBe("authorization_code")
+    expect(tokenRequests[0]?.get("code")).toBe("accepted")
+    expect(tokenRequests[0]?.get("code_verifier")).not.toBeNull()
+  })
+
+  test("refreshes tokens loaded from a persisted credential", async () => {
+    const tokenRequests: URLSearchParams[] = []
+    const server = Bun.serve({
+      port: 0,
+      async fetch(request) {
+        const url = new URL(request.url)
+        if (request.method !== "POST" || url.pathname !== "/token") return new Response(null, { status: 404 })
+        tokenRequests.push(new URLSearchParams(await request.text()))
+        return Response.json({ access_token: "next", token_type: "Bearer" })
+      },
+    })
+    const store = McpOAuth.memoryStore()
+    await store.saveTokens(
+      McpOAuth.toTokens(
+        Credential.OAuth.make({
+          type: "oauth",
+          methodID: Integration.MethodID.make("oauth"),
+          access: "expired",
+          refresh: "refresh",
+          expires: Date.now() - 1000,
+          metadata: { serverUrl: server.url.href, tokenType: "Bearer" },
+        }),
+      ),
+    )
+    const oauthProvider = McpOAuth.provider({
+      redirectUrl: "http://127.0.0.1/callback",
+      client: { id: "client" },
+      onRedirect: () => undefined,
+      store,
+    })
+
+    const result = await auth(oauthProvider, { serverUrl: server.url.href }).finally(() => server.stop(true))
+
+    expect(result).toBe("AUTHORIZED")
+    expect(await store.tokens()).toEqual({ access_token: "next", token_type: "Bearer", refresh_token: "refresh" })
+    expect(tokenRequests).toHaveLength(1)
+    expect(tokenRequests[0]?.get("grant_type")).toBe("refresh_token")
+    expect(tokenRequests[0]?.get("refresh_token")).toBe("refresh")
+  })
+
   test("shares concurrent refreshes for the same token", async () => {
     let requests = 0
     const pending = Promise.withResolvers<void>()

packages/core/test/mcp.test.ts

@@ -44,7 +44,7 @@ import { testEffect } from "./lib/effect"
 import { imagePassthrough } from "./lib/image"
 import { location } from "./fixture/location"
 import { hostEnvironmentLayer, recordingEnvironmentLayer } from "./fixture/environment"
-import { executeTool, toolDefinitions, toolIdentity, waitForCodeModeTool, waitForTool } from "./lib/tool"
+import { executeTool, toolDefinitions, toolIdentity, waitForTool } from "./lib/tool"
 
 let assertion: Deferred.Deferred<Permission.AssertInput> | undefined
 let decision: Effect.Effect<void, Permission.Error> = Effect.void
@@ -474,6 +474,37 @@ test("retains output schemas across paginated MCP discovery", async () => {
   ])
 })
 
+test("lists paginated prompts and invokes them through the MCP client", async () => {
+  const result = await Effect.runPromise(
+    Effect.scoped(
+      Effect.gen(function* () {
+        const connection = yield* connect(
+          "prompts",
+          new ConfigMCP.Local({
+            type: "local",
+            command: [process.execPath, path.join(import.meta.dir, "fixture/mcp-prompts.ts")],
+          }),
+          import.meta.dir,
+        )
+        return {
+          prompts: yield* connection.prompts(),
+          result: yield* connection.prompt({ name: "first", args: { topic: "Effect" } }),
+        }
+      }),
+    ),
+  )
+
+  expect(result.prompts).toEqual([
+    {
+      name: "first",
+      description: "First prompt",
+      arguments: [{ name: "topic", description: "Topic to explain", required: true }],
+    },
+    { name: "second", description: "Second prompt", arguments: undefined },
+  ])
+  expect(result.result).toEqual({ messages: [{ role: "user", content: { type: "text", text: "Effect" } }] })
+})
+
 test("spawns local MCP servers through the location environment", async () => {
   const spawns: Array<ChildProcess.Command> = []
   const cwd = path.join(import.meta.dir, "fixture")
@@ -1563,7 +1594,9 @@ testEffect(Layer.empty).effect("coalesces queued MCP tool notifications after in
 it.effect("advertises MCP output schemas to Code Mode", () =>
   Effect.gen(function* () {
     const registry = yield* Tool.Service
-    const toolSet = yield* waitForCodeModeTool(registry, "demo.search")
+    const registration = yield* McpTool.Service
+    yield* registration.flush
+    const toolSet = yield* registry.snapshot()
     const execute = toolSet.definitions.find((tool) => tool.name === "execute")
 
     expect(toolSet.definitions.map((tool) => tool.name)).toEqual([
@@ -1582,7 +1615,11 @@ it.effect("returns content-only MCP results through Code Mode", () =>
     assertion = yield* Deferred.make<Permission.AssertInput>()
     decision = Effect.void
     const registry = yield* Tool.Service
-    const toolSet = yield* waitForCodeModeTool(registry, "demo.status")
+    const registration = yield* McpTool.Service
+    yield* registration.flush
+    const toolSet = yield* registry.snapshot()
+
+    expect(toolSet.codeModeCatalog?.some((tool) => tool.path === "demo.status")).toBe(true)
 
     const execution = yield* toolSet.execute({
       sessionID: Session.ID.make("ses_mcp_content_only"),
@@ -1605,7 +1642,8 @@ it.effect("returns content-only MCP results through Code Mode", () =>
 it.effect("advertises MCP tools directly when Code Mode is disabled for the server", () =>
   Effect.gen(function* () {
     const registry = yield* Tool.Service
-    yield* waitForTool(registry, "direct_lookup")
+    const registration = yield* McpTool.Service
+    yield* registration.flush
     const definitions = yield* toolDefinitions(registry)
     const execute = definitions.find((tool) => tool.name === "execute")
 
@@ -1621,7 +1659,8 @@ it.effect("fails the call when MCP reports isError", () =>
     assertion = yield* Deferred.make<Permission.AssertInput>()
     decision = Effect.void
     const registry = yield* Tool.Service
-    yield* waitForTool(registry, "direct_fail")
+    const registration = yield* McpTool.Service
+    yield* registration.flush
 
     const execution = yield* executeTool(registry, {
       sessionID: Session.ID.make("ses_mcp_is_error"),
@@ -1639,7 +1678,8 @@ it.effect("preserves MCP text and media content for the model", () =>
     assertion = yield* Deferred.make<Permission.AssertInput>()
     decision = Effect.void
     const registry = yield* Tool.Service
-    yield* waitForTool(registry, "direct_media")
+    const registration = yield* McpTool.Service
+    yield* registration.flush
 
     const execution = yield* executeTool(registry, {
       sessionID: Session.ID.make("ses_mcp_media"),
@@ -1662,7 +1702,10 @@ it.effect("waits for permission before calling an MCP tool", () =>
     const permission = yield* Deferred.make<void>()
     decision = Deferred.await(permission)
     const registry = yield* Tool.Service
-    const toolSet = yield* waitForCodeModeTool(registry, "demo.search")
+    const registration = yield* McpTool.Service
+    yield* registration.flush
+    const toolSet = yield* registry.snapshot()
+    expect(toolSet.codeModeCatalog?.some((tool) => tool.path === "demo.search")).toBe(true)
 
     const fiber = yield* toolSet
       .execute({
@@ -1703,7 +1746,10 @@ it.effect("does not call MCP when permission is blocked", () =>
     assertion = yield* Deferred.make<Permission.AssertInput>()
     decision = Effect.fail(new Permission.BlockedError({ rules: [], permission: "demo_search", resources: ["*"] }))
     const registry = yield* Tool.Service
-    const toolSet = yield* waitForCodeModeTool(registry, "demo.search")
+    const registration = yield* McpTool.Service
+    yield* registration.flush
+    const toolSet = yield* registry.snapshot()
+    expect(toolSet.codeModeCatalog?.some((tool) => tool.path === "demo.search")).toBe(true)
 
     const execution = yield* toolSet.execute({
       sessionID: Session.ID.make("ses_mcp_blocked"),

packages/core/test/model-resolver.test.ts

@@ -71,6 +71,57 @@ function withConfigEnv<A, E, R>(env: Record<string, string>, effect: () => Effec
 }
 
 describe("ModelResolver", () => {
+  it.effect("routes Merge Gateway images through native Chat without loading an AI SDK", () =>
+    Effect.gen(function* () {
+      const resolved = yield* ModelResolver.fromCatalogModel(
+        model(Provider.aisdk("merge-gateway-ai-sdk-provider"), {
+          providerID: Provider.ID.make("merge-gateway"),
+          modelID: "zai/glm-5.3-flash",
+          body: { tags: [{ key: "env", value: "test" }] },
+        }),
+        Credential.Key.make({ type: "key", key: "test-key" }),
+        { loadAISDK: () => Effect.die("Merge Gateway must use the native provider") },
+      )
+      const prepared = yield* compileRequest(
+        LLM.request({
+          model: resolved,
+          messages: [
+            Message.user([
+              Message.text("[Image 1] describe this image"),
+              { type: "media", mediaType: "image/png", data: "iVBORw0KGgo=" },
+              { type: "media", mediaType: "image/jpeg", data: "/9j/" },
+            ]),
+          ],
+        }),
+      )
+      expect(prepared.route).toBe("openai-compatible-chat")
+      expect(resolved.route.endpoint.baseURL).toBe("https://api-gateway.merge.dev/v1/ai-sdk")
+      expect(resolved.route.defaults.headers?.["x-test"]).toBe("header")
+      expect(resolved.route.defaults.http?.body).toEqual({ tags: [{ key: "env", value: "test" }] })
+      const headers = yield* resolved.route.auth.apply({
+        request: LLM.request({ model: resolved, prompt: "Hello" }),
+        method: "POST",
+        url: "https://api-gateway.merge.dev/v1/ai-sdk/chat/completions",
+        body: "{}",
+        headers: Headers.empty,
+      })
+      expect(headers.authorization).toBe("Bearer test-key")
+      expect(prepared.body).toMatchObject({
+        model: "zai/glm-5.3-flash",
+        messages: [
+          {
+            role: "user",
+            content: [
+              { type: "text", text: "[Image 1] describe this image" },
+              { type: "image_url", image_url: { url: "data:image/png;base64,iVBORw0KGgo=" } },
+              { type: "image_url", image_url: { url: "data:image/jpeg;base64,/9j/" } },
+            ],
+          },
+        ],
+      })
+    }),
+  )
+
   it.effect("constructs native Azure requests with deployment IDs and projected resource URLs", () =>
     Effect.gen(function* () {
       const responses = yield* ModelResolver.fromCatalogModel(

packages/core/test/plugin/models-dev.test.ts

@@ -14,6 +14,7 @@ import { ModelsDevPlugin } from "@opencode-ai/core/plugin/models-dev"
 import { ProviderPlugins } from "@opencode-ai/core/plugin/provider"
 import { Provider } from "@opencode-ai/core/provider"
 import { AbsolutePath } from "@opencode-ai/core/schema"
+import { withEnv } from "../fixture/env"
 import { location } from "../fixture/location"
 import { testEffect } from "../lib/effect"
 import { catalogHost, host, integrationHost } from "./host"
@@ -29,27 +30,6 @@ const it = testEffect(layer)
 const models = (file: string) =>
   AppNodeBuilder.build(ModelsDev.node, [[ModelsDev.node, ModelsDev.configured({ file, fetch: false })]])
 
-function withEnv<A, E, R>(variables: Record<string, string | undefined>, effect: () => Effect.Effect<A, E, R>) {
-  return Effect.acquireUseRelease(
-    Effect.sync(() => {
-      const previous = Object.fromEntries(Object.keys(variables).map((key) => [key, process.env[key]]))
-      Object.entries(variables).forEach(([key, value]) => {
-        if (value === undefined) delete process.env[key]
-        else process.env[key] = value
-      })
-      return previous
-    }),
-    effect,
-    (previous) =>
-      Effect.sync(() => {
-        Object.entries(previous).forEach(([key, value]) => {
-          if (value === undefined) delete process.env[key]
-          else process.env[key] = value
-        })
-      }),
-  )
-}
-
 describe("ModelsDevPlugin", () => {
   it.effect("projects normalized models.dev snapshots into the catalog", () =>
     Effect.gen(function* () {

packages/core/test/plugin/provider-cloudflare-ai-gateway.test.ts

@@ -7,6 +7,7 @@ import { Plugin } from "@opencode-ai/core/plugin"
 import { PluginHost } from "@opencode-ai/core/plugin/host"
 import { CloudflareAIGatewayPlugin } from "@opencode-ai/core/plugin/provider/cloudflare-ai-gateway"
 import { Provider } from "@opencode-ai/core/provider"
+import { withEnv } from "../fixture/env"
 import { Integration } from "@opencode-ai/core/integration"
 import { testEffect } from "../lib/effect"
 import { PluginTestLayer } from "./fixture"
@@ -15,32 +16,10 @@ const it = testEffect(PluginTestLayer)
 
 const addPlugin = Effect.fn(function* () {
   const plugin = yield* Plugin.Service
-  const aisdk = yield* AISDK.Service
   const host = yield* PluginHost.make(plugin)
   yield* CloudflareAIGatewayPlugin.effect(host)
 })
 
-function withEnv<A, E, R>(vars: Record<string, string | undefined>, fx: () => Effect.Effect<A, E, R>) {
-  return Effect.acquireUseRelease(
-    Effect.sync(() => {
-      const previous = Object.fromEntries(Object.keys(vars).map((key) => [key, process.env[key]]))
-      Object.entries(vars).forEach(([key, value]) => {
-        if (value === undefined) delete process.env[key]
-        else process.env[key] = value
-      })
-      return previous
-    }),
-    fx,
-    (previous) =>
-      Effect.sync(() => {
-        Object.entries(previous).forEach(([key, value]) => {
-          if (value === undefined) delete process.env[key]
-          else process.env[key] = value
-        })
-      }),
-  )
-}
-
 const aiGatewayCalls: Record<string, unknown>[] = []
 const unifiedCalls: string[] = []
 const gatewayModelCalls: unknown[] = []
@@ -108,9 +87,8 @@ describe("CloudflareAIGatewayPlugin", () => {
     withEnv({ CLOUDFLARE_ACCOUNT_ID: undefined, CLOUDFLARE_GATEWAY_ID: undefined }, () =>
       Effect.gen(function* () {
         yield* addPlugin()
-        expect(
-          (yield* (yield* Integration.Service).get(Integration.ID.make("cloudflare-ai-gateway")))?.methods,
-        ).toContainEqual({
+        const integrations = yield* Integration.Service
+        expect((yield* integrations.get(Integration.ID.make("cloudflare-ai-gateway")))?.methods).toContainEqual({
           type: "key",
           label: "Gateway API token",
           form: [
@@ -132,7 +110,6 @@ describe("CloudflareAIGatewayPlugin", () => {
       },
       () =>
         Effect.gen(function* () {
-          const plugin = yield* Plugin.Service
           const aisdk = yield* AISDK.Service
           yield* addPlugin()
           const result = yield* aisdk.runSDK({
@@ -153,7 +130,6 @@ describe("CloudflareAIGatewayPlugin", () => {
     withEnv(cloudflareEnv(), () =>
       Effect.gen(function* () {
         resetCalls()
-        const plugin = yield* Plugin.Service
         const aisdk = yield* AISDK.Service
         yield* addPlugin()
 
@@ -198,7 +174,6 @@ describe("CloudflareAIGatewayPlugin", () => {
     withEnv(cloudflareEnv(), () =>
       Effect.gen(function* () {
         resetCalls()
-        const plugin = yield* Plugin.Service
         const aisdk = yield* AISDK.Service
         yield* addPlugin()
 
@@ -228,7 +203,6 @@ describe("CloudflareAIGatewayPlugin", () => {
     withEnv(cloudflareEnv(), () =>
       Effect.gen(function* () {
         resetCalls()
-        const plugin = yield* Plugin.Service
         const aisdk = yield* AISDK.Service
         yield* addPlugin()
 
@@ -266,7 +240,6 @@ describe("CloudflareAIGatewayPlugin", () => {
       () =>
         Effect.gen(function* () {
           resetCalls()
-          const plugin = yield* Plugin.Service
           const aisdk = yield* AISDK.Service
           yield* addPlugin()
 
@@ -298,7 +271,6 @@ describe("CloudflareAIGatewayPlugin", () => {
     withEnv(cloudflareEnv({ CLOUDFLARE_API_TOKEN: undefined, CF_AIG_TOKEN: "cf-aig-token" }), () =>
       Effect.gen(function* () {
         resetCalls()
-        const plugin = yield* Plugin.Service
         const aisdk = yield* AISDK.Service
         yield* addPlugin()
 
@@ -321,7 +293,6 @@ describe("CloudflareAIGatewayPlugin", () => {
     withEnv(cloudflareEnv({ CLOUDFLARE_ACCOUNT_ID: undefined, CLOUDFLARE_GATEWAY_ID: undefined }), () =>
       Effect.gen(function* () {
         resetCalls()
-        const plugin = yield* Plugin.Service
         const aisdk = yield* AISDK.Service
         yield* addPlugin()
 
@@ -345,7 +316,6 @@ describe("CloudflareAIGatewayPlugin", () => {
     withEnv(cloudflareEnv({ CLOUDFLARE_API_TOKEN: undefined, CF_AIG_TOKEN: undefined }), () =>
       Effect.gen(function* () {
         resetCalls()
-        const plugin = yield* Plugin.Service
         const aisdk = yield* AISDK.Service
         yield* addPlugin()
 
@@ -375,7 +345,6 @@ describe("CloudflareAIGatewayPlugin", () => {
       () =>
         Effect.gen(function* () {
           resetCalls()
-          const plugin = yield* Plugin.Service
           const aisdk = yield* AISDK.Service
           const catalog = yield* Catalog.Service
           yield* catalog.transform((catalog) =>
@@ -384,9 +353,11 @@ describe("CloudflareAIGatewayPlugin", () => {
             }),
           )
           yield* addPlugin()
-          expect(
-            (yield* (yield* Integration.Service).get(Integration.ID.make("cloudflare-ai-gateway")))?.methods,
-          ).toContainEqual({ type: "key", label: "Gateway API token" })
+          const integrations = yield* Integration.Service
+          expect((yield* integrations.get(Integration.ID.make("cloudflare-ai-gateway")))?.methods).toContainEqual({
+            type: "key",
+            label: "Gateway API token",
+          })
 
           const result = yield* aisdk.runSDK({
             model: Model.Info.make({
@@ -408,7 +379,6 @@ describe("CloudflareAIGatewayPlugin", () => {
     withEnv(cloudflareEnv(), () =>
       Effect.gen(function* () {
         resetCalls()
-        const plugin = yield* Plugin.Service
         const aisdk = yield* AISDK.Service
         yield* addPlugin()
 
@@ -440,7 +410,6 @@ describe("CloudflareAIGatewayPlugin", () => {
     withEnv(cloudflareEnv(), () =>
       Effect.gen(function* () {
         resetCalls()
-        const plugin = yield* Plugin.Service
         const aisdk = yield* AISDK.Service
         yield* addPlugin()
 

packages/core/test/plugin/provider-dynamic.test.ts

@@ -156,7 +156,6 @@ describe("DynamicProviderPlugin", () => {
 
   itWithAISDK.live("wraps missing provider factory exports as AISDK init errors", () =>
     Effect.gen(function* () {
-      const plugin = yield* Plugin.Service
       const aisdk = yield* AISDK.Service
       const tmp = yield* tempEntrypoint("export const notAProviderFactory = true\n")
       yield* addPlugin(npmEntrypoint(tmp.entrypoint))
@@ -176,7 +175,6 @@ describe("DynamicProviderPlugin", () => {
 
   itWithAISDK.effect("uses the model modelID for the default language model", () =>
     Effect.gen(function* () {
-      const plugin = yield* Plugin.Service
       const aisdk = yield* AISDK.Service
       yield* addPlugin()
       const language = yield* aisdk.language(

packages/core/test/plugin/provider-github-copilot.test.ts

@@ -21,7 +21,6 @@ const it = testEffect(PluginTestLayer)
 
 const addPlugin = Effect.fn(function* () {
   const plugin = yield* Plugin.Service
-  const aisdk = yield* AISDK.Service
   const host = yield* PluginHost.make(plugin)
   yield* GithubCopilotPlugin.effect(host)
 })
@@ -57,7 +56,8 @@ describe("GithubCopilotPlugin", () => {
   it.effect("registers GitHub Copilot device OAuth", () =>
     Effect.gen(function* () {
       yield* addPlugin()
-      expect((yield* (yield* Integration.Service).get(Integration.ID.make("github-copilot")))?.methods).toContainEqual({
+      const integrations = yield* Integration.Service
+      expect((yield* integrations.get(Integration.ID.make("github-copilot")))?.methods).toContainEqual({
         id: Integration.MethodID.make("device"),
         type: "oauth",
         label: "Login with GitHub Copilot",
@@ -124,7 +124,8 @@ describe("GithubCopilotPlugin", () => {
   it.effect("adds Copilot authentication to native Anthropic requests", () =>
     Effect.gen(function* () {
       yield* addPlugin()
-      const event = yield* (yield* PluginHooks.Service).trigger("session", "http.request", {
+      const hooks = yield* PluginHooks.Service
+      const event = yield* hooks.trigger("session", "http.request", {
         sessionID: Session.ID.make("ses_test"),
         agent: Agent.ID.make("build"),
         model: Model.Ref.make({ providerID: Provider.ID.githubCopilot, id: Model.ID.make("claude-sonnet-4.5") }),
@@ -145,7 +146,8 @@ describe("GithubCopilotPlugin", () => {
   it.effect("classifies title generation as a background interaction", () =>
     Effect.gen(function* () {
       yield* addPlugin()
-      const event = yield* (yield* PluginHooks.Service).trigger("session", "http.request", {
+      const hooks = yield* PluginHooks.Service
+      const event = yield* hooks.trigger("session", "http.request", {
         sessionID: Session.ID.make("ses_title"),
         agent: Agent.ID.make("title"),
         model: Model.Ref.make({ providerID: Provider.ID.githubCopilot, id: Model.ID.make("gpt-5.4-nano") }),
@@ -158,7 +160,8 @@ describe("GithubCopilotPlugin", () => {
   it.effect("classifies compaction requests", () =>
     Effect.gen(function* () {
       yield* addPlugin()
-      const event = yield* (yield* PluginHooks.Service).trigger("session", "http.request", {
+      const hooks = yield* PluginHooks.Service
+      const event = yield* hooks.trigger("session", "http.request", {
         sessionID: Session.ID.make("ses_compaction"),
         agent: Agent.ID.make("compaction"),
         model: Model.Ref.make({ providerID: Provider.ID.githubCopilot, id: Model.ID.make("gpt-5.4") }),
@@ -170,7 +173,6 @@ describe("GithubCopilotPlugin", () => {
 
   it.effect("creates the bundled Copilot SDK for the GitHub Copilot package", () =>
     Effect.gen(function* () {
-      const plugin = yield* Plugin.Service
       const aisdk = yield* AISDK.Service
       yield* addPlugin()
       const ignored = yield* aisdk.runSDK({
@@ -221,7 +223,6 @@ describe("GithubCopilotPlugin", () => {
 
   it.effect("selects languageModel when responses and chat are absent", () =>
     Effect.gen(function* () {
-      const plugin = yield* Plugin.Service
       const aisdk = yield* AISDK.Service
       const calls: string[] = []
       yield* addPlugin()
@@ -240,7 +241,6 @@ describe("GithubCopilotPlugin", () => {
 
   it.effect("selects languageModel with the API model ID when responses and chat are absent", () =>
     Effect.gen(function* () {
-      const plugin = yield* Plugin.Service
       const aisdk = yield* AISDK.Service
       const calls: string[] = []
       yield* addPlugin()
@@ -259,7 +259,6 @@ describe("GithubCopilotPlugin", () => {
 
   it.effect("uses responses for gpt-5 models except gpt-5-mini", () =>
     Effect.gen(function* () {
-      const plugin = yield* Plugin.Service
       const aisdk = yield* AISDK.Service
       const calls: string[] = []
       yield* addPlugin()
@@ -320,7 +319,6 @@ describe("GithubCopilotPlugin", () => {
 
   it.effect("uses advertised Copilot endpoint metadata before model ID fallbacks", () =>
     Effect.gen(function* () {
-      const plugin = yield* Plugin.Service
       const aisdk = yield* AISDK.Service
       const calls: string[] = []
       yield* addPlugin()
@@ -350,7 +348,6 @@ describe("GithubCopilotPlugin", () => {
 
   it.effect("uses the API model ID when selecting responses or chat", () =>
     Effect.gen(function* () {
-      const plugin = yield* Plugin.Service
       const aisdk = yield* AISDK.Service
       const calls: string[] = []
       yield* addPlugin()
@@ -417,7 +414,6 @@ describe("GithubCopilotPlugin", () => {
 
   it.effect("ignores non-Copilot providers", () =>
     Effect.gen(function* () {
-      const plugin = yield* Plugin.Service
       const aisdk = yield* AISDK.Service
       const calls: string[] = []
       yield* addPlugin()

packages/core/test/plugin/provider-gitlab.test.ts

@@ -1,12 +1,12 @@
 import { AISDK } from "@opencode-ai/core/aisdk"
 import { describe, expect, mock } from "bun:test"
 import { Effect } from "effect"
-import { Catalog } from "@opencode-ai/core/catalog"
 import { Model } from "@opencode-ai/core/model"
 import { Plugin } from "@opencode-ai/core/plugin"
 import { PluginHost } from "@opencode-ai/core/plugin/host"
 import { GitLabPlugin } from "@opencode-ai/core/plugin/provider/gitlab"
 import { Provider } from "@opencode-ai/core/provider"
+import { withEnv } from "../fixture/env"
 import { testEffect } from "../lib/effect"
 import { PluginTestLayer } from "./fixture"
 
@@ -15,32 +15,10 @@ const it = testEffect(PluginTestLayer)
 
 const addPlugin = Effect.fn(function* () {
   const plugin = yield* Plugin.Service
-  const aisdk = yield* AISDK.Service
   const host = yield* PluginHost.make(plugin)
   yield* GitLabPlugin.effect(host)
 })
 
-function withEnv<A, E, R>(vars: Record<string, string | undefined>, effect: () => Effect.Effect<A, E, R>) {
-  return Effect.acquireUseRelease(
-    Effect.sync(() => {
-      const previous = Object.fromEntries(Object.keys(vars).map((key) => [key, process.env[key]]))
-      Object.entries(vars).forEach(([key, value]) => {
-        if (value === undefined) delete process.env[key]
-        else process.env[key] = value
-      })
-      return previous
-    }),
-    effect,
-    (previous) =>
-      Effect.sync(() =>
-        Object.entries(previous).forEach(([key, value]) => {
-          if (value === undefined) delete process.env[key]
-          else process.env[key] = value
-        }),
-      ),
-  )
-}
-
 void mock.module("gitlab-ai-provider", () => ({
   VERSION: "test-version",
   createGitLab: (options: Record<string, unknown>) => {
@@ -64,7 +42,6 @@ describe("GitLabPlugin", () => {
       () =>
         Effect.gen(function* () {
           gitlabSDKOptions.length = 0
-          const plugin = yield* Plugin.Service
           const aisdk = yield* AISDK.Service
           yield* addPlugin()
           yield* aisdk.runSDK({
@@ -102,7 +79,6 @@ describe("GitLabPlugin", () => {
       () =>
         Effect.gen(function* () {
           gitlabSDKOptions.length = 0
-          const plugin = yield* Plugin.Service
           const aisdk = yield* AISDK.Service
           yield* addPlugin()
           yield* aisdk.runSDK({
@@ -128,7 +104,6 @@ describe("GitLabPlugin", () => {
       () =>
         Effect.gen(function* () {
           gitlabSDKOptions.length = 0
-          const plugin = yield* Plugin.Service
           const aisdk = yield* AISDK.Service
           yield* addPlugin()
           yield* aisdk.runSDK({
@@ -170,7 +145,6 @@ describe("GitLabPlugin", () => {
   it.effect("ignores non-GitLab SDK packages", () =>
     Effect.gen(function* () {
       gitlabSDKOptions.length = 0
-      const plugin = yield* Plugin.Service
       const aisdk = yield* AISDK.Service
       yield* addPlugin()
       const result = yield* aisdk.runSDK({
@@ -189,7 +163,6 @@ describe("GitLabPlugin", () => {
 
   it.effect("uses workflowChat for duo workflow models and preserves selectedModelRef", () =>
     Effect.gen(function* () {
-      const plugin = yield* Plugin.Service
       const aisdk = yield* AISDK.Service
       const calls: [string, unknown][] = []
       yield* addPlugin()
@@ -223,7 +196,6 @@ describe("GitLabPlugin", () => {
 
   it.effect("uses exact static workflow model ids when the provider recognizes them", () =>
     Effect.gen(function* () {
-      const plugin = yield* Plugin.Service
       const aisdk = yield* AISDK.Service
       const calls: [string, unknown][] = []
       yield* addPlugin()
@@ -251,7 +223,6 @@ describe("GitLabPlugin", () => {
 
   it.effect("uses provider feature flags instead of model settings feature flags", () =>
     Effect.gen(function* () {
-      const plugin = yield* Plugin.Service
       const aisdk = yield* AISDK.Service
       const calls: [string, unknown][] = []
       yield* addPlugin()
@@ -278,7 +249,6 @@ describe("GitLabPlugin", () => {
 
   it.effect("uses agenticChat with provider aiGatewayHeaders and feature flags for normal models", () =>
     Effect.gen(function* () {
-      const plugin = yield* Plugin.Service
       const aisdk = yield* AISDK.Service
       const calls: [string, unknown][] = []
       yield* addPlugin()

packages/core/test/plugin/provider-kilo.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect } from "bun:test"
+import { describe, expect, test } from "bun:test"
 import { Effect } from "effect"
 import { Catalog } from "@opencode-ai/core/catalog"
 import { Plugin } from "@opencode-ai/core/plugin"
@@ -18,9 +18,9 @@ const addPlugin = Effect.fn(function* () {
 })
 
 describe("KiloPlugin", () => {
-  it.effect("is registered so legacy referer headers can be applied", () =>
-    Effect.sync(() => expect(ProviderPlugins.map((item) => item.id)).toContain("opencode.provider.kilo")),
-  )
+  test("is registered so legacy referer headers can be applied", () => {
+    expect(ProviderPlugins.map((item) => item.id)).toContain("opencode.provider.kilo")
+  })
 
   it.effect("applies legacy referer headers only to Kilo endpoints", () =>
     Effect.gen(function* () {

packages/core/test/plugin/provider-llmgateway.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect } from "bun:test"
+import { describe, expect, test } from "bun:test"
 import { Effect } from "effect"
 import { Catalog } from "@opencode-ai/core/catalog"
 import { Integration } from "@opencode-ai/core/integration"
@@ -15,14 +15,13 @@ const it = testEffect(PluginTestLayer)
 const addPlugin = Effect.fn(function* () {
   const plugin = yield* Plugin.Service
   const host = yield* PluginHost.make(plugin)
-  const integration = yield* Integration.Service
-  yield* LLMGatewayPlugin.effect(host).pipe(Effect.provideService(Integration.Service, integration))
+  yield* LLMGatewayPlugin.effect(host)
 })
 
 describe("LLMGatewayPlugin", () => {
-  it.effect("is registered so legacy referer headers can be applied", () =>
-    Effect.sync(() => expect(ProviderPlugins.map((item) => item.id)).toContain("opencode.provider.llmgateway")),
-  )
+  test("is registered so legacy referer headers can be applied", () => {
+    expect(ProviderPlugins.map((item) => item.id)).toContain("opencode.provider.llmgateway")
+  })
 
   it.effect("applies legacy referer headers only to enabled llmgateway", () =>
     Effect.gen(function* () {

packages/core/test/plugin/provider-lmstudio.test.ts

@@ -9,7 +9,7 @@ import { LMStudioPlugin, make } from "@opencode-ai/core/plugin/provider/lmstudio
 import { ProviderPlugins } from "@opencode-ai/core/plugin/provider"
 import { Provider } from "@opencode-ai/core/provider"
 import { Document, Event, Info } from "@opencode-ai/schema/config"
-import { describe, expect } from "bun:test"
+import { describe, expect, test } from "bun:test"
 import { Duration, Effect, Layer, Schema } from "effect"
 import { testEffect } from "../lib/effect"
 import { PluginTestLayer } from "./fixture"
@@ -38,12 +38,10 @@ function eventually<A>(
 }
 
 describe("LMStudioPlugin", () => {
-  it.effect("is registered as a built-in provider plugin", () =>
-    Effect.sync(() => {
-      expect(LMStudioPlugin.id).toBe("opencode.provider.lmstudio")
-      expect(ProviderPlugins.map((item) => item.id)).toContain("opencode.provider.lmstudio")
-    }),
-  )
+  test("is registered as a built-in provider plugin", () => {
+    expect(LMStudioPlugin.id).toBe("opencode.provider.lmstudio")
+    expect(ProviderPlugins.map((item) => item.id)).toContain("opencode.provider.lmstudio")
+  })
 
   it.live("discovers local language models with their capabilities and effective context", () =>
     Effect.acquireUseRelease(

packages/core/test/plugin/provider-merge-gateway.test.ts

@@ -0,0 +1,149 @@
+import { describe, expect, test } from "bun:test"
+import { Effect, Layer } from "effect"
+import { HttpClient, HttpClientResponse } from "effect/unstable/http"
+import { LLM, Message } from "@opencode-ai/ai"
+import { LLMClient, RequestExecutor } from "@opencode-ai/ai/route"
+import { Catalog } from "@opencode-ai/core/catalog"
+import { Credential } from "@opencode-ai/core/credential"
+import { Model } from "@opencode-ai/core/model"
+import { ModelResolver } from "@opencode-ai/core/model-resolver"
+import { Plugin } from "@opencode-ai/core/plugin"
+import { PluginHost } from "@opencode-ai/core/plugin/host"
+import { ProviderPlugins } from "@opencode-ai/core/plugin/provider"
+import { MergeGatewayPlugin } from "@opencode-ai/core/plugin/provider/merge-gateway"
+import { Provider } from "@opencode-ai/core/provider"
+import { testEffect } from "../lib/effect"
+import { PluginTestLayer } from "./fixture"
+
+const it = testEffect(PluginTestLayer)
+const providerID = Provider.ID.make("merge-gateway")
+const modelID = Model.ID.make("zai/glm-5.3-flash")
+const addPlugin = Effect.fn(function* () {
+  const plugin = yield* Plugin.Service
+  const host = yield* PluginHost.make(plugin)
+  yield* MergeGatewayPlugin.effect(host)
+})
+
+describe("MergeGatewayPlugin", () => {
+  test("is registered as a built-in provider plugin", () => {
+    expect(ProviderPlugins).toContain(MergeGatewayPlugin)
+  })
+
+  it.effect("sets gateway defaults by effective package and leaves later overrides intact", () =>
+    Effect.gen(function* () {
+      const catalog = yield* Catalog.Service
+      const other = Model.ID.make("other")
+      const custom = Provider.ID.make("custom")
+      yield* catalog.transform((draft) => {
+        draft.provider.update(providerID, (provider) => {
+          provider.package = Provider.aisdk("merge-gateway-ai-sdk-provider")
+        })
+        draft.model.update(providerID, modelID, (model) => {
+          model.compatibility = { reasoningField: "reasoning_content", requireFinishReason: true }
+        })
+        draft.model.update(providerID, other, (model) => {
+          model.package = Provider.aisdk("@ai-sdk/openai-compatible")
+        })
+        draft.model.update(custom, modelID, (model) => {
+          model.package = Provider.aisdk("merge-gateway-ai-sdk-provider")
+        })
+      })
+      yield* addPlugin()
+      expect((yield* catalog.model.get(providerID, modelID))?.compatibility).toEqual({
+        reasoningField: "thinking",
+        maxTokensField: "max_tokens",
+        requireReasoning: false,
+        requireFinishReason: true,
+      })
+      expect((yield* catalog.model.get(providerID, other))?.compatibility).toBeUndefined()
+      expect((yield* catalog.model.get(custom, modelID))?.compatibility?.reasoningField).toBe("thinking")
+      yield* catalog.transform((draft) => {
+        draft.model.update(providerID, modelID, (model) => {
+          model.compatibility = { ...model.compatibility, reasoningField: "custom_thinking" }
+        })
+      })
+      expect((yield* catalog.model.get(providerID, modelID))?.compatibility?.reasoningField).toBe("custom_thinking")
+    }),
+  )
+
+  it.effect("uses native HTTP for images, thinking, tool calls, and usage", () =>
+    Effect.gen(function* () {
+      const catalog = yield* Catalog.Service
+      yield* catalog.transform((draft) => {
+        draft.provider.update(providerID, (provider) => {
+          provider.package = Provider.aisdk("merge-gateway-ai-sdk-provider")
+        })
+        draft.model.update(providerID, modelID, (model) => {
+          model.body = { tags: [{ key: "env", value: "test" }] }
+        })
+      })
+      yield* addPlugin()
+      const info = yield* catalog.model.get(providerID, modelID)
+      if (!info) throw new Error("Missing Merge model")
+      const model = yield* ModelResolver.fromCatalogModel(info, Credential.Key.make({ type: "key", key: "test-key" }))
+      const transport = Layer.succeed(
+        HttpClient.HttpClient,
+        HttpClient.make((request) =>
+          Effect.sync(() => {
+            expect(request.url).toBe("https://api-gateway.merge.dev/v1/ai-sdk/chat/completions")
+            expect(request.headers.authorization).toBe("Bearer test-key")
+            if (request.body._tag !== "Uint8Array") throw new Error("Expected JSON request")
+            const body = JSON.parse(new TextDecoder().decode(request.body.body))
+            expect(body.max_tokens).toBe(100)
+            expect(body).not.toHaveProperty("max_completion_tokens")
+            expect(body.tags).toEqual([{ key: "env", value: "test" }])
+            expect(body.messages[0]).toMatchObject({
+              role: "user",
+              content: [{ type: "image_url", image_url: { url: "data:image/png;base64,iVBORw0KGgo=" } }],
+            })
+            expect(body.messages[1]).not.toHaveProperty("thinking")
+            const chunks = [
+              { choices: [{ index: 0, delta: { thinking: "Inspecting the image." }, finish_reason: null }] },
+              { choices: [{ index: 0, delta: { content: "I see it." }, finish_reason: null }] },
+              {
+                choices: [
+                  {
+                    index: 0,
+                    delta: {
+                      tool_calls: [
+                        {
+                          index: 0,
+                          id: "call_1",
+                          type: "function",
+                          function: { name: "read", arguments: '{"path":"image.png"}' },
+                        },
+                      ],
+                    },
+                    finish_reason: "tool_calls",
+                  },
+                ],
+              },
+              { choices: [], usage: { prompt_tokens: 10, completion_tokens: 5, total_tokens: 15 } },
+            ]
+            return HttpClientResponse.fromWeb(
+              request,
+              new Response(chunks.map((chunk) => `data: ${JSON.stringify(chunk)}\n\n`).join("") + "data: [DONE]\n\n", {
+                headers: { "content-type": "text/event-stream" },
+              }),
+            )
+          }),
+        ),
+      )
+      const response = yield* LLMClient.generate(
+        LLM.request({
+          model,
+          generation: { maxTokens: 100 },
+          messages: [
+            Message.user({ type: "media", mediaType: "image/png", data: "iVBORw0KGgo=" }),
+            Message.assistant("Let me look."),
+            Message.user("Continue"),
+          ],
+        }),
+      ).pipe(Effect.provide(LLMClient.layer.pipe(Layer.provide(RequestExecutor.layer.pipe(Layer.provide(transport))))))
+      expect(response.text).toBe("I see it.")
+      expect(response.reasoning).toBe("Inspecting the image.")
+      expect(response.toolCalls).toMatchObject([{ name: "read", input: { path: "image.png" } }])
+      expect(response.usage).toMatchObject({ inputTokens: 10, outputTokens: 5 })
+    }),
+  )
+})

packages/core/test/plugin/provider-nvidia.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect } from "bun:test"
+import { describe, expect, test } from "bun:test"
 import { Effect } from "effect"
 import { Catalog } from "@opencode-ai/core/catalog"
 import { Plugin } from "@opencode-ai/core/plugin"
@@ -18,9 +18,9 @@ const addPlugin = Effect.fn(function* () {
 })
 
 describe("NvidiaPlugin", () => {
-  it.effect("is registered so legacy referer headers can be applied", () =>
-    Effect.sync(() => expect(ProviderPlugins.map((item) => item.id)).toContain("opencode.provider.nvidia")),
-  )
+  test("is registered so legacy referer headers can be applied", () => {
+    expect(ProviderPlugins.map((item) => item.id)).toContain("opencode.provider.nvidia")
+  })
 
   it.effect("applies NVIDIA tracking headers only to nvidia", () =>
     Effect.gen(function* () {

packages/core/test/plugin/provider-openai.test.ts

@@ -28,8 +28,7 @@ const it = testEffect(PluginTestLayer)
 const addPlugin = Effect.fn(function* () {
   const plugin = yield* Plugin.Service
   const host = yield* PluginHost.make(plugin)
-  const integrations = yield* Integration.Service
-  yield* OpenAIPlugin.effect(host).pipe(Effect.provideService(Integration.Service, integrations))
+  yield* OpenAIPlugin.effect(host)
 })
 
 const addGithubCopilotPlugin = Effect.fn(function* () {
@@ -65,7 +64,8 @@ describe("OpenAIPlugin", () => {
   it.effect("registers browser and headless ChatGPT OAuth methods", () =>
     Effect.gen(function* () {
       yield* addPlugin()
-      expect((yield* (yield* Integration.Service).get(Integration.ID.make("openai")))?.methods).toEqual([
+      const integrations = yield* Integration.Service
+      expect((yield* integrations.get(Integration.ID.make("openai")))?.methods).toEqual([
         {
           id: Integration.MethodID.make("chatgpt-browser"),
           type: "oauth",

packages/core/test/plugin/provider-opencode.test.ts

@@ -3,13 +3,13 @@ import { Money } from "@opencode-ai/schema/money"
 import { Effect } from "effect"
 import { Catalog } from "@opencode-ai/core/catalog"
 import { Credential } from "@opencode-ai/core/credential"
-import { Bus } from "@opencode-ai/core/bus"
 import { Integration } from "@opencode-ai/core/integration"
 import { Model } from "@opencode-ai/core/model"
 import { Plugin } from "@opencode-ai/core/plugin"
 import { PluginHost } from "@opencode-ai/core/plugin/host"
 import { OpencodePlugin } from "@opencode-ai/core/plugin/provider/opencode"
 import { Provider } from "@opencode-ai/core/provider"
+import { withEnv } from "../fixture/env"
 import { testEffect } from "../lib/effect"
 import { PluginTestLayer } from "./fixture"
 
@@ -18,12 +18,7 @@ const it = testEffect(PluginTestLayer)
 const addPlugin = Effect.fn(function* () {
   const plugin = yield* Plugin.Service
   const host = yield* PluginHost.make(plugin)
-  const bus = yield* Bus.Service
-  const integration = yield* Integration.Service
-  yield* OpencodePlugin.effect(host).pipe(
-    Effect.provideService(Bus.Service, bus),
-    Effect.provideService(Integration.Service, integration),
-  )
+  yield* OpencodePlugin.effect(host)
 })
 
 function required<T>(value: T | undefined): T {
@@ -45,27 +40,6 @@ function eventually<A>(
   })
 }
 
-function withEnv<A, E, R>(vars: Record<string, string | undefined>, effect: () => Effect.Effect<A, E, R>) {
-  return Effect.acquireUseRelease(
-    Effect.sync(() => {
-      const previous = Object.fromEntries(Object.keys(vars).map((key) => [key, process.env[key]]))
-      Object.entries(vars).forEach(([key, value]) => {
-        if (value === undefined) delete process.env[key]
-        else process.env[key] = value
-      })
-      return previous
-    }),
-    effect,
-    (previous) =>
-      Effect.sync(() =>
-        Object.entries(previous).forEach(([key, value]) => {
-          if (value === undefined) delete process.env[key]
-          else process.env[key] = value
-        }),
-      ),
-  )
-}
-
 const cost = (input: number, output = 0) => [
   {
     input: Money.USDPerMillionTokens.make(input),
@@ -81,7 +55,8 @@ describe("OpencodePlugin", () => {
   it.effect("registers account and service account methods", () =>
     Effect.gen(function* () {
       yield* addPlugin()
-      expect((yield* (yield* Integration.Service).get(Integration.ID.make("opencode")))?.methods).toEqual([
+      const integrations = yield* Integration.Service
+      expect((yield* integrations.get(Integration.ID.make("opencode")))?.methods).toEqual([
         {
           id: Integration.MethodID.make("device"),
           type: "oauth",
@@ -140,7 +115,8 @@ describe("OpencodePlugin", () => {
           expect(requests).toContain("POST /console/auth/device/token")
           expect(requests).toContain("GET /console/api/user")
           expect(requests).toContain("GET /console/api/orgs")
-          expect((yield* (yield* Credential.Service).list(Integration.ID.make("opencode")))[0]?.value).toMatchObject({
+          const credentials = yield* Credential.Service
+          expect((yield* credentials.list(Integration.ID.make("opencode")))[0]?.value).toMatchObject({
             metadata: { server: `${server.url.origin}/console` },
           })
         }),
@@ -166,7 +142,8 @@ describe("OpencodePlugin", () => {
       (server) =>
         Effect.gen(function* () {
           yield* addPlugin()
-          const error = yield* (yield* Integration.Service).oauth
+          const integrations = yield* Integration.Service
+          const error = yield* integrations.oauth
             .connect({
               integrationID: Integration.ID.make("opencode"),
               methodID: Integration.MethodID.make("device"),
@@ -183,7 +160,8 @@ describe("OpencodePlugin", () => {
   it.effect("rejects non-HTTP OpenCode servers", () =>
     Effect.gen(function* () {
       yield* addPlugin()
-      const error = yield* (yield* Integration.Service).oauth
+      const integrations = yield* Integration.Service
+      const error = yield* integrations.oauth
         .connect({
           integrationID: Integration.ID.make("opencode"),
           methodID: Integration.MethodID.make("device"),
@@ -198,7 +176,8 @@ describe("OpencodePlugin", () => {
   it.effect("rejects non-string OpenCode servers", () =>
     Effect.gen(function* () {
       yield* addPlugin()
-      const error = yield* (yield* Integration.Service).oauth
+      const integrations = yield* Integration.Service
+      const error = yield* integrations.oauth
         .connect({
           integrationID: Integration.ID.make("opencode"),
           methodID: Integration.MethodID.make("device"),
@@ -299,7 +278,8 @@ describe("OpencodePlugin", () => {
             settings: { baseURL: `${server.url.origin}/v1`, custom: "value" },
             headers: { "x-org-id": "org" },
           })
-          expect(yield* (yield* Integration.Service).get(Integration.ID.make("remote"))).toBeUndefined()
+          const integrations = yield* Integration.Service
+          expect(yield* integrations.get(Integration.ID.make("remote"))).toBeUndefined()
 
           const model = required(yield* catalog.model.get(Provider.ID.make("remote"), Model.ID.make("model")))
           expect(model).toMatchObject({
@@ -365,19 +345,9 @@ describe("OpencodePlugin", () => {
       Effect.gen(function* () {
         const catalog = yield* Catalog.Service
         yield* catalog.transform((catalog) => {
-          const provider = Provider.Info.make({
-            ...Provider.Info.empty(Provider.ID.opencode),
-            package: Provider.aisdk("test-provider"),
-          })
-          const model = Model.Info.make({
-            ...Model.Info.default(provider.id, Model.ID.make("paid")),
-            modelID: Model.ID.make("paid"),
-            package: Provider.aisdk("test-provider"),
-            cost: cost(1),
-          })
-          catalog.provider.update(provider.id, () => {})
-          catalog.model.update(provider.id, model.id, (draft) => {
-            draft.cost = [...model.cost]
+          catalog.provider.update(Provider.ID.opencode, () => {})
+          catalog.model.update(Provider.ID.opencode, Model.ID.make("paid"), (draft) => {
+            draft.cost = cost(1)
           })
         })
         yield* addPlugin()
@@ -392,19 +362,9 @@ describe("OpencodePlugin", () => {
       Effect.gen(function* () {
         const catalog = yield* Catalog.Service
         yield* catalog.transform((catalog) => {
-          const provider = Provider.Info.make({
-            ...Provider.Info.empty(Provider.ID.opencode),
-            package: Provider.aisdk("test-provider"),
-          })
-          const model = Model.Info.make({
-            ...Model.Info.default(provider.id, Model.ID.make("free")),
-            modelID: Model.ID.make("free"),
-            package: Provider.aisdk("test-provider"),
-            cost: cost(0),
-          })
-          catalog.provider.update(provider.id, () => {})
-          catalog.model.update(provider.id, model.id, (draft) => {
-            draft.cost = [...model.cost]
+          catalog.provider.update(Provider.ID.opencode, () => {})
+          catalog.model.update(Provider.ID.opencode, Model.ID.make("free"), (draft) => {
+            draft.cost = cost(0)
           })
         })
         yield* addPlugin()
@@ -421,19 +381,9 @@ describe("OpencodePlugin", () => {
       Effect.gen(function* () {
         const catalog = yield* Catalog.Service
         yield* catalog.transform((catalog) => {
-          const provider = Provider.Info.make({
-            ...Provider.Info.empty(Provider.ID.opencode),
-            package: Provider.aisdk("test-provider"),
-          })
-          const model = Model.Info.make({
-            ...Model.Info.default(provider.id, Model.ID.make("output-only")),
-            modelID: Model.ID.make("output-only"),
-            package: Provider.aisdk("test-provider"),
-            cost: cost(0, 1),
-          })
-          catalog.provider.update(provider.id, () => {})
-          catalog.model.update(provider.id, model.id, (draft) => {
-            draft.cost = [...model.cost]
+          catalog.provider.update(Provider.ID.opencode, () => {})
+          catalog.model.update(Provider.ID.opencode, Model.ID.make("output-only"), (draft) => {
+            draft.cost = cost(0, 1)
           })
         })
         yield* addPlugin()
@@ -450,19 +400,9 @@ describe("OpencodePlugin", () => {
       Effect.gen(function* () {
         const catalog = yield* Catalog.Service
         yield* catalog.transform((catalog) => {
-          const provider = Provider.Info.make({
-            ...Provider.Info.empty(Provider.ID.opencode),
-            package: Provider.aisdk("test-provider"),
-          })
-          const model = Model.Info.make({
-            ...Model.Info.default(provider.id, Model.ID.make("paid")),
-            modelID: Model.ID.make("paid"),
-            package: Provider.aisdk("test-provider"),
-            cost: cost(1),
-          })
-          catalog.provider.update(provider.id, () => {})
-          catalog.model.update(provider.id, model.id, (draft) => {
-            draft.cost = [...model.cost]
+          catalog.provider.update(Provider.ID.opencode, () => {})
+          catalog.model.update(Provider.ID.opencode, Model.ID.make("paid"), (draft) => {
+            draft.cost = cost(1)
           })
         })
         yield* addPlugin()
@@ -484,19 +424,9 @@ describe("OpencodePlugin", () => {
           })
         })
         yield* catalog.transform((catalog) => {
-          const provider = Provider.Info.make({
-            ...Provider.Info.empty(Provider.ID.opencode),
-            package: Provider.aisdk("test-provider"),
-          })
-          const model = Model.Info.make({
-            ...Model.Info.default(provider.id, Model.ID.make("paid")),
-            modelID: Model.ID.make("paid"),
-            package: Provider.aisdk("test-provider"),
-            cost: cost(1),
-          })
-          catalog.provider.update(provider.id, () => {})
-          catalog.model.update(provider.id, model.id, (draft) => {
-            draft.cost = [...model.cost]
+          catalog.provider.update(Provider.ID.opencode, () => {})
+          catalog.model.update(Provider.ID.opencode, Model.ID.make("paid"), (draft) => {
+            draft.cost = cost(1)
           })
         })
         yield* addPlugin()
@@ -511,23 +441,12 @@ describe("OpencodePlugin", () => {
       Effect.gen(function* () {
         const catalog = yield* Catalog.Service
         yield* catalog.transform((catalog) => {
-          const provider = Provider.Info.make({
-            ...Provider.Info.empty(Provider.ID.opencode),
-            package: Provider.aisdk("test-provider"),
-            settings: { apiKey: "configured" },
-          })
-          const model = Model.Info.make({
-            ...Model.Info.default(provider.id, Model.ID.make("paid")),
-            modelID: Model.ID.make("paid"),
-            package: Provider.aisdk("test-provider"),
-            cost: cost(1),
-          })
-          catalog.provider.update(provider.id, (draft) => {
-            draft.package = provider.package
+          catalog.provider.update(Provider.ID.opencode, (draft) => {
+            draft.package = Provider.aisdk("test-provider")
             draft.settings = { apiKey: "configured" }
           })
-          catalog.model.update(provider.id, model.id, (draft) => {
-            draft.cost = [...model.cost]
+          catalog.model.update(Provider.ID.opencode, Model.ID.make("paid"), (draft) => {
+            draft.cost = cost(1)
           })
         })
         yield* addPlugin()
@@ -542,19 +461,9 @@ describe("OpencodePlugin", () => {
       Effect.gen(function* () {
         const catalog = yield* Catalog.Service
         yield* catalog.transform((catalog) => {
-          const provider = Provider.Info.make({
-            ...Provider.Info.empty(Provider.ID.openai),
-            package: Provider.aisdk("test-provider"),
-          })
-          const model = Model.Info.make({
-            ...Model.Info.default(provider.id, Model.ID.make("paid")),
-            modelID: Model.ID.make("paid"),
-            package: Provider.aisdk("test-provider"),
-            cost: cost(1),
-          })
-          catalog.provider.update(provider.id, () => {})
-          catalog.model.update(provider.id, model.id, (draft) => {
-            draft.cost = [...model.cost]
+          catalog.provider.update(Provider.ID.openai, () => {})
+          catalog.model.update(Provider.ID.openai, Model.ID.make("paid"), (draft) => {
+            draft.cost = cost(1)
           })
         })
         yield* addPlugin()

packages/core/test/plugin/provider-openrouter.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect } from "bun:test"
+import { describe, expect, test } from "bun:test"
 import { Effect } from "effect"
 import { Catalog } from "@opencode-ai/core/catalog"
 import { Model } from "@opencode-ai/core/model"
@@ -19,9 +19,9 @@ const addPlugin = Effect.fn(function* () {
 })
 
 describe("OpenRouterPlugin", () => {
-  it.effect("is registered so legacy OpenRouter behavior can be applied", () =>
-    Effect.sync(() => expect(ProviderPlugins.map((item) => item.id)).toContain("opencode.provider.openrouter")),
-  )
+  test("is registered so legacy OpenRouter behavior can be applied", () => {
+    expect(ProviderPlugins.map((item) => item.id)).toContain("opencode.provider.openrouter")
+  })
 
   it.effect("applies legacy referer headers only to openrouter", () =>
     Effect.gen(function* () {