refactor(core): name shell records as commands

packages/core/src/instance.ts

@@ -1,145 +0,0 @@
-import { Effect, Layer } from "effect"
-import { Agent } from "./agent.js"
-import { AISDK } from "./aisdk.js"
-import { Catalog } from "./catalog.js"
-import { Command } from "./command.js"
-import { Config } from "./config.js"
-import { LayerNode } from "@opencode-ai/util/effect/layer-node"
-import { Node } from "@opencode-ai/util/effect/app-node"
-import { FileMutation } from "./file-mutation.js"
-import { Environment } from "./environment/index.js"
-import { Formatter } from "./formatter.js"
-import { FileSystem } from "./filesystem.js"
-import { FileSystemSearch } from "./filesystem/search.js"
-import { Generate } from "./generate.js"
-import { Form } from "./form.js"
-import { Image } from "./image.js"
-import { LocationWatcher } from "./filesystem/location-watcher.js"
-import { Integration } from "./integration.js"
-import { Location } from "./location.js"
-import { LocationMutation } from "./location-mutation.js"
-import { ModelResolver } from "./model-resolver.js"
-import { MCP } from "./mcp/index.js"
-import { Permission } from "./permission.js"
-import { Plugin } from "./plugin.js"
-import { PluginHooks } from "./plugin/hooks.js"
-import { InstancePlugins } from "./plugin/instance.js"
-import { PluginSupervisor } from "./plugin/supervisor.js"
-import { Worktree } from "./worktree.js"
-import { Pty } from "./pty.js"
-import { Shell } from "./shell.js"
-import { ShellSelect } from "./shell/select.js"
-import { Reference } from "./reference.js"
-import { WebSearch } from "./websearch.js"
-import { ReferenceInstructions } from "./reference/instructions.js"
-import { SessionRunnerLLM } from "./session/runner/llm.js"
-import { SessionRunnerModel } from "./session/runner/model.js"
-import { SessionModelTransport } from "./session/model-transport.js"
-import { SessionCompaction } from "./session/compaction.js"
-import { SessionTitle } from "./session/title.js"
-import { Skill } from "./skill.js"
-import { SkillInstructions } from "./skill/instructions.js"
-import { Snapshot } from "./snapshot.js"
-import { InstructionDiscovery } from "./instruction-discovery.js"
-import { InstructionBuiltIns } from "./instructions/builtins.js"
-import { InstructionEntry } from "./session/instruction-entry.js"
-import { SessionInstructions } from "./session/instructions.js"
-import { SessionGenerateNode } from "./session/generate-node.js"
-import { McpTool } from "./tool/mcp.js"
-import { ReadToolFileSystem } from "./tool/read-filesystem.js"
-import { Tool } from "./tool.js"
-import { ToolOutput } from "./tool-output.js"
-import { Vcs } from "./vcs.js"
-
-export * as Instance from "./instance.js"
-
-const nodes = [
-  Location.node,
-  Environment.node,
-  Config.node,
-  Agent.node,
-  Command.node,
-  Reference.node,
-  WebSearch.node,
-  Integration.node,
-  Catalog.node,
-  ModelResolver.node,
-  AISDK.node,
-  Plugin.node,
-  PluginHooks.node,
-  InstancePlugins.node,
-  PluginSupervisor.node,
-  Worktree.refreshNode,
-  FileSystemSearch.node,
-  FileSystem.node,
-  ShellSelect.node,
-  Pty.node,
-  Shell.node,
-  Skill.node,
-  InstructionBuiltIns.node,
-  InstructionDiscovery.node,
-  LocationMutation.node,
-  FileMutation.node,
-  Formatter.node,
-  MCP.node,
-  Permission.node,
-  Tool.node,
-  ToolOutput.node,
-  Image.node,
-  SkillInstructions.node,
-  ReferenceInstructions.node,
-  InstructionEntry.node,
-  Form.node,
-  Generate.node,
-  SessionGenerateNode.node,
-  ReadToolFileSystem.node,
-  McpTool.node,
-  SessionInstructions.node,
-  SessionRunnerModel.node,
-  SessionModelTransport.node,
-  SessionCompaction.node,
-  SessionTitle.node,
-  Snapshot.node,
-  SessionRunnerLLM.node,
-  Vcs.node,
-  // Start repository watches only after boot-critical filesystem and Git work.
-  LocationWatcher.node,
-] as const satisfies readonly Node.LocationNode<unknown, unknown>[]
-
-export const graph = LayerNode.group<typeof nodes>(nodes)
-
-export type Services = LayerNode.Output<typeof graph>
-export type Error = LayerNode.Error<typeof graph>
-
-export interface Options {
-  // Plugins this instance is born with; empty and absent are equivalent.
-  readonly plugins?: InstancePlugins.List
-  readonly replacements?: LayerNode.Replacements
-}
-
-// One instance is one compiled, fresh copy of the graph standing on a directory.
-export function layer(ref: Location.Ref, options: Options = {}) {
-  const startedAt = performance.now()
-  // Bound pairs come last, so they win over caller replacements of the same nodes.
-  const allReplacements = (options.replacements ?? []).concat([
-    [Location.node, Location.boundNode(ref)],
-    [InstancePlugins.node, InstancePlugins.bound(options.plugins ?? [])],
-  ])
-  // Apply replacements during hoist, not afterward: replacements can
-  // introduce new tagged dependencies (Location.boundNode depends on
-  // Project), and the hoist walk is the only pass that can still slice
-  // those back out.
-  const location = LayerNode.hoist(graph, Node.tags.values.global, allReplacements)
-
-  return LayerNode.compile(location.node).pipe(
-    Layer.fresh,
-    Layer.tap(() =>
-      Effect.logInfo("location services booted", {
-        directory: ref.directory,
-        workspaceID: ref.workspaceID,
-        durationMs: Math.round(performance.now() - startedAt),
-      }),
-    ),
-    Layer.provide(LayerNode.compile(location.hoisted)),
-  )
-}

