wip

2026-06-26 15:41:43 -04:00 · 2026-06-26 15:41:43 -04:00 · 2f0343ca24
commit 2f0343ca24
parent 0e731c2a1a
106 changed files with 1377 additions and 748 deletions
--- a/packages/core/src/.#location-layer.ts
+++ b/packages/core/src/.#location-layer.ts
@ -0,0 +1 @@
+james@james-6.local.2380:1780672839
--- a/packages/core/src/.#location-mutation.ts
+++ b/packages/core/src/.#location-mutation.ts
@ -0,0 +1 @@
+james@james-6.local.2380:1780672839
--- a/packages/core/src/agent.ts
+++ b/packages/core/src/agent.ts
@ -1,5 +1,6 @@
 export * as AgentV2 from "./agent"

+import { makeLocationNode } from "./effect/scoped-node"
 import { Array, Context, Effect, Layer, Types } from "effect"
 import { Agent } from "@opencode-ai/schema/agent"
 import { State } from "./state"
@ -106,3 +107,5 @@ export const layer = Layer.effect(
 )

 export const locationLayer = layer
+
+export const node = makeLocationNode({ service: Service, layer, deps: [] })
--- a/packages/core/src/aisdk.ts
+++ b/packages/core/src/aisdk.ts
@ -1,5 +1,6 @@
 export * as AISDK from "./aisdk"

+import { makeLocationNode } from "./effect/scoped-node"
 import type { LanguageModelV3 } from "@ai-sdk/provider"
 import { Cause, Context, Effect, Layer, Schema, Scope } from "effect"
 import { ModelV2 } from "./model"
@ -231,4 +232,6 @@ export const locationLayer = Layer.effect(
  }),
 )

+export const node = makeLocationNode({ service: Service, layer: locationLayer, deps: [] })
+
 export const defaultLayer = locationLayer
--- a/packages/core/src/background-job.ts
+++ b/packages/core/src/background-job.ts
@ -2,6 +2,7 @@ export * as BackgroundJob from "./background-job"

 import { Cause, Clock, Context, Deferred, Effect, Exit, Layer, Scope, SynchronizedRef } from "effect"
 import { Identifier } from "./id/id"
+import { makeGlobalNode } from "./effect/scoped-node"

 export type Status = "running" | "completed" | "error" | "cancelled"

@ -362,3 +363,5 @@ export const make = Effect.gen(function* () {
 export const layer = Layer.effect(Service, make)

 export const defaultLayer = layer
+
+export const node = makeGlobalNode({ service: Service, layer, deps: [] })
--- a/packages/core/src/catalog.ts
+++ b/packages/core/src/catalog.ts
@ -1,5 +1,6 @@
 export * as Catalog from "./catalog"

+import { makeLocationNode } from "./effect/scoped-node"
 import { Array, Context, Effect, Layer, Option, Order, pipe, Schema } from "effect"
 import { Catalog } from "@opencode-ai/schema/catalog"
 import { ModelV2 } from "./model"
@ -291,3 +292,5 @@ export const locationLayer = layer.pipe(
  Layer.provideMerge(Integration.locationLayer),
  Layer.provideMerge(Policy.locationLayer),
 )
+
+export const node = makeLocationNode({ service: Service, layer, deps: [EventV2.node, Policy.node, Integration.node] })
--- a/packages/core/src/command.ts
+++ b/packages/core/src/command.ts
@ -1,5 +1,6 @@
 export * as CommandV2 from "./command"

+import { makeLocationNode } from "./effect/scoped-node"
 import { Context, Effect, Layer, Types } from "effect"
 import { Command } from "@opencode-ai/schema/command"
 import { State } from "./state"
@ -59,3 +60,5 @@ export const layer = Layer.effect(
 )

 export const locationLayer = layer
+
+export const node = makeLocationNode({ service: Service, layer, deps: [] })
--- a/packages/core/src/config.ts
+++ b/packages/core/src/config.ts
@ -1,5 +1,6 @@
 export * as Config from "./config"

+import { makeLocationNode } from "./effect/scoped-node"
 import path from "path"
 import { type ParseError, parse } from "jsonc-parser"
 import { Context, Effect, Layer, Option, Schema } from "effect"
@ -218,3 +219,9 @@ export const layer = Layer.effect(
 )

 export const locationLayer = layer.pipe(Layer.provideMerge(Policy.locationLayer))
+
+export const node = makeLocationNode({
+  service: Service,
+  layer,
+  deps: [FSUtil.node, Global.node, Location.node, Policy.node],
+})
--- a/packages/core/src/credential.ts
+++ b/packages/core/src/credential.ts
@ -5,6 +5,7 @@ import { Context, Effect, Layer, Schema } from "effect"
 import { Credential } from "@opencode-ai/schema/credential"
 import { Integration } from "@opencode-ai/schema/integration"
 import { Database } from "./database/database"
+import { makeGlobalNode } from "./effect/scoped-node"
 import { CredentialTable } from "./credential/sql"

 export const ID = Credential.ID
@ -135,3 +136,5 @@ export const layer = Layer.effect(
 )

 export const defaultLayer = layer.pipe(Layer.provide(Database.defaultLayer))
+
+export const node = makeGlobalNode({ service: Service, layer, deps: [Database.node] })
--- a/packages/core/src/cross-spawn-spawner.ts
+++ b/packages/core/src/cross-spawn-spawner.ts
@ -24,7 +24,7 @@ import {
 import * as NodeChildProcess from "node:child_process"
 import { PassThrough } from "node:stream"
 import launch from "cross-spawn"
-import { LayerNode } from "./effect/layer-node"
+import { makeGlobalNode } from "./effect/scoped-node"
 import { filesystem, path } from "./effect/layer-node-platform"

 const toError = (err: unknown): Error => (err instanceof globalThis.Error ? err : new globalThis.Error(String(err)))
@ -503,6 +503,6 @@ export const layer: Layer.Layer<ChildProcessSpawner, never, FileSystem.FileSyste
 )

 export const defaultLayer = layer.pipe(Layer.provide(NodeFileSystem.layer), Layer.provide(NodePath.layer))
-export const node = LayerNode.make({ service: ChildProcessSpawner, layer, deps: [filesystem, path] })
+export const node = makeGlobalNode({ service: ChildProcessSpawner, layer, deps: [filesystem, path] })

 export * as CrossSpawnSpawner from "./cross-spawn-spawner"
--- a/packages/core/src/database/database.ts
+++ b/packages/core/src/database/database.ts
@ -8,7 +8,7 @@ import { Flag } from "../flag/flag"
 import { isAbsolute, join } from "path"
 import { DatabaseMigration } from "./migration"
 import { InstallationChannel } from "../installation/version"
-import { LayerNode } from "../effect/layer-node"
+import { makeGlobalNode } from "../effect/scoped-node"

 const makeDatabase = EffectDrizzleSqlite.makeWithDefaults()
 type DatabaseShape = Effect.Success<typeof makeDatabase>
@ -60,4 +60,4 @@ export const defaultLayer = Layer.unwrap(
  }),
 ).pipe(Layer.provide(Global.defaultLayer))

-export const node = LayerNode.make({ service: Service, layer: layerFromPath(path()), deps: [] })
+export const node = makeGlobalNode({ service: Service, layer: layerFromPath(path()), deps: [] })
--- a/packages/core/src/effect/layer-node-platform.ts
+++ b/packages/core/src/effect/layer-node-platform.ts
@ -3,16 +3,16 @@ import { LLMClient, RequestExecutor } from "@opencode-ai/llm/route"
 import { FileSystem, Path } from "effect"
 import { FetchHttpClient } from "effect/unstable/http"
 import { HttpClient } from "effect/unstable/http"
-import { LayerNode } from "./layer-node"
+import { makeGlobalNode } from "./scoped-node"

