Merge branch 'dev' into kit/effectify-plugin

Replace the legacy Instance.state() lazy-init pattern with the standard
Effect service pattern (Interface, Service class, Layer, promise facades).
Register Plugin.Service in InstanceServices and add its layer to the
instance lookup.

packages/opencode/specs/effect-migration.md

@@ -126,10 +126,10 @@ Done now:
 
 Still open and likely worth migrating:
 
-- [ ] `Plugin`
+- [x] `Plugin`
 - [ ] `ToolRegistry`
 - [ ] `Pty`
-- [x] `Worktree`
+- [ ] `Worktree`
 - [ ] `Installation`
 - [ ] `Bus`
 - [ ] `Command`

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

@@ -1,5 +1,5 @@
 import z from "zod"
-import type { ZodType } from "zod"
+import type { ZodObject, ZodRawShape } 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 ZodType>(type: Type, properties: Properties) {
+  export function define<Type extends string, Properties extends ZodObject<ZodRawShape>>(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: any
+      payload: { type: string; properties: Record<string, unknown> }
     },
   ]
 }>()

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,
+          payload: event as { type: string; properties: Record<string, unknown> },
         })
       })
       // Wait 250ms and retry if SSE connection fails

packages/opencode/src/effect/instances.ts

@@ -10,7 +10,7 @@ import { ProviderAuth } from "@/provider/auth-service"
 import { Question } from "@/question/service"
 import { Skill } from "@/skill/service"
 import { Snapshot } from "@/snapshot/service"
-import { Worktree } from "@/worktree"
+import { Plugin } from "@/plugin"
 import { InstanceContext } from "./instance-context"
 import { registerDisposer } from "./instance-registry"
 
@@ -27,7 +27,7 @@ export type InstanceServices =
   | File.Service
   | Skill.Service
   | Snapshot.Service
-  | Worktree.Service
+  | Plugin.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
@@ -48,7 +48,7 @@ function lookup(_key: string) {
     File.layer,
     Skill.defaultLayer,
     Snapshot.defaultLayer,
-    Worktree.layer,
+    Plugin.layer,
   ).pipe(Layer.provide(ctx))
 }
 

packages/opencode/src/plugin/index.ts

@@ -1,28 +1,52 @@
 import type { Hooks, PluginInput, Plugin as PluginInstance } from "@opencode-ai/plugin"
-import { Config } from "../config/config"
 import { Bus } from "../bus"
 import { Log } from "../util/log"
 import { createOpencodeClient } from "@opencode-ai/sdk"
-import { Server } from "../server/server"
 import { BunProc } from "../bun"
-import { Instance } from "../project/instance"
 import { Flag } from "../flag/flag"
-import { CodexAuthPlugin } from "./codex"
-import { Session } from "../session"
 import { NamedError } from "@opencode-ai/util/error"
