perf(run-events): unblock bus dispatch with runFork in subscriber callbacks

Bus.subscribeCallback wraps the callback's return value in
Effect.tryPromise(() => Promise.resolve().then(() => callback(msg)))
inside a runForEach loop, so a Promise-returning callback (such as
Effect.runPromise) serializes handler completion per subscription —
each descendant question/permission event waits for the previous
handler's reject/reply round trip before dispatch advances.

Replace Effect.runPromise with Effect.runFork. runFork returns a
Fiber synchronously (non-thenable), so the bus's tryPromise resolves
immediately and the next event dispatches without waiting. Handler
defects no longer surface through Bus.on's tryPromise.catch, so wrap
the forked effect with Effect.tapCause + log.error.

Drops the per-event Promise wrapper allocation and unblocks
concurrent dispatch for long-running subagent loops with many
simultaneous descendants.

Addresses audit finding F7 (Opus diamond review, 2026-04-22).

Author: tesdal

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

@@ -1,4 +1,4 @@
-import { Effect, Option } from "effect"
+import { Cause, Effect, Fiber, Option } from "effect"
 import { Bus } from "@/bus"
 import { Permission } from "@/permission"
 import { Question } from "@/question"
@@ -86,8 +86,33 @@ export const make = Effect.fn("RunEvents.make")(function* (config: Config) {
     }
   }
 
+  // bus.subscribeCallback wraps the callback in an Effect.tryPromise-based
+  // subscription handler, so a Promise-returning callback (like Effect.runPromise)
+  // serializes handler completion per subscription. runFork returns a Fiber
+  // synchronously (non-thenable), unblocking dispatch so descendant question/
+  // permission events are processed concurrently — important for long-running
+  // subagent loops with many simultaneous descendants. Defects inside the forked
+  // fiber do not surface through that subscription callback wrapper, so log them
+  // here instead. Track in-flight fibers so unsubscribe() can interrupt them and
+  // bound handler work to the RunEvents lifecycle.
+  const inflight = new Set<Fiber.Fiber<void>>()
+  const fork = (effect: Effect.Effect<void>) => {
+    const fiber: Fiber.Fiber<void> = Effect.runFork(
+      effect.pipe(
+        Effect.tapCause((cause) =>
+          Cause.hasInterruptsOnly(cause)
+            ? Effect.void
+            : Effect.sync(() => log.error("handler failed", { cause })),
+        ),
+        Effect.ensuring(Effect.sync(() => inflight.delete(fiber))),
+      ),
+    )
+    inflight.add(fiber)
+    return fiber
+  }
+
   const unsubQuestion = yield* bus.subscribeCallback(Question.Event.Asked, (evt) =>
-    Effect.runPromise(
+    fork(
       Effect.gen(function* () {
         const mine = yield* isDescendant(evt.properties.sessionID)
         if (!mine) return
@@ -98,7 +123,7 @@ export const make = Effect.fn("RunEvents.make")(function* (config: Config) {
   )
 
   const unsubPermission = yield* bus.subscribeCallback(Permission.Event.Asked, (evt) =>
-    Effect.runPromise(
+    fork(
       Effect.gen(function* () {
         const mine = yield* isDescendant(evt.properties.sessionID)
         if (!mine) return
@@ -115,6 +140,8 @@ export const make = Effect.fn("RunEvents.make")(function* (config: Config) {
   const unsubscribe = () => {
     unsubQuestion()
     unsubPermission()
+    inflight.forEach((fiber) => Effect.runFork(Fiber.interrupt(fiber)))
+    inflight.clear()
   }
 
   return { stats, unsubscribe } satisfies Handle