chore(core): merge dev into session subpath fix

AGENTS.md

@@ -137,7 +137,7 @@ const table = sqliteTable("session", {
 
 ## Testing
 
-- Avoid mocks as much as possible, you shouldn't be using globalThis.\* at all unless it's the only option.
+- Avoid mocks as much as possible
 - Test actual implementation, do not duplicate logic into tests
 - Tests cannot run from repo root (guard: `do-not-run-tests-from-root`); run from package dirs like `packages/opencode`.
 
@@ -152,7 +152,7 @@ const table = sqliteTable("session", {
 - Keep `SessionExecution` process-global and Session-ID based. Its local implementation owns the process-local Session coordinator and discovers placement through `SessionStore` plus `LocationServiceMap.get(session.location)` only when a drain starts; no layer should take a Session ID. V2 interruption targets the active process-local ownership chain for that Session; idle or missing interruption is a no-op.
 - Keep `SessionRunner`, model resolution, tool registry, permissions, and filesystem Location-scoped. Omitted `Location.workspaceID` means implicit-local placement; explicit workspace identity remains reserved for future placement semantics.
 - Preserve one explicit `llm.stream(request)` call per provider turn and reload projected history before durable continuation. Do not bridge through legacy `SessionPrompt.loop(...)` or delegate orchestration to an in-memory tool loop.
-- Keep local Session drains process-local until clustering is implemented. `SessionRunCoordinator` joins explicit same-Session resumes, coalesces prompt wakeups, and allows different Sessions to run concurrently. Advisory wakes drain eligible durable inbox rows only; post-crash continuation recovery requires a separate explicit design before it may retry provider work. A drain has no durable identity or transcript boundary.
-- Keep delivery vocabulary explicit. Prompts steer by default and promote at the next safe provider-turn boundary while the current drain requires continuation. An explicit `queue` input remains pending until the Session would otherwise become idle; promote one queued input at that boundary, then reevaluate continuation before promoting another. Promoting any new user input resets the selected agent's provider-turn allowance; a batch of steers resets it once.
+- Keep local Session drains process-local until clustering is implemented. `SessionRunCoordinator` joins explicit same-Session resumes, coalesces prompt wakeups, and allows different Sessions to run concurrently. Advisory wakes drain eligible durable inbox rows only; post-crash activity recovery requires a separate explicit design before it may retry provider work.
+- Keep delivery vocabulary explicit. Prompts steer by default and coalesce into the active activity at the next safe provider-turn boundary. Explicit `queue` inputs open FIFO future activities one at a time after the active activity settles.
 - Keep EventV2 replay owner claims separate from clustered Session execution ownership.
 - Keep the System Context algebra, registry, and built-ins in `src/system-context`; keep Context Source producers with their observed domains, and keep Session History selection plus Context Epoch persistence Session-owned.

CONTEXT.md

@@ -39,18 +39,6 @@ An expected temporary inability to observe a **Context Source** value; the runti
 **Safe Provider-Turn Boundary**:
 The point immediately before a provider call, after durable input promotion and any required tool settlement, where context changes may be admitted chronologically.
 
-**Admitted Prompt**:
-A durable user input accepted into the Session inbox but not yet included in **Session History**.
-
-**Prompt Promotion**:
-The durable transition that removes an **Admitted Prompt** from pending input and appends its user message to **Session History**.
-
-**Provider Turn**:
-One request to a model provider and the response projected from that request.
-
-**Session Drain**:
-One process-local execution span that promotes eligible input and runs required **Provider Turns** until no immediate continuation remains. A Session Drain has no durable identity or transcript boundary.
-
 **Model Tool Output**:
 The bounded projection of a Core-executed tool result persisted in Session history and replayed to the model. A tool may shape this projection semantically, but the Tool Registry enforces the final size limit.
 
@@ -79,11 +67,6 @@ The host-supplied environment overlay applied by the server when creating a PTY,
 - Changes from multiple **Context Sources** admitted at one safe boundary combine into one **Mid-Conversation System Message**.
 - Context changes are sampled and admitted lazily at a **Safe Provider-Turn Boundary**, never pushed asynchronously when their source changes.
 - At a **Safe Provider-Turn Boundary**, newly promoted user input or settled tool results precede any combined **Mid-Conversation System Message**.
-- An **Admitted Prompt** is replayable pending input, not yet model-visible **Session History**.
-- **Prompt Promotion** atomically consumes the pending inbox entry and appends its model-visible user message.
-- Steering prompts promote at the next **Safe Provider-Turn Boundary** while the current **Session Drain** still requires continuation. Promoting any newly admitted user input resets the selected agent's provider-turn allowance; multiple prompts promoted at one boundary reset it once.
-- A queued prompt does not promote while the current **Session Drain** requires continuation. The runner promotes one queued prompt when the Session would otherwise become idle, then reevaluates continuation before promoting another.
-- A **Session Drain** is process-local coordination rather than a durable domain entity. Durable recovery must reason from prompts, projected history, provider attempts, and tool state rather than inventing an enclosing execution identity.
 - The first provider turn renders the latest complete **Baseline System Context** and initializes its **Context Snapshot** without emitting a redundant **Mid-Conversation System Message**; unavailable initial context blocks the turn instead of persisting an incomplete baseline.
 - Initial **System Context** preparation precedes the first durable input promotion so an unavailable baseline leaves that input pending and retryable; ordinary reconciliation remains after promotion.
 - Compaction starts a new **Context Epoch** with a freshly rendered **Baseline System Context** and **Context Snapshot**; prior **Mid-Conversation System Messages** remain durable audit history but leave projected model history.

packages/console/app/src/routes/zen/util/handler.ts

@@ -196,13 +196,6 @@ export async function handler(
           Object.entries(providerInfo.headerMappings ?? {}).forEach(([k, v]) => {
             headers.set(k, headers.get(v)!)
           })
-          Object.entries(providerInfo.headerModifier ?? {}).forEach(([k, v]) => {
-            if (v === "$ip") return headers.set(k, ip)
-            if (v === "$session") return headers.set(k, sessionId)
-            if (v === "$model") return headers.set(k, model)
-            if (v === "$request") return headers.set(k, requestId)
-            headers.set(k, v)
-          })
           headers.delete("host")
           headers.delete("content-length")
           headers.delete("x-opencode-request")

packages/console/core/src/model.ts

@@ -53,7 +53,6 @@ export namespace ZenData {
     apiKey: z.union([z.string(), z.record(z.string(), z.string())]),
     format: FormatSchema.optional(),
     headerMappings: z.record(z.string(), z.string()).optional(),
-    headerModifier: z.record(z.string(), z.any()).optional(),
     payloadModifier: z.record(z.string(), z.any()).optional(),
     payloadMappings: z.record(z.string(), z.string()).optional(),
     adjustCacheUsage: z.boolean().optional(),

packages/core/src/agent.ts

@@ -108,7 +108,7 @@ export const layer = Layer.effect(
 
     return Service.of({
       transform: state.transform,
-      reload: state.reload,
+      rebuild: state.rebuild,
       get: Effect.fn("AgentV2.get")(function* (id) {
         return state.get().agents.get(id)
       }),

packages/core/src/aisdk.ts

@@ -1,27 +1,14 @@
 export * as AISDK from "./aisdk"
 
 import type { LanguageModelV3 } from "@ai-sdk/provider"
-import { Cause, Context, Effect, Layer, Schema, Scope } from "effect"
+import { Cause, Context, Effect, Layer, Schema } from "effect"
 import { ModelV2 } from "./model"
+import { EventV2 } from "./event"
+import { PluginV2 } from "./plugin"
 import { ProviderV2 } from "./provider"
-import { State } from "./state"
 
 type SDK = any
 
-export interface SDKEvent {
-  readonly model: ModelV2.Info
-  readonly package: string
-  readonly options: Record<string, any>
-  sdk?: SDK
-}
-
-export interface LanguageEvent {
-  readonly model: ModelV2.Info
-  readonly sdk: SDK
-  readonly options: Record<string, any>
-  language?: LanguageModelV3
-}
-
 function wrapSSE(res: Response, ms: number, ctl: AbortController) {
   if (typeof ms !== "number" || ms <= 0) return res
   if (!res.body) return res
@@ -130,70 +117,19 @@ function initError(providerID: ProviderV2.ID) {
 }
 
 export interface Interface {
-  readonly hook: {
-    readonly sdk: (
-      callback: (event: SDKEvent) => Effect.Effect<void> | void,
-    ) => Effect.Effect<State.Registration, never, Scope.Scope>
-    readonly language: (
-      callback: (event: LanguageEvent) => Effect.Effect<void> | void,
-    ) => Effect.Effect<State.Registration, never, Scope.Scope>
-  }
-  readonly runSDK: (event: SDKEvent) => Effect.Effect<SDKEvent>
-  readonly runLanguage: (event: LanguageEvent) => Effect.Effect<LanguageEvent>
   readonly language: (model: ModelV2.Info) => Effect.Effect<LanguageModelV3, InitError>
 }
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/v2/AISDK") {}
 
-export const locationLayer = Layer.effect(
+export const layer = Layer.effect(
   Service,
   Effect.gen(function* () {
-    let sdkHooks: ((event: SDKEvent) => Effect.Effect<void> | void)[] = []
-    let languageHooks: ((event: LanguageEvent) => Effect.Effect<void> | void)[] = []
+    const plugin = yield* PluginV2.Service
     const languages = new Map<string, LanguageModelV3>()
     const sdks = new Map<string, SDK>()
 
-    const register = <Event>(
-      hooks: () => ((event: Event) => Effect.Effect<void> | void)[],
-      update: (hooks: ((event: Event) => Effect.Effect<void> | void)[]) => void,
-    ) =>
-      Effect.fn("AISDK.hook")(function* (callback: (event: Event) => Effect.Effect<void> | void) {
-        const scope = yield* Scope.Scope
-        let active = true
-        update([...hooks(), callback])
-        const dispose = Effect.sync(() => {
-          if (!active) return
-          active = false
-          update(hooks().filter((item) => item !== callback))
-        })
-        yield* Scope.addFinalizer(scope, dispose)
-        return { dispose }
-      })
-
-    const run = Effect.fnUntraced(function* <Event>(
-      hooks: readonly ((event: Event) => Effect.Effect<void> | void)[],
-      event: Event,
-    ) {
-      for (const hook of hooks) {
-        const result = hook(event)
-        if (Effect.isEffect(result)) yield* result
-      }
-      return event
-    })
-
-    const service = Service.of({
-      hook: {
-        sdk: register(
-          () => sdkHooks,
-          (next) => (sdkHooks = next),
-        ),
-        language: register(
-          () => languageHooks,
-          (next) => (languageHooks = next),
-        ),
-      },
-      runSDK: (event) => run(sdkHooks, event),
-      runLanguage: (event) => run(languageHooks, event),
+    return Service.of({
       language: Effect.fn("AISDK.language")(function* (model) {
         const key = `${model.providerID}/${model.id}/${model.request.variant ?? "default"}`
         const existing = languages.get(key)
@@ -212,14 +148,26 @@ export const locationLayer = Layer.effect(
         })
         const sdk =
           sdks.get(sdkKey) ??
-          (yield* service.runSDK({ model, package: model.api.package, options }).pipe(initError(model.providerID))).sdk
+          (yield* plugin
+            .trigger("aisdk.sdk", { model, package: model.api.package, options }, {})
+            .pipe(initError(model.providerID))).sdk
         if (!sdk)
           return yield* new InitError({
             providerID: model.providerID,
             cause: new Error("No AISDK provider plugin returned an SDK"),
           })
         sdks.set(sdkKey, sdk)
-        const result = yield* service.runLanguage({ model, sdk, options }).pipe(initError(model.providerID))
+        const result = yield* plugin
+          .trigger(
+            "aisdk.language",
+            {
+              model,
+              sdk,
+              options,
+            },
+            {},
+          )
+          .pipe(initError(model.providerID))
         const language = yield* Effect.sync(() => result.language ?? sdk.languageModel(model.api.id)).pipe(
           initError(model.providerID),
         )
@@ -227,8 +175,7 @@ export const locationLayer = Layer.effect(
         return language
       }),
     })
-    return service
   }),
 )
 
-export const defaultLayer = locationLayer
+export const defaultLayer = layer.pipe(Layer.provide(PluginV2.locationLayer.pipe(Layer.provide(EventV2.defaultLayer))))

packages/core/src/catalog.ts

@@ -170,7 +170,7 @@ export const layer = Layer.effect(
     })
     const result: Interface = {
       transform: state.transform,
-      reload: state.reload,
+      rebuild: state.rebuild,
 
       provider: {
         get: Effect.fn("CatalogV2.provider.get")(function* (providerID) {

packages/core/src/command.ts

@@ -52,7 +52,7 @@ export const layer = Layer.effect(
     })
 
     return Service.of({
-      reload: state.reload,
+      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,6 +1,6 @@
 export * as ConfigAgentPlugin from "./agent"
 
-import { define } from "../../plugin/internal"
+import { define } from "@opencode-ai/plugin/v2/effect"
 import path from "path"
 import { Effect, Option, Schema } from "effect"
 import { AgentV2 } from "../../agent"

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

@@ -1,6 +1,6 @@
 export * as ConfigCommandPlugin from "./command"
 
-import { define } from "../../plugin/internal"
+import { define } from "@opencode-ai/plugin/v2/effect"
 import path from "path"
 import { Effect, Option, Schema } from "effect"
 import { CommandV2 } from "../../command"

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

@@ -1,91 +0,0 @@
-export * as ConfigExternalPlugin from "./external"
-
-import type { Plugin as EffectPlugin } from "@opencode-ai/plugin/v2/effect"
-import type { Plugin as PromisePlugin } from "@opencode-ai/plugin/v2/promise"
-import { Effect, Schema } from "effect"
-import path from "path"
-import { fileURLToPath, pathToFileURL } from "url"
-import { Config } from "../../config"
-import { FSUtil } from "../../fs-util"
-import { Location } from "../../location"
-import { Npm } from "../../npm"
-import { define } from "../../plugin/internal"
-import { PluginPromise } from "../../plugin/promise"
-
-const PluginModule = Schema.Struct({
-  default: Schema.Union([
-    Schema.Struct({
-      id: Schema.String,
-      effect: Schema.declare<EffectPlugin["effect"]>(
-        (input): input is EffectPlugin["effect"] => typeof input === "function",
-      ),
-    }),
-    Schema.Struct({
-      id: Schema.String,
-      setup: Schema.declare<PromisePlugin["setup"]>(
-        (input): input is PromisePlugin["setup"] => typeof input === "function",
-      ),
-    }),
-  ]),
-})
-
-export const Plugin = define({
-  id: "config-plugin",
-  effect: Effect.fn(function* (ctx) {
-    const config = yield* Config.Service
-    const fs = yield* FSUtil.Service
-    const location = yield* Location.Service
-    const npm = yield* Npm.Service
-    yield* Effect.gen(function* () {
-      const configured: { package: string; options?: Record<string, any> }[] = []
-
-      for (const entry of yield* config.entries()) {
-        if (entry.type === "document") {
-          const directory = entry.path ? path.dirname(entry.path) : location.directory
-          for (const item of entry.info.plugins ?? []) {
-            const ref = typeof item === "string" ? { package: item } : item
-            const packageName = (() => {
-              if (ref.package.startsWith("file://")) return fileURLToPath(ref.package)
-              if (ref.package.startsWith("./") || ref.package.startsWith("../")) {
-                return path.resolve(directory, ref.package)
-              }
-              return ref.package
-            })()
-            configured.push({ package: packageName, options: ref.options })
-          }
-        }
-
-        if (entry.type === "directory") {
-          const files = yield* fs
-            .glob("{plugin,plugins}/*.{ts,js}", {
-              cwd: entry.path,
-              absolute: true,
-              include: "file",
-              dot: true,
-              symlink: true,
-            })
-            .pipe(Effect.orElseSucceed(() => []))
-          files.sort()
-          for (const file of files) configured.push({ package: file })
-        }
-      }
-
-      for (const ref of configured) {
-        yield* Effect.gen(function* () {
-          const entrypoint = path.isAbsolute(ref.package)
-            ? pathToFileURL(ref.package).href
-            : (yield* npm.add(ref.package)).entrypoint
-          if (!entrypoint) return
-
-          const mod = yield* Effect.promise(() => import(entrypoint))
-          const value = (yield* Schema.decodeUnknownEffect(PluginModule)(mod)).default
-          const plugin = "effect" in value ? value : PluginPromise.fromPromise(value)
-          yield* ctx.plugin.add({
-            id: plugin.id,
-            effect: (host) => plugin.effect({ ...host, options: ref.options ?? {} }),
-          })
-        }).pipe(Effect.ignoreCause)
-      }
-    }).pipe(Effect.forkScoped({ startImmediately: true }))
-  }),
-})

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

@@ -1,6 +1,6 @@
 export * as ConfigProviderPlugin from "./provider"
 
-import { define } from "../../plugin/internal"
+import { define } from "@opencode-ai/plugin/v2/effect"
 import { Effect } from "effect"
 import { Config } from "../../config"
 import { ModelV2 } from "../../model"

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

@@ -1,28 +1,24 @@
 export * as ConfigReferencePlugin from "./reference"
 
-import { define } from "../../plugin/internal"
+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 { Reference } from "../../reference"
 import { AbsolutePath } from "../../schema"
-import { Global } from "../../global"
-import { Location } from "../../location"
 
 export const Plugin = define({
   id: "core/config-reference",
   effect: Effect.fn(function* (ctx) {
     const config = yield* Config.Service
-    const location = yield* Location.Service
-    const global = yield* Global.Service
     yield* ctx.reference.transform(
       Effect.fn(function* (draft) {
         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 = define({
                 ? 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,

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

@@ -1,20 +1,16 @@
 export * as ConfigSkillPlugin from "./skill"
 
-import { define } from "../../plugin/internal"
+import { define } from "@opencode-ai/plugin/v2/effect"
 import path from "path"
 import { Effect } from "effect"
 import { Config } from "../../config"
 import { AbsolutePath } from "../../schema"
 import { SkillV2 } from "../../skill"
-import { Global } from "../../global"
-import { Location } from "../../location"
 
 export const Plugin = define({
   id: "config-skill",
   effect: Effect.fn(function* (ctx) {
     const config = yield* Config.Service
-    const global = yield* Global.Service
-    const location = yield* Location.Service
     yield* ctx.skill.transform(
       Effect.fn(function* (draft) {
         const entries = yield* config.entries()
@@ -33,11 +29,13 @@ export const Plugin = define({
             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
           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/database/migration.gen.ts

@@ -38,7 +38,5 @@ export const migrations = (
     import("./migration/20260611192811_lush_chimera"),
     import("./migration/20260612174303_project_dir_strategy"),
     import("./migration/20260622142730_simplify_session_context_epoch"),
-    import("./migration/20260622170816_reset_v2_session_state"),
-    import("./migration/20260622202450_simplify_session_input"),
   ])
 ).map((module) => module.default) satisfies DatabaseMigration.Migration[]

packages/core/src/database/migration/20260622170816_reset_v2_session_state.ts

@@ -1,17 +0,0 @@
-import { Effect } from "effect"
-import type { DatabaseMigration } from "../migration"
-
-export default {
-  id: "20260622170816_reset_v2_session_state",
-  up(tx) {
-    return Effect.gen(function* () {
-      yield* tx.run(`DELETE FROM \`session_context_epoch\`;`)
-      yield* tx.run(`DELETE FROM \`session_input\`;`)
-      yield* tx.run(`DELETE FROM \`session_message\`;`)
-      yield* tx.run(`DELETE FROM \`event\`;`)
-      yield* tx.run(`DELETE FROM \`event_sequence\`;`)
-      yield* tx.run(`UPDATE \`session\` SET \`workspace_id\` = NULL WHERE \`workspace_id\` IS NOT NULL;`)
-      yield* tx.run(`DELETE FROM \`workspace\`;`)
-    })
-  },
-} satisfies DatabaseMigration.Migration

packages/core/src/database/migration/20260622202450_simplify_session_input.ts

@@ -1,17 +0,0 @@
-import { Effect } from "effect"
-import type { DatabaseMigration } from "../migration"
-
-export default {
-  id: "20260622202450_simplify_session_input",
-  up(tx) {
-    return Effect.gen(function* () {
-      yield* tx.run(`DELETE FROM \`session_context_epoch\`;`)
-      yield* tx.run(`DELETE FROM \`session_input\`;`)
-      yield* tx.run(`DELETE FROM \`session_message\`;`)
-      yield* tx.run(`DELETE FROM \`event\`;`)
-      yield* tx.run(`DELETE FROM \`event_sequence\`;`)
-      yield* tx.run(`UPDATE \`session\` SET \`workspace_id\` = NULL WHERE \`workspace_id\` IS NOT NULL;`)
-      yield* tx.run(`DELETE FROM \`workspace\`;`)
-    })
-  },
-} satisfies DatabaseMigration.Migration

packages/core/src/event.ts

@@ -46,19 +46,6 @@ export type Payload<D extends Definition = Definition> = {
 export type Subscriber<D extends Definition = Definition> = (event: Payload<D>) => Effect.Effect<void>
 export type Unsubscribe = Effect.Effect<void>
 
-export const latestSequence = Effect.fn("EventV2.latestSequence")(function* (
-  db: Database.Interface["db"],
-  aggregateID: string,
-) {
-  const row = yield* db
-    .select({ seq: EventSequenceTable.seq })
-    .from(EventSequenceTable)
-    .where(eq(EventSequenceTable.aggregate_id, aggregateID))
-    .get()
-    .pipe(Effect.orDie)
-  return row?.seq ?? -1
-})
-
 export type SerializedEvent = {
   readonly id: ID
   readonly type: string

packages/core/src/integration.ts

@@ -432,7 +432,7 @@ export const locationLayer = Layer.effect(
 
     return Service.of({
       transform: state.transform,
-      reload: state.reload,
+      rebuild: state.rebuild,
       get: Effect.fn("Integration.get")(function* (id) {
         const entry = state.get().integrations.get(id)
         if (!entry) return undefined

packages/core/src/location-layer.ts

@@ -7,7 +7,7 @@ import { Catalog } from "./catalog"
 import { Integration } from "./integration"
 import { CommandV2 } from "./command"
 import { AgentV2 } from "./agent"
-import { PluginInternal } from "./plugin/internal"
+import { PluginBoot } from "./plugin/boot"
 import { Project } from "./project"
 import { ProjectCopy } from "./project/copy"
 import { ProjectDirectories } from "./project/directories"
@@ -65,7 +65,7 @@ export class LocationServiceMap extends LayerMap.Service<LocationServiceMap>()("
       Integration.locationLayer,
       CommandV2.locationLayer,
       AgentV2.locationLayer,
-      PluginInternal.locationLayer,
+      PluginBoot.locationLayer,
       ProjectCopy.locationLayer,
       FileSystem.locationLayer,
       Watcher.locationLayer,

packages/core/src/plugin.ts

@@ -1,17 +1,12 @@
 export * as PluginV2 from "./plugin"
 
+import { createDraft, finishDraft, type Draft } from "immer"
+import type { LanguageModelV3 } from "@ai-sdk/provider"
 import { Context, Effect, Exit, Layer, Schema, Scope } from "effect"
-import type { Plugin } from "@opencode-ai/plugin/v2/effect"
-import { AgentV2 } from "./agent"
-import { AISDK } from "./aisdk"
-import { Catalog } from "./catalog"
-import { CommandV2 } from "./command"
+import type { ModelV2 } from "./model"
+import type { Catalog } from "./catalog"
 import { EventV2 } from "./event"
-import { Integration } from "./integration"
 import { KeyedMutex } from "./effect/keyed-mutex"
-import { PluginHost } from "./plugin/host"
-import { Reference } from "./reference"
-import { SkillV2 } from "./skill"
 import { State } from "./state"
 
 export const ID = Schema.String.pipe(Schema.brand("Plugin.ID"))
@@ -26,9 +21,69 @@ export const Event = {
   }),
 }
 
+type HookSpec = {
+  "catalog.transform": {
+    input: Catalog.Draft
+    output: {}
+  }
+  "aisdk.language": {
+    input: {
+      model: ModelV2.Info
+      sdk: any
+      options: Record<string, any>
+    }
+    output: {
+      language?: LanguageModelV3
+    }
+  }
+  "aisdk.sdk": {
+    input: {
+      model: ModelV2.Info
+      package: string
+      options: Record<string, any>
+    }
+    output: {
+      sdk?: any
+    }
+  }
+}
+
+export type Hooks = {
+  [Name in keyof HookSpec]: Readonly<HookSpec[Name]["input"]> & {
+    -readonly [Field in keyof HookSpec[Name]["output"]]: HookSpec[Name]["output"][Field] extends object
+      ? Draft<HookSpec[Name]["output"][Field]>
+      : HookSpec[Name]["output"][Field]
+  }
+}
+
+export type HookFunctions = {
+  [key in keyof Hooks]?: (input: Hooks[key]) => Effect.Effect<void>
+}
+
+export type HookInput<Name extends keyof Hooks> = HookSpec[Name]["input"]
+export type HookOutput<Name extends keyof Hooks> = HookSpec[Name]["output"]
+
 export interface Interface {
-  readonly add: (id: ID, effect: Plugin["effect"]) => Effect.Effect<void>
+  readonly add: (input: {
+    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,
+    input: HookInput<Name>,
+    output: HookOutput<Name>,
+  ) => Effect.Effect<HookInput<Name> & HookOutput<Name>>
+  readonly trigger: <Name extends keyof Hooks>(
+    name: Name,
+    input: HookInput<Name>,
+    output: HookOutput<Name>,
+  ) => Effect.Effect<HookInput<Name> & HookOutput<Name>>
 }
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/v2/Plugin") {}
@@ -36,77 +91,127 @@ export class Service extends Context.Service<Service, Interface>()("@opencode/v2
 export const layer = Layer.effect(
   Service,
   Effect.gen(function* () {
+    let hooks: {
+      id: ID
+      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 locks = KeyedMutex.makeUnsafe<ID>()
     const scope = yield* Scope.make()
-    const active = new Map<ID, Scope.Closeable>()
-    const loading = new Set<ID>()
-    let host: Parameters<Plugin["effect"]>[0]
-
-    const add = Effect.fn("Plugin.add")(function* (id: ID, effect: Plugin["effect"]) {
-      if (loading.has(id)) return yield* Effect.die(`Plugin load cycle detected for ${id}`)
-
-      yield* locks.withLock(id)(
-        Effect.sync(() => loading.add(id)).pipe(
-          Effect.andThen(
-            State.batch(
-              Effect.gen(function* () {
-                const existing = active.get(id)
-                active.delete(id)
-                if (existing) yield* Scope.close(existing, Exit.void).pipe(Effect.ignore)
-
-                const child = yield* Scope.fork(scope)
-                yield* effect(host).pipe(
-                  Scope.provide(child),
-                  Effect.withSpan("Plugin.load", { attributes: { "plugin.id": id } }),
-                  Effect.onExit((exit) => (Exit.isFailure(exit) ? Scope.close(child, exit) : Effect.void)),
-                )
-                active.set(id, child)
-                yield* events.publish(Event.Added, { id })
-              }),
-            ),
-          ),
-          Effect.ensuring(Effect.sync(() => loading.delete(id))),
-        ),
-      )
-    })
-
-    const remove = Effect.fn("Plugin.remove")(function* (id: ID) {
-      if (loading.has(id)) return yield* Effect.die(`Cannot remove plugin ${id} while it is loading`)
-
-      yield* locks.withLock(id)(
-        State.batch(
-          Effect.gen(function* () {
-            const current = active.get(id)
-            active.delete(id)
-            if (current) yield* Scope.close(current, Exit.void).pipe(Effect.ignore)
-          }),
-        ),
-      )
-    })
 
+    // One registry-owned scope lets shutdown remove every plugin transform in one batch.
     yield* Effect.addFinalizer((exit) =>
       Effect.gen(function* () {
-        active.clear()
+        hooks = []
         yield* State.batch(Scope.close(scope, exit))
       }),
     )
 
-    const service = Service.of({
-      add,
-      remove,
+    const svc = Service.of({
+      add: Effect.fn("Plugin.add")(function* (input) {
+        const id = ID.make(input.id)
+        yield* locks.withLock(id)(
+          Effect.gen(function* () {
+            const existing = hooks.find((item) => item.id === id)
+            if (existing) yield* State.batch(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": id,
+                },
+              }),
+              Effect.onExit((exit) => (Exit.isFailure(exit) ? Scope.close(childScope, exit) : Effect.void)),
+            )
+            const next = {
+              id,
+              hooks: result ?? {},
+              scope: childScope,
+            }
+            hooks = existing ? hooks.with(hooks.indexOf(existing), next) : [...hooks, next]
+            yield* events.publish(Event.Added, { id })
+          }),
+        )
+      }),
+      trigger: Effect.fn("Plugin.trigger")(function* (name, input, output) {
+        return yield* svc.triggerFor(ID.make("*"), name, input, output)
+      }),
+      triggerFor: Effect.fn("Plugin.triggerFor")(function* (id, name, input, output) {
+        const draftEntries = new Map<string, ReturnType<typeof createDraft>>()
+        const event = {
+          ...input,
+          ...output,
+        } as Record<string, unknown>
+
+        for (const [field, value] of Object.entries(output)) {
+          if (value && typeof value === "object") {
+            draftEntries.set(field, createDraft(value))
+            event[field] = draftEntries.get(field)
+          }
+        }
+
+        for (const item of hooks) {
+          if (id !== ID.make("*") && item.id !== id) continue
+          const match = item.hooks[name]
+          if (!match) continue
+          yield* match(event as any).pipe(
+            Effect.withSpan(`Plugin.hook.${name}`, {
+              attributes: {
+                plugin: item.id,
+                hook: name,
+              },
+            }),
+          )
+        }
+
+        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)
+        }
+
+        return event as any
+      }),
+      remove: Effect.fn("Plugin.remove")(function* (id) {
+        yield* locks.withLock(id)(
+          Effect.gen(function* () {
+            const existing = hooks.find((item) => item.id === id)
+            hooks = hooks.filter((item) => item.id !== id)
+            if (existing) yield* State.batch(Scope.close(existing.scope, Exit.void)).pipe(Effect.ignore)
+          }),
+        )
+      }),
+      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 }
+      }),
     })
-    host = yield* PluginHost.make(service)
-    return service
+    return svc
   }),
 )
 
-export const locationLayer = layer.pipe(
-  Layer.provideMerge(AgentV2.locationLayer),
-  Layer.provideMerge(AISDK.locationLayer),
-  Layer.provideMerge(Catalog.locationLayer),
-  Layer.provideMerge(CommandV2.locationLayer),
-  Layer.provideMerge(Integration.locationLayer),
-  Layer.provideMerge(Reference.locationLayer),
-  Layer.provideMerge(SkillV2.locationLayer),
-)
+export const locationLayer = layer
+
+// opencode
+// sdcok

packages/core/src/plugin/agent.ts

@@ -1,11 +1,10 @@
 export * as AgentPlugin from "./agent"
 
 import path from "path"
-import { define } from "./internal"
+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"
 
 const TRUNCATION_GLOB = path.join(Global.Path.data, "tool-output", "*")
@@ -100,8 +99,7 @@ Rules:
 export const Plugin = define({
   id: "agent",
   effect: Effect.fn(function* (ctx) {
-    const location = yield* Location.Service
-    const worktree = location.directory
+    const worktree = ctx.location.directory
     const whitelistedDirs = [TRUNCATION_GLOB, path.join(Global.Path.tmp, "*")]
     const readonlyExternalDirectory: PermissionV2.Ruleset = [
       { action: "external_directory", resource: "*", effect: "ask" },

packages/core/src/plugin/boot.ts

@@ -0,0 +1,137 @@
+export * as PluginBoot from "./boot"
+
+import type { Plugin as PublicPlugin } from "@opencode-ai/plugin/v2/effect"
+import { Context, Deferred, Effect, Layer } from "effect"
+import { Integration } from "../integration"
+import { AgentV2 } from "../agent"
+import { Catalog } from "../catalog"
+import { CommandV2 } from "../command"
+import { Config } from "../config"
+import { ConfigAgentPlugin } from "../config/plugin/agent"
+import { ConfigCommandPlugin } from "../config/plugin/command"
+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"
+import { Npm } from "../npm"
+import { PluginV2 } from "../plugin"
+import { AgentPlugin } from "./agent"
+import { CommandPlugin } from "./command"
+import { SkillPlugin } from "./skill"
+import { ConfigProviderPlugin } from "../config/plugin/provider"
+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 InternalPlugin = PublicPlugin<any>
+
+export interface Interface {
+  readonly add: (plugin: PublicPlugin<any>) => Effect.Effect<void>
+  readonly wait: () => Effect.Effect<void>
+}
+
+export class Service extends Context.Service<Service, Interface>()("@opencode/v2/PluginBoot") {}
+
+export const layer = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    const catalog = yield* Catalog.Service
+    const commands = yield* CommandV2.Service
+    const plugin = yield* PluginV2.Service
+    const integration = yield* Integration.Service
+    const agents = yield* AgentV2.Service
+    const config = yield* Config.Service
+    const location = yield* Location.Service
+    const modelsDev = yield* ModelsDev.Service
+    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 reference = yield* Reference.Service
+    const host = yield* PluginHost.make()
+    const done = yield* Deferred.make<void>()
+
+    const add = Effect.fn("PluginBoot.add")(function* (input: InternalPlugin) {
+      yield* plugin.add({
+        id: input.id,
+        effect: input
+          .effect(host)
+          .pipe(
+            Effect.provideService(Catalog.Service, catalog),
+            Effect.provideService(CommandV2.Service, commands),
+            Effect.provideService(Integration.Service, integration),
+            Effect.provideService(AgentV2.Service, agents),
+            Effect.provideService(Config.Service, config),
+            Effect.provideService(Location.Service, location),
+            Effect.provideService(ModelsDev.Service, modelsDev),
+            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, reference),
+          ),
+      })
+    })
+
+    const boot = Effect.gen(function* () {
+      yield* State.batch(
+        Effect.gen(function* () {
+          yield* add(AgentPlugin.Plugin)
+          yield* add(CommandPlugin.Plugin)
+          yield* add(SkillPlugin.Plugin)
+          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(
+      Effect.exit,
+      Effect.flatMap((exit) => Deferred.done(done, exit)),
+      Effect.forkScoped,
+    )
+
+    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),
+  Layer.provideMerge(Config.locationLayer),
+  Layer.provideMerge(AgentV2.locationLayer),
+  Layer.provideMerge(SkillV2.locationLayer),
+  Layer.provideMerge(Reference.locationLayer),
+  Layer.provideMerge(FileSystem.locationLayer),
+)

packages/core/src/plugin/command.ts

@@ -1,22 +1,20 @@
 export * as CommandPlugin from "./command"
 
-import { define } from "./internal"
+import { define } from "@opencode-ai/plugin/v2/effect"
 import { Effect } from "effect"
-import { Location } from "../location"
 import PROMPT_INITIALIZE from "./command/initialize.txt"
 import PROMPT_REVIEW from "./command/review.txt"
 
 export const Plugin = define({
   id: "command",
   effect: Effect.fn(function* (ctx) {
-    const location = yield* Location.Service
     yield* ctx.command.transform((draft) => {
       draft.update("init", (command) => {
-        command.template = PROMPT_INITIALIZE.replace("${path}", location.project.directory)
+        command.template = PROMPT_INITIALIZE.replace("${path}", ctx.location.project.directory)
         command.description = "guided AGENTS.md setup"
       })
       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

@@ -1,31 +1,58 @@
 export * as PluginHost from "./host"
 
-import type { PluginContext as Interface } from "@opencode-ai/plugin/v2/effect"
-import { Effect, Schema } from "effect"
+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 { AISDK } from "../aisdk"
 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"
 
-export const make = Effect.fn("PluginHost.make")(function* (plugin: PluginV2.Interface) {
+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 aisdk = yield* AISDK.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 {
-    options: {},
     agent: {
-      reload: agents.reload,
+      get: (id) => agents.get(AgentV2.ID.make(id)),
+      default: agents.default,
+      list: agents.all,
+      rebuild: agents.rebuild,
       transform: (callback) =>
         agents.transform((draft) =>
           callback({
@@ -38,35 +65,51 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: PluginV2.Int
         ),
     },
     aisdk: {
-      sdk: (callback) =>
-        aisdk.hook.sdk((event) => {
-          const output = {
-            model: event.model,
-            package: event.package,
-            options: event.options,
-            sdk: event.sdk,
-          }
-          const result = callback(output)
-          return Effect.suspend(() => (Effect.isEffect(result) ? result : Effect.void)).pipe(
-            Effect.tap(() => Effect.sync(() => (event.sdk = output.sdk))),
-          )
-        }),
-      language: (callback) =>
-        aisdk.hook.language((event) => {
+      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 = callback(output)
+          const result = run(output)
           return Effect.suspend(() => (Effect.isEffect(result) ? result : Effect.void)).pipe(
             Effect.tap(() => Effect.sync(() => (event.language = output.language))),
           )
-        }),
+        })
+      },
     },
     catalog: {
-      reload: catalog.reload,
+      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({
@@ -92,11 +135,41 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: PluginV2.Int
         ),
     },
     command: {
-      reload: commands.reload,
+      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: {
-      reload: integration.reload,
+      get: (id) => integration.get(Integration.ID.make(id)),
+      list: integration.list,
+      rebuild: integration.rebuild,
       transform: (callback) =>
         integration.transform((draft) =>
           callback({
@@ -125,12 +198,19 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: PluginV2.Int
           }),
         ),
     },
-    plugin: {
-      add: (input) => plugin.add(PluginV2.ID.make(input.id), input.effect),
-      remove: (id) => plugin.remove(PluginV2.ID.make(id)),
+    location,
+    npm,
+    path: {
+      home: global.home,
+      data: global.data,
+      cache: global.cache,
+      config: global.config,
+      state: global.state,
+      temp: global.tmp,
     },
     reference: {
-      reload: reference.reload,
+      list: reference.list,
+      rebuild: reference.rebuild,
       transform: (callback) =>
         reference.transform((draft) =>
           callback({
@@ -141,7 +221,9 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: PluginV2.Int
         ),
     },
     skill: {
-      reload: skill.reload,
+      sources: skill.sources,
+      list: skill.list,
+      rebuild: skill.rebuild,
       transform: (callback) =>
         skill.transform((draft) =>
           callback({

packages/core/src/plugin/internal.ts

@@ -1,118 +0,0 @@
-export * as PluginInternal from "./internal"
-
-import type { PluginContext } from "@opencode-ai/plugin/v2/effect"
-import { Effect, Layer, Scope } from "effect"
-import { AgentV2 } from "../agent"
-import { Catalog } from "../catalog"
-import { CommandV2 } from "../command"
-import { Config } from "../config"
-import { ConfigAgentPlugin } from "../config/plugin/agent"
-import { ConfigCommandPlugin } from "../config/plugin/command"
-import { ConfigExternalPlugin } from "../config/plugin/external"
-import { ConfigProviderPlugin } from "../config/plugin/provider"
-import { ConfigReferencePlugin } from "../config/plugin/reference"
-import { ConfigSkillPlugin } from "../config/plugin/skill"
-import { EventV2 } from "../event"
-import { FileSystem } from "../filesystem"
-import { FSUtil } from "../fs-util"
-import { Global } from "../global"
-import { Integration } from "../integration"
-import { Location } from "../location"
-import { ModelsDev } from "../models-dev"
-import { Npm } from "../npm"
-import { PluginV2 } from "../plugin"
-import { Reference } from "../reference"
-import { SkillV2 } from "../skill"
-import { AgentPlugin } from "./agent"
-import { CommandPlugin } from "./command"
-import { ModelsDevPlugin } from "./models-dev"
-import { ProviderPlugins } from "./provider"
-import { SkillPlugin } from "./skill"
-
-export type Requirements =
-  | AgentV2.Service
-  | Catalog.Service
-  | CommandV2.Service
-  | Config.Service
-  | EventV2.Service
-  | FileSystem.Service
-  | FSUtil.Service
-  | Global.Service
-  | Integration.Service
-  | Location.Service
-  | ModelsDev.Service
-  | Npm.Service
-  | Reference.Service
-  | SkillV2.Service
-
-export interface Plugin<R = never> {
-  readonly id: string
-  readonly effect: (context: PluginContext) => Effect.Effect<void, never, R | Scope.Scope>
-}
-
-export function define<R>(plugin: Plugin<R>) {
-  return plugin
-}
-
-export const locationLayer = Layer.effectDiscard(
-  Effect.gen(function* () {
-    const catalog = yield* Catalog.Service
-    const commands = yield* CommandV2.Service
-    const plugin = yield* PluginV2.Service
-    const integration = yield* Integration.Service
-    const agents = yield* AgentV2.Service
-    const config = yield* Config.Service
-    const location = yield* Location.Service
-    const modelsDev = yield* ModelsDev.Service
-    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 reference = yield* Reference.Service
-    const add = <R>(input: Plugin<R>) => {
-      const loaded = {
-        id: input.id,
-        effect: (context: PluginContext) =>
-          input
-            .effect(context)
-            .pipe(
-              Effect.provideService(Catalog.Service, catalog),
-              Effect.provideService(CommandV2.Service, commands),
-              Effect.provideService(Integration.Service, integration),
-              Effect.provideService(AgentV2.Service, agents),
-              Effect.provideService(Config.Service, config),
-              Effect.provideService(Location.Service, location),
-              Effect.provideService(ModelsDev.Service, modelsDev),
-              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, reference),
-            ),
-      }
-      return plugin.add(PluginV2.ID.make(loaded.id), loaded.effect)
-    }
-
-    yield* Effect.gen(function* () {
-      yield* add(AgentPlugin.Plugin)
-      yield* add(CommandPlugin.Plugin)
-      yield* add(SkillPlugin.Plugin)
-      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)
-      yield* add(ConfigExternalPlugin.Plugin)
-    }).pipe(Effect.withSpan("PluginInternal.boot"), Effect.forkScoped({ startImmediately: true }))
-  }),
-).pipe(
-  Layer.provideMerge(PluginV2.locationLayer),
-  Layer.provideMerge(Config.locationLayer),
-  Layer.provideMerge(FileSystem.locationLayer),
-)

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

@@ -1,6 +1,5 @@
-import { define } from "./internal"
+import { define } from "@opencode-ai/plugin/v2/effect"
 import { Effect, Stream } from "effect"
-import { EventV2 } from "../event"
 import { ModelV2 } from "../model"
 import { ModelRequest } from "../model-request"
 import { ModelsDev } from "../models-dev"
@@ -53,7 +52,6 @@ export const ModelsDevPlugin = define({
   id: "models-dev",
   effect: Effect.fn(function* (ctx) {
     const modelsDev = yield* ModelsDev.Service
-    const events = yield* EventV2.Service
     yield* ctx.integration.transform(
       Effect.fn(function* (integrations) {
         const data = yield* modelsDev.get()
@@ -130,8 +128,8 @@ export const ModelsDevPlugin = define({
         }
       }),
     )
-    yield* events.subscribe(ModelsDev.Event.Refreshed).pipe(
-      Stream.runForEach(() => ctx.integration.reload().pipe(Effect.andThen(ctx.catalog.reload()))),
+    yield* ctx.event.subscribe("models-dev.refreshed").pipe(
+      Stream.runForEach(() => ctx.integration.rebuild().pipe(Effect.andThen(ctx.catalog.rebuild()))),
       Effect.forkScoped({ startImmediately: true }),
     )
   }),

packages/core/src/plugin/promise.ts

@@ -1,89 +0,0 @@
-export * as PluginPromise from "./promise"
-
-import { define } from "@opencode-ai/plugin/v2/effect"
-import type { Plugin, PluginContext, Registration } from "@opencode-ai/plugin/v2/promise"
-import { Effect, Scope } from "effect"
-
-// The Effect host hands back this registration shape; mirror it structurally so
-// we do not have to alias the Effect package's `Registration` against the Promise one.
-type HostRegistration = { readonly dispose: Effect.Effect<void> }
-
-/**
- * Adapts a Promise plugin into an Effect plugin so the existing Effect-only
- * loader (`PluginV2` / `PluginInternal`) can run it unchanged.
- *
- * Hook registrations created during the async `setup` attach to the plugin's
- * scope, so unloading the plugin disposes them. The captured fiber context
- * preserves boot-time batching, so Promise-plugin transforms still coalesce
- * into one reload per domain.
- */
-export function fromPromise(plugin: Plugin) {
-  return define({
-    id: plugin.id,
-    effect: (host) =>
-      Effect.gen(function* () {
-        const scope = yield* Scope.Scope
-        const context = yield* Effect.context<Scope.Scope>()
-
-        // Run a hook registration on the plugin scope and resolve once it is registered.
-        const register = (effect: Effect.Effect<HostRegistration, never, Scope.Scope>): Promise<Registration> =>
-          Effect.runPromiseWith(context)(Scope.provide(scope)(effect)).then((registration) => ({
-            dispose: () => Effect.runPromiseWith(context)(registration.dispose),
-          }))
-
-        const run = (effect: Effect.Effect<void>) => Effect.runPromiseWith(context)(effect)
-
-        const transform =
-          <Draft>(domain: {
-            transform: (
-              callback: (draft: Draft) => Effect.Effect<void> | void,
-            ) => Effect.Effect<HostRegistration, never, Scope.Scope>
-          }) =>
-          (callback: (draft: Draft) => Promise<void> | void) =>
-            register(domain.transform((draft) => Effect.promise(() => Promise.resolve(callback(draft)))))
-
-        const context2: PluginContext = {
-          options: host.options,
-          agent: {
-            transform: transform(host.agent),
-            reload: () => run(host.agent.reload()),
-          },
-          aisdk: {
-            sdk: (callback) =>
-              register(host.aisdk.sdk((event) => Effect.promise(() => Promise.resolve(callback(event))))),
-            language: (callback) =>
-              register(host.aisdk.language((event) => Effect.promise(() => Promise.resolve(callback(event))))),
-          },
-          catalog: {
-            transform: transform(host.catalog),
-            reload: () => run(host.catalog.reload()),
-          },
-          command: {
-            transform: transform(host.command),
-            reload: () => run(host.command.reload()),
-          },
-          integration: {
-            transform: transform(host.integration),
-            reload: () => run(host.integration.reload()),
-          },
-          plugin: {
-            add: (input) => {
-              const child = fromPromise(input)
-              return run(host.plugin.add(child))
-            },
-            remove: (id) => run(host.plugin.remove(id)),
-          },
-          reference: {
-            transform: transform(host.reference),
-            reload: () => run(host.reference.reload()),
-          },
-          skill: {
-            transform: transform(host.skill),
-            reload: () => run(host.skill.reload()),
-          },
-        }
-
-        yield* Effect.promise(() => Promise.resolve(plugin.setup(context2)))
-      }),
-  })
-}

packages/core/src/plugin/provider.ts

@@ -30,10 +30,8 @@ import { VercelPlugin } from "./provider/vercel"
 import { VenicePlugin } from "./provider/venice"
 import { XAIPlugin } from "./provider/xai"
 import { ZenmuxPlugin } from "./provider/zenmux"
-import type { PluginInternal } from "./internal"
-import type { Scope } from "effect"
 
-export const ProviderPlugins: PluginInternal.Plugin<PluginInternal.Requirements | Scope.Scope>[] = [
+export const ProviderPlugins = [
   AlibabaPlugin,
   AmazonBedrockPlugin,
   AnthropicPlugin,

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

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

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

@@ -1,6 +1,6 @@
 import { Effect } from "effect"
 import type { LanguageModelV3 } from "@ai-sdk/provider"
-import { define } from "../internal"
+import { define } from "@opencode-ai/plugin/v2/effect"
 import { ProviderV2 } from "../../provider"
 
 type MantleSDK = {
@@ -78,7 +78,8 @@ export const AmazonBedrockPlugin = define({
         }
       }),
     )
-    yield* ctx.aisdk.sdk(
+    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 }
@@ -111,7 +112,8 @@ export const AmazonBedrockPlugin = define({
         evt.sdk = mod.createAmazonBedrock(options)
       }),
     )
-    yield* ctx.aisdk.language(
+    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") {

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

@@ -1,5 +1,5 @@
 import { Effect } from "effect"
-import { define } from "../internal"
+import { define } from "@opencode-ai/plugin/v2/effect"
 
 export const AnthropicPlugin = define({
   id: "anthropic",
@@ -16,7 +16,8 @@ export const AnthropicPlugin = define({
         }
       }),
     )
-    yield* ctx.aisdk.sdk(
+    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"))

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

@@ -1,5 +1,5 @@
 import { Effect } from "effect"
-import { define } from "../internal"
+import { define } from "@opencode-ai/plugin/v2/effect"
 import { ProviderV2 } from "../../provider"
 
 function selectLanguage(sdk: any, modelID: string, useChat: boolean) {
@@ -28,7 +28,8 @@ export const AzurePlugin = define({
         }
       }),
     )
-    yield* ctx.aisdk.sdk(
+    yield* ctx.aisdk.hook(
+      "sdk",
       Effect.fn(function* (evt) {
         if (evt.package !== "@ai-sdk/azure") return
         if (evt.model.providerID === ProviderV2.ID.azure) {
@@ -46,7 +47,8 @@ export const AzurePlugin = define({
         evt.sdk = mod.createAzure(evt.options)
       }),
     )
-    yield* ctx.aisdk.language(
+    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))
@@ -72,7 +74,8 @@ export const AzureCognitiveServicesPlugin = define({
         }
       }),
     )
-    yield* ctx.aisdk.language(
+    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,5 +1,5 @@
 import { Effect } from "effect"
-import { define } from "../internal"
+import { define } from "@opencode-ai/plugin/v2/effect"
 
 export const CerebrasPlugin = define({
   id: "cerebras",
@@ -15,7 +15,8 @@ export const CerebrasPlugin = define({
         }
       }),
     )
-    yield* ctx.aisdk.sdk(
+    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"))

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

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

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

@@ -1,7 +1,7 @@
 import os from "os"
 import { InstallationVersion } from "../../installation/version"
 import { Effect } from "effect"
-import { define } from "../internal"
+import { define } from "@opencode-ai/plugin/v2/effect"
 import { ProviderV2 } from "../../provider"
 
 const providerID = ProviderV2.ID.make("cloudflare-workers-ai")
@@ -21,7 +21,8 @@ export const CloudflareWorkersAIPlugin = define({
         })
       }),
     )
-    yield* ctx.aisdk.sdk(
+    yield* ctx.aisdk.hook(
+      "sdk",
       Effect.fn(function* (evt) {
         if (evt.model.providerID !== providerID) return
         if (evt.package !== "@ai-sdk/openai-compatible") return
@@ -37,7 +38,8 @@ export const CloudflareWorkersAIPlugin = define({
         )
       }),
     )
-    yield* ctx.aisdk.language(
+    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,10 +1,11 @@
 import { Effect } from "effect"
-import { define } from "../internal"
+import { define } from "@opencode-ai/plugin/v2/effect"
 
 export const CoherePlugin = define({
   id: "cohere",
   effect: Effect.fn(function* (ctx) {
-    yield* ctx.aisdk.sdk(
+    yield* ctx.aisdk.hook(
+      "sdk",
       Effect.fn(function* (evt) {
         if (evt.package !== "@ai-sdk/cohere") return
         const mod = yield* Effect.promise(() => import("@ai-sdk/cohere"))

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

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

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

@@ -1,19 +1,18 @@
 import { Effect } from "effect"
 import { pathToFileURL } from "url"
-import { define } from "../internal"
-import { Npm } from "../../npm"
+import { define } from "@opencode-ai/plugin/v2/effect"
 
 export const DynamicProviderPlugin = define({
   id: "dynamic-provider",
   effect: Effect.fn(function* (ctx) {
-    const npm = yield* Npm.Service
-    yield* ctx.aisdk.sdk(
+    yield* ctx.aisdk.hook(
+      "sdk",
       Effect.fn(function* (evt) {
         if (evt.sdk) return
 
         const installedPath = evt.package.startsWith("file://")
           ? evt.package
-          : (yield* npm.add(evt.package).pipe(Effect.orDie)).entrypoint
+          : (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 () => {

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

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

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

@@ -1,6 +1,6 @@
 import { Effect } from "effect"
 import { ModelV2 } from "../../model"
-import { define } from "../internal"
+import { define } from "@opencode-ai/plugin/v2/effect"
 import { ProviderV2 } from "../../provider"
 
 function shouldUseResponses(modelID: string) {
@@ -25,14 +25,16 @@ export const GithubCopilotPlugin = define({
         })
       }),
     )
-    yield* ctx.aisdk.sdk(
+    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)
       }),
     )
-    yield* ctx.aisdk.language(
+    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) {

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

@@ -1,13 +1,14 @@
 import os from "os"
 import { InstallationVersion } from "../../installation/version"
 import { Effect } from "effect"
-import { define } from "../internal"
+import { define } from "@opencode-ai/plugin/v2/effect"
 import { ProviderV2 } from "../../provider"
 
 export const GitLabPlugin = define({
   id: "gitlab",
   effect: Effect.fn(function* (ctx) {
-    yield* ctx.aisdk.sdk(
+    yield* ctx.aisdk.hook(
+      "sdk",
       Effect.fn(function* (evt) {
         if (evt.package !== "gitlab-ai-provider") return
         const mod = yield* Effect.promise(() => import("gitlab-ai-provider"))
@@ -31,7 +32,8 @@ export const GitLabPlugin = define({
         })
       }),
     )
-    yield* ctx.aisdk.language(
+    yield* ctx.aisdk.hook(
+      "language",
       Effect.fn(function* (evt) {
         if (evt.model.providerID !== ProviderV2.ID.gitlab) return
         const featureFlags =

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

@@ -1,5 +1,5 @@
 import { Effect } from "effect"
-import { define } from "../internal"
+import { define } from "@opencode-ai/plugin/v2/effect"
 import { ProviderV2 } from "../../provider"
 
 function resolveProject(options: Record<string, any>) {
@@ -84,7 +84,8 @@ export const GoogleVertexPlugin = define({
         }
       }),
     )
-    yield* ctx.aisdk.sdk(
+    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)
@@ -103,7 +104,8 @@ export const GoogleVertexPlugin = define({
         })
       }),
     )
-    yield* ctx.aisdk.language(
+    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())
@@ -137,7 +139,8 @@ export const GoogleVertexAnthropicPlugin = define({
         }
       }),
     )
-    yield* ctx.aisdk.sdk(
+    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"))
@@ -163,7 +166,8 @@ export const GoogleVertexAnthropicPlugin = define({
         })
       }),
     )
-    yield* ctx.aisdk.language(
+    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,10 +1,11 @@
 import { Effect } from "effect"
-import { define } from "../internal"
+import { define } from "@opencode-ai/plugin/v2/effect"
 
 export const GooglePlugin = define({
   id: "google",
   effect: Effect.fn(function* (ctx) {
-    yield* ctx.aisdk.sdk(
+    yield* ctx.aisdk.hook(
+      "sdk",
       Effect.fn(function* (evt) {
         if (evt.package !== "@ai-sdk/google") return
         const mod = yield* Effect.promise(() => import("@ai-sdk/google"))

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

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

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

@@ -1,5 +1,5 @@
 import { Effect } from "effect"
-import { define } from "../internal"
+import { define } from "@opencode-ai/plugin/v2/effect"
 
 export const KiloPlugin = define({
   id: "kilo",

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

@@ -1,11 +1,9 @@
 import { Effect } from "effect"
-import { define } from "../internal"
-import { Integration } from "../../integration"
+import { define } from "@opencode-ai/plugin/v2/effect"
 
 export const LLMGatewayPlugin = define({
   id: "llmgateway",
   effect: Effect.fn(function* (ctx) {
-    const integrations = yield* Integration.Service
     yield* ctx.catalog.transform(
       Effect.fn(function* (evt) {
         for (const item of evt.provider.list()) {
@@ -13,7 +11,7 @@ export const LLMGatewayPlugin = define({
           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* integrations.get(Integration.ID.make(item.provider.id)))) 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"

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

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

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

@@ -1,5 +1,5 @@
 import { Effect } from "effect"
-import { define } from "../internal"
+import { define } from "@opencode-ai/plugin/v2/effect"
 
 export const NvidiaPlugin = define({
   id: "nvidia",

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

@@ -1,10 +1,11 @@
 import { Effect } from "effect"
-import { define } from "../internal"
+import { define } from "@opencode-ai/plugin/v2/effect"
 
 export const OpenAICompatiblePlugin = define({
   id: "openai-compatible",
   effect: Effect.fn(function* (ctx) {
-    yield* ctx.aisdk.sdk(
+    yield* ctx.aisdk.hook(
+      "sdk",
       Effect.fn(function* (evt) {
         if (evt.sdk) return
         if (!evt.package.includes("@ai-sdk/openai-compatible")) return

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

@@ -1,6 +1,6 @@
 import { Effect } from "effect"
 import { ModelV2 } from "../../model"
-import { define } from "../internal"
+import { define } from "@opencode-ai/plugin/v2/effect"
 import { ProviderV2 } from "../../provider"
 import { Integration } from "../../integration"
 import { browser, headless } from "./openai-auth"
@@ -27,14 +27,16 @@ export const OpenAIPlugin = define({
         }
       }),
     )
-    yield* ctx.aisdk.sdk(
+    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.language(
+    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 { define } from "../internal"
+import { define } from "@opencode-ai/plugin/v2/effect"
 import { ProviderV2 } from "../../provider"
-import { Integration } from "../../integration"
 
 export const OpencodePlugin = define({
   id: "opencode",
   effect: Effect.fn(function* (ctx) {
-    const integrations = yield* Integration.Service
     let hasKey = false
     yield* ctx.catalog.transform(
       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,
         )

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

@@ -1,6 +1,6 @@
 import { Effect } from "effect"
 import { ModelV2 } from "../../model"
-import { define } from "../internal"
+import { define } from "@opencode-ai/plugin/v2/effect"
 
 export const OpenRouterPlugin = define({
   id: "openrouter",
@@ -25,7 +25,8 @@ export const OpenRouterPlugin = define({
         }
       }),
     )
-    yield* ctx.aisdk.sdk(
+    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"))

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

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

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

@@ -1,14 +1,13 @@
 import { Effect } from "effect"
 import { pathToFileURL } from "url"
-import { define } from "../internal"
-import { Npm } from "../../npm"
+import { define } from "@opencode-ai/plugin/v2/effect"
 import { ProviderV2 } from "../../provider"
 
 export const SapAICorePlugin = define({
   id: "sap-ai-core",
   effect: Effect.fn(function* (ctx) {
-    const npm = yield* Npm.Service
-    yield* ctx.aisdk.sdk(
+    yield* ctx.aisdk.hook(
+      "sdk",
       Effect.fn(function* (evt) {
         if (evt.model.providerID !== ProviderV2.ID.make("sap-ai-core")) return
         const serviceKey =
@@ -18,7 +17,7 @@ export const SapAICorePlugin = define({
 
         const installedPath = evt.package.startsWith("file://")
           ? evt.package
-          : (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 () => {
@@ -36,7 +35,8 @@ export const SapAICorePlugin = define({
         )
       }),
     )
-    yield* ctx.aisdk.language(
+    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 { define } from "../internal"
+import { define } from "@opencode-ai/plugin/v2/effect"
 import { ProviderV2 } from "../../provider"
 
 type FetchLike = (url: string | URL | Request, init?: RequestInit) => Promise<Response>
@@ -67,7 +67,8 @@ export function cortexFetch(upstream: FetchLike = fetch) {
 export const SnowflakeCortexPlugin = define({
   id: "snowflake-cortex",
   effect: Effect.fn(function* (ctx) {
-    yield* ctx.aisdk.sdk(
+    yield* ctx.aisdk.hook(
+      "sdk",
       Effect.fn(function* (evt) {
         if (evt.model.providerID !== ProviderV2.ID.make("snowflake-cortex")) return
         const token =

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

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

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

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

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

@@ -1,5 +1,5 @@
 import { Effect } from "effect"
-import { define } from "../internal"
+import { define } from "@opencode-ai/plugin/v2/effect"
 
 export const VercelPlugin = define({
   id: "vercel",
@@ -16,7 +16,8 @@ export const VercelPlugin = define({
         }
       }),
     )
-    yield* ctx.aisdk.sdk(
+    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"))

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

@@ -1,18 +1,20 @@
 import { Effect } from "effect"
-import { define } from "../internal"
+import { define } from "@opencode-ai/plugin/v2/effect"
 import { ProviderV2 } from "../../provider"
 
 export const XAIPlugin = define({
   id: "xai",
   effect: Effect.fn(function* (ctx) {
-    yield* ctx.aisdk.sdk(
+    yield* ctx.aisdk.hook(
+      "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)
       }),
     )
-    yield* ctx.aisdk.language(
+    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,5 +1,5 @@
 import { Effect } from "effect"
-import { define } from "../internal"
+import { define } from "@opencode-ai/plugin/v2/effect"
 
 export const ZenmuxPlugin = define({
   id: "zenmux",

packages/core/src/plugin/skill.ts

@@ -2,7 +2,7 @@
 
 export * as SkillPlugin from "./skill"
 
-import { define } from "./internal"
+import { define } from "@opencode-ai/plugin/v2/effect"
 import { Effect } from "effect"
 import { AbsolutePath } from "../schema"
 import { SkillV2 } from "../skill"

packages/core/src/project/copy.ts

@@ -13,6 +13,7 @@ import { Slug } from "../util/slug"
 import { EventV2 } from "../event"
 import { Database } from "../database/database"
 import { Location } from "../location"
+import { PluginBoot } from "../plugin/boot"
 
 export const StrategyID = Schema.Trim.pipe(Schema.check(Schema.isNonEmpty()), Schema.brand("ProjectCopy.StrategyID"))
 export type StrategyID = typeof StrategyID.Type
@@ -124,8 +125,10 @@ export class Service extends Context.Service<Service, Interface>()("@opencode/Pr
 
 export const refreshAfterBoot = Effect.gen(function* () {
   const location = yield* Location.Service
+  const boot = yield* PluginBoot.Service
   const copies = yield* Service
   yield* Effect.gen(function* () {
+    yield* boot.wait()
     yield* Effect.logInfo("project copy refresh started", { projectID: location.project.id })
     const result = yield* copies.refresh({ projectID: location.project.id })
     yield* Effect.logInfo("project copy refresh done", {

packages/core/src/reference.ts

@@ -126,7 +126,7 @@ export const layer = Layer.effect(
 
     return Service.of({
       transform: state.transform,
-      reload: state.reload,
+      rebuild: state.rebuild,
       list: Effect.fn("Reference.list")(function* () {
         return Array.from(materialized.values())
       }),

packages/core/src/reference/guidance.ts

@@ -1,6 +1,7 @@
 export * as ReferenceGuidance from "./guidance"
 
 import { Context, Effect, Layer, Schema } from "effect"
+import { PluginBoot } from "../plugin/boot"
 import { Reference } from "../reference"
 import { SystemContext } from "../system-context/index"
 
@@ -33,10 +34,12 @@ export class Service extends Context.Service<Service, Interface>()("@opencode/v2
 export const layer = Layer.effect(
   Service,
   Effect.gen(function* () {
+    const boot = yield* PluginBoot.Service
     const references = yield* Reference.Service
 
     return Service.of({
       load: Effect.fn("ReferenceGuidance.load")(function* () {
+        yield* boot.wait()
         const available = (yield* references.list())
           .filter((reference) => reference.description !== undefined)
           .map((reference) => ({

packages/core/src/session.ts

@@ -2,7 +2,7 @@ export * as SessionV2 from "./session"
 export * from "./session/schema"
 
 import { DateTime, Effect, Layer, Schema, Context, Stream } from "effect"
-import { and, asc, desc, eq, gt, like, lt, or, type SQL } from "drizzle-orm"
+import { and, asc, desc, eq, gt, gte, like, lt, or, type SQL } from "drizzle-orm"
 import { ProjectV2 } from "./project"
 import { WorkspaceV2 } from "./workspace"
 import { ModelV2 } from "./model"
@@ -248,6 +248,13 @@ export const layer = Layer.effect(
         if ("directory" in input) conditions.push(eq(SessionTable.directory, input.directory))
         if (input.workspaceID) conditions.push(eq(SessionTable.workspace_id, input.workspaceID))
         if ("project" in input) conditions.push(eq(SessionTable.project_id, input.project))
+        if ("subpath" in input && input.subpath)
+          conditions.push(
+            or(
+              eq(SessionTable.path, input.subpath),
+              and(gte(SessionTable.path, `${input.subpath}/`), lt(SessionTable.path, `${input.subpath}0`)),
+            )!,
+          )
         if (input.search) conditions.push(like(SessionTable.title, `%${input.search}%`))
         if (input.anchor) {
           conditions.push(

packages/core/src/session/context-epoch.ts

@@ -64,7 +64,7 @@ const prepareOnce = Effect.fnUntraced(function* (
     return { baseline: stored.baseline, baselineSeq: stored.baseline_seq }
   }
   if (result._tag === "ReplacementReady") {
-    const baselineSeq = replacementSeq ?? (yield* EventV2.latestSequence(db, sessionID))
+    const baselineSeq = replacementSeq ?? (yield* SessionInput.latestSeq(db, sessionID))
     yield* replace(db, sessionID, baselineSeq, result.generation)
     return { baseline: result.generation.baseline, baselineSeq }
   }
@@ -124,7 +124,7 @@ const insert = Effect.fnUntraced(function* (
   sessionID: SessionSchema.ID,
   generation: SystemContext.Generation,
 ) {
-  const baselineSeq = yield* EventV2.latestSequence(db, sessionID)
+  const baselineSeq = yield* SessionInput.latestSeq(db, sessionID)
   yield* db
     .insert(SessionContextEpochTable)
     .values({

packages/core/src/session/event.ts

@@ -25,12 +25,6 @@ const Base = {
   timestamp: V2Schema.DateTimeUtcFromMillis,
   sessionID: SessionSchema.ID,
 }
-const PromptFields = {
-  ...Base,
-  messageID: SessionMessageID.ID,
-  prompt: Prompt,
-  delivery: Schema.Literals(["steer", "queue"]),
-}
 
 const options = {
   durable: {
@@ -89,16 +83,40 @@ export type Moved = typeof Moved.Type
 export const Prompted = EventV2.define({
   type: "session.next.prompted",
   ...options,
-  schema: PromptFields,
+  schema: {
+    ...Base,
+    messageID: SessionMessageID.ID,
+    prompt: Prompt,
+    delivery: Schema.Literals(["steer", "queue"]),
+  },
 })
 export type Prompted = typeof Prompted.Type
 
-export const PromptAdmitted = EventV2.define({
-  type: "session.next.prompt.admitted",
-  ...options,
-  schema: PromptFields,
-})
-export type PromptAdmitted = typeof PromptAdmitted.Type
+export namespace PromptLifecycle {
+  export const Admitted = EventV2.define({
+    type: "session.next.prompt.admitted",
+    ...options,
+    schema: {
+      ...Base,
+      messageID: SessionMessageID.ID,
+      prompt: Prompt,
+      delivery: Schema.Literals(["steer", "queue"]),
+    },
+  })
+  export type Admitted = typeof Admitted.Type
+
+  export const Promoted = EventV2.define({
+    type: "session.next.prompt.promoted",
+    ...options,
+    schema: {
+      ...Base,
+      messageID: SessionMessageID.ID,
+      prompt: Prompt,
+      timeCreated: V2Schema.DateTimeUtcFromMillis,
+    },
+  })
+  export type Promoted = typeof Promoted.Type
+}
 
 export const ContextUpdated = EventV2.define({
   type: "session.next.context.updated",
@@ -418,9 +436,20 @@ export namespace Compaction {
   })
   export type Delta = typeof Delta.Type
 
-  export const Ended = EventV2.define({
+  // Retain the unpublished v1 decoder so stored beta events remain replayable.
+  export const EndedV1 = EventV2.define({
     type: "session.next.compaction.ended",
     ...options,
+    schema: {
+      ...Base,
+      text: Schema.String,
+      include: Schema.String.pipe(Schema.optional),
+    },
+  })
+
+  export const Ended = EventV2.define({
+    type: "session.next.compaction.ended",
+    durable: { aggregate: "sessionID", version: 2 },
     schema: {
       ...Base,
       messageID: SessionMessageID.ID,
@@ -437,7 +466,8 @@ const DurableDefinitions = [
   ModelSwitched,
   Moved,
   Prompted,
-  PromptAdmitted,
+  PromptLifecycle.Admitted,
+  PromptLifecycle.Promoted,
   ContextUpdated,
   Synthetic,
   Shell.Started,

packages/core/src/session/input.ts

@@ -4,6 +4,7 @@ import { and, asc, eq, isNull, lte } from "drizzle-orm"
 import { DateTime, Effect, Schema } from "effect"
 import type { Database } from "../database/database"
 import type { EventV2 } from "../event"
+import { EventSequenceTable } from "../event/sql"
 import { NonNegativeInt } from "../schema"
 import { V2Schema } from "../v2-schema"
 import { SessionEvent } from "./event"
@@ -64,7 +65,7 @@ export const admit = Effect.fn("SessionInput.admit")(function* (
   if (existing !== undefined) return existing
   const timestamp = yield* DateTime.now
   return yield* events
-    .publish(SessionEvent.PromptAdmitted, {
+    .publish(SessionEvent.PromptLifecycle.Admitted, {
       messageID: input.id,
       sessionID: input.sessionID,
       timestamp,
@@ -92,6 +93,19 @@ export const admit = Effect.fn("SessionInput.admit")(function* (
     )
 })
 
+export const latestSeq = Effect.fn("SessionInput.latestSeq")(function* (
+  db: DatabaseService,
+  sessionID: SessionSchema.ID,
+) {
+  const row = yield* db
+    .select({ seq: EventSequenceTable.seq })
+    .from(EventSequenceTable)
+    .where(eq(EventSequenceTable.aggregate_id, sessionID))
+    .get()
+    .pipe(Effect.orDie)
+  return row?.seq ?? -1
+})
+
 export const projectAdmitted = Effect.fn("SessionInput.projectAdmitted")(function* (
   db: DatabaseService,
   input: {
@@ -103,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 !== undefined) return yield* Effect.die(new LifecycleConflict({ id: input.id }))
   const stored = yield* db
     .insert(SessionInputTable)
     .values({
@@ -127,13 +134,12 @@ export const projectAdmitted = Effect.fn("SessionInput.projectAdmitted")(functio
   if (!stored) return yield* Effect.die(new LifecycleConflict({ id: input.id }))
 })
 
-export const projectPrompted = Effect.fn("SessionInput.projectPrompted")(function* (
+export const projectPromoted = Effect.fn("SessionInput.projectPromoted")(function* (
   db: DatabaseService,
   input: {
     readonly id: SessionMessage.ID
     readonly sessionID: SessionSchema.ID
     readonly prompt: Prompt
-    readonly delivery: Delivery
     readonly timeCreated: DateTime.Utc
     readonly promotedSeq: number
   },
@@ -151,32 +157,14 @@ export const projectPrompted = Effect.fn("SessionInput.projectPrompted")(functio
     .returning()
     .get()
     .pipe(Effect.orDie)
-  if (updated) {
-    const stored = fromRow(updated)
-    if (!matchesProjection(stored, input)) return yield* Effect.die(new LifecycleConflict({ id: input.id }))
-    return
-  }
-
-  const stored = yield* find(db, input.id)
-  if (stored) {
-    if (!matchesProjection(stored, input) || stored.promotedSeq !== input.promotedSeq)
-      return yield* Effect.die(new LifecycleConflict({ id: input.id }))
-    return
-  }
-
-  yield* db
-    .insert(SessionInputTable)
-    .values({
-      id: input.id,
-      session_id: input.sessionID,
-      prompt: encodePrompt(input.prompt),
-      delivery: input.delivery,
-      admitted_seq: input.promotedSeq,
-      promoted_seq: input.promotedSeq,
-      time_created: DateTime.toEpochMillis(input.timeCreated),
-    })
-    .run()
-    .pipe(Effect.orDie)
+  if (!updated) return yield* Effect.die(new LifecycleConflict({ id: input.id }))
+  const stored = fromRow(updated)
+  if (
+    !matchesPrompt(stored, input) ||
+    DateTime.toEpochMillis(stored.timeCreated) !== DateTime.toEpochMillis(input.timeCreated)
+  )
+    return yield* Effect.die(new LifecycleConflict({ id: input.id }))
+  return toMessage(stored)
 })
 
 export const hasPending = Effect.fn("SessionInput.hasPending")(function* (
@@ -213,17 +201,35 @@ const matchesPrompt = (input: Admitted, expected: { readonly sessionID: SessionS
   input.sessionID === expected.sessionID &&
   JSON.stringify(encodePrompt(input.prompt)) === JSON.stringify(encodePrompt(expected.prompt))
 
-const matchesProjection = (
-  input: Admitted,
-  expected: {
+export const projectLegacyPrompted = Effect.fn("SessionInput.projectLegacyPrompted")(function* (
+  db: DatabaseService,
+  input: {
+    readonly id: SessionMessage.ID
     readonly sessionID: SessionSchema.ID
     readonly prompt: Prompt
     readonly delivery: Delivery
     readonly timeCreated: DateTime.Utc
+    readonly promotedSeq: number
   },
-) =>
-  equivalent(input, expected) &&
-  DateTime.toEpochMillis(input.timeCreated) === DateTime.toEpochMillis(expected.timeCreated)
+) {
+  const inserted = yield* db
+    .insert(SessionInputTable)
+    .values({
+      id: input.id,
+      session_id: input.sessionID,
+      admitted_seq: input.promotedSeq,
+      prompt: encodePrompt(input.prompt),
+      delivery: input.delivery,
+      promoted_seq: input.promotedSeq,
+      time_created: DateTime.toEpochMillis(input.timeCreated),
+    })
+    .onConflictDoNothing()
+    .returning()
+    .get()
+    .pipe(Effect.orDie)
+  if (!inserted) return yield* Effect.die("Prompt projection conflicts with admitted input")
+  return fromRow(inserted)
+})
 
 const publish = Effect.fn("SessionInput.publish")(function* (
   db: DatabaseService,
@@ -232,19 +238,18 @@ const publish = Effect.fn("SessionInput.publish")(function* (
   rows: ReadonlyArray<typeof SessionInputTable.$inferSelect>,
 ) {
   for (const row of rows) {
-    const id = SessionMessage.ID.make(row.id)
     yield* events
-      .publish(SessionEvent.Prompted, {
+      .publish(SessionEvent.PromptLifecycle.Promoted, {
         sessionID,
-        timestamp: DateTime.makeUnsafe(row.time_created),
-        messageID: id,
+        timestamp: yield* DateTime.now,
+        messageID: SessionMessage.ID.make(row.id),
         prompt: decodePrompt(row.prompt),
-        delivery: row.delivery,
+        timeCreated: DateTime.makeUnsafe(row.time_created),
       })
       .pipe(
         Effect.catchDefect((defect) =>
           defect instanceof LifecycleConflict
-            ? find(db, id).pipe(
+            ? find(db, SessionMessage.ID.make(row.id)).pipe(
                 Effect.flatMap((stored) => (stored?.promotedSeq === undefined ? Effect.die(defect) : Effect.void)),
               )
             : Effect.die(defect),
@@ -298,3 +303,13 @@ export const promoteNextQueued = Effect.fn("SessionInput.promoteNextQueued")(fun
     .pipe(Effect.orDie)
   return row === undefined ? false : yield* publish(db, events, sessionID, [row]).pipe(Effect.as(true))
 })
+
+const toMessage = (input: Admitted) =>
+  new SessionMessage.User({
+    id: input.id,
+    type: "user",
+    text: input.prompt.text,
+    files: input.prompt.files,
+    agents: input.prompt.agents,
+    time: { created: input.timeCreated },
+  })

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

@@ -137,6 +137,7 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {
         )
       },
       "session.next.prompt.admitted": () => Effect.void,
+      "session.next.prompt.promoted": () => Effect.void,
       "session.next.context.updated": (event) =>
         adapter.appendMessage(
           new SessionMessage.System({

packages/core/src/session/projector.ts

@@ -21,6 +21,7 @@ type DatabaseService = Database.Interface["db"]
 const decodeMessage = Schema.decodeUnknownSync(SessionMessage.Message)
 const encodeMessage = Schema.encodeSync(SessionMessage.Message)
 
+class PromptAlreadyProjected extends Error {}
 export class SessionAlreadyProjected extends Error {}
 
 type Usage = {
@@ -349,19 +350,27 @@ export const layer = Layer.effectDiscard(
     )
     yield* events.project(SessionEvent.Prompted, (event) =>
       Effect.gen(function* () {
+        const messageID = event.data.messageID
+        const existing = yield* db
+          .select({ id: SessionMessageTable.id })
+          .from(SessionMessageTable)
+          .where(eq(SessionMessageTable.id, messageID))
+          .get()
+          .pipe(Effect.orDie)
+        if (existing) return yield* Effect.die(new PromptAlreadyProjected())
+        yield* run(db, event)
         if (event.durable === undefined) return yield* Effect.die("Durable Session event is missing aggregate sequence")
-        yield* SessionInput.projectPrompted(db, {
-          id: event.data.messageID,
+        yield* SessionInput.projectLegacyPrompted(db, {
+          id: messageID,
           sessionID: event.data.sessionID,
           prompt: event.data.prompt,
           delivery: event.data.delivery,
           timeCreated: event.data.timestamp,
           promotedSeq: event.durable.seq,
         })
-        yield* run(db, event)
       }),
     )
-    yield* events.project(SessionEvent.PromptAdmitted, (event) =>
+    yield* events.project(SessionEvent.PromptLifecycle.Admitted, (event) =>
       Effect.gen(function* () {
         if (event.durable === undefined) return yield* Effect.die("Durable Session event is missing aggregate sequence")
         yield* SessionInput.projectAdmitted(db, {
@@ -374,6 +383,22 @@ export const layer = Layer.effectDiscard(
         })
       }),
     )
+    yield* events.project(SessionEvent.PromptLifecycle.Promoted, (event) =>
+      Effect.gen(function* () {
+        if (event.durable === undefined) return yield* Effect.die("Durable Session event is missing aggregate sequence")
+        yield* insertMessage(
+          db,
+          event,
+          yield* SessionInput.projectPromoted(db, {
+            id: event.data.messageID,
+            sessionID: event.data.sessionID,
+            prompt: event.data.prompt,
+            timeCreated: event.data.timeCreated,
+            promotedSeq: event.durable.seq,
+          }),
+        )
+      }),
+    )
     yield* events.project(SessionEvent.ContextUpdated, (event) => run(db, event))
     yield* events.project(SessionEvent.Synthetic, (event) => run(db, event))
     yield* events.project(SessionEvent.Shell.Started, (event) => run(db, event))
@@ -392,7 +417,9 @@ export const layer = Layer.effectDiscard(
     yield* events.project(SessionEvent.Reasoning.Started, (event) => run(db, event))
     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) => run(db, event))
+    yield* events.project(SessionEvent.Compaction.Ended, (event) =>
+      event.durable?.version === 1 ? Effect.void : run(db, event),
+    )
   }),
 )
 

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

@@ -79,7 +79,7 @@ import { MAX_STEPS_PROMPT } from "./max-steps"
  *   - [ ] Update title, summaries, compaction state, and cleanup in bounded background work.
  *
  * Use `llm.stream(request)` for each provider turn. Keep tool execution and continuation here.
- * Durable continuation recovery remains a separate future slice with an explicit retry policy.
+ * Durable activity recovery remains a separate future slice with an explicit retry policy.
  *
  * The current slice loads V2 history, translates it, resolves a model through a core service, and persists one
  * provider turn. Registry definitions are advertised, local tool calls are settled durably, and an
@@ -142,9 +142,9 @@ export const layer = Layer.effect(
 
     type TurnTransition =
       // Automatic compaction completed; rebuild the request from compacted history.
-      | { readonly _tag: "ContinueAfterCompaction"; readonly step: number }
+      | { readonly _tag: "ContinueAfterCompaction" }
       // Overflow compaction completed; rebuild once through the path without overflow recovery.
-      | { readonly _tag: "ContinueAfterOverflowCompaction"; readonly step: number }
+      | { readonly _tag: "ContinueAfterOverflowCompaction" }
 
     class TurnTransitionError extends Error {
       constructor(readonly transition: TurnTransition) {
@@ -152,9 +152,10 @@ export const layer = Layer.effect(
       }
     }
 
-    const continueAfterCompaction = (step: number) => new TurnTransitionError({ _tag: "ContinueAfterCompaction", step })
-    const continueAfterOverflowCompaction = (step: number) =>
-      new TurnTransitionError({ _tag: "ContinueAfterOverflowCompaction", step })
+    const continueAfterCompaction = new TurnTransitionError({ _tag: "ContinueAfterCompaction" })
+    const continueAfterOverflowCompaction = new TurnTransitionError({
+      _tag: "ContinueAfterOverflowCompaction",
+    })
 
     const loadSystemContext = (agent: AgentV2.Selection) =>
       Effect.all([systemContext.load(), skillGuidance.load(agent), referenceGuidance.load()], {
@@ -174,23 +175,20 @@ export const layer = Layer.effect(
       const initialized = yield* SessionContextEpoch.initialize(db, loadSystemContext(agent), session.id)
       const toolFibers = yield* FiberSet.make<void, ToolOutputStore.Error>()
       let needsContinuation = false
-      let currentStep = step
       if (promotion) {
-        const cutoff = yield* EventV2.latestSequence(db, session.id)
-        let promoted = 0
-        if (promotion === "steer") promoted = yield* SessionInput.promoteSteers(db, events, session.id, cutoff)
+        const cutoff = yield* SessionInput.latestSeq(db, session.id)
+        if (promotion === "steer") yield* SessionInput.promoteSteers(db, events, session.id, cutoff)
         if (promotion === "queue") {
-          promoted += Number(yield* SessionInput.promoteNextQueued(db, events, session.id))
-          promoted += yield* SessionInput.promoteSteers(db, events, session.id, cutoff)
+          yield* SessionInput.promoteNextQueued(db, events, session.id)
+          yield* SessionInput.promoteSteers(db, events, session.id, cutoff)
         }
-        if (promoted > 0) currentStep = 1
       }
       const system =
         initialized ?? (yield* SessionContextEpoch.prepare(db, events, loadSystemContext(agent), session.id))
       const model = yield* models.resolve(session)
       const entries = yield* SessionHistory.entriesForRunner(db, session.id, system.baselineSeq)
       const context = entries.map((entry) => entry.message)
-      const isLastStep = agent.info?.steps !== undefined && currentStep >= agent.info.steps
+      const isLastStep = agent.info?.steps !== undefined && step >= agent.info.steps
       const toolMaterialization = isLastStep ? undefined : yield* tools.materialize(agent.info?.permissions)
       const promptCacheKey = /^ses_[0-9a-f]{64}$/.test(session.id) ? session.id.slice(4) : session.id
       const request = LLM.request({
@@ -204,7 +202,7 @@ export const layer = Layer.effect(
         toolChoice: isLastStep ? "none" : undefined,
       })
       if (yield* compaction.compactIfNeeded({ sessionID: session.id, entries, model, request }))
-        return yield* Effect.die(continueAfterCompaction(currentStep))
+        return yield* Effect.die(continueAfterCompaction)
       const publisher = createLLMEventPublisher(events, {
         sessionID: session.id,
         agent: agent.id,
@@ -274,7 +272,7 @@ export const layer = Layer.effect(
             isContextOverflowFailure(overflowFailure ?? failure) &&
             (yield* restore(recoverOverflow({ sessionID: session.id, entries, model, request })))
           )
-            return yield* Effect.die(continueAfterOverflowCompaction(currentStep))
+            return yield* Effect.die(continueAfterOverflowCompaction)
           if (overflowFailure) yield* publish(overflowFailure)
           const llmFailure = failure instanceof LLMError ? failure : undefined
           if (llmFailure && !publisher.hasProviderError()) {
@@ -308,7 +306,7 @@ export const layer = Layer.effect(
             yield* withPublication(publisher.failUnsettledTools("Provider did not return a tool result", true))
           if (stream._tag === "Failure") return yield* Effect.failCause(stream.cause)
           if (settled._tag === "Failure") return yield* Effect.failCause(settled.cause)
-          return { needsContinuation: !publisher.hasProviderError() && needsContinuation, step: currentStep }
+          return !publisher.hasProviderError() && needsContinuation
         }),
       )
     }, Effect.scoped)
@@ -316,7 +314,7 @@ export const layer = Layer.effect(
       sessionID: SessionSchema.ID,
       promotion: SessionInput.Delivery | undefined,
       step: number,
-    ) => Effect.Effect<{ readonly needsContinuation: boolean; readonly step: number }, RunError>
+    ) => Effect.Effect<boolean, RunError>
 
     const runAfterOverflowCompaction: RunTurn = Effect.fnUntraced(function* (sessionID, promotion, step) {
       return yield* runTurnAttempt(sessionID, promotion, step).pipe(
@@ -326,7 +324,7 @@ export const layer = Layer.effect(
             if (defect.transition._tag === "ContinueAfterOverflowCompaction")
               return yield* Effect.die("Post-compaction provider attempt cannot recover another overflow")
             yield* Effect.yieldNow
-            return yield* runAfterOverflowCompaction(sessionID, undefined, defect.transition.step)
+            return yield* runAfterOverflowCompaction(sessionID, undefined, step)
           }),
         ),
       )
@@ -339,8 +337,8 @@ export const layer = Layer.effect(
             if (!(defect instanceof TurnTransitionError)) return yield* Effect.die(defect)
             yield* Effect.yieldNow
             if (defect.transition._tag === "ContinueAfterOverflowCompaction")
-              return yield* runAfterOverflowCompaction(sessionID, undefined, defect.transition.step)
-            return yield* runTurn(sessionID, undefined, defect.transition.step)
+              return yield* runAfterOverflowCompaction(sessionID, undefined, step)
+            return yield* runTurn(sessionID, undefined, step)
           }),
         ),
       )
@@ -355,19 +353,16 @@ export const layer = Layer.effect(
       if (!input.force && !hasSteer && !hasQueue) return
       yield* failInterruptedTools(input.sessionID)
       let promotion: SessionInput.Delivery | undefined = hasSteer ? "steer" : hasQueue ? "queue" : undefined
-      let shouldRun = input.force || hasSteer || hasQueue
-      while (shouldRun) {
+      let openActivity = input.force || hasSteer || hasQueue
+      while (openActivity) {
         let needsContinuation = true
-        let step = 1
-        while (needsContinuation) {
-          const result = yield* runTurn(input.sessionID, promotion, step)
-          needsContinuation = result.needsContinuation
-          step = result.step + 1
+        for (let step = 1; needsContinuation; step++) {
+          needsContinuation = yield* runTurn(input.sessionID, promotion, step)
           promotion = "steer"
           if (!needsContinuation) needsContinuation = yield* SessionInput.hasPending(db, input.sessionID, "steer")
         }
-        shouldRun = yield* SessionInput.hasPending(db, input.sessionID, "queue")
-        promotion = shouldRun ? "queue" : undefined
+        openActivity = yield* SessionInput.hasPending(db, input.sessionID, "queue")
+        promotion = openActivity ? "queue" : undefined
       }
     })
 

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

@@ -13,6 +13,7 @@ import { Integration } from "../../integration"
 import { IntegrationConnection } from "../../integration/connection"
 import { ModelV2 } from "../../model"
 import { ModelRequest } from "../../model-request"
+import { PluginBoot } from "../../plugin/boot"
 import { ProviderV2 } from "../../provider"
 import { SessionSchema } from "../schema"
 
@@ -177,9 +178,11 @@ export const locationLayer = Layer.effect(
     const catalog = yield* Catalog.Service
     const credentials = yield* Credential.Service
     const integrations = yield* Integration.Service
+    const boot = yield* PluginBoot.Service
     return Service.of({
       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.available()).find(

packages/core/src/skill.ts

@@ -148,7 +148,7 @@ export const layer = Layer.effect(
 
     return Service.of({
       transform: state.transform,
-      reload: state.reload,
+      rebuild: state.rebuild,
       sources: Effect.fn("SkillV2.sources")(function* () {
         return state.get().sources
       }),

packages/core/src/skill/guidance.ts

@@ -3,6 +3,7 @@ export * as SkillGuidance from "./guidance"
 import { Context, Effect, Layer, Schema } from "effect"
 import { AgentV2 } from "../agent"
 import { PermissionV2 } from "../permission"
+import { PluginBoot } from "../plugin/boot"
 import { SkillV2 } from "../skill"
 import { SystemContext } from "../system-context/index"
 
@@ -39,10 +40,12 @@ export class Service extends Context.Service<Service, Interface>()("@opencode/v2
 export const layer = Layer.effect(
   Service,
   Effect.gen(function* () {
+    const boot = yield* PluginBoot.Service
     const skills = yield* SkillV2.Service
 
     return Service.of({
       load: Effect.fn("SkillGuidance.load")(function* (selection) {
+        yield* boot.wait()
         const agent = selection.info
         if (!agent) return SystemContext.empty
         const permitted = SkillV2.available(yield* skills.list(), agent)

packages/core/src/state.ts

@@ -3,7 +3,7 @@ export * as State from "./state"
 import { Context, Effect, Scope, Semaphore } from "effect"
 
 /**
- * A replayable transform applied to a draft during reload.
+ * A replayable transform applied to a draft during rebuild.
  *
  * Domain drafts expose readable and writable state while preserving concise
  * plugin/config code. Transforms may perform Effects before returning.
@@ -19,14 +19,14 @@ export type Transform<DraftApi> = (
   transform: TransformCallback<DraftApi>,
 ) => Effect.Effect<Registration, never, Scope.Scope>
 
-export type Reload = () => Effect.Effect<void>
+export type Rebuild = () => Effect.Effect<void>
 
 export interface Transformable<DraftApi> {
   readonly transform: Transform<DraftApi>
-  readonly reload: Reload
+  readonly rebuild: Rebuild
 }
 
-const CurrentBatch = Context.Reference<Set<Reload> | undefined>("@opencode/State/CurrentBatch", {
+const CurrentBatch = Context.Reference<Set<Rebuild> | undefined>("@opencode/State/CurrentBatch", {
   defaultValue: () => undefined,
 })
 
@@ -34,15 +34,15 @@ 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 reloads = new Set<Reload>()
-    const result = yield* effect.pipe(Effect.provideService(CurrentBatch, reloads))
-    yield* Effect.forEach(reloads, (reload) => reload(), { discard: true })
+    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 reload. */
+  /** Creates the base value for initial state and every scoped-transform rebuild. */
   readonly initial: () => State
   /** Wraps mutable state in a domain-specific draft API. */
   readonly draft: MakeDraft<State, DraftApi>
@@ -54,7 +54,7 @@ export interface Interface<State, DraftApi> extends Transformable<DraftApi> {
   readonly get: () => State
   /**
    * Registers and applies a scoped transform. Closing the owning Scope removes
-   * the transform and reloads the materialized state.
+   * the transform and rebuilds the materialized state.
    */
 }
 
@@ -78,11 +78,11 @@ export function create<State, DraftApi>(options: Options<State, DraftApi>): Inte
   const materialize = Effect.fnUntraced(function* () {
     const next = options.initial()
     const api = options.draft(next)
-    for (const transform of transforms) yield* apply(transform.run, api).pipe(Effect.withSpan("State.reload.update"))
+    for (const transform of transforms) yield* apply(transform.run, api).pipe(Effect.withSpan("State.rebuild.update"))
     yield* commit(next)
   })
 
-  const reload = () => semaphore.withPermit(materialize())
+  const rebuild = () => semaphore.withPermit(materialize())
 
   const result: Interface<State, DraftApi> = {
     get: () => state,
@@ -101,7 +101,7 @@ export function create<State, DraftApi>(options: Options<State, DraftApi>): Inte
                 return Effect.gen(function* () {
                   const batch = yield* CurrentBatch
                   if (batch) {
-                    batch.add(reload)
+                    batch.add(rebuild)
                     return
                   }
                   yield* materialize()
@@ -116,13 +116,13 @@ export function create<State, DraftApi>(options: Options<State, DraftApi>): Inte
           )
           yield* Scope.addFinalizer(scope, dispose)
           const batch = yield* CurrentBatch
-          if (batch) batch.add(reload)
-          else yield* reload()
+          if (batch) batch.add(rebuild)
+          else yield* rebuild()
           return { dispose }
         }),
       )
     }),
-    reload,
+    rebuild,
   }
   return result
 }

packages/core/src/tool/skill.ts

@@ -5,6 +5,7 @@ import { pathToFileURL } from "url"
 import { ToolFailure } from "@opencode-ai/llm"
 import { Effect, Layer, Schema } from "effect"
 import { FSUtil } from "../fs-util"
+import { PluginBoot } from "../plugin/boot"
 import { SkillV2 } from "../skill"
 import { PermissionV2 } from "../permission"
 import { Tool } from "./tool"
@@ -57,8 +58,10 @@ export const layer = Layer.effectDiscard(
   Effect.gen(function* () {
     const tools = yield* Tools.Service
     const fs = yield* FSUtil.Service
+    const boot = yield* PluginBoot.Service
     const skills = yield* SkillV2.Service
     const permission = yield* PermissionV2.Service
+    yield* boot.wait()
     yield* tools
       .register({
         [name]: Tool.make({

packages/core/test/agent.test.ts

@@ -50,7 +50,7 @@ describe("AgentV2", () => {
       )
       description = "New description"
       hidden = false
-      yield* agent.reload()
+      yield* agent.rebuild()
 
       expect(yield* agent.get(id)).toMatchObject({ description: "New description", hidden: false })
     }),
@@ -104,12 +104,8 @@ describe("AgentV2", () => {
       yield* AgentPlugin.Plugin.effect(
         host({
           agent: agentHost(agent),
+          location: location({ directory: AbsolutePath.make("/project") }),
         }),
-      ).pipe(
-        Effect.provideService(
-          Location.Service,
-          Location.Service.of(location({ directory: AbsolutePath.make("/project") })),
-        ),
       )
 
       const agents = yield* agent.all()

packages/core/test/catalog.test.ts

@@ -259,7 +259,7 @@ describe("CatalogV2", () => {
       expect((yield* catalog.model.default())?.id).toBe(old)
 
       configured = false
-      yield* catalog.reload()
+      yield* catalog.rebuild()
       expect((yield* catalog.model.default())?.id).toBe(newest)
     }),
   )

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

@@ -42,7 +42,7 @@ Review files`,
           })
 
           const command = yield* CommandV2.Service
-          yield* ConfigCommandPlugin.Plugin.effect(host({ command: { ...command, reload: command.reload } })).pipe(
+          yield* ConfigCommandPlugin.Plugin.effect(host({ command })).pipe(
             Effect.provideService(
               Config.Service,
               Config.Service.of({

packages/core/test/config/fixtures/plugin/directory-plugin.ts

@@ -1,13 +0,0 @@
-import { define } from "@opencode-ai/plugin/v2/promise"
-
-export default define({
-  id: "directory-plugin",
-  setup: async (ctx) => {
-    await ctx.agent.transform((agents) => {
-      agents.update("directory", (agent) => {
-        agent.description = "Loaded from plugin directory"
-        agent.mode = "subagent"
-      })
-    })
-  },
-})

packages/core/test/config/plugin.test.ts

@@ -1,248 +0,0 @@
-import path from "path"
-import { describe, expect } from "bun:test"
-import { Effect, Schema } from "effect"
-import { AgentV2 } from "@opencode-ai/core/agent"
-import { Config } from "@opencode-ai/core/config"
-import { ConfigExternalPlugin } from "@opencode-ai/core/config/plugin/external"
-import { FSUtil } from "@opencode-ai/core/fs-util"
-import { Location } from "@opencode-ai/core/location"
-import { Npm } from "@opencode-ai/core/npm"
-import { PluginV2 } from "@opencode-ai/core/plugin"
-import { PluginHost } from "@opencode-ai/core/plugin/host"
-import { AbsolutePath } from "@opencode-ai/core/schema"
-import { testEffect } from "../lib/effect"
-import { PluginTestLayer } from "../plugin/fixture"
-
-const it = testEffect(PluginTestLayer)
-const decode = Schema.decodeUnknownSync(Config.Info)
-
-describe("ConfigExternalPlugin", () => {
-  it.live("resolves and loads a configured Promise plugin with options", () =>
-    Effect.gen(function* () {
-      const plugins = yield* PluginV2.Service
-      const agents = yield* AgentV2.Service
-      const fs = yield* FSUtil.Service
-      const location = yield* Location.Service
-      const npm = yield* Npm.Service
-      const host = yield* PluginHost.make(plugins)
-      const document = path.join(import.meta.dir, "config.json")
-
-      yield* ConfigExternalPlugin.Plugin.effect(host).pipe(
-        Effect.provideService(PluginV2.Service, plugins),
-        Effect.provideService(FSUtil.Service, fs),
-        Effect.provideService(Location.Service, location),
-        Effect.provideService(Npm.Service, npm),
-        Effect.provideService(
-          Config.Service,
-          Config.Service.of({
-            entries: () =>
-              Effect.succeed([
-                new Config.Document({
-                  type: "document",
-                  path: document,
-                  info: decode({
-                    plugins: [
-                      {
-                        package: "../plugin/fixtures/config-promise-plugin.ts",
-                        options: { description: "Loaded from config" },
-                      },
-                    ],
-                  }),
-                }),
-              ]),
-          }),
-        ),
-      )
-
-      expect(yield* waitForAgent(agents, "configured")).toMatchObject({
-        description: "Loaded from config",
-        mode: "subagent",
-      })
-    }),
-  )
-
-  it.live("loads a configured Effect plugin with options", () =>
-    Effect.gen(function* () {
-      const plugins = yield* PluginV2.Service
-      const agents = yield* AgentV2.Service
-      const fs = yield* FSUtil.Service
-      const location = yield* Location.Service
-      const npm = yield* Npm.Service
-      const host = yield* PluginHost.make(plugins)
-
-      yield* ConfigExternalPlugin.Plugin.effect(host).pipe(
-        Effect.provideService(PluginV2.Service, plugins),
-        Effect.provideService(FSUtil.Service, fs),
-        Effect.provideService(Location.Service, location),
-        Effect.provideService(Npm.Service, npm),
-        Effect.provideService(
-          Config.Service,
-          Config.Service.of({
-            entries: () =>
-              Effect.succeed([
-                new Config.Document({
-                  type: "document",
-                  path: path.join(import.meta.dir, "config.json"),
-                  info: decode({
-                    plugins: [
-                      {
-                        package: "../plugin/fixtures/config-effect-plugin.ts",
-                        options: { description: "Effect plugin from config" },
-                      },
-                    ],
-                  }),
-                }),
-              ]),
-          }),
-        ),
-      )
-
-      expect(yield* waitForAgent(agents, "effect-configured")).toMatchObject({
-        description: "Effect plugin from config",
-        mode: "subagent",
-      })
-    }),
-  )
-
-  it.live("ignores invalid plugins and continues loading", () =>
-    Effect.gen(function* () {
-      const plugins = yield* PluginV2.Service
-      const agents = yield* AgentV2.Service
-      const fs = yield* FSUtil.Service
-      const location = yield* Location.Service
-      const npm = yield* Npm.Service
-      const host = yield* PluginHost.make(plugins)
-
-      yield* ConfigExternalPlugin.Plugin.effect(host).pipe(
-        Effect.provideService(PluginV2.Service, plugins),
-        Effect.provideService(FSUtil.Service, fs),
-        Effect.provideService(Location.Service, location),
-        Effect.provideService(Npm.Service, npm),
-        Effect.provideService(
-          Config.Service,
-          Config.Service.of({
-            entries: () =>
-              Effect.succeed([
-                new Config.Document({
-                  type: "document",
-                  path: path.join(import.meta.dir, "config.json"),
-                  info: decode({
-                    plugins: [
-                      "../plugin/fixtures/missing-plugin.ts",
-                      "../plugin/fixtures/invalid-plugin.ts",
-                      {
-                        package: "../plugin/fixtures/config-promise-plugin.ts",
-                        options: { description: "Loaded after invalid plugins" },
-                      },
-                    ],
-                  }),
-                }),
-              ]),
-          }),
-        ),
-      )
-
-      expect(yield* waitForAgent(agents, "configured")).toMatchObject({
-        description: "Loaded after invalid plugins",
-      })
-    }),
-  )
-
-  it.live("installs and resolves npm plugin packages", () =>
-    Effect.gen(function* () {
-      const plugins = yield* PluginV2.Service
-      const agents = yield* AgentV2.Service
-      const fs = yield* FSUtil.Service
-      const location = yield* Location.Service
-      const host = yield* PluginHost.make(plugins)
-      let installed: string | undefined
-      const npm = Npm.Service.of({
-        add: (spec) =>
-          Effect.sync(() => {
-            installed = spec
-            return {
-              directory: import.meta.dir,
-              entrypoint: path.join(import.meta.dir, "../plugin/fixtures/config-promise-plugin.ts"),
-            }
-          }),
-        install: () => Effect.void,
-        which: () => Effect.succeed(undefined),
-      })
-
-      yield* ConfigExternalPlugin.Plugin.effect(host).pipe(
-        Effect.provideService(PluginV2.Service, plugins),
-        Effect.provideService(FSUtil.Service, fs),
-        Effect.provideService(Location.Service, location),
-        Effect.provideService(Npm.Service, npm),
-        Effect.provideService(
-          Config.Service,
-          Config.Service.of({
-            entries: () =>
-              Effect.succeed([
-                new Config.Document({
-                  type: "document",
-                  info: decode({
-                    plugins: [
-                      {
-                        package: "example-plugin@1.0.0",
-                        options: { description: "Installed from npm" },
-                      },
-                    ],
-                  }),
-                }),
-              ]),
-          }),
-        ),
-      )
-
-      expect(yield* waitForAgent(agents, "configured")).toMatchObject({
-        description: "Installed from npm",
-      })
-      expect(installed).toBe("example-plugin@1.0.0")
-    }),
-  )
-
-  it.live("loads plugin files from config directories", () =>
-    Effect.gen(function* () {
-      const plugins = yield* PluginV2.Service
-      const agents = yield* AgentV2.Service
-      const fs = yield* FSUtil.Service
-      const location = yield* Location.Service
-      const npm = yield* Npm.Service
-      const host = yield* PluginHost.make(plugins)
-
-      yield* ConfigExternalPlugin.Plugin.effect(host).pipe(
-        Effect.provideService(PluginV2.Service, plugins),
-        Effect.provideService(FSUtil.Service, fs),
-        Effect.provideService(Location.Service, location),
-        Effect.provideService(Npm.Service, npm),
-        Effect.provideService(
-          Config.Service,
-          Config.Service.of({
-            entries: () =>
-              Effect.succeed([
-                new Config.Directory({
-                  type: "directory",
-                  path: AbsolutePath.make(path.join(import.meta.dir, "fixtures")),
-                }),
-              ]),
-          }),
-        ),
-      )
-
-      expect(yield* waitForAgent(agents, "directory")).toMatchObject({
-        description: "Loaded from plugin directory",
-        mode: "subagent",
-      })
-    }),
-  )
-})
-
-const waitForAgent = Effect.fnUntraced(function* (agents: AgentV2.Interface, id: string) {
-  for (let attempt = 0; attempt < 100; attempt++) {
-    const agent = yield* agents.get(AgentV2.ID.make(id))
-    if (agent) return agent
-    yield* Effect.sleep("10 millis")
-  }
-  return yield* Effect.die(`Timed out waiting for agent ${id}`)
-})

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

@@ -15,8 +15,11 @@ const it = testEffect(PluginTestLayer)
 
 const addPlugin = Effect.fn(function* (config: Config.Interface) {
   const plugin = yield* PluginV2.Service
-  const host = yield* PluginHost.make(plugin)
-  yield* ConfigProviderPlugin.Plugin.effect(host).pipe(Effect.provideService(Config.Service, config))
+  const host = yield* PluginHost.make()
+  yield* plugin.add({
+    ...ConfigProviderPlugin.Plugin,
+    effect: ConfigProviderPlugin.Plugin.effect(host).pipe(Effect.provideService(Config.Service, config)),
+  })
 })
 
 function required<T>(value: T | undefined): T {

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

@@ -36,11 +36,16 @@ describe("ConfigSkillPlugin.Plugin", () => {
 
       yield* ConfigSkillPlugin.Plugin.effect(
         host({
-          skill: { transform, reload: () => Effect.void },
+          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(Global.Service, Global.Service.of({ ...Global.make(), home: "/home/test" })),
-        Effect.provideService(Location.Service, Location.Service.of(location({ directory }))),
         Effect.provideService(
           Config.Service,
           Config.Service.of({

packages/core/test/database-migration.test.ts

@@ -14,8 +14,6 @@ import sessionMessageProjectionOrderMigration from "@opencode-ai/core/database/m
 import eventSourcedSessionInputMigration from "@opencode-ai/core/database/migration/20260604172448_event_sourced_session_input"
 import contextEpochAgentMigration from "@opencode-ai/core/database/migration/20260605042240_add_context_epoch_agent"
 import simplifyIntegrationCredentialsMigration from "@opencode-ai/core/database/migration/20260611192811_lush_chimera"
-import simplifySessionInputMigration from "@opencode-ai/core/database/migration/20260622202450_simplify_session_input"
-import { EventV2 } from "@opencode-ai/core/event"
 import { ProjectV2 } from "@opencode-ai/core/project"
 import { ProjectTable } from "@opencode-ai/core/project/sql"
 import { AbsolutePath } from "@opencode-ai/core/schema"
@@ -24,8 +22,6 @@ import { SessionTable } from "@opencode-ai/core/session/sql"
 import sessionMetadataMigration from "@opencode-ai/core/database/migration/20260511173437_session-metadata"
 import type { SqlClient as SqlClientService } from "effect/unstable/sql/SqlClient"
 import { Database } from "@opencode-ai/core/database/database"
-import { SessionProjector } from "@opencode-ai/core/session/projector"
-import { SessionV1 } from "@opencode-ai/core/v1/session"
 import { tmpdir } from "./fixture/tmpdir"
 
 const run = <A, E>(effect: Effect.Effect<A, E, SqlClientService>) =>
@@ -230,94 +226,6 @@ describe("DatabaseMigration", () => {
     )
   })
 
-  test("preserves canonical V1 state and restarts its event stream", async () => {
-    await run(
-      Effect.gen(function* () {
-        const db = yield* makeDb
-        yield* db.run(sql`PRAGMA foreign_keys = ON`)
-        yield* DatabaseMigration.apply(db)
-        yield* db.run(
-          sql`INSERT INTO project (id, worktree, time_created, time_updated, sandboxes) VALUES ('global', '/project', 1, 1, '[]')`,
-        )
-        yield* db.run(
-          sql`INSERT INTO workspace (id, type, project_id, time_used) VALUES ('workspace', 'local', 'global', 1)`,
-        )
-        yield* db.run(
-          sql`INSERT INTO session (id, project_id, workspace_id, slug, directory, title, version, time_created, time_updated) VALUES ('session', 'global', 'workspace', 'session', '/project', 'Before', 'test', 1, 1)`,
-        )
-        yield* db.run(
-          sql`INSERT INTO message (id, session_id, time_created, time_updated, data) VALUES ('message', 'session', 1, 1, '{}')`,
-        )
-        yield* db.run(
-          sql`INSERT INTO part (id, message_id, session_id, time_created, time_updated, data) VALUES ('part', 'message', 'session', 1, 1, '{}')`,
-        )
-        yield* db.run(sql`INSERT INTO event_sequence (aggregate_id, seq) VALUES ('session', 9)`)
-        yield* db.run(
-          sql`INSERT INTO event (id, aggregate_id, seq, type, data) VALUES ('event', 'session', 9, 'session.updated.1', '{}')`,
-        )
-        yield* db.run(
-          sql`INSERT INTO session_input (id, session_id, prompt, delivery, admitted_seq, time_created) VALUES ('input', 'session', '{}', 'steer', 9, 1)`,
-        )
-        yield* db.run(
-          sql`INSERT INTO session_message (id, session_id, type, seq, time_created, time_updated, data) VALUES ('projected', 'session', 'user', 9, 1, 1, '{}')`,
-        )
-        yield* db.run(
-          sql`INSERT INTO session_context_epoch (session_id, baseline, snapshot, baseline_seq) VALUES ('session', 'baseline', '{}', 9)`,
-        )
-        yield* db.run(sql`DELETE FROM migration WHERE id = ${simplifySessionInputMigration.id}`)
-        yield* DatabaseMigration.applyOnly(db, [simplifySessionInputMigration])
-
-        const database = Layer.succeed(Database.Service, { db })
-        const events = EventV2.layer.pipe(Layer.provide(database))
-        yield* EventV2.Service.use((service) =>
-          service.publish(SessionV1.Event.Updated, {
-            sessionID: SessionSchema.ID.make("session"),
-            info: {
-              id: SessionSchema.ID.make("session"),
-              slug: "session",
-              projectID: ProjectV2.ID.global,
-              directory: "/project",
-              title: "After",
-              version: "test",
-              time: { created: 1, updated: 2 },
-            },
-          }),
-        ).pipe(
-          Effect.provide(
-            Layer.merge(events, SessionProjector.layer.pipe(Layer.provide(events), Layer.provide(database))),
-          ),
-        )
-
-        expect(
-          yield* db.get(sql`
-            SELECT
-              (SELECT title FROM session WHERE id = 'session') AS title,
-              (SELECT workspace_id FROM session WHERE id = 'session') AS workspaceID,
-              (SELECT COUNT(*) FROM message WHERE id = 'message') AS messages,
-              (SELECT COUNT(*) FROM part WHERE id = 'part') AS parts,
-              (SELECT COUNT(*) FROM workspace) AS workspaces,
-              (SELECT COUNT(*) FROM session_input) AS sessionInputs,
-              (SELECT COUNT(*) FROM session_message) AS sessionMessages,
-              (SELECT COUNT(*) FROM session_context_epoch) AS contextEpochs,
-              (SELECT seq FROM event_sequence WHERE aggregate_id = 'session') AS seq,
-              (SELECT type FROM event WHERE aggregate_id = 'session') AS eventType
-          `),
-        ).toEqual({
-          title: "After",
-          workspaceID: null,
-          messages: 1,
-          parts: 1,
-          workspaces: 0,
-          sessionInputs: 0,
-          sessionMessages: 0,
-          contextEpochs: 0,
-          seq: 0,
-          eventType: "session.updated.1",
-        })
-      }),
-    )
-  })
-
   test("resets incompatible projected Session messages before adding sequence order", async () => {
     await run(
       Effect.gen(function* () {

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

@@ -1,15 +1,15 @@
 import fs from "fs/promises"
 import path from "path"
 import { describe, expect } from "bun:test"
-import { DateTime, Effect, Equal, Hash, Layer, Schema } from "effect"
+import { DateTime, 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"
-import { PluginV2 } from "@opencode-ai/core/plugin"
 import { ModelV2 } from "@opencode-ai/core/model"
+import { PluginBoot } from "@opencode-ai/core/plugin/boot"
 import { ProjectV2 } from "@opencode-ai/core/project"
 import { ProviderV2 } from "@opencode-ai/core/provider"
 import { AbsolutePath } from "@opencode-ai/core/schema"
@@ -88,6 +88,7 @@ describe("LocationServiceMap", () => {
 
           const update = (directory: string) =>
             Effect.gen(function* () {
+              yield* PluginBoot.Service.use((boot) => boot.wait())
               yield* Reference.Service
               const catalog = yield* Catalog.Service
               yield* catalog.transform((editor) => editor.provider.update(ProviderV2.ID.make("test"), () => {}))
@@ -196,21 +197,36 @@ describe("LocationServiceMap", () => {
     ).pipe(
       Effect.flatMap((dir) =>
         Effect.gen(function* () {
-          const plugins = yield* PluginV2.Service
-          const reviewer = define({
-            id: "reviewer",
-            effect: (ctx) =>
-              ctx.agent
-                .transform((agent) => {
-                  agent.update("reviewer", (item) => {
-                    item.description = "Reviews code"
-                    item.mode = "subagent"
+          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"
+                    })
                   })
-                })
-                .pipe(Effect.asVoid),
-          })
-          yield* plugins.add(PluginV2.ID.make(reviewer.id), reviewer.effect)
+                  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",

packages/core/test/plugin.test.ts

@@ -1,43 +1,127 @@
 import { describe, expect } from "bun:test"
-import { Effect } from "effect"
-import { define } from "@opencode-ai/plugin/v2/effect"
-import { AgentV2 } from "@opencode-ai/core/agent"
+import { Context, Deferred, Effect, Exit, Fiber, Layer, Scope } from "effect"
+import { EventV2 } from "@opencode-ai/core/event"
 import { PluginV2 } from "@opencode-ai/core/plugin"
-import { testEffect } from "./lib/effect"
-import { PluginTestLayer } from "./plugin/fixture"
+import { State } from "@opencode-ai/core/state"
+import { it } from "./lib/effect"
 
-const it = testEffect(PluginTestLayer)
+const events = Layer.mock(EventV2.Service)({
+  publish: (definition, data) =>
+    Effect.succeed({
+      id: EventV2.ID.make("evt_plugin_test"),
+      type: definition.type,
+      data,
+    }),
+})
+const plugins = PluginV2.layer.pipe(Layer.provide(events))
+
+function state() {
+  return State.create({
+    initial: () => ({ values: [] as string[] }),
+    draft: (draft) => ({
+      add: (value: string) => draft.values.push(value),
+    }),
+  })
+}
 
 describe("PluginV2", () => {
-  it.effect("adds, replaces, and removes plugins", () =>
+  it.effect("closes plugin-owned scopes when the registry layer finalizes", () =>
     Effect.gen(function* () {
-      const plugins = yield* PluginV2.Service
-      const agents = yield* AgentV2.Service
-      let description = "first"
+      const values = state()
+      const layerScope = yield* Scope.fork(yield* Scope.Scope)
+      const plugin = Context.get(yield* Layer.buildWithScope(Layer.fresh(plugins), layerScope), PluginV2.Service)
 
-      const managed = () =>
-        define({
-          id: "managed",
-          effect: (ctx) =>
-            ctx.agent
-              .transform((agents) =>
-                agents.update("configured", (agent) => {
-                  agent.description = description
-                }),
-              )
-              .pipe(Effect.asVoid),
+      yield* plugin.add({
+        id: PluginV2.ID.make("scoped"),
+        effect: Effect.gen(function* () {
+          yield* values.transform((editor) => {
+            editor.add("scoped")
+          })
+        }),
+      })
+      expect(values.get().values).toEqual(["scoped"])
+
+      yield* Scope.close(layerScope, Exit.void)
+      expect(values.get().values).toEqual([])
+    }),
+  )
+
+  it.effect("batches plugin state rebuilds when the registry layer finalizes", () =>
+    Effect.gen(function* () {
+      let finalized = 0
+      const values = State.create({
+        initial: () => ({ values: [] as string[] }),
+        draft: (draft) => ({ add: (value: string) => draft.values.push(value) }),
+        finalize: () => Effect.sync(() => finalized++),
+      })
+      const layerScope = yield* Scope.fork(yield* Scope.Scope)
+      const plugin = Context.get(yield* Layer.buildWithScope(Layer.fresh(plugins), layerScope), PluginV2.Service)
+
+      yield* State.batch(
+        Effect.forEach(
+          ["first", "second"],
+          (id) =>
+            plugin.add({
+              id: PluginV2.ID.make(id),
+              effect: values
+                .transform((editor) => {
+                  editor.add(id)
+                })
+                .pipe(Effect.asVoid),
+            }),
+          { discard: true },
+        ),
+      )
+      finalized = 0
+
+      yield* Scope.close(layerScope, Exit.void)
+      expect(values.get().values).toEqual([])
+      expect(finalized).toBe(1)
+    }),
+  )
+
+  it.effect("serializes same-ID additions and leaves one removable attachment", () =>
+    Effect.gen(function* () {
+      const values = state()
+      const layerScope = yield* Scope.fork(yield* Scope.Scope)
+      const plugin = Context.get(yield* Layer.buildWithScope(Layer.fresh(plugins), layerScope), PluginV2.Service)
+      const id = PluginV2.ID.make("shared")
+      const firstStarted = yield* Deferred.make<void>()
+      const releaseFirst = yield* Deferred.make<void>()
+
+      const first = yield* plugin
+        .add({
+          id,
+          effect: Effect.gen(function* () {
+            yield* values.transform((editor) => {
+              editor.add("first")
+            })
+            yield* Deferred.succeed(firstStarted, undefined)
+            yield* Deferred.await(releaseFirst)
+          }),
         })
+        .pipe(Effect.forkChild)
+      yield* Deferred.await(firstStarted)
 
-      yield* plugins.add(PluginV2.ID.make("managed"), managed().effect)
+      const second = yield* plugin
+        .add({
+          id,
+          effect: Effect.gen(function* () {
+            yield* values.transform((editor) => {
+              editor.add("second")
+            })
+          }),
+        })
+        .pipe(Effect.forkChild({ startImmediately: true }))
+      expect(values.get().values).toEqual(["first"])
 
-      expect((yield* agents.get(AgentV2.ID.make("configured")))?.description).toBe("first")
+      yield* Deferred.succeed(releaseFirst, undefined)
+      yield* Fiber.join(first)
+      yield* Fiber.join(second)
+      expect(values.get().values).toEqual(["second"])
 
-      description = "second"
-      yield* plugins.add(PluginV2.ID.make("managed"), managed().effect)
-      expect((yield* agents.get(AgentV2.ID.make("configured")))?.description).toBe("second")
-
-      yield* plugins.remove(PluginV2.ID.make("managed"))
-      expect(yield* agents.get(AgentV2.ID.make("configured"))).toBeUndefined()
+      yield* plugin.remove(id)
+      expect(values.get().values).toEqual([])
     }),
   )
 })

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

@@ -24,13 +24,9 @@ describe("CommandPlugin.Plugin", () => {
       const command = yield* CommandV2.Service
       yield* CommandPlugin.Plugin.effect(
         host({
-          command: { transform: command.transform, reload: command.reload },
+          command,
+          location: location({ directory }, { projectDirectory: project }),
         }),
-      ).pipe(
-        Effect.provideService(
-          Location.Service,
-          Location.Service.of(location({ directory }, { projectDirectory: project })),
-        ),
       )
 
       expect(yield* command.get("init")).toMatchObject({

packages/core/test/plugin/fixture.ts

@@ -1,3 +1,6 @@
+import { AgentV2 } from "@opencode-ai/core/agent"
+import { Catalog } from "@opencode-ai/core/catalog"
+import { CommandV2 } from "@opencode-ai/core/command"
 import { Credential } from "@opencode-ai/core/credential"
 import { EventV2 } from "@opencode-ai/core/event"
 import { FileSystem } from "@opencode-ai/core/filesystem"
@@ -5,13 +8,23 @@ import { FSUtil } from "@opencode-ai/core/fs-util"
 import { Global } from "@opencode-ai/core/global"
 import { Npm } from "@opencode-ai/core/npm"
 import { PluginV2 } from "@opencode-ai/core/plugin"
+import { Reference } from "@opencode-ai/core/reference"
 import { RepositoryCache } from "@opencode-ai/core/repository-cache"
 import { Ripgrep } from "@opencode-ai/core/ripgrep"
+import { SkillV2 } from "@opencode-ai/core/skill"
 import { SkillDiscovery } from "@opencode-ai/core/skill/discovery"
 import { Effect, Layer } from "effect"
 import { tempLocationLayer } from "../fixture/location"
 
-export const PluginTestLayer = Layer.mergeAll(FileSystem.locationLayer, PluginV2.locationLayer).pipe(
+export const PluginTestLayer = Layer.mergeAll(
+  AgentV2.locationLayer,
+  CommandV2.locationLayer,
+  Catalog.locationLayer,
+  FileSystem.locationLayer,
+  PluginV2.locationLayer,
+  Reference.locationLayer,
+  SkillV2.locationLayer,
+).pipe(
   Layer.provideMerge(
     Layer.mergeAll(
       Credential.defaultLayer,

packages/core/test/plugin/fixtures/config-effect-plugin.ts

@@ -1,15 +0,0 @@
-import { define } from "@opencode-ai/plugin/v2/effect"
-import { Effect } from "effect"
-
-export default define({
-  id: "config-effect-plugin",
-  effect: (ctx) =>
-    ctx.agent
-      .transform((agents) => {
-        agents.update("effect-configured", (agent) => {
-          agent.description = ctx.options.description
-          agent.mode = "subagent"
-        })
-      })
-      .pipe(Effect.asVoid),
-})

packages/core/test/plugin/fixtures/config-promise-plugin.ts

@@ -1,13 +0,0 @@
-import { define } from "@opencode-ai/plugin/v2/promise"
-
-export default define({
-  id: "config-promise-plugin",
-  setup: async (ctx) => {
-    await ctx.agent.transform((agents) => {
-      agents.update("configured", (agent) => {
-        agent.description = ctx.options.description
-        agent.mode = "subagent"
-      })
-    })
-  },
-})

packages/core/test/plugin/fixtures/invalid-plugin.ts

@@ -1 +0,0 @@
-export default {}

packages/core/test/plugin/host.ts

@@ -1,55 +1,120 @@
-import type { PluginContext } from "@opencode-ai/plugin/v2/effect"
+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 } from "effect"
+import { Effect, Stream } from "effect"
 
-type Overrides = Partial<Omit<PluginContext, "options">>
-
-export function host(overrides: Overrides = {}): PluginContext {
+export function host(overrides: Partial<PluginHost> = {}): PluginHost {
   return {
-    options: {},
-    agent: overrides.agent ?? {
+    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"),
-      reload: () => Effect.die("unused agent.reload"),
     },
-    aisdk: overrides.aisdk ?? {
-      sdk: () => Effect.die("unused aisdk.sdk"),
-      language: () => Effect.die("unused aisdk.language"),
-    },
-    catalog: overrides.catalog ?? {
+    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"),
-      reload: () => Effect.die("unused catalog.reload"),
     },
-    command: overrides.command ?? {
+    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"),
-      reload: () => Effect.die("unused command.reload"),
     },
-    integration: overrides.integration ?? {
+    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"),
-      reload: () => Effect.die("unused integration.reload"),
     },
-    plugin: overrides.plugin ?? {
-      add: () => Effect.die("unused plugin.add"),
-      remove: () => Effect.die("unused plugin.remove"),
+    location: {
+      directory: "/unused/location",
+      project: { directory: "/unused/project" },
     },
-    reference: overrides.reference ?? {
+    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"),
-      reload: () => Effect.die("unused reference.reload"),
     },
-    skill: overrides.skill ?? {
+    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"),
-      reload: () => Effect.die("unused skill.reload"),
+    },
+    ...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): PluginContext["agent"] {
+export function agentHost(agent: AgentV2.Interface): PluginHost["agent"] {
   return {
-    reload: agent.reload,
+    ...host().agent,
     transform: (callback) =>
       agent.transform((draft) =>
         callback({
@@ -71,9 +136,10 @@ export function agentHost(agent: AgentV2.Interface): PluginContext["agent"] {
   }
 }
 
-export function catalogHost(catalog: Catalog.Interface): PluginContext["catalog"] {
+export function catalogHost(catalog: Catalog.Interface): PluginHost["catalog"] {
   return {
-    reload: catalog.reload,
+    ...host().catalog,
+    rebuild: catalog.rebuild,
     transform: (callback) =>
       catalog.transform((draft) =>
         callback({
@@ -135,9 +201,17 @@ export function catalogHost(catalog: Catalog.Interface): PluginContext["catalog"
   }
 }
 
-export function integrationHost(integration: Integration.Interface): PluginContext["integration"] {
+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 {
-    reload: integration.reload,
+    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({

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

@@ -1,13 +1,15 @@
 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"
+import { Database } from "@opencode-ai/core/database/database"
 import { EventV2 } from "@opencode-ai/core/event"
 import { Flag } from "@opencode-ai/core/flag/flag"
 import { Location } from "@opencode-ai/core/location"
 import { ModelsDev } from "@opencode-ai/core/models-dev"
+import { PluginV2 } from "@opencode-ai/core/plugin"
 import { ModelsDevPlugin } from "@opencode-ai/core/plugin/models-dev"
 import { Policy } from "@opencode-ai/core/policy"
 import { AbsolutePath } from "@opencode-ai/core/schema"
@@ -20,13 +22,21 @@ const locationLayer = Layer.succeed(
   Location.Service,
   Location.Service.of(location({ directory: AbsolutePath.make(import.meta.dir) })),
 )
+const plugins = PluginV2.layer.pipe(Layer.provide(events))
 const policy = Policy.layer.pipe(Layer.provide(locationLayer))
 const connections = Credential.defaultLayer.pipe(Layer.fresh)
 const integrations = Integration.locationLayer.pipe(Layer.provide(events), Layer.provide(connections))
 const catalog = Catalog.layer.pipe(
-  Layer.provide(Layer.mergeAll(events, locationLayer, policy, connections, integrations)),
+  Layer.provide(Layer.mergeAll(events, locationLayer, plugins, policy, connections, integrations)),
+)
+const layer = Layer.mergeAll(
+  catalog.pipe(Layer.provide(connections)),
+  integrations,
+  connections,
+  events,
+  locationLayer,
+  plugins,
 )
-const layer = Layer.mergeAll(catalog.pipe(Layer.provide(connections)), integrations, connections, events, locationLayer)
 const it = testEffect(layer)
 
 describe("ModelsDevPlugin", () => {
@@ -48,6 +58,7 @@ describe("ModelsDevPlugin", () => {
           yield* ModelsDevPlugin.effect(
             host({
               catalog: catalogHost(catalog),
+              event: { subscribe: () => Stream.never },
               integration: integrationHost(integrations),
             }),
           )

packages/core/test/plugin/promise.test.ts

@@ -1,67 +0,0 @@
-import { describe, expect } from "bun:test"
-import { Effect } from "effect"
-import { AgentV2 } from "@opencode-ai/core/agent"
-import { PluginV2 } from "@opencode-ai/core/plugin"
-import { PluginHost } from "@opencode-ai/core/plugin/host"
-import { PluginPromise } from "@opencode-ai/core/plugin/promise"
-import { define } from "@opencode-ai/plugin/v2/promise"
-import { testEffect } from "../lib/effect"
-import { PluginTestLayer } from "./fixture"
-
-const it = testEffect(PluginTestLayer)
-
-describe("fromPromise", () => {
-  it.effect("loads a promise plugin and registers a transform hook", () =>
-    Effect.gen(function* () {
-      const agents = yield* AgentV2.Service
-      const plugin = yield* PluginV2.Service
-      const host = yield* PluginHost.make(plugin)
-
-      const promisePlugin = define({
-        id: "promise-example",
-        setup: async (ctx) => {
-          expect(ctx.options.mode).toBe("strict")
-          await ctx.agent.transform((draft) => {
-            draft.update("reviewer", (item) => {
-              item.description = "Reviews code"
-              item.mode = "subagent"
-            })
-          })
-        },
-      })
-
-      const adapted = PluginPromise.fromPromise(promisePlugin)
-      yield* adapted.effect({ ...host, options: { mode: "strict" } })
-
-      expect(yield* agents.get(AgentV2.ID.make("reviewer"))).toMatchObject({
-        description: "Reviews code",
-        mode: "subagent",
-      })
-    }),
-  )
-
-  it.effect("disposes a hook registration on request", () =>
-    Effect.gen(function* () {
-      const agents = yield* AgentV2.Service
-      const plugin = yield* PluginV2.Service
-      const host = yield* PluginHost.make(plugin)
-
-      const promisePlugin = define({
-        id: "promise-dispose",
-        setup: async (ctx) => {
-          const registration = await ctx.agent.transform((draft) => {
-            draft.update("temp", (item) => {
-              item.description = "temporary"
-            })
-          })
-          await registration.dispose()
-        },
-      })
-
-      const adapted = PluginPromise.fromPromise(promisePlugin)
-      yield* adapted.effect(host)
-
-      expect(yield* agents.get(AgentV2.ID.make("temp"))).toBeUndefined()
-    }),
-  )
-})

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

@@ -1,4 +1,3 @@
-import { AISDK } from "@opencode-ai/core/aisdk"
 import { describe, expect } from "bun:test"
 import { createAlibaba } from "@ai-sdk/alibaba"
 import { Effect } from "effect"
@@ -14,25 +13,27 @@ const it = testEffect(PluginTestLayer)
 
 const addPlugin = Effect.fn(function* () {
   const plugin = yield* PluginV2.Service
-  const aisdk = yield* AISDK.Service
-  const host = yield* PluginHost.make(plugin)
-  yield* AlibabaPlugin.effect(host)
+  const host = yield* PluginHost.make()
+  yield* plugin.add({ id: AlibabaPlugin.id, effect: AlibabaPlugin.effect(host) })
 })
 
 describe("AlibabaPlugin", () => {
   it.effect("creates an Alibaba SDK for @ai-sdk/alibaba", () =>
     Effect.gen(function* () {
       const plugin = yield* PluginV2.Service
-      const aisdk = yield* AISDK.Service
       yield* addPlugin()
-      const result = yield* aisdk.runSDK({
-        model: new ModelV2.Info({
-          ...ModelV2.Info.empty(ProviderV2.ID.make("alibaba"), ModelV2.ID.make("qwen")),
-          api: { id: ModelV2.ID.make("qwen"), type: "aisdk", package: "test-provider" },
-        }),
-        package: "@ai-sdk/alibaba",
-        options: { name: "alibaba" },
-      })
+      const result = yield* plugin.trigger(
+        "aisdk.sdk",
+        {
+          model: new ModelV2.Info({
+            ...ModelV2.Info.empty(ProviderV2.ID.make("alibaba"), ModelV2.ID.make("qwen")),
+            api: { id: ModelV2.ID.make("qwen"), type: "aisdk", package: "test-provider" },
+          }),
+          package: "@ai-sdk/alibaba",
+          options: { name: "alibaba" },
+        },
+        {},
+      )
       expect(result.sdk).toBeDefined()
     }),
   )
@@ -40,16 +41,19 @@ describe("AlibabaPlugin", () => {
   it.effect("ignores non-Alibaba SDK packages", () =>
     Effect.gen(function* () {
       const plugin = yield* PluginV2.Service
-      const aisdk = yield* AISDK.Service
       yield* addPlugin()
-      const result = yield* aisdk.runSDK({
-        model: new ModelV2.Info({
-          ...ModelV2.Info.empty(ProviderV2.ID.make("alibaba"), ModelV2.ID.make("qwen")),
-          api: { id: ModelV2.ID.make("qwen"), type: "aisdk", package: "test-provider" },
-        }),
-        package: "@ai-sdk/openai-compatible",
-        options: { name: "alibaba" },
-      })
+      const result = yield* plugin.trigger(
+        "aisdk.sdk",
+        {
+          model: new ModelV2.Info({
+            ...ModelV2.Info.empty(ProviderV2.ID.make("alibaba"), ModelV2.ID.make("qwen")),
+            api: { id: ModelV2.ID.make("qwen"), type: "aisdk", package: "test-provider" },
+          }),
+          package: "@ai-sdk/openai-compatible",
+          options: { name: "alibaba" },
+        },
+        {},
+      )
       expect(result.sdk).toBeUndefined()
     }),
   )
@@ -57,16 +61,19 @@ describe("AlibabaPlugin", () => {
   it.effect("matches the old bundled Alibaba SDK provider naming", () =>
     Effect.gen(function* () {
       const plugin = yield* PluginV2.Service
-      const aisdk = yield* AISDK.Service
       yield* addPlugin()
-      const result = yield* aisdk.runSDK({
-        model: new ModelV2.Info({
-          ...ModelV2.Info.empty(ProviderV2.ID.make("custom-alibaba"), ModelV2.ID.make("qwen")),
-          api: { id: ModelV2.ID.make("qwen"), type: "aisdk", package: "test-provider" },
-        }),
-        package: "@ai-sdk/alibaba",
-        options: { name: "custom-alibaba", apiKey: "test" },
-      })
+      const result = yield* plugin.trigger(
+        "aisdk.sdk",
+        {
+          model: new ModelV2.Info({
+            ...ModelV2.Info.empty(ProviderV2.ID.make("custom-alibaba"), ModelV2.ID.make("qwen")),
+            api: { id: ModelV2.ID.make("qwen"), type: "aisdk", package: "test-provider" },
+          }),
+          package: "@ai-sdk/alibaba",
+          options: { name: "custom-alibaba", apiKey: "test" },
+        },
+        {},
+      )
       const expected = createAlibaba({ apiKey: "test", ...{ name: "custom-alibaba" } }).languageModel("qwen")
       const actual = result.sdk?.languageModel("qwen")
       expect(actual?.provider).toBe(expected.provider)
@@ -77,13 +84,12 @@ describe("AlibabaPlugin", () => {
   it.effect("uses the old default languageModel(api.id) behavior", () =>
     Effect.gen(function* () {
       const plugin = yield* PluginV2.Service
-      const aisdk = yield* AISDK.Service
       yield* addPlugin()
       const item = new ModelV2.Info({
         ...ModelV2.Info.empty(ProviderV2.ID.make("alibaba"), ModelV2.ID.make("alias")),
         api: { id: ModelV2.ID.make("qwen-plus"), type: "aisdk", package: "test-provider" },
       })
-      const result = yield* aisdk.runSDK({ model: item, package: "@ai-sdk/alibaba", options: {} })
+      const result = yield* plugin.trigger("aisdk.sdk", { model: item, package: "@ai-sdk/alibaba", options: {} }, {})
       const language = result.sdk?.languageModel(item.api.id)
       expect(language?.modelId).toBe("qwen-plus")
       expect(language?.provider).toBe("alibaba.chat")

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

@@ -1,4 +1,3 @@
-import { AISDK } from "@opencode-ai/core/aisdk"
 import { describe, expect } from "bun:test"
 import type { LanguageModelV3 } from "@ai-sdk/provider"
 import { Effect } from "effect"
@@ -15,9 +14,8 @@ const it = testEffect(PluginTestLayer)
 
 const addPlugin = Effect.fn(function* () {
   const plugin = yield* PluginV2.Service
-  const aisdk = yield* AISDK.Service
-  const host = yield* PluginHost.make(plugin)
-  yield* AmazonBedrockPlugin.effect(host)
+  const host = yield* PluginHost.make()
+  yield* plugin.add({ id: AmazonBedrockPlugin.id, effect: AmazonBedrockPlugin.effect(host) })
 })
 
 function required<T>(value: T | undefined): T {
@@ -111,22 +109,25 @@ describe("AmazonBedrockPlugin", () => {
     withEnv({ AWS_BEARER_TOKEN_BEDROCK: undefined, AWS_PROFILE: undefined, AWS_ACCESS_KEY_ID: undefined }, () =>
       Effect.gen(function* () {
         const plugin = yield* PluginV2.Service
-        const aisdk = yield* AISDK.Service
         yield* addPlugin()
-        const result = yield* aisdk.runSDK({
-          model: new ModelV2.Info({
-            ...ModelV2.Info.empty(ProviderV2.ID.amazonBedrock, ModelV2.ID.make("anthropic.claude-sonnet-4-5")),
-            api: { id: ModelV2.ID.make("anthropic.claude-sonnet-4-5"), type: "aisdk", package: "test-provider" },
-          }),
-          package: "@ai-sdk/amazon-bedrock",
-          options: {
-            name: "amazon-bedrock",
-            bearerToken: "token",
-            baseURL: "https://base.example",
-            endpoint: "https://endpoint.example",
-            region: "us-east-1",
+        const result = yield* plugin.trigger(
+          "aisdk.sdk",
+          {
+            model: new ModelV2.Info({
+              ...ModelV2.Info.empty(ProviderV2.ID.amazonBedrock, ModelV2.ID.make("anthropic.claude-sonnet-4-5")),
+              api: { id: ModelV2.ID.make("anthropic.claude-sonnet-4-5"), type: "aisdk", package: "test-provider" },
+            }),
+            package: "@ai-sdk/amazon-bedrock",
+            options: {
+              name: "amazon-bedrock",
+              bearerToken: "token",
+              baseURL: "https://base.example",
+              endpoint: "https://endpoint.example",
+              region: "us-east-1",
+            },
           },
-        })
+          {},
+        )
         expect(bedrockBaseURL(result.sdk)).toBe("https://endpoint.example")
       }),
     ),
@@ -136,21 +137,24 @@ describe("AmazonBedrockPlugin", () => {
     withEnv({ AWS_BEARER_TOKEN_BEDROCK: undefined, AWS_PROFILE: undefined, AWS_ACCESS_KEY_ID: undefined }, () =>
       Effect.gen(function* () {
         const plugin = yield* PluginV2.Service
-        const aisdk = yield* AISDK.Service
         yield* addPlugin()
-        const result = yield* aisdk.runSDK({
-          model: new ModelV2.Info({
-            ...ModelV2.Info.empty(ProviderV2.ID.amazonBedrock, ModelV2.ID.make("anthropic.claude-sonnet-4-5")),
-            api: { id: ModelV2.ID.make("anthropic.claude-sonnet-4-5"), type: "aisdk", package: "test-provider" },
-          }),
-          package: "@ai-sdk/amazon-bedrock",
-          options: {
-            name: "amazon-bedrock",
-            bearerToken: "token",
-            baseURL: "https://base.example",
-            region: "us-east-1",
+        const result = yield* plugin.trigger(
+          "aisdk.sdk",
+          {
+            model: new ModelV2.Info({
+              ...ModelV2.Info.empty(ProviderV2.ID.amazonBedrock, ModelV2.ID.make("anthropic.claude-sonnet-4-5")),
+              api: { id: ModelV2.ID.make("anthropic.claude-sonnet-4-5"), type: "aisdk", package: "test-provider" },
+            }),
+            package: "@ai-sdk/amazon-bedrock",
+            options: {
+              name: "amazon-bedrock",
+              bearerToken: "token",
+              baseURL: "https://base.example",
+              region: "us-east-1",
+            },
           },
-        })
+          {},
+        )
         expect(bedrockBaseURL(result.sdk)).toBe("https://base.example")
       }),
     ),
@@ -170,20 +174,23 @@ describe("AmazonBedrockPlugin", () => {
       () =>
         Effect.gen(function* () {
           const plugin = yield* PluginV2.Service
-          const aisdk = yield* AISDK.Service
           yield* addPlugin()
-          const result = yield* aisdk.runSDK({
-            model: new ModelV2.Info({
-              ...ModelV2.Info.empty(ProviderV2.ID.amazonBedrock, ModelV2.ID.make("anthropic.claude-sonnet-4-5")),
-              api: {
-                id: ModelV2.ID.make("anthropic.claude-sonnet-4-5"),
-                type: "aisdk",
-                package: "test-provider",
-              },
-            }),
-            package: "@ai-sdk/amazon-bedrock",
-            options: { name: "amazon-bedrock" },
-          })
+          const result = yield* plugin.trigger(
+            "aisdk.sdk",
+            {
+              model: new ModelV2.Info({
+                ...ModelV2.Info.empty(ProviderV2.ID.amazonBedrock, ModelV2.ID.make("anthropic.claude-sonnet-4-5")),
+                api: {
+                  id: ModelV2.ID.make("anthropic.claude-sonnet-4-5"),
+                  type: "aisdk",
+                  package: "test-provider",
+                },
+              }),
+              package: "@ai-sdk/amazon-bedrock",
+              options: { name: "amazon-bedrock" },
+            },
+            {},
+          )
           expect(result.sdk).toBeDefined()
           expect(bedrockBaseURL(result.sdk)).toBe("https://bedrock-runtime.us-east-1.amazonaws.com")
         }),
@@ -194,16 +201,19 @@ describe("AmazonBedrockPlugin", () => {
     withEnv({ AWS_BEARER_TOKEN_BEDROCK: "token", AWS_REGION: "us-east-1" }, () =>
       Effect.gen(function* () {
         const plugin = yield* PluginV2.Service
-        const aisdk = yield* AISDK.Service
         yield* addPlugin()
-        const result = yield* aisdk.runSDK({
-          model: new ModelV2.Info({
-            ...ModelV2.Info.empty(ProviderV2.ID.amazonBedrock, ModelV2.ID.make("anthropic.claude-sonnet-4-5")),
-            api: { id: ModelV2.ID.make("anthropic.claude-sonnet-4-5"), type: "aisdk", package: "test-provider" },
-          }),
-          package: "@ai-sdk/amazon-bedrock",
-          options: { name: "amazon-bedrock", region: "eu-west-1" },
-        })
+        const result = yield* plugin.trigger(
+          "aisdk.sdk",
+          {
+            model: new ModelV2.Info({
+              ...ModelV2.Info.empty(ProviderV2.ID.amazonBedrock, ModelV2.ID.make("anthropic.claude-sonnet-4-5")),
+              api: { id: ModelV2.ID.make("anthropic.claude-sonnet-4-5"), type: "aisdk", package: "test-provider" },
+            }),
+            package: "@ai-sdk/amazon-bedrock",
+            options: { name: "amazon-bedrock", region: "eu-west-1" },
+          },
+          {},
+        )
         expect(bedrockBaseURL(result.sdk)).toBe("https://bedrock-runtime.eu-west-1.amazonaws.com")
       }),
     ),
@@ -213,16 +223,19 @@ describe("AmazonBedrockPlugin", () => {
     withEnv({ AWS_BEARER_TOKEN_BEDROCK: "token", AWS_REGION: "eu-west-1" }, () =>
       Effect.gen(function* () {
         const plugin = yield* PluginV2.Service
-        const aisdk = yield* AISDK.Service
         yield* addPlugin()
-        const result = yield* aisdk.runSDK({
-          model: new ModelV2.Info({
-            ...ModelV2.Info.empty(ProviderV2.ID.amazonBedrock, ModelV2.ID.make("anthropic.claude-sonnet-4-5")),
-            api: { id: ModelV2.ID.make("anthropic.claude-sonnet-4-5"), type: "aisdk", package: "test-provider" },
-          }),
-          package: "@ai-sdk/amazon-bedrock",
-          options: { name: "amazon-bedrock" },
-        })
+        const result = yield* plugin.trigger(
+          "aisdk.sdk",
+          {
+            model: new ModelV2.Info({
+              ...ModelV2.Info.empty(ProviderV2.ID.amazonBedrock, ModelV2.ID.make("anthropic.claude-sonnet-4-5")),
+              api: { id: ModelV2.ID.make("anthropic.claude-sonnet-4-5"), type: "aisdk", package: "test-provider" },
+            }),
+            package: "@ai-sdk/amazon-bedrock",
+            options: { name: "amazon-bedrock" },
+          },
+          {},
+        )
         expect(bedrockBaseURL(result.sdk)).toBe("https://bedrock-runtime.eu-west-1.amazonaws.com")
       }),
     ),
@@ -232,16 +245,19 @@ describe("AmazonBedrockPlugin", () => {
     withEnv({ AWS_BEARER_TOKEN_BEDROCK: "token", AWS_REGION: undefined }, () =>
       Effect.gen(function* () {
         const plugin = yield* PluginV2.Service
-        const aisdk = yield* AISDK.Service
         yield* addPlugin()
-        const result = yield* aisdk.runSDK({
-          model: new ModelV2.Info({
-            ...ModelV2.Info.empty(ProviderV2.ID.amazonBedrock, ModelV2.ID.make("anthropic.claude-sonnet-4-5")),
-            api: { id: ModelV2.ID.make("anthropic.claude-sonnet-4-5"), type: "aisdk", package: "test-provider" },
-          }),
-          package: "@ai-sdk/amazon-bedrock",
-          options: { name: "amazon-bedrock" },
-        })
+        const result = yield* plugin.trigger(
+          "aisdk.sdk",
+          {
+            model: new ModelV2.Info({
+              ...ModelV2.Info.empty(ProviderV2.ID.amazonBedrock, ModelV2.ID.make("anthropic.claude-sonnet-4-5")),
+              api: { id: ModelV2.ID.make("anthropic.claude-sonnet-4-5"), type: "aisdk", package: "test-provider" },
+            }),
+            package: "@ai-sdk/amazon-bedrock",
+            options: { name: "amazon-bedrock" },
+          },
+          {},
+        )
         expect(bedrockBaseURL(result.sdk)).toBe("https://bedrock-runtime.us-east-1.amazonaws.com")
       }),
     ),
@@ -251,24 +267,27 @@ describe("AmazonBedrockPlugin", () => {
     withEnv({ AWS_ACCESS_KEY_ID: undefined, AWS_BEARER_TOKEN_BEDROCK: undefined, AWS_PROFILE: undefined }, () =>
       Effect.gen(function* () {
         const plugin = yield* PluginV2.Service
-        const aisdk = yield* AISDK.Service
         const headers: Array<string | null> = []
         yield* addPlugin()
-        const result = yield* aisdk.runSDK({
-          model: new ModelV2.Info({
-            ...ModelV2.Info.empty(ProviderV2.ID.amazonBedrock, ModelV2.ID.make("anthropic.claude-sonnet-4-5")),
-            api: { id: ModelV2.ID.make("anthropic.claude-sonnet-4-5"), type: "aisdk", package: "test-provider" },
-          }),
-          package: "@ai-sdk/amazon-bedrock",
-          options: {
-            name: "amazon-bedrock",
-            bearerToken: "option-token",
-            fetch: async (_input: Parameters<typeof fetch>[0], init?: RequestInit) => {
-              headers.push(new Headers(init?.headers).get("Authorization"))
-              return new Response("{}")
+        const result = yield* plugin.trigger(
+          "aisdk.sdk",
+          {
+            model: new ModelV2.Info({
+              ...ModelV2.Info.empty(ProviderV2.ID.amazonBedrock, ModelV2.ID.make("anthropic.claude-sonnet-4-5")),
+              api: { id: ModelV2.ID.make("anthropic.claude-sonnet-4-5"), type: "aisdk", package: "test-provider" },
+            }),
+            package: "@ai-sdk/amazon-bedrock",
+            options: {
+              name: "amazon-bedrock",
+              bearerToken: "option-token",
+              fetch: async (_input: Parameters<typeof fetch>[0], init?: RequestInit) => {
+                headers.push(new Headers(init?.headers).get("Authorization"))
+                return new Response("{}")
+              },
             },
           },
-        })
+          {},
+        )
         yield* Effect.promise(() => bedrockFetch(result.sdk)("https://bedrock.example", { method: "POST" }))
         expect(process.env.AWS_BEARER_TOKEN_BEDROCK).toBe("option-token")
         expect(headers).toEqual(["Bearer option-token"])
@@ -280,24 +299,27 @@ describe("AmazonBedrockPlugin", () => {
     withEnv({ AWS_BEARER_TOKEN_BEDROCK: "env-token" }, () =>
       Effect.gen(function* () {
         const plugin = yield* PluginV2.Service
-        const aisdk = yield* AISDK.Service
         const headers: Array<string | null> = []
         yield* addPlugin()
-        const result = yield* aisdk.runSDK({
-          model: new ModelV2.Info({
-            ...ModelV2.Info.empty(ProviderV2.ID.amazonBedrock, ModelV2.ID.make("anthropic.claude-sonnet-4-5")),
-            api: { id: ModelV2.ID.make("anthropic.claude-sonnet-4-5"), type: "aisdk", package: "test-provider" },
-          }),
-          package: "@ai-sdk/amazon-bedrock",
-          options: {
-            name: "amazon-bedrock",
-            bearerToken: "option-token",
-            fetch: async (_input: Parameters<typeof fetch>[0], init?: RequestInit) => {
-              headers.push(new Headers(init?.headers).get("Authorization"))
-              return new Response("{}")
+        const result = yield* plugin.trigger(
+          "aisdk.sdk",
+          {
+            model: new ModelV2.Info({
+              ...ModelV2.Info.empty(ProviderV2.ID.amazonBedrock, ModelV2.ID.make("anthropic.claude-sonnet-4-5")),
+              api: { id: ModelV2.ID.make("anthropic.claude-sonnet-4-5"), type: "aisdk", package: "test-provider" },
+            }),
+            package: "@ai-sdk/amazon-bedrock",
+            options: {
+              name: "amazon-bedrock",
+              bearerToken: "option-token",
+              fetch: async (_input: Parameters<typeof fetch>[0], init?: RequestInit) => {
+                headers.push(new Headers(init?.headers).get("Authorization"))
+                return new Response("{}")
+              },
             },
           },
-        })
+          {},
+        )
         yield* Effect.promise(() => bedrockFetch(result.sdk)("https://bedrock.example", { method: "POST" }))
         expect(process.env.AWS_BEARER_TOKEN_BEDROCK).toBe("env-token")
         expect(headers).toEqual(["Bearer env-token"])
@@ -309,25 +331,28 @@ describe("AmazonBedrockPlugin", () => {
     withEnv({ AWS_BEARER_TOKEN_BEDROCK: undefined, AWS_PROFILE: undefined, AWS_ACCESS_KEY_ID: undefined }, () =>
       Effect.gen(function* () {
         const plugin = yield* PluginV2.Service
-        const aisdk = yield* AISDK.Service
         yield* addPlugin()
-        const result = yield* aisdk.runSDK({
-          model: new ModelV2.Info({
-            ...ModelV2.Info.empty(ProviderV2.ID.amazonBedrock, ModelV2.ID.make("openai.gpt-5.5")),
-            api: {
-              id: ModelV2.ID.make("openai.gpt-5.5"),
-              type: "aisdk",
-              package: "@ai-sdk/amazon-bedrock/mantle",
+        const result = yield* plugin.trigger(
+          "aisdk.sdk",
+          {
+            model: new ModelV2.Info({
+              ...ModelV2.Info.empty(ProviderV2.ID.amazonBedrock, ModelV2.ID.make("openai.gpt-5.5")),
+              api: {
+                id: ModelV2.ID.make("openai.gpt-5.5"),
+                type: "aisdk",
+                package: "@ai-sdk/amazon-bedrock/mantle",
+              },
+            }),
+            package: "@ai-sdk/amazon-bedrock/mantle",
+            options: {
+              name: "amazon-bedrock",
+              bearerToken: "token",
+              baseURL: "https://bedrock-mantle.us-east-2.api.aws/openai/v1",
+              region: "us-east-2",
             },
-          }),
-          package: "@ai-sdk/amazon-bedrock/mantle",
-          options: {
-            name: "amazon-bedrock",
-            bearerToken: "token",
-            baseURL: "https://bedrock-mantle.us-east-2.api.aws/openai/v1",
-            region: "us-east-2",
           },
-        })
+          {},
+        )
         const language = result.sdk.responses("openai.gpt-5.5")
         expect(openAIUrl(language, "/responses", "openai.gpt-5.5")).toBe(
           "https://bedrock-mantle.us-east-2.api.aws/openai/v1/responses",
@@ -339,33 +364,40 @@ describe("AmazonBedrockPlugin", () => {
   it.effect("selects Mantle APIs without Bedrock cross-region prefixes", () =>
     Effect.gen(function* () {
       const plugin = yield* PluginV2.Service
-      const aisdk = yield* AISDK.Service
       const calls: string[] = []
       yield* addPlugin()
-      yield* aisdk.runLanguage({
-        model: new ModelV2.Info({
-          ...ModelV2.Info.empty(ProviderV2.ID.amazonBedrock, ModelV2.ID.make("openai.gpt-5.5")),
-          api: {
-            id: ModelV2.ID.make("openai.gpt-5.5"),
-            type: "aisdk",
-            package: "@ai-sdk/amazon-bedrock/mantle",
-          },
-        }),
-        sdk: fakeSelectorSdk(calls),
-        options: { baseURL: "https://bedrock-mantle.us-east-2.api.aws/openai/v1", region: "us-east-2" },
-      })
-      yield* aisdk.runLanguage({
-        model: new ModelV2.Info({
-          ...ModelV2.Info.empty(ProviderV2.ID.amazonBedrock, ModelV2.ID.make("openai.gpt-oss-safeguard-120b")),
-          api: {
-            id: ModelV2.ID.make("openai.gpt-oss-safeguard-120b"),
-            type: "aisdk",
-            package: "@ai-sdk/amazon-bedrock/mantle",
-          },
-        }),
-        sdk: fakeSelectorSdk(calls),
-        options: { region: "us-east-1" },
-      })
+      yield* plugin.trigger(
+        "aisdk.language",
+        {
+          model: new ModelV2.Info({
+            ...ModelV2.Info.empty(ProviderV2.ID.amazonBedrock, ModelV2.ID.make("openai.gpt-5.5")),
+            api: {
+              id: ModelV2.ID.make("openai.gpt-5.5"),
+              type: "aisdk",
+              package: "@ai-sdk/amazon-bedrock/mantle",
+            },
+          }),
+          sdk: fakeSelectorSdk(calls),
+          options: { baseURL: "https://bedrock-mantle.us-east-2.api.aws/openai/v1", region: "us-east-2" },
+        },
+        {},
+      )
+      yield* plugin.trigger(
+        "aisdk.language",
+        {
+          model: new ModelV2.Info({
+            ...ModelV2.Info.empty(ProviderV2.ID.amazonBedrock, ModelV2.ID.make("openai.gpt-oss-safeguard-120b")),
+            api: {
+              id: ModelV2.ID.make("openai.gpt-oss-safeguard-120b"),
+              type: "aisdk",
+              package: "@ai-sdk/amazon-bedrock/mantle",
+            },
+          }),
+          sdk: fakeSelectorSdk(calls),
+          options: { region: "us-east-1" },
+        },
+        {},
+      )
       expect(calls).toEqual(["responses:openai.gpt-5.5", "chat:openai.gpt-oss-safeguard-120b"])
     }),
   )
@@ -373,20 +405,23 @@ describe("AmazonBedrockPlugin", () => {
   it.effect("ignores other Bedrock provider subpaths", () =>
     Effect.gen(function* () {
       const plugin = yield* PluginV2.Service
-      const aisdk = yield* AISDK.Service
       yield* addPlugin()
-      const result = yield* aisdk.runSDK({
-        model: new ModelV2.Info({
-          ...ModelV2.Info.empty(ProviderV2.ID.amazonBedrock, ModelV2.ID.make("anthropic.claude-sonnet-4-5")),
-          api: {
-            id: ModelV2.ID.make("anthropic.claude-sonnet-4-5"),
-            type: "aisdk",
-            package: "@ai-sdk/amazon-bedrock/anthropic",
-          },
-        }),
-        package: "@ai-sdk/amazon-bedrock/anthropic",
-        options: { name: "amazon-bedrock" },
-      })
+      const result = yield* plugin.trigger(
+        "aisdk.sdk",
+        {
+          model: new ModelV2.Info({
+            ...ModelV2.Info.empty(ProviderV2.ID.amazonBedrock, ModelV2.ID.make("anthropic.claude-sonnet-4-5")),
+            api: {
+              id: ModelV2.ID.make("anthropic.claude-sonnet-4-5"),
+              type: "aisdk",
+              package: "@ai-sdk/amazon-bedrock/anthropic",
+            },
+          }),
+          package: "@ai-sdk/amazon-bedrock/anthropic",
+          options: { name: "amazon-bedrock" },
+        },
+        {},
+      )
       expect(result.sdk).toBeUndefined()
     }),
   )
@@ -403,27 +438,30 @@ describe("AmazonBedrockPlugin", () => {
       () =>
         Effect.gen(function* () {
           const plugin = yield* PluginV2.Service
-          const aisdk = yield* AISDK.Service
           const headers: Array<string | null> = []
           yield* addPlugin()
-          const result = yield* aisdk.runSDK({
-            model: new ModelV2.Info({
-              ...ModelV2.Info.empty(ProviderV2.ID.amazonBedrock, ModelV2.ID.make("anthropic.claude-sonnet-4-5")),
-              api: {
-                id: ModelV2.ID.make("anthropic.claude-sonnet-4-5"),
-                type: "aisdk",
-                package: "test-provider",
-              },
-            }),
-            package: "@ai-sdk/amazon-bedrock",
-            options: {
-              name: "amazon-bedrock",
-              fetch: async (_input: Parameters<typeof fetch>[0], init?: RequestInit) => {
-                headers.push(new Headers(init?.headers).get("Authorization"))
-                return new Response("{}")
+          const result = yield* plugin.trigger(
+            "aisdk.sdk",
+            {
+              model: new ModelV2.Info({
+                ...ModelV2.Info.empty(ProviderV2.ID.amazonBedrock, ModelV2.ID.make("anthropic.claude-sonnet-4-5")),
+                api: {
+                  id: ModelV2.ID.make("anthropic.claude-sonnet-4-5"),
+                  type: "aisdk",
+                  package: "test-provider",
+                },
+              }),
+              package: "@ai-sdk/amazon-bedrock",
+              options: {
+                name: "amazon-bedrock",
+                fetch: async (_input: Parameters<typeof fetch>[0], init?: RequestInit) => {
+                  headers.push(new Headers(init?.headers).get("Authorization"))
+                  return new Response("{}")
+                },
               },
             },
-          })
+            {},
+          )
           yield* Effect.promise(() =>
             bedrockFetch(result.sdk)("https://bedrock-runtime.us-east-1.amazonaws.com/model/test/invoke", {
               body: "{}",
@@ -438,53 +476,72 @@ describe("AmazonBedrockPlugin", () => {
   it.effect("applies legacy cross-region inference prefixes", () =>
     Effect.gen(function* () {
       const plugin = yield* PluginV2.Service
-      const aisdk = yield* AISDK.Service
       const calls: string[] = []
       yield* addPlugin()
-      yield* aisdk.runLanguage({
-        model: new ModelV2.Info({
-          ...ModelV2.Info.empty(ProviderV2.ID.amazonBedrock, ModelV2.ID.make("anthropic.claude-sonnet-4-5")),
-          api: { id: ModelV2.ID.make("anthropic.claude-sonnet-4-5"), type: "aisdk", package: "test-provider" },
-        }),
-        sdk: { languageModel: fakeSelectorSdk(calls).languageModel },
-        options: {},
-      })
-      yield* aisdk.runLanguage({
-        model: new ModelV2.Info({
-          ...ModelV2.Info.empty(ProviderV2.ID.amazonBedrock, ModelV2.ID.make("anthropic.claude-sonnet-4-5")),
-          api: { id: ModelV2.ID.make("anthropic.claude-sonnet-4-5"), type: "aisdk", package: "test-provider" },
-        }),
-        sdk: { languageModel: fakeSelectorSdk(calls).languageModel },
-        options: { region: "eu-west-1" },
-      })
-      yield* aisdk.runLanguage({
-        model: new ModelV2.Info({
-          ...ModelV2.Info.empty(ProviderV2.ID.amazonBedrock, ModelV2.ID.make("global.anthropic.claude-sonnet-4-5")),
-          api: {
-            id: ModelV2.ID.make("global.anthropic.claude-sonnet-4-5"),
-            type: "aisdk",
-            package: "test-provider",
-          },
-        }),
-        sdk: { languageModel: fakeSelectorSdk(calls).languageModel },
-        options: { region: "eu-west-1" },
-      })
-      yield* aisdk.runLanguage({
-        model: new ModelV2.Info({
-          ...ModelV2.Info.empty(ProviderV2.ID.amazonBedrock, ModelV2.ID.make("anthropic.claude-sonnet-4-5")),
-          api: { id: ModelV2.ID.make("anthropic.claude-sonnet-4-5"), type: "aisdk", package: "test-provider" },
-        }),
-        sdk: { languageModel: fakeSelectorSdk(calls).languageModel },
-        options: { region: "ap-northeast-1" },
-      })
-      yield* aisdk.runLanguage({
-        model: new ModelV2.Info({
-          ...ModelV2.Info.empty(ProviderV2.ID.amazonBedrock, ModelV2.ID.make("anthropic.claude-sonnet-4-5")),
-          api: { id: ModelV2.ID.make("anthropic.claude-sonnet-4-5"), type: "aisdk", package: "test-provider" },
-        }),
-        sdk: { languageModel: fakeSelectorSdk(calls).languageModel },
-        options: { region: "ap-southeast-2" },
-      })
+      yield* plugin.trigger(
+        "aisdk.language",
+        {
+          model: new ModelV2.Info({
+            ...ModelV2.Info.empty(ProviderV2.ID.amazonBedrock, ModelV2.ID.make("anthropic.claude-sonnet-4-5")),
+            api: { id: ModelV2.ID.make("anthropic.claude-sonnet-4-5"), type: "aisdk", package: "test-provider" },
+          }),
+          sdk: { languageModel: fakeSelectorSdk(calls).languageModel },
+          options: {},
+        },
+        {},
+      )
+      yield* plugin.trigger(
+        "aisdk.language",
+        {
+          model: new ModelV2.Info({
+            ...ModelV2.Info.empty(ProviderV2.ID.amazonBedrock, ModelV2.ID.make("anthropic.claude-sonnet-4-5")),
+            api: { id: ModelV2.ID.make("anthropic.claude-sonnet-4-5"), type: "aisdk", package: "test-provider" },
+          }),
+          sdk: { languageModel: fakeSelectorSdk(calls).languageModel },
+          options: { region: "eu-west-1" },
+        },
+        {},
+      )
+      yield* plugin.trigger(
+        "aisdk.language",
+        {
+          model: new ModelV2.Info({
+            ...ModelV2.Info.empty(ProviderV2.ID.amazonBedrock, ModelV2.ID.make("global.anthropic.claude-sonnet-4-5")),
+            api: {
+              id: ModelV2.ID.make("global.anthropic.claude-sonnet-4-5"),
+              type: "aisdk",
+              package: "test-provider",
+            },
+          }),
+          sdk: { languageModel: fakeSelectorSdk(calls).languageModel },
+          options: { region: "eu-west-1" },
+        },
+        {},
+      )
+      yield* plugin.trigger(
+        "aisdk.language",
+        {
+          model: new ModelV2.Info({
+            ...ModelV2.Info.empty(ProviderV2.ID.amazonBedrock, ModelV2.ID.make("anthropic.claude-sonnet-4-5")),
+            api: { id: ModelV2.ID.make("anthropic.claude-sonnet-4-5"), type: "aisdk", package: "test-provider" },
+          }),
+          sdk: { languageModel: fakeSelectorSdk(calls).languageModel },
+          options: { region: "ap-northeast-1" },
+        },
+        {},
+      )
+      yield* plugin.trigger(
+        "aisdk.language",
+        {
+          model: new ModelV2.Info({
+            ...ModelV2.Info.empty(ProviderV2.ID.amazonBedrock, ModelV2.ID.make("anthropic.claude-sonnet-4-5")),
+            api: { id: ModelV2.ID.make("anthropic.claude-sonnet-4-5"), type: "aisdk", package: "test-provider" },
+          }),
+          sdk: { languageModel: fakeSelectorSdk(calls).languageModel },
+          options: { region: "ap-southeast-2" },
+        },
+        {},
+      )
       expect(calls).toEqual([
         "languageModel:us.anthropic.claude-sonnet-4-5",
         "languageModel:eu.anthropic.claude-sonnet-4-5",
@@ -499,17 +556,20 @@ describe("AmazonBedrockPlugin", () => {
     withEnv({ AWS_REGION: "eu-west-1" }, () =>
       Effect.gen(function* () {
         const plugin = yield* PluginV2.Service
-        const aisdk = yield* AISDK.Service
         const calls: string[] = []
         yield* addPlugin()
-        yield* aisdk.runLanguage({
-          model: new ModelV2.Info({
-            ...ModelV2.Info.empty(ProviderV2.ID.amazonBedrock, ModelV2.ID.make("anthropic.claude-sonnet-4-5")),
-            api: { id: ModelV2.ID.make("anthropic.claude-sonnet-4-5"), type: "aisdk", package: "test-provider" },
-          }),
-          sdk: { languageModel: fakeSelectorSdk(calls).languageModel },
-          options: {},
-        })
+        yield* plugin.trigger(
+          "aisdk.language",
+          {
+            model: new ModelV2.Info({
+              ...ModelV2.Info.empty(ProviderV2.ID.amazonBedrock, ModelV2.ID.make("anthropic.claude-sonnet-4-5")),
+              api: { id: ModelV2.ID.make("anthropic.claude-sonnet-4-5"), type: "aisdk", package: "test-provider" },
+            }),
+            sdk: { languageModel: fakeSelectorSdk(calls).languageModel },
+            options: {},
+          },
+          {},
+        )
         expect(calls).toEqual(["languageModel:eu.anthropic.claude-sonnet-4-5"])
       }),
     ),
@@ -518,7 +578,6 @@ describe("AmazonBedrockPlugin", () => {
   it.effect("applies the full legacy cross-region prefix matrix", () =>
     Effect.gen(function* () {
       const plugin = yield* PluginV2.Service
-      const aisdk = yield* AISDK.Service
       const calls: string[] = []
       const cases = [
         { region: "us-east-1", modelID: "amazon.nova-micro-v1:0", expected: "us.amazon.nova-micro-v1:0" },
@@ -588,14 +647,18 @@ describe("AmazonBedrockPlugin", () => {
       ]
       yield* addPlugin()
       for (const item of cases) {
-        yield* aisdk.runLanguage({
-          model: new ModelV2.Info({
-            ...ModelV2.Info.empty(ProviderV2.ID.amazonBedrock, ModelV2.ID.make(item.modelID)),
-            api: { id: ModelV2.ID.make(item.modelID), type: "aisdk", package: "test-provider" },
-          }),
-          sdk: { languageModel: fakeSelectorSdk(calls).languageModel },
-          options: { region: item.region },
-        })
+        yield* plugin.trigger(
+          "aisdk.language",
+          {
+            model: new ModelV2.Info({
+              ...ModelV2.Info.empty(ProviderV2.ID.amazonBedrock, ModelV2.ID.make(item.modelID)),
+              api: { id: ModelV2.ID.make(item.modelID), type: "aisdk", package: "test-provider" },
+            }),
+            sdk: { languageModel: fakeSelectorSdk(calls).languageModel },
+            options: { region: item.region },
+          },
+          {},
+        )
       }
       expect(calls).toEqual(cases.map((item) => `languageModel:${item.expected}`))
     }),
@@ -604,17 +667,20 @@ describe("AmazonBedrockPlugin", () => {
   it.effect("ignores non-Bedrock providers for language selection", () =>
     Effect.gen(function* () {
       const plugin = yield* PluginV2.Service
-      const aisdk = yield* AISDK.Service
       const calls: string[] = []
       yield* addPlugin()
-      const result = yield* aisdk.runLanguage({
-        model: new ModelV2.Info({
-          ...ModelV2.Info.empty(ProviderV2.ID.openai, ModelV2.ID.make("anthropic.claude-sonnet-4-5")),
-          api: { id: ModelV2.ID.make("anthropic.claude-sonnet-4-5"), type: "aisdk", package: "test-provider" },
-        }),
-        sdk: { languageModel: fakeSelectorSdk(calls).languageModel },
-        options: { region: "eu-west-1" },
-      })
+      const result = yield* plugin.trigger(
+        "aisdk.language",
+        {
+          model: new ModelV2.Info({
+            ...ModelV2.Info.empty(ProviderV2.ID.openai, ModelV2.ID.make("anthropic.claude-sonnet-4-5")),
+            api: { id: ModelV2.ID.make("anthropic.claude-sonnet-4-5"), type: "aisdk", package: "test-provider" },
+          }),
+          sdk: { languageModel: fakeSelectorSdk(calls).languageModel },
+          options: { region: "eu-west-1" },
+        },
+        {},
+      )
       expect(calls).toEqual([])
       expect(result.language).toBeUndefined()
     }),

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

@@ -1,4 +1,3 @@
-import { AISDK } from "@opencode-ai/core/aisdk"
 import { describe, expect } from "bun:test"
 import { Effect } from "effect"
 import { Catalog } from "@opencode-ai/core/catalog"
@@ -14,9 +13,8 @@ const it = testEffect(PluginTestLayer)
 
 const addPlugin = Effect.fn(function* () {
   const plugin = yield* PluginV2.Service
-  const aisdk = yield* AISDK.Service
-  const host = yield* PluginHost.make(plugin)
-  yield* AnthropicPlugin.effect(host)
+  const host = yield* PluginHost.make()
+  yield* plugin.add({ id: AnthropicPlugin.id, effect: AnthropicPlugin.effect(host) })
 })
 
 function required<T>(value: T | undefined): T {
@@ -61,16 +59,19 @@ describe("AnthropicPlugin", () => {
   it.effect("creates Anthropic SDKs with the model provider ID as the SDK name", () =>
     Effect.gen(function* () {
       const plugin = yield* PluginV2.Service
-      const aisdk = yield* AISDK.Service
       yield* addPlugin()
-      const result = yield* aisdk.runSDK({
-        model: new ModelV2.Info({
-          ...ModelV2.Info.empty(ProviderV2.ID.make("custom-anthropic"), ModelV2.ID.make("claude-sonnet-4-5")),
-          api: { id: ModelV2.ID.make("claude-sonnet-4-5"), type: "aisdk", package: "@ai-sdk/anthropic" },
-        }),
-        package: "@ai-sdk/anthropic",
-        options: { name: "custom-anthropic", apiKey: "test" },
-      })
+      const result = yield* plugin.trigger(
+        "aisdk.sdk",
+        {
+          model: new ModelV2.Info({
+            ...ModelV2.Info.empty(ProviderV2.ID.make("custom-anthropic"), ModelV2.ID.make("claude-sonnet-4-5")),
+            api: { id: ModelV2.ID.make("claude-sonnet-4-5"), type: "aisdk", package: "@ai-sdk/anthropic" },
+          }),
+          package: "@ai-sdk/anthropic",
+          options: { name: "custom-anthropic", apiKey: "test" },
+        },
+        {},
+      )
       expect(result.sdk.languageModel("claude-sonnet-4-5").provider).toBe("custom-anthropic")
     }),
   )
@@ -78,16 +79,19 @@ describe("AnthropicPlugin", () => {
   it.effect("uses the Anthropic provider ID as the SDK name for the bundled Anthropic provider", () =>
     Effect.gen(function* () {
       const plugin = yield* PluginV2.Service
-      const aisdk = yield* AISDK.Service
       yield* addPlugin()
-      const result = yield* aisdk.runSDK({
-        model: new ModelV2.Info({
-          ...ModelV2.Info.empty(ProviderV2.ID.anthropic, ModelV2.ID.make("claude-sonnet-4-5")),
-          api: { id: ModelV2.ID.make("claude-sonnet-4-5"), type: "aisdk", package: "@ai-sdk/anthropic" },
-        }),
-        package: "@ai-sdk/anthropic",
-        options: { name: "anthropic", apiKey: "test" },
-      })
+      const result = yield* plugin.trigger(
+        "aisdk.sdk",
+        {
+          model: new ModelV2.Info({
+            ...ModelV2.Info.empty(ProviderV2.ID.anthropic, ModelV2.ID.make("claude-sonnet-4-5")),
+            api: { id: ModelV2.ID.make("claude-sonnet-4-5"), type: "aisdk", package: "@ai-sdk/anthropic" },
+          }),
+          package: "@ai-sdk/anthropic",
+          options: { name: "anthropic", apiKey: "test" },
+        },
+        {},
+      )
       expect(result.sdk.languageModel("claude-sonnet-4-5").provider).toBe("anthropic")
     }),
   )

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

@@ -1,4 +1,3 @@
-import { AISDK } from "@opencode-ai/core/aisdk"
 import { describe, expect } from "bun:test"
 import type { LanguageModelV3 } from "@ai-sdk/provider"
 import { Effect } from "effect"
@@ -15,9 +14,8 @@ const it = testEffect(PluginTestLayer)
 
 const addPlugin = Effect.fn(function* () {
   const plugin = yield* PluginV2.Service
-  const aisdk = yield* AISDK.Service
-  const host = yield* PluginHost.make(plugin)
-  yield* AzureCognitiveServicesPlugin.effect(host)
+  const host = yield* PluginHost.make()
+  yield* plugin.add({ id: AzureCognitiveServicesPlugin.id, effect: AzureCognitiveServicesPlugin.effect(host) })
 })
 
 function required<T>(value: T | undefined): T {
@@ -116,17 +114,20 @@ describe("AzureCognitiveServicesPlugin", () => {
   it.effect("selects chat only for completion URLs", () =>
     Effect.gen(function* () {
       const plugin = yield* PluginV2.Service
-      const aisdk = yield* AISDK.Service
       const calls: string[] = []
       yield* addPlugin()
-      yield* aisdk.runLanguage({
-        model: new ModelV2.Info({
-          ...ModelV2.Info.empty(ProviderV2.ID.make("azure-cognitive-services"), ModelV2.ID.make("deployment")),
-          api: { id: ModelV2.ID.make("deployment"), type: "aisdk", package: "test-provider" },
-        }),
-        sdk: fakeSelectorSdk(calls),
-        options: { useCompletionUrls: true },
-      })
+      yield* plugin.trigger(
+        "aisdk.language",
+        {
+          model: new ModelV2.Info({
+            ...ModelV2.Info.empty(ProviderV2.ID.make("azure-cognitive-services"), ModelV2.ID.make("deployment")),
+            api: { id: ModelV2.ID.make("deployment"), type: "aisdk", package: "test-provider" },
+          }),
+          sdk: fakeSelectorSdk(calls),
+          options: { useCompletionUrls: true },
+        },
+        {},
+      )
       expect(calls).toEqual(["chat:deployment"])
     }),
   )
@@ -134,25 +135,32 @@ describe("AzureCognitiveServicesPlugin", () => {
   it.effect("uses the legacy Azure selector order and provider guard", () =>
     Effect.gen(function* () {
       const plugin = yield* PluginV2.Service
-      const aisdk = yield* AISDK.Service
       const calls: string[] = []
       yield* addPlugin()
-      yield* aisdk.runLanguage({
-        model: new ModelV2.Info({
-          ...ModelV2.Info.empty(ProviderV2.ID.make("azure-cognitive-services"), ModelV2.ID.make("deployment")),
-          api: { id: ModelV2.ID.make("deployment"), type: "aisdk", package: "test-provider" },
-        }),
-        sdk: fakeSelectorSdk(calls),
-        options: {},
-      })
-      const ignored = yield* aisdk.runLanguage({
-        model: new ModelV2.Info({
-          ...ModelV2.Info.empty(ProviderV2.ID.openai, ModelV2.ID.make("deployment")),
-          api: { id: ModelV2.ID.make("deployment"), type: "aisdk", package: "test-provider" },
-        }),
-        sdk: fakeSelectorSdk(calls),
-        options: {},
-      })
+      yield* plugin.trigger(
+        "aisdk.language",
+        {
+          model: new ModelV2.Info({
+            ...ModelV2.Info.empty(ProviderV2.ID.make("azure-cognitive-services"), ModelV2.ID.make("deployment")),
+            api: { id: ModelV2.ID.make("deployment"), type: "aisdk", package: "test-provider" },
+          }),
+          sdk: fakeSelectorSdk(calls),
+          options: {},
+        },
+        {},
+      )
+      const ignored = yield* plugin.trigger(
+        "aisdk.language",
+        {
+          model: new ModelV2.Info({
+            ...ModelV2.Info.empty(ProviderV2.ID.openai, ModelV2.ID.make("deployment")),
+            api: { id: ModelV2.ID.make("deployment"), type: "aisdk", package: "test-provider" },
+          }),
+          sdk: fakeSelectorSdk(calls),
+          options: {},
+        },
+        {},
+      )
       expect(calls).toEqual(["responses:deployment"])
       expect(ignored.language).toBeUndefined()
     }),
@@ -161,34 +169,51 @@ describe("AzureCognitiveServicesPlugin", () => {
   it.effect("falls back from responses to messages, chat, then languageModel", () =>
     Effect.gen(function* () {
       const plugin = yield* PluginV2.Service
-      const aisdk = yield* AISDK.Service
       const calls: string[] = []
       const sdk = fakeSelectorSdk(calls)
       yield* addPlugin()
-      yield* aisdk.runLanguage({
-        model: new ModelV2.Info({
-          ...ModelV2.Info.empty(ProviderV2.ID.make("azure-cognitive-services"), ModelV2.ID.make("messages-deployment")),
-          api: { id: ModelV2.ID.make("messages-deployment"), type: "aisdk", package: "test-provider" },
-        }),
-        sdk: { messages: sdk.messages, chat: sdk.chat, languageModel: sdk.languageModel },
-        options: {},
-      })
-      yield* aisdk.runLanguage({
-        model: new ModelV2.Info({
-          ...ModelV2.Info.empty(ProviderV2.ID.make("azure-cognitive-services"), ModelV2.ID.make("chat-deployment")),
-          api: { id: ModelV2.ID.make("chat-deployment"), type: "aisdk", package: "test-provider" },
-        }),
-        sdk: { chat: sdk.chat, languageModel: sdk.languageModel },
-        options: {},
-      })
-      yield* aisdk.runLanguage({
-        model: new ModelV2.Info({
-          ...ModelV2.Info.empty(ProviderV2.ID.make("azure-cognitive-services"), ModelV2.ID.make("language-deployment")),
-          api: { id: ModelV2.ID.make("language-deployment"), type: "aisdk", package: "test-provider" },
-        }),
-        sdk: { languageModel: sdk.languageModel },
-        options: {},
-      })
+      yield* plugin.trigger(
+        "aisdk.language",
+        {
+          model: new ModelV2.Info({
+            ...ModelV2.Info.empty(
+              ProviderV2.ID.make("azure-cognitive-services"),
+              ModelV2.ID.make("messages-deployment"),
+            ),
+            api: { id: ModelV2.ID.make("messages-deployment"), type: "aisdk", package: "test-provider" },
+          }),
+          sdk: { messages: sdk.messages, chat: sdk.chat, languageModel: sdk.languageModel },
+          options: {},
+        },
+        {},
+      )
+      yield* plugin.trigger(
+        "aisdk.language",
+        {
+          model: new ModelV2.Info({
+            ...ModelV2.Info.empty(ProviderV2.ID.make("azure-cognitive-services"), ModelV2.ID.make("chat-deployment")),
+            api: { id: ModelV2.ID.make("chat-deployment"), type: "aisdk", package: "test-provider" },
+          }),
+          sdk: { chat: sdk.chat, languageModel: sdk.languageModel },
+          options: {},
+        },
+        {},
+      )
+      yield* plugin.trigger(
+        "aisdk.language",
+        {
+          model: new ModelV2.Info({
+            ...ModelV2.Info.empty(
+              ProviderV2.ID.make("azure-cognitive-services"),
+              ModelV2.ID.make("language-deployment"),
+            ),
+            api: { id: ModelV2.ID.make("language-deployment"), type: "aisdk", package: "test-provider" },
+          }),
+          sdk: { languageModel: sdk.languageModel },
+          options: {},
+        },
+        {},
+      )
       expect(calls).toEqual([
         "messages:messages-deployment",
         "chat:chat-deployment",

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

@@ -1,4 +1,3 @@
-import { AISDK } from "@opencode-ai/core/aisdk"
 import { describe, expect } from "bun:test"
 import type { LanguageModelV3 } from "@ai-sdk/provider"
 import { Effect } from "effect"
@@ -15,9 +14,8 @@ const it = testEffect(PluginTestLayer)
 
 const addPlugin = Effect.fn(function* () {
   const plugin = yield* PluginV2.Service
-  const aisdk = yield* AISDK.Service
-  const host = yield* PluginHost.make(plugin)
-  yield* AzurePlugin.effect(host)
+  const host = yield* PluginHost.make()
+  yield* plugin.add({ id: AzurePlugin.id, effect: AzurePlugin.effect(host) })
 })
 
 function required<T>(value: T | undefined): T {
@@ -144,16 +142,19 @@ describe("AzurePlugin", () => {
     withEnv({ AZURE_RESOURCE_NAME: undefined }, () =>
       Effect.gen(function* () {
         const plugin = yield* PluginV2.Service
-        const aisdk = yield* AISDK.Service
         yield* addPlugin()
-        const result = yield* aisdk.runSDK({
-          model: new ModelV2.Info({
-            ...ModelV2.Info.empty(ProviderV2.ID.azure, ModelV2.ID.make("deployment")),
-            api: { id: ModelV2.ID.make("deployment"), type: "aisdk", package: "test-provider" },
-          }),
-          package: "@ai-sdk/azure",
-          options: { name: "azure", baseURL: "https://proxy.example.com/openai" },
-        })
+        const result = yield* plugin.trigger(
+          "aisdk.sdk",
+          {
+            model: new ModelV2.Info({
+              ...ModelV2.Info.empty(ProviderV2.ID.azure, ModelV2.ID.make("deployment")),
+              api: { id: ModelV2.ID.make("deployment"), type: "aisdk", package: "test-provider" },
+            }),
+            package: "@ai-sdk/azure",
+            options: { name: "azure", baseURL: "https://proxy.example.com/openai" },
+          },
+          {},
+        )
         expect(result.sdk).toBeDefined()
       }),
     ),
@@ -162,17 +163,21 @@ describe("AzurePlugin", () => {
   it.effect("rejects missing resourceName when baseURL is not configured", () =>
     withEnv({ AZURE_RESOURCE_NAME: undefined }, () =>
       Effect.gen(function* () {
-        const aisdk = yield* AISDK.Service
+        const plugin = yield* PluginV2.Service
         yield* addPlugin()
-        const exit = yield* aisdk
-          .runSDK({
-            model: new ModelV2.Info({
-              ...ModelV2.Info.empty(ProviderV2.ID.azure, ModelV2.ID.make("deployment")),
-              api: { id: ModelV2.ID.make("deployment"), type: "aisdk", package: "test-provider" },
-            }),
-            package: "@ai-sdk/azure",
-            options: { name: "azure" },
-          })
+        const exit = yield* plugin
+          .trigger(
+            "aisdk.sdk",
+            {
+              model: new ModelV2.Info({
+                ...ModelV2.Info.empty(ProviderV2.ID.azure, ModelV2.ID.make("deployment")),
+                api: { id: ModelV2.ID.make("deployment"), type: "aisdk", package: "test-provider" },
+              }),
+              package: "@ai-sdk/azure",
+              options: { name: "azure" },
+            },
+            {},
+          )
           .pipe(Effect.exit)
         expect(exit._tag).toBe("Failure")
       }),
@@ -182,17 +187,20 @@ describe("AzurePlugin", () => {
   it.effect("selects chat only for completion URLs", () =>
     Effect.gen(function* () {
       const plugin = yield* PluginV2.Service
-      const aisdk = yield* AISDK.Service
       const calls: string[] = []
       yield* addPlugin()
-      yield* aisdk.runLanguage({
-        model: new ModelV2.Info({
-          ...ModelV2.Info.empty(ProviderV2.ID.azure, ModelV2.ID.make("deployment")),
-          api: { id: ModelV2.ID.make("deployment"), type: "aisdk", package: "test-provider" },
-        }),
-        sdk: fakeSelectorSdk(calls),
-        options: { useCompletionUrls: true },
-      })
+      yield* plugin.trigger(
+        "aisdk.language",
+        {
+          model: new ModelV2.Info({
+            ...ModelV2.Info.empty(ProviderV2.ID.azure, ModelV2.ID.make("deployment")),
+            api: { id: ModelV2.ID.make("deployment"), type: "aisdk", package: "test-provider" },
+          }),
+          sdk: fakeSelectorSdk(calls),
+          options: { useCompletionUrls: true },
+        },
+        {},
+      )
       expect(calls).toEqual(["chat:deployment"])
     }),
   )
@@ -200,17 +208,20 @@ describe("AzurePlugin", () => {
   it.effect("selects chat from per-call useCompletionUrls", () =>
     Effect.gen(function* () {
       const plugin = yield* PluginV2.Service
-      const aisdk = yield* AISDK.Service
       const calls: string[] = []
       yield* addPlugin()
-      yield* aisdk.runLanguage({
-        model: new ModelV2.Info({
-          ...ModelV2.Info.empty(ProviderV2.ID.azure, ModelV2.ID.make("deployment")),
-          api: { id: ModelV2.ID.make("deployment"), type: "aisdk", package: "test-provider" },
-        }),
-        sdk: fakeSelectorSdk(calls),
-        options: { useCompletionUrls: true },
-      })
+      yield* plugin.trigger(
+        "aisdk.language",
+        {
+          model: new ModelV2.Info({
+            ...ModelV2.Info.empty(ProviderV2.ID.azure, ModelV2.ID.make("deployment")),
+            api: { id: ModelV2.ID.make("deployment"), type: "aisdk", package: "test-provider" },
+          }),
+          sdk: fakeSelectorSdk(calls),
+          options: { useCompletionUrls: true },
+        },
+        {},
+      )
       expect(calls).toEqual(["chat:deployment"])
     }),
   )
@@ -218,18 +229,21 @@ describe("AzurePlugin", () => {
   it.effect("ignores model useCompletionUrls when per-call option is unset", () =>
     Effect.gen(function* () {
       const plugin = yield* PluginV2.Service
-      const aisdk = yield* AISDK.Service
       const calls: string[] = []
       yield* addPlugin()
-      yield* aisdk.runLanguage({
-        model: new ModelV2.Info({
-          ...ModelV2.Info.empty(ProviderV2.ID.azure, ModelV2.ID.make("deployment")),
-          api: { id: ModelV2.ID.make("deployment"), type: "aisdk", package: "test-provider" },
-          request: { headers: {}, body: { useCompletionUrls: true } },
-        }),
-        sdk: fakeSelectorSdk(calls),
-        options: {},
-      })
+      yield* plugin.trigger(
+        "aisdk.language",
+        {
+          model: new ModelV2.Info({
+            ...ModelV2.Info.empty(ProviderV2.ID.azure, ModelV2.ID.make("deployment")),
+            api: { id: ModelV2.ID.make("deployment"), type: "aisdk", package: "test-provider" },
+            request: { headers: {}, body: { useCompletionUrls: true } },
+          }),
+          sdk: fakeSelectorSdk(calls),
+          options: {},
+        },
+        {},
+      )
       expect(calls).toEqual(["responses:deployment"])
     }),
   )
@@ -237,25 +251,32 @@ describe("AzurePlugin", () => {
   it.effect("uses the legacy Azure selector order and provider guard", () =>
     Effect.gen(function* () {
       const plugin = yield* PluginV2.Service
-      const aisdk = yield* AISDK.Service
       const calls: string[] = []
       yield* addPlugin()
-      yield* aisdk.runLanguage({
-        model: new ModelV2.Info({
-          ...ModelV2.Info.empty(ProviderV2.ID.azure, ModelV2.ID.make("deployment")),
-          api: { id: ModelV2.ID.make("deployment"), type: "aisdk", package: "test-provider" },
-        }),
-        sdk: fakeSelectorSdk(calls),
-        options: {},
-      })
-      const ignored = yield* aisdk.runLanguage({
-        model: new ModelV2.Info({
-          ...ModelV2.Info.empty(ProviderV2.ID.openai, ModelV2.ID.make("deployment")),
-          api: { id: ModelV2.ID.make("deployment"), type: "aisdk", package: "test-provider" },
-        }),
-        sdk: fakeSelectorSdk(calls),
-        options: {},
-      })
+      yield* plugin.trigger(
+        "aisdk.language",
+        {
+          model: new ModelV2.Info({
+            ...ModelV2.Info.empty(ProviderV2.ID.azure, ModelV2.ID.make("deployment")),
+            api: { id: ModelV2.ID.make("deployment"), type: "aisdk", package: "test-provider" },
+          }),
+          sdk: fakeSelectorSdk(calls),
+          options: {},
+        },
+        {},
+      )
+      const ignored = yield* plugin.trigger(
+        "aisdk.language",
+        {
+          model: new ModelV2.Info({
+            ...ModelV2.Info.empty(ProviderV2.ID.openai, ModelV2.ID.make("deployment")),
+            api: { id: ModelV2.ID.make("deployment"), type: "aisdk", package: "test-provider" },
+          }),
+          sdk: fakeSelectorSdk(calls),
+          options: {},
+        },
+        {},
+      )
       expect(calls).toEqual(["responses:deployment"])
       expect(ignored.language).toBeUndefined()
     }),
@@ -264,29 +285,36 @@ describe("AzurePlugin", () => {
   it.effect("falls back through the legacy Azure selector order", () =>
     Effect.gen(function* () {
       const plugin = yield* PluginV2.Service
-      const aisdk = yield* AISDK.Service
       const calls: string[] = []
       const make = (method: string) => (id: string) => {
         calls.push(`${method}:${id}`)
         return { modelId: id, provider: method, specificationVersion: "v3" }
       }
       yield* addPlugin()
-      yield* aisdk.runLanguage({
-        model: new ModelV2.Info({
-          ...ModelV2.Info.empty(ProviderV2.ID.azure, ModelV2.ID.make("messages-deployment")),
-          api: { id: ModelV2.ID.make("messages-deployment"), type: "aisdk", package: "test-provider" },
-        }),
-        sdk: { messages: make("messages"), chat: make("chat"), languageModel: make("languageModel") },
-        options: {},
-      })
-      yield* aisdk.runLanguage({
-        model: new ModelV2.Info({
-          ...ModelV2.Info.empty(ProviderV2.ID.azure, ModelV2.ID.make("language-deployment")),
-          api: { id: ModelV2.ID.make("language-deployment"), type: "aisdk", package: "test-provider" },
-        }),
-        sdk: { languageModel: make("languageModel") },
-        options: {},
-      })
+      yield* plugin.trigger(
+        "aisdk.language",
+        {
+          model: new ModelV2.Info({
+            ...ModelV2.Info.empty(ProviderV2.ID.azure, ModelV2.ID.make("messages-deployment")),
+            api: { id: ModelV2.ID.make("messages-deployment"), type: "aisdk", package: "test-provider" },
+          }),
+          sdk: { messages: make("messages"), chat: make("chat"), languageModel: make("languageModel") },
+          options: {},
+        },
+        {},
+      )
+      yield* plugin.trigger(
+        "aisdk.language",
+        {
+          model: new ModelV2.Info({
+            ...ModelV2.Info.empty(ProviderV2.ID.azure, ModelV2.ID.make("language-deployment")),
+            api: { id: ModelV2.ID.make("language-deployment"), type: "aisdk", package: "test-provider" },
+          }),
+          sdk: { languageModel: make("languageModel") },
+          options: {},
+        },
+        {},
+      )
       expect(calls).toEqual(["messages:messages-deployment", "languageModel:language-deployment"])
     }),
   )