-export const filesystem = LayerNode.make({ service: FileSystem.FileSystem, layer: NodeFileSystem.layer, deps: [] })
-export const path = LayerNode.make({ service: Path.Path, layer: NodePath.layer, deps: [] })
-export const httpClient = LayerNode.make({ service: HttpClient.HttpClient, layer: FetchHttpClient.layer, deps: [] })
-export const requestExecutor = LayerNode.make({
+export const filesystem = makeGlobalNode({ service: FileSystem.FileSystem, layer: NodeFileSystem.layer, deps: [] })
+export const path = makeGlobalNode({ service: Path.Path, layer: NodePath.layer, deps: [] })
+export const httpClient = makeGlobalNode({ service: HttpClient.HttpClient, layer: FetchHttpClient.layer, deps: [] })
+export const requestExecutor = makeGlobalNode({
  service: RequestExecutor.Service,
  layer: RequestExecutor.layer,
  deps: [httpClient],
 })
-export const llmClient = LayerNode.make({ service: LLMClient.Service, layer: LLMClient.layer, deps: [requestExecutor] })
+export const llmClient = makeGlobalNode({ service: LLMClient.Service, layer: LLMClient.layer, deps: [requestExecutor] })

 export * as LayerNodePlatform from "./layer-node-platform"
--- a/packages/core/src/effect/layer-node-tree.ts
+++ b/packages/core/src/effect/layer-node-tree.ts
@ -0,0 +1,182 @@
+import { Layer } from "effect"
+import { LayerNode } from "./layer-node"
+
+type AnyNode = LayerNode.Node<unknown, unknown, any>
+type RuntimeLayer = Layer.Layer<never, unknown, unknown>
+
+type Separated<N, Names extends readonly [string, ...string[]]> = {
+  readonly [Name in Names[number]]: N extends LayerNode.Node<infer A, infer E, any>
+    ? LayerNode.Node<A, E>
+    : never
+}
+
+export function separate<const Root extends AnyNode, const Names extends readonly [string, ...string[]]>(
+  root: Root,
+  tiers: LayerNode.Tiers<Names>,
+): Separated<Root, Names> {
+  const roots = new Map<LayerNode.Tier, AnyNode[]>()
+  const serviceTiers = new Map<string, LayerNode.Tier>()
+  const visited = new Set<AnyNode>()
+
+  const validate = (node: AnyNode) => {
+    if (node.kind === "group") {
+      node.dependencies.forEach(validate)
+      return
+    }
+    if (visited.has(node)) return
+    visited.add(node)
+    const tier = requireTier(node, tiers)
+    const existing = serviceTiers.get(node.name)
+    if (existing && existing !== tier) {
+      throw new Error(`Service ${node.name} belongs to both tier ${existing} and tier ${tier}`)
+    }
+    serviceTiers.set(node.name, tier)
+    node.dependencies.forEach(validate)
+  }
+  validate(root)
+
+  for (const node of flatten(root)) {
+    const tier = requireTier(node, tiers)
+    const current = roots.get(tier) ?? []
+    roots.set(tier, current)
+    current.push(node)
+  }
+
+  return Object.fromEntries(
+    tiers.names.map((name) => [name, LayerNode.group(roots.get(tiers.values[name as Names[number]]) ?? [])]),
+  ) as Separated<Root, Names>
+}
+
+export function hoist<A, E, T extends LayerNode.Tier>(
+  root: LayerNode.Node<A, E, any>,
+  tier: T,
+  tiers: LayerNode.Tiers<readonly [string, ...string[]]>,
+): {
+  readonly node: LayerNode.Node<A, E>
+  readonly hoisted: LayerNode.Node<unknown, unknown>
+} {
+  const indexes = new Map(tiers.names.map((name, index) => [tiers.values[name], index]))
+  const current = indexes.get(tier)
+  if (current === undefined) throw new Error(`Tier ${tier} is not in the tier configuration`)
+  const visited = new Map<AnyNode, AnyNode>()
+  const hoisted = new Map<string, AnyNode>()
+  let hoistedTier: LayerNode.Tier | undefined
+  const visiting = new Set<AnyNode>()
+  const stack: AnyNode[] = []
+
+  const visit = (node: AnyNode): AnyNode => {
+    if (node.kind === "group") {
+      return { ...node, dependencies: node.dependencies.map(visit) }
+    }
+
+    const existingNode = visited.get(node)
+    if (existingNode) return existingNode
+
+    const dependencyTier = requireTier(node, tiers)
+    const index = indexes.get(dependencyTier)!
+    if (index < current) throw new Error(`Tier ${tier} cannot depend on lower tier ${dependencyTier}`)
+    if (index > current) {
+      if (hoistedTier && hoistedTier !== dependencyTier) {
+        throw new Error(`Tree ${tier} hoists dependencies into multiple tiers`)
+      }
+      hoistedTier = dependencyTier
+      const existing = hoisted.get(node.name)
+      if (existing && existing !== node) {
+        throw new Error(`Tier ${tier} has conflicting implementations for ${node.name}`)
+      }
+      hoisted.set(node.name, node)
+      const empty = LayerNode.group([])
+      visited.set(node, empty)
+      return empty
+    }
+    if (node.kind === "unbound") {
+      return node
+    }
+
+    if (visiting.has(node)) {
+      const start = stack.indexOf(node)
+      throw new Error(
+        `Cycle detected in layer tree: ${[...stack.slice(start), node].map((item) => item.name).join(" -> ")}`,
+      )
+    }
+    visiting.add(node)
+    stack.push(node)
+    try {
+      const dependencies = node.dependencies.map(visit)
+      const clone = { ...node, dependencies }
+      visited.set(node, clone)
+      return clone
+    } finally {
+      stack.pop()
+      visiting.delete(node)
+    }
+  }
+
+  return {
+    node: visit(root) as LayerNode.Node<A, E>,
+    hoisted: LayerNode.group(Array.from(hoisted.values())),
+  }
+}
+
+export function compile(
+  root: LayerNode.Node<unknown, unknown, any>,
+  replacements?: ReadonlyMap<Layer.Any, Layer.Any>,
+): Layer.Layer<never, unknown> {
+  const cache = new Map<AnyNode, RuntimeLayer>()
+  const compileNode = (node: AnyNode): RuntimeLayer => {
+    if (node.kind === "unbound") throw new Error(`Unbound layer node: ${node.name}`)
+    const cached = cache.get(node)
+    if (cached) return cached
+    const dependencies = node.dependencies.flatMap(flatten).map(compileNode)
+    const implementation = (replacements?.get(node.implementation!) ?? node.implementation!) as RuntimeLayer
+    const layer =
+      dependencies.length === 0
+        ? implementation
+        : implementation.pipe(Layer.provide(dependencies as [RuntimeLayer, ...RuntimeLayer[]]))
+    cache.set(node, layer)
+    return layer
+  }
+  const layers = flatten(root).map((node) => compileNode(node))
+  const layer = layers.reduce<RuntimeLayer>((result, layer) => layer.pipe(Layer.provideMerge(result)), Layer.empty)
+  return layer as Layer.Layer<never, unknown>
+}
+
+export function bind<A, E, T extends LayerNode.Tier | undefined>(
+  root: LayerNode.Node<A, E, T>,
+  source: AnyNode,
+  replacement: AnyNode,
+): LayerNode.Node<A, E, T> {
+  if (source.kind !== "unbound") throw new Error(`Cannot bind non-unbound layer node: ${source.name}`)
+  if (source.name !== replacement.name) {
+    throw new Error(`Cannot bind ${source.name} to ${replacement.name}`)
+  }
+  if (source.tier !== replacement.tier) {
+    throw new Error(`Cannot bind ${source.name} across tiers`)
+  }
+  const visited = new Map<AnyNode, AnyNode>()
+  const visit = (node: AnyNode): AnyNode => {
+    if (node === source) return replacement
+    const existing = visited.get(node)
+    if (existing) return existing
+    if (node.kind === "unbound") return node
+    const clone = { ...node, dependencies: node.dependencies.map(visit) }
+    visited.set(node, clone)
+    return clone
+  }
+  return visit(root) as LayerNode.Node<A, E, T>
+}
+
+function flatten(node: AnyNode): readonly AnyNode[] {
+  return node.kind === "group" ? node.dependencies.flatMap(flatten) : [node]
+}
+
+function requireTier(node: AnyNode, tiers: LayerNode.Tiers<readonly [string, ...string[]]>): LayerNode.Tier {
+  const tier =
+    node.tier ?? (tiers.names.length === 1 && tiers.names[0] === "untiered" ? tiers.values.untiered : undefined)
+  if (!tier || !tiers.names.some((name) => tiers.values[name] === tier)) {
+    throw new Error(`Node ${node.name} is not in the tier configuration`)
+  }
+  return tier
+}
+
+export * as LayerNodeTree from "./layer-node-tree"
--- a/packages/core/src/effect/layer-node.ts
+++ b/packages/core/src/effect/layer-node.ts
@ -1,6 +1,5 @@
 import { Brand, Context, Layer } from "effect"

-type RuntimeLayer = Layer.Layer<never, unknown, unknown>
 type AnyNode = Node<unknown, unknown, any>
 type NodeList<Item extends AnyNode = AnyNode> = readonly [] | readonly [Item, ...Item[]]
 type Output<Item> = [Item] extends [never] ? never : Item extends Node<infer A, unknown, any> ? A : never
@ -18,8 +17,8 @@ export type Tier<Name extends string = string> = Name & Brand.Brand<"LayerNode.T

 const makeTier = Brand.nominal<Tier>()

-export type Node<A, E = never, T extends Tier | undefined = undefined> = {
-  readonly kind: "layer" | "group"
+export interface Node<A, E = never, T extends Tier | undefined = undefined> {
+  readonly kind: "layer" | "unbound" | "group"
  readonly name: string
  readonly service?: Context.Service.Any
  readonly implementation?: Layer.Any
@ -34,7 +33,7 @@ type NodeIdentity =
  | { readonly name: string; readonly service?: never }
 type DistributiveOmit<A, K extends PropertyKey> = A extends unknown ? Omit<A, K> : never

-type NodeInput<
+type MakeInput<
  Implementation extends Layer.Any,
  Items extends NodeList,
  T extends Tier | undefined = undefined,
@ -49,8 +48,12 @@ export function make<
  const Items extends NodeList,
  const T extends Tier | undefined = undefined,
 >(
-  input: NodeInput<Implementation, Items, T>,
-): Node<Layer.Success<Implementation>, Layer.Error<Implementation> | Error<Items[number]>, T> {
+  input: MakeInput<Implementation, Items, T>,
+): Node<
+  Layer.Success<Implementation>,
+  Layer.Error<Implementation> | Error<Items[number]>,
+  T
+> {
  return {
    kind: "layer",
    name: input.service !== undefined ? input.service.key : input.name,
@ -61,7 +64,20 @@ export function make<
  }
 }

-export function group<const Items extends NodeList>(
+export function unbound<R, Shape, const T extends Tier>(
+  service: Context.Key<R, Shape>,
+  tier: T,
+): Node<R, never, T> {
+  return {
+    kind: "unbound",
+    name: service.key,
+    service,
+    dependencies: [],
+    tier,
+  }
+}
+
+export function group<const Items extends readonly AnyNode[]>(
  dependencies: Items,
 ): Node<Output<Items[number]>, Error<Items[number]>> {
  return { kind: "group", name: "group", dependencies }
@ -76,19 +92,26 @@ type AllowedTierNames<Names extends readonly string[], Name extends Names[number
    : AllowedTierNames<Tail, Name>
  : never

-type NodeInTiers<Names extends string> = Node<unknown, unknown, Tier<Names>>
+type NodeInTiers<Names extends string> = Node<unknown, unknown, Tier<Names> | undefined>
+type CheckTiers<Items extends NodeList, Names extends string> = [Exclude<Items[number], NodeInTiers<Names>>] extends [
+  never,
+]
+  ? unknown
+  : { readonly "Invalid tier dependencies": Exclude<Items[number], NodeInTiers<Names>> }

 export interface Tiers<Names extends readonly [string, ...string[]]> {
  readonly names: Names
  readonly values: { readonly [K in Names[number]]: Tier<K> }
  readonly make: <Name extends Names[number]>(
    name: Name,
-  ) => <
-    const Implementation extends Layer.Any,
-    const Items extends NodeList<NodeInTiers<AllowedTierNames<Names, Name>>>,
-  >(
-    input: DistributiveOmit<NodeInput<Implementation, Items, Tier<Name>>, "tier">,
-  ) => Node<Layer.Success<Implementation>, Layer.Error<Implementation> | Error<Items[number]>, Tier<Name>>
+  ) => <const Implementation extends Layer.Any, const Items extends NodeList>(
+    input: DistributiveOmit<MakeInput<Implementation, Items, Tier<Name>>, "tier"> &
+      CheckTiers<Items, AllowedTierNames<Names, Name>>,
+  ) => Node<
+    Layer.Success<Implementation>,
+    Layer.Error<Implementation> | Error<Items[number]>,
+    Tier<Name>
+  >
 }

 export function tiers<const Names extends readonly [string, ...string[]]>(names: Names): Tiers<Names> {
@ -96,14 +119,11 @@ export function tiers<const Names extends readonly [string, ...string[]]>(names:
  return {
    names,
    values,
-    make: ((name: Names[number]) => (input: DistributiveOmit<NodeInput<Layer.Any, NodeList, Tier>, "tier">) =>
+    make: ((name: Names[number]) => (input: DistributiveOmit<MakeInput<Layer.Any, NodeList, Tier>, "tier">) =>
      make({ ...input, tier: values[name] })) as Tiers<Names>["make"],
  }
 }

-const defaultTiers = tiers(["untiered"])
-const untiered = defaultTiers.values.untiered
-
 export type Replacement = {
  readonly source: Layer.Any
  readonly replacement: Layer.Any
@ -120,129 +140,4 @@ export function replace<A, E, R, E2>(
  return { source, replacement }
 }

-export function buildLayer<
-  A,
-  E,
-  const Names extends readonly [string, ...string[]] = readonly ["untiered"],
-  const Built extends Layer.Any = Layer.Layer<never, never, never>,
->(
-  node: Node<A, E, any>,
-  options?: {
-    readonly tiers?: Tiers<Names>
-    readonly buildTier?: (tier: Names[number], layers: readonly Layer.Any[]) => Built
-    readonly replacements?: readonly Replacement[]
-  },
-): Layer.Layer<A | Layer.Success<Built>, E | Layer.Error<Built>, never> {
-  const tiers = options?.tiers ?? (defaultTiers as unknown as Tiers<Names>)
-  const replacementMap = new Map(options?.replacements?.map((item) => [item.source, item.replacement]))
-  const plans = plan(node, tiers, replacementMap)
-  const layers: RuntimeLayer[] = tiers.names.map((name) => {
-    const tier = tiers.values[name as Names[number]]
-    const layers = plans.get(tier) ?? []
-    return (options?.buildTier?.(name, layers) ?? combine(layers)) as RuntimeLayer
-  })
-  if (layers.length === 0) return Layer.empty as never
-  return layers.slice(1).reduce((result, layer) => result.pipe(Layer.provideMerge(layer)), layers[0]) as never
-}
-
-export function combine(layers: readonly Layer.Any[]): RuntimeLayer {
-  return layers.reduce<RuntimeLayer>(
-    (result, layer) => (layer as RuntimeLayer).pipe(Layer.provideMerge(result)),
-    Layer.empty as RuntimeLayer,
-  )
-}
-
-function plan(
-  root: AnyNode,
-  tiers: Tiers<readonly [string, ...string[]]>,
-  replacements: ReadonlyMap<Layer.Any, Layer.Any>,
-) {
-  const indexes = new Map(tiers.names.map((name, index) => [tiers.values[name], index]))
-  const plans = new Map<Tier, Layer.Any[]>()
-  const activeImplementations = new Map<Tier, Map<string, AnyNode>>()
-  const serviceTiers = new Map<string, Tier>()
-  const visiting = new Set<AnyNode>()
-  const stack: AnyNode[] = []
-  const boundaryVisited = new Map<AnyNode, Set<Tier>>()
-  const boundaryServices = new Map<Tier, Map<string, AnyNode>>()
-
-  const validateBoundary = (node: AnyNode, origin: Tier) => {
-    const checked = boundaryVisited.get(node) ?? new Set<Tier>()
-    boundaryVisited.set(node, checked)
-    if (checked.has(origin)) return false
-    checked.add(origin)
-    const services = boundaryServices.get(origin) ?? new Map<string, AnyNode>()
-    boundaryServices.set(origin, services)
-    const key = node.name
-    const existing = services.get(key)
-    if (existing && existing !== node) {
-      throw new Error(`Tier ${origin} has conflicting implementations for ${key}`)
-    }
-    services.set(key, node)
-    return true
-  }
-
-  const visit = (node: AnyNode, currentTier?: Tier, origins: readonly Tier[] = []) => {
-    if (node.kind === "group") {
-      node.dependencies.forEach((dependency) => visit(dependency, currentTier, origins))
-      return
-    }
-
-    const tier = node.tier ?? untiered
-    if (!indexes.has(tier)) throw new Error(`Node ${node.name} is not in the tier configuration`)
-    const key = node.name
-    const serviceTier = serviceTiers.get(key)
-    if (serviceTier && serviceTier !== tier) {
-      throw new Error(`Service ${key} belongs to both tier ${serviceTier} and tier ${tier}`)
-    }
-    serviceTiers.set(key, tier)
-    const nextOrigins = [...origins]
-    if (currentTier) {
-      const current = indexes.get(currentTier)!
-      const required = indexes.get(tier)!
-      if (required < current) {
-        throw new Error(`Tier ${currentTier} cannot depend on lower tier ${tier}`)
-      }
-      if (required > current) nextOrigins.push(currentTier)
-    }
-    const unseenOrigins = nextOrigins.filter((origin) => validateBoundary(node, origin))
-
-    // A node may need to be emitted more than once because the final output is a
-    // flat list of layers applied with Layer.provideMerge. If another node for
-    // the same service was emitted afterward, this node is no longer the active
-    // implementation for subsequent consumers. Re-emitting restores the intended
-    // implementation ordering while Effect memoization avoids reacquiring the layer.
-    const implementations = activeImplementations.get(tier) ?? new Map<string, AnyNode>()
-    activeImplementations.set(tier, implementations)
-    if (implementations.get(key) === node && unseenOrigins.length === 0) return
-
-    if (visiting.has(node)) {
-      const start = stack.indexOf(node)
-      throw new Error(
-        `Cycle detected in layer graph: ${[...stack.slice(start), node].map((item) => item.name).join(" -> ")}`,
-      )
-    }
-
-    visiting.add(node)
-    stack.push(node)
-    try {
-      node.dependencies.forEach((dependency) => visit(dependency, tier, unseenOrigins))
-      const layers = plans.get(tier) ?? []
-      plans.set(tier, layers)
-      layers.push(replacements.get(node.implementation!) ?? node.implementation!)
-      implementations.set(key, node)
-    } finally {
-      stack.pop()
-      visiting.delete(node)
-    }
-  }
-
-  visit(root)
-  return plans
-}
-
-function requireTier(node: AnyNode, indexes: ReadonlyMap<Tier, number>) {
-  if (!node.tier || !indexes.has(node.tier)) throw new Error(`Node ${node.name} is not in the tier configuration`)
-}
-
 export * as LayerNode from "./layer-node"
--- a/packages/core/src/effect/scoped-node-build.ts
+++ b/packages/core/src/effect/scoped-node-build.ts
@ -0,0 +1,32 @@
+import { Layer } from "effect"
+import { buildLocationServiceMap, type LocationError, type LocationServices } from "../location-layer"
+import { LocationServiceMap, node as locationServiceMapNode } from "../location-service-map"
+import { LayerNode } from "./layer-node"
+import { LayerNodeTree } from "./layer-node-tree"
+import { makeGlobalNode, tiers } from "./scoped-node"
+
+export function build<A, E>(
+  root: LayerNode.Node<A, E, any>,
+  replacements?: readonly LayerNode.Replacement[],
+): Layer.Layer<LocationServiceMap | A, LocationError | E> {
+  const separated = LayerNodeTree.separate(root, tiers)
+
+  const location = LayerNodeTree.hoist(separated.location, tiers.values.location, tiers)
+
+  const replacementMap = new Map(replacements?.map((item) => [item.source, item.replacement]))
+
+  const locationMap = buildLocationServiceMap(
+    location.node as unknown as LayerNode.Node<LocationServices, LocationError, any>,
+    replacementMap,
+  ).pipe(Layer.provide(LayerNodeTree.compile(location.hoisted, replacementMap)))
+
+  const locationMapNode = makeGlobalNode({ service: LocationServiceMap, layer: locationMap, deps: [] })
+  const globalNode = LayerNodeTree.bind(separated.global, locationServiceMapNode, locationMapNode)
+
+  return LayerNodeTree.compile(globalNode, replacementMap).pipe(Layer.provideMerge(locationMap)) as Layer.Layer<
+    LocationServiceMap | A,
+    LocationError | E
+  >
+}
+
+export * as ScopedNodeBuild from "./scoped-node-build"
--- a/packages/core/src/event.ts
+++ b/packages/core/src/event.ts
@ -7,7 +7,7 @@ import { and, asc, eq, gt } from "drizzle-orm"
 import { Database } from "./database/database"
 import { EventSequenceTable, EventTable } from "./event/sql"
 import { Location } from "./location"
-import { LayerNode } from "./effect/layer-node"
+import { makeGlobalNode } from "./effect/scoped-node"
 import { isDeepStrictEqual } from "node:util"
 import { Durable } from "@opencode-ai/schema/durable-event-manifest"

@ -569,6 +569,6 @@ export const layerWith = (options?: LayerOptions) =>
  )

 export const layer = layerWith()
-export const node = LayerNode.make({ service: Service, layer: layer, deps: [Database.node] })
+export const node = makeGlobalNode({ service: Service, layer: layer, deps: [Database.node] })

 export const defaultLayer = layer.pipe(Layer.provide(Database.defaultLayer))
--- a/packages/core/src/file-mutation.ts
+++ b/packages/core/src/file-mutation.ts
@ -1,5 +1,6 @@
 export * as FileMutation from "./file-mutation"

+import { makeLocationNode } from "./effect/scoped-node"
 import { Context, Effect, Layer, Schema } from "effect"
 import { dirname } from "path"
 import { KeyedMutex } from "./effect/keyed-mutex"
@ -192,6 +193,8 @@ function sameBytes(left: Uint8Array, right: Uint8Array) {

 export const locationLayer = layer

+export const node = makeLocationNode({ service: Service, layer, deps: [FSUtil.node] })
+
 /**
 * Deferred until the corresponding V2 integrations exist.
 */
--- a/packages/core/src/filesystem.ts
+++ b/packages/core/src/filesystem.ts
@ -1,5 +1,6 @@
 export * as FileSystem from "./filesystem"

+import { makeLocationNode } from "./effect/scoped-node"
 import path from "path"
 import { Context, Effect, Layer, Schema } from "effect"
 import { FSUtil } from "./fs-util"
@ -113,3 +114,9 @@ const baseLayer = Layer.effect(
 export const layer = baseLayer.pipe(Layer.provide(FileSystemSearch.locationLayer), Layer.provide(FSUtil.defaultLayer))

 export const locationLayer = layer
+
+export const node = makeLocationNode({
+  service: Service,
+  layer: baseLayer,
+  deps: [FSUtil.node, Location.node, FileSystemSearch.node],
+})
--- a/packages/core/src/filesystem/search.ts
+++ b/packages/core/src/filesystem/search.ts
@ -1,5 +1,6 @@
 export * as FileSystemSearch from "./search"

+import { makeLocationNode } from "../effect/scoped-node"
 import path from "path"
 import { Context, Effect, Layer, Scope } from "effect"
 import { Fff } from "#fff"
@ -229,6 +230,8 @@ export const fffLayer = Layer.effect(
  }),
 )

-export const locationLayer = Layer.unwrap(
-  Effect.sync(() => (Flag.OPENCODE_DISABLE_FFF || !Fff.available() ? ripgrepLayer : fffLayer)),
-)
+const layer = Layer.unwrap(Effect.sync(() => (Flag.OPENCODE_DISABLE_FFF || !Fff.available() ? ripgrepLayer : fffLayer)))
+
+export const locationLayer = layer
+
+export const node = makeLocationNode({ service: Service, layer, deps: [FSUtil.node, Location.node, Ripgrep.node] })
--- a/packages/core/src/filesystem/watcher.ts
+++ b/packages/core/src/filesystem/watcher.ts
@ -3,6 +3,7 @@ export * as Watcher from "./watcher"
 // @ts-ignore
 import { createWrapper } from "@parcel/watcher/wrapper"
 import type ParcelWatcher from "@parcel/watcher"
+import { makeLocationNode } from "../effect/scoped-node"
 import { Cause, Context, Effect, Layer } from "effect"
 import { FileSystemWatcher } from "@opencode-ai/schema/filesystem-watcher"
 import path from "path"
@ -133,3 +134,9 @@ export const layer = Layer.effect(
 )

 export const locationLayer = layer.pipe(Layer.provide(Config.locationLayer), Layer.provide(Git.defaultLayer))
+
+export const node = makeLocationNode({
+  service: Service,
+  layer,
+  deps: [FSUtil.node, Location.node, Config.node, Git.node, EventV2.node],
+})
--- a/packages/core/src/fs-util.ts
+++ b/packages/core/src/fs-util.ts
@ -7,7 +7,7 @@ import { Context, Effect, FileSystem, Layer, Schema } from "effect"
 import type { PlatformError } from "effect/PlatformError"
 import { Glob } from "./util/glob"
 import { serviceUse } from "./effect/service-use"
-import { LayerNode } from "./effect/layer-node"
+import { makeGlobalNode } from "./effect/scoped-node"
 import { filesystem } from "./effect/layer-node-platform"

 export namespace FSUtil {
@ -201,7 +201,7 @@ export namespace FSUtil {
  )

  export const defaultLayer = layer.pipe(Layer.provide(NodeFileSystem.layer))
-  export const node = LayerNode.make({ service: Service, layer: layer, deps: [filesystem] })
+  export const node = makeGlobalNode({ service: Service, layer: layer, deps: [filesystem] })

  // Pure helpers that don't need Effect (path manipulation, sync operations)
  export function mimeType(p: string): string {
--- a/packages/core/src/git.ts
+++ b/packages/core/src/git.ts
@ -7,7 +7,7 @@ import { ChildProcess } from "effect/unstable/process"
 import { AbsolutePath, RelativePath } from "./schema"
 import { FSUtil } from "./fs-util"
 import { AppProcess } from "./process"
-import { LayerNode } from "./effect/layer-node"
+import { makeGlobalNode } from "./effect/scoped-node"
 import { File } from "./file"
 import { KeyedMutex } from "./effect/keyed-mutex"

@ -944,7 +944,7 @@ export const layer = Layer.effect(
 )

 export const defaultLayer = layer.pipe(Layer.provide(FSUtil.defaultLayer), Layer.provide(AppProcess.defaultLayer))
-export const node = LayerNode.make({ service: Service, layer: layer, deps: [FSUtil.node, AppProcess.node] })
+export const node = makeGlobalNode({ service: Service, layer: layer, deps: [FSUtil.node, AppProcess.node] })

 interface Result {
  readonly exitCode: number
--- a/packages/core/src/global.ts
+++ b/packages/core/src/global.ts
@ -5,7 +5,7 @@ import os from "os"
 import { Context, Effect, Layer } from "effect"
 import { Flock } from "./util/flock"
 import { Flag } from "./flag/flag"
-import { LayerNode } from "./effect/layer-node"
+import { makeGlobalNode } from "./effect/scoped-node"

 const app = "opencode"
 const data = path.join(xdgData!, app)
@ -77,7 +77,7 @@ export const layer = Layer.effect(
 )

 export const defaultLayer = layer
-export const node = LayerNode.make({ service: Service, layer: layer, deps: [] })
+export const node = makeGlobalNode({ service: Service, layer: layer, deps: [] })

 export const layerWith = (input: Partial<Interface>) =>
  Layer.effect(
--- a/packages/core/src/image.ts
+++ b/packages/core/src/image.ts
@ -1,5 +1,6 @@
 export * as Image from "./image"

+import { makeLocationNode } from "./effect/scoped-node"
 import { Context, Effect, Layer, Schema } from "effect"
 import { Config } from "./config"
 import { FileSystem } from "./filesystem"
@ -76,3 +77,5 @@ export const layer = Layer.effect(
 )

 export const locationLayer = layer.pipe(Layer.provide(Config.locationLayer))
+
+export const node = makeLocationNode({ service: Service, layer, deps: [Config.node] })
--- a/packages/core/src/instruction-context.ts
+++ b/packages/core/src/instruction-context.ts
@ -9,6 +9,7 @@ import { Location } from "./location"
 import { AbsolutePath } from "./schema"
 import { SystemContext } from "./system-context/index"
 import { SystemContextRegistry } from "./system-context/registry"
+import { makeLocationNode } from "./effect/scoped-node"

 class File extends Schema.Class<File>("InstructionContext.File")({
  path: AbsolutePath,
@ -87,6 +88,12 @@ export const layer = Layer.effectDiscard(
  }),
 )

+export const node = makeLocationNode({
+  name: "instruction-context",
+  layer,
+  deps: [FSUtil.node, Global.node, Location.node, SystemContextRegistry.node],
+})
+
 function render(files: ReadonlyArray<File>) {
  return files.map((file) => `Instructions from: ${file.path}\n${file.content}`).join("\n\n")
 }
--- a/packages/core/src/integration.ts
+++ b/packages/core/src/integration.ts
@ -1,5 +1,6 @@
 export * as Integration from "./integration"

+import { makeLocationNode } from "./effect/scoped-node"
 import {
  Cause,
  Clock,
@ -515,3 +516,5 @@ export const locationLayer = Layer.effect(
    })
  }),
 )
+
+export const node = makeLocationNode({ service: Service, layer: locationLayer, deps: [Credential.node, EventV2.node] })
--- a/packages/core/src/location-layer.ts
+++ b/packages/core/src/location-layer.ts
@ -1,151 +1,125 @@
 import { Effect, Layer, LayerMap } from "effect"
-import { Location } from "./location"
-import { Policy } from "./policy"
-import { Config } from "./config"
-import { PluginV2 } from "./plugin"
-import { Catalog } from "./catalog"
-import { Integration } from "./integration"
-import { CommandV2 } from "./command"
 import { AgentV2 } from "./agent"
-import { PluginInternal } from "./plugin/internal"
-import { Project } from "./project"
-import { ProjectCopy } from "./project/copy"
-import { ProjectDirectories } from "./project/directories"
-import { EventV2 } from "./event"
-import { Credential } from "./credential"
-import { Npm } from "./npm"
-import { ModelsDev } from "./models-dev"
-import { FSUtil } from "./fs-util"
-import { Git } from "./git"
-import { Global } from "./global"
-import { Database } from "./database/database"
-import { PermissionV2 } from "./permission"
-import { PermissionSaved } from "./permission/saved"
-import { FileSystem } from "./filesystem"
-import { Ripgrep } from "./ripgrep"
-import { Watcher } from "./filesystem/watcher"
-import { LocationMutation } from "./location-mutation"
+import { AISDK } from "./aisdk"
+import { Catalog } from "./catalog"
+import { CommandV2 } from "./command"
+import { Config } from "./config"
+import { LayerNode } from "./effect/layer-node"
+import { LayerNodeTree } from "./effect/layer-node-tree"
+import { ScopedNode } from "./effect/scoped-node"
 import { FileMutation } from "./file-mutation"
+import { FileSystem } from "./filesystem"
+import { FileSystemSearch } from "./filesystem/search"
+import { Watcher } from "./filesystem/watcher"
+import { Image } from "./image"
+import { Integration } from "./integration"
+import { Location } from "./location"
+import { LocationMutation } from "./location-mutation"
+import { LocationServiceMap } from "./location-service-map"
+import { PermissionV2 } from "./permission"
+import { PluginV2 } from "./plugin"
+import { PluginInternal } from "./plugin/internal"
+import { Policy } from "./policy"
+import { ProjectCopy } from "./project/copy"
+import { Pty } from "./pty"
+import { QuestionV2 } from "./question"
 import { Reference } from "./reference"
 import { ReferenceGuidance } from "./reference/guidance"
-import { RepositoryCache } from "./repository-cache"
-import { Pty } from "./pty"
-import { SkillV2 } from "./skill"
-import { SkillGuidance } from "./skill/guidance"
-import { BuiltInTools } from "./tool/builtins"
-import { Image } from "./image"
-import { ToolRegistry } from "./tool/registry"
-import { ApplicationTools } from "./tool/application-tools"
-import { ToolOutputStore } from "./tool-output-store"
-import { AppProcess } from "./process"
-import { SessionStore } from "./session/store"
-import { SessionTodo } from "./session/todo"
-import { QuestionV2 } from "./question"
-import { LLMClient } from "@opencode-ai/llm"
-import { RequestExecutor } from "@opencode-ai/llm/route"
 import * as SessionRunnerLLM from "./session/runner/llm"
 import { SessionRunnerModel } from "./session/runner/model"
-import { SystemContextBuiltIns } from "./system-context/builtins"
-import { FetchHttpClient } from "effect/unstable/http"
+import { SessionTodo } from "./session/todo"
+import { SkillV2 } from "./skill"
+import { SkillGuidance } from "./skill/guidance"
 import { Snapshot } from "./snapshot"
+import { SystemContextBuiltIns } from "./system-context/builtins"
+import { SystemContextRegistry } from "./system-context/registry"
+import { BuiltInTools } from "./tool/builtins"
+import { ReadToolFileSystem } from "./tool/read-filesystem"
+import { ToolRegistry } from "./tool/registry"
+import { ToolOutputStore } from "./tool-output-store"

-export class LocationServiceMap extends LayerMap.Service<LocationServiceMap>()("@opencode/example/LocationServiceMap", {
-  lookup: (ref: Location.Ref) => {
-    const boot = Layer.effectDiscard(
-      Effect.logInfo("booting location services", { directory: ref.directory, workspaceID: ref.workspaceID }),
-    )
-    const location = Location.layer(ref)
-    const systemContext = SystemContextBuiltIns.locationLayer
-    const base = Layer.mergeAll(
-      location,
-      Policy.locationLayer,
-      Config.locationLayer,
-      Reference.locationLayer,
-      PluginV2.locationLayer,
-      Catalog.locationLayer,
-      Integration.locationLayer,
-      CommandV2.locationLayer,
-      AgentV2.locationLayer,
-      PluginInternal.locationLayer,
-      ProjectCopy.locationLayer,
-      FileSystem.locationLayer,
-      Watcher.locationLayer,
-      Pty.locationLayer,
-      SkillV2.locationLayer,
-      systemContext,
-      LocationMutation.locationLayer.pipe(Layer.orDie),
-    ).pipe(Layer.provideMerge(location))
-    const resources = ToolOutputStore.layer.pipe(Layer.provide(base))
-    const permissionsAndTools = ToolRegistry.layer.pipe(
-      Layer.provideMerge(PermissionV2.locationLayer),
-      Layer.provide(resources),
-      Layer.provide(base),
-    )
-    const services = Layer.mergeAll(base, resources, permissionsAndTools)
-    const image = Image.layer.pipe(Layer.provide(services))
-    const mutation = FileMutation.locationLayer.pipe(Layer.provide(services))
-    const skillGuidance = SkillGuidance.locationLayer.pipe(Layer.provide(services))
-    const referenceGuidance = ReferenceGuidance.locationLayer.pipe(Layer.provide(services))
-    const todos = SessionTodo.layer.pipe(Layer.provide(services))
-    const questions = QuestionV2.locationLayer.pipe(Layer.provide(services))
-    const builtInTools = BuiltInTools.locationLayer.pipe(
-      Layer.provide(services),
-      Layer.provide(mutation),
-      Layer.provide(resources),
-      Layer.provide(todos),
-      Layer.provide(questions),
-      Layer.provide(image),
-    )
-    const model = SessionRunnerModel.locationLayer.pipe(Layer.provide(services))
-    const snapshot = Snapshot.locationLayer.pipe(Layer.provide(services))
-    const runner = SessionRunnerLLM.defaultLayer.pipe(
-      Layer.provide(services),
-      Layer.provide(model),
-      Layer.provide(skillGuidance),
-      Layer.provide(referenceGuidance),
-      Layer.provide(snapshot),
-    )
+export { LocationServiceMap, node } from "./location-service-map"

-    // Kick off a background project copy refresh to update locations now that we
-    // have a location
-    const projectCopyRefresh = Layer.effectDiscard(ProjectCopy.refreshAfterBoot).pipe(Layer.provide(services))
+export const locationServices = LayerNode.group([
+  Location.node,
+  Policy.node,
+  Config.node,
+  AgentV2.node,
+  CommandV2.node,
+  Reference.node,
+  Integration.node,
+  Catalog.node,
+  AISDK.node,
+  PluginV2.node,
+  PluginInternal.node,
+  ProjectCopy.node,
+  ProjectCopy.refreshNode,
+  FileSystemSearch.node,
+  FileSystem.node,
+  Watcher.node,
+  Pty.node,
+  SkillV2.node,
+  SystemContextRegistry.node,
+  SystemContextBuiltIns.node,
+  LocationMutation.node,
+  FileMutation.node,
+  PermissionV2.node,
+  ToolOutputStore.node,
+  ToolRegistry.node,
+  ToolRegistry.toolsNode,
+  Image.node,
+  SkillGuidance.node,
+  ReferenceGuidance.node,
+  SessionTodo.node,
+  QuestionV2.node,
+  ReadToolFileSystem.node,
+  BuiltInTools.node,
+  SessionRunnerModel.node,
+  Snapshot.node,
+  SessionRunnerLLM.node,
+])

-    return Layer.mergeAll(
-      boot,
-      services,
-      image,
-      mutation,
-      resources,
-      todos,
-      questions,
-      model,
-      snapshot,
-      runner,
-      builtInTools,
-      referenceGuidance,
-      projectCopyRefresh,
-    ).pipe(Layer.fresh)
-  },
-  idleTimeToLive: "60 minutes",
-  dependencies: [
-    Project.defaultLayer,
-    EventV2.defaultLayer,
-    Credential.defaultLayer,
-    Npm.defaultLayer,
-    ModelsDev.defaultLayer,
-    FSUtil.defaultLayer,
-    Git.defaultLayer,
-    AppProcess.defaultLayer,
-    Global.defaultLayer,
-    Ripgrep.defaultLayer,
-    Database.defaultLayer,
-    ProjectDirectories.defaultLayer,
-    SessionStore.layer.pipe(Layer.provide(Database.defaultLayer)),
-    PermissionSaved.defaultLayer,
-    RepositoryCache.defaultLayer,
-    LLMClient.layer.pipe(Layer.provide(RequestExecutor.defaultLayer)),
-    FetchHttpClient.layer,
-    ToolOutputStore.defaultCleanupLayer,
-    ApplicationTools.layer,
-  ],
-}) {}
+type NodeOutput<N> = N extends LayerNode.Node<infer A, unknown, any> ? A : never
+type NodeError<N> = N extends LayerNode.Node<unknown, infer E, any> ? E : never
+export type LocationServices = NodeOutput<typeof locationServices>
+export type LocationError = NodeError<typeof locationServices>
+export type LocationTierServices = Exclude<LocationServices, Location.Service>
+
+export function buildLocationServiceMap(
+  location: LayerNode.Node<LocationServices, LocationError, any>,
+  replacements?: ReadonlyMap<Layer.Any, Layer.Any>,
+): Layer.Layer<LocationServiceMap, LocationError> {
+  return Layer.effect(
+    LocationServiceMap,
+    LayerMap.make(
+      (ref: Location.Ref) => {
+        const layer = LayerNodeTree.compile(
+          LayerNodeTree.bind(location, Location.node, Location.boundNode(ref)),
+          replacements,
+        ) as Layer.Layer<LocationServices, LocationError>
+        return layer.pipe(
+          Layer.fresh,
+          Layer.tap(() =>
+            Effect.logInfo("booting location services", {
+              directory: ref.directory,
+              workspaceID: ref.workspaceID,
+            }),
+          ),
+        )
+      },
+      { idleTimeToLive: "60 minutes" },
+    ),
+  )
+}
+
+// This is temporary for backwards compatibility
+const separatedLocationServices = LayerNodeTree.separate(locationServices, ScopedNode.tiers)
+const hoistedLocationServices = LayerNodeTree.hoist(
+  separatedLocationServices.location,
+  ScopedNode.tiers.values.location,
+  ScopedNode.tiers,
+)
+
+export const locationServiceMapLayer = buildLocationServiceMap(
+  hoistedLocationServices.node as LayerNode.Node<LocationServices, LocationError, any>,
+).pipe(Layer.provide(LayerNodeTree.compile(hoistedLocationServices.hoisted))) as Layer.Layer<LocationServiceMap>
--- a/packages/core/src/location-mutation.ts
+++ b/packages/core/src/location-mutation.ts
@ -1,5 +1,6 @@
 export * as LocationMutation from "./location-mutation"

+import { makeLocationNode } from "./effect/scoped-node"
 import path from "path"
 import { Context, Effect, Layer, Schema } from "effect"
 import { FSUtil } from "./fs-util"
@ -153,3 +154,9 @@ export const layer = Layer.effect(
 )

 export const locationLayer = layer
+
+export const node = makeLocationNode({
+  service: Service,
+  layer: layer.pipe(Layer.orDie),
+  deps: [FSUtil.node, Location.node],
+})
--- a/packages/core/src/location-service-map.ts
+++ b/packages/core/src/location-service-map.ts
@ -0,0 +1,16 @@
+import { Context, Effect, Layer, LayerMap } from "effect"
+import { LayerNode } from "./effect/layer-node"
+import { ScopedNode } from "./effect/scoped-node"
+import { Location } from "./location"
+import type { LocationError, LocationServices } from "./location-layer"
+
+export class LocationServiceMap extends Context.Service<
+  LocationServiceMap,
+  LayerMap.LayerMap<Location.Ref, LocationServices, LocationError>
+>()("@opencode/example/LocationServiceMap") {
+  static get(ref: Location.Ref) {
+    return Layer.unwrap(Effect.map(LocationServiceMap, (locations) => locations.get(ref)))
+  }
+}
+
+export const node = LayerNode.unbound(LocationServiceMap, ScopedNode.tiers.values.global)
--- a/packages/core/src/location.ts
+++ b/packages/core/src/location.ts
@ -1,6 +1,8 @@
 import { Context, Effect, Layer } from "effect"
 import { Info, Ref, response } from "@opencode-ai/schema/location"
 import { Project } from "./project"
+import { LayerNode } from "./effect/layer-node"
+import { makeLocationNode, tiers } from "./effect/scoped-node"

 export * as Location from "./location"

@ -12,6 +14,8 @@ export interface Interface extends Info {

 export class Service extends Context.Service<Service, Interface>()("@opencode/Location") {}

+export const node = LayerNode.unbound(Service, tiers.values.location)
+
 export const layer = (ref: Ref) =>
  Layer.effect(
    Service,
@ -26,3 +30,10 @@ export const layer = (ref: Ref) =>
      })
    }),
  )
+
+export const boundNode = (ref: Ref) =>
+  makeLocationNode({
+    service: Service,
+    layer: layer(ref),
+    deps: [Project.node],
+  })
--- a/packages/core/src/models-dev.ts
+++ b/packages/core/src/models-dev.ts
@ -9,7 +9,7 @@ import { Hash } from "./util/hash"
 import { FSUtil } from "./fs-util"
 import { InstallationChannel, InstallationVersion } from "./installation/version"
 import { EventV2 } from "./event"
-import { LayerNode } from "./effect/layer-node"
+import { makeGlobalNode } from "./effect/scoped-node"
 import { httpClient } from "./effect/layer-node-platform"

 export const CatalogModelStatus = Schema.Literals(["alpha", "beta", "deprecated"])
@ -244,6 +244,6 @@ export const defaultLayer = layer.pipe(
  Layer.provide(FSUtil.defaultLayer),
  Layer.provide(EventV2.defaultLayer),
 )
-export const node = LayerNode.make({ service: Service, layer: layer, deps: [FSUtil.node, EventV2.node, httpClient] })
+export const node = makeGlobalNode({ service: Service, layer: layer, deps: [FSUtil.node, EventV2.node, httpClient] })

 export * as ModelsDev from "./models-dev"
--- a/packages/core/src/npm.ts
+++ b/packages/core/src/npm.ts
@ -7,7 +7,7 @@ import { NodeFileSystem } from "@effect/platform-node"
 import { FSUtil } from "./fs-util"
 import { Global } from "./global"
 import { EffectFlock } from "./util/effect-flock"
-import { LayerNode } from "./effect/layer-node"
+import { makeGlobalNode } from "./effect/scoped-node"
 import { filesystem } from "./effect/layer-node-platform"
 import { makeRuntime } from "./effect/runtime"
 import { NpmConfig } from "./npm-config"
@ -253,7 +253,7 @@ export const defaultLayer = layer.pipe(
  Layer.provide(Global.layer),
  Layer.provide(NodeFileSystem.layer),
 )
-export const node = LayerNode.make({
+export const node = makeGlobalNode({
  service: Service,
  layer: layer,
  deps: [FSUtil.node, Global.node, filesystem, EffectFlock.node],
--- a/packages/core/src/permission.ts
+++ b/packages/core/src/permission.ts
@ -1,5 +1,6 @@
 export * as PermissionV2 from "./permission"

+import { makeLocationNode } from "./effect/scoped-node"
 import { Context, Deferred, Effect as EffectRuntime, Layer, Schema } from "effect"
 import { Permission } from "@opencode-ai/schema/permission"
 import { EventV2 } from "./event"
@ -300,3 +301,9 @@ export const layer = Layer.effect(
 )

 export const locationLayer = layer.pipe(Layer.provideMerge(AgentV2.locationLayer))
+
+export const node = makeLocationNode({
+  service: Service,
+  layer,
+  deps: [EventV2.node, Location.node, AgentV2.node, SessionStore.node, PermissionSaved.node],
+})
--- a/packages/core/src/permission/saved.ts
+++ b/packages/core/src/permission/saved.ts
@ -3,6 +3,7 @@ export * as PermissionSaved from "./saved"
 import { eq } from "drizzle-orm"
 import { Context, Effect, Layer, Schema } from "effect"
 import { Database } from "../database/database"
+import { makeGlobalNode } from "../effect/scoped-node"
 import { ProjectV2 } from "../project"
 import { PermissionTable } from "./sql"
 import { PermissionSaved } from "@opencode-ai/schema/permission-saved"
@ -76,3 +77,5 @@ export const layer = Layer.effect(
 )

 export const defaultLayer = layer.pipe(Layer.provide(Database.defaultLayer))
+
+export const node = makeGlobalNode({ service: Service, layer, deps: [Database.node] })
--- a/packages/core/src/plugin.ts
+++ b/packages/core/src/plugin.ts
@ -1,5 +1,6 @@
 export * as PluginV2 from "./plugin"

+import { makeLocationNode } from "./effect/scoped-node"
 import { Context, Deferred, Effect, Exit, Layer, Scope } from "effect"
 import type { Plugin as PluginRuntime } from "@opencode-ai/plugin/v2/effect"
 import { Plugin } from "@opencode-ai/schema/plugin"
@ -150,3 +151,18 @@ export const locationLayer = layer.pipe(
  Layer.provideMerge(Reference.locationLayer),
  Layer.provideMerge(SkillV2.locationLayer),
 )
+
+export const node = makeLocationNode({
+  service: Service,
+  layer,
+  deps: [
+    EventV2.node,
+    AgentV2.node,
+    AISDK.node,
+    Catalog.node,
+    CommandV2.node,
+    Integration.node,
+    Reference.node,
+    SkillV2.node,
+  ],
+})
--- a/packages/core/src/plugin/internal.ts
+++ b/packages/core/src/plugin/internal.ts
@ -1,5 +1,7 @@
 export * as PluginInternal from "./internal"

+import { makeLocationNode } from "../effect/scoped-node"
+import { httpClient } from "../effect/layer-node-platform"
 import type { PluginContext } from "@opencode-ai/plugin/v2/effect"
 import { Effect, Layer, Scope } from "effect"
 import { AgentV2 } from "../agent"
@ -57,7 +59,7 @@ export function define<R>(plugin: Plugin<R>) {
  return plugin
 }

-export const locationLayer = Layer.effectDiscard(
+const layer = Layer.effectDiscard(
  Effect.gen(function* () {
    const catalog = yield* Catalog.Service
    const commands = yield* CommandV2.Service
@ -117,9 +119,34 @@ export const locationLayer = Layer.effectDiscard(
      yield* add(VariantPlugin.Plugin)
    }).pipe(Effect.withSpan("PluginInternal.boot"), Effect.forkScoped({ startImmediately: true }))
  }),
-).pipe(
+)
+
+export const locationLayer = layer.pipe(
  Layer.provideMerge(PluginV2.locationLayer),
  Layer.provideMerge(Config.locationLayer),
  Layer.provideMerge(FileSystem.locationLayer),
  Layer.provideMerge(FetchHttpClient.layer),
 )
+
+export const node = makeLocationNode({
+  name: "plugin-internal",
+  layer,
+  deps: [
+    Catalog.node,
+    CommandV2.node,
+    PluginV2.node,
+    Integration.node,
+    AgentV2.node,
+    Config.node,
+    Location.node,
+    ModelsDev.node,
+    Npm.node,
+    EventV2.node,
+    FSUtil.node,
+    FileSystem.node,
+    Global.node,
+    httpClient,
+    SkillV2.node,
+    Reference.node,
+  ],
+})
--- a/packages/core/src/policy.ts
+++ b/packages/core/src/policy.ts
@ -1,5 +1,6 @@
 export * as Policy from "./policy"

+import { makeLocationNode } from "./effect/scoped-node"
 import { Context, Effect as EffectRuntime, Layer, Schema } from "effect"
 import { Wildcard } from "./util/wildcard"
 import { Location } from "./location"
@ -44,3 +45,5 @@ export const layer = Layer.effect(
 )

 export const locationLayer = layer
+
+export const node = makeLocationNode({ service: Service, layer, deps: [Location.node] })
--- a/packages/core/src/process.ts
+++ b/packages/core/src/process.ts
@ -3,7 +3,7 @@ import type { PlatformError } from "effect/PlatformError"
 import { ChildProcess } from "effect/unstable/process"
 import { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner"
 import { CrossSpawnSpawner } from "./cross-spawn-spawner"
-import { LayerNode } from "./effect/layer-node"
+import { makeGlobalNode } from "./effect/scoped-node"

 export class AppProcessError extends Schema.TaggedErrorClass<AppProcessError>()("AppProcessError", {
  command: Schema.String,
@ -238,6 +238,6 @@ export const layer = Layer.effect(
 )

 export const defaultLayer = layer.pipe(Layer.provide(CrossSpawnSpawner.defaultLayer))
-export const node = LayerNode.make({ service: Service, layer: layer, deps: [CrossSpawnSpawner.node] })
+export const node = makeGlobalNode({ service: Service, layer: layer, deps: [CrossSpawnSpawner.node] })

 export * as AppProcess from "./process"
--- a/packages/core/src/project.ts
+++ b/packages/core/src/project.ts
@ -6,7 +6,7 @@ import path from "path"
 import { AbsolutePath } from "./schema"
 import { FSUtil } from "./fs-util"
 import { Git } from "./git"
-import { LayerNode } from "./effect/layer-node"
+import { makeGlobalNode } from "./effect/scoped-node"
 import { Hash } from "./util/hash"
 import { ProjectDirectories } from "./project/directories"
 import { ProjectSchema } from "./project/schema"
@ -134,7 +134,7 @@ export const defaultLayer = layer.pipe(
  Layer.provide(Git.defaultLayer),
  Layer.provideMerge(ProjectDirectories.defaultLayer),
 )
-export const node = LayerNode.make({
+export const node = makeGlobalNode({
  service: Service,
  layer: layer,
  deps: [FSUtil.node, Git.node, ProjectDirectories.node],
--- a/packages/core/src/project/copy.ts
+++ b/packages/core/src/project/copy.ts
@ -5,7 +5,7 @@ import path from "path"
 import { AbsolutePath } from "../schema"
 import { FSUtil } from "../fs-util"
 import { Git } from "../git"
-import { LayerNode } from "../effect/layer-node"
+import { makeLocationNode } from "../effect/scoped-node"
 import { Project } from "../project"
 import { ProjectDirectories } from "./directories"
 import { makeGitWorktreeStrategy } from "./copy-strategies"
@ -279,8 +279,14 @@ export const layer = Layer.effect(
 )

 export const locationLayer = layer
-export const node = LayerNode.make({
+export const node = makeLocationNode({
  service: Service,
  layer: layer,
  deps: [FSUtil.node, Git.node, ProjectDirectories.node, EventV2.node, Database.node],
 })
+
+export const refreshNode = makeLocationNode({
+  name: "project-copy-refresh",
+  layer: Layer.effectDiscard(refreshAfterBoot),
+  deps: [node, Location.node],
+})
--- a/packages/core/src/project/directories.ts
+++ b/packages/core/src/project/directories.ts
@ -3,7 +3,7 @@ export * as ProjectDirectories from "./directories"
 import { and, asc, desc, eq, isNotNull, isNull, ne, or } from "drizzle-orm"
 import { Context, Effect, Layer, Schema } from "effect"
 import { Database } from "../database/database"
-import { LayerNode } from "../effect/layer-node"
+import { makeGlobalNode } from "../effect/scoped-node"
 import { AbsolutePath, optional } from "../schema"
 import { ProjectSchema } from "./schema"
 import { ProjectDirectoryTable } from "./sql"
@ -156,4 +156,4 @@ export const layer = Layer.effect(
 )

 export const defaultLayer = layer.pipe(Layer.provide(Database.defaultLayer))
-export const node = LayerNode.make({ service: Service, layer: layer, deps: [Database.node] })
+export const node = makeGlobalNode({ service: Service, layer: layer, deps: [Database.node] })
--- a/packages/core/src/pty.ts
+++ b/packages/core/src/pty.ts
@ -1,5 +1,6 @@
 export * as Pty from "./pty"

+import { makeLocationNode } from "./effect/scoped-node"
 import type { Disp, Proc } from "#pty"
 import { Context, Effect, Layer, Schema, Types } from "effect"
 import { Pty } from "@opencode-ai/schema/pty"
@ -313,3 +314,5 @@ export const layer = Layer.effect(
 )

 export const locationLayer = layer.pipe(Layer.provide(Config.locationLayer))
+
+export const node = makeLocationNode({ service: Service, layer, deps: [EventV2.node, Location.node, Config.node] })
--- a/packages/core/src/pty/ticket.ts
+++ b/packages/core/src/pty/ticket.ts
@ -4,7 +4,7 @@ import { WorkspaceV2 } from "../workspace"
 import { PtyTicket } from "@opencode-ai/schema/pty-ticket"
 import { PtyID } from "./schema"
 import { Cache, Context, Duration, Effect, Layer } from "effect"
-import { LayerNode } from "../effect/layer-node"
+import { makeGlobalNode } from "../effect/scoped-node"

 const DEFAULT_TTL = Duration.seconds(60)
 const CAPACITY = 10_000
@ -54,4 +54,4 @@ export const make = (ttl: Duration.Input = DEFAULT_TTL) =>
 export const layer = Layer.effect(Service, make())

 export const defaultLayer = layer
-export const node = LayerNode.make({ service: Service, layer: layer, deps: [] })
+export const node = makeGlobalNode({ service: Service, layer: layer, deps: [] })
--- a/packages/core/src/question.ts
+++ b/packages/core/src/question.ts
@ -1,5 +1,6 @@
 export * as QuestionV2 from "./question"

+import { makeLocationNode } from "./effect/scoped-node"
 import { Context, Deferred, Effect, Layer, Schema } from "effect"
 import { Question } from "@opencode-ai/schema/question"
 import { EventV2 } from "./event"
@ -148,3 +149,5 @@ export const layer = Layer.effect(
 )

 export const locationLayer = layer
+
+export const node = makeLocationNode({ service: Service, layer, deps: [EventV2.node] })
--- a/packages/core/src/reference.ts
+++ b/packages/core/src/reference.ts
@ -1,5 +1,6 @@
 export * as Reference from "./reference"

+import { makeLocationNode } from "./effect/scoped-node"
 import { Context, Effect, Layer, Scope, Types } from "effect"
 import { Reference } from "@opencode-ai/schema/reference"
 import { Global } from "./global"
@ -120,3 +121,9 @@ export const layer = Layer.effect(
 )

 export const locationLayer = layer
+
+export const node = makeLocationNode({
+  service: Service,
+  layer,
+  deps: [Global.node, EventV2.node, RepositoryCache.node],
+})
--- a/packages/core/src/reference/guidance.ts
+++ b/packages/core/src/reference/guidance.ts
@ -1,5 +1,6 @@
 export * as ReferenceGuidance from "./guidance"

+import { makeLocationNode } from "../effect/scoped-node"
 import { Context, Effect, Layer, Schema } from "effect"
 import { Reference } from "../reference"
 import { SystemContext } from "../system-context/index"
@ -64,3 +65,5 @@ export const layer = Layer.effect(
 )

 export const locationLayer = layer
+
+export const node = makeLocationNode({ service: Service, layer, deps: [Reference.node] })
--- a/packages/core/src/repository-cache.ts
+++ b/packages/core/src/repository-cache.ts
@ -5,6 +5,7 @@ import { Git } from "./git"
 import { Global } from "./global"
 import { Repository } from "./repository"
 import { AbsolutePath } from "./schema"
+import { makeGlobalNode } from "./effect/scoped-node"
 import { EffectFlock } from "./util/effect-flock"

 export type Result = {
@ -229,6 +230,12 @@ export const defaultLayer: Layer.Layer<Service> = layer.pipe(
  Layer.provide(Global.defaultLayer),
 )

+export const node = makeGlobalNode({
+  service: Service,
+  layer,
+  deps: [EffectFlock.node, FSUtil.node, Git.node, Global.node],
+})
+
 function statusForRepository(input: { reuse: boolean; refresh?: boolean; branchMatches?: boolean }) {
  if (!input.reuse) return "cloned" as const
  if (input.branchMatches === false || input.refresh) return "refreshed" as const
--- a/packages/core/src/ripgrep.ts
+++ b/packages/core/src/ripgrep.ts
@ -3,7 +3,7 @@ export * as Ripgrep from "./ripgrep"
 import { Context, Effect, Fiber, Layer, Schema, Stream } from "effect"
 import { ChildProcess } from "effect/unstable/process"
 import { Entry, Match } from "@opencode-ai/schema/filesystem"
-import { LayerNode } from "./effect/layer-node"
+import { makeGlobalNode } from "./effect/scoped-node"
 import { AppProcess, collectStream, waitForAbort } from "./process"
 import { NonNegativeInt, PositiveInt, RelativePath } from "./schema"
 import { RipgrepBinary } from "./ripgrep/binary"
@ -279,4 +279,4 @@ export const layer = Layer.effect(
 )

 export const defaultLayer = layer.pipe(Layer.provide(Layer.merge(RipgrepBinary.defaultLayer, AppProcess.defaultLayer)))
-export const node = LayerNode.make({ service: Service, layer: layer, deps: [RipgrepBinary.node, AppProcess.node] })
+export const node = makeGlobalNode({ service: Service, layer: layer, deps: [RipgrepBinary.node, AppProcess.node] })
--- a/packages/core/src/ripgrep/binary.ts
+++ b/packages/core/src/ripgrep/binary.ts
@ -4,7 +4,7 @@ import { FetchHttpClient, HttpClient, HttpClientRequest } from "effect/unstable/
 import { ChildProcess } from "effect/unstable/process"
 import { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner"
 import { CrossSpawnSpawner } from "../cross-spawn-spawner"
-import { LayerNode } from "../effect/layer-node"
+import { makeGlobalNode } from "../effect/scoped-node"
 import { httpClient } from "../effect/layer-node-platform"
 import { FSUtil } from "../fs-util"
 import { Global } from "../global"
@ -130,7 +130,7 @@ export namespace RipgrepBinary {
    Layer.provide(CrossSpawnSpawner.defaultLayer),
  )

-  export const node = LayerNode.make({
+  export const node = makeGlobalNode({
    service: Service,
    layer: layer,
    deps: [FSUtil.node, httpClient, CrossSpawnSpawner.node],
--- a/packages/core/src/session.ts
+++ b/packages/core/src/session.ts
@ -26,6 +26,9 @@ import { fromRow } from "./session/info"
 import { SessionRunner } from "./session/runner/index"
 import { SessionStore } from "./session/store"
 import { SessionExecution } from "./session/execution"
+import { SessionExecutionLocal } from "./session/execution/local"
+import { makeGlobalNode } from "./effect/scoped-node"
+import { LocationServiceMap, node as locationServiceMapNode } from "./location-service-map"
 import { MessageDecodeError } from "./session/error"
 import { SessionEvent } from "./session/event"
 import { SessionInput } from "./session/input"
@ -170,279 +173,267 @@ export interface Interface {

 export class Service extends Context.Service<Service, Interface>()("@opencode/v2/Session") {}

-export const layer = Layer.unwrap(
-  Effect.promise(() => import("./location-layer")).pipe(
-    Effect.map(({ LocationServiceMap }) =>
-      Layer.effect(
-        Service,
-        Effect.gen(function* () {
-          const database = yield* Database.Service
-          const db = database.db
-          const events = yield* EventV2.Service
-          const projects = yield* ProjectV2.Service
-          const execution = yield* SessionExecution.Service
-          const store = yield* SessionStore.Service
-          const locations = yield* LocationServiceMap
-          const decodeMessage = Schema.decodeUnknownEffect(SessionMessage.Message)
-          const isDurableSessionEvent = Schema.is(SessionEvent.Durable)
-          const decode = (row: typeof SessionMessageTable.$inferSelect) =>
-            decodeMessage({ ...row.data, id: row.id, type: row.type }).pipe(
-              Effect.mapError(
-                () =>
-                  new MessageDecodeError({
-                    sessionID: SessionSchema.ID.make(row.session_id),
-                    messageID: SessionMessage.ID.make(row.id),
-                  }),
+export const layer = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    const database = yield* Database.Service
+    const db = database.db
+    const events = yield* EventV2.Service
+    const projects = yield* ProjectV2.Service
+    const execution = yield* SessionExecution.Service
+    const store = yield* SessionStore.Service
+    const locations = yield* LocationServiceMap
+    const decodeMessage = Schema.decodeUnknownEffect(SessionMessage.Message)
+    const isDurableSessionEvent = Schema.is(SessionEvent.Durable)
+    const decode = (row: typeof SessionMessageTable.$inferSelect) =>
+      decodeMessage({ ...row.data, id: row.id, type: row.type }).pipe(
+        Effect.mapError(
+          () =>
+            new MessageDecodeError({
+              sessionID: SessionSchema.ID.make(row.session_id),
+              messageID: SessionMessage.ID.make(row.id),
+            }),
+        ),
+      )
+
+    const result = Service.of({
+      create: Effect.fn("V2Session.create")(function* (input) {
+        const sessionID = input.id ?? SessionSchema.ID.create()
+        const recorded = yield* store.get(sessionID)
+        if (recorded) return recorded
+        const project = yield* projects.resolve(input.location.directory)
+        yield* db
+          .insert(ProjectTable)
+          .values({ id: project.id, worktree: project.directory, vcs: project.vcs?.type, sandboxes: [] })
+          .onConflictDoNothing()
+          .run()
+          .pipe(Effect.orDie)
+        const now = Date.now()
+        const info = SessionV1.SessionInfo.make({
+          id: sessionID,
+          slug: Slug.create(),
+          version: InstallationVersion,
+          projectID: project.id,
+          directory: input.location.directory,
+          path: path.relative(project.directory, input.location.directory).replaceAll("\\", "/"),
+          workspaceID: input.location.workspaceID ? WorkspaceV2.ID.make(input.location.workspaceID) : undefined,
+          title: `New session - ${new Date(now).toISOString()}`,
+          agent: input.agent,
+          model: input.model
+            ? {
+                id: ModelV2.ID.make(input.model.id),
+                providerID: input.model.providerID,
+                variant: input.model.variant,
+              }
+            : undefined,
+          cost: 0,
+          tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+          time: { created: now, updated: now },
+        })
+        const projected = yield* events
+          .publish(SessionV1.Event.Created, { sessionID, info }, { location: input.location })
+          .pipe(
+            Effect.as({ type: "created" } as const),
+            Effect.catchDefect((defect) => {
+              if (!(defect instanceof SessionProjector.SessionAlreadyProjected)) {
+                return Effect.die(defect)
+              }
+              // Concurrent creation lost the projection race. The existing Session identity wins.
+              return store
+                .get(sessionID)
+                .pipe(
+                  Effect.flatMap((session) =>
+                    session ? Effect.succeed({ type: "existing", session } as const) : Effect.die(defect),
+                  ),
+                )
+            }),
+          )
+        if (projected.type === "existing") return projected.session
+        // TODO: Restore recorded sessions onto replacement synchronized workspaces in a future API slice.
+        return yield* result.get(sessionID).pipe(Effect.orDie)
+      }),
+      get: Effect.fn("V2Session.get")(function* (sessionID) {
+        const session = yield* store.get(sessionID)
+        if (!session) return yield* new NotFoundError({ sessionID })
+        return session
+      }),
+      list: Effect.fn("V2Session.list")(function* (input = {}) {
+        const direction = input.anchor?.direction ?? "next"
+        const requestedOrder = input.order ?? "desc"
+        const order = direction === "previous" ? (requestedOrder === "asc" ? "desc" : "asc") : requestedOrder
+        const sortColumn = SessionTable.time_created
+        const conditions: SQL[] = []
+        if ("directory" in input) conditions.push(eq(SessionTable.directory, input.directory))
+        if (input.workspaceID) conditions.push(eq(SessionTable.workspace_id, input.workspaceID))
+        if ("project" in input) conditions.push(eq(SessionTable.project_id, input.project))
+        if (input.search) conditions.push(like(SessionTable.title, `%${input.search}%`))
+        if (input.anchor) {
+          conditions.push(
+            order === "asc"
+              ? or(
+                  gt(sortColumn, input.anchor.time),
+                  and(eq(sortColumn, input.anchor.time), gt(SessionTable.id, input.anchor.id)),
+                )!
+              : or(
+                  lt(sortColumn, input.anchor.time),
+                  and(eq(sortColumn, input.anchor.time), lt(SessionTable.id, input.anchor.id)),
+                )!,
+          )
+        }
+        const query = db
+          .select()
+          .from(SessionTable)
+          .where(conditions.length > 0 ? and(...conditions) : undefined)
+          .orderBy(
+            order === "asc" ? asc(sortColumn) : desc(sortColumn),
+            order === "asc" ? asc(SessionTable.id) : desc(SessionTable.id),
+          )
+        const rows = yield* (input.limit === undefined ? query.all() : query.limit(input.limit).all()).pipe(
+          Effect.orDie,
+        )
+        return (direction === "previous" ? rows.toReversed() : rows).map((row) => fromRow(row))
+      }),
+      messages: Effect.fn("V2Session.messages")(function* (input) {
+        yield* result.get(input.sessionID)
+        const direction = input.cursor?.direction ?? "next"
+        const requestedOrder = input.order ?? "desc"
+        const order = direction === "previous" ? (requestedOrder === "asc" ? "desc" : "asc") : requestedOrder
+        const anchor = input.cursor
+          ? yield* db
+              .select({ seq: SessionMessageTable.seq })
+              .from(SessionMessageTable)
+              .where(
+                and(eq(SessionMessageTable.session_id, input.sessionID), eq(SessionMessageTable.id, input.cursor.id)),
+              )
+              .get()
+              .pipe(Effect.orDie)
+          : undefined
+        if (input.cursor && !anchor) return []
+        const boundary = anchor
+          ? order === "asc"
+            ? gt(SessionMessageTable.seq, anchor.seq)
+            : lt(SessionMessageTable.seq, anchor.seq)
+          : undefined
+        const where = boundary
+          ? and(eq(SessionMessageTable.session_id, input.sessionID), boundary)
+          : eq(SessionMessageTable.session_id, input.sessionID)
+        const query = db
+          .select()
+          .from(SessionMessageTable)
+          .where(where)
+          .orderBy(order === "asc" ? asc(SessionMessageTable.seq) : desc(SessionMessageTable.seq))
+        const rows = yield* (input.limit === undefined ? query.all() : query.limit(input.limit).all()).pipe(
+          Effect.orDie,
+        )
+        return yield* Effect.forEach(direction === "previous" ? rows.toReversed() : rows, decode)
+      }),
+      message: Effect.fn("V2Session.message")(function* (input) {
+        const stored = yield* store.message(input.messageID)
+        return stored?.sessionID === input.sessionID ? stored.message : undefined
+      }),
+      context: Effect.fn("V2Session.context")(function* (sessionID) {
+        yield* result.get(sessionID)
+        return yield* store.context(sessionID)
+      }),
+      events: (input) =>
+        Stream.unwrap(
+          result
+            .get(input.sessionID)
+            .pipe(Effect.as(events.durable({ aggregateID: input.sessionID, after: input.after }))),
+        ).pipe(Stream.filter((event): event is SessionEvent.DurableEvent => isDurableSessionEvent(event))),
+      prompt: Effect.fn("V2Session.prompt")((input) =>
+        Effect.uninterruptible(
+          Effect.gen(function* () {
+            yield* result.get(input.sessionID)
+            const messageID = input.id ?? SessionMessage.ID.create()
+            const delivery = input.delivery ?? "steer"
+            const expected = { sessionID: input.sessionID, messageID, prompt: input.prompt, delivery }
+            const admitted = yield* SessionInput.admit(db, events, {
+              id: messageID,
+              sessionID: input.sessionID,
+              prompt: input.prompt,
+              delivery,
+            }).pipe(
+              Effect.catchDefect((defect) =>
+                defect instanceof SessionInput.LifecycleConflict
+                  ? new PromptConflictError({ sessionID: input.sessionID, messageID })
+                  : Effect.die(defect),
              ),
            )
-
-          const result = Service.of({
-            create: Effect.fn("V2Session.create")(function* (input) {
-              const sessionID = input.id ?? SessionSchema.ID.create()
-              const recorded = yield* store.get(sessionID)
-              if (recorded) return recorded
-              const project = yield* projects.resolve(input.location.directory)
-              yield* db
-                .insert(ProjectTable)
-                .values({ id: project.id, worktree: project.directory, vcs: project.vcs?.type, sandboxes: [] })
-                .onConflictDoNothing()
-                .run()
-                .pipe(Effect.orDie)
-              const now = Date.now()
-              const info = SessionV1.SessionInfo.make({
-                id: sessionID,
-                slug: Slug.create(),
-                version: InstallationVersion,
-                projectID: project.id,
-                directory: input.location.directory,
-                path: path.relative(project.directory, input.location.directory).replaceAll("\\", "/"),
-                workspaceID: input.location.workspaceID ? WorkspaceV2.ID.make(input.location.workspaceID) : undefined,
-                title: `New session - ${new Date(now).toISOString()}`,
-                agent: input.agent,
-                model: input.model
-                  ? {
-                      id: ModelV2.ID.make(input.model.id),
-                      providerID: input.model.providerID,
-                      variant: input.model.variant,
-                    }
-                  : undefined,
-                cost: 0,
-                tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
-                time: { created: now, updated: now },
-              })
-              const projected = yield* events
-                .publish(SessionV1.Event.Created, { sessionID, info }, { location: input.location })
-                .pipe(
-                  Effect.as({ type: "created" } as const),
-                  Effect.catchDefect((defect) => {
-                    if (!(defect instanceof SessionProjector.SessionAlreadyProjected)) {
-                      return Effect.die(defect)
-                    }
-                    // Concurrent creation lost the projection race. The existing Session identity wins.
-                    return store
-                      .get(sessionID)
-                      .pipe(
-                        Effect.flatMap((session) =>
-                          session ? Effect.succeed({ type: "existing", session } as const) : Effect.die(defect),
-                        ),
-                      )
-                  }),
-                )
-              if (projected.type === "existing") return projected.session
-              // TODO: Restore recorded sessions onto replacement synchronized workspaces in a future API slice.
-              return yield* result.get(sessionID).pipe(Effect.orDie)
-            }),
-            get: Effect.fn("V2Session.get")(function* (sessionID) {
-              const session = yield* store.get(sessionID)
-              if (!session) return yield* new NotFoundError({ sessionID })
-              return session
-            }),
-            list: Effect.fn("V2Session.list")(function* (input = {}) {
-              const direction = input.anchor?.direction ?? "next"
-              const requestedOrder = input.order ?? "desc"
-              const order = direction === "previous" ? (requestedOrder === "asc" ? "desc" : "asc") : requestedOrder
-              const sortColumn = SessionTable.time_created
-              const conditions: SQL[] = []
-              if ("directory" in input) conditions.push(eq(SessionTable.directory, input.directory))
-              if (input.workspaceID) conditions.push(eq(SessionTable.workspace_id, input.workspaceID))
-              if ("project" in input) conditions.push(eq(SessionTable.project_id, input.project))
-              if (input.search) conditions.push(like(SessionTable.title, `%${input.search}%`))
-              if (input.anchor) {
-                conditions.push(
-                  order === "asc"
-                    ? or(
-                        gt(sortColumn, input.anchor.time),
-                        and(eq(sortColumn, input.anchor.time), gt(SessionTable.id, input.anchor.id)),
-                      )!
-                    : or(
-                        lt(sortColumn, input.anchor.time),
-                        and(eq(sortColumn, input.anchor.time), lt(SessionTable.id, input.anchor.id)),
-                      )!,
-                )
-              }
-              const query = db
-                .select()
-                .from(SessionTable)
-                .where(conditions.length > 0 ? and(...conditions) : undefined)
-                .orderBy(
-                  order === "asc" ? asc(sortColumn) : desc(sortColumn),
-                  order === "asc" ? asc(SessionTable.id) : desc(SessionTable.id),
-                )
-              const rows = yield* (input.limit === undefined ? query.all() : query.limit(input.limit).all()).pipe(
-                Effect.orDie,
-              )
-              return (direction === "previous" ? rows.toReversed() : rows).map((row) => fromRow(row))
-            }),
-            messages: Effect.fn("V2Session.messages")(function* (input) {
-              yield* result.get(input.sessionID)
-              const direction = input.cursor?.direction ?? "next"
-              const requestedOrder = input.order ?? "desc"
-              const order = direction === "previous" ? (requestedOrder === "asc" ? "desc" : "asc") : requestedOrder
-              const anchor = input.cursor
-                ? yield* db
-                    .select({ seq: SessionMessageTable.seq })
-                    .from(SessionMessageTable)
-                    .where(
-                      and(
-                        eq(SessionMessageTable.session_id, input.sessionID),
-                        eq(SessionMessageTable.id, input.cursor.id),
-                      ),
-                    )
-                    .get()
-                    .pipe(Effect.orDie)
-                : undefined
-              if (input.cursor && !anchor) return []
-              const boundary = anchor
-                ? order === "asc"
-                  ? gt(SessionMessageTable.seq, anchor.seq)
-                  : lt(SessionMessageTable.seq, anchor.seq)
-                : undefined
-              const where = boundary
-                ? and(eq(SessionMessageTable.session_id, input.sessionID), boundary)
-                : eq(SessionMessageTable.session_id, input.sessionID)
-              const query = db
-                .select()
-                .from(SessionMessageTable)
-                .where(where)
-                .orderBy(order === "asc" ? asc(SessionMessageTable.seq) : desc(SessionMessageTable.seq))
-              const rows = yield* (input.limit === undefined ? query.all() : query.limit(input.limit).all()).pipe(
-                Effect.orDie,
-              )
-              return yield* Effect.forEach(direction === "previous" ? rows.toReversed() : rows, decode)
-            }),
-            message: Effect.fn("V2Session.message")(function* (input) {
-              const stored = yield* store.message(input.messageID)
-              return stored?.sessionID === input.sessionID ? stored.message : undefined
-            }),
-            context: Effect.fn("V2Session.context")(function* (sessionID) {
-              yield* result.get(sessionID)
-              return yield* store.context(sessionID)
-            }),
-            events: (input) =>
-              Stream.unwrap(
-                result
-                  .get(input.sessionID)
-                  .pipe(Effect.as(events.durable({ aggregateID: input.sessionID, after: input.after }))),
-              ).pipe(Stream.filter((event): event is SessionEvent.DurableEvent => isDurableSessionEvent(event))),
-            prompt: Effect.fn("V2Session.prompt")((input) =>
-              Effect.uninterruptible(
-                Effect.gen(function* () {
-                  yield* result.get(input.sessionID)
-                  const messageID = input.id ?? SessionMessage.ID.create()
-                  const delivery = input.delivery ?? "steer"
-                  const expected = { sessionID: input.sessionID, messageID, prompt: input.prompt, delivery }
-                  const admitted = yield* SessionInput.admit(db, events, {
-                    id: messageID,
-                    sessionID: input.sessionID,
-                    prompt: input.prompt,
-                    delivery,
-                  }).pipe(
-                    Effect.catchDefect((defect) =>
-                      defect instanceof SessionInput.LifecycleConflict
-                        ? new PromptConflictError({ sessionID: input.sessionID, messageID })
-                        : Effect.die(defect),
-                    ),
-                  )
-                  if (!SessionInput.equivalent(admitted, expected))
-                    return yield* new PromptConflictError({ sessionID: input.sessionID, messageID })
-                  if (input.resume !== false) yield* execution.wake(admitted.sessionID)
-                  return admitted
-                }),
-              ),
-            ),
-            shell: Effect.fn("V2Session.shell")(function* () {
-              return yield* new OperationUnavailableError({ operation: "shell" })
-            }),
-            skill: Effect.fn("V2Session.skill")(function* () {
-              return yield* new OperationUnavailableError({ operation: "skill" })
-            }),
-            switchAgent: Effect.fn("V2Session.switchAgent")(function* (input) {
-              yield* result.get(input.sessionID)
-              yield* events.publish(SessionEvent.AgentSwitched, {
-                sessionID: input.sessionID,
-                messageID: SessionMessage.ID.create(),
-                timestamp: yield* DateTime.now,
-                agent: input.agent,
-              })
-            }),
-            switchModel: Effect.fn("V2Session.switchModel")(function* (input) {
-              yield* result.get(input.sessionID)
-              yield* events.publish(SessionEvent.ModelSwitched, {
-                sessionID: input.sessionID,
-                messageID: SessionMessage.ID.create(),
-                timestamp: yield* DateTime.now,
-                model: input.model,
-              })
-            }),
-            compact: Effect.fn("V2Session.compact")(function* (input) {
-              yield* result.get(input.sessionID)
-              return yield* new OperationUnavailableError({ operation: "compact" })
-            }),
-            wait: Effect.fn("V2Session.wait")(function* (sessionID) {
-              yield* result.get(sessionID)
-              return yield* new OperationUnavailableError({ operation: "wait" })
-            }),
-            resume: Effect.fn("V2Session.resume")(function* (sessionID) {
-              yield* result.get(sessionID)
-              yield* execution.resume(sessionID)
-            }),
-            interrupt: Effect.fn("V2Session.interrupt")((sessionID) =>
-              Effect.uninterruptible(execution.interrupt(sessionID)),
-            ),
-            revert: {
-              stage: Effect.fn("V2Session.revert.stage")(function* (input) {
-                const session = yield* result.get(input.sessionID)
-                return yield* SessionRevert.stage({ session, messageID: input.messageID, files: input.files }).pipe(
-                  Effect.provideService(Database.Service, database),
-                  Effect.provideService(EventV2.Service, events),
-                  Effect.provide(locations.get(session.location)),
-                )
-              }),
-              clear: Effect.fn("V2Session.revert.clear")(function* (sessionID) {
-                const session = yield* result.get(sessionID)
-                yield* SessionRevert.clear(session).pipe(
-                  Effect.provideService(EventV2.Service, events),
-                  Effect.provide(locations.get(session.location)),
-                )
-              }),
-              commit: Effect.fn("V2Session.revert.commit")(function* (sessionID) {
-                const session = yield* result.get(sessionID)
-                yield* SessionRevert.commit(session).pipe(Effect.provideService(EventV2.Service, events))
-              }),
-            },
-          })
-
-          return result
-        }),
+            if (!SessionInput.equivalent(admitted, expected))
+              return yield* new PromptConflictError({ sessionID: input.sessionID, messageID })
+            if (input.resume !== false) yield* execution.wake(admitted.sessionID)
+            return admitted
+          }),
+        ),
      ),
-    ),
-  ),
+      shell: Effect.fn("V2Session.shell")(function* () {
+        return yield* new OperationUnavailableError({ operation: "shell" })
+      }),
+      skill: Effect.fn("V2Session.skill")(function* () {
+        return yield* new OperationUnavailableError({ operation: "skill" })
+      }),
+      switchAgent: Effect.fn("V2Session.switchAgent")(function* (input) {
+        yield* result.get(input.sessionID)
+        yield* events.publish(SessionEvent.AgentSwitched, {
+          sessionID: input.sessionID,
+          messageID: SessionMessage.ID.create(),
+          timestamp: yield* DateTime.now,
+          agent: input.agent,
+        })
+      }),
+      switchModel: Effect.fn("V2Session.switchModel")(function* (input) {
+        yield* result.get(input.sessionID)
+        yield* events.publish(SessionEvent.ModelSwitched, {
+          sessionID: input.sessionID,
+          messageID: SessionMessage.ID.create(),
+          timestamp: yield* DateTime.now,
+          model: input.model,
+        })
+      }),
+      compact: Effect.fn("V2Session.compact")(function* (input) {
+        yield* result.get(input.sessionID)
+        return yield* new OperationUnavailableError({ operation: "compact" })
+      }),
+      wait: Effect.fn("V2Session.wait")(function* (sessionID) {
+        yield* result.get(sessionID)
+        return yield* new OperationUnavailableError({ operation: "wait" })
+      }),
+      resume: Effect.fn("V2Session.resume")(function* (sessionID) {
+        yield* result.get(sessionID)
+        yield* execution.resume(sessionID)
+      }),
+      interrupt: Effect.fn("V2Session.interrupt")((sessionID) =>
+        Effect.uninterruptible(execution.interrupt(sessionID)),
+      ),
+      revert: {
+        stage: Effect.fn("V2Session.revert.stage")(function* (input) {
+          const session = yield* result.get(input.sessionID)
+          return yield* SessionRevert.stage({ session, messageID: input.messageID, files: input.files }).pipe(
+            Effect.provideService(Database.Service, database),
+            Effect.provideService(EventV2.Service, events),
+            Effect.provide(locations.get(session.location)),
+          )
+        }),
+        clear: Effect.fn("V2Session.revert.clear")(function* (sessionID) {
+          const session = yield* result.get(sessionID)
+          yield* SessionRevert.clear(session).pipe(
+            Effect.provideService(EventV2.Service, events),
+            Effect.provide(locations.get(session.location)),
+          )
+        }),
+        commit: Effect.fn("V2Session.revert.commit")(function* (sessionID) {
+          const session = yield* result.get(sessionID)
+          yield* SessionRevert.commit(session).pipe(Effect.provideService(EventV2.Service, events))
+        }),
+      },
+    })
+
+    return result
+  }),
 )

 export const defaultLayer = layer.pipe(
-  Layer.provide(
-    Layer.unwrap(Effect.promise(() => import("./location-layer")).pipe(Effect.map((m) => m.LocationServiceMap.layer))),
-  ),
  Layer.provide(SessionExecution.noopLayer),
  Layer.provide(SessionStore.defaultLayer),
  Layer.provide(SessionProjector.defaultLayer),
@ -451,3 +442,17 @@ export const defaultLayer = layer.pipe(
  Layer.provide(ProjectV2.defaultLayer),
  Layer.orDie,
 )
+
+export const node = makeGlobalNode({
+  service: Service,
+  layer: layer.pipe(Layer.orDie),
+  deps: [
+    Database.node,
+    EventV2.node,
+    ProjectV2.node,
+    SessionExecutionLocal.node,
+    SessionStore.node,
+    locationServiceMapNode,
+    SessionProjector.node,
+  ],
+})
--- a/packages/core/src/session/execution/local.ts
+++ b/packages/core/src/session/execution/local.ts
@ -1,5 +1,6 @@
 import { Cause, Effect, Layer } from "effect"
-import { LocationServiceMap } from "../../location-layer"
+import { LocationServiceMap, node as locationServiceMapNode } from "../../location-service-map"
+import { makeGlobalNode } from "../../effect/scoped-node"
 import { SessionRunCoordinator } from "../run-coordinator"
 import { SessionRunner } from "../runner"
 import { SessionSchema } from "../schema"
@ -36,3 +37,11 @@ export const layer = Layer.effect(
 )

 export const defaultLayer = layer.pipe(Layer.provide(SessionStore.defaultLayer))
+
+export const node = makeGlobalNode({
+  service: SessionExecution.Service,
+  layer,
+  deps: [SessionStore.node, locationServiceMapNode],
+})
+
+export * as SessionExecutionLocal from "./local"
--- a/packages/core/src/session/projector.ts
+++ b/packages/core/src/session/projector.ts
@ -4,7 +4,7 @@ import { and, desc, eq, gt, or, sql } from "drizzle-orm"
 import { DateTime, Effect, Layer, Schema } from "effect"
 import { Database } from "../database/database"
 import { EventV2 } from "../event"
-import { LayerNode } from "../effect/layer-node"
+import { makeGlobalNode } from "../effect/scoped-node"
 import { SessionEvent } from "./event"
 import { SessionV1 } from "../v1/session"
 import { WorkspaceTable } from "../control-plane/workspace.sql"
@ -456,4 +456,4 @@ export const layer = Layer.effectDiscard(
 )

 export const defaultLayer = layer.pipe(Layer.provide(EventV2.defaultLayer), Layer.provide(Database.defaultLayer))
-export const node = LayerNode.make({ name: "session-projector", layer, deps: [EventV2.node, Database.node] })
+export const node = makeGlobalNode({ name: "session-projector", layer, deps: [EventV2.node, Database.node] })
--- a/packages/core/src/session/runner/llm.ts
+++ b/packages/core/src/session/runner/llm.ts
@ -36,6 +36,8 @@ import { createLLMEventPublisher } from "./publish-llm-event"
 import { toLLMMessages } from "./to-llm-message"
 import { MAX_STEPS_PROMPT } from "./max-steps"
 import { Snapshot } from "../../snapshot"
+import { makeLocationNode } from "../../effect/scoped-node"
+import { llmClient } from "../../effect/layer-node-platform"

 /**
 * Runs one durable coding-agent Session until it settles.
@ -404,3 +406,23 @@ export const layer = Layer.effect(
 )

 export const defaultLayer = layer
+
+export const node = makeLocationNode({
+  service: Service,
+  layer,
+  deps: [
+    EventV2.node,
+    llmClient,
+    AgentV2.node,
+    ToolRegistry.node,
+    SessionRunnerModel.node,
+    SessionStore.node,
+    Location.node,
+    SystemContextRegistry.node,
+    SkillGuidance.node,
+    ReferenceGuidance.node,
+    Config.node,
+    Snapshot.node,
+    Database.node,
+  ],
+})
--- a/packages/core/src/session/runner/model.ts
+++ b/packages/core/src/session/runner/model.ts
@ -1,5 +1,6 @@
 export * as SessionRunnerModel from "./model"

+import { makeLocationNode } from "../../effect/scoped-node"
 import { type Model } from "@opencode-ai/llm"
 import * as AnthropicMessages from "@opencode-ai/llm/protocols/anthropic-messages"
 import * as OpenAICompatibleChat from "@opencode-ai/llm/protocols/openai-compatible-chat"
@ -213,3 +214,5 @@ export const locationLayer = Layer.effect(
    })
  }),
 )
+
+export const node = makeLocationNode({ service: Service, layer: locationLayer, deps: [Catalog.node, Integration.node] })
--- a/packages/core/src/session/store.ts
+++ b/packages/core/src/session/store.ts
@ -3,6 +3,7 @@ export * as SessionStore from "./store"
 import { eq } from "drizzle-orm"
 import { Context, Effect, Layer, Schema } from "effect"
 import { Database } from "../database/database"
+import { makeGlobalNode } from "../effect/scoped-node"
 import { SessionHistory } from "./history"
 import { MessageDecodeError } from "./error"
 import { SessionMessage } from "./message"
@ -60,3 +61,5 @@ export const layer = Layer.effect(
 )

 export const defaultLayer = layer.pipe(Layer.provide(Database.defaultLayer))
+
+export const node = makeGlobalNode({ service: Service, layer, deps: [Database.node] })
--- a/packages/core/src/session/todo.ts
+++ b/packages/core/src/session/todo.ts
@ -4,6 +4,7 @@ import { asc, eq } from "drizzle-orm"
 import { Context, Effect, Layer } from "effect"
 import { SessionTodo } from "@opencode-ai/schema/session-todo"
 import { Database } from "../database/database"
+import { makeLocationNode } from "../effect/scoped-node"
 import { EventV2 } from "../event"
 import { SessionSchema } from "./schema"
 import { TodoTable } from "./sql"
@ -75,3 +76,5 @@ export const layer = Layer.effect(
 )

 export const defaultLayer = layer.pipe(Layer.provide(EventV2.defaultLayer), Layer.provide(Database.defaultLayer))
+
+export const node = makeLocationNode({ service: Service, layer, deps: [EventV2.node, Database.node] })
--- a/packages/core/src/skill.ts
+++ b/packages/core/src/skill.ts
@ -1,5 +1,6 @@
 export * as SkillV2 from "./skill"

+import { makeLocationNode } from "./effect/scoped-node"
 import path from "path"
 import { Context, Effect, Layer, Schema, Types } from "effect"
 import { Skill } from "@opencode-ai/schema/skill"
@ -129,3 +130,5 @@ export const layer = Layer.effect(
 )

 export const locationLayer = layer.pipe(Layer.provide(SkillDiscovery.defaultLayer))
+
+export const node = makeLocationNode({ service: Service, layer, deps: [SkillDiscovery.node, FSUtil.node] })
--- a/packages/core/src/skill/discovery.ts
+++ b/packages/core/src/skill/discovery.ts
@ -5,6 +5,8 @@ import { Context, Effect, Layer, Schedule, Schema } from "effect"
 import { FetchHttpClient, HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http"
 import { FSUtil } from "../fs-util"
 import { Global } from "../global"
+import { makeGlobalNode } from "../effect/scoped-node"
+import { httpClient } from "../effect/layer-node-platform"
 import { AbsolutePath } from "../schema"

 const skillConcurrency = 4
@ -165,3 +167,5 @@ export const defaultLayer = layer.pipe(
  Layer.provide(FSUtil.defaultLayer),
  Layer.provide(Global.defaultLayer),
 )
+
+export const node = makeGlobalNode({ service: Service, layer, deps: [httpClient, FSUtil.node, Global.node] })
--- a/packages/core/src/skill/guidance.ts
+++ b/packages/core/src/skill/guidance.ts
@ -1,5 +1,6 @@
 export * as SkillGuidance from "./guidance"

+import { makeLocationNode } from "../effect/scoped-node"
 import { Context, Effect, Layer, Schema } from "effect"
 import { AgentV2 } from "../agent"
 import { PermissionV2 } from "../permission"
@ -71,3 +72,5 @@ export const layer = Layer.effect(
 )

 export const locationLayer = layer
+
+export const node = makeLocationNode({ service: Service, layer, deps: [SkillV2.node] })
--- a/packages/core/src/snapshot.ts
+++ b/packages/core/src/snapshot.ts
@ -1,5 +1,6 @@
 export * as Snapshot from "./snapshot"

+import { makeLocationNode } from "./effect/scoped-node"
 import path from "path"
 import { Context, Effect, Layer, Schema } from "effect"
 import { Config } from "./config"
@ -228,6 +229,12 @@ export const layer = Layer.effect(

 export const locationLayer = layer.pipe(Layer.provideMerge(Config.locationLayer))

+export const node = makeLocationNode({
+  service: Service,
+  layer,
+  deps: [Config.node, FSUtil.node, Git.node, Global.node, Location.node],
+})
+
 export const noopLayer = Layer.succeed(
  Service,
  Service.of({
--- a/packages/core/src/system-context/builtins.ts
+++ b/packages/core/src/system-context/builtins.ts
@ -1,10 +1,13 @@
 export * as SystemContextBuiltIns from "./builtins"

+import { makeLocationNode } from "../effect/scoped-node"
 import { DateTime, Effect, Layer, Schema } from "effect"
 import { Location } from "../location"
 import { SystemContext } from "./index"
 import { InstructionContext } from "../instruction-context"
 import { SystemContextRegistry } from "./registry"
+import { FSUtil } from "../fs-util"
+import { Global } from "../global"

 const builtIns = Layer.effectDiscard(
  Effect.gen(function* () {
@ -45,3 +48,9 @@ export const layer = Layer.mergeAll(builtIns, InstructionContext.layer).pipe(
 )

 export const locationLayer = layer
+
+export const node = makeLocationNode({
+  name: "system-context-builtins",
+  layer,
+  deps: [Location.node, SystemContextRegistry.node, InstructionContext.node, FSUtil.node, Global.node],
+})
--- a/packages/core/src/system-context/registry.ts
+++ b/packages/core/src/system-context/registry.ts
@ -2,6 +2,7 @@ export * as SystemContextRegistry from "./registry"

 import { Context, Effect, Layer, Ref, Scope } from "effect"
 import { SystemContext } from "./index"
+import { makeLocationNode } from "../effect/scoped-node"

 export interface Entry {
  readonly key: SystemContext.Key
@ -44,3 +45,5 @@ export const layer = Layer.effect(
    })
  }),
 )
+
+export const node = makeLocationNode({ service: Service, layer, deps: [] })
--- a/packages/core/src/tool-output-store.ts
+++ b/packages/core/src/tool-output-store.ts
@ -5,6 +5,7 @@ import { Context, Duration, Effect, Layer, Option, Schedule, Schema } from "effe
 import { Config } from "./config"
 import { FSUtil } from "./fs-util"
 import { Global } from "./global"
+import { makeGlobalNode, makeLocationNode } from "./effect/scoped-node"
 import { SessionSchema } from "./session/schema"
 import { Identifier } from "./util/identifier"
 import type { ToolOutput } from "@opencode-ai/llm"
@ -193,6 +194,8 @@ export const layer = Layer.effect(

 export const defaultLayer = layer.pipe(Layer.provide(FSUtil.defaultLayer), Layer.provide(Global.defaultLayer))

+export const node = makeLocationNode({ service: Service, layer, deps: [FSUtil.node, Global.node, Config.node] })
+
 /** Runs retention scanning once globally rather than once per active Location. */
 export const cleanupLayer = Layer.effectDiscard(
  Effect.gen(function* () {
@ -202,3 +205,5 @@ export const cleanupLayer = Layer.effectDiscard(
 )

 export const defaultCleanupLayer = Layer.merge(defaultLayer, cleanupLayer.pipe(Layer.provide(defaultLayer)))
+
+export const cleanupNode = makeGlobalNode({ name: "tool-output-cleanup", layer: defaultCleanupLayer, deps: [] })
--- a/packages/core/src/tool/application-tools.ts
+++ b/packages/core/src/tool/application-tools.ts
@ -3,6 +3,7 @@ export * as ApplicationTools from "./application-tools"
 import { Context, Effect, Layer, Scope } from "effect"
 import { State } from "../state"
 import { Tool } from "./tool"
+import { makeGlobalNode } from "../effect/scoped-node"

 type Data = {
  readonly entries: Map<string, Entry>
@ -52,3 +53,5 @@ export const layer = Layer.effect(
    })
  }),
 )
+
+export const node = makeGlobalNode({ service: Service, layer, deps: [] })
--- a/packages/core/src/tool/builtins.ts
+++ b/packages/core/src/tool/builtins.ts
@ -1,5 +1,6 @@
 export * as BuiltInTools from "./builtins"

+import { makeLocationNode } from "../effect/scoped-node"
 import { Layer } from "effect"
 import { BashTool } from "./bash"
 import { ApplyPatchTool } from "./apply-patch"
@ -14,6 +15,20 @@ import { TodoWriteTool } from "./todowrite"
 import { WebFetchTool } from "./webfetch"
 import { WebSearchTool } from "./websearch"
 import { WriteTool } from "./write"
+import { FSUtil } from "../fs-util"
+import { AppProcess } from "../process"
+import { Config } from "../config"
+import { Location } from "../location"
+import { LocationMutation } from "../location-mutation"
+import { FileMutation } from "../file-mutation"
+import { PermissionV2 } from "../permission"
+import { Ripgrep } from "../ripgrep"
+import { Image } from "../image"
+import { QuestionV2 } from "../question"
+import { SkillV2 } from "../skill"
+import { SessionTodo } from "../session/todo"
+import { ToolRegistry } from "./registry"
+import { httpClient } from "../effect/layer-node-platform"

 /**
 * Composes only the shipped Location-scoped built-in tool transforms.
@ -42,3 +57,25 @@ export const locationLayer = Layer.mergeAll(
  WebSearchTool.layer.pipe(Layer.provide(WebSearchTool.defaultConfigLayer)),
  WriteTool.layer,
 )
+
+export const node = makeLocationNode({
+  name: "built-in-tools",
+  layer: locationLayer,
+  deps: [
+    ToolRegistry.toolsNode,
+    FSUtil.node,
+    AppProcess.node,
+    Config.node,
+    Location.node,
+    LocationMutation.node,
+    FileMutation.node,
+    PermissionV2.node,
+    Ripgrep.node,
+    Image.node,
+    QuestionV2.node,
+    SkillV2.node,
+    SessionTodo.node,
+    ReadToolFileSystem.node,
+    httpClient,
+  ],
+})
--- a/packages/core/src/tool/read-filesystem.ts
+++ b/packages/core/src/tool/read-filesystem.ts
@ -5,6 +5,7 @@ import { pathToFileURL } from "url"
 import { Context, Effect, Layer, Option, Schema } from "effect"
 import { FileSystem } from "../filesystem"
 import { FSUtil } from "../fs-util"
+import { makeLocationNode } from "../effect/scoped-node"
 import { AbsolutePath, PositiveInt, RelativePath } from "../schema"

 export const MAX_READ_LINES = 2_000
@ -361,3 +362,5 @@ export const layer = Layer.effect(
    })
  }),
 )
+
+export const node = makeLocationNode({ service: Service, layer, deps: [FSUtil.node] })
--- a/packages/core/src/tool/registry.ts
+++ b/packages/core/src/tool/registry.ts
@ -11,6 +11,7 @@ import { Wildcard } from "../util/wildcard"
 import { ApplicationTools } from "./application-tools"
 import { definition, permission, settle, validateName, type AnyTool, type RegistrationError } from "./tool"
 import { Tools } from "./tools"
+import { makeLocationNode } from "../effect/scoped-node"

 export type ExecuteInput = {
  readonly sessionID: SessionSchema.ID
@ -137,3 +138,15 @@ export const defaultLayer = layer.pipe(
  Layer.provide(ApplicationTools.layer),
  Layer.provide(ToolOutputStore.defaultLayer),
 )
+
+export const node = makeLocationNode({
+  service: Service,
+  layer,
+  deps: [ApplicationTools.node, ToolOutputStore.node],
+})
+
+export const toolsNode = makeLocationNode({
+  service: Tools.Service,
+  layer,
+  deps: [ApplicationTools.node, ToolOutputStore.node],
+})
--- a/packages/core/src/util/effect-flock.ts
+++ b/packages/core/src/util/effect-flock.ts
@ -6,7 +6,7 @@ import type { FileSystem, Scope } from "effect"
 import type { PlatformError } from "effect/PlatformError"
 import { FSUtil } from "../fs-util"
 import { Global } from "../global"
-import { LayerNode } from "../effect/layer-node"
+import { makeGlobalNode } from "../effect/scoped-node"
 import { Hash } from "./hash"

 export namespace EffectFlock {
@ -281,5 +281,5 @@ export namespace EffectFlock {
  )

  export const defaultLayer = layer.pipe(Layer.provide(FSUtil.defaultLayer), Layer.provide(Global.layer))
-  export const node = LayerNode.make({ service: Service, layer: layer, deps: [Global.node, FSUtil.node] })
+  export const node = makeGlobalNode({ service: Service, layer: layer, deps: [Global.node, FSUtil.node] })
 }
--- a/packages/core/test/location-layer.test.ts
+++ b/packages/core/test/location-layer.test.ts
@ -6,7 +6,7 @@ import { Tool } from "@opencode-ai/core/tool/tool"
 import { define } from "@opencode-ai/plugin/v2/effect"
 import { AgentV2 } from "@opencode-ai/core/agent"
 import { Catalog } from "@opencode-ai/core/catalog"
-import { LocationServiceMap } from "@opencode-ai/core/location-layer"
+import { LocationServiceMap, locationServiceMapLayer } from "@opencode-ai/core/location-layer"
 import { Location } from "@opencode-ai/core/location"
 import { PluginV2 } from "@opencode-ai/core/plugin"
 import { ModelV2 } from "@opencode-ai/core/model"
@ -34,7 +34,7 @@ const applicationTools = ApplicationTools.layer
 const it = testEffect(
  Layer.merge(
    Layer.mergeAll(applicationTools, Database.defaultLayer, EventV2.defaultLayer),
-    LocationServiceMap.layer.pipe(
+    locationServiceMapLayer.pipe(
      Layer.provide(applicationTools),
      Layer.provide(
        Layer.mergeAll(
--- a/packages/core/test/move-session.test.ts
+++ b/packages/core/test/move-session.test.ts
@ -14,7 +14,7 @@ import { ProjectTable } from "@opencode-ai/core/project/sql"
 import { ProjectDirectories } from "@opencode-ai/core/project/directories"
 import { AbsolutePath } from "@opencode-ai/core/schema"
 import { SessionV2 } from "@opencode-ai/core/session"
-import { LocationServiceMap } from "@opencode-ai/core/location-layer"
+import { locationServiceMapLayer } from "@opencode-ai/core/location-layer"
 import { SessionExecution } from "@opencode-ai/core/session/execution"
 import { SessionProjector } from "@opencode-ai/core/session/projector"
 import { SessionTable } from "@opencode-ai/core/session/sql"
@ -29,7 +29,7 @@ const project = Project.layer.pipe(
  Layer.provide(ProjectDirectories.defaultLayer),
 )
 const sessions = SessionV2.layer.pipe(
-  Layer.provide(LocationServiceMap.layer),
+  Layer.provide(locationServiceMapLayer),
  Layer.provide(Database.defaultLayer),
  Layer.provide(EventV2.defaultLayer),
  Layer.provide(project),
--- a/packages/core/test/permission.test.ts
+++ b/packages/core/test/permission.test.ts
@ -11,7 +11,7 @@ import { Project } from "@opencode-ai/core/project"
 import { ProjectTable } from "@opencode-ai/core/project/sql"
 import { AbsolutePath } from "@opencode-ai/core/schema"
 import { SessionV2 } from "@opencode-ai/core/session"
-import { LocationServiceMap } from "@opencode-ai/core/location-layer"
+import { locationServiceMapLayer } from "@opencode-ai/core/location-layer"
 import { SessionTable } from "@opencode-ai/core/session/sql"
 import { SessionExecution } from "@opencode-ai/core/session/execution"
 import { SessionStore } from "@opencode-ai/core/session/store"
@ -24,7 +24,7 @@ const current = Layer.succeed(
  Location.Service.of(location({ directory: AbsolutePath.make("/project") })),
 )
 const sessions = SessionV2.layer.pipe(
-  Layer.provide(LocationServiceMap.layer),
+  Layer.provide(locationServiceMapLayer),
  Layer.provide(EventV2.defaultLayer),
  Layer.provide(Database.defaultLayer),
  Layer.provide(SessionStore.defaultLayer),
--- a/packages/core/test/session-create.test.ts
+++ b/packages/core/test/session-create.test.ts
@ -13,7 +13,7 @@ import { ProjectTable } from "@opencode-ai/core/project/sql"
 import { ProviderV2 } from "@opencode-ai/core/provider"
 import { AbsolutePath } from "@opencode-ai/core/schema"
 import { SessionV2 } from "@opencode-ai/core/session"
-import { LocationServiceMap } from "@opencode-ai/core/location-layer"
+import { locationServiceMapLayer } from "@opencode-ai/core/location-layer"
 import { SessionV1 } from "@opencode-ai/core/v1/session"
 import { Prompt } from "@opencode-ai/core/session/prompt"
 import { SessionProjector } from "@opencode-ai/core/session/projector"
@ -35,7 +35,7 @@ const projects = Layer.succeed(
  }),
 )
 const sessions = SessionV2.layer.pipe(
-  Layer.provide(LocationServiceMap.layer),
+  Layer.provide(locationServiceMapLayer),
  Layer.provide(EventV2.defaultLayer),
  Layer.provide(Database.defaultLayer),
  Layer.provide(SessionStore.defaultLayer),
--- a/packages/core/test/session-projector.test.ts
+++ b/packages/core/test/session-projector.test.ts
@ -10,7 +10,7 @@ import { ProjectTable } from "@opencode-ai/core/project/sql"
 import { ProviderV2 } from "@opencode-ai/core/provider"
 import { AbsolutePath } from "@opencode-ai/core/schema"
 import { SessionV2 } from "@opencode-ai/core/session"
-import { LocationServiceMap } from "@opencode-ai/core/location-layer"
+import { locationServiceMapLayer } from "@opencode-ai/core/location-layer"
 import { SessionEvent } from "@opencode-ai/core/session/event"
 import { SessionMessage } from "@opencode-ai/core/session/message"
 import { Prompt } from "@opencode-ai/core/session/prompt"
@ -164,7 +164,7 @@ describe("SessionProjector", () => {
    }).pipe(
      Effect.provide(
        SessionV2.layer.pipe(
-          Layer.provide(LocationServiceMap.layer),
+          Layer.provide(locationServiceMapLayer),
          Layer.provide(EventV2.defaultLayer),
          Layer.provide(Database.defaultLayer),
          Layer.provide(Project.defaultLayer),
--- a/packages/core/test/session-prompt.test.ts
+++ b/packages/core/test/session-prompt.test.ts
@ -9,7 +9,7 @@ import { Project } from "@opencode-ai/core/project"
 import { ProjectTable } from "@opencode-ai/core/project/sql"
 import { AbsolutePath } from "@opencode-ai/core/schema"
 import { SessionV2 } from "@opencode-ai/core/session"
-import { LocationServiceMap } from "@opencode-ai/core/location-layer"
+import { locationServiceMapLayer } from "@opencode-ai/core/location-layer"
 import { Prompt } from "@opencode-ai/core/session/prompt"
 import { SessionMessage } from "@opencode-ai/core/session/message"
 import { SessionProjector } from "@opencode-ai/core/session/projector"
@ -40,7 +40,7 @@ const execution = Layer.succeed(
  }),
 )
 const sessions = SessionV2.layer.pipe(
-  Layer.provide(LocationServiceMap.layer),
+  Layer.provide(locationServiceMapLayer),
  Layer.provide(EventV2.defaultLayer),
  Layer.provide(Database.defaultLayer),
  Layer.provide(SessionStore.defaultLayer),
--- a/packages/core/test/session-runner-recorded.test.ts
+++ b/packages/core/test/session-runner-recorded.test.ts
@ -12,7 +12,7 @@ import { Project } from "@opencode-ai/core/project"
 import { ProjectTable } from "@opencode-ai/core/project/sql"
 import { AbsolutePath } from "@opencode-ai/core/schema"
 import { SessionV2 } from "@opencode-ai/core/session"
-import { LocationServiceMap } from "@opencode-ai/core/location-layer"
+import { locationServiceMapLayer } from "@opencode-ai/core/location-layer"
 import { Snapshot } from "@opencode-ai/core/snapshot"
 import { Prompt } from "@opencode-ai/core/session/prompt"
 import { SessionProjector } from "@opencode-ai/core/session/projector"
@ -102,7 +102,7 @@ const execution = Layer.effect(
  }),
 ).pipe(Layer.provide(runner))
 const sessions = SessionV2.layer.pipe(
-  Layer.provide(LocationServiceMap.layer),
+  Layer.provide(locationServiceMapLayer),
  Layer.provide(EventV2.defaultLayer),
  Layer.provide(Database.defaultLayer),
  Layer.provide(SessionStore.defaultLayer),
--- a/packages/core/test/session-runner.test.ts
+++ b/packages/core/test/session-runner.test.ts
@ -19,7 +19,7 @@ import { ProjectTable } from "@opencode-ai/core/project/sql"
 import { QuestionV2 } from "@opencode-ai/core/question"
 import { AbsolutePath } from "@opencode-ai/core/schema"
 import { SessionV2 } from "@opencode-ai/core/session"
-import { LocationServiceMap } from "@opencode-ai/core/location-layer"
+import { locationServiceMapLayer } from "@opencode-ai/core/location-layer"
 import { Snapshot } from "@opencode-ai/core/snapshot"
 import { ContextSnapshotDecodeError } from "@opencode-ai/core/session/error"
 import { SessionEvent } from "@opencode-ai/core/session/event"
@ -261,7 +261,7 @@ const execution = Layer.effect(
  }),
 ).pipe(Layer.provide(runner))
 const sessions = SessionV2.layer.pipe(
-  Layer.provide(LocationServiceMap.layer),
+  Layer.provide(locationServiceMapLayer),
  Layer.provide(EventV2.defaultLayer),
  Layer.provide(Database.defaultLayer),
  Layer.provide(SessionStore.defaultLayer),