use forkScoped + Fiber.join for lazy LSP init (match old Instance.state behavior)

Replace the legacy Instance.state() pattern in LSP with Interface,
Service, layer, and async facades using runPromiseInstance. Wire
LSP.Service into InstanceServices and add runSyncInstance helper.

packages/opencode/specs/effect-migration.md

@@ -132,7 +132,7 @@ Still open and likely worth migrating:
 - [ ] `Worktree`
 - [ ] `Installation`
 - [ ] `Bus`
-- [x] `Command`
+- [ ] `Command`
 - [ ] `Config`
 - [ ] `Session`
 - [ ] `SessionProcessor`
@@ -140,5 +140,5 @@ Still open and likely worth migrating:
 - [ ] `SessionCompaction`
 - [ ] `Provider`
 - [ ] `Project`
-- [ ] `LSP`
+- [x] `LSP`
 - [ ] `MCP`

packages/opencode/src/bus/bus-event.ts

@@ -1,5 +1,5 @@
 import z from "zod"
-import type { ZodObject, ZodRawShape } from "zod"
+import type { ZodType } from "zod"
 import { Log } from "../util/log"
 
 export namespace BusEvent {
@@ -9,7 +9,7 @@ export namespace BusEvent {
 
   const registry = new Map<string, Definition>()
 
-  export function define<Type extends string, Properties extends ZodObject<ZodRawShape>>(type: Type, properties: Properties) {
+  export function define<Type extends string, Properties extends ZodType>(type: Type, properties: Properties) {
     const result = {
       type,
       properties,

packages/opencode/src/bus/global.ts

@@ -4,7 +4,7 @@ export const GlobalBus = new EventEmitter<{
   event: [
     {
       directory?: string
-      payload: { type: string; properties: Record<string, unknown> }
+      payload: any
     },
   ]
 }>()

packages/opencode/src/command/index.ts

@@ -1,18 +1,15 @@
 import { BusEvent } from "@/bus/bus-event"
-import { InstanceContext } from "@/effect/instance-context"
-import { runPromiseInstance } from "@/effect/runtime"
 import { SessionID, MessageID } from "@/session/schema"
-import { Effect, Fiber, Layer, ServiceMap } from "effect"
 import z from "zod"
 import { Config } from "../config/config"
+import { Instance } from "../project/instance"
+import { Identifier } from "../id/id"
 import PROMPT_INITIALIZE from "./template/initialize.txt"
 import PROMPT_REVIEW from "./template/review.txt"
 import { MCP } from "../mcp"
 import { Skill } from "../skill"
-import { Log } from "../util/log"
 
 export namespace Command {
-  const log = Log.create({ service: "command" })
   export const Event = {
     Executed: BusEvent.define(
       "command.executed",
@@ -60,126 +57,95 @@ export namespace Command {
     REVIEW: "review",
   } as const
 
-  export interface Interface {
-    readonly get: (name: string) => Effect.Effect<Info | undefined>
-    readonly list: () => Effect.Effect<Info[]>
-  }
+  const state = Instance.state(async () => {
+    const cfg = await Config.get()
 
-  export class Service extends ServiceMap.Service<Service, Interface>()("@opencode/Command") {}
+    const result: Record<string, Info> = {
+      [Default.INIT]: {
+        name: Default.INIT,
+        description: "create/update AGENTS.md",
+        source: "command",
+        get template() {
+          return PROMPT_INITIALIZE.replace("${path}", Instance.worktree)
+        },
+        hints: hints(PROMPT_INITIALIZE),
+      },
+      [Default.REVIEW]: {
+        name: Default.REVIEW,
+        description: "review changes [commit|branch|pr], defaults to uncommitted",
+        source: "command",
+        get template() {
+          return PROMPT_REVIEW.replace("${path}", Instance.worktree)
+        },
+        subtask: true,
+        hints: hints(PROMPT_REVIEW),
+      },
+    }
 
-  export const layer = Layer.effect(
-    Service,
-    Effect.gen(function* () {
-      const instance = yield* InstanceContext
+    for (const [name, command] of Object.entries(cfg.command ?? {})) {
+      result[name] = {
+        name,
+        agent: command.agent,
+        model: command.model,
+        description: command.description,
+        source: "command",
+        get template() {
+          return command.template
+        },
+        subtask: command.subtask,
+        hints: hints(command.template),
+      }
+    }
+    for (const [name, prompt] of Object.entries(await MCP.prompts())) {
+      result[name] = {
+        name,
+        source: "mcp",
+        description: prompt.description,
+        get template() {
+          // since a getter can't be async we need to manually return a promise here
+          return new Promise<string>(async (resolve, reject) => {
+            const template = await MCP.getPrompt(
+              prompt.client,
+              prompt.name,
+              prompt.arguments
+                ? // substitute each argument with $1, $2, etc.
+                  Object.fromEntries(prompt.arguments?.map((argument, i) => [argument.name, `$${i + 1}`]))
+                : {},
+            ).catch(reject)
+            resolve(
+              template?.messages
+                .map((message) => (message.content.type === "text" ? message.content.text : ""))
+                .join("\n") || "",
+            )
+          })
+        },
+        hints: prompt.arguments?.map((_, i) => `$${i + 1}`) ?? [],
+      }
+    }
 
-      const commands: Record<string, Info> = {}
+    // Add skills as invokable commands
+    for (const skill of await Skill.all()) {
+      // Skip if a command with this name already exists
+      if (result[skill.name]) continue
+      result[skill.name] = {
+        name: skill.name,
+        description: skill.description,
+        source: "skill",
+        get template() {
+          return skill.content
+        },
+        hints: [],
+      }
+    }
 
-      const load = Effect.fn("Command.load")(function* () {
-        yield* Effect.promise(async () => {
-          const cfg = await Config.get()
-
-          commands[Default.INIT] = {
-            name: Default.INIT,
-            description: "create/update AGENTS.md",
-            source: "command",
-            get template() {
-              return PROMPT_INITIALIZE.replace("${path}", instance.worktree)
-            },
-            hints: hints(PROMPT_INITIALIZE),
-          }
-          commands[Default.REVIEW] = {
-            name: Default.REVIEW,
-            description: "review changes [commit|branch|pr], defaults to uncommitted",
-            source: "command",
-            get template() {
-              return PROMPT_REVIEW.replace("${path}", instance.worktree)
-            },
-            subtask: true,
-            hints: hints(PROMPT_REVIEW),
-          }
-
-          for (const [name, command] of Object.entries(cfg.command ?? {})) {
-            commands[name] = {
-              name,
-              agent: command.agent,
-              model: command.model,
-              description: command.description,
-              source: "command",
-              get template() {
-                return command.template
-              },
-              subtask: command.subtask,
-              hints: hints(command.template),
-            }
-          }
-          for (const [name, prompt] of Object.entries(await MCP.prompts())) {
-            commands[name] = {
-              name,
-              source: "mcp",
-              description: prompt.description,
-              get template() {
-                // since a getter can't be async we need to manually return a promise here
-                return new Promise<string>(async (resolve, reject) => {
-                  const template = await MCP.getPrompt(
-                    prompt.client,
-                    prompt.name,
-                    prompt.arguments
-                      ? // substitute each argument with $1, $2, etc.
-                        Object.fromEntries(prompt.arguments?.map((argument, i) => [argument.name, `$${i + 1}`]))
-                      : {},
-                  ).catch(reject)
-                  resolve(
-                    template?.messages
-                      .map((message) => (message.content.type === "text" ? message.content.text : ""))
-                      .join("\n") || "",
-                  )
-                })
-              },
-              hints: prompt.arguments?.map((_, i) => `$${i + 1}`) ?? [],
-            }
-          }
-
-          // Add skills as invokable commands
-          for (const skill of await Skill.all()) {
-            // Skip if a command with this name already exists
-            if (commands[skill.name]) continue
-            commands[skill.name] = {
-              name: skill.name,
-              description: skill.description,
-              source: "skill",
-              get template() {
-                return skill.content
-              },
-              hints: [],
-            }
-          }
-        })
-      })
-
-      const loadFiber = yield* load().pipe(
-        Effect.catchCause((cause) => Effect.sync(() => log.error("init failed", { cause }))),
-        Effect.forkScoped,
-      )
-
-      const get = Effect.fn("Command.get")(function* (name: string) {
-        yield* Fiber.join(loadFiber)
-        return commands[name]
-      })
-
-      const list = Effect.fn("Command.list")(function* () {
-        yield* Fiber.join(loadFiber)
-        return Object.values(commands)
-      })
-
-      return Service.of({ get, list })
-    }),
-  )
+    return result
+  })
 
   export async function get(name: string) {
-    return runPromiseInstance(Service.use((svc) => svc.get(name)))
+    return state().then((x) => x[name])
   }
 
   export async function list() {
-    return runPromiseInstance(Service.use((svc) => svc.list()))
+    return state().then((x) => Object.values(x))
   }
 }

packages/opencode/src/control-plane/workspace.ts

@@ -124,7 +124,7 @@ export namespace Workspace {
       await parseSSE(res.body, stop, (event) => {
         GlobalBus.emit("event", {
           directory: space.id,
-          payload: event as { type: string; properties: Record<string, unknown> },
+          payload: event,
         })
       })
       // Wait 250ms and retry if SSE connection fails

packages/opencode/src/effect/instances.ts

@@ -1,9 +1,9 @@
 import { Effect, Layer, LayerMap, ServiceMap } from "effect"
-import { Command } from "@/command"
 import { File } from "@/file"
 import { FileTime } from "@/file/time"
 import { FileWatcher } from "@/file/watcher"
 import { Format } from "@/format"
+import { LSP } from "@/lsp"
 import { PermissionNext } from "@/permission"
 import { Instance } from "@/project/instance"
 import { Vcs } from "@/project/vcs"
@@ -17,7 +17,6 @@ import { registerDisposer } from "./instance-registry"
 export { InstanceContext } from "./instance-context"
 
 export type InstanceServices =
-  | Command.Service
   | Question.Service
   | PermissionNext.Service
   | ProviderAuth.Service
@@ -28,6 +27,7 @@ export type InstanceServices =
   | File.Service
   | Skill.Service
   | Snapshot.Service
+  | LSP.Service
 
 // NOTE: LayerMap only passes the key (directory string) to lookup, but we need
 // the full instance context (directory, worktree, project). We read from the
@@ -38,7 +38,6 @@ export type InstanceServices =
 function lookup(_key: string) {
   const ctx = Layer.sync(InstanceContext, () => InstanceContext.of(Instance.current))
   return Layer.mergeAll(
-    Layer.fresh(Command.layer),
     Layer.fresh(Question.layer),
     Layer.fresh(PermissionNext.layer),
     Layer.fresh(ProviderAuth.defaultLayer),
@@ -49,6 +48,7 @@ function lookup(_key: string) {
     Layer.fresh(File.layer),
     Layer.fresh(Skill.defaultLayer),
     Layer.fresh(Snapshot.defaultLayer),
+    Layer.fresh(LSP.layer),
   ).pipe(Layer.provide(ctx))
 }
 

packages/opencode/src/effect/runtime.ts

@@ -18,6 +18,10 @@ export function runPromiseInstance<A, E>(effect: Effect.Effect<A, E, InstanceSer
   return runtime.runPromise(effect.pipe(Effect.provide(Instances.get(Instance.directory))))
 }
 
+export function runSyncInstance<A, E>(effect: Effect.Effect<A, E, InstanceServices>) {
+  return runtime.runSync(effect.pipe(Effect.provide(Instances.get(Instance.directory))))
+}
+
 export function disposeRuntime() {
   return runtime.dispose()
 }

packages/opencode/src/lsp/index.ts

@@ -1,5 +1,7 @@
 import { BusEvent } from "@/bus/bus-event"
 import { Bus } from "@/bus"
+import { InstanceContext } from "@/effect/instance-context"
+import { runPromiseInstance } from "@/effect/runtime"
 import { Log } from "../util/log"
 import { LSPClient } from "./client"
 import path from "path"
@@ -7,10 +9,10 @@ import { pathToFileURL, fileURLToPath } from "url"
 import { LSPServer } from "./server"
 import z from "zod"
 import { Config } from "../config/config"
-import { Instance } from "../project/instance"
 import { Flag } from "@/flag/flag"
 import { Process } from "../util/process"
 import { spawn as lspspawn } from "./launch"
+import { Effect, Fiber, Layer, ServiceMap } from "effect"
 
 export namespace LSP {
   const log = Log.create({ service: "lsp" })
@@ -77,77 +79,6 @@ export namespace LSP {
     }
   }
 
-  const state = Instance.state(
-    async () => {
-      const clients: LSPClient.Info[] = []
-      const servers: Record<string, LSPServer.Info> = {}
-      const cfg = await Config.get()
-
-      if (cfg.lsp === false) {
-        log.info("all LSPs are disabled")
-        return {
-          broken: new Set<string>(),
-          servers,
-          clients,
-          spawning: new Map<string, Promise<LSPClient.Info | undefined>>(),
-        }
-      }
-
-      for (const server of Object.values(LSPServer)) {
-        servers[server.id] = server
-      }
-
-      filterExperimentalServers(servers)
-
-      for (const [name, item] of Object.entries(cfg.lsp ?? {})) {
-        const existing = servers[name]
-        if (item.disabled) {
-          log.info(`LSP server ${name} is disabled`)
-          delete servers[name]
-          continue
-        }
-        servers[name] = {
-          ...existing,
-          id: name,
-          root: existing?.root ?? (async () => Instance.directory),
-          extensions: item.extensions ?? existing?.extensions ?? [],
-          spawn: async (root) => {
-            return {
-              process: lspspawn(item.command[0], item.command.slice(1), {
-                cwd: root,
-                env: {
-                  ...process.env,
-                  ...item.env,
-                },
-              }),
-              initialization: item.initialization,
-            }
-          },
-        }
-      }
-
-      log.info("enabled LSP servers", {
-        serverIds: Object.values(servers)
-          .map((server) => server.id)
-          .join(", "),
-      })
-
-      return {
-        broken: new Set<string>(),
-        servers,
-        clients,
-        spawning: new Map<string, Promise<LSPClient.Info | undefined>>(),
-      }
-    },
-    async (state) => {
-      await Promise.all(state.clients.map((client) => client.shutdown()))
-    },
-  )
-
-  export async function init() {
-    return state()
-  }
-
   export const Status = z
     .object({
       id: z.string(),
@@ -160,162 +91,6 @@ export namespace LSP {
     })
   export type Status = z.infer<typeof Status>
 
-  export async function status() {
-    return state().then((x) => {
-      const result: Status[] = []
-      for (const client of x.clients) {
-        result.push({
-          id: client.serverID,
-          name: x.servers[client.serverID].id,
-          root: path.relative(Instance.directory, client.root),
-          status: "connected",
-        })
-      }
-      return result
-    })
-  }
-
-  async function getClients(file: string) {
-    const s = await state()
-    const extension = path.parse(file).ext || file
-    const result: LSPClient.Info[] = []
-
-    async function schedule(server: LSPServer.Info, root: string, key: string) {
-      const handle = await server
-        .spawn(root)
-        .then((value) => {
-          if (!value) s.broken.add(key)
-          return value
-        })
-        .catch((err) => {
-          s.broken.add(key)
-          log.error(`Failed to spawn LSP server ${server.id}`, { error: err })
-          return undefined
-        })
-
-      if (!handle) return undefined
-      log.info("spawned lsp server", { serverID: server.id })
-
-      const client = await LSPClient.create({
-        serverID: server.id,
-        server: handle,
-        root,
-      }).catch(async (err) => {
-        s.broken.add(key)
-        await Process.stop(handle.process)
-        log.error(`Failed to initialize LSP client ${server.id}`, { error: err })
-        return undefined
-      })
-
-      if (!client) {
-        return undefined
-      }
-
-      const existing = s.clients.find((x) => x.root === root && x.serverID === server.id)
-      if (existing) {
-        await Process.stop(handle.process)
-        return existing
-      }
-
-      s.clients.push(client)
-      return client
-    }
-
-    for (const server of Object.values(s.servers)) {
-      if (server.extensions.length && !server.extensions.includes(extension)) continue
-
-      const root = await server.root(file)
-      if (!root) continue
-      if (s.broken.has(root + server.id)) continue
-
-      const match = s.clients.find((x) => x.root === root && x.serverID === server.id)
-      if (match) {
-        result.push(match)
-        continue
-      }
-
-      const inflight = s.spawning.get(root + server.id)
-      if (inflight) {
-        const client = await inflight
-        if (!client) continue
-        result.push(client)
-        continue
-      }
-
-      const task = schedule(server, root, root + server.id)
-      s.spawning.set(root + server.id, task)
-
-      task.finally(() => {
-        if (s.spawning.get(root + server.id) === task) {
-          s.spawning.delete(root + server.id)
-        }
-      })
-
-      const client = await task
-      if (!client) continue
-
-      result.push(client)
-      Bus.publish(Event.Updated, {})
-    }
-
-    return result
-  }
-
-  export async function hasClients(file: string) {
-    const s = await state()
-    const extension = path.parse(file).ext || file
-    for (const server of Object.values(s.servers)) {
-      if (server.extensions.length && !server.extensions.includes(extension)) continue
-      const root = await server.root(file)
-      if (!root) continue
-      if (s.broken.has(root + server.id)) continue
-      return true
-    }
-    return false
-  }
-
-  export async function touchFile(input: string, waitForDiagnostics?: boolean) {
-    log.info("touching file", { file: input })
-    const clients = await getClients(input)
-    await Promise.all(
-      clients.map(async (client) => {
-        const wait = waitForDiagnostics ? client.waitForDiagnostics({ path: input }) : Promise.resolve()
-        await client.notify.open({ path: input })
-        return wait
-      }),
-    ).catch((err) => {
-      log.error("failed to touch file", { err, file: input })
-    })
-  }
-
-  export async function diagnostics() {
-    const results: Record<string, LSPClient.Diagnostic[]> = {}
-    for (const result of await runAll(async (client) => client.diagnostics)) {
-      for (const [path, diagnostics] of result.entries()) {
-        const arr = results[path] || []
-        arr.push(...diagnostics)
-        results[path] = arr
-      }
-    }
-    return results
-  }
-
-  export async function hover(input: { file: string; line: number; character: number }) {
-    return run(input.file, (client) => {
-      return client.connection
-        .sendRequest("textDocument/hover", {
-          textDocument: {
-            uri: pathToFileURL(input.file).href,
-          },
-          position: {
-            line: input.line,
-            character: input.character,
-          },
-        })
-        .catch(() => null)
-    })
-  }
-
   enum SymbolKind {
     File = 1,
     Module = 2,
@@ -356,114 +131,504 @@ export namespace LSP {
     SymbolKind.Enum,
   ]
 
-  export async function workspaceSymbol(query: string) {
-    return runAll((client) =>
-      client.connection
-        .sendRequest("workspace/symbol", {
-          query,
+  export interface Interface {
+    readonly init: () => Effect.Effect<void>
+    readonly status: () => Effect.Effect<Status[]>
+    readonly hasClients: (file: string) => Effect.Effect<boolean>
+    readonly touchFile: (input: string, waitForDiagnostics?: boolean) => Effect.Effect<void>
+    readonly diagnostics: () => Effect.Effect<Record<string, LSPClient.Diagnostic[]>>
+    readonly hover: (input: { file: string; line: number; character: number }) => Effect.Effect<any>
+    readonly workspaceSymbol: (query: string) => Effect.Effect<LSP.Symbol[]>
+    readonly documentSymbol: (uri: string) => Effect.Effect<(LSP.DocumentSymbol | LSP.Symbol)[]>
+    readonly definition: (input: { file: string; line: number; character: number }) => Effect.Effect<any[]>
+    readonly references: (input: { file: string; line: number; character: number }) => Effect.Effect<any[]>
+    readonly implementation: (input: { file: string; line: number; character: number }) => Effect.Effect<any[]>
+    readonly prepareCallHierarchy: (input: { file: string; line: number; character: number }) => Effect.Effect<any[]>
+    readonly incomingCalls: (input: { file: string; line: number; character: number }) => Effect.Effect<any[]>
+    readonly outgoingCalls: (input: { file: string; line: number; character: number }) => Effect.Effect<any[]>
+  }
+
+  export class Service extends ServiceMap.Service<Service, Interface>()("@opencode/LSP") {}
+
+  export const layer = Layer.effect(
+    Service,
+    Effect.gen(function* () {
+      const instance = yield* InstanceContext
+      const directory = instance.directory
+
+      const clients: LSPClient.Info[] = []
+      const servers: Record<string, LSPServer.Info> = {}
+      const broken = new Set<string>()
+      const spawning = new Map<string, Promise<LSPClient.Info | undefined>>()
+
+      // Load server configs lazily — forkScoped so it doesn't block layer construction
+      const load = Effect.fn("LSP.load")(function* () {
+        yield* Effect.promise(async () => {
+          const cfg = await Config.get()
+
+          if (cfg.lsp === false) {
+            log.info("all LSPs are disabled")
+            return
+          }
+
+          for (const server of Object.values(LSPServer)) {
+            servers[server.id] = server
+          }
+
+          filterExperimentalServers(servers)
+
+          for (const [name, item] of Object.entries(cfg.lsp ?? {})) {
+            const existing = servers[name]
+            if (item.disabled) {
+              log.info(`LSP server ${name} is disabled`)
+              delete servers[name]
+              continue
+            }
+            servers[name] = {
+              ...existing,
+              id: name,
+              root: existing?.root ?? (async () => directory),
+              extensions: item.extensions ?? existing?.extensions ?? [],
+              spawn: async (root) => {
+                return {
+                  process: lspspawn(item.command[0], item.command.slice(1), {
+                    cwd: root,
+                    env: {
+                      ...process.env,
+                      ...item.env,
+                    },
+                  }),
+                  initialization: item.initialization,
+                }
+              },
+            }
+          }
+
+          log.info("enabled LSP servers", {
+            serverIds: Object.values(servers)
+              .map((server) => server.id)
+              .join(", "),
+          })
         })
-        .then((result: any) => result.filter((x: LSP.Symbol) => kinds.includes(x.kind)))
-        .then((result: any) => result.slice(0, 10))
-        .catch(() => []),
-    ).then((result) => result.flat() as LSP.Symbol[])
+      })
+
+      const loadFiber = yield* load().pipe(
+        Effect.catchCause((cause) => Effect.sync(() => log.error("init failed", { cause }))),
+        Effect.forkScoped,
+      )
+
+      // Cleanup: shut down all LSP clients when the scope is closed
+      yield* Effect.addFinalizer(() =>
+        Effect.promise(async () => {
+          await Promise.all(clients.map((client) => client.shutdown()))
+        }),
+      )
+
+      async function getClientsForFile(file: string) {
+        const extension = path.parse(file).ext || file
+        const result: LSPClient.Info[] = []
+
+        async function schedule(server: LSPServer.Info, root: string, key: string) {
+          const handle = await server
+            .spawn(root)
+            .then((value) => {
+              if (!value) broken.add(key)
+              return value
+            })
+            .catch((err) => {
+              broken.add(key)
+              log.error(`Failed to spawn LSP server ${server.id}`, { error: err })
+              return undefined
+            })
+
+          if (!handle) return undefined
+          log.info("spawned lsp server", { serverID: server.id })
+
+          const client = await LSPClient.create({
+            serverID: server.id,
+            server: handle,
+            root,
+          }).catch(async (err) => {
+            broken.add(key)
+            await Process.stop(handle.process)
+            log.error(`Failed to initialize LSP client ${server.id}`, { error: err })
+            return undefined
+          })
+
+          if (!client) {
+            return undefined
+          }
+
+          const existing = clients.find((x) => x.root === root && x.serverID === server.id)
+          if (existing) {
+            await Process.stop(handle.process)
+            return existing
+          }
+
+          clients.push(client)
+          return client
+        }
+
+        for (const server of Object.values(servers)) {
+          if (server.extensions.length && !server.extensions.includes(extension)) continue
+
+          const root = await server.root(file)
+          if (!root) continue
+          if (broken.has(root + server.id)) continue
+
+          const match = clients.find((x) => x.root === root && x.serverID === server.id)
+          if (match) {
+            result.push(match)
+            continue
+          }
+
+          const inflight = spawning.get(root + server.id)
+          if (inflight) {
+            const client = await inflight
+            if (!client) continue
+            result.push(client)
+            continue
+          }
+
+          const task = schedule(server, root, root + server.id)
+          spawning.set(root + server.id, task)
+
+          task.finally(() => {
+            if (spawning.get(root + server.id) === task) {
+              spawning.delete(root + server.id)
+            }
+          })
+
+          const client = await task
+          if (!client) continue
+
+          result.push(client)
+          Bus.publish(Event.Updated, {})
+        }
+
+        return result
+      }
+
+      async function runAllClients<T>(input: (client: LSPClient.Info) => Promise<T>): Promise<T[]> {
+        const tasks = clients.map((x) => input(x))
+        return Promise.all(tasks)
+      }
+
+      async function runForFile<T>(file: string, input: (client: LSPClient.Info) => Promise<T>): Promise<T[]> {
+        const matched = await getClientsForFile(file)
+        const tasks = matched.map((x) => input(x))
+        return Promise.all(tasks)
+      }
+
+      const init = Effect.fn("LSP.init")(function* () {
+        yield* Fiber.join(loadFiber)
+      })
+
+      const status = Effect.fn("LSP.status")(function* () {
+        yield* Fiber.join(loadFiber)
+        const result: Status[] = []
+        for (const client of clients) {
+          result.push({
+            id: client.serverID,
+            name: servers[client.serverID].id,
+            root: path.relative(directory, client.root),
+            status: "connected",
+          })
+        }
+        return result
+      })
+
+      const hasClients = Effect.fn("LSP.hasClients")(function* (file: string) {
+        yield* Fiber.join(loadFiber)
+        return yield* Effect.promise(async () => {
+          const extension = path.parse(file).ext || file
+          for (const server of Object.values(servers)) {
+            if (server.extensions.length && !server.extensions.includes(extension)) continue
+            const root = await server.root(file)
+            if (!root) continue
+            if (broken.has(root + server.id)) continue
+            return true
+          }
+          return false
+        })
+      })
+
+      const touchFile = Effect.fn("LSP.touchFile")(function* (input: string, waitForDiagnostics?: boolean) {
+        yield* Fiber.join(loadFiber)
+        yield* Effect.promise(async () => {
+          log.info("touching file", { file: input })
+          const matched = await getClientsForFile(input)
+          await Promise.all(
+            matched.map(async (client) => {
+              const wait = waitForDiagnostics ? client.waitForDiagnostics({ path: input }) : Promise.resolve()
+              await client.notify.open({ path: input })
+              return wait
+            }),
+          ).catch((err) => {
+            log.error("failed to touch file", { err, file: input })
+          })
+        })
+      })
+
+      const diagnostics = Effect.fn("LSP.diagnostics")(function* () {
+        yield* Fiber.join(loadFiber)
+        return yield* Effect.promise(async () => {
+          const results: Record<string, LSPClient.Diagnostic[]> = {}
+          for (const result of await runAllClients(async (client) => client.diagnostics)) {
+            for (const [path, diagnostics] of result.entries()) {
+              const arr = results[path] || []
+              arr.push(...diagnostics)
+              results[path] = arr
+            }
+          }
+          return results
+        })
+      })
+
+      const hover = Effect.fn("LSP.hover")(function* (input: { file: string; line: number; character: number }) {
+        yield* Fiber.join(loadFiber)
+        return yield* Effect.promise(async () => {
+          return runForFile(input.file, (client) => {
+            return client.connection
+              .sendRequest("textDocument/hover", {
+                textDocument: {
+                  uri: pathToFileURL(input.file).href,
+                },
+                position: {
+                  line: input.line,
+                  character: input.character,
+                },
+              })
+              .catch(() => null)
+          })
+        })
+      })
+
+      const workspaceSymbol = Effect.fn("LSP.workspaceSymbol")(function* (query: string) {
+        yield* Fiber.join(loadFiber)
+        return yield* Effect.promise(async () => {
+          return runAllClients((client) =>
+            client.connection
+              .sendRequest("workspace/symbol", {
+                query,
+              })
+              .then((result: any) => result.filter((x: LSP.Symbol) => kinds.includes(x.kind)))
+              .then((result: any) => result.slice(0, 10))
+              .catch(() => []),
+          ).then((result) => result.flat() as LSP.Symbol[])
+        })
+      })
+
+      const documentSymbol = Effect.fn("LSP.documentSymbol")(function* (uri: string) {
+        yield* Fiber.join(loadFiber)
+        return yield* Effect.promise(async () => {
+          const file = fileURLToPath(uri)
+          return runForFile(file, (client) =>
+            client.connection
+              .sendRequest("textDocument/documentSymbol", {
+                textDocument: {
+                  uri,
+                },
+              })
+              .catch(() => []),
+          )
+            .then((result) => result.flat() as (LSP.DocumentSymbol | LSP.Symbol)[])
+            .then((result) => result.filter(Boolean))
+        })
+      })
+
+      const definition = Effect.fn("LSP.definition")(function* (input: {
+        file: string
+        line: number
+        character: number
+      }) {
+        yield* Fiber.join(loadFiber)
+        return yield* Effect.promise(async () => {
+          return runForFile(input.file, (client) =>
+            client.connection
+              .sendRequest("textDocument/definition", {
+                textDocument: { uri: pathToFileURL(input.file).href },
+                position: { line: input.line, character: input.character },
+              })
+              .catch(() => null),
+          ).then((result) => result.flat().filter(Boolean))
+        })
+      })
+
+      const references = Effect.fn("LSP.references")(function* (input: {
+        file: string
+        line: number
+        character: number
+      }) {
+        yield* Fiber.join(loadFiber)
+        return yield* Effect.promise(async () => {
+          return runForFile(input.file, (client) =>
+            client.connection
+              .sendRequest("textDocument/references", {
+                textDocument: { uri: pathToFileURL(input.file).href },
+                position: { line: input.line, character: input.character },
+                context: { includeDeclaration: true },
+              })
+              .catch(() => []),
+          ).then((result) => result.flat().filter(Boolean))
+        })
+      })
+
+      const implementation = Effect.fn("LSP.implementation")(function* (input: {
+        file: string
+        line: number
+        character: number
+      }) {
+        yield* Fiber.join(loadFiber)
+        return yield* Effect.promise(async () => {
+          return runForFile(input.file, (client) =>
+            client.connection
+              .sendRequest("textDocument/implementation", {
+                textDocument: { uri: pathToFileURL(input.file).href },
+                position: { line: input.line, character: input.character },
+              })
+              .catch(() => null),
+          ).then((result) => result.flat().filter(Boolean))
+        })
+      })
+
+      const prepareCallHierarchy = Effect.fn("LSP.prepareCallHierarchy")(function* (input: {
+        file: string
+        line: number
+        character: number
+      }) {
+        yield* Fiber.join(loadFiber)
+        return yield* Effect.promise(async () => {
+          return runForFile(input.file, (client) =>
+            client.connection
+              .sendRequest("textDocument/prepareCallHierarchy", {
+                textDocument: { uri: pathToFileURL(input.file).href },
+                position: { line: input.line, character: input.character },
+              })
+              .catch(() => []),
+          ).then((result) => result.flat().filter(Boolean))
+        })
+      })
+
+      const incomingCalls = Effect.fn("LSP.incomingCalls")(function* (input: {
+        file: string
+        line: number
+        character: number
+      }) {
+        yield* Fiber.join(loadFiber)
+        return yield* Effect.promise(async () => {
+          return runForFile(input.file, async (client) => {
+            const items = (await client.connection
+              .sendRequest("textDocument/prepareCallHierarchy", {
+                textDocument: { uri: pathToFileURL(input.file).href },
+                position: { line: input.line, character: input.character },
+              })
+              .catch(() => [])) as any[]
+            if (!items?.length) return []
+            return client.connection
+              .sendRequest("callHierarchy/incomingCalls", { item: items[0] })
+              .catch(() => [])
+          }).then((result) => result.flat().filter(Boolean))
+        })
+      })
+
+      const outgoingCalls = Effect.fn("LSP.outgoingCalls")(function* (input: {
+        file: string
+        line: number
+        character: number
+      }) {
+        yield* Fiber.join(loadFiber)
+        return yield* Effect.promise(async () => {
+          return runForFile(input.file, async (client) => {
+            const items = (await client.connection
+              .sendRequest("textDocument/prepareCallHierarchy", {
+                textDocument: { uri: pathToFileURL(input.file).href },
+                position: { line: input.line, character: input.character },
+              })
+              .catch(() => [])) as any[]
+            if (!items?.length) return []
+            return client.connection
+              .sendRequest("callHierarchy/outgoingCalls", { item: items[0] })
+              .catch(() => [])
+          }).then((result) => result.flat().filter(Boolean))
+        })
+      })
+
+      log.info("init")
+      return Service.of({
+        init,
+        status,
+        hasClients,
+        touchFile,
+        diagnostics,
+        hover,
+        workspaceSymbol,
+        documentSymbol,
+        definition,
+        references,
+        implementation,
+        prepareCallHierarchy,
+        incomingCalls,
+        outgoingCalls,
+      })
+    }),
+  )
+
+  // Async facades
+  export async function init() {
+    return runPromiseInstance(Service.use((svc) => svc.init()))
+  }
+
+  export async function status() {
+    return runPromiseInstance(Service.use((svc) => svc.status()))
+  }
+
+  export async function hasClients(file: string) {
+    return runPromiseInstance(Service.use((svc) => svc.hasClients(file)))
+  }
+
+  export async function touchFile(input: string, waitForDiagnostics?: boolean) {
+    return runPromiseInstance(Service.use((svc) => svc.touchFile(input, waitForDiagnostics)))
+  }
+
+  export async function diagnostics() {
+    return runPromiseInstance(Service.use((svc) => svc.diagnostics()))
+  }
+
+  export async function hover(input: { file: string; line: number; character: number }) {
+    return runPromiseInstance(Service.use((svc) => svc.hover(input)))
+  }
+
+  export async function workspaceSymbol(query: string) {
+    return runPromiseInstance(Service.use((svc) => svc.workspaceSymbol(query)))
   }
 
   export async function documentSymbol(uri: string) {
-    const file = fileURLToPath(uri)
-    return run(file, (client) =>
-      client.connection
-        .sendRequest("textDocument/documentSymbol", {
-          textDocument: {
-            uri,
-          },
-        })
-        .catch(() => []),
-    )
-      .then((result) => result.flat() as (LSP.DocumentSymbol | LSP.Symbol)[])
-      .then((result) => result.filter(Boolean))
+    return runPromiseInstance(Service.use((svc) => svc.documentSymbol(uri)))
   }
 
   export async function definition(input: { file: string; line: number; character: number }) {
-    return run(input.file, (client) =>
-      client.connection
-        .sendRequest("textDocument/definition", {
-          textDocument: { uri: pathToFileURL(input.file).href },
-          position: { line: input.line, character: input.character },
-        })
-        .catch(() => null),
-    ).then((result) => result.flat().filter(Boolean))
+    return runPromiseInstance(Service.use((svc) => svc.definition(input)))
   }
 
   export async function references(input: { file: string; line: number; character: number }) {
-    return run(input.file, (client) =>
-      client.connection
-        .sendRequest("textDocument/references", {
-          textDocument: { uri: pathToFileURL(input.file).href },
-          position: { line: input.line, character: input.character },
-          context: { includeDeclaration: true },
-        })
-        .catch(() => []),
-    ).then((result) => result.flat().filter(Boolean))
+    return runPromiseInstance(Service.use((svc) => svc.references(input)))
   }
 
   export async function implementation(input: { file: string; line: number; character: number }) {
-    return run(input.file, (client) =>
-      client.connection
-        .sendRequest("textDocument/implementation", {
-          textDocument: { uri: pathToFileURL(input.file).href },
-          position: { line: input.line, character: input.character },
-        })
-        .catch(() => null),
-    ).then((result) => result.flat().filter(Boolean))
+    return runPromiseInstance(Service.use((svc) => svc.implementation(input)))
   }
 
   export async function prepareCallHierarchy(input: { file: string; line: number; character: number }) {
-    return run(input.file, (client) =>
-      client.connection
-        .sendRequest("textDocument/prepareCallHierarchy", {
-          textDocument: { uri: pathToFileURL(input.file).href },
-          position: { line: input.line, character: input.character },
-        })
-        .catch(() => []),
-    ).then((result) => result.flat().filter(Boolean))
+    return runPromiseInstance(Service.use((svc) => svc.prepareCallHierarchy(input)))
   }
 
   export async function incomingCalls(input: { file: string; line: number; character: number }) {
-    return run(input.file, async (client) => {
-      const items = (await client.connection
-        .sendRequest("textDocument/prepareCallHierarchy", {
-          textDocument: { uri: pathToFileURL(input.file).href },
-          position: { line: input.line, character: input.character },
-        })
-        .catch(() => [])) as any[]
-      if (!items?.length) return []
-      return client.connection.sendRequest("callHierarchy/incomingCalls", { item: items[0] }).catch(() => [])
-    }).then((result) => result.flat().filter(Boolean))
+    return runPromiseInstance(Service.use((svc) => svc.incomingCalls(input)))
   }
 
   export async function outgoingCalls(input: { file: string; line: number; character: number }) {
-    return run(input.file, async (client) => {
-      const items = (await client.connection
-        .sendRequest("textDocument/prepareCallHierarchy", {
-          textDocument: { uri: pathToFileURL(input.file).href },
-          position: { line: input.line, character: input.character },
-        })
-        .catch(() => [])) as any[]
-      if (!items?.length) return []
-      return client.connection.sendRequest("callHierarchy/outgoingCalls", { item: items[0] }).catch(() => [])
-    }).then((result) => result.flat().filter(Boolean))
-  }
-
-  async function runAll<T>(input: (client: LSPClient.Info) => Promise<T>): Promise<T[]> {
-    const clients = await state().then((x) => x.clients)
-    const tasks = clients.map((x) => input(x))
-    return Promise.all(tasks)
-  }
-
-  async function run<T>(file: string, input: (client: LSPClient.Info) => Promise<T>): Promise<T[]> {
-    const clients = await getClients(file)
-    const tasks = clients.map((x) => input(x))
-    return Promise.all(tasks)
+    return runPromiseInstance(Service.use((svc) => svc.outgoingCalls(input)))
   }
 
   export namespace Diagnostic {

packages/opencode/src/session/prompt.ts

@@ -1782,9 +1782,6 @@ NOTE: At any point in time through this workflow you should feel free to ask the
   export async function command(input: CommandInput) {
     log.info("command", input)
     const command = await Command.get(input.command)
-    if (!command) {
-      throw new NamedError.Unknown({ message: `Command not found: "${input.command}"` })
-    }
     const agentName = command.agent ?? input.agent ?? (await Agent.defaultAgent())
 
     const raw = input.arguments.match(argsRegex) ?? []

packages/opencode/test/file/watcher.test.ts

@@ -5,9 +5,9 @@ import path from "path"
 import { Deferred, Effect, Option } from "effect"
 import { tmpdir } from "../fixture/fixture"
 import { watcherConfigLayer, withServices } from "../fixture/instance"
-import { Bus } from "../../src/bus"
 import { FileWatcher } from "../../src/file/watcher"
 import { Instance } from "../../src/project/instance"
+import { GlobalBus } from "../../src/bus/global"
 
 // Native @parcel/watcher bindings aren't reliably available in CI (missing on Linux, flaky on Windows)
 const describeWatcher = FileWatcher.hasNativeBinding() && !process.env.CI ? describe : describe.skip
@@ -16,6 +16,7 @@ const describeWatcher = FileWatcher.hasNativeBinding() && !process.env.CI ? desc
 // Helpers
 // ---------------------------------------------------------------------------
 
+type BusUpdate = { directory?: string; payload: { type: string; properties: WatcherEvent } }
 type WatcherEvent = { file: string; event: "add" | "change" | "unlink" }
 
 /** Run `body` with a live FileWatcher service. */
@@ -35,17 +36,22 @@ function withWatcher<E>(directory: string, body: Effect.Effect<void, E>) {
 function listen(directory: string, check: (evt: WatcherEvent) => boolean, hit: (evt: WatcherEvent) => void) {
   let done = false
 
-  const unsub = Bus.subscribe(FileWatcher.Event.Updated, (evt) => {
+  function on(evt: BusUpdate) {
     if (done) return
-    if (!check(evt.properties)) return
-    hit(evt.properties)
-  })
+    if (evt.directory !== directory) return
+    if (evt.payload.type !== FileWatcher.Event.Updated.type) return
+    if (!check(evt.payload.properties)) return
+    hit(evt.payload.properties)
+  }
 
-  return () => {
+  function cleanup() {
     if (done) return
     done = true
-    unsub()
+    GlobalBus.off("event", on)
   }
+
+  GlobalBus.on("event", on)
+  return cleanup
 }
 
 function wait(directory: string, check: (evt: WatcherEvent) => boolean) {