-import { CopilotAuthPlugin } from "./copilot"
+import { Effect, Layer, ServiceMap } from "effect"
-import { gitlabAuthPlugin as GitlabAuthPlugin } from "opencode-gitlab-auth"
+import { InstanceContext } from "@/effect/instance-context"
 
 export namespace Plugin {
   const log = Log.create({ service: "plugin" })
 
-  // Built-in plugins that are directly imported (not installed from npm)
+  export interface Interface {
-  const INTERNAL_PLUGINS: PluginInstance[] = [CodexAuthPlugin, CopilotAuthPlugin, GitlabAuthPlugin]
+    readonly trigger: <
+      Name extends Exclude<keyof Required<Hooks>, "auth" | "event" | "tool">,
+      Input = Parameters<Required<Hooks>[Name]>[0],
+      Output = Parameters<Required<Hooks>[Name]>[1],
+    >(
+      name: Name,
+      input: Input,
+      output: Output,
+    ) => Effect.Effect<Output>
+    readonly list: () => Effect.Effect<Hooks[]>
+    readonly init: () => Effect.Effect<void>
+  }
 
-  const state = Instance.state(async () => {
+  export class Service extends ServiceMap.Service<Service, Interface>()("@opencode/Plugin") {}
+
+  export const layer = Layer.effect(
+    Service,
+    Effect.gen(function* () {
+      const instance = yield* InstanceContext
+      const hooks: Hooks[] = []
+      let task: Promise<void> | undefined
+
+      const load = Effect.fn("Plugin.load")(function* () {
+        yield* Effect.promise(async () => {
+          const [{ Config }, { Server }, codex, copilot, gitlab] = await Promise.all([
+            import("../config/config"),
+            import("../server/server"),
+            import("./codex"),
+            import("./copilot"),
+            import("opencode-gitlab-auth"),
+          ])
+          const internal: PluginInstance[] = [codex.CodexAuthPlugin, copilot.CopilotAuthPlugin, gitlab.gitlabAuthPlugin]
           const client = createOpencodeClient({
             baseUrl: "http://localhost:4096",
-      directory: Instance.directory,
+            directory: instance.directory,
             headers: Flag.OPENCODE_SERVER_PASSWORD
               ? {
                   Authorization: `Basic ${Buffer.from(`${Flag.OPENCODE_SERVER_USERNAME ?? "opencode"}:${Flag.OPENCODE_SERVER_PASSWORD}`).toString("base64")}`,
@@ -31,19 +55,18 @@ export namespace Plugin {
             fetch: async (...args) => Server.Default().fetch(...args),
           })
           const config = await Config.get()
-    const hooks: Hooks[] = []
           const input: PluginInput = {
             client,
-      project: Instance.project,
+            project: instance.project,
-      worktree: Instance.worktree,
+            worktree: instance.worktree,
-      directory: Instance.directory,
+            directory: instance.directory,
             get serverUrl(): URL {
               return Server.url ?? new URL("http://localhost:4096")
             },
             $: Bun.$,
           }
 
-    for (const plugin of INTERNAL_PLUGINS) {
+          for (const plugin of internal) {
             log.info("loading internal plugin", { name: plugin.name })
             const init = await plugin(input).catch((err) => {
               log.error("failed to load internal plugin", { name: plugin.name, error: err })
@@ -66,11 +89,13 @@ export namespace Plugin {
                 const cause = err instanceof Error ? err.cause : err
                 const detail = cause instanceof Error ? cause.message : String(cause ?? err)
                 log.error("failed to install plugin", { pkg, version, error: detail })
+                void import("../session").then(({ Session }) =>
                   Bus.publish(Session.Event.Error, {
                     error: new NamedError.Unknown({
                       message: `Failed to install plugin ${pkg}@${version}: ${detail}`,
                     }).toObject(),
-          })
+                  }),
+                )
                 return ""
               })
               if (!plugin) continue
@@ -90,27 +115,36 @@ export namespace Plugin {
               .catch((err) => {
                 const message = err instanceof Error ? err.message : String(err)
                 log.error("failed to load plugin", { path: plugin, error: message })
+                void import("../session").then(({ Session }) =>
                   Bus.publish(Session.Event.Error, {
                     error: new NamedError.Unknown({
                       message: `Failed to load plugin ${plugin}: ${message}`,
                     }).toObject(),
-          })
+                  }),
+                )
               })
           }
-
+        })
-    return {
-      hooks,
-      input,
-    }
       })
 
-  export async function trigger<
+      const ensure = Effect.fn("Plugin.ensure")(function* () {
+        yield* Effect.promise(() => {
+          task ??= Effect.runPromise(
+            load().pipe(Effect.catchCause((cause) => Effect.sync(() => log.error("init failed", { cause })))),
+          )
+          return task
+        })
+      })
+
+      const trigger = Effect.fn("Plugin.trigger")(function* <
         Name extends Exclude<keyof Required<Hooks>, "auth" | "event" | "tool">,
         Input = Parameters<Required<Hooks>[Name]>[0],
         Output = Parameters<Required<Hooks>[Name]>[1],
-  >(name: Name, input: Input, output: Output): Promise<Output> {
+      >(name: Name, input: Input, output: Output) {
         if (!name) return output
-    for (const hook of await state().then((x) => x.hooks)) {
+        yield* ensure()
+        yield* Effect.promise(async () => {
+          for (const hook of hooks) {
             const fn = hook[name]
             if (!fn) continue
             // @ts-expect-error if you feel adventurous, please fix the typing, make sure to bump the try-counter if you
@@ -118,27 +152,55 @@ export namespace Plugin {
             // try-counter: 2
             await fn(input, output)
           }
+        })
         return output
-  }
+      })
 
-  export async function list() {
+      const list = Effect.fn("Plugin.list")(function* () {
-    return state().then((x) => x.hooks)
+        yield* ensure()
-  }
+        return hooks
+      })
 
-  export async function init() {
+      const init = Effect.fn("Plugin.init")(function* () {
-    const hooks = await state().then((x) => x.hooks)
+        yield* ensure()
+        yield* Effect.promise(async () => {
+          const { Config } = await import("../config/config")
           const config = await Config.get()
           for (const hook of hooks) {
-      // @ts-expect-error this is because we haven't moved plugin to sdk v2
+            await (hook as any).config?.(config)
-      await hook.config?.(config)
           }
           Bus.subscribeAll(async (input) => {
-      const hooks = await state().then((x) => x.hooks)
             for (const hook of hooks) {
               hook["event"]?.({
                 event: input,
               })
             }
           })
+        })
+      })
+
+      return Service.of({ trigger, list, init })
+    }),
+  ).pipe(Layer.fresh)
+
+  async function run<A, E>(effect: Effect.Effect<A, E, Service>) {
+    const { runPromiseInstance } = await import("@/effect/runtime")
+    return runPromiseInstance(effect)
+  }
+
+  export async function trigger<
+    Name extends Exclude<keyof Required<Hooks>, "auth" | "event" | "tool">,
+    Input = Parameters<Required<Hooks>[Name]>[0],
+    Output = Parameters<Required<Hooks>[Name]>[1],
+  >(name: Name, input: Input, output: Output): Promise<Output> {
+    return run(Service.use((svc) => svc.trigger(name, input, output)))
+  }
+
+  export async function list(): Promise<Hooks[]> {
+    return run(Service.use((svc) => svc.list()))
+  }
+
+  export async function init() {
+    return run(Service.use((svc) => svc.init()))
   }
 }

packages/opencode/src/provider/auth-service.ts

@@ -1,4 +1,4 @@
-import type { AuthOuathResult } from "@opencode-ai/plugin"
+import type { AuthOuathResult, Hooks } from "@opencode-ai/plugin"
 import { NamedError } from "@opencode-ai/util/error"
 import * as Auth from "@/auth/effect"
 import { ProviderID } from "./schema"
@@ -6,6 +6,8 @@ import { Array as Arr, Effect, Layer, Record, Result, ServiceMap, Struct } from
 import z from "zod"
 
 export namespace ProviderAuth {
+  type Hook = NonNullable<Hooks["auth"]>
+
   export const Method = z
     .object({
       type: z.union([z.literal("oauth"), z.literal("api")]),
@@ -105,20 +107,26 @@ export namespace ProviderAuth {
     Service,
     Effect.gen(function* () {
       const auth = yield* Auth.Auth.Service
-      const hooks = yield* Effect.promise(async () => {
+      let hooks: Record<ProviderID, Hook> | undefined
-        const mod = await import("../plugin")
-        const plugins = await mod.Plugin.list()
-        return Record.fromEntries(
-          Arr.filterMap(plugins, (x) =>
-            x.auth?.provider !== undefined
-              ? Result.succeed([ProviderID.make(x.auth.provider), x.auth] as const)
-              : Result.failVoid,
-          ),
-        )
-      })
       const pending = new Map<ProviderID, AuthOuathResult>()
 
+      const load = Effect.fn("ProviderAuth.load")(function* () {
+        if (hooks) return hooks
+        hooks = yield* Effect.promise(async () => {
+          const mod = await import("../plugin")
+          const plugins = await mod.Plugin.list()
+          const result = {} as Record<ProviderID, Hook>
+          for (const item of plugins) {
+            if (item.auth?.provider === undefined) continue
+            result[ProviderID.make(item.auth.provider)] = item.auth
+          }
+          return result
+        })
+        return hooks
+      })
+
       const methods = Effect.fn("ProviderAuth.methods")(function* () {
+        const hooks = yield* load()
         return Record.map(hooks, (item) =>
           item.methods.map(
             (method): Method => ({
@@ -152,6 +160,7 @@ export namespace ProviderAuth {
         method: number
         inputs?: Record<string, string>
       }) {
+        const hooks = yield* load()
         const method = hooks[input.providerID].methods[input.method]
         if (method.type !== "oauth") return
 
@@ -178,6 +187,7 @@ export namespace ProviderAuth {
         method: number
         code?: string
       }) {
+        yield* load()
         const match = pending.get(input.providerID)
         if (!match) return yield* Effect.fail(new OauthMissing({ providerID: input.providerID }))
         if (match.method === "code" && !input.code) {

packages/opencode/src/worktree/index.ts

@@ -4,17 +4,17 @@ import z from "zod"
 import { NamedError } from "@opencode-ai/util/error"
 import { Global } from "../global"
 import { Instance } from "../project/instance"
+import { InstanceBootstrap } from "../project/bootstrap"
 import { Project } from "../project/project"
 import { Database, eq } from "../storage/db"
 import { ProjectTable } from "../project/project.sql"
 import type { ProjectID } from "../project/schema"
+import { fn } from "../util/fn"
 import { Log } from "../util/log"
 import { Process } from "../util/process"
 import { git } from "../util/git"
 import { BusEvent } from "@/bus/bus-event"
 import { GlobalBus } from "@/bus/global"
-import { InstanceContext } from "@/effect/instance-context"
-import { Effect, Layer, ServiceMap } from "effect"
 
 export namespace Worktree {
   const log = Log.create({ service: "worktree" })
@@ -267,7 +267,7 @@ export namespace Worktree {
     return process.platform === "win32" ? normalized.toLowerCase() : normalized
   }
 
-  async function candidateName(worktreeDir: string, root: string, base?: string) {
+  async function candidate(root: string, base?: string) {
     for (const attempt of Array.from({ length: 26 }, (_, i) => i)) {
       const name = base ? (attempt === 0 ? base : `${base}-${randomName()}`) : randomName()
       const branch = `opencode/${name}`
@@ -277,7 +277,7 @@ export namespace Worktree {
 
       const ref = `refs/heads/${branch}`
       const branchCheck = await git(["show-ref", "--verify", "--quiet", ref], {
-        cwd: worktreeDir,
+        cwd: Instance.worktree,
       })
       if (branchCheck.exitCode === 0) continue
 
@@ -335,51 +335,29 @@ export namespace Worktree {
     }, 0)
   }
 
-  // ---------------------------------------------------------------------------
+  export async function makeWorktreeInfo(name?: string): Promise<Info> {
-  // Effect service
+    if (Instance.project.vcs !== "git") {
-  // ---------------------------------------------------------------------------
-
-  export interface Interface {
-    readonly makeWorktreeInfo: (name?: string) => Effect.Effect<Info>
-    readonly createFromInfo: (info: Info, startCommand?: string) => Effect.Effect<() => Promise<void>>
-    readonly create: (input?: CreateInput) => Effect.Effect<Info>
-    readonly remove: (input: RemoveInput) => Effect.Effect<boolean>
-    readonly reset: (input: ResetInput) => Effect.Effect<boolean>
-  }
-
-  export class Service extends ServiceMap.Service<Service, Interface>()("@opencode/Worktree") {}
-
-  export const layer = Layer.effect(
-    Service,
-    Effect.gen(function* () {
-      const instance = yield* InstanceContext
-
-      const makeWorktreeInfoEffect = Effect.fn("Worktree.makeWorktreeInfo")(function* (name?: string) {
-        return yield* Effect.promise(async () => {
-          if (instance.project.vcs !== "git") {
       throw new NotGitError({ message: "Worktrees are only supported for git projects" })
     }
 
-          const root = path.join(Global.Path.data, "worktree", instance.project.id)
+    const root = path.join(Global.Path.data, "worktree", Instance.project.id)
     await fs.mkdir(root, { recursive: true })
 
     const base = name ? slug(name) : ""
-          return candidateName(instance.worktree, root, base || undefined)
+    return candidate(root, base || undefined)
-        })
+  }
-      })
 
-      const createFromInfoEffect = Effect.fn("Worktree.createFromInfo")(function* (info: Info, startCommand?: string) {
+  export async function createFromInfo(info: Info, startCommand?: string) {
-        return yield* Effect.promise(async (): Promise<() => Promise<void>> => {
     const created = await git(["worktree", "add", "--no-checkout", "-b", info.branch, info.directory], {
-            cwd: instance.worktree,
+      cwd: Instance.worktree,
     })
     if (created.exitCode !== 0) {
       throw new CreateFailedError({ message: errorText(created) || "Failed to create git worktree" })
     }
 
-          await Project.addSandbox(instance.project.id, info.directory).catch(() => undefined)
+    await Project.addSandbox(Instance.project.id, info.directory).catch(() => undefined)
 
-          const projectID = instance.project.id
+    const projectID = Instance.project.id
     const extra = startCommand?.trim()
 
     return () => {
@@ -402,10 +380,7 @@ export namespace Worktree {
 
         const booted = await Instance.provide({
           directory: info.directory,
-                init: async () => {
+          init: InstanceBootstrap,
-                  const { InstanceBootstrap } = await import("../project/bootstrap")
-                  return InstanceBootstrap()
-                },
           fn: () => undefined,
         })
           .then(() => true)
@@ -443,13 +418,11 @@ export namespace Worktree {
         log.error("worktree start task failed", { directory: info.directory, error })
       })
     }
-        })
+  }
-      })
 
-      const createEffect = Effect.fn("Worktree.create")(function* (input?: CreateInput) {
+  export const create = fn(CreateInput.optional(), async (input) => {
-        const parsed = input ? CreateInput.optional().parse(input) : undefined
+    const info = await makeWorktreeInfo(input?.name)
-        const info = yield* makeWorktreeInfoEffect(parsed?.name)
+    const bootstrap = await createFromInfo(info, input?.startCommand)
-        const bootstrap = yield* createFromInfoEffect(info, parsed?.startCommand)
     // This is needed due to how worktrees currently work in the
     // desktop app
     setTimeout(() => {
@@ -458,14 +431,12 @@ export namespace Worktree {
     return info
   })
 
-      const removeEffect = Effect.fn("Worktree.remove")(function* (input: RemoveInput) {
+  export const remove = fn(RemoveInput, async (input) => {
-        return yield* Effect.promise(async () => {
+    if (Instance.project.vcs !== "git") {
-          const parsed = RemoveInput.parse(input)
-          if (instance.project.vcs !== "git") {
       throw new NotGitError({ message: "Worktrees are only supported for git projects" })
     }
 
-          const directory = await canonical(parsed.directory)
+    const directory = await canonical(input.directory)
     const locate = async (stdout: Uint8Array | undefined) => {
       const lines = outputText(stdout)
         .split("\n")
@@ -511,7 +482,7 @@ export namespace Worktree {
       await git(["fsmonitor--daemon", "stop"], { cwd: target })
     }
 
-          const list = await git(["worktree", "list", "--porcelain"], { cwd: instance.worktree })
+    const list = await git(["worktree", "list", "--porcelain"], { cwd: Instance.worktree })
     if (list.exitCode !== 0) {
       throw new RemoveFailedError({ message: errorText(list) || "Failed to read git worktrees" })
     }
@@ -529,10 +500,10 @@ export namespace Worktree {
 
     await stop(entry.path)
     const removed = await git(["worktree", "remove", "--force", entry.path], {
-            cwd: instance.worktree,
+      cwd: Instance.worktree,
     })
     if (removed.exitCode !== 0) {
-            const next = await git(["worktree", "list", "--porcelain"], { cwd: instance.worktree })
+      const next = await git(["worktree", "list", "--porcelain"], { cwd: Instance.worktree })
       if (next.exitCode !== 0) {
         throw new RemoveFailedError({
           message: errorText(removed) || errorText(next) || "Failed to remove git worktree",
@@ -549,7 +520,7 @@ export namespace Worktree {
 
     const branch = entry.branch?.replace(/^refs\/heads\//, "")
     if (branch) {
-            const deleted = await git(["branch", "-D", branch], { cwd: instance.worktree })
+      const deleted = await git(["branch", "-D", branch], { cwd: Instance.worktree })
       if (deleted.exitCode !== 0) {
         throw new RemoveFailedError({ message: errorText(deleted) || "Failed to delete worktree branch" })
       }
@@ -557,22 +528,19 @@ export namespace Worktree {
 
     return true
   })
-      })
 
-      const resetEffect = Effect.fn("Worktree.reset")(function* (input: ResetInput) {
+  export const reset = fn(ResetInput, async (input) => {
-        return yield* Effect.promise(async () => {
+    if (Instance.project.vcs !== "git") {
-          const parsed = ResetInput.parse(input)
-          if (instance.project.vcs !== "git") {
       throw new NotGitError({ message: "Worktrees are only supported for git projects" })
     }
 
-          const directory = await canonical(parsed.directory)
+    const directory = await canonical(input.directory)
-          const primary = await canonical(instance.worktree)
+    const primary = await canonical(Instance.worktree)
     if (directory === primary) {
       throw new ResetFailedError({ message: "Cannot reset the primary workspace" })
     }
 
-          const list = await git(["worktree", "list", "--porcelain"], { cwd: instance.worktree })
+    const list = await git(["worktree", "list", "--porcelain"], { cwd: Instance.worktree })
     if (list.exitCode !== 0) {
       throw new ResetFailedError({ message: errorText(list) || "Failed to read git worktrees" })
     }
@@ -605,7 +573,7 @@ export namespace Worktree {
       throw new ResetFailedError({ message: "Worktree not found" })
     }
 
-          const remoteList = await git(["remote"], { cwd: instance.worktree })
+    const remoteList = await git(["remote"], { cwd: Instance.worktree })
     if (remoteList.exitCode !== 0) {
       throw new ResetFailedError({ message: errorText(remoteList) || "Failed to list git remotes" })
     }
@@ -624,19 +592,18 @@ export namespace Worktree {
           : ""
 
     const remoteHead = remote
-            ? await git(["symbolic-ref", `refs/remotes/${remote}/HEAD`], { cwd: instance.worktree })
+      ? await git(["symbolic-ref", `refs/remotes/${remote}/HEAD`], { cwd: Instance.worktree })
       : { exitCode: 1, stdout: undefined, stderr: undefined }
 
     const remoteRef = remoteHead.exitCode === 0 ? outputText(remoteHead.stdout) : ""
     const remoteTarget = remoteRef ? remoteRef.replace(/^refs\/remotes\//, "") : ""
-          const remoteBranch =
+    const remoteBranch = remote && remoteTarget.startsWith(`${remote}/`) ? remoteTarget.slice(`${remote}/`.length) : ""
-            remote && remoteTarget.startsWith(`${remote}/`) ? remoteTarget.slice(`${remote}/`.length) : ""
 
     const mainCheck = await git(["show-ref", "--verify", "--quiet", "refs/heads/main"], {
-            cwd: instance.worktree,
+      cwd: Instance.worktree,
     })
     const masterCheck = await git(["show-ref", "--verify", "--quiet", "refs/heads/master"], {
-            cwd: instance.worktree,
+      cwd: Instance.worktree,
     })
     const localBranch = mainCheck.exitCode === 0 ? "main" : masterCheck.exitCode === 0 ? "master" : ""
 
@@ -646,7 +613,7 @@ export namespace Worktree {
     }
 
     if (remoteBranch) {
-            const fetch = await git(["fetch", remote, remoteBranch], { cwd: instance.worktree })
+      const fetch = await git(["fetch", remote, remoteBranch], { cwd: Instance.worktree })
       if (fetch.exitCode !== 0) {
         throw new ResetFailedError({ message: errorText(fetch) || `Failed to fetch ${target}` })
       }
@@ -660,19 +627,15 @@ export namespace Worktree {
 
     const resetToTarget = await git(["reset", "--hard", target], { cwd: worktreePath })
     if (resetToTarget.exitCode !== 0) {
-            throw new ResetFailedError({
+      throw new ResetFailedError({ message: errorText(resetToTarget) || "Failed to reset worktree to target" })
-              message: errorText(resetToTarget) || "Failed to reset worktree to target",
-            })
     }
 
-          const cleanResult = await sweep(worktreePath)
+    const clean = await sweep(worktreePath)
-          if (cleanResult.exitCode !== 0) {
+    if (clean.exitCode !== 0) {
-            throw new ResetFailedError({ message: errorText(cleanResult) || "Failed to clean worktree" })
+      throw new ResetFailedError({ message: errorText(clean) || "Failed to clean worktree" })
     }
 
-          const update = await git(["submodule", "update", "--init", "--recursive", "--force"], {
+    const update = await git(["submodule", "update", "--init", "--recursive", "--force"], { cwd: worktreePath })
-            cwd: worktreePath,
-          })
     if (update.exitCode !== 0) {
       throw new ResetFailedError({ message: errorText(update) || "Failed to update submodules" })
     }
@@ -701,58 +664,9 @@ export namespace Worktree {
       throw new ResetFailedError({ message: `Worktree reset left local changes:\n${dirty}` })
     }
 
-          const projectID = instance.project.id
+    const projectID = Instance.project.id
     queueStartScripts(worktreePath, { projectID })
 
     return true
   })
-      })
-
-      return Service.of({
-        makeWorktreeInfo: makeWorktreeInfoEffect,
-        createFromInfo: createFromInfoEffect,
-        create: createEffect,
-        remove: removeEffect,
-        reset: resetEffect,
-      })
-    }),
-  ).pipe(Layer.fresh)
-
-  async function run<A, E>(effect: Effect.Effect<A, E, Service>) {
-    const { runPromiseInstance } = await import("@/effect/runtime")
-    return runPromiseInstance(effect)
-  }
-
-  // ---------------------------------------------------------------------------
-  // Promise facades
-  // ---------------------------------------------------------------------------
-
-  export async function makeWorktreeInfo(name?: string): Promise<Info> {
-    return run(Service.use((svc) => svc.makeWorktreeInfo(name)))
-  }
-
-  export async function createFromInfo(info: Info, startCommand?: string) {
-    return run(Service.use((svc) => svc.createFromInfo(info, startCommand)))
-  }
-
-  export const create = Object.assign(
-    async (input?: CreateInput) => {
-      return run(Service.use((svc) => svc.create(input)))
-    },
-    { schema: CreateInput.optional() },
-  )
-
-  export const remove = Object.assign(
-    async (input: RemoveInput) => {
-      return run(Service.use((svc) => svc.remove(input)))
-    },
-    { schema: RemoveInput },
-  )
-
-  export const reset = Object.assign(
-    async (input: ResetInput) => {
-      return run(Service.use((svc) => svc.reset(input)))
-    },
-    { schema: ResetInput },
-  )
 }

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

@@ -16,7 +16,7 @@ const describeWatcher = FileWatcher.hasNativeBinding() && !process.env.CI ? desc
 // Helpers
 // ---------------------------------------------------------------------------
 
-type BusUpdate = { directory?: string; payload: { type: string; properties: WatcherEvent } }
+type BusUpdate = { directory?: string; payload: { type: string; properties: Record<string, unknown> } }
 type WatcherEvent = { file: string; event: "add" | "change" | "unlink" }
 
 /** Run `body` with a live FileWatcher service. */
@@ -40,18 +40,18 @@ function listen(directory: string, check: (evt: WatcherEvent) => boolean, hit: (
     if (done) return
     if (evt.directory !== directory) return
     if (evt.payload.type !== FileWatcher.Event.Updated.type) return
-    if (!check(evt.payload.properties)) return
+    const props = evt.payload.properties as WatcherEvent
-    hit(evt.payload.properties)
+    if (!check(props)) return
+    hit(props)
   }
 
-  function cleanup() {
+  GlobalBus.on("event", on)
+
+  return () => {
     if (done) return
     done = true
     GlobalBus.off("event", on)
   }
-
-  GlobalBus.on("event", on)
-  return cleanup
 }
 
 function wait(directory: string, check: (evt: WatcherEvent) => boolean) {