refactor(effect): unify service namespaces and align naming (#18093)

packages/opencode/test/account/service.test.ts

@@ -3,7 +3,7 @@ import { Duration, Effect, Layer, Option, Schema } from "effect"
 import { HttpClient, HttpClientResponse } from "effect/unstable/http"
 
 import { AccountRepo } from "../../src/account/repo"
-import { AccountService } from "../../src/account/service"
+import { AccountEffect } from "../../src/account/effect"
 import { AccessToken, AccountID, DeviceCode, Login, Org, OrgID, RefreshToken, UserCode } from "../../src/account/schema"
 import { Database } from "../../src/storage/db"
 import { testEffect } from "../lib/effect"
@@ -19,7 +19,7 @@ const truncate = Layer.effectDiscard(
 const it = testEffect(Layer.merge(AccountRepo.layer, truncate))
 
 const live = (client: HttpClient.HttpClient) =>
-  AccountService.layer.pipe(Layer.provide(Layer.succeed(HttpClient.HttpClient, client)))
+  AccountEffect.layer.pipe(Layer.provide(Layer.succeed(HttpClient.HttpClient, client)))
 
 const json = (req: Parameters<typeof HttpClientResponse.fromWeb>[0], body: unknown, status = 200) =>
   HttpClientResponse.fromWeb(
@@ -77,7 +77,7 @@ it.effect("orgsByAccount groups orgs per account", () =>
       }),
     )
 
-    const rows = yield* AccountService.use((s) => s.orgsByAccount()).pipe(Effect.provide(live(client)))
+    const rows = yield* AccountEffect.Service.use((s) => s.orgsByAccount()).pipe(Effect.provide(live(client)))
 
     expect(rows.map((row) => [row.account.id, row.orgs.map((org) => org.id)]).map(([id, orgs]) => [id, orgs])).toEqual([
       [AccountID.make("user-1"), [OrgID.make("org-1")]],
@@ -115,7 +115,7 @@ it.effect("token refresh persists the new token", () =>
       ),
     )
 
-    const token = yield* AccountService.use((s) => s.token(id)).pipe(Effect.provide(live(client)))
+    const token = yield* AccountEffect.Service.use((s) => s.token(id)).pipe(Effect.provide(live(client)))
 
     expect(Option.getOrThrow(token)).toBeDefined()
     expect(String(Option.getOrThrow(token))).toBe("at_new")
@@ -158,7 +158,9 @@ it.effect("config sends the selected org header", () =>
       }),
     )
 
