fix(desktop): handle moved projects and deleted paths

bun.lock

@@ -317,7 +317,6 @@
         "ai-gateway-provider": "3.1.2",
         "bun-pty": "0.4.8",
         "cross-spawn": "catalog:",
-        "diff": "catalog:",
         "drizzle-orm": "catalog:",
         "effect": "catalog:",
         "fuzzysort": "3.1.0",

nix/hashes.json

@@ -1,8 +1,8 @@
 {
   "nodeModules": {
-    "x86_64-linux": "sha256-A3dgTsHBfIn+trqbserr1CAERfKeJjTiUxZxzkz4tPU=",
-    "aarch64-linux": "sha256-G72CWFF7gTNHxmq5TFMRFiffqp9Voqcoe1oz8Kk47vU=",
-    "aarch64-darwin": "sha256-7/lxVQWuebPDFo+cuel/S1IpwLuTxFYIUYBsNimqcI4=",
-    "x86_64-darwin": "sha256-GTRYa17f0SpwrWh+M3Q2MTIUzzGINknKMmRzYUgqMus="
+    "x86_64-linux": "sha256-rB/CcrBUQVZ08nBFSYA8u2w88rQmTpKxKPkIreDEKgI=",
+    "aarch64-linux": "sha256-ZRTphtic8Ip96MnILteFgZAUxjK9O4YfJu2O6u/0H8k=",
+    "aarch64-darwin": "sha256-VK5XIzraP0HtqnPwPCejiDKer4ewtNtX1vxP5uuyjSk=",
+    "x86_64-darwin": "sha256-ZLPHqcCZB1EmxQk95cmUpiODTTKOyi7PSF0yr/rDk6Y="
   }
 }

packages/app/src/components/debug-bar.tsx

@@ -3,7 +3,6 @@ import { batch, createEffect, onCleanup, onMount } from "solid-js"
 import { createStore } from "solid-js/store"
 import { makeEventListener } from "@solid-primitives/event-listener"
 import { Tooltip } from "@opencode-ai/ui/tooltip"
