plugin: ctx.event.subscribe() loses location scoping — plugins receive events from all locations #58707

Summary

ctx.event.subscribe() in a Promise plugin is not reliably location-scoped: on one shared-server run every plugin instance received session events from all locations, so a plugin that tracks "is a session in my directory running" reflected activity from unrelated projects. On another server run (same machine, same config, hours earlier) the same plugin correctly received only its own location's events.

Environment

• opencode version: v2.1.4 (channel=latest; server process that showed the bug started on v2.1.4; the scoped behavior was observed on a server process started earlier that day when the installed binary was v2.1.2/v2.1.4 mid-update — auto-update channel)
• OS: Linux 7.0.0-38-generic x86_64 (Ubuntu)
• Terminal: TERM=xterm-256color, COLORTERM=truecolor
• Shell: /bin/bash
• Install/channel: official installer, latest channel, shared background service (client-server architecture)
• Active plugins: local server plugins in ~/.config/opencode/plugins/ (status_monitor.ts — the affected one; orca-opencode-status.js); reproduction below uses a minimal standalone plugin

Reproduction

1. Save this plugin to ~/.config/opencode/plugins/loc-events.ts:

import fs from "node:fs"
import { Plugin } from "@opencode/plugin"

export default Plugin.define({
  id: "loc-events",
  setup(ctx) {
    const dir = ctx.location.directory
    const log = (m: string) =>
      fs.appendFileSync("/tmp/loc-events.log", `${new Date().toISOString()} [${dir}] ${m}\n`)
    log("loaded")
    void (async () => {
      for await (const event of ctx.event.subscribe()) {
        const e = event as {
          type: string
          location?: { directory?: string }
          data?: { sessionID?: string }
        }
        log(`${e.type} loc=${e.location?.directory ?? "-"} sid=${e.data?.sessionID ?? "-"}`)
      }
    })()
  },
})

2. Restart the shared service (opencode service restart), open two TUIs in different directories (e.g. ~/projectA and ~/projectB).
3. Send a prompt in projectA.
4. Watch /tmp/loc-events.log.

Expected Behavior

The plugin instance loaded in projectB only receives events belonging to projectB's location — or, at minimum, the behavior is consistent between server runs. Per packages/core/src/plugin/host.ts, the plugin host subscribes through the location-aware bus (bus.subscribe() → local(...) filter in packages/core/src/bus.ts), which scopes delivery to the ambient location when one is in scope.

Actual Behavior

All instances receive an identical, unscoped stream: session.execution.started, session.step.*, session.tool.*, shell.created, etc. for sessions of other locations. Aggregated per-instance event counters captured at the same wall-clock second from three concurrent instances (directories /home/stanislavus, /home/stanislavus/PycharmProjects/coding-agent-status, /tmp/opencode) are byte-identical — all three counted the same session's events, and that session belonged to only one of the three locations:

2026-10-24T12:07:49.489Z [opencode]            events: shell.exited=1 shell.deleted=1 session.tool.success=1 session.step.ended=1 session.usage.updated=1 session.step.started=1 session.reasoning.started=1 session.reasoning.delta=4
2026-10-24T12:07:49.489Z [stanislavus]         events: shell.exited=1 shell.deleted=1 session.tool.success=1 session.step.ended=1 session.usage.updated=1 session.step.started=1 session.reasoning.started=1 session.reasoning.delta=4
2026-10-24T12:07:49.491Z [coding-agent-status] events: shell.exited=1 shell.deleted=1 session.tool.success=1 session.step.ended=1 session.usage.updated=1 session.step.started=1 session.reasoning.started=1 session.reasoning.delta=4

Additionally, earlier the same day on a different server process (started 05:12 UTC, before the binary auto-updated to v2.1.4), the scoping worked: a foreign location's session.execution.started did not reach another location's plugin instance, verified via state-change timestamps of a per-directory status plugin. After the next server start (11:03 UTC, v2.1.4) the streams became global. Same machine, same config, same plugin API — inconsistent between server runs.

Session event envelopes on v2.1.4 do carry event.location.directory, so plugins can filter manually; the concern is that the built-in scoping silently differs between runs.

Additional Context

• Real-world impact: a fleet status plugin (one dashboard card per project directory, heartbeats over HTTP) showed every project as "running" whenever any single session on the shared server was active.
• Workaround: filter every session event by event.location.directory === ctx.location.directory, falling back to the session.created event's data.location.directory, then to ctx.session.get({ sessionID }) lookups (fail open when a session cannot be attributed).
• For contrast, the HTTP endpoint GET /api/event is explicitly documented as "Subscribe to native events and plugin RPC events across all server locations" — global delivery there is intended; the plugin-context subscription is the one whose scoping flipped.
• Frequency: consistent within a server run; differs between runs. Observed once going scoped → unscoped after a server restart.
• Possibly related observation on v2.0.27 (fixed by v2.1.4): form.created/form.replied were not delivered to ctx.event.subscribe() at all while other session.* events kept flowing (verified with a pending question-tool form). Not reproducible on v2.1.4, mentioning only as delivery-reliability context.