fix: wait for plugins to complete before exit

- Track pending plugin event handlers in plugin service
- Add OPENCODE_EXPERIMENTAL_PLUGIN_EXIT_DEFAULT_TIMEOUT_MS env var (default: 60000ms)
- Wait for pending plugin events when session becomes idle
- Await event loop completion in run command before exiting

Fixes issue where plugins were interrupted mid-execution when
opencode-dev run exits, causing incomplete plugin processing.

Author: 0byte-coding

packages/opencode/src/cli/cmd/run.ts

@@ -27,6 +27,7 @@ import { BashTool } from "../../tool/bash"
 import { TodoWriteTool } from "../../tool/todo"
 import { Locale } from "../../util"
 import { AppRuntime } from "@/effect/app-runtime"
+import { Plugin } from "../../plugin"
 
 type ToolProps<T> = {
   input: Tool.InferParameters<T>
@@ -534,6 +535,12 @@ export const RunCommand = cmd({
             event.properties.sessionID === sessionID &&
             event.properties.status.type === "idle"
           ) {
+            // Wait for plugins to finish processing the session.idle event
+            if (!args.attach) {
+              await AppRuntime.runPromise(Plugin.Service.use((svc) => svc.waitForPendingEvents())).catch((e) => {
+                console.error("Failed to wait for pending plugin events:", e)
+              })
+            }
             break
           }
 
@@ -631,7 +638,7 @@ export const RunCommand = cmd({
       }
       await share(sdk, sessionID)
 
-      loop().catch((e) => {
+      const loopPromise = loop().catch((e) => {
         console.error(e)
         process.exit(1)
       })
@@ -655,6 +662,8 @@ export const RunCommand = cmd({
           parts: [...files, { type: "text", text: message }],
         })
       }
+
+      await loopPromise
     }
 
     if (args.attach) {

packages/opencode/src/flag/flag.ts

@@ -66,6 +66,7 @@ export const Flag = {
     copy === undefined ? process.platform === "win32" : truthy("OPENCODE_EXPERIMENTAL_DISABLE_COPY_ON_SELECT"),
   OPENCODE_ENABLE_EXA: truthy("OPENCODE_ENABLE_EXA") || OPENCODE_EXPERIMENTAL || truthy("OPENCODE_EXPERIMENTAL_EXA"),
   OPENCODE_EXPERIMENTAL_BASH_DEFAULT_TIMEOUT_MS: number("OPENCODE_EXPERIMENTAL_BASH_DEFAULT_TIMEOUT_MS"),
+  OPENCODE_EXPERIMENTAL_PLUGIN_EXIT_DEFAULT_TIMEOUT_MS: number("OPENCODE_EXPERIMENTAL_PLUGIN_EXIT_DEFAULT_TIMEOUT_MS"),
   OPENCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX: number("OPENCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX"),
   OPENCODE_EXPERIMENTAL_OXFMT: OPENCODE_EXPERIMENTAL || truthy("OPENCODE_EXPERIMENTAL_OXFMT"),
   OPENCODE_EXPERIMENTAL_LSP_TY: truthy("OPENCODE_EXPERIMENTAL_LSP_TY"),

packages/opencode/src/plugin/index.ts

@@ -30,6 +30,7 @@ const log = Log.create({ service: "plugin" })
 
 type State = {
   hooks: Hooks[]
+  pendingEvents: Set<Promise<void>>
 }
 
 // Hook names that follow the (input, output) => Promise<void> trigger pattern
@@ -49,6 +50,7 @@ export interface Interface {
   ) => Effect.Effect<Output>
   readonly list: () => Effect.Effect<Hooks[]>
   readonly init: () => Effect.Effect<void>
+  readonly waitForPendingEvents: (timeoutMs?: number) => Effect.Effect<void>
 }
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/Plugin") {}
@@ -111,6 +113,7 @@ export const layer = Layer.effect(
     const state = yield* InstanceState.make<State>(
       Effect.fn("Plugin.state")(function* (ctx) {
         const hooks: Hooks[] = []
+        const pendingEvents = new Set<Promise<void>>()
         const bridge = yield* EffectBridge.make()
 
         function publishPluginError(message: string) {
@@ -245,14 +248,21 @@ export const layer = Layer.effect(
           Stream.runForEach((input) =>
             Effect.sync(() => {
               for (const hook of hooks) {
-                void hook["event"]?.({ event: input as any })
+                const eventHandler = hook["event"]
+                if (!eventHandler) continue
+                const promise = Promise.resolve()
+                  .then(() => eventHandler({ event: input as any }))
+                  .finally(() => {
+                    pendingEvents.delete(promise)
+                  })
+                pendingEvents.add(promise)
               }
             }),
           ),
           Effect.forkScoped,
         )
 
-        return { hooks }
+        return { hooks, pendingEvents }
       }),
     )
 
@@ -280,7 +290,25 @@ export const layer = Layer.effect(
       yield* InstanceState.get(state)
     })
 
-    return Service.of({ trigger, list, init })
+    const waitForPendingEvents = Effect.fn("Plugin.waitForPendingEvents")(function* (timeoutMs?: number) {
+      const s = yield* InstanceState.get(state)
+      const timeout = timeoutMs ?? Flag.OPENCODE_EXPERIMENTAL_PLUGIN_EXIT_DEFAULT_TIMEOUT_MS ?? 60000
+
+      yield* Effect.tryPromise({
+        try: async () => {
+          // Wait a tick to let event handlers be added to pendingEvents
+          await Promise.resolve()
+          const pending = Array.from(s.pendingEvents)
+          if (pending.length === 0) return
+          await Promise.race([Promise.all(pending), new Promise<void>((resolve) => setTimeout(resolve, timeout))])
+        },
+        catch: (err) => {
+          log.error("failed to wait for pending plugin events", { error: err })
+        },
+      }).pipe(Effect.ignore)
+    })
+
+    return Service.of({ trigger, list, init, waitForPendingEvents })
   }),
 )