fix(core): skip unchanged plugin activation

packages/core/src/plugin.ts

@@ -21,10 +21,14 @@ import { ToolHooks } from "./tool/hooks"
 import { PluginHooks } from "./plugin/hooks"
 
 export interface Interface {
-  readonly activate: (plugins: readonly Plugin[]) => Effect.Effect<void>
+  readonly activate: (plugins: readonly Versioned[]) => Effect.Effect<void>
   readonly list: () => Effect.Effect<Info[]>
 }
 
+export interface Versioned extends Plugin {
+  readonly version: string
+}
+
 export class Service extends Context.Service<Service, Interface>()("@opencode/v2/Plugin") {}
 
 const layer = Layer.effect(
@@ -32,11 +36,11 @@ const layer = Layer.effect(
   Effect.gen(function* () {
     const events = yield* EventV2.Service
     const scope = yield* Scope.make()
-    const active = new Map<typeof ID.Type, { readonly plugin: Plugin; readonly scope: Scope.Closeable }>()
+    const active = new Map<typeof ID.Type, { readonly plugin: Versioned; readonly scope: Scope.Closeable }>()
     const lock = Semaphore.makeUnsafe(1)
     let host: Parameters<Plugin["effect"]>[0]
 
-    const load = Effect.fnUntraced(function* (plugin: Plugin) {
+    const load = Effect.fnUntraced(function* (plugin: Versioned) {
       const child = yield* Scope.fork(scope)
       const inherit = yield* State.inherit()
       const loaded = yield* Effect.suspend(() => plugin.effect(host)).pipe(
@@ -55,7 +59,7 @@ const layer = Layer.effect(
       return undefined
     })
 
-    const activate = Effect.fn("Plugin.activate")(function* (plugins: readonly Plugin[]) {
+    const activate = Effect.fn("Plugin.activate")(function* (plugins: readonly Versioned[]) {
       const definitions = plugins.map((plugin) => ({ ...plugin, id: ID.make(plugin.id) }))
       const ids = new Set<typeof ID.Type>()
       for (const definition of definitions) {
@@ -65,6 +69,20 @@ const layer = Layer.effect(
 
       yield* lock.withPermit(
         Effect.gen(function* () {
+          const next = definitions.map((definition) => ({ id: definition.id, version: definition.version }))
+          const current = Array.from(active.values(), (entry) => ({
+            id: entry.plugin.id,
+            version: entry.plugin.version,
+          }))
+          if (
+            current.length === next.length &&
+            current.every((definition, index) => {
+              const candidate = next[index]
+              return definition.id === candidate?.id && definition.version === candidate.version
+            })
+          )
+            return
+
           yield* State.batch(
             Effect.gen(function* () {
               for (const definition of definitions) {

packages/core/src/plugin/sdk.ts

@@ -4,6 +4,7 @@ import type { Plugin } from "@opencode-ai/plugin/v2/effect/plugin"
 import { Context, Effect, Layer } from "effect"
 import { makeGlobalNode } from "../effect/app-node"
 import { EventV2 } from "../event"
+import type { PluginV2 } from "../plugin"
 
 export const Updated = EventV2.ephemeral({ type: "sdk.plugin.updated", schema: {} })
 
@@ -20,7 +21,7 @@ export const Updated = EventV2.ephemeral({ type: "sdk.plugin.updated", schema: {
  */
 export interface Interface {
   readonly register: (plugin: Plugin) => Effect.Effect<void>
-  readonly all: () => readonly Plugin[]
+  readonly all: () => readonly PluginV2.Versioned[]
 }
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/SdkPlugins") {}
@@ -29,11 +30,12 @@ export const layer = Layer.effect(
   Service,
   Effect.gen(function* () {
     const events = yield* EventV2.Service
-    const plugins = new Map<string, Plugin>()
+    const plugins = new Map<string, PluginV2.Versioned>()
+    let revision = 0
     return Service.of({
       register: (plugin) =>
         Effect.sync(() => {
-          plugins.set(plugin.id, plugin)
+          plugins.set(plugin.id, { ...plugin, version: String(++revision) })
         }).pipe(Effect.andThen(events.publish(Updated, {})), Effect.asVoid),
       all: () => [...plugins.values()],
     })

packages/core/src/plugin/supervisor.ts

@@ -116,15 +116,15 @@ const scan = Effect.fn("PluginSupervisor.scan")(function* (entries: readonly Con
 })
 
 const resolve = Effect.fn("PluginSupervisor.resolve")(function* (
-  pre: readonly Plugin[],
-  post: readonly Plugin[],
+  pre: readonly PluginV2.Versioned[],
+  post: readonly PluginV2.Versioned[],
   operations: readonly Operation[],
 ) {
   const matches = (selector: string, target: string) =>
     selector === "*" || (selector.endsWith(".*") ? target.startsWith(selector.slice(0, -1)) : selector === target)
   const definitions = [...pre, ...post]
   const enabled = new Set(definitions.map((plugin) => plugin.id))
-  const packages = new Map<string, Plugin>()
+  const packages = new Map<string, PluginV2.Versioned>()
   const plugins = () => [...definitions, ...packages.values()]
 
   for (const operation of operations) {
@@ -178,8 +178,9 @@ const load = Effect.fn("PluginSupervisor.load")(function* (operation: Extract<Op
   const plugin = "effect" in value ? value : PluginPromise.fromPromise(value)
   return {
     id: plugin.id,
+    version: JSON.stringify(operation),
     effect: (host) => plugin.effect({ ...host, options: operation.options }),
-  } satisfies Plugin
+  } satisfies PluginV2.Versioned
 })
 
 function discoverDirectory(fs: FSUtil.Interface, directory: string) {
@@ -253,10 +254,11 @@ const layer = Layer.effect(
           // Resolve OpenCode's internal plugins with their privileged Location services.
           const internal = yield* PluginInternal.list()
           // Combine internal plugins with host-contributed SDK plugins in boot order.
-          const pre = [...internal.pre, ...sdk.all()]
+          const pre = [...internal.pre.map((plugin) => ({ ...plugin, version: "internal" })), ...sdk.all()]
+          const post = internal.post.map((plugin) => ({ ...plugin, version: "internal" }))
           const operations = yield* scan(yield* config.entries())
           // Apply config operations and load enabled package plugins into one ordered generation.
-          const plugins = yield* resolve(pre, internal.post, operations)
+          const plugins = yield* resolve(pre, post, operations)
           // Replace the active generation in one scoped, batched activation.
           yield* registry.activate(plugins)
           applied = target