remove unused instance context service

packages/opencode/src/effect/instance-context.ts

@@ -1,14 +0,0 @@
-import { ServiceMap } from "effect"
-import type { Project } from "@/project/project"
-
-export declare namespace InstanceContext {
-  export interface Info {
-    readonly directory: string
-    readonly worktree: string
-    readonly project: Project.Info
-  }
-}
-
-export class InstanceContext extends ServiceMap.Service<InstanceContext, InstanceContext.Info>()(
-  "opencode/InstanceContext",
-) {}

packages/opencode/src/project/instance.ts

@@ -1,5 +1,4 @@
 import { GlobalBus } from "@/bus/global"
-import type { InstanceContext } from "@/effect/instance-context"
 import { disposeInstance } from "@/effect/instance-registry"
 import { Filesystem } from "@/util/filesystem"
 import { iife } from "@/util/iife"
@@ -8,7 +7,11 @@ import { Context } from "../util/context"
 import { Project } from "./project"
 import { State } from "./state"
 
-export type Info = InstanceContext.Info
+export interface Info {
+  directory: string
+  worktree: string
+  project: Project.Info
+}
 
 const context = Context.create<Info>("instance")
 const cache = new Map<string, Promise<Info>>()

packages/opencode/test/fixture/instance.ts

@@ -1,5 +1,4 @@
 import { ConfigProvider, Layer, ManagedRuntime } from "effect"
-import { InstanceContext } from "../../src/effect/instance-context"
 import { Instance } from "../../src/project/instance"
 
 /** ConfigProvider that enables the experimental file watcher. */
@@ -15,26 +14,18 @@ export const watcherConfigLayer = ConfigProvider.layer(
  * the ManagedRuntime. Cleanup is automatic — the runtime is disposed
  * and Instance context is torn down when `body` completes.
  *
- * Layers may depend on InstanceContext (provided automatically).
  * Pass extra layers via `options.provide` (e.g. ConfigProvider.layer).
  */
 export function withServices<S>(
   directory: string,
-  layer: Layer.Layer<S, any, InstanceContext>,
+  layer: Layer.Layer<S>,
   body: (rt: ManagedRuntime.ManagedRuntime<S, never>) => Promise<void>,
   options?: { provide?: Layer.Layer<never>[] },
 ) {
   return Instance.provide({
     directory,
     fn: async () => {
-      const ctx = Layer.sync(InstanceContext, () =>
-        InstanceContext.of({
-          directory: Instance.directory,
-          worktree: Instance.worktree,
-          project: Instance.project,
-        }),
-      )
-      let resolved: Layer.Layer<S> = layer.pipe(Layer.provide(ctx)) as any
+      let resolved: Layer.Layer<S> = layer
       if (options?.provide) {
         for (const l of options.provide) {
           resolved = resolved.pipe(Layer.provide(l)) as any