fix(ui): remove left sidebar and back/forward nav when no project

packages/app/src/components/titlebar.tsx

@@ -58,6 +58,7 @@ export function Titlebar() {
   })
 
   const path = () => `${location.pathname}${location.search}${location.hash}`
+  const home = createMemo(() => !params.dir)
   const creating = createMemo(() => {
     if (!params.dir) return false
     if (params.id) return false
@@ -175,113 +176,119 @@ export function Titlebar() {
       >
         <Show when={mac()}>
           <div class="h-full shrink-0" style={{ width: `${72 / zoom()}px` }} />
-          <div class="xl:hidden w-10 shrink-0 flex items-center justify-center">
-            <IconButton
-              icon="menu"
-              variant="ghost"
-              class="titlebar-icon rounded-md"
-              onClick={layout.mobileSidebar.toggle}
-              aria-label={language.t("sidebar.menu.toggle")}
-              aria-expanded={layout.mobileSidebar.opened()}
-            />
-          </div>
+          <Show when={!home()}>
+            <div class="xl:hidden w-10 shrink-0 flex items-center justify-center">
+              <IconButton
+                icon="menu"
+                variant="ghost"
+                class="titlebar-icon rounded-md"
+                onClick={layout.mobileSidebar.toggle}
+                aria-label={language.t("sidebar.menu.toggle")}
+                aria-expanded={layout.mobileSidebar.opened()}
+              />
+            </div>
+          </Show>
         </Show>
         <Show when={!mac()}>
-          <div class="xl:hidden w-[48px] shrink-0 flex items-center justify-center">
-            <IconButton
-              icon="menu"
-              variant="ghost"
-              class="titlebar-icon rounded-md"
-              onClick={layout.mobileSidebar.toggle}
-              aria-label={language.t("sidebar.menu.toggle")}
-              aria-expanded={layout.mobileSidebar.opened()}
-            />
-          </div>
+          <Show when={!home()}>
+            <div class="xl:hidden w-[48px] shrink-0 flex items-center justify-center">
+              <IconButton
+                icon="menu"
+                variant="ghost"
+                class="titlebar-icon rounded-md"
+                onClick={layout.mobileSidebar.toggle}
+                aria-label={language.t("sidebar.menu.toggle")}
+                aria-expanded={layout.mobileSidebar.opened()}
+              />
+            </div>
+          </Show>
         </Show>
         <div class="flex items-center gap-1 shrink-0">
-          <TooltipKeybind
-            class={web() ? "hidden xl:flex shrink-0 ml-14" : "hidden xl:flex shrink-0 ml-2"}
-            placement="bottom"
-            title={language.t("command.sidebar.toggle")}
-            keybind={command.keybind("sidebar.toggle")}
-          >
-            <Button
-              variant="ghost"
-              class="group/sidebar-toggle titlebar-icon w-8 h-6 p-0 box-border"
-              onClick={layout.sidebar.toggle}
-              aria-label={language.t("command.sidebar.toggle")}
-              aria-expanded={layout.sidebar.opened()}
+          <Show when={!home()}>
+            <TooltipKeybind
+              class={web() ? "hidden xl:flex shrink-0 ml-14" : "hidden xl:flex shrink-0 ml-2"}
+              placement="bottom"
+              title={language.t("command.sidebar.toggle")}
+              keybind={command.keybind("sidebar.toggle")}
             >
-              <Icon size="small" name={layout.sidebar.opened() ? "sidebar-active" : "sidebar"} />
-            </Button>
-          </TooltipKeybind>
-          <div class="hidden xl:flex items-center shrink-0">
-            <Show when={params.dir}>
-              <div
-                class="flex items-center shrink-0 w-8 mr-1"
-                aria-hidden={layout.sidebar.opened() ? "true" : undefined}
+              <Button
+                variant="ghost"
+                class="group/sidebar-toggle titlebar-icon w-8 h-6 p-0 box-border"
+                onClick={layout.sidebar.toggle}
+                aria-label={language.t("command.sidebar.toggle")}
+                aria-expanded={layout.sidebar.opened()}
               >
+                <Icon size="small" name={layout.sidebar.opened() ? "sidebar-active" : "sidebar"} />
+              </Button>
+            </TooltipKeybind>
+            <div class="hidden xl:flex items-center shrink-0">
+              <Show when={params.dir}>
                 <div
-                  class="transition-opacity"
-                  classList={{
-                    "opacity-100 duration-120 ease-out": !layout.sidebar.opened(),
-                    "opacity-0 duration-120 ease-in delay-0 pointer-events-none": layout.sidebar.opened(),
-                  }}
+                  class="flex items-center shrink-0 w-8 mr-1"
+                  aria-hidden={layout.sidebar.opened() ? "true" : undefined}
                 >
-                  <TooltipKeybind
-                    placement="bottom"
-                    title={language.t("command.session.new")}
-                    keybind={command.keybind("session.new")}
-                    openDelay={2000}
+                  <div
+                    class="transition-opacity"
+                    classList={{
+                      "opacity-100 duration-120 ease-out": !layout.sidebar.opened(),
+                      "opacity-0 duration-120 ease-in delay-0 pointer-events-none": layout.sidebar.opened(),
+                    }}
                   >
-                    <Button
-                      variant="ghost"
-                      icon={creating() ? "new-session-active" : "new-session"}
-                      class="titlebar-icon w-8 h-6 p-0 box-border"
-                      disabled={layout.sidebar.opened()}
-                      tabIndex={layout.sidebar.opened() ? -1 : undefined}
-                      onClick={() => {
-                        if (!params.dir) return
-                        navigate(`/${params.dir}/session`)
-                      }}
-                      aria-label={language.t("command.session.new")}
-                      aria-current={creating() ? "page" : undefined}
-                    />
-                  </TooltipKeybind>
+                    <TooltipKeybind
+                      placement="bottom"
+                      title={language.t("command.session.new")}
+                      keybind={command.keybind("session.new")}
+                      openDelay={2000}
+                    >
+                      <Button
+                        variant="ghost"
+                        icon={creating() ? "new-session-active" : "new-session"}
+                        class="titlebar-icon w-8 h-6 p-0 box-border"
+                        disabled={layout.sidebar.opened()}
+                        tabIndex={layout.sidebar.opened() ? -1 : undefined}
+                        onClick={() => {
+                          if (!params.dir) return
+                          navigate(`/${params.dir}/session`)
+                        }}
+                        aria-label={language.t("command.session.new")}
+                        aria-current={creating() ? "page" : undefined}
+                      />
+                    </TooltipKeybind>
+                  </div>
                 </div>
+              </Show>
+              <div
+                class="flex items-center gap-0 transition-transform"
+                classList={{
+                  "translate-x-0": !layout.sidebar.opened(),
+                  "-translate-x-[36px]": layout.sidebar.opened(),
+                  "duration-180 ease-out": !layout.sidebar.opened(),
+                  "duration-180 ease-in": layout.sidebar.opened(),
+                }}
+              >
+                <Tooltip placement="bottom" value={language.t("common.goBack")} openDelay={2000}>
+                  <Button
+                    variant="ghost"
+                    icon="chevron-left"
+                    class="titlebar-icon w-6 h-6 p-0 box-border"
+                    disabled={!canBack()}
+                    onClick={back}
+                    aria-label={language.t("common.goBack")}
+                  />
+                </Tooltip>
+                <Tooltip placement="bottom" value={language.t("common.goForward")} openDelay={2000}>
+                  <Button
+                    variant="ghost"
+                    icon="chevron-right"
+                    class="titlebar-icon w-6 h-6 p-0 box-border"
+                    disabled={!canForward()}
+                    onClick={forward}
+                    aria-label={language.t("common.goForward")}
+                  />
+                </Tooltip>
               </div>
-            </Show>
-            <div
-              class="flex items-center gap-0 transition-transform"
-              classList={{
-                "translate-x-0": !layout.sidebar.opened(),
-                "-translate-x-[36px]": layout.sidebar.opened(),
-                "duration-180 ease-out": !layout.sidebar.opened(),
-                "duration-180 ease-in": layout.sidebar.opened(),
-              }}
-            >
-              <Tooltip placement="bottom" value={language.t("common.goBack")} openDelay={2000}>
-                <Button
-                  variant="ghost"
-                  icon="chevron-left"
-                  class="titlebar-icon w-6 h-6 p-0 box-border"
-                  disabled={!canBack()}
-                  onClick={back}
-                  aria-label={language.t("common.goBack")}
-                />
-              </Tooltip>
-              <Tooltip placement="bottom" value={language.t("common.goForward")} openDelay={2000}>
-                <Button
-                  variant="ghost"
-                  icon="chevron-right"
-                  class="titlebar-icon w-6 h-6 p-0 box-border"
-                  disabled={!canForward()}
-                  onClick={forward}
-                  aria-label={language.t("common.goForward")}
-                />
-              </Tooltip>
             </div>
-          </div>
+          </Show>
         </div>
         <div id="opencode-titlebar-left" class="flex items-center gap-3 min-w-0 px-2" />
       </div>

packages/app/src/pages/layout.tsx

@@ -111,6 +111,7 @@ export default function Layout(props: ParentProps) {
   let scrollContainerRef: HTMLDivElement | undefined
 
   const params = useParams()
+  const home = createMemo(() => !params.dir)
   const globalSDK = useGlobalSDK()
   const globalSync = useGlobalSync()
   const layout = useLayout()
@@ -2241,7 +2242,7 @@ export default function Layout(props: ParentProps) {
   const sidebarContent = (mobile?: boolean) => (
     <SidebarContent
       mobile={mobile}
-      opened={() => layout.sidebar.opened()}
+      opened={() => (home() ? false : layout.sidebar.opened())}
       aimMove={aim.move}
       projects={projects}
       renderProject={(project) => (
@@ -2285,7 +2286,7 @@ export default function Layout(props: ParentProps) {
                 "absolute inset-y-0 left-0": true,
                 "z-10": true,
               }}
-              style={{ width: `${Math.max(layout.sidebar.width(), 244)}px` }}
+              style={{ width: home() ? "4rem" : `${Math.max(layout.sidebar.width(), 244)}px` }}
               ref={(el) => {
                 setState("nav", el)
               }}
@@ -2294,13 +2295,14 @@ export default function Layout(props: ParentProps) {
               }}
               onMouseLeave={() => {
                 aim.reset()
+                if (home()) return
                 if (!sidebarHovering()) return
 
                 arm()
               }}
             >
               <div class="@container w-full h-full contain-strict">{sidebarContent()}</div>
-              <Show when={layout.sidebar.opened()}>
+              <Show when={!home() && layout.sidebar.opened()}>
                 <div onPointerDown={() => setState("sizing", true)}>
                   <ResizeHandle
                     direction="horizontal"
@@ -2325,46 +2327,54 @@ export default function Layout(props: ParentProps) {
               style={{ left: "calc(4rem + 12px)" }}
             />
 
-            <div class="xl:hidden">
-              <div
-                classList={{
-                  "fixed inset-x-0 top-10 bottom-0 z-40 transition-opacity duration-200": true,
-                  "opacity-100 pointer-events-auto": layout.mobileSidebar.opened(),
-                  "opacity-0 pointer-events-none": !layout.mobileSidebar.opened(),
-                }}
-                onClick={(e) => {
-                  if (e.target === e.currentTarget) layout.mobileSidebar.hide()
-                }}
-              />
-              <nav
-                aria-label={language.t("sidebar.nav.projectsAndSessions")}
-                data-component="sidebar-nav-mobile"
-                classList={{
-                  "@container fixed top-10 bottom-0 left-0 z-50 w-full max-w-[400px] overflow-hidden border-r border-border-weaker-base bg-background-base transition-transform duration-200 ease-out": true,
-                  "translate-x-0": layout.mobileSidebar.opened(),
-                  "-translate-x-full": !layout.mobileSidebar.opened(),
-                }}
-                onClick={(e) => e.stopPropagation()}
-              >
-                {sidebarContent(true)}
-              </nav>
-            </div>
+            <Show when={!home()}>
+              <div class="xl:hidden">
+                <div
+                  classList={{
+                    "fixed inset-x-0 top-10 bottom-0 z-40 transition-opacity duration-200": true,
+                    "opacity-100 pointer-events-auto": layout.mobileSidebar.opened(),
+                    "opacity-0 pointer-events-none": !layout.mobileSidebar.opened(),
+                  }}
+                  onClick={(e) => {
+                    if (e.target === e.currentTarget) layout.mobileSidebar.hide()
+                  }}
+                />
+                <nav
+                  aria-label={language.t("sidebar.nav.projectsAndSessions")}
+                  data-component="sidebar-nav-mobile"
+                  classList={{
+                    "@container fixed top-10 bottom-0 left-0 z-50 w-full max-w-[400px] overflow-hidden border-r border-border-weaker-base bg-background-base transition-transform duration-200 ease-out": true,
+                    "translate-x-0": layout.mobileSidebar.opened(),
+                    "-translate-x-full": !layout.mobileSidebar.opened(),
+                  }}
+                  onClick={(e) => e.stopPropagation()}
+                >
+                  {sidebarContent(true)}
+                </nav>
+              </div>
+            </Show>
 
             <div
               classList={{
                 "absolute inset-0": true,
-                "xl:inset-y-0 xl:right-0 xl:left-[var(--main-left)]": true,
+                "xl:inset-y-0 xl:right-0": true,
+                "xl:left-[var(--main-left)]": true,
                 "z-20": true,
                 "transition-[left] duration-200 ease-[cubic-bezier(0.22,1,0.36,1)] will-change-[left] motion-reduce:transition-none":
                   !state.sizing,
               }}
               style={{
-                "--main-left": layout.sidebar.opened() ? `${Math.max(layout.sidebar.width(), 244)}px` : "4rem",
+                "--main-left": home()
+                  ? "4rem"
+                  : layout.sidebar.opened()
+                    ? `${Math.max(layout.sidebar.width(), 244)}px`
+                    : "4rem",
               }}
             >
               <main
                 classList={{
-                  "size-full overflow-x-hidden flex flex-col items-start contain-strict border-t border-border-weak-base bg-background-base xl:border-l xl:rounded-tl-[12px]": true,
+                  "size-full overflow-x-hidden flex flex-col items-start contain-strict border-t border-border-weak-base bg-background-base": true,
+                  "xl:border-l xl:rounded-tl-[12px]": true,
                 }}
               >
                 <Show when={!autoselecting()} fallback={<div class="size-full" />}>
@@ -2373,43 +2383,47 @@ export default function Layout(props: ParentProps) {
               </main>
             </div>
 
-            <div
-              classList={{
-                "hidden xl:flex absolute inset-y-0 left-16 z-30": true,
-                "opacity-100 translate-x-0 pointer-events-auto": state.peeked && !layout.sidebar.opened(),
-                "opacity-0 -translate-x-2 pointer-events-none": !state.peeked || layout.sidebar.opened(),
-                "transition-[opacity,transform] motion-reduce:transition-none": true,
-                "duration-180 ease-out": state.peeked && !layout.sidebar.opened(),
-                "duration-120 ease-in": !state.peeked || layout.sidebar.opened(),
-              }}
-              onMouseMove={disarm}
-              onMouseEnter={() => {
-                disarm()
-                aim.reset()
-              }}
-              onPointerDown={disarm}
-              onMouseLeave={() => {
-                arm()
-              }}
-            >
-              <Show when={peekProject()}>
-                <SidebarPanel project={peekProject} merged={false} />
-              </Show>
-            </div>
+            <Show when={!home()}>
+              <div
+                classList={{
+                  "hidden xl:flex absolute inset-y-0 left-16 z-30": true,
+                  "opacity-100 translate-x-0 pointer-events-auto": state.peeked && !layout.sidebar.opened(),
+                  "opacity-0 -translate-x-2 pointer-events-none": !state.peeked || layout.sidebar.opened(),
+                  "transition-[opacity,transform] motion-reduce:transition-none": true,
+                  "duration-180 ease-out": state.peeked && !layout.sidebar.opened(),
+                  "duration-120 ease-in": !state.peeked || layout.sidebar.opened(),
+                }}
+                onMouseMove={disarm}
+                onMouseEnter={() => {
+                  disarm()
+                  aim.reset()
+                }}
+                onPointerDown={disarm}
+                onMouseLeave={() => {
+                  arm()
+                }}
+              >
+                <Show when={peekProject()}>
+                  <SidebarPanel project={peekProject} merged={false} />
+                </Show>
+              </div>
+            </Show>
 
-            <div
-              classList={{
-                "hidden xl:block pointer-events-none absolute inset-y-0 right-0 z-25 overflow-hidden": true,
-                "opacity-100 translate-x-0": state.peeked && !layout.sidebar.opened(),
-                "opacity-0 -translate-x-2": !state.peeked || layout.sidebar.opened(),
-                "transition-[opacity,transform] motion-reduce:transition-none": true,
-                "duration-180 ease-out": state.peeked && !layout.sidebar.opened(),
-                "duration-120 ease-in": !state.peeked || layout.sidebar.opened(),
-              }}
-              style={{ left: `calc(4rem + ${Math.max(Math.max(layout.sidebar.width(), 244) - 64, 0)}px)` }}
-            >
-              <div class="h-full w-px" style={{ "box-shadow": "var(--shadow-sidebar-overlay)" }} />
-            </div>
+            <Show when={!home()}>
+              <div
+                classList={{
+                  "hidden xl:block pointer-events-none absolute inset-y-0 right-0 z-25 overflow-hidden": true,
+                  "opacity-100 translate-x-0": state.peeked && !layout.sidebar.opened(),
+                  "opacity-0 -translate-x-2": !state.peeked || layout.sidebar.opened(),
+                  "transition-[opacity,transform] motion-reduce:transition-none": true,
+                  "duration-180 ease-out": state.peeked && !layout.sidebar.opened(),
+                  "duration-120 ease-in": !state.peeked || layout.sidebar.opened(),
+                }}
+                style={{ left: `calc(4rem + ${Math.max(Math.max(layout.sidebar.width(), 244) - 64, 0)}px)` }}
+              >
+                <div class="h-full w-px" style={{ "box-shadow": "var(--shadow-sidebar-overlay)" }} />
+              </div>
+            </Show>
           </div>
         </div>
         {import.meta.env.DEV && <DebugBar />}

packages/opencode/AGENTS.md

@@ -34,7 +34,6 @@ Instructions to follow when writing Effect.
 - Use `Effect.gen(function* () { ... })` for composition.
 - Use `Effect.fn("ServiceName.method")` for named/traced effects and `Effect.fnUntraced` for internal helpers.
 - `Effect.fn` / `Effect.fnUntraced` accept pipeable operators as extra arguments, so avoid unnecessary `flow` or outer `.pipe()` wrappers.
-- **`Effect.callback`** (not `Effect.async`) for callback-based APIs. The classic `Effect.async` was renamed to `Effect.callback` in effect-smol/v4.
 
 ## Time
 
@@ -43,37 +42,3 @@ Instructions to follow when writing Effect.
 ## Errors
 
 - In `Effect.gen/fn`, prefer `yield* new MyError(...)` over `yield* Effect.fail(new MyError(...))` for direct early-failure branches.
-
-## Instance-scoped Effect services
-
-Services that need per-directory lifecycle (created/destroyed per instance) go through the `Instances` LayerMap:
-
-1. Define a `ServiceMap.Service` with a `static readonly layer` (see `FileWatcherService`, `QuestionService`, `PermissionService`, `ProviderAuthService`).
-2. Add it to `InstanceServices` union and `Layer.mergeAll(...)` in `src/effect/instances.ts`.
-3. Use `InstanceContext` inside the layer to read `directory` and `project` instead of `Instance.*` globals.
-4. Call from legacy code via `runPromiseInstance(MyService.use((s) => s.method()))`.
-
-### Instance.bind — ALS context for native callbacks
-
-`Instance.bind(fn)` captures the current Instance AsyncLocalStorage context and returns a wrapper that restores it synchronously when called.
-
-**Use it** when passing callbacks to native C/C++ addons (`@parcel/watcher`, `node-pty`, native `fs.watch`, etc.) that need to call `Bus.publish`, `Instance.state()`, or anything that reads `Instance.directory`.
-
-**Don't need it** for `setTimeout`, `Promise.then`, `EventEmitter.on`, or Effect fibers — Node.js ALS propagates through those automatically.
-
-```typescript
-// Native addon callback — needs Instance.bind
-const cb = Instance.bind((err, evts) => {
-  Bus.publish(MyEvent, { ... })
-})
-nativeAddon.subscribe(dir, cb)
-```
-
-## Flag → Effect.Config migration
-
-Flags in `src/flag/flag.ts` are being migrated from static `truthy(...)` reads to `Config.boolean(...).pipe(Config.withDefault(false))` as their consumers get effectified.
-
-- Effectful flags return `Config<boolean>` and are read with `yield*` inside `Effect.gen`.
-- The default `ConfigProvider` reads from `process.env`, so env vars keep working.
-- Tests can override via `ConfigProvider.layer(ConfigProvider.fromUnknown({ ... }))`.
-- Keep all flags in `flag.ts` as the single registry — just change the implementation from `truthy()` to `Config.boolean()` when the consumer moves to Effect.

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

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

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

@@ -1,12 +0,0 @@
-const disposers = new Set<(directory: string) => Promise<void>>()
-
-export function registerDisposer(disposer: (directory: string) => Promise<void>) {
-  disposers.add(disposer)
-  return () => {
-    disposers.delete(disposer)
-  }
-}
-
-export async function disposeInstance(directory: string) {
-  await Promise.allSettled([...disposers].map((disposer) => disposer(directory)))
-}

packages/opencode/src/effect/instances.ts

@@ -1,64 +0,0 @@
-import { Effect, Layer, LayerMap, ServiceMap } from "effect"
-import { registerDisposer } from "./instance-registry"
-import { InstanceContext } from "./instance-context"
-import { ProviderAuthService } from "@/provider/auth-service"
-import { QuestionService } from "@/question/service"
-import { PermissionService } from "@/permission/service"
-import { FileWatcherService } from "@/file/watcher"
-import { VcsService } from "@/project/vcs"
-import { FileTimeService } from "@/file/time"
-import { FormatService } from "@/format"
-import { FileService } from "@/file"
-import { SkillService } from "@/skill/skill"
-import { Instance } from "@/project/instance"
-
-export { InstanceContext } from "./instance-context"
-
-export type InstanceServices =
-  | QuestionService
-  | PermissionService
-  | ProviderAuthService
-  | FileWatcherService
-  | VcsService
-  | FileTimeService
-  | FormatService
-  | FileService
-  | SkillService
-
-function lookup(directory: string) {
-  const project = Instance.project
-  const ctx = Layer.sync(InstanceContext, () => InstanceContext.of({ directory, project }))
-  return Layer.mergeAll(
-    Layer.fresh(QuestionService.layer),
-    Layer.fresh(PermissionService.layer),
-    Layer.fresh(ProviderAuthService.layer),
-    Layer.fresh(FileWatcherService.layer).pipe(Layer.orDie),
-    Layer.fresh(VcsService.layer),
-    Layer.fresh(FileTimeService.layer).pipe(Layer.orDie),
-    Layer.fresh(FormatService.layer),
-    Layer.fresh(FileService.layer),
-    Layer.fresh(SkillService.layer),
-  ).pipe(Layer.provide(ctx))
-}
-
-export class Instances extends ServiceMap.Service<Instances, LayerMap.LayerMap<string, InstanceServices>>()(
-  "opencode/Instances",
-) {
-  static readonly layer = Layer.effect(
-    Instances,
-    Effect.gen(function* () {
-      const layerMap = yield* LayerMap.make(lookup, { idleTimeToLive: Infinity })
-      const unregister = registerDisposer((directory) => Effect.runPromise(layerMap.invalidate(directory)))
-      yield* Effect.addFinalizer(() => Effect.sync(unregister))
-      return Instances.of(layerMap)
-    }),
-  )
-
-  static get(directory: string): Layer.Layer<InstanceServices, never, Instances> {
-    return Layer.unwrap(Instances.use((map) => Effect.succeed(map.get(directory))))
-  }
-
-  static invalidate(directory: string): Effect.Effect<void, never, Instances> {
-    return Instances.use((map) => map.invalidate(directory))
-  }
-}

packages/opencode/src/effect/runtime.ts

@@ -1,14 +1,9 @@
-import { Effect, Layer, ManagedRuntime } from "effect"
+import { Layer, ManagedRuntime } from "effect"
 import { AccountService } from "@/account/service"
 import { AuthService } from "@/auth/service"
-import { Instances } from "@/effect/instances"
-import type { InstanceServices } from "@/effect/instances"
-import { Instance } from "@/project/instance"
+import { PermissionService } from "@/permission/service"
+import { QuestionService } from "@/question/service"
 
 export const runtime = ManagedRuntime.make(
-  Layer.mergeAll(AccountService.defaultLayer, Instances.layer).pipe(Layer.provideMerge(AuthService.defaultLayer)),
+  Layer.mergeAll(AccountService.defaultLayer, AuthService.defaultLayer, PermissionService.layer, QuestionService.layer),
 )
-
-export function runPromiseInstance<A, E>(effect: Effect.Effect<A, E, InstanceServices>) {
-  return runtime.runPromise(effect.pipe(Effect.provide(Instances.get(Instance.directory))))
-}

packages/opencode/src/file/time.ts

@@ -1,115 +1,71 @@
+import { Instance } from "../project/instance"
 import { Log } from "../util/log"
-import { Flag } from "@/flag/flag"
+import { Flag } from "../flag/flag"
 import { Filesystem } from "../util/filesystem"
-import { Effect, Layer, ServiceMap, Semaphore } from "effect"
-import { runPromiseInstance } from "@/effect/runtime"
-import type { SessionID } from "@/session/schema"
-
-const log = Log.create({ service: "file.time" })
-
-export namespace FileTimeService {
-  export interface Service {
-    readonly read: (sessionID: SessionID, file: string) => Effect.Effect<void>
-    readonly get: (sessionID: SessionID, file: string) => Effect.Effect<Date | undefined>
-    readonly assert: (sessionID: SessionID, filepath: string) => Effect.Effect<void>
-    readonly withLock: <T>(filepath: string, fn: () => Promise<T>) => Effect.Effect<T>
-  }
-}
-
-type Stamp = {
-  readonly read: Date
-  readonly mtime: number | undefined
-  readonly ctime: number | undefined
-  readonly size: number | undefined
-}
-
-function stamp(file: string): Stamp {
-  const stat = Filesystem.stat(file)
-  const size = typeof stat?.size === "bigint" ? Number(stat.size) : stat?.size
-  return {
-    read: new Date(),
-    mtime: stat?.mtime?.getTime(),
-    ctime: stat?.ctime?.getTime(),
-    size,
-  }
-}
-
-function session(reads: Map<SessionID, Map<string, Stamp>>, sessionID: SessionID) {
-  let value = reads.get(sessionID)
-  if (!value) {
-    value = new Map<string, Stamp>()
-    reads.set(sessionID, value)
-  }
-  return value
-}
-
-export class FileTimeService extends ServiceMap.Service<FileTimeService, FileTimeService.Service>()(
-  "@opencode/FileTime",
-) {
-  static readonly layer = Layer.effect(
-    FileTimeService,
-    Effect.gen(function* () {
-      const disableCheck = yield* Flag.OPENCODE_DISABLE_FILETIME_CHECK
-      const reads = new Map<SessionID, Map<string, Stamp>>()
-      const locks = new Map<string, Semaphore.Semaphore>()
-
-      function getLock(filepath: string) {
-        let lock = locks.get(filepath)
-        if (!lock) {
-          lock = Semaphore.makeUnsafe(1)
-          locks.set(filepath, lock)
-        }
-        return lock
-      }
-
-      return FileTimeService.of({
-        read: Effect.fn("FileTimeService.read")(function* (sessionID: SessionID, file: string) {
-          log.info("read", { sessionID, file })
-          session(reads, sessionID).set(file, stamp(file))
-        }),
-
-        get: Effect.fn("FileTimeService.get")(function* (sessionID: SessionID, file: string) {
-          return reads.get(sessionID)?.get(file)?.read
-        }),
-
-        assert: Effect.fn("FileTimeService.assert")(function* (sessionID: SessionID, filepath: string) {
-          if (disableCheck) return
-
-          const time = reads.get(sessionID)?.get(filepath)
-          if (!time) throw new Error(`You must read file ${filepath} before overwriting it. Use the Read tool first`)
-          const next = stamp(filepath)
-          const changed = next.mtime !== time.mtime || next.ctime !== time.ctime || next.size !== time.size
-
-          if (changed) {
-            throw new Error(
-              `File ${filepath} has been modified since it was last read.\nLast modification: ${new Date(next.mtime ?? next.read.getTime()).toISOString()}\nLast read: ${time.read.toISOString()}\n\nPlease read the file again before modifying it.`,
-            )
-          }
-        }),
-
-        withLock: Effect.fn("FileTimeService.withLock")(function* <T>(filepath: string, fn: () => Promise<T>) {
-          const lock = getLock(filepath)
-          return yield* Effect.promise(fn).pipe(lock.withPermits(1))
-        }),
-      })
-    }),
-  )
-}
 
 export namespace FileTime {
-  export function read(sessionID: SessionID, file: string) {
-    return runPromiseInstance(FileTimeService.use((s) => s.read(sessionID, file)))
+  const log = Log.create({ service: "file.time" })
+  // Per-session read times plus per-file write locks.
+  // All tools that overwrite existing files should run their
+  // assert/read/write/update sequence inside withLock(filepath, ...)
+  // so concurrent writes to the same file are serialized.
+  export const state = Instance.state(() => {
+    const read: {
+      [sessionID: string]: {
+        [path: string]: Date | undefined
+      }
+    } = {}
+    const locks = new Map<string, Promise<void>>()
+    return {
+      read,
+      locks,
+    }
+  })
+
+  export function read(sessionID: string, file: string) {
+    log.info("read", { sessionID, file })
+    const { read } = state()
+    read[sessionID] = read[sessionID] || {}
+    read[sessionID][file] = new Date()
   }
 
-  export function get(sessionID: SessionID, file: string) {
-    return runPromiseInstance(FileTimeService.use((s) => s.get(sessionID, file)))
-  }
-
-  export async function assert(sessionID: SessionID, filepath: string) {
-    return runPromiseInstance(FileTimeService.use((s) => s.assert(sessionID, filepath)))
+  export function get(sessionID: string, file: string) {
+    return state().read[sessionID]?.[file]
   }
 
   export async function withLock<T>(filepath: string, fn: () => Promise<T>): Promise<T> {
-    return runPromiseInstance(FileTimeService.use((s) => s.withLock(filepath, fn)))
+    const current = state()
+    const currentLock = current.locks.get(filepath) ?? Promise.resolve()
+    let release: () => void = () => {}
+    const nextLock = new Promise<void>((resolve) => {
+      release = resolve
+    })
+    const chained = currentLock.then(() => nextLock)
+    current.locks.set(filepath, chained)
+    await currentLock
+    try {
+      return await fn()
+    } finally {
+      release()
+      if (current.locks.get(filepath) === chained) {
+        current.locks.delete(filepath)
+      }
+    }
+  }
+
+  export async function assert(sessionID: string, filepath: string) {
+    if (Flag.OPENCODE_DISABLE_FILETIME_CHECK === true) {
+      return
+    }
+
+    const time = get(sessionID, filepath)
+    if (!time) throw new Error(`You must read file ${filepath} before overwriting it. Use the Read tool first`)
+    const mtime = Filesystem.stat(filepath)?.mtime
+    // Allow a 50ms tolerance for Windows NTFS timestamp fuzziness / async flushing
+    if (mtime && mtime.getTime() > time.getTime() + 50) {
+      throw new Error(
+        `File ${filepath} has been modified since it was last read.\nLast modification: ${mtime.toISOString()}\nLast read: ${time.toISOString()}\n\nPlease read the file again before modifying it.`,
+      )
+    }
   }
 }

packages/opencode/src/file/watcher.ts

@@ -1,8 +1,7 @@
 import { BusEvent } from "@/bus/bus-event"
 import { Bus } from "@/bus"
-import { InstanceContext } from "@/effect/instance-context"
-import { Instance } from "@/project/instance"
 import z from "zod"
+import { Instance } from "../project/instance"
 import { Log } from "../util/log"
 import { FileIgnore } from "./ignore"
 import { Config } from "../config/config"
@@ -10,139 +9,118 @@ import path from "path"
 // @ts-ignore
 import { createWrapper } from "@parcel/watcher/wrapper"
 import { lazy } from "@/util/lazy"
+import { withTimeout } from "@/util/timeout"
 import type ParcelWatcher from "@parcel/watcher"
+import { Flag } from "@/flag/flag"
 import { readdir } from "fs/promises"
 import { git } from "@/util/git"
 import { Protected } from "./protected"
-import { Flag } from "@/flag/flag"
-import { Cause, Effect, Layer, ServiceMap } from "effect"
 
 const SUBSCRIBE_TIMEOUT_MS = 10_000
 
 declare const OPENCODE_LIBC: string | undefined
 
-const log = Log.create({ service: "file.watcher" })
-
-const event = {
-  Updated: BusEvent.define(
-    "file.watcher.updated",
-    z.object({
-      file: z.string(),
-      event: z.union([z.literal("add"), z.literal("change"), z.literal("unlink")]),
-    }),
-  ),
-}
-
-const watcher = lazy((): typeof import("@parcel/watcher") | undefined => {
-  try {
-    const binding = require(
-      `@parcel/watcher-${process.platform}-${process.arch}${process.platform === "linux" ? `-${OPENCODE_LIBC || "glibc"}` : ""}`,
-    )
-    return createWrapper(binding) as typeof import("@parcel/watcher")
-  } catch (error) {
-    log.error("failed to load watcher binding", { error })
-    return
-  }
-})
-
-function getBackend() {
-  if (process.platform === "win32") return "windows"
-  if (process.platform === "darwin") return "fs-events"
-  if (process.platform === "linux") return "inotify"
-}
-
 export namespace FileWatcher {
-  export const Event = event
-  /** Whether the native @parcel/watcher binding is available on this platform. */
-  export const hasNativeBinding = () => !!watcher()
-}
+  const log = Log.create({ service: "file.watcher" })
 
-const init = Effect.fn("FileWatcherService.init")(function* () {})
-
-export namespace FileWatcherService {
-  export interface Service {
-    readonly init: () => Effect.Effect<void>
-  }
-}
-
-export class FileWatcherService extends ServiceMap.Service<FileWatcherService, FileWatcherService.Service>()(
-  "@opencode/FileWatcher",
-) {
-  static readonly layer = Layer.effect(
-    FileWatcherService,
-    Effect.gen(function* () {
-      const instance = yield* InstanceContext
-      if (yield* Flag.OPENCODE_EXPERIMENTAL_DISABLE_FILEWATCHER) return FileWatcherService.of({ init })
-
-      log.info("init", { directory: instance.directory })
-
-      const backend = getBackend()
-      if (!backend) {
-        log.error("watcher backend not supported", { directory: instance.directory, platform: process.platform })
-        return FileWatcherService.of({ init })
-      }
-
-      const w = watcher()
-      if (!w) return FileWatcherService.of({ init })
-
-      log.info("watcher backend", { directory: instance.directory, platform: process.platform, backend })
-
-      const subs: ParcelWatcher.AsyncSubscription[] = []
-      yield* Effect.addFinalizer(() => Effect.promise(() => Promise.allSettled(subs.map((sub) => sub.unsubscribe()))))
-
-      const cb: ParcelWatcher.SubscribeCallback = Instance.bind((err, evts) => {
-        if (err) return
-        for (const evt of evts) {
-          if (evt.type === "create") Bus.publish(event.Updated, { file: evt.path, event: "add" })
-          if (evt.type === "update") Bus.publish(event.Updated, { file: evt.path, event: "change" })
-          if (evt.type === "delete") Bus.publish(event.Updated, { file: evt.path, event: "unlink" })
-        }
-      })
-
-      const subscribe = (dir: string, ignore: string[]) => {
-        const pending = w.subscribe(dir, cb, { ignore, backend })
-        return Effect.gen(function* () {
-          const sub = yield* Effect.promise(() => pending)
-          subs.push(sub)
-        }).pipe(
-          Effect.timeout(SUBSCRIBE_TIMEOUT_MS),
-          Effect.catchCause((cause) => {
-            log.error("failed to subscribe", { dir, cause: Cause.pretty(cause) })
-            // Clean up a subscription that resolves after timeout
-            pending.then((s) => s.unsubscribe()).catch(() => {})
-            return Effect.void
-          }),
-        )
-      }
-
-      const cfg = yield* Effect.promise(() => Config.get())
-      const cfgIgnores = cfg.watcher?.ignore ?? []
-
-      if (yield* Flag.OPENCODE_EXPERIMENTAL_FILEWATCHER) {
-        yield* subscribe(instance.directory, [...FileIgnore.PATTERNS, ...cfgIgnores, ...Protected.paths()])
-      }
-
-      if (instance.project.vcs === "git") {
-        const result = yield* Effect.promise(() =>
-          git(["rev-parse", "--git-dir"], {
-            cwd: instance.project.worktree,
-          }),
-        )
-        const vcsDir = result.exitCode === 0 ? path.resolve(instance.project.worktree, result.text().trim()) : undefined
-        if (vcsDir && !cfgIgnores.includes(".git") && !cfgIgnores.includes(vcsDir)) {
-          const ignore = (yield* Effect.promise(() => readdir(vcsDir).catch(() => []))).filter(
-            (entry) => entry !== "HEAD",
-          )
-          yield* subscribe(vcsDir, ignore)
-        }
-      }
-
-      return FileWatcherService.of({ init })
-    }).pipe(
-      Effect.catchCause((cause) => {
-        log.error("failed to init watcher service", { cause: Cause.pretty(cause) })
-        return Effect.succeed(FileWatcherService.of({ init }))
+  export const Event = {
+    Updated: BusEvent.define(
+      "file.watcher.updated",
+      z.object({
+        file: z.string(),
+        event: z.union([z.literal("add"), z.literal("change"), z.literal("unlink")]),
       }),
     ),
+  }
+
+  const watcher = lazy((): typeof import("@parcel/watcher") | undefined => {
+    try {
+      const binding = require(
+        `@parcel/watcher-${process.platform}-${process.arch}${process.platform === "linux" ? `-${OPENCODE_LIBC || "glibc"}` : ""}`,
+      )
+      return createWrapper(binding) as typeof import("@parcel/watcher")
+    } catch (error) {
+      log.error("failed to load watcher binding", { error })
+      return
+    }
+  })
+
+  const state = Instance.state(
+    async () => {
+      log.info("init")
+      const cfg = await Config.get()
+      const backend = (() => {
+        if (process.platform === "win32") return "windows"
+        if (process.platform === "darwin") return "fs-events"
+        if (process.platform === "linux") return "inotify"
+      })()
+      if (!backend) {
+        log.error("watcher backend not supported", { platform: process.platform })
+        return {}
+      }
+      log.info("watcher backend", { platform: process.platform, backend })
+
+      const w = watcher()
+      if (!w) return {}
+
+      const subscribe: ParcelWatcher.SubscribeCallback = (err, evts) => {
+        if (err) return
+        for (const evt of evts) {
+          if (evt.type === "create") Bus.publish(Event.Updated, { file: evt.path, event: "add" })
+          if (evt.type === "update") Bus.publish(Event.Updated, { file: evt.path, event: "change" })
+          if (evt.type === "delete") Bus.publish(Event.Updated, { file: evt.path, event: "unlink" })
+        }
+      }
+
+      const subs: ParcelWatcher.AsyncSubscription[] = []
+      const cfgIgnores = cfg.watcher?.ignore ?? []
+
+      if (Flag.OPENCODE_EXPERIMENTAL_FILEWATCHER) {
+        const pending = w.subscribe(Instance.directory, subscribe, {
+          ignore: [...FileIgnore.PATTERNS, ...cfgIgnores, ...Protected.paths()],
+          backend,
+        })
+        const sub = await withTimeout(pending, SUBSCRIBE_TIMEOUT_MS).catch((err) => {
+          log.error("failed to subscribe to Instance.directory", { error: err })
+          pending.then((s) => s.unsubscribe()).catch(() => {})
+          return undefined
+        })
+        if (sub) subs.push(sub)
+      }
+
+      if (Instance.project.vcs === "git") {
+        const result = await git(["rev-parse", "--git-dir"], {
+          cwd: Instance.worktree,
+        })
+        const vcsDir = result.exitCode === 0 ? path.resolve(Instance.worktree, result.text().trim()) : undefined
+        if (vcsDir && !cfgIgnores.includes(".git") && !cfgIgnores.includes(vcsDir)) {
+          const gitDirContents = await readdir(vcsDir).catch(() => [])
+          const ignoreList = gitDirContents.filter((entry) => entry !== "HEAD")
+          const pending = w.subscribe(vcsDir, subscribe, {
+            ignore: ignoreList,
+            backend,
+          })
+          const sub = await withTimeout(pending, SUBSCRIBE_TIMEOUT_MS).catch((err) => {
+            log.error("failed to subscribe to vcsDir", { error: err })
+            pending.then((s) => s.unsubscribe()).catch(() => {})
+            return undefined
+          })
+          if (sub) subs.push(sub)
+        }
+      }
+
+      return { subs }
+    },
+    async (state) => {
+      if (!state.subs) return
+      await Promise.all(state.subs.map((sub) => sub?.unsubscribe()))
+    },
   )
+
+  export function init() {
+    if (Flag.OPENCODE_EXPERIMENTAL_DISABLE_FILEWATCHER) {
+      return
+    }
+    state()
+  }
 }

packages/opencode/src/flag/flag.ts

@@ -1,5 +1,3 @@
-import { Config } from "effect"
-
 function truthy(key: string) {
   const value = process.env[key]?.toLowerCase()
   return value === "true" || value === "1"
@@ -42,12 +40,8 @@ export namespace Flag {
 
   // Experimental
   export const OPENCODE_EXPERIMENTAL = truthy("OPENCODE_EXPERIMENTAL")
-  export const OPENCODE_EXPERIMENTAL_FILEWATCHER = Config.boolean("OPENCODE_EXPERIMENTAL_FILEWATCHER").pipe(
-    Config.withDefault(false),
-  )
-  export const OPENCODE_EXPERIMENTAL_DISABLE_FILEWATCHER = Config.boolean(
-    "OPENCODE_EXPERIMENTAL_DISABLE_FILEWATCHER",
-  ).pipe(Config.withDefault(false))
+  export const OPENCODE_EXPERIMENTAL_FILEWATCHER = truthy("OPENCODE_EXPERIMENTAL_FILEWATCHER")
+  export const OPENCODE_EXPERIMENTAL_DISABLE_FILEWATCHER = truthy("OPENCODE_EXPERIMENTAL_DISABLE_FILEWATCHER")
   export const OPENCODE_EXPERIMENTAL_ICON_DISCOVERY =
     OPENCODE_EXPERIMENTAL || truthy("OPENCODE_EXPERIMENTAL_ICON_DISCOVERY")
 
@@ -61,9 +55,7 @@ export namespace Flag {
   export const OPENCODE_EXPERIMENTAL_OXFMT = OPENCODE_EXPERIMENTAL || truthy("OPENCODE_EXPERIMENTAL_OXFMT")
   export const OPENCODE_EXPERIMENTAL_LSP_TY = truthy("OPENCODE_EXPERIMENTAL_LSP_TY")
   export const OPENCODE_EXPERIMENTAL_LSP_TOOL = OPENCODE_EXPERIMENTAL || truthy("OPENCODE_EXPERIMENTAL_LSP_TOOL")
-  export const OPENCODE_DISABLE_FILETIME_CHECK = Config.boolean("OPENCODE_DISABLE_FILETIME_CHECK").pipe(
-    Config.withDefault(false),
-  )
+  export const OPENCODE_DISABLE_FILETIME_CHECK = truthy("OPENCODE_DISABLE_FILETIME_CHECK")
   export const OPENCODE_EXPERIMENTAL_PLAN_MODE = OPENCODE_EXPERIMENTAL || truthy("OPENCODE_EXPERIMENTAL_PLAN_MODE")
   export const OPENCODE_EXPERIMENTAL_WORKSPACES = OPENCODE_EXPERIMENTAL || truthy("OPENCODE_EXPERIMENTAL_WORKSPACES")
   export const OPENCODE_EXPERIMENTAL_MARKDOWN = !falsy("OPENCODE_EXPERIMENTAL_MARKDOWN")

packages/opencode/src/format/index.ts

@@ -9,13 +9,10 @@ import { Config } from "../config/config"
 import { mergeDeep } from "remeda"
 import { Instance } from "../project/instance"
 import { Process } from "../util/process"
-import { InstanceContext } from "@/effect/instance-context"
-import { Effect, Layer, ServiceMap } from "effect"
-import { runPromiseInstance } from "@/effect/runtime"
-
-const log = Log.create({ service: "format" })
 
 export namespace Format {
+  const log = Log.create({ service: "format" })
+
   export const Status = z
     .object({
       name: z.string(),
@@ -27,135 +24,117 @@ export namespace Format {
     })
   export type Status = z.infer<typeof Status>
 
-  export async function init() {
-    return runPromiseInstance(FormatService.use((s) => s.init()))
+  const state = Instance.state(async () => {
+    const enabled: Record<string, boolean> = {}
+    const cfg = await Config.get()
+
+    const formatters: Record<string, Formatter.Info> = {}
+    if (cfg.formatter === false) {
+      log.info("all formatters are disabled")
+      return {
+        enabled,
+        formatters,
+      }
+    }
+
+    for (const item of Object.values(Formatter)) {
+      formatters[item.name] = item
+    }
+    for (const [name, item] of Object.entries(cfg.formatter ?? {})) {
+      if (item.disabled) {
+        delete formatters[name]
+        continue
+      }
+      const result: Formatter.Info = mergeDeep(formatters[name] ?? {}, {
+        command: [],
+        extensions: [],
+        ...item,
+      })
+
+      if (result.command.length === 0) continue
+
+      result.enabled = async () => true
+      result.name = name
+      formatters[name] = result
+    }
+
+    return {
+      enabled,
+      formatters,
+    }
+  })
+
+  async function isEnabled(item: Formatter.Info) {
+    const s = await state()
+    let status = s.enabled[item.name]
+    if (status === undefined) {
+      status = await item.enabled()
+      s.enabled[item.name] = status
+    }
+    return status
+  }
+
+  async function getFormatter(ext: string) {
+    const formatters = await state().then((x) => x.formatters)
+    const result = []
+    for (const item of Object.values(formatters)) {
+      log.info("checking", { name: item.name, ext })
+      if (!item.extensions.includes(ext)) continue
+      if (!(await isEnabled(item))) continue
+      log.info("enabled", { name: item.name, ext })
+      result.push(item)
+    }
+    return result
   }
 
   export async function status() {
-    return runPromiseInstance(FormatService.use((s) => s.status()))
+    const s = await state()
+    const result: Status[] = []
+    for (const formatter of Object.values(s.formatters)) {
+      const enabled = await isEnabled(formatter)
+      result.push({
+        name: formatter.name,
+        extensions: formatter.extensions,
+        enabled,
+      })
+    }
+    return result
   }
-}
 
-export namespace FormatService {
-  export interface Service {
-    readonly init: () => Effect.Effect<void>
-    readonly status: () => Effect.Effect<Format.Status[]>
-  }
-}
+  export function init() {
+    log.info("init")
+    Bus.subscribe(File.Event.Edited, async (payload) => {
+      const file = payload.properties.file
+      log.info("formatting", { file })
+      const ext = path.extname(file)
 
-export class FormatService extends ServiceMap.Service<FormatService, FormatService.Service>()("@opencode/Format") {
-  static readonly layer = Layer.effect(
-    FormatService,
-    Effect.gen(function* () {
-      const instance = yield* InstanceContext
-
-      const enabled: Record<string, boolean> = {}
-      const formatters: Record<string, Formatter.Info> = {}
-
-      const cfg = yield* Effect.promise(() => Config.get())
-
-      if (cfg.formatter !== false) {
-        for (const item of Object.values(Formatter)) {
-          formatters[item.name] = item
-        }
-        for (const [name, item] of Object.entries(cfg.formatter ?? {})) {
-          if (item.disabled) {
-            delete formatters[name]
-            continue
-          }
-          const result = mergeDeep(formatters[name] ?? {}, {
-            command: [],
-            extensions: [],
-            ...item,
-          }) as Formatter.Info
-
-          if (result.command.length === 0) continue
-
-          result.enabled = async () => true
-          result.name = name
-          formatters[name] = result
-        }
-      } else {
-        log.info("all formatters are disabled")
-      }
-
-      async function isEnabled(item: Formatter.Info) {
-        let status = enabled[item.name]
-        if (status === undefined) {
-          status = await item.enabled()
-          enabled[item.name] = status
-        }
-        return status
-      }
-
-      async function getFormatter(ext: string) {
-        const result = []
-        for (const item of Object.values(formatters)) {
-          log.info("checking", { name: item.name, ext })
-          if (!item.extensions.includes(ext)) continue
-          if (!(await isEnabled(item))) continue
-          log.info("enabled", { name: item.name, ext })
-          result.push(item)
-        }
-        return result
-      }
-
-      const unsubscribe = Bus.subscribe(
-        File.Event.Edited,
-        Instance.bind(async (payload) => {
-          const file = payload.properties.file
-          log.info("formatting", { file })
-          const ext = path.extname(file)
-
-          for (const item of await getFormatter(ext)) {
-            log.info("running", { command: item.command })
-            try {
-              const proc = Process.spawn(
-                item.command.map((x) => x.replace("$FILE", file)),
-                {
-                  cwd: instance.directory,
-                  env: { ...process.env, ...item.environment },
-                  stdout: "ignore",
-                  stderr: "ignore",
-                },
-              )
-              const exit = await proc.exited
-              if (exit !== 0)
-                log.error("failed", {
-                  command: item.command,
-                  ...item.environment,
-                })
-            } catch (error) {
-              log.error("failed to format file", {
-                error,
-                command: item.command,
-                ...item.environment,
-                file,
-              })
-            }
-          }
-        }),
-      )
-
-      yield* Effect.addFinalizer(() => Effect.sync(unsubscribe))
-      log.info("init")
-
-      const init = Effect.fn("FormatService.init")(function* () {})
-
-      const status = Effect.fn("FormatService.status")(function* () {
-        const result: Format.Status[] = []
-        for (const formatter of Object.values(formatters)) {
-          const isOn = yield* Effect.promise(() => isEnabled(formatter))
-          result.push({
-            name: formatter.name,
-            extensions: formatter.extensions,
-            enabled: isOn,
+      for (const item of await getFormatter(ext)) {
+        log.info("running", { command: item.command })
+        try {
+          const proc = Process.spawn(
+            item.command.map((x) => x.replace("$FILE", file)),
+            {
+              cwd: Instance.directory,
+              env: { ...process.env, ...item.environment },
+              stdout: "ignore",
+              stderr: "ignore",
+            },
+          )
+          const exit = await proc.exited
+          if (exit !== 0)
+            log.error("failed", {
+              command: item.command,
+              ...item.environment,
+            })
+        } catch (error) {
+          log.error("failed to format file", {
+            error,
+            command: item.command,
+            ...item.environment,
+            file,
           })
         }
-        return result
-      })
-
-      return FormatService.of({ init, status })
-    }),
-  )
+      }
+    })
+  }
 }

packages/opencode/src/permission/next.ts

@@ -1,9 +1,18 @@
-import { runPromiseInstance } from "@/effect/runtime"
+import { runtime } from "@/effect/runtime"
 import { Config } from "@/config/config"
 import { fn } from "@/util/fn"
 import { Wildcard } from "@/util/wildcard"
+import { Effect } from "effect"
 import os from "os"
 import * as S from "./service"
+import type {
+  Action as ActionType,
+  PermissionError,
+  Reply as ReplyType,
+  Request as RequestType,
+  Rule as RuleType,
+  Ruleset as RulesetType,
+} from "./service"
 
 export namespace PermissionNext {
   function expand(pattern: string): string {
@@ -14,16 +23,20 @@ export namespace PermissionNext {
     return pattern
   }
 
+  function runPromise<A>(f: (service: S.PermissionService.Api) => Effect.Effect<A, PermissionError>) {
+    return runtime.runPromise(S.PermissionService.use(f))
+  }
+
   export const Action = S.Action
-  export type Action = S.Action
+  export type Action = ActionType
   export const Rule = S.Rule
-  export type Rule = S.Rule
+  export type Rule = RuleType
   export const Ruleset = S.Ruleset
-  export type Ruleset = S.Ruleset
+  export type Ruleset = RulesetType
   export const Request = S.Request
-  export type Request = S.Request
+  export type Request = RequestType
   export const Reply = S.Reply
-  export type Reply = S.Reply
+  export type Reply = ReplyType
   export const Approval = S.Approval
   export const Event = S.Event
   export const Service = S.PermissionService
@@ -53,16 +66,12 @@ export namespace PermissionNext {
     return rulesets.flat()
   }
 
-  export const ask = fn(S.AskInput, async (input) =>
-    runPromiseInstance(S.PermissionService.use((service) => service.ask(input))),
-  )
+  export const ask = fn(S.AskInput, async (input) => runPromise((service) => service.ask(input)))
 
-  export const reply = fn(S.ReplyInput, async (input) =>
-    runPromiseInstance(S.PermissionService.use((service) => service.reply(input))),
-  )
+  export const reply = fn(S.ReplyInput, async (input) => runPromise((service) => service.reply(input)))
 
   export async function list() {
-    return runPromiseInstance(S.PermissionService.use((service) => service.list()))
+    return runPromise((service) => service.list())
   }
 
   export function evaluate(permission: string, pattern: string, ...rulesets: Ruleset[]): Rule {

packages/opencode/src/permission/service.ts

@@ -1,10 +1,11 @@
 import { Bus } from "@/bus"
 import { BusEvent } from "@/bus/bus-event"
-import { InstanceContext } from "@/effect/instance-context"
+import { Instance } from "@/project/instance"
 import { ProjectID } from "@/project/schema"
 import { MessageID, SessionID } from "@/session/schema"
 import { PermissionTable } from "@/session/session.sql"
 import { Database, eq } from "@/storage/db"
+import { InstanceState } from "@/util/instance-state"
 import { Log } from "@/util/log"
 import { Wildcard } from "@/util/wildcard"
 import { Deferred, Effect, Layer, Schema, ServiceMap } from "effect"
@@ -103,6 +104,11 @@ interface PendingEntry {
   deferred: Deferred.Deferred<void, RejectedError | CorrectedError>
 }
 
+type State = {
+  pending: Map<PermissionID, PendingEntry>
+  approved: Ruleset
+}
+
 export const AskInput = Request.partial({ id: true }).extend({
   ruleset: Ruleset,
 })
@@ -127,19 +133,25 @@ export class PermissionService extends ServiceMap.Service<PermissionService, Per
   static readonly layer = Layer.effect(
     PermissionService,
     Effect.gen(function* () {
-      const { project } = yield* InstanceContext
-      const row = Database.use((db) =>
-        db.select().from(PermissionTable).where(eq(PermissionTable.project_id, project.id)).get(),
+      const instanceState = yield* InstanceState.make<State>(() =>
+        Effect.sync(() => {
+          const row = Database.use((db) =>
+            db.select().from(PermissionTable).where(eq(PermissionTable.project_id, Instance.project.id)).get(),
+          )
+          return {
+            pending: new Map<PermissionID, PendingEntry>(),
+            approved: row?.data ?? [],
+          }
+        }),
       )
-      const pending = new Map<PermissionID, PendingEntry>()
-      const approved: Ruleset = row?.data ?? []
 
       const ask = Effect.fn("PermissionService.ask")(function* (input: z.infer<typeof AskInput>) {
+        const state = yield* InstanceState.get(instanceState)
         const { ruleset, ...request } = input
-        let needsAsk = false
+        let pending = false
 
         for (const pattern of request.patterns) {
-          const rule = evaluate(request.permission, pattern, ruleset, approved)
+          const rule = evaluate(request.permission, pattern, ruleset, state.approved)
           log.info("evaluated", { permission: request.permission, pattern, action: rule })
           if (rule.action === "deny") {
             return yield* new DeniedError({
@@ -147,10 +159,10 @@ export class PermissionService extends ServiceMap.Service<PermissionService, Per
             })
           }
           if (rule.action === "allow") continue
-          needsAsk = true
+          pending = true
         }
 
-        if (!needsAsk) return
+        if (!pending) return
 
         const id = request.id ?? PermissionID.ascending()
         const info: Request = {
@@ -160,21 +172,22 @@ export class PermissionService extends ServiceMap.Service<PermissionService, Per
         log.info("asking", { id, permission: info.permission, patterns: info.patterns })
 
         const deferred = yield* Deferred.make<void, RejectedError | CorrectedError>()
-        pending.set(id, { info, deferred })
+        state.pending.set(id, { info, deferred })
         void Bus.publish(Event.Asked, info)
         return yield* Effect.ensuring(
           Deferred.await(deferred),
           Effect.sync(() => {
-            pending.delete(id)
+            state.pending.delete(id)
           }),
         )
       })
 
       const reply = Effect.fn("PermissionService.reply")(function* (input: z.infer<typeof ReplyInput>) {
-        const existing = pending.get(input.requestID)
+        const state = yield* InstanceState.get(instanceState)
+        const existing = state.pending.get(input.requestID)
         if (!existing) return
 
-        pending.delete(input.requestID)
+        state.pending.delete(input.requestID)
         void Bus.publish(Event.Replied, {
           sessionID: existing.info.sessionID,
           requestID: existing.info.id,
@@ -187,9 +200,9 @@ export class PermissionService extends ServiceMap.Service<PermissionService, Per
             input.message ? new CorrectedError({ feedback: input.message }) : new RejectedError(),
           )
 
-          for (const [id, item] of pending.entries()) {
+          for (const [id, item] of state.pending.entries()) {
             if (item.info.sessionID !== existing.info.sessionID) continue
-            pending.delete(id)
+            state.pending.delete(id)
             void Bus.publish(Event.Replied, {
               sessionID: item.info.sessionID,
               requestID: item.info.id,
@@ -204,20 +217,20 @@ export class PermissionService extends ServiceMap.Service<PermissionService, Per
         if (input.reply === "once") return
 
         for (const pattern of existing.info.always) {
-          approved.push({
+          state.approved.push({
             permission: existing.info.permission,
             pattern,
             action: "allow",
           })
         }
 
-        for (const [id, item] of pending.entries()) {
+        for (const [id, item] of state.pending.entries()) {
           if (item.info.sessionID !== existing.info.sessionID) continue
           const ok = item.info.patterns.every(
-            (pattern) => evaluate(item.info.permission, pattern, approved).action === "allow",
+            (pattern) => evaluate(item.info.permission, pattern, state.approved).action === "allow",
           )
           if (!ok) continue
-          pending.delete(id)
+          state.pending.delete(id)
           void Bus.publish(Event.Replied, {
             sessionID: item.info.sessionID,
             requestID: item.info.id,
@@ -233,7 +246,8 @@ export class PermissionService extends ServiceMap.Service<PermissionService, Per
       })
 
       const list = Effect.fn("PermissionService.list")(function* () {
-        return Array.from(pending.values(), (item) => item.info)
+        const state = yield* InstanceState.get(instanceState)
+        return Array.from(state.pending.values(), (item) => item.info)
       })
 
       return PermissionService.of({ ask, reply, list })

packages/opencode/src/project/bootstrap.ts

@@ -1,28 +1,27 @@
 import { Plugin } from "../plugin"
 import { Format } from "../format"
 import { LSP } from "../lsp"
-import { FileWatcherService } from "../file/watcher"
+import { FileWatcher } from "../file/watcher"
 import { File } from "../file"
 import { Project } from "./project"
 import { Bus } from "../bus"
 import { Command } from "../command"
 import { Instance } from "./instance"
-import { VcsService } from "./vcs"
+import { Vcs } from "./vcs"
 import { Log } from "@/util/log"
 import { ShareNext } from "@/share/share-next"
 import { Snapshot } from "../snapshot"
 import { Truncate } from "../tool/truncation"
-import { runPromiseInstance } from "@/effect/runtime"
 
 export async function InstanceBootstrap() {
   Log.Default.info("bootstrapping", { directory: Instance.directory })
   await Plugin.init()
   ShareNext.init()
-  await Format.init()
+  Format.init()
   await LSP.init()
-  await runPromiseInstance(FileWatcherService.use((service) => service.init()))
+  FileWatcher.init()
   File.init()
-  await runPromiseInstance(VcsService.use((s) => s.init()))
+  Vcs.init()
   Snapshot.init()
   Truncate.init()
 

packages/opencode/src/project/instance.ts

@@ -1,3 +1,4 @@
+import { Effect } from "effect"
 import { Log } from "@/util/log"
 import { Context } from "../util/context"
 import { Project } from "./project"
@@ -5,7 +6,7 @@ import { State } from "./state"
 import { iife } from "@/util/iife"
 import { GlobalBus } from "@/bus/global"
 import { Filesystem } from "@/util/filesystem"
-import { disposeInstance } from "@/effect/instance-registry"
+import { InstanceState } from "@/util/instance-state"
 
 interface Context {
   directory: string
@@ -101,33 +102,23 @@ export const Instance = {
     if (Instance.worktree === "/") return false
     return Filesystem.contains(Instance.worktree, filepath)
   },
-  /**
-   * Captures the current instance ALS context and returns a wrapper that
-   * restores it when called. Use this for callbacks that fire outside the
-   * instance async context (native addons, event emitters, timers, etc.).
-   */
-  bind<F extends (...args: any[]) => any>(fn: F): F {
-    const ctx = context.use()
-    return ((...args: any[]) => context.provide(ctx, () => fn(...args))) as F
-  },
   state<S>(init: () => S, dispose?: (state: Awaited<S>) => Promise<void>): () => S {
     return State.create(() => Instance.directory, init, dispose)
   },
   async reload(input: { directory: string; init?: () => Promise<any>; project?: Project.Info; worktree?: string }) {
     const directory = Filesystem.resolve(input.directory)
     Log.Default.info("reloading instance", { directory })
-    await Promise.all([State.dispose(directory), disposeInstance(directory)])
+    await Promise.all([State.dispose(directory), Effect.runPromise(InstanceState.dispose(directory))])
     cache.delete(directory)
     const next = track(directory, boot({ ...input, directory }))
     emit(directory)
     return await next
   },
   async dispose() {
-    const directory = Instance.directory
-    Log.Default.info("disposing instance", { directory })
-    await Promise.all([State.dispose(directory), disposeInstance(directory)])
-    cache.delete(directory)
-    emit(directory)
+    Log.Default.info("disposing instance", { directory: Instance.directory })
+    await Promise.all([State.dispose(Instance.directory), Effect.runPromise(InstanceState.dispose(Instance.directory))])
+    cache.delete(Instance.directory)
+    emit(Instance.directory)
   },
   async disposeAll() {
     if (disposal.all) return disposal.all

packages/opencode/src/project/vcs.ts

@@ -1,12 +1,11 @@
 import { BusEvent } from "@/bus/bus-event"
 import { Bus } from "@/bus"
+import path from "path"
 import z from "zod"
 import { Log } from "@/util/log"
 import { Instance } from "./instance"
-import { InstanceContext } from "@/effect/instance-context"
 import { FileWatcher } from "@/file/watcher"
 import { git } from "@/util/git"
-import { Effect, Layer, ServiceMap } from "effect"
 
 const log = Log.create({ service: "vcs" })
 
@@ -28,57 +27,50 @@ export namespace Vcs {
       ref: "VcsInfo",
     })
   export type Info = z.infer<typeof Info>
-}
 
-export namespace VcsService {
-  export interface Service {
-    readonly init: () => Effect.Effect<void>
-    readonly branch: () => Effect.Effect<string | undefined>
+  async function currentBranch() {
+    const result = await git(["rev-parse", "--abbrev-ref", "HEAD"], {
+      cwd: Instance.worktree,
+    })
+    if (result.exitCode !== 0) return
+    const text = result.text().trim()
+    if (!text) return
+    return text
+  }
+
+  const state = Instance.state(
+    async () => {
+      if (Instance.project.vcs !== "git") {
+        return { branch: async () => undefined, unsubscribe: undefined }
+      }
+      let current = await currentBranch()
+      log.info("initialized", { branch: current })
+
+      const unsubscribe = Bus.subscribe(FileWatcher.Event.Updated, async (evt) => {
+        if (!evt.properties.file.endsWith("HEAD")) return
+        const next = await currentBranch()
+        if (next !== current) {
+          log.info("branch changed", { from: current, to: next })
+          current = next
+          Bus.publish(Event.BranchUpdated, { branch: next })
+        }
+      })
+
+      return {
+        branch: async () => current,
+        unsubscribe,
+      }
+    },
+    async (state) => {
+      state.unsubscribe?.()
+    },
+  )
+
+  export async function init() {
+    return state()
+  }
+
+  export async function branch() {
+    return await state().then((s) => s.branch())
   }
 }
-
-export class VcsService extends ServiceMap.Service<VcsService, VcsService.Service>()("@opencode/Vcs") {
-  static readonly layer = Layer.effect(
-    VcsService,
-    Effect.gen(function* () {
-      const instance = yield* InstanceContext
-      let current: string | undefined
-
-      if (instance.project.vcs === "git") {
-        const currentBranch = async () => {
-          const result = await git(["rev-parse", "--abbrev-ref", "HEAD"], {
-            cwd: instance.project.worktree,
-          })
-          if (result.exitCode !== 0) return undefined
-          const text = result.text().trim()
-          return text || undefined
-        }
-
-        current = yield* Effect.promise(() => currentBranch())
-        log.info("initialized", { branch: current })
-
-        const unsubscribe = Bus.subscribe(
-          FileWatcher.Event.Updated,
-          Instance.bind(async (evt) => {
-            if (!evt.properties.file.endsWith("HEAD")) return
-            const next = await currentBranch()
-            if (next !== current) {
-              log.info("branch changed", { from: current, to: next })
-              current = next
-              Bus.publish(Vcs.Event.BranchUpdated, { branch: next })
-            }
-          }),
-        )
-
-        yield* Effect.addFinalizer(() => Effect.sync(unsubscribe))
-      }
-
-      return VcsService.of({
-        init: Effect.fn("VcsService.init")(function* () {}),
-        branch: Effect.fn("VcsService.branch")(function* () {
-          return current
-        }),
-      })
-    }),
-  )
-}

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

@@ -1,9 +1,12 @@
+import { Effect, Layer, Record, ServiceMap, Struct } from "effect"
+import { Instance } from "@/project/instance"
+import { Plugin } from "../plugin"
+import { filter, fromEntries, map, pipe } from "remeda"
 import type { AuthOuathResult } from "@opencode-ai/plugin"
 import { NamedError } from "@opencode-ai/util/error"
 import * as Auth from "@/auth/service"
+import { InstanceState } from "@/util/instance-state"
 import { ProviderID } from "./schema"
-import { Effect, Layer, Record, ServiceMap, Struct } from "effect"
-import { filter, fromEntries, map, pipe } from "remeda"
 import z from "zod"
 
 export const Method = z
@@ -51,13 +54,21 @@ export type ProviderAuthError =
 
 export namespace ProviderAuthService {
   export interface Service {
+    /** Get available auth methods for each provider (e.g. OAuth, API key). */
     readonly methods: () => Effect.Effect<Record<string, Method[]>>
+
+    /** Start an OAuth authorization flow for a provider. Returns the URL to redirect to. */
     readonly authorize: (input: { providerID: ProviderID; method: number }) => Effect.Effect<Authorization | undefined>
+
+    /** Complete an OAuth flow after the user has authorized. Exchanges the code/callback for credentials. */
     readonly callback: (input: {
       providerID: ProviderID
       method: number
       code?: string
     }) => Effect.Effect<void, ProviderAuthError>
+
+    /** Set an API key directly for a provider (no OAuth flow). */
+    readonly api: (input: { providerID: ProviderID; key: string }) => Effect.Effect<void, Auth.AuthServiceError>
   }
 }
 
@@ -68,29 +79,32 @@ export class ProviderAuthService extends ServiceMap.Service<ProviderAuthService,
     ProviderAuthService,
     Effect.gen(function* () {
       const auth = yield* Auth.AuthService
-      const hooks = yield* Effect.promise(async () => {
-        const mod = await import("../plugin")
-        return pipe(
-          await mod.Plugin.list(),
-          filter((x) => x.auth?.provider !== undefined),
-          map((x) => [x.auth!.provider, x.auth!] as const),
-          fromEntries(),
-        )
-      })
-      const pending = new Map<ProviderID, AuthOuathResult>()
+      const state = yield* InstanceState.make(() =>
+        Effect.promise(async () => {
+          const methods = pipe(
+            await Plugin.list(),
+            filter((x) => x.auth?.provider !== undefined),
+            map((x) => [x.auth!.provider, x.auth!] as const),
+            fromEntries(),
+          )
+          return { methods, pending: new Map<ProviderID, AuthOuathResult>() }
+        }),
+      )
 
       const methods = Effect.fn("ProviderAuthService.methods")(function* () {
-        return Record.map(hooks, (item) => item.methods.map((method): Method => Struct.pick(method, ["type", "label"])))
+        const x = yield* InstanceState.get(state)
+        return Record.map(x.methods, (y) => y.methods.map((z): Method => Struct.pick(z, ["type", "label"])))
       })
 
       const authorize = Effect.fn("ProviderAuthService.authorize")(function* (input: {
         providerID: ProviderID
         method: number
       }) {
-        const method = hooks[input.providerID].methods[input.method]
+        const s = yield* InstanceState.get(state)
+        const method = s.methods[input.providerID].methods[input.method]
         if (method.type !== "oauth") return
         const result = yield* Effect.promise(() => method.authorize())
-        pending.set(input.providerID, result)
+        s.pending.set(input.providerID, result)
         return {
           url: result.url,
           method: result.method,
@@ -103,14 +117,17 @@ export class ProviderAuthService extends ServiceMap.Service<ProviderAuthService,
         method: number
         code?: string
       }) {
-        const match = pending.get(input.providerID)
+        const s = yield* InstanceState.get(state)
+        const match = s.pending.get(input.providerID)
         if (!match) return yield* Effect.fail(new OauthMissing({ providerID: input.providerID }))
+
         if (match.method === "code" && !input.code)
           return yield* Effect.fail(new OauthCodeMissing({ providerID: input.providerID }))
 
         const result = yield* Effect.promise(() =>
           match.method === "code" ? match.callback(input.code!) : match.callback(),
         )
+
         if (!result || result.type !== "success") return yield* Effect.fail(new OauthCallbackFailed({}))
 
         if ("key" in result) {
@@ -131,10 +148,18 @@ export class ProviderAuthService extends ServiceMap.Service<ProviderAuthService,
         }
       })
 
+      const api = Effect.fn("ProviderAuthService.api")(function* (input: { providerID: ProviderID; key: string }) {
+        yield* auth.set(input.providerID, {
+          type: "api",
+          key: input.key,
+        })
+      })
+
       return ProviderAuthService.of({
         methods,
         authorize,
         callback,
+        api,
       })
     }),
   )

packages/opencode/src/provider/auth.ts

@@ -1,16 +1,25 @@
+import { Effect, ManagedRuntime } from "effect"
 import z from "zod"
 
-import { runPromiseInstance } from "@/effect/runtime"
 import { fn } from "@/util/fn"
 import * as S from "./auth-service"
 import { ProviderID } from "./schema"
 
+// Separate runtime: ProviderAuthService can't join the shared runtime because
+// runtime.ts → auth-service.ts → provider/auth.ts creates a circular import.
+// AuthService is stateless file I/O so the duplicate instance is harmless.
+const rt = ManagedRuntime.make(S.ProviderAuthService.defaultLayer)
+
+function runPromise<A>(f: (service: S.ProviderAuthService.Service) => Effect.Effect<A, S.ProviderAuthError>) {
+  return rt.runPromise(S.ProviderAuthService.use(f))
+}
+
 export namespace ProviderAuth {
   export const Method = S.Method
   export type Method = S.Method
 
   export async function methods() {
-    return runPromiseInstance(S.ProviderAuthService.use((service) => service.methods()))
+    return runPromise((service) => service.methods())
   }
 
   export const Authorization = S.Authorization
@@ -21,8 +30,7 @@ export namespace ProviderAuth {
       providerID: ProviderID.zod,
       method: z.number(),
     }),
-    async (input): Promise<Authorization | undefined> =>
-      runPromiseInstance(S.ProviderAuthService.use((service) => service.authorize(input))),
+    async (input): Promise<Authorization | undefined> => runPromise((service) => service.authorize(input)),
   )
 
   export const callback = fn(
@@ -31,7 +39,15 @@ export namespace ProviderAuth {
       method: z.number(),
       code: z.string().optional(),
     }),
-    async (input) => runPromiseInstance(S.ProviderAuthService.use((service) => service.callback(input))),
+    async (input) => runPromise((service) => service.callback(input)),
+  )
+
+  export const api = fn(
+    z.object({
+      providerID: ProviderID.zod,
+      key: z.string(),
+    }),
+    async (input) => runPromise((service) => service.api(input)),
   )
 
   export import OauthMissing = S.OauthMissing

packages/opencode/src/pty/index.ts

@@ -167,44 +167,40 @@ export namespace Pty {
       subscribers: new Map(),
     }
     state().set(id, session)
-    ptyProcess.onData(
-      Instance.bind((chunk) => {
-        session.cursor += chunk.length
+    ptyProcess.onData((chunk) => {
+      session.cursor += chunk.length
 
-        for (const [key, ws] of session.subscribers.entries()) {
-          if (ws.readyState !== 1) {
-            session.subscribers.delete(key)
-            continue
-          }
-
-          if (ws.data !== key) {
-            session.subscribers.delete(key)
-            continue
-          }
-
-          try {
-            ws.send(chunk)
-          } catch {
-            session.subscribers.delete(key)
-          }
+      for (const [key, ws] of session.subscribers.entries()) {
+        if (ws.readyState !== 1) {
+          session.subscribers.delete(key)
+          continue
         }
 
-        session.buffer += chunk
-        if (session.buffer.length <= BUFFER_LIMIT) return
-        const excess = session.buffer.length - BUFFER_LIMIT
-        session.buffer = session.buffer.slice(excess)
-        session.bufferCursor += excess
-      }),
-    )
-    ptyProcess.onExit(
-      Instance.bind(({ exitCode }) => {
-        if (session.info.status === "exited") return
-        log.info("session exited", { id, exitCode })
-        session.info.status = "exited"
-        Bus.publish(Event.Exited, { id, exitCode })
-        remove(id)
-      }),
-    )
+        if (ws.data !== key) {
+          session.subscribers.delete(key)
+          continue
+        }
+
+        try {
+          ws.send(chunk)
+        } catch {
+          session.subscribers.delete(key)
+        }
+      }
+
+      session.buffer += chunk
+      if (session.buffer.length <= BUFFER_LIMIT) return
+      const excess = session.buffer.length - BUFFER_LIMIT
+      session.buffer = session.buffer.slice(excess)
+      session.bufferCursor += excess
+    })
+    ptyProcess.onExit(({ exitCode }) => {
+      if (session.info.status === "exited") return
+      log.info("session exited", { id, exitCode })
+      session.info.status = "exited"
+      Bus.publish(Event.Exited, { id, exitCode })
+      remove(id)
+    })
     Bus.publish(Event.Created, { info })
     return info
   }

packages/opencode/src/question/index.ts

@@ -1,8 +1,13 @@
-import { runPromiseInstance } from "@/effect/runtime"
+import { Effect } from "effect"
+import { runtime } from "@/effect/runtime"
 import * as S from "./service"
 import type { QuestionID } from "./schema"
 import type { SessionID, MessageID } from "@/session/schema"
 
+function runPromise<A, E>(f: (service: S.QuestionService.Service) => Effect.Effect<A, E>) {
+  return runtime.runPromise(S.QuestionService.use(f))
+}
+
 export namespace Question {
   export const Option = S.Option
   export type Option = S.Option
@@ -22,18 +27,18 @@ export namespace Question {
     questions: Info[]
     tool?: { messageID: MessageID; callID: string }
   }): Promise<Answer[]> {
-    return runPromiseInstance(S.QuestionService.use((service) => service.ask(input)))
+    return runPromise((service) => service.ask(input))
   }
 
   export async function reply(input: { requestID: QuestionID; answers: Answer[] }): Promise<void> {
-    return runPromiseInstance(S.QuestionService.use((service) => service.reply(input)))
+    return runPromise((service) => service.reply(input))
   }
 
   export async function reject(requestID: QuestionID): Promise<void> {
-    return runPromiseInstance(S.QuestionService.use((service) => service.reject(requestID)))
+    return runPromise((service) => service.reject(requestID))
   }
 
   export async function list(): Promise<Request[]> {
-    return runPromiseInstance(S.QuestionService.use((service) => service.list()))
+    return runPromise((service) => service.list())
   }
 }

packages/opencode/src/question/service.ts

@@ -2,6 +2,7 @@ import { Deferred, Effect, Layer, Schema, ServiceMap } from "effect"
 import { Bus } from "@/bus"
 import { BusEvent } from "@/bus/bus-event"
 import { SessionID, MessageID } from "@/session/schema"
+import { InstanceState } from "@/util/instance-state"
 import { Log } from "@/util/log"
 import z from "zod"
 import { QuestionID } from "./schema"
@@ -103,13 +104,18 @@ export class QuestionService extends ServiceMap.Service<QuestionService, Questio
   static readonly layer = Layer.effect(
     QuestionService,
     Effect.gen(function* () {
-      const pending = new Map<QuestionID, PendingEntry>()
+      const instanceState = yield* InstanceState.make<Map<QuestionID, PendingEntry>>(() =>
+        Effect.succeed(new Map<QuestionID, PendingEntry>()),
+      )
+
+      const getPending = InstanceState.get(instanceState)
 
       const ask = Effect.fn("QuestionService.ask")(function* (input: {
         sessionID: SessionID
         questions: Info[]
         tool?: { messageID: MessageID; callID: string }
       }) {
+        const pending = yield* getPending
         const id = QuestionID.ascending()
         log.info("asking", { id, questions: input.questions.length })
 
@@ -132,6 +138,7 @@ export class QuestionService extends ServiceMap.Service<QuestionService, Questio
       })
 
       const reply = Effect.fn("QuestionService.reply")(function* (input: { requestID: QuestionID; answers: Answer[] }) {
+        const pending = yield* getPending
         const existing = pending.get(input.requestID)
         if (!existing) {
           log.warn("reply for unknown request", { requestID: input.requestID })
@@ -148,6 +155,7 @@ export class QuestionService extends ServiceMap.Service<QuestionService, Questio
       })
 
       const reject = Effect.fn("QuestionService.reject")(function* (requestID: QuestionID) {
+        const pending = yield* getPending
         const existing = pending.get(requestID)
         if (!existing) {
           log.warn("reject for unknown request", { requestID })
@@ -163,6 +171,7 @@ export class QuestionService extends ServiceMap.Service<QuestionService, Questio
       })
 
       const list = Effect.fn("QuestionService.list")(function* () {
+        const pending = yield* getPending
         return Array.from(pending.values(), (x) => x.info)
       })
 

packages/opencode/src/server/server.ts

@@ -14,8 +14,7 @@ import { LSP } from "../lsp"
 import { Format } from "../format"
 import { TuiRoutes } from "./routes/tui"
 import { Instance } from "../project/instance"
-import { Vcs, VcsService } from "../project/vcs"
-import { runPromiseInstance } from "@/effect/runtime"
+import { Vcs } from "../project/vcs"
 import { Agent } from "../agent/agent"
 import { Skill } from "../skill/skill"
 import { Auth } from "../auth"
@@ -331,7 +330,7 @@ export namespace Server {
           },
         }),
         async (c) => {
-          const branch = await runPromiseInstance(VcsService.use((s) => s.branch()))
+          const branch = await Vcs.branch()
           return c.json({
             branch,
           })

packages/opencode/src/session/compaction.ts

@@ -200,8 +200,6 @@ When constructing the summary, try to stick to this template:
 ---`
 
     const promptText = compacting.prompt ?? [defaultPrompt, ...compacting.context].join("\n\n")
-    const msgs = structuredClone(messages)
-    await Plugin.trigger("experimental.chat.messages.transform", {}, { messages: msgs })
     const result = await processor.process({
       user: userMessage,
       agent,
@@ -210,7 +208,7 @@ When constructing the summary, try to stick to this template:
       tools: {},
       system: [],
       messages: [
-        ...MessageV2.toModelMessages(msgs, model, { stripMedia: true }),
+        ...MessageV2.toModelMessages(messages, model, { stripMedia: true }),
         {
           role: "user",
           content: [

packages/opencode/src/session/prompt.ts

@@ -1245,7 +1245,7 @@ export namespace SessionPrompt {
                 ]
               }
 
-              await FileTime.read(input.sessionID, filepath)
+              FileTime.read(input.sessionID, filepath)
               return [
                 {
                   messageID: info.id,

packages/opencode/src/skill/skill.ts

@@ -10,25 +10,15 @@ import { Global } from "@/global"
 import { Filesystem } from "@/util/filesystem"
 import { Flag } from "@/flag/flag"
 import { Bus } from "@/bus"
+import { Session } from "@/session"
 import { Discovery } from "./discovery"
 import { Glob } from "../util/glob"
 import { pathToFileURL } from "url"
 import type { Agent } from "@/agent/agent"
 import { PermissionNext } from "@/permission/next"
-import { InstanceContext } from "@/effect/instance-context"
-import { Effect, Layer, ServiceMap } from "effect"
-import { runPromiseInstance } from "@/effect/runtime"
-
-const log = Log.create({ service: "skill" })
-
-// External skill directories to search for (project-level and global)
-// These follow the directory layout used by Claude Code and other agents.
-const EXTERNAL_DIRS = [".claude", ".agents"]
-const EXTERNAL_SKILL_PATTERN = "skills/**/SKILL.md"
-const OPENCODE_SKILL_PATTERN = "{skill,skills}/**/SKILL.md"
-const SKILL_PATTERN = "**/SKILL.md"
 
 export namespace Skill {
+  const log = Log.create({ service: "skill" })
   export const Info = z.object({
     name: z.string(),
     description: z.string(),
@@ -55,20 +45,155 @@ export namespace Skill {
     }),
   )
 
+  // External skill directories to search for (project-level and global)
+  // These follow the directory layout used by Claude Code and other agents.
+  const EXTERNAL_DIRS = [".claude", ".agents"]
+  const EXTERNAL_SKILL_PATTERN = "skills/**/SKILL.md"
+  const OPENCODE_SKILL_PATTERN = "{skill,skills}/**/SKILL.md"
+  const SKILL_PATTERN = "**/SKILL.md"
+
+  export const state = Instance.state(async () => {
+    const skills: Record<string, Info> = {}
+    const dirs = new Set<string>()
+
+    const addSkill = async (match: string) => {
+      const md = await ConfigMarkdown.parse(match).catch((err) => {
+        const message = ConfigMarkdown.FrontmatterError.isInstance(err)
+          ? err.data.message
+          : `Failed to parse skill ${match}`
+        Bus.publish(Session.Event.Error, { error: new NamedError.Unknown({ message }).toObject() })
+        log.error("failed to load skill", { skill: match, err })
+        return undefined
+      })
+
+      if (!md) return
+
+      const parsed = Info.pick({ name: true, description: true }).safeParse(md.data)
+      if (!parsed.success) return
+
+      // Warn on duplicate skill names
+      if (skills[parsed.data.name]) {
+        log.warn("duplicate skill name", {
+          name: parsed.data.name,
+          existing: skills[parsed.data.name].location,
+          duplicate: match,
+        })
+      }
+
+      dirs.add(path.dirname(match))
+
+      skills[parsed.data.name] = {
+        name: parsed.data.name,
+        description: parsed.data.description,
+        location: match,
+        content: md.content,
+      }
+    }
+
+    const scanExternal = async (root: string, scope: "global" | "project") => {
+      return Glob.scan(EXTERNAL_SKILL_PATTERN, {
+        cwd: root,
+        absolute: true,
+        include: "file",
+        dot: true,
+        symlink: true,
+      })
+        .then((matches) => Promise.all(matches.map(addSkill)))
+        .catch((error) => {
+          log.error(`failed to scan ${scope} skills`, { dir: root, error })
+        })
+    }
+
+    // Scan external skill directories (.claude/skills/, .agents/skills/, etc.)
+    // Load global (home) first, then project-level (so project-level overwrites)
+    if (!Flag.OPENCODE_DISABLE_EXTERNAL_SKILLS) {
+      for (const dir of EXTERNAL_DIRS) {
+        const root = path.join(Global.Path.home, dir)
+        if (!(await Filesystem.isDir(root))) continue
+        await scanExternal(root, "global")
+      }
+
+      for await (const root of Filesystem.up({
+        targets: EXTERNAL_DIRS,
+        start: Instance.directory,
+        stop: Instance.worktree,
+      })) {
+        await scanExternal(root, "project")
+      }
+    }
+
+    // Scan .opencode/skill/ directories
+    for (const dir of await Config.directories()) {
+      const matches = await Glob.scan(OPENCODE_SKILL_PATTERN, {
+        cwd: dir,
+        absolute: true,
+        include: "file",
+        symlink: true,
+      })
+      for (const match of matches) {
+        await addSkill(match)
+      }
+    }
+
+    // Scan additional skill paths from config
+    const config = await Config.get()
+    for (const skillPath of config.skills?.paths ?? []) {
+      const expanded = skillPath.startsWith("~/") ? path.join(os.homedir(), skillPath.slice(2)) : skillPath
+      const resolved = path.isAbsolute(expanded) ? expanded : path.join(Instance.directory, expanded)
+      if (!(await Filesystem.isDir(resolved))) {
+        log.warn("skill path not found", { path: resolved })
+        continue
+      }
+      const matches = await Glob.scan(SKILL_PATTERN, {
+        cwd: resolved,
+        absolute: true,
+        include: "file",
+        symlink: true,
+      })
+      for (const match of matches) {
+        await addSkill(match)
+      }
+    }
+
+    // Download and load skills from URLs
+    for (const url of config.skills?.urls ?? []) {
+      const list = await Discovery.pull(url)
+      for (const dir of list) {
+        dirs.add(dir)
+        const matches = await Glob.scan(SKILL_PATTERN, {
+          cwd: dir,
+          absolute: true,
+          include: "file",
+          symlink: true,
+        })
+        for (const match of matches) {
+          await addSkill(match)
+        }
+      }
+    }
+
+    return {
+      skills,
+      dirs: Array.from(dirs),
+    }
+  })
+
   export async function get(name: string) {
-    return runPromiseInstance(SkillService.use((s) => s.get(name)))
+    return state().then((x) => x.skills[name])
   }
 
   export async function all() {
-    return runPromiseInstance(SkillService.use((s) => s.all()))
+    return state().then((x) => Object.values(x.skills))
   }
 
   export async function dirs() {
-    return runPromiseInstance(SkillService.use((s) => s.dirs()))
+    return state().then((x) => x.dirs)
   }
 
   export async function available(agent?: Agent.Info) {
-    return runPromiseInstance(SkillService.use((s) => s.available(agent)))
+    const list = await all()
+    if (!agent) return list
+    return list.filter((skill) => PermissionNext.evaluate("skill", skill.name, agent.permission).action !== "deny")
   }
 
   export function fmt(list: Info[], opts: { verbose: boolean }) {
@@ -91,176 +216,3 @@ export namespace Skill {
     return ["## Available Skills", ...list.flatMap((skill) => `- **${skill.name}**: ${skill.description}`)].join("\n")
   }
 }
-
-export namespace SkillService {
-  export interface Service {
-    readonly get: (name: string) => Effect.Effect<Skill.Info | undefined>
-    readonly all: () => Effect.Effect<Skill.Info[]>
-    readonly dirs: () => Effect.Effect<string[]>
-    readonly available: (agent?: Agent.Info) => Effect.Effect<Skill.Info[]>
-  }
-}
-
-export class SkillService extends ServiceMap.Service<SkillService, SkillService.Service>()("@opencode/Skill") {
-  static readonly layer = Layer.effect(
-    SkillService,
-    Effect.gen(function* () {
-      const instance = yield* InstanceContext
-
-      const skills: Record<string, Skill.Info> = {}
-      const skillDirs = new Set<string>()
-      let task: Promise<void> | undefined
-
-      const addSkill = async (match: string) => {
-        const md = await ConfigMarkdown.parse(match).catch(async (err) => {
-          const message = ConfigMarkdown.FrontmatterError.isInstance(err)
-            ? err.data.message
-            : `Failed to parse skill ${match}`
-          const { Session } = await import("@/session")
-          Bus.publish(Session.Event.Error, { error: new NamedError.Unknown({ message }).toObject() })
-          log.error("failed to load skill", { skill: match, err })
-          return undefined
-        })
-
-        if (!md) return
-
-        const parsed = Skill.Info.pick({ name: true, description: true }).safeParse(md.data)
-        if (!parsed.success) return
-
-        // Warn on duplicate skill names
-        if (skills[parsed.data.name]) {
-          log.warn("duplicate skill name", {
-            name: parsed.data.name,
-            existing: skills[parsed.data.name].location,
-            duplicate: match,
-          })
-        }
-
-        skillDirs.add(path.dirname(match))
-
-        skills[parsed.data.name] = {
-          name: parsed.data.name,
-          description: parsed.data.description,
-          location: match,
-          content: md.content,
-        }
-      }
-
-      const scanExternal = async (root: string, scope: "global" | "project") => {
-        return Glob.scan(EXTERNAL_SKILL_PATTERN, {
-          cwd: root,
-          absolute: true,
-          include: "file",
-          dot: true,
-          symlink: true,
-        })
-          .then((matches) => Promise.all(matches.map(addSkill)))
-          .catch((error) => {
-            log.error(`failed to scan ${scope} skills`, { dir: root, error })
-          })
-      }
-
-      function ensureScanned() {
-        if (task) return task
-        task = (async () => {
-          // Scan external skill directories (.claude/skills/, .agents/skills/, etc.)
-          // Load global (home) first, then project-level (so project-level overwrites)
-          if (!Flag.OPENCODE_DISABLE_EXTERNAL_SKILLS) {
-            for (const dir of EXTERNAL_DIRS) {
-              const root = path.join(Global.Path.home, dir)
-              if (!(await Filesystem.isDir(root))) continue
-              await scanExternal(root, "global")
-            }
-
-            for await (const root of Filesystem.up({
-              targets: EXTERNAL_DIRS,
-              start: instance.directory,
-              stop: instance.project.worktree,
-            })) {
-              await scanExternal(root, "project")
-            }
-          }
-
-          // Scan .opencode/skill/ directories
-          for (const dir of await Config.directories()) {
-            const matches = await Glob.scan(OPENCODE_SKILL_PATTERN, {
-              cwd: dir,
-              absolute: true,
-              include: "file",
-              symlink: true,
-            })
-            for (const match of matches) {
-              await addSkill(match)
-            }
-          }
-
-          // Scan additional skill paths from config
-          const config = await Config.get()
-          for (const skillPath of config.skills?.paths ?? []) {
-            const expanded = skillPath.startsWith("~/") ? path.join(os.homedir(), skillPath.slice(2)) : skillPath
-            const resolved = path.isAbsolute(expanded) ? expanded : path.join(instance.directory, expanded)
-            if (!(await Filesystem.isDir(resolved))) {
-              log.warn("skill path not found", { path: resolved })
-              continue
-            }
-            const matches = await Glob.scan(SKILL_PATTERN, {
-              cwd: resolved,
-              absolute: true,
-              include: "file",
-              symlink: true,
-            })
-            for (const match of matches) {
-              await addSkill(match)
-            }
-          }
-
-          // Download and load skills from URLs
-          for (const url of config.skills?.urls ?? []) {
-            const list = await Discovery.pull(url)
-            for (const dir of list) {
-              skillDirs.add(dir)
-              const matches = await Glob.scan(SKILL_PATTERN, {
-                cwd: dir,
-                absolute: true,
-                include: "file",
-                symlink: true,
-              })
-              for (const match of matches) {
-                await addSkill(match)
-              }
-            }
-          }
-
-          log.info("init", { count: Object.keys(skills).length })
-        })().catch((err) => {
-          task = undefined
-          throw err
-        })
-        return task
-      }
-
-      return SkillService.of({
-        get: Effect.fn("SkillService.get")(function* (name: string) {
-          yield* Effect.promise(() => ensureScanned())
-          return skills[name]
-        }),
-        all: Effect.fn("SkillService.all")(function* () {
-          yield* Effect.promise(() => ensureScanned())
-          return Object.values(skills)
-        }),
-        dirs: Effect.fn("SkillService.dirs")(function* () {
-          yield* Effect.promise(() => ensureScanned())
-          return Array.from(skillDirs)
-        }),
-        available: Effect.fn("SkillService.available")(function* (agent?: Agent.Info) {
-          yield* Effect.promise(() => ensureScanned())
-          const list = Object.values(skills)
-          if (!agent) return list
-          return list.filter(
-            (skill) => PermissionNext.evaluate("skill", skill.name, agent.permission).action !== "deny",
-          )
-        }),
-      })
-    }),
-  )
-}

packages/opencode/src/tool/edit.ts

@@ -78,7 +78,7 @@ export const EditTool = Tool.define("edit", {
           file: filePath,
           event: existed ? "change" : "add",
         })
-        await FileTime.read(ctx.sessionID, filePath)
+        FileTime.read(ctx.sessionID, filePath)
         return
       }
 
@@ -119,7 +119,7 @@ export const EditTool = Tool.define("edit", {
       diff = trimDiff(
         createTwoFilesPatch(filePath, filePath, normalizeLineEndings(contentOld), normalizeLineEndings(contentNew)),
       )
-      await FileTime.read(ctx.sessionID, filePath)
+      FileTime.read(ctx.sessionID, filePath)
     })
 
     const filediff: Snapshot.FileDiff = {

packages/opencode/src/tool/read.ts

@@ -214,7 +214,7 @@ export const ReadTool = Tool.define("read", {
 
     // just warms the lsp client
     LSP.touchFile(filepath, false)
-    await FileTime.read(ctx.sessionID, filepath)
+    FileTime.read(ctx.sessionID, filepath)
 
     if (instructions.length > 0) {
       output += `\n\n<system-reminder>\n${instructions.map((i) => i.content).join("\n\n")}\n</system-reminder>`

packages/opencode/src/tool/write.ts

@@ -49,7 +49,7 @@ export const WriteTool = Tool.define("write", {
       file: filepath,
       event: exists ? "change" : "add",
     })
-    await FileTime.read(ctx.sessionID, filepath)
+    FileTime.read(ctx.sessionID, filepath)
 
     let output = "Wrote file successfully."
     await LSP.touchFile(filepath, true)

packages/opencode/src/util/instance-state.ts

@@ -0,0 +1,63 @@
+import { Effect, ScopedCache, Scope } from "effect"
+
+import { Instance } from "@/project/instance"
+
+type Disposer = (directory: string) => Effect.Effect<void>
+const disposers = new Set<Disposer>()
+
+const TypeId = "~opencode/InstanceState"
+
+/**
+ * Effect version of `Instance.state` — lazily-initialized, per-directory
+ * cached state for Effect services.
+ *
+ * Values are created on first access for a given directory and cached for
+ * subsequent reads. Concurrent access shares a single initialization —
+ * no duplicate work or races. Use `Effect.acquireRelease` in `init` if
+ * the value needs cleanup on disposal.
+ */
+export interface InstanceState<A, E = never, R = never> {
+  readonly [TypeId]: typeof TypeId
+  readonly cache: ScopedCache.ScopedCache<string, A, E, R>
+}
+
+export namespace InstanceState {
+  /** Create a new InstanceState with the given initializer. */
+  export const make = <A, E = never, R = never>(
+    init: (directory: string) => Effect.Effect<A, E, R | Scope.Scope>,
+  ): Effect.Effect<InstanceState<A, E, Exclude<R, Scope.Scope>>, never, R | Scope.Scope> =>
+    Effect.gen(function* () {
+      const cache = yield* ScopedCache.make<string, A, E, R>({
+        capacity: Number.POSITIVE_INFINITY,
+        lookup: init,
+      })
+
+      const disposer: Disposer = (directory) => ScopedCache.invalidate(cache, directory)
+      disposers.add(disposer)
+      yield* Effect.addFinalizer(() => Effect.sync(() => void disposers.delete(disposer)))
+
+      return {
+        [TypeId]: TypeId,
+        cache,
+      }
+    })
+
+  /** Get the cached value for the current directory, initializing it if needed. */
+  export const get = <A, E, R>(self: InstanceState<A, E, R>) =>
+    Effect.suspend(() => ScopedCache.get(self.cache, Instance.directory))
+
+  /** Check whether a value exists for the current directory. */
+  export const has = <A, E, R>(self: InstanceState<A, E, R>) =>
+    Effect.suspend(() => ScopedCache.has(self.cache, Instance.directory))
+
+  /** Invalidate the cached value for the current directory. */
+  export const invalidate = <A, E, R>(self: InstanceState<A, E, R>) =>
+    Effect.suspend(() => ScopedCache.invalidate(self.cache, Instance.directory))
+
+  /** Invalidate the given directory across all InstanceState caches. */
+  export const dispose = (directory: string) =>
+    Effect.all(
+      [...disposers].map((disposer) => disposer(directory)),
+      { concurrency: "unbounded" },
+    )
+}

packages/opencode/test/file/index.test.ts

@@ -1,5 +1,4 @@
 import { describe, test, expect } from "bun:test"
-import { $ } from "bun"
 import path from "path"
 import fs from "fs/promises"
 import { File } from "../../src/file"
@@ -392,469 +391,4 @@ describe("file/index Filesystem patterns", () => {
       })
     })
   })
-
-  describe("File.status()", () => {
-    test("detects modified file", async () => {
-      await using tmp = await tmpdir({ git: true })
-      const filepath = path.join(tmp.path, "file.txt")
-      await fs.writeFile(filepath, "original\n", "utf-8")
-      await $`git add .`.cwd(tmp.path).quiet()
-      await $`git commit --no-gpg-sign -m "add file"`.cwd(tmp.path).quiet()
-      await fs.writeFile(filepath, "modified\nextra line\n", "utf-8")
-
-      await Instance.provide({
-        directory: tmp.path,
-        fn: async () => {
-          const result = await File.status()
-          const entry = result.find((f) => f.path === "file.txt")
-          expect(entry).toBeDefined()
-          expect(entry!.status).toBe("modified")
-          expect(entry!.added).toBeGreaterThan(0)
-          expect(entry!.removed).toBeGreaterThan(0)
-        },
-      })
-    })
-
-    test("detects untracked file as added", async () => {
-      await using tmp = await tmpdir({ git: true })
-      await fs.writeFile(path.join(tmp.path, "new.txt"), "line1\nline2\nline3\n", "utf-8")
-
-      await Instance.provide({
-        directory: tmp.path,
-        fn: async () => {
-          const result = await File.status()
-          const entry = result.find((f) => f.path === "new.txt")
-          expect(entry).toBeDefined()
-          expect(entry!.status).toBe("added")
-          expect(entry!.added).toBe(4) // 3 lines + trailing newline splits to 4
-          expect(entry!.removed).toBe(0)
-        },
-      })
-    })
-
-    test("detects deleted file", async () => {
-      await using tmp = await tmpdir({ git: true })
-      const filepath = path.join(tmp.path, "gone.txt")
-      await fs.writeFile(filepath, "content\n", "utf-8")
-      await $`git add .`.cwd(tmp.path).quiet()
-      await $`git commit --no-gpg-sign -m "add file"`.cwd(tmp.path).quiet()
-      await fs.rm(filepath)
-
-      await Instance.provide({
-        directory: tmp.path,
-        fn: async () => {
-          const result = await File.status()
-          // Deleted files appear in both numstat (as "modified") and diff-filter=D (as "deleted")
-          const entries = result.filter((f) => f.path === "gone.txt")
-          expect(entries.some((e) => e.status === "deleted")).toBe(true)
-        },
-      })
-    })
-
-    test("detects mixed changes", async () => {
-      await using tmp = await tmpdir({ git: true })
-      await fs.writeFile(path.join(tmp.path, "keep.txt"), "keep\n", "utf-8")
-      await fs.writeFile(path.join(tmp.path, "remove.txt"), "remove\n", "utf-8")
-      await $`git add .`.cwd(tmp.path).quiet()
-      await $`git commit --no-gpg-sign -m "initial"`.cwd(tmp.path).quiet()
-
-      // Modify one, delete one, add one
-      await fs.writeFile(path.join(tmp.path, "keep.txt"), "changed\n", "utf-8")
-      await fs.rm(path.join(tmp.path, "remove.txt"))
-      await fs.writeFile(path.join(tmp.path, "brand-new.txt"), "hello\n", "utf-8")
-
-      await Instance.provide({
-        directory: tmp.path,
-        fn: async () => {
-          const result = await File.status()
-          expect(result.some((f) => f.path === "keep.txt" && f.status === "modified")).toBe(true)
-          expect(result.some((f) => f.path === "remove.txt" && f.status === "deleted")).toBe(true)
-          expect(result.some((f) => f.path === "brand-new.txt" && f.status === "added")).toBe(true)
-        },
-      })
-    })
-
-    test("returns empty for non-git project", async () => {
-      await using tmp = await tmpdir()
-
-      await Instance.provide({
-        directory: tmp.path,
-        fn: async () => {
-          const result = await File.status()
-          expect(result).toEqual([])
-        },
-      })
-    })
-
-    test("returns empty for clean repo", async () => {
-      await using tmp = await tmpdir({ git: true })
-
-      await Instance.provide({
-        directory: tmp.path,
-        fn: async () => {
-          const result = await File.status()
-          expect(result).toEqual([])
-        },
-      })
-    })
-
-    test("parses binary numstat as 0", async () => {
-      await using tmp = await tmpdir({ git: true })
-      const filepath = path.join(tmp.path, "data.bin")
-      // Write content with null bytes so git treats it as binary
-      const binaryData = Buffer.alloc(256)
-      for (let i = 0; i < 256; i++) binaryData[i] = i
-      await fs.writeFile(filepath, binaryData)
-      await $`git add .`.cwd(tmp.path).quiet()
-      await $`git commit --no-gpg-sign -m "add binary"`.cwd(tmp.path).quiet()
-      // Modify the binary
-      const modified = Buffer.alloc(512)
-      for (let i = 0; i < 512; i++) modified[i] = i % 256
-      await fs.writeFile(filepath, modified)
-
-      await Instance.provide({
-        directory: tmp.path,
-        fn: async () => {
-          const result = await File.status()
-          const entry = result.find((f) => f.path === "data.bin")
-          expect(entry).toBeDefined()
-          expect(entry!.status).toBe("modified")
-          expect(entry!.added).toBe(0)
-          expect(entry!.removed).toBe(0)
-        },
-      })
-    })
-  })
-
-  describe("File.list()", () => {
-    test("returns files and directories with correct shape", async () => {
-      await using tmp = await tmpdir({ git: true })
-      await fs.mkdir(path.join(tmp.path, "subdir"))
-      await fs.writeFile(path.join(tmp.path, "file.txt"), "content", "utf-8")
-      await fs.writeFile(path.join(tmp.path, "subdir", "nested.txt"), "nested", "utf-8")
-
-      await Instance.provide({
-        directory: tmp.path,
-        fn: async () => {
-          const nodes = await File.list()
-          expect(nodes.length).toBeGreaterThanOrEqual(2)
-          for (const node of nodes) {
-            expect(node).toHaveProperty("name")
-            expect(node).toHaveProperty("path")
-            expect(node).toHaveProperty("absolute")
-            expect(node).toHaveProperty("type")
-            expect(node).toHaveProperty("ignored")
-            expect(["file", "directory"]).toContain(node.type)
-          }
-        },
-      })
-    })
-
-    test("sorts directories before files, alphabetical within each", async () => {
-      await using tmp = await tmpdir({ git: true })
-      await fs.mkdir(path.join(tmp.path, "beta"))
-      await fs.mkdir(path.join(tmp.path, "alpha"))
-      await fs.writeFile(path.join(tmp.path, "zz.txt"), "", "utf-8")
-      await fs.writeFile(path.join(tmp.path, "aa.txt"), "", "utf-8")
-
-      await Instance.provide({
-        directory: tmp.path,
-        fn: async () => {
-          const nodes = await File.list()
-          const dirs = nodes.filter((n) => n.type === "directory")
-          const files = nodes.filter((n) => n.type === "file")
-          // Dirs come first
-          const firstFile = nodes.findIndex((n) => n.type === "file")
-          const lastDir = nodes.findLastIndex((n) => n.type === "directory")
-          if (lastDir >= 0 && firstFile >= 0) {
-            expect(lastDir).toBeLessThan(firstFile)
-          }
-          // Alphabetical within dirs
-          expect(dirs.map((d) => d.name)).toEqual(dirs.map((d) => d.name).toSorted())
-          // Alphabetical within files
-          expect(files.map((f) => f.name)).toEqual(files.map((f) => f.name).toSorted())
-        },
-      })
-    })
-
-    test("excludes .git and .DS_Store", async () => {
-      await using tmp = await tmpdir({ git: true })
-      await fs.writeFile(path.join(tmp.path, ".DS_Store"), "", "utf-8")
-      await fs.writeFile(path.join(tmp.path, "visible.txt"), "", "utf-8")
-
-      await Instance.provide({
-        directory: tmp.path,
-        fn: async () => {
-          const nodes = await File.list()
-          const names = nodes.map((n) => n.name)
-          expect(names).not.toContain(".git")
-          expect(names).not.toContain(".DS_Store")
-          expect(names).toContain("visible.txt")
-        },
-      })
-    })
-
-    test("marks gitignored files as ignored", async () => {
-      await using tmp = await tmpdir({ git: true })
-      await fs.writeFile(path.join(tmp.path, ".gitignore"), "*.log\nbuild/\n", "utf-8")
-      await fs.writeFile(path.join(tmp.path, "app.log"), "log data", "utf-8")
-      await fs.writeFile(path.join(tmp.path, "main.ts"), "code", "utf-8")
-      await fs.mkdir(path.join(tmp.path, "build"))
-
-      await Instance.provide({
-        directory: tmp.path,
-        fn: async () => {
-          const nodes = await File.list()
-          const logNode = nodes.find((n) => n.name === "app.log")
-          const tsNode = nodes.find((n) => n.name === "main.ts")
-          const buildNode = nodes.find((n) => n.name === "build")
-          expect(logNode?.ignored).toBe(true)
-          expect(tsNode?.ignored).toBe(false)
-          expect(buildNode?.ignored).toBe(true)
-        },
-      })
-    })
-
-    test("lists subdirectory contents", async () => {
-      await using tmp = await tmpdir({ git: true })
-      await fs.mkdir(path.join(tmp.path, "sub"))
-      await fs.writeFile(path.join(tmp.path, "sub", "a.txt"), "", "utf-8")
-      await fs.writeFile(path.join(tmp.path, "sub", "b.txt"), "", "utf-8")
-
-      await Instance.provide({
-        directory: tmp.path,
-        fn: async () => {
-          const nodes = await File.list("sub")
-          expect(nodes.length).toBe(2)
-          expect(nodes.map((n) => n.name).sort()).toEqual(["a.txt", "b.txt"])
-          // Paths should be relative to project root (normalize for Windows)
-          expect(nodes[0].path.replaceAll("\\", "/").startsWith("sub/")).toBe(true)
-        },
-      })
-    })
-
-    test("throws for paths outside project directory", async () => {
-      await using tmp = await tmpdir({ git: true })
-
-      await Instance.provide({
-        directory: tmp.path,
-        fn: async () => {
-          await expect(File.list("../outside")).rejects.toThrow("Access denied")
-        },
-      })
-    })
-
-    test("works without git", async () => {
-      await using tmp = await tmpdir()
-      await fs.writeFile(path.join(tmp.path, "file.txt"), "hi", "utf-8")
-
-      await Instance.provide({
-        directory: tmp.path,
-        fn: async () => {
-          const nodes = await File.list()
-          expect(nodes.length).toBeGreaterThanOrEqual(1)
-          // Without git, ignored should be false for all
-          for (const node of nodes) {
-            expect(node.ignored).toBe(false)
-          }
-        },
-      })
-    })
-  })
-
-  describe("File.search()", () => {
-    async function setupSearchableRepo() {
-      const tmp = await tmpdir({ git: true })
-      await fs.writeFile(path.join(tmp.path, "index.ts"), "code", "utf-8")
-      await fs.writeFile(path.join(tmp.path, "utils.ts"), "utils", "utf-8")
-      await fs.writeFile(path.join(tmp.path, "readme.md"), "readme", "utf-8")
-      await fs.mkdir(path.join(tmp.path, "src"))
-      await fs.mkdir(path.join(tmp.path, ".hidden"))
-      await fs.writeFile(path.join(tmp.path, "src", "main.ts"), "main", "utf-8")
-      await fs.writeFile(path.join(tmp.path, ".hidden", "secret.ts"), "secret", "utf-8")
-      return tmp
-    }
-
-    test("empty query returns files", async () => {
-      await using tmp = await setupSearchableRepo()
-
-      await Instance.provide({
-        directory: tmp.path,
-        fn: async () => {
-          File.init()
-          // Give the background scan time to populate
-          await new Promise((r) => setTimeout(r, 500))
-
-          const result = await File.search({ query: "", type: "file" })
-          expect(result.length).toBeGreaterThan(0)
-        },
-      })
-    })
-
-    test("empty query returns dirs sorted with hidden last", async () => {
-      await using tmp = await setupSearchableRepo()
-
-      await Instance.provide({
-        directory: tmp.path,
-        fn: async () => {
-          File.init()
-          await new Promise((r) => setTimeout(r, 500))
-
-          const result = await File.search({ query: "", type: "directory" })
-          expect(result.length).toBeGreaterThan(0)
-          // Find first hidden dir index
-          const firstHidden = result.findIndex((d) => d.split("/").some((p) => p.startsWith(".") && p.length > 1))
-          const lastVisible = result.findLastIndex((d) => !d.split("/").some((p) => p.startsWith(".") && p.length > 1))
-          if (firstHidden >= 0 && lastVisible >= 0) {
-            expect(firstHidden).toBeGreaterThan(lastVisible)
-          }
-        },
-      })
-    })
-
-    test("fuzzy matches file names", async () => {
-      await using tmp = await setupSearchableRepo()
-
-      await Instance.provide({
-        directory: tmp.path,
-        fn: async () => {
-          File.init()
-          await new Promise((r) => setTimeout(r, 500))
-
-          const result = await File.search({ query: "main", type: "file" })
-          expect(result.some((f) => f.includes("main"))).toBe(true)
-        },
-      })
-    })
-
-    test("type filter returns only files", async () => {
-      await using tmp = await setupSearchableRepo()
-
-      await Instance.provide({
-        directory: tmp.path,
-        fn: async () => {
-          File.init()
-          await new Promise((r) => setTimeout(r, 500))
-
-          const result = await File.search({ query: "", type: "file" })
-          // Files don't end with /
-          for (const f of result) {
-            expect(f.endsWith("/")).toBe(false)
-          }
-        },
-      })
-    })
-
-    test("type filter returns only directories", async () => {
-      await using tmp = await setupSearchableRepo()
-
-      await Instance.provide({
-        directory: tmp.path,
-        fn: async () => {
-          File.init()
-          await new Promise((r) => setTimeout(r, 500))
-
-          const result = await File.search({ query: "", type: "directory" })
-          // Directories end with /
-          for (const d of result) {
-            expect(d.endsWith("/")).toBe(true)
-          }
-        },
-      })
-    })
-
-    test("respects limit", async () => {
-      await using tmp = await setupSearchableRepo()
-
-      await Instance.provide({
-        directory: tmp.path,
-        fn: async () => {
-          File.init()
-          await new Promise((r) => setTimeout(r, 500))
-
-          const result = await File.search({ query: "", type: "file", limit: 2 })
-          expect(result.length).toBeLessThanOrEqual(2)
-        },
-      })
-    })
-
-    test("query starting with dot prefers hidden files", async () => {
-      await using tmp = await setupSearchableRepo()
-
-      await Instance.provide({
-        directory: tmp.path,
-        fn: async () => {
-          File.init()
-          await new Promise((r) => setTimeout(r, 500))
-
-          const result = await File.search({ query: ".hidden", type: "directory" })
-          expect(result.length).toBeGreaterThan(0)
-          expect(result[0]).toContain(".hidden")
-        },
-      })
-    })
-  })
-
-  describe("File.read() - diff/patch", () => {
-    test("returns diff and patch for modified tracked file", async () => {
-      await using tmp = await tmpdir({ git: true })
-      const filepath = path.join(tmp.path, "file.txt")
-      await fs.writeFile(filepath, "original content\n", "utf-8")
-      await $`git add .`.cwd(tmp.path).quiet()
-      await $`git commit --no-gpg-sign -m "add file"`.cwd(tmp.path).quiet()
-      await fs.writeFile(filepath, "modified content\n", "utf-8")
-
-      await Instance.provide({
-        directory: tmp.path,
-        fn: async () => {
-          const result = await File.read("file.txt")
-          expect(result.type).toBe("text")
-          expect(result.content).toBe("modified content")
-          expect(result.diff).toBeDefined()
-          expect(result.diff).toContain("original content")
-          expect(result.diff).toContain("modified content")
-          expect(result.patch).toBeDefined()
-          expect(result.patch!.hunks.length).toBeGreaterThan(0)
-        },
-      })
-    })
-
-    test("returns diff for staged changes", async () => {
-      await using tmp = await tmpdir({ git: true })
-      const filepath = path.join(tmp.path, "staged.txt")
-      await fs.writeFile(filepath, "before\n", "utf-8")
-      await $`git add .`.cwd(tmp.path).quiet()
-      await $`git commit --no-gpg-sign -m "add file"`.cwd(tmp.path).quiet()
-      await fs.writeFile(filepath, "after\n", "utf-8")
-      await $`git add .`.cwd(tmp.path).quiet()
-
-      await Instance.provide({
-        directory: tmp.path,
-        fn: async () => {
-          const result = await File.read("staged.txt")
-          expect(result.diff).toBeDefined()
-          expect(result.patch).toBeDefined()
-        },
-      })
-    })
-
-    test("returns no diff for unmodified file", async () => {
-      await using tmp = await tmpdir({ git: true })
-      const filepath = path.join(tmp.path, "clean.txt")
-      await fs.writeFile(filepath, "unchanged\n", "utf-8")
-      await $`git add .`.cwd(tmp.path).quiet()
-      await $`git commit --no-gpg-sign -m "add file"`.cwd(tmp.path).quiet()
-
-      await Instance.provide({
-        directory: tmp.path,
-        fn: async () => {
-          const result = await File.read("clean.txt")
-          expect(result.type).toBe("text")
-          expect(result.content).toBe("unchanged")
-          expect(result.diff).toBeUndefined()
-          expect(result.patch).toBeUndefined()
-        },
-      })
-    })
-  })
 })

packages/opencode/test/file/time.test.ts

@@ -1,16 +1,13 @@
-import { describe, test, expect, afterEach } from "bun:test"
+import { describe, test, expect, beforeEach } from "bun:test"
 import path from "path"
 import fs from "fs/promises"
 import { FileTime } from "../../src/file/time"
 import { Instance } from "../../src/project/instance"
-import { SessionID } from "../../src/session/schema"
 import { Filesystem } from "../../src/util/filesystem"
 import { tmpdir } from "../fixture/fixture"
 
-afterEach(() => Instance.disposeAll())
-
 describe("file/time", () => {
-  const sessionID = SessionID.make("ses_00000000000000000000000001")
+  const sessionID = "test-session-123"
 
   describe("read() and get()", () => {
     test("stores read timestamp", async () => {
@@ -21,13 +18,12 @@ describe("file/time", () => {
       await Instance.provide({
         directory: tmp.path,
         fn: async () => {
-          const before = await FileTime.get(sessionID, filepath)
+          const before = FileTime.get(sessionID, filepath)
           expect(before).toBeUndefined()
 
-          await FileTime.read(sessionID, filepath)
-          await Bun.sleep(10)
+          FileTime.read(sessionID, filepath)
 
-          const after = await FileTime.get(sessionID, filepath)
+          const after = FileTime.get(sessionID, filepath)
           expect(after).toBeInstanceOf(Date)
           expect(after!.getTime()).toBeGreaterThan(0)
         },
@@ -42,12 +38,11 @@ describe("file/time", () => {
       await Instance.provide({
         directory: tmp.path,
         fn: async () => {
-          await FileTime.read(SessionID.make("ses_00000000000000000000000002"), filepath)
-          await FileTime.read(SessionID.make("ses_00000000000000000000000003"), filepath)
-          await Bun.sleep(10)
+          FileTime.read("session1", filepath)
+          FileTime.read("session2", filepath)
 
-          const time1 = await FileTime.get(SessionID.make("ses_00000000000000000000000002"), filepath)
-          const time2 = await FileTime.get(SessionID.make("ses_00000000000000000000000003"), filepath)
+          const time1 = FileTime.get("session1", filepath)
+          const time2 = FileTime.get("session2", filepath)
 
           expect(time1).toBeDefined()
           expect(time2).toBeDefined()
@@ -64,16 +59,14 @@ describe("file/time", () => {
         directory: tmp.path,
         fn: async () => {
           FileTime.read(sessionID, filepath)
-          await Bun.sleep(10)
-          const first = await FileTime.get(sessionID, filepath)
+          const first = FileTime.get(sessionID, filepath)!
 
-          await Bun.sleep(10)
+          await new Promise((resolve) => setTimeout(resolve, 10))
 
           FileTime.read(sessionID, filepath)
-          await Bun.sleep(10)
-          const second = await FileTime.get(sessionID, filepath)
+          const second = FileTime.get(sessionID, filepath)!
 
-          expect(second!.getTime()).toBeGreaterThanOrEqual(first!.getTime())
+          expect(second.getTime()).toBeGreaterThanOrEqual(first.getTime())
         },
       })
     })
@@ -89,7 +82,8 @@ describe("file/time", () => {
         directory: tmp.path,
         fn: async () => {
           FileTime.read(sessionID, filepath)
-          await Bun.sleep(10)
+
+          // Should not throw
           await FileTime.assert(sessionID, filepath)
         },
       })
@@ -117,8 +111,13 @@ describe("file/time", () => {
         directory: tmp.path,
         fn: async () => {
           FileTime.read(sessionID, filepath)
-          await Bun.sleep(100)
+
+          // Wait to ensure different timestamps
+          await new Promise((resolve) => setTimeout(resolve, 100))
+
+          // Modify file after reading
           await fs.writeFile(filepath, "modified content", "utf-8")
+
           await expect(FileTime.assert(sessionID, filepath)).rejects.toThrow("modified since it was last read")
         },
       })
@@ -133,7 +132,7 @@ describe("file/time", () => {
         directory: tmp.path,
         fn: async () => {
           FileTime.read(sessionID, filepath)
-          await Bun.sleep(100)
+          await new Promise((resolve) => setTimeout(resolve, 100))
           await fs.writeFile(filepath, "modified", "utf-8")
 
           let error: Error | undefined
@@ -148,6 +147,28 @@ describe("file/time", () => {
         },
       })
     })
+
+    test("skips check when OPENCODE_DISABLE_FILETIME_CHECK is true", async () => {
+      await using tmp = await tmpdir()
+      const filepath = path.join(tmp.path, "file.txt")
+      await fs.writeFile(filepath, "content", "utf-8")
+
+      await Instance.provide({
+        directory: tmp.path,
+        fn: async () => {
+          const { Flag } = await import("../../src/flag/flag")
+          const original = Flag.OPENCODE_DISABLE_FILETIME_CHECK
+          ;(Flag as { OPENCODE_DISABLE_FILETIME_CHECK: boolean }).OPENCODE_DISABLE_FILETIME_CHECK = true
+
+          try {
+            // Should not throw even though file wasn't read
+            await FileTime.assert(sessionID, filepath)
+          } finally {
+            ;(Flag as { OPENCODE_DISABLE_FILETIME_CHECK: boolean }).OPENCODE_DISABLE_FILETIME_CHECK = original
+          }
+        },
+      })
+    })
   })
 
   describe("withLock()", () => {
@@ -194,7 +215,7 @@ describe("file/time", () => {
 
           const op1 = FileTime.withLock(filepath, async () => {
             order.push(1)
-            await Bun.sleep(50)
+            await new Promise((resolve) => setTimeout(resolve, 10))
             order.push(2)
           })
 
@@ -204,7 +225,12 @@ describe("file/time", () => {
           })
 
           await Promise.all([op1, op2])
-          expect(order).toEqual([1, 2, 3, 4])
+
+          // Operations should be serialized
+          expect(order).toContain(1)
+          expect(order).toContain(2)
+          expect(order).toContain(3)
+          expect(order).toContain(4)
         },
       })
     })
@@ -222,8 +248,8 @@ describe("file/time", () => {
 
           const op1 = FileTime.withLock(filepath1, async () => {
             started1 = true
-            await Bun.sleep(50)
-            expect(started2).toBe(true)
+            await new Promise((resolve) => setTimeout(resolve, 50))
+            expect(started2).toBe(true) // op2 should have started while op1 is running
           })
 
           const op2 = FileTime.withLock(filepath2, async () => {
@@ -231,6 +257,7 @@ describe("file/time", () => {
           })
 
           await Promise.all([op1, op2])
+
           expect(started1).toBe(true)
           expect(started2).toBe(true)
         },
@@ -250,6 +277,7 @@ describe("file/time", () => {
             }),
           ).rejects.toThrow("Test error")
 
+          // Lock should be released, subsequent operations should work
           let executed = false
           await FileTime.withLock(filepath, async () => {
             executed = true
@@ -258,6 +286,31 @@ describe("file/time", () => {
         },
       })
     })
+
+    test("deadlocks on nested locks (expected behavior)", async () => {
+      await using tmp = await tmpdir()
+      const filepath = path.join(tmp.path, "file.txt")
+
+      await Instance.provide({
+        directory: tmp.path,
+        fn: async () => {
+          // Nested locks on same file cause deadlock - this is expected
+          // The outer lock waits for inner to complete, but inner waits for outer to release
+          const timeout = new Promise<never>((_, reject) =>
+            setTimeout(() => reject(new Error("Deadlock detected")), 100),
+          )
+
+          const nestedLock = FileTime.withLock(filepath, async () => {
+            return FileTime.withLock(filepath, async () => {
+              return "inner"
+            })
+          })
+
+          // Should timeout due to deadlock
+          await expect(Promise.race([nestedLock, timeout])).rejects.toThrow("Deadlock detected")
+        },
+      })
+    })
   })
 
   describe("stat() Filesystem.stat pattern", () => {
@@ -270,12 +323,12 @@ describe("file/time", () => {
         directory: tmp.path,
         fn: async () => {
           FileTime.read(sessionID, filepath)
-          await Bun.sleep(10)
 
           const stats = Filesystem.stat(filepath)
           expect(stats?.mtime).toBeInstanceOf(Date)
           expect(stats!.mtime.getTime()).toBeGreaterThan(0)
 
+          // FileTime.assert uses this stat internally
           await FileTime.assert(sessionID, filepath)
         },
       })
@@ -290,11 +343,11 @@ describe("file/time", () => {
         directory: tmp.path,
         fn: async () => {
           FileTime.read(sessionID, filepath)
-          await Bun.sleep(10)
 
           const originalStat = Filesystem.stat(filepath)
 
-          await Bun.sleep(100)
+          // Wait and modify
+          await new Promise((resolve) => setTimeout(resolve, 100))
           await fs.writeFile(filepath, "modified", "utf-8")
 
           const newStat = Filesystem.stat(filepath)

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

@@ -1,236 +0,0 @@
-import { $ } from "bun"
-import { afterEach, describe, expect, test } from "bun:test"
-import fs from "fs/promises"
-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 { 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
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-type BusUpdate = { directory?: string; payload: { type: string; properties: WatcherEvent } }
-type WatcherEvent = { file: string; event: "add" | "change" | "unlink" }
-
-/** Run `body` with a live FileWatcherService. */
-function withWatcher<E>(directory: string, body: Effect.Effect<void, E>) {
-  return withServices(
-    directory,
-    FileWatcherService.layer,
-    async (rt) => {
-      await rt.runPromise(FileWatcherService.use((s) => s.init()))
-      await Effect.runPromise(ready(directory))
-      await Effect.runPromise(body)
-    },
-    { provide: [watcherConfigLayer] },
-  )
-}
-
-function listen(directory: string, check: (evt: WatcherEvent) => boolean, hit: (evt: WatcherEvent) => void) {
-  let done = false
-
-  function on(evt: BusUpdate) {
-    if (done) return
-    if (evt.directory !== directory) return
-    if (evt.payload.type !== FileWatcher.Event.Updated.type) return
-    if (!check(evt.payload.properties)) return
-    hit(evt.payload.properties)
-  }
-
-  function cleanup() {
-    if (done) return
-    done = true
-    GlobalBus.off("event", on)
-  }
-
-  GlobalBus.on("event", on)
-  return cleanup
-}
-
-function wait(directory: string, check: (evt: WatcherEvent) => boolean) {
-  return Effect.callback<WatcherEvent>((resume) => {
-    const cleanup = listen(directory, check, (evt) => {
-      cleanup()
-      resume(Effect.succeed(evt))
-    })
-    return Effect.sync(cleanup)
-  }).pipe(Effect.timeout("5 seconds"))
-}
-
-function nextUpdate<E>(directory: string, check: (evt: WatcherEvent) => boolean, trigger: Effect.Effect<void, E>) {
-  return Effect.acquireUseRelease(
-    wait(directory, check).pipe(Effect.forkChild({ startImmediately: true })),
-    (fiber) =>
-      Effect.gen(function* () {
-        yield* trigger
-        return yield* Fiber.join(fiber)
-      }),
-    Fiber.interrupt,
-  )
-}
-
-/** Effect that asserts no matching event arrives within `ms`. */
-function noUpdate<E>(
-  directory: string,
-  check: (evt: WatcherEvent) => boolean,
-  trigger: Effect.Effect<void, E>,
-  ms = 500,
-) {
-  return Effect.gen(function* () {
-    const deferred = yield* Deferred.make<WatcherEvent>()
-
-    yield* Effect.acquireUseRelease(
-      Effect.sync(() =>
-        listen(directory, check, (evt) => {
-          Effect.runSync(Deferred.succeed(deferred, evt))
-        }),
-      ),
-      () =>
-        Effect.gen(function* () {
-          yield* trigger
-          expect(yield* Deferred.await(deferred).pipe(Effect.timeoutOption(`${ms} millis`))).toEqual(Option.none())
-        }),
-      (cleanup) => Effect.sync(cleanup),
-    )
-  })
-}
-
-function ready(directory: string) {
-  const file = path.join(directory, `.watcher-${Math.random().toString(36).slice(2)}`)
-  const head = path.join(directory, ".git", "HEAD")
-
-  return Effect.gen(function* () {
-    yield* nextUpdate(
-      directory,
-      (evt) => evt.file === file && evt.event === "add",
-      Effect.promise(() => fs.writeFile(file, "ready")),
-    ).pipe(Effect.ensuring(Effect.promise(() => fs.rm(file, { force: true }).catch(() => undefined))), Effect.asVoid)
-
-    const git = yield* Effect.promise(() =>
-      fs
-        .stat(head)
-        .then(() => true)
-        .catch(() => false),
-    )
-    if (!git) return
-
-    const branch = `watch-${Math.random().toString(36).slice(2)}`
-    const hash = yield* Effect.promise(() => $`git rev-parse HEAD`.cwd(directory).quiet().text())
-    yield* nextUpdate(
-      directory,
-      (evt) => evt.file === head && evt.event !== "unlink",
-      Effect.promise(async () => {
-        await fs.writeFile(path.join(directory, ".git", "refs", "heads", branch), hash.trim() + "\n")
-        await fs.writeFile(head, `ref: refs/heads/${branch}\n`)
-      }),
-    ).pipe(Effect.asVoid)
-  })
-}
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describeWatcher("FileWatcherService", () => {
-  afterEach(() => Instance.disposeAll())
-
-  test("publishes root create, update, and delete events", async () => {
-    await using tmp = await tmpdir({ git: true })
-    const file = path.join(tmp.path, "watch.txt")
-    const dir = tmp.path
-    const cases = [
-      { event: "add" as const, trigger: Effect.promise(() => fs.writeFile(file, "a")) },
-      { event: "change" as const, trigger: Effect.promise(() => fs.writeFile(file, "b")) },
-      { event: "unlink" as const, trigger: Effect.promise(() => fs.unlink(file)) },
-    ]
-
-    await withWatcher(
-      dir,
-      Effect.forEach(cases, ({ event, trigger }) =>
-        nextUpdate(dir, (evt) => evt.file === file && evt.event === event, trigger).pipe(
-          Effect.tap((evt) => Effect.sync(() => expect(evt).toEqual({ file, event }))),
-        ),
-      ),
-    )
-  })
-
-  test("watches non-git roots", async () => {
-    await using tmp = await tmpdir()
-    const file = path.join(tmp.path, "plain.txt")
-    const dir = tmp.path
-
-    await withWatcher(
-      dir,
-      nextUpdate(
-        dir,
-        (e) => e.file === file && e.event === "add",
-        Effect.promise(() => fs.writeFile(file, "plain")),
-      ).pipe(Effect.tap((evt) => Effect.sync(() => expect(evt).toEqual({ file, event: "add" })))),
-    )
-  })
-
-  test("cleanup stops publishing events", async () => {
-    await using tmp = await tmpdir({ git: true })
-    const file = path.join(tmp.path, "after-dispose.txt")
-
-    // Start and immediately stop the watcher (withWatcher disposes on exit)
-    await withWatcher(tmp.path, Effect.void)
-
-    // Now write a file — no watcher should be listening
-    await Effect.runPromise(
-      noUpdate(
-        tmp.path,
-        (e) => e.file === file,
-        Effect.promise(() => fs.writeFile(file, "gone")),
-      ),
-    )
-  })
-
-  test("ignores .git/index changes", async () => {
-    await using tmp = await tmpdir({ git: true })
-    const gitIndex = path.join(tmp.path, ".git", "index")
-    const edit = path.join(tmp.path, "tracked.txt")
-
-    await withWatcher(
-      tmp.path,
-      noUpdate(
-        tmp.path,
-        (e) => e.file === gitIndex,
-        Effect.promise(async () => {
-          await fs.writeFile(edit, "a")
-          await $`git add .`.cwd(tmp.path).quiet().nothrow()
-        }),
-      ),
-    )
-  })
-
-  test("publishes .git/HEAD events", async () => {
-    await using tmp = await tmpdir({ git: true })
-    const head = path.join(tmp.path, ".git", "HEAD")
-    const branch = `watch-${Math.random().toString(36).slice(2)}`
-    await $`git branch ${branch}`.cwd(tmp.path).quiet()
-
-    await withWatcher(
-      tmp.path,
-      nextUpdate(
-        tmp.path,
-        (evt) => evt.file === head && evt.event !== "unlink",
-        Effect.promise(() => fs.writeFile(head, `ref: refs/heads/${branch}\n`)),
-      ).pipe(
-        Effect.tap((evt) =>
-          Effect.sync(() => {
-            expect(evt.file).toBe(head)
-            expect(["add", "change"]).toContain(evt.event)
-          }),
-        ),
-      ),
-    )
-  })
-})

packages/opencode/test/fixture/instance.ts

@@ -1,47 +0,0 @@
-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. */
-export const watcherConfigLayer = ConfigProvider.layer(
-  ConfigProvider.fromUnknown({
-    OPENCODE_EXPERIMENTAL_FILEWATCHER: "true",
-    OPENCODE_EXPERIMENTAL_DISABLE_FILEWATCHER: "false",
-  }),
-)
-
-/**
- * Boot an Instance with the given service layers and run `body` with
- * 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>,
-  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, project: Instance.project }),
-      )
-      let resolved: Layer.Layer<S> = Layer.fresh(layer).pipe(Layer.provide(ctx)) as any
-      if (options?.provide) {
-        for (const l of options.provide) {
-          resolved = resolved.pipe(Layer.provide(l)) as any
-        }
-      }
-      const rt = ManagedRuntime.make(resolved)
-      try {
-        await body(rt)
-      } finally {
-        await rt.dispose()
-      }
-    },
-  })
-}

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

@@ -1,64 +0,0 @@
-import { afterEach, describe, expect, test } from "bun:test"
-import { tmpdir } from "../fixture/fixture"
-import { withServices } from "../fixture/instance"
-import { FormatService } from "../../src/format"
-import { Instance } from "../../src/project/instance"
-
-describe("FormatService", () => {
-  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()))
-      expect(Array.isArray(statuses)).toBe(true)
-      expect(statuses.length).toBeGreaterThan(0)
-
-      for (const s of statuses) {
-        expect(typeof s.name).toBe("string")
-        expect(Array.isArray(s.extensions)).toBe(true)
-        expect(typeof s.enabled).toBe("boolean")
-      }
-
-      const gofmt = statuses.find((s) => s.name === "gofmt")
-      expect(gofmt).toBeDefined()
-      expect(gofmt!.extensions).toContain(".go")
-    })
-  })
-
-  test("status() returns empty list when formatter is disabled", async () => {
-    await using tmp = await tmpdir({
-      config: { formatter: false },
-    })
-
-    await withServices(tmp.path, FormatService.layer, async (rt) => {
-      const statuses = await rt.runPromise(FormatService.use((s) => s.status()))
-      expect(statuses).toEqual([])
-    })
-  })
-
-  test("status() excludes formatters marked as disabled in config", async () => {
-    await using tmp = await tmpdir({
-      config: {
-        formatter: {
-          gofmt: { disabled: true },
-        },
-      },
-    })
-
-    await withServices(tmp.path, FormatService.layer, async (rt) => {
-      const statuses = await rt.runPromise(FormatService.use((s) => s.status()))
-      const gofmt = statuses.find((s) => s.name === "gofmt")
-      expect(gofmt).toBeUndefined()
-    })
-  })
-
-  test("init() completes without error", async () => {
-    await using tmp = await tmpdir()
-
-    await withServices(tmp.path, FormatService.layer, async (rt) => {
-      await rt.runPromise(FormatService.use((s) => s.init()))
-    })
-  })
-})

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

@@ -1,9 +1,7 @@
-import { afterEach, test, expect } from "bun:test"
+import { test, expect } from "bun:test"
 import os from "os"
-import { Effect } from "effect"
 import { Bus } from "../../src/bus"
 import { runtime } from "../../src/effect/runtime"
-import { Instances } from "../../src/effect/instances"
 import { PermissionNext } from "../../src/permission/next"
 import * as S from "../../src/permission/service"
 import { PermissionID } from "../../src/permission/schema"
@@ -11,10 +9,6 @@ import { Instance } from "../../src/project/instance"
 import { tmpdir } from "../fixture/fixture"
 import { MessageID, SessionID } from "../../src/session/schema"
 
-afterEach(async () => {
-  await Instance.disposeAll()
-})
-
 async function rejectAll(message?: string) {
   for (const req of await PermissionNext.list()) {
     await PermissionNext.reply({
@@ -977,7 +971,7 @@ test("ask - should deny even when an earlier pattern is ask", async () => {
   await Instance.provide({
     directory: tmp.path,
     fn: async () => {
-      const err = await PermissionNext.ask({
+      const ask = PermissionNext.ask({
         sessionID: SessionID.make("session_test"),
         permission: "bash",
         patterns: ["echo hello", "rm -rf /"],
@@ -987,12 +981,24 @@ test("ask - should deny even when an earlier pattern is ask", async () => {
           { permission: "bash", pattern: "echo *", action: "ask" },
           { permission: "bash", pattern: "rm *", action: "deny" },
         ],
-      }).then(
-        () => undefined,
-        (err) => err,
-      )
+      })
 
-      expect(err).toBeInstanceOf(PermissionNext.DeniedError)
+      const out = await Promise.race([
+        ask.then(
+          () => ({ ok: true as const, err: undefined }),
+          (err) => ({ ok: false as const, err }),
+        ),
+        Bun.sleep(100).then(() => "timeout" as const),
+      ])
+
+      if (out === "timeout") {
+        await rejectAll()
+        await ask.catch(() => {})
+        throw new Error("ask timed out instead of denying immediately")
+      }
+
+      expect(out.ok).toBe(false)
+      expect(out.err).toBeInstanceOf(PermissionNext.DeniedError)
       expect(await PermissionNext.list()).toHaveLength(0)
     },
   })
@@ -1014,7 +1020,7 @@ test("ask - abort should clear pending request", async () => {
             always: [],
             ruleset: [{ permission: "bash", pattern: "*", action: "ask" }],
           }),
-        ).pipe(Effect.provide(Instances.get(Instance.directory))),
+        ),
         { signal: ctl.signal },
       )
 

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

@@ -1,117 +0,0 @@
-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 { tmpdir } from "../fixture/fixture"
-import { watcherConfigLayer, withServices } from "../fixture/instance"
-import { FileWatcher, FileWatcherService } from "../../src/file/watcher"
-import { Instance } from "../../src/project/instance"
-import { GlobalBus } from "../../src/bus/global"
-import { Vcs, VcsService } from "../../src/project/vcs"
-
-// Skip in CI — native @parcel/watcher binding needed
-const describeVcs = FileWatcher.hasNativeBinding() && !process.env.CI ? describe : describe.skip
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function withVcs(
-  directory: string,
-  body: (rt: ManagedRuntime.ManagedRuntime<FileWatcherService | VcsService, never>) => Promise<void>,
-) {
-  return withServices(
-    directory,
-    Layer.merge(FileWatcherService.layer, VcsService.layer),
-    async (rt) => {
-      await rt.runPromise(FileWatcherService.use((s) => s.init()))
-      await rt.runPromise(VcsService.use((s) => s.init()))
-      await Bun.sleep(200)
-      await body(rt)
-    },
-    { provide: [watcherConfigLayer] },
-  )
-}
-
-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) {
-  return new Promise<string | undefined>((resolve, reject) => {
-    const timer = setTimeout(() => {
-      GlobalBus.off("event", on)
-      reject(new Error("timed out waiting for BranchUpdated event"))
-    }, timeout)
-
-    function on(evt: BranchEvent) {
-      if (evt.directory !== directory) return
-      if (evt.payload.type !== Vcs.Event.BranchUpdated.type) return
-      clearTimeout(timer)
-      GlobalBus.off("event", on)
-      resolve(evt.payload.properties.branch)
-    }
-
-    GlobalBus.on("event", on)
-  })
-}
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describeVcs("Vcs", () => {
-  afterEach(() => Instance.disposeAll())
-
-  test("branch() returns current branch name", async () => {
-    await using tmp = await tmpdir({ git: true })
-
-    await withVcs(tmp.path, async (rt) => {
-      const branch = await rt.runPromise(VcsService.use((s) => s.branch()))
-      expect(branch).toBeDefined()
-      expect(typeof branch).toBe("string")
-    })
-  })
-
-  test("branch() returns undefined for non-git directories", async () => {
-    await using tmp = await tmpdir()
-
-    await withVcs(tmp.path, async (rt) => {
-      const branch = await rt.runPromise(VcsService.use((s) => s.branch()))
-      expect(branch).toBeUndefined()
-    })
-  })
-
-  test("publishes BranchUpdated when .git/HEAD changes", async () => {
-    await using tmp = await tmpdir({ git: true })
-    const branch = `test-${Math.random().toString(36).slice(2)}`
-    await $`git branch ${branch}`.cwd(tmp.path).quiet()
-
-    await withVcs(tmp.path, async () => {
-      const pending = nextBranchUpdate(tmp.path)
-
-      const head = path.join(tmp.path, ".git", "HEAD")
-      await fs.writeFile(head, `ref: refs/heads/${branch}\n`)
-
-      const updated = await pending
-      expect(updated).toBe(branch)
-    })
-  })
-
-  test("branch() reflects the new branch after HEAD change", async () => {
-    await using tmp = await tmpdir({ git: true })
-    const branch = `test-${Math.random().toString(36).slice(2)}`
-    await $`git branch ${branch}`.cwd(tmp.path).quiet()
-
-    await withVcs(tmp.path, async (rt) => {
-      const pending = nextBranchUpdate(tmp.path)
-
-      const head = path.join(tmp.path, ".git", "HEAD")
-      await fs.writeFile(head, `ref: refs/heads/${branch}\n`)
-
-      await pending
-      const current = await rt.runPromise(VcsService.use((s) => s.branch()))
-      expect(current).toBe(branch)
-    })
-  })
-})

packages/opencode/test/provider/auth.test.ts

@@ -0,0 +1,20 @@
+import { afterEach, expect, test } from "bun:test"
+import { Auth } from "../../src/auth"
+import { ProviderAuth } from "../../src/provider/auth"
+import { ProviderID } from "../../src/provider/schema"
+
+afterEach(async () => {
+  await Auth.remove("test-provider-auth")
+})
+
+test("ProviderAuth.api persists auth via AuthService", async () => {
+  await ProviderAuth.api({
+    providerID: ProviderID.make("test-provider-auth"),
+    key: "sk-test",
+  })
+
+  expect(await Auth.get("test-provider-auth")).toEqual({
+    type: "api",
+    key: "sk-test",
+  })
+})

packages/opencode/test/pty/pty-session.test.ts

@@ -6,7 +6,7 @@ import type { PtyID } from "../../src/pty/schema"
 import { tmpdir } from "../fixture/fixture"
 import { setTimeout as sleep } from "node:timers/promises"
 
-const wait = async (fn: () => boolean, ms = 5000) => {
+const wait = async (fn: () => boolean, ms = 2000) => {
   const end = Date.now() + ms
   while (Date.now() < end) {
     if (fn()) return
@@ -20,7 +20,7 @@ const pick = (log: Array<{ type: "created" | "exited" | "deleted"; id: PtyID }>,
 }
 
 describe("pty", () => {
-  test("publishes created, exited, deleted in order for a short-lived process", async () => {
+  test("publishes created, exited, deleted in order for /bin/ls + remove", async () => {
     if (process.platform === "win32") return
 
     await using dir = await tmpdir({ git: true })
@@ -37,11 +37,7 @@ describe("pty", () => {
 
         let id: PtyID | undefined
         try {
-          const info = await Pty.create({
-            command: "/usr/bin/env",
-            args: ["sh", "-c", "sleep 0.1"],
-            title: "sleep",
-          })
+          const info = await Pty.create({ command: "/bin/ls", title: "ls" })
           id = info.id
 
           await wait(() => pick(log, id!).includes("exited"))

packages/opencode/test/question/question.test.ts

@@ -1,14 +1,10 @@
-import { afterEach, test, expect } from "bun:test"
+import { test, expect } from "bun:test"
 import { Question } from "../../src/question"
 import { Instance } from "../../src/project/instance"
 import { QuestionID } from "../../src/question/schema"
 import { tmpdir } from "../fixture/fixture"
 import { SessionID } from "../../src/session/schema"
 
-afterEach(async () => {
-  await Instance.disposeAll()
-})
-
 /** Reject all pending questions so dangling Deferred fibers don't hang the test. */
 async function rejectAll() {
   const pending = await Question.list()

packages/opencode/test/util/instance-state.test.ts

@@ -0,0 +1,261 @@
+import { afterEach, expect, test } from "bun:test"
+import { Duration, Effect, Layer, ManagedRuntime, ServiceMap } from "effect"
+
+import { Instance } from "../../src/project/instance"
+import { InstanceState } from "../../src/util/instance-state"
+import { tmpdir } from "../fixture/fixture"
+
+async function access<A, E>(state: InstanceState<A, E>, dir: string) {
+  return Instance.provide({
+    directory: dir,
+    fn: () => Effect.runPromise(InstanceState.get(state)),
+  })
+}
+
+afterEach(async () => {
+  await Instance.disposeAll()
+})
+
+test("InstanceState caches values for the same instance", async () => {
+  await using tmp = await tmpdir()
+  let n = 0
+
+  await Effect.runPromise(
+    Effect.scoped(
+      Effect.gen(function* () {
+        const state = yield* InstanceState.make(() => Effect.sync(() => ({ n: ++n })))
+
+        const a = yield* Effect.promise(() => access(state, tmp.path))
+        const b = yield* Effect.promise(() => access(state, tmp.path))
+
+        expect(a).toBe(b)
+        expect(n).toBe(1)
+      }),
+    ),
+  )
+})
+
+test("InstanceState isolates values by directory", async () => {
+  await using a = await tmpdir()
+  await using b = await tmpdir()
+  let n = 0
+
+  await Effect.runPromise(
+    Effect.scoped(
+      Effect.gen(function* () {
+        const state = yield* InstanceState.make((dir) => Effect.sync(() => ({ dir, n: ++n })))
+
+        const x = yield* Effect.promise(() => access(state, a.path))
+        const y = yield* Effect.promise(() => access(state, b.path))
+        const z = yield* Effect.promise(() => access(state, a.path))
+
+        expect(x).toBe(z)
+        expect(x).not.toBe(y)
+        expect(n).toBe(2)
+      }),
+    ),
+  )
+})
+
+test("InstanceState is disposed on instance reload", async () => {
+  await using tmp = await tmpdir()
+  const seen: string[] = []
+  let n = 0
+
+  await Effect.runPromise(
+    Effect.scoped(
+      Effect.gen(function* () {
+        const state = yield* InstanceState.make(() =>
+          Effect.acquireRelease(
+            Effect.sync(() => ({ n: ++n })),
+            (value) =>
+              Effect.sync(() => {
+                seen.push(String(value.n))
+              }),
+          ),
+        )
+
+        const a = yield* Effect.promise(() => access(state, tmp.path))
+        yield* Effect.promise(() => Instance.reload({ directory: tmp.path }))
+        const b = yield* Effect.promise(() => access(state, tmp.path))
+
+        expect(a).not.toBe(b)
+        expect(seen).toEqual(["1"])
+      }),
+    ),
+  )
+})
+
+test("InstanceState is disposed on disposeAll", async () => {
+  await using a = await tmpdir()
+  await using b = await tmpdir()
+  const seen: string[] = []
+
+  await Effect.runPromise(
+    Effect.scoped(
+      Effect.gen(function* () {
+        const state = yield* InstanceState.make((dir) =>
+          Effect.acquireRelease(
+            Effect.sync(() => ({ dir })),
+            (value) =>
+              Effect.sync(() => {
+                seen.push(value.dir)
+              }),
+          ),
+        )
+
+        yield* Effect.promise(() => access(state, a.path))
+        yield* Effect.promise(() => access(state, b.path))
+        yield* Effect.promise(() => Instance.disposeAll())
+
+        expect(seen.sort()).toEqual([a.path, b.path].sort())
+      }),
+    ),
+  )
+})
+
+test("InstanceState.get reads correct directory per-evaluation (not captured once)", async () => {
+  await using a = await tmpdir()
+  await using b = await tmpdir()
+
+  // Regression: InstanceState.get must be lazy (Effect.suspend) so the
+  // directory is read per-evaluation, not captured once at the call site.
+  // Without this, a service built inside a ManagedRuntime Layer would
+  // freeze to whichever directory triggered the first layer build.
+
+  interface TestApi {
+    readonly getDir: () => Effect.Effect<string>
+  }
+
+  class TestService extends ServiceMap.Service<TestService, TestApi>()("@test/ALS-lazy") {
+    static readonly layer = Layer.effect(
+      TestService,
+      Effect.gen(function* () {
+        const state = yield* InstanceState.make((dir) => Effect.sync(() => dir))
+        // `get` is created once during layer build — must be lazy
+        const get = InstanceState.get(state)
+
+        const getDir = Effect.fn("TestService.getDir")(function* () {
+          return yield* get
+        })
+
+        return TestService.of({ getDir })
+      }),
+    )
+  }
+
+  const rt = ManagedRuntime.make(TestService.layer)
+
+  try {
+    const resultA = await Instance.provide({
+      directory: a.path,
+      fn: () => rt.runPromise(TestService.use((s) => s.getDir())),
+    })
+    expect(resultA).toBe(a.path)
+
+    // Second call with different directory must NOT return A's directory
+    const resultB = await Instance.provide({
+      directory: b.path,
+      fn: () => rt.runPromise(TestService.use((s) => s.getDir())),
+    })
+    expect(resultB).toBe(b.path)
+  } finally {
+    await rt.dispose()
+  }
+})
+
+test("InstanceState.get isolates concurrent fibers across real delays, yields, and timer callbacks", async () => {
+  await using a = await tmpdir()
+  await using b = await tmpdir()
+  await using c = await tmpdir()
+
+  // Adversarial: concurrent fibers with real timer delays (macrotask
+  // boundaries via setTimeout/Bun.sleep), explicit scheduler yields,
+  // and many async steps. If ALS context leaks or gets lost at any
+  // point, a fiber will see the wrong directory.
+
+  interface TestApi {
+    readonly getDir: () => Effect.Effect<string>
+  }
+
+  class TestService extends ServiceMap.Service<TestService, TestApi>()("@test/ALS-adversarial") {
+    static readonly layer = Layer.effect(
+      TestService,
+      Effect.gen(function* () {
+        const state = yield* InstanceState.make((dir) => Effect.sync(() => dir))
+
+        const getDir = Effect.fn("TestService.getDir")(function* () {
+          // Mix of async boundary types to maximise interleaving:
+          // 1. Real timer delay (macrotask — setTimeout under the hood)
+          yield* Effect.promise(() => Bun.sleep(1))
+          // 2. Effect.sleep (Effect's own timer, uses its internal scheduler)
+          yield* Effect.sleep(Duration.millis(1))
+          // 3. Explicit scheduler yields
+          for (let i = 0; i < 100; i++) {
+            yield* Effect.yieldNow
+          }
+          // 4. Microtask boundaries
+          for (let i = 0; i < 100; i++) {
+            yield* Effect.promise(() => Promise.resolve())
+          }
+          // 5. Another Effect.sleep
+          yield* Effect.sleep(Duration.millis(2))
+          // 6. Another real timer to force a second macrotask hop
+          yield* Effect.promise(() => Bun.sleep(1))
+          // NOW read the directory — ALS must still be correct
+          return yield* InstanceState.get(state)
+        })
+
+        return TestService.of({ getDir })
+      }),
+    )
+  }
+
+  const rt = ManagedRuntime.make(TestService.layer)
+
+  try {
+    const [resultA, resultB, resultC] = await Promise.all([
+      Instance.provide({
+        directory: a.path,
+        fn: () => rt.runPromise(TestService.use((s) => s.getDir())),
+      }),
+      Instance.provide({
+        directory: b.path,
+        fn: () => rt.runPromise(TestService.use((s) => s.getDir())),
+      }),
+      Instance.provide({
+        directory: c.path,
+        fn: () => rt.runPromise(TestService.use((s) => s.getDir())),
+      }),
+    ])
+
+    expect(resultA).toBe(a.path)
+    expect(resultB).toBe(b.path)
+    expect(resultC).toBe(c.path)
+  } finally {
+    await rt.dispose()
+  }
+})
+
+test("InstanceState dedupes concurrent lookups for the same directory", async () => {
+  await using tmp = await tmpdir()
+  let n = 0
+
+  await Effect.runPromise(
+    Effect.scoped(
+      Effect.gen(function* () {
+        const state = yield* InstanceState.make(() =>
+          Effect.promise(async () => {
+            n += 1
+            await Bun.sleep(10)
+            return { n }
+          }),
+        )
+
+        const [a, b] = yield* Effect.promise(() => Promise.all([access(state, tmp.path), access(state, tmp.path)]))
+        expect(a).toBe(b)
+        expect(n).toBe(1)
+      }),
+    ),
+  )
+})

packages/sdk/js/src/v2/gen/types.gen.ts

@@ -54,6 +54,35 @@ export type EventServerInstanceDisposed = {
   }
 }
 
+export type PermissionRequest = {
+  id: string
+  sessionID: string
+  permission: string
+  patterns: Array<string>
+  metadata: {
+    [key: string]: unknown
+  }
+  always: Array<string>
+  tool?: {
+    messageID: string
+    callID: string
+  }
+}
+
+export type EventPermissionAsked = {
+  type: "permission.asked"
+  properties: PermissionRequest
+}
+
+export type EventPermissionReplied = {
+  type: "permission.replied"
+  properties: {
+    sessionID: string
+    requestID: string
+    reply: "once" | "always" | "reject"
+  }
+}
+
 export type QuestionOption = {
   /**
    * Display text (1-5 words, concise)
@@ -125,50 +154,6 @@ export type EventQuestionRejected = {
   }
 }
 
-export type PermissionRequest = {
-  id: string
-  sessionID: string
-  permission: string
-  patterns: Array<string>
-  metadata: {
-    [key: string]: unknown
-  }
-  always: Array<string>
-  tool?: {
-    messageID: string
-    callID: string
-  }
-}
-
-export type EventPermissionAsked = {
-  type: "permission.asked"
-  properties: PermissionRequest
-}
-
-export type EventPermissionReplied = {
-  type: "permission.replied"
-  properties: {
-    sessionID: string
-    requestID: string
-    reply: "once" | "always" | "reject"
-  }
-}
-
-export type EventFileWatcherUpdated = {
-  type: "file.watcher.updated"
-  properties: {
-    file: string
-    event: "add" | "change" | "unlink"
-  }
-}
-
-export type EventVcsBranchUpdated = {
-  type: "vcs.branch.updated"
-  properties: {
-    branch?: string
-  }
-}
-
 export type EventServerConnected = {
   type: "server.connected"
   properties: {
@@ -700,6 +685,14 @@ export type EventSessionCompacted = {
   }
 }
 
+export type EventFileWatcherUpdated = {
+  type: "file.watcher.updated"
+  properties: {
+    file: string
+    event: "add" | "change" | "unlink"
+  }
+}
+
 export type Todo = {
   /**
    * Brief description of the task
@@ -889,6 +882,13 @@ export type EventSessionError = {
   }
 }
 
+export type EventVcsBranchUpdated = {
+  type: "vcs.branch.updated"
+  properties: {
+    branch?: string
+  }
+}
+
 export type EventWorkspaceReady = {
   type: "workspace.ready"
   properties: {
@@ -962,13 +962,11 @@ export type Event =
   | EventInstallationUpdateAvailable
   | EventProjectUpdated
   | EventServerInstanceDisposed
+  | EventPermissionAsked
+  | EventPermissionReplied
   | EventQuestionAsked
   | EventQuestionReplied
   | EventQuestionRejected
-  | EventPermissionAsked
-  | EventPermissionReplied
-  | EventFileWatcherUpdated
-  | EventVcsBranchUpdated
   | EventServerConnected
   | EventGlobalDisposed
   | EventLspClientDiagnostics
@@ -982,6 +980,7 @@ export type Event =
   | EventSessionStatus
   | EventSessionIdle
   | EventSessionCompacted
+  | EventFileWatcherUpdated
   | EventTodoUpdated
   | EventTuiPromptAppend
   | EventTuiCommandExecute
@@ -995,6 +994,7 @@ export type Event =
   | EventSessionDeleted
   | EventSessionDiff
   | EventSessionError
+  | EventVcsBranchUpdated
   | EventWorkspaceReady
   | EventWorkspaceFailed
   | EventPtyCreated

packages/sdk/openapi.json

@@ -7062,6 +7062,96 @@
         },
         "required": ["type", "properties"]
       },
+      "PermissionRequest": {
+        "type": "object",
+        "properties": {
+          "id": {
+            "type": "string",
+            "pattern": "^per.*"
+          },
+          "sessionID": {
+            "type": "string",
+            "pattern": "^ses.*"
+          },
+          "permission": {
+            "type": "string"
+          },
+          "patterns": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            }
+          },
+          "metadata": {
+            "type": "object",
+            "propertyNames": {
+              "type": "string"
+            },
+            "additionalProperties": {}
+          },
+          "always": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            }
+          },
+          "tool": {
+            "type": "object",
+            "properties": {
+              "messageID": {
+                "type": "string",
+                "pattern": "^msg.*"
+              },
+              "callID": {
+                "type": "string"
+              }
+            },
+            "required": ["messageID", "callID"]
+          }
+        },
+        "required": ["id", "sessionID", "permission", "patterns", "metadata", "always"]
+      },
+      "Event.permission.asked": {
+        "type": "object",
+        "properties": {
+          "type": {
+            "type": "string",
+            "const": "permission.asked"
+          },
+          "properties": {
+            "$ref": "#/components/schemas/PermissionRequest"
+          }
+        },
+        "required": ["type", "properties"]
+      },
+      "Event.permission.replied": {
+        "type": "object",
+        "properties": {
+          "type": {
+            "type": "string",
+            "const": "permission.replied"
+          },
+          "properties": {
+            "type": "object",
+            "properties": {
+              "sessionID": {
+                "type": "string",
+                "pattern": "^ses.*"
+              },
+              "requestID": {
+                "type": "string",
+                "pattern": "^per.*"
+              },
+              "reply": {
+                "type": "string",
+                "enum": ["once", "always", "reject"]
+              }
+            },
+            "required": ["sessionID", "requestID", "reply"]
+          }
+        },
+        "required": ["type", "properties"]
+      },
       "QuestionOption": {
         "type": "object",
         "properties": {
@@ -7212,149 +7302,6 @@
         },
         "required": ["type", "properties"]
       },
-      "PermissionRequest": {
-        "type": "object",
-        "properties": {
-          "id": {
-            "type": "string",
-            "pattern": "^per.*"
-          },
-          "sessionID": {
-            "type": "string",
-            "pattern": "^ses.*"
-          },
-          "permission": {
-            "type": "string"
-          },
-          "patterns": {
-            "type": "array",
-            "items": {
-              "type": "string"
-            }
-          },
-          "metadata": {
-            "type": "object",
-            "propertyNames": {
-              "type": "string"
-            },
-            "additionalProperties": {}
-          },
-          "always": {
-            "type": "array",
-            "items": {
-              "type": "string"
-            }
-          },
-          "tool": {
-            "type": "object",
-            "properties": {
-              "messageID": {
-                "type": "string",
-                "pattern": "^msg.*"
-              },
-              "callID": {
-                "type": "string"
-              }
-            },
-            "required": ["messageID", "callID"]
-          }
-        },
-        "required": ["id", "sessionID", "permission", "patterns", "metadata", "always"]
-      },
-      "Event.permission.asked": {
-        "type": "object",
-        "properties": {
-          "type": {
-            "type": "string",
-            "const": "permission.asked"
-          },
-          "properties": {
-            "$ref": "#/components/schemas/PermissionRequest"
-          }
-        },
-        "required": ["type", "properties"]
-      },
-      "Event.permission.replied": {
-        "type": "object",
-        "properties": {
-          "type": {
-            "type": "string",
-            "const": "permission.replied"
-          },
-          "properties": {
-            "type": "object",
-            "properties": {
-              "sessionID": {
-                "type": "string",
-                "pattern": "^ses.*"
-              },
-              "requestID": {
-                "type": "string",
-                "pattern": "^per.*"
-              },
-              "reply": {
-                "type": "string",
-                "enum": ["once", "always", "reject"]
-              }
-            },
-            "required": ["sessionID", "requestID", "reply"]
-          }
-        },
-        "required": ["type", "properties"]
-      },
-      "Event.file.watcher.updated": {
-        "type": "object",
-        "properties": {
-          "type": {
-            "type": "string",
-            "const": "file.watcher.updated"
-          },
-          "properties": {
-            "type": "object",
-            "properties": {
-              "file": {
-                "type": "string"
-              },
-              "event": {
-                "anyOf": [
-                  {
-                    "type": "string",
-                    "const": "add"
-                  },
-                  {
-                    "type": "string",
-                    "const": "change"
-                  },
-                  {
-                    "type": "string",
-                    "const": "unlink"
-                  }
-                ]
-              }
-            },
-            "required": ["file", "event"]
-          }
-        },
-        "required": ["type", "properties"]
-      },
-      "Event.vcs.branch.updated": {
-        "type": "object",
-        "properties": {
-          "type": {
-            "type": "string",
-            "const": "vcs.branch.updated"
-          },
-          "properties": {
-            "type": "object",
-            "properties": {
-              "branch": {
-                "type": "string"
-              }
-            }
-          }
-        },
-        "required": ["type", "properties"]
-      },
       "Event.server.connected": {
         "type": "object",
         "properties": {
@@ -8919,6 +8866,41 @@
         },
         "required": ["type", "properties"]
       },
+      "Event.file.watcher.updated": {
+        "type": "object",
+        "properties": {
+          "type": {
+            "type": "string",
+            "const": "file.watcher.updated"
+          },
+          "properties": {
+            "type": "object",
+            "properties": {
+              "file": {
+                "type": "string"
+              },
+              "event": {
+                "anyOf": [
+                  {
+                    "type": "string",
+                    "const": "add"
+                  },
+                  {
+                    "type": "string",
+                    "const": "change"
+                  },
+                  {
+                    "type": "string",
+                    "const": "unlink"
+                  }
+                ]
+              }
+            },
+            "required": ["file", "event"]
+          }
+        },
+        "required": ["type", "properties"]
+      },
       "Todo": {
         "type": "object",
         "properties": {
@@ -9405,6 +9387,24 @@
         },
         "required": ["type", "properties"]
       },
+      "Event.vcs.branch.updated": {
+        "type": "object",
+        "properties": {
+          "type": {
+            "type": "string",
+            "const": "vcs.branch.updated"
+          },
+          "properties": {
+            "type": "object",
+            "properties": {
+              "branch": {
+                "type": "string"
+              }
+            }
+          }
+        },
+        "required": ["type", "properties"]
+      },
       "Event.workspace.ready": {
         "type": "object",
         "properties": {
@@ -9611,6 +9611,12 @@
           {
             "$ref": "#/components/schemas/Event.server.instance.disposed"
           },
+          {
+            "$ref": "#/components/schemas/Event.permission.asked"
+          },
+          {
+            "$ref": "#/components/schemas/Event.permission.replied"
+          },
           {
             "$ref": "#/components/schemas/Event.question.asked"
           },
@@ -9620,18 +9626,6 @@
           {
             "$ref": "#/components/schemas/Event.question.rejected"
           },
-          {
-            "$ref": "#/components/schemas/Event.permission.asked"
-          },
-          {
-            "$ref": "#/components/schemas/Event.permission.replied"
-          },
-          {
-            "$ref": "#/components/schemas/Event.file.watcher.updated"
-          },
-          {
-            "$ref": "#/components/schemas/Event.vcs.branch.updated"
-          },
           {
             "$ref": "#/components/schemas/Event.server.connected"
           },
@@ -9671,6 +9665,9 @@
           {
             "$ref": "#/components/schemas/Event.session.compacted"
           },
+          {
+            "$ref": "#/components/schemas/Event.file.watcher.updated"
+          },
           {
             "$ref": "#/components/schemas/Event.todo.updated"
           },
@@ -9710,6 +9707,9 @@
           {
             "$ref": "#/components/schemas/Event.session.error"
           },
+          {
+            "$ref": "#/components/schemas/Event.vcs.branch.updated"
+          },
           {
             "$ref": "#/components/schemas/Event.workspace.ready"
           },