fix(opencode): map filesystem client errors

.github/workflows/test.yml

@@ -99,7 +99,8 @@ jobs:
       - name: Setup Node
         uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4.4.0
         with:
-          node-version: "24"
+          # Playwright 1.59 hangs while extracting Chromium with Node 24.16.
+          node-version: "24.15"
 
       - name: Setup Bun
         uses: ./.github/actions/setup-bun

bun.lock

@@ -276,6 +276,7 @@
         "@opencode-ai/effect-drizzle-sqlite": "workspace:*",
         "@opencode-ai/effect-sqlite-node": "workspace:*",
         "@opencode-ai/llm": "workspace:*",
+        "@opencode-ai/plugin": "workspace:*",
         "@openrouter/ai-sdk-provider": "2.9.0",
         "@opentelemetry/api": "1.9.0",
         "@opentelemetry/context-async-hooks": "2.6.1",
@@ -625,6 +626,7 @@
       "name": "@opencode-ai/plugin",
       "version": "1.17.9",
       "dependencies": {
+        "@ai-sdk/provider": "3.0.8",
         "@opencode-ai/sdk": "workspace:*",
         "effect": "catalog:",
         "zod": "catalog:",

nix/hashes.json

@@ -1,8 +1,8 @@
 {
   "nodeModules": {
-    "x86_64-linux": "sha256-g0tDvRf7MErZ1PEeUazEYi492ZHiRT8kYv3bPdkss/I=",
+    "x86_64-linux": "sha256-oWSGu+SP66Aquy/0Vaq7Bgp8404ZdOWbQX+O7h3jxHU=",
-    "aarch64-linux": "sha256-6sKgf3ftbIqlPxlFkoPzoWPsJp3IwXD+H3Y6g874xmk=",
+    "aarch64-linux": "sha256-UsS0+c+GwtIukmWwQeFbY/3Oaz3t4Q7C6cFMGkmlyAY=",
-    "aarch64-darwin": "sha256-Se/Nls/KlkuK2ysDQ9DeAzSaX3NsL2iDdf/dsv2GIXc=",
+    "aarch64-darwin": "sha256-CArz92ewPmXO+ORFCBkCH8LzMpU/DjyaO4ic7QL0UpI=",
-    "x86_64-darwin": "sha256-V9MCkqnvQ1nkD2PaaTfNFKkBZGymj6KxrSAK6+DTF8Y="
+    "x86_64-darwin": "sha256-rhnz9gmG6L06wIzfMhTaXDDEf6IbMD32CavqwXoqcUs="
   }
 }

packages/core/package.json

@@ -91,6 +91,7 @@
     "@opencode-ai/effect-drizzle-sqlite": "workspace:*",
     "@opencode-ai/effect-sqlite-node": "workspace:*",
     "@opencode-ai/llm": "workspace:*",
+    "@opencode-ai/plugin": "workspace:*",
     "@opentelemetry/api": "1.9.0",
     "@opentelemetry/context-async-hooks": "2.6.1",
     "@opentelemetry/exporter-trace-otlp-http": "0.214.0",

packages/core/src/agent.ts

@@ -1,7 +1,6 @@
 export * as AgentV2 from "./agent"
 
-import { Array, Context, Effect, Layer, Schema, Scope } from "effect"
+import { Array, Context, Effect, Layer, Schema, Scope, Types } from "effect"
-import { castDraft, enableMapSet, type Draft } from "immer"
 import { ModelV2 } from "./model"
 import { PermissionSchema } from "./permission/schema"
 import { ProviderV2 } from "./provider"
@@ -49,21 +48,19 @@ export interface Selection {
 }
 
 type Data = {
-  agents: Map<ID, Info>
+  agents: Map<ID, Types.DeepMutable<Info>>
   default?: ID
 }
 
-export type Editor = {
+export type Draft = {
   list: () => readonly Info[]
   get: (id: ID) => Info | undefined
   default: (id: ID | undefined) => void
-  update: (id: ID, fn: (agent: Draft<Info>) => void) => void
+  update: (id: ID, fn: (agent: Types.DeepMutable<Info>) => void) => void
   remove: (id: ID) => void
 }
 
-export interface Interface {
+export interface Interface extends State.Transformable<Draft> {
-  readonly transform: State.Interface<Data, Editor>["transform"]
-  readonly update: State.Interface<Data, Editor>["update"]
   readonly get: (id: ID) => Effect.Effect<Info | undefined>
   readonly default: () => Effect.Effect<Info | undefined>
   readonly resolve: (id?: ID | string) => Effect.Effect<Info | undefined>
@@ -73,21 +70,19 @@ export interface Interface {
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/v2/Agent") {}
 
-enableMapSet()
-
 export const layer = Layer.effect(
   Service,
   Effect.gen(function* () {
-    const state = State.create<Data, Editor>({
+    const state = State.create<Data, Draft>({
       initial: () => ({ agents: new Map() }),
-      editor: (draft) => ({
+      draft: (draft) => ({
         list: () => Array.fromIterable(draft.agents.values()) as Info[],
         get: (id) => draft.agents.get(id),
         default: (id) => {
           draft.default = id
         },
         update: (id, fn) => {
-          const current = draft.agents.get(id) ?? castDraft(Info.empty(id))
+          const current = draft.agents.get(id) ?? (Info.empty(id) as Types.DeepMutable<Info>)
           if (!draft.agents.has(id)) draft.agents.set(id, current)
           fn(current)
           current.id = id
@@ -113,7 +108,7 @@ export const layer = Layer.effect(
 
     return Service.of({
       transform: state.transform,
-      update: state.update,
+      rebuild: state.rebuild,
       get: Effect.fn("AgentV2.get")(function* (id) {
         return state.get().agents.get(id)
       }),

packages/core/src/catalog.ts

@@ -1,36 +1,21 @@
 export * as Catalog from "./catalog"
 
-import { Array, Context, Effect, Layer, Option, Order, pipe, Schema, Scope, Stream } from "effect"
+import { Array, Context, Effect, Layer, Option, Order, pipe, Schema } from "effect"
-import { castDraft, enableMapSet, type Draft } from "immer"
 import { ModelV2 } from "./model"
 import { ModelRequest } from "./model-request"
-import { PluginV2 } from "./plugin"
 import { ProviderV2 } from "./provider"
-import { Location } from "./location"
 import { EventV2 } from "./event"
 import { Policy } from "./policy"
 import { State } from "./state"
 import { Integration } from "./integration"
 
 export type ProviderRecord = {
-  provider: ProviderV2.Info
+  provider: ProviderV2.MutableInfo
-  models: Map<ModelV2.ID, ModelV2.Info>
+  models: Map<ModelV2.ID, ModelV2.MutableInfo>
 }
 
 export type DefaultModel = { providerID: ProviderV2.ID; modelID: ModelV2.ID }
 
-export class ProviderNotFoundError extends Schema.TaggedErrorClass<ProviderNotFoundError>()(
-  "CatalogV2.ProviderNotFound",
-  {
-    providerID: ProviderV2.ID,
-  },
-) {}
-
-export class ModelNotFoundError extends Schema.TaggedErrorClass<ModelNotFoundError>()("CatalogV2.ModelNotFound", {
-  providerID: ProviderV2.ID,
-  modelID: ModelV2.ID,
-}) {}
-
 export const PolicyActions = Schema.Literals(["provider.use"])
 
 export const Event = {
@@ -42,16 +27,16 @@ type Data = {
   defaultModel?: DefaultModel
 }
 
-export type Editor = {
+export type Draft = {
   provider: {
     list: () => readonly ProviderRecord[]
     get: (providerID: ProviderV2.ID) => ProviderRecord | undefined
-    update: (providerID: ProviderV2.ID, fn: (provider: Draft<ProviderV2.Info>) => void) => void
+    update: (providerID: ProviderV2.ID, fn: (provider: ProviderV2.MutableInfo) => void) => void
     remove: (providerID: ProviderV2.ID) => void
   }
   model: {
     get: (providerID: ProviderV2.ID, modelID: ModelV2.ID) => ModelV2.Info | undefined
-    update: (providerID: ProviderV2.ID, modelID: ModelV2.ID, fn: (model: Draft<ModelV2.Info>) => void) => void
+    update: (providerID: ProviderV2.ID, modelID: ModelV2.ID, fn: (model: ModelV2.MutableInfo) => void) => void
     remove: (providerID: ProviderV2.ID, modelID: ModelV2.ID) => void
     default: {
       get: () => DefaultModel | undefined
@@ -60,38 +45,29 @@ export type Editor = {
   }
 }
 
-export interface Interface {
+export interface Interface extends State.Transformable<Draft> {
-  readonly transform: State.Interface<Data, Editor>["transform"]
   readonly provider: {
-    readonly get: (providerID: ProviderV2.ID) => Effect.Effect<ProviderV2.Info, ProviderNotFoundError>
+    readonly get: (providerID: ProviderV2.ID) => Effect.Effect<ProviderV2.Info | undefined>
     readonly all: () => Effect.Effect<ProviderV2.Info[]>
     readonly available: () => Effect.Effect<ProviderV2.Info[]>
   }
   readonly model: {
-    readonly get: (
+    readonly get: (providerID: ProviderV2.ID, modelID: ModelV2.ID) => Effect.Effect<ModelV2.Info | undefined>
-      providerID: ProviderV2.ID,
-      modelID: ModelV2.ID,
-    ) => Effect.Effect<ModelV2.Info, ProviderNotFoundError | ModelNotFoundError>
     readonly all: () => Effect.Effect<ModelV2.Info[]>
     readonly available: () => Effect.Effect<ModelV2.Info[]>
-    readonly default: () => Effect.Effect<Option.Option<ModelV2.Info>>
+    readonly default: () => Effect.Effect<ModelV2.Info | undefined>
-    readonly small: (providerID: ProviderV2.ID) => Effect.Effect<Option.Option<ModelV2.Info>>
+    readonly small: (providerID: ProviderV2.ID) => Effect.Effect<ModelV2.Info | undefined>
   }
 }
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/v2/Catalog") {}
 
-enableMapSet()
-
 export const layer = Layer.effect(
   Service,
   Effect.gen(function* () {
-    const location = yield* Location.Service
-    const plugin = yield* PluginV2.Service
     const events = yield* EventV2.Service
     const policy = yield* Policy.Service
     const integrations = yield* Integration.Service
-    const scope = yield* Scope.Scope
 
     const available = (provider: ProviderV2.Info, integration: Integration.Info | undefined, connected: boolean) => {
       if (provider.disabled) return false
@@ -120,32 +96,26 @@ export const layer = Layer.effect(
       })
     }
 
-    function* getRecord(providerID: ProviderV2.ID) {
+    const normalizeApi = (item: ProviderV2.MutableInfo | ModelV2.MutableInfo) => {
-      const match = state.get().providers.get(providerID)
-      if (!match) return yield* new ProviderNotFoundError({ providerID })
-      return match
-    }
-
-    const normalizeApi = (item: Draft<ProviderV2.Info> | Draft<ModelV2.Info>) => {
       if (typeof item.request.body.baseURL !== "string") return
       item.api.url = item.request.body.baseURL
       delete item.request.body.baseURL
     }
 
-    const state = State.create<Data, Editor>({
+    const state = State.create<Data, Draft>({
       initial: () => ({ providers: new Map() }),
-      editor: (draft) => {
+      draft: (draft) => {
-        const result: Editor = {
+        const result: Draft = {
           provider: {
             list: () => Array.fromIterable(draft.providers.values()) as ProviderRecord[],
             get: (providerID) => draft.providers.get(providerID),
             update: (providerID, fn) => {
               let current = draft.providers.get(providerID)
               if (!current) {
-                current = castDraft({
+                current = {
-                  provider: ProviderV2.Info.empty(providerID),
+                  provider: ProviderV2.Info.empty(providerID) as ProviderV2.MutableInfo,
-                  models: new Map<ModelV2.ID, ModelV2.Info>(),
+                  models: new Map<ModelV2.ID, ModelV2.MutableInfo>(),
-                })
+                }
                 draft.providers.set(providerID, current)
               }
               fn(current.provider)
@@ -160,13 +130,14 @@ export const layer = Layer.effect(
             update: (providerID, modelID, fn) => {
               let record = draft.providers.get(providerID)
               if (!record) {
-                record = castDraft({
+                record = {
-                  provider: ProviderV2.Info.empty(providerID),
+                  provider: ProviderV2.Info.empty(providerID) as ProviderV2.MutableInfo,
-                  models: new Map<ModelV2.ID, ModelV2.Info>(),
+                  models: new Map<ModelV2.ID, ModelV2.MutableInfo>(),
-                })
+                }
                 draft.providers.set(providerID, record)
               }
-              const model = record.models.get(modelID) ?? castDraft(ModelV2.Info.empty(providerID, modelID))
+              const model =
+                record.models.get(modelID) ?? (ModelV2.Info.empty(providerID, modelID) as ModelV2.MutableInfo)
               if (!record.models.has(modelID)) record.models.set(modelID, model)
               fn(model)
               model.id = modelID
@@ -186,8 +157,7 @@ export const layer = Layer.effect(
         }
         return result
       },
-      finalize: Effect.fn("CatalogV2.finalize")(function* (catalog, reason) {
+      finalize: Effect.fn("CatalogV2.finalize")(function* (catalog) {
-        if (reason !== "plugin.added") yield* plugin.trigger("catalog.transform", catalog, {}).pipe(Effect.asVoid)
         if (policy.hasStatements()) {
           for (const record of [...catalog.provider.list()]) {
             if ((yield* policy.evaluate("provider.use", record.provider.id, "allow")) === "deny") {
@@ -198,25 +168,13 @@ export const layer = Layer.effect(
         yield* events.publish(Event.Updated, {})
       }),
     })
-    yield* events.subscribe(PluginV2.Event.Added).pipe(
-      // Plugin registries are location scoped even though the event bus is process scoped.
-      Stream.filter(
-        (event) =>
-          event.location?.directory === location.directory && event.location.workspaceID === location.workspaceID,
-      ),
-      Stream.runForEach((event) =>
-        state.mutate((catalog) => plugin.triggerFor(event.data.id, "catalog.transform", catalog, {}), "plugin.added"),
-      ),
-      Effect.forkIn(scope, { startImmediately: true }),
-    )
-
     const result: Interface = {
       transform: state.transform,
+      rebuild: state.rebuild,
 
       provider: {
         get: Effect.fn("CatalogV2.provider.get")(function* (providerID) {
-          const record = yield* getRecord(providerID)
+          return state.get().providers.get(providerID)?.provider
-          return record.provider
         }),
 
         all: Effect.fn("CatalogV2.provider.all")(function* () {
@@ -238,10 +196,10 @@ export const layer = Layer.effect(
 
       model: {
         get: Effect.fn("CatalogV2.model.get")(function* (providerID, modelID) {
-          const record = yield* getRecord(providerID)
+          const record = state.get().providers.get(providerID)
+          if (!record) return
           const model = record.models.get(modelID)
-          if (!model) return yield* new ModelNotFoundError({ providerID, modelID })
+          return model && projectModel(model, record.provider)
-          return projectModel(model, record.provider)
         }),
 
         all: Effect.fn("CatalogV2.model.all")(function* () {
@@ -250,7 +208,7 @@ export const layer = Layer.effect(
             Array.flatMap((record) => {
               return Array.fromIterable(record.models.values()).map((model) => projectModel(model, record.provider))
             }),
-            Array.sortWith((item) => item.time.released.epochMilliseconds, Order.flip(Order.Number)),
+            Array.sortWith((item) => item.time.released, Order.flip(Order.Number)),
           )
         }),
 
@@ -262,31 +220,30 @@ export const layer = Layer.effect(
         default: Effect.fn("CatalogV2.model.default")(function* () {
           const defaultModel = state.get().defaultModel
           if (defaultModel) {
-            const provider = yield* result.provider.get(defaultModel.providerID).pipe(Effect.option)
+            const provider = yield* result.provider.get(defaultModel.providerID)
-            if (
+            if (provider && (yield* result.provider.available()).some((item) => item.id === provider.id)) {
-              Option.isSome(provider) &&
+              const model = yield* result.model.get(defaultModel.providerID, defaultModel.modelID)
-              (yield* result.provider.available()).some((item) => item.id === provider.value.id)
+              if (model?.enabled) return model
-            ) {
-              const model = yield* result.model.get(defaultModel.providerID, defaultModel.modelID).pipe(Effect.option)
-              if (Option.isSome(model) && model.value.enabled) return model
             }
           }
 
-          return pipe(
+          return Option.getOrUndefined(
+            pipe(
               yield* result.model.available(),
-            Array.sortWith((item) => item.time.released.epochMilliseconds, Order.flip(Order.Number)),
+              Array.sortWith((item) => item.time.released, Order.flip(Order.Number)),
               Array.head,
+            ),
           )
         }),
 
         small: Effect.fn("CatalogV2.model.small")(function* (providerID) {
           const record = state.get().providers.get(providerID)
-          if (!record) return Option.none<ModelV2.Info>()
+          if (!record) return
           const provider = record.provider
 
           if (providerID === ProviderV2.ID.opencode) {
             const gpt5Nano = record.models.get(ModelV2.ID.make("gpt-5-nano"))
-            if (gpt5Nano?.enabled && gpt5Nano.status === "active") return Option.some(projectModel(gpt5Nano, provider))
+            if (gpt5Nano?.enabled && gpt5Nano.status === "active") return projectModel(gpt5Nano, provider)
           }
 
           const candidates = pipe(
@@ -302,7 +259,7 @@ export const layer = Layer.effect(
             Array.map((model) => ({
               model,
               cost: model.cost[0] ? model.cost[0].input + model.cost[0].output : 999,
-              age: (Date.now() - model.time.released.epochMilliseconds) / (1000 * 60 * 60 * 24 * 30),
+              age: (Date.now() - model.time.released) / (1000 * 60 * 60 * 24 * 30),
               small: SMALL_MODEL_RE.test(`${model.id} ${model.family ?? ""} ${model.name}`.toLowerCase()),
             })),
             Array.filter((item) => item.cost > 0 && item.age <= 18),
@@ -319,10 +276,12 @@ export const layer = Layer.effect(
             )
           }
 
-          return pipe(
+          return Option.getOrUndefined(
+            pipe(
               candidates,
               Array.filter((item) => item.small),
               (items) => (items.length > 0 ? pick(items) : pick(candidates)),
+            ),
           )
         }),
       },
@@ -336,6 +295,5 @@ const SMALL_MODEL_RE = /\b(nano|flash|lite|mini|haiku|small|fast)\b/
 
 export const locationLayer = layer.pipe(
   Layer.provideMerge(Integration.locationLayer),
-  Layer.provideMerge(PluginV2.locationLayer),
   Layer.provideMerge(Policy.locationLayer),
 )

packages/core/src/command.ts

@@ -1,7 +1,6 @@
 export * as CommandV2 from "./command"
 
-import { Context, Effect, Layer, Schema } from "effect"
+import { Context, Effect, Layer, Schema, Types } from "effect"
-import { castDraft, type Draft } from "immer"
 import { ModelV2 } from "./model"
 import { State } from "./state"
 
@@ -15,19 +14,17 @@ export class Info extends Schema.Class<Info>("CommandV2.Info")({
 }) {}
 
 export type Data = {
-  commands: Map<string, Info>
+  commands: Map<string, Types.DeepMutable<Info>>
 }
 
-export type Editor = {
+export type Draft = {
   list: () => readonly Info[]
   get: (name: string) => Info | undefined
-  update: (name: string, update: (command: Draft<Info>) => void) => void
+  update: (name: string, update: (command: Types.DeepMutable<Info>) => void) => void
   remove: (name: string) => void
 }
 
-export interface Interface {
+export interface Interface extends State.Transformable<Draft> {
-  readonly transform: State.Interface<Data, Editor>["transform"]
-  readonly update: State.Interface<Data, Editor>["update"]
   readonly get: (name: string) => Effect.Effect<Info | undefined>
   readonly list: () => Effect.Effect<Info[]>
 }
@@ -37,13 +34,13 @@ export class Service extends Context.Service<Service, Interface>()("@opencode/v2
 export const layer = Layer.effect(
   Service,
   Effect.sync(() => {
-    const state = State.create<Data, Editor>({
+    const state = State.create<Data, Draft>({
       initial: () => ({ commands: new Map() }),
-      editor: (draft) => ({
+      draft: (draft) => ({
         list: () => Array.from(draft.commands.values()) as Info[],
         get: (name) => draft.commands.get(name),
         update: (name, update) => {
-          const current = draft.commands.get(name) ?? castDraft(new Info({ name, template: "" }))
+          const current = draft.commands.get(name) ?? (new Info({ name, template: "" }) as Types.DeepMutable<Info>)
           if (!draft.commands.has(name)) draft.commands.set(name, current)
           update(current)
           current.name = name
@@ -55,7 +52,7 @@ export const layer = Layer.effect(
     })
 
     return Service.of({
-      update: state.update,
+      rebuild: state.rebuild,
       transform: state.transform,
       get: Effect.fn("CommandV2.get")(function* (name) {
         return state.get().commands.get(name)

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

@@ -1,5 +1,6 @@
 export * as ConfigAgentPlugin from "./agent"
 
+import { define } from "@opencode-ai/plugin/v2/effect"
 import path from "path"
 import { Effect, Option, Schema } from "effect"
 import { AgentV2 } from "../../agent"
@@ -8,7 +9,6 @@ import { ConfigAgent } from "../agent"
 import { ConfigMarkdown } from "../markdown"
 import { FSUtil } from "../../fs-util"
 import { ModelV2 } from "../../model"
-import { PluginV2 } from "../../plugin"
 import { ConfigAgentV1 } from "../../v1/config/agent"
 import { ConfigMigrateV1 } from "../../v1/config/migrate"
 
@@ -33,12 +33,13 @@ const agentKeys = new Set([
   "permissions",
 ])
 
-export const Plugin = PluginV2.define({
+export const Plugin = define({
-  id: PluginV2.ID.make("config-agent"),
+  id: "config-agent",
-  effect: Effect.gen(function* () {
+  effect: Effect.fn(function* (ctx) {
-    const agent = yield* AgentV2.Service
     const config = yield* Config.Service
     const fs = yield* FSUtil.Service
+    yield* ctx.agent.transform(
+      Effect.fn(function* (draft) {
         const documents = yield* Effect.forEach(yield* config.entries(), (entry) => {
           if (entry.type === "document") return Effect.succeed([entry])
           return Effect.gen(function* () {
@@ -55,25 +56,23 @@ export const Plugin = PluginV2.define({
             )
           })
         }).pipe(Effect.map((documents) => documents.flat()))
-
-    yield* agent.update((editor) => {
         const global = documents.flatMap((document) => document.info.permissions ?? [])
         const configuredDefault = Config.latest(documents, "default_agent")
-      if (configuredDefault !== undefined) editor.default(AgentV2.ID.make(configuredDefault))
+        if (configuredDefault !== undefined) draft.default(AgentV2.ID.make(configuredDefault))
-      for (const current of editor.list()) {
+        for (const current of draft.list()) {
-        editor.update(current.id, (agent) => agent.permissions.push(...global))
+          draft.update(current.id, (agent) => agent.permissions.push(...global))
         }
 
         for (const document of documents) {
           for (const [id, item] of Object.entries(document.info.agents ?? {})) {
             const agentID = AgentV2.ID.make(id)
             if (item.disabled) {
-            editor.remove(agentID)
+              draft.remove(agentID)
               continue
             }
 
-          const exists = editor.get(agentID) !== undefined
+            const exists = draft.get(agentID) !== undefined
-          editor.update(agentID, (agent) => {
+            draft.update(agentID, (agent) => {
               if (!exists) agent.permissions.push(...global)
               if (item.model !== undefined) {
                 const model = ModelV2.parse(item.model)
@@ -96,7 +95,8 @@ export const Plugin = PluginV2.define({
             })
           }
         }
-    })
+      }),
+    )
   }),
 })
 

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

@@ -1,24 +1,24 @@
 export * as ConfigCommandPlugin from "./command"
 
+import { define } from "@opencode-ai/plugin/v2/effect"
 import path from "path"
 import { Effect, Option, Schema } from "effect"
 import { CommandV2 } from "../../command"
 import { Config } from "../../config"
 import { FSUtil } from "../../fs-util"
 import { ModelV2 } from "../../model"
-import { PluginV2 } from "../../plugin"
 import { ConfigCommand } from "../command"
 import { ConfigMarkdown } from "../markdown"
 
 const decodeCommand = Schema.decodeUnknownOption(ConfigCommand.Info)
 
-export const Plugin = PluginV2.define({
+export const Plugin = define({
-  id: PluginV2.ID.make("config-command"),
+  id: "config-command",
-  effect: Effect.gen(function* () {
+  effect: Effect.fn(function* (ctx) {
-    const command = yield* CommandV2.Service
     const config = yield* Config.Service
     const fs = yield* FSUtil.Service
-    const transform = yield* command.transform()
+    yield* ctx.command.transform(
+      Effect.fn(function* (draft) {
         const documents = yield* Effect.forEach(yield* config.entries(), (entry) => {
           if (entry.type === "document") return Effect.succeed([{ commands: entry.info.commands }])
           return loadDirectory(fs, entry.path).pipe(
@@ -27,11 +27,9 @@ export const Plugin = PluginV2.define({
             ]),
           )
         }).pipe(Effect.map((documents) => documents.flat()))
-
-    yield* transform((editor) => {
         for (const document of documents) {
           for (const [name, command] of Object.entries(document.commands ?? {})) {
-          editor.update(name, (item) => {
+            draft.update(name, (item) => {
               item.template = command.template
               if (command.description !== undefined) item.description = command.description
               if (command.agent !== undefined) item.agent = command.agent
@@ -46,7 +44,8 @@ export const Plugin = PluginV2.define({
             })
           }
         }
-    })
+      }),
+    )
   }),
 })
 

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

@@ -1,33 +1,29 @@
 export * as ConfigProviderPlugin from "./provider"
 
+import { define } from "@opencode-ai/plugin/v2/effect"
 import { Effect } from "effect"
-import { Catalog } from "../../catalog"
 import { Config } from "../../config"
-import { Integration } from "../../integration"
 import { ModelV2 } from "../../model"
 import { ModelRequest } from "../../model-request"
-import { PluginV2 } from "../../plugin"
 import { ProviderV2 } from "../../provider"
 
-export const Plugin = PluginV2.define({
+export const Plugin = define({
-  id: PluginV2.ID.make("config-provider"),
+  id: "config-provider",
-  effect: Effect.gen(function* () {
+  effect: Effect.fn(function* (ctx) {
-    const catalog = yield* Catalog.Service
     const config = yield* Config.Service
-    const integrations = yield* Integration.Service
+    yield* ctx.integration.transform(
-    const transform = yield* catalog.transform()
+      Effect.fn(function* (integrations) {
-    const integrationTransform = yield* integrations.transform()
+        const files = (yield* config.entries()).filter((entry): entry is Config.Document => entry.type === "document")
-    const entries = yield* config.entries()
-    const files = entries.filter((entry): entry is Config.Document => entry.type === "document")
         const configuredIntegrations = new Set(
           files.flatMap((file) =>
-        Object.entries(file.info.providers ?? {}).flatMap(([id, provider]) => (provider.env === undefined ? [] : [id])),
+            Object.entries(file.info.providers ?? {}).flatMap(([id, provider]) =>
+              provider.env === undefined ? [] : [id],
+            ),
           ),
         )
-    yield* integrationTransform((integrations) => {
         for (const file of files) {
           for (const [id, item] of Object.entries(file.info.providers ?? {})) {
-          const integrationID = Integration.ID.make(id)
+            const integrationID = id
             if (!configuredIntegrations.has(id) && !integrations.get(integrationID)) continue
             integrations.update(integrationID, (integration) => {
               integration.name = item.name ?? integration.name
@@ -40,9 +36,13 @@ export const Plugin = PluginV2.define({
             }
           }
         }
-    })
+      }),
+    )
 
-    yield* transform((catalog) => {
+    yield* ctx.catalog.transform(
+      Effect.fn(function* (catalog) {
+        const entries = yield* config.entries()
+        const files = entries.filter((entry): entry is Config.Document => entry.type === "document")
         const configuredDefault = Config.latest(entries, "model")
         if (configuredDefault !== undefined) {
           const model = ModelV2.parse(configuredDefault)
@@ -50,7 +50,7 @@ export const Plugin = PluginV2.define({
         }
         for (const file of files) {
           for (const [id, item] of Object.entries(file.info.providers ?? {})) {
-          const providerID = ProviderV2.ID.make(id)
+            const providerID = id
             catalog.provider.update(providerID, (provider) => {
               if (item.name !== undefined) provider.name = item.name
               if (item.api !== undefined) provider.api = { ...item.api }
@@ -63,7 +63,7 @@ export const Plugin = PluginV2.define({
             const providerPackage = providerApi?.type === "aisdk" ? providerApi.package : undefined
 
             for (const [id, config] of Object.entries(item.models ?? {})) {
-            catalog.model.update(providerID, ModelV2.ID.make(id), (model) => {
+              catalog.model.update(providerID, id, (model) => {
                 if (config.family !== undefined) model.family = config.family
                 if (config.name !== undefined) model.name = config.name
                 if (config.api !== undefined) model.api = { ...model.api, ...config.api }
@@ -118,6 +118,7 @@ export const Plugin = PluginV2.define({
             }
           }
         }
-    })
+      }),
+    )
   }),
 })

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

@@ -1,28 +1,24 @@
 export * as ConfigReferencePlugin from "./reference"
 
+import { define } from "@opencode-ai/plugin/v2/effect"
 import path from "path"
 import { Effect } from "effect"
 import { Config } from "../../config"
 import { ConfigReference } from "../reference"
-import { Global } from "../../global"
-import { Location } from "../../location"
-import { PluginV2 } from "../../plugin"
 import { Reference } from "../../reference"
 import { AbsolutePath } from "../../schema"
 
-export const Plugin = {
+export const Plugin = define({
-  id: PluginV2.ID.make("core/config-reference"),
+  id: "core/config-reference",
-  effect: Effect.gen(function* () {
+  effect: Effect.fn(function* (ctx) {
     const config = yield* Config.Service
-    const global = yield* Global.Service
+    yield* ctx.reference.transform(
-    const location = yield* Location.Service
+      Effect.fn(function* (draft) {
-    const references = yield* Reference.Service
-    const update = yield* references.transform()
         const entries = new Map<string, Reference.Source>()
         for (const doc of (yield* config.entries()).filter(
           (entry): entry is Config.Document => entry.type === "document",
         )) {
-      const directory = doc.path ? path.dirname(doc.path) : location.directory
+          const directory = doc.path ? path.dirname(doc.path) : ctx.location.directory
           for (const [name, entry] of Object.entries(doc.info.references ?? {})) {
             if (!validAlias(name)) continue
             entries.set(
@@ -31,7 +27,7 @@ export const Plugin = {
                 ? new Reference.LocalSource({
                     type: "local",
                     path: AbsolutePath.make(
-                  localPath(directory, global.home, typeof entry === "string" ? entry : entry.path),
+                      localPath(directory, ctx.path.home, typeof entry === "string" ? entry : entry.path),
                     ),
                     description: typeof entry === "string" ? undefined : entry.description,
                     hidden: typeof entry === "string" ? undefined : entry.hidden,
@@ -46,12 +42,11 @@ export const Plugin = {
             )
           }
         }
-
+        for (const [name, source] of entries) draft.add(name, source)
-    yield* update((editor) => {
-      for (const [name, source] of entries) editor.add(name, source)
-    })
       }),
-}
+    )
+  }),
+})
 
 function validAlias(name: string) {
   return name.length > 0 && !/[\/\s`,]/.test(name)

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

@@ -1,48 +1,45 @@
 export * as ConfigSkillPlugin from "./skill"
 
+import { define } from "@opencode-ai/plugin/v2/effect"
 import path from "path"
 import { Effect } from "effect"
 import { Config } from "../../config"
-import { Global } from "../../global"
-import { Location } from "../../location"
-import { PluginV2 } from "../../plugin"
 import { AbsolutePath } from "../../schema"
 import { SkillV2 } from "../../skill"
 
-export const Plugin = PluginV2.define({
+export const Plugin = define({
-  id: PluginV2.ID.make("config-skill"),
+  id: "config-skill",
-  effect: Effect.gen(function* () {
+  effect: Effect.fn(function* (ctx) {
     const config = yield* Config.Service
-    const global = yield* Global.Service
+    yield* ctx.skill.transform(
-    const location = yield* Location.Service
+      Effect.fn(function* (draft) {
-    const skill = yield* SkillV2.Service
-    const transform = yield* skill.transform()
         const entries = yield* config.entries()
         const directories = entries.flatMap((entry) => (entry.type === "directory" ? [entry.path] : []))
         const items = entries.flatMap((entry) => (entry.type === "document" ? (entry.info.skills ?? []) : []))
-
-    yield* transform((editor) => {
         for (const directory of directories) {
-        editor.source(
+          draft.source(
             new SkillV2.DirectorySource({ type: "directory", path: AbsolutePath.make(path.join(directory, "skill")) }),
           )
-        editor.source(
+          draft.source(
             new SkillV2.DirectorySource({ type: "directory", path: AbsolutePath.make(path.join(directory, "skills")) }),
           )
         }
         for (const item of items) {
           if (URL.canParse(item) && /^(https?:)$/.test(new URL(item).protocol)) {
-          editor.source(new SkillV2.UrlSource({ type: "url", url: item }))
+            draft.source(new SkillV2.UrlSource({ type: "url", url: item }))
             continue
           }
-        const expanded = item.startsWith("~/") ? path.join(global.home, item.slice(2)) : item
+          const expanded = item.startsWith("~/") ? path.join(ctx.path.home, item.slice(2)) : item
-        editor.source(
+          draft.source(
             new SkillV2.DirectorySource({
               type: "directory",
-            path: AbsolutePath.make(path.isAbsolute(expanded) ? expanded : path.join(location.directory, expanded)),
+              path: AbsolutePath.make(
+                path.isAbsolute(expanded) ? expanded : path.join(ctx.location.directory, expanded),
+              ),
             }),
           )
         }
-    })
+      }),
+    )
   }),
 })

packages/core/src/event.ts

@@ -5,7 +5,7 @@ import { and, asc, eq, gt } from "drizzle-orm"
 import { Database } from "./database/database"
 import { EventSequenceTable, EventTable } from "./event/sql"
 import { Location } from "./location"
-import { externalID, type ExternalID, NonNegativeInt, withStatics } from "./schema"
+import { externalID, type ExternalID, withStatics } from "./schema"
 import { Identifier } from "./util/identifier"
 import { LayerNode } from "./effect/layer-node"
 import { isDeepStrictEqual } from "node:util"
@@ -19,16 +19,9 @@ export const ID = Schema.String.check(Schema.isStartsWith("evt_")).pipe(
 )
 export type ID = typeof ID.Type
 
-/**
- * Durable aggregate continuation position for embedded replay streams.
- * TODO: Decide whether a future HTTP / SDK surface should expose an opaque cursor instead.
- */
-export const Cursor = NonNegativeInt.pipe(Schema.brand("EventV2.Cursor"))
-export type Cursor = typeof Cursor.Type
-
 export type Definition<Type extends string = string, DataSchema extends Schema.Top = Schema.Top> = {
   readonly type: Type
-  readonly sync?: {
+  readonly durable?: {
     readonly version: number
     readonly aggregate: string
   }
@@ -41,20 +34,16 @@ export type Payload<D extends Definition = Definition> = {
   readonly id: ID
   readonly type: D["type"]
   readonly data: Data<D>
-  /** Durable aggregate order, populated while synchronized events are projected. */
+  readonly durable?: {
-  readonly seq?: number
+    readonly aggregateID: string
-  readonly version?: number
+    readonly seq: number
+    readonly version: number
+  }
   readonly location?: Location.Ref
   readonly metadata?: Record<string, unknown>
-  /** Internal replay marker for projectors that own non-replicated operational state. */
-  readonly replay?: boolean
 }
 
-export type Projector<D extends Definition = Definition> = (event: Payload<D>) => Effect.Effect<void>
+export type Subscriber<D extends Definition = Definition> = (event: Payload<D>) => Effect.Effect<void>
-type AnyProjector = (event: Payload) => Effect.Effect<void>
-export type CommitGuard = (event: Payload) => Effect.Effect<void>
-export type Listener = (event: Payload) => Effect.Effect<void>
-export type Sync = (event: Payload) => Effect.Effect<void>
 export type Unsubscribe = Effect.Effect<void>
 
 export type SerializedEvent = {
@@ -65,13 +54,8 @@ export type SerializedEvent = {
   readonly data: Record<string, unknown>
 }
 
-export type CursorEvent<E extends Payload = Payload> = {
+export class InvalidDurableEventError extends Schema.TaggedErrorClass<InvalidDurableEventError>()(
-  readonly cursor: Cursor
+  "EventV2.InvalidDurableEvent",
-  readonly event: E
-}
-
-export class InvalidSyncEventError extends Schema.TaggedErrorClass<InvalidSyncEventError>()(
-  "EventV2.InvalidSyncEvent",
   {
     type: Schema.String,
     message: Schema.String,
@@ -83,19 +67,11 @@ export function versionedType(type: string, version: number) {
 }
 
 export const registry = new Map<string, Definition>()
-type SyncDefinition = Definition & {
+const durableRegistry = new Map<string, Definition>()
-  readonly sync: NonNullable<Definition["sync"]>
-  readonly encode: (data: unknown) => unknown
-  readonly decode: (data: unknown) => unknown
-}
-const syncRegistry = new Map<string, SyncDefinition>()
-
-// Synchronized events cross a JSON boundary, so their data schemas must encode and decode without services.
-const syncCodec = (definition: Definition) => definition.data as Schema.Codec<unknown, unknown, never, never>
 
 export function define<const Type extends string, Fields extends Schema.Struct.Fields>(input: {
   readonly type: Type
-  readonly sync?: {
+  readonly durable?: {
     readonly version: number
     readonly aggregate: string
   }
@@ -106,28 +82,25 @@ export function define<const Type extends string, Fields extends Schema.Struct.F
     id: ID,
     metadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
     type: Schema.Literal(input.type),
-    version: Schema.optional(Schema.Number),
+    durable: Schema.optional(Schema.Struct({ aggregateID: Schema.String, seq: Schema.Number, version: Schema.Number })),
     location: Schema.optional(Location.Ref),
     data: Data,
   }).annotate({ identifier: input.type })
 
   const definition = Object.assign(Payload, {
     type: input.type,
-    ...(input.sync === undefined ? {} : { sync: input.sync }),
+    ...(input.durable === undefined ? {} : { durable: input.durable }),
     data: Data,
   })
   const existing = registry.get(input.type)
-  if (input.sync === undefined || existing?.sync === undefined || input.sync.version >= existing.sync.version) {
+  if (
+    input.durable === undefined ||
+    existing?.durable === undefined ||
+    input.durable.version >= existing.durable.version
+  ) {
     registry.set(input.type, definition)
   }
-  if (input.sync)
+  if (input.durable) durableRegistry.set(versionedType(input.type, input.durable.version), definition)
-    syncRegistry.set(
-      versionedType(input.type, input.sync.version),
-      Object.assign(definition, {
-        encode: Schema.encodeUnknownSync(syncCodec(definition)),
-        decode: Schema.decodeUnknownSync(syncCodec(definition)),
-      }) as SyncDefinition,
-    )
   return definition as Schema.Schema<Payload<Definition<Type, Schema.Struct<Fields>>>> &
     Definition<Type, Schema.Struct<Fields>>
 }
@@ -140,7 +113,7 @@ export interface PublishOptions {
   readonly id?: ID
   readonly metadata?: Record<string, unknown>
   readonly location?: Location.Ref
-  /** Local operational projection committed atomically with a new synchronized event. Not replayed or serialized. */
+  /** Local operational projection committed atomically with a new durable event. Not replayed or serialized. */
   readonly commit?: (seq: number) => Effect.Effect<void>
 }
 
@@ -152,14 +125,10 @@ export interface Interface {
   ) => Effect.Effect<Payload<D>>
   readonly subscribe: <D extends Definition>(definition: D) => Stream.Stream<Payload<D>>
   readonly all: () => Stream.Stream<Payload>
-  readonly aggregateEvents: (input: {
+  readonly durable: (input: { readonly aggregateID: string; readonly after?: number }) => Stream.Stream<Payload>
-    readonly aggregateID: string
+  /** @deprecated Use `all()` and consume the returned stream. */
-    readonly after?: Cursor
+  readonly listen: (listener: Subscriber) => Effect.Effect<Unsubscribe>
-  }) => Stream.Stream<CursorEvent>
+  readonly project: <D extends Definition>(definition: D, projector: Subscriber<D>) => Effect.Effect<void>
-  readonly sync: (handler: Sync) => Effect.Effect<Unsubscribe>
-  readonly listen: (listener: Listener) => Effect.Effect<Unsubscribe>
-  readonly beforeCommit: (guard: CommitGuard) => Effect.Effect<void>
-  readonly project: <D extends Definition>(definition: D, projector: Projector<D>) => Effect.Effect<void>
   readonly replay: (
     event: SerializedEvent,
     options?: { readonly publish?: boolean; readonly ownerID?: string; readonly strictOwner?: boolean },
@@ -182,37 +151,37 @@ export const layerWith = (options?: LayerOptions) =>
   Layer.effect(
     Service,
     Effect.gen(function* () {
-      const all = yield* PubSub.unbounded<Payload>()
+      const pubsub = {
-      const synchronized = new Map<string, Set<PubSub.PubSub<void>>>()
+        all: yield* PubSub.unbounded<Payload>(),
-      const typed = new Map<string, PubSub.PubSub<Payload>>()
+        durable: new Map<string, Set<PubSub.PubSub<void>>>(),
-      const projectors = new Map<string, AnyProjector[]>()
+        typed: new Map<string, PubSub.PubSub<Payload>>(),
-      const commitGuards = new Array<CommitGuard>()
+      }
-      const listeners = new Array<Listener>()
+      const projectors = new Map<string, Subscriber[]>()
-      const syncHandlers = new Array<Sync>()
+      const listeners = new Array<Subscriber>()
       const { db } = yield* Database.Service
 
       const getOrCreate = (definition: Definition) =>
         Effect.gen(function* () {
-          const existing = typed.get(definition.type)
+          const existing = pubsub.typed.get(definition.type)
           if (existing) return existing
-          const pubsub = yield* PubSub.unbounded<Payload>()
+          const created = yield* PubSub.unbounded<Payload>()
-          typed.set(definition.type, pubsub)
+          pubsub.typed.set(definition.type, created)
-          return pubsub
+          return created
         })
 
       yield* Effect.addFinalizer(() =>
         Effect.gen(function* () {
-          yield* PubSub.shutdown(all)
+          yield* PubSub.shutdown(pubsub.all)
           yield* Effect.forEach(
-            synchronized.values(),
+            pubsub.durable.values(),
             (pubsubs) => Effect.forEach(pubsubs, PubSub.shutdown, { discard: true }),
             { discard: true },
           )
-          yield* Effect.forEach(typed.values(), PubSub.shutdown, { discard: true })
+          yield* Effect.forEach(pubsub.typed.values(), PubSub.shutdown, { discard: true })
         }),
       )
 
-      function commitSyncEvent(
+      function commitDurableEvent(
         event: Payload,
         input?: {
           readonly seq: number
@@ -224,28 +193,20 @@ export const layerWith = (options?: LayerOptions) =>
       ) {
         return Effect.gen(function* () {
           const definition = registry.get(event.type)
-          const sync = definition?.sync
+          const durable = definition?.durable
-          if (sync) {
+          if (durable) {
-            if (event.version !== sync.version) {
+            const aggregateID = (event.data as Record<string, unknown>)[durable.aggregate]
-              yield* Effect.die(
-                new InvalidSyncEventError({
-                  type: event.type,
-                  message: `Expected event version ${sync.version}, got ${event.version}`,
-                }),
-              )
-            }
-            const aggregateID = (event.data as Record<string, unknown>)[sync.aggregate]
             if (typeof aggregateID !== "string") {
               yield* Effect.die(
-                new InvalidSyncEventError({
+                new InvalidDurableEventError({
                   type: event.type,
-                  message: `Expected string aggregate field ${sync.aggregate}`,
+                  message: `Expected string aggregate field ${durable.aggregate}`,
                 }),
               )
             } else {
               if (input && input.aggregateID !== aggregateID) {
                 yield* Effect.die(
-                  new InvalidSyncEventError({
+                  new InvalidDurableEventError({
                     type: event.type,
                     message: `Aggregate mismatch: expected ${input.aggregateID}, got ${aggregateID}`,
                   }),
@@ -265,12 +226,12 @@ export const layerWith = (options?: LayerOptions) =>
                             .get()
                             .pipe(Effect.orDie)
                           const latest = row?.seq ?? -1
-                          const encoded = syncRegistry
+                          const encoded = Schema.encodeUnknownSync(
-                            .get(versionedType(definition.type, sync.version))!
+                            definition.data as Schema.Codec<unknown, unknown, never, never>,
-                            .encode(event.data) as Record<string, unknown>
+                          )(event.data) as Record<string, unknown>
                           if (input?.strictOwner && row?.ownerID && row.ownerID !== input.ownerID) {
                             yield* Effect.die(
-                              new InvalidSyncEventError({
+                              new InvalidDurableEventError({
                                 type: event.type,
                                 message: `Replay owner mismatch for aggregate ${aggregateID}: expected ${row.ownerID}, got ${input.ownerID ?? "none"}`,
                               }),
@@ -285,7 +246,7 @@ export const layerWith = (options?: LayerOptions) =>
                               .pipe(Effect.orDie)
                             if (
                               stored?.id === event.id &&
-                              stored.type === versionedType(definition.type, sync.version) &&
+                              stored.type === versionedType(definition.type, durable.version) &&
                               isDeepStrictEqual(stored.data, encoded)
                             ) {
                               if (input.ownerID && row?.ownerID == null) {
@@ -299,7 +260,7 @@ export const layerWith = (options?: LayerOptions) =>
                               return
                             }
                             yield* Effect.die(
-                              new InvalidSyncEventError({
+                              new InvalidDurableEventError({
                                 type: event.type,
                                 message: `Replay diverged at aggregate ${aggregateID} sequence ${input.seq}`,
                               }),
@@ -311,7 +272,7 @@ export const layerWith = (options?: LayerOptions) =>
                           const seq = input?.seq ?? latest + 1
                           if (input && seq !== latest + 1) {
                             yield* Effect.die(
-                              new InvalidSyncEventError({
+                              new InvalidDurableEventError({
                                 type: event.type,
                                 message: `Sequence mismatch for aggregate ${aggregateID}: expected ${latest + 1}, got ${seq}`,
                               }),
@@ -325,16 +286,17 @@ export const layerWith = (options?: LayerOptions) =>
                             .pipe(Effect.orDie)
                           if (stored)
                             yield* Effect.die(
-                              new InvalidSyncEventError({
+                              new InvalidDurableEventError({
                                 type: event.type,
                                 message: `Event ${event.id} already exists at aggregate ${stored.aggregateID} sequence ${stored.seq}`,
                               }),
                             )
-                          for (const guard of commitGuards) {
+                          const committed = {
-                            yield* guard(event)
+                            ...event,
-                          }
+                            durable: { aggregateID, seq, version: durable.version },
+                          } as Payload
                           for (const projector of list) {
-                            yield* projector({ ...event, seq } as Payload)
+                            yield* projector(committed)
                           }
                           if (commit) yield* commit(seq)
                           yield* db
@@ -356,7 +318,7 @@ export const layerWith = (options?: LayerOptions) =>
                                 id: event.id,
                                 aggregate_id: aggregateID,
                                 seq,
-                                type: versionedType(definition.type, sync.version),
+                                type: versionedType(definition.type, durable.version),
                                 data: encoded,
                               },
                             ])
@@ -369,8 +331,8 @@ export const layerWith = (options?: LayerOptions) =>
                     .pipe(Effect.orDie)
                   if (committed) {
                     yield* Effect.forEach(
-                      synchronized.get(committed.aggregateID) ?? [],
+                      pubsub.durable.get(committed.aggregateID) ?? [],
-                      (pubsub) => PubSub.publish(pubsub, undefined),
+                      (wake) => PubSub.publish(wake, undefined),
                       { discard: true },
                     )
                   }
@@ -384,19 +346,25 @@ export const layerWith = (options?: LayerOptions) =>
 
       function publishEvent<D extends Definition>(event: Payload<D>, commit?: PublishOptions["commit"]) {
         return Effect.gen(function* () {
-          const durable = registry.get(event.type)?.sync !== undefined
+          const definition = registry.get(event.type)
-          if (!durable && commit)
+          if (!definition?.durable && commit)
             return yield* Effect.die(
-              new InvalidSyncEventError({
+              new InvalidDurableEventError({
                 type: event.type,
-                message: "Local commit hooks require a synchronized event",
+                message: "Local commit hooks require a durable event",
               }),
             )
-          if (durable) {
+          if (definition?.durable) {
-            const committed = yield* commitSyncEvent(event as Payload, undefined, commit)
+            const committed = yield* commitDurableEvent(event as Payload, undefined, commit)
             if (committed) {
-              event = { ...event, seq: committed.seq }
+              event = {
-              yield* Effect.forEach(syncHandlers, (sync) => observe(event as Payload, "sync", sync), { discard: true })
+                ...event,
+                durable: {
+                  aggregateID: committed.aggregateID,
+                  seq: committed.seq,
+                  version: definition.durable.version,
+                },
+              }
               yield* notify(event as Payload, true)
               return event
             }
@@ -406,12 +374,11 @@ export const layerWith = (options?: LayerOptions) =>
         })
       }
 
-      const observe = (event: Payload, kind: "sync" | "listener", observer: (event: Payload) => Effect.Effect<void>) =>
+      const observe = (event: Payload, observer: (event: Payload) => Effect.Effect<void>) =>
         Effect.suspend(() => observer(event)).pipe(
           Effect.catchCauseIf(
             (cause) => !Cause.hasInterrupts(cause),
-            (cause) =>
+            (cause) => Effect.logError("Event listener failed", { eventID: event.id, eventType: event.type, cause }),
-              Effect.logError("Event observer failed", { eventID: event.id, eventType: event.type, kind, cause }),
           ),
         )
 
@@ -419,12 +386,12 @@ export const layerWith = (options?: LayerOptions) =>
         return Effect.gen(function* () {
           yield* Effect.forEach(
             listeners,
-            (listener) => (isolateListeners ? observe(event, "listener", listener) : listener(event)),
+            (listener) => (isolateListeners ? observe(event, listener) : listener(event)),
             { discard: true },
           )
-          const pubsub = typed.get(event.type)
+          const typed = pubsub.typed.get(event.type)
-          if (pubsub) yield* PubSub.publish(pubsub, event)
+          if (typed) yield* PubSub.publish(typed, event)
-          yield* PubSub.publish(all, event)
+          yield* PubSub.publish(pubsub.all, event)
         })
       }
 
@@ -441,7 +408,6 @@ export const layerWith = (options?: LayerOptions) =>
               id: options?.id ?? ID.create(),
               ...(options?.metadata ? { metadata: options.metadata } : {}),
               type: definition.type,
-              ...(definition.sync === undefined ? {} : { version: definition.sync.version }),
               ...(location ? { location } : {}),
               data,
             } as Payload<D>,
@@ -455,27 +421,37 @@ export const layerWith = (options?: LayerOptions) =>
         options?: { readonly publish?: boolean; readonly ownerID?: string; readonly strictOwner?: boolean },
       ) {
         return Effect.gen(function* () {
-          const definition = syncRegistry.get(event.type)
+          const definition = durableRegistry.get(event.type)
-          if (!definition) {
+          if (!definition?.durable) {
             yield* Effect.die(
-              new InvalidSyncEventError({ type: event.type, message: `Unknown sync event type ${event.type}` }),
+              new InvalidDurableEventError({ type: event.type, message: `Unknown durable event type ${event.type}` }),
             )
           } else {
             const payload = {
               id: event.id,
               type: definition.type,
-              version: definition.sync.version,
+              data: Schema.decodeUnknownSync(definition.data as Schema.Codec<unknown, unknown, never, never>)(
-              data: definition.decode(event.data),
+                event.data,
-              replay: true,
+              ),
             } as Payload
-            const committed = yield* commitSyncEvent(payload, {
+            const committed = yield* commitDurableEvent(payload, {
               seq: event.seq,
               aggregateID: event.aggregateID,
               ownerID: options?.ownerID,
               strictOwner: options?.strictOwner,
             })
             if (committed && options?.publish) {
-              yield* notify({ ...payload, seq: committed.seq }, true)
+              yield* notify(
+                {
+                  ...payload,
+                  durable: {
+                    aggregateID: committed.aggregateID,
+                    seq: committed.seq,
+                    version: definition.durable.version,
+                  },
+                },
+                true,
+              )
             }
           }
         })
@@ -490,7 +466,7 @@ export const layerWith = (options?: LayerOptions) =>
           if (!source) return undefined
           if (events.some((event) => event.aggregateID !== source)) {
             yield* Effect.die(
-              new InvalidSyncEventError({
+              new InvalidDurableEventError({
                 type: events[0]?.type ?? "unknown",
                 message: "Replay events must belong to the same aggregate",
               }),
@@ -501,7 +477,7 @@ export const layerWith = (options?: LayerOptions) =>
             const seq = start + index
             if (event.seq !== seq) {
               yield* Effect.die(
-                new InvalidSyncEventError({
+                new InvalidDurableEventError({
                   type: event.type,
                   message: `Replay sequence mismatch at index ${index}: expected ${seq}, got ${event.seq}`,
                 }),
@@ -540,22 +516,18 @@ export const layerWith = (options?: LayerOptions) =>
           Stream.map((event) => event as Payload<D>),
         )
 
-      const streamAll = (): Stream.Stream<Payload> => Stream.fromPubSub(all)
+      const streamAll = (): Stream.Stream<Payload> => Stream.fromPubSub(pubsub.all)
 
-      const decodeSerializedEvent = (event: SerializedEvent): CursorEvent => {
+      const decodeSerializedEvent = (event: SerializedEvent): Payload => {
-        const definition = syncRegistry.get(event.type)
+        const definition = durableRegistry.get(event.type)
-        if (!definition) {
+        if (!definition?.durable) {
-          throw new InvalidSyncEventError({ type: event.type, message: `Unknown sync event type ${event.type}` })
+          throw new InvalidDurableEventError({ type: event.type, message: `Unknown durable event type ${event.type}` })
         }
         return {
-          cursor: Cursor.make(event.seq),
-          event: {
           id: event.id,
           type: definition.type,
-            version: definition.sync.version,
+          durable: { aggregateID: event.aggregateID, seq: event.seq, version: definition.durable.version },
-            seq: event.seq,
+          data: Schema.decodeUnknownSync(definition.data as Schema.Codec<unknown, unknown, never, never>)(event.data),
-            data: definition.decode(event.data),
-          },
         }
       }
 
@@ -583,43 +555,40 @@ export const layerWith = (options?: LayerOptions) =>
           ),
         )
 
-      const subscribeSynchronized = (aggregateID: string) =>
+      const subscribeDurable = (aggregateID: string) =>
         Effect.gen(function* () {
-          const pubsub = yield* PubSub.sliding<void>(1)
+          const wake = yield* PubSub.sliding<void>(1)
-          const subscription = yield* PubSub.subscribe(pubsub)
+          const subscription = yield* PubSub.subscribe(wake)
           yield* Effect.acquireRelease(
             Effect.sync(() => {
-              const pubsubs = synchronized.get(aggregateID) ?? new Set()
+              const wakes = pubsub.durable.get(aggregateID) ?? new Set()
-              pubsubs.add(pubsub)
+              wakes.add(wake)
-              synchronized.set(aggregateID, pubsubs)
+              pubsub.durable.set(aggregateID, wakes)
             }),
             () =>
               Effect.sync(() => {
-                const pubsubs = synchronized.get(aggregateID)
+                const wakes = pubsub.durable.get(aggregateID)
-                pubsubs?.delete(pubsub)
+                wakes?.delete(wake)
-                if (pubsubs?.size === 0) synchronized.delete(aggregateID)
+                if (wakes?.size === 0) pubsub.durable.delete(aggregateID)
-              }).pipe(Effect.andThen(PubSub.shutdown(pubsub))),
+              }).pipe(Effect.andThen(PubSub.shutdown(wake))),
           )
           return subscription
         })
 
-      const streamEvents = (input: {
+      const durable = (input: { readonly aggregateID: string; readonly after?: number }): Stream.Stream<Payload> =>
-        readonly aggregateID: string
-        readonly after?: Cursor
-      }): Stream.Stream<CursorEvent> =>
         Stream.unwrap(
           Effect.gen(function* () {
-            const synchronized = yield* subscribeSynchronized(input.aggregateID)
+            const wakes = yield* subscribeDurable(input.aggregateID)
-            let cursor = input.after ?? -1
+            let sequence = input.after ?? -1
-            const read = Effect.suspend(() => readAfter(input.aggregateID, cursor)).pipe(
+            const read = Effect.suspend(() => readAfter(input.aggregateID, sequence)).pipe(
               Effect.tap((events) =>
                 Effect.sync(() => {
-                  cursor = events.at(-1)?.cursor ?? cursor
+                  sequence = events.at(-1)?.durable?.seq ?? sequence
                 }),
               ),
             )
             const historical = yield* read
-            const live = Stream.fromSubscription(synchronized).pipe(
+            const live = Stream.fromSubscription(wakes).pipe(
               Stream.mapEffect(() => read),
               Stream.flattenIterable,
             )
@@ -627,7 +596,7 @@ export const layerWith = (options?: LayerOptions) =>
           }),
         )
 
-      const listen = (listener: Listener): Effect.Effect<Unsubscribe> =>
+      const listen = (listener: Subscriber): Effect.Effect<Unsubscribe> =>
         Effect.sync(() => {
           listeners.push(listener)
           return Effect.sync(() => {
@@ -636,21 +605,7 @@ export const layerWith = (options?: LayerOptions) =>
           })
         })
 
-      const sync = (handler: Sync): Effect.Effect<Unsubscribe> =>
+      const project = <D extends Definition>(definition: D, projector: Subscriber<D>): Effect.Effect<void> =>
-        Effect.sync(() => {
-          syncHandlers.push(handler)
-          return Effect.sync(() => {
-            const index = syncHandlers.indexOf(handler)
-            if (index >= 0) syncHandlers.splice(index, 1)
-          })
-        })
-
-      const beforeCommit = (guard: CommitGuard): Effect.Effect<void> =>
-        Effect.sync(() => {
-          commitGuards.push(guard)
-        })
-
-      const project = <D extends Definition>(definition: D, projector: Projector<D>): Effect.Effect<void> =>
         Effect.sync(() => {
           const list = projectors.get(definition.type) ?? []
           list.push((event) => projector(event as Payload<D>))
@@ -661,10 +616,8 @@ export const layerWith = (options?: LayerOptions) =>
         publish,
         subscribe,
         all: streamAll,
-        aggregateEvents: streamEvents,
+        durable,
-        sync,
         listen,
-        beforeCommit,
         project,
         replay,
         replayAll,

packages/core/src/filesystem.ts

@@ -7,8 +7,8 @@ import { FSUtil } from "./fs-util"
 import { Location } from "./location"
 import { PositiveInt, RelativePath } from "./schema"
 import { FileSystemSearch } from "./filesystem/search"
-import { Entry, Match } from "./filesystem/schema"
+import { Entry, Match, PathError } from "./filesystem/schema"
-export { Entry, Match, Submatch } from "./filesystem/schema"
+export { Entry, Match, PathError, Submatch } from "./filesystem/schema"
 
 export const ReadInput = Schema.Struct({
   path: RelativePath,
@@ -58,8 +58,10 @@ export const Event = {
 }
 
 export interface Interface {
-  readonly read: (input: ReadInput) => Effect.Effect<{ readonly content: Uint8Array; readonly mime: string }>
+  readonly read: (
-  readonly list: (input?: ListInput) => Effect.Effect<Entry[]>
+    input: ReadInput,
+  ) => Effect.Effect<{ readonly content: Uint8Array; readonly mime: string }, PathError | FSUtil.Error>
+  readonly list: (input?: ListInput) => Effect.Effect<Entry[], PathError | FSUtil.Error>
   readonly find: (input: FindInput) => Effect.Effect<Entry[]>
   readonly glob: (input: GlobInput) => Effect.Effect<readonly Entry[]>
   readonly grep: (input: GrepInput) => Effect.Effect<readonly Match[]>
@@ -77,9 +79,9 @@ const baseLayer = Layer.effect(
     const resolve = Effect.fnUntraced(function* (input?: RelativePath) {
       const absolute = path.resolve(location.directory, input ?? ".")
       if (!FSUtil.contains(location.directory, absolute))
-        return yield* Effect.die(new Error("Path escapes the location"))
+        return yield* new PathError({ path: input ?? ".", reason: "lexical_escape" })
-      const real = yield* fs.realPath(absolute).pipe(Effect.orDie)
+      const real = yield* fs.realPath(absolute)
-      if (!FSUtil.contains(root, real)) return yield* Effect.die(new Error("Path escapes the location"))
+      if (!FSUtil.contains(root, real)) return yield* new PathError({ path: input ?? ".", reason: "symlink_escape" })
       return { absolute, real, directory: location.directory, root }
     })
     return Service.of({
@@ -88,19 +90,18 @@ const baseLayer = Layer.effect(
       grep: search.grep,
       read: Effect.fn("FileSystem.read")(function* (input) {
         const target = yield* resolve(input.path)
-        const info = yield* fs.stat(target.real).pipe(Effect.orDie)
+        const info = yield* fs.stat(target.real)
-        if (info.type !== "File") return yield* Effect.die(new Error("Path is not a file"))
+        if (info.type !== "File") return yield* new PathError({ path: input.path, reason: "not_file" })
         return {
-          content: yield* fs.readFile(target.real).pipe(Effect.orDie),
+          content: yield* fs.readFile(target.real),
           mime: FSUtil.mimeType(target.real),
         }
       }),
       list: Effect.fn("FileSystem.list")(function* (input = {}) {
         const target = yield* resolve(input.path)
-        const info = yield* fs.stat(target.real).pipe(Effect.orDie)
+        const info = yield* fs.stat(target.real)
-        if (info.type !== "Directory") return yield* Effect.die(new Error("Path is not a directory"))
+        if (info.type !== "Directory") return yield* new PathError({ path: input.path ?? ".", reason: "not_directory" })
         return yield* fs.readDirectoryEntries(target.real).pipe(
-          Effect.orDie,
           Effect.map((items) =>
             items
               .flatMap((item) => {

packages/core/src/filesystem/schema.ts

@@ -21,3 +21,8 @@ export class Match extends Schema.Class<Match>("FileSystem.Match")({
   text: Schema.String,
   submatches: Schema.Array(Submatch),
 }) {}
+
+export class PathError extends Schema.TaggedErrorClass<PathError>()("FileSystem.PathError", {
+  path: Schema.String,
+  reason: Schema.Literals(["lexical_escape", "symlink_escape", "not_file", "not_directory"]),
+}) {}

packages/core/src/integration.ts

@@ -1,7 +1,19 @@
 export * as Integration from "./integration"
 
-import { Cause, Clock, Context, Duration, Effect, Exit, Layer, Schedule, Schema, Scope, SynchronizedRef } from "effect"
+import {
-import { castDraft, enableMapSet, type Draft } from "immer"
+  Cause,
+  Clock,
+  Context,
+  Duration,
+  Effect,
+  Exit,
+  Layer,
+  Schedule,
+  Schema,
+  Scope,
+  SynchronizedRef,
+  Types,
+} from "effect"
 import { Credential } from "./credential"
 import { IntegrationSchema } from "./integration/schema"
 import { withStatics } from "./schema"
@@ -42,13 +54,15 @@ export const SelectPrompt = Schema.Struct({
   type: Schema.Literal("select"),
   key: Schema.String,
   message: Schema.String,
-  options: Schema.Array(
+  options: Schema.mutable(
+    Schema.Array(
       Schema.Struct({
         label: Schema.String,
         value: Schema.String,
         hint: Schema.optional(Schema.String),
       }),
     ),
+  ),
   when: Schema.optional(When),
 }).annotate({ identifier: "Integration.SelectPrompt" })
 export type SelectPrompt = typeof SelectPrompt.Type
@@ -60,7 +74,7 @@ export const OAuthMethod = Schema.Struct({
   id: MethodID,
   type: Schema.Literal("oauth"),
   label: Schema.String,
-  prompts: Schema.optional(Schema.Array(Prompt)),
+  prompts: Schema.optional(Schema.mutable(Schema.Array(Prompt))),
 }).annotate({ identifier: "Integration.OAuthMethod" })
 export type OAuthMethod = typeof OAuthMethod.Type
 
@@ -72,7 +86,7 @@ export type KeyMethod = typeof KeyMethod.Type
 
 export const EnvMethod = Schema.Struct({
   type: Schema.Literal("env"),
-  names: Schema.Array(Schema.String),
+  names: Schema.mutable(Schema.Array(Schema.String)),
 }).annotate({ identifier: "Integration.EnvMethod" })
 export type EnvMethod = typeof EnvMethod.Type
 
@@ -82,8 +96,8 @@ export type Method = typeof Method.Type
 export class Info extends Schema.Class<Info>("Integration.Info")({
   id: ID,
   name: Schema.String,
-  methods: Schema.Array(Method),
+  methods: Schema.mutable(Schema.Array(Method)),
-  connections: Schema.Array(IntegrationConnection.Info),
+  connections: Schema.mutable(Schema.Array(IntegrationConnection.Info)),
 }) {}
 
 export type Inputs = Readonly<{ [key: string]: string }>
@@ -172,19 +186,19 @@ export type Ref = {
 }
 
 type Entry = {
-  ref: Ref
+  ref: Types.DeepMutable<Ref>
-  methods: Method[]
+  methods: Types.DeepMutable<Method>[]
-  implementations: Map<MethodID, OAuthImplementation>
+  implementations: Map<MethodID, Types.DeepMutable<OAuthImplementation>>
 }
 
 type Data = {
   integrations: Map<ID, Entry>
 }
 
-export type Editor = {
+export type Draft = {
   list: () => readonly Ref[]
   get: (id: ID) => Ref | undefined
-  update: (id: ID, update: (integration: Draft<Ref>) => void) => void
+  update: (id: ID, update: (integration: Types.DeepMutable<Ref>) => void) => void
   remove: (id: ID) => void
   method: {
     list: (integrationID: ID) => readonly Method[]
@@ -193,11 +207,8 @@ export type Editor = {
   }
 }
 
-export interface Interface {
+export interface Interface extends State.Transformable<Draft> {
   /** Registers a scoped transform over the integration registry. */
-  readonly transform: State.Interface<Data, Editor>["transform"]
-  /** Registers and immediately applies a scoped integration registry update. */
-  readonly update: State.Interface<Data, Editor>["update"]
   /** Returns one integration with its methods and current connections. */
   readonly get: (id: ID) => Effect.Effect<Info | undefined>
   /** Returns all integrations with their methods and current connections. */
@@ -252,8 +263,6 @@ export interface Interface {
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/v2/Integration") {}
 
-enableMapSet()
-
 const attemptLifetime = Duration.toMillis(Duration.minutes(10))
 const terminalRetention = Duration.toMillis(Duration.minutes(1))
 const scrubInterval = Duration.seconds(30)
@@ -284,15 +293,17 @@ export const locationLayer = Layer.effect(
     const events = yield* EventV2.Service
     const scope = yield* Scope.Scope
     const attempts = SynchronizedRef.makeUnsafe(new Map<AttemptID, AttemptEntry>())
-    const state = State.create<Data, Editor>({
+    const state = State.create<Data, Draft>({
       initial: () => ({ integrations: new Map<ID, Entry>() }),
-      editor: (draft) => ({
+      draft: (draft) => ({
         list: () => Array.from(draft.integrations.values(), (entry) => entry.ref) as Ref[],
         get: (id) => draft.integrations.get(id)?.ref as Ref | undefined,
         update: (id, update) => {
-          const current =
+          const current = draft.integrations.get(id) ?? {
-            draft.integrations.get(id) ??
+            ref: { id, name: id },
-            castDraft({ ref: { id, name: id } as Ref, methods: [], implementations: new Map() })
+            methods: [],
+            implementations: new Map(),
+          }
           if (!draft.integrations.has(id)) draft.integrations.set(id, current)
           update(current.ref)
           current.ref.id = id
@@ -301,16 +312,14 @@ export const locationLayer = Layer.effect(
         method: {
           list: (integrationID) => (draft.integrations.get(integrationID)?.methods as Method[] | undefined) ?? [],
           update: (implementation) => {
-            const current =
+            const current = draft.integrations.get(implementation.integrationID) ?? {
-              draft.integrations.get(implementation.integrationID) ??
-              castDraft({
               ref: {
                 id: implementation.integrationID,
                 name: implementation.integrationID,
-                } as Ref,
+              },
               methods: [],
-                implementations: new Map<MethodID, OAuthImplementation>(),
+              implementations: new Map<MethodID, Types.DeepMutable<OAuthImplementation>>(),
-              })
+            }
             if (!draft.integrations.has(implementation.integrationID)) {
               draft.integrations.set(implementation.integrationID, current)
             }
@@ -319,10 +328,13 @@ export const locationLayer = Layer.effect(
               if (method.type !== "oauth" || implementation.method.type !== "oauth") return true
               return method.id === implementation.method.id
             })
-            if (index === -1) current.methods.push(castDraft(implementation.method))
+            if (index === -1) current.methods.push(implementation.method as Types.DeepMutable<Method>)
-            else current.methods[index] = castDraft(implementation.method)
+            else current.methods[index] = implementation.method as Types.DeepMutable<Method>
-            if (isOAuthImplementation(implementation)) {
+            if (implementation.method.type === "oauth") {
-              current.implementations.set(implementation.method.id, castDraft(implementation))
+              current.implementations.set(
+                implementation.method.id,
+                implementation as Types.DeepMutable<OAuthImplementation>,
+              )
             }
           },
           remove: (integrationID, method) => {
@@ -434,7 +446,7 @@ export const locationLayer = Layer.effect(
 
     return Service.of({
       transform: state.transform,
-      update: state.update,
+      rebuild: state.rebuild,
       get: Effect.fn("Integration.get")(function* (id) {
         const entry = state.get().integrations.get(id)
         if (!entry) return undefined

packages/core/src/model-request.ts

@@ -33,7 +33,7 @@ export type Request = typeof Request.Type
 interface MutableRequest {
   headers: Record<string, string>
   body: Record<string, unknown>
-  generation?: Generation
+  generation?: Record<string, unknown>
   options?: Record<string, unknown>
 }
 

packages/core/src/model.ts

@@ -1,5 +1,4 @@
-import { DateTime, Schema } from "effect"
+import { Schema, Types } from "effect"
-import { DateTimeUtcFromMillis } from "effect/Schema"
 import { ProviderV2 } from "./provider"
 import { ModelRequest } from "./model-request"
 
@@ -16,8 +15,8 @@ export type Family = typeof Family.Type
 export const Capabilities = Schema.Struct({
   tools: Schema.Boolean,
   // mime patterns, image, audio, video/*, text/*
-  input: Schema.String.pipe(Schema.Array),
+  input: Schema.String.pipe(Schema.Array, Schema.mutable),
-  output: Schema.String.pipe(Schema.Array),
+  output: Schema.String.pipe(Schema.Array, Schema.mutable),
 })
 export type Capabilities = typeof Capabilities.Type
 
@@ -67,11 +66,11 @@ export class Info extends Schema.Class<Info>("ModelV2.Info")({
   variants: Schema.Struct({
     id: VariantID,
     ...ModelRequest.Request.fields,
-  }).pipe(Schema.Array),
+  }).pipe(Schema.Array, Schema.mutable),
   time: Schema.Struct({
-    released: DateTimeUtcFromMillis,
+    released: Schema.Finite,
   }),
-  cost: Cost.pipe(Schema.Array),
+  cost: Cost.pipe(Schema.Array, Schema.mutable),
   status: Schema.Literals(["alpha", "beta", "deprecated", "active"]),
   enabled: Schema.Boolean,
   limit: Schema.Struct({
@@ -103,7 +102,7 @@ export class Info extends Schema.Class<Info>("ModelV2.Info")({
       },
       variants: [],
       time: {
-        released: DateTime.makeUnsafe(0),
+        released: 0,
       },
       cost: [],
       status: "active",
@@ -116,6 +115,10 @@ export class Info extends Schema.Class<Info>("ModelV2.Info")({
   }
 }
 
+export type MutableInfo = Omit<Types.DeepMutable<Info>, "api"> & {
+  api: ProviderV2.MutableApi<Api>
+}
+
 export function parse(input: string): { providerID: ProviderV2.ID; modelID: ID } {
   const [providerID, ...modelID] = input.split("/")
   return {

packages/core/src/npm.ts

@@ -20,7 +20,7 @@ export class InstallFailedError extends Schema.TaggedErrorClass<InstallFailedErr
 
 export interface EntryPoint {
   readonly directory: string
-  readonly entrypoint: Option.Option<string>
+  readonly entrypoint?: string
 }
 
 export interface Interface {
@@ -34,7 +34,7 @@ export interface Interface {
       }[]
     },
   ) => Effect.Effect<void, EffectFlock.LockError | InstallFailedError>
-  readonly which: (pkg: string, bin?: string) => Effect.Effect<Option.Option<string>>
+  readonly which: (pkg: string, bin?: string) => Effect.Effect<string | undefined>
 }
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/Npm") {}
@@ -47,12 +47,11 @@ export function sanitize(pkg: string) {
 }
 
 const resolveEntryPoint = (name: string, dir: string): EntryPoint => {
-  let entrypoint: Option.Option<string>
+  let entrypoint: string | undefined
   try {
-    const resolved = typeof Bun !== "undefined" ? import.meta.resolve(name, dir) : import.meta.resolve(dir)
+    entrypoint = typeof Bun !== "undefined" ? import.meta.resolve(name, dir) : import.meta.resolve(dir)
-    entrypoint = Option.some(resolved)
   } catch {
-    entrypoint = Option.none()
+    entrypoint = undefined
   }
   return {
     directory: dir,
@@ -130,7 +129,7 @@ export const layer = Layer.effect(
       const first = tree.edgesOut.values().next().value?.to
       if (!first) {
         const result = resolveEntryPoint(name, path.join(dir, "node_modules", name))
-        if (Option.isSome(result.entrypoint)) return result
+        if (result.entrypoint) return result
         return yield* new InstallFailedError({ add: [pkg], dir })
       }
       return resolveEntryPoint(first.name, first.path)
@@ -219,7 +218,8 @@ export const layer = Layer.effect(
         return Option.some(files[0])
       })
 
-      return yield* Effect.gen(function* () {
+      return Option.getOrUndefined(
+        yield* Effect.gen(function* () {
           const bin = yield* pick()
           if (Option.isSome(bin)) {
             return Option.some(path.join(binDir, bin.value))
@@ -235,6 +235,7 @@ export const layer = Layer.effect(
         }).pipe(
           Effect.scoped,
           Effect.orElseSucceed(() => Option.none<string>()),
+        ),
       )
     })
 
@@ -261,14 +262,9 @@ export async function install(...args: Parameters<Interface["install"]>) {
 }
 
 export async function add(...args: Parameters<Interface["add"]>) {
-  const entry = await runPromise((svc) => svc.add(...args))
+  return runPromise((svc) => svc.add(...args))
-  return {
-    directory: entry.directory,
-    entrypoint: Option.getOrUndefined(entry.entrypoint),
-  }
 }
 
 export async function which(...args: Parameters<Interface["which"]>) {
-  const resolved = await runPromise((svc) => svc.which(...args))
+  return runPromise((svc) => svc.which(...args))
-  return Option.getOrUndefined(resolved)
 }

packages/core/src/permission/schema.ts

@@ -12,5 +12,5 @@ export const Rule = Schema.Struct({
 }).annotate({ identifier: "PermissionV2.Rule" })
 export type Rule = typeof Rule.Type
 
-export const Ruleset = Schema.Array(Rule).annotate({ identifier: "PermissionV2.Ruleset" })
+export const Ruleset = Schema.mutable(Schema.Array(Rule)).annotate({ identifier: "PermissionV2.Ruleset" })
 export type Ruleset = typeof Ruleset.Type

packages/core/src/plugin.ts

@@ -7,6 +7,7 @@ import type { ModelV2 } from "./model"
 import type { Catalog } from "./catalog"
 import { EventV2 } from "./event"
 import { KeyedMutex } from "./effect/keyed-mutex"
+import { State } from "./state"
 
 export const ID = Schema.String.pipe(Schema.brand("Plugin.ID"))
 export type ID = typeof ID.Type
@@ -22,7 +23,7 @@ export const Event = {
 
 type HookSpec = {
   "catalog.transform": {
-    input: Catalog.Editor
+    input: Catalog.Draft
     output: {}
   }
   "aisdk.language": {
@@ -62,18 +63,16 @@ export type HookFunctions = {
 export type HookInput<Name extends keyof Hooks> = HookSpec[Name]["input"]
 export type HookOutput<Name extends keyof Hooks> = HookSpec[Name]["output"]
 
-export type Effect<R = never> = Effect.Effect<HookFunctions | void, never, R | Scope.Scope>
-
-export function define<R>(input: { id: ID; effect: Effect.Effect<HookFunctions | void, never, R> }) {
-  return input
-}
-
 export interface Interface {
   readonly add: (input: {
-    id: ID
+    id: string
     effect: Effect.Effect<void | HookFunctions, never, Scope.Scope>
   }) => Effect.Effect<void, never, never>
   readonly remove: (id: ID) => Effect.Effect<void>
+  readonly hook: <Name extends keyof Hooks>(
+    name: Name,
+    callback: (input: Hooks[Name]) => Effect.Effect<void> | void,
+  ) => Effect.Effect<State.Registration, never, Scope.Scope>
   readonly triggerFor: <Name extends keyof Hooks>(
     id: ID,
     name: Name,
@@ -97,35 +96,40 @@ export const layer = Layer.effect(
       hooks: HookFunctions
       scope: Scope.Closeable
     }[] = []
+    let registrations: {
+      [Name in keyof Hooks]: {
+        name: Name
+        callback: (input: Hooks[Name]) => Effect.Effect<void> | void
+      }
+    }[keyof Hooks][] = []
     const events = yield* EventV2.Service
     const scope = yield* Scope.Scope
     const locks = KeyedMutex.makeUnsafe<ID>()
 
     const svc = Service.of({
       add: Effect.fn("Plugin.add")(function* (input) {
-        yield* locks.withLock(input.id)(
+        const id = ID.make(input.id)
+        yield* locks.withLock(id)(
           Effect.gen(function* () {
-            const existing = hooks.find((item) => item.id === input.id)
+            const existing = hooks.find((item) => item.id === id)
             if (existing) yield* Scope.close(existing.scope, Exit.void).pipe(Effect.ignore)
             const childScope = yield* Scope.fork(scope)
             const result = yield* input.effect.pipe(
               Scope.provide(childScope),
               Effect.withSpan("Plugin.load", {
                 attributes: {
-                  "plugin.id": input.id,
+                  "plugin.id": id,
                 },
               }),
               Effect.onExit((exit) => (Exit.isFailure(exit) ? Scope.close(childScope, exit) : Effect.void)),
             )
-            hooks = [
+            const next = {
-              ...hooks.filter((item) => item.id !== input.id),
+              id,
-              {
-                id: input.id,
               hooks: result ?? {},
               scope: childScope,
-              },
+            }
-            ]
+            hooks = existing ? hooks.with(hooks.indexOf(existing), next) : [...hooks, next]
-            yield* events.publish(Event.Added, { id: input.id })
+            yield* events.publish(Event.Added, { id })
           }),
         )
       }),
@@ -160,6 +164,12 @@ export const layer = Layer.effect(
           )
         }
 
+        for (const item of registrations) {
+          if (item.name !== name) continue
+          const result = item.callback(event as never)
+          if (Effect.isEffect(result)) yield* result
+        }
+
         for (const [field, draft] of draftEntries) {
           event[field] = finishDraft(draft)
         }
@@ -175,6 +185,19 @@ export const layer = Layer.effect(
           }),
         )
       }),
+      hook: Effect.fn("Plugin.hook")(function* (name, callback) {
+        const scope = yield* Scope.Scope
+        const registration = { name, callback } as (typeof registrations)[number]
+        let active = true
+        registrations = [...registrations, registration]
+        const dispose = Effect.sync(() => {
+          if (!active) return
+          active = false
+          registrations = registrations.filter((item) => item !== registration)
+        })
+        yield* Scope.addFinalizer(scope, dispose)
+        return { dispose }
+      }),
     })
     return svc
   }),

packages/core/src/plugin/agent.ts

@@ -1,12 +1,11 @@
 export * as AgentPlugin from "./agent"
 
 import path from "path"
+import { define } from "@opencode-ai/plugin/v2/effect"
 import { Effect } from "effect"
 import { AgentV2 } from "../agent"
 import { Global } from "../global"
-import { Location } from "../location"
 import { PermissionV2 } from "../permission"
-import { PluginV2 } from "../plugin"
 
 const TRUNCATION_GLOB = path.join(Global.Path.data, "tool-output", "*")
 const BUILD_SYSTEM =
@@ -97,12 +96,10 @@ Rules:
 - If the conversation ends with an unanswered question to the user, preserve that exact question
 - If the conversation ends with an imperative statement or request to the user (e.g. "Now please run the command and paste the console output"), always include that exact request in the summary`
 
-export const Plugin = PluginV2.define({
+export const Plugin = define({
-  id: PluginV2.ID.make("agent"),
+  id: "agent",
-  effect: Effect.gen(function* () {
+  effect: Effect.fn(function* (ctx) {
-    const agent = yield* AgentV2.Service
+    const worktree = ctx.location.directory
-    const location = yield* Location.Service
-    const worktree = location.directory
     const whitelistedDirs = [TRUNCATION_GLOB, path.join(Global.Path.tmp, "*")]
     const readonlyExternalDirectory: PermissionV2.Ruleset = [
       { action: "external_directory", resource: "*", effect: "ask" },
@@ -122,8 +119,8 @@ export const Plugin = PluginV2.define({
       { action: "read", resource: "*.env.example", effect: "allow" },
     ]
 
-    yield* agent.update((editor) => {
+    yield* ctx.agent.transform((draft) => {
-      editor.update(AgentV2.defaultID, (item) => {
+      draft.update(AgentV2.defaultID, (item) => {
         item.description = "The default agent. Executes tools based on configured permissions."
         item.system ??= BUILD_SYSTEM
         item.mode = "primary"
@@ -135,7 +132,7 @@ export const Plugin = PluginV2.define({
         )
       })
 
-      editor.update(AgentV2.ID.make("plan"), (item) => {
+      draft.update(AgentV2.ID.make("plan"), (item) => {
         item.description = "Plan mode. Disallows all edit tools."
         item.mode = "primary"
         item.permissions.push(
@@ -154,14 +151,14 @@ export const Plugin = PluginV2.define({
         )
       })
 
-      editor.update(AgentV2.ID.make("general"), (item) => {
+      draft.update(AgentV2.ID.make("general"), (item) => {
         item.description =
           "General-purpose agent for researching complex questions and executing multi-step tasks. Use this agent to execute multiple units of work in parallel."
         item.mode = "subagent"
         item.permissions.push(...PermissionV2.merge(defaults, [{ action: "todowrite", resource: "*", effect: "deny" }]))
       })
 
-      editor.update(AgentV2.ID.make("explore"), (item) => {
+      draft.update(AgentV2.ID.make("explore"), (item) => {
         item.description =
           'Fast agent specialized for exploring codebases. Use this when you need to quickly find files by patterns (eg. "src/components/**/*.tsx"), search code for keywords (eg. "API endpoints"), or answer questions about the codebase (eg. "how do API endpoints work?"). When calling this agent, specify the desired thoroughness level: "quick" for basic searches, "medium" for moderate exploration, or "very thorough" for comprehensive analysis across multiple locations and naming conventions.'
         item.system = PROMPT_EXPLORE
@@ -182,21 +179,21 @@ export const Plugin = PluginV2.define({
         )
       })
 
-      editor.update(AgentV2.ID.make("compaction"), (item) => {
+      draft.update(AgentV2.ID.make("compaction"), (item) => {
         item.mode = "primary"
         item.hidden = true
         item.system = PROMPT_COMPACTION
         item.permissions.push(...PermissionV2.merge(defaults, [{ action: "*", resource: "*", effect: "deny" }]))
       })
 
-      editor.update(AgentV2.ID.make("title"), (item) => {
+      draft.update(AgentV2.ID.make("title"), (item) => {
         item.mode = "primary"
         item.hidden = true
         item.system = PROMPT_TITLE
         item.permissions.push(...PermissionV2.merge(defaults, [{ action: "*", resource: "*", effect: "deny" }]))
       })
 
-      editor.update(AgentV2.ID.make("summary"), (item) => {
+      draft.update(AgentV2.ID.make("summary"), (item) => {
         item.mode = "primary"
         item.hidden = true
         item.system = PROMPT_SUMMARY

packages/core/src/plugin/boot.ts

@@ -1,7 +1,7 @@
 export * as PluginBoot from "./boot"
 
+import type { Plugin as PublicPlugin } from "@opencode-ai/plugin/v2/effect"
 import { Context, Deferred, Effect, Layer } from "effect"
-import { Credential } from "../credential"
 import { Integration } from "../integration"
 import { AgentV2 } from "../agent"
 import { Catalog } from "../catalog"
@@ -13,6 +13,7 @@ import { ConfigSkillPlugin } from "../config/plugin/skill"
 import { ConfigReferencePlugin } from "../config/plugin/reference"
 import { EventV2 } from "../event"
 import { FSUtil } from "../fs-util"
+import { FileSystem } from "../filesystem"
 import { Global } from "../global"
 import { Location } from "../location"
 import { ModelsDev } from "../models-dev"
@@ -26,29 +27,13 @@ import { ModelsDevPlugin } from "./models-dev"
 import { ProviderPlugins } from "./provider"
 import { SkillV2 } from "../skill"
 import { Reference } from "../reference"
+import { State } from "../state"
+import { PluginHost } from "./host"
 
-type Plugin = {
+type InternalPlugin = PublicPlugin<any>
-  id: PluginV2.ID
-  effect: PluginV2.Effect<
-    | Catalog.Service
-    | CommandV2.Service
-    | Credential.Service
-    | Integration.Service
-    | AgentV2.Service
-    | Npm.Service
-    | EventV2.Service
-    | FSUtil.Service
-    | Global.Service
-    | Location.Service
-    | PluginV2.Service
-    | Config.Service
-    | ModelsDev.Service
-    | SkillV2.Service
-    | Reference.Service
-  >
-}
 
 export interface Interface {
+  readonly add: (plugin: PublicPlugin<any>) => Effect.Effect<void>
   readonly wait: () => Effect.Effect<void>
 }
 
@@ -60,8 +45,7 @@ export const layer = Layer.effect(
     const catalog = yield* Catalog.Service
     const commands = yield* CommandV2.Service
     const plugin = yield* PluginV2.Service
-    const credentials = yield* Credential.Service
+    const integration = yield* Integration.Service
-    const integrations = yield* Integration.Service
     const agents = yield* AgentV2.Service
     const config = yield* Config.Service
     const location = yield* Location.Service
@@ -69,19 +53,22 @@ export const layer = Layer.effect(
     const npm = yield* Npm.Service
     const events = yield* EventV2.Service
     const fs = yield* FSUtil.Service
+    const filesystem = yield* FileSystem.Service
     const global = yield* Global.Service
     const skill = yield* SkillV2.Service
-    const references = yield* Reference.Service
+    const reference = yield* Reference.Service
+    const host = yield* PluginHost.make()
     const done = yield* Deferred.make<void>()
 
-    const add = Effect.fn("PluginBoot.add")(function* (input: Plugin) {
+    const add = Effect.fn("PluginBoot.add")(function* (input: InternalPlugin) {
       yield* plugin.add({
         id: input.id,
-        effect: input.effect.pipe(
+        effect: input
+          .effect(host)
+          .pipe(
             Effect.provideService(Catalog.Service, catalog),
             Effect.provideService(CommandV2.Service, commands),
-          Effect.provideService(Credential.Service, credentials),
+            Effect.provideService(Integration.Service, integration),
-          Effect.provideService(Integration.Service, integrations),
             Effect.provideService(AgentV2.Service, agents),
             Effect.provideService(Config.Service, config),
             Effect.provideService(Location.Service, location),
@@ -89,27 +76,31 @@ export const layer = Layer.effect(
             Effect.provideService(Npm.Service, npm),
             Effect.provideService(EventV2.Service, events),
             Effect.provideService(FSUtil.Service, fs),
+            Effect.provideService(FileSystem.Service, filesystem),
             Effect.provideService(Global.Service, global),
             Effect.provideService(SkillV2.Service, skill),
-          Effect.provideService(Reference.Service, references),
+            Effect.provideService(Reference.Service, reference),
-          Effect.provideService(PluginV2.Service, plugin),
           ),
       })
     })
 
     const boot = Effect.gen(function* () {
+      yield* State.batch(
+        Effect.gen(function* () {
           yield* add(AgentPlugin.Plugin)
           yield* add(CommandPlugin.Plugin)
           yield* add(SkillPlugin.Plugin)
-      for (const item of ProviderPlugins) {
-        yield* add(item)
-      }
           yield* add(ModelsDevPlugin)
           yield* add(ConfigProviderPlugin.Plugin)
           yield* add(ConfigAgentPlugin.Plugin)
           yield* add(ConfigCommandPlugin.Plugin)
           yield* add(ConfigSkillPlugin.Plugin)
           yield* add(ConfigReferencePlugin.Plugin)
+          for (const item of ProviderPlugins) {
+            yield* add(item)
+          }
+        }),
+      )
     }).pipe(Effect.withSpan("PluginBoot.boot"))
 
     yield* boot.pipe(
@@ -119,12 +110,22 @@ export const layer = Layer.effect(
     )
 
     return Service.of({
+      add: (input) =>
+        Deferred.await(done).pipe(
+          Effect.andThen(
+            plugin.add({
+              id: input.id,
+              effect: input.effect(host),
+            }),
+          ),
+        ),
       wait: () => Deferred.await(done),
     })
   }),
 )
 
 export const locationLayer = layer.pipe(
+  Layer.provideMerge(PluginV2.locationLayer),
   Layer.provideMerge(Integration.locationLayer),
   Layer.provideMerge(Catalog.locationLayer),
   Layer.provideMerge(CommandV2.locationLayer),
@@ -132,4 +133,5 @@ export const locationLayer = layer.pipe(
   Layer.provideMerge(AgentV2.locationLayer),
   Layer.provideMerge(SkillV2.locationLayer),
   Layer.provideMerge(Reference.locationLayer),
+  Layer.provideMerge(FileSystem.locationLayer),
 )

packages/core/src/plugin/command.ts

@@ -1,26 +1,20 @@
 export * as CommandPlugin from "./command"
 
+import { define } from "@opencode-ai/plugin/v2/effect"
 import { Effect } from "effect"
-import { CommandV2 } from "../command"
-import { Location } from "../location"
-import { PluginV2 } from "../plugin"
 import PROMPT_INITIALIZE from "./command/initialize.txt"
 import PROMPT_REVIEW from "./command/review.txt"
 
-export const Plugin = PluginV2.define({
+export const Plugin = define({
-  id: PluginV2.ID.make("command"),
+  id: "command",
-  effect: Effect.gen(function* () {
+  effect: Effect.fn(function* (ctx) {
-    const command = yield* CommandV2.Service
+    yield* ctx.command.transform((draft) => {
-    const location = yield* Location.Service
+      draft.update("init", (command) => {
-    const transform = yield* command.transform()
+        command.template = PROMPT_INITIALIZE.replace("${path}", ctx.location.project.directory)
-
-    yield* transform((editor) => {
-      editor.update("init", (command) => {
-        command.template = PROMPT_INITIALIZE.replace("${path}", location.project.directory)
         command.description = "guided AGENTS.md setup"
       })
-      editor.update("review", (command) => {
+      draft.update("review", (command) => {
-        command.template = PROMPT_REVIEW.replace("${path}", location.project.directory)
+        command.template = PROMPT_REVIEW.replace("${path}", ctx.location.project.directory)
         command.description = "review changes [commit|branch|pr], defaults to uncommitted"
         command.subtask = true
       })

packages/core/src/plugin/host.ts

@@ -0,0 +1,236 @@
+export * as PluginHost from "./host"
+
+import type { LanguageModelV3 } from "@ai-sdk/provider"
+import type { PluginHost as Interface } from "@opencode-ai/plugin/v2/effect"
+import type { Event as SDKEvent, ModelV2Info } from "@opencode-ai/sdk/v2/types"
+import { Effect, Schema, Stream } from "effect"
+import { AgentV2 } from "../agent"
+import { Catalog } from "../catalog"
+import { CommandV2 } from "../command"
+import { EventV2 } from "../event"
+import { FileSystem } from "../filesystem"
+import { Global } from "../global"
+import { Integration } from "../integration"
+import { Location } from "../location"
+import { ModelV2 } from "../model"
+import { Npm } from "../npm"
+import { PluginV2 } from "../plugin"
+import { ProviderV2 } from "../provider"
+import { Reference } from "../reference"
+import { SkillV2 } from "../skill"
+
+type EventMap = { [Item in SDKEvent as Item["type"]]: Item }
+type SDKHook = (event: {
+  readonly model: ModelV2Info
+  readonly package: string
+  readonly options: Record<string, any>
+  sdk?: any
+}) => Effect.Effect<void> | void
+type LanguageHook = (event: {
+  readonly model: ModelV2Info
+  readonly sdk: any
+  readonly options: Record<string, any>
+  language?: LanguageModelV3
+}) => Effect.Effect<void> | void
+
+export const make = Effect.fn("PluginHost.make")(function* () {
+  const agents = yield* AgentV2.Service
+  const catalog = yield* Catalog.Service
+  const commands = yield* CommandV2.Service
+  const events = yield* EventV2.Service
+  const filesystem = yield* FileSystem.Service
+  const global = yield* Global.Service
+  const integration = yield* Integration.Service
+  const location = yield* Location.Service
+  const npm = yield* Npm.Service
+  const plugin = yield* PluginV2.Service
+  const reference = yield* Reference.Service
+  const skill = yield* SkillV2.Service
+
+  return {
+    agent: {
+      get: (id) => agents.get(AgentV2.ID.make(id)),
+      default: agents.default,
+      list: agents.all,
+      rebuild: agents.rebuild,
+      transform: (callback) =>
+        agents.transform((draft) =>
+          callback({
+            list: draft.list,
+            get: (id) => draft.get(AgentV2.ID.make(id)),
+            default: (id) => draft.default(id === undefined ? undefined : AgentV2.ID.make(id)),
+            update: (id, update) => draft.update(AgentV2.ID.make(id), update),
+            remove: (id) => draft.remove(AgentV2.ID.make(id)),
+          }),
+        ),
+    },
+    aisdk: {
+      hook: (name, callback) => {
+        if (name === "sdk") {
+          const run = callback as SDKHook
+          return plugin.hook("aisdk.sdk", (event) => {
+            const output = {
+              model: event.model,
+              package: event.package,
+              options: event.options,
+              sdk: event.sdk,
+            }
+            const result = run(output)
+            return Effect.suspend(() => (Effect.isEffect(result) ? result : Effect.void)).pipe(
+              Effect.tap(() => Effect.sync(() => (event.sdk = output.sdk))),
+            )
+          })
+        }
+        const run = callback as LanguageHook
+        return plugin.hook("aisdk.language", (event) => {
+          const output = {
+            model: event.model,
+            sdk: event.sdk,
+            options: event.options,
+            language: event.language,
+          }
+          const result = run(output)
+          return Effect.suspend(() => (Effect.isEffect(result) ? result : Effect.void)).pipe(
+            Effect.tap(() => Effect.sync(() => (event.language = output.language))),
+          )
+        })
+      },
+    },
+    catalog: {
+      provider: {
+        get: (id) => catalog.provider.get(ProviderV2.ID.make(id)),
+        list: catalog.provider.all,
+        available: catalog.provider.available,
+      },
+      model: {
+        get: (providerID, modelID) => catalog.model.get(ProviderV2.ID.make(providerID), ModelV2.ID.make(modelID)),
+        list: catalog.model.all,
+        available: catalog.model.available,
+        default: catalog.model.default,
+        small: (providerID) => catalog.model.small(ProviderV2.ID.make(providerID)),
+      },
+      rebuild: catalog.rebuild,
+      transform: (callback) =>
+        catalog.transform((draft) =>
+          callback({
+            provider: {
+              list: draft.provider.list,
+              get: (id) => draft.provider.get(ProviderV2.ID.make(id)),
+              update: (id, update) => draft.provider.update(ProviderV2.ID.make(id), update),
+              remove: (id) => draft.provider.remove(ProviderV2.ID.make(id)),
+            },
+            model: {
+              get: (providerID, modelID) => draft.model.get(ProviderV2.ID.make(providerID), ModelV2.ID.make(modelID)),
+              update: (providerID, modelID, update) =>
+                draft.model.update(ProviderV2.ID.make(providerID), ModelV2.ID.make(modelID), update),
+              remove: (providerID, modelID) =>
+                draft.model.remove(ProviderV2.ID.make(providerID), ModelV2.ID.make(modelID)),
+              default: {
+                get: draft.model.default.get,
+                set: (providerID, modelID) =>
+                  draft.model.default.set(ProviderV2.ID.make(providerID), ModelV2.ID.make(modelID)),
+              },
+            },
+          }),
+        ),
+    },
+    command: {
+      get: commands.get,
+      list: commands.list,
+      rebuild: commands.rebuild,
+      transform: commands.transform,
+    },
+    event: {
+      subscribe: <Type extends keyof EventMap>(type: Type): Stream.Stream<EventMap[Type]> =>
+        Stream.unwrap(
+          Effect.sync(() => {
+            const definition = EventV2.registry.get(type)
+            if (!definition) throw new Error(`Unknown event type: ${type}`)
+            const encode = Schema.encodeUnknownSync(definition.data as Schema.Codec<unknown, unknown, never, never>)
+            return events.subscribe(definition).pipe(
+              Stream.map(
+                (event) =>
+                  ({
+                    id: event.id,
+                    type: event.type,
+                    properties: encode(event.data),
+                  }) as unknown as EventMap[Type],
+              ),
+            )
+          }),
+        ),
+    },
+    filesystem: {
+      read: (input) => filesystem.read(Schema.decodeUnknownSync(FileSystem.ReadInput)(input)),
+      list: (input) => filesystem.list(Schema.decodeUnknownSync(FileSystem.ListInput)(input ?? {})),
+      find: (input) => filesystem.find(Schema.decodeUnknownSync(FileSystem.FindInput)(input)),
+      glob: (input) => filesystem.glob(Schema.decodeUnknownSync(FileSystem.GlobInput)(input)),
+    },
+    integration: {
+      get: (id) => integration.get(Integration.ID.make(id)),
+      list: integration.list,
+      rebuild: integration.rebuild,
+      transform: (callback) =>
+        integration.transform((draft) =>
+          callback({
+            list: draft.list,
+            get: (id) => draft.get(Integration.ID.make(id)),
+            update: (id, update) => draft.update(Integration.ID.make(id), update),
+            remove: (id) => draft.remove(Integration.ID.make(id)),
+            method: {
+              list: (id) => draft.method.list(Integration.ID.make(id)),
+              update: (input) => {
+                if (input.method.type === "env") {
+                  draft.method.update({
+                    integrationID: Integration.ID.make(input.integrationID),
+                    method: { type: "env", names: input.method.names },
+                  })
+                  return
+                }
+                draft.method.update({
+                  integrationID: Integration.ID.make(input.integrationID),
+                  method: { type: "key", label: input.method.label },
+                })
+              },
+              remove: (id, method) =>
+                draft.method.remove(Integration.ID.make(id), Schema.decodeUnknownSync(Integration.Method)(method)),
+            },
+          }),
+        ),
+    },
+    location,
+    npm,
+    path: {
+      home: global.home,
+      data: global.data,
+      cache: global.cache,
+      config: global.config,
+      state: global.state,
+      temp: global.tmp,
+    },
+    reference: {
+      list: reference.list,
+      rebuild: reference.rebuild,
+      transform: (callback) =>
+        reference.transform((draft) =>
+          callback({
+            add: (name, source) => draft.add(name, Schema.decodeUnknownSync(Reference.Source)(source)),
+            remove: draft.remove,
+            list: draft.list,
+          }),
+        ),
+    },
+    skill: {
+      sources: skill.sources,
+      list: skill.list,
+      rebuild: skill.rebuild,
+      transform: (callback) =>
+        skill.transform((draft) =>
+          callback({
+            source: (source) => draft.source(Schema.decodeUnknownSync(SkillV2.Source)(source)),
+            list: draft.list,
+          }),
+        ),
+    },
+  } satisfies Interface
+})

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

@@ -1,16 +1,13 @@
-import { DateTime, Effect, Scope, Stream } from "effect"
+import { define } from "@opencode-ai/plugin/v2/effect"
-import { Catalog } from "../catalog"
+import { Effect, Stream } from "effect"
-import { Integration } from "../integration"
-import { EventV2 } from "../event"
 import { ModelV2 } from "../model"
 import { ModelRequest } from "../model-request"
 import { ModelsDev } from "../models-dev"
-import { PluginV2 } from "../plugin"
 import { ProviderV2 } from "../provider"
 
 function released(date: string) {
   const time = Date.parse(date)
-  return DateTime.makeUnsafe(Number.isFinite(time) ? time : 0)
+  return Number.isFinite(time) ? time : 0
 }
 
 function cost(input: ModelsDev.Model["cost"]) {
@@ -51,22 +48,16 @@ function variants(model: ModelsDev.Model, packageName?: string) {
   })
 }
 
-export const ModelsDevPlugin = PluginV2.define({
+export const ModelsDevPlugin = define({
-  id: PluginV2.ID.make("models-dev"),
+  id: "models-dev",
-  effect: Effect.gen(function* () {
+  effect: Effect.fn(function* (ctx) {
-    const catalog = yield* Catalog.Service
-    const integrations = yield* Integration.Service
     const modelsDev = yield* ModelsDev.Service
-    const events = yield* EventV2.Service
+    yield* ctx.integration.transform(
-    const scope = yield* Scope.Scope
+      Effect.fn(function* (integrations) {
-    const transform = yield* catalog.transform()
-    const integrationTransform = yield* integrations.transform()
-    const refresh = Effect.fn("ModelsDevPlugin.refresh")(function* () {
         const data = yield* modelsDev.get()
-      yield* integrationTransform((integrations) => {
         for (const item of Object.values(data)) {
           if (item.env.length === 0) continue
-          const integrationID = Integration.ID.make(item.id)
+          const integrationID = item.id
           integrations.update(integrationID, (integration) => (integration.name = item.name))
           integrations.method.update({
             integrationID,
@@ -77,8 +68,11 @@ export const ModelsDevPlugin = PluginV2.define({
             method: { type: "env", names: [...item.env] },
           })
         }
-      })
+      }),
-      yield* transform((catalog) => {
+    )
+    yield* ctx.catalog.transform(
+      Effect.fn(function* (catalog) {
+        const data = yield* modelsDev.get()
         for (const item of Object.values(data)) {
           const providerID = ProviderV2.ID.make(item.id)
           catalog.provider.update(providerID, (provider) => {
@@ -132,11 +126,10 @@ export const ModelsDevPlugin = PluginV2.define({
             })
           }
         }
-      })
+      }),
-    })
+    )
-    yield* refresh()
+    yield* ctx.event.subscribe("models-dev.refreshed").pipe(
-    yield* events.subscribe(ModelsDev.Event.Refreshed).pipe(
+      Stream.runForEach(() => ctx.integration.rebuild().pipe(Effect.andThen(ctx.catalog.rebuild()))),
-      Stream.runForEach(() => refresh()),
       Effect.forkScoped({ startImmediately: true }),
     )
   }),

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

@@ -1,15 +1,16 @@
 import { Effect } from "effect"
-import { PluginV2 } from "../../plugin"
+import { define } from "@opencode-ai/plugin/v2/effect"
 
-export const AlibabaPlugin = PluginV2.define({
+export const AlibabaPlugin = define({
-  id: PluginV2.ID.make("alibaba"),
+  id: "alibaba",
-  effect: Effect.gen(function* () {
+  effect: Effect.fn(function* (ctx) {
-    return {
+    yield* ctx.aisdk.hook(
-      "aisdk.sdk": Effect.fn(function* (evt) {
+      "sdk",
+      Effect.fn(function* (evt) {
         if (evt.package !== "@ai-sdk/alibaba") return
         const mod = yield* Effect.promise(() => import("@ai-sdk/alibaba"))
         evt.sdk = mod.createAlibaba(evt.options)
       }),
-    }
+    )
   }),
 })

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

@@ -1,6 +1,6 @@
 import { Effect } from "effect"
 import type { LanguageModelV3 } from "@ai-sdk/provider"
-import { PluginV2 } from "../../plugin"
+import { define } from "@opencode-ai/plugin/v2/effect"
 import { ProviderV2 } from "../../provider"
 
 type MantleSDK = {
@@ -59,11 +59,11 @@ function selectMantleModel(sdk: MantleSDK, modelID: string) {
   return sdk.responses(modelID)
 }
 
-export const AmazonBedrockPlugin = PluginV2.define({
+export const AmazonBedrockPlugin = define({
-  id: PluginV2.ID.make("amazon-bedrock"),
+  id: "amazon-bedrock",
-  effect: Effect.gen(function* () {
+  effect: Effect.fn(function* (ctx) {
-    return {
+    yield* ctx.catalog.transform(
-      "catalog.transform": Effect.fn(function* (evt) {
+      Effect.fn(function* (evt) {
         for (const item of evt.provider.list()) {
           if (item.provider.api.type !== "aisdk") continue
           if (item.provider.api.package !== "@ai-sdk/amazon-bedrock") continue
@@ -77,7 +77,10 @@ export const AmazonBedrockPlugin = PluginV2.define({
           })
         }
       }),
-      "aisdk.sdk": Effect.fn(function* (evt) {
+    )
+    yield* ctx.aisdk.hook(
+      "sdk",
+      Effect.fn(function* (evt) {
         if (!["@ai-sdk/amazon-bedrock", "@ai-sdk/amazon-bedrock/mantle"].includes(evt.package)) return
         const options = { ...evt.options }
         const profile = typeof options.profile === "string" ? options.profile : process.env.AWS_PROFILE
@@ -108,7 +111,10 @@ export const AmazonBedrockPlugin = PluginV2.define({
         const mod = yield* Effect.promise(() => import("@ai-sdk/amazon-bedrock"))
         evt.sdk = mod.createAmazonBedrock(options)
       }),
-      "aisdk.language": Effect.fn(function* (evt) {
+    )
+    yield* ctx.aisdk.hook(
+      "language",
+      Effect.fn(function* (evt) {
         if (evt.model.providerID !== ProviderV2.ID.amazonBedrock) return
         if (evt.model.api.type === "aisdk" && evt.model.api.package === "@ai-sdk/amazon-bedrock/mantle") {
           evt.language = selectMantleModel(evt.sdk, evt.model.api.id)
@@ -117,6 +123,6 @@ export const AmazonBedrockPlugin = PluginV2.define({
         const region = typeof evt.options.region === "string" ? evt.options.region : process.env.AWS_REGION
         evt.language = evt.sdk.languageModel(resolveModelID(evt.model.api.id, region))
       }),
-    }
+    )
   }),
 })

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

@@ -1,11 +1,11 @@
 import { Effect } from "effect"
-import { PluginV2 } from "../../plugin"
+import { define } from "@opencode-ai/plugin/v2/effect"
 
-export const AnthropicPlugin = PluginV2.define({
+export const AnthropicPlugin = define({
-  id: PluginV2.ID.make("anthropic"),
+  id: "anthropic",
-  effect: Effect.gen(function* () {
+  effect: Effect.fn(function* (ctx) {
-    return {
+    yield* ctx.catalog.transform(
-      "catalog.transform": Effect.fn(function* (evt) {
+      Effect.fn(function* (evt) {
         for (const item of evt.provider.list()) {
           if (item.provider.api.type !== "aisdk") continue
           if (item.provider.api.package !== "@ai-sdk/anthropic") continue
@@ -15,11 +15,14 @@ export const AnthropicPlugin = PluginV2.define({
           })
         }
       }),
-      "aisdk.sdk": Effect.fn(function* (evt) {
+    )
+    yield* ctx.aisdk.hook(
+      "sdk",
+      Effect.fn(function* (evt) {
         if (evt.package !== "@ai-sdk/anthropic") return
         const mod = yield* Effect.promise(() => import("@ai-sdk/anthropic"))
         evt.sdk = mod.createAnthropic(evt.options)
       }),
-    }
+    )
   }),
 })

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

@@ -1,5 +1,5 @@
 import { Effect } from "effect"
-import { PluginV2 } from "../../plugin"
+import { define } from "@opencode-ai/plugin/v2/effect"
 import { ProviderV2 } from "../../provider"
 
 function selectLanguage(sdk: any, modelID: string, useChat: boolean) {
@@ -10,11 +10,11 @@ function selectLanguage(sdk: any, modelID: string, useChat: boolean) {
   return sdk.languageModel(modelID)
 }
 
-export const AzurePlugin = PluginV2.define({
+export const AzurePlugin = define({
-  id: PluginV2.ID.make("azure"),
+  id: "azure",
-  effect: Effect.gen(function* () {
+  effect: Effect.fn(function* (ctx) {
-    return {
+    yield* ctx.catalog.transform(
-      "catalog.transform": Effect.fn(function* (evt) {
+      Effect.fn(function* (evt) {
         for (const item of evt.provider.list()) {
           if (item.provider.api.type !== "aisdk") continue
           if (item.provider.api.package !== "@ai-sdk/azure") continue
@@ -27,7 +27,10 @@ export const AzurePlugin = PluginV2.define({
           })
         }
       }),
-      "aisdk.sdk": Effect.fn(function* (evt) {
+    )
+    yield* ctx.aisdk.hook(
+      "sdk",
+      Effect.fn(function* (evt) {
         if (evt.package !== "@ai-sdk/azure") return
         if (evt.model.providerID === ProviderV2.ID.azure) {
           if (
@@ -43,19 +46,22 @@ export const AzurePlugin = PluginV2.define({
         const mod = yield* Effect.promise(() => import("@ai-sdk/azure"))
         evt.sdk = mod.createAzure(evt.options)
       }),
-      "aisdk.language": Effect.fn(function* (evt) {
+    )
+    yield* ctx.aisdk.hook(
+      "language",
+      Effect.fn(function* (evt) {
         if (evt.model.providerID !== ProviderV2.ID.azure) return
         evt.language = selectLanguage(evt.sdk, evt.model.api.id, Boolean(evt.options.useCompletionUrls))
       }),
-    }
+    )
   }),
 })
 
-export const AzureCognitiveServicesPlugin = PluginV2.define({
+export const AzureCognitiveServicesPlugin = define({
-  id: PluginV2.ID.make("azure-cognitive-services"),
+  id: "azure-cognitive-services",
-  effect: Effect.gen(function* () {
+  effect: Effect.fn(function* (ctx) {
-    return {
+    yield* ctx.catalog.transform(
-      "catalog.transform": Effect.fn(function* (evt) {
+      Effect.fn(function* (evt) {
         const resourceName = process.env.AZURE_COGNITIVE_SERVICES_RESOURCE_NAME
         if (!resourceName) return
         for (const item of evt.provider.list()) {
@@ -67,10 +73,13 @@ export const AzureCognitiveServicesPlugin = PluginV2.define({
           })
         }
       }),
-      "aisdk.language": Effect.fn(function* (evt) {
+    )
+    yield* ctx.aisdk.hook(
+      "language",
+      Effect.fn(function* (evt) {
         if (evt.model.providerID !== ProviderV2.ID.make("azure-cognitive-services")) return
         evt.language = selectLanguage(evt.sdk, evt.model.api.id, Boolean(evt.options.useCompletionUrls))
       }),
-    }
+    )
   }),
 })

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

@@ -1,24 +1,27 @@
 import { Effect } from "effect"
-import { PluginV2 } from "../../plugin"
+import { define } from "@opencode-ai/plugin/v2/effect"
 
-export const CerebrasPlugin = PluginV2.define({
+export const CerebrasPlugin = define({
-  id: PluginV2.ID.make("cerebras"),
+  id: "cerebras",
-  effect: Effect.gen(function* () {
+  effect: Effect.fn(function* (ctx) {
-    return {
+    yield* ctx.catalog.transform(
-      "catalog.transform": Effect.fn(function* (ctx) {
+      Effect.fn(function* (evt) {
-        for (const item of ctx.provider.list()) {
+        for (const item of evt.provider.list()) {
           if (item.provider.api.type !== "aisdk") continue
           if (item.provider.api.package !== "@ai-sdk/cerebras") continue
-          ctx.provider.update(item.provider.id, (provider) => {
+          evt.provider.update(item.provider.id, (provider) => {
             provider.request.headers["X-Cerebras-3rd-Party-Integration"] = "opencode"
           })
         }
       }),
-      "aisdk.sdk": Effect.fn(function* (evt) {
+    )
+    yield* ctx.aisdk.hook(
+      "sdk",
+      Effect.fn(function* (evt) {
         if (evt.package !== "@ai-sdk/cerebras") return
         const mod = yield* Effect.promise(() => import("@ai-sdk/cerebras"))
         evt.sdk = mod.createCerebras(evt.options)
       }),
-    }
+    )
   }),
 })

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

@@ -1,13 +1,14 @@
 import os from "os"
 import { InstallationVersion } from "../../installation/version"
 import { Effect, Option, Schema } from "effect"
-import { PluginV2 } from "../../plugin"
+import { define } from "@opencode-ai/plugin/v2/effect"
 
-export const CloudflareAIGatewayPlugin = PluginV2.define({
+export const CloudflareAIGatewayPlugin = define({
-  id: PluginV2.ID.make("cloudflare-ai-gateway"),
+  id: "cloudflare-ai-gateway",
-  effect: Effect.gen(function* () {
+  effect: Effect.fn(function* (ctx) {
-    return {
+    yield* ctx.aisdk.hook(
-      "aisdk.sdk": Effect.fn(function* (evt) {
+      "sdk",
+      Effect.fn(function* (evt) {
         if (evt.package !== "ai-gateway-provider") return
         if (evt.options.baseURL) return
 
@@ -31,7 +32,7 @@ export const CloudflareAIGatewayPlugin = PluginV2.define({
           },
         }
       }),
-    }
+    )
   }),
 })
 

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

@@ -1,16 +1,16 @@
 import os from "os"
 import { InstallationVersion } from "../../installation/version"
 import { Effect } from "effect"
-import { PluginV2 } from "../../plugin"
+import { define } from "@opencode-ai/plugin/v2/effect"
 import { ProviderV2 } from "../../provider"
 
 const providerID = ProviderV2.ID.make("cloudflare-workers-ai")
 
-export const CloudflareWorkersAIPlugin = PluginV2.define({
+export const CloudflareWorkersAIPlugin = define({
-  id: PluginV2.ID.make("cloudflare-workers-ai"),
+  id: "cloudflare-workers-ai",
-  effect: Effect.gen(function* () {
+  effect: Effect.fn(function* (ctx) {
-    return {
+    yield* ctx.catalog.transform(
-      "catalog.transform": Effect.fn(function* (evt) {
+      Effect.fn(function* (evt) {
         const item = evt.provider.get(providerID)
         if (!item) return
         evt.provider.update(item.provider.id, (provider) => {
@@ -20,7 +20,10 @@ export const CloudflareWorkersAIPlugin = PluginV2.define({
           if (accountId) provider.api.url = workersEndpoint(accountId)
         })
       }),
-      "aisdk.sdk": Effect.fn(function* (evt) {
+    )
+    yield* ctx.aisdk.hook(
+      "sdk",
+      Effect.fn(function* (evt) {
         if (evt.model.providerID !== providerID) return
         if (evt.package !== "@ai-sdk/openai-compatible") return
 
@@ -34,11 +37,14 @@ export const CloudflareWorkersAIPlugin = PluginV2.define({
           }) as any,
         )
       }),
-      "aisdk.language": Effect.fn(function* (evt) {
+    )
+    yield* ctx.aisdk.hook(
+      "language",
+      Effect.fn(function* (evt) {
         if (evt.model.providerID !== providerID) return
         evt.language = evt.sdk.languageModel(evt.model.api.id)
       }),
-    }
+    )
   }),
 })
 

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

@@ -1,15 +1,16 @@
 import { Effect } from "effect"
-import { PluginV2 } from "../../plugin"
+import { define } from "@opencode-ai/plugin/v2/effect"
 
-export const CoherePlugin = PluginV2.define({
+export const CoherePlugin = define({
-  id: PluginV2.ID.make("cohere"),
+  id: "cohere",
-  effect: Effect.gen(function* () {
+  effect: Effect.fn(function* (ctx) {
-    return {
+    yield* ctx.aisdk.hook(
-      "aisdk.sdk": Effect.fn(function* (evt) {
+      "sdk",
+      Effect.fn(function* (evt) {
         if (evt.package !== "@ai-sdk/cohere") return
         const mod = yield* Effect.promise(() => import("@ai-sdk/cohere"))
         evt.sdk = mod.createCohere(evt.options)
       }),
-    }
+    )
   }),
 })

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

@@ -1,15 +1,16 @@
 import { Effect } from "effect"
-import { PluginV2 } from "../../plugin"
+import { define } from "@opencode-ai/plugin/v2/effect"
 
-export const DeepInfraPlugin = PluginV2.define({
+export const DeepInfraPlugin = define({
-  id: PluginV2.ID.make("deepinfra"),
+  id: "deepinfra",
-  effect: Effect.gen(function* () {
+  effect: Effect.fn(function* (ctx) {
-    return {
+    yield* ctx.aisdk.hook(
-      "aisdk.sdk": Effect.fn(function* (evt) {
+      "sdk",
+      Effect.fn(function* (evt) {
         if (evt.package !== "@ai-sdk/deepinfra") return
         const mod = yield* Effect.promise(() => import("@ai-sdk/deepinfra"))
         evt.sdk = mod.createDeepInfra(evt.options)
       }),
-    }
+    )
   }),
 })

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

@@ -1,19 +1,18 @@
-import { Npm } from "../../npm"
+import { Effect } from "effect"
-import { Effect, Option } from "effect"
 import { pathToFileURL } from "url"
-import { PluginV2 } from "../../plugin"
+import { define } from "@opencode-ai/plugin/v2/effect"
 
-export const DynamicProviderPlugin = PluginV2.define({
+export const DynamicProviderPlugin = define({
-  id: PluginV2.ID.make("dynamic-provider"),
+  id: "dynamic-provider",
-  effect: Effect.gen(function* () {
+  effect: Effect.fn(function* (ctx) {
-    const npm = yield* Npm.Service
+    yield* ctx.aisdk.hook(
-    return {
+      "sdk",
-      "aisdk.sdk": Effect.fn(function* (evt) {
+      Effect.fn(function* (evt) {
         if (evt.sdk) return
 
         const installedPath = evt.package.startsWith("file://")
           ? evt.package
-          : Option.getOrUndefined((yield* npm.add(evt.package).pipe(Effect.orDie)).entrypoint)
+          : (yield* ctx.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(async () => {
@@ -26,6 +25,6 @@ export const DynamicProviderPlugin = PluginV2.define({
 
         evt.sdk = mod[match](evt.options)
       }),
-    }
+    )
   }),
 })

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

@@ -1,15 +1,16 @@
 import { Effect } from "effect"
-import { PluginV2 } from "../../plugin"
+import { define } from "@opencode-ai/plugin/v2/effect"
 
-export const GatewayPlugin = PluginV2.define({
+export const GatewayPlugin = define({
-  id: PluginV2.ID.make("gateway"),
+  id: "gateway",
-  effect: Effect.gen(function* () {
+  effect: Effect.fn(function* (ctx) {
-    return {
+    yield* ctx.aisdk.hook(
-      "aisdk.sdk": Effect.fn(function* (evt) {
+      "sdk",
+      Effect.fn(function* (evt) {
         if (evt.package !== "@ai-sdk/gateway") return
         const mod = yield* Effect.promise(() => import("@ai-sdk/gateway"))
         evt.sdk = mod.createGateway(evt.options)
       }),
-    }
+    )
   }),
 })

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

@@ -1,6 +1,6 @@
 import { Effect } from "effect"
 import { ModelV2 } from "../../model"
-import { PluginV2 } from "../../plugin"
+import { define } from "@opencode-ai/plugin/v2/effect"
 import { ProviderV2 } from "../../provider"
 
 function shouldUseResponses(modelID: string) {
@@ -11,16 +11,31 @@ function shouldUseResponses(modelID: string) {
   return Number(match[1]) >= 5 && !modelID.startsWith("gpt-5-mini")
 }
 
-export const GithubCopilotPlugin = PluginV2.define({
+export const GithubCopilotPlugin = define({
-  id: PluginV2.ID.make("github-copilot"),
+  id: "github-copilot",
-  effect: Effect.gen(function* () {
+  effect: Effect.fn(function* (ctx) {
-    return {
+    yield* ctx.catalog.transform(
-      "aisdk.sdk": Effect.fn(function* (evt) {
+      Effect.fn(function* (evt) {
+        const item = evt.provider.get(ProviderV2.ID.githubCopilot)
+        if (!item || !item.models.has(ModelV2.ID.make("gpt-5-chat-latest"))) return
+        evt.model.update(item.provider.id, ModelV2.ID.make("gpt-5-chat-latest"), (model) => {
+          // This chat-only alias conflicts with the Copilot GPT-5 Responses route,
+          // so hide it only for Copilot rather than for every provider catalog.
+          model.enabled = false
+        })
+      }),
+    )
+    yield* ctx.aisdk.hook(
+      "sdk",
+      Effect.fn(function* (evt) {
         if (evt.package !== "@ai-sdk/github-copilot") return
         const mod = yield* Effect.promise(() => import("../../github-copilot/copilot-provider"))
         evt.sdk = mod.createOpenaiCompatible(evt.options)
       }),
-      "aisdk.language": Effect.fn(function* (evt) {
+    )
+    yield* ctx.aisdk.hook(
+      "language",
+      Effect.fn(function* (evt) {
         if (evt.model.providerID !== ProviderV2.ID.githubCopilot) return
         if (evt.sdk.responses === undefined && evt.sdk.chat === undefined) {
           evt.language = evt.sdk.languageModel(evt.model.api.id)
@@ -30,15 +45,6 @@ export const GithubCopilotPlugin = PluginV2.define({
           ? evt.sdk.responses(evt.model.api.id)
           : evt.sdk.chat(evt.model.api.id)
       }),
-      "catalog.transform": Effect.fn(function* (evt) {
+    )
-        const item = evt.provider.get(ProviderV2.ID.githubCopilot)
-        if (!item || !item.models.has(ModelV2.ID.make("gpt-5-chat-latest"))) return
-        evt.model.update(item.provider.id, ModelV2.ID.make("gpt-5-chat-latest"), (model) => {
-          // This chat-only alias conflicts with the Copilot GPT-5 Responses route,
-          // so hide it only for Copilot rather than for every provider catalog.
-          model.enabled = false
-        })
-      }),
-    }
   }),
 })

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

@@ -1,14 +1,15 @@
 import os from "os"
 import { InstallationVersion } from "../../installation/version"
 import { Effect } from "effect"
-import { PluginV2 } from "../../plugin"
+import { define } from "@opencode-ai/plugin/v2/effect"
 import { ProviderV2 } from "../../provider"
 
-export const GitLabPlugin = PluginV2.define({
+export const GitLabPlugin = define({
-  id: PluginV2.ID.make("gitlab"),
+  id: "gitlab",
-  effect: Effect.gen(function* () {
+  effect: Effect.fn(function* (ctx) {
-    return {
+    yield* ctx.aisdk.hook(
-      "aisdk.sdk": Effect.fn(function* (evt) {
+      "sdk",
+      Effect.fn(function* (evt) {
         if (evt.package !== "gitlab-ai-provider") return
         const mod = yield* Effect.promise(() => import("gitlab-ai-provider"))
         evt.sdk = mod.createGitLab({
@@ -30,7 +31,10 @@ export const GitLabPlugin = PluginV2.define({
           },
         })
       }),
-      "aisdk.language": Effect.fn(function* (evt) {
+    )
+    yield* ctx.aisdk.hook(
+      "language",
+      Effect.fn(function* (evt) {
         if (evt.model.providerID !== ProviderV2.ID.gitlab) return
         const featureFlags =
           typeof evt.options.featureFlags === "object" && evt.options.featureFlags ? evt.options.featureFlags : {}
@@ -58,6 +62,6 @@ export const GitLabPlugin = PluginV2.define({
           featureFlags,
         })
       }),
-    }
+    )
   }),
 })

packages/core/src/plugin/provider/google-vertex.ts

@@ -1,5 +1,5 @@
 import { Effect } from "effect"
-import { PluginV2 } from "../../plugin"
+import { define } from "@opencode-ai/plugin/v2/effect"
 import { ProviderV2 } from "../../provider"
 
 function resolveProject(options: Record<string, any>) {
@@ -54,11 +54,11 @@ function authFetch(fetchWithRuntimeOptions?: unknown) {
   }
 }
 
-export const GoogleVertexPlugin = PluginV2.define({
+export const GoogleVertexPlugin = define({
-  id: PluginV2.ID.make("google-vertex"),
+  id: "google-vertex",
-  effect: Effect.gen(function* () {
+  effect: Effect.fn(function* (ctx) {
-    return {
+    yield* ctx.catalog.transform(
-      "catalog.transform": Effect.fn(function* (evt) {
+      Effect.fn(function* (evt) {
         for (const item of evt.provider.list()) {
           if (item.provider.api.type !== "aisdk") continue
           if (
@@ -83,7 +83,10 @@ export const GoogleVertexPlugin = PluginV2.define({
           })
         }
       }),
-      "aisdk.sdk": Effect.fn(function* (evt) {
+    )
+    yield* ctx.aisdk.hook(
+      "sdk",
+      Effect.fn(function* (evt) {
         if (evt.model.providerID === ProviderV2.ID.googleVertex && evt.package.includes("@ai-sdk/openai-compatible")) {
           evt.options.fetch = authFetch(evt.options.fetch)
           return
@@ -100,19 +103,22 @@ export const GoogleVertexPlugin = PluginV2.define({
           location,
         })
       }),
-      "aisdk.language": Effect.fn(function* (evt) {
+    )
+    yield* ctx.aisdk.hook(
+      "language",
+      Effect.fn(function* (evt) {
         if (evt.model.providerID !== ProviderV2.ID.googleVertex) return
         evt.language = evt.sdk.languageModel(String(evt.model.api.id).trim())
       }),
-    }
+    )
   }),
 })
 
-export const GoogleVertexAnthropicPlugin = PluginV2.define({
+export const GoogleVertexAnthropicPlugin = define({
-  id: PluginV2.ID.make("google-vertex-anthropic"),
+  id: "google-vertex-anthropic",
-  effect: Effect.gen(function* () {
+  effect: Effect.fn(function* (ctx) {
-    return {
+    yield* ctx.catalog.transform(
-      "catalog.transform": Effect.fn(function* (evt) {
+      Effect.fn(function* (evt) {
         for (const item of evt.provider.list()) {
           if (item.provider.api.type !== "aisdk") continue
           if (item.provider.api.package !== "@ai-sdk/google-vertex/anthropic") continue
@@ -132,7 +138,10 @@ export const GoogleVertexAnthropicPlugin = PluginV2.define({
           })
         }
       }),
-      "aisdk.sdk": Effect.fn(function* (evt) {
+    )
+    yield* ctx.aisdk.hook(
+      "sdk",
+      Effect.fn(function* (evt) {
         if (evt.package !== "@ai-sdk/google-vertex/anthropic") return
         const mod = yield* Effect.promise(() => import("@ai-sdk/google-vertex/anthropic"))
         const project =
@@ -156,10 +165,13 @@ export const GoogleVertexAnthropicPlugin = PluginV2.define({
             : {}),
         })
       }),
-      "aisdk.language": Effect.fn(function* (evt) {
+    )
+    yield* ctx.aisdk.hook(
+      "language",
+      Effect.fn(function* (evt) {
         if (evt.model.providerID !== ProviderV2.ID.make("google-vertex-anthropic")) return
         evt.language = evt.sdk.languageModel(String(evt.model.api.id).trim())
       }),
-    }
+    )
   }),
 })

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

@@ -1,15 +1,16 @@
 import { Effect } from "effect"
-import { PluginV2 } from "../../plugin"
+import { define } from "@opencode-ai/plugin/v2/effect"
 
-export const GooglePlugin = PluginV2.define({
+export const GooglePlugin = define({
-  id: PluginV2.ID.make("google"),
+  id: "google",
-  effect: Effect.gen(function* () {
+  effect: Effect.fn(function* (ctx) {
-    return {
+    yield* ctx.aisdk.hook(
-      "aisdk.sdk": Effect.fn(function* (evt) {
+      "sdk",
+      Effect.fn(function* (evt) {
         if (evt.package !== "@ai-sdk/google") return
         const mod = yield* Effect.promise(() => import("@ai-sdk/google"))
         evt.sdk = mod.createGoogleGenerativeAI(evt.options)
       }),
-    }
+    )
   }),
 })

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

@@ -1,15 +1,16 @@
 import { Effect } from "effect"
-import { PluginV2 } from "../../plugin"
+import { define } from "@opencode-ai/plugin/v2/effect"
 
-export const GroqPlugin = PluginV2.define({
+export const GroqPlugin = define({
-  id: PluginV2.ID.make("groq"),
+  id: "groq",
-  effect: Effect.gen(function* () {
+  effect: Effect.fn(function* (ctx) {
-    return {
+    yield* ctx.aisdk.hook(
-      "aisdk.sdk": Effect.fn(function* (evt) {
+      "sdk",
+      Effect.fn(function* (evt) {
         if (evt.package !== "@ai-sdk/groq") return
         const mod = yield* Effect.promise(() => import("@ai-sdk/groq"))
         evt.sdk = mod.createGroq(evt.options)
       }),
-    }
+    )
   }),
 })

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

@@ -1,11 +1,11 @@
 import { Effect } from "effect"
-import { PluginV2 } from "../../plugin"
+import { define } from "@opencode-ai/plugin/v2/effect"
 
-export const KiloPlugin = PluginV2.define({
+export const KiloPlugin = define({
-  id: PluginV2.ID.make("kilo"),
+  id: "kilo",
-  effect: Effect.gen(function* () {
+  effect: Effect.fn(function* (ctx) {
-    return {
+    yield* ctx.catalog.transform(
-      "catalog.transform": Effect.fn(function* (evt) {
+      Effect.fn(function* (evt) {
         for (const item of evt.provider.list()) {
           if (item.provider.api.type !== "aisdk") continue
           if (item.provider.api.package !== "@ai-sdk/openai-compatible") continue
@@ -16,6 +16,6 @@ export const KiloPlugin = PluginV2.define({
           })
         }
       }),
-    }
+    )
   }),
 })

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

@@ -1,19 +1,17 @@
 import { Effect } from "effect"
-import { Integration } from "../../integration"
+import { define } from "@opencode-ai/plugin/v2/effect"
-import { PluginV2 } from "../../plugin"
 
-export const LLMGatewayPlugin = PluginV2.define({
+export const LLMGatewayPlugin = define({
-  id: PluginV2.ID.make("llmgateway"),
+  id: "llmgateway",
-  effect: Effect.gen(function* () {
+  effect: Effect.fn(function* (ctx) {
-    const integrations = yield* Integration.Service
+    yield* ctx.catalog.transform(
-    return {
+      Effect.fn(function* (evt) {
-      "catalog.transform": Effect.fn(function* (evt) {
         for (const item of evt.provider.list()) {
           if (item.provider.disabled) continue
-          if (!(yield* integrations.get(Integration.ID.make(item.provider.id)))) continue
           if (item.provider.api.type !== "aisdk") continue
           if (item.provider.api.package !== "@ai-sdk/openai-compatible") continue
           if (item.provider.api.url !== "https://api.llmgateway.io/v1") continue
+          if (!(yield* ctx.integration.get(item.provider.id))) continue
           evt.provider.update(item.provider.id, (provider) => {
             provider.request.headers["HTTP-Referer"] = "https://opencode.ai/"
             provider.request.headers["X-Title"] = "opencode"
@@ -21,6 +19,6 @@ export const LLMGatewayPlugin = PluginV2.define({
           })
         }
       }),
-    }
+    )
   }),
 })

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

@@ -1,15 +1,16 @@
 import { Effect } from "effect"
-import { PluginV2 } from "../../plugin"
+import { define } from "@opencode-ai/plugin/v2/effect"
 
-export const MistralPlugin = PluginV2.define({
+export const MistralPlugin = define({
-  id: PluginV2.ID.make("mistral"),
+  id: "mistral",
-  effect: Effect.gen(function* () {
+  effect: Effect.fn(function* (ctx) {
-    return {
+    yield* ctx.aisdk.hook(
-      "aisdk.sdk": Effect.fn(function* (evt) {
+      "sdk",
+      Effect.fn(function* (evt) {
         if (evt.package !== "@ai-sdk/mistral") return
         const mod = yield* Effect.promise(() => import("@ai-sdk/mistral"))
         evt.sdk = mod.createMistral(evt.options)
       }),
-    }
+    )
   }),
 })

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

@@ -1,11 +1,11 @@
 import { Effect } from "effect"
-import { PluginV2 } from "../../plugin"
+import { define } from "@opencode-ai/plugin/v2/effect"
 
-export const NvidiaPlugin = PluginV2.define({
+export const NvidiaPlugin = define({
-  id: PluginV2.ID.make("nvidia"),
+  id: "nvidia",
-  effect: Effect.gen(function* () {
+  effect: Effect.fn(function* (ctx) {
-    return {
+    yield* ctx.catalog.transform(
-      "catalog.transform": Effect.fn(function* (evt) {
+      Effect.fn(function* (evt) {
         for (const item of evt.provider.list()) {
           if (item.provider.api.type !== "aisdk") continue
           if (item.provider.api.package !== "@ai-sdk/openai-compatible") continue
@@ -17,6 +17,6 @@ export const NvidiaPlugin = PluginV2.define({
           })
         }
       }),
-    }
+    )
   }),
 })

packages/core/src/plugin/provider/openai-compatible.ts

@@ -1,17 +1,18 @@
 import { Effect } from "effect"
-import { PluginV2 } from "../../plugin"
+import { define } from "@opencode-ai/plugin/v2/effect"
 
-export const OpenAICompatiblePlugin = PluginV2.define({
+export const OpenAICompatiblePlugin = define({
-  id: PluginV2.ID.make("openai-compatible"),
+  id: "openai-compatible",
-  effect: Effect.gen(function* () {
+  effect: Effect.fn(function* (ctx) {
-    return {
+    yield* ctx.aisdk.hook(
-      "aisdk.sdk": Effect.fn(function* (evt) {
+      "sdk",
+      Effect.fn(function* (evt) {
         if (evt.sdk) return
         if (!evt.package.includes("@ai-sdk/openai-compatible")) return
         if (evt.options.includeUsage !== false) evt.options.includeUsage = true
         const mod = yield* Effect.promise(() => import("@ai-sdk/openai-compatible"))
         evt.sdk = mod.createOpenAICompatible(evt.options as any)
       }),
-    }
+    )
   }),
 })

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

@@ -1,29 +1,20 @@
 import { Effect } from "effect"
 import { ModelV2 } from "../../model"
-import { PluginV2 } from "../../plugin"
+import { define } from "@opencode-ai/plugin/v2/effect"
 import { ProviderV2 } from "../../provider"
 import { Integration } from "../../integration"
 import { browser, headless } from "./openai-auth"
 
-export const OpenAIPlugin = PluginV2.define({
+export const OpenAIPlugin = define({
-  id: PluginV2.ID.make("openai"),
+  id: "openai",
-  effect: Effect.gen(function* () {
+  effect: Effect.fn(function* (ctx) {
     const integrations = yield* Integration.Service
-    yield* integrations.update((editor) => {
+    yield* integrations.transform((draft) => {
-      editor.method.update(browser)
+      draft.method.update(browser)
-      editor.method.update(headless)
+      draft.method.update(headless)
     })
-    return {
+    yield* ctx.catalog.transform(
-      "aisdk.sdk": Effect.fn(function* (evt) {
+      Effect.fn(function* (evt) {
-        if (evt.package !== "@ai-sdk/openai") return
-        const mod = yield* Effect.promise(() => import("@ai-sdk/openai"))
-        evt.sdk = mod.createOpenAI(evt.options)
-      }),
-      "aisdk.language": Effect.fn(function* (evt) {
-        if (evt.model.providerID !== ProviderV2.ID.openai) return
-        evt.language = evt.sdk.responses(evt.model.api.id)
-      }),
-      "catalog.transform": Effect.fn(function* (evt) {
         for (const item of evt.provider.list()) {
           if (item.provider.api.type !== "aisdk") continue
           if (item.provider.api.package !== "@ai-sdk/openai") continue
@@ -35,6 +26,21 @@ export const OpenAIPlugin = PluginV2.define({
           })
         }
       }),
-    }
+    )
+    yield* ctx.aisdk.hook(
+      "sdk",
+      Effect.fn(function* (evt) {
+        if (evt.package !== "@ai-sdk/openai") return
+        const mod = yield* Effect.promise(() => import("@ai-sdk/openai"))
+        evt.sdk = mod.createOpenAI(evt.options)
+      }),
+    )
+    yield* ctx.aisdk.hook(
+      "language",
+      Effect.fn(function* (evt) {
+        if (evt.model.providerID !== ProviderV2.ID.openai) return
+        evt.language = evt.sdk.responses(evt.model.api.id)
+      }),
+    )
   }),
 })

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

@@ -1,18 +1,16 @@
 import { Effect } from "effect"
-import { Integration } from "../../integration"
+import { define } from "@opencode-ai/plugin/v2/effect"
-import { PluginV2 } from "../../plugin"
 import { ProviderV2 } from "../../provider"
 
-export const OpencodePlugin = PluginV2.define({
+export const OpencodePlugin = define({
-  id: PluginV2.ID.make("opencode"),
+  id: "opencode",
-  effect: Effect.gen(function* () {
+  effect: Effect.fn(function* (ctx) {
-    const integrations = yield* Integration.Service
     let hasKey = false
-    return {
+    yield* ctx.catalog.transform(
-      "catalog.transform": Effect.fn(function* (evt) {
+      Effect.fn(function* (evt) {
         const item = evt.provider.get(ProviderV2.ID.opencode)
         if (!item) return
-        const integration = yield* integrations.get(Integration.ID.make(item.provider.id))
+        const integration = yield* ctx.integration.get(item.provider.id)
         hasKey = Boolean(
           process.env.OPENCODE_API_KEY || integration?.connections.length || item.provider.request.body.apiKey,
         )
@@ -27,6 +25,6 @@ export const OpencodePlugin = PluginV2.define({
           })
         }
       }),
-    }
+    )
   }),
 })

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

@@ -1,12 +1,12 @@
 import { Effect } from "effect"
 import { ModelV2 } from "../../model"
-import { PluginV2 } from "../../plugin"
+import { define } from "@opencode-ai/plugin/v2/effect"
 
-export const OpenRouterPlugin = PluginV2.define({
+export const OpenRouterPlugin = define({
-  id: PluginV2.ID.make("openrouter"),
+  id: "openrouter",
-  effect: Effect.gen(function* () {
+  effect: Effect.fn(function* (ctx) {
-    return {
+    yield* ctx.catalog.transform(
-      "catalog.transform": Effect.fn(function* (evt) {
+      Effect.fn(function* (evt) {
         for (const item of evt.provider.list()) {
           if (item.provider.api.type !== "aisdk") continue
           if (item.provider.api.package !== "@openrouter/ai-sdk-provider") continue
@@ -24,11 +24,14 @@ export const OpenRouterPlugin = PluginV2.define({
           }
         }
       }),
-      "aisdk.sdk": Effect.fn(function* (evt) {
+    )
+    yield* ctx.aisdk.hook(
+      "sdk",
+      Effect.fn(function* (evt) {
         if (evt.package !== "@openrouter/ai-sdk-provider") return
         const mod = yield* Effect.promise(() => import("@openrouter/ai-sdk-provider"))
         evt.sdk = mod.createOpenRouter(evt.options)
       }),
-    }
+    )
   }),
 })

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

@@ -1,15 +1,16 @@
 import { Effect } from "effect"
-import { PluginV2 } from "../../plugin"
+import { define } from "@opencode-ai/plugin/v2/effect"
 
-export const PerplexityPlugin = PluginV2.define({
+export const PerplexityPlugin = define({
-  id: PluginV2.ID.make("perplexity"),
+  id: "perplexity",
-  effect: Effect.gen(function* () {
+  effect: Effect.fn(function* (ctx) {
-    return {
+    yield* ctx.aisdk.hook(
-      "aisdk.sdk": Effect.fn(function* (evt) {
+      "sdk",
+      Effect.fn(function* (evt) {
         if (evt.package !== "@ai-sdk/perplexity") return
         const mod = yield* Effect.promise(() => import("@ai-sdk/perplexity"))
         evt.sdk = mod.createPerplexity(evt.options)
       }),
-    }
+    )
   }),
 })

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

@@ -1,15 +1,14 @@
-import { Npm } from "../../npm"
+import { Effect } from "effect"
-import { Effect, Option } from "effect"
 import { pathToFileURL } from "url"
-import { PluginV2 } from "../../plugin"
+import { define } from "@opencode-ai/plugin/v2/effect"
 import { ProviderV2 } from "../../provider"
 
-export const SapAICorePlugin = PluginV2.define({
+export const SapAICorePlugin = define({
-  id: PluginV2.ID.make("sap-ai-core"),
+  id: "sap-ai-core",
-  effect: Effect.gen(function* () {
+  effect: Effect.fn(function* (ctx) {
-    const npm = yield* Npm.Service
+    yield* ctx.aisdk.hook(
-    return {
+      "sdk",
-      "aisdk.sdk": Effect.fn(function* (evt) {
+      Effect.fn(function* (evt) {
         if (evt.model.providerID !== ProviderV2.ID.make("sap-ai-core")) return
         const serviceKey =
           process.env.AICORE_SERVICE_KEY ??
@@ -18,7 +17,7 @@ export const SapAICorePlugin = PluginV2.define({
 
         const installedPath = evt.package.startsWith("file://")
           ? evt.package
-          : Option.getOrUndefined((yield* npm.add(evt.package).pipe(Effect.orDie)).entrypoint)
+          : (yield* ctx.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(async () => {
@@ -35,10 +34,13 @@ export const SapAICorePlugin = PluginV2.define({
             : {},
         )
       }),
-      "aisdk.language": Effect.fn(function* (evt) {
+    )
+    yield* ctx.aisdk.hook(
+      "language",
+      Effect.fn(function* (evt) {
         if (evt.model.providerID !== ProviderV2.ID.make("sap-ai-core")) return
         evt.language = evt.sdk(evt.model.api.id)
       }),
-    }
+    )
   }),
 })

packages/core/src/plugin/provider/snowflake-cortex.ts

@@ -1,5 +1,5 @@
 import { Effect } from "effect"
-import { PluginV2 } from "../../plugin"
+import { define } from "@opencode-ai/plugin/v2/effect"
 import { ProviderV2 } from "../../provider"
 
 type FetchLike = (url: string | URL | Request, init?: RequestInit) => Promise<Response>
@@ -64,11 +64,12 @@ export function cortexFetch(upstream: FetchLike = fetch) {
   }
 }
 
-export const SnowflakeCortexPlugin = PluginV2.define({
+export const SnowflakeCortexPlugin = define({
-  id: PluginV2.ID.make("snowflake-cortex"),
+  id: "snowflake-cortex",
-  effect: Effect.gen(function* () {
+  effect: Effect.fn(function* (ctx) {
-    return {
+    yield* ctx.aisdk.hook(
-      "aisdk.sdk": Effect.fn(function* (evt) {
+      "sdk",
+      Effect.fn(function* (evt) {
         if (evt.model.providerID !== ProviderV2.ID.make("snowflake-cortex")) return
         const token =
           process.env.SNOWFLAKE_CORTEX_TOKEN ??
@@ -84,6 +85,6 @@ export const SnowflakeCortexPlugin = PluginV2.define({
           fetch: cortexFetch(upstream) as typeof fetch,
         } as any)
       }),
-    }
+    )
   }),
 })

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

@@ -1,15 +1,16 @@
 import { Effect } from "effect"
-import { PluginV2 } from "../../plugin"
+import { define } from "@opencode-ai/plugin/v2/effect"
 
-export const TogetherAIPlugin = PluginV2.define({
+export const TogetherAIPlugin = define({
-  id: PluginV2.ID.make("togetherai"),
+  id: "togetherai",
-  effect: Effect.gen(function* () {
+  effect: Effect.fn(function* (ctx) {
-    return {
+    yield* ctx.aisdk.hook(
-      "aisdk.sdk": Effect.fn(function* (evt) {
+      "sdk",
+      Effect.fn(function* (evt) {
         if (evt.package !== "@ai-sdk/togetherai") return
         const mod = yield* Effect.promise(() => import("@ai-sdk/togetherai"))
         evt.sdk = mod.createTogetherAI(evt.options)
       }),
-    }
+    )
   }),
 })

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

@@ -1,15 +1,16 @@
 import { Effect } from "effect"
-import { PluginV2 } from "../../plugin"
+import { define } from "@opencode-ai/plugin/v2/effect"
 
-export const VenicePlugin = PluginV2.define({
+export const VenicePlugin = define({
-  id: PluginV2.ID.make("venice"),
+  id: "venice",
-  effect: Effect.gen(function* () {
+  effect: Effect.fn(function* (ctx) {
-    return {
+    yield* ctx.aisdk.hook(
-      "aisdk.sdk": Effect.fn(function* (evt) {
+      "sdk",
+      Effect.fn(function* (evt) {
         if (evt.package !== "venice-ai-sdk-provider") return
         const mod = yield* Effect.promise(() => import("venice-ai-sdk-provider"))
         evt.sdk = mod.createVenice(evt.options)
       }),
-    }
+    )
   }),
 })

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

@@ -1,11 +1,11 @@
 import { Effect } from "effect"
-import { PluginV2 } from "../../plugin"
+import { define } from "@opencode-ai/plugin/v2/effect"
 
-export const VercelPlugin = PluginV2.define({
+export const VercelPlugin = define({
-  id: PluginV2.ID.make("vercel"),
+  id: "vercel",
-  effect: Effect.gen(function* () {
+  effect: Effect.fn(function* (ctx) {
-    return {
+    yield* ctx.catalog.transform(
-      "catalog.transform": Effect.fn(function* (evt) {
+      Effect.fn(function* (evt) {
         for (const item of evt.provider.list()) {
           if (item.provider.api.type !== "aisdk") continue
           if (item.provider.api.package !== "@ai-sdk/vercel") continue
@@ -15,11 +15,14 @@ export const VercelPlugin = PluginV2.define({
           })
         }
       }),
-      "aisdk.sdk": Effect.fn(function* (evt) {
+    )
+    yield* ctx.aisdk.hook(
+      "sdk",
+      Effect.fn(function* (evt) {
         if (evt.package !== "@ai-sdk/vercel") return
         const mod = yield* Effect.promise(() => import("@ai-sdk/vercel"))
         evt.sdk = mod.createVercel(evt.options)
       }),
-    }
+    )
   }),
 })

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

@@ -1,20 +1,24 @@
 import { Effect } from "effect"
-import { PluginV2 } from "../../plugin"
+import { define } from "@opencode-ai/plugin/v2/effect"
 import { ProviderV2 } from "../../provider"
 
-export const XAIPlugin = PluginV2.define({
+export const XAIPlugin = define({
-  id: PluginV2.ID.make("xai"),
+  id: "xai",
-  effect: Effect.gen(function* () {
+  effect: Effect.fn(function* (ctx) {
-    return {
+    yield* ctx.aisdk.hook(
-      "aisdk.sdk": Effect.fn(function* (evt) {
+      "sdk",
+      Effect.fn(function* (evt) {
         if (evt.package !== "@ai-sdk/xai") return
         const mod = yield* Effect.promise(() => import("@ai-sdk/xai"))
         evt.sdk = mod.createXai(evt.options)
       }),
-      "aisdk.language": Effect.fn(function* (evt) {
+    )
+    yield* ctx.aisdk.hook(
+      "language",
+      Effect.fn(function* (evt) {
         if (evt.model.providerID !== ProviderV2.ID.make("xai")) return
         evt.language = evt.sdk.responses(evt.model.api.id)
       }),
-    }
+    )
   }),
 })

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

@@ -1,11 +1,11 @@
 import { Effect } from "effect"
-import { PluginV2 } from "../../plugin"
+import { define } from "@opencode-ai/plugin/v2/effect"
 
-export const ZenmuxPlugin = PluginV2.define({
+export const ZenmuxPlugin = define({
-  id: PluginV2.ID.make("zenmux"),
+  id: "zenmux",
-  effect: Effect.gen(function* () {
+  effect: Effect.fn(function* (ctx) {
-    return {
+    yield* ctx.catalog.transform(
-      "catalog.transform": Effect.fn(function* (evt) {
+      Effect.fn(function* (evt) {
         for (const item of evt.provider.list()) {
           if (item.provider.api.type !== "aisdk") continue
           if (item.provider.api.package !== "@ai-sdk/openai-compatible") continue
@@ -16,6 +16,6 @@ export const ZenmuxPlugin = PluginV2.define({
           })
         }
       }),
-    }
+    )
   }),
 })

packages/core/src/plugin/skill.ts

@@ -2,22 +2,19 @@
 
 export * as SkillPlugin from "./skill"
 
+import { define } from "@opencode-ai/plugin/v2/effect"
 import { Effect } from "effect"
-import { PluginV2 } from "../plugin"
 import { AbsolutePath } from "../schema"
 import { SkillV2 } from "../skill"
 import customizeOpencodeContent from "./skill/customize-opencode.md" with { type: "text" }
 
 export const CustomizeOpencodeContent = customizeOpencodeContent
 
-export const Plugin = PluginV2.define({
+export const Plugin = define({
-  id: PluginV2.ID.make("skill"),
+  id: "skill",
-  effect: Effect.gen(function* () {
+  effect: Effect.fn(function* (ctx) {
-    const skill = yield* SkillV2.Service
+    yield* ctx.skill.transform((draft) => {
-    const transform = yield* skill.transform()
+      draft.source(
-
-    yield* transform((editor) => {
-      editor.source(
         new SkillV2.EmbeddedSource({
           type: "embedded",
           skill: new SkillV2.Info({

packages/core/src/provider.ts

@@ -1,7 +1,7 @@
 export * as ProviderV2 from "./provider"
 
 import { withStatics } from "./schema"
-import { Schema } from "effect"
+import { Schema, Types } from "effect"
 
 export const ID = Schema.String.pipe(
   Schema.brand("ProviderV2.ID"),
@@ -37,6 +37,9 @@ export const Native = Schema.Struct({
 
 export const Api = Schema.Union([AISDK, Native]).pipe(Schema.toTaggedUnion("type"))
 export type Api = typeof Api.Type
+export type MutableApi<T extends Api = Api> = T extends Api
+  ? Omit<Types.DeepMutable<T>, "settings"> & (undefined extends T["settings"] ? { settings?: any } : { settings: any })
+  : never
 
 export const Request = Schema.Struct({
   headers: Schema.Record(Schema.String, Schema.String),
@@ -66,3 +69,5 @@ export class Info extends Schema.Class<Info>("ProviderV2.Info")({
     })
   }
 }
+
+export type MutableInfo = Omit<Types.DeepMutable<Info>, "api"> & { api: MutableApi }

packages/core/src/public/session.ts

@@ -1,7 +1,6 @@
 export * as Session from "./session"
 
 import { Effect, Schema, Stream } from "effect"
-import { EventV2 } from "../event"
 import { ModelV2 } from "../model"
 import { SessionV2 } from "../session"
 import { MessageDecodeError } from "../session/error"
@@ -34,9 +33,7 @@ export type Delivery = SessionInput.Delivery
 export const ListInput = SessionV2.ListInput
 export type ListInput = SessionV2.ListInput
 
-export const EventCursor = EventV2.Cursor
+export type Event = SessionEvent.DurableEvent
-export type EventCursor = EventV2.Cursor
-export type Event = EventV2.CursorEvent<SessionEvent.DurableEvent>
 
 export const NotFoundError = SessionV2.NotFoundError
 export type NotFoundError = SessionV2.NotFoundError
@@ -99,7 +96,7 @@ export interface MessageInput {
 
 export interface EventsInput {
   readonly sessionID: ID
-  readonly after?: EventCursor
+  readonly after?: number
 }
 
 export interface Interface {

packages/core/src/reference.ts

@@ -1,7 +1,6 @@
 export * as Reference from "./reference"
 
-import { Context, Effect, Layer, Schema, Scope } from "effect"
+import { Context, Effect, Layer, Schema, Scope, Types } from "effect"
-import { castDraft } from "immer"
 import { Global } from "./global"
 import { EventV2 } from "./event"
 import { Repository } from "./repository"
@@ -40,17 +39,16 @@ export class Info extends Schema.Class<Info>("Reference.Info")({
 }) {}
 
 type Data = {
-  sources: Map<string, Source>
+  sources: Map<string, Types.DeepMutable<Source>>
 }
 
-type Editor = {
+type Draft = {
   add(name: string, source: Source): void
   remove(name: string): void
   list(): readonly [string, Source][]
 }
 
-export interface Interface {
+export interface Interface extends State.Transformable<Draft> {
-  readonly transform: State.Interface<Data, Editor>["transform"]
   readonly list: () => Effect.Effect<Info[]>
 }
 
@@ -64,18 +62,18 @@ export const layer = Layer.effect(
     const cache = yield* RepositoryCache.Service
     const scope = yield* Scope.Scope
     const materialized = new Map<string, Info>()
-    const state = State.create<Data, Editor>({
+    const state = State.create<Data, Draft>({
       initial: () => ({ sources: new Map() }),
-      editor: (draft) => ({
+      draft: (draft) => ({
-        add: (name, source) => draft.sources.set(name, castDraft(source)),
+        add: (name, source) => draft.sources.set(name, source as Types.DeepMutable<Source>),
         remove: (name) => draft.sources.delete(name),
         list: () => Array.from(draft.sources.entries()) as [string, Source][],
       }),
-      finalize: (editor) =>
+      finalize: (draft) =>
         Effect.gen(function* () {
           materialized.clear()
           const seen = new Map<string, string | undefined>()
-          for (const [name, source] of editor.list()) {
+          for (const [name, source] of draft.list()) {
             if (source.type === "local") {
               materialized.set(
                 name,
@@ -128,6 +126,7 @@ export const layer = Layer.effect(
 
     return Service.of({
       transform: state.transform,
+      rebuild: state.rebuild,
       list: Effect.fn("Reference.list")(function* () {
         return Array.from(materialized.values())
       }),

packages/core/src/session.ts

@@ -124,8 +124,8 @@ export interface Interface {
   ) => Effect.Effect<SessionMessage.Message[], NotFoundError | MessageDecodeError>
   readonly events: (input: {
     sessionID: SessionSchema.ID
-    after?: EventV2.Cursor
+    after?: number
-  }) => Stream.Stream<EventV2.CursorEvent<SessionEvent.DurableEvent>, NotFoundError>
+  }) => Stream.Stream<SessionEvent.DurableEvent, NotFoundError>
   readonly switchAgent: (input: {
     sessionID: SessionSchema.ID
     agent: string
@@ -339,12 +339,8 @@ export const layer = Layer.effect(
         Stream.unwrap(
           result
             .get(input.sessionID)
-            .pipe(Effect.as(events.aggregateEvents({ aggregateID: input.sessionID, after: input.after }))),
+            .pipe(Effect.as(events.durable({ aggregateID: input.sessionID, after: input.after }))),
-        ).pipe(
+        ).pipe(Stream.filter((event): event is SessionEvent.DurableEvent => isDurableSessionEvent(event))),
-          Stream.filter((event): event is EventV2.CursorEvent<SessionEvent.DurableEvent> =>
-            isDurableSessionEvent(event.event),
-          ),
-        ),
       prompt: Effect.fn("V2Session.prompt")((input) =>
         Effect.uninterruptible(
           Effect.gen(function* () {
@@ -413,9 +409,9 @@ export const layer = Layer.effect(
               sessionID,
               timestamp: yield* DateTime.now,
             })
-            if (event.seq === undefined)
+            if (event.durable === undefined)
               return yield* Effect.die("Interrupt request event is missing aggregate sequence")
-            yield* execution.interrupt(sessionID, event.seq)
+            yield* execution.interrupt(sessionID, event.durable.seq)
           }),
         ),
       ),

packages/core/src/session/event.ts

@@ -27,13 +27,13 @@ const Base = {
 }
 
 const options = {
-  sync: {
+  durable: {
     aggregate: "sessionID",
     version: 1,
   },
 } as const
 const stepSettlementOptions = {
-  sync: {
+  durable: {
     aggregate: "sessionID",
     version: 2,
   },
@@ -456,7 +456,7 @@ export namespace Compaction {
 
   export const Ended = EventV2.define({
     type: "session.next.compaction.ended",
-    sync: { aggregate: "sessionID", version: 2 },
+    durable: { aggregate: "sessionID", version: 2 },
     schema: {
       ...Base,
       messageID: SessionMessageID.ID,

packages/core/src/session/input.ts

@@ -74,11 +74,11 @@ export const admit = Effect.fn("SessionInput.admit")(function* (
     })
     .pipe(
       Effect.flatMap((event) =>
-        event.seq === undefined
+        event.durable === undefined
           ? Effect.die("Prompt admission event is missing aggregate sequence")
           : Effect.succeed(
               new Admitted({
-                admittedSeq: event.seq,
+                admittedSeq: event.durable.seq,
                 id: input.id,
                 sessionID: input.sessionID,
                 prompt: input.prompt,
@@ -117,13 +117,6 @@ export const projectAdmitted = Effect.fn("SessionInput.projectAdmitted")(functio
     readonly timeCreated: DateTime.Utc
   },
 ) {
-  const message = yield* db
-    .select({ id: SessionMessageTable.id })
-    .from(SessionMessageTable)
-    .where(eq(SessionMessageTable.id, input.id))
-    .get()
-    .pipe(Effect.orDie)
-  if (message) return yield* Effect.die(new LifecycleConflict({ id: input.id }))
   const stored = yield* db
     .insert(SessionInputTable)
     .values({
@@ -208,37 +201,6 @@ const matchesPrompt = (input: Admitted, expected: { readonly sessionID: SessionS
   input.sessionID === expected.sessionID &&
   JSON.stringify(encodePrompt(input.prompt)) === JSON.stringify(encodePrompt(expected.prompt))
 
-export const guardReservedID = Effect.fn("SessionInput.guardReservedID")(function* (
-  db: DatabaseService,
-  event: EventV2.Payload,
-) {
-  if (
-    Schema.is(SessionEvent.PromptLifecycle.Admitted)(event) ||
-    Schema.is(SessionEvent.PromptLifecycle.Promoted)(event)
-  )
-    return
-  const id = reservedID(event)
-  if (id === undefined) return
-  const admitted = yield* db
-    .select({ id: SessionInputTable.id })
-    .from(SessionInputTable)
-    .where(eq(SessionInputTable.id, id))
-    .get()
-    .pipe(Effect.orDie)
-  if (admitted === undefined) return
-  return yield* Effect.die(new LifecycleConflict({ id }))
-})
-
-const reservedID = (event: EventV2.Payload) => {
-  if (Schema.is(SessionEvent.Step.Started)(event)) return event.data.assistantMessageID
-  if (Schema.is(SessionEvent.AgentSwitched)(event)) return event.data.messageID
-  if (Schema.is(SessionEvent.ModelSwitched)(event)) return event.data.messageID
-  if (Schema.is(SessionEvent.Prompted)(event)) return event.data.messageID
-  if (Schema.is(SessionEvent.Synthetic)(event)) return event.data.messageID
-  if (Schema.is(SessionEvent.Shell.Started)(event)) return event.data.messageID
-  if (Schema.is(SessionEvent.Compaction.Started)(event)) return event.data.messageID
-}
-
 export const projectLegacyPrompted = Effect.fn("SessionInput.projectLegacyPrompted")(function* (
   db: DatabaseService,
   input: {

packages/core/src/session/projector.ts

@@ -115,7 +115,7 @@ function run(db: DatabaseService, event: SessionEvent.Event) {
     const decodeRow = (row: typeof SessionMessageTable.$inferSelect) =>
       decodeMessage({ ...row.data, id: row.id, type: row.type })
     const updateMessage = (message: SessionMessage.Message) => {
-      if (event.seq === undefined) return Effect.die("Synchronized Session event is missing aggregate sequence")
+      if (event.durable === undefined) return Effect.die("Durable Session event is missing aggregate sequence")
       const encoded = encodeMessage(message)
       const { id, type, ...data } = encoded
       return db
@@ -192,7 +192,7 @@ function run(db: DatabaseService, event: SessionEvent.Event) {
 }
 
 function insertMessage(db: DatabaseService, event: SessionEvent.Event, message: SessionMessage.Message) {
-  if (event.seq === undefined) return Effect.die("Synchronized Session event is missing aggregate sequence")
+  if (event.durable === undefined) return Effect.die("Durable Session event is missing aggregate sequence")
   const encoded = encodeMessage(message)
   const { id, type, ...data } = encoded
   return db
@@ -201,7 +201,7 @@ function insertMessage(db: DatabaseService, event: SessionEvent.Event, message:
       id: SessionMessage.ID.make(id),
       session_id: event.data.sessionID,
       type,
-      seq: event.seq,
+      seq: event.durable.seq,
       time_created: DateTime.toEpochMillis(message.time.created),
       data,
     })
@@ -213,7 +213,6 @@ export const layer = Layer.effectDiscard(
   Effect.gen(function* () {
     const events = yield* EventV2.Service
     const { db } = yield* Database.Service
-    yield* events.beforeCommit((event) => SessionInput.guardReservedID(db, event))
     yield* events.project(SessionV1.Event.Created, (event) =>
       Effect.gen(function* () {
         const stored = yield* db
@@ -331,7 +330,7 @@ export const layer = Layer.effectDiscard(
       }),
     )
     yield* events.project(SessionEvent.AgentSwitched, (event) => {
-      if (event.seq === undefined) return Effect.die("Synchronized Session event is missing aggregate sequence")
+      if (event.durable === undefined) return Effect.die("Durable Session event is missing aggregate sequence")
       return db
         .update(SessionTable)
         .set({ agent: event.data.agent, time_updated: DateTime.toEpochMillis(event.data.timestamp) })
@@ -340,7 +339,7 @@ export const layer = Layer.effectDiscard(
         .pipe(
           Effect.orDie,
           Effect.andThen(run(db, event)),
-          Effect.andThen(SessionContextEpoch.requestReplacement(db, event.data.sessionID, event.seq)),
+          Effect.andThen(SessionContextEpoch.requestReplacement(db, event.data.sessionID, event.durable.seq)),
         )
     })
     yield* events.project(SessionEvent.ModelSwitched, (event) =>
@@ -352,9 +351,8 @@ export const layer = Layer.effectDiscard(
           .run()
           .pipe(Effect.orDie)
         yield* run(db, event)
-        if (event.seq === undefined)
+        if (event.durable === undefined) return yield* Effect.die("Durable Session event is missing aggregate sequence")
-          return yield* Effect.die("Synchronized Session event is missing aggregate sequence")
+        yield* SessionContextEpoch.requestReplacement(db, event.data.sessionID, event.durable.seq)
-        yield* SessionContextEpoch.requestReplacement(db, event.data.sessionID, event.seq)
       }),
     )
     yield* events.project(SessionEvent.Prompted, (event) =>
@@ -368,24 +366,22 @@ export const layer = Layer.effectDiscard(
           .pipe(Effect.orDie)
         if (existing) return yield* Effect.die(new PromptAlreadyProjected())
         yield* run(db, event)
-        if (event.seq === undefined)
+        if (event.durable === undefined) return yield* Effect.die("Durable Session event is missing aggregate sequence")
-          return yield* Effect.die("Synchronized Session event is missing aggregate sequence")
         yield* SessionInput.projectLegacyPrompted(db, {
           id: messageID,
           sessionID: event.data.sessionID,
           prompt: event.data.prompt,
           delivery: event.data.delivery,
           timeCreated: event.data.timestamp,
-          promotedSeq: event.seq,
+          promotedSeq: event.durable.seq,
         })
       }),
     )
     yield* events.project(SessionEvent.PromptLifecycle.Admitted, (event) =>
       Effect.gen(function* () {
-        if (event.seq === undefined)
+        if (event.durable === undefined) return yield* Effect.die("Durable Session event is missing aggregate sequence")
-          return yield* Effect.die("Synchronized Session event is missing aggregate sequence")
         yield* SessionInput.projectAdmitted(db, {
-          admittedSeq: event.seq,
+          admittedSeq: event.durable.seq,
           id: event.data.messageID,
           sessionID: event.data.sessionID,
           prompt: event.data.prompt,
@@ -396,8 +392,7 @@ export const layer = Layer.effectDiscard(
     )
     yield* events.project(SessionEvent.PromptLifecycle.Promoted, (event) =>
       Effect.gen(function* () {
-        if (event.seq === undefined)
+        if (event.durable === undefined) return yield* Effect.die("Durable Session event is missing aggregate sequence")
-          return yield* Effect.die("Synchronized Session event is missing aggregate sequence")
         yield* insertMessage(
           db,
           event,
@@ -406,18 +401,14 @@ export const layer = Layer.effectDiscard(
             sessionID: event.data.sessionID,
             prompt: event.data.prompt,
             timeCreated: event.data.timeCreated,
-            promotedSeq: event.seq,
+            promotedSeq: event.durable.seq,
           }),
         )
       }),
     )
     yield* events.project(SessionEvent.InterruptRequested, () => Effect.void)
-    yield* events.project(SessionEvent.ContextUpdated, (event) => {
+    // TODO: Reconstruct context epoch replacement state during replay without adding replay state to every EventV2 payload.
-      if (!event.replay || event.seq === undefined) return run(db, event)
+    yield* events.project(SessionEvent.ContextUpdated, (event) => run(db, event))
-      return run(db, event).pipe(
-        Effect.andThen(SessionContextEpoch.requestReplacement(db, event.data.sessionID, event.seq)),
-      )
-    })
     yield* events.project(SessionEvent.Synthetic, (event) => run(db, event))
     yield* events.project(SessionEvent.Shell.Started, (event) => run(db, event))
     yield* events.project(SessionEvent.Shell.Ended, (event) => run(db, event))
@@ -436,9 +427,9 @@ export const layer = Layer.effectDiscard(
     yield* events.project(SessionEvent.Reasoning.Ended, (event) => run(db, event))
     // yield* events.project(SessionEvent.Retried, (event) => run(db, event))
     yield* events.project(SessionEvent.Compaction.Ended, (event) => {
-      if (event.version === 1) return Effect.void
+      if (event.durable === undefined) return Effect.die("Durable Session event is missing aggregate sequence")
-      const seq = event.seq
+      if (event.durable.version === 1) return Effect.void
-      if (seq === undefined) return Effect.die("Synchronized Session event is missing aggregate sequence")
+      const seq = event.durable.seq
       return Effect.gen(function* () {
         yield* run(db, event)
         yield* SessionContextEpoch.requestReplacement(db, event.data.sessionID, seq)

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

@@ -33,11 +33,7 @@ export class UnsupportedApiError extends Schema.TaggedErrorClass<UnsupportedApiE
   },
 ) {}
 
-export type Error =
+export type Error = ModelNotSelectedError | UnsupportedApiError
-  | Catalog.ProviderNotFoundError
-  | Catalog.ModelNotFoundError
-  | ModelNotSelectedError
-  | UnsupportedApiError
 
 export interface Interface {
   readonly resolve: (session: SessionSchema.Info) => Effect.Effect<Model, Error>
@@ -149,10 +145,12 @@ export const locationLayer = Layer.effect(
       resolve: Effect.fn("SessionRunnerModel.resolve")(function* (session) {
         // Location plugins populate and filter the catalog asynchronously during layer startup.
         yield* boot.wait()
+        const defaultModel = session.model ? undefined : yield* catalog.model.default()
         const selected = session.model
           ? yield* catalog.model.get(session.model.providerID, session.model.id)
-          : (Option.getOrUndefined((yield* catalog.model.default()).pipe(Option.filter(supported))) ??
+          : defaultModel && supported(defaultModel)
-            (yield* catalog.model.available()).find(supported))
+            ? defaultModel
+            : (yield* catalog.model.available()).find(supported)
         if (!selected) return yield* new ModelNotSelectedError({ sessionID: session.id })
         const connection = yield* integrations.connection.forIntegration(Integration.ID.make(selected.providerID))
         return yield* fromCatalogModel(

packages/core/src/skill.ts

@@ -1,8 +1,7 @@
 export * as SkillV2 from "./skill"
 
 import path from "path"
-import { Context, Effect, Layer, Schema } from "effect"
+import { Context, Effect, Layer, Schema, Types } from "effect"
-import { castDraft } from "immer"
 import { AgentV2 } from "./agent"
 import { ConfigMarkdown } from "./config/markdown"
 import { FSUtil } from "./fs-util"
@@ -65,16 +64,15 @@ const Frontmatter = Schema.Struct({
 const decodeFrontmatter = Schema.decodeUnknownOption(Frontmatter)
 
 export type Data = {
-  sources: Source[]
+  sources: Types.DeepMutable<Source>[]
 }
 
-export type Editor = {
+export type Draft = {
   source: (source: Source) => void
   list: () => readonly Source[]
 }
 
-export interface Interface {
+export interface Interface extends State.Transformable<Draft> {
-  readonly transform: State.Interface<Data, Editor>["transform"]
   readonly sources: () => Effect.Effect<Source[]>
   readonly list: () => Effect.Effect<Info[]>
 }
@@ -87,12 +85,12 @@ export const layer = Layer.effect(
     const discovery = yield* SkillDiscovery.Service
     const fs = yield* FSUtil.Service
 
-    const state = State.create<Data, Editor>({
+    const state = State.create<Data, Draft>({
       initial: () => ({ sources: [] }),
-      editor: (draft) => ({
+      draft: (draft) => ({
         source: (source) => {
           if (draft.sources.some((item) => Source.equals(item, source))) return
-          draft.sources.push(castDraft(source))
+          draft.sources.push(source as Types.DeepMutable<Source>)
         },
         list: () => draft.sources as Source[],
       }),
@@ -150,6 +148,7 @@ export const layer = Layer.effect(
 
     return Service.of({
       transform: state.transform,
+      rebuild: state.rebuild,
       sources: Effect.fn("SkillV2.sources")(function* () {
         return state.get().sources
       }),

packages/core/src/state.ts

@@ -1,112 +1,128 @@
 export * as State from "./state"
 
-import { Effect, Scope, Semaphore } from "effect"
+import { Context, Effect, Scope, Semaphore } from "effect"
-import type { Draft, Objectish } from "immer"
 
 /**
- * A replayable transform applied to an editor during rebuild.
+ * A replayable transform applied to a draft during rebuild.
  *
- * Transforms are intentionally synchronous and mutation-shaped: domain editors
+ * Domain drafts expose readable and writable state while preserving concise
- * hide the draft representation while preserving concise plugin/config code.
+ * plugin/config code. Transforms may perform Effects before returning.
  */
-export type Transform<Editor> = (editor: Editor) => void
+type TransformCallback<DraftApi> = (draft: DraftApi) => Effect.Effect<void> | void
-export type MakeEditor<State extends Objectish, Editor> = (draft: Draft<State>) => Editor
+export type MakeDraft<State, DraftApi> = (state: State) => DraftApi
 
-export interface Options<State extends Objectish, Editor> {
+export interface Registration {
+  readonly dispose: Effect.Effect<void>
+}
+
+export type Transform<DraftApi> = (
+  transform: TransformCallback<DraftApi>,
+) => Effect.Effect<Registration, never, Scope.Scope>
+
+export type Rebuild = () => Effect.Effect<void>
+
+export interface Transformable<DraftApi> {
+  readonly transform: Transform<DraftApi>
+  readonly rebuild: Rebuild
+}
+
+const CurrentBatch = Context.Reference<Set<Rebuild> | undefined>("@opencode/State/CurrentBatch", {
+  defaultValue: () => undefined,
+})
+
+export function batch<A, E, R>(effect: Effect.Effect<A, E, R>) {
+  return Effect.gen(function* () {
+    const current = yield* CurrentBatch
+    if (current) return yield* effect
+    const rebuilds = new Set<Rebuild>()
+    const result = yield* effect.pipe(Effect.provideService(CurrentBatch, rebuilds))
+    yield* Effect.forEach(rebuilds, (rebuild) => rebuild(), { discard: true })
+    return result
+  })
+}
+
+export interface Options<State, DraftApi> {
   /** Creates the base value for initial state and every scoped-transform rebuild. */
   readonly initial: () => State
-  /** Wraps the mutable draft in a domain-specific editor. */
+  /** Wraps mutable state in a domain-specific draft API. */
-  readonly editor: MakeEditor<State, Editor>
+  readonly draft: MakeDraft<State, DraftApi>
-  /**
+  /** Runs after all active transforms and before the rebuilt state becomes visible. */
-   * Completes every committed edit.
+  readonly finalize?: (draft: DraftApi) => Effect.Effect<void>
-   *
-   * For rebuilds, this runs after all active transforms have been replayed and
-   * before the rebuilt state becomes visible. For direct updates, this runs
-   * after the current state has already been edited. The optional reason is
-   * caller-defined metadata for exceptional update origins.
-   */
-  readonly finalize?: (editor: Editor, reason?: string) => Effect.Effect<void>
 }
 
-export interface Interface<State extends Objectish, Editor> {
+export interface Interface<State, DraftApi> extends Transformable<DraftApi> {
   readonly get: () => State
   /**
-   * Registers a scoped transform slot and returns the slot updater.
+   * Registers and applies a scoped transform. Closing the owning Scope removes
-   *
+   * the transform and rebuilds the materialized state.
-   * Acquiring the slot has no visible effect until the returned updater is
-   * called. Each updater call replaces that slot's transform, then rebuilds the
-   * materialized state from `initial()` by replaying all active transforms in
-   * registration order. Closing the owning Scope removes the slot and rebuilds.
    */
-  readonly transform: () => Effect.Effect<(transform: Transform<Editor>) => Effect.Effect<void>, never, Scope.Scope>
-  /** Registers and applies a replayable transform in the current Scope. */
-  readonly update: (update: Transform<Editor>) => Effect.Effect<void, never, Scope.Scope>
-  /**
-   * Mutates the current materialized state directly, once.
-   *
-   * This is not replayable transform state: a later rebuild starts again
-   * from `initial()` plus active transforms, so direct edits must be reserved
-   * for current-state adjustments that are intentionally outside the transform
-   * fold.
-   */
-  readonly mutate: (update: (editor: Editor) => Effect.Effect<void>, reason?: string) => Effect.Effect<void>
 }
 
-export function create<State extends Objectish, Editor>(options: Options<State, Editor>): Interface<State, Editor> {
+export function create<State, DraftApi>(options: Options<State, DraftApi>): Interface<State, DraftApi> {
   let state = options.initial()
-  let transforms: { update: Transform<Editor> }[] = []
+  let transforms: { run: TransformCallback<DraftApi> }[] = []
   const semaphore = Semaphore.makeUnsafe(1)
 
-  const commit = Effect.fn("State.commit")(function* (next: State, reason?: string) {
+  const commit = Effect.fn("State.commit")(function* (next: State) {
-    const api = options.editor(next as Draft<State>)
+    const api = options.draft(next)
-    if (options.finalize) yield* options.finalize(api, reason)
+    if (options.finalize) yield* options.finalize(api)
     state = next
   })
 
-  const rebuild = Effect.fnUntraced(function* () {
+  const apply = (transform: TransformCallback<DraftApi>, draft: DraftApi) =>
+    Effect.suspend(() => {
+      const result = transform(draft)
+      return Effect.isEffect(result) ? Effect.asVoid(result).pipe(Effect.orDie) : Effect.void
+    })
+
+  const materialize = Effect.fnUntraced(function* () {
     const next = options.initial()
-    const api = options.editor(next as Draft<State>)
+    const api = options.draft(next)
-    for (const transform of transforms)
+    for (const transform of transforms) yield* apply(transform.run, api).pipe(Effect.withSpan("State.rebuild.update"))
-      yield* Effect.sync(() => transform.update(api)).pipe(Effect.withSpan("State.rebuild.update", {}))
     yield* commit(next)
   })
 
-  const result: Interface<State, Editor> = {
+  const rebuild = () => semaphore.withPermit(materialize())
+
+  const result: Interface<State, DraftApi> = {
     get: () => state,
-    transform: Effect.fn("State.transform")(function* () {
+    transform: Effect.fn("State.transform")(function* (update) {
       const scope = yield* Scope.Scope
       return yield* Effect.uninterruptible(
         Effect.gen(function* () {
-          const transform = { update: (_editor: Editor) => {} }
+          const transform = { run: update }
-          transforms = [...transforms, transform]
+          let active = true
-          yield* Scope.addFinalizer(
+          const dispose = Effect.uninterruptible(
-            scope,
             semaphore.withPermit(
-              Effect.sync(() => {
+              Effect.suspend(() => {
+                if (!active) return Effect.void
+                active = false
                 transforms = transforms.filter((item) => item !== transform)
-              }).pipe(Effect.andThen(rebuild())),
+                return Effect.gen(function* () {
+                  const batch = yield* CurrentBatch
+                  if (batch) {
+                    batch.add(rebuild)
+                    return
+                  }
+                  yield* materialize()
+                })
+              }),
             ),
           )
-          return (update: Transform<Editor>) =>
+          yield* semaphore.withPermit(
-            Effect.uninterruptible(
-              semaphore.withPermit(
             Effect.sync(() => {
-                  transform.update = update
+              transforms = [...transforms, transform]
-                }).pipe(Effect.andThen(rebuild())),
+            }),
-              ),
           )
+          yield* Scope.addFinalizer(scope, dispose)
+          const batch = yield* CurrentBatch
+          if (batch) batch.add(rebuild)
+          else yield* rebuild()
+          return { dispose }
         }),
       )
     }),
-    update: Effect.fn("State.update")(function* (update) {
+    rebuild,
-      const transform = yield* result.transform()
-      yield* transform(update)
-    }),
-    mutate: Effect.fn("State.mutate")(function* (update, reason) {
-      const api = options.editor(state as Draft<State>)
-      yield* update(api)
-      if (options.finalize) yield* options.finalize(api, reason)
-    }, semaphore.withPermit),
   }
   return result
 }

packages/core/src/tool/application-tools.ts

@@ -1,7 +1,6 @@
 export * as ApplicationTools from "./application-tools"
 
 import { Context, Effect, Layer, Scope } from "effect"
-import { enableMapSet } from "immer"
 import { State } from "../state"
 import { Tool } from "./tool"
 
@@ -9,7 +8,7 @@ type Data = {
   readonly entries: Map<string, Entry>
 }
 
-type Editor = {
+type Draft = {
   readonly set: (name: string, entry: Entry) => void
 }
 
@@ -27,14 +26,12 @@ export interface Interface {
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/ApplicationTools") {}
 
-enableMapSet()
-
 export const layer = Layer.effect(
   Service,
   Effect.gen(function* () {
-    const state = State.create<Data, Editor>({
+    const state = State.create<Data, Draft>({
       initial: () => ({ entries: new Map() }),
-      editor: (draft) => ({
+      draft: (draft) => ({
         set: (name, tool) => {
           draft.entries.set(name, tool)
         },
@@ -47,9 +44,8 @@ export const layer = Layer.effect(
         if (entries.length === 0) return
         yield* Effect.forEach(entries, ([name]) => Tool.validateName(name), { discard: true })
         const registrations = entries.map(([name, tool]) => [name, { identity: {}, tool }] as const)
-        const transform = yield* state.transform()
+        yield* state.transform((draft) => {
-        yield* transform((editor) => {
+          for (const [name, entry] of registrations) draft.set(name, entry)
-          for (const [name, entry] of registrations) editor.set(name, entry)
         })
       }),
       entries: () => state.get().entries,

packages/core/src/v1/session.ts

@@ -502,7 +502,7 @@ export type WithParts = {
 }
 
 const options = {
-  sync: {
+  durable: {
     aggregate: "sessionID",
     version: 1,
   },

packages/core/test/agent.test.ts

@@ -6,6 +6,7 @@ import { AgentPlugin } from "@opencode-ai/core/plugin/agent"
 import { AbsolutePath } from "@opencode-ai/core/schema"
 import { location } from "./fixture/location"
 import { testEffect } from "./lib/effect"
+import { agentHost, host } from "./plugin/host"
 
 const it = testEffect(AgentV2.locationLayer)
 
@@ -23,9 +24,7 @@ describe("AgentV2", () => {
     Effect.gen(function* () {
       const agent = yield* AgentV2.Service
       const id = AgentV2.ID.make("reviewer")
-      const transform = yield* agent.transform()
+      yield* agent.transform((editor) =>
-
-      yield* transform((editor) =>
         editor.update(id, (info) => {
           info.description = "Reviews code"
           info.mode = "subagent"
@@ -41,19 +40,17 @@ describe("AgentV2", () => {
     Effect.gen(function* () {
       const agent = yield* AgentV2.Service
       const id = AgentV2.ID.make("reviewer")
-      const transform = yield* agent.transform()
+      let description = "Old description"
-
+      let hidden = true
-      yield* transform((editor) =>
+      yield* agent.transform((editor) =>
         editor.update(id, (info) => {
-          info.description = "Old description"
+          info.description = description
-          info.hidden = true
+          info.hidden = hidden
-        }),
-      )
-      yield* transform((editor) =>
-        editor.update(id, (info) => {
-          info.description = "New description"
         }),
       )
+      description = "New description"
+      hidden = false
+      yield* agent.rebuild()
 
       expect(yield* agent.get(id)).toMatchObject({ description: "New description", hidden: false })
     }),
@@ -64,9 +61,7 @@ describe("AgentV2", () => {
       const agent = yield* AgentV2.Service
       const id = AgentV2.ID.make("scoped")
       const scope = yield* Scope.make()
-      const transform = yield* agent.transform().pipe(Scope.provide(scope))
+      yield* agent.transform((editor) => editor.update(id, () => {})).pipe(Scope.provide(scope))
-
-      yield* transform((editor) => editor.update(id, () => {}))
       expect(yield* agent.get(id)).toBeDefined()
 
       yield* Scope.close(scope, Exit.void)
@@ -79,7 +74,7 @@ describe("AgentV2", () => {
       const agent = yield* AgentV2.Service
       const id = AgentV2.ID.make("build")
 
-      yield* agent.update((editor) =>
+      yield* agent.transform((editor) =>
         editor.update(id, (info) => {
           info.mode = "primary"
           info.hidden = true
@@ -95,10 +90,10 @@ describe("AgentV2", () => {
       const agent = yield* AgentV2.Service
       const id = AgentV2.ID.make("custom")
 
-      yield* agent.update((editor) => editor.update(id, () => {}))
+      yield* agent.transform((editor) => editor.update(id, () => {}))
       expect(yield* agent.get(id)).toEqual(AgentV2.Info.empty(id))
 
-      yield* agent.update((editor) => editor.remove(id))
+      yield* agent.transform((editor) => editor.remove(id))
       expect(yield* agent.get(id)).toBeUndefined()
     }),
   )
@@ -106,11 +101,11 @@ describe("AgentV2", () => {
   it.effect("does not ambiently opt built-in agents into bash", () =>
     Effect.gen(function* () {
       const agent = yield* AgentV2.Service
-      yield* AgentPlugin.Plugin.effect.pipe(
+      yield* AgentPlugin.Plugin.effect(
-        Effect.provideService(
+        host({
-          Location.Service,
+          agent: agentHost(agent),
-          Location.Service.of(location({ directory: AbsolutePath.make("/project") })),
+          location: location({ directory: AbsolutePath.make("/project") }),
-        ),
+        }),
       )
 
       const agents = yield* agent.all()

packages/core/test/catalog.test.ts

@@ -1,18 +1,17 @@
 import { describe, expect } from "bun:test"
-import { DateTime, Effect, Fiber, Layer, Option, Stream } from "effect"
+import { Effect, Fiber, Layer, Stream } from "effect"
 import { Catalog } from "@opencode-ai/core/catalog"
 import { Integration } from "@opencode-ai/core/integration"
 import { Credential } from "@opencode-ai/core/credential"
 import { EventV2 } from "@opencode-ai/core/event"
 import { Location } from "@opencode-ai/core/location"
 import { ModelV2 } from "@opencode-ai/core/model"
-import { PluginV2 } from "@opencode-ai/core/plugin"
 import { Policy } from "@opencode-ai/core/policy"
-import { Project } from "@opencode-ai/core/project"
 import { ProviderV2 } from "@opencode-ai/core/provider"
 import { AbsolutePath } from "@opencode-ai/core/schema"
 import { location } from "./fixture/location"
 import { testEffect } from "./lib/effect"
+import { required } from "./plugin/provider-helper"
 
 const locationLayer = Layer.succeed(
   Location.Service,
@@ -41,7 +40,7 @@ describe("CatalogV2", () => {
         .pipe(Stream.take(1), Stream.runCollect, Effect.forkScoped)
       yield* Effect.yieldNow
 
-      yield* (yield* catalog.transform())((editor) => editor.provider.update(ProviderV2.ID.make("test"), () => {}))
+      yield* catalog.transform((editor) => editor.provider.update(ProviderV2.ID.make("test"), () => {}))
 
       expect((yield* Fiber.join(updated)).length).toBe(1)
     }),
@@ -76,14 +75,13 @@ describe("CatalogV2", () => {
 
     return Effect.gen(function* () {
       const catalog = yield* Catalog.Service
-      const transform = yield* catalog.transform()
+      yield* catalog.transform((editor) => editor.provider.update(ProviderV2.ID.make("test"), () => {}))
-      yield* transform((editor) => editor.provider.update(ProviderV2.ID.make("test"), () => {}))
 
       expect((yield* catalog.provider.available()).map((provider) => provider.id)).toEqual([ProviderV2.ID.make("test")])
-      expect((yield* catalog.provider.get(ProviderV2.ID.make("test"))).request.body).toEqual({})
+      expect(required(yield* catalog.provider.get(ProviderV2.ID.make("test"))).request.body).toEqual({})
       active = second
       expect((yield* catalog.provider.available()).map((provider) => provider.id)).toEqual([ProviderV2.ID.make("test")])
-      expect((yield* catalog.provider.get(ProviderV2.ID.make("test"))).request.body).toEqual({})
+      expect(required(yield* catalog.provider.get(ProviderV2.ID.make("test"))).request.body).toEqual({})
     }).pipe(Effect.provide(layer))
   })
 
@@ -99,13 +97,13 @@ describe("CatalogV2", () => {
           const catalog = yield* Catalog.Service
           const integrations = yield* Integration.Service
           const providerID = ProviderV2.ID.make("test")
-          yield* integrations.update((editor) =>
+          yield* integrations.transform((editor) =>
             editor.method.update({
               integrationID: Integration.ID.make(providerID),
               method: { type: "env", names: ["CATALOG_TEST_API_KEY"] },
             }),
           )
-          yield* (yield* catalog.transform())((editor) => editor.provider.update(providerID, () => {}))
+          yield* catalog.transform((editor) => editor.provider.update(providerID, () => {}))
 
           expect((yield* catalog.provider.available()).map((provider) => provider.id)).toContain(providerID)
         }),
@@ -121,9 +119,7 @@ describe("CatalogV2", () => {
     Effect.gen(function* () {
       const catalog = yield* Catalog.Service
       const providerID = ProviderV2.ID.make("test")
-      const transform = yield* catalog.transform()
+      yield* catalog.transform((catalog) =>
-
-      yield* transform((catalog) =>
         catalog.provider.update(providerID, (provider) => {
           provider.api = {
             type: "aisdk",
@@ -134,7 +130,7 @@ describe("CatalogV2", () => {
         }),
       )
 
-      expect((yield* catalog.provider.get(providerID)).api).toEqual({
+      expect(required(yield* catalog.provider.get(providerID)).api).toEqual({
         type: "aisdk",
         package: "@ai-sdk/openai-compatible",
         url: "https://override.example.com",
@@ -147,9 +143,7 @@ describe("CatalogV2", () => {
       const catalog = yield* Catalog.Service
       const providerID = ProviderV2.ID.make("test")
       const modelID = ModelV2.ID.make("model")
-      const transform = yield* catalog.transform()
+      yield* catalog.transform((catalog) => {
-
-      yield* transform((catalog) => {
         catalog.provider.update(providerID, (provider) => {
           provider.api = {
             type: "aisdk",
@@ -168,7 +162,7 @@ describe("CatalogV2", () => {
         })
       })
 
-      expect((yield* catalog.model.get(providerID, modelID)).api).toEqual({
+      expect(required(yield* catalog.model.get(providerID, modelID)).api).toEqual({
         id: modelID,
         type: "aisdk",
         package: "@ai-sdk/openai-compatible",
@@ -183,9 +177,7 @@ describe("CatalogV2", () => {
       const catalog = yield* Catalog.Service
       const providerID = ProviderV2.ID.make("test")
       const modelID = ModelV2.ID.make("model")
-      const transform = yield* catalog.transform()
+      yield* catalog.transform((catalog) => {
-
-      yield* transform((catalog) => {
         catalog.provider.update(providerID, (provider) => {
           provider.api = {
             type: "aisdk",
@@ -196,7 +188,7 @@ describe("CatalogV2", () => {
         catalog.model.update(providerID, modelID, () => {})
       })
 
-      expect((yield* catalog.model.get(providerID, modelID)).api).toEqual({
+      expect(required(yield* catalog.model.get(providerID, modelID)).api).toEqual({
         id: modelID,
         type: "aisdk",
         package: "@ai-sdk/openai-compatible",
@@ -205,106 +197,12 @@ describe("CatalogV2", () => {
     }),
   )
 
-  it.effect("runs catalog transform hooks after baseURL is normalized", () =>
-    Effect.gen(function* () {
-      const catalog = yield* Catalog.Service
-      const plugin = yield* PluginV2.Service
-      const providerID = ProviderV2.ID.make("test")
-      const seen: unknown[] = []
-      const transform = yield* catalog.transform()
-
-      yield* plugin.add({
-        id: PluginV2.ID.make("test"),
-        effect: Effect.succeed({
-          "catalog.transform": (evt) =>
-            Effect.sync(() => {
-              const item = evt.provider.get(providerID)
-              if (!item) return
-              seen.push(item.provider.api.type)
-              if (item?.provider.api.type === "aisdk") seen.push(item.provider.api.url)
-              seen.push(item?.provider.request.body.baseURL)
-            }),
-        }),
-      })
-      yield* transform((catalog) =>
-        catalog.provider.update(providerID, (provider) => {
-          provider.api = { type: "aisdk", package: "@ai-sdk/openai-compatible" }
-          provider.request.body.baseURL = "https://provider.example.com"
-        }),
-      )
-
-      expect(seen).toEqual(["aisdk", "https://provider.example.com", undefined])
-    }),
-  )
-
-  it.effect("runs catalog transform when a plugin is added", () =>
-    Effect.gen(function* () {
-      const catalog = yield* Catalog.Service
-      const plugin = yield* PluginV2.Service
-      const providerID = ProviderV2.ID.make("test")
-      const transform = yield* catalog.transform()
-
-      yield* transform((catalog) =>
-        catalog.provider.update(providerID, (provider) => {
-          provider.name = "Before"
-        }),
-      )
-      yield* plugin.add({
-        id: PluginV2.ID.make("test-transform"),
-        effect: Effect.succeed({
-          "catalog.transform": (evt) =>
-            Effect.sync(() =>
-              evt.provider.update(providerID, (provider) => {
-                provider.name = "After"
-              }),
-            ),
-        }),
-      })
-      yield* Effect.yieldNow
-
-      expect((yield* catalog.provider.get(providerID)).name).toBe("After")
-    }),
-  )
-
-  it.effect("ignores plugin additions from another location", () =>
-    Effect.gen(function* () {
-      const events = yield* EventV2.Service
-      const plugin = yield* PluginV2.Service
-      let invoked = 0
-
-      yield* plugin.add({
-        id: PluginV2.ID.make("test-transform"),
-        effect: Effect.succeed({
-          "catalog.transform": () => Effect.sync(() => invoked++),
-        }),
-      })
-      yield* Effect.yieldNow
-      expect(invoked).toBe(1)
-
-      yield* events.publish(
-        PluginV2.Event.Added,
-        { id: PluginV2.ID.make("test-transform") },
-        {
-          location: new Location.Info({
-            directory: AbsolutePath.make("other"),
-            project: { id: Project.ID.global, directory: AbsolutePath.make("other") },
-          }),
-        },
-      )
-      yield* Effect.yieldNow
-
-      expect(invoked).toBe(1)
-    }),
-  )
-
   it.effect("resolves provider and model request merges", () =>
     Effect.gen(function* () {
       const catalog = yield* Catalog.Service
       const providerID = ProviderV2.ID.make("test")
       const modelID = ModelV2.ID.make("model")
-      const transform = yield* catalog.transform()
+      yield* catalog.transform((catalog) => {
-
-      yield* transform((catalog) => {
         catalog.provider.update(providerID, (provider) => {
           provider.request.headers.provider = "provider"
           provider.request.headers.shared = "provider"
@@ -321,7 +219,7 @@ describe("CatalogV2", () => {
         })
       })
 
-      const model = yield* catalog.model.get(providerID, modelID)
+      const model = required(yield* catalog.model.get(providerID, modelID))
       expect(model.request.headers).toEqual({ provider: "provider", shared: "model", model: "model" })
       expect(model.request.body).toEqual({ provider: true, model: true, request: true })
       expect(model.request.options).toEqual({ shared: "model", model: true })
@@ -332,19 +230,17 @@ describe("CatalogV2", () => {
     Effect.gen(function* () {
       const catalog = yield* Catalog.Service
       const providerID = ProviderV2.ID.make("test")
-      const transform = yield* catalog.transform()
+      yield* catalog.transform((catalog) => {
-
-      yield* transform((catalog) => {
         catalog.provider.update(providerID, () => {})
         catalog.model.update(providerID, ModelV2.ID.make("old"), (model) => {
-          model.time.released = DateTime.makeUnsafe(1000)
+          model.time.released = 1000
         })
         catalog.model.update(providerID, ModelV2.ID.make("new"), (model) => {
-          model.time.released = DateTime.makeUnsafe(2000)
+          model.time.released = 2000
         })
       })
 
-      expect(Option.getOrUndefined(yield* catalog.model.default())?.id).toMatch("new")
+      expect((yield* catalog.model.default())?.id).toMatch("new")
     }),
   )
 
@@ -354,26 +250,26 @@ describe("CatalogV2", () => {
       const providerID = ProviderV2.ID.make("test")
       const old = ModelV2.ID.make("old")
       const newest = ModelV2.ID.make("new")
-      const transform = yield* catalog.transform()
+      const models = (catalog: Catalog.Draft) => {
-
-      const models = (catalog: Catalog.Editor) => {
         catalog.provider.update(providerID, () => {})
         catalog.model.update(providerID, old, (model) => {
-          model.time.released = DateTime.makeUnsafe(1000)
+          model.time.released = 1000
         })
         catalog.model.update(providerID, newest, (model) => {
-          model.time.released = DateTime.makeUnsafe(2000)
+          model.time.released = 2000
         })
       }
 
-      yield* transform((catalog) => {
+      let configured = true
+      yield* catalog.transform((catalog) => {
         models(catalog)
-        catalog.model.default.set(providerID, old)
+        if (configured) catalog.model.default.set(providerID, old)
       })
-      expect(Option.getOrUndefined(yield* catalog.model.default())?.id).toBe(old)
+      expect((yield* catalog.model.default())?.id).toBe(old)
 
-      yield* transform(models)
+      configured = false
-      expect(Option.getOrUndefined(yield* catalog.model.default())?.id).toBe(newest)
+      yield* catalog.rebuild()
+      expect((yield* catalog.model.default())?.id).toBe(newest)
     }),
   )
 
@@ -384,9 +280,7 @@ describe("CatalogV2", () => {
       const enabledProvider = ProviderV2.ID.make("enabled")
       const disabledModel = ModelV2.ID.make("configured")
       const fallbackModel = ModelV2.ID.make("fallback")
-      const transform = yield* catalog.transform()
+      yield* catalog.transform((catalog) => {
-
-      yield* transform((catalog) => {
         catalog.provider.update(disabledProvider, (provider) => {
           provider.disabled = true
         })
@@ -396,7 +290,7 @@ describe("CatalogV2", () => {
         catalog.model.default.set(disabledProvider, disabledModel)
       })
 
-      expect(Option.getOrUndefined(yield* catalog.model.default())).toMatchObject({
+      expect(yield* catalog.model.default()).toMatchObject({
         providerID: enabledProvider,
         id: fallbackModel,
       })
@@ -407,25 +301,23 @@ describe("CatalogV2", () => {
     Effect.gen(function* () {
       const catalog = yield* Catalog.Service
       const providerID = ProviderV2.ID.make("test")
-      const transform = yield* catalog.transform()
+      yield* catalog.transform((catalog) => {
-
-      yield* transform((catalog) => {
         catalog.provider.update(providerID, () => {})
         catalog.model.update(providerID, ModelV2.ID.make("cheap-large"), (model) => {
           model.capabilities.input = ["text"]
           model.capabilities.output = ["text"]
           model.cost = [{ input: 1, output: 1, cache: { read: 0, write: 0 } }]
-          model.time.released = DateTime.makeUnsafe(Date.now())
+          model.time.released = Date.now()
         })
         catalog.model.update(providerID, ModelV2.ID.make("expensive-mini"), (model) => {
           model.capabilities.input = ["text"]
           model.capabilities.output = ["text"]
           model.cost = [{ input: 10, output: 10, cache: { read: 0, write: 0 } }]
-          model.time.released = DateTime.makeUnsafe(Date.now())
+          model.time.released = Date.now()
         })
       })
 
-      expect(Option.getOrUndefined(yield* catalog.model.small(providerID))?.id).toMatch("expensive-mini")
+      expect((yield* catalog.model.small(providerID))?.id).toMatch("expensive-mini")
     }),
   )
 
@@ -434,17 +326,15 @@ describe("CatalogV2", () => {
       const catalog = yield* Catalog.Service
       const policy = yield* Policy.Service
       const providerID = ProviderV2.ID.make("blocked")
-      const transform = yield* catalog.transform()
-
       yield* policy.load([new Policy.Info({ effect: "deny", action: "provider.use", resource: "blocked" })])
-      yield* transform((catalog) => {
+      yield* catalog.transform((catalog) => {
         catalog.provider.update(providerID, () => {})
         catalog.model.update(providerID, ModelV2.ID.make("model"), () => {})
       })
 
       expect(yield* catalog.provider.all()).toEqual([])
       expect(yield* catalog.model.all()).toEqual([])
-      expect(yield* catalog.provider.get(providerID).pipe(Effect.option)).toEqual(Option.none())
+      expect(yield* catalog.provider.get(providerID)).toBeUndefined()
     }),
   )
 })

packages/core/test/command.test.ts

@@ -11,8 +11,7 @@ describe("CommandV2", () => {
   it.effect("applies command transforms and preserves later overrides", () =>
     Effect.gen(function* () {
       const command = yield* CommandV2.Service
-      const transform = yield* command.transform()
+      yield* command.transform((editor) => {
-      yield* transform((editor) => {
         editor.update("review", (command) => {
           command.template = "First"
           command.description = "Review code"

packages/core/test/config/agent.test.ts

@@ -10,6 +10,7 @@ import { PermissionV2 } from "@opencode-ai/core/permission"
 import { AbsolutePath } from "@opencode-ai/core/schema"
 import { tmpdir } from "../fixture/tmpdir"
 import { testEffect } from "../lib/effect"
+import { agentHost, host } from "../plugin/host"
 
 const it = testEffect(Layer.mergeAll(AgentV2.locationLayer, FSUtil.defaultLayer))
 const decode = Schema.decodeUnknownSync(Config.Info)
@@ -19,9 +20,7 @@ describe("ConfigAgentPlugin.Plugin", () => {
     Effect.gen(function* () {
       const agents = yield* AgentV2.Service
       const build = AgentV2.ID.make("build")
-      const defaults = yield* agents.transform()
+      yield* agents.transform((editor) =>
-
-      yield* defaults((editor) =>
         editor.update(build, (agent) => {
           agent.mode = "primary"
           agent.permissions.push({ action: "bash", resource: "*", effect: "allow" })
@@ -68,9 +67,8 @@ describe("ConfigAgentPlugin.Plugin", () => {
           ]),
       })
 
-      yield* ConfigAgentPlugin.Plugin.effect.pipe(
+      yield* ConfigAgentPlugin.Plugin.effect(host({ agent: agentHost(agents) })).pipe(
         Effect.provideService(Config.Service, config),
-        Effect.provideService(AgentV2.Service, agents),
       )
 
       const buildAgent = yield* agents.get(build)
@@ -150,9 +148,8 @@ describe("ConfigAgentPlugin.Plugin", () => {
           ]),
       })
 
-      yield* ConfigAgentPlugin.Plugin.effect.pipe(
+      yield* ConfigAgentPlugin.Plugin.effect(host({ agent: agentHost(agents) })).pipe(
         Effect.provideService(Config.Service, config),
-        Effect.provideService(AgentV2.Service, agents),
       )
 
       const reviewer = yield* agents.get(AgentV2.ID.make("reviewer"))
@@ -177,8 +174,7 @@ describe("ConfigAgentPlugin.Plugin", () => {
     Effect.gen(function* () {
       const agents = yield* AgentV2.Service
       const build = AgentV2.ID.make("build")
-      const defaults = yield* agents.transform()
+      yield* agents.transform((editor) => editor.update(build, () => {}))
-      yield* defaults((editor) => editor.update(build, () => {}))
 
       const config = Config.Service.of({
         entries: () =>
@@ -190,9 +186,8 @@ describe("ConfigAgentPlugin.Plugin", () => {
           ]),
       })
 
-      yield* ConfigAgentPlugin.Plugin.effect.pipe(
+      yield* ConfigAgentPlugin.Plugin.effect(host({ agent: agentHost(agents) })).pipe(
         Effect.provideService(Config.Service, config),
-        Effect.provideService(AgentV2.Service, agents),
       )
 
       expect(yield* agents.get(build)).toBeUndefined()
@@ -251,9 +246,8 @@ Use native v2 fields.`,
               ]),
           })
 
-          yield* ConfigAgentPlugin.Plugin.effect.pipe(
+          yield* ConfigAgentPlugin.Plugin.effect(host({ agent: agentHost(agents) })).pipe(
             Effect.provideService(Config.Service, config),
-            Effect.provideService(AgentV2.Service, agents),
           )
 
           expect(yield* agents.get(AgentV2.ID.make("reviewer"))).toMatchObject({

packages/core/test/config/command.test.ts

@@ -11,6 +11,7 @@ import { ProviderV2 } from "@opencode-ai/core/provider"
 import { AbsolutePath } from "@opencode-ai/core/schema"
 import { tmpdir } from "../fixture/tmpdir"
 import { testEffect } from "../lib/effect"
+import { host } from "../plugin/host"
 
 const it = testEffect(Layer.mergeAll(CommandV2.locationLayer, FSUtil.defaultLayer))
 const decode = Schema.decodeUnknownSync(Config.Info)
@@ -41,8 +42,7 @@ Review files`,
           })
 
           const command = yield* CommandV2.Service
-          yield* ConfigCommandPlugin.Plugin.effect.pipe(
+          yield* ConfigCommandPlugin.Plugin.effect(host({ command })).pipe(
-            Effect.provideService(CommandV2.Service, command),
             Effect.provideService(
               Config.Service,
               Config.Service.of({

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

@@ -7,7 +7,8 @@ import { Integration } from "@opencode-ai/core/integration"
 import { ModelV2 } from "@opencode-ai/core/model"
 import { PluginV2 } from "@opencode-ai/core/plugin"
 import { ProviderV2 } from "@opencode-ai/core/provider"
-import { it, withEnv } from "../plugin/provider-helper"
+import { it, required, withEnv } from "../plugin/provider-helper"
+import { catalogHost, host, integrationHost } from "../plugin/host"
 
 function request(headers: Record<string, string>, variant?: string) {
   return {
@@ -58,14 +59,12 @@ describe("ConfigProviderPlugin.Plugin", () => {
 
       yield* plugin.add({
         ...ConfigProviderPlugin.Plugin,
-        effect: ConfigProviderPlugin.Plugin.effect.pipe(
+        effect: ConfigProviderPlugin.Plugin.effect(
-          Effect.provideService(Config.Service, config),
+          host({ catalog: catalogHost(catalog), integration: integrationHost(integrations) }),
-          Effect.provideService(Catalog.Service, catalog),
+        ).pipe(Effect.provideService(Config.Service, config)),
-          Effect.provideService(Integration.Service, integrations),
-        ),
       })
 
-      const model = yield* catalog.model.get(providerID, modelID)
+      const model = required(yield* catalog.model.get(providerID, modelID))
       expect(model.variants).toMatchObject([
         {
           id: "high",
@@ -119,14 +118,12 @@ describe("ConfigProviderPlugin.Plugin", () => {
 
       yield* plugin.add({
         ...ConfigProviderPlugin.Plugin,
-        effect: ConfigProviderPlugin.Plugin.effect.pipe(
+        effect: ConfigProviderPlugin.Plugin.effect(
-          Effect.provideService(Config.Service, config),
+          host({ catalog: catalogHost(catalog), integration: integrationHost(integrations) }),
-          Effect.provideService(Catalog.Service, catalog),
+        ).pipe(Effect.provideService(Config.Service, config)),
-          Effect.provideService(Integration.Service, integrations),
-        ),
       })
 
-      const model = yield* catalog.model.get(providerID, modelID)
+      const model = required(yield* catalog.model.get(providerID, modelID))
       expect(model.variants[0]).toMatchObject({
         id: "high",
         body: {},
@@ -222,16 +219,14 @@ describe("ConfigProviderPlugin.Plugin", () => {
 
         yield* plugin.add({
           ...ConfigProviderPlugin.Plugin,
-          effect: ConfigProviderPlugin.Plugin.effect.pipe(
+          effect: ConfigProviderPlugin.Plugin.effect(
-            Effect.provideService(Config.Service, config),
+            host({ catalog: catalogHost(catalog), integration: integrationHost(integrations) }),
-            Effect.provideService(Catalog.Service, catalog),
+          ).pipe(Effect.provideService(Config.Service, config)),
-            Effect.provideService(Integration.Service, integrations),
-          ),
         })
 
-        const provider = yield* catalog.provider.get(providerID)
+        const provider = required(yield* catalog.provider.get(providerID))
-        const model = yield* catalog.model.get(providerID, modelID)
+        const model = required(yield* catalog.model.get(providerID, modelID))
-        expect(Option.getOrUndefined(yield* catalog.model.default())?.id).toBe(ModelV2.ID.make("default"))
+        expect((yield* catalog.model.default())?.id).toBe(ModelV2.ID.make("default"))
         expect(provider.name).toBe("Renamed")
         expect((yield* integrations.get(Integration.ID.make("custom")))?.methods).toContainEqual({
           type: "env",

packages/core/test/config/skill.test.ts

@@ -9,6 +9,7 @@ import { AbsolutePath } from "@opencode-ai/core/schema"
 import { SkillV2 } from "@opencode-ai/core/skill"
 import { location } from "../fixture/location"
 import { testEffect } from "../lib/effect"
+import { host } from "../plugin/host"
 
 const it = testEffect(Layer.empty)
 const decode = Schema.decodeUnknownSync(Config.Info)
@@ -18,16 +19,33 @@ describe("ConfigSkillPlugin.Plugin", () => {
     Effect.gen(function* () {
       const directory = AbsolutePath.make("/repo/packages/app")
       const sources: SkillV2.Source[] = []
-      const transform = Effect.fnUntraced(function* () {
+      const transform = Effect.fnUntraced(function* (update: (draft: SkillV2.Draft) => void | Effect.Effect<void>) {
-        return Effect.fnUntraced(function* (update: (editor: SkillV2.Editor) => void) {
+        const result = update({
-          update({
+          source: (source) => {
-            source: (source) => sources.push(source),
+            sources.push(source)
+          },
           list: () => sources,
         })
+        if (Effect.isEffect(result)) yield* result
+        const dispose = Effect.sync(() => {
+          sources.length = 0
         })
+        yield* Effect.addFinalizer(() => dispose)
+        return { dispose }
       })
 
-      yield* ConfigSkillPlugin.Plugin.effect.pipe(
+      yield* ConfigSkillPlugin.Plugin.effect(
+        host({
+          location: location({ directory }),
+          path: { ...host().path, home: "/home/test" },
+          skill: SkillV2.Service.of({
+            transform,
+            rebuild: () => Effect.void,
+            sources: () => Effect.succeed(sources),
+            list: () => Effect.succeed([]),
+          }),
+        }),
+      ).pipe(
         Effect.provideService(
           Config.Service,
           Config.Service.of({
@@ -43,16 +61,6 @@ describe("ConfigSkillPlugin.Plugin", () => {
               ]),
           }),
         ),
-        Effect.provideService(Global.Service, Global.Service.of(Global.make({ home: "/home/test" }))),
-        Effect.provideService(Location.Service, Location.Service.of(location({ directory }))),
-        Effect.provideService(
-          SkillV2.Service,
-          SkillV2.Service.of({
-            transform,
-            sources: () => Effect.succeed(sources),
-            list: () => Effect.succeed([]),
-          }),
-        ),
       )
 
       expect(sources).toEqual([

packages/core/test/event.test.ts

@@ -30,7 +30,7 @@ const Message = EventV2.define({
 
 const SyncMessage = EventV2.define({
   type: "test.sync",
-  sync: {
+  durable: {
     version: 1,
     aggregate: "id",
   },
@@ -42,7 +42,7 @@ const SyncMessage = EventV2.define({
 
 const SyncSent = EventV2.define({
   type: "test.sent",
-  sync: {
+  durable: {
     version: 1,
     aggregate: "messageID",
   },
@@ -61,7 +61,7 @@ const GlobalMessage = EventV2.define({
 
 const VersionedMessage = EventV2.define({
   type: "test.versioned",
-  sync: {
+  durable: {
     version: 2,
     aggregate: "id",
   },
@@ -73,7 +73,7 @@ const VersionedMessage = EventV2.define({
 
 const SyncTimestamp = EventV2.define({
   type: "test.timestamp",
-  sync: {
+  durable: {
     version: 1,
     aggregate: "id",
   },
@@ -132,7 +132,7 @@ describe("EventV2", () => {
       const event = yield* events.publish(VersionedMessage, { id: "one", text: "hello" })
 
       expect(event.type).toBe("test.versioned")
-      expect(event.version).toBe(2)
+      expect(event.durable?.version).toBe(2)
     }),
   )
 
@@ -146,12 +146,12 @@ describe("EventV2", () => {
     Effect.sync(() => {
       const latest = EventV2.define({
         type: "test.out-of-order",
-        sync: { version: 2, aggregate: "id" },
+        durable: { version: 2, aggregate: "id" },
         schema: { id: Schema.String },
       })
       EventV2.define({
         type: "test.out-of-order",
-        sync: { version: 1, aggregate: "id" },
+        durable: { version: 1, aggregate: "id" },
         schema: { id: Schema.String },
       })
 
@@ -190,7 +190,7 @@ describe("EventV2", () => {
     }),
   )
 
-  it.effect("commits local operational state inside a new synchronized event transaction", () =>
+  it.effect("commits local operational state inside a new durable event transaction", () =>
     Effect.gen(function* () {
       const events = yield* EventV2.Service
       const received = new Array<string>()
@@ -207,7 +207,7 @@ describe("EventV2", () => {
     }),
   )
 
-  it.effect("rolls back the synchronized event and projector when the local commit fails", () =>
+  it.effect("rolls back the durable event and projector when the local commit fails", () =>
     Effect.gen(function* () {
       const events = yield* EventV2.Service
       const { db } = yield* Database.Service
@@ -236,7 +236,7 @@ describe("EventV2", () => {
       const events = yield* EventV2.Service
       const exit = yield* events.publish(Message, { text: "hello" }, { commit: () => Effect.void }).pipe(Effect.exit)
 
-      expect(String(exit)).toContain("Local commit hooks require a synchronized event")
+      expect(String(exit)).toContain("Local commit hooks require a durable event")
     }),
   )
 
@@ -290,7 +290,6 @@ describe("EventV2", () => {
     Effect.gen(function* () {
       const events = yield* EventV2.Service
       const received = new Array<string>()
-      yield* events.sync(() => Effect.die("sync defect"))
       yield* events.listen(() => {
         throw new Error("listener defect")
       })
@@ -303,7 +302,7 @@ describe("EventV2", () => {
       const event = yield* events.publish(SyncMessage, { id: "one", text: "hello" })
 
       expect(received).toEqual([SyncMessage.type])
-      expect(event.seq).toBeNumber()
+      expect(event.durable?.seq).toBeNumber()
     }),
   )
 
@@ -336,49 +335,7 @@ describe("EventV2", () => {
     }),
   )
 
-  it.effect("does not synchronize live-only events", () =>
+  it.effect("inserts durable event rows on publish", () =>
-    Effect.gen(function* () {
-      const events = yield* EventV2.Service
-      const synchronized = new Array<string>()
-      const unsubscribe = yield* events.sync((event) =>
-        Effect.sync(() => {
-          synchronized.push(event.type)
-        }),
-      )
-      yield* Effect.addFinalizer(() => unsubscribe)
-
-      yield* events.publish(Message, { text: "live only" })
-      yield* events.publish(SyncMessage, { id: "one", text: "durable" })
-
-      expect(synchronized).toEqual([SyncMessage.type])
-    }),
-  )
-
-  it.effect("synchronizes only after the durable event commits", () =>
-    Effect.gen(function* () {
-      const events = yield* EventV2.Service
-      const { db } = yield* Database.Service
-      const synchronized = new Array<boolean>()
-      yield* events.sync((event) =>
-        db
-          .select({ id: EventTable.id })
-          .from(EventTable)
-          .where(eq(EventTable.id, event.id))
-          .get()
-          .pipe(
-            Effect.orDie,
-            Effect.map((row) => synchronized.push(row !== undefined)),
-            Effect.asVoid,
-          ),
-      )
-
-      yield* events.publish(SyncMessage, { id: EventV2.ID.create(), text: "durable" })
-
-      expect(synchronized).toEqual([true])
-    }),
-  )
-
-  it.effect("inserts sync event rows on publish", () =>
     Effect.gen(function* () {
       const events = yield* EventV2.Service
       const { db } = yield* Database.Service
@@ -398,7 +355,7 @@ describe("EventV2", () => {
     }),
   )
 
-  it.effect("increments sync event seq per aggregate", () =>
+  it.effect("increments durable event seq per aggregate", () =>
     Effect.gen(function* () {
       const events = yield* EventV2.Service
       const { db } = yield* Database.Service
@@ -417,22 +374,22 @@ describe("EventV2", () => {
     }),
   )
 
-  it.effect("replays durable aggregate events after a cursor and tails new events", () =>
+  it.effect("replays durable aggregate events after a sequence and tails new events", () =>
     Effect.gen(function* () {
       const events = yield* EventV2.Service
       const aggregateID = EventV2.ID.create()
       yield* events.publish(SyncMessage, { id: aggregateID, text: "zero" })
       yield* events.publish(SyncMessage, { id: aggregateID, text: "one" })
       const fiber = yield* events
-        .aggregateEvents({ aggregateID, after: EventV2.Cursor.make(0) })
+        .durable({ aggregateID, after: 0 })
         .pipe(Stream.take(2), Stream.runCollect, Effect.forkScoped)
       yield* Effect.yieldNow
 
       yield* events.publish(SyncMessage, { id: aggregateID, text: "two" })
 
-      expect(Array.from(yield* Fiber.join(fiber)).map((event) => [event.cursor, event.event.data])).toEqual([
+      expect(Array.from(yield* Fiber.join(fiber)).map((event) => [event.durable?.seq, event.data])).toEqual([
-        [EventV2.Cursor.make(1), { id: aggregateID, text: "one" }],
+        [1, { id: aggregateID, text: "one" }],
-        [EventV2.Cursor.make(2), { id: aggregateID, text: "two" }],
+        [2, { id: aggregateID, text: "two" }],
       ])
     }),
   )
@@ -442,20 +399,18 @@ describe("EventV2", () => {
       const events = yield* EventV2.Service
       const aggregateID = EventV2.ID.create()
       yield* events.publish(SyncMessage, { id: aggregateID, text: "zero" })
-      const fiber = yield* events
+      const fiber = yield* events.durable({ aggregateID }).pipe(Stream.take(2), Stream.runCollect, Effect.forkScoped)
-        .aggregateEvents({ aggregateID })
-        .pipe(Stream.take(2), Stream.runCollect, Effect.forkScoped)
 
       yield* events.publish(SyncMessage, { id: aggregateID, text: "one" })
 
       expect(
         Array.from(yield* Fiber.join(fiber)).map((event) => [
-          event.cursor,
+          event.durable?.seq,
-          (event.event.data as { text: string }).text,
+          (event.data as { text: string }).text,
         ]),
       ).toEqual([
-        [EventV2.Cursor.make(0), "zero"],
+        [0, "zero"],
-        [EventV2.Cursor.make(1), "one"],
+        [1, "one"],
       ])
     }),
   )
@@ -476,17 +431,15 @@ describe("EventV2", () => {
       yield* Effect.gen(function* () {
         const events = yield* EventV2.Service
         const aggregateID = EventV2.ID.create()
-        const fiber = yield* events
+        const fiber = yield* events.durable({ aggregateID }).pipe(Stream.take(1), Stream.runCollect, Effect.forkScoped)
-          .aggregateEvents({ aggregateID })
-          .pipe(Stream.take(1), Stream.runCollect, Effect.forkScoped)
         yield* Deferred.await(readStarted)
 
         pause = false
         yield* events.publish(SyncMessage, { id: aggregateID, text: "during handoff" })
         yield* Deferred.succeed(continueRead, undefined)
 
-        expect(Array.from(yield* Fiber.join(fiber)).map((event) => [event.cursor, event.event.data])).toEqual([
+        expect(Array.from(yield* Fiber.join(fiber)).map((event) => [event.durable?.seq, event.data])).toEqual([
-          [EventV2.Cursor.make(0), { id: aggregateID, text: "during handoff" }],
+          [0, { id: aggregateID, text: "during handoff" }],
         ])
       }).pipe(Effect.provide(Layer.mergeAll(database, eventLayer)))
     }),
@@ -498,7 +451,7 @@ describe("EventV2", () => {
       const aggregateID = EventV2.ID.create()
       const count = 64
       const fiber = yield* events
-        .aggregateEvents({ aggregateID })
+        .durable({ aggregateID })
         .pipe(Stream.take(count), Stream.runCollect, Effect.forkScoped)
       yield* Effect.yieldNow
 
@@ -506,11 +459,8 @@ describe("EventV2", () => {
         yield* events.publish(SyncMessage, { id: aggregateID, text: String(index) })
       }
 
-      expect(Array.from(yield* Fiber.join(fiber)).map((event) => [event.cursor, event.event.data])).toEqual(
+      expect(Array.from(yield* Fiber.join(fiber)).map((event) => [event.durable?.seq, event.data])).toEqual(
-        Array.from({ length: count }, (_, index) => [
+        Array.from({ length: count }, (_, index) => [index, { id: aggregateID, text: String(index) }]),
-          EventV2.Cursor.make(index),
-          { id: aggregateID, text: String(index) },
-        ]),
       )
     }),
   )
@@ -519,15 +469,13 @@ describe("EventV2", () => {
     Effect.gen(function* () {
       const events = yield* EventV2.Service
       const aggregateID = EventV2.ID.create()
-      const fiber = yield* events
+      const fiber = yield* events.durable({ aggregateID }).pipe(Stream.take(1), Stream.runCollect, Effect.forkScoped)
-        .aggregateEvents({ aggregateID })
-        .pipe(Stream.take(1), Stream.runCollect, Effect.forkScoped)
       yield* Effect.yieldNow
 
       yield* events.publish(Message, { text: "live only" })
       yield* events.publish(SyncMessage, { id: aggregateID, text: "durable" })
 
-      expect(Array.from(yield* Fiber.join(fiber)).map((event) => event.event.type)).toEqual([SyncMessage.type])
+      expect(Array.from(yield* Fiber.join(fiber)).map((event) => event.type)).toEqual([SyncMessage.type])
     }),
   )
 
@@ -550,7 +498,7 @@ describe("EventV2", () => {
     }),
   )
 
-  it.effect("replays sync events through projectors", () =>
+  it.effect("replays durable events through projectors", () =>
     Effect.gen(function* () {
       const events = yield* EventV2.Service
       const received = new Array<EventV2.Payload>()
@@ -706,7 +654,7 @@ describe("EventV2", () => {
         })
         .pipe(Effect.exit)
 
-      expect(String(exit)).toContain("Unknown sync event type")
+      expect(String(exit)).toContain("Unknown durable event type")
     }),
   )
 
@@ -843,7 +791,7 @@ describe("EventV2", () => {
       const replayed = {
         id: published.id,
         type: EventV2.versionedType(SyncMessage.type, 1),
-        seq: published.seq!,
+        seq: published.durable!.seq,
         aggregateID,
         data: published.data,
       }
@@ -988,7 +936,7 @@ describe("EventV2", () => {
       yield* events.replay(replayed, { publish: true })
       yield* events.replay(replayed, { publish: true })
 
-      expect(received).toMatchObject([{ id: replayed.id, seq: 0, data: replayed.data }])
+      expect(received).toMatchObject([{ id: replayed.id, durable: { seq: 0, version: 1 }, data: replayed.data }])
     }),
   )
 
@@ -1110,7 +1058,7 @@ describe("EventV2", () => {
     }),
   )
 
-  it.effect("remove clears sync event sequence", () =>
+  it.effect("remove clears durable event sequence", () =>
     Effect.gen(function* () {
       const events = yield* EventV2.Service
       const received = new Array<EventV2.Payload>()

packages/core/test/integration.test.ts

@@ -51,7 +51,7 @@ describe("Integration", () => {
       const openai = Integration.ID.make("openai")
 
       yield* integrations
-        .update((editor) => editor.update(openai, (integration) => (integration.name = "OpenAI")))
+        .transform((editor) => editor.update(openai, (integration) => (integration.name = "OpenAI")))
         .pipe(Scope.provide(scope))
       expect(yield* integrations.get(openai)).toEqual(
         new Integration.Info({ id: openai, name: "OpenAI", methods: [], connections: [] }),
@@ -70,10 +70,10 @@ describe("Integration", () => {
       const second = yield* Scope.fork(yield* Scope.Scope)
 
       yield* integrations
-        .update((editor) => editor.update(id, (integration) => (integration.name = "OpenAI")))
+        .transform((editor) => editor.update(id, (integration) => (integration.name = "OpenAI")))
         .pipe(Scope.provide(first))
       yield* integrations
-        .update((editor) => editor.update(id, (integration) => (integration.name = "OpenAI Override")))
+        .transform((editor) => editor.update(id, (integration) => (integration.name = "OpenAI Override")))
         .pipe(Scope.provide(second))
       expect((yield* integrations.get(id))?.name).toBe("OpenAI Override")
 
@@ -99,7 +99,7 @@ describe("Integration", () => {
         })
 
       yield* integrations
-        .update((editor) =>
+        .transform((editor) =>
           editor.method.update({
             integrationID,
             method: { id: methodID, type: "oauth", label: "ChatGPT" },
@@ -108,7 +108,7 @@ describe("Integration", () => {
         )
         .pipe(Scope.provide(first))
       yield* integrations
-        .update((editor) => {
+        .transform((editor) => {
           expect(editor.get(integrationID)).toEqual({ id: integrationID, name: "openai" })
           expect(editor.list()).toEqual([{ id: integrationID, name: "openai" }])
           expect(editor.method.list(integrationID)).toEqual([
@@ -141,7 +141,7 @@ describe("Integration", () => {
       const integrations = yield* Integration.Service
       const events = yield* EventV2.Service
       const integrationID = Integration.ID.make("openai")
-      yield* integrations.update((editor) =>
+      yield* integrations.transform((editor) =>
         editor.method.update({
           integrationID,
           method: { type: "key", label: "API key" },
@@ -179,7 +179,7 @@ describe("Integration", () => {
       const integrations = yield* Integration.Service
       const integrationID = Integration.ID.make("openai")
       const methodID = Integration.MethodID.make("chatgpt")
-      yield* integrations.update((editor) =>
+      yield* integrations.transform((editor) =>
         editor.method.update({
           integrationID,
           method: { id: methodID, type: "oauth", label: "ChatGPT" },
@@ -238,7 +238,7 @@ describe("Integration", () => {
       const integrationID = Integration.ID.make("openai")
       const methodID = Integration.MethodID.make("chatgpt")
       let closed = false
-      yield* integrations.update((editor) =>
+      yield* integrations.transform((editor) =>
         editor.method.update({
           integrationID,
           method: { id: methodID, type: "oauth", label: "ChatGPT" },
@@ -275,7 +275,7 @@ describe("Integration", () => {
       const integrations = yield* Integration.Service
       const integrationID = Integration.ID.make("openai")
       const methodID = Integration.MethodID.make("browser")
-      yield* integrations.update((editor) =>
+      yield* integrations.transform((editor) =>
         editor.method.update({
           integrationID,
           method: { id: methodID, type: "oauth", label: "Browser" },
@@ -312,7 +312,7 @@ describe("Integration", () => {
       const integrationID = Integration.ID.make("openai")
       const methodID = Integration.MethodID.make("browser")
       let closed = false
-      yield* integrations.update((editor) =>
+      yield* integrations.transform((editor) =>
         editor.method.update({
           integrationID,
           method: { id: methodID, type: "oauth", label: "Browser" },
@@ -375,7 +375,7 @@ describe("Integration", () => {
       () =>
         Effect.gen(function* () {
           const integrations = yield* Integration.Service
-          yield* integrations.update((editor) =>
+          yield* integrations.transform((editor) =>
             editor.method.update({
               integrationID,
               method: {

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

@@ -1,7 +1,7 @@
 import fs from "fs/promises"
 import path from "path"
 import { describe, expect } from "bun:test"
-import { Effect, Exit, Layer } from "effect"
+import { Cause, Effect, Exit, Layer } from "effect"
 import { FileSystem } from "@opencode-ai/core/filesystem"
 import { FSUtil } from "@opencode-ai/core/fs-util"
 import { Location } from "@opencode-ai/core/location"
@@ -31,6 +31,13 @@ const withTmp = <A, E, R>(f: (directory: string) => Effect.Effect<A, E, R>) =>
   ).pipe(Effect.flatMap((tmp) => f(tmp.path)))
 
 describe("FileSystem", () => {
+  const expectFail = (exit: Exit.Exit<unknown, unknown>) => {
+    expect(Exit.isFailure(exit)).toBe(true)
+    if (Exit.isSuccess(exit)) return
+    expect(Cause.hasFails(exit.cause)).toBe(true)
+    expect(Cause.hasDies(exit.cause)).toBe(false)
+  }
+
   it.live("reads text and binary files", () =>
     withTmp((directory) =>
       Effect.gen(function* () {
@@ -60,13 +67,39 @@ describe("FileSystem", () => {
     ),
   )
 
-  it.live("rejects lexical escapes", () =>
+  it.live("fails for missing paths", () =>
     withTmp((directory) =>
       Effect.gen(function* () {
-        const result = yield* (yield* FileSystem.Service)
+        const exit = yield* (yield* FileSystem.Service)
-          .read({ path: RelativePath.make("../outside.txt") })
+          .read({ path: RelativePath.make("missing.txt") })
           .pipe(Effect.exit)
-        expect(Exit.isFailure(result)).toBe(true)
+        expectFail(exit)
+      }).pipe(provide(directory)),
+    ),
+  )
+
+  it.live("fails for wrong path kinds", () =>
+    withTmp((directory) =>
+      Effect.gen(function* () {
+        yield* Effect.promise(() => fs.mkdir(path.join(directory, "src")))
+        yield* Effect.promise(() => fs.writeFile(path.join(directory, "README.md"), "# Test"))
+        const service = yield* FileSystem.Service
+        expectFail(yield* service.read({ path: RelativePath.make("src") }).pipe(Effect.exit))
+        expectFail(yield* service.list({ path: RelativePath.make("README.md") }).pipe(Effect.exit))
+      }).pipe(provide(directory)),
+    ),
+  )
+
+  it.live("fails for lexical and symlink escapes", () =>
+    withTmp((directory) =>
+      Effect.gen(function* () {
+        const outside = path.join(directory, "..", "outside.txt")
+        yield* Effect.promise(() => fs.writeFile(outside, "outside"))
+        yield* Effect.promise(() => fs.symlink(outside, path.join(directory, "linked.txt")))
+        const service = yield* FileSystem.Service
+        expectFail(yield* service.read({ path: RelativePath.make("../outside.txt") }).pipe(Effect.exit))
+        expectFail(yield* service.read({ path: RelativePath.make("linked.txt") }).pipe(Effect.exit))
+        yield* Effect.promise(() => fs.rm(outside))
       }).pipe(provide(directory)),
     ),
   )

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

@@ -1,8 +1,10 @@
 import fs from "fs/promises"
 import path from "path"
 import { describe, expect } from "bun:test"
-import { Effect, Equal, Hash, Layer, Schema } from "effect"
+import { Deferred, Effect, Equal, Hash, Layer, Schema, Stream } from "effect"
 import { Tool } from "@opencode-ai/core/public"
+import { define } from "@opencode-ai/plugin/v2/effect"
+import { AgentV2 } from "@opencode-ai/core/agent"
 import { Catalog } from "@opencode-ai/core/catalog"
 import { LocationServiceMap } from "@opencode-ai/core/location-layer"
 import { Location } from "@opencode-ai/core/location"
@@ -86,8 +88,7 @@ describe("LocationServiceMap", () => {
               yield* PluginBoot.Service.use((boot) => boot.wait())
               yield* Reference.Service
               const catalog = yield* Catalog.Service
-              const transform = yield* catalog.transform()
+              yield* catalog.transform((editor) => editor.provider.update(ProviderV2.ID.make("test"), () => {}))
-              yield* transform((editor) => editor.provider.update(ProviderV2.ID.make("test"), () => {}))
               return {
                 providers: yield* catalog.provider.all(),
                 tools: yield* toolDefinitions(yield* ToolRegistry.Service),
@@ -135,4 +136,53 @@ describe("LocationServiceMap", () => {
       ),
     ),
   )
+
+  it.live("installs public plugins into a location", () =>
+    Effect.acquireRelease(
+      Effect.promise(() => tmpdir()),
+      (dir) => Effect.promise(() => dir[Symbol.asyncDispose]()),
+    ).pipe(
+      Effect.flatMap((dir) =>
+        Effect.gen(function* () {
+          const boot = yield* PluginBoot.Service
+          const catalogUpdated = yield* Deferred.make<void>()
+          const seen: string[] = []
+          yield* boot.add(
+            define({
+              id: "reviewer",
+              effect: (ctx) =>
+                Effect.gen(function* () {
+                  yield* ctx.event.subscribe("catalog.updated").pipe(
+                    Stream.runForEach(() => Deferred.succeed(catalogUpdated, undefined).pipe(Effect.asVoid)),
+                    Effect.forkScoped({ startImmediately: true }),
+                  )
+                  yield* ctx.agent.transform((agent) => {
+                    agent.update("reviewer", (item) => {
+                      item.description = "Reviews code"
+                      item.mode = "subagent"
+                    })
+                  })
+                  seen.push((yield* ctx.agent.get("reviewer"))?.description ?? "")
+                  yield* ctx.catalog.transform((catalog) => {
+                    catalog.provider.update("public", (provider) => {
+                      provider.name = "Public provider"
+                    })
+                  })
+                }),
+            }),
+          )
+
+          yield* Deferred.await(catalogUpdated)
+          expect(seen).toEqual(["Reviews code"])
+          expect(yield* (yield* AgentV2.Service).get(AgentV2.ID.make("reviewer"))).toMatchObject({
+            description: "Reviews code",
+            mode: "subagent",
+          })
+        }).pipe(
+          Effect.scoped,
+          Effect.provide(LocationServiceMap.get(Location.Ref.make({ directory: AbsolutePath.make(dir.path) }))),
+        ),
+      ),
+    ),
+  )
 })

packages/core/test/npm.test.ts

@@ -60,7 +60,7 @@ describe("Npm.add", () => {
       return yield* npm.add(spec)
     }).pipe(Effect.scoped, Effect.provide(npmLayer(path.join(tmp.path, "cache"))), Effect.runPromise)
 
-    expect(Option.isSome(entry.entrypoint)).toBe(true)
+    expect(entry.entrypoint).toBeDefined()
   })
 })
 

packages/core/test/permission.test.ts

@@ -74,8 +74,7 @@ function setup(rules: PermissionV2.Ruleset = []) {
 function setRules(rules: PermissionV2.Ruleset) {
   return Effect.gen(function* () {
     const agents = yield* AgentV2.Service
-    const update = yield* agents.transform()
+    yield* agents.transform((editor) =>
-    yield* update((editor) =>
       editor.update(AgentV2.ID.make("test"), (agent) => {
         agent.permissions = [...rules]
       }),
@@ -130,7 +129,7 @@ describe("PermissionV2", () => {
     Effect.gen(function* () {
       yield* setup([{ action: "read", resource: "*", effect: "allow" }])
       const agents = yield* AgentV2.Service
-      yield* agents.update((editor) =>
+      yield* agents.transform((editor) =>
         editor.update(AgentV2.ID.make("reviewer"), (agent) => {
           agent.permissions.push({ action: "read", resource: "*", effect: "deny" })
         }),
@@ -139,7 +138,7 @@ describe("PermissionV2", () => {
 
       expect(yield* service.ask(assertion())).toMatchObject({ effect: "allow" })
       expect(yield* service.ask(assertion({ agent: AgentV2.ID.make("reviewer") }))).toMatchObject({ effect: "deny" })
-      yield* agents.update((editor) =>
+      yield* agents.transform((editor) =>
         editor.update(AgentV2.ID.make("reviewer"), (agent) => {
           agent.permissions = []
         }),
@@ -187,8 +186,7 @@ describe("PermissionV2", () => {
         .run()
         .pipe(Effect.orDie)
       const agents = yield* AgentV2.Service
-      const update = yield* agents.transform()
+      yield* agents.transform((editor) =>
-      yield* update((editor) =>
         editor.update(AgentV2.ID.make("build"), (agent) => {
           agent.permissions = [{ action: "todowrite", resource: "*", effect: "allow" }]
         }),
@@ -214,7 +212,7 @@ describe("PermissionV2", () => {
         .run()
         .pipe(Effect.orDie)
       const agents = yield* AgentV2.Service
-      yield* agents.update((editor) => {
+      yield* agents.transform((editor) => {
         editor.remove(AgentV2.ID.make("test"))
         editor.remove(AgentV2.ID.make("build"))
       })

packages/core/test/plugin.test.ts

@@ -18,7 +18,7 @@ const plugins = PluginV2.layer.pipe(Layer.provide(events))
 function state() {
   return State.create({
     initial: () => ({ values: [] as string[] }),
-    editor: (draft) => ({
+    draft: (draft) => ({
       add: (value: string) => draft.values.push(value),
     }),
   })
@@ -34,8 +34,9 @@ describe("PluginV2", () => {
       yield* plugin.add({
         id: PluginV2.ID.make("scoped"),
         effect: Effect.gen(function* () {
-          const transform = yield* values.transform()
+          yield* values.transform((editor) => {
-          yield* transform((editor) => editor.add("scoped"))
+            editor.add("scoped")
+          })
         }),
       })
       expect(values.get().values).toEqual(["scoped"])
@@ -58,8 +59,9 @@ describe("PluginV2", () => {
         .add({
           id,
           effect: Effect.gen(function* () {
-            const transform = yield* values.transform()
+            yield* values.transform((editor) => {
-            yield* transform((editor) => editor.add("first"))
+              editor.add("first")
+            })
             yield* Deferred.succeed(firstStarted, undefined)
             yield* Deferred.await(releaseFirst)
           }),
@@ -71,8 +73,9 @@ describe("PluginV2", () => {
         .add({
           id,
           effect: Effect.gen(function* () {
-            const transform = yield* values.transform()
+            yield* values.transform((editor) => {
-            yield* transform((editor) => editor.add("second"))
+              editor.add("second")
+            })
           }),
         })
         .pipe(Effect.forkChild({ startImmediately: true }))

packages/core/test/plugin/command.test.ts

@@ -6,6 +6,7 @@ import { CommandPlugin } from "@opencode-ai/core/plugin/command"
 import { AbsolutePath } from "@opencode-ai/core/schema"
 import { location } from "../fixture/location"
 import { testEffect } from "../lib/effect"
+import { host } from "./host"
 
 const directory = AbsolutePath.make("/repo/packages/app")
 const project = AbsolutePath.make("/repo")
@@ -21,12 +22,11 @@ describe("CommandPlugin.Plugin", () => {
   it.effect("registers built-in init and review commands", () =>
     Effect.gen(function* () {
       const command = yield* CommandV2.Service
-      yield* CommandPlugin.Plugin.effect.pipe(
+      yield* CommandPlugin.Plugin.effect(
-        Effect.provideService(CommandV2.Service, command),
+        host({
-        Effect.provideService(
+          command,
-          Location.Service,
+          location: location({ directory }, { projectDirectory: project }),
-          Location.Service.of(location({ directory }, { projectDirectory: project })),
+        }),
-        ),
       )
 
       expect(yield* command.get("init")).toMatchObject({

packages/core/test/plugin/host.ts

@@ -0,0 +1,319 @@
+import type { AISDKHooks, PluginHost } from "@opencode-ai/plugin/v2/effect"
+import { AgentV2 } from "@opencode-ai/core/agent"
+import { Catalog } from "@opencode-ai/core/catalog"
+import { Integration } from "@opencode-ai/core/integration"
+import { ModelV2 } from "@opencode-ai/core/model"
+import { PluginV2 } from "@opencode-ai/core/plugin"
+import { ProviderV2 } from "@opencode-ai/core/provider"
+import type { IntegrationEnvMethod, IntegrationKeyMethod, IntegrationOAuthMethod } from "@opencode-ai/sdk/v2/types"
+import { Effect, Stream } from "effect"
+
+export function host(overrides: Partial<PluginHost> = {}): PluginHost {
+  return {
+    aisdk: {
+      hook: () => Effect.die("unused aisdk.hook"),
+    },
+    agent: {
+      get: () => Effect.die("unused agent.get"),
+      default: () => Effect.die("unused agent.default"),
+      list: () => Effect.die("unused agent.list"),
+      rebuild: () => Effect.die("unused agent.rebuild"),
+      transform: () => Effect.die("unused agent.transform"),
+    },
+    catalog: {
+      provider: {
+        get: () => Effect.die("unused catalog.provider.get"),
+        list: () => Effect.die("unused catalog.provider.list"),
+        available: () => Effect.die("unused catalog.provider.available"),
+      },
+      model: {
+        get: () => Effect.die("unused catalog.model.get"),
+        list: () => Effect.die("unused catalog.model.list"),
+        available: () => Effect.die("unused catalog.model.available"),
+        default: () => Effect.die("unused catalog.model.default"),
+        small: () => Effect.die("unused catalog.model.small"),
+      },
+      rebuild: () => Effect.die("unused catalog.rebuild"),
+      transform: () => Effect.die("unused catalog.transform"),
+    },
+    command: {
+      get: () => Effect.die("unused command.get"),
+      list: () => Effect.die("unused command.list"),
+      rebuild: () => Effect.die("unused command.rebuild"),
+      transform: () => Effect.die("unused command.transform"),
+    },
+    event: {
+      subscribe: () => Stream.die("unused event.subscribe"),
+    },
+    filesystem: {
+      read: () => Effect.die("unused filesystem.read"),
+      list: () => Effect.die("unused filesystem.list"),
+      find: () => Effect.die("unused filesystem.find"),
+      glob: () => Effect.die("unused filesystem.glob"),
+    },
+    integration: {
+      get: () => Effect.die("unused integration.get"),
+      list: () => Effect.die("unused integration.list"),
+      rebuild: () => Effect.die("unused integration.rebuild"),
+      transform: () => Effect.die("unused integration.transform"),
+    },
+    location: {
+      directory: "/unused/location",
+      project: { directory: "/unused/project" },
+    },
+    npm: {
+      add: () => Effect.die("unused npm.add"),
+    },
+    path: {
+      home: "/unused/home",
+      data: "/unused/data",
+      cache: "/unused/cache",
+      config: "/unused/config",
+      state: "/unused/state",
+      temp: "/unused/temp",
+    },
+    reference: {
+      list: () => Effect.die("unused reference.list"),
+      rebuild: () => Effect.die("unused reference.rebuild"),
+      transform: () => Effect.die("unused reference.transform"),
+    },
+    skill: {
+      sources: () => Effect.die("unused skill.sources"),
+      list: () => Effect.die("unused skill.list"),
+      rebuild: () => Effect.die("unused skill.rebuild"),
+      transform: () => Effect.die("unused skill.transform"),
+    },
+    ...overrides,
+  }
+}
+
+export function aisdkHost(plugin: PluginV2.Interface): PluginHost["aisdk"] {
+  return {
+    hook: (name, callback) => {
+      if (name === "sdk") {
+        const run = callback as AISDKHooks["sdk"]
+        return plugin.hook("aisdk.sdk", (event) => {
+          const output = { ...event }
+          const result = run(output)
+          return Effect.suspend(() => (Effect.isEffect(result) ? result : Effect.void)).pipe(
+            Effect.tap(() => Effect.sync(() => (event.sdk = output.sdk))),
+          )
+        })
+      }
+      const run = callback as AISDKHooks["language"]
+      return plugin.hook("aisdk.language", (event) => {
+        const output = { ...event }
+        const result = run(output)
+        return Effect.suspend(() => (Effect.isEffect(result) ? result : Effect.void)).pipe(
+          Effect.tap(() => Effect.sync(() => (event.language = output.language))),
+        )
+      })
+    },
+  }
+}
+
+export function agentHost(agent: AgentV2.Interface): PluginHost["agent"] {
+  return {
+    ...host().agent,
+    transform: (callback) =>
+      agent.transform((draft) =>
+        callback({
+          list: () => draft.list().map(agentInfo),
+          get: (id) => {
+            const value = draft.get(AgentV2.ID.make(id))
+            return value && agentInfo(value)
+          },
+          default: (id) => draft.default(id === undefined ? undefined : AgentV2.ID.make(id)),
+          update: (id, update) =>
+            draft.update(AgentV2.ID.make(id), (value) => {
+              const current = agentInfo(value)
+              update(current)
+              Object.assign(value, current, { id: AgentV2.ID.make(current.id) })
+            }),
+          remove: (id) => draft.remove(AgentV2.ID.make(id)),
+        }),
+      ),
+  }
+}
+
+export function catalogHost(catalog: Catalog.Interface): PluginHost["catalog"] {
+  return {
+    ...host().catalog,
+    rebuild: catalog.rebuild,
+    transform: (callback) =>
+      catalog.transform((draft) =>
+        callback({
+          provider: {
+            list: () =>
+              draft.provider.list().map((value) => ({
+                provider: providerInfo(value.provider),
+                models: new Map(Array.from(value.models, ([id, model]) => [id, modelInfo(model)])),
+              })),
+            get: (id) => {
+              const value = draft.provider.get(ProviderV2.ID.make(id))
+              return (
+                value && {
+                  provider: providerInfo(value.provider),
+                  models: new Map(Array.from(value.models, ([id, model]) => [id, modelInfo(model)])),
+                }
+              )
+            },
+            update: (id, update) =>
+              draft.provider.update(ProviderV2.ID.make(id), (value) => {
+                const current = providerInfo(value)
+                update(current)
+                Object.assign(value, current, { id: ProviderV2.ID.make(current.id) })
+              }),
+            remove: (id) => draft.provider.remove(ProviderV2.ID.make(id)),
+          },
+          model: {
+            get: (providerID, modelID) => {
+              const value = draft.model.get(ProviderV2.ID.make(providerID), ModelV2.ID.make(modelID))
+              return value && modelInfo(value)
+            },
+            update: (providerID, modelID, update) =>
+              draft.model.update(ProviderV2.ID.make(providerID), ModelV2.ID.make(modelID), (value) => {
+                const current = modelInfo(value)
+                update(current)
+                Object.assign(value, current, {
+                  id: ModelV2.ID.make(current.id),
+                  providerID: ProviderV2.ID.make(current.providerID),
+                  family: current.family === undefined ? undefined : ModelV2.Family.make(current.family),
+                  variants: current.variants.map((variant) => ({
+                    ...variant,
+                    id: ModelV2.VariantID.make(variant.id),
+                  })),
+                })
+              }),
+            remove: (providerID, modelID) =>
+              draft.model.remove(ProviderV2.ID.make(providerID), ModelV2.ID.make(modelID)),
+            default: {
+              get: () => {
+                const value = draft.model.default.get()
+                return value && { providerID: value.providerID, modelID: value.modelID }
+              },
+              set: (providerID, modelID) =>
+                draft.model.default.set(ProviderV2.ID.make(providerID), ModelV2.ID.make(modelID)),
+            },
+          },
+        }),
+      ),
+  }
+}
+
+export function integrationHost(integration: Integration.Interface): PluginHost["integration"] {
+  const info = (value: Integration.Info) => ({
+    id: value.id,
+    name: value.name,
+    methods: value.methods.map(method),
+    connections: value.connections.map((item) => ({ ...item })),
+  })
+  return {
+    get: (id) => integration.get(Integration.ID.make(id)).pipe(Effect.map((value) => value && info(value))),
+    list: () => integration.list().pipe(Effect.map((items) => items.map(info))),
+    rebuild: integration.rebuild,
+    transform: (callback) =>
+      integration.transform((draft) =>
+        callback({
+          list: () => draft.list().map((value) => ({ id: value.id, name: value.name })),
+          get: (id) => {
+            const value = draft.get(Integration.ID.make(id))
+            return value && { id: value.id, name: value.name }
+          },
+          update: (id, update) => draft.update(Integration.ID.make(id), update),
+          remove: (id) => draft.remove(Integration.ID.make(id)),
+          method: {
+            list: (id) => draft.method.list(Integration.ID.make(id)).map(method),
+            update: (input) =>
+              input.method.type === "env"
+                ? draft.method.update({
+                    integrationID: Integration.ID.make(input.integrationID),
+                    method: { ...input.method, names: [...input.method.names] },
+                  })
+                : draft.method.update({
+                    integrationID: Integration.ID.make(input.integrationID),
+                    method: input.method,
+                  }),
+            remove: (id, item) => draft.method.remove(Integration.ID.make(id), internalMethod(item)),
+          },
+        }),
+      ),
+  }
+}
+
+function method(value: Integration.Method) {
+  if (value.type === "env") return { type: value.type, names: [...value.names] }
+  if (value.type === "key") return { type: value.type, label: value.label }
+  return {
+    type: value.type,
+    id: value.id,
+    label: value.label,
+    prompts: value.prompts?.map((prompt) => {
+      if (prompt.type === "text") return { ...prompt }
+      return { ...prompt, options: prompt.options.map((option) => ({ ...option })) }
+    }),
+  }
+}
+
+function internalMethod(
+  value: IntegrationOAuthMethod | IntegrationKeyMethod | IntegrationEnvMethod,
+): Integration.Method {
+  if (value.type === "env") return value
+  if (value.type === "key") return value
+  return {
+    ...value,
+    id: Integration.MethodID.make(value.id),
+  }
+}
+
+function agentInfo(value: AgentV2.Info) {
+  return {
+    ...value,
+    model: value.model && { ...value.model },
+    request: { headers: { ...value.request.headers }, body: { ...value.request.body } },
+    permissions: value.permissions.map((permission) => ({ ...permission })),
+  }
+}
+
+function providerInfo(value: ProviderV2.MutableInfo) {
+  return {
+    ...value,
+    api: { ...value.api, settings: value.api.settings && { ...value.api.settings } },
+    request: { headers: { ...value.request.headers }, body: { ...value.request.body } },
+  }
+}
+
+function modelInfo(value: ModelV2.Info | ModelV2.MutableInfo) {
+  return {
+    ...value,
+    api: { ...value.api, settings: value.api.settings && { ...value.api.settings } },
+    capabilities: {
+      ...value.capabilities,
+      input: [...value.capabilities.input],
+      output: [...value.capabilities.output],
+    },
+    request: {
+      ...value.request,
+      headers: { ...value.request.headers },
+      body: { ...value.request.body },
+      generation: value.request.generation && {
+        ...value.request.generation,
+        stop: value.request.generation.stop && [...value.request.generation.stop],
+      },
+      options: value.request.options && { ...value.request.options },
+    },
+    variants: value.variants.map((variant) => ({
+      ...variant,
+      headers: { ...variant.headers },
+      body: { ...variant.body },
+      generation: variant.generation && {
+        ...variant.generation,
+        stop: variant.generation.stop && [...variant.generation.stop],
+      },
+      options: variant.options && { ...variant.options },
+    })),
+    time: { ...value.time },
+    cost: value.cost.map((cost) => ({ ...cost, tier: cost.tier && { ...cost.tier }, cache: { ...cost.cache } })),
+    limit: { ...value.limit },
+  }
+}

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

@@ -1,6 +1,6 @@
 import path from "path"
 import { describe, expect } from "bun:test"
-import { Effect, Layer } from "effect"
+import { Effect, Layer, Stream } from "effect"
 import { Catalog } from "@opencode-ai/core/catalog"
 import { Integration } from "@opencode-ai/core/integration"
 import { Credential } from "@opencode-ai/core/credential"
@@ -15,6 +15,7 @@ import { Policy } from "@opencode-ai/core/policy"
 import { AbsolutePath } from "@opencode-ai/core/schema"
 import { location } from "../fixture/location"
 import { testEffect } from "../lib/effect"
+import { catalogHost, host, integrationHost } from "./host"
 
 const events = EventV2.defaultLayer
 const locationLayer = Layer.succeed(
@@ -56,8 +57,15 @@ describe("ModelsDevPlugin", () => {
       }),
       () =>
         Effect.gen(function* () {
-          yield* ModelsDevPlugin.effect
           const integrations = yield* Integration.Service
+          const catalog = yield* Catalog.Service
+          yield* ModelsDevPlugin.effect(
+            host({
+              catalog: catalogHost(catalog),
+              event: { subscribe: () => Stream.never },
+              integration: integrationHost(integrations),
+            }),
+          )
           expect(yield* integrations.list()).toEqual([
             new Integration.Info({
               id: Integration.ID.make("acme"),

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

@@ -4,13 +4,13 @@ import { Effect } from "effect"
 import { ModelV2 } from "@opencode-ai/core/model"
 import { PluginV2 } from "@opencode-ai/core/plugin"
 import { AlibabaPlugin } from "@opencode-ai/core/plugin/provider/alibaba"
-import { it, model } from "./provider-helper"
+import { addPlugin, it, model } from "./provider-helper"
 
 describe("AlibabaPlugin", () => {
   it.effect("creates an Alibaba SDK for @ai-sdk/alibaba", () =>
     Effect.gen(function* () {
       const plugin = yield* PluginV2.Service
-      yield* plugin.add(AlibabaPlugin)
+      yield* addPlugin(plugin, AlibabaPlugin)
       const result = yield* plugin.trigger(
         "aisdk.sdk",
         { model: model("alibaba", "qwen"), package: "@ai-sdk/alibaba", options: { name: "alibaba" } },
@@ -23,7 +23,7 @@ describe("AlibabaPlugin", () => {
   it.effect("ignores non-Alibaba SDK packages", () =>
     Effect.gen(function* () {
       const plugin = yield* PluginV2.Service
-      yield* plugin.add(AlibabaPlugin)
+      yield* addPlugin(plugin, AlibabaPlugin)
       const result = yield* plugin.trigger(
         "aisdk.sdk",
         { model: model("alibaba", "qwen"), package: "@ai-sdk/openai-compatible", options: { name: "alibaba" } },
@@ -36,7 +36,7 @@ describe("AlibabaPlugin", () => {
   it.effect("matches the old bundled Alibaba SDK provider naming", () =>
     Effect.gen(function* () {
       const plugin = yield* PluginV2.Service
-      yield* plugin.add(AlibabaPlugin)
+      yield* addPlugin(plugin, AlibabaPlugin)
       const result = yield* plugin.trigger(
         "aisdk.sdk",
         {
@@ -56,7 +56,7 @@ describe("AlibabaPlugin", () => {
   it.effect("uses the old default languageModel(api.id) behavior", () =>
     Effect.gen(function* () {
       const plugin = yield* PluginV2.Service
-      yield* plugin.add(AlibabaPlugin)
+      yield* addPlugin(plugin, AlibabaPlugin)
       const item = model("alibaba", "alias", { api: { id: ModelV2.ID.make("qwen-plus") } })
       const result = yield* plugin.trigger("aisdk.sdk", { model: item, package: "@ai-sdk/alibaba", options: {} }, {})
       const language = result.sdk?.languageModel(item.api.id)

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

@@ -4,7 +4,7 @@ import { Catalog } from "@opencode-ai/core/catalog"
 import { PluginV2 } from "@opencode-ai/core/plugin"
 import { AmazonBedrockPlugin } from "@opencode-ai/core/plugin/provider/amazon-bedrock"
 import { ProviderV2 } from "@opencode-ai/core/provider"
-import { fakeSelectorSdk, it, model, provider, withEnv } from "./provider-helper"
+import { addPlugin, fakeSelectorSdk, it, model, provider, required, withEnv } from "./provider-helper"
 
 function bedrockBaseURL(sdk: unknown, modelID = "anthropic.claude-sonnet-4-5") {
   const language = (sdk as { languageModel: (id: string) => unknown }).languageModel(modelID)
@@ -30,9 +30,8 @@ describe("AmazonBedrockPlugin", () => {
     Effect.gen(function* () {
       const plugin = yield* PluginV2.Service
       const catalog = yield* Catalog.Service
-      yield* plugin.add(AmazonBedrockPlugin)
+      yield* addPlugin(plugin, AmazonBedrockPlugin)
-      const transform = yield* catalog.transform()
+      yield* catalog.transform((catalog) => {
-      yield* transform((catalog) => {
         const bedrock = provider("amazon-bedrock", {
           api: { type: "aisdk", package: "@ai-sdk/amazon-bedrock" },
           request: {
@@ -45,7 +44,7 @@ describe("AmazonBedrockPlugin", () => {
           item.request = bedrock.request
         })
       })
-      const result = yield* catalog.provider.get(ProviderV2.ID.amazonBedrock)
+      const result = required(yield* catalog.provider.get(ProviderV2.ID.amazonBedrock))
       expect(result.api).toEqual({
         type: "aisdk",
         package: "@ai-sdk/amazon-bedrock",
@@ -59,7 +58,7 @@ describe("AmazonBedrockPlugin", () => {
     withEnv({ AWS_BEARER_TOKEN_BEDROCK: undefined, AWS_PROFILE: undefined, AWS_ACCESS_KEY_ID: undefined }, () =>
       Effect.gen(function* () {
         const plugin = yield* PluginV2.Service
-        yield* plugin.add(AmazonBedrockPlugin)
+        yield* addPlugin(plugin, AmazonBedrockPlugin)
         const result = yield* plugin.trigger(
           "aisdk.sdk",
           {
@@ -84,7 +83,7 @@ describe("AmazonBedrockPlugin", () => {
     withEnv({ AWS_BEARER_TOKEN_BEDROCK: undefined, AWS_PROFILE: undefined, AWS_ACCESS_KEY_ID: undefined }, () =>
       Effect.gen(function* () {
         const plugin = yield* PluginV2.Service
-        yield* plugin.add(AmazonBedrockPlugin)
+        yield* addPlugin(plugin, AmazonBedrockPlugin)
         const result = yield* plugin.trigger(
           "aisdk.sdk",
           {
@@ -118,7 +117,7 @@ describe("AmazonBedrockPlugin", () => {
       () =>
         Effect.gen(function* () {
           const plugin = yield* PluginV2.Service
-          yield* plugin.add(AmazonBedrockPlugin)
+          yield* addPlugin(plugin, AmazonBedrockPlugin)
           const result = yield* plugin.trigger(
             "aisdk.sdk",
             {
@@ -138,7 +137,7 @@ describe("AmazonBedrockPlugin", () => {
     withEnv({ AWS_BEARER_TOKEN_BEDROCK: "token", AWS_REGION: "us-east-1" }, () =>
       Effect.gen(function* () {
         const plugin = yield* PluginV2.Service
-        yield* plugin.add(AmazonBedrockPlugin)
+        yield* addPlugin(plugin, AmazonBedrockPlugin)
         const result = yield* plugin.trigger(
           "aisdk.sdk",
           {
@@ -157,7 +156,7 @@ describe("AmazonBedrockPlugin", () => {
     withEnv({ AWS_BEARER_TOKEN_BEDROCK: "token", AWS_REGION: "eu-west-1" }, () =>
       Effect.gen(function* () {
         const plugin = yield* PluginV2.Service
-        yield* plugin.add(AmazonBedrockPlugin)
+        yield* addPlugin(plugin, AmazonBedrockPlugin)
         const result = yield* plugin.trigger(
           "aisdk.sdk",
           {
@@ -176,7 +175,7 @@ describe("AmazonBedrockPlugin", () => {
     withEnv({ AWS_BEARER_TOKEN_BEDROCK: "token", AWS_REGION: undefined }, () =>
       Effect.gen(function* () {
         const plugin = yield* PluginV2.Service
-        yield* plugin.add(AmazonBedrockPlugin)
+        yield* addPlugin(plugin, AmazonBedrockPlugin)
         const result = yield* plugin.trigger(
           "aisdk.sdk",
           {
@@ -196,7 +195,7 @@ describe("AmazonBedrockPlugin", () => {
       Effect.gen(function* () {
         const plugin = yield* PluginV2.Service
         const headers: Array<string | null> = []
-        yield* plugin.add(AmazonBedrockPlugin)
+        yield* addPlugin(plugin, AmazonBedrockPlugin)
         const result = yield* plugin.trigger(
           "aisdk.sdk",
           {
@@ -225,7 +224,7 @@ describe("AmazonBedrockPlugin", () => {
       Effect.gen(function* () {
         const plugin = yield* PluginV2.Service
         const headers: Array<string | null> = []
-        yield* plugin.add(AmazonBedrockPlugin)
+        yield* addPlugin(plugin, AmazonBedrockPlugin)
         const result = yield* plugin.trigger(
           "aisdk.sdk",
           {
@@ -253,7 +252,7 @@ describe("AmazonBedrockPlugin", () => {
     withEnv({ AWS_BEARER_TOKEN_BEDROCK: undefined, AWS_PROFILE: undefined, AWS_ACCESS_KEY_ID: undefined }, () =>
       Effect.gen(function* () {
         const plugin = yield* PluginV2.Service
-        yield* plugin.add(AmazonBedrockPlugin)
+        yield* addPlugin(plugin, AmazonBedrockPlugin)
         const result = yield* plugin.trigger(
           "aisdk.sdk",
           {
@@ -282,7 +281,7 @@ describe("AmazonBedrockPlugin", () => {
     Effect.gen(function* () {
       const plugin = yield* PluginV2.Service
       const calls: string[] = []
-      yield* plugin.add(AmazonBedrockPlugin)
+      yield* addPlugin(plugin, AmazonBedrockPlugin)
       yield* plugin.trigger(
         "aisdk.language",
         {
@@ -312,7 +311,7 @@ describe("AmazonBedrockPlugin", () => {
   it.effect("ignores other Bedrock provider subpaths", () =>
     Effect.gen(function* () {
       const plugin = yield* PluginV2.Service
-      yield* plugin.add(AmazonBedrockPlugin)
+      yield* addPlugin(plugin, AmazonBedrockPlugin)
       const result = yield* plugin.trigger(
         "aisdk.sdk",
         {
@@ -341,7 +340,7 @@ describe("AmazonBedrockPlugin", () => {
         Effect.gen(function* () {
           const plugin = yield* PluginV2.Service
           const headers: Array<string | null> = []
-          yield* plugin.add(AmazonBedrockPlugin)
+          yield* addPlugin(plugin, AmazonBedrockPlugin)
           const result = yield* plugin.trigger(
             "aisdk.sdk",
             {
@@ -372,7 +371,7 @@ describe("AmazonBedrockPlugin", () => {
     Effect.gen(function* () {
       const plugin = yield* PluginV2.Service
       const calls: string[] = []
-      yield* plugin.add(AmazonBedrockPlugin)
+      yield* addPlugin(plugin, AmazonBedrockPlugin)
       yield* plugin.trigger(
         "aisdk.language",
         {
@@ -433,7 +432,7 @@ describe("AmazonBedrockPlugin", () => {
       Effect.gen(function* () {
         const plugin = yield* PluginV2.Service
         const calls: string[] = []
-        yield* plugin.add(AmazonBedrockPlugin)
+        yield* addPlugin(plugin, AmazonBedrockPlugin)
         yield* plugin.trigger(
           "aisdk.language",
           {
@@ -518,7 +517,7 @@ describe("AmazonBedrockPlugin", () => {
           expected: "au.anthropic.claude-sonnet-4-5",
         },
       ]
-      yield* plugin.add(AmazonBedrockPlugin)
+      yield* addPlugin(plugin, AmazonBedrockPlugin)
       for (const item of cases) {
         yield* plugin.trigger(
           "aisdk.language",
@@ -538,7 +537,7 @@ describe("AmazonBedrockPlugin", () => {
     Effect.gen(function* () {
       const plugin = yield* PluginV2.Service
       const calls: string[] = []
-      yield* plugin.add(AmazonBedrockPlugin)
+      yield* addPlugin(plugin, AmazonBedrockPlugin)
       const result = yield* plugin.trigger(
         "aisdk.language",
         {

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

@@ -4,16 +4,15 @@ import { Catalog } from "@opencode-ai/core/catalog"
 import { PluginV2 } from "@opencode-ai/core/plugin"
 import { AnthropicPlugin } from "@opencode-ai/core/plugin/provider/anthropic"
 import { ProviderV2 } from "@opencode-ai/core/provider"
-import { it, model, provider } from "./provider-helper"
+import { addPlugin, it, model, provider, required } from "./provider-helper"
 
 describe("AnthropicPlugin", () => {
   it.effect("applies legacy beta headers", () =>
     Effect.gen(function* () {
       const plugin = yield* PluginV2.Service
       const catalog = yield* Catalog.Service
-      yield* plugin.add(AnthropicPlugin)
+      yield* addPlugin(plugin, AnthropicPlugin)
-      const transform = yield* catalog.transform()
+      yield* catalog.transform((catalog) => {
-      yield* transform((catalog) => {
         const item = provider("anthropic", {
           api: { type: "aisdk", package: "@ai-sdk/anthropic" },
           request: { headers: { Existing: "1" }, body: {} },
@@ -23,10 +22,10 @@ describe("AnthropicPlugin", () => {
           draft.request = item.request
         })
       })
-      expect((yield* catalog.provider.get(ProviderV2.ID.anthropic)).request.headers["anthropic-beta"]).toBe(
+      expect(required(yield* catalog.provider.get(ProviderV2.ID.anthropic)).request.headers["anthropic-beta"]).toBe(
         "interleaved-thinking-2025-05-14,fine-grained-tool-streaming-2025-05-14",
       )
-      expect((yield* catalog.provider.get(ProviderV2.ID.anthropic)).request.headers.Existing).toBe("1")
+      expect(required(yield* catalog.provider.get(ProviderV2.ID.anthropic)).request.headers.Existing).toBe("1")
     }),
   )
 
@@ -34,10 +33,11 @@ describe("AnthropicPlugin", () => {
     Effect.gen(function* () {
       const plugin = yield* PluginV2.Service
       const catalog = yield* Catalog.Service
-      yield* plugin.add(AnthropicPlugin)
+      yield* addPlugin(plugin, AnthropicPlugin)
-      const transform = yield* catalog.transform()
+      yield* catalog.transform((catalog) => catalog.provider.update(provider("openai").id, () => {}))
-      yield* transform((catalog) => catalog.provider.update(provider("openai").id, () => {}))
+      expect(
-      expect((yield* catalog.provider.get(ProviderV2.ID.openai)).request.headers["anthropic-beta"]).toBeUndefined()
+        required(yield* catalog.provider.get(ProviderV2.ID.openai)).request.headers["anthropic-beta"],
+      ).toBeUndefined()
     }),
   )
 
@@ -45,7 +45,7 @@ describe("AnthropicPlugin", () => {
     Effect.gen(function* () {
       const plugin = yield* PluginV2.Service
       const providers: string[] = []
-      yield* plugin.add(AnthropicPlugin)
+      yield* addPlugin(plugin, AnthropicPlugin)
       yield* plugin.add({
         id: PluginV2.ID.make("anthropic-sdk-inspector"),
         effect: Effect.succeed({
@@ -72,7 +72,7 @@ describe("AnthropicPlugin", () => {
     Effect.gen(function* () {
       const plugin = yield* PluginV2.Service
       const providers: string[] = []
-      yield* plugin.add(AnthropicPlugin)
+      yield* addPlugin(plugin, AnthropicPlugin)
       yield* plugin.add({
         id: PluginV2.ID.make("anthropic-sdk-inspector"),
         effect: Effect.succeed({

packages/core/test/plugin/provider-azure-cognitive-services.test.ts

@@ -4,7 +4,7 @@ import { Catalog } from "@opencode-ai/core/catalog"
 import { PluginV2 } from "@opencode-ai/core/plugin"
 import { AzureCognitiveServicesPlugin } from "@opencode-ai/core/plugin/provider/azure"
 import { ProviderV2 } from "@opencode-ai/core/provider"
-import { fakeSelectorSdk, it, model, provider, withEnv } from "./provider-helper"
+import { addPlugin, fakeSelectorSdk, it, model, provider, required, withEnv } from "./provider-helper"
 
 describe("AzureCognitiveServicesPlugin", () => {
   it.effect("maps the resource env var to the Azure SDK baseURL", () =>
@@ -12,14 +12,13 @@ describe("AzureCognitiveServicesPlugin", () => {
       Effect.gen(function* () {
         const plugin = yield* PluginV2.Service
         const catalog = yield* Catalog.Service
-        yield* plugin.add(AzureCognitiveServicesPlugin)
+        yield* addPlugin(plugin, AzureCognitiveServicesPlugin)
-        const transform = yield* catalog.transform()
+        yield* catalog.transform((catalog) => {
-        yield* transform((catalog) => {
           catalog.provider.update(ProviderV2.ID.make("azure-cognitive-services"), (item) => {
             item.api = { type: "aisdk", package: "@ai-sdk/openai-compatible" }
           })
         })
-        const result = yield* catalog.provider.get(ProviderV2.ID.make("azure-cognitive-services"))
+        const result = required(yield* catalog.provider.get(ProviderV2.ID.make("azure-cognitive-services")))
         expect(result.api).toEqual({
           type: "aisdk",
           package: "@ai-sdk/openai-compatible",
@@ -36,9 +35,8 @@ describe("AzureCognitiveServicesPlugin", () => {
       Effect.gen(function* () {
         const plugin = yield* PluginV2.Service
         const catalog = yield* Catalog.Service
-        yield* plugin.add(AzureCognitiveServicesPlugin)
+        yield* addPlugin(plugin, AzureCognitiveServicesPlugin)
-        const transform = yield* catalog.transform()
+        yield* catalog.transform((catalog) => {
-        yield* transform((catalog) => {
           const azure = provider("azure-cognitive-services", {
             api: { type: "aisdk", package: "@ai-sdk/openai-compatible" },
           })
@@ -50,8 +48,8 @@ describe("AzureCognitiveServicesPlugin", () => {
             item.api = openai.api
           })
         })
-        const azure = yield* catalog.provider.get(ProviderV2.ID.make("azure-cognitive-services"))
+        const azure = required(yield* catalog.provider.get(ProviderV2.ID.make("azure-cognitive-services")))
-        const openai = yield* catalog.provider.get(ProviderV2.ID.openai)
+        const openai = required(yield* catalog.provider.get(ProviderV2.ID.openai))
         expect(azure.request.body.baseURL).toBeUndefined()
         expect(azure.api).toEqual({ type: "aisdk", package: "@ai-sdk/openai-compatible" })
         expect(openai.request.body.baseURL).toBeUndefined()
@@ -64,7 +62,7 @@ describe("AzureCognitiveServicesPlugin", () => {
     Effect.gen(function* () {
       const plugin = yield* PluginV2.Service
       const calls: string[] = []
-      yield* plugin.add(AzureCognitiveServicesPlugin)
+      yield* addPlugin(plugin, AzureCognitiveServicesPlugin)
       yield* plugin.trigger(
         "aisdk.language",
         {
@@ -82,7 +80,7 @@ describe("AzureCognitiveServicesPlugin", () => {
     Effect.gen(function* () {
       const plugin = yield* PluginV2.Service
       const calls: string[] = []
-      yield* plugin.add(AzureCognitiveServicesPlugin)
+      yield* addPlugin(plugin, AzureCognitiveServicesPlugin)
       yield* plugin.trigger(
         "aisdk.language",
         { model: model("azure-cognitive-services", "deployment"), sdk: fakeSelectorSdk(calls), options: {} },
@@ -103,7 +101,7 @@ describe("AzureCognitiveServicesPlugin", () => {
       const plugin = yield* PluginV2.Service
       const calls: string[] = []
       const sdk = fakeSelectorSdk(calls)
-      yield* plugin.add(AzureCognitiveServicesPlugin)
+      yield* addPlugin(plugin, AzureCognitiveServicesPlugin)
       yield* plugin.trigger(
         "aisdk.language",
         {

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

@@ -1,35 +1,10 @@
 import { describe, expect } from "bun:test"
-import { Effect, Layer } from "effect"
+import { Effect } from "effect"
-import { Credential } from "@opencode-ai/core/credential"
-import { Integration } from "@opencode-ai/core/integration"
-import { Database } from "@opencode-ai/core/database/database"
 import { Catalog } from "@opencode-ai/core/catalog"
-import { EventV2 } from "@opencode-ai/core/event"
-import { Location } from "@opencode-ai/core/location"
 import { PluginV2 } from "@opencode-ai/core/plugin"
 import { AzurePlugin } from "@opencode-ai/core/plugin/provider/azure"
 import { ProviderV2 } from "@opencode-ai/core/provider"
-import { AbsolutePath } from "@opencode-ai/core/schema"
+import { addPlugin, fakeSelectorSdk, it, model, provider, required, withEnv } from "./provider-helper"
-import { location } from "../fixture/location"
-import { testEffect } from "../lib/effect"
-import { fakeSelectorSdk, it, model, npmLayer, provider, withEnv } from "./provider-helper"
-
-const database = Database.layerFromPath(":memory:").pipe(Layer.fresh)
-const preferences = Credential.layer.pipe(Layer.provide(database))
-const accounts = Layer.merge(
-  Credential.layer.pipe(Layer.provide(database), Layer.provide(preferences), Layer.provide(EventV2.defaultLayer)),
-  preferences,
-)
-const itWithAccount = testEffect(
-  Catalog.locationLayer.pipe(
-    Layer.provideMerge(accounts),
-    Layer.provideMerge(EventV2.defaultLayer),
-    Layer.provideMerge(
-      Layer.succeed(Location.Service, Location.Service.of(location({ directory: AbsolutePath.make("test") }))),
-    ),
-    Layer.provideMerge(npmLayer),
-  ),
-)
 
 describe("AzurePlugin", () => {
   it.effect("resolves resourceName from env", () =>
@@ -37,14 +12,13 @@ describe("AzurePlugin", () => {
       Effect.gen(function* () {
         const plugin = yield* PluginV2.Service
         const catalog = yield* Catalog.Service
-        yield* plugin.add(AzurePlugin)
+        yield* catalog.transform((catalog) => {
-        const transform = yield* catalog.transform()
-        yield* transform((catalog) => {
           catalog.provider.update(ProviderV2.ID.azure, (item) => {
             item.api = { type: "aisdk", package: "@ai-sdk/azure" }
           })
         })
-        expect((yield* catalog.provider.get(ProviderV2.ID.azure)).request.body.resourceName).toBe("from-env")
+        yield* addPlugin(plugin, AzurePlugin)
+        expect(required(yield* catalog.provider.get(ProviderV2.ID.azure)).request.body.resourceName).toBe("from-env")
       }),
     ),
   )
@@ -54,9 +28,7 @@ describe("AzurePlugin", () => {
       Effect.gen(function* () {
         const plugin = yield* PluginV2.Service
         const catalog = yield* Catalog.Service
-        yield* plugin.add(AzurePlugin)
+        yield* catalog.transform((catalog) => {
-        const transform = yield* catalog.transform()
-        yield* transform((catalog) => {
           const azure = provider("azure", {
             api: { type: "aisdk", package: "@ai-sdk/azure" },
             request: { headers: {}, body: { resourceName: "from-config" } },
@@ -67,38 +39,9 @@ describe("AzurePlugin", () => {
           })
           catalog.provider.update(ProviderV2.ID.openai, () => {})
         })
-        expect((yield* catalog.provider.get(ProviderV2.ID.azure)).request.body.resourceName).toBe("from-config")
+        yield* addPlugin(plugin, AzurePlugin)
-        expect((yield* catalog.provider.get(ProviderV2.ID.openai)).request.body.resourceName).toBeUndefined()
+        expect(required(yield* catalog.provider.get(ProviderV2.ID.azure)).request.body.resourceName).toBe("from-config")
-      }),
+        expect(required(yield* catalog.provider.get(ProviderV2.ID.openai)).request.body.resourceName).toBeUndefined()
-    ),
-  )
-
-  itWithAccount.effect("prefers account resourceName over env", () =>
-    withEnv(
-      {
-        AZURE_RESOURCE_NAME: "from-env",
-      },
-      () =>
-        Effect.gen(function* () {
-          const plugin = yield* PluginV2.Service
-          const credentials = yield* Credential.Service
-          const catalog = yield* Catalog.Service
-          yield* credentials.create({
-            integrationID: Integration.ID.make("azure"),
-            value: new Credential.Key({
-              type: "key",
-              key: "key",
-              metadata: { resourceName: "from-account" },
-            }),
-          })
-          yield* plugin.add(AzurePlugin)
-          const transform = yield* catalog.transform()
-          yield* transform((catalog) => {
-            catalog.provider.update(ProviderV2.ID.azure, (item) => {
-              item.api = { type: "aisdk", package: "@ai-sdk/azure" }
-            })
-          })
-          expect((yield* catalog.provider.get(ProviderV2.ID.azure)).request.body.resourceName).toBe("from-account")
       }),
     ),
   )
@@ -108,9 +51,7 @@ describe("AzurePlugin", () => {
       Effect.gen(function* () {
         const plugin = yield* PluginV2.Service
         const catalog = yield* Catalog.Service
-        yield* plugin.add(AzurePlugin)
+        yield* catalog.transform((catalog) => {
-        const transform = yield* catalog.transform()
-        yield* transform((catalog) => {
           const azure = provider("azure", {
             api: { type: "aisdk", package: "@ai-sdk/azure" },
             request: { headers: {}, body: { resourceName: "" } },
@@ -120,7 +61,8 @@ describe("AzurePlugin", () => {
             item.request = azure.request
           })
         })
-        expect((yield* catalog.provider.get(ProviderV2.ID.azure)).request.body.resourceName).toBe("from-env")
+        yield* addPlugin(plugin, AzurePlugin)
+        expect(required(yield* catalog.provider.get(ProviderV2.ID.azure)).request.body.resourceName).toBe("from-env")
       }),
     ),
   )
@@ -130,9 +72,7 @@ describe("AzurePlugin", () => {
       Effect.gen(function* () {
         const plugin = yield* PluginV2.Service
         const catalog = yield* Catalog.Service
-        yield* plugin.add(AzurePlugin)
+        yield* catalog.transform((catalog) => {
-        const transform = yield* catalog.transform()
-        yield* transform((catalog) => {
           const azure = provider("azure", {
             api: { type: "aisdk", package: "@ai-sdk/azure" },
             request: { headers: {}, body: { resourceName: "   " } },
@@ -142,7 +82,8 @@ describe("AzurePlugin", () => {
             item.request = azure.request
           })
         })
-        expect((yield* catalog.provider.get(ProviderV2.ID.azure)).request.body.resourceName).toBe("from-env")
+        yield* addPlugin(plugin, AzurePlugin)
+        expect(required(yield* catalog.provider.get(ProviderV2.ID.azure)).request.body.resourceName).toBe("from-env")
       }),
     ),
   )
@@ -151,7 +92,7 @@ describe("AzurePlugin", () => {
     withEnv({ AZURE_RESOURCE_NAME: undefined }, () =>
       Effect.gen(function* () {
         const plugin = yield* PluginV2.Service
-        yield* plugin.add(AzurePlugin)
+        yield* addPlugin(plugin, AzurePlugin)
         const result = yield* plugin.trigger(
           "aisdk.sdk",
           {
@@ -170,7 +111,7 @@ describe("AzurePlugin", () => {
     withEnv({ AZURE_RESOURCE_NAME: undefined }, () =>
       Effect.gen(function* () {
         const plugin = yield* PluginV2.Service
-        yield* plugin.add(AzurePlugin)
+        yield* addPlugin(plugin, AzurePlugin)
         const exit = yield* plugin
           .trigger(
             "aisdk.sdk",
@@ -187,7 +128,7 @@ describe("AzurePlugin", () => {
     Effect.gen(function* () {
       const plugin = yield* PluginV2.Service
       const calls: string[] = []
-      yield* plugin.add(AzurePlugin)
+      yield* addPlugin(plugin, AzurePlugin)
       yield* plugin.trigger(
         "aisdk.language",
         { model: model("azure", "deployment"), sdk: fakeSelectorSdk(calls), options: { useCompletionUrls: true } },
@@ -201,7 +142,7 @@ describe("AzurePlugin", () => {
     Effect.gen(function* () {
       const plugin = yield* PluginV2.Service
       const calls: string[] = []
-      yield* plugin.add(AzurePlugin)
+      yield* addPlugin(plugin, AzurePlugin)
       yield* plugin.trigger(
         "aisdk.language",
         { model: model("azure", "deployment"), sdk: fakeSelectorSdk(calls), options: { useCompletionUrls: true } },
@@ -215,7 +156,7 @@ describe("AzurePlugin", () => {
     Effect.gen(function* () {
       const plugin = yield* PluginV2.Service
       const calls: string[] = []
-      yield* plugin.add(AzurePlugin)
+      yield* addPlugin(plugin, AzurePlugin)
       yield* plugin.trigger(
         "aisdk.language",
         {
@@ -235,7 +176,7 @@ describe("AzurePlugin", () => {
     Effect.gen(function* () {
       const plugin = yield* PluginV2.Service
       const calls: string[] = []
-      yield* plugin.add(AzurePlugin)
+      yield* addPlugin(plugin, AzurePlugin)
       yield* plugin.trigger(
         "aisdk.language",
         { model: model("azure", "deployment"), sdk: fakeSelectorSdk(calls), options: {} },
@@ -259,7 +200,7 @@ describe("AzurePlugin", () => {
         calls.push(`${method}:${id}`)
         return { modelId: id, provider: method, specificationVersion: "v3" }
       }
-      yield* plugin.add(AzurePlugin)
+      yield* addPlugin(plugin, AzurePlugin)
       yield* plugin.trigger(
         "aisdk.language",
         {

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

@@ -4,7 +4,7 @@ import { Catalog } from "@opencode-ai/core/catalog"
 import { PluginV2 } from "@opencode-ai/core/plugin"
 import { CerebrasPlugin } from "@opencode-ai/core/plugin/provider/cerebras"
 import { ProviderV2 } from "@opencode-ai/core/provider"
-import { it, model } from "./provider-helper"
+import { addPlugin, it, model, required } from "./provider-helper"
 
 const cerebrasOptions: Record<string, unknown>[] = []
 
@@ -23,15 +23,14 @@ describe("CerebrasPlugin", () => {
     Effect.gen(function* () {
       const plugin = yield* PluginV2.Service
       const catalog = yield* Catalog.Service
-      yield* plugin.add(CerebrasPlugin)
+      yield* addPlugin(plugin, CerebrasPlugin)
-      const transform = yield* catalog.transform()
+      yield* catalog.transform((catalog) => {
-      yield* transform((catalog) => {
         catalog.provider.update(ProviderV2.ID.make("cerebras"), (item) => {
           item.api = { type: "aisdk", package: "@ai-sdk/cerebras" }
           item.request.headers.Existing = "1"
         })
       })
-      expect((yield* catalog.provider.get(ProviderV2.ID.make("cerebras"))).request.headers).toEqual({
+      expect(required(yield* catalog.provider.get(ProviderV2.ID.make("cerebras"))).request.headers).toEqual({
         Existing: "1",
         "X-Cerebras-3rd-Party-Integration": "opencode",
       })
@@ -42,10 +41,9 @@ describe("CerebrasPlugin", () => {
     Effect.gen(function* () {
       const plugin = yield* PluginV2.Service
       const catalog = yield* Catalog.Service
-      yield* plugin.add(CerebrasPlugin)
+      yield* addPlugin(plugin, CerebrasPlugin)
-      const transform = yield* catalog.transform()
+      yield* catalog.transform((catalog) => catalog.provider.update(ProviderV2.ID.make("groq"), () => {}))
-      yield* transform((catalog) => catalog.provider.update(ProviderV2.ID.make("groq"), () => {}))
+      expect(required(yield* catalog.provider.get(ProviderV2.ID.make("groq"))).request.headers).toEqual({})
-      expect((yield* catalog.provider.get(ProviderV2.ID.make("groq"))).request.headers).toEqual({})
     }),
   )
 
@@ -53,7 +51,7 @@ describe("CerebrasPlugin", () => {
     Effect.gen(function* () {
       cerebrasOptions.length = 0
       const plugin = yield* PluginV2.Service
-      yield* plugin.add(CerebrasPlugin)
+      yield* addPlugin(plugin, CerebrasPlugin)
       const result = yield* plugin.trigger(
         "aisdk.sdk",
         {
@@ -72,7 +70,7 @@ describe("CerebrasPlugin", () => {
     Effect.gen(function* () {
       cerebrasOptions.length = 0
       const plugin = yield* PluginV2.Service
-      yield* plugin.add(CerebrasPlugin)
+      yield* addPlugin(plugin, CerebrasPlugin)
       yield* plugin.trigger(
         "aisdk.sdk",
         {
@@ -90,7 +88,7 @@ describe("CerebrasPlugin", () => {
     Effect.gen(function* () {
       cerebrasOptions.length = 0
       const plugin = yield* PluginV2.Service
-      yield* plugin.add(CerebrasPlugin)
+      yield* addPlugin(plugin, CerebrasPlugin)
       const result = yield* plugin.trigger(
         "aisdk.sdk",
         {

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

@@ -2,7 +2,7 @@ import { describe, expect, mock } from "bun:test"
 import { Effect } from "effect"
 import { PluginV2 } from "@opencode-ai/core/plugin"
 import { CloudflareAIGatewayPlugin } from "@opencode-ai/core/plugin/provider/cloudflare-ai-gateway"
-import { it, model, withEnv } from "./provider-helper"
+import { addPlugin, it, model, withEnv } from "./provider-helper"
 
 const aiGatewayCalls: Record<string, unknown>[] = []
 const unifiedCalls: string[] = []
@@ -78,7 +78,7 @@ describe("CloudflareAIGatewayPlugin", () => {
       () =>
         Effect.gen(function* () {
           const plugin = yield* PluginV2.Service
-          yield* plugin.add(CloudflareAIGatewayPlugin)
+          yield* addPlugin(plugin, CloudflareAIGatewayPlugin)
           const result = yield* plugin.trigger(
             "aisdk.sdk",
             {
@@ -98,7 +98,7 @@ describe("CloudflareAIGatewayPlugin", () => {
       Effect.gen(function* () {
         resetCalls()
         const plugin = yield* PluginV2.Service
-        yield* plugin.add(CloudflareAIGatewayPlugin)
+        yield* addPlugin(plugin, CloudflareAIGatewayPlugin)
 
         yield* plugin.trigger(
           "aisdk.sdk",
@@ -142,7 +142,7 @@ describe("CloudflareAIGatewayPlugin", () => {
       Effect.gen(function* () {
         resetCalls()
         const plugin = yield* PluginV2.Service
-        yield* plugin.add(CloudflareAIGatewayPlugin)
+        yield* addPlugin(plugin, CloudflareAIGatewayPlugin)
 
         yield* plugin.trigger(
           "aisdk.sdk",
@@ -171,7 +171,7 @@ describe("CloudflareAIGatewayPlugin", () => {
       Effect.gen(function* () {
         resetCalls()
         const plugin = yield* PluginV2.Service
-        yield* plugin.add(CloudflareAIGatewayPlugin)
+        yield* addPlugin(plugin, CloudflareAIGatewayPlugin)
 
         yield* plugin.trigger(
           "aisdk.sdk",
@@ -208,7 +208,7 @@ describe("CloudflareAIGatewayPlugin", () => {
         Effect.gen(function* () {
           resetCalls()
           const plugin = yield* PluginV2.Service
-          yield* plugin.add(CloudflareAIGatewayPlugin)
+          yield* addPlugin(plugin, CloudflareAIGatewayPlugin)
 
           yield* plugin.trigger(
             "aisdk.sdk",
@@ -239,7 +239,7 @@ describe("CloudflareAIGatewayPlugin", () => {
       Effect.gen(function* () {
         resetCalls()
         const plugin = yield* PluginV2.Service
-        yield* plugin.add(CloudflareAIGatewayPlugin)
+        yield* addPlugin(plugin, CloudflareAIGatewayPlugin)
 
         yield* plugin.trigger(
           "aisdk.sdk",
@@ -261,7 +261,7 @@ describe("CloudflareAIGatewayPlugin", () => {
       Effect.gen(function* () {
         resetCalls()
         const plugin = yield* PluginV2.Service
-        yield* plugin.add(CloudflareAIGatewayPlugin)
+        yield* addPlugin(plugin, CloudflareAIGatewayPlugin)
 
         const result = yield* plugin.trigger(
           "aisdk.sdk",
@@ -284,7 +284,7 @@ describe("CloudflareAIGatewayPlugin", () => {
       Effect.gen(function* () {
         resetCalls()
         const plugin = yield* PluginV2.Service
-        yield* plugin.add(CloudflareAIGatewayPlugin)
+        yield* addPlugin(plugin, CloudflareAIGatewayPlugin)
 
         const result = yield* plugin.trigger(
           "aisdk.sdk",
@@ -313,7 +313,7 @@ describe("CloudflareAIGatewayPlugin", () => {
         Effect.gen(function* () {
           resetCalls()
           const plugin = yield* PluginV2.Service
-          yield* plugin.add(CloudflareAIGatewayPlugin)
+          yield* addPlugin(plugin, CloudflareAIGatewayPlugin)
 
           const result = yield* plugin.trigger(
             "aisdk.sdk",
@@ -336,7 +336,7 @@ describe("CloudflareAIGatewayPlugin", () => {
       Effect.gen(function* () {
         resetCalls()
         const plugin = yield* PluginV2.Service
-        yield* plugin.add(CloudflareAIGatewayPlugin)
+        yield* addPlugin(plugin, CloudflareAIGatewayPlugin)
 
         const result = yield* plugin.trigger(
           "aisdk.sdk",
@@ -364,7 +364,7 @@ describe("CloudflareAIGatewayPlugin", () => {
       Effect.gen(function* () {
         resetCalls()
         const plugin = yield* PluginV2.Service
-        yield* plugin.add(CloudflareAIGatewayPlugin)
+        yield* addPlugin(plugin, CloudflareAIGatewayPlugin)
 
         const result = yield* plugin.trigger(
           "aisdk.sdk",

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

@@ -1,36 +1,11 @@
 import { describe, expect } from "bun:test"
-import { Effect, Layer } from "effect"
+import { Effect } from "effect"
-import { Credential } from "@opencode-ai/core/credential"
-import { Integration } from "@opencode-ai/core/integration"
-import { Database } from "@opencode-ai/core/database/database"
 import { Catalog } from "@opencode-ai/core/catalog"
-import { Location } from "@opencode-ai/core/location"
-import { EventV2 } from "@opencode-ai/core/event"
 import { ModelV2 } from "@opencode-ai/core/model"
 import { PluginV2 } from "@opencode-ai/core/plugin"
 import { CloudflareWorkersAIPlugin } from "@opencode-ai/core/plugin/provider/cloudflare-workers-ai"
 import { ProviderV2 } from "@opencode-ai/core/provider"
-import { AbsolutePath } from "@opencode-ai/core/schema"
+import { addPlugin, fakeSelectorSdk, it, model, required, withEnv } from "./provider-helper"
-import { location } from "../fixture/location"
-import { testEffect } from "../lib/effect"
-import { fakeSelectorSdk, it, model, npmLayer, withEnv } from "./provider-helper"
-
-const database = Database.layerFromPath(":memory:").pipe(Layer.fresh)
-const preferences = Credential.layer.pipe(Layer.provide(database))
-const accounts = Layer.merge(
-  Credential.layer.pipe(Layer.provide(database), Layer.provide(preferences), Layer.provide(EventV2.defaultLayer)),
-  preferences,
-)
-const itWithAccount = testEffect(
-  Catalog.locationLayer.pipe(
-    Layer.provideMerge(accounts),
-    Layer.provideMerge(EventV2.defaultLayer),
-    Layer.provideMerge(
-      Layer.succeed(Location.Service, Location.Service.of(location({ directory: AbsolutePath.make("test") }))),
-    ),
-    Layer.provideMerge(npmLayer),
-  ),
-)
 
 function cloudflareLanguage(sdk: unknown, modelID = "@cf/model") {
   return (sdk as { languageModel: (id: string) => { config: CloudflareConfig; provider: string } }).languageModel(
@@ -57,14 +32,13 @@ describe("CloudflareWorkersAIPlugin", () => {
       Effect.gen(function* () {
         const plugin = yield* PluginV2.Service
         const catalog = yield* Catalog.Service
-        yield* plugin.add(CloudflareWorkersAIPlugin)
+        yield* catalog.transform((catalog) =>
-        const transform = yield* catalog.transform()
-        yield* transform((catalog) =>
           catalog.provider.update(ProviderV2.ID.make("cloudflare-workers-ai"), (provider) => {
             provider.api = { type: "aisdk", package: "test-provider" }
           }),
         )
-        const provider = yield* catalog.provider.get(ProviderV2.ID.make("cloudflare-workers-ai"))
+        yield* addPlugin(plugin, CloudflareWorkersAIPlugin)
+        const provider = required(yield* catalog.provider.get(ProviderV2.ID.make("cloudflare-workers-ai")))
         const sdk = yield* plugin.trigger(
           "aisdk.sdk",
           {
@@ -89,14 +63,13 @@ describe("CloudflareWorkersAIPlugin", () => {
       Effect.gen(function* () {
         const plugin = yield* PluginV2.Service
         const catalog = yield* Catalog.Service
-        yield* plugin.add(CloudflareWorkersAIPlugin)
+        yield* catalog.transform((catalog) =>
-        const transform = yield* catalog.transform()
-        yield* transform((catalog) =>
           catalog.provider.update(ProviderV2.ID.make("cloudflare-workers-ai"), (provider) => {
             provider.api = { type: "aisdk", package: "test-provider", url: "https://proxy.example/v1" }
           }),
         )
-        expect((yield* catalog.provider.get(ProviderV2.ID.make("cloudflare-workers-ai"))).api).toEqual({
+        yield* addPlugin(plugin, CloudflareWorkersAIPlugin)
+        expect(required(yield* catalog.provider.get(ProviderV2.ID.make("cloudflare-workers-ai"))).api).toEqual({
           type: "aisdk",
           package: "test-provider",
           url: "https://proxy.example/v1",
@@ -109,7 +82,7 @@ describe("CloudflareWorkersAIPlugin", () => {
     withEnv({ CLOUDFLARE_ACCOUNT_ID: undefined, CLOUDFLARE_API_KEY: "key" }, () =>
       Effect.gen(function* () {
         const plugin = yield* PluginV2.Service
-        yield* plugin.add(CloudflareWorkersAIPlugin)
+        yield* addPlugin(plugin, CloudflareWorkersAIPlugin)
         const result = yield* plugin.trigger(
           "aisdk.sdk",
           {
@@ -126,56 +99,19 @@ describe("CloudflareWorkersAIPlugin", () => {
     ),
   )
 
-  itWithAccount.effect("falls back to account metadata when account env is absent", () =>
-    withEnv(
-      {
-        CLOUDFLARE_ACCOUNT_ID: undefined,
-        CLOUDFLARE_API_KEY: undefined,
-      },
-      () =>
-        Effect.gen(function* () {
-          const plugin = yield* PluginV2.Service
-          const credentials = yield* Credential.Service
-          const catalog = yield* Catalog.Service
-          yield* credentials.create({
-            integrationID: Integration.ID.make("cloudflare-workers-ai"),
-            value: new Credential.Key({
-              type: "key",
-              key: "account-key",
-              metadata: { accountId: "account-acct" },
-            }),
-          })
-          yield* plugin.add(CloudflareWorkersAIPlugin)
-          const transform = yield* catalog.transform()
-          yield* transform((catalog) =>
-            catalog.provider.update(ProviderV2.ID.make("cloudflare-workers-ai"), (provider) => {
-              provider.api = { type: "aisdk", package: "test-provider" }
-            }),
-          )
-          expect((yield* catalog.provider.get(ProviderV2.ID.make("cloudflare-workers-ai"))).request.body).toMatchObject(
-            {
-              apiKey: "account-key",
-              accountId: "account-acct",
-            },
-          )
-        }),
-    ),
-  )
-
   it.effect("uses env account ID over configured account ID", () =>
     withEnv({ CLOUDFLARE_ACCOUNT_ID: "env-acct" }, () =>
       Effect.gen(function* () {
         const plugin = yield* PluginV2.Service
         const catalog = yield* Catalog.Service
-        yield* plugin.add(CloudflareWorkersAIPlugin)
+        yield* catalog.transform((catalog) =>
-        const transform = yield* catalog.transform()
-        yield* transform((catalog) =>
           catalog.provider.update(ProviderV2.ID.make("cloudflare-workers-ai"), (provider) => {
             provider.api = { type: "aisdk", package: "test-provider" }
             provider.request.body.accountId = "configured-acct"
           }),
         )
-        expect((yield* catalog.provider.get(ProviderV2.ID.make("cloudflare-workers-ai"))).api).toEqual({
+        yield* addPlugin(plugin, CloudflareWorkersAIPlugin)
+        expect(required(yield* catalog.provider.get(ProviderV2.ID.make("cloudflare-workers-ai"))).api).toEqual({
           type: "aisdk",
           package: "test-provider",
           url: "https://api.cloudflare.com/client/v4/accounts/env-acct/ai/v1",
@@ -188,7 +124,7 @@ describe("CloudflareWorkersAIPlugin", () => {
     withEnv({ CLOUDFLARE_ACCOUNT_ID: "acct", CLOUDFLARE_API_KEY: "env-key" }, () =>
       Effect.gen(function* () {
         const plugin = yield* PluginV2.Service
-        yield* plugin.add(CloudflareWorkersAIPlugin)
+        yield* addPlugin(plugin, CloudflareWorkersAIPlugin)
         const result = yield* plugin.trigger(
           "aisdk.sdk",
           {
@@ -217,7 +153,7 @@ describe("CloudflareWorkersAIPlugin", () => {
     withEnv({ CLOUDFLARE_ACCOUNT_ID: "acct", CLOUDFLARE_API_KEY: "key" }, () =>
       Effect.gen(function* () {
         const plugin = yield* PluginV2.Service
-        yield* plugin.add(CloudflareWorkersAIPlugin)
+        yield* addPlugin(plugin, CloudflareWorkersAIPlugin)
         const result = yield* plugin.trigger(
           "aisdk.sdk",
           {
@@ -247,7 +183,7 @@ describe("CloudflareWorkersAIPlugin", () => {
     Effect.gen(function* () {
       const plugin = yield* PluginV2.Service
       const calls: string[] = []
-      yield* plugin.add(CloudflareWorkersAIPlugin)
+      yield* addPlugin(plugin, CloudflareWorkersAIPlugin)
       const result = yield* plugin.trigger(
         "aisdk.language",
         {
@@ -266,7 +202,7 @@ describe("CloudflareWorkersAIPlugin", () => {
     withEnv({ CLOUDFLARE_ACCOUNT_ID: "acct", CLOUDFLARE_API_KEY: "key" }, () =>
       Effect.gen(function* () {
         const plugin = yield* PluginV2.Service
-        yield* plugin.add(CloudflareWorkersAIPlugin)
+        yield* addPlugin(plugin, CloudflareWorkersAIPlugin)
         const result = yield* plugin.trigger(
           "aisdk.sdk",
           {

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

@@ -3,7 +3,7 @@ import { Effect } from "effect"
 import { ModelV2 } from "@opencode-ai/core/model"
 import { PluginV2 } from "@opencode-ai/core/plugin"
 import { CoherePlugin } from "@opencode-ai/core/plugin/provider/cohere"
-import { fakeSelectorSdk, it, model } from "./provider-helper"
+import { addPlugin, fakeSelectorSdk, it, model } from "./provider-helper"
 
 const cohereOptions: Record<string, any>[] = []
 
@@ -24,7 +24,7 @@ describe("CoherePlugin", () => {
   it.effect("creates a Cohere SDK only for @ai-sdk/cohere", () =>
     Effect.gen(function* () {
       const plugin = yield* PluginV2.Service
-      yield* plugin.add(CoherePlugin)
+      yield* addPlugin(plugin, CoherePlugin)
 
       const ignored = yield* plugin.trigger(
         "aisdk.sdk",
@@ -45,7 +45,7 @@ describe("CoherePlugin", () => {
   it.effect("uses the model provider ID as the bundled SDK name", () =>
     Effect.gen(function* () {
       const plugin = yield* PluginV2.Service
-      yield* plugin.add(CoherePlugin)
+      yield* addPlugin(plugin, CoherePlugin)
       const result = yield* plugin.trigger(
         "aisdk.sdk",
         {
@@ -70,7 +70,7 @@ describe("CoherePlugin", () => {
       const plugin = yield* PluginV2.Service
       const calls: string[] = []
       const sdk = fakeSelectorSdk(calls)
-      yield* plugin.add(CoherePlugin)
+      yield* addPlugin(plugin, CoherePlugin)
       const result = yield* plugin.trigger(
         "aisdk.language",
         { model: model("cohere", "alias", { api: { id: ModelV2.ID.make("command-r-plus") } }), sdk, options: {} },

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

@@ -5,7 +5,7 @@ import { EventV2 } from "@opencode-ai/core/event"
 import { PluginV2 } from "@opencode-ai/core/plugin"
 import { DeepInfraPlugin } from "@opencode-ai/core/plugin/provider/deepinfra"
 import { testEffect } from "../lib/effect"
-import { it, model } from "./provider-helper"
+import { addPlugin, it, model } from "./provider-helper"
 
 const itAISDK = testEffect(
   Layer.provideMerge(AISDK.layer, PluginV2.locationLayer.pipe(Layer.provide(EventV2.defaultLayer))),
@@ -36,7 +36,7 @@ describe("DeepInfraPlugin", () => {
     Effect.gen(function* () {
       resetDeepInfraMock()
       const plugin = yield* PluginV2.Service
-      yield* plugin.add(DeepInfraPlugin)
+      yield* addPlugin(plugin, DeepInfraPlugin)
       const result = yield* plugin.trigger(
         "aisdk.sdk",
         { model: model("deepinfra", "model"), package: "@ai-sdk/deepinfra", options: { name: "deepinfra" } },
@@ -50,7 +50,7 @@ describe("DeepInfraPlugin", () => {
     Effect.gen(function* () {
       resetDeepInfraMock()
       const plugin = yield* PluginV2.Service
-      yield* plugin.add(DeepInfraPlugin)
+      yield* addPlugin(plugin, DeepInfraPlugin)
       const result = yield* plugin.trigger(
         "aisdk.sdk",
         {
@@ -69,7 +69,7 @@ describe("DeepInfraPlugin", () => {
     Effect.gen(function* () {
       resetDeepInfraMock()
       const plugin = yield* PluginV2.Service
-      yield* plugin.add(DeepInfraPlugin)
+      yield* addPlugin(plugin, DeepInfraPlugin)
       const result = yield* plugin.trigger(
         "aisdk.sdk",
         {
@@ -88,7 +88,7 @@ describe("DeepInfraPlugin", () => {
     Effect.gen(function* () {
       resetDeepInfraMock()
       const plugin = yield* PluginV2.Service
-      yield* plugin.add(DeepInfraPlugin)
+      yield* addPlugin(plugin, DeepInfraPlugin)
       const packages = [
         "unmatched-package",
         "@ai-sdk/deepinfra-compatible",
@@ -119,7 +119,7 @@ describe("DeepInfraPlugin", () => {
       resetDeepInfraMock()
       const plugin = yield* PluginV2.Service
       const aisdk = yield* AISDK.Service
-      yield* plugin.add(DeepInfraPlugin)
+      yield* addPlugin(plugin, DeepInfraPlugin)
       const language = yield* aisdk.language(
         model("deepinfra", "meta-llama/Llama-3.3-70B-Instruct", {
           api: { type: "aisdk", package: "@ai-sdk/deepinfra" },

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

@@ -11,6 +11,7 @@ import { ModelV2 } from "@opencode-ai/core/model"
 import { PluginV2 } from "@opencode-ai/core/plugin"
 import { DynamicProviderPlugin } from "@opencode-ai/core/plugin/provider/dynamic"
 import { testEffect } from "../lib/effect"
+import { host } from "./host"
 import { fixtureProvider, it, model, npmLayer } from "./provider-helper"
 
 const fixtureProviderPath = fileURLToPath(fixtureProvider)
@@ -18,19 +19,24 @@ const itWithAISDK = testEffect(
   AISDK.layer.pipe(Layer.provideMerge(PluginV2.locationLayer.pipe(Layer.provide(EventV2.defaultLayer)))),
 )
 
-function npmEntrypointLayer(entrypoint: Option.Option<string>) {
+function npmEntrypointLayer(entrypoint?: string) {
   return Layer.succeed(
     Npm.Service,
     Npm.Service.of({
       add: () => Effect.succeed({ directory: "", entrypoint }),
       install: () => Effect.void,
-      which: () => Effect.succeed(Option.none<string>()),
+      which: () => Effect.succeed(undefined),
     }),
   )
 }
 
 function dynamicPlugin(layer = npmLayer) {
-  return { id: DynamicProviderPlugin.id, effect: DynamicProviderPlugin.effect.pipe(Effect.provide(layer)) }
+  return {
+    id: DynamicProviderPlugin.id,
+    effect: Effect.gen(function* () {
+      yield* DynamicProviderPlugin.effect(host({ npm: yield* Npm.Service }))
+    }).pipe(Effect.provide(layer)),
+  }
 }
 
 function tempEntrypoint(source: string) {
@@ -102,7 +108,7 @@ describe("DynamicProviderPlugin", () => {
   it.effect("loads npm packages through their resolved import entrypoint", () =>
     Effect.gen(function* () {
       const plugin = yield* PluginV2.Service
-      yield* plugin.add(dynamicPlugin(npmEntrypointLayer(Option.some(fixtureProviderPath))))
+      yield* plugin.add(dynamicPlugin(npmEntrypointLayer(fixtureProviderPath)))
       const result = yield* plugin.trigger(
         "aisdk.sdk",
         {
@@ -120,7 +126,7 @@ describe("DynamicProviderPlugin", () => {
     Effect.gen(function* () {
       const plugin = yield* PluginV2.Service
       const aisdk = yield* AISDK.Service
-      yield* plugin.add(dynamicPlugin(npmEntrypointLayer(Option.none<string>())))
+      yield* plugin.add(dynamicPlugin(npmEntrypointLayer()))
       const exit = yield* aisdk
         .language(model("missing-entrypoint", "alias", { api: { type: "aisdk", package: "fixture-provider" } }))
         .pipe(Effect.exit)
@@ -149,7 +155,7 @@ describe("DynamicProviderPlugin", () => {
       const plugin = yield* PluginV2.Service
       const aisdk = yield* AISDK.Service
       const tmp = yield* tempEntrypoint("export const notAProviderFactory = true\n")
-      yield* plugin.add(dynamicPlugin(npmEntrypointLayer(Option.some(tmp.entrypoint))))
+      yield* plugin.add(dynamicPlugin(npmEntrypointLayer(tmp.entrypoint)))
       const exit = yield* aisdk
         .language(model("missing-factory", "alias", { api: { type: "aisdk", package: "fixture-provider" } }))
         .pipe(Effect.exit)

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

@@ -2,7 +2,7 @@ import { describe, expect, mock } from "bun:test"
 import { Effect } from "effect"
 import { PluginV2 } from "@opencode-ai/core/plugin"
 import { GatewayPlugin } from "@opencode-ai/core/plugin/provider/gateway"
-import { it, model } from "./provider-helper"
+import { addPlugin, it, model } from "./provider-helper"
 
 const gatewayCalls: Record<string, unknown>[] = []
 const vercelGatewayModels = ["anthropic/claude-sonnet-4", "openai/gpt-5", "google/gemini-2.5-pro"]
@@ -27,7 +27,7 @@ describe("GatewayPlugin", () => {
     Effect.gen(function* () {
       gatewayCalls.length = 0
       const plugin = yield* PluginV2.Service
-      yield* plugin.add(GatewayPlugin)
+      yield* addPlugin(plugin, GatewayPlugin)
       const result = yield* plugin.trigger(
         "aisdk.sdk",
         { model: model("gateway", "model"), package: "@ai-sdk/gateway", options: { name: "gateway" } },
@@ -42,7 +42,7 @@ describe("GatewayPlugin", () => {
     Effect.gen(function* () {
       gatewayCalls.length = 0
       const plugin = yield* PluginV2.Service
-      yield* plugin.add(GatewayPlugin)
+      yield* addPlugin(plugin, GatewayPlugin)
 
       const result = yield* plugin.trigger(
         "aisdk.sdk",
@@ -63,7 +63,7 @@ describe("GatewayPlugin", () => {
     Effect.gen(function* () {
       gatewayCalls.length = 0
       const plugin = yield* PluginV2.Service
-      yield* plugin.add(GatewayPlugin)
+      yield* addPlugin(plugin, GatewayPlugin)
 
       for (const modelID of vercelGatewayModels) {
         const ignored = yield* plugin.trigger(