-import { TooltipV2 } from "@opencode-ai/ui/v2/tooltip-v2"
 import { useLanguage } from "@/context/language"
 
 type Mem = Performance & {
@@ -52,62 +51,31 @@ const bad = (n: number | undefined, limit: number, low = false) => {
 
 const session = (path: string) => path.includes("/session")
 
-function Cell(props: {
-  bad?: boolean
-  dim?: boolean
-  inline?: boolean
-  label: string
-  tip: string
-  value: string
-  wide?: boolean
-}) {
-  const content = () => (
-    <div
-      classList={{
-        "flex min-w-0 items-center": true,
-        "min-h-[20px] w-fit flex-row justify-start gap-1.5 px-1.5 py-0.5 text-left": !!props.inline,
-        "justify-center text-center": !props.inline,
-        "min-h-[42px] w-full flex-col rounded-[8px] px-0.5 py-1": !props.inline,
-        "col-span-2": !!props.wide && !props.inline,
-      }}
-    >
-      <div
-        classList={{
-          "text-[10px] leading-none font-black uppercase tracking-[0.04em] opacity-70": true,
-        }}
-      >
-        {props.label}
-      </div>
-      <div
-        classList={{
-          "uppercase leading-none font-bold tabular-nums": true,
-          "text-[11px]": !!props.inline,
-          "text-[13px] sm:text-[14px]": !props.inline,
-          "text-text-on-critical-base": !!props.bad,
-          "opacity-70": !!props.dim,
-        }}
-      >
-        {props.value}
-      </div>
-    </div>
-  )
-
-  if (props.inline) {
-    return (
-      <TooltipV2 value={props.tip} placement="top">
-        {content()}
-      </TooltipV2>
-    )
-  }
-
+function Cell(props: { bad?: boolean; dim?: boolean; label: string; tip: string; value: string; wide?: boolean }) {
   return (
     <Tooltip value={props.tip} placement="top">
-      {content()}
+      <div
+        classList={{
+          "flex min-h-[42px] w-full min-w-0 flex-col items-center justify-center rounded-[8px] px-0.5 py-1 text-center": true,
+          "col-span-2": !!props.wide,
+        }}
+      >
+        <div class="text-[10px] leading-none font-black uppercase tracking-[0.04em] opacity-70">{props.label}</div>
+        <div
+          classList={{
+            "text-[13px] leading-none font-bold tabular-nums sm:text-[14px]": true,
+            "text-text-on-critical-base": !!props.bad,
+            "opacity-70": !!props.dim,
+          }}
+        >
+          {props.value}
+        </div>
+      </div>
     </Tooltip>
   )
 }
 
-export function DebugBar(props: { inline?: boolean } = {}) {
+export function DebugBar() {
   const language = useLanguage()
   const location = useLocation()
   const routing = useIsRouting()
@@ -133,7 +101,7 @@ export function DebugBar(props: { inline?: boolean } = {}) {
     },
   })
 
-  const na = () => language.t("debugBar.na").toUpperCase()
+  const na = () => language.t("debugBar.na")
   const heap = () => (state.heap.limit ? (state.heap.used ?? 0) / state.heap.limit : undefined)
   const heapv = () => {
     const value = heap()
@@ -395,30 +363,15 @@ export function DebugBar(props: { inline?: boolean } = {}) {
   return (
     <aside
       aria-label={language.t("debugBar.ariaLabel")}
-      classList={{
-        "pointer-events-auto hidden overflow-hidden text-text-strong md:block": true,
-        "mt-[-6px] w-full shrink-0 px-3 py-1": !!props.inline,
-        "fixed bottom-3 right-3 z-50 w-[308px] max-w-[calc(100vw-1.5rem)] rounded-xl border border-border-base bg-surface-raised-stronger-non-alpha p-0.5 shadow-[var(--shadow-lg-border-base)] sm:bottom-4 sm:right-4 sm:w-[324px]":
-          !props.inline,
-      }}
+      class="pointer-events-auto fixed bottom-3 right-3 z-50 hidden w-[308px] max-w-[calc(100vw-1.5rem)] overflow-hidden rounded-xl border border-border-base bg-surface-raised-stronger-non-alpha p-0.5 text-text-strong shadow-[var(--shadow-lg-border-base)] md:block sm:bottom-4 sm:right-4 sm:w-[324px]"
     >
-      <div
-        classList={{
-          "font-mono": true,
-          "gap-[9px]": !!props.inline,
-          "gap-px": !props.inline,
-          "flex w-full flex-nowrap items-center justify-start": !!props.inline,
-          "grid-cols-5": !props.inline,
-          grid: !props.inline,
-        }}
-      >
+      <div class="grid grid-cols-5 gap-px font-mono">
         <Cell
           label={language.t("debugBar.nav.label")}
           tip={language.t("debugBar.nav.tip")}
           value={navv()}
           bad={bad(state.nav.dur, 400)}
           dim={state.nav.dur === undefined && !state.nav.pending}
-          inline={props.inline}
         />
         <Cell
           label={language.t("debugBar.fps.label")}
@@ -426,7 +379,6 @@ export function DebugBar(props: { inline?: boolean } = {}) {
           value={state.fps === undefined ? na() : `${Math.round(state.fps)}`}
           bad={bad(state.fps, 50, true)}
           dim={state.fps === undefined}
-          inline={props.inline}
         />
         <Cell
           label={language.t("debugBar.frame.label")}
@@ -434,7 +386,6 @@ export function DebugBar(props: { inline?: boolean } = {}) {
           value={time(state.gap) ?? na()}
           bad={bad(state.gap, 50)}
           dim={state.gap === undefined}
-          inline={props.inline}
         />
         <Cell
           label={language.t("debugBar.jank.label")}
@@ -442,7 +393,6 @@ export function DebugBar(props: { inline?: boolean } = {}) {
           value={state.jank === undefined ? na() : `${state.jank}`}
           bad={bad(state.jank, 8)}
           dim={state.jank === undefined}
-          inline={props.inline}
         />
         <Cell
           label={language.t("debugBar.long.label")}
@@ -450,7 +400,6 @@ export function DebugBar(props: { inline?: boolean } = {}) {
           value={longv()}
           bad={bad(state.long.block, 200)}
           dim={state.long.count === undefined}
-          inline={props.inline}
         />
         <Cell
           label={language.t("debugBar.delay.label")}
@@ -458,7 +407,6 @@ export function DebugBar(props: { inline?: boolean } = {}) {
           value={time(state.delay) ?? na()}
           bad={bad(state.delay, 100)}
           dim={state.delay === undefined}
-          inline={props.inline}
         />
         <Cell
           label={language.t("debugBar.inp.label")}
@@ -466,7 +414,6 @@ export function DebugBar(props: { inline?: boolean } = {}) {
           value={time(state.inp) ?? na()}
           bad={bad(state.inp, 200)}
           dim={state.inp === undefined}
-          inline={props.inline}
         />
         <Cell
           label={language.t("debugBar.cls.label")}
@@ -474,7 +421,6 @@ export function DebugBar(props: { inline?: boolean } = {}) {
           value={state.cls === undefined ? na() : state.cls.toFixed(2)}
           bad={bad(state.cls, 0.1)}
           dim={state.cls === undefined}
-          inline={props.inline}
         />
         <Cell
           label={language.t("debugBar.mem.label")}
@@ -489,7 +435,6 @@ export function DebugBar(props: { inline?: boolean } = {}) {
           value={heapv()}
           bad={bad(heap(), 0.8)}
           dim={state.heap.used === undefined}
-          inline={props.inline}
           wide
         />
       </div>

packages/app/src/components/dialog-connect-provider.tsx

@@ -65,7 +65,6 @@ export function DialogConnectProvider(props: { provider: string; directory?: Acc
   const [store, setStore] = createStore({
     methodIndex: undefined as undefined | number,
     authorization: undefined as undefined | ProviderAuthAuthorization,
-    promptInputs: undefined as undefined | Record<string, string>,
     state: "pending" as undefined | "pending" | "complete" | "error" | "prompt",
     error: undefined as string | undefined,
   })
@@ -74,7 +73,6 @@ export function DialogConnectProvider(props: { provider: string; directory?: Acc
     | { type: "method.select"; index: number }
     | { type: "method.reset" }
     | { type: "auth.prompt" }
-    | { type: "auth.inputs"; inputs: Record<string, string> }
     | { type: "auth.pending" }
     | { type: "auth.complete"; authorization: ProviderAuthAuthorization }
     | { type: "auth.error"; error: string }
@@ -85,7 +83,6 @@ export function DialogConnectProvider(props: { provider: string; directory?: Acc
         if (action.type === "method.select") {
           draft.methodIndex = action.index
           draft.authorization = undefined
-          draft.promptInputs = undefined
           draft.state = undefined
           draft.error = undefined
           return
@@ -93,7 +90,6 @@ export function DialogConnectProvider(props: { provider: string; directory?: Acc
         if (action.type === "method.reset") {
           draft.methodIndex = undefined
           draft.authorization = undefined
-          draft.promptInputs = undefined
           draft.state = undefined
           draft.error = undefined
           return
@@ -103,12 +99,6 @@ export function DialogConnectProvider(props: { provider: string; directory?: Acc
           draft.error = undefined
           return
         }
-        if (action.type === "auth.inputs") {
-          draft.promptInputs = action.inputs
-          draft.state = undefined
-          draft.error = undefined
-          return
-        }
         if (action.type === "auth.pending") {
           draft.state = "pending"
           draft.error = undefined
@@ -161,15 +151,6 @@ export function DialogConnectProvider(props: { provider: string; directory?: Acc
     const method = methods()[index]
     dispatch({ type: "method.select", index })
 
-    if (method.type === "api" && method.prompts?.length) {
-      if (!inputs) {
-        dispatch({ type: "auth.prompt" })
-        return
-      }
-      dispatch({ type: "auth.inputs", inputs })
-      return
-    }
-
     if (method.type === "oauth") {
       if (method.prompts?.length && !inputs) {
         dispatch({ type: "auth.prompt" })
@@ -209,7 +190,7 @@ export function DialogConnectProvider(props: { provider: string; directory?: Acc
     }
   }
 
-  function AuthPromptsView() {
+  function OAuthPromptsView() {
     const [formStore, setFormStore] = createStore({
       value: {} as Record<string, string>,
       index: 0,
@@ -217,7 +198,8 @@ export function DialogConnectProvider(props: { provider: string; directory?: Acc
 
     const prompts = createMemo<NonNullable<ProviderAuthMethod["prompts"]>>(() => {
       const value = method()
-      return value?.prompts ?? []
+      if (value?.type !== "oauth") return []
+      return value.prompts ?? []
     })
     const matches = (prompt: NonNullable<ReturnType<typeof prompts>[number]>, value: Record<string, string>) => {
       if (!prompt.when) return true
@@ -248,10 +230,6 @@ export function DialogConnectProvider(props: { provider: string; directory?: Acc
         setFormStore("index", next)
         return
       }
-      if (method()?.type === "api") {
-        dispatch({ type: "auth.inputs", inputs: value })
-        return
-      }
       await selectMethod(store.methodIndex, value)
     }
 
@@ -436,7 +414,6 @@ export function DialogConnectProvider(props: { provider: string; directory?: Acc
         auth: {
           type: "api",
           key: apiKey,
-          ...(store.promptInputs ? { metadata: store.promptInputs } : {}),
         },
       })
       await complete()
@@ -645,7 +622,7 @@ export function DialogConnectProvider(props: { provider: string; directory?: Acc
                 </div>
               </Match>
               <Match when={store.state === "prompt"}>
-                <AuthPromptsView />
+                <OAuthPromptsView />
               </Match>
               <Match when={store.state === "error"}>
                 <div class="text-14-regular text-text-base">

packages/app/src/components/file-tree.test.ts

@@ -40,6 +40,7 @@ beforeAll(async () => {
 describe("file tree fetch discipline", () => {
   test("root lists on mount unless already loaded or loading", () => {
     expect(shouldListRoot({ level: 0 })).toBe(true)
+    expect(shouldListRoot({ level: 0, filtered: true })).toBe(false)
     expect(shouldListRoot({ level: 0, dir: { loaded: true } })).toBe(false)
     expect(shouldListRoot({ level: 0, dir: { loading: true } })).toBe(false)
     expect(shouldListRoot({ level: 1 })).toBe(false)

packages/app/src/components/file-tree.tsx

@@ -32,7 +32,12 @@ type Filter = {
   dirs: Set<string>
 }
 
-export function shouldListRoot(input: { level: number; dir?: { loaded?: boolean; loading?: boolean } }) {
+export function shouldListRoot(input: {
+  level: number
+  filtered?: boolean
+  dir?: { loaded?: boolean; loading?: boolean }
+}) {
+  if (input.filtered) return false
   if (input.level !== 0) return false
   if (input.dir?.loaded) return false
   if (input.dir?.loading) return false
@@ -309,7 +314,7 @@ export default function FileTree(props: {
       filter: current,
       expanded: (dir) => untrack(() => file.tree.state(dir)?.expanded) ?? false,
     })
-    for (const dir of dirs) file.tree.expand(dir)
+    for (const dir of dirs) file.tree.expand(dir, { load: false })
   })
 
   createEffect(
@@ -317,7 +322,7 @@ export default function FileTree(props: {
       () => props.path,
       (path) => {
         const dir = untrack(() => file.tree.state(path))
-        if (!shouldListRoot({ level, dir })) return
+        if (!shouldListRoot({ level, filtered: !!filter(), dir })) return
         void file.tree.list(path)
       },
       { defer: false },
@@ -401,7 +406,9 @@ export default function FileTree(props: {
                   data-scope="filetree"
                   forceMount={false}
                   open={expanded()}
-                  onOpenChange={(open) => (open ? file.tree.expand(node.path) : file.tree.collapse(node.path))}
+                  onOpenChange={(open) =>
+                    open ? file.tree.expand(node.path, { load: !filter() }) : file.tree.collapse(node.path)
+                  }
                 >
                   <Collapsible.Trigger>
                     <FileTreeNode

packages/app/src/components/prompt-input.tsx

@@ -35,8 +35,6 @@ import { DockShellForm, DockTray } from "@opencode-ai/ui/dock-surface"
 import { Icon } from "@opencode-ai/ui/icon"
 import { ProviderIcon } from "@opencode-ai/ui/provider-icon"
 import { Tooltip, TooltipKeybind } from "@opencode-ai/ui/tooltip"
-import { KeybindV2 } from "@opencode-ai/ui/v2/keybind-v2"
-import { TooltipV2 } from "@opencode-ai/ui/v2/tooltip-v2"
 import { IconButton } from "@opencode-ai/ui/icon-button"
 import { Select } from "@opencode-ai/ui/select"
 import { useDialog } from "@opencode-ai/ui/context/dialog"
@@ -1364,7 +1362,7 @@ export const PromptInput: Component<PromptInputProps> = (props) => {
     shouldAnimate: providersShouldFadeIn(),
     paid: props.controls.model.paid,
     title: language.t("command.model.choose"),
-    keybind: command.keybindParts("model.choose"),
+    keybind: command.keybind("model.choose"),
     model: props.controls.model.selection,
     providerID: props.controls.model.selection.current()?.provider?.id,
     modelName: props.controls.model.selection.current()?.name ?? language.t("dialog.model.select.title"),
@@ -1381,7 +1379,7 @@ export const PromptInput: Component<PromptInputProps> = (props) => {
   const showAgentControl = createMemo(() => props.controls.agents.visible && props.controls.agents.options.length > 0)
   const agentControlState = createMemo<ComposerAgentControlState>(() => ({
     title: language.t("command.agent.cycle"),
-    keybind: command.keybindParts("agent.cycle"),
+    keybind: command.keybind("agent.cycle"),
     options: props.controls.agents.options,
     current: props.controls.agents.current,
     style: control(),
@@ -1499,14 +1497,10 @@ export const PromptInput: Component<PromptInputProps> = (props) => {
               <div class="flex h-11 items-center px-2">
                 <div class="flex min-w-0 flex-1 items-center gap-0">
                   {fileAttachmentInput()}
-                  <TooltipV2
+                  <TooltipKeybind
                     placement="top"
-                    value={
-                      <>
-                        {language.t("prompt.action.attachFile")}
-                        <KeybindV2 keys={command.keybindParts("file.attach")} variant="neutral" />
-                      </>
-                    }
+                    title={language.t("prompt.action.attachFile")}
+                    keybind={command.keybind("file.attach")}
                   >
                     <IconButton
                       data-action="prompt-attach"
@@ -1520,7 +1514,7 @@ export const PromptInput: Component<PromptInputProps> = (props) => {
                       tabIndex={store.mode === "normal" ? undefined : -1}
                       aria-label={language.t("prompt.action.attachFile")}
                     />
-                  </TooltipV2>
+                  </TooltipKeybind>
                   <Show when={showAgentControl()}>
                     <ComposerAgentControl state={agentControlState()} />
                   </Show>
@@ -1535,15 +1529,11 @@ export const PromptInput: Component<PromptInputProps> = (props) => {
                           !props.controls.model.selection.variant.current() && !store.variantOpen,
                       }}
                     >
-                      <TooltipV2
+                      <TooltipKeybind
                         placement="top"
                         gutter={4}
-                        value={
-                          <>
-                            {language.t("command.model.variant.cycle")}
-                            <KeybindV2 keys={command.keybindParts("model.variant.cycle")} variant="neutral" />
-                          </>
-                        }
+                        title={language.t("command.model.variant.cycle")}
+                        keybind={command.keybind("model.variant.cycle")}
                       >
                         <Select
                           size="normal"
@@ -1561,11 +1551,11 @@ export const PromptInput: Component<PromptInputProps> = (props) => {
                           triggerProps={{ "data-action": "prompt-model-variant" }}
                           variant="ghost"
                         />
-                      </TooltipV2>
+                      </TooltipKeybind>
                     </div>
                   </Show>
                 </div>
-                <TooltipV2 placement="top" inactive={!working() && blank()} value={tip()}>
+                <Tooltip placement="top" inactive={!working() && blank()} value={tip()}>
                   <IconButton
                     data-action="prompt-submit"
                     type="submit"
@@ -1580,7 +1570,7 @@ export const PromptInput: Component<PromptInputProps> = (props) => {
                     }}
                     aria-label={stopping() ? language.t("prompt.action.stop") : language.t("prompt.action.send")}
                   />
-                </TooltipV2>
+                </Tooltip>
               </div>
             </DockShellForm>
           </div>
@@ -1926,7 +1916,7 @@ export const PromptInput: Component<PromptInputProps> = (props) => {
 
 type ComposerAgentControlState = {
   title: string
-  keybind: string[]
+  keybind: string
   options: string[]
   current: string
   style: JSX.CSSProperties | undefined
@@ -1938,7 +1928,7 @@ type ComposerModelControlState = {
   shouldAnimate: boolean
   paid: boolean
   title: string
-  keybind: string[]
+  keybind: string
   model: ReturnType<typeof useLocal>["model"]
   providerID?: string
   modelName: string
@@ -1953,16 +1943,7 @@ function ComposerAgentControl(props: { state: ComposerAgentControlState }) {
       <div class="pointer-events-none absolute left-2 top-1/2 z-10 flex size-4 -translate-y-1/2 items-center justify-center text-v2-icon-icon-muted">
         <Icon name="sliders" size="small" />
       </div>
-      <TooltipV2
-        placement="top"
-        gutter={4}
-        value={
-          <>
-            {props.state.title}
-            <KeybindV2 keys={props.state.keybind} variant="neutral" />
-          </>
-        }
-      >
+      <TooltipKeybind placement="top" gutter={4} title={props.state.title} keybind={props.state.keybind}>
         <Select
           size="normal"
           options={props.state.options}
@@ -1974,7 +1955,7 @@ function ComposerAgentControl(props: { state: ComposerAgentControlState }) {
           triggerProps={{ "data-action": "prompt-agent" }}
           variant="ghost"
         />
-      </TooltipV2>
+      </TooltipKeybind>
     </div>
   )
 }
@@ -1985,16 +1966,7 @@ function ComposerModelControl(props: { state: ComposerModelControlState }) {
       <Show
         when={props.state.paid}
         fallback={
-          <TooltipV2
-            placement="top"
-            gutter={4}
-            value={
-              <>
-                {props.state.title}
-                <KeybindV2 keys={props.state.keybind} variant="neutral" />
-              </>
-            }
-          >
+          <TooltipKeybind placement="top" gutter={4} title={props.state.title} keybind={props.state.keybind}>
             <Button
               data-action="prompt-model"
               as="div"
@@ -2019,19 +1991,10 @@ function ComposerModelControl(props: { state: ComposerModelControlState }) {
                 <Icon name="chevron-down" size="small" class="text-v2-icon-icon-muted" />
               </span>
             </Button>
-          </TooltipV2>
+          </TooltipKeybind>
         }
       >
-        <TooltipV2
-          placement="top"
-          gutter={4}
-          value={
-            <>
-              {props.state.title}
-              <KeybindV2 keys={props.state.keybind} variant="neutral" />
-            </>
-          }
-        >
+        <TooltipKeybind placement="top" gutter={4} title={props.state.title} keybind={props.state.keybind}>
           <ModelSelectorPopover
             model={props.state.model}
             triggerAs={Button}
@@ -2060,7 +2023,7 @@ function ComposerModelControl(props: { state: ComposerModelControlState }) {
               <Icon name="chevron-down" size="small" class="text-v2-icon-icon-muted" />
             </span>
           </ModelSelectorPopover>
-        </TooltipV2>
+        </TooltipKeybind>
       </Show>
     </Show>
   )

packages/app/src/components/titlebar.tsx

@@ -99,8 +99,6 @@ export function Titlebar(props: { update?: TitlebarUpdate }) {
 
   const path = () => `${location.pathname}${location.search}${location.hash}`
   const creating = createMemo(() => {
-    const route = layout.route()
-    if (route.type === "draft" || route.type === "dir-new-sesssion") return true
     if (!params.dir) return false
     if (params.id) return false
     const parts = location.pathname.replace(/\/+$/, "").split("/")
@@ -468,7 +466,7 @@ export function Titlebar(props: { update?: TitlebarUpdate }) {
                   }}
                   onReorder={(keys) => tabsStoreActions.reorder(keys)}
                 />
-                <Show when={!creating()}>
+                <Show when={!(creating() && params.dir)}>
                   <TooltipV2
                     placement="bottom"
                     value={

packages/app/src/context/file/tree-store.test.ts

@@ -0,0 +1,28 @@
+import { describe, expect, test } from "bun:test"
+import { createRoot } from "solid-js"
+import { createFileTreeStore } from "./tree-store"
+
+describe("file tree store", () => {
+  test("expands synthetic directories without listing them", () => {
+    const listed: string[] = []
+    const value = createRoot((dispose) => ({
+      dispose,
+      tree: createFileTreeStore({
+        scope: () => "/project",
+        normalizeDir: (input) => input,
+        list: (input) => {
+          listed.push(input)
+          return Promise.resolve([])
+        },
+        onError: () => undefined,
+      }),
+    }))
+
+    value.tree.expandDir("deleted/parent", { load: false })
+
+    expect(value.tree.dirState("deleted/parent")?.expanded).toBe(true)
+    expect(listed).toEqual([])
+
+    value.dispose()
+  })
+})

packages/app/src/context/file/tree-store.ts

@@ -127,10 +127,11 @@ export function createFileTreeStore(options: TreeStoreOptions) {
     return promise
   }
 
-  const expandDir = (input: string) => {
+  const expandDir = (input: string, opts?: { load?: boolean }) => {
     const dir = options.normalizeDir(input)
     ensureDir(dir)
     setTree("dir", dir, "expanded", true)
+    if (opts?.load === false) return
     void listDir(dir)
   }
 

packages/app/src/context/server-sdk.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test"
-import { coalesceServerEvents, enqueueServerEvent, resumeStreamAfterPageShow } from "./server-sdk"
+import { coalesceServerEvents, resumeStreamAfterPageShow } from "./server-sdk"
 import type { Event } from "@opencode-ai/sdk/v2/client"
 
 describe("resumeStreamAfterPageShow", () => {
@@ -15,23 +15,19 @@ describe("resumeStreamAfterPageShow", () => {
 })
 
 describe("coalesceServerEvents", () => {
-  const delta = (value: string, field = "text", partID = "part") => ({
+  const delta = (value: string, field = "text") => ({
     directory: "/repo",
     payload: {
       type: "message.part.delta",
-      properties: { messageID: "msg", partID, field, delta: value },
+      properties: { messageID: "msg", partID: "part", field, delta: value },
     } as Event,
   })
 
   test("merges adjacent deltas for the same field", () => {
-    const first = delta("hello ")
-    const second = delta("world")
-    first.payload.id = "first"
-    second.payload.id = "second"
-    const result = coalesceServerEvents([first, second])
+    const result = coalesceServerEvents([delta("hello "), delta("world")])
 
     expect(result).toHaveLength(1)
-    expect(result[0]?.payload).toMatchObject({ id: "second", properties: { delta: "hello world" } })
+    expect(result[0]?.payload).toMatchObject({ properties: { delta: "hello world" } })
   })
 
   test("preserves event boundaries and distinct fields", () => {
@@ -49,112 +45,9 @@ describe("coalesceServerEvents", () => {
     ])
   })
 
-  test("preserves event ID order across interleaved deltas", () => {
-    const first = delta("a")
-    const other = delta("b", "text", "other")
-    const last = delta("c")
-    first.payload.id = "1"
-    other.payload.id = "2"
-    last.payload.id = "3"
+  test("drops stale deltas", () => {
+    const result = coalesceServerEvents([delta("stale")], new Set(["/repo:msg:part"]))
 
-    const result = coalesceServerEvents([first, other, last])
-
-    expect(result.map((event) => event.payload.id)).toEqual(["1", "2", "3"])
-  })
-})
-
-describe("enqueueServerEvent", () => {
-  const partUpdated = (text: string) =>
-    ({
-      type: "message.part.updated",
-      properties: {
-        sessionID: "session",
-        part: { id: "part", sessionID: "session", messageID: "message", type: "text", text },
-      },
-    }) as Event
-
-  test("preserves part updates across message remove and re-add barriers", () => {
-    const events: Array<{ directory: string; payload: Event }> = []
-    const enqueue = (payload: Event) => enqueueServerEvent(events, { directory: "/repo", payload })
-
-    enqueue(partUpdated("old"))
-    enqueue({ type: "message.removed", properties: { sessionID: "session", messageID: "message" } } as Event)
-    enqueue({
-      type: "message.updated",
-      properties: {
-        sessionID: "session",
-        info: {
-          id: "message",
-          sessionID: "session",
-          role: "user",
-          time: { created: 1 },
-          agent: "build",
-          model: { providerID: "provider", modelID: "model" },
-        },
-      },
-    } as Event)
-    enqueue(partUpdated("new"))
-
-    expect(events.map((event) => event.payload.type)).toEqual([
-      "message.part.updated",
-      "message.removed",
-      "message.updated",
-      "message.part.updated",
-    ])
-  })
-
-  test("preserves deltas after a replacement snapshot", () => {
-    const events: Array<{ directory: string; payload: Event }> = []
-    const enqueue = (payload: Event) => enqueueServerEvent(events, { directory: "/repo", payload })
-
-    enqueue(partUpdated("a"))
-    enqueue(partUpdated("ab"))
-    enqueue({
-      type: "message.part.delta",
-      properties: { sessionID: "session", messageID: "message", partID: "part", field: "text", delta: "c" },
-    } as Event)
-
-    const result = coalesceServerEvents(events)
-    expect(result.map((event) => event.payload.type)).toEqual(["message.part.updated", "message.part.delta"])
-    expect(result[0]?.payload).toMatchObject({ properties: { part: { text: "ab" } } })
-    expect(result[1]?.payload).toMatchObject({ properties: { delta: "c" } })
-  })
-
-  test("preserves updates after session deletion", () => {
-    const events: Array<{ directory: string; payload: Event }> = []
-    const enqueue = (payload: Event) => enqueueServerEvent(events, { directory: "/repo", payload })
-
-    enqueue(partUpdated("old"))
-    enqueue({
-      type: "session.deleted",
-      properties: { sessionID: "session", info: { id: "session" } },
-    } as Event)
-    enqueue(partUpdated("new"))
-
-    expect(events.map((event) => event.payload.type)).toEqual([
-      "message.part.updated",
-      "session.deleted",
-      "message.part.updated",
-    ])
-  })
-
-  test("does not coalesce edge-triggered session statuses", () => {
-    const events: Array<{ directory: string; payload: Event }> = []
-    const enqueue = (status: "retry" | "busy") =>
-      enqueueServerEvent(events, {
-        directory: "/repo",
-        payload: {
-          type: "session.status",
-          properties: {
-            sessionID: "session",
-            status: status === "retry" ? { type: "retry", attempt: 1, message: "retry", next: 1 } : { type: "busy" },
-          },
-        } as Event,
-      })
-
-    enqueue("retry")
-    enqueue("busy")
-
-    expect(events).toHaveLength(2)
+    expect(result).toEqual([])
   })
 })

packages/app/src/context/server-sdk.tsx

@@ -17,56 +17,34 @@ const isAbortError = (error: unknown) =>
 const isStreamClosed = (error: unknown, signal?: AbortSignal) => isAbortError(error) || signal?.aborted === true
 type QueuedServerEvent = { directory: string; payload: Event }
 
-const coalescedKey = (event: QueuedServerEvent) => {
-  if (event.payload.type === "lsp.updated") return `lsp.updated:${event.directory}`
-  if (event.payload.type === "message.part.updated") {
-    const part = event.payload.properties.part
-    return `message.part.updated:${event.directory}:${part.messageID}:${part.id}`
-  }
-  return undefined
-}
+const deltaKey = (directory: string, messageID: string, partID: string) => `${directory}:${messageID}:${partID}`
 
-export function enqueueServerEvent(queue: QueuedServerEvent[], event: QueuedServerEvent) {
-  const key = coalescedKey(event)
-  const previous = queue[queue.length - 1]
-  if (key && previous && coalescedKey(previous) === key) {
-    queue[queue.length - 1] = event
-    return false
-  }
-  queue.push(event)
-  return true
-}
-
-export function coalesceServerEvents(events: QueuedServerEvent[]) {
+export function coalesceServerEvents(events: QueuedServerEvent[], stale?: Set<string>) {
   const output: QueuedServerEvent[] = []
+  const deltas = new Map<string, number>()
   events.forEach((event) => {
+    if (stale && event.payload.type === "message.part.delta") {
+      const props = event.payload.properties
+      if (stale.has(deltaKey(event.directory, props.messageID, props.partID))) return
+    }
     if (event.payload.type !== "message.part.delta") {
+      deltas.clear()
       output.push(event)
       return
     }
     const props = event.payload.properties
-    const previous = output[output.length - 1]
-    if (
-      !previous ||
-      previous.payload.type !== "message.part.delta" ||
-      previous.directory !== event.directory ||
-      previous.payload.properties.messageID !== props.messageID ||
-      previous.payload.properties.partID !== props.partID ||
-      previous.payload.properties.field !== props.field
-    ) {
+    const id = `${deltaKey(event.directory, props.messageID, props.partID)}:${props.field}`
+    const index = deltas.get(id)
+    const existing = index === undefined ? undefined : output[index]
+    if (!existing || existing.payload.type !== "message.part.delta") {
+      deltas.set(id, output.length)
       output.push({
         directory: event.directory,
         payload: { ...event.payload, properties: { ...props } },
       })
       return
     }
-    output[output.length - 1] = {
-      directory: event.directory,
-      payload: {
-        ...event.payload,
-        properties: { ...props, delta: previous.payload.properties.delta + props.delta },
-      },
-    }
+    existing.payload.properties.delta += props.delta
   })
   return output
 }
@@ -107,9 +85,20 @@ function createServerSdkContextBase(server: ServerConnection.Any, scope: ServerS
 
   let queue: Queued[] = []
   let buffer: Queued[] = []
+  const coalesced = new Map<string, number>()
+  const staleDeltas = new Set<string>()
   let timer: ReturnType<typeof setTimeout> | undefined
   let last = 0
 
+  const key = (directory: string, payload: Event) => {
+    if (payload.type === "session.status") return `session.status:${directory}:${payload.properties.sessionID}`
+    if (payload.type === "lsp.updated") return `lsp.updated:${directory}`
+    if (payload.type === "message.part.updated") {
+      const part = payload.properties.part
+      return `message.part.updated:${directory}:${part.messageID}:${part.id}`
+    }
+  }
+
   const flush = () => {
     if (timer) clearTimeout(timer)
     timer = undefined
@@ -117,12 +106,15 @@ function createServerSdkContextBase(server: ServerConnection.Any, scope: ServerS
     if (queue.length === 0) return
 
     const events = queue
+    const skip = staleDeltas.size > 0 ? new Set(staleDeltas) : undefined
     queue = buffer
     buffer = events
     queue.length = 0
+    coalesced.clear()
+    staleDeltas.clear()
 
     last = Date.now()
-    const output = coalesceServerEvents(events)
+    const output = coalesceServerEvents(events, skip)
     batch(() => {
       output.forEach((event) => emitter.emit(event.directory, event.payload))
     })
@@ -192,12 +184,29 @@ function createServerSdkContextBase(server: ServerConnection.Any, scope: ServerS
           for await (const event of events.stream) {
             resetHeartbeat()
             streamErrorLogged = false
-            if (event.payload.type !== "sync") {
-              const directory = event.directory ?? "global"
-              const payload = event.payload as Event
-              if (enqueueServerEvent(queue, { directory, payload })) schedule()
+            const directory = event.directory ?? "global"
+            if (event.payload.type === "sync") {
+              continue
             }
 
+            const payload = event.payload as Event
+
+            const k = key(directory, payload)
+            if (k) {
+              const i = coalesced.get(k)
+              if (i !== undefined) {
+                queue[i] = { directory, payload }
+                if (payload.type === "message.part.updated") {
+                  const part = payload.properties.part
+                  staleDeltas.add(deltaKey(directory, part.messageID, part.id))
+                }
+                continue
+              }
+              coalesced.set(k, queue.length)
+            }
+            queue.push({ directory, payload })
+            schedule()
+
             if (Date.now() - yielded < STREAM_YIELD_MS) continue
             yielded = Date.now()
             await wait(0)

packages/app/src/context/server-session.ts

@@ -18,67 +18,44 @@ import { rootSession } from "@/utils/session-route"
 import { dropSessionCaches, pickSessionCacheEvictions, SESSION_CACHE_LIMIT } from "./global-sync/session-cache"
 
 const cmp = (a: string, b: string) => (a < b ? -1 : a > b ? 1 : 0)
-const cmpMessage = (a: Message, b: Message) => a.time.created - b.time.created || cmp(a.id, b.id)
 const SKIP_PARTS = new Set(["patch", "step-start", "step-finish"])
 const initialMessagePageSize = 2
 const historyMessagePageSize = 200
 const sessionInfoLimit = 2_048
-const emptyIDs: ReadonlySet<string> = new Set()
 
 type OptimisticItem = {
   message: Message
   parts: Part[]
-  confirmedParts?: Part[]
-  confirmedMessage?: boolean
 }
 
-type MessagePage = {
-  session: Message[]
-  part: { id: string; part: Part[] }[]
-  cursor?: string
-  complete: boolean
+const hasParts = (parts: Part[] | undefined, want: Part[]) => {
+  if (!parts) return want.length === 0
+  return want.every((part) => Binary.search(parts, part.id, (item) => item.id).found)
 }
 
-// Most markers describe the current HTTP attempt; deltaParts persists non-durable stream state across retries.
-type MessageLoadState = {
-  touchedMessages: Set<string>
-  removedMessages: Set<string>
-  retainedMessages: Set<string>
-  touchedParts: Map<string, Set<string>>
-  deltaParts: Map<string, Set<string>>
-  carriedDeltaParts: Map<string, Set<string>>
-  removedParts: Map<string, Set<string>>
-  optimisticParts: Map<string, Set<string>>
-  orphanParents: Set<string>
-  clearedMessageParts: Set<string>
-}
-
-function mergeOptimisticPage(page: MessagePage, items: OptimisticItem[]) {
-  if (items.length === 0) return { ...page, observed: [] as { messageID: string; parts: Part[] }[] }
+function mergeOptimisticPage(
+  page: { session: Message[]; part: { id: string; part: Part[] }[]; cursor?: string; complete: boolean },
+  items: OptimisticItem[],
+) {
+  if (items.length === 0) return { ...page, confirmed: [] as string[] }
   const session = [...page.session]
   const part = new Map(page.part.map((item) => [item.id, item.part]))
-  const observed: { messageID: string; parts: Part[] }[] = []
+  const confirmed: string[] = []
   for (const item of items) {
     const result = Binary.search(session, item.message.id, (message) => message.id)
     if (!result.found) session.splice(result.index, 0, item.message)
     const current = part.get(item.message.id)
-    const confirmed = result.found
-      ? item.parts.filter((part) => Binary.search(current ?? [], part.id, (value) => value.id).found)
-      : []
-    if (result.found) observed.push({ messageID: item.message.id, parts: confirmed })
-    part.set(
-      item.message.id,
-      merge(
-        result.found ? (current ?? []) : merge(item.confirmedParts ?? [], current ?? []),
-        item.parts.filter((part) => !confirmed.includes(part)),
-      ),
-    )
+    if (result.found && hasParts(current, item.parts)) {
+      confirmed.push(item.message.id)
+      continue
+    }
+    part.set(item.message.id, merge(current ?? [], item.parts))
   }
   return {
     ...page,
     session,
     part: [...part.entries()].sort((a, b) => cmp(a[0], b[0])).map(([id, parts]) => ({ id, part: parts })),
-    observed,
+    confirmed,
   }
 }
 
@@ -98,38 +75,7 @@ function merge<T extends { id: string }>(a: readonly T[], b: readonly T[]) {
   return [...items.values()].sort((x, y) => cmp(x.id, y.id))
 }
 
-function reconcileFetched<T extends { id: string }>(
-  fetched: T[],
-  current: readonly T[],
-  options: {
-    touched?: ReadonlySet<string>
-    retained?: ReadonlySet<string>
-    preserveUnfetched?: boolean | ((item: T) => boolean)
-  } = {},
-) {
-  const result = new Map(fetched.map((item) => [item.id, item]))
-  const live = new Map(current.map((item) => [item.id, item]))
-  if (options.preserveUnfetched) {
-    for (const item of current) {
-      if (!result.has(item.id) && (options.preserveUnfetched === true || options.preserveUnfetched(item)))
-        result.set(item.id, item)
-    }
-  }
-  for (const id of options.retained ?? emptyIDs) {
-    if (result.has(id)) continue
-    const item = live.get(id)
-    if (item) result.set(id, item)
-  }
-  // Events observed while the request is pending are the freshest client state for those identities.
-  for (const id of options.touched ?? emptyIDs) {
-    const item = live.get(id)
-    if (item) result.set(id, item)
-    if (!item) result.delete(id)
-  }
-  return [...result.values()].sort((a, b) => cmp(a.id, b.id))
-}
-
-export function createServerSession(client: OpencodeClient, options?: { retry?: typeof retry }) {
+export function createServerSession(client: OpencodeClient) {
   const [data, setData] = createStore({
     info: {} as Record<string, Session | undefined>,
     session_status: {} as Record<string, SessionStatus>,
@@ -149,32 +95,10 @@ export function createServerSession(client: OpencodeClient, options?: { retry?:
   const inflightDiff = new Map<string, Promise<void>>()
   const inflightTodo = new Map<string, Promise<void>>()
   const optimistic = new Map<string, Map<string, OptimisticItem>>()
-  const messageLoads = new Map<string, MessageLoadState>()
-  const pendingParts = new Map<string, Map<string, Set<string>>>()
-  const orphanParts = new Map<string, Set<string>>()
-  const removedMessages = new Map<string, Set<string>>()
-  const deltaBases = new Map<string, { base: string; sessionID: string }>()
-  const deleteMessageParts = (
-    cache: { part: Record<string, Part[] | undefined>; part_text_accum_delta: Record<string, string | undefined> },
-    messageID: string,
-  ) => {
-    for (const part of cache.part[messageID] ?? []) {
-      delete cache.part_text_accum_delta[part.id]
-      deltaBases.delete(part.id)
-    }
-    delete cache.part[messageID]
-  }
   const seen = new Set<string>()
   const infoSeen = new Set<string>()
   const pinned = new Map<string, number>()
-  const generations = new Map<string, object>()
-  const generation = (sessionID: string) => {
-    const current = generations.get(sessionID)
-    if (current) return current
-    const created = {}
-    generations.set(sessionID, created)
-    return created
-  }
+  const generations = new Map<string, number>()
   const [meta, setMeta] = createStore({
     limit: {} as Record<string, number | undefined>,
     cursor: {} as Record<string, string | undefined>,
@@ -191,11 +115,6 @@ export function createServerSession(client: OpencodeClient, options?: { retry?:
       const preserve = new Set([
         ...pinned.keys(),
         ...requests.keys(),
-        ...inflight.keys(),
-        ...inflightDiff.keys(),
-        ...inflightTodo.keys(),
-        ...messageLoads.keys(),
-        ...optimistic.keys(),
         ...Object.entries(data.permission)
           .filter(([, items]) => items.length > 0)
           .map(([sessionID]) => sessionID),
@@ -219,7 +138,6 @@ export function createServerSession(client: OpencodeClient, options?: { retry?:
         if (!preserve.has(sessionID)) stale.push(sessionID)
       }
       stale.forEach((sessionID) => infoSeen.delete(sessionID))
-      stale.forEach((sessionID) => generations.delete(sessionID))
       setData(
         "info",
         produce((draft) => stale.forEach((sessionID) => delete draft[sessionID])),
@@ -233,27 +151,21 @@ export function createServerSession(client: OpencodeClient, options?: { retry?:
     if (cached && !options?.force) return Promise.resolve(cached)
     const pending = requests.get(sessionID)
     if (pending) return pending
-    const active = generation(sessionID)
+    const generation = generations.get(sessionID) ?? 0
     const request = client.session.get({ sessionID }).then((result) => {
       if (!result.data) throw new Error(`Session not found: ${sessionID}`)
-      if (generations.get(sessionID) !== active) return result.data
+      if ((generations.get(sessionID) ?? 0) !== generation) return result.data
       return remember(result.data)
     })
     requests.set(sessionID, request)
-    const cleanup = () => {
-      if (requests.get(sessionID) === request) requests.delete(sessionID)
-      if (
-        generations.get(sessionID) === active &&
-        !data.info[sessionID] &&
-        !requests.has(sessionID) &&
-        !messageLoads.has(sessionID) &&
-        !inflight.has(sessionID) &&
-        !inflightDiff.has(sessionID) &&
-        !inflightTodo.has(sessionID)
-      )
-        generations.delete(sessionID)
-    }
-    void request.then(cleanup, cleanup)
+    void request.then(
+      () => {
+        if (requests.get(sessionID) === request) requests.delete(sessionID)
+      },
+      () => {
+        if (requests.get(sessionID) === request) requests.delete(sessionID)
+      },
+    )
     return request
   }
 
@@ -283,121 +195,15 @@ export function createServerSession(client: OpencodeClient, options?: { retry?:
     if (items.size === 0) optimistic.delete(sessionID)
   }
 
-  const clearOptimisticPart = (sessionID: string, messageID: string, partID: string) => {
-    const items = optimistic.get(sessionID)
-    const item = items?.get(messageID)
-    if (!items || !item) return
-    const parts = item.parts.filter((part) => part.id !== partID)
-    const confirmedParts = item.confirmedParts?.filter((part) => part.id !== partID)
-    if (parts.length === 0) {
-      clearOptimistic(sessionID, messageID)
-      return
-    }
-    items.set(messageID, { ...item, parts, confirmedParts, confirmedMessage: true })
-  }
-
-  const confirmOptimisticPart = (sessionID: string, messageID: string, part: Part) => {
-    const items = optimistic.get(sessionID)
-    const item = items?.get(messageID)
-    if (!items || !item) return
-    const parts = item.parts.filter((value) => value.id !== part.id)
-    if (parts.length === 0) {
-      clearOptimistic(sessionID, messageID)
-      return
-    }
-    items.set(messageID, {
-      ...item,
-      parts,
-      confirmedParts: merge(item.confirmedParts ?? [], [part]),
-      confirmedMessage: true,
-    })
-  }
-
-  const confirmOptimistic = (sessionID: string, messageID: string, confirmedParts: Part[]) => {
-    const items = optimistic.get(sessionID)
-    const item = items?.get(messageID)
-    if (!items || !item) return
-    const confirmed = new Set(confirmedParts.map((part) => part.id))
-    const parts = item.parts.filter((part) => !confirmed.has(part.id))
-    if (parts.length === 0) {
-      clearOptimistic(sessionID, messageID)
-      return
-    }
-    items.set(messageID, {
-      ...item,
-      parts,
-      confirmedParts: merge(item.confirmedParts ?? [], confirmedParts),
-      confirmedMessage: true,
-    })
-  }
-
-  const trackPartChange = (sessionID: string, messageID: string, partID: string) => {
-    const load = messageLoads.get(sessionID)
-    if (!load) return
-    // A part event keeps an existing parent when the fetched page omits it without overriding fetched metadata.
-    const messages = data.message[sessionID]
-    if (messages && Binary.search(messages, messageID, (message) => message.id).found)
-      load.retainedMessages.add(messageID)
-    const parts = load.touchedParts.get(messageID)
-    if (parts) {
-      parts.add(partID)
-      return
-    }
-    load.touchedParts.set(messageID, new Set([partID]))
-  }
-
-  const resetMessageLoad = (sessionID: string, load: MessageLoadState) => {
-    load.touchedMessages.clear()
-    load.retainedMessages.clear()
-    load.touchedParts.clear()
-    load.carriedDeltaParts.clear()
-    load.clearedMessageParts.clear()
-    for (const messageID of load.removedMessages) {
-      load.touchedMessages.add(messageID)
-      load.clearedMessageParts.add(messageID)
-    }
-    for (const [messageID, parts] of load.deltaParts) {
-      load.touchedParts.set(messageID, new Set(parts))
-      load.carriedDeltaParts.set(messageID, new Set(parts))
-      const messages = data.message[sessionID]
-      if (messages && Binary.search(messages, messageID, (message) => message.id).found)
-        load.retainedMessages.add(messageID)
-    }
-    for (const [messageID, parts] of load.removedParts) {
-      const touched = load.touchedParts.get(messageID) ?? new Set<string>()
-      parts.forEach((partID) => touched.add(partID))
-      load.touchedParts.set(messageID, touched)
-      const messages = data.message[sessionID]
-      if (messages && Binary.search(messages, messageID, (message) => message.id).found)
-        load.retainedMessages.add(messageID)
-    }
-    for (const [messageID, parts] of load.optimisticParts) {
-      load.removedMessages.delete(messageID)
-      load.clearedMessageParts.add(messageID)
-      load.touchedMessages.add(messageID)
-      const touched = load.touchedParts.get(messageID) ?? new Set<string>()
-      parts.forEach((partID) => touched.add(partID))
-      load.touchedParts.set(messageID, touched)
-    }
-  }
-
   const evict = (sessionIDs: string[]) => {
     if (sessionIDs.length === 0) return
-    const evicted = new Set(sessionIDs)
-    for (const [partID, item] of deltaBases) {
-      if (evicted.has(item.sessionID)) deltaBases.delete(partID)
-    }
     sessionIDs.forEach((sessionID) => {
-      generations.delete(sessionID)
+      generations.set(sessionID, (generations.get(sessionID) ?? 0) + 1)
       clearOptimistic(sessionID)
       requests.delete(sessionID)
       inflight.delete(sessionID)
       inflightDiff.delete(sessionID)
       inflightTodo.delete(sessionID)
-      messageLoads.delete(sessionID)
-      pendingParts.delete(sessionID)
-      orphanParts.delete(sessionID)
-      removedMessages.delete(sessionID)
     })
     setData(
       produce((draft) => {
@@ -424,7 +230,6 @@ export function createServerSession(client: OpencodeClient, options?: { retry?:
       ...inflight.keys(),
       ...inflightDiff.keys(),
       ...inflightTodo.keys(),
-      ...messageLoads.keys(),
       ...optimistic.keys(),
       ...Object.entries(data.permission)
         .filter(([, items]) => items.length > 0)
@@ -442,11 +247,8 @@ export function createServerSession(client: OpencodeClient, options?: { retry?:
       pickSessionCacheEvictions({ seen, keep: sessionID, limit: SESSION_CACHE_LIMIT, preserve: protectedSessions() }),
     )
 
-  const fetchMessages = async (sessionID: string, limit: number, before?: string, onAttempt?: () => void) => {
-    const response = await (options?.retry ?? retry)(() => {
-      onAttempt?.()
-      return client.session.messages({ sessionID, limit, before })
-    })
+  const fetchMessages = async (sessionID: string, limit: number, before?: string) => {
+    const response = await retry(() => client.session.messages({ sessionID, limit, before }))
     const items = (response.data ?? []).filter((item) => !!item?.info?.id)
     return {
       session: items.map((item) => cleanMessage(item.info)).sort((a, b) => cmp(a.id, b.id)),
@@ -459,153 +261,30 @@ export function createServerSession(client: OpencodeClient, options?: { retry?:
     }
   }
 
-  const replaceMessages = (sessionID: string, messages: Message[]) => {
-    const messageIDs = new Set(messages.map((message) => message.id))
-    const dropped = (data.message[sessionID] ?? []).filter((message) => !messageIDs.has(message.id))
-    setData("message", sessionID, reconcile(messages, { key: "id" }))
-    setData(
-      produce((draft) => {
-        for (const message of dropped) deleteMessageParts(draft, message.id)
-      }),
-    )
-    return messageIDs
-  }
-
-  const replaceParts = (
-    sessionID: string,
-    items: MessagePage["part"],
-    messageIDs: Set<string>,
-    load?: MessageLoadState,
-  ) => {
-    for (const item of items) {
-      if (!messageIDs.has(item.id)) continue
-      const fetched = load?.clearedMessageParts.has(item.id)
-        ? []
-        : item.part.filter((part) => !SKIP_PARTS.has(part.type))
-      const fetchedIDs = new Set(fetched.map((part) => part.id))
-      const pending = pendingParts.get(sessionID)?.get(item.id)
-      const touched = new Set([...(load?.touchedParts.get(item.id) ?? []), ...(pending ?? [])])
-      for (const part of fetched) {
-        const accumulated = data.part_text_accum_delta[part.id]
-        const base = deltaBases.get(part.id)?.base
-        const preserveDelta =
-          base !== undefined &&
-          accumulated !== undefined &&
-          "text" in part &&
-          typeof part.text === "string" &&
-          part.text.startsWith(base) &&
-          accumulated.startsWith(part.text) &&
-          accumulated !== part.text
-        if (preserveDelta) touched.add(part.id)
-        if (load?.carriedDeltaParts.get(item.id)?.has(part.id) && !preserveDelta) touched.delete(part.id)
-      }
-      for (const partID of load?.carriedDeltaParts.get(item.id) ?? []) {
-        if (!fetchedIDs.has(partID)) touched.delete(partID)
-      }
-      const parts = reconcileFetched(fetched, data.part[item.id] ?? [], { touched })
-      if (!parts.length) {
-        orphanParts.get(sessionID)?.delete(item.id)
-        setData(produce((draft) => deleteMessageParts(draft, item.id)))
-        continue
-      }
-      const partIDs = new Set(parts.map((part) => part.id))
-      setData(
-        "part_text_accum_delta",
-        produce((draft) => {
-          for (const part of data.part[item.id] ?? []) {
-            if (!partIDs.has(part.id) || !touched.has(part.id)) {
-              delete draft[part.id]
-              deltaBases.delete(part.id)
-            }
-          }
-        }),
-      )
-      setData("part", item.id, reconcile(parts, { key: "id" }))
-      orphanParts.get(sessionID)?.delete(item.id)
-    }
-  }
-
-  const applyMessagePage = (
-    sessionID: string,
-    page: MessagePage,
-    load: MessageLoadState | undefined,
-    preserveUnfetched: boolean | ((message: Message) => boolean),
-    cleanupOrphans: boolean,
-  ) => {
-    const merged = mergeOptimisticPage(page, [...(optimistic.get(sessionID)?.values() ?? [])])
-    merged.observed.forEach((item) => {
-      if (!load?.clearedMessageParts.has(item.messageID)) confirmOptimistic(sessionID, item.messageID, item.parts)
-    })
-    const touchedMessages = new Set([...(load?.touchedMessages ?? []), ...(removedMessages.get(sessionID) ?? [])])
-    const messages = reconcileFetched(merged.session, data.message[sessionID] ?? [], {
-      touched: touchedMessages,
-      retained: load?.retainedMessages,
-      preserveUnfetched,
-    })
-    batch(() => {
-      const messageIDs = replaceMessages(sessionID, messages)
-      replaceParts(sessionID, merged.part, messageIDs, load)
-      const orphans = orphanParts.get(sessionID)
-      if (cleanupOrphans && page.complete && orphans) {
-        for (const messageID of orphans) {
-          if (!messageIDs.has(messageID)) setData(produce((draft) => deleteMessageParts(draft, messageID)))
-        }
-        orphanParts.delete(sessionID)
-      }
-      setMeta("limit", sessionID, messages.length)
-      setMeta("cursor", sessionID, merged.cursor)
-      setMeta("complete", sessionID, merged.complete)
-      setMeta("at", sessionID, Date.now())
-    })
-  }
-
   const loadMessages = async (sessionID: string, limit: number, before?: string, mode?: "replace" | "prepend") => {
     if (meta.loading[sessionID]) return
-    const active = generation(sessionID)
-    const load: MessageLoadState = {
-      touchedMessages: new Set(),
-      removedMessages: new Set(),
-      retainedMessages: new Set(),
-      touchedParts: new Map(),
-      deltaParts: new Map(),
-      carriedDeltaParts: new Map(),
-      removedParts: new Map(),
-      optimisticParts: new Map(),
-      orphanParents: new Set(),
-      clearedMessageParts: new Set(),
-    }
-    messageLoads.set(sessionID, load)
+    const generation = generations.get(sessionID) ?? 0
     setMeta("loading", sessionID, true)
-    let applied = false
-    await fetchMessages(sessionID, limit, before, () => resetMessageLoad(sessionID, load))
+    await fetchMessages(sessionID, limit, before)
       .then((page) => {
-        if (generations.get(sessionID) !== active) return
-        const first = page.session.reduce<Message | undefined>(
-          (oldest, message) => (!oldest || cmpMessage(message, oldest) < 0 ? message : oldest),
-          undefined,
-        )
-        const preserveUnfetched =
-          mode === "prepend" || (!page.complete && (!first || ((message: Message) => cmpMessage(message, first) < 0)))
-        applyMessagePage(
-          sessionID,
-          page,
-          messageLoads.get(sessionID) === load ? load : undefined,
-          preserveUnfetched,
-          mode !== "prepend",
-        )
-        applied = true
+        if ((generations.get(sessionID) ?? 0) !== generation) return
+        const next = mergeOptimisticPage(page, [...(optimistic.get(sessionID)?.values() ?? [])])
+        next.confirmed.forEach((messageID) => clearOptimistic(sessionID, messageID))
+        const messages = mode === "prepend" ? merge(data.message[sessionID] ?? [], next.session) : next.session
+        batch(() => {
+          setData("message", sessionID, reconcile(messages, { key: "id" }))
+          for (const item of next.part) {
+            const parts = item.part.filter((part) => !SKIP_PARTS.has(part.type))
+            if (parts.length) setData("part", item.id, reconcile(parts, { key: "id" }))
+          }
+          setMeta("limit", sessionID, messages.length)
+          setMeta("cursor", sessionID, next.cursor)
+          setMeta("complete", sessionID, next.complete)
+          setMeta("at", sessionID, Date.now())
+        })
       })
       .finally(() => {
-        if (!applied && generations.get(sessionID) === active && messageLoads.get(sessionID) === load) {
-          for (const messageID of load.orphanParents) {
-            if (!orphanParts.get(sessionID)?.has(messageID)) continue
-            setData(produce((draft) => deleteMessageParts(draft, messageID)))
-            orphanParts.get(sessionID)?.delete(messageID)
-          }
-          if (orphanParts.get(sessionID)?.size === 0) orphanParts.delete(sessionID)
-        }
-        if (messageLoads.get(sessionID) === load) messageLoads.delete(sessionID)
-        if (generations.get(sessionID) === active) setMeta("loading", sessionID, false)
+        if ((generations.get(sessionID) ?? 0) === generation) setMeta("loading", sessionID, false)
       })
   }
 
@@ -660,13 +339,7 @@ export function createServerSession(client: OpencodeClient, options?: { retry?:
     const eventID = eventSessionID(event)
     if (eventID) {
       touch(eventID)
-      if (
-        !data.info[eventID] &&
-        event.type !== "session.created" &&
-        event.type !== "session.updated" &&
-        event.type !== "session.deleted"
-      )
-        void resolve(eventID).catch(() => {})
+      if (!data.info[eventID]) void resolve(eventID).catch(() => {})
     }
     switch (event.type) {
       case "session.created":
@@ -705,21 +378,6 @@ export function createServerSession(client: OpencodeClient, options?: { retry?:
       }
       case "message.updated": {
         const info = cleanMessage((event.properties as { info: Message }).info)
-        const load = messageLoads.get(info.sessionID)
-        load?.touchedMessages.add(info.id)
-        load?.removedMessages.delete(info.id)
-        const items = optimistic.get(info.sessionID)
-        const item = items?.get(info.id)
-        if (items && item) {
-          if (item.parts.length === 0) clearOptimistic(info.sessionID, info.id)
-          if (item.parts.length > 0) items.set(info.id, { ...item, confirmedMessage: true })
-        }
-        const orphans = orphanParts.get(info.sessionID)
-        orphans?.delete(info.id)
-        if (orphans?.size === 0) orphanParts.delete(info.sessionID)
-        const removedMessagesForSession = removedMessages.get(info.sessionID)
-        removedMessagesForSession?.delete(info.id)
-        if (removedMessagesForSession?.size === 0) removedMessages.delete(info.sessionID)
         const messages = data.message[info.sessionID]
         if (!messages) {
           setData("message", info.sessionID, [info])
@@ -737,20 +395,6 @@ export function createServerSession(client: OpencodeClient, options?: { retry?:
       }
       case "message.removed": {
         const props = event.properties as { sessionID: string; messageID: string }
-        const load = messageLoads.get(props.sessionID)
-        load?.touchedMessages.add(props.messageID)
-        load?.removedMessages.add(props.messageID)
-        load?.clearedMessageParts.add(props.messageID)
-        load?.deltaParts.delete(props.messageID)
-        load?.carriedDeltaParts.delete(props.messageID)
-        load?.removedParts.delete(props.messageID)
-        load?.optimisticParts.delete(props.messageID)
-        pendingParts.get(props.sessionID)?.delete(props.messageID)
-        if (pendingParts.get(props.sessionID)?.size === 0) pendingParts.delete(props.sessionID)
-        const removedMessagesForSession = removedMessages.get(props.sessionID) ?? new Set<string>()
-        removedMessagesForSession.add(props.messageID)
-        removedMessages.set(props.sessionID, removedMessagesForSession)
-        clearOptimistic(props.sessionID, props.messageID)
         setData(
           produce((draft) => {
             const messages = draft.message[props.sessionID]
@@ -758,7 +402,8 @@ export function createServerSession(client: OpencodeClient, options?: { retry?:
               const result = Binary.search(messages, props.messageID, (message) => message.id)
               if (result.found) messages.splice(result.index, 1)
             }
-            deleteMessageParts(draft, props.messageID)
+            for (const part of draft.part[props.messageID] ?? []) delete draft.part_text_accum_delta[part.id]
+            delete draft.part[props.messageID]
           }),
         )
         return
@@ -766,42 +411,6 @@ export function createServerSession(client: OpencodeClient, options?: { retry?:
       case "message.part.updated": {
         const part = (event.properties as { part: Part }).part
         if (SKIP_PARTS.has(part.type)) return
-        const messages = data.message[part.sessionID]
-        const load = messageLoads.get(part.sessionID)
-        const missing = !messages || !Binary.search(messages, part.messageID, (message) => message.id).found
-        // Outside a page load, accepting a part without its ordered parent event would create an unbounded orphan.
-        if (
-          missing &&
-          (!load ||
-            load.clearedMessageParts.has(part.messageID) ||
-            removedMessages.get(part.sessionID)?.has(part.messageID))
-        )
-          return
-        if (missing) {
-          const orphans = orphanParts.get(part.sessionID) ?? new Set<string>()
-          orphans.add(part.messageID)
-          orphanParts.set(part.sessionID, orphans)
-          load?.orphanParents.add(part.messageID)
-        }
-        const deltas = load?.deltaParts.get(part.messageID)
-        deltas?.delete(part.id)
-        if (deltas?.size === 0) load?.deltaParts.delete(part.messageID)
-        const carried = load?.carriedDeltaParts.get(part.messageID)
-        carried?.delete(part.id)
-        if (carried?.size === 0) load?.carriedDeltaParts.delete(part.messageID)
-        const removed = load?.removedParts.get(part.messageID)
-        removed?.delete(part.id)
-        if (removed?.size === 0) load?.removedParts.delete(part.messageID)
-        const pending = pendingParts.get(part.sessionID)?.get(part.messageID)
-        pending?.delete(part.id)
-        if (pending?.size === 0) pendingParts.get(part.sessionID)?.delete(part.messageID)
-        if (pendingParts.get(part.sessionID)?.size === 0) pendingParts.delete(part.sessionID)
-        const optimistic = load?.optimisticParts.get(part.messageID)
-        optimistic?.delete(part.id)
-        if (optimistic?.size === 0) load?.optimisticParts.delete(part.messageID)
-        deltaBases.delete(part.id)
-        trackPartChange(part.sessionID, part.messageID, part.id)
-        confirmOptimisticPart(part.sessionID, part.messageID, part)
         setData(
           "part_text_accum_delta",
           produce((draft) => void delete draft[part.id]),
@@ -822,34 +431,10 @@ export function createServerSession(client: OpencodeClient, options?: { retry?:
         return
       }
       case "message.part.removed": {
-        const props = event.properties as { sessionID: string; messageID: string; partID: string }
-        // Part removal is event-only on the server, so its tombstone lasts until a later update or eviction.
-        const pending = pendingParts.get(props.sessionID) ?? new Map<string, Set<string>>()
-        const parts = pending.get(props.messageID) ?? new Set<string>()
-        parts.add(props.partID)
-        pending.set(props.messageID, parts)
-        pendingParts.set(props.sessionID, pending)
-        const deltas = messageLoads.get(props.sessionID)?.deltaParts.get(props.messageID)
-        deltas?.delete(props.partID)
-        if (deltas?.size === 0) messageLoads.get(props.sessionID)?.deltaParts.delete(props.messageID)
-        const load = messageLoads.get(props.sessionID)
-        const carried = load?.carriedDeltaParts.get(props.messageID)
-        carried?.delete(props.partID)
-        if (carried?.size === 0) load?.carriedDeltaParts.delete(props.messageID)
-        if (load) {
-          const parts = load.removedParts.get(props.messageID) ?? new Set<string>()
-          parts.add(props.partID)
-          load.removedParts.set(props.messageID, parts)
-          const optimistic = load.optimisticParts.get(props.messageID)
-          optimistic?.delete(props.partID)
-          if (optimistic?.size === 0) load.optimisticParts.delete(props.messageID)
-        }
-        trackPartChange(props.sessionID, props.messageID, props.partID)
-        clearOptimisticPart(props.sessionID, props.messageID, props.partID)
+        const props = event.properties as { messageID: string; partID: string }
         setData(
           produce((draft) => {
             delete draft.part_text_accum_delta[props.partID]
-            deltaBases.delete(props.partID)
             const parts = draft.part[props.messageID]
             if (!parts) return
             const result = Binary.search(parts, props.partID, (part) => part.id)
@@ -860,31 +445,13 @@ export function createServerSession(client: OpencodeClient, options?: { retry?:
         return
       }
       case "message.part.delta": {
-        const props = event.properties as {
-          sessionID: string
-          messageID: string
-          partID: string
-          field: string
-          delta: string
-        }
+        const props = event.properties as { messageID: string; partID: string; field: string; delta: string }
         const parts = data.part[props.messageID]
         if (!parts) return
         const result = Binary.search(parts, props.partID, (part) => part.id)
         if (!result.found) return
-        trackPartChange(props.sessionID, props.messageID, props.partID)
-        const load = messageLoads.get(props.sessionID)
-        if (load) {
-          const parts = load.deltaParts.get(props.messageID) ?? new Set<string>()
-          parts.add(props.partID)
-          load.deltaParts.set(props.messageID, parts)
-          const carried = load.carriedDeltaParts.get(props.messageID)
-          carried?.delete(props.partID)
-          if (carried?.size === 0) load.carriedDeltaParts.delete(props.messageID)
-        }
         const field = props.field as keyof (typeof parts)[number]
         const current = parts[result.index]?.[field]
-        if (!deltaBases.has(props.partID) && typeof current === "string")
-          deltaBases.set(props.partID, { base: current, sessionID: props.sessionID })
         setData(
           "part_text_accum_delta",
           props.partID,
@@ -992,70 +559,32 @@ export function createServerSession(client: OpencodeClient, options?: { retry?:
     },
     optimistic: {
       add(input: { sessionID: string; message: Message; parts: Part[] }) {
-        const parts = input.parts
-          .filter((part) => !!part?.id && !SKIP_PARTS.has(part.type))
-          .sort((a, b) => cmp(a.id, b.id))
-        const load = messageLoads.get(input.sessionID)
-        if (load?.clearedMessageParts.has(input.message.id)) {
-          const touched = load.touchedParts.get(input.message.id) ?? new Set<string>()
-          parts.forEach((part) => touched.add(part.id))
-          load.touchedParts.set(input.message.id, touched)
-        }
-        if (load) {
-          load.removedMessages.delete(input.message.id)
-          load.optimisticParts.set(input.message.id, new Set(parts.map((part) => part.id)))
-        }
         const items = optimistic.get(input.sessionID)
-        const removedMessagesForSession = removedMessages.get(input.sessionID)
-        removedMessagesForSession?.delete(input.message.id)
-        if (removedMessagesForSession?.size === 0) removedMessages.delete(input.sessionID)
-        if (items) items.set(input.message.id, { ...input, parts, confirmedParts: [] })
-        if (!items)
-          optimistic.set(input.sessionID, new Map([[input.message.id, { ...input, parts, confirmedParts: [] }]]))
+        if (items) items.set(input.message.id, input)
+        if (!items) optimistic.set(input.sessionID, new Map([[input.message.id, input]]))
         setData("message", input.sessionID, (messages = []) => merge(messages, [input.message]))
         setData(
-          "part_text_accum_delta",
-          produce((draft) => {
-            for (const part of [...(data.part[input.message.id] ?? []), ...parts]) {
-              delete draft[part.id]
-              deltaBases.delete(part.id)
-            }
-          }),
+          "part",
+          input.message.id,
+          input.parts.filter((part) => !!part?.id).sort((a, b) => cmp(a.id, b.id)),
         )
-        setData("part", input.message.id, parts)
       },
       remove(input: { sessionID: string; messageID: string }) {
-        const item = optimistic.get(input.sessionID)?.get(input.messageID)
-        if (!item) return
-        messageLoads.get(input.sessionID)?.optimisticParts.delete(input.messageID)
         clearOptimistic(input.sessionID, input.messageID)
-        if (item.confirmedMessage) {
-          const partIDs = new Set(item.parts.map((part) => part.id))
-          setData(
-            produce((draft) => {
-              for (const part of item.parts) {
-                delete draft.part_text_accum_delta[part.id]
-                deltaBases.delete(part.id)
-              }
-              const parts = draft.part[input.messageID]
-              if (!parts) return
-              draft.part[input.messageID] = parts.filter((part) => !partIDs.has(part.id))
-              if (draft.part[input.messageID]?.length === 0) delete draft.part[input.messageID]
-            }),
-          )
-          return
-        }
         setData("message", input.sessionID, (messages) => messages?.filter((message) => message.id !== input.messageID))
-        setData(produce((draft) => deleteMessageParts(draft, input.messageID)))
+        setData(
+          "part",
+          produce((draft) => void delete draft[input.messageID]),
+        )
       },
     },
     diff(sessionID: string, options?: { force?: boolean }) {
       touch(sessionID)
       if (data.session_diff[sessionID] !== undefined && !options?.force) return Promise.resolve()
       return runInflight(inflightDiff, sessionID, () => {
-        const active = generation(sessionID)
+        const generation = generations.get(sessionID) ?? 0
         return retry(() => client.session.diff({ sessionID })).then((result) => {
-          if (generations.get(sessionID) !== active) return
+          if ((generations.get(sessionID) ?? 0) !== generation) return
           setData("session_diff", sessionID, reconcile(cleanDiffs(result.data), { key: "file" }))
         })
       })
@@ -1064,9 +593,9 @@ export function createServerSession(client: OpencodeClient, options?: { retry?:
       touch(sessionID)
       if (data.todo[sessionID] !== undefined && !options?.force) return Promise.resolve()
       return runInflight(inflightTodo, sessionID, () => {
-        const active = generation(sessionID)
+        const generation = generations.get(sessionID) ?? 0
         return retry(() => client.session.todo({ sessionID })).then((result) => {
-          if (generations.get(sessionID) !== active) return
+          if ((generations.get(sessionID) ?? 0) !== generation) return
           setData("todo", sessionID, reconcile(result.data ?? [], { key: "id" }))
         })
       })

packages/app/src/context/tabs.tsx

@@ -163,14 +163,12 @@ export const { use: useTabs, provider: TabsProvider } = createSimpleContext({
       },
       newDraft(draft: Omit<DraftTab, "type" | "draftID">, prompt?: string) {
         const draftID = uuid()
-        void startTransition(() => {
-          setStore(
-            produce((tabs) => {
-              tabs.push({ type: "draft", draftID, ...draft })
-            }),
-          )
-          navigate(prompt ? `${draftHref(draftID)}&prompt=${encodeURIComponent(prompt)}` : draftHref(draftID))
-        })
+        setStore(
+          produce((tabs) => {
+            tabs.push({ type: "draft", draftID, ...draft })
+          }),
+        )
+        navigate(prompt ? `${draftHref(draftID)}&prompt=${encodeURIComponent(prompt)}` : draftHref(draftID))
       },
       updateDraft(draftID: string, draft: Partial<Omit<DraftTab, "type" | "draftID">>) {
         setStore(
@@ -179,11 +177,13 @@ export const { use: useTabs, provider: TabsProvider } = createSimpleContext({
         )
       },
       promoteDraft(draftID: string, session: Omit<SessionTab, "type">) {
-        // Keep the replacement and navigation atomic so /new-session never renders
-        // after its backing draft tab has been removed from the store.
+        // We're viewing this draft when /new-session?draftId=… points at it. Promoting
+        // replaces the draft tab with a session tab, so the draft route would stop resolving
+        // and fall back home. Navigate to the new session first so we leave /new-session
+        // before the draft is removed from the store.
         const active = location.pathname === "/new-session" && location.query.draftId === draftID
         const next = { type: "session" as const, ...session }
-        void startTransition(() => {
+        startTransition(() => {
           setStore(
             produce((tabs) => {
               const index = tabs.findIndex((tab) => tab.type === "draft" && tab.draftID === draftID)

packages/app/src/pages/home.tsx

@@ -408,7 +408,7 @@ export function NewHome() {
 
   return (
     <div class="rounded-[10px] shadow-[var(--v2-elevation-raised)] m-2 min-h-0 lg:overflow-hidden bg-v2-background-bg-base self-stretch flex-1">
-      <div class="mx-auto grid h-full w-full max-w-[1080px] grid-rows-[auto_minmax(0,1fr)_auto] gap-4 px-3 lg:grid-cols-[280px_minmax(0,720px)] lg:grid-rows-1 lg:gap-8 lg:px-6">
+      <div class="mx-auto grid h-full w-full max-w-[1080px] grid-rows-[auto_minmax(0,1fr)_auto] gap-4 px-3 pb-3 lg:grid-cols-[280px_minmax(0,720px)] lg:grid-rows-1 lg:gap-8 lg:px-6 lg:pb-16">
         <HomeProjectColumn
           projects={projects()}
           selected={selection()}
@@ -455,7 +455,7 @@ export function NewHome() {
             onClose={closeSearch}
             onSelect={selectSearchSession}
           />
-          <ScrollView class="mt-3 -mr-3 min-h-0 flex-1">
+          <ScrollView class="mt-3 min-h-0 flex-1">
             <Show
               when={!sessionLoad.isLoading}
               fallback={
@@ -468,7 +468,7 @@ export function NewHome() {
                 when={groups().length > 0}
                 fallback={<HomeSessionsEmpty onNewSession={newSessionProject() ? openNewSession : undefined} />}
               >
-                <div class="flex flex-col gap-6 pt-3 pr-3 pb-16">
+                <div class="pt-3 flex flex-col gap-6">
                   <For each={groups()}>
                     {(group, index) => (
                       <div class="flex min-w-0 flex-col gap-4">
@@ -965,7 +965,7 @@ function HomeSessionSearch(props: {
             style={{
               top: "-6px",
               left: "-6px",
-              width: "calc(100% + 12px)",
+              width: "calc(100% + 14px)",
             }}
           >
             <div class="flex flex-col pt-9">
@@ -1133,7 +1133,7 @@ function HomeSessionSearchResultRow(props: {
 function HomeSessionGroupHeader(props: { title: string; onNewSession?: () => void }) {
   const language = useLanguage()
   return (
-    <div class="flex h-7 min-w-0 items-center justify-between pl-3">
+    <div class="flex h-7 min-w-0 items-center justify-between pl-[18px]">
       <div class={HOME_SECTION_LABEL}>{props.title}</div>
       <Show when={props.onNewSession}>
         {(onNewSession) => (

packages/app/src/pages/layout-new.tsx

@@ -36,7 +36,7 @@ export default function NewLayout(props: ParentProps) {
       <main class="flex-1 min-h-0 min-w-0 overflow-x-hidden flex flex-col items-start contain-strict">
         <Suspense>{props.children}</Suspense>
       </main>
-      {import.meta.env.DEV && <DebugBar inline />}
+      {import.meta.env.DEV && <DebugBar />}
       <HelpButton />
       <ToastRegion v2 />
     </div>

packages/client/src/generated/types.ts

@@ -512,7 +512,6 @@ export type SessionsContextOutput = {
               readonly id: string
               readonly text: string
               readonly providerMetadata?: { readonly [x: string]: { readonly [x: string]: JsonValue } }
-              readonly time?: { readonly created: number; readonly completed?: number }
             }
           | {
               readonly type: "tool"
@@ -1590,7 +1589,6 @@ export type SessionsMessageOutput = {
               readonly id: string
               readonly text: string
               readonly providerMetadata?: { readonly [x: string]: { readonly [x: string]: JsonValue } }
-              readonly time?: { readonly created: number; readonly completed?: number }
             }
           | {
               readonly type: "tool"

packages/core/package.json

@@ -16,8 +16,6 @@
     "opencode": "./bin/opencode"
   },
   "exports": {
-    "./effect/layer-node": "./src/effect/layer-node.ts",
-    "./effect/app-node": "./src/effect/app-node.ts",
     "./session/runner": "./src/session/runner/index.ts",
     "./system-context": "./src/system-context/index.ts",
     "./*": "./src/*.ts"
@@ -104,7 +102,6 @@
     "ai-gateway-provider": "3.1.2",
     "bun-pty": "0.4.8",
     "cross-spawn": "catalog:",
-    "diff": "catalog:",
     "drizzle-orm": "catalog:",
     "effect": "catalog:",
     "fuzzysort": "3.1.0",

packages/core/src/agent.ts

@@ -1,6 +1,5 @@
 export * as AgentV2 from "./agent"
 
-import { makeLocationNode } from "./effect/app-node"
 import { Array, Context, Effect, Layer, Types } from "effect"
 import { Agent } from "@opencode-ai/schema/agent"
 import { State } from "./state"
@@ -107,5 +106,3 @@ export const layer = Layer.effect(
 )
 
 export const locationLayer = layer
-
-export const node = makeLocationNode({ service: Service, layer, deps: [] })

packages/core/src/aisdk.ts

@@ -1,6 +1,5 @@
 export * as AISDK from "./aisdk"
 
-import { makeLocationNode } from "./effect/app-node"
 import type { LanguageModelV3 } from "@ai-sdk/provider"
 import { Cause, Context, Effect, Layer, Schema, Scope } from "effect"
 import { ModelV2 } from "./model"
@@ -232,6 +231,4 @@ export const locationLayer = Layer.effect(
   }),
 )
 
-export const node = makeLocationNode({ service: Service, layer: locationLayer, deps: [] })
-
 export const defaultLayer = locationLayer

packages/core/src/background-job.ts

@@ -2,7 +2,6 @@ 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/app-node"
 
 export type Status = "running" | "completed" | "error" | "cancelled"
 
@@ -363,5 +362,3 @@ 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: [] })

packages/core/src/catalog.ts

@@ -1,6 +1,5 @@
 export * as Catalog from "./catalog"
 
-import { makeLocationNode } from "./effect/app-node"
 import { Array, Context, Effect, Layer, Option, Order, pipe, Schema } from "effect"
 import { Catalog } from "@opencode-ai/schema/catalog"
 import { ModelV2 } from "./model"
@@ -297,5 +296,3 @@ 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] })

packages/core/src/command.ts

@@ -1,6 +1,5 @@
 export * as CommandV2 from "./command"
 
-import { makeLocationNode } from "./effect/app-node"
 import { Context, Effect, Layer, Types } from "effect"
 import { Command } from "@opencode-ai/schema/command"
 import { State } from "./state"
@@ -60,5 +59,3 @@ export const layer = Layer.effect(
 )
 
 export const locationLayer = layer
-
-export const node = makeLocationNode({ service: Service, layer, deps: [] })

packages/core/src/config.ts

@@ -1,6 +1,5 @@
 export * as Config from "./config"
 
-import { makeLocationNode } from "./effect/app-node"
 import path from "path"
 import { type ParseError, parse } from "jsonc-parser"
 import { Context, Effect, Layer, Option, Schema } from "effect"
@@ -219,9 +218,3 @@ 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],
-})

packages/core/src/credential.ts

@@ -5,7 +5,6 @@ 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/app-node"
 import { CredentialTable } from "./credential/sql"
 
 export const ID = Credential.ID
@@ -136,5 +135,3 @@ export const layer = Layer.effect(
 )
 
 export const defaultLayer = layer.pipe(Layer.provide(Database.defaultLayer))
-
-export const node = makeGlobalNode({ service: Service, layer, deps: [Database.node] })

packages/core/src/cross-spawn-spawner.ts

@@ -24,8 +24,8 @@ import {
 import * as NodeChildProcess from "node:child_process"
 import { PassThrough } from "node:stream"
 import launch from "cross-spawn"
-import { makeGlobalNode } from "./effect/app-node"
-import { filesystem, path } from "./effect/app-node-platform"
+import { LayerNode } from "./effect/layer-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 = makeGlobalNode({ service: ChildProcessSpawner, layer, deps: [filesystem, path] })
+export const node = LayerNode.make({ service: ChildProcessSpawner, layer, deps: [filesystem, path] })
 
 export * as CrossSpawnSpawner from "./cross-spawn-spawner"

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 { makeGlobalNode } from "../effect/app-node"
+import { LayerNode } from "../effect/layer-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 = makeGlobalNode({ service: Service, layer: layerFromPath(path()), deps: [] })
+export const node = LayerNode.make({ service: Service, layer: layerFromPath(path()), deps: [] })

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

@@ -1,24 +0,0 @@
-import { Layer } from "effect"
-import { buildLocationServiceMap } from "../location-services"
-import { LocationServiceMap } from "../location-service-map"
-import { LayerNode } from "./layer-node"
-import { makeGlobalNode } from "./app-node"
-
-export function build<A, E>(root: LayerNode.Node<A, E, any>, replacements?: readonly LayerNode.Replacement[]) {
-  const replacementMap = new Map(replacements?.map((item) => [item.source, item.replacement]))
-
-  if (!LayerNode.hasUnbound(root, LocationServiceMap.node)) {
-    // If the location service map is not needed, we shouldn't pull it
-    // in. Compile the graph normally
-    return LayerNode.compile(root, replacementMap)
-  }
-
-  const locationMap = buildLocationServiceMap(replacementMap)
-  const locationMapNode = makeGlobalNode({ service: LocationServiceMap.Service, layer: locationMap, deps: [] })
-
-  const app = LayerNode.bind(root, LocationServiceMap.node, locationMapNode)
-
-  return LayerNode.compile(app, replacementMap)
-}
-
-export * as AppNodeBuilder from "./app-node-builder"

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

@@ -1,14 +0,0 @@
-import { LayerNode } from "./layer-node"
-
-export const tags = LayerNode.tags({
-  location: ["global"],
-  global: [],
-})
-
-export type GlobalNode<A, E = never> = LayerNode.Node<A, E, (typeof tags.values)["global"]>
-export type LocationNode<A, E = never> = LayerNode.Node<A, E, (typeof tags.values)["location"]>
-
-export const makeGlobalNode = tags.make("global")
-export const makeLocationNode = tags.make("location")
-
-export * as Node from "./app-node"

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 { makeGlobalNode } from "./app-node"
+import { LayerNode } from "./layer-node"
 
-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({
+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({
   service: RequestExecutor.Service,
   layer: RequestExecutor.layer,
   deps: [httpClient],
 })
-export const llmClient = makeGlobalNode({ service: LLMClient.Service, layer: LLMClient.layer, deps: [requestExecutor] })
+export const llmClient = LayerNode.make({ service: LLMClient.Service, layer: LLMClient.layer, deps: [requestExecutor] })
 
-export * as LayerNodePlatform from "./app-node-platform"
+export * as LayerNodePlatform from "./layer-node-platform"

packages/core/src/effect/layer-node.ts

@@ -1,11 +1,10 @@
 import { Brand, Context, Layer } from "effect"
 
-type AnyNode = Node<unknown, unknown, any>
 type RuntimeLayer = Layer.Layer<never, unknown, unknown>
+type AnyNode = Node<unknown, unknown, any>
 type NodeList<Item extends AnyNode = AnyNode> = readonly [] | readonly [Item, ...Item[]]
-export type Output<Item> = [Item] extends [never] ? never : Item extends Node<infer A, unknown, any> ? A : never
-export type Error<Item> = [Item] extends [never] ? never : Item extends Node<unknown, infer E, any> ? E : never
-type NodeTag<Item> = [Item] extends [never] ? undefined : Item extends Node<unknown, unknown, infer T> ? T : never
+type Output<Item> = [Item] extends [never] ? never : Item extends Node<infer A, unknown, any> ? A : never
+type Error<Item> = [Item] extends [never] ? never : Item extends Node<unknown, infer E, any> ? E : never
 type Missing<Required, Dependencies extends NodeList> = Exclude<Required, Output<Dependencies[number]>>
 type CheckDependencies<Implementation extends Layer.Any, Dependencies extends NodeList> = [
   Missing<Layer.Services<Implementation>, Dependencies>,
@@ -15,17 +14,17 @@ type CheckDependencies<Implementation extends Layer.Any, Dependencies extends No
 declare const $OutputType: unique symbol
 declare const $ErrorType: unique symbol
 
-export type Tag<Name extends string = string> = Name & Brand.Brand<"LayerNode.Tag">
+export type Tier<Name extends string = string> = Name & Brand.Brand<"LayerNode.Tier">
 
-const makeTag = Brand.nominal<Tag>()
+const makeTier = Brand.nominal<Tier>()
 
-export interface Node<A, E = never, T extends Tag | undefined = undefined> {
-  readonly kind: "layer" | "unbound" | "group"
+export type Node<A, E = never, T extends Tier | undefined = undefined> = {
+  readonly kind: "layer" | "group"
   readonly name: string
   readonly service?: Context.Service.Any
   readonly implementation?: Layer.Any
   readonly dependencies: readonly AnyNode[]
-  readonly tag?: T
+  readonly tier?: T
   readonly [$OutputType]?: () => A
   readonly [$ErrorType]?: () => E
 }
@@ -35,55 +34,22 @@ type NodeIdentity =
   | { readonly name: string; readonly service?: never }
 type DistributiveOmit<A, K extends PropertyKey> = A extends unknown ? Omit<A, K> : never
 
-export type TagConfig = Readonly<Record<string, readonly string[]>>
-type TagNames<Config extends TagConfig> = keyof Config & string
-type NodeInTags<Names extends string> = Node<unknown, unknown, Tag<Names> | undefined>
-type CheckTags<Items extends NodeList, Names extends string> = [Exclude<Items[number], NodeInTags<Names>>] extends [
-  never,
-]
-  ? unknown
-  : { readonly "Invalid tag dependencies": Exclude<Items[number], NodeInTags<Names>> }
-
-export interface Tags<Config extends TagConfig> {
-  readonly values: { readonly [Name in TagNames<Config>]: Tag<Name> }
-  readonly make: <Name extends TagNames<Config>>(
-    name: Name,
-  ) => <const Implementation extends Layer.Any, const Items extends NodeList>(
-    input: DistributiveOmit<MakeInput<Implementation, Items, Tag<Name>>, "tag"> &
-      CheckTags<Items, Name | Extract<Config[Name][number], string>>,
-  ) => Node<Layer.Success<Implementation>, Layer.Error<Implementation> | Error<Items[number]>, Tag<Name>>
-}
-
-export function tags<const Config extends { readonly [Name in keyof Config]: readonly (keyof Config & string)[] }>(
-  config: Config,
-): Tags<Config> {
-  const names = Object.keys(config) as TagNames<Config>[]
-  const values = Object.fromEntries(names.map((name) => [name, makeTag(name)])) as Tags<Config>["values"]
-  return {
-    values,
-    make: ((name: TagNames<Config>) => (input: DistributiveOmit<MakeInput<Layer.Any, NodeList, Tag>, "tag">) =>
-      make({ ...input, tag: values[name] })) as Tags<Config>["make"],
-  }
-}
-
-// Nodes ---------------------------------------------------------------------
-
-type MakeInput<
+type NodeInput<
   Implementation extends Layer.Any,
   Items extends NodeList,
-  T extends Tag | undefined = undefined,
+  T extends Tier | undefined = undefined,
 > = NodeIdentity & {
   readonly layer: Implementation
   readonly deps: Items & CheckDependencies<Implementation, NoInfer<Items>>
-  readonly tag?: T
+  readonly tier?: T
 }
 
 export function make<
   const Implementation extends Layer.Any,
   const Items extends NodeList,
-  const T extends Tag | undefined = undefined,
+  const T extends Tier | undefined = undefined,
 >(
-  input: MakeInput<Implementation, Items, T>,
+  input: NodeInput<Implementation, Items, T>,
 ): Node<Layer.Success<Implementation>, Layer.Error<Implementation> | Error<Items[number]>, T> {
   return {
     kind: "layer",
@@ -91,26 +57,53 @@ export function make<
     service: input.service,
     implementation: input.layer,
     dependencies: input.deps,
-    tag: input.tag,
+    tier: input.tier,
   }
 }
 
-export function unbound<R, Shape, const T extends Tag>(service: Context.Key<R, Shape>, tag: T): Node<R, never, T> {
-  return {
-    kind: "unbound",
-    name: service.key,
-    service,
-    dependencies: [],
-    tag,
-  }
-}
-
-export function group<const Items extends readonly AnyNode[]>(
+export function group<const Items extends NodeList>(
   dependencies: Items,
-): Node<Output<Items[number]>, Error<Items[number]>, NodeTag<Items[number]>> {
+): Node<Output<Items[number]>, Error<Items[number]>> {
   return { kind: "group", name: "group", dependencies }
 }
 
+type AllowedTierNames<Names extends readonly string[], Name extends Names[number]> = Names extends readonly [
+  infer Head extends string,
+  ...infer Tail extends readonly string[],
+]
+  ? Head extends Name
+    ? Head | Tail[number]
+    : AllowedTierNames<Tail, Name>
+  : never
+
+type NodeInTiers<Names extends string> = Node<unknown, unknown, Tier<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>>
+}
+
+export function tiers<const Names extends readonly [string, ...string[]]>(names: Names): Tiers<Names> {
+  const values = Object.fromEntries(names.map((name) => [name, makeTier(name)])) as Tiers<Names>["values"]
+  return {
+    names,
+    values,
+    make: ((name: Names[number]) => (input: DistributiveOmit<NodeInput<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
@@ -127,147 +120,129 @@ export function replace<A, E, R, E2>(
   return { source, replacement }
 }
 
-// Tree -----------------------------------------------------------------------
-
-type Visit<Result> = (node: AnyNode, context: VisitContext<Result>) => Result
-
-type VisitContext<Result> = {
-  readonly cache: Map<AnyNode, Result>
-  readonly visit: (node: AnyNode) => Result
+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
 }
 
-function walk<Result>(
+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,
-  visit: Visit<Result>,
-  options: {
-    readonly cache?: Map<AnyNode, Result>
-    readonly resolve?: (node: AnyNode) => AnyNode
-    readonly detectCycles?: boolean
-  } = {},
+  tiers: Tiers<readonly [string, ...string[]]>,
+  replacements: ReadonlyMap<Layer.Any, Layer.Any>,
 ) {
-  const cache = options.cache ?? new Map<AnyNode, Result>()
+  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 recur = (node: AnyNode): Result => {
-    const target = options.resolve?.(node) ?? node
-    const cached = cache.get(target)
-    if (cached !== undefined || cache.has(target)) return cached!
+  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
+  }
 
-    if (options.detectCycles !== false && visiting.has(target)) {
-      const start = stack.indexOf(target)
+  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 tree: ${[...stack.slice(start), target].map((item) => item.name).join(" -> ")}`,
+        `Cycle detected in layer graph: ${[...stack.slice(start), node].map((item) => item.name).join(" -> ")}`,
       )
     }
 
-    visiting.add(target)
-    stack.push(target)
+    visiting.add(node)
+    stack.push(node)
     try {
-      const result = visit(target, { cache, visit: recur })
-      if (!cache.has(target)) cache.set(target, result)
-      return result
+      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(target)
+      visiting.delete(node)
     }
   }
 
-  return recur(root)
+  visit(root)
+  return plans
 }
 
-export function hoist<A, E, T extends Tag>(
-  root: Node<A, E, any>,
-  tag: T,
-): {
-  readonly node: Node<A, E>
-  readonly hoisted: Node<unknown, E>
-} {
-  const hoisted = new Map<string, AnyNode>()
-
-  const node = walk<AnyNode>(root, (node, context) => {
-    if (node.kind === "group") {
-      return { ...node, dependencies: node.dependencies.map(context.visit) }
-    }
-    if (node.tag === tag) {
-      const existing = hoisted.get(node.name)
-      if (existing && existing !== node) {
-        throw new Error(`Tag ${tag} has conflicting implementations for ${node.name}`)
-      }
-      hoisted.set(node.name, node)
-      return group([])
-    }
-    if (node.kind === "unbound") {
-      return node
-    }
-    return { ...node, dependencies: node.dependencies.map(context.visit) }
-  })
-
-  return {
-    node: node as Node<A, E>,
-    hoisted: group(Array.from(hoisted.values())) as Node<unknown, E>,
-  }
-}
-
-export function compile<A, E>(
-  root: Node<A, E, any>,
-  replacements?: ReadonlyMap<Layer.Any, Layer.Any>,
-): Layer.Layer<A, E> {
-  const cache = new Map<AnyNode, RuntimeLayer>()
-  const compileNode = (node: AnyNode) =>
-    walk<RuntimeLayer>(
-      node,
-      (node, context) => {
-        if (node.kind === "unbound") throw new Error(`Unbound layer node: ${node.name}`)
-        const dependencies = node.dependencies.flatMap(flatten).map(context.visit)
-        const implementation = (replacements?.get(node.implementation!) ?? node.implementation!) as RuntimeLayer
-        return dependencies.length === 0
-          ? implementation
-          : implementation.pipe(Layer.provide(dependencies as [RuntimeLayer, ...RuntimeLayer[]]))
-      },
-      { cache },
-    )
-  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<A, E>
-}
-
-export function hasUnbound(root: Node<unknown, unknown, any>, source: AnyNode): boolean {
-  if (source.kind !== "unbound") throw new Error(`Cannot check non-unbound layer node: ${source.name}`)
-  return walk<boolean>(root, (node, context) => {
-    if (node === source) return true
-    return node.dependencies.some(context.visit)
-  })
-}
-
-export function bind<A, E, T extends Tag | undefined>(
-  root: Node<A, E, T>,
-  source: AnyNode,
-  replacement: AnyNode,
-): 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.tag !== replacement.tag) {
-    throw new Error(`Cannot bind ${source.name} across tags`)
-  }
-  return walk<AnyNode>(
-    root,
-    (target, context) => {
-      if (target.kind === "unbound") return target
-      const dependencies: AnyNode[] = []
-      const clone = { ...target, dependencies }
-      context.cache.set(target, clone)
-      dependencies.push(...target.dependencies.map(context.visit))
-      return clone
-    },
-    { detectCycles: false, resolve: (node) => (node === source ? replacement : node) },
-  ) as Node<A, E, T>
-}
-
-function flatten(node: AnyNode): readonly AnyNode[] {
-  return node.kind === "group" ? node.dependencies.flatMap(flatten) : [node]
+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"

packages/core/src/effect/scoped-node.ts

@@ -0,0 +1,11 @@
+import { LayerNode } from "./layer-node"
+
+export const tiers = LayerNode.tiers(["location", "global"])
+
+export type GlobalNode<A, E = never> = LayerNode.Node<A, E, (typeof tiers.values)["global"]>
+export type LocationNode<A, E = never> = LayerNode.Node<A, E, (typeof tiers.values)["location"]>
+
+export const makeGlobalNode = tiers.make("global")
+export const makeLocationNode = tiers.make("location")
+
+export * as ScopedNode from "./scoped-node"

packages/core/src/event.ts

@@ -7,7 +7,7 @@ import { and, asc, eq, gt, inArray } from "drizzle-orm"
 import { Database } from "./database/database"
 import { EventSequenceTable, EventTable } from "./event/sql"
 import { Location } from "./location"
-import { makeGlobalNode } from "./effect/app-node"
+import { LayerNode } from "./effect/layer-node"
 import { isDeepStrictEqual } from "node:util"
 import { Durable } from "@opencode-ai/schema/durable-event-manifest"
 
@@ -635,6 +635,6 @@ export const layerWith = (options?: LayerOptions) =>
   )
 
 export const layer = layerWith()
-export const node = makeGlobalNode({ service: Service, layer: layer, deps: [Database.node] })
+export const node = LayerNode.make({ service: Service, layer: layer, deps: [Database.node] })
 
 export const defaultLayer = layer.pipe(Layer.provide(Database.defaultLayer))

packages/core/src/file-mutation.ts

@@ -1,6 +1,5 @@
 export * as FileMutation from "./file-mutation"
 
-import { makeLocationNode } from "./effect/app-node"
 import { Context, Effect, Layer, Schema } from "effect"
 import { dirname } from "path"
 import { KeyedMutex } from "./effect/keyed-mutex"
@@ -193,8 +192,6 @@ 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.
  */

packages/core/src/filesystem.ts

@@ -1,6 +1,5 @@
 export * as FileSystem from "./filesystem"
 
-import { makeLocationNode } from "./effect/app-node"
 import path from "path"
 import { Context, Effect, Layer, Schema } from "effect"
 import { FSUtil } from "./fs-util"
@@ -114,9 +113,3 @@ 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],
-})

packages/core/src/filesystem/search.ts

@@ -1,6 +1,5 @@
 export * as FileSystemSearch from "./search"
 
-import { makeLocationNode } from "../effect/app-node"
 import path from "path"
 import { Context, Effect, Layer, Scope } from "effect"
 import { Fff } from "#fff"
@@ -230,8 +229,6 @@ export const fffLayer = Layer.effect(
   }),
 )
 
-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] })
+export const locationLayer = Layer.unwrap(
+  Effect.sync(() => (Flag.OPENCODE_DISABLE_FFF || !Fff.available() ? ripgrepLayer : fffLayer)),
+)

packages/core/src/filesystem/watcher.ts

@@ -3,7 +3,6 @@ export * as Watcher from "./watcher"
 // @ts-ignore
 import { createWrapper } from "@parcel/watcher/wrapper"
 import type ParcelWatcher from "@parcel/watcher"
-import { makeLocationNode } from "../effect/app-node"
 import { Cause, Context, Effect, Layer } from "effect"
 import { FileSystemWatcher } from "@opencode-ai/schema/filesystem-watcher"
 import path from "path"
@@ -134,9 +133,3 @@ 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],
-})

packages/core/src/fs-util.ts

@@ -7,8 +7,8 @@ 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 { makeGlobalNode } from "./effect/app-node"
-import { filesystem } from "./effect/app-node-platform"
+import { LayerNode } from "./effect/layer-node"
+import { filesystem } from "./effect/layer-node-platform"
 
 export namespace FSUtil {
   export class FileSystemError extends Schema.TaggedErrorClass<FileSystemError>()("FileSystemError", {
@@ -201,7 +201,7 @@ export namespace FSUtil {
   )
 
   export const defaultLayer = layer.pipe(Layer.provide(NodeFileSystem.layer))
-  export const node = makeGlobalNode({ service: Service, layer: layer, deps: [filesystem] })
+  export const node = LayerNode.make({ service: Service, layer: layer, deps: [filesystem] })
 
   // Pure helpers that don't need Effect (path manipulation, sync operations)
   export function mimeType(p: string): string {

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 { makeGlobalNode } from "./effect/app-node"
+import { LayerNode } from "./effect/layer-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 = makeGlobalNode({ service: Service, layer: layer, deps: [FSUtil.node, AppProcess.node] })
+export const node = LayerNode.make({ service: Service, layer: layer, deps: [FSUtil.node, AppProcess.node] })
 
 interface Result {
   readonly exitCode: number

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 { makeGlobalNode } from "./effect/app-node"
+import { LayerNode } from "./effect/layer-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 = makeGlobalNode({ service: Service, layer: layer, deps: [] })
+export const node = LayerNode.make({ service: Service, layer: layer, deps: [] })
 
 export const layerWith = (input: Partial<Interface>) =>
   Layer.effect(

packages/core/src/image.ts

@@ -1,6 +1,5 @@
 export * as Image from "./image"
 
-import { makeLocationNode } from "./effect/app-node"
 import { Context, Effect, Layer, Schema } from "effect"
 import { Config } from "./config"
 import { FileSystem } from "./filesystem"
@@ -77,5 +76,3 @@ export const layer = Layer.effect(
 )
 
 export const locationLayer = layer.pipe(Layer.provide(Config.locationLayer))
-
-export const node = makeLocationNode({ service: Service, layer, deps: [Config.node] })

packages/core/src/instruction-context.ts

@@ -9,7 +9,6 @@ import { Location } from "./location"
 import { AbsolutePath } from "./schema"
 import { SystemContext } from "./system-context/index"
 import { SystemContextRegistry } from "./system-context/registry"
-import { makeLocationNode } from "./effect/app-node"
 
 class File extends Schema.Class<File>("InstructionContext.File")({
   path: AbsolutePath,
@@ -88,12 +87,6 @@ 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")
 }

packages/core/src/integration.ts

@@ -1,6 +1,5 @@
 export * as Integration from "./integration"
 
-import { makeLocationNode } from "./effect/app-node"
 import {
   Cause,
   Clock,
@@ -516,5 +515,3 @@ export const locationLayer = Layer.effect(
     })
   }),
 )
-
-export const node = makeLocationNode({ service: Service, layer: locationLayer, deps: [Credential.node, EventV2.node] })

packages/core/src/location-layer.ts

@@ -0,0 +1,151 @@
+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 { FileMutation } from "./file-mutation"
+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 { Snapshot } from "./snapshot"
+
+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),
+    )
+
+    // 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))
+
+    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,
+  ],
+}) {}

packages/core/src/location-mutation.ts

@@ -1,6 +1,5 @@
 export * as LocationMutation from "./location-mutation"
 
-import { makeLocationNode } from "./effect/app-node"
 import path from "path"
 import { Context, Effect, Layer, Schema } from "effect"
 import { FSUtil } from "./fs-util"
@@ -154,9 +153,3 @@ 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],
-})

packages/core/src/location-service-map.ts

@@ -1,18 +0,0 @@
-import { Context, Effect, Layer, LayerMap } from "effect"
-import { LayerNode } from "./effect/layer-node"
-import { Node } from "./effect/app-node"
-import { Location } from "./location"
-import type { LocationError, LocationServices } from "./location-services"
-
-export class Service extends Context.Service<
-  Service,
-  LayerMap.LayerMap<Location.Ref, LocationServices, LocationError>
->()("@opencode/example/LocationServiceMap") {
-  static get(ref: Location.Ref) {
-    return Layer.unwrap(Effect.map(Service, (locations) => locations.get(ref)))
-  }
-}
-
-export const node = LayerNode.unbound(Service, Node.tags.values.global)
-
-export * as LocationServiceMap from "./location-service-map"

packages/core/src/location-services.ts

@@ -1,112 +0,0 @@
-import { Effect, Layer, LayerMap } from "effect"
-import { AgentV2 } from "./agent"
-import { AISDK } from "./aisdk"
-import { Catalog } from "./catalog"
-import { CommandV2 } from "./command"
-import { Config } from "./config"
-import { LayerNode } from "./effect/layer-node"
-import { Node } from "./effect/app-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 * as SessionRunnerLLM from "./session/runner/llm"
-import { SessionRunnerModel } from "./session/runner/model"
-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 { LocationServiceMap } from "./location-service-map"
-
-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,
-])
-
-export type LocationServices = LayerNode.Output<typeof locationServices>
-export type LocationError = LayerNode.Error<typeof locationServices>
-
-export function buildLocationServiceMap(
-  replacements?: ReadonlyMap<Layer.Any, Layer.Any>,
-): Layer.Layer<LocationServiceMap.Service> {
-  return Layer.effect(
-    LocationServiceMap.Service,
-    LayerMap.make(
-      (ref: Location.Ref) => {
-        const location = LayerNode.hoist(
-          LayerNode.bind(locationServices, Location.node, Location.boundNode(ref)),
-          Node.tags.values.global,
-        )
-        return LayerNode.compile(location.node, replacements).pipe(
-          Layer.fresh,
-          Layer.tap(() =>
-            Effect.logInfo("booting location services", {
-              directory: ref.directory,
-              workspaceID: ref.workspaceID,
-            }),
-          ),
-          Layer.provide(LayerNode.compile(location.hoisted, replacements)),
-        )
-      },
-      { idleTimeToLive: "60 minutes" },
-    ),
-  )
-}
-
-// This is temporary for backwards compatibility
-export const locationServiceMapLayer = buildLocationServiceMap()

packages/core/src/location.ts

@@ -1,8 +1,6 @@
 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, tags } from "./effect/app-node"
 
 export * as Location from "./location"
 
@@ -14,8 +12,6 @@ export interface Interface extends Info {
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/Location") {}
 
-export const node = LayerNode.unbound(Service, tags.values.location)
-
 export const layer = (ref: Ref) =>
   Layer.effect(
     Service,
@@ -30,10 +26,3 @@ export const layer = (ref: Ref) =>
       })
     }),
   )
-
-export const boundNode = (ref: Ref) =>
-  makeLocationNode({
-    service: Service,
-    layer: layer(ref),
-    deps: [Project.node],
-  })

packages/core/src/models-dev.ts

@@ -9,8 +9,8 @@ import { Hash } from "./util/hash"
 import { FSUtil } from "./fs-util"
 import { InstallationChannel, InstallationVersion } from "./installation/version"
 import { EventV2 } from "./event"
-import { makeGlobalNode } from "./effect/app-node"
-import { httpClient } from "./effect/app-node-platform"
+import { LayerNode } from "./effect/layer-node"
+import { httpClient } from "./effect/layer-node-platform"
 
 export const CatalogModelStatus = Schema.Literals(["alpha", "beta", "deprecated"])
 export type CatalogModelStatus = typeof CatalogModelStatus.Type
@@ -244,6 +244,6 @@ export const defaultLayer = layer.pipe(
   Layer.provide(FSUtil.defaultLayer),
   Layer.provide(EventV2.defaultLayer),
 )
-export const node = makeGlobalNode({ service: Service, layer: layer, deps: [FSUtil.node, EventV2.node, httpClient] })
+export const node = LayerNode.make({ service: Service, layer: layer, deps: [FSUtil.node, EventV2.node, httpClient] })
 
 export * as ModelsDev from "./models-dev"

packages/core/src/npm.ts

@@ -7,8 +7,8 @@ import { NodeFileSystem } from "@effect/platform-node"
 import { FSUtil } from "./fs-util"
 import { Global } from "./global"
 import { EffectFlock } from "./util/effect-flock"
-import { makeGlobalNode } from "./effect/app-node"
-import { filesystem } from "./effect/app-node-platform"
+import { LayerNode } from "./effect/layer-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 = makeGlobalNode({
+export const node = LayerNode.make({
   service: Service,
   layer: layer,
   deps: [FSUtil.node, Global.node, filesystem, EffectFlock.node],

packages/core/src/permission.ts

@@ -1,6 +1,5 @@
 export * as PermissionV2 from "./permission"
 
-import { makeLocationNode } from "./effect/app-node"
 import { Context, Deferred, Effect as EffectRuntime, Layer, Schema } from "effect"
 import { Permission } from "@opencode-ai/schema/permission"
 import { EventV2 } from "./event"
@@ -301,9 +300,3 @@ 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],
-})

packages/core/src/permission/saved.ts

@@ -3,7 +3,6 @@ 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/app-node"
 import { ProjectV2 } from "../project"
 import { PermissionTable } from "./sql"
 import { PermissionSaved } from "@opencode-ai/schema/permission-saved"
@@ -77,5 +76,3 @@ export const layer = Layer.effect(
 )
 
 export const defaultLayer = layer.pipe(Layer.provide(Database.defaultLayer))
-
-export const node = makeGlobalNode({ service: Service, layer, deps: [Database.node] })

packages/core/src/plugin.ts

@@ -1,6 +1,5 @@
 export * as PluginV2 from "./plugin"
 
-import { makeLocationNode } from "./effect/app-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"
@@ -151,18 +150,3 @@ 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,
-  ],
-})

packages/core/src/plugin/internal.ts

@@ -1,7 +1,5 @@
 export * as PluginInternal from "./internal"
 
-import { makeLocationNode } from "../effect/app-node"
-import { httpClient } from "../effect/app-node-platform"
 import type { PluginContext } from "@opencode-ai/plugin/v2/effect"
 import { Effect, Layer, Scope } from "effect"
 import { AgentV2 } from "../agent"
@@ -25,7 +23,6 @@ import { Npm } from "../npm"
 import { PluginV2 } from "../plugin"
 import { Reference } from "../reference"
 import { SkillV2 } from "../skill"
-import { State } from "../state"
 import { FetchHttpClient, HttpClient } from "effect/unstable/http"
 import { AgentPlugin } from "./agent"
 import { CommandPlugin } from "./command"
@@ -60,7 +57,7 @@ export function define<R>(plugin: Plugin<R>) {
   return plugin
 }
 
-const layer = Layer.effectDiscard(
+export const locationLayer = Layer.effectDiscard(
   Effect.gen(function* () {
     const catalog = yield* Catalog.Service
     const commands = yield* CommandV2.Service
@@ -105,51 +102,24 @@ const layer = Layer.effectDiscard(
       return plugin.add(PluginV2.ID.make(loaded.id), loaded.effect)
     }
 
-    yield* State.batch(
-      Effect.gen(function* () {
-        yield* add(ConfigReferencePlugin.Plugin)
-        yield* add(AgentPlugin.Plugin)
-        yield* add(CommandPlugin.Plugin)
-        yield* add(SkillPlugin.Plugin)
-        yield* add(ModelsDevPlugin)
-        yield* add(ConfigAgentPlugin.Plugin)
-        yield* add(ConfigCommandPlugin.Plugin)
-        yield* add(ConfigSkillPlugin.Plugin)
-        for (const item of ProviderPlugins) yield* add(item)
-        yield* add(ConfigExternalPlugin.Plugin)
-        yield* add(ConfigProviderPlugin.Plugin)
-        yield* add(VariantPlugin.Plugin)
-      }),
-    ).pipe(Effect.withSpan("PluginInternal.boot"), Effect.forkScoped({ startImmediately: true }))
+    yield* Effect.gen(function* () {
+      yield* add(ConfigReferencePlugin.Plugin)
+      yield* add(AgentPlugin.Plugin)
+      yield* add(CommandPlugin.Plugin)
+      yield* add(SkillPlugin.Plugin)
+      yield* add(ModelsDevPlugin)
+      yield* add(ConfigAgentPlugin.Plugin)
+      yield* add(ConfigCommandPlugin.Plugin)
+      yield* add(ConfigSkillPlugin.Plugin)
+      for (const item of ProviderPlugins) yield* add(item)
+      yield* add(ConfigExternalPlugin.Plugin)
+      yield* add(ConfigProviderPlugin.Plugin)
+      yield* add(VariantPlugin.Plugin)
+    }).pipe(Effect.withSpan("PluginInternal.boot"), Effect.forkScoped({ startImmediately: true }))
   }),
-)
-
-export const locationLayer = layer.pipe(
+).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,
-  ],
-})

packages/core/src/plugin/provider/opencode.ts

@@ -1,4 +1,4 @@
-import { Duration, Effect, Schema, Semaphore, Stream } from "effect"
+import { Duration, Effect, Schema, Stream } from "effect"
 import type { Scope } from "effect"
 import type { IntegrationOAuthMethodRegistration } from "@opencode-ai/plugin/v2/effect/integration"
 import { define } from "@opencode-ai/plugin/v2/effect/plugin"
@@ -79,7 +79,6 @@ export const OpencodePlugin = define<HttpClient.HttpClient | EventV2.Service | S
   effect: Effect.fn(function* (ctx) {
     const events = yield* EventV2.Service
     const http = yield* HttpClient.HttpClient
-    const loading = Semaphore.makeUnsafe(1)
     let connected = false
     let providers: typeof ConfigV1.Info.Type.provider | undefined
 
@@ -106,7 +105,7 @@ export const OpencodePlugin = define<HttpClient.HttpClient | EventV2.Service | S
       draft.method.update({ integrationID: "opencode", method: { type: "key", label: "API key (service account)" } })
     })
 
-    connected = (yield* ctx.integration.connection.active("opencode")) !== undefined
+    yield* load()
     yield* ctx.catalog.transform((catalog) => {
       for (const [providerID, item] of Object.entries(providers ?? {})) {
         catalog.provider.update(providerID, (provider) => {
@@ -177,13 +176,11 @@ export const OpencodePlugin = define<HttpClient.HttpClient | EventV2.Service | S
       }
     })
 
-    const refresh = () => loading.withPermit(load().pipe(Effect.andThen(ctx.catalog.reload())))
     yield* events.subscribe(Integration.Event.ConnectionUpdated).pipe(
       Stream.filter((event) => event.data.integrationID === Integration.ID.make("opencode")),
-      Stream.runForEach(refresh),
+      Stream.runForEach(() => load().pipe(Effect.andThen(ctx.catalog.reload()))),
       Effect.forkScoped({ startImmediately: true }),
     )
-    yield* refresh().pipe(Effect.forkScoped)
   }),
 })
 

packages/core/src/policy.ts

@@ -1,6 +1,5 @@
 export * as Policy from "./policy"
 
-import { makeLocationNode } from "./effect/app-node"
 import { Context, Effect as EffectRuntime, Layer, Schema } from "effect"
 import { Wildcard } from "./util/wildcard"
 import { Location } from "./location"
@@ -45,5 +44,3 @@ export const layer = Layer.effect(
 )
 
 export const locationLayer = layer
-
-export const node = makeLocationNode({ service: Service, layer, deps: [Location.node] })

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 { makeGlobalNode } from "./effect/app-node"
+import { LayerNode } from "./effect/layer-node"
 
 export class AppProcessError extends Schema.TaggedErrorClass<AppProcessError>()("AppProcessError", {
   command: Schema.String,
@@ -20,7 +20,6 @@ export class AppProcessError extends Schema.TaggedErrorClass<AppProcessError>()(
 }
 
 export interface RunOptions {
-  readonly combineOutput?: boolean
   readonly maxOutputBytes?: number
   readonly maxErrorBytes?: number
   readonly signal?: AbortSignal
@@ -38,10 +37,8 @@ export interface RunStreamOptions {
 export interface RunResult {
   readonly command: string
   readonly exitCode: number
-  readonly output?: Buffer
   readonly stdout: Buffer
   readonly stderr: Buffer
-  readonly outputTruncated?: boolean
   readonly stdoutTruncated: boolean
   readonly stderrTruncated: boolean
 }
@@ -146,22 +143,6 @@ export const layer = Layer.effect(
       const collect = Effect.scoped(
         Effect.gen(function* () {
           const handle = yield* spawner.spawn(command)
-          if (options?.combineOutput) {
-            const [output, exitCode] = yield* Effect.all(
-              [collectStream(handle.all, options.maxOutputBytes), handle.exitCode],
-              { concurrency: "unbounded" },
-            )
-            return {
-              command: description,
-              exitCode,
-              output: output.buffer,
-              stdout: Buffer.alloc(0),
-              stderr: Buffer.alloc(0),
-              outputTruncated: output.truncated,
-              stdoutTruncated: false,
-              stderrTruncated: false,
-            } satisfies RunResult
-          }
           const [stdout, stderr, exitCode] = yield* Effect.all(
             [
               collectStream(handle.stdout, options?.maxOutputBytes),
@@ -257,6 +238,6 @@ export const layer = Layer.effect(
 )
 
 export const defaultLayer = layer.pipe(Layer.provide(CrossSpawnSpawner.defaultLayer))
-export const node = makeGlobalNode({ service: Service, layer: layer, deps: [CrossSpawnSpawner.node] })
+export const node = LayerNode.make({ service: Service, layer: layer, deps: [CrossSpawnSpawner.node] })
 
 export * as AppProcess from "./process"

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 { makeGlobalNode } from "./effect/app-node"
+import { LayerNode } from "./effect/layer-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 = makeGlobalNode({
+export const node = LayerNode.make({
   service: Service,
   layer: layer,
   deps: [FSUtil.node, Git.node, ProjectDirectories.node],

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 { makeLocationNode } from "../effect/app-node"
+import { LayerNode } from "../effect/layer-node"
 import { Project } from "../project"
 import { ProjectDirectories } from "./directories"
 import { makeGitWorktreeStrategy } from "./copy-strategies"
@@ -279,14 +279,8 @@ export const layer = Layer.effect(
 )
 
 export const locationLayer = layer
-export const node = makeLocationNode({
+export const node = LayerNode.make({
   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],
-})

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 { makeGlobalNode } from "../effect/app-node"
+import { LayerNode } from "../effect/layer-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 = makeGlobalNode({ service: Service, layer: layer, deps: [Database.node] })
+export const node = LayerNode.make({ service: Service, layer: layer, deps: [Database.node] })

packages/core/src/pty.ts

@@ -1,6 +1,5 @@
 export * as Pty from "./pty"
 
-import { makeLocationNode } from "./effect/app-node"
 import type { Disp, Proc } from "#pty"
 import { Context, Effect, Layer, Schema, Types } from "effect"
 import { Pty } from "@opencode-ai/schema/pty"
@@ -314,5 +313,3 @@ 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] })

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 { makeGlobalNode } from "../effect/app-node"
+import { LayerNode } from "../effect/layer-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 = makeGlobalNode({ service: Service, layer: layer, deps: [] })
+export const node = LayerNode.make({ service: Service, layer: layer, deps: [] })

packages/core/src/public-event-manifest.ts

@@ -1,7 +1,3 @@
 export * as PublicEventManifest from "./public-event-manifest"
 
-import { Event } from "@opencode-ai/schema/event"
-import { EventManifest } from "@opencode-ai/schema/event-manifest"
-
-export const Definitions = EventManifest.ServerDefinitions
-export const Latest = Event.latest(Definitions)
+export { ServerDefinitions as Definitions } from "@opencode-ai/schema/event-manifest"

packages/core/src/question.ts

@@ -1,6 +1,5 @@
 export * as QuestionV2 from "./question"
 
-import { makeLocationNode } from "./effect/app-node"
 import { Context, Deferred, Effect, Layer, Schema } from "effect"
 import { Question } from "@opencode-ai/schema/question"
 import { EventV2 } from "./event"
@@ -149,5 +148,3 @@ export const layer = Layer.effect(
 )
 
 export const locationLayer = layer
-
-export const node = makeLocationNode({ service: Service, layer, deps: [EventV2.node] })

packages/core/src/reference.ts

@@ -1,6 +1,5 @@
 export * as Reference from "./reference"
 
-import { makeLocationNode } from "./effect/app-node"
 import { Context, Effect, Layer, Scope, Types } from "effect"
 import { Reference } from "@opencode-ai/schema/reference"
 import { Global } from "./global"
@@ -121,9 +120,3 @@ export const layer = Layer.effect(
 )
 
 export const locationLayer = layer
-
-export const node = makeLocationNode({
-  service: Service,
-  layer,
-  deps: [Global.node, EventV2.node, RepositoryCache.node],
-})

packages/core/src/reference/guidance.ts

@@ -1,6 +1,5 @@
 export * as ReferenceGuidance from "./guidance"
 
-import { makeLocationNode } from "../effect/app-node"
 import { Context, Effect, Layer, Schema } from "effect"
 import { Reference } from "../reference"
 import { SystemContext } from "../system-context/index"
@@ -65,5 +64,3 @@ export const layer = Layer.effect(
 )
 
 export const locationLayer = layer
-
-export const node = makeLocationNode({ service: Service, layer, deps: [Reference.node] })

packages/core/src/repository-cache.ts

@@ -5,7 +5,6 @@ import { Git } from "./git"
 import { Global } from "./global"
 import { Repository } from "./repository"
 import { AbsolutePath } from "./schema"
-import { makeGlobalNode } from "./effect/app-node"
 import { EffectFlock } from "./util/effect-flock"
 
 export type Result = {
@@ -230,12 +229,6 @@ 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

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 { makeGlobalNode } from "./effect/app-node"
+import { LayerNode } from "./effect/layer-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 = makeGlobalNode({ service: Service, layer: layer, deps: [RipgrepBinary.node, AppProcess.node] })
+export const node = LayerNode.make({ service: Service, layer: layer, deps: [RipgrepBinary.node, AppProcess.node] })

packages/core/src/ripgrep/binary.ts

@@ -4,8 +4,8 @@ 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 { makeGlobalNode } from "../effect/app-node"
-import { httpClient } from "../effect/app-node-platform"
+import { LayerNode } from "../effect/layer-node"
+import { httpClient } from "../effect/layer-node-platform"
 import { FSUtil } from "../fs-util"
 import { Global } from "../global"
 import { which } from "../util/which"
@@ -130,7 +130,7 @@ export namespace RipgrepBinary {
     Layer.provide(CrossSpawnSpawner.defaultLayer),
   )
 
-  export const node = makeGlobalNode({
+  export const node = LayerNode.make({
     service: Service,
     layer: layer,
     deps: [FSUtil.node, httpClient, CrossSpawnSpawner.node],

packages/core/src/session.ts

@@ -27,8 +27,6 @@ import { fromRow } from "./session/info"
 import { SessionRunner } from "./session/runner/index"
 import { SessionStore } from "./session/store"
 import { SessionExecution } from "./session/execution"
-import { makeGlobalNode } from "./effect/app-node"
-import { LocationServiceMap } from "./location-service-map"
 import { MessageDecodeError } from "./session/error"
 import { SessionEvent } from "./session/event"
 import { SessionInput } from "./session/input"
@@ -181,283 +179,289 @@ export interface Interface {
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/v2/Session") {}
 
-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.Service
-    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))),
-      history: Effect.fn("V2Session.history")(function* (input) {
-        yield* result.get(input.sessionID)
-        return yield* EventV2.readAggregate(db, {
-          ...input,
-          aggregateID: input.sessionID,
-          manifest: SessionDurable,
-        })
-      }),
-      prompt: Effect.fn("V2Session.prompt")((input) =>
-        Effect.uninterruptible(
-          Effect.gen(function* () {
-            yield* result.get(input.sessionID)
-            const prompt = resolvePrompt(input.prompt)
-            const messageID = input.id ?? SessionMessage.ID.create()
-            const delivery = input.delivery ?? "steer"
-            const expected = { sessionID: input.sessionID, messageID, prompt, delivery }
-            const admitted = yield* SessionInput.admit(db, events, {
-              id: messageID,
-              sessionID: input.sessionID,
-              prompt,
-              delivery,
-            }).pipe(
-              Effect.catchDefect((defect) =>
-                defect instanceof SessionInput.LifecycleConflict
-                  ? new PromptConflictError({ sessionID: input.sessionID, messageID })
-                  : Effect.die(defect),
+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),
+                  }),
               ),
             )
-            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) {
-        const session = yield* result.get(input.sessionID)
-        if (
-          session.model?.providerID === input.model.providerID &&
-          session.model.id === input.model.id &&
-          (session.model.variant ?? "default") === (input.model.variant ?? "default")
-        )
-          return
-        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" })
-      }),
-      active: execution.active,
-      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
-  }),
+          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))),
+            history: Effect.fn("V2Session.history")(function* (input) {
+              yield* result.get(input.sessionID)
+              return yield* EventV2.readAggregate(db, {
+                ...input,
+                aggregateID: input.sessionID,
+                manifest: SessionDurable,
+              })
+            }),
+            prompt: Effect.fn("V2Session.prompt")((input) =>
+              Effect.uninterruptible(
+                Effect.gen(function* () {
+                  yield* result.get(input.sessionID)
+                  const prompt = resolvePrompt(input.prompt)
+                  const messageID = input.id ?? SessionMessage.ID.create()
+                  const delivery = input.delivery ?? "steer"
+                  const expected = { sessionID: input.sessionID, messageID, prompt, delivery }
+                  const admitted = yield* SessionInput.admit(db, events, {
+                    id: messageID,
+                    sessionID: input.sessionID,
+                    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" })
+            }),
+            active: execution.active,
+            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(SessionStore.defaultLayer),
   Layer.provide(SessionProjector.defaultLayer),
   Layer.provide(EventV2.defaultLayer),
@@ -479,17 +483,3 @@ const resolvePrompt = (input: PromptInput.Prompt) =>
       }
     }),
   })
-
-export const node = makeGlobalNode({
-  service: Service,
-  layer: layer.pipe(Layer.orDie),
-  deps: [
-    Database.node,
-    EventV2.node,
-    ProjectV2.node,
-    SessionExecution.node,
-    SessionStore.node,
-    LocationServiceMap.node,
-    SessionProjector.node,
-  ],
-})

packages/core/src/session/execution.ts

@@ -1,8 +1,6 @@
 export * as SessionExecution from "./execution"
 
 import { Context, Effect, Layer } from "effect"
-import { LayerNode } from "../effect/layer-node"
-import { Node } from "../effect/app-node"
 import { SessionRunner } from "./runner/index"
 import { SessionSchema } from "./schema"
 
@@ -20,8 +18,6 @@ export interface Interface {
 /** Routes execution from a Session ID to the runner owned by that Session's Location. */
 export class Service extends Context.Service<Service, Interface>()("@opencode/v2/SessionExecution") {}
 
-export const node = LayerNode.unbound(Service, Node.tags.values.global)
-
 /** Low-level compatibility layer for callers that only need durable Session recording. */
 export const noopLayer = Layer.succeed(
   Service,

packages/core/src/session/execution/local.ts

@@ -1,6 +1,5 @@
 import { Cause, Effect, Layer } from "effect"
-import { LocationServiceMap } from "../../location-service-map"
-import { makeGlobalNode } from "../../effect/app-node"
+import { LocationServiceMap } from "../../location-layer"
 import { SessionRunCoordinator } from "../run-coordinator"
 import { SessionRunner } from "../runner"
 import { SessionSchema } from "../schema"
@@ -12,7 +11,7 @@ export const layer = Layer.effect(
   SessionExecution.Service,
   Effect.gen(function* () {
     const store = yield* SessionStore.Service
-    const locations = yield* LocationServiceMap.Service
+    const locations = yield* LocationServiceMap
     const coordinator = yield* SessionRunCoordinator.make<SessionSchema.ID, SessionRunner.RunError>({
       drain: Effect.fnUntraced(function* (sessionID: SessionSchema.ID, force) {
         const session = yield* store.get(sessionID)
@@ -38,11 +37,3 @@ 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, LocationServiceMap.node],
-})
-
-export * as SessionExecutionLocal from "./local"

packages/core/src/session/message-updater.ts

@@ -349,7 +349,6 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {
                 id: event.data.reasoningID,
                 text: "",
                 providerMetadata: event.data.providerMetadata,
-                time: { created: event.data.timestamp },
               }),
             ),
           )
@@ -366,7 +365,6 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {
           const match = latestReasoning(draft, event.data.reasoningID)
           if (match) {
             match.text = event.data.text
-            match.time = { created: match.time?.created ?? event.data.timestamp, completed: event.data.timestamp }
             if (event.data.providerMetadata !== undefined) match.providerMetadata = event.data.providerMetadata
           }
         })

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 { makeGlobalNode } from "../effect/app-node"
+import { LayerNode } from "../effect/layer-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 = makeGlobalNode({ name: "session-projector", layer, deps: [EventV2.node, Database.node] })
+export const node = LayerNode.make({ name: "session-projector", layer, deps: [EventV2.node, Database.node] })

packages/core/src/session/runner/llm.ts

@@ -36,8 +36,6 @@ 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/app-node"
-import { llmClient } from "../../effect/app-node-platform"
 
 /**
  * Runs one durable coding-agent Session until it settles.
@@ -335,8 +333,7 @@ export const layer = Layer.effect(
           if (stream._tag === "Success" && !publisher.hasProviderError())
             yield* withPublication(publisher.failUnsettledTools("Provider did not return a tool result", true))
           if (stream._tag === "Failure") return yield* Effect.failCause(stream.cause)
-          if (settled._tag === "Failure" && Cause.hasInterrupts(settled.cause))
-            return yield* Effect.failCause(settled.cause)
+          if (settled._tag === "Failure") return yield* Effect.failCause(settled.cause)
           return { needsContinuation: !publisher.hasProviderError() && needsContinuation, step: currentStep }
         }),
       )
@@ -407,23 +404,3 @@ 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,
-  ],
-})

packages/core/src/session/runner/model.ts

@@ -1,6 +1,5 @@
 export * as SessionRunnerModel from "./model"
 
-import { makeLocationNode } from "../../effect/app-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"
@@ -133,7 +132,7 @@ export const fromCatalogModel = (
   credential?: Credential.Value,
 ): Effect.Effect<Model, UnsupportedApiError> => {
   const resolved =
-    credential?.type !== "key" || credential.metadata === undefined
+    credential?.metadata === undefined
       ? model
       : produce(model, (draft) => {
           Object.assign(draft.request.body, credential.metadata)
@@ -214,5 +213,3 @@ export const locationLayer = Layer.effect(
     })
   }),
 )
-
-export const node = makeLocationNode({ service: Service, layer: locationLayer, deps: [Catalog.node, Integration.node] })

packages/core/src/session/store.ts

@@ -3,7 +3,6 @@ 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/app-node"
 import { SessionHistory } from "./history"
 import { MessageDecodeError } from "./error"
 import { SessionMessage } from "./message"
@@ -61,5 +60,3 @@ export const layer = Layer.effect(
 )
 
 export const defaultLayer = layer.pipe(Layer.provide(Database.defaultLayer))
-
-export const node = makeGlobalNode({ service: Service, layer, deps: [Database.node] })

packages/core/src/session/todo.ts

@@ -4,7 +4,6 @@ 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/app-node"
 import { EventV2 } from "../event"
 import { SessionSchema } from "./schema"
 import { TodoTable } from "./sql"
@@ -76,5 +75,3 @@ 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] })

packages/core/src/skill.ts

@@ -1,6 +1,5 @@
 export * as SkillV2 from "./skill"
 
-import { makeLocationNode } from "./effect/app-node"
 import path from "path"
 import { Context, Effect, Layer, Schema, Types } from "effect"
 import { Skill } from "@opencode-ai/schema/skill"
@@ -130,5 +129,3 @@ 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] })

packages/core/src/skill/discovery.ts

@@ -5,8 +5,6 @@ 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/app-node"
-import { httpClient } from "../effect/app-node-platform"
 import { AbsolutePath } from "../schema"
 
 const skillConcurrency = 4
@@ -215,5 +213,3 @@ 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] })

packages/core/src/skill/guidance.ts

@@ -1,6 +1,5 @@
 export * as SkillGuidance from "./guidance"
 
-import { makeLocationNode } from "../effect/app-node"
 import { Context, Effect, Layer, Schema } from "effect"
 import { AgentV2 } from "../agent"
 import { PermissionV2 } from "../permission"
@@ -72,5 +71,3 @@ export const layer = Layer.effect(
 )
 
 export const locationLayer = layer
-
-export const node = makeLocationNode({ service: Service, layer, deps: [SkillV2.node] })

packages/core/src/snapshot.ts

@@ -1,6 +1,5 @@
 export * as Snapshot from "./snapshot"
 
-import { makeLocationNode } from "./effect/app-node"
 import path from "path"
 import { Context, Effect, Layer, Schema } from "effect"
 import { Config } from "./config"
@@ -229,12 +228,6 @@ 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({

packages/core/src/system-context/builtins.ts

@@ -1,13 +1,10 @@
 export * as SystemContextBuiltIns from "./builtins"
 
-import { makeLocationNode } from "../effect/app-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* () {
@@ -48,9 +45,3 @@ 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],
-})

packages/core/src/system-context/registry.ts

@@ -2,7 +2,6 @@ export * as SystemContextRegistry from "./registry"
 
 import { Context, Effect, Layer, Ref, Scope } from "effect"
 import { SystemContext } from "./index"
-import { makeLocationNode } from "../effect/app-node"
 
 export interface Entry {
   readonly key: SystemContext.Key
@@ -45,5 +44,3 @@ export const layer = Layer.effect(
     })
   }),
 )
-
-export const node = makeLocationNode({ service: Service, layer, deps: [] })

packages/core/src/tool-output-store.ts

@@ -5,7 +5,6 @@ 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/app-node"
 import { SessionSchema } from "./session/schema"
 import { Identifier } from "./util/identifier"
 import type { ToolOutput } from "@opencode-ai/llm"
@@ -194,8 +193,6 @@ 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* () {
@@ -205,5 +202,3 @@ 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: [] })

packages/core/src/tool/application-tools.ts

@@ -3,7 +3,6 @@ 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/app-node"
 
 type Data = {
   readonly entries: Map<string, Entry>
@@ -53,5 +52,3 @@ export const layer = Layer.effect(
     })
   }),
 )
-
-export const node = makeGlobalNode({ service: Service, layer, deps: [] })

packages/core/src/tool/apply-patch.ts

@@ -1,8 +1,6 @@
 export * as ApplyPatchTool from "./apply-patch"
 
 import { ToolFailure } from "@opencode-ai/llm"
-import { FileDiff } from "@opencode-ai/schema/file-diff"
-import { createTwoFilesPatch, diffLines } from "diff"
 import { Effect, Layer, Schema } from "effect"
 import { FileMutation } from "../file-mutation"
 import { FSUtil } from "../fs-util"
@@ -26,10 +24,7 @@ export const Applied = Schema.Struct({
   target: Schema.String,
 })
 
-export const Output = Schema.Struct({
-  applied: Schema.Array(Applied),
-  files: Schema.Array(FileDiff.Info),
-})
+export const Output = Schema.Struct({ applied: Schema.Array(Applied) })
 export type Output = typeof Output.Type
 
 export const toModelOutput = (output: Output) =>
@@ -41,17 +36,11 @@ export const toModelOutput = (output: Output) =>
   ].join("\n")
 
 type Prepared =
-  | (Extract<Patch.Hunk, { readonly type: "add" | "delete" }> & {
-      readonly target: LocationMutation.Target
-      readonly before: string
-      readonly after: string
-    })
+  | (Extract<Patch.Hunk, { readonly type: "add" | "delete" }> & { readonly target: LocationMutation.Target })
   | (Extract<Patch.Hunk, { readonly type: "update" }> & {
       readonly target: LocationMutation.Target
       readonly source: Uint8Array
       readonly content: string
-      readonly before: string
-      readonly after: string
     })
 
 export const layer = Layer.effectDiscard(
@@ -124,36 +113,29 @@ export const layer = Layer.effectDiscard(
                 for (const { hunk, target } of targets) {
                   yield* Effect.gen(function* () {
                     if (hunk.type === "add") {
-                      prepared.push({
-                        ...hunk,
-                        target,
-                        before: "",
-                        after:
-                          hunk.contents.endsWith("\n") || hunk.contents === "" ? hunk.contents : `${hunk.contents}\n`,
-                      })
+                      prepared.push({ ...hunk, target })
                       return
                     }
                     if ((yield* fs.stat(target.canonical)).type !== "File") yield* fail(hunk.path)
-                    const source = yield* fs.readFile(target.canonical)
-                    const original = new TextDecoder("utf-8", { ignoreBOM: true }).decode(source)
-                    const before = original.replace(/^\uFEFF/, "")
                     if (hunk.type === "delete") {
-                      prepared.push({ ...hunk, target, before, after: "" })
+                      prepared.push({ ...hunk, target })
                       return
                     }
-                    const update = Patch.derive(hunk.path, hunk.chunks, original)
+                    const source = yield* fs.readFile(target.canonical)
+                    const update = Patch.derive(
+                      hunk.path,
+                      hunk.chunks,
+                      new TextDecoder("utf-8", { ignoreBOM: true }).decode(source),
+                    )
                     prepared.push({
                       ...hunk,
                       target,
                       source,
                       content: Patch.joinBom(update.content, update.bom),
-                      before,
-                      after: update.content,
                     })
                   }).pipe(Effect.mapError(() => fail(hunk.path)))
                 }
 
-                const patchFiles = prepared.map(patchFile)
                 yield* Effect.forEach(
                   prepared,
                   (change) =>
@@ -183,7 +165,7 @@ export const layer = Layer.effectDiscard(
                     }).pipe(Effect.mapError(() => fail(change.path))),
                   { discard: true },
                 )
-                return { applied, files: patchFiles }
+                return { applied }
               }).pipe(Effect.mapError((error) => (error instanceof ToolFailure ? error : fail("patch"))))
             },
           }),
@@ -193,19 +175,3 @@ export const layer = Layer.effectDiscard(
       .pipe(Effect.orDie)
   }),
 )
-
-function patchFile(change: Prepared): typeof FileDiff.Info.Type {
-  const counts = diffLines(change.before, change.after).reduce(
-    (result, item) => ({
-      additions: result.additions + (item.added ? (item.count ?? 0) : 0),
-      deletions: result.deletions + (item.removed ? (item.count ?? 0) : 0),
-    }),
-    { additions: 0, deletions: 0 },
-  )
-  return {
-    file: change.target.resource,
-    patch: createTwoFilesPatch(change.target.resource, change.target.resource, change.before, change.after),
-    status: change.type === "add" ? "added" : change.type === "delete" ? "deleted" : "modified",
-    ...counts,
-  }
-}

packages/core/src/tool/bash.ts

@@ -30,15 +30,16 @@ export const Input = Schema.Struct({
     }),
 })
 
-const StructuredOutput = Schema.Struct({
-  exit: Schema.Number.pipe(Schema.optional),
-  truncated: Schema.Boolean,
-  timeout: Schema.Boolean.pipe(Schema.optional),
-})
-
 const Output = Schema.Struct({
-  ...StructuredOutput.fields,
+  command: Schema.String,
+  cwd: Schema.String,
+  exitCode: Schema.Number.pipe(Schema.optional),
+  /** Bounded compact equivalent of stdout/stderr: stderr is labeled when present. */
   output: Schema.String,
+  truncated: Schema.Boolean,
+  stdoutTruncated: Schema.Boolean.pipe(Schema.optional),
+  stderrTruncated: Schema.Boolean.pipe(Schema.optional),
+  timedOut: Schema.Boolean.pipe(Schema.optional),
   warnings: Schema.Array(Schema.String).pipe(Schema.optional),
 })
 
@@ -46,12 +47,24 @@ type Output = typeof Output.Type
 
 const defaultShell = () => (process.platform === "win32" ? (process.env.COMSPEC ?? "cmd.exe") : "/bin/sh")
 
+const compactOutput = (stdout: string, stderr: string) => {
+  const output = stdout && stderr ? `${stdout}\n\nstderr:\n${stderr}` : stderr ? `stderr:\n${stderr}` : stdout
+  return output || "(no output)"
+}
+
+const captureNotice = (stdoutTruncated: boolean, stderrTruncated: boolean) => {
+  if (stdoutTruncated && stderrTruncated) return "[stdout and stderr capture truncated at the in-memory safety limit]"
+  if (stdoutTruncated) return "[stdout capture truncated at the in-memory safety limit]"
+  if (stderrTruncated) return "[stderr capture truncated at the in-memory safety limit]"
+  return undefined
+}
+
 const modelOutput = (output: Output) => {
   const warnings = output.warnings?.length
     ? `\n\nWarnings:\n${output.warnings.map((warning) => `- ${warning}`).join("\n")}`
     : ""
-  if (output.timeout) return `${warnings.trimStart()}${warnings ? "\n\n" : ""}Command timed out before completion.`
-  return `${warnings.trimStart()}${warnings ? "\n\n" : ""}Command exited with code ${output.exit}.`
+  if (output.timedOut) return `${output.output}${warnings}\n\nCommand timed out before completion.`
+  return `${output.output}${warnings}\n\nCommand exited with code ${output.exitCode}.`
 }
 
 const isTimeout = (error: AppProcess.AppProcessError) =>
@@ -103,16 +116,7 @@ export const layer = Layer.effectDiscard(
           description: `Execute one shell command string with the host user's filesystem, process, and network authority. The active Location is the default working directory. Relative workdir values resolve from that Location. External workdir values require external_directory approval; best-effort command-argument path warnings are advisory only. Timeout values are milliseconds (default: ${DEFAULT_TIMEOUT_MS}; maximum: ${MAX_TIMEOUT_MS}). Uses the configured shell when set; otherwise uses /bin/sh on POSIX and COMSPEC or cmd.exe on Windows.`,
           input: Input,
           output: Output,
-          structured: StructuredOutput,
-          toStructuredOutput: ({ output }) => ({
-            truncated: output.truncated,
-            ...(output.exit === undefined ? {} : { exit: output.exit }),
-            ...(output.timeout === undefined ? {} : { timeout: output.timeout }),
-          }),
-          toModelOutput: ({ output }) => [
-            { type: "text", text: output.output },
-            { type: "text", text: modelOutput(output) },
-          ],
+          toModelOutput: ({ output }) => [{ type: "text", text: modelOutput(output) }],
           execute: (input, context) =>
             Effect.gen(function* () {
               const source = {
@@ -159,9 +163,9 @@ export const layer = Layer.effectDiscard(
               const timeout = input.timeout ?? DEFAULT_TIMEOUT_MS
               const result = yield* appProcess
                 .run(command, {
-                  combineOutput: true,
                   timeout: Duration.millis(timeout),
                   maxOutputBytes: MAX_CAPTURE_BYTES,
+                  maxErrorBytes: MAX_CAPTURE_BYTES,
                 })
                 .pipe(
                   Effect.catchTag("AppProcessError", (error) =>
@@ -170,22 +174,26 @@ export const layer = Layer.effectDiscard(
                 )
               if (!result) {
                 return {
+                  command: input.command,
+                  cwd: target.canonical,
                   output: `Command exceeded timeout of ${timeout} ms. Retry with a larger timeout if the command is expected to take longer.`,
                   truncated: false,
-                  timeout: true,
+                  timedOut: true,
                   ...(warnings.length ? { warnings } : {}),
                 }
               }
 
-              const output = result.output?.toString("utf8") || "(no output)"
-              const notice = result.outputTruncated
-                ? "[output capture truncated at the in-memory safety limit]"
-                : undefined
+              const compact = compactOutput(result.stdout.toString("utf8"), result.stderr.toString("utf8"))
+              const notice = captureNotice(result.stdoutTruncated, result.stderrTruncated)
               return {
-                exit: result.exitCode,
-                output: notice ? `${output}\n\n${notice}` : output,
-                truncated: result.outputTruncated === true,
+                command: input.command,
+                cwd: target.canonical,
+                exitCode: result.exitCode,
+                output: notice ? `${compact}\n\n${notice}` : compact,
+                truncated: result.stdoutTruncated || result.stderrTruncated,
                 ...(warnings.length ? { warnings } : {}),
+                ...(result.stdoutTruncated ? { stdoutTruncated: true } : {}),
+                ...(result.stderrTruncated ? { stderrTruncated: true } : {}),
               }
             }).pipe(Effect.mapError(() => new ToolFailure({ message: `Unable to execute command: ${input.command}` }))),
         }),

packages/core/src/tool/builtins.ts

@@ -1,6 +1,5 @@
 export * as BuiltInTools from "./builtins"
 
-import { makeLocationNode } from "../effect/app-node"
 import { Layer } from "effect"
 import { BashTool } from "./bash"
 import { ApplyPatchTool } from "./apply-patch"
@@ -15,20 +14,6 @@ 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/app-node-platform"
 
 /**
  * Composes only the shipped Location-scoped built-in tool transforms.
@@ -57,25 +42,3 @@ 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,
-  ],
-})

packages/core/src/tool/edit.ts

@@ -7,8 +7,6 @@
 export * as EditTool from "./edit"
 
 import { ToolFailure } from "@opencode-ai/llm"
-import { FileDiff } from "@opencode-ai/schema/file-diff"
-import { createTwoFilesPatch, diffLines } from "diff"
 import { Effect, Layer, Schema } from "effect"
 import { FileMutation } from "../file-mutation"
 import { FSUtil } from "../fs-util"
@@ -32,7 +30,10 @@ export const Input = Schema.Struct({
 })
 
 export const Output = Schema.Struct({
-  files: Schema.Array(FileDiff.Info),
+  operation: Schema.Literal("write"),
+  target: Schema.String,
+  resource: Schema.String,
+  existed: Schema.Boolean,
   replacements: Schema.Number,
 })
 export type Output = typeof Output.Type
@@ -70,7 +71,7 @@ const previewLines = (value: string, prefix: "+" | "-") => {
 
 export const toModelOutput = (output: Output, oldString: string, newString: string) =>
   [
-    `Edited file successfully: ${output.files[0]?.file}`,
+    `Edited file successfully: ${output.resource}`,
     `Replacements: ${output.replacements}`,
     "```diff",
     ...previewLines(oldString, "-"),
@@ -178,13 +179,6 @@ export const layer = Layer.effectDiscard(
                   input.replaceAll === true
                     ? source.text.replaceAll(oldString, newString)
                     : source.text.replace(oldString, newString)
-                const counts = diffLines(source.text, replaced).reduce(
-                  (result, item) => ({
-                    additions: result.additions + (item.added ? (item.count ?? 0) : 0),
-                    deletions: result.deletions + (item.removed ? (item.count ?? 0) : 0),
-                  }),
-                  { additions: 0, deletions: 0 },
-                )
                 const next = splitBom(replaced)
                 const result = yield* unableToEdit(
                   files.writeIfUnchanged({
@@ -193,17 +187,7 @@ export const layer = Layer.effectDiscard(
                     content: joinBom(next.text, source.bom || next.bom),
                   }),
                 )
-                return {
-                  files: [
-                    {
-                      file: result.resource,
-                      patch: createTwoFilesPatch(result.resource, result.resource, source.text, replaced),
-                      status: "modified" as const,
-                      ...counts,
-                    },
-                  ],
-                  replacements,
-                } satisfies Output
+                return { ...result, replacements } satisfies Output
               })
             },
           }),

packages/core/src/tool/read-filesystem.ts

@@ -5,7 +5,6 @@ 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/app-node"
 import { AbsolutePath, PositiveInt, RelativePath } from "../schema"
 
 export const MAX_READ_LINES = 2_000
@@ -362,5 +361,3 @@ export const layer = Layer.effect(
     })
   }),
 )
-
-export const node = makeLocationNode({ service: Service, layer, deps: [FSUtil.node] })

packages/core/src/tool/registry.ts

@@ -11,7 +11,6 @@ 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/app-node"
 
 export type ExecuteInput = {
   readonly sessionID: SessionSchema.ID
@@ -138,15 +137,3 @@ 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],
-})

packages/core/src/tool/tool.ts

@@ -37,19 +37,10 @@ export type Content =
   | { readonly type: "text"; readonly text: string }
   | { readonly type: "file"; readonly data: string; readonly mime: string; readonly name?: string }
 
-type Config<
-  Input extends SchemaType<any>,
-  Output extends SchemaType<any>,
-  Structured extends SchemaType<any> = Output,
-> = {
+type Config<Input extends SchemaType<any>, Output extends SchemaType<any>> = {
   readonly description: string
   readonly input: Input
   readonly output: Output
-  readonly structured?: Structured
-  readonly toStructuredOutput?: (input: {
-    readonly input: Schema.Schema.Type<Input>
-    readonly output: Output["Encoded"]
-  }) => Schema.Schema.Type<Structured>
   readonly execute: (
     input: Schema.Schema.Type<Input>,
     context: Context,
@@ -68,12 +59,10 @@ type Runtime = {
 
 const runtimes = new WeakMap<AnyTool, Runtime>()
 
-export function make<
-  Input extends SchemaType<any>,
-  Output extends SchemaType<any>,
-  Structured extends SchemaType<any> = Output,
->(config: Config<Input, Output, Structured>): Definition<Input, Structured> {
-  const tool = Object.freeze({}) as Definition<Input, Structured>
+export function make<Input extends SchemaType<any>, Output extends SchemaType<any>>(
+  config: Config<Input, Output>,
+): Definition<Input, Output> {
+  const tool = Object.freeze({}) as Definition<Input, Output>
   const definitions = new Map<string, ToolDefinition>()
   runtimes.set(tool, {
     definition: (name) => {
@@ -83,7 +72,7 @@ export function make<
         name,
         description: config.description,
         inputSchema: toJsonSchema(config.input),
-        outputSchema: toJsonSchema(config.structured ?? config.output),
+        outputSchema: toJsonSchema(config.output),
       })
       definitions.set(name, definition)
       return definition
@@ -95,13 +84,6 @@ export function make<
           config.execute(input, context).pipe(
             Effect.flatMap((output) =>
               Schema.encodeEffect(config.output)(output).pipe(
-                Effect.flatMap((output) => {
-                  if (!config.structured || !config.toStructuredOutput)
-                    return Effect.succeed({ output, structured: output })
-                  return Schema.encodeEffect(config.structured)(config.toStructuredOutput({ input, output })).pipe(
-                    Effect.map((structured) => ({ output, structured })),
-                  )
-                }),
                 Effect.mapError(
                   (error) =>
                     new ToolFailure({
@@ -110,8 +92,8 @@ export function make<
                 ),
               ),
             ),
-            Effect.map(({ output, structured }) => ({
-              structured,
+            Effect.map((output) => ({
+              structured: output,
               content:
                 config.toModelOutput?.({ input, output }).map((part) =>
                   part.type === "text"

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 { makeGlobalNode } from "../effect/app-node"
+import { LayerNode } from "../effect/layer-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 = makeGlobalNode({ service: Service, layer: layer, deps: [Global.node, FSUtil.node] })
+  export const node = LayerNode.make({ service: Service, layer: layer, deps: [Global.node, FSUtil.node] })
 }

packages/core/src/v1/config/provider-options.ts

@@ -42,15 +42,6 @@ const openai: Lowerer = {
   },
   request(options) {
     const result = snake(options)
-    if (options.reasoningEffort !== undefined || options.reasoningSummary !== undefined) {
-      result.reasoning = {
-        ...(isRecord(result.reasoning) ? result.reasoning : {}),
-        ...(options.reasoningEffort !== undefined ? { effort: options.reasoningEffort } : {}),
-        ...(options.reasoningSummary !== undefined ? { summary: options.reasoningSummary } : {}),
-      }
-      delete result.reasoning_effort
-      delete result.reasoning_summary
-    }
     if (options.textVerbosity !== undefined) {
       result.text = { ...(isRecord(result.text) ? result.text : {}), verbosity: options.textVerbosity }
       delete result.text_verbosity

packages/core/test/config/config.test.ts

@@ -601,9 +601,9 @@ describe("Config", () => {
               models: {
                 model: {
                   request: {
-                    body: { temperature: 0.3, reasoning: { effort: "high" }, service_tier: "priority" },
+                    body: { temperature: 0.3, reasoning_effort: "high", service_tier: "priority" },
                   },
-                  variants: [{ id: "high", body: { reasoning: { effort: "high", summary: "auto" } } }],
+                  variants: [{ id: "high", body: { reasoning_effort: "high", reasoning_summary: "auto" } }],
                 },
               },
             })

packages/core/test/config/provider-options.test.ts

@@ -42,14 +42,12 @@ describe("ConfigProviderOptionsV1", () => {
     expect(
       lowerer.request({
         reasoningEffort: "high",
-        reasoningSummary: "auto",
-        reasoning: { encryptedContent: true },
         textVerbosity: "low",
         text: { outputFormat: "plain" },
         nestedValue: { camelCase: true },
       }),
     ).toEqual({
-      reasoning: { encrypted_content: true, effort: "high", summary: "auto" },
+      reasoning_effort: "high",
       text: { output_format: "plain", verbosity: "low" },
       nested_value: { camel_case: true },
     })
@@ -140,8 +138,8 @@ describe("ConfigProviderOptionsV1", () => {
       body: { trace: true },
       settings: { resourceName: "resource" },
     })
-    expect(lowerer.request({ reasoningEffort: "high", reasoningSummary: "auto", textVerbosity: "low" })).toEqual({
-      reasoning: { effort: "high", summary: "auto" },
+    expect(lowerer.request({ reasoningEffort: "high", textVerbosity: "low" })).toEqual({
+      reasoning_effort: "high",
       text: { verbosity: "low" },
     })
   })

packages/core/test/effect/layer-node/layer-node-types.test.ts

@@ -1,136 +0,0 @@
-import { test } from "bun:test"
-import { Context, Effect, Layer } from "effect"
-import { LayerNode } from "@opencode-ai/core/effect/layer-node"
-import { makeGlobalNode, makeLocationNode } from "@opencode-ai/core/effect/app-node"
-
-class A extends Context.Service<A, {}>()("test/LayerNodeA") {}
-class B extends Context.Service<B, {}>()("test/LayerNodeB") {}
-class C extends Context.Service<C, {}>()("test/LayerNodeC") {}
-class LayerError {
-  readonly _tag = "LayerError"
-}
-class OtherError {
-  readonly _tag = "OtherError"
-}
-
-const tags = LayerNode.tags({ app: [] })
-const make = tags.make("app")
-const build = <A, E>(root: LayerNode.Node<A, E, any>) => LayerNode.compile(root) as Layer.Layer<A, E>
-const aLayer = Layer.succeed(A, A.of({}))
-const bLayer = Layer.effect(B, Effect.as(A, B.of({})))
-const cLayer = Layer.effect(
-  C,
-  Effect.gen(function* () {
-    yield* A
-    yield* B
-    return C.of({})
-  }),
-)
-const failingA = Layer.effect(A, Effect.fail(new LayerError()))
-const a = make({ service: A, layer: aLayer, deps: [] })
-const b = make({ service: B, layer: bLayer, deps: [a] })
-const c = make({ service: C, layer: cLayer, deps: [a, b] })
-const failing = make({ service: A, layer: failingA, deps: [] })
-const dependent = make({ service: B, layer: bLayer, deps: [failing] })
-const inputA = LayerNode.unbound(A, tags.values.app)
-const inputDependent = make({ service: B, layer: bLayer, deps: [inputA] })
-
-make({ name: "manual-a", layer: aLayer, deps: [] })
-
-// @ts-expect-error A node must have a service or name
-make({ layer: aLayer, deps: [] })
-
-// @ts-expect-error Service and name are mutually exclusive
-make({ service: A, name: "a", layer: aLayer, deps: [] })
-
-// @ts-expect-error B requires A
-make({ service: B, layer: bLayer, deps: [] })
-
-// @ts-expect-error C requires A and B
-make({ service: C, layer: cLayer, deps: [a] })
-
-const closed = build(LayerNode.group([c]))
-const closedWithError = build(LayerNode.group([dependent]))
-const checkClosed: Layer.Layer<C, never, never> = closed
-const checkError: Layer.Layer<B, LayerError, never> = closedWithError
-void checkClosed
-void checkError
-
-LayerNode.replace(aLayer, Layer.succeed(A, A.of({})))
-
-// @ts-expect-error Replacement must provide A
-LayerNode.replace(aLayer, Layer.succeed(B, B.of({})))
-
-// @ts-expect-error Replacement cannot introduce a new error
-LayerNode.replace(aLayer, Layer.effect(A, Effect.fail(new OtherError())))
-
-// @ts-expect-error Replacement must be closed
-LayerNode.replace(bLayer, bLayer)
-
-class TagA extends Context.Service<TagA, {}>()("test/TagA") {}
-class TagB extends Context.Service<TagB, {}>()("test/TagB") {}
-class TagC extends Context.Service<TagC, {}>()("test/TagC") {}
-
-const scopedTags = LayerNode.tags({ request: ["global"], global: [] })
-const request = scopedTags.make("request")
-const global = scopedTags.make("global")
-const globalA = global({ service: TagA, layer: Layer.succeed(TagA, TagA.of({})), deps: [] })
-const requestA = request({ service: TagA, layer: Layer.succeed(TagA, TagA.of({})), deps: [] })
-const requestB = request({ service: TagB, layer: Layer.succeed(TagB, TagB.of({})), deps: [] })
-const tagBLayer = Layer.effect(TagB, Effect.as(TagA, TagB.of({})))
-const tagCLayer = Layer.effect(
-  TagC,
-  Effect.gen(function* () {
-    yield* TagA
-    yield* TagB
-    return TagC.of({})
-  }),
-)
-
-request({ service: TagB, layer: tagBLayer, deps: [globalA] })
-request({ service: TagC, layer: tagCLayer, deps: [globalA, requestB] })
-request({ service: TagC, layer: tagCLayer, deps: [LayerNode.group([globalA, requestB])] })
-
-// @ts-expect-error Tag configuration can only reference declared tags
-LayerNode.tags({ request: ["missing"], global: [] })
-
-// @ts-expect-error An unrelated dependency cannot satisfy TagA
-request({ service: TagB, layer: tagBLayer, deps: [requestB] })
-
-// @ts-expect-error Providing only TagA leaves TagB missing
-request({ service: TagC, layer: tagCLayer, deps: [globalA] })
-
-// @ts-expect-error Providing only TagB leaves TagA missing
-request({ service: TagC, layer: tagCLayer, deps: [requestB] })
-
-// @ts-expect-error Duplicate TagA providers still leave TagB missing
-request({ service: TagC, layer: tagCLayer, deps: [globalA, requestA] })
-
-// @ts-expect-error A group with only TagA still leaves TagB missing
-request({ service: TagC, layer: tagCLayer, deps: [LayerNode.group([globalA])] })
-
-// @ts-expect-error Global cannot depend on request
-global({ service: TagB, layer: tagBLayer, deps: [requestA] })
-
-// @ts-expect-error Groups preserve their child tags
-global({ service: TagB, layer: tagBLayer, deps: [LayerNode.group([requestA])] })
-
-class ScopedA extends Context.Service<ScopedA, {}>()("test/ScopedA") {}
-class ScopedB extends Context.Service<ScopedB, {}>()("test/ScopedB") {}
-
-const scopedA = Layer.succeed(ScopedA, ScopedA.of({}))
-const scopedB = Layer.effect(ScopedB, Effect.as(ScopedA, ScopedB.of({})))
-const globalScopedA = makeGlobalNode({ service: ScopedA, layer: scopedA, deps: [] })
-const locationScopedA = makeLocationNode({ service: ScopedA, layer: scopedA, deps: [] })
-
-makeGlobalNode({ service: ScopedB, layer: scopedB, deps: [globalScopedA] })
-makeLocationNode({ service: ScopedB, layer: scopedB, deps: [globalScopedA] })
-makeLocationNode({ service: ScopedB, layer: scopedB, deps: [locationScopedA] })
-
-// @ts-expect-error Global nodes cannot depend on location nodes
-makeGlobalNode({ service: ScopedB, layer: scopedB, deps: [locationScopedA] })
-
-// @ts-expect-error ScopedB requires ScopedA
-makeLocationNode({ service: ScopedB, layer: scopedB, deps: [] })
-
-test("type exploration compiles", () => {})

packages/core/test/effect/layer-node/layer-node.test.ts

@@ -1,222 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { Context, Effect, Layer } from "effect"
-import { LayerNode } from "@opencode-ai/core/effect/layer-node"
-
-class Value extends Context.Service<Value, { readonly value: string }>()("test/LayerNodeValue") {}
-class Greeting extends Context.Service<Greeting, { readonly value: string }>()("test/LayerNodeGreeting") {}
-class Left extends Context.Service<Left, { readonly value: string }>()("test/LayerNodeLeft") {}
-class Right extends Context.Service<Right, { readonly value: string }>()("test/LayerNodeRight") {}
-class Database extends Context.Service<Database, { readonly name: string }>()("test/GraphDatabase") {}
-class Users extends Context.Service<Users, { readonly list: Effect.Effect<string[]> }>()("test/GraphUsers") {}
-class App extends Context.Service<App, { readonly run: Effect.Effect<string[]> }>()("test/GraphApp") {}
-
-const tags = LayerNode.tags({ app: [] })
-const make = tags.make("app")
-const build = <A, E>(root: LayerNode.Node<A, E, any>, replacements?: readonly LayerNode.Replacement[]) =>
-  LayerNode.compile(root, new Map(replacements?.map((item) => [item.source, item.replacement]))) as Layer.Layer<A, E>
-const valueLayer = Layer.succeed(Value, Value.of({ value: "production" }))
-const greetingLayer = Layer.effect(
-  Greeting,
-  Effect.map(Value, (value) => Greeting.of({ value: `hello ${value.value}` })),
-)
-const value = make({ service: Value, layer: valueLayer, deps: [] })
-const greeting = make({ service: Greeting, layer: greetingLayer, deps: [value] })
-
-describe("layer node", () => {
-  test("builds an untagged graph", async () => {
-    const value = LayerNode.make({ service: Value, layer: valueLayer, deps: [] })
-    const greeting = LayerNode.make({ service: Greeting, layer: greetingLayer, deps: [value] })
-    const program = Effect.map(Greeting, (item) => item.value).pipe(
-      Effect.provide(LayerNode.compile(LayerNode.group([greeting]))),
-    )
-    expect(await Effect.runPromise(program)).toBe("hello production")
-  })
-
-  test("builds a dependency graph", async () => {
-    const program = Effect.map(Greeting, (item) => item.value).pipe(Effect.provide(build(LayerNode.group([greeting]))))
-    expect(await Effect.runPromise(program)).toBe("hello production")
-  })
-
-  test("exposes roots but hides transitive dependencies", () => {
-    const layer = build(LayerNode.group([greeting]))
-    const check: Layer.Layer<Greeting> = layer
-    void check
-  })
-
-  test("preserves branch-specific implementations across roots", async () => {
-    const firstValue = make({ service: Value, layer: Layer.succeed(Value, Value.of({ value: "first" })), deps: [] })
-    const secondValue = make({ service: Value, layer: Layer.succeed(Value, Value.of({ value: "second" })), deps: [] })
-    const leftLayer = Layer.effect(
-      Left,
-      Effect.map(Value, (item) => Left.of({ value: item.value })),
-    )
-    const rightLayer = Layer.effect(
-      Right,
-      Effect.map(Value, (item) => Right.of({ value: item.value })),
-    )
-    const left = make({ service: Left, layer: leftLayer, deps: [firstValue] })
-    const right = make({ service: Right, layer: rightLayer, deps: [secondValue] })
-    const layer = build(LayerNode.group([left, right]))
-    const program = Effect.gen(function* () {
-      return [(yield* Left).value, (yield* Right).value]
-    }).pipe(Effect.provide(layer))
-    expect(await Effect.runPromise(program)).toEqual(["first", "second"])
-  })
-
-  test("requires unbound nodes to be bound before compilation", async () => {
-    const unbound = LayerNode.unbound(Value, tags.values.app)
-    const greeting = make({ service: Greeting, layer: greetingLayer, deps: [unbound] })
-    const tree = LayerNode.group([greeting])
-    expect(() => LayerNode.compile(tree)).toThrow("Unbound layer node: test/LayerNodeValue")
-    const bound = LayerNode.bind(tree, unbound, value)
-    const layer = LayerNode.compile(bound) as Layer.Layer<Greeting>
-    const program = Effect.map(Greeting, (item) => item.value).pipe(Effect.provide(layer))
-    expect(await Effect.runPromise(program)).toBe("hello production")
-  })
-
-  test("replaces a layer by identity", async () => {
-    const replacement = Layer.succeed(Value, Value.of({ value: "simulation" }))
-    const program = Effect.map(Greeting, (item) => item.value).pipe(
-      Effect.provide(build(LayerNode.group([greeting]), [LayerNode.replace(valueLayer, replacement)])),
-    )
-    expect(await Effect.runPromise(program)).toBe("hello simulation")
-  })
-
-  test("replaces every use of the same layer", async () => {
-    const leftLayer = Layer.effect(
-      Left,
-      Effect.map(Value, (item) => Left.of({ value: item.value })),
-    )
-    const rightLayer = Layer.effect(
-      Right,
-      Effect.map(Value, (item) => Right.of({ value: item.value })),
-    )
-    const left = make({ service: Left, layer: leftLayer, deps: [value] })
-    const right = make({ service: Right, layer: rightLayer, deps: [value] })
-    const replacement = Layer.succeed(Value, Value.of({ value: "replaced" }))
-    const layer = build(LayerNode.group([left, right]), [LayerNode.replace(valueLayer, replacement)])
-    const program = Effect.gen(function* () {
-      return [(yield* Left).value, (yield* Right).value]
-    }).pipe(Effect.provide(layer))
-    expect(await Effect.runPromise(program)).toEqual(["replaced", "replaced"])
-  })
-
-  test("does not acquire an unused replacement", async () => {
-    let acquisitions = 0
-    const other = Layer.succeed(Value, Value.of({ value: "other" }))
-    const replacement = Layer.effect(
-      Value,
-      Effect.sync(() => {
-        acquisitions++
-        return Value.of({ value: "replacement" })
-      }),
-    )
-    await Effect.runPromise(
-      Effect.map(Greeting, (item) => item.value).pipe(
-        Effect.provide(build(LayerNode.group([greeting]), [LayerNode.replace(other, replacement)])),
-      ),
-    )
-    expect(acquisitions).toBe(0)
-  })
-
-  test("hoists and compiles tagged graphs", async () => {
-    const tags = LayerNode.tags({ location: ["global"], global: [] })
-    const global = tags.make("global")
-    const location = tags.make("location")
-    const database = global({
-      service: Database,
-      layer: Layer.succeed(Database, Database.of({ name: "Alice" })),
-      deps: [],
-    })
-    const users = location({
-      service: Users,
-      layer: Layer.effect(
-        Users,
-        Effect.gen(function* () {
-          const db = yield* Database
-          return Users.of({ list: Effect.succeed([db.name]) })
-        }),
-      ),
-      deps: [database],
-    })
-    const app = location({
-      service: App,
-      layer: Layer.effect(
-        App,
-        Effect.gen(function* () {
-          const service = yield* Users
-          return App.of({ run: service.list })
-        }),
-      ),
-      deps: [users],
-    })
-
-    const result = LayerNode.hoist(LayerNode.group([app]), tags.values.global)
-    expect(result.node.dependencies[0]?.dependencies[0]?.dependencies[0]).toMatchObject({
-      kind: "group",
-      dependencies: [],
-    })
-    expect(result.hoisted.dependencies).toEqual([database])
-
-    const layer = LayerNode.compile(result.node).pipe(
-      Layer.provide(LayerNode.compile(result.hoisted)),
-    ) as unknown as Layer.Layer<App>
-    const program = Effect.gen(function* () {
-      return yield* (yield* App).run
-    }).pipe(Effect.provide(layer))
-
-    expect(await Effect.runPromise(program)).toEqual(["Alice"])
-  })
-
-  test("rejects conflicting hoisted implementations", () => {
-    const tags = LayerNode.tags({ location: ["global"], global: [] })
-    const global = tags.make("global")
-    const location = tags.make("location")
-    const first = global({
-      service: Database,
-      layer: Layer.succeed(Database, Database.of({ name: "first" })),
-      deps: [],
-    })
-    const second = global({
-      service: Database,
-      layer: Layer.succeed(Database, Database.of({ name: "second" })),
-      deps: [],
-    })
-    const left = location({
-      service: Users,
-      layer: Layer.effect(Users, Effect.as(Database, Users.of({ list: Effect.succeed([]) }))),
-      deps: [first],
-    })
-    const right = location({
-      service: App,
-      layer: Layer.effect(App, Effect.as(Database, App.of({ run: Effect.succeed([]) }))),
-      deps: [second],
-    })
-
-    expect(() => LayerNode.hoist(LayerNode.group([left, right]), tags.values.global)).toThrow(
-      "Tag global has conflicting implementations for test/GraphDatabase",
-    )
-  })
-
-  test("treats dependency groups as transparent while hoisting", () => {
-    const tags = LayerNode.tags({ location: ["global"], global: [] })
-    const global = tags.make("global")
-    const location = tags.make("location")
-    const database = global({
-      service: Database,
-      layer: Layer.succeed(Database, Database.of({ name: "Alice" })),
-      deps: [],
-    })
-    const users = location({
-      service: Users,
-      layer: Layer.effect(Users, Effect.as(Database, Users.of({ list: Effect.succeed([]) }))),
-      deps: [LayerNode.group([database])],
-    })
-    const result = LayerNode.hoist(LayerNode.group([users]), tags.values.global)
-
-    expect(result.node.dependencies[0]?.dependencies[0]?.dependencies[0]).toMatchObject({
-      kind: "group",
-      dependencies: [],
-    })
-  })
-})