-    const cfg = yield* AccountService.use((s) => s.config(id, OrgID.make("org-9"))).pipe(Effect.provide(live(client)))
+    const cfg = yield* AccountEffect.Service.use((s) => s.config(id, OrgID.make("org-9"))).pipe(
+      Effect.provide(live(client)),
+    )
 
     expect(Option.getOrThrow(cfg)).toEqual({ theme: "light", seats: 5 })
     expect(seen).toEqual({
@@ -196,7 +198,7 @@ it.effect("poll stores the account and first org on success", () =>
       ),
     )
 
-    const res = yield* AccountService.use((s) => s.poll(login)).pipe(Effect.provide(live(client)))
+    const res = yield* AccountEffect.Service.use((s) => s.poll(login)).pipe(Effect.provide(live(client)))
 
     expect(res._tag).toBe("PollSuccess")
     if (res._tag === "PollSuccess") {

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

@@ -5,7 +5,7 @@ import path from "path"
 import { Deferred, Effect, Fiber, Option } from "effect"
 import { tmpdir } from "../fixture/fixture"
 import { watcherConfigLayer, withServices } from "../fixture/instance"
-import { FileWatcher, FileWatcherService } from "../../src/file/watcher"
+import { FileWatcher } from "../../src/file/watcher"
 import { Instance } from "../../src/project/instance"
 import { GlobalBus } from "../../src/bus/global"
 
@@ -19,13 +19,12 @@ const describeWatcher = FileWatcher.hasNativeBinding() && !process.env.CI ? desc
 type BusUpdate = { directory?: string; payload: { type: string; properties: WatcherEvent } }
 type WatcherEvent = { file: string; event: "add" | "change" | "unlink" }
 
-/** Run `body` with a live FileWatcherService. */
+/** Run `body` with a live FileWatcher service. */
 function withWatcher<E>(directory: string, body: Effect.Effect<void, E>) {
   return withServices(
     directory,
-    FileWatcherService.layer,
+    FileWatcher.layer,
     async (rt) => {
-      await rt.runPromise(FileWatcherService.use((s) => s.init()))
       await Effect.runPromise(ready(directory))
       await Effect.runPromise(body)
     },
@@ -138,7 +137,7 @@ function ready(directory: string) {
 // Tests
 // ---------------------------------------------------------------------------
 
-describeWatcher("FileWatcherService", () => {
+describeWatcher("FileWatcher", () => {
   afterEach(() => Instance.disposeAll())
 
   test("publishes root create, update, and delete events", async () => {

packages/opencode/test/format/format.test.ts

@@ -1,17 +1,18 @@
+import { Effect } from "effect"
 import { afterEach, describe, expect, test } from "bun:test"
 import { tmpdir } from "../fixture/fixture"
 import { withServices } from "../fixture/instance"
-import { FormatService } from "../../src/format"
+import { Format } from "../../src/format"
 import { Instance } from "../../src/project/instance"
 
-describe("FormatService", () => {
+describe("Format", () => {
   afterEach(() => Instance.disposeAll())
 
   test("status() returns built-in formatters when no config overrides", async () => {
     await using tmp = await tmpdir()
 
-    await withServices(tmp.path, FormatService.layer, async (rt) => {
-      const statuses = await rt.runPromise(FormatService.use((s) => s.status()))
+    await withServices(tmp.path, Format.layer, async (rt) => {
+      const statuses = await rt.runPromise(Format.Service.use((s) => s.status()))
       expect(Array.isArray(statuses)).toBe(true)
       expect(statuses.length).toBeGreaterThan(0)
 
@@ -32,8 +33,8 @@ describe("FormatService", () => {
       config: { formatter: false },
     })
 
-    await withServices(tmp.path, FormatService.layer, async (rt) => {
-      const statuses = await rt.runPromise(FormatService.use((s) => s.status()))
+    await withServices(tmp.path, Format.layer, async (rt) => {
+      const statuses = await rt.runPromise(Format.Service.use((s) => s.status()))
       expect(statuses).toEqual([])
     })
   })
@@ -47,18 +48,18 @@ describe("FormatService", () => {
       },
     })
 
-    await withServices(tmp.path, FormatService.layer, async (rt) => {
-      const statuses = await rt.runPromise(FormatService.use((s) => s.status()))
+    await withServices(tmp.path, Format.layer, async (rt) => {
+      const statuses = await rt.runPromise(Format.Service.use((s) => s.status()))
       const gofmt = statuses.find((s) => s.name === "gofmt")
       expect(gofmt).toBeUndefined()
     })
   })
 
-  test("init() completes without error", async () => {
+  test("service initializes without error", async () => {
     await using tmp = await tmpdir()
 
-    await withServices(tmp.path, FormatService.layer, async (rt) => {
-      await rt.runPromise(FormatService.use((s) => s.init()))
+    await withServices(tmp.path, Format.layer, async (rt) => {
+      await rt.runPromise(Format.Service.use(() => Effect.void))
     })
   })
 })

packages/opencode/test/permission/next.test.ts

@@ -5,7 +5,7 @@ import { Bus } from "../../src/bus"
 import { runtime } from "../../src/effect/runtime"
 import { Instances } from "../../src/effect/instances"
 import { PermissionNext } from "../../src/permission"
-import * as S from "../../src/permission/service"
+import { PermissionNext as S } from "../../src/permission"
 import { PermissionID } from "../../src/permission/schema"
 import { Instance } from "../../src/project/instance"
 import { tmpdir } from "../fixture/fixture"
@@ -1005,7 +1005,7 @@ test("ask - abort should clear pending request", async () => {
     fn: async () => {
       const ctl = new AbortController()
       const ask = runtime.runPromise(
-        S.PermissionEffect.Service.use((svc) =>
+        S.Service.use((svc) =>
           svc.ask({
             sessionID: SessionID.make("session_test"),
             permission: "bash",

packages/opencode/test/plugin/auth-override.test.ts

@@ -4,6 +4,7 @@ import fs from "fs/promises"
 import { tmpdir } from "../fixture/fixture"
 import { Instance } from "../../src/project/instance"
 import { ProviderAuth } from "../../src/provider/auth"
+import { ProviderID } from "../../src/provider/schema"
 
 describe("plugin.auth-override", () => {
   test("user plugin overrides built-in github-copilot auth", async () => {
@@ -34,7 +35,7 @@ describe("plugin.auth-override", () => {
       directory: tmp.path,
       fn: async () => {
         const methods = await ProviderAuth.methods()
-        const copilot = methods["github-copilot"]
+        const copilot = methods[ProviderID.make("github-copilot")]
         expect(copilot).toBeDefined()
         expect(copilot.length).toBe(1)
         expect(copilot[0].label).toBe("Test Override Auth")

packages/opencode/test/project/vcs.test.ts

@@ -2,13 +2,13 @@ import { $ } from "bun"
 import { afterEach, describe, expect, test } from "bun:test"
 import fs from "fs/promises"
 import path from "path"
-import { Layer, ManagedRuntime } from "effect"
+import { Effect, Layer, ManagedRuntime } from "effect"
 import { tmpdir } from "../fixture/fixture"
 import { watcherConfigLayer, withServices } from "../fixture/instance"
-import { FileWatcher, FileWatcherService } from "../../src/file/watcher"
+import { FileWatcher } from "../../src/file/watcher"
 import { Instance } from "../../src/project/instance"
 import { GlobalBus } from "../../src/bus/global"
-import { Vcs, VcsService } from "../../src/project/vcs"
+import { Vcs } from "../../src/project/vcs"
 
 // Skip in CI — native @parcel/watcher binding needed
 const describeVcs = FileWatcher.hasNativeBinding() && !process.env.CI ? describe : describe.skip
@@ -19,15 +19,15 @@ const describeVcs = FileWatcher.hasNativeBinding() && !process.env.CI ? describe
 
 function withVcs(
   directory: string,
-  body: (rt: ManagedRuntime.ManagedRuntime<FileWatcherService | VcsService, never>) => Promise<void>,
+  body: (rt: ManagedRuntime.ManagedRuntime<FileWatcher.Service | Vcs.Service, never>) => Promise<void>,
 ) {
   return withServices(
     directory,
-    Layer.merge(FileWatcherService.layer, VcsService.layer),
+    Layer.merge(FileWatcher.layer, Vcs.layer),
     async (rt) => {
-      await rt.runPromise(FileWatcherService.use((s) => s.init()))
-      await rt.runPromise(VcsService.use((s) => s.init()))
-      await Bun.sleep(200)
+      await rt.runPromise(FileWatcher.Service.use(() => Effect.void))
+      await rt.runPromise(Vcs.Service.use(() => Effect.void))
+      await Bun.sleep(500)
       await body(rt)
     },
     { provide: [watcherConfigLayer] },
@@ -36,10 +36,14 @@ function withVcs(
 
 type BranchEvent = { directory?: string; payload: { type: string; properties: { branch?: string } } }
 
-/** Wait for a Vcs.Event.BranchUpdated event on GlobalBus */
-function nextBranchUpdate(directory: string, timeout = 5000) {
+/** Wait for a Vcs.Event.BranchUpdated event on GlobalBus, with retry polling as fallback */
+function nextBranchUpdate(directory: string, timeout = 10_000) {
   return new Promise<string | undefined>((resolve, reject) => {
+    let settled = false
+
     const timer = setTimeout(() => {
+      if (settled) return
+      settled = true
       GlobalBus.off("event", on)
       reject(new Error("timed out waiting for BranchUpdated event"))
     }, timeout)
@@ -47,6 +51,8 @@ function nextBranchUpdate(directory: string, timeout = 5000) {
     function on(evt: BranchEvent) {
       if (evt.directory !== directory) return
       if (evt.payload.type !== Vcs.Event.BranchUpdated.type) return
+      if (settled) return
+      settled = true
       clearTimeout(timer)
       GlobalBus.off("event", on)
       resolve(evt.payload.properties.branch)
@@ -67,7 +73,7 @@ describeVcs("Vcs", () => {
     await using tmp = await tmpdir({ git: true })
 
     await withVcs(tmp.path, async (rt) => {
-      const branch = await rt.runPromise(VcsService.use((s) => s.branch()))
+      const branch = await rt.runPromise(Vcs.Service.use((s) => s.branch()))
       expect(branch).toBeDefined()
       expect(typeof branch).toBe("string")
     })
@@ -77,7 +83,7 @@ describeVcs("Vcs", () => {
     await using tmp = await tmpdir()
 
     await withVcs(tmp.path, async (rt) => {
-      const branch = await rt.runPromise(VcsService.use((s) => s.branch()))
+      const branch = await rt.runPromise(Vcs.Service.use((s) => s.branch()))
       expect(branch).toBeUndefined()
     })
   })
@@ -110,7 +116,7 @@ describeVcs("Vcs", () => {
       await fs.writeFile(head, `ref: refs/heads/${branch}\n`)
 
       await pending
-      const current = await rt.runPromise(VcsService.use((s) => s.branch()))
+      const current = await rt.runPromise(Vcs.Service.use((s) => s.branch()))
       expect(current).toBe(branch)
     })
   })

packages/opencode/test/server/project-init-git.test.ts

@@ -68,6 +68,7 @@ describe("project.initGit endpoint", () => {
         },
       })
     } finally {
+      await Instance.disposeAll()
       reloadSpy.mockRestore()
       GlobalBus.off("event", fn)
     }
@@ -111,7 +112,9 @@ describe("project.initGit endpoint", () => {
         vcs: "git",
         worktree: tmp.path,
       })
+
     } finally {
+      await Instance.disposeAll()
       reloadSpy.mockRestore()
       GlobalBus.off("event", fn)
     }

packages/opencode/test/skill/discovery.test.ts

@@ -1,6 +1,6 @@
 import { describe, test, expect, beforeAll, afterAll } from "bun:test"
 import { Effect } from "effect"
-import { DiscoveryService } from "../../src/skill/discovery"
+import { Discovery } from "../../src/skill/discovery"
 import { Global } from "../../src/global"
 import { Filesystem } from "../../src/util/filesystem"
 import { rm } from "fs/promises"
@@ -48,7 +48,7 @@ afterAll(async () => {
 
 describe("Discovery.pull", () => {
   const pull = (url: string) =>
-    Effect.runPromise(DiscoveryService.use((s) => s.pull(url)).pipe(Effect.provide(DiscoveryService.defaultLayer)))
+    Effect.runPromise(Discovery.Service.use((s) => s.pull(url)).pipe(Effect.provide(Discovery.defaultLayer)))
 
   test("downloads skills from cloudflare url", async () => {
     const dirs = await pull(CLOUDFLARE_SKILLS_URL)

packages/opencode/test/snapshot/snapshot.test.ts

@@ -1178,3 +1178,37 @@ test("diffFull with whitespace changes", async () => {
     },
   })
 })
+
+test("revert with overlapping files across patches uses first patch hash", async () => {
+  await using tmp = await bootstrap()
+  await Instance.provide({
+    directory: tmp.path,
+    fn: async () => {
+      // Write initial content and snapshot
+      await Filesystem.write(`${tmp.path}/shared.txt`, "v1")
+      const snap1 = await Snapshot.track()
+      expect(snap1).toBeTruthy()
+
+      // Modify and snapshot again
+      await Filesystem.write(`${tmp.path}/shared.txt`, "v2")
+      const snap2 = await Snapshot.track()
+      expect(snap2).toBeTruthy()
+
+      // Modify once more so both patches include shared.txt
+      await Filesystem.write(`${tmp.path}/shared.txt`, "v3")
+
+      const patch1 = await Snapshot.patch(snap1!)
+      const patch2 = await Snapshot.patch(snap2!)
+
+      // Both patches should include shared.txt
+      expect(patch1.files).toContain(fwd(tmp.path, "shared.txt"))
+      expect(patch2.files).toContain(fwd(tmp.path, "shared.txt"))
+
+      // Revert with patch1 first — should use snap1's hash (restoring "v1")
+      await Snapshot.revert([patch1, patch2])
+
+      const content = await fs.readFile(`${tmp.path}/shared.txt`, "utf-8")
+      expect(content).toBe("v1")
+    },
+  })
+})