packages/core/src/location-service-map.ts

@@ -2,11 +2,11 @@ import { Context, Effect, Layer, LayerMap } from "effect"
 import { LayerNode } from "@opencode-ai/util/effect/layer-node"
 import { Node } from "@opencode-ai/util/effect/app-node"
 import { Location } from "./location.js"
-import type { Instance } from "./instance.js"
+import type { LocationError, LocationServices } from "./location-services.js"
 
 export class Service extends Context.Service<
   Service,
-  LayerMap.LayerMap<Location.Ref, Instance.Services, Instance.Error>
+  LayerMap.LayerMap<Location.Ref, LocationServices, LocationError>
 >()("@opencode/example/LocationServiceMap") {
   static get(ref: Location.Ref) {
     return Layer.unwrap(Effect.map(Service, (locations) => locations.get(ref)))

packages/core/src/location-services.ts

@@ -1,16 +1,118 @@
 import { Duration, Effect, Layer, LayerMap } from "effect"
 import { existsSync } from "fs"
 import path from "path"
+import { Agent } from "./agent.js"
+import { AISDK } from "./aisdk.js"
+import { Catalog } from "./catalog.js"
+import { Command } from "./command.js"
+import { Config } from "./config.js"
 import { LayerNode } from "@opencode-ai/util/effect/layer-node"
-import { Instance } from "./instance.js"
+import { Node } from "@opencode-ai/util/effect/app-node"
+import { Bus } from "./bus.js"
+import { FileMutation } from "./file-mutation.js"
+import { Environment } from "./environment/index.js"
+import { Formatter } from "./formatter.js"
+import { FileSystem } from "./filesystem.js"
+import { FileSystemSearch } from "./filesystem/search.js"
+import { Generate } from "./generate.js"
+import { Form } from "./form.js"
+import { Image } from "./image.js"
+import { LocationWatcher } from "./filesystem/location-watcher.js"
+import { Integration } from "./integration.js"
 import { Location } from "./location.js"
+import { LocationMutation } from "./location-mutation.js"
 import { LocationServiceMap } from "./location-service-map.js"
+import { ModelResolver } from "./model-resolver.js"
+import { MCP } from "./mcp/index.js"
+import { Permission } from "./permission.js"
+import { Plugin } from "./plugin.js"
+import { PluginHooks } from "./plugin/hooks.js"
+import { PluginSupervisor } from "./plugin/supervisor.js"
+import { Worktree } from "./worktree.js"
+import { Pty } from "./pty.js"
+import { Shell } from "./shell.js"
+import { ShellSelect } from "./shell/select.js"
+import { Reference } from "./reference.js"
+import { WebSearch } from "./websearch.js"
+import { ReferenceInstructions } from "./reference/instructions.js"
+import { SessionRunnerLLM } from "./session/runner/llm.js"
+import { SessionRunnerModel } from "./session/runner/model.js"
+import { SessionModelTransport } from "./session/model-transport.js"
+import { SessionCompaction } from "./session/compaction.js"
+import { SessionTitle } from "./session/title.js"
+import { Skill } from "./skill.js"
+import { SkillInstructions } from "./skill/instructions.js"
+import { Snapshot } from "./snapshot.js"
+import { InstructionDiscovery } from "./instruction-discovery.js"
+import { InstructionBuiltIns } from "./instructions/builtins.js"
+import { InstructionEntry } from "./session/instruction-entry.js"
+import { SessionInstructions } from "./session/instructions.js"
+import { SessionGenerateNode } from "./session/generate-node.js"
+import { McpTool } from "./tool/mcp.js"
+import { ReadToolFileSystem } from "./tool/read-filesystem.js"
+import { Tool } from "./tool.js"
+import { ToolOutput } from "./tool-output.js"
+import { Vcs } from "./vcs.js"
 import { AbsolutePath } from "./schema.js"
 
 export { LocationServiceMap } from "./location-service-map.js"
 
-export type LocationServices = Instance.Services
-export type LocationError = Instance.Error
+const locationServiceNodes = [
+  Location.node,
+  Environment.node,
+  Config.node,
+  Agent.node,
+  Command.node,
+  Reference.node,
+  WebSearch.node,
+  Integration.node,
+  Catalog.node,
+  ModelResolver.node,
+  AISDK.node,
+  Plugin.node,
+  PluginHooks.node,
+  PluginSupervisor.node,
+  Worktree.refreshNode,
+  FileSystemSearch.node,
+  FileSystem.node,
+  ShellSelect.node,
+  Pty.node,
+  Shell.node,
+  Skill.node,
+  InstructionBuiltIns.node,
+  InstructionDiscovery.node,
+  LocationMutation.node,
+  FileMutation.node,
+  Formatter.node,
+  MCP.node,
+  Permission.node,
+  Tool.node,
+  ToolOutput.node,
+  Image.node,
+  SkillInstructions.node,
+  ReferenceInstructions.node,
+  InstructionEntry.node,
+  Form.node,
+  Generate.node,
+  SessionGenerateNode.node,
+  ReadToolFileSystem.node,
+  McpTool.node,
+  SessionInstructions.node,
+  SessionRunnerModel.node,
+  SessionModelTransport.node,
+  SessionCompaction.node,
+  SessionTitle.node,
+  Snapshot.node,
+  SessionRunnerLLM.node,
+  Vcs.node,
+  // Start repository watches only after boot-critical filesystem and Git work.
+  LocationWatcher.node,
+] as const satisfies readonly Node.LocationNode<unknown, unknown>[]
+
+export const locationServices = LayerNode.group<typeof locationServiceNodes>(locationServiceNodes)
+
+export type LocationServices = LayerNode.Output<typeof locationServices>
+export type LocationError = LayerNode.Error<typeof locationServices>
 
 export function buildLocationServiceMap(
   replacements: LayerNode.Replacements = [],
@@ -25,14 +127,37 @@ export function buildLocationServiceMap(
   return Layer.effect(
     LocationServiceMap.Service,
     Effect.map(
-      LayerMap.make((ref: Location.Ref) => Instance.layer(ref, { replacements }), {
-        // Workspace-placed directories exist only inside the workspace, so a
-        // local stat consults the wrong filesystem. Workspace liveness is
-        // owned by placement; do not probe the sandbox here, which would
-        // provision lazily-idle workspaces.
-        idleTimeToLive: (ref) =>
-          ref.workspaceID !== undefined || existsSync(ref.directory) ? Duration.infinity : Duration.zero,
-      }),
+      LayerMap.make(
+        (ref: Location.Ref) => {
+          const startedAt = performance.now()
+          const allReplacements = replacements.concat([[Location.node, Location.boundNode(ref)]])
+          // Apply replacements during hoist, not afterward: replacements can
+          // introduce new tagged dependencies (Location.boundNode depends on
+          // Project), and the hoist walk is the only pass that can still slice
+          // those back out.
+          const location = LayerNode.hoist(locationServices, Node.tags.values.global, allReplacements)
+
+          return LayerNode.compile(location.node).pipe(
+            Layer.fresh,
+            Layer.tap(() =>
+              Effect.logInfo("location services booted", {
+                directory: ref.directory,
+                workspaceID: ref.workspaceID,
+                durationMs: Math.round(performance.now() - startedAt),
+              }),
+            ),
+            Layer.provide(LayerNode.compile(location.hoisted)),
+          )
+        },
+        {
+          // Workspace-placed directories exist only inside the workspace, so a
+          // local stat consults the wrong filesystem. Workspace liveness is
+          // owned by placement; do not probe the sandbox here, which would
+          // provision lazily-idle workspaces.
+          idleTimeToLive: (ref) =>
+            ref.workspaceID !== undefined || existsSync(ref.directory) ? Duration.infinity : Duration.zero,
+        },
+      ),
       (inner) => ({
         ...inner,
         get: (ref: Location.Ref) => inner.get(canonical(ref)),

packages/core/src/plugin/instance.ts

@@ -1,49 +0,0 @@
-export * as InstancePlugins from "./instance.js"
-
-import type { Plugin } from "@opencode-ai/plugin/effect/plugin"
-import { Context, Layer } from "effect"
-import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
-import type { Versioned } from "../plugin.js"
-
-/**
- * Holds the plugins one instance is born with. Unlike the host-global
- * `SdkPlugins` store, this list is a birth argument of a single instance:
- * `Instance.layer` binds it through the replacement mechanism, so two
- * instances in one process can carry different plugins. The list is immutable
- * for the instance's lifetime; runtime dynamism lives inside plugins through
- * the container transform/reload APIs.
- *
- * Limitations, both shared with `SdkPlugins`: `vcs` marker declarations are
- * not seen by `ProjectMarkers` (it is global and runs during project
- * resolution, before the instance exists), and config plugin operations may
- * disable instance plugins by id.
- */
-export type List = readonly Plugin[]
-
-export interface Interface {
-  readonly all: () => readonly Versioned[]
-}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/InstancePlugins") {}
-
-export const node = makeLocationNode({
-  service: Service,
-  layer: Layer.succeed(Service, Service.of({ all: () => [] })),
-  deps: [],
-})
-
-// The constant version is load-bearing: the plugin registry treats an
-// unchanged (id, version) pair as the same plugin across activations, which
-// is only correct because a bound list never changes after creation.
-// `source: "sdk"` means host-contributed; an instance list is the
-// per-instance form of the same channel.
-export function bound(plugins: List) {
-  const duplicates = plugins.filter((plugin, index) => plugins.findIndex((other) => other.id === plugin.id) !== index)
-  if (duplicates.length > 0) {
-    throw new Error(`duplicate instance plugin ids: ${duplicates.map((plugin) => plugin.id).join(", ")}`)
-  }
-  const stamped = plugins.map(
-    (plugin): Versioned => ({ ...plugin, version: "instance", source: { type: "sdk" } }),
-  )
-  return Layer.succeed(Service, Service.of({ all: () => stamped }))
-}

packages/core/src/plugin/supervisor.ts

@@ -9,7 +9,6 @@ import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
 import { Bus } from "../bus.js"
 import { Npm } from "@opencode-ai/util/npm"
 import { Plugin } from "../plugin.js"
-import { InstancePlugins } from "./instance.js"
 import { PluginInternal } from "./internal.js"
 import { PluginModule } from "./module.js"
 import { SdkPlugins } from "./sdk.js"
@@ -86,7 +85,6 @@ export const layer = Layer.effect(
   Effect.gen(function* () {
     const registry = yield* Plugin.Service
     const sdk = yield* SdkPlugins.Service
-    const instance = yield* InstancePlugins.Service
     const sources = yield* ConfigPluginSource.Service
     const bus = yield* Bus.Service
     const ready = yield* Latch.make()
@@ -95,13 +93,10 @@ export const layer = Layer.effect(
     const activate = Effect.fn("PluginSupervisor.activate")(function* () {
       // Resolve OpenCode's internal plugins with their privileged Location services.
       const internal = yield* PluginInternal.list()
-      // Combine internal plugins with host-contributed plugins in boot order.
-      // Instance-bound plugins come last: later activation can override earlier
-      // container writes, so the instance's explicit choices win over globals.
+      // Combine internal plugins with host-contributed SDK plugins in boot order.
       const pre = [
         ...internal.pre.map((plugin) => ({ ...plugin, version: "internal", source: { type: "builtin" as const } })),
         ...sdk.all(),
-        ...instance.all(),
       ]
       const post = internal.post.map((plugin) => ({
         ...plugin,
@@ -143,7 +138,6 @@ export const layer = Layer.effect(
 const nodeDeps = [
   Plugin.node,
   SdkPlugins.node,
-  InstancePlugins.node,
   ConfigPluginSource.node,
   Bus.node,
   Npm.node,

packages/core/src/shell.ts

@@ -122,8 +122,8 @@ const layer = () =>
       const environments = yield* SessionEnvironment.Service
       const context = yield* Effect.context()
       const runFork = Effect.runForkWith(context)
-      const sessions = new Map<string, Active>()
-      const exitOrder: string[] = []
+      const commands = new Map<Shell.ID, Active>()
+      const exitOrder: Shell.ID[] = []
 
       const outputDir = path.join(global.data, DIRECTORY, location.project.id)
       const { mkdir, unlink } = yield* Effect.promise(() => import("fs/promises"))
@@ -132,44 +132,44 @@ const layer = () =>
 
       yield* Effect.addFinalizer(() =>
         Effect.gen(function* () {
-          for (const session of sessions.values()) {
-            if (session.timeoutFiber) yield* Fiber.interrupt(session.timeoutFiber)
+          for (const command of commands.values()) {
+            if (command.timeoutFiber) yield* Fiber.interrupt(command.timeoutFiber)
             // Teardown interrupts pending commands; it is not a terminal command failure.
-            yield* Deferred.interrupt(session.done)
+            yield* Deferred.interrupt(command.done)
           }
-          sessions.clear()
+          commands.clear()
           exitOrder.length = 0
         }),
       )
 
       const require = Effect.fnUntraced(function* (id: Shell.ID) {
-        const session = sessions.get(id)
-        if (!session) return yield* new NotFoundError({ id })
-        return session
+        const command = commands.get(id)
+        if (!command) return yield* new NotFoundError({ id })
+        return command
       })
 
-      const removeSession = Effect.fnUntraced(function* (id: Shell.ID) {
-        const session = sessions.get(id)
+      const removeCommand = Effect.fnUntraced(function* (id: Shell.ID) {
+        const command = commands.get(id)
         const index = exitOrder.indexOf(id)
         if (index !== -1) exitOrder.splice(index, 1)
-        if (!session) return
-        sessions.delete(id)
-        if (session.timeoutFiber) yield* Fiber.interrupt(session.timeoutFiber)
+        if (!command) return
+        commands.delete(id)
+        if (command.timeoutFiber) yield* Fiber.interrupt(command.timeoutFiber)
         // Unblock any wait still pending when the command is removed before it terminated.
-        yield* Deferred.fail(session.done, new NotFoundError({ id }))
-        yield* Effect.promise(() => unlink(session.file).catch(() => {}))
+        yield* Deferred.fail(command.done, new NotFoundError({ id }))
+        yield* Effect.promise(() => unlink(command.file).catch(() => {}))
         yield* bus.publish(Shell.Event.Deleted, { id })
       })
 
       const remove = Effect.fn("Shell.remove")(function* (id: Shell.ID) {
         yield* require(id)
-        yield* removeSession(id)
+        yield* removeCommand(id)
       })
 
       const list = Effect.fn("Shell.list")(function* () {
-        return Array.from(sessions.values())
-          .filter((session) => session.info.status === "running")
-          .map((session) => session.info)
+        return Array.from(commands.values())
+          .filter((command) => command.info.status === "running")
+          .map((command) => command.info)
       })
 
       const get = Effect.fn("Shell.get")(function* (id: Shell.ID) {
@@ -181,24 +181,24 @@ const layer = () =>
       })
 
       const timeout = Effect.fn("Shell.timeout")(function* (id: Shell.ID, duration: number) {
-        const session = yield* require(id)
-        if (session.info.status !== "running" || !session.timeout) return session.info
-        yield* session.timeout(duration)
-        return session.info
+        const command = yield* require(id)
+        if (command.info.status !== "running" || !command.timeout) return command.info
+        yield* command.timeout(duration)
+        return command.info
       })
 
       const output = Effect.fnUntraced(function* (id: Shell.ID, input?: Shell.OutputInput) {
-        const session = yield* require(id)
+        const command = yield* require(id)
         const cursor = input?.cursor ?? 0
         const limit = input?.limit ?? 65536
-        if (cursor >= session.size) return { output: "", cursor: session.size, size: session.size, truncated: false }
+        if (cursor >= command.size) return { output: "", cursor: command.size, size: command.size, truncated: false }
         const start = Math.max(0, cursor)
-        const length = Math.min(limit, session.size - start)
+        const length = Math.min(limit, command.size - start)
         const buffer = Buffer.alloc(length)
         const bytesRead = yield* Effect.promise(
           () =>
             new Promise<number>((resolve) => {
-              const stream = createReadStream(session.file, { start, end: start + length - 1 })
+              const stream = createReadStream(command.file, { start, end: start + length - 1 })
               let offset = 0
               stream.on("data", (chunk: string | Buffer) => {
                 const bytes = Buffer.from(chunk)
@@ -212,7 +212,7 @@ const layer = () =>
         return {
           output: buffer.subarray(0, bytesRead).toString("utf8"),
           cursor: start + bytesRead,
-          size: session.size,
+          size: command.size,
           truncated: false,
         }
       })
@@ -257,7 +257,7 @@ const layer = () =>
 
         // Spawn through the Environment and stream combined output to the file. The handle is scope-bound, so
         // the managing fiber keeps its scope open until the command terminates (it awaits `done` at the
-        // end). `create` returns once `ready` resolves with the registered session.
+        // end). `create` returns once `ready` resolves with the registered command.
         const ready = Deferred.makeUnsafe<Active, AppProcess.AppProcessError>()
         runFork(
           Effect.scoped(
@@ -275,7 +275,7 @@ const layer = () =>
                 .pipe(
                   Effect.mapError((cause) => new AppProcess.AppProcessError({ command: invocation.command, cause })),
                 )
-              const session: Active = {
+              const command: Active = {
                 info: produce(info, (draft) => {
                   draft.pid = handle.pid
                 }),
@@ -283,7 +283,7 @@ const layer = () =>
                 size: 0,
                 done: Deferred.makeUnsafe<Info, NotFoundError>(),
               }
-              sessions.set(id, session)
+              commands.set(id, command)
 
               const stream = createWriteStream(file)
               const outputDone = Latch.makeUnsafe()
@@ -291,7 +291,7 @@ const layer = () =>
                 Stream.runForEach((chunk: Uint8Array) =>
                   Effect.sync(() => {
                     stream.write(chunk)
-                    session.size += chunk.length
+                    command.size += chunk.length
                   }),
                 ),
               )
@@ -317,8 +317,8 @@ const layer = () =>
 
               const finish = (status: Info["status"], exit?: number, beforeWait = Effect.void) =>
                 Effect.gen(function* () {
-                  if (session.info.status !== "running") return
-                  session.info = produce(session.info, (draft) => {
+                  if (command.info.status !== "running") return
+                  command.info = produce(command.info, (draft) => {
                     draft.status = status
                     if (exit !== undefined) draft.exit = exit
                     draft.time.completed = Date.now()
@@ -326,10 +326,10 @@ const layer = () =>
                   yield* beforeWait
                   yield* outputDone.await
                   // Resolve waiters with the terminal Info before any retention eviction, so an evicted
-                  // session still reports success rather than the removal NotFoundError. This runs before
+                  // command still reports success rather than the removal NotFoundError. This runs before
                   // the timeout-fiber interrupt below, which on the timeout path would otherwise cancel
                   // this very fiber (finish is invoked by the timeout fiber) before waiters are resolved.
-                  yield* Deferred.succeed(session.done, session.info)
+                  yield* Deferred.succeed(command.done, command.info)
                   yield* bus.publish(Shell.Event.Exited, {
                     id,
                     ...(exit !== undefined ? { exit } : {}),
@@ -339,19 +339,19 @@ const layer = () =>
                   while (exitOrder.length > EXITED_LIMIT) {
                     const oldest = exitOrder[0]
                     if (!oldest) break
-                    yield* removeSession(Shell.ID.make(oldest))
+                    yield* removeCommand(oldest)
                   }
                   // Cancel a pending timeout once the command exits on its own. Interrupting last avoids
                   // aborting finish when finish itself runs on the timeout fiber.
-                  if (session.timeoutFiber) yield* Fiber.interrupt(session.timeoutFiber)
+                  if (command.timeoutFiber) yield* Fiber.interrupt(command.timeoutFiber)
                 })
 
-              session.timeout = (duration) =>
+              command.timeout = (duration) =>
                 Effect.gen(function* () {
-                  if (session.timeoutFiber) yield* Fiber.interrupt(session.timeoutFiber)
-                  session.timeoutFiber = undefined
-                  if (duration === 0 || session.info.status !== "running") return
-                  session.timeoutFiber = runFork(
+                  if (command.timeoutFiber) yield* Fiber.interrupt(command.timeoutFiber)
+                  command.timeoutFiber = undefined
+                  if (duration === 0 || command.info.status !== "running") return
+                  command.timeoutFiber = runFork(
                     Effect.sleep(Duration.millis(duration)).pipe(
                       Effect.flatMap(() =>
                         finish("timeout", undefined, handle.kill().pipe(Effect.catch(() => Effect.void))),
@@ -361,7 +361,7 @@ const layer = () =>
                   )
                 })
 
-              yield* session.timeout(invocation.timeout)
+              yield* command.timeout(invocation.timeout)
 
               runFork(
                 handle.exitCode.pipe(
@@ -371,16 +371,16 @@ const layer = () =>
               )
 
               yield* bus.publish(Shell.Event.Created, { info })
-              yield* Deferred.succeed(ready, session)
+              yield* Deferred.succeed(ready, command)
               // Hold the handle's scope open until the command terminates; closing it earlier would
               // release (kill) the process before its exit is observed.
-              yield* Deferred.await(session.done).pipe(Effect.catch(() => Effect.void))
+              yield* Deferred.await(command.done).pipe(Effect.catch(() => Effect.void))
             }),
           ).pipe(Effect.catchTag("AppProcessError", (error) => Deferred.fail(ready, error))),
         )
 
-        const session = yield* Deferred.await(ready)
-        return session.info
+        const command = yield* Deferred.await(ready)
+        return command.info
       })
 
       return Service.of({ create, list, get, wait, timeout, output, remove })

packages/core/test/instance-plugins.test.ts

@@ -1,104 +0,0 @@
-import fs from "fs/promises"
-import path from "path"
-import { describe, expect, test } from "bun:test"
-import { Duration, Effect, Layer, LayerMap } from "effect"
-import { Plugin } from "@opencode-ai/plugin/effect"
-import { Agent } from "@opencode-ai/core/agent"
-import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
-import { LayerNode } from "@opencode-ai/util/effect/layer-node"
-import { Global } from "@opencode-ai/util/global"
-import { Instance } from "@opencode-ai/core/instance"
-import { InstancePlugins } from "@opencode-ai/core/plugin/instance"
-import { LocationServiceMap } from "@opencode-ai/core/location-services"
-import { Location } from "@opencode-ai/core/location"
-import { PluginSupervisor } from "@opencode-ai/core/plugin/supervisor"
-import { SdkPlugins } from "@opencode-ai/core/plugin/sdk"
-import { AbsolutePath } from "@opencode-ai/core/schema"
-import { tmpdir } from "./fixture/tmpdir"
-import { tempGlobalLayer } from "./fixture/global"
-import { testEffect } from "./lib/effect"
-import { Database } from "../src/database/database"
-import { Bus } from "../src/bus"
-
-const agentPlugin = (pluginID: string, agentID: string) =>
-  Plugin.define({
-    id: pluginID,
-    effect: (ctx) => ctx.agent.transform((agents) => agents.update(Agent.ID.make(agentID), () => {})),
-  })
-
-// A host-owned assignment in miniature: the map decides per ref which plugins
-// an instance is born with, the way an embedder will per Slack thread.
-const instances = Layer.effect(
-  LocationServiceMap.Service,
-  LayerMap.make(
-    (ref: Location.Ref) =>
-      Instance.layer(ref, {
-        plugins: path.basename(ref.directory) === "thread-a" ? [agentPlugin("thread-a-plugin", "thread-a-agent")] : [],
-        replacements: [[Global.node, tempGlobalLayer]],
-      }),
-    { idleTimeToLive: Duration.infinity },
-  ),
-)
-
-const it = testEffect(
-  AppNodeBuilder.build(LayerNode.group([Database.node, Bus.node, SdkPlugins.node, LocationServiceMap.node]), [
-    [Global.node, tempGlobalLayer],
-    [LocationServiceMap.node, instances],
-  ]),
-)
-
-describe("InstancePlugins", () => {
-  it.live("binds plugins to one instance without leaking to siblings", () =>
-    Effect.acquireRelease(
-      Effect.promise(() => tmpdir()),
-      (dir) => Effect.promise(() => dir[Symbol.asyncDispose]()),
-    ).pipe(
-      Effect.flatMap((dir) =>
-        Effect.gen(function* () {
-          const locations = yield* LocationServiceMap.Service
-          const sdk = yield* SdkPlugins.Service
-          yield* sdk.register(agentPlugin("global-plugin", "global-agent"))
-
-          const dirA = path.join(dir.path, "thread-a")
-          const dirB = path.join(dir.path, "thread-b")
-          yield* Effect.promise(() => fs.mkdir(dirA))
-          yield* Effect.promise(() => fs.mkdir(dirB))
-          const refA = Location.Ref.make({ directory: AbsolutePath.make(dirA) })
-          const refB = Location.Ref.make({ directory: AbsolutePath.make(dirB) })
-
-          const agents = (ref: Location.Ref) =>
-            Effect.gen(function* () {
-              const supervisor = yield* PluginSupervisor.Service
-              yield* supervisor.flush
-              const service = yield* Agent.Service
-              return {
-                bound: yield* service.get(Agent.ID.make("thread-a-agent")),
-                global: yield* service.get(Agent.ID.make("global-agent")),
-              }
-            }).pipe(Effect.scoped, Effect.provide(locations.get(ref)))
-
-          const a = yield* agents(refA)
-          expect(a.bound).toBeDefined()
-          expect(a.global).toBeDefined()
-
-          const b = yield* agents(refB)
-          expect(b.bound).toBeUndefined()
-          expect(b.global).toBeDefined()
-
-          // Eviction and rebuild re-bind the same list.
-          yield* locations.invalidate(refA)
-          const rebuilt = yield* agents(refA)
-          expect(rebuilt.bound).toBeDefined()
-          expect(rebuilt.global).toBeDefined()
-        }),
-      ),
-    ),
-  )
-})
-
-describe("InstancePlugins.bound", () => {
-  test("rejects duplicate ids in one list", () => {
-    const plugin = Plugin.define({ id: "dup", effect: () => Effect.void })
-    expect(() => InstancePlugins.bound([plugin, plugin])).toThrow("duplicate instance plugin ids: dup")
-  })
-})