fix(server): avoid booting unloaded locations on pending form and permission reads

packages/app/src/session/requests/model.ts

@@ -19,6 +19,21 @@ export function createSessionRequestModel() {
   const data = useData()
   const language = useLanguage()
   const settings = useSettings()
+
+  const familySessions = createMemo(() => {
+    const id = params.id
+
+    if (!id) return []
+
+    return [...new Set([id, ...data.session.family(id)])].flatMap((sessionID) => {
+      const info = data.session.get(sessionID)
+
+      return info ? [info] : []
+    })
+  })
+
+  const treeIDs = createMemo(() => sessionTreeIDs(familySessions(), params.id))
+
   createEffect(() => {
     const id = params.id
 
@@ -28,16 +43,15 @@ export function createSessionRequestModel() {
     )
   })
   createEffect(() => {
-    const id = params.id
+    if (serverSDK.connection.status() !== "connected") return
+    const ids = treeIDs()
 
-    if (!id || serverSDK.connection.status() !== "connected") return
-    void Promise.all(
-      sessionTreeIDs(data.session.list(), id).map((sessionID) => data.session.form.sync(sessionID)),
-    ).catch(() => undefined)
+    if (!ids.length) return
+    void Promise.all(ids.map((sessionID) => data.session.form.sync(sessionID))).catch(() => undefined)
   })
 
   const formRequest = createMemo((): FormInfo | undefined => {
-    return sessionFormRequest(data.session.list(), data.session.form.list, params.id)
+    return sessionFormRequest(familySessions(), data.session.form.list, params.id)
   })
 
   // MCP elicitations are owned by the Location rather than a Session, so they are listed per Location.
@@ -102,7 +116,7 @@ export function createSessionRequestModel() {
 
     if (settings.permissions.autoApproves(project)) return
 
-    return sessionPermissionRequest(data.session.list(), data.session.permission.list, id)
+    return sessionPermissionRequest(familySessions(), data.session.permission.list, id)
   })
 
   const blocked = createMemo(() => {
@@ -131,7 +145,7 @@ export function createSessionRequestModel() {
   const running = createSessionBackground({
     sessionID: owner,
     messages: data.session.message.list,
-    sessions: data.session.list,
+    sessions: familySessions,
     status: data.session.status,
     shells: () => data.shell.list({ directory: sdk().directory }),
   })

packages/app/src/shell/layout/project-avatar-state.ts

@@ -21,7 +21,6 @@ export function useSessionTabAvatarState(
 
     if (!data) return []
 
-    if (!root?.()) return data.session.list()
     const id = sessionId()
 
     return [...new Set([id, ...data.session.family(id)])].flatMap((id) => {
@@ -68,8 +67,7 @@ export function useSessionTabAvatarState(
     const busy = (id: string) =>
       data.session.status(id) === "running" || data.session.pending.list(id).some((item) => item.type !== "synthetic")
 
-    if (root?.())
-      return data.session.list().some((session) => data.session.root(session.id) === sessionId() && busy(session.id))
+    if (root?.()) return [...new Set([sessionId(), ...data.session.family(sessionId())])].some(busy)
 
     return busy(sessionId())
   })

packages/core/src/effect/app-node-builder.ts

@@ -11,9 +11,7 @@ const instances = makeGlobalNode({
     Instance.Service,
     Effect.gen(function* () {
       const locations = yield* LocationServiceMap.Service
-      return Instance.Service.of({
-        provide: (session) => Effect.provide(locations.get(session.location)),
-      })
+      return Instance.fromLocations(locations)
     }),
   ),
   deps: [LocationServiceMap.node],

packages/core/src/instance.ts

@@ -55,7 +55,7 @@ import { ToolOutput } from "./tool-output.js"
 import { Vcs } from "./vcs.js"
 
 export * as Instance from "./instance.js"
-export { Service, node, type Interface } from "./instance/service.js"
+export { Service, fromLocations, node, provideContextEffectOption, type Interface } from "./instance/service.js"
 
 const nodes = [
   Location.node,

packages/core/src/instance/service.ts

@@ -1,7 +1,8 @@
 export * as Instance from "./service.js"
 export type { Services } from "../instance.js"
 
-import { Context, type Effect } from "effect"
+import { Context, Effect, type LayerMap, Option, Scope } from "effect"
+import type { Location } from "@opencode/schema/location"
 import type { Session } from "@opencode/schema/session"
 import { Node } from "@opencode/util/effect/app-node"
 import { LayerNode } from "@opencode/util/effect/layer-node"
@@ -12,6 +13,32 @@ export interface Interface {
   readonly provide: (
     session: Session.Info,
   ) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E | Error, Exclude<R, Services>>
+  readonly provideIfLoaded: (
+    session: Session.Info,
+  ) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<Option.Option<A>, E, Exclude<R, Services>>
+}
+
+export function provideContextEffectOption<K, E0>(
+  get: (key: K) => Effect.Effect<Option.Option<Context.Context<Services>>, E0, Scope.Scope>,
+  key: K,
+) {
+  return <A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<Option.Option<A>, E, Exclude<R, Services>> =>
+    Effect.scopedWith((scope) =>
+      Effect.gen(function* () {
+        const context = yield* get(key).pipe(Scope.provide(scope), Effect.option, Effect.map(Option.flatten))
+        if (Option.isNone(context)) return Option.none()
+        return Option.some(yield* effect.pipe(Effect.provide(context.value)))
+      }),
+    )
+}
+
+export function fromLocations(
+  locations: Pick<LayerMap.LayerMap<Location.Ref, Services, Error>, "get" | "contextEffectOption">,
+): Interface {
+  return Service.of({
+    provide: (session) => Effect.provide(locations.get(session.location)),
+    provideIfLoaded: (session) => provideContextEffectOption(locations.contextEffectOption, session.location),
+  })
 }
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/Instance") {}

packages/core/src/location-services.ts

@@ -73,11 +73,7 @@ export function buildLocationServiceMap(
       }
       // Cached instances borrow their owner instead of retaining its Layer scope.
       const bindings: LayerNode.Replacements = [
-        Instance.node.replace(
-          Layer.succeed(Instance.Service, {
-            provide: (session) => Effect.provide(map.get(session.location)),
-          }),
-        ),
+        Instance.node.replace(Layer.succeed(Instance.Service, Instance.fromLocations(map))),
         ...replacements,
         LocationServiceMap.node.replace(Layer.succeed(LocationServiceMap.Service, map)),
       ]

packages/core/test/instance-vanilla.test.ts

@@ -50,11 +50,7 @@ const instances = Layer.effect(
       Global.node.replace(tempGlobalLayer),
       offlineModels,
       LocationServiceMap.node.replace(Layer.succeed(LocationServiceMap.Service, map)),
-      Instance.node.replace(
-        Layer.succeed(Instance.Service, {
-          provide: (session) => Effect.provide(map.get(session.location)),
-        }),
-      ),
+      Instance.node.replace(Layer.succeed(Instance.Service, Instance.fromLocations(map))),
     ]
     return map
   }),

packages/core/test/plugin/supervisor-reload.test.ts

@@ -71,11 +71,7 @@ const instances = Layer.effect(
       Npm.node.replace(npmLayer),
       Watcher.node.replace(Layer.succeed(Watcher.Service, watcher)),
       LocationServiceMap.node.replace(Layer.succeed(LocationServiceMap.Service, map)),
-      Instance.node.replace(
-        Layer.succeed(Instance.Service, {
-          provide: (session) => Effect.provide(map.get(session.location)),
-        }),
-      ),
+      Instance.node.replace(Layer.succeed(Instance.Service, Instance.fromLocations(map))),
     ]
     return map
   }),

packages/core/test/plugin/supervisor.test.ts

@@ -58,11 +58,7 @@ const instances = Layer.effect(
       offlineModels,
       ConfigPluginSource.node.replace(sourceLayer),
       LocationServiceMap.node.replace(Layer.succeed(LocationServiceMap.Service, map)),
-      Instance.node.replace(
-        Layer.succeed(Instance.Service, {
-          provide: (session) => Effect.provide(map.get(session.location)),
-        }),
-      ),
+      Instance.node.replace(Layer.succeed(Instance.Service, Instance.fromLocations(map))),
     ]
     return map
   }),

packages/core/test/session-generate.test.ts

@@ -250,6 +250,7 @@ const setup = Effect.gen(function* () {
             Layer.mock(Plugin.Service, { awaitActivation: Effect.void }),
           ) as Layer.Layer<Instance.Services>,
         ),
+      provideIfLoaded: () => () => Effect.die("Unexpected loaded-only instance lookup"),
     }),
   }
 })

packages/core/test/session-move.test.ts

@@ -126,6 +126,8 @@ const sourceProbe = (options: { execution?: boolean } = {}) =>
                       }
                       return yield* effect.pipe(Effect.provide(locations.get(session.location)))
                     }),
+                  provideIfLoaded: (session) =>
+                    Instance.provideContextEffectOption(locations.contextEffectOption, session.location),
                 })
               }),
             ),
@@ -287,7 +289,7 @@ describe("Session.move", () => {
                   Effect.gen(function* () {
                     const locations = yield* LocationServiceMap.Service
                     const privateInstances = yield* LayerMap.make(
-                      () =>
+                      (_id: Session.ID) =>
                         Instance.layer(source, {
                           discovery: false,
                           replacements: [
@@ -306,6 +308,10 @@ describe("Session.move", () => {
                             ? privateInstances.get(session.id)
                             : locations.get(session.location),
                         ),
+                      provideIfLoaded: (session) =>
+                        session.id === selectedID && session.location.directory === source.directory
+                          ? Instance.provideContextEffectOption(privateInstances.contextEffectOption, session.id)
+                          : Instance.provideContextEffectOption(locations.contextEffectOption, session.location),
                     })
                     const bindings: LayerNode.Replacements = [
                       ...replacements,

packages/core/test/session-owned.test.ts

@@ -147,6 +147,7 @@ const setup = Effect.fnUntraced(function* (options?: {
   const instances = Instance.Service.of({
     // This fixture supplies only the instance services exercised by Session.
     provide: (session) => Effect.provide(servicesFor(session.location) as Layer.Layer<Instance.Services>),
+    provideIfLoaded: () => () => Effect.die("Unexpected loaded-only instance lookup"),
   })
   const sessions = yield* Session.make().pipe(
     Effect.satisfiesServicesType<

packages/core/test/session-remove.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect } from "bun:test"
-import { Effect, Layer, RcMap, Scope } from "effect"
+import { Effect, Layer, Option, RcMap, Scope } from "effect"
 import { AppNodeBuilder } from "@opencode/core/effect/app-node-builder"
 import { LayerNode } from "@opencode/util/effect/layer-node"
 import { Database } from "@opencode/core/database/database"
@@ -115,3 +115,39 @@ describe("Session.remove", () => {
     }),
   )
 })
+
+describe("Instance.provideIfLoaded", () => {
+  it.live("skips absent instances and scopes loaded borrows without replacing the caller's Scope", () =>
+    Effect.gen(function* () {
+      const temporary = yield* tmpdirScoped()
+      const sessions = yield* Session.Service
+      const instances = yield* Instance.Service
+      const locations = yield* LocationServiceMap.Service
+      const scope = yield* Scope.Scope
+      const session = yield* sessions.create({
+        location: Location.Ref.make({ directory: AbsolutePath.make(temporary.path) }),
+      })
+      const absent = Effect.die("An unloaded instance must not run the effect").pipe(instances.provideIfLoaded(session))
+
+      expect(yield* absent).toEqual(Option.none())
+      expect(Array.from(yield* RcMap.keys(locations.rcMap))).toEqual([])
+      yield* Location.Service.pipe(instances.provide(session))
+      expect(Array.from(yield* RcMap.keys(locations.rcMap))).toEqual([session.location])
+      expect(yield* Effect.void.pipe(instances.provideIfLoaded(session))).toEqual(Option.some(undefined))
+      const failure = new Error("Borrowed operation failed")
+      expect(yield* Effect.fail(failure).pipe(instances.provideIfLoaded(session), Effect.flip)).toBe(failure)
+
+      const borrowed = yield* Effect.gen(function* () {
+        const location = yield* Location.Service
+        const callerScope = yield* Scope.Scope
+        expect(callerScope).toBe(scope)
+        yield* locations.invalidate(session.location)
+        return location.directory
+      }).pipe(instances.provideIfLoaded(session), Effect.satisfiesServicesType<Scope.Scope>())
+
+      expect(borrowed).toEqual(Option.some(session.location.directory))
+      expect(Array.from(yield* RcMap.keys(locations.rcMap))).toEqual([])
+      expect(yield* absent).toEqual(Option.none())
+    }),
+  )
+})

packages/protocol/openapi.json

@@ -4382,18 +4382,11 @@
             }
           },
           "404": {
-            "description": "SessionNotFoundError | LocationNotFoundError",
+            "description": "SessionNotFoundError",
             "content": {
               "application/json": {
                 "schema": {
-                  "anyOf": [
-                    {
-                      "$ref": "#/components/schemas/SessionNotFoundErrorEncoded"
-                    },
-                    {
-                      "$ref": "#/components/schemas/LocationNotFoundErrorEncoded"
-                    }
-                  ]
+                  "$ref": "#/components/schemas/SessionNotFoundErrorEncoded"
                 }
               }
             }
@@ -9088,18 +9081,11 @@
             }
           },
           "404": {
-            "description": "SessionNotFoundError | LocationNotFoundError",
+            "description": "SessionNotFoundError",
             "content": {
               "application/json": {
                 "schema": {
-                  "anyOf": [
-                    {
-                      "$ref": "#/components/schemas/SessionNotFoundErrorEncoded"
-                    },
-                    {
-                      "$ref": "#/components/schemas/LocationNotFoundErrorEncoded"
-                    }
-                  ]
+                  "$ref": "#/components/schemas/SessionNotFoundErrorEncoded"
                 }
               }
             }

packages/protocol/src/groups/permission.ts

@@ -8,7 +8,6 @@ import { Context, Schema } from "effect"
 import { HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, HttpApiSchema, OpenApi } from "effect/http-api"
 import {
   ConflictError,
-  LocationNotFoundError,
   PermissionNotFoundError,
   PermissionSavedNotFoundError,
   SessionNotFoundError,
@@ -113,7 +112,7 @@ export const makePermissionGroup = <
       HttpApiEndpoint.get("session.permission.list", "/api/session/:sessionID/permission", {
         params: { sessionID: Session.ID },
         success: Schema.Struct({ data: Schema.Array(Permission.Request) }),
-        error: [SessionNotFoundError, LocationNotFoundError],
+        error: SessionNotFoundError,
       }).annotateMerge(
         OpenApi.annotations({
           identifier: "session.permission.list",

packages/protocol/src/groups/session.ts

@@ -736,15 +736,13 @@ export const makeSessionGroup = <I extends HttpApiMiddleware.AnyId, S, FormI ext
         params: { sessionID: Schema.String },
         success: Schema.Struct({ data: Schema.Array(Form.Info) }),
         error: SessionNotFoundError,
-      })
-        .middleware(formLocationMiddleware)
-        .annotateMerge(
-          OpenApi.annotations({
-            identifier: "session.form.list",
-            summary: "List session forms",
-            description: "Retrieve pending forms for a session.",
-          }),
-        ),
+      }).annotateMerge(
+        OpenApi.annotations({
+          identifier: "session.form.list",
+          summary: "List session forms",
+          description: "Retrieve pending forms for a session.",
+        }),
+      ),
     )
     .add(
       HttpApiEndpoint.post("session.form.create", "/api/session/:sessionID/form", {

packages/sdk/src/internal/instances.ts

@@ -56,6 +56,9 @@ export function layer(options: Options, replacements: () => LayerNode.Replacemen
         ...LocationServiceMap.canonical(session.location),
       })
       const provide = (session: Session.Info) => Effect.provide(instances.get(key(session)))
+      const provideIfLoaded = (session: Session.Info) =>
+        Instance.provideContextEffectOption(instances.contextEffectOption, key(session))
+      const selector = Instance.Service.of({ provide, provideIfLoaded })
       const instances: LayerMap.LayerMap<
         ReturnType<typeof key>,
         Instance.Services,
@@ -71,7 +74,7 @@ export function layer(options: Options, replacements: () => LayerNode.Replacemen
                   ...replacements(),
                   // Instances borrow this selector and the host's Location map instead of retaining
                   // their Layer scopes; retaining the selector would block its shutdown on its own entries.
-                  Instance.node.replace(Layer.succeed(Instance.Service, { provide })),
+                  Instance.node.replace(Layer.succeed(Instance.Service, selector)),
                   LocationServiceMap.node.replace(Layer.succeed(LocationServiceMap.Service, locations)),
                 ],
               }).pipe(
@@ -101,7 +104,7 @@ export function layer(options: Options, replacements: () => LayerNode.Replacemen
           ),
         { idleTimeToLive: Duration.infinity },
       )
-      return Instance.Service.of({ provide })
+      return selector
     }),
   )
 }