test(plugin): type selected event callback

feat(plugin): select event subscriptions
2026-08-17 01:48:29 -04:00 · 2026-08-15 18:59:17 -04:00 · 2026-08-15 18:55:44 -04:00
52 changed files with 194 additions and 539 deletions
@@ -466,7 +466,6 @@ jobs:
          VITE_SENTRY_ENVIRONMENT: ${{ (github.ref_name == 'beta' && 'beta') || 'production' }}
          VITE_SENTRY_RELEASE: desktop@${{ needs.version.outputs.version }}
          OPENCODE_CLI_TARGET: ${{ matrix.settings.target }}
-          OPENCODE_CLI_DIST: ${{ github.workspace }}/packages/cli/dist

      - name: Package
        if: needs.version.outputs.release
@@ -60,11 +60,7 @@ export function NewSessionView(props: {
                  <Show
                    when={props.workspace.bar.visible()}
                    fallback={
-                      <PromptGitStatus
-                        branch={props.workspace.bar.branch()}
-                        noGit={!props.workspace.project.git()}
-                        class="ms-1"
-                      />
+                      <PromptGitStatus branch={props.workspace.bar.branch()} noGit={!props.workspace.project.git()} />
                    }
                  >
                    <PromptWorkspaceSelector
@@ -5,8 +5,7 @@ const fs = require("fs")
 const path = require("path")
 const os = require("os")

-const forwardedSignals =
-  process.platform === "win32" ? ["SIGINT", "SIGTERM", "SIGHUP"] : ["SIGINT", "SIGTERM", "SIGHUP", "SIGUSR1"]
+const forwardedSignals = ["SIGINT", "SIGTERM", "SIGHUP"]

 function run(target) {
  const child = childProcess.spawn(target, process.argv.slice(2), { stdio: "inherit" })
@@ -27,7 +27,6 @@ const requestedTarget = process.argv.find((arg) => arg.startsWith("--target="))?
 const skipInstall = process.argv.includes("--skip-install")
 const skipWebUi = process.argv.includes("--skip-web-ui")
 const solidPlugin = createSolidTransformPlugin()
-const releaseAssets = new Map<string, Promise<Map<string, string>>>()

 const allTargets: {
  os: string
@@ -117,9 +116,9 @@ for (const item of targets) {
      autoloadTsconfig: true,
      autoloadPackageJson: true,
      target: target.replace(binary, "bun") as Bun.Build.CompileTarget,
-      ...(executablePath ? { executablePath } : {}),
+      executablePath,
      outfile: path.join(outdir, name, "bin", binary),
-      execArgv: [`--user-agent=${binary}/${Script.version}`, "--use-system-ca", "--no-warnings", "--"],
+      execArgv: [`--user-agent=${binary}/${Script.version}`, "--use-system-ca", "--"],
      windows: {},
    },
    define: {
@@ -162,13 +161,7 @@ async function compileExecutable(item: (typeof allTargets)[number]) {
  if (!release) return

  const platform = item.os === "win32" ? "windows" : item.os
-  const name = [
-    "bun",
-    platform,
-    item.arch === "arm64" ? "aarch64" : item.arch,
-    item.abi,
-    item.avx2 === false ? "baseline" : undefined,
-  ]
+  const name = ["bun", platform, item.arch, item.abi, item.avx2 === false ? "baseline" : undefined]
    .filter(Boolean)
    .join("-")
  const cache = path.join(outdir, ".bun", release)
@@ -177,13 +170,7 @@ async function compileExecutable(item: (typeof allTargets)[number]) {

  await mkdir(cache, { recursive: true })
  const archive = path.join(cache, `${name}.zip`)
-  const assets = await compileReleaseAssets(release)
-  const url = assets.get(`${name}.zip`)
-  if (!url) throw new Error(`Bun release ${release} does not include ${name}.zip`)
-  const token = process.env.GH_TOKEN ?? process.env.GITHUB_TOKEN
-  const response = await fetch(url, {
-    headers: { Accept: "application/octet-stream", ...(token ? { Authorization: `Bearer ${token}` } : {}) },
-  })
+  const response = await fetch(`https://github.com/oven-sh/bun/releases/download/${release}/${name}.zip`)
  if (!response.ok) throw new Error(`Failed to download ${name} from Bun release ${release}: ${response.status}`)
  await Bun.write(archive, response)
  await $`unzip -oq ${archive} -d ${cache}`
@@ -191,38 +178,6 @@ async function compileExecutable(item: (typeof allTargets)[number]) {
  return executable
 }

-function compileReleaseAssets(release: string) {
-  const existing = releaseAssets.get(release)
-  if (existing) return existing
-  const pending = fetch(`https://api.github.com/repos/oven-sh/bun/releases/tags/${release}?cache=${Date.now()}`)
-    .then(async (response) => {
-      if (!response.ok) throw new Error(`Failed to resolve Bun release ${release}: ${response.status}`)
-      const data: unknown = await response.json()
-      if (typeof data !== "object" || data === null || !("assets" in data) || !Array.isArray(data.assets)) {
-        throw new Error(`Bun release ${release} returned invalid metadata`)
-      }
-      return new Map(
-        data.assets
-          .filter(
-            (asset): asset is { name: string; url: string } =>
-              typeof asset === "object" &&
-              asset !== null &&
-              "name" in asset &&
-              typeof asset.name === "string" &&
-              "url" in asset &&
-              typeof asset.url === "string",
-          )
-          .map((asset) => [asset.name, asset.url]),
-      )
-    })
-    .catch((error) => {
-      releaseAssets.delete(release)
-      throw error
-    })
-  releaseAssets.set(release, pending)
-  return pending
-}
-
 function targetName(item: (typeof allTargets)[number]) {
  return [
    binary,
@@ -20,6 +20,7 @@ async function publish(dir: string, name: string, version: string) {
    await $`bun pm pack`.cwd(dir)
    await $`npm publish *.tgz --access public --tag ${Script.channel}`.cwd(dir)
  }
+  if (Script.channel === "beta") await $`npm dist-tag add ${`${name}@${version}`} next`
 }

 async function publishDistribution(input: { root: string; name: string; binary: string; packagePrefix: string }) {
@@ -1,6 +1,5 @@
-import { Argument, Command, Flag } from "effect/unstable/cli"
+import { Argument, Flag } from "effect/unstable/cli"
 import { Spec } from "../framework/spec"
-import { GlobalFlags } from "./global-flags"

 declare const OPENCODE_CLI_NAME: string | undefined

@@ -27,7 +26,7 @@ const PermissionParams = {
  ),
 }

-const Root = Spec.make(typeof OPENCODE_CLI_NAME === "string" ? OPENCODE_CLI_NAME : "opencode", {
+export const Commands = Spec.make(typeof OPENCODE_CLI_NAME === "string" ? OPENCODE_CLI_NAME : "opencode", {
  description: "OpenCode 2.0 preview command line interface",
  params: {
    ...ServerParams,
@@ -71,7 +70,7 @@ const Root = Spec.make(typeof OPENCODE_CLI_NAME === "string" ? OPENCODE_CLI_NAME
      description: "Debugging and troubleshooting tools",
      commands: [
        Spec.make("agents", { description: "List all agents" }),
-        Spec.make("config", { description: "List configuration sources" }),
+        Spec.make("config", { description: "Show resolved configuration" }),
      ],
    }),
    Spec.make("console", {
@@ -278,5 +277,3 @@ const Root = Spec.make(typeof OPENCODE_CLI_NAME === "string" ? OPENCODE_CLI_NAME
    }),
  ],
 })
-
-export const Commands = { ...Root, spec: Root.spec.pipe(Command.withGlobalFlags(GlobalFlags.all)) }
@@ -1,12 +0,0 @@
-export * as GlobalFlags from "./global-flags"
-
-import { Flag, GlobalFlag } from "effect/unstable/cli"
-
-export const CpuProfile = GlobalFlag.setting("cpu-profile")({
-  flag: Flag.string("cpu-profile").pipe(
-    Flag.withDescription("Write a CPU profile to this path when the process stops"),
-    Flag.optional,
-  ),
-})
-
-export const all = [CpuProfile] as const
@@ -10,17 +10,15 @@ import { Updater } from "../../services/updater"
 import { UpdatePreflight } from "../../services/update-preflight"
 import { Npm } from "@opencode-ai/util/npm"
 import { OPENCODE_CHANNEL, OPENCODE_VERSION } from "../../version"
-import { Env } from "../../env"

 export default Runtime.handler(Commands, (input) =>
  Effect.gen(function* () {
    const requestedDirectory = Option.getOrUndefined(input.directory)
-    const requestedServer = Option.getOrUndefined(input.server)
    if (requestedDirectory !== undefined) process.chdir(requestedDirectory)
    const preflight = UpdatePreflight.make()
    yield* Effect.addFinalizer(() => Effect.promise(() => preflight.close()))
    const server = yield* ServerConnection.resolve({
-      server: requestedServer,
+      server: Option.getOrUndefined(input.server),
      standalone: input.standalone,
      mismatch: "replace",
      onStart: (reason, previousVersion) => {
@@ -77,7 +75,6 @@ export default Runtime.handler(Commands, (input) =>
        resolve: (spec) =>
          runPromise(npm.add(spec, { subpaths: ["tui"] }).pipe(Effect.map((result) => result.entrypoint))),
      },
-      environment: requestedServer === undefined ? Env.session() : undefined,
      terminalHandoff: () => preflight.finish(),
      log: (level, message, tags) => {
        const effect =
@@ -1,45 +0,0 @@
-export * as CpuProfile from "./cpu-profile"
-
-import { Effect, FileSystem } from "effect"
-import { Session } from "node:inspector"
-import path from "node:path"
-
-export function run<A, E, R>(file: string, effect: Effect.Effect<A, E, R>) {
-  const target = path.resolve(file)
-  return Effect.acquireUseRelease(
-    Effect.gen(function* () {
-      const fs = yield* FileSystem.FileSystem
-      yield* fs.makeDirectory(path.dirname(target), { recursive: true })
-      const session = new Session()
-      session.connect()
-      yield* command(session, "Profiler.enable")
-      yield* command(session, "Profiler.start")
-      yield* Effect.logInfo("CPU profile started", { path: target })
-      return session
-    }),
-    () => effect,
-    (session) =>
-      Effect.tryPromise(
-        () =>
-          new Promise<void>((resolve, reject) => {
-            session.post("Profiler.stop", (error, result) => {
-              session.disconnect()
-              if (error) return reject(error)
-              Bun.write(target, JSON.stringify(result.profile)).then(() => resolve(), reject)
-            })
-          }),
-      ).pipe(
-        Effect.andThen(Effect.logInfo("CPU profile written", { path: target })),
-        Effect.catchCause((cause) => Effect.logError("Failed to write CPU profile", { path: target, cause })),
-      ),
-  )
-}
-
-function command(session: Session, method: "Profiler.enable" | "Profiler.start") {
-  return Effect.tryPromise(
-    () =>
-      new Promise<void>((resolve, reject) => {
-        session.post(method, (error) => (error ? reject(error) : resolve()))
-      }),
-  )
-}
@@ -12,13 +12,4 @@ export const password = Config.redacted("OPENCODE_PASSWORD").pipe(
  Config.withDefault(undefined),
 )

-export function session() {
-  return Object.fromEntries(
-    Object.entries(process.env).filter(
-      (entry): entry is [string, string] =>
-        entry[1] !== undefined && entry[0] !== "OPENCODE_PASSWORD" && entry[0] !== "OPENCODE_SERVER_PASSWORD",
-    ),
-  )
-}
-
 export * as Env from "./env"
@@ -1,13 +1,10 @@
-import { Effect, FileSystem, Option, Scope } from "effect"
+import { Effect, FileSystem, Scope } from "effect"
 import { Command } from "effect/unstable/cli"
 import { Spec } from "./spec"
 import { Global } from "@opencode-ai/util/global"
 import { Updater } from "../services/updater"
 import { Config } from "../config"
 import { Npm } from "@opencode-ai/util/npm"
-import { GlobalFlags } from "../commands/global-flags"
-import { CpuProfile } from "../cpu-profile"
-import path from "node:path"

 export type Input<Value> =
  Value extends Spec.Node<infer _Name, infer Command, infer _Commands>
@@ -89,22 +86,7 @@ function provide(node: Spec.Any, handlers: ReadonlyArray<LazyHandler>): Provided
    ? node.spec.pipe(
        Command.withHandler((input) =>
          Effect.gen(function* () {
-            const module = yield* Effect.promise(handler.load)
-            const cpuProfile = Option.getOrUndefined(yield* GlobalFlags.CpuProfile)
-            if (!cpuProfile) return yield* module.default(input)
-            const target = path.resolve(cpuProfile)
-            const previous = process.env.OPENCODE_CPU_PROFILE
-            process.env.OPENCODE_CPU_PROFILE = target
-            return yield* (
-              node.name === "serve" ? CpuProfile.run(target, module.default(input)) : module.default(input)
-            ).pipe(
-              Effect.ensuring(
-                Effect.sync(() => {
-                  if (previous === undefined) delete process.env.OPENCODE_CPU_PROFILE
-                  else process.env.OPENCODE_CPU_PROFILE = previous
-                }),
-              ),
-            )
+            yield* Effect.flatMap(Effect.promise(handler.load), (module) => module.default(input))
          }),
        ),
      )
@@ -1,37 +0,0 @@
-import { Global } from "@opencode-ai/util/global"
-import { Effect, Queue } from "effect"
-import path from "node:path"
-
-export const listen = Effect.gen(function* () {
-  const global = yield* Global.Service
-  if (process.platform === "win32") return
-  const signals = yield* Queue.dropping<void>(1)
-  yield* Effect.acquireRelease(
-    Effect.sync(() => {
-      const handler = () => Queue.offerUnsafe(signals, undefined)
-      process.on("SIGUSR1", handler)
-      return handler
-    }),
-    (handler) => Effect.sync(() => process.off("SIGUSR1", handler)),
-  )
-  yield* Queue.take(signals).pipe(
-    Effect.andThen(
-      Effect.suspend(() => {
-        const file = path.join(
-          global.log,
-          `heap-${process.pid}-${new Date().toISOString().replace(/[:.]/g, "")}.heapsnapshot`,
-        )
-        return Effect.gen(function* () {
-          yield* Effect.logInfo("writing heap snapshot", { path: file })
-          const { writeHeapSnapshot } = yield* Effect.tryPromise(() => import("node:v8"))
-          yield* Effect.try(() => writeHeapSnapshot(file))
-          yield* Effect.logInfo("heap snapshot written", { path: file })
-        }).pipe(Effect.catchCause((cause) => Effect.logError("failed to write heap snapshot", { path: file, cause })))
-      }),
-    ),
-    Effect.forever,
-    Effect.forkScoped({ startImmediately: true }),
-  )
-})
-
-export * as Heap from "./heap"
@@ -12,7 +12,6 @@ import { Global } from "@opencode-ai/util/global"
 import { AppProcess } from "@opencode-ai/util/process"
 import { Config } from "./config"
 import { Npm } from "@opencode-ai/util/npm"
-import { Heap } from "./heap"

 const Handlers = Runtime.handlers(Commands, {
  $: () => import("./commands/handlers/default"),
@@ -55,16 +54,13 @@ const Handlers = Runtime.handlers(Commands, {
  serve: () => import("./commands/handlers/serve"),
 })

-Effect.gen(function* () {
-  yield* Heap.listen
-  yield* Effect.logInfo("cli starting", {
-    version: OPENCODE_VERSION,
-    channel: OPENCODE_CHANNEL,
-    local: OPENCODE_LOCAL,
-    args: process.argv.slice(2),
-  })
-  return yield* Runtime.run(Commands, Handlers, { version: OPENCODE_VERSION })
+Effect.logInfo("cli starting", {
+  version: OPENCODE_VERSION,
+  channel: OPENCODE_CHANNEL,
+  local: OPENCODE_LOCAL,
+  args: process.argv.slice(2),
 }).pipe(
+  Effect.flatMap(() => Runtime.run(Commands, Handlers, { version: OPENCODE_VERSION })),
  Effect.annotateLogs({ role: "cli" }),
  Effect.provide(Config.layer),
  Effect.provide(Updater.layer),
@@ -104,12 +104,7 @@ export const options = Effect.fnUntraced(function* (input: { readonly checkVersi
  return {
    file,
    version: input.checkVersion ? OPENCODE_VERSION : undefined,
-    command: [
-      ...selfCommand(),
-      "serve",
-      "--service",
-      ...(process.env.OPENCODE_CPU_PROFILE ? ["--cpu-profile", process.env.OPENCODE_CPU_PROFILE] : []),
-    ],
+    command: [...selfCommand(), "serve", "--service"],
  }
 })

@@ -10,10 +10,9 @@ describe("debug config command", () => {

    expect(debug.exitCode).toBe(0)
    expect(debug.stdout).toContain("config")
-    expect(debug.stdout).toContain("List configuration sources")
+    expect(debug.stdout).toContain("Show resolved configuration")
    expect(config.exitCode).toBe(0)
    expect(config.stdout).toContain("opencode debug config [flags]")
-    expect(config.stdout).toContain("List configuration sources")
  })

  test("prints config entries from the invoking directory without reordering permissions", async () => {
@@ -1,24 +0,0 @@
-import { expect, test } from "bun:test"
-import { Env } from "../src/env"
-
-test("session environment omits server credentials", () => {
-  const previousPassword = process.env.OPENCODE_PASSWORD
-  const previousLegacyPassword = process.env.OPENCODE_SERVER_PASSWORD
-  const previousValue = process.env.OPENCODE_SESSION_ENV_TEST
-  process.env.OPENCODE_PASSWORD = "password"
-  process.env.OPENCODE_SERVER_PASSWORD = "legacy"
-  process.env.OPENCODE_SESSION_ENV_TEST = "included"
-
-  const environment = Env.session()
-
-  if (previousPassword === undefined) delete process.env.OPENCODE_PASSWORD
-  else process.env.OPENCODE_PASSWORD = previousPassword
-  if (previousLegacyPassword === undefined) delete process.env.OPENCODE_SERVER_PASSWORD
-  else process.env.OPENCODE_SERVER_PASSWORD = previousLegacyPassword
-  if (previousValue === undefined) delete process.env.OPENCODE_SESSION_ENV_TEST
-  else process.env.OPENCODE_SESSION_ENV_TEST = previousValue
-
-  expect(environment.OPENCODE_PASSWORD).toBeUndefined()
-  expect(environment.OPENCODE_SERVER_PASSWORD).toBeUndefined()
-  expect(environment.OPENCODE_SESSION_ENV_TEST).toBe("included")
-})
@@ -19,29 +19,6 @@ test("managed service ports are stable per installation channel", () => {
  expect(ServiceConfig.defaultPort("preview-a")).not.toBe(ServiceConfig.defaultPort("preview-b"))
 })

-test("managed service forwards the CPU profile path to the server", async () => {
-  const root = await fs.mkdtemp(path.join(os.tmpdir(), "opencode-service-profile-"))
-  const profile = path.join(root, "server.cpuprofile")
-  try {
-    const previous = process.env.OPENCODE_CPU_PROFILE
-    process.env.OPENCODE_CPU_PROFILE = profile
-    try {
-      const options = await Effect.runPromise(
-        ServiceConfig.options().pipe(
-          Effect.provide(Global.layerWith({ config: path.join(root, "config"), state: path.join(root, "state") })),
-          Effect.provide(NodeFileSystem.layer),
-        ),
-      )
-      expect(options.command.slice(-2)).toEqual(["--cpu-profile", profile])
-    } finally {
-      if (previous === undefined) delete process.env.OPENCODE_CPU_PROFILE
-      else process.env.OPENCODE_CPU_PROFILE = previous
-    }
-  } finally {
-    await fs.rm(root, { recursive: true, force: true })
-  }
-})
-
 test("local channel stores service config with the local service filename", async () => {
  const root = await fs.mkdtemp(path.join(os.tmpdir(), "opencode-service-"))
  try {
@@ -914,10 +914,6 @@ export type Endpoint5_34Input = { readonly sessionID: Session.ID; readonly messa
 export type Endpoint5_34Output = SessionMessage.Info
 export type SessionMessageOperation<E = never> = (input: Endpoint5_34Input) => Effect.Effect<Endpoint5_34Output, E>

-export type Endpoint5_35Input = { readonly sessionID: Session.ID; readonly variables: { readonly [x: string]: string } }
-export type Endpoint5_35Output = void
-export type SessionEnvironmentOperation<E = never> = (input: Endpoint5_35Input) => Effect.Effect<Endpoint5_35Output, E>
-
 export interface SessionApi<E = never> {
  readonly list: SessionListOperation<E>
  readonly create: SessionCreateOperation<E>
@@ -962,7 +958,6 @@ export interface SessionApi<E = never> {
  readonly interrupt: SessionInterruptOperation<E>
  readonly background: SessionBackgroundOperation<E>
  readonly message: SessionMessageOperation<E>
-  readonly environment: SessionEnvironmentOperation<E>
 }

 export type Endpoint6_0Input = {
@@ -86,8 +86,6 @@ import type {
  Endpoint5_33Output,
  Endpoint5_34Input,
  Endpoint5_34Output,
-  Endpoint5_35Input,
-  Endpoint5_35Output,
  Endpoint6_0Input,
  Endpoint6_0Output,
  Endpoint7_0Input,
@@ -612,14 +610,6 @@ const Endpoint5_34 = (raw: RawClient["server.session"]) => (input: Endpoint5_34I
    ),
  )

-const Endpoint5_35 = (raw: RawClient["server.session"]) => (input: Endpoint5_35Input) =>
-  preserveEffect<Endpoint5_35Output>()(
-    raw["session.environment"]({
-      params: { sessionID: input["sessionID"] },
-      payload: { variables: input["variables"] },
-    }).pipe(Effect.mapError(mapClientError)),
-  )
-
 const adaptGroup5 = (raw: RawClient["server.session"]) => ({
  list: Endpoint5_0(raw),
  create: Endpoint5_1(raw),
@@ -649,7 +639,6 @@ const adaptGroup5 = (raw: RawClient["server.session"]) => ({
  interrupt: Endpoint5_32(raw),
  background: Endpoint5_33(raw),
  message: Endpoint5_34(raw),
-  environment: Endpoint5_35(raw),
 })

 const Endpoint6_0 = (raw: RawClient["server.message"]) => (input: Endpoint6_0Input) =>
@@ -80,8 +80,6 @@ import type {
  SessionBackgroundOutput,
  SessionMessageInput,
  SessionMessageOutput,
-  SessionEnvironmentInput,
-  SessionEnvironmentOutput,
  MessageListInput,
  MessageListOutput,
  ModelListInput,
@@ -898,18 +896,6 @@ export function make(options: ClientOptions) {
          },
          requestOptions,
        ).then((value) => value.data),
-      environment: (input: SessionEnvironmentInput, requestOptions?: RequestOptions) =>
-        request<SessionEnvironmentOutput>(
-          {
-            method: "PUT",
-            path: `/api/session/${encodeURIComponent(input.sessionID)}/environment`,
-            body: { variables: input["variables"] },
-            successStatus: 204,
-            declaredStatuses: [404, 401, 400],
-            empty: true,
-          },
-          requestOptions,
-        ),
    },
    message: {
      list: (input: MessageListInput, requestOptions?: RequestOptions) =>
@@ -3936,13 +3936,6 @@ export type SessionMessageInput = {

 export type SessionMessageOutput = { data: SessionMessageInfo }["data"]

-export type SessionEnvironmentInput = {
-  readonly sessionID: { readonly sessionID: string }["sessionID"]
-  readonly variables: { readonly variables: { readonly [x: string]: string } }["variables"]
-}
-
-export type SessionEnvironmentOutput = void
-
 export type MessageListInput = {
  readonly sessionID: { readonly sessionID: string }["sessionID"]
  readonly limit?: {
@@ -82,7 +82,7 @@ export const Plugin = define({
      .pipe(
        Stream.filterEffect((update) => Effect.map(config.entries(), (entries) => isAgentSource(entries, update.path))),
      )
-    const configUpdates = ctx.event.subscribe().pipe(Stream.filter((event) => event.type === "config.updated"))
+    const configUpdates = ctx.event.subscribe("config.updated")
    yield* Stream.merge(sourceChanges, configUpdates).pipe(
      Stream.debounce("100 millis"),
      Stream.runForEach(() => reload),
@@ -43,7 +43,7 @@ export const Plugin = define({
          Effect.map(config.entries(), (entries) => isCommandSource(entries, update.path)),
        ),
      )
-    const configUpdates = ctx.event.subscribe().pipe(Stream.filter((event) => event.type === "config.updated"))
+    const configUpdates = ctx.event.subscribe("config.updated")
    yield* Stream.merge(sourceChanges, configUpdates).pipe(
      Stream.debounce("100 millis"),
      Stream.runForEach(() => reload),
@@ -22,8 +22,7 @@ export const Plugin = define({
        if (policy?.effect === "deny") catalog.provider.remove(record.provider.id)
      }
    })
-    yield* ctx.event.subscribe().pipe(
-      Stream.filter((event) => event.type === "config.updated"),
+    yield* ctx.event.subscribe("config.updated").pipe(
      Stream.runForEach(() =>
        config.entries().pipe(
          Effect.tap((entries) => Effect.sync(() => (loaded.entries = entries))),
@@ -97,8 +97,7 @@ export const Plugin = define({
        }
      }
    })
-    yield* ctx.event.subscribe().pipe(
-      Stream.filter((event) => event.type === "config.updated"),
+    yield* ctx.event.subscribe("config.updated").pipe(
      Stream.runForEach(() =>
        config.entries().pipe(
          Effect.tap((entries) => Effect.sync(() => (loaded.entries = entries))),
@@ -49,8 +49,7 @@ export const Plugin = define({
      }
      for (const [name, source] of entries) draft.add(name, source)
    })
-    yield* ctx.event.subscribe().pipe(
-      Stream.filter((event) => event.type === "config.updated"),
+    yield* ctx.event.subscribe("config.updated").pipe(
      Stream.runForEach(() =>
        config.entries().pipe(
          Effect.tap((entries) => Effect.sync(() => (loaded.entries = entries))),
@@ -180,8 +180,7 @@ export const Plugin = define({
    yield* ctx.skill.transform((draft) => {
      for (const skill of loaded.skills) draft.add(skill)
    })
-    yield* ctx.event.subscribe().pipe(
-      Stream.filter((event) => event.type === "config.updated"),
+    yield* ctx.event.subscribe("config.updated").pipe(
      Stream.runForEach(() =>
        config.entries().pipe(
          Effect.tap((entries) => Effect.sync(() => (loaded.entries = entries))),
@@ -14,8 +14,7 @@ export const Plugin = define({
      if (selection === false) websearch.default.set(false)
      if (selection) websearch.default.set(selection.provider)
    })
-    yield* ctx.event.subscribe().pipe(
-      Stream.filter((event) => event.type === "config.updated"),
+    yield* ctx.event.subscribe("config.updated").pipe(
      Stream.runForEach(() =>
        config.entries().pipe(
          Effect.tap((entries) => Effect.sync(() => (loaded.entries = entries))),
@@ -59,6 +59,12 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: import("../p
    ref.directory === location.directory && ref.workspaceID === location.workspaceID
  const response = <A, E, R>(effect: Effect.Effect<A, E, R>) =>
    effect.pipe(Effect.map((data) => ({ location: locationInfo(), data })))
+  const subscribe: Plugin.Context["event"]["subscribe"] = (type?: EventManifest.ServerEvent["type"]) => {
+    if (type === undefined) return bus.subscribe().pipe(Stream.filter(EventManifest.isServer))
+    const definition = EventManifest.Server.get(type)
+    if (!definition) return Stream.fail(new Error(`Unknown plugin event type: ${type}`))
+    return bus.subscribe(definition).pipe(Stream.filter(EventManifest.isServer))
+  }

  return {
    app,
@@ -180,7 +186,7 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: import("../p
        }),
    },
    event: {
-      subscribe: () => bus.subscribe().pipe(Stream.filter(EventManifest.isServer)),
+      subscribe,
    },
    integration: {
      list: () => response(integration.list()),
@@ -51,7 +51,6 @@ import { Global } from "@opencode-ai/util/global"
 import { Shell as ShellSchema } from "@opencode-ai/schema/shell"
 import { KeyedMutex } from "./effect/keyed-mutex.js"
 import { fileURLToPath } from "url"
-import { SessionEnvironment } from "./session/environment.js"

 // get project -> project.locations
 //
@@ -166,10 +165,6 @@ export interface Interface {
    input: ForkInput,
  ) => Effect.Effect<SessionSchema.Info, NotFoundError | MessageNotFoundError | ForkEmptyError>
  readonly get: (sessionID: SessionSchema.ID) => Effect.Effect<SessionSchema.Info, NotFoundError>
-  readonly environment: (input: {
-    readonly sessionID: SessionSchema.ID
-    readonly variables?: SessionEnvironment.Variables
-  }) => Effect.Effect<SessionEnvironment.Variables | undefined, NotFoundError>
  readonly remove: (sessionID: SessionSchema.ID) => Effect.Effect<void, NotFoundError>
  readonly messages: (input: {
    sessionID: SessionSchema.ID
@@ -309,7 +304,6 @@ const layer = Layer.effect(
    const locations = yield* LocationServiceMap.Service
    const fs = yield* FSUtil.Service
    const jobs = yield* Job.Service
-    const environments = yield* SessionEnvironment.Service
    const scope = yield* Scope.Scope
    const activeShells = new Set<SessionSchema.ID>()
    const shellLocks = KeyedMutex.makeUnsafe<SessionSchema.ID>()
@@ -453,11 +447,6 @@ const layer = Layer.effect(
        if (!session) return yield* new NotFoundError({ sessionID })
        return session
      }),
-      environment: Effect.fn("Session.environment")(function* (input) {
-        yield* result.get(input.sessionID)
-        if (input.variables !== undefined) yield* environments.set(input.sessionID, input.variables)
-        return yield* environments.get(input.sessionID)
-      }),
      remove: Effect.fn("Session.remove")(function* (sessionID) {
        const session = yield* result.get(sessionID)
        yield* execution.interrupt(sessionID)
@@ -465,7 +454,6 @@ const layer = Layer.effect(
        yield* closeTransport(session)
        const children = yield* result.list({ parentID: sessionID })
        yield* Effect.forEach(children.data, (child) => result.remove(child.id), { concurrency: 1, discard: true })
-        yield* environments.clear(sessionID)
        yield* bus.publish(SessionEvent.Deleted, { sessionID })
        yield* bus.remove(sessionID)
      }),
@@ -664,12 +652,7 @@ const layer = Layer.effect(
            const started = yield* Effect.gen(function* () {
              const shell = yield* Shell.Service
              return yield* shell
-                .create({
-                  command: input.command,
-                  cwd: session.location.directory,
-                  timeout: 0,
-                  metadata: { sessionID: input.sessionID },
-                })
+                .create({ command: input.command, cwd: session.location.directory, timeout: 0 })
                .pipe(Effect.orDie)
            }).pipe(Effect.provide(locations.get(session.location)))
            yield* bus.publish(
@@ -1119,7 +1102,6 @@ export const node = makeGlobalNode({
  layer: layer.pipe(Layer.orDie),
  deps: [
    Job.node,
-    SessionEnvironment.node,
    Database.node,
    Bus.node,
    Project.node,
@@ -1,41 +0,0 @@
-export * as SessionEnvironment from "./environment.js"
-
-import { Context, Effect, Layer, Ref } from "effect"
-import { makeGlobalNode } from "@opencode-ai/util/effect/app-node"
-import { SessionSchema } from "./schema.js"
-
-export type Variables = Readonly<Record<string, string>>
-
-export interface Interface {
-  readonly get: (sessionID: SessionSchema.ID) => Effect.Effect<Variables | undefined>
-  readonly set: (sessionID: SessionSchema.ID, variables: Variables) => Effect.Effect<void>
-  readonly clear: (sessionID: SessionSchema.ID) => Effect.Effect<void>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/SessionEnvironment") {}
-
-const layer = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const environments = yield* Ref.make(new Map<SessionSchema.ID, Variables>())
-
-    return Service.of({
-      get: Effect.fn("SessionEnvironment.get")(function* (sessionID) {
-        return (yield* Ref.get(environments)).get(sessionID)
-      }),
-      set: Effect.fn("SessionEnvironment.set")(function* (sessionID, variables) {
-        yield* Ref.update(environments, (current) => new Map(current).set(sessionID, { ...variables }))
-      }),
-      clear: Effect.fn("SessionEnvironment.clear")(function* (sessionID) {
-        yield* Ref.update(environments, (current) => {
-          if (!current.has(sessionID)) return current
-          const next = new Map(current)
-          next.delete(sessionID)
-          return next
-        })
-      }),
-    })
-  }),
-)
-
-export const node = makeGlobalNode({ service: Service, layer, deps: [] })
@@ -150,10 +150,6 @@ export const createLLMEventPublisher = (bus: Pick<Bus.Interface, "publish">, inp
      if (!current) return yield* Effect.die(new Error(`${name} delta before start: ${id}`))
      if (!current.pending) return undefined
      const now = yield* Clock.currentTimeMillis
-      if (!force && current.publishedAt === undefined) {
-        current.publishedAt = now
-        return undefined
-      }
      if (!force && current.publishedAt !== undefined && now - current.publishedAt < deltaBatchInterval)
        return undefined
      yield* delta(id, current.pending, current.ordinal)
@@ -15,8 +15,6 @@ import { Global } from "@opencode-ai/util/global"
 import { ShellSelect } from "./shell/select.js"
 import type { ShellCreateBefore } from "@opencode-ai/plugin/effect/shell"
 import { PluginHooks } from "./plugin/hooks.js"
-import { SessionEnvironment } from "./session/environment.js"
-import { SessionSchema } from "./session/schema.js"

 export class NotFoundError extends Schema.TaggedErrorClass<NotFoundError>()("Shell.NotFoundError", {
  id: Shell.ID,
@@ -78,7 +76,6 @@ export const layer = (options?: ShellSelect.Options) =>
      const global = yield* Global.Service
      const environment = yield* Environment.Service
      const hooks = yield* PluginHooks.Service
-      const environments = yield* SessionEnvironment.Service
      const context = yield* Effect.context()
      const runFork = Effect.runForkWith(context)
      const sessions = new Map<string, Active>()
@@ -187,18 +184,13 @@ export const layer = (options?: ShellSelect.Options) =>
        input: Shell.CreateInput,
        before?: (input: ShellCreateBefore) => Effect.Effect<void, E, R>,
      ) {
-        const sessionID = input.metadata?.sessionID
-        const sessionEnvironment =
-          location.workspaceID === undefined && Schema.is(SessionSchema.ID)(sessionID)
-            ? yield* environments.get(sessionID)
-            : undefined
        const invocation: ShellCreateBefore = {
          command: input.command,
          cwd: input.cwd ?? location.directory,
          timeout: input.timeout,
          shell: yield* resolve(),
          env: {
-            ...(sessionEnvironment ?? process.env),
+            ...process.env,
            TERM: "xterm-256color",
            OPENCODE_TERMINAL: "1",
          },
@@ -357,15 +349,7 @@ export function configured(options?: ShellSelect.Options) {
  return makeLocationNode({
    service: Service,
    layer: layer(options),
-    deps: [
-      Bus.node,
-      Location.node,
-      Config.node,
-      Global.node,
-      Environment.node,
-      PluginHooks.node,
-      SessionEnvironment.node,
-    ],
+    deps: [Bus.node, Location.node, Config.node, Global.node, Environment.node, PluginHooks.node],
  })
 }

@@ -20,24 +20,55 @@ class Secret extends Context.Service<Secret, string>()("@opencode/test/PluginSec
 const versioned = <R>(plugin: EffectPlugin.Plugin<R>, version = "1") => ({ ...plugin, version })

 describe("Plugin", () => {
-  it.live("exposes public events through the plugin context", () =>
+  it.live("selects one public event type through the plugin context", () =>
    Effect.gen(function* () {
      const plugins = yield* Plugin.Service
      const bus = yield* Bus.Service
      const host = yield* PluginHost.make(plugins)
-      const received = yield* host.event.subscribe().pipe(
-        Stream.filter((event) => event.type === "config.updated"),
-        Stream.runHead,
-        Effect.forkScoped({ startImmediately: true }),
-      )
+      const received = yield* host.event
+        .subscribe("config.updated")
+        .pipe(Stream.runHead, Effect.forkScoped({ startImmediately: true }))
      yield* Effect.sleep("10 millis")

+      yield* bus.publish(Plugin.Event.Updated, {})
      yield* bus.publish(ConfigSchema.Event.Updated, {})

      expect((yield* Fiber.join(received)).valueOrUndefined?.type).toBe("config.updated")
    }),
  )

+  it.live("exposes all public events through a wildcard plugin subscription", () =>
+    Effect.gen(function* () {
+      const plugins = yield* Plugin.Service
+      const bus = yield* Bus.Service
+      const host = yield* PluginHost.make(plugins)
+      const received = yield* host.event
+        .subscribe()
+        .pipe(Stream.take(2), Stream.runCollect, Effect.forkScoped({ startImmediately: true }))
+      yield* Effect.sleep("10 millis")
+
+      yield* bus.publish(Plugin.Event.Updated, {})
+      yield* bus.publish(ConfigSchema.Event.Updated, {})
+
+      expect(Array.from(yield* Fiber.join(received), (event) => event.type)).toEqual([
+        "plugin.updated",
+        "config.updated",
+      ])
+    }),
+  )
+
+  it.effect("rejects unknown runtime plugin event types", () =>
+    Effect.gen(function* () {
+      const plugins = yield* Plugin.Service
+      const host = yield* PluginHost.make(plugins)
+      const subscribe = host.event.subscribe as unknown as (type: string) => Stream.Stream<never, Error>
+
+      const failure = yield* subscribe("unknown.event").pipe(Stream.runDrain, Effect.flip)
+
+      expect(failure.message).toBe("Unknown plugin event type: unknown.event")
+    }),
+  )
+
  it.effect("replaces plugins by ID and version", () =>
    Effect.gen(function* () {
      const plugins = yield* Plugin.Service
@@ -1,6 +1,6 @@
 import { describe, expect } from "bun:test"
 import { Message, SystemPart } from "@opencode-ai/ai"
-import { DateTime, Effect, Schema } from "effect"
+import { DateTime, Effect, Schema, Stream } from "effect"
 import { Agent } from "@opencode-ai/core/agent"
 import { Catalog } from "@opencode-ai/core/catalog"
 import { Model } from "@opencode-ai/core/model"
@@ -18,6 +18,8 @@ import { Provider } from "@opencode-ai/core/provider"
 import { Project } from "@opencode-ai/core/project"
 import { AbsolutePath } from "@opencode-ai/core/schema"
 import { define } from "@opencode-ai/plugin/promise/plugin"
+import { Plugin as EffectPlugin } from "@opencode-ai/plugin/effect"
+import type { PluginEventType } from "@opencode-ai/plugin/effect/event"
 import { Money } from "@opencode-ai/schema/money"
 import type { SessionHooks } from "@opencode-ai/plugin/effect/session"
 import { testEffect } from "../lib/effect"
@@ -27,6 +29,28 @@ import { host as testHost } from "./host"
 const it = testEffect(PluginTestLayer)

 describe("fromPromise", () => {
+  it.effect("forwards a selected event type", () =>
+    Effect.gen(function* () {
+      let selected: string | undefined
+      const subscribe: EffectPlugin.Context["event"]["subscribe"] = (type?: PluginEventType) => {
+        selected = type
+        return Stream.empty
+      }
+      const host = testHost({ event: { subscribe } })
+
+      yield* PluginPromise.fromPromise(
+        define({
+          id: "promise-event-subscribe",
+          setup: (ctx) => {
+            ctx.event.subscribe("config.updated")
+          },
+        }),
+      ).effect(host)
+
+      expect(selected).toBe("config.updated")
+    }),
+  )
+
  it.effect("adapts session creation through the protocol schema", () =>
    Effect.gen(function* () {
      let seen: unknown
@@ -679,18 +679,13 @@ describe("Session.create", () => {
        const created = yield* session.create({
          location: Location.Ref.make({ directory: AbsolutePath.make(directory) }),
        })
-        yield* session.environment({ sessionID: created.id, variables: { OPENCODE_SESSION_ENV_TEST: "attached" } })

-        const command =
-          process.platform === "win32"
-            ? "[Console]::Out.Write($env:OPENCODE_SESSION_ENV_TEST)"
-            : 'printf %s "$OPENCODE_SESSION_ENV_TEST"'
-        yield* session.shell({ sessionID: created.id, command })
+        yield* session.shell({ sessionID: created.id, command: "echo hello" })

        const messages = yield* session.messages({ sessionID: created.id, order: "asc" })
        const shell = messages.find((message): message is SessionMessage.Shell => message.type === "shell")
-        expect(shell).toMatchObject({ type: "shell", command, status: "exited", exit: 0 })
-        expect(shell?.output?.output).toContain("attached")
+        expect(shell).toMatchObject({ type: "shell", command: "echo hello", status: "exited", exit: 0 })
+        expect(shell?.output?.output).toContain("hello")
        expect(shell?.output?.truncated).toBe(false)
        expect(shell?.time.completed).toBeDefined()
      }),
@@ -1,30 +0,0 @@
-import { describe, expect } from "bun:test"
-import { Effect } from "effect"
-import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
-import { Session } from "@opencode-ai/core/session"
-import { SessionEnvironment } from "@opencode-ai/core/session/environment"
-import { testEffect } from "./lib/effect"
-
-const it = testEffect(AppNodeBuilder.build(SessionEnvironment.node))
-
-describe("SessionEnvironment", () => {
-  it.effect("stores replacement snapshots by session", () =>
-    Effect.gen(function* () {
-      const environments = yield* SessionEnvironment.Service
-      const first = Session.ID.make("ses_environment_first")
-      const second = Session.ID.make("ses_environment_second")
-
-      yield* environments.set(first, { TOOLCHAIN: "first", PATH: "/first/bin" })
-      yield* environments.set(second, { TOOLCHAIN: "second" })
-      yield* environments.set(first, { TOOLCHAIN: "updated" })
-
-      expect(yield* environments.get(first)).toEqual({ TOOLCHAIN: "updated" })
-      expect(yield* environments.get(second)).toEqual({ TOOLCHAIN: "second" })
-
-      yield* environments.clear(first)
-
-      expect(yield* environments.get(first)).toBeUndefined()
-      expect(yield* environments.get(second)).toEqual({ TOOLCHAIN: "second" })
-    }),
-  )
-})
@@ -12,7 +12,6 @@ import { SessionExecution } from "@opencode-ai/core/session/execution"
 import { SessionModelTransport } from "@opencode-ai/core/session/model-transport"
 import { SessionProjector } from "@opencode-ai/core/session/projector"
 import { SessionStore } from "@opencode-ai/core/session/store"
-import { SessionEnvironment } from "@opencode-ai/core/session/environment"
 import { LocationServiceMap } from "@opencode-ai/core/location-services"
 import { testEffect } from "./lib/effect"
 import { globalProjectLayer } from "./lib/project"
@@ -33,7 +32,6 @@ const it = testEffect(
      Bus.node,
      SessionProjector.node,
      SessionStore.node,
-      SessionEnvironment.node,
      Session.node,
      LocationServiceMap.node,
    ]),
@@ -52,8 +50,6 @@ describe("Session.remove", () => {
      const session = yield* Session.Service
      const parent = yield* session.create({ location })
      const child = yield* session.create({ parentID: parent.id })
-      yield* session.environment({ sessionID: parent.id, variables: { SESSION_ENV: "parent" } })
-      yield* session.environment({ sessionID: child.id, variables: { SESSION_ENV: "child" } })
      yield* (yield* LocationServiceMap.Service).contextEffect(location)
      closed.length = 0

@@ -61,9 +57,6 @@ describe("Session.remove", () => {

      expect((yield* session.list()).data).toEqual([])
      expect(closed).toEqual([parent.id, child.id])
-      const environments = yield* SessionEnvironment.Service
-      expect(yield* environments.get(parent.id)).toBeUndefined()
-      expect(yield* environments.get(child.id)).toBeUndefined()
      expect(yield* Effect.result(session.get(parent.id))).toMatchObject({ _tag: "Failure" })
      expect(yield* Effect.result(session.get(child.id))).toMatchObject({ _tag: "Failure" })
    }),
@@ -217,13 +217,16 @@ it.effect("batches text deltas and flushes pending text before the terminal even
      { discard: true },
    )

-    expect(published.filter((event) => event.type === "session.text.delta")).toHaveLength(0)
+    expect(published.filter((event) => event.type === "session.text.delta").map((event) => event.data)).toMatchObject([
+      { delta: "one" },
+    ])
    yield* TestClock.adjust("99 millis")
-    expect(published.filter((event) => event.type === "session.text.delta")).toHaveLength(0)
+    expect(published.filter((event) => event.type === "session.text.delta")).toHaveLength(1)
    yield* TestClock.adjust("1 millis")
    yield* publisher.publish(LLMEvent.textDelta({ id: "text", text: " four" }))
    expect(published.filter((event) => event.type === "session.text.delta").map((event) => event.data)).toMatchObject([
-      { delta: "one two three four" },
+      { delta: "one" },
+      { delta: " two three four" },
    ])

    yield* publisher.publish(LLMEvent.textDelta({ id: "text", text: " five" }))
@@ -250,7 +253,7 @@ it.effect("batches reasoning deltas and flushes pending reasoning before the ter

    expect(
      published.filter((event) => event.type === "session.reasoning.delta").map((event) => event.data),
-    ).toMatchObject([{ delta: "one two three" }])
+    ).toMatchObject([{ delta: "one" }, { delta: " two three" }])
    expect(published.slice(-2).map((event) => event.type)).toEqual([
      "session.reasoning.delta",
      "session.reasoning.ended.1",
@@ -767,7 +767,7 @@ const verifyEphemeralDeltas = (kind: FragmentKind) =>
    yield* admit(session, prompt)
    const bus = yield* Bus.Service
    const live = fixture.delta
-      ? yield* bus.subscribe(fixture.delta).pipe(Stream.take(1), Stream.runCollect, Effect.forkScoped)
+      ? yield* bus.subscribe(fixture.delta).pipe(Stream.take(2), Stream.runCollect, Effect.forkScoped)
      : undefined
    yield* Effect.yieldNow
    yield* TestLLM.push(fixture.completeEvents)
@@ -785,7 +785,7 @@ const verifyEphemeralDeltas = (kind: FragmentKind) =>
      : []
    if (live) {
      const streamed = Array.from(yield* Fiber.join(live))
-      expect(streamed).toHaveLength(1)
+      expect(streamed).toHaveLength(2)
      expect(
        streamed
          .map((event) => {
@@ -260,36 +260,6 @@ describe("ShellTool", () => {
    { timeout: 15_000 },
  )

-  productionIt.live(
-    "uses the session environment instead of the server environment",
-    () =>
-      Effect.acquireUseRelease(
-        Effect.promise(() => tmpdir()),
-        (tmp) => {
-          reset()
-          return withSession(tmp.path, (registry) =>
-            Effect.gen(function* () {
-              const sessions = yield* Session.Service
-              yield* sessions.environment({
-                sessionID,
-                variables: { OPENCODE_SESSION_ENV_TEST: "from-session" },
-              })
-              const command = isWindows
-                ? "[Console]::Out.Write($env:OPENCODE_SESSION_ENV_TEST)"
-                : 'printf %s "$OPENCODE_SESSION_ENV_TEST"'
-
-              const settled = yield* executeTool(registry, call({ command }))
-
-              expect(settled.status).toBe("completed")
-              expect(settled.content?.[0]).toEqual({ type: "text", text: "from-session" })
-            }),
-          )
-        },
-        (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]().then(() => undefined)),
-      ),
-    { timeout: 15_000 },
-  )
-
  it.live("resolves a relative workdir from the active Location", () =>
    Effect.acquireUseRelease(
      Effect.promise(() => tmpdir()),
@@ -1,3 +1,15 @@
 import type { EventApi } from "@opencode-ai/client/effect/api"
+import type { OpenCodeEvent } from "@opencode-ai/client/effect"
+import type { Stream } from "effect"

-export interface EventDomain extends Pick<EventApi<unknown>, "subscribe"> {}
+export type PluginEvent = Exclude<OpenCodeEvent, { readonly type: "server.connected" }>
+export type PluginEventType = PluginEvent["type"]
+
+export interface EventSubscribe {
+  (): Stream.Stream<PluginEvent, unknown>
+  (type: PluginEventType): Stream.Stream<PluginEvent, unknown>
+}
+
+export interface EventDomain extends Omit<EventApi<unknown>, "subscribe"> {
+  readonly subscribe: EventSubscribe
+}
@@ -2,6 +2,7 @@ import { Tool } from "@opencode-ai/schema/tool"
 import { Effect, Schema, SchemaAST, Scope, Stream } from "effect"
 import { HttpApiEndpoint, HttpApiSchema } from "effect/unstable/httpapi"
 import { define } from "../effect/plugin.js"
+import type { PluginEventType } from "./event.js"
 import type { Context, Plugin } from "./plugin.js"
 import type { Info } from "./tool.js"

@@ -149,13 +150,15 @@ export function fromPromise(plugin: Plugin) {
            reload: () => run(host.command.reload()),
          },
          event: {
-            subscribe: () =>
-              Stream.toAsyncIterable(
-                host.event.subscribe().pipe(
+            subscribe: (type?: PluginEventType) => {
+              const events = type === undefined ? host.event.subscribe() : host.event.subscribe(type)
+              return Stream.toAsyncIterable(
+                events.pipe(
                  Stream.mapEffect((event) => Schema.encodeUnknownEffect(OpenCodeEvent)(event)),
                  Stream.map((event) => event as unknown as PromiseEvent),
                ),
-              ),
+              )
+            },
          },
          integration: {
            list: adaptApiMethod(IntegrationEndpoints["integration.list"], host.integration.list),
@@ -1,3 +1,14 @@
+import type { OpenCodeEvent } from "@opencode-ai/client"
 import type { EventApi } from "@opencode-ai/client/promise/api"

-export interface EventDomain extends Pick<EventApi, "subscribe"> {}
+export type PluginEvent = Exclude<OpenCodeEvent, { readonly type: "server.connected" }>
+export type PluginEventType = PluginEvent["type"]
+
+export interface EventSubscribe {
+  (): AsyncIterable<PluginEvent>
+  (type: PluginEventType): AsyncIterable<PluginEvent>
+}
+
+export interface EventDomain extends Omit<EventApi, "subscribe"> {
+  readonly subscribe: EventSubscribe
+}
@@ -0,0 +1,26 @@
+import { expect, test } from "bun:test"
+import type { Context as EffectContext } from "../src/effect/plugin.js"
+import type { Context as PromiseContext } from "../src/promise/plugin.js"
+
+function effectSubscriptions(ctx: EffectContext) {
+  ctx.event.subscribe()
+  ctx.event.subscribe("config.updated")
+  // @ts-expect-error server.connected is a network-only marker
+  ctx.event.subscribe("server.connected")
+  // @ts-expect-error plugin subscriptions select at most one event type
+  ctx.event.subscribe(["config.updated"])
+}
+
+function promiseSubscriptions(ctx: PromiseContext) {
+  ctx.event.subscribe()
+  ctx.event.subscribe("config.updated")
+  // @ts-expect-error server.connected is a network-only marker
+  ctx.event.subscribe("server.connected")
+  // @ts-expect-error plugin subscriptions select at most one event type
+  ctx.event.subscribe(["config.updated"])
+}
+
+test("event subscription types support wildcard and one public event", () => {
+  expect(effectSubscriptions).toBeFunction()
+  expect(promiseSubscriptions).toBeFunction()
+})
@@ -693,20 +693,6 @@ export const makeSessionGroup = <I extends HttpApiMiddleware.AnyId, S>(sessionLo
        }),
      ),
    )
-    .add(
-      HttpApiEndpoint.put("session.environment", "/api/session/:sessionID/environment", {
-        params: { sessionID: Session.ID },
-        payload: Schema.Struct({ variables: Schema.Record(Schema.String, Schema.String) }),
-        success: HttpApiSchema.NoContent,
-        error: SessionNotFoundError,
-      }).annotateMerge(
-        OpenApi.annotations({
-          identifier: "v2.session.environment",
-          summary: "Set session environment",
-          description: "Replace the process environment used by local shell commands for this session.",
-        }),
-      ),
-    )
    .annotateMerge(
      OpenApi.annotations({
        title: "session",
@@ -196,22 +196,6 @@ export const SessionHandler = HttpApiBuilder.group(Api, "server.session", (handl
          return HttpApiSchema.NoContent.make()
        }),
      )
-      .handle(
-        "session.environment",
-        Effect.fn(function* (ctx) {
-          yield* session.environment({ sessionID: ctx.params.sessionID, variables: ctx.payload.variables }).pipe(
-            Effect.catchTag(
-              "Session.NotFoundError",
-              (error) =>
-                new SessionNotFoundError({
-                  sessionID: error.sessionID,
-                  message: `Session not found: ${error.sessionID}`,
-                }),
-            ),
-          )
-          return HttpApiSchema.NoContent.make()
-        }),
-      )
      .handle(
        "session.fork",
        Effect.fn(function* (ctx) {
@@ -41,7 +41,6 @@ import {
  useTuiApp,
  useTuiPaths,
  useTuiStartup,
-  useTuiTerminalEnvironment,
  type TuiApp,
 } from "./context/runtime"
 import { DialogProvider, useDialog } from "./ui/dialog"
@@ -186,7 +185,6 @@ export type TuiInput = {
  args: Args
  config: Config.Interface
  packages: PackageResolver
-  environment?: Readonly<Record<string, string>>
  terminalHandoff?: () => Promise<
    | {
        readonly renderer: CliRenderer
@@ -334,7 +332,6 @@ export const run = Effect.fn("Tui.run")(function* (input: TuiInput) {
                                  : process.env.DISPLAY
                                    ? "x11"
                                    : undefined,
-                                variables: input.environment,
                              }}
                            >
                              <TuiStartupProvider
@@ -483,17 +480,6 @@ function App(props: { pair?: DialogPairCredentials }) {
  const promptRef = usePromptRef()
  const plugins = usePlugin()
  const clipboard = useClipboard()
-  const terminalEnvironment = useTuiTerminalEnvironment()
-  createEffect(() => {
-    if (client.connection.status() !== "connected") return
-    if (route.data.type !== "session") return
-    const session = data.session.get(route.data.sessionID)
-    if (!session) return
-    if (session.location.workspaceID !== undefined || terminalEnvironment.variables === undefined) return
-    void client.api.session
-      .environment({ sessionID: session.id, variables: terminalEnvironment.variables })
-      .catch(toast.error)
-  })
  const [layout, updateLayout] = useStorage().store<{ verticalTabsWidth?: number }>("layout", {
    initial: { verticalTabsWidth: SESSION_SIDEBAR_WIDTH },
  })
@@ -1206,19 +1206,6 @@ export function Prompt(props: PromptProps) {

      sessionID = created.id
      session = created
-      if (created.location.workspaceID === undefined && terminalEnvironment.variables !== undefined) {
-        const error = await client.api.session
-          .environment({ sessionID, variables: terminalEnvironment.variables })
-          .then(
-            () => undefined,
-            (error) => error,
-          )
-        if (error) {
-          if (finishMoveProgress) move.finishSubmit()
-          toast.show({ title: "Failed to set session environment", message: errorMessage(error), variant: "error" })
-          return true
-        }
-      }
    }

    // Capture mode before it gets reset
@@ -17,7 +17,6 @@ export type TuiTerminalEnvironment = Readonly<{
  platform: string
  multiplexer?: "tmux" | "screen"
  displayServer?: "wayland" | "x11"
-  variables?: Readonly<Record<string, string>>
 }>

 export type TuiStartup = Readonly<{
@@ -184,6 +184,14 @@ and plugin options.
 | `ctx.event`            | `subscribe` to the current public server event stream                                        |
 | `ctx.options`          | Readonly options from the matching config object                                             |

+Event subscriptions can receive every plugin-visible public event, or select
+one event type:
+
+```ts
+ctx.event.subscribe()
+ctx.event.subscribe("config.updated")
+```
+
 ### Transform hooks

 Transform hooks let a plugin modify how OpenCode is configured. Use them to add
@@ -68,6 +68,22 @@ await $`bun ./packages/core/script/publish.ts`
 console.log("\n=== ui ===\n")
 await $`bun ./packages/ui/script/publish.ts`

+if (Script.channel === "beta") {
+  const packages = [
+    "@opencode-ai/schema",
+    "@opencode-ai/codemode",
+    "@opencode-ai/theme",
+    "@opencode-ai/ai",
+    "@opencode-ai/util",
+    "@opencode-ai/protocol",
+    "@opencode-ai/client",
+    "@opencode-ai/plugin",
+    "@opencode-ai/core",
+    "@opencode-ai/ui",
+  ]
+  await Promise.all(packages.map((name) => $`npm dist-tag add ${`${name}@${Script.version}`} next`))
+}
+
 if (Script.release) {
  await $`bun ./packages/desktop/scripts/finalize-latest-json.ts`
  await $`bun ./packages/desktop/scripts/finalize-latest-yml.ts`
Author	SHA1	Message	Date
Dax Raad	5b9892f0f7	test(plugin): type selected event callback	2026-08-15 18:59:17 -04:00
Dax Raad	58deb52dcd	feat(plugin): select event subscriptions	2026-08-15 18:55:44 -04:00