fix(core): share session runtime coordination

fix(core): route subagent through session runtime
refactor(core): add location session runtime
2026-06-28 19:47:17 +00:00 · 2026-06-28 19:39:07 +00:00 · 2026-06-28 19:34:35 +00:00 · 2026-06-28 19:21:34 +00:00 · 2026-06-28 14:02:46 -04:00 · 2026-06-28 12:52:39 -04:00
185 changed files with 6922 additions and 5514 deletions
@@ -6,6 +6,7 @@ on:
    branches:
      - ci
      - dev
+      - v2
      - beta
      - fix/npm-native-binary-install
      - snapshot-*
@@ -31,6 +32,9 @@ permissions:
  contents: write
  packages: write

+env:
+  OPENCODE_CHANNEL: ${{ (github.ref_name == 'v2' && 'next') || '' }}
+
 jobs:
  version:
    runs-on: blacksmith-4vcpu-ubuntu-2404
@@ -122,7 +126,7 @@ jobs:
      - build-cli
      - version
    runs-on: blacksmith-4vcpu-windows-2025
-    if: github.repository == 'anomalyco/opencode'
+    if: github.repository == 'anomalyco/opencode' && github.ref_name != 'v2'
    env:
      AZURE_CLIENT_ID: ${{ secrets.AZURE_CLIENT_ID }}
      AZURE_TENANT_ID: ${{ secrets.AZURE_TENANT_ID }}
@@ -221,7 +225,7 @@ jobs:
    needs:
      - build-cli
      - version
-    if: github.repository == 'anomalyco/opencode'
+    if: github.repository == 'anomalyco/opencode' && github.ref_name != 'v2'
    continue-on-error: false
    env:
      AZURE_CLIENT_ID: ${{ secrets.AZURE_CLIENT_ID }}
@@ -447,6 +451,7 @@ jobs:
          path: packages/opencode/dist

      - uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4.3.0
+        if: github.ref_name != 'v2'
        with:
          name: opencode-cli-signed-windows
          path: packages/opencode/dist
@@ -4,6 +4,7 @@ on:
  push:
    branches:
      - dev
+      - v2
  pull_request:
  workflow_dispatch:

@@ -74,13 +75,9 @@ jobs:
        working-directory: packages/client
        run: bun run check:generated

-      - name: Run HttpApi exerciser gates
-        if: runner.os == 'Linux'
-        working-directory: packages/opencode
-        run: bun run test:httpapi
-
  e2e:
    name: e2e (${{ matrix.settings.name }})
+    if: github.ref_name != 'v2' && github.head_ref != 'v2'
    strategy:
      fail-fast: false
      matrix:
@@ -94,7 +94,7 @@
      "name": "@opencode-ai/cli",
      "version": "1.17.11",
      "bin": {
-        "lildax": "./bin/lildax.cjs",
+        "opencode2": "./bin/opencode2.cjs",
      },
      "dependencies": {
        "@effect/platform-node": "catalog:",
@@ -106,12 +106,15 @@
        "@opentui/solid": "catalog:",
        "@parcel/watcher": "2.5.1",
        "effect": "catalog:",
+        "jsonc-parser": "3.3.1",
+        "semver": "catalog:",
        "solid-js": "catalog:",
      },
      "devDependencies": {
        "@opencode-ai/script": "workspace:*",
        "@tsconfig/bun": "catalog:",
        "@types/bun": "catalog:",
+        "@types/semver": "catalog:",
        "@typescript/native-preview": "catalog:",
      },
    },
@@ -936,6 +939,7 @@
        "@opentui/core": "catalog:",
        "@opentui/keymap": "catalog:",
        "@opentui/solid": "catalog:",
+        "@solid-primitives/event-bus": "1.1.2",
        "clipboardy": "4.0.0",
        "diff": "catalog:",
        "effect": "catalog:",
@@ -5979,6 +5983,8 @@

    "@openauthjs/openauth/jose": ["jose@5.9.6", "", {}, "sha512-AMlnetc9+CV9asI19zHmrgS/WYsWUwCn2R7RzlbJWD7F9eWYUTGyBmU9o6PxngtLGOiDGPRu+Uc4fhKzbpteZQ=="],

+    "@opencode-ai/cli/semver": ["semver@7.7.4", "", { "bin": { "semver": "bin/semver.js" } }, "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA=="],
+
    "@opencode-ai/core/@ai-sdk/openai": ["@ai-sdk/openai@3.0.53", "", { "dependencies": { "@ai-sdk/provider": "3.0.8", "@ai-sdk/provider-utils": "4.0.23" }, "peerDependencies": { "zod": "^3.25.76 || ^4.1.8" } }, "sha512-Wld+Rbc05KaUn08uBt06eEuwcgalcIFtIl32Yp+GxuZXUQwOb6YeAuq+C6da4ch6BurFoqEaLemJVwjBb7x+PQ=="],

    "@opencode-ai/core/@ai-sdk/openai-compatible": ["@ai-sdk/openai-compatible@2.0.41", "", { "dependencies": { "@ai-sdk/provider": "3.0.8", "@ai-sdk/provider-utils": "4.0.23" }, "peerDependencies": { "zod": "^3.25.76 || ^4.1.8" } }, "sha512-kNAGINk71AlOXx10Dq/PXw4t/9XjdK8uxfpVElRwtSFMdeSiLVt58p9TPx4/FJD+hxZuVhvxYj9r42osxWq79g=="],
@@ -2,11 +2,12 @@
  "$schema": "https://json.schemastore.org/package.json",
  "name": "opencode",
  "description": "AI-powered development tool",
+  "version": "0.0.0",
  "private": true,
  "type": "module",
  "packageManager": "bun@1.3.14",
  "scripts": {
-    "dev": "bun run --cwd packages/opencode --conditions=browser src/index.ts",
+    "dev": "bun run --cwd packages/cli --conditions=browser src/index.ts",
    "dev:desktop": "bun --cwd packages/desktop dev",
    "dev:web": "bun --cwd packages/app dev",
    "dev:console": "ulimit -n 10240 2>/dev/null; bun run --cwd packages/console/app dev",
@@ -9,7 +9,7 @@ import { useSync } from "@/context/sync"
 import { useLanguage } from "@/context/language"
 import { useProviders } from "@/hooks/use-providers"
 import { useSDK } from "@/context/sdk"
-import { getSessionContext, getSessionTokenTotal } from "@/components/session/session-context-metrics"
+import { getSessionContextMetrics } from "@/components/session/session-context-metrics"
 import { useSessionLayout } from "@/pages/session/session-layout"
 import { createSessionTabs } from "@/pages/session/helpers"

@@ -45,7 +45,6 @@ export function SessionContextUsage(props: SessionContextUsageProps) {
    normalizeTab: (tab) => (tab.startsWith("file://") ? file.tab(tab) : tab),
  })
  const messages = createMemo(() => (params.id ? (sync().data.message[params.id] ?? []) : []))
-  const info = createMemo(() => (params.id ? sync().session.get(params.id) : undefined))

  const usd = createMemo(
    () =>
@@ -55,10 +54,10 @@ export function SessionContextUsage(props: SessionContextUsageProps) {
      }),
  )

-  const context = createMemo(() => getSessionContext(messages(), [...providers.all().values()]))
-  const tokens = createMemo(() => info()?.tokens)
+  const metrics = createMemo(() => getSessionContextMetrics(messages(), [...providers.all().values()]))
+  const context = createMemo(() => metrics().context)
  const cost = createMemo(() => {
-    return usd().format(info()?.cost ?? 0)
+    return usd().format(metrics().totalCost)
  })

  const openContext = () => {
@@ -83,22 +82,18 @@ export function SessionContextUsage(props: SessionContextUsageProps) {

  const tooltipValue = () => (
    <div>
-      <Show when={tokens()}>
-        {(value) => (
-          <div class="flex items-center gap-2">
-            <span class="text-text-invert-strong">
-              {getSessionTokenTotal(value())?.toLocaleString(language.intl())}
-            </span>
-            <span class="text-text-invert-base">{language.t("context.usage.tokens")}</span>
-          </div>
-        )}
-      </Show>
      <Show when={context()}>
        {(ctx) => (
-          <div class="flex items-center gap-2">
-            <span class="text-text-invert-strong">{ctx().usage ?? 0}%</span>
-            <span class="text-text-invert-base">{language.t("context.usage.usage")}</span>
-          </div>
+          <>
+            <div class="flex items-center gap-2">
+              <span class="text-text-invert-strong">{ctx().total.toLocaleString(language.intl())}</span>
+              <span class="text-text-invert-base">{language.t("context.usage.tokens")}</span>
+            </div>
+            <div class="flex items-center gap-2">
+              <span class="text-text-invert-strong">{ctx().usage ?? 0}%</span>
+              <span class="text-text-invert-base">{language.t("context.usage.usage")}</span>
+            </div>
+          </>
        )}
      </Show>
      <div class="flex items-center gap-2">
@@ -1,6 +1,6 @@
 import { describe, expect, test } from "bun:test"
 import type { Message } from "@opencode-ai/sdk/v2/client"
-import { getSessionContext, getSessionTokenTotal } from "./session-context-metrics"
+import { getSessionContextMetrics } from "./session-context-metrics"

 const assistant = (
  id: string,
@@ -37,8 +37,8 @@ const user = (id: string) => {
  } as unknown as Message
 }

-describe("getSessionContext", () => {
-  test("computes usage from latest assistant with tokens", () => {
+describe("getSessionContextMetrics", () => {
+  test("computes totals and usage from latest assistant with tokens", () => {
    const messages = [
      user("u1"),
      assistant("a1", { input: 0, output: 0, reasoning: 0, read: 0, write: 0 }, 0.5),
@@ -57,52 +57,45 @@ describe("getSessionContext", () => {
      },
    ]

-    const ctx = getSessionContext(messages, providers)
+    const metrics = getSessionContextMetrics(messages, providers)

-    expect(ctx?.message.id).toBe("a2")
-    expect(ctx?.usage).toBe(50)
-    expect(ctx?.providerLabel).toBe("OpenAI")
-    expect(ctx?.modelLabel).toBe("GPT-4.1")
+    expect(metrics.totalCost).toBe(1.75)
+    expect(metrics.context?.message.id).toBe("a2")
+    expect(metrics.context?.total).toBe(500)
+    expect(metrics.context?.usage).toBe(50)
+    expect(metrics.context?.providerLabel).toBe("OpenAI")
+    expect(metrics.context?.modelLabel).toBe("GPT-4.1")
  })

  test("preserves fallback labels and null usage when model metadata is missing", () => {
    const messages = [assistant("a1", { input: 40, output: 10, reasoning: 0, read: 0, write: 0 }, 0.1, "p-1", "m-1")]
    const providers = [{ id: "p-1", models: {} }]

-    const ctx = getSessionContext(messages, providers)
+    const metrics = getSessionContextMetrics(messages, providers)

-    expect(ctx?.providerLabel).toBe("p-1")
-    expect(ctx?.modelLabel).toBe("m-1")
-    expect(ctx?.limit).toBeUndefined()
-    expect(ctx?.usage).toBeNull()
+    expect(metrics.context?.providerLabel).toBe("p-1")
+    expect(metrics.context?.modelLabel).toBe("m-1")
+    expect(metrics.context?.limit).toBeUndefined()
+    expect(metrics.context?.usage).toBeNull()
  })

  test("recomputes when message array is mutated in place", () => {
    const messages = [assistant("a1", { input: 10, output: 10, reasoning: 10, read: 10, write: 10 }, 0.25)]
    const providers = [{ id: "openai", models: {} }]

-    const one = getSessionContext(messages, providers)
+    const one = getSessionContextMetrics(messages, providers)
    messages.push(assistant("a2", { input: 100, output: 20, reasoning: 0, read: 0, write: 0 }, 0.75))
-    const two = getSessionContext(messages, providers)
+    const two = getSessionContextMetrics(messages, providers)

-    expect(one?.message.id).toBe("a1")
-    expect(two?.message.id).toBe("a2")
+    expect(one.context?.message.id).toBe("a1")
+    expect(two.context?.message.id).toBe("a2")
+    expect(two.totalCost).toBe(1)
  })

-  test("returns undefined when inputs are undefined", () => {
-    const ctx = getSessionContext(undefined, undefined)
+  test("returns empty metrics when inputs are undefined", () => {
+    const metrics = getSessionContextMetrics(undefined, undefined)

-    expect(ctx).toBeUndefined()
-  })
-
-  test("computes stored session token totals", () => {
-    expect(
-      getSessionTokenTotal({
-        input: 10,
-        output: 20,
-        reasoning: 30,
-        cache: { read: 40, write: 50 },
-      }),
-    ).toBe(150)
+    expect(metrics.totalCost).toBe(0)
+    expect(metrics.context).toBeUndefined()
  })
 })
@@ -1,4 +1,4 @@
-import type { AssistantMessage, Message, Session } from "@opencode-ai/sdk/v2/client"
+import type { AssistantMessage, Message } from "@opencode-ai/sdk/v2/client"

 type Provider = {
  id: string
@@ -21,9 +21,19 @@ type Context = {
  modelLabel: string
  limit: number | undefined
  input: number
+  output: number
+  reasoning: number
+  cacheRead: number
+  cacheWrite: number
+  total: number
  usage: number | null
 }

+type Metrics = {
+  totalCost: number
+  context: Context | undefined
+}
+
 const tokenTotal = (msg: AssistantMessage) => {
  return msg.tokens.input + msg.tokens.output + msg.tokens.reasoning + msg.tokens.cache.read + msg.tokens.cache.write
 }
@@ -37,9 +47,10 @@ const lastAssistantWithTokens = (messages: Message[]) => {
  }
 }

-const build = (messages: Message[] = [], providers: Provider[] = []): Context | undefined => {
+const build = (messages: Message[] = [], providers: Provider[] = []): Metrics => {
+  const totalCost = messages.reduce((sum, msg) => sum + (msg.role === "assistant" ? msg.cost : 0), 0)
  const message = lastAssistantWithTokens(messages)
-  if (!message) return undefined
+  if (!message) return { totalCost, context: undefined }

  const provider = providers.find((item) => item.id === message.providerID)
  const model = provider?.models[message.modelID]
@@ -47,22 +58,25 @@ const build = (messages: Message[] = [], providers: Provider[] = []): Context |
  const total = tokenTotal(message)

  return {
-    message,
-    provider,
-    model,
-    providerLabel: provider?.name ?? message.providerID,
-    modelLabel: model?.name ?? message.modelID,
-    limit,
-    input: message.tokens.input,
-    usage: limit ? Math.round((total / limit) * 100) : null,
+    totalCost,
+    context: {
+      message,
+      provider,
+      model,
+      providerLabel: provider?.name ?? message.providerID,
+      modelLabel: model?.name ?? message.modelID,
+      limit,
+      input: message.tokens.input,
+      output: message.tokens.output,
+      reasoning: message.tokens.reasoning,
+      cacheRead: message.tokens.cache.read,
+      cacheWrite: message.tokens.cache.write,
+      total,
+      usage: limit ? Math.round((total / limit) * 100) : null,
+    },
  }
 }

-export function getSessionContext(messages: Message[] = [], providers: Provider[] = []) {
+export function getSessionContextMetrics(messages: Message[] = [], providers: Provider[] = []) {
  return build(messages, providers)
 }
-
-export function getSessionTokenTotal(tokens: Session["tokens"] | undefined) {
-  if (!tokens) return undefined
-  return tokens.input + tokens.output + tokens.reasoning + tokens.cache.read + tokens.cache.write
-}
@@ -15,7 +15,7 @@ import { useLanguage } from "@/context/language"
 import { useProviders } from "@/hooks/use-providers"
 import { useSDK } from "@/context/sdk"
 import { useSessionLayout } from "@/pages/session/session-layout"
-import { getSessionContext, getSessionTokenTotal } from "./session-context-metrics"
+import { getSessionContextMetrics } from "./session-context-metrics"
 import { estimateSessionContextBreakdown, type SessionContextBreakdownKey } from "./session-context-breakdown"
 import { createSessionContextFormatter } from "./session-context-format"

@@ -134,12 +134,12 @@ export function SessionContextTab() {
      }),
  )

-  const ctx = createMemo(() => getSessionContext(messages(), [...providers.all().values()]))
-  const tokens = createMemo(() => info()?.tokens)
+  const metrics = createMemo(() => getSessionContextMetrics(messages(), [...providers.all().values()]))
+  const ctx = createMemo(() => metrics().context)
  const formatter = createMemo(() => createSessionContextFormatter(language.intl()))

  const cost = createMemo(() => {
-    return usd().format(info()?.cost ?? 0)
+    return usd().format(metrics().totalCost)
  })

  const counts = createMemo(() => {
@@ -204,14 +204,14 @@ export function SessionContextTab() {
    { label: "context.stats.provider", value: providerLabel },
    { label: "context.stats.model", value: modelLabel },
    { label: "context.stats.limit", value: () => formatter().number(ctx()?.limit) },
-    { label: "context.stats.totalTokens", value: () => formatter().number(getSessionTokenTotal(tokens())) },
+    { label: "context.stats.totalTokens", value: () => formatter().number(ctx()?.total) },
    { label: "context.stats.usage", value: () => formatter().percent(ctx()?.usage) },
-    { label: "context.stats.inputTokens", value: () => formatter().number(tokens()?.input) },
-    { label: "context.stats.outputTokens", value: () => formatter().number(tokens()?.output) },
-    { label: "context.stats.reasoningTokens", value: () => formatter().number(tokens()?.reasoning) },
+    { label: "context.stats.inputTokens", value: () => formatter().number(ctx()?.input) },
+    { label: "context.stats.outputTokens", value: () => formatter().number(ctx()?.output) },
+    { label: "context.stats.reasoningTokens", value: () => formatter().number(ctx()?.reasoning) },
    {
      label: "context.stats.cacheTokens",
-      value: () => `${formatter().number(tokens()?.cache.read)} / ${formatter().number(tokens()?.cache.write)}`,
+      value: () => `${formatter().number(ctx()?.cacheRead)} / ${formatter().number(ctx()?.cacheWrite)}`,
    },
    { label: "context.stats.userMessages", value: () => counts().user.toLocaleString(language.intl()) },
    { label: "context.stats.assistantMessages", value: () => counts().assistant.toLocaleString(language.intl()) },
@@ -1,7 +1,7 @@
 import { createSimpleContext } from "@opencode-ai/ui/context"
 import { base64Encode } from "@opencode-ai/core/util/encode"
 import { useParams } from "@solidjs/router"
-import { batch, createEffect, createMemo, startTransition } from "solid-js"
+import { batch, createEffect, createMemo } from "solid-js"
 import { createStore } from "solid-js/store"
 import { useModels } from "@/context/models"
 import { useProviders } from "@/hooks/use-providers"
@@ -294,21 +294,19 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
        model.set({ providerID: entry.provider.id, modelID: entry.id })
      },
      set(item: ModelKey | undefined, options?: { recent?: boolean }) {
-        startTransition(() =>
-          batch(() => {
-            setStore("last", {
-              type: "model",
-              agent: agent.current()?.name,
-              model: item ?? null,
-              variant: selected(),
-            })
-            write({ model: item })
-            if (!item) return
-            models.setVisibility(item, true)
-            if (!options?.recent) return
-            models.recent.push(item)
-          }),
-        )
+        batch(() => {
+          setStore("last", {
+            type: "model",
+            agent: agent.current()?.name,
+            model: item ?? null,
+            variant: selected(),
+          })
+          write({ model: item })
+          if (!item) return
+          models.setVisibility(item, true)
+          if (!options?.recent) return
+          models.recent.push(item)
+        })
      },
      visible(item: ModelKey) {
        return models.visible(item)
@@ -337,21 +335,19 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
          return Object.keys(item.variants)
        },
        set(value: string | undefined) {
-          startTransition(() =>
-            batch(() => {
-              const model = current()
-              setStore("last", {
-                type: "variant",
-                agent: agent.current()?.name,
-                model: model ? { providerID: model.provider.id, modelID: model.id } : null,
-                variant: value ?? null,
-              })
-              write({ variant: value ?? null })
-              if (model) {
-                models.variant.set({ providerID: model.provider.id, modelID: model.id }, value ?? undefined)
-              }
-            }),
-          )
+          batch(() => {
+            const model = current()
+            setStore("last", {
+              type: "variant",
+              agent: agent.current()?.name,
+              model: model ? { providerID: model.provider.id, modelID: model.id } : null,
+              variant: value ?? null,
+            })
+            write({ variant: value ?? null })
+            if (model) {
+              models.variant.set({ providerID: model.provider.id, modelID: model.id }, value ?? undefined)
+            }
+          })
        },
        cycle() {
          const items = this.list()
@@ -138,14 +138,12 @@ export const { use: useTabs, provider: TabsProvider } = createSimpleContext({
        const next = { type: "session" as const, ...tab }
        const existing = store.find((item) => tabKey(item) === tabKey(next))
        if (existing) return existing
-        void startTransition(() => {
-          setStore(
-            produce((tabs) => {
-              if (tabs.some((item) => tabKey(item) === tabKey(next))) return
-              tabs.push(next)
-            }),
-          )
-        })
+        setStore(
+          produce((tabs) => {
+            if (tabs.some((item) => tabKey(item) === tabKey(next))) return
+            tabs.push(next)
+          }),
+        )
        return next
      },
      reorder(keys: string[]) {
@@ -0,0 +1,98 @@
+# V2 CLI and TUI development guide
+
+## Migration context
+
+- The TUI is being ported from legacy APIs to the new V2 APIs. New and migrated TUI behavior should use `sdk.client.v2` and the location-scoped data in `packages/tui/src/context/data.tsx` instead of adding dependencies on legacy sync state.
+- Preserve established TUI behavior unless the task intentionally changes it. When behavior, copy, keyboard interaction, or layout is unclear, compare the local V2 TUI with the latest released legacy TUI.
+- Run both versions in separate Terminal Control sessions and save PNG-only captures at equivalent states:
+
+```bash
+# From packages/cli: local V2 TUI
+termctrl start opencode-v2-dev --host opentui --cols 112 --rows 34 -- bun dev --standalone
+
+# Released legacy TUI behavior reference
+termctrl start opencode-legacy --host opentui --cols 112 --rows 34 -- bunx opencode-ai@latest
+
+termctrl save opencode-v2-dev --format png --out /tmp/opencode/v2.png
+termctrl save opencode-legacy --format png --out /tmp/opencode/legacy.png
+```
+
+- Use the same viewport and send equivalent inputs to both sessions before comparing screenshots. The released CLI is a behavioral reference, not a source of V2 API design; keep the local implementation on V2 endpoints.
+- Stop both sessions after comparison: `termctrl stop opencode-v2-dev` and `termctrl stop opencode-legacy`.
+
+## Interactive debugging
+
+- This package is the V2 CLI adapter. Run its `dev` script when testing the TUI; do not use the repository-root `bun dev`, which launches the legacy `packages/opencode` CLI.
+- Run commands from `packages/cli`. Use `bun dev --standalone` for most debugging so the TUI starts with a private V2 server instead of depending on the background service.
+- Use `termctrl` for interactive checks instead of starting the TUI as a blocking foreground process. It provides a real PTY, handles OpenTUI's host handshake, and can save reviewable screenshots.
+- Use a dedicated session name and do not reuse or kill an unrelated session.
+
+```bash
+termctrl start opencode-v2-dev --host opentui --cols 112 --rows 34 -- bun dev --standalone
+termctrl wait opencode-v2-dev "Ask anything" --timeout 20000
+termctrl show opencode-v2-dev
+```
+
+- Wait for visible text before interacting instead of relying on fixed sleeps. Use the text expected from the screen under test, such as `Ask anything` or `Connect a provider`.
+- Drive the running TUI with `termctrl send`. Prefix typed input with `text:` and send control keys separately so the interaction matches real terminal input.
+
+```bash
+termctrl send opencode-v2-dev 'text:example prompt' enter
+termctrl send opencode-v2-dev ctrl-c
+```
+
+- Use `termctrl show` after each meaningful interaction and inspect the full visible screen for rendering errors, stale state, error toasts, and unexpected exits.
+- Save PNG evidence for every user-visible bug and fix. Do not save text captures; inspect the rendered PNG. Write temporary captures outside the repository unless the artifact is intended to be committed.
+
+```bash
+termctrl save opencode-v2-dev --format png --out /tmp/opencode/v2-tui.png
+```
+
+- For resize-sensitive changes, resize the viewport, wait for the expected content, and capture the screen again:
+
+```bash
+termctrl resize opencode-v2-dev --cols 100 --rows 30
+termctrl show opencode-v2-dev
+```
+
+- Source changes may require restarting the process. Use `termctrl restart opencode-v2-dev` rather than assuming the running TUI reloaded the change.
+- To exercise background-service behavior, omit `--standalone`. Service lifecycle commands are available through `bun dev service start`, `bun dev service status`, and `bun dev service stop`.
+- Always clean up the Terminal Control session when the check is complete:
+
+```bash
+termctrl stop opencode-v2-dev
+```
+
+## Server/API debugging
+
+- Use `bun dev api --help` from `packages/cli` to inspect the API debugging command. It sends one request to the V2 server using the same daemon discovery/auth path as the CLI.
+- Use `bun dev api` to introspect the server-side data backing the TUI. This is useful when debugging UI bugs: compare what the screen renders with the raw session, message, event, agent, or health data returned by the API to determine whether the bug is in the server state, the client data layer, or the TUI rendering.
+- `bun dev api` accepts either an OpenAPI operation ID or a raw HTTP method plus path:
+
+```bash
+bun dev api get /health
+bun dev api get /openapi.json
+bun dev api <operationId> --param key=value
+```
+
+- Pass JSON request bodies with `--data`/`-d`; the command sets `content-type: application/json` automatically unless you provide a header. Add extra headers with `--header`/`-H name:value`.
+- If no compatible background server is registered, `bun dev api` starts one through the daemon service. Use `bun dev service status`, `bun dev service restart`, and `bun dev service stop` when you need explicit lifecycle control.
+- Prefer raw method/path calls for quick server debugging and operation IDs when exercising documented OpenAPI routes with path or query parameters.
+
+## Debugger
+
+- To debug the V2 CLI or TUI with Bun's inspector, launch the CLI entrypoint through Terminal Control with an inspector URL, then attach a debugger to that URL:
+
+```bash
+termctrl start opencode-v2-debug --host opentui --cols 112 --rows 34 -- \
+  bun run --inspect=ws://localhost:6499/ src/index.ts --standalone
+```
+
+- Use `--inspect-wait` or `--inspect-brk` when execution must pause until the debugger attaches.
+- Use `termctrl logs opencode-v2-debug` for inspector output or startup failures emitted before the TUI renderer starts. Use `termctrl show` for the visible full-screen TUI.
+
+## Verification
+
+- Run `bun typecheck` from `packages/cli` after CLI adapter changes.
+- Run `bun typecheck` and `bun test` from `packages/tui` after shared TUI changes. Do not run tests from the repository root.
+- Treat automated checks and Terminal Control smoke tests as complementary. For user-visible changes, verify initial render, the changed interaction, Ctrl-C exit behavior, and save a screenshot of the corrected state.
@@ -31,11 +31,11 @@ function run(target) {

 const envPath = process.env.OPENCODE_BIN_PATH
 const scriptDir = path.dirname(fs.realpathSync(__filename))
-const cached = path.join(scriptDir, ".lildax")
+const cached = path.join(scriptDir, ".opencode2")
 const platform = { darwin: "darwin", linux: "linux", win32: "windows" }[os.platform()] || os.platform()
 const arch = { x64: "x64", arm64: "arm64", arm: "arm" }[os.arch()] || os.arch()
 const base = "@opencode-ai/cli-" + platform + "-" + arch
-const binary = platform === "windows" ? "lildax.exe" : "lildax"
+const binary = platform === "windows" ? "opencode2.exe" : "opencode2"

 function supportsAvx2() {
  if (arch !== "x64") return false
@@ -121,7 +121,7 @@ function findBinary(startDir) {
 const resolved = envPath || (fs.existsSync(cached) ? cached : findBinary(scriptDir))
 if (!resolved) {
  console.error(
-    "It seems that your package manager failed to install the right lildax CLI package. Try manually installing " +
+    "It seems that your package manager failed to install the right opencode2 CLI package. Try manually installing " +
      names.map((name) => `"${name}"`).join(" or ") +
      " package",
  )
@@ -5,7 +5,7 @@
  "type": "module",
  "license": "MIT",
  "bin": {
-    "lildax": "./bin/lildax.cjs"
+    "opencode2": "./bin/opencode2.cjs"
  },
  "files": [
    "bin"
@@ -25,12 +25,15 @@
    "@opentui/solid": "catalog:",
    "@parcel/watcher": "2.5.1",
    "effect": "catalog:",
+    "jsonc-parser": "3.3.1",
+    "semver": "catalog:",
    "solid-js": "catalog:"
  },
  "devDependencies": {
    "@opencode-ai/script": "workspace:*",
    "@tsconfig/bun": "catalog:",
    "@types/bun": "catalog:",
+    "@types/semver": "catalog:",
    "@typescript/native-preview": "catalog:"
  }
 }
@@ -10,7 +10,7 @@ import pkg from "../package.json"
 import { modelsData } from "./generate"

 const dir = path.resolve(import.meta.dirname, "..")
-const binary = "lildax"
+const binary = "opencode2"
 process.chdir(dir)

 await rm("dist", { recursive: true, force: true })
@@ -25,14 +25,15 @@ for (const filepath of new Bun.Glob("*/package.json").scanSync({ cwd: "./dist" }
 }
 console.log("binaries", binaries)
 const version = Object.values(binaries)[0]
+const name = pkg.name

-await $`mkdir -p ./dist/${pkg.name}/bin`
-await $`cp ./bin/lildax.cjs ./dist/${pkg.name}/bin/lildax`
-await Bun.file(`./dist/${pkg.name}/package.json`).write(
+await $`mkdir -p ./dist/${name}/bin`
+await $`cp ./bin/opencode2.cjs ./dist/${name}/bin/opencode2`
+await Bun.file(`./dist/${name}/package.json`).write(
  JSON.stringify(
    {
-      name: pkg.name,
-      bin: { lildax: "./bin/lildax" },
+      name,
+      bin: { opencode2: "./bin/opencode2" },
      version,
      license: pkg.license,
      repository: { type: "git", url: "git+https://github.com/anomalyco/opencode.git" },
@@ -50,4 +51,4 @@ await Promise.all(
    publish(`./dist/${name.replace("@opencode-ai/", "")}`, name, version),
  ),
 )
-await publish(`./dist/${pkg.name}`, pkg.name, version)
+await publish(`./dist/${name}`, name, version)
@@ -5,6 +5,16 @@ declare const OPENCODE_CLI_NAME: string | undefined

 export const Commands = Spec.make(typeof OPENCODE_CLI_NAME === "string" ? OPENCODE_CLI_NAME : "opencode", {
  description: "OpenCode 2.0 preview command line interface",
+  params: {
+    directory: Argument.string("directory").pipe(
+      Argument.withDescription("Directory to start OpenCode in"),
+      Argument.optional,
+    ),
+    standalone: Flag.boolean("standalone").pipe(
+      Flag.withDescription("Run with a private server instead of the background service"),
+      Flag.withDefault(false),
+    ),
+  },
  commands: [
    Spec.make("api", {
      description: "Make a request to the running server",
@@ -46,6 +56,7 @@ export const Commands = Spec.make(typeof OPENCODE_CLI_NAME === "string" ? OPENCO
        hostname: Flag.string("hostname").pipe(Flag.withDefault("127.0.0.1")),
        port: Flag.integer("port").pipe(Flag.optional),
        register: Flag.boolean("register").pipe(Flag.withDefault(false)),
+        stdio: Flag.boolean("stdio").pipe(Flag.withDefault(false)),
      },
    }),
  ],
@@ -1,13 +1,27 @@
 import { Commands } from "../commands"
 import { Runtime } from "../../framework/runtime"
-import { Effect } from "effect"
+import { Effect, Option } from "effect"
 import { Daemon } from "../../services/daemon"
+import { Standalone } from "../../services/standalone"
+import { Updater } from "../../services/updater"

-export default Runtime.handler(Commands, () =>
+export default Runtime.handler(Commands, (input) =>
  Effect.gen(function* () {
+    const directory = Option.getOrUndefined(input.directory)
+    if (directory !== undefined) process.chdir(directory)
+    const updater = yield* Updater.Service
+    yield* updater.check()
    const daemon = yield* Daemon.Service
-    const transport = yield* daemon.transport()
+    const transport = yield* (input.standalone ? Standalone.transport() : daemon.transport())
    const { runTui } = yield* Effect.promise(() => import("../../tui"))
-    yield* runTui(transport)
+    yield* runTui(
+      transport,
+      input.standalone
+        ? undefined
+        : async () => {
+            await Effect.runPromise(daemon.stop())
+            return Effect.runPromise(daemon.transport())
+          },
+    )
  }),
 )
@@ -6,9 +6,12 @@ import * as Effect from "effect/Effect"
 import { HttpRouter, HttpServer } from "effect/unstable/http"
 import { createServer } from "node:http"
 import { createRoutes } from "@opencode-ai/server/routes"
+import { ServerAuth } from "@opencode-ai/server/auth"
+import { createOpencodeClient } from "@opencode-ai/sdk/v2/client"
 import { Commands } from "../commands"
 import { Runtime } from "../../framework/runtime"
 import { Daemon } from "../../services/daemon"
+import { Updater } from "../../services/updater"

 export default Runtime.handler(
  Commands.commands.serve,
@@ -16,15 +19,43 @@ export default Runtime.handler(
    return yield* Effect.scoped(
      Effect.gen(function* () {
        const daemon = yield* Daemon.Service
-        const address = yield* listen(input.hostname, input.port, yield* daemon.password())
+        const standalonePassword = process.env.OPENCODE_SERVER_PASSWORD
+        if (input.stdio) delete process.env.OPENCODE_SERVER_PASSWORD
+        const password = input.stdio ? standalonePassword : yield* daemon.password()
+        if (!password) return yield* Effect.fail(new Error("Missing server password"))
+        const address = yield* listen(input.hostname, input.port, password)
+        yield* Effect.tryPromise(() =>
+          createOpencodeClient({
+            baseUrl: HttpServer.formatAddress(address),
+            headers: ServerAuth.headers({ password }),
+          }).v2.location.get(undefined, { throwOnError: true }),
+        )
        if (input.register) yield* daemon.register(address)
-        console.log(`server listening on ${HttpServer.formatAddress(address)}`)
-        return yield* Effect.never
-      }),
+        const url = HttpServer.formatAddress(address)
+        console.log(input.stdio ? JSON.stringify({ url }) : `server listening on ${url}`)
+        const updater = yield* Updater.Service
+        yield* updater.check().pipe(Effect.forkScoped)
+        return yield* (input.stdio ? waitForStdinClose() : Effect.never)
+      }).pipe(Effect.annotateLogs({ role: "server" })),
    )
  }),
 )

+function waitForStdinClose() {
+  return Effect.callback<void>((resume) => {
+    const close = () => resume(Effect.void)
+    process.stdin.once("end", close)
+    process.stdin.once("close", close)
+    process.stdin.resume()
+    if (process.stdin.readableEnded || process.stdin.destroyed) close()
+    return Effect.sync(() => {
+      process.stdin.off("end", close)
+      process.stdin.off("close", close)
+      process.stdin.pause()
+    })
+  })
+}
+
 function listen(hostname: string, port: Option.Option<number>, password: string) {
  if (Option.isSome(port)) return bind(hostname, port.value, password)
  const next = (port: number): ReturnType<typeof bind> =>
@@ -35,11 +66,15 @@ function listen(hostname: string, port: Option.Option<number>, password: string)
 }

 function bind(hostname: string, port: number, password: string) {
+  const server = createServer()
  return Layer.build(
    HttpRouter.serve(createRoutes(password), { disableListenLog: true, disableLogger: true }).pipe(
-      Layer.provideMerge(NodeHttpServer.layer(() => createServer(), { port, host: hostname })),
+      Layer.provideMerge(NodeHttpServer.layer(() => server, { port, host: hostname })),
      Layer.provide(Credential.defaultLayer),
      Layer.provide(PermissionSaved.defaultLayer),
    ),
-  ).pipe(Effect.map((context) => Context.get(context, HttpServer.HttpServer).address))
+  ).pipe(
+    Effect.tap(() => Effect.addFinalizer(() => Effect.sync(() => server.closeAllConnections()))),
+    Effect.map((context) => Context.get(context, HttpServer.HttpServer).address),
+  )
 }
@@ -8,6 +8,6 @@ export default Runtime.handler(
  Commands.commands.service.commands.status,
  Effect.fn("cli.service.status")(function* () {
    const url = yield* (yield* Daemon.Service).status()
-    process.stdout.write((url ? `running ${url}` : "stopped") + EOL)
+    process.stdout.write((url ? url : "stopped") + EOL)
  }),
 )
@@ -2,6 +2,8 @@ import * as Effect from "effect/Effect"
 import * as Command from "effect/unstable/cli/Command"
 import { Spec } from "./spec"
 import { Daemon } from "../services/daemon"
+import { Updater } from "../services/updater"
+import { Scope } from "effect"

 export type Input<Value> =
  Value extends Spec.Node<infer _Name, infer Command, infer _Commands>
@@ -10,11 +12,11 @@ export type Input<Value> =
      ? Input
      : never

-type RuntimeHandler = (input: unknown) => Effect.Effect<void, unknown, Daemon.Service>
+type RuntimeHandler = (input: unknown) => Effect.Effect<void, unknown, Daemon.Service | Updater.Service | Scope.Scope>
 type Loader<Node extends Spec.Any> = () => Promise<{
-  default: (input: Input<Node>) => Effect.Effect<void, any, Daemon.Service>
+  default: (input: Input<Node>) => Effect.Effect<void, any, Daemon.Service | Updater.Service | Scope.Scope>
 }>
-type ProvidedCommand = Command.Command<string, unknown, unknown, unknown, Daemon.Service>
+type ProvidedCommand = Command.Command<string, unknown, unknown, unknown, Daemon.Service | Updater.Service | Scope.Scope>

 export type Handlers<Node extends Spec.Any> = keyof Node["commands"] extends never
  ? Loader<Node>
@@ -2,10 +2,21 @@

 import * as NodeRuntime from "@effect/platform-node/NodeRuntime"
 import * as NodeServices from "@effect/platform-node/NodeServices"
+import { NodeFileSystem } from "@effect/platform-node"
 import * as Effect from "effect/Effect"
+import { Layer, Logger, References } from "effect"
 import { Commands } from "./commands/commands"
 import { Runtime } from "./framework/runtime"
 import { Daemon } from "./services/daemon"
+import { Logging } from "@opencode-ai/core/observability/logging"
+import { Updater } from "./services/updater"
+import { InstallationChannel, InstallationVersion, InstallationLocal } from "@opencode-ai/core/installation/version"
+
+const LoggingLayer = Logger.layer(Logging.loggers(), { mergeWithExisting: false }).pipe(
+  Layer.provide(NodeFileSystem.layer),
+  Layer.orDie,
+  Layer.merge(Layer.succeed(References.MinimumLogLevel, Logging.minimumLogLevel())),
+)

 const Handlers = Runtime.handlers(Commands, {
  $: () => import("./commands/handlers/default"),
@@ -24,9 +35,14 @@ const Handlers = Runtime.handlers(Commands, {
  serve: () => import("./commands/handlers/serve"),
 })

-Runtime.run(Commands, Handlers, { version: "local" }).pipe(
+Effect.logInfo("cli starting", { version: InstallationVersion, channel: InstallationChannel, local: InstallationLocal }).pipe(
+  Effect.flatMap(() => Runtime.run(Commands, Handlers, { version: InstallationVersion })),
+  Effect.annotateLogs({ role: "cli" }),
  Effect.provide(Daemon.defaultLayer),
+  Effect.provide(Updater.defaultLayer),
+  Effect.provide(LoggingLayer),
  Effect.provide(NodeServices.layer),
  Effect.scoped,
+  Effect.tap(() => Effect.sync(() => process.exit(0))),
  NodeRuntime.runMain,
 )
@@ -1,5 +1,5 @@
 import { Global } from "@opencode-ai/core/global"
-import { InstallationVersion } from "@opencode-ai/core/installation/version"
+import { InstallationChannel, InstallationVersion } from "@opencode-ai/core/installation/version"
 import { createOpencodeClient } from "@opencode-ai/sdk/v2/client"
 import { ServerAuth } from "@opencode-ai/server/auth"
 import { Context, Effect, FileSystem, Layer, Option, Schedule, Schema, Scope } from "effect"
@@ -28,6 +28,10 @@ const Registration = Schema.Struct({
 })
 type Registration = typeof Registration.Type

+const Config = Schema.Struct({
+  password: Schema.optional(Schema.String),
+})
+
 function sameRegistration(left: Registration, right: Registration) {
  return left.id === right.id && left.version === right.version && left.url === right.url && left.pid === right.pid
 }
@@ -37,22 +41,30 @@ export const layer = Layer.effect(
  Effect.gen(function* () {
    const fs = yield* FileSystem.FileSystem
    const directory = Global.Path.state
-    const file = path.join(directory, "server.json")
-    const passwordFile = path.join(directory, "password")
+    const file = path.join(directory, InstallationChannel === "local" ? "server-local.json" : "server.json")
+    const configFile = path.join(Global.Path.config, "service.json")
+    const legacyPasswordFile = path.join(directory, "password")
    const decodeRegistration = Schema.decodeUnknownEffect(Schema.fromJsonString(Registration))
+    const decodeConfig = Schema.decodeUnknownEffect(Schema.fromJsonString(Config))

    const password = Effect.fn("cli.daemon.password")(function* (value?: string) {
-      const existing = yield* fs.readFileString(passwordFile).pipe(Effect.catch(() => Effect.succeed(undefined)))
-      if (value === undefined && existing) return existing
+      const config = yield* fs
+        .readFileString(configFile)
+        .pipe(Effect.flatMap(decodeConfig), Effect.catch(() => Effect.succeed(undefined)))
+      if (value === undefined && config?.password) return config.password
+
+      const legacy = yield* fs
+        .readFileString(legacyPasswordFile)
+        .pipe(Effect.catch(() => Effect.succeed(undefined)))
+      const next = value ?? legacy ?? randomBytes(32).toString("base64url")

      // Keep one private credential across server restarts so discovered clients
      // can reconnect without exposing a password flag or environment variable.
-      const generated = value ?? randomBytes(32).toString("base64url")
-      const temp = passwordFile + ".tmp"
-      yield* fs.makeDirectory(directory, { recursive: true })
-      yield* fs.writeFileString(temp, generated, { mode: 0o600 })
-      yield* fs.rename(temp, passwordFile)
-      return generated
+      const temp = configFile + ".tmp"
+      yield* fs.writeFileString(temp, JSON.stringify({ password: next }, null, 2) + "\n", { mode: 0o600 })
+      yield* fs.rename(temp, configFile)
+      if (legacy) yield* fs.remove(legacyPasswordFile).pipe(Effect.ignore)
+      return next
    })

    const registration = Effect.fnUntraced(function* () {
@@ -111,7 +123,7 @@ export const layer = Layer.effect(
      const existing = yield* healthy().pipe(Effect.option)
      const found = Option.getOrUndefined(existing)
      const compiled = path.basename(process.execPath).replace(/\.exe$/, "") !== "bun"
-      if (found?.version === InstallationVersion && compiled) return found.url
+      if (found?.version === InstallationVersion) return found.url
      if (found) yield* stopProcess(found).pipe(Effect.ignore)

      const entrypoint = compiled ? undefined : process.argv[1]
@@ -0,0 +1,41 @@
+import { ServerAuth } from "@opencode-ai/server/auth"
+import { CrossSpawnSpawner } from "@opencode-ai/core/cross-spawn-spawner"
+import { Effect, Schema, Stream } from "effect"
+import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process"
+import { randomBytes } from "node:crypto"
+import path from "node:path"
+
+const Ready = Schema.Struct({ url: Schema.String })
+const decodeReady = Schema.decodeUnknownPromise(Schema.fromJsonString(Ready))
+
+function command(password: string) {
+  const compiled = path.basename(process.execPath).replace(/\.exe$/, "") !== "bun"
+  const entrypoint = compiled ? [] : process.argv[1] ? [process.argv[1]] : []
+  if (!compiled && entrypoint.length === 0) throw new Error("Failed to resolve CLI entrypoint")
+  return ChildProcess.make(process.execPath, [...entrypoint, "serve", "--stdio", "--port", "0"], {
+    cwd: process.cwd(),
+    env: { OPENCODE_SERVER_PASSWORD: password },
+    extendEnv: true,
+    // The server treats EOF on this pipe as the end of its ownership lease.
+    // The OS closes it even when the TUI is killed before Effect finalizers run.
+    stdin: "pipe",
+    stderr: "ignore",
+    killSignal: "SIGTERM",
+    forceKillAfter: "3 seconds",
+  })
+}
+
+export const transport = Effect.fn("cli.standalone.transport")(
+  function* () {
+    const password = randomBytes(32).toString("base64url")
+    const spawner = yield* ChildProcessSpawner.ChildProcessSpawner
+    const proc = yield* spawner.spawn(command(password))
+    const output = yield* proc.stdout.pipe(Stream.decodeText(), Stream.splitLines, Stream.take(1), Stream.mkString)
+    if (!output) return yield* Effect.fail(new Error("Standalone server exited before reporting readiness"))
+    const ready = yield* Effect.tryPromise(() => decodeReady(output))
+    return { url: ready.url, headers: ServerAuth.headers({ password }), pid: proc.pid }
+  },
+  Effect.provide(CrossSpawnSpawner.defaultLayer),
+)
+
+export * as Standalone from "./standalone"
@@ -0,0 +1,33 @@
+import { describe, expect, test } from "bun:test"
+import { action, decodePolicy } from "./updater"
+
+describe("updater", () => {
+  test("reads autoupdate from JSONC", () => {
+    expect(decodePolicy('{ // preference\n "autoupdate": "notify",\n}')).toBe("notify")
+    expect(decodePolicy('{ "autoupdate": false }')).toBe(false)
+    expect(decodePolicy('{ "autoupdate": "invalid" }')).toBeUndefined()
+  })
+
+  test("automatically updates patches and minors", () => {
+    expect(action("1.2.3", "1.2.4", true)).toBe("upgrade")
+    expect(action("1.2.3", "1.3.0", true)).toBe("upgrade")
+    expect(action("1.2.3", "1.2.4", "notify")).toBe("upgrade")
+    expect(action("1.2.3", "1.3.0", "notify")).toBe("upgrade")
+  })
+
+  test("skips when autoupdate is disabled", () => {
+    expect(action("1.2.3", "1.2.4", false)).toBe("none")
+  })
+
+  test("never automatically updates majors", () => {
+    expect(action("1.2.3", "2.0.0", true)).toBe("none")
+  })
+
+  test("reports up-to-date only when versions match", () => {
+    expect(action("1.2.3", "1.2.3", true)).toBe("none")
+  })
+
+  test("upgrades when latest is lower (rollback)", () => {
+    expect(action("1.2.4", "1.2.3", true)).toBe("upgrade")
+  })
+})
@@ -0,0 +1,158 @@
+import { Global } from "@opencode-ai/core/global"
+import { Flag } from "@opencode-ai/core/flag/flag"
+import { AppProcess } from "@opencode-ai/core/process"
+import {
+  InstallationChannel,
+  InstallationLocal,
+  InstallationVersion,
+} from "@opencode-ai/core/installation/version"
+import { Context, Duration, Effect, FileSystem, Layer } from "effect"
+import { ChildProcess } from "effect/unstable/process"
+import { parse, type ParseError } from "jsonc-parser"
+import path from "node:path"
+import semver from "semver"
+
+export type Policy = boolean | "notify"
+export type Action = "none" | "upgrade"
+type Method = "npm" | "pnpm" | "bun" | "yarn"
+
+const packageName = "@opencode-ai/cli"
+
+export interface Interface {
+  readonly check: () => Effect.Effect<void>
+}
+
+export class Service extends Context.Service<Service, Interface>()("@opencode/cli/Updater") {}
+
+export function decodePolicy(text: string): Policy | undefined {
+  // The CLI only projects this host-level preference instead of initializing
+  // the location-scoped server configuration graph.
+  const errors: ParseError[] = []
+  const input: unknown = parse(text, errors, { allowTrailingComma: true })
+  if (errors.length || typeof input !== "object" || input === null || !("autoupdate" in input)) return
+  const value = input.autoupdate
+  if (typeof value === "boolean" || value === "notify") return value
+}
+
+export function action(current: string, latest: string, policy: Policy): Action {
+  if (policy === false) return "none"
+  if (!semver.valid(current) || !semver.valid(latest) || semver.eq(latest, current)) return "none"
+  // Major upgrades are never installed automatically.
+  if (semver.major(latest) !== semver.major(current)) return "none"
+  return "upgrade"
+}
+
+export const layer = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem
+    const global = yield* Global.Service
+    const appProcess = yield* AppProcess.Service
+    const channel = InstallationChannel.replace(/[^a-zA-Z0-9._-]/g, "-")
+
+    const readPolicy = Effect.fnUntraced(function* () {
+      const values = yield* Effect.forEach(["config.json", "opencode.json", "opencode.jsonc"], (name) =>
+        fs
+          .readFileString(path.join(global.config, name))
+          .pipe(Effect.map(decodePolicy), Effect.catch(() => Effect.succeed(undefined))),
+      )
+      return values.findLast((value) => value !== undefined) ?? true
+    })
+
+    const run = Effect.fnUntraced(function* (command: string[], timeout: Duration.Input = "10 seconds") {
+      return yield* appProcess
+        .run(ChildProcess.make(command[0], command.slice(1)), {
+          timeout,
+          maxOutputBytes: 100_000,
+          maxErrorBytes: 100_000,
+        })
+        .pipe(
+          Effect.map((result) => ({
+            code: result.exitCode,
+            stdout: result.stdout.toString("utf8"),
+            stderr: result.stderr.toString("utf8"),
+          })),
+          Effect.catch(() => Effect.succeed({ code: 1, stdout: "", stderr: "" })),
+        )
+    })
+
+    const method = Effect.fnUntraced(function* () {
+      const checks: ReadonlyArray<{ method: Method; command: string[] }> = [
+        { method: "npm", command: ["npm", "list", "-g", "--depth=0", packageName] },
+        { method: "pnpm", command: ["pnpm", "list", "-g", "--depth=0", packageName] },
+        { method: "bun", command: ["bun", "pm", "ls", "-g"] },
+        { method: "yarn", command: ["yarn", "global", "list"] },
+      ]
+      const results = yield* Effect.forEach(
+        checks,
+        (check) => run(check.command).pipe(Effect.map((result) => ({ check, result }))),
+        { concurrency: "unbounded" },
+      )
+      return results.find((result) => result.result.stdout.includes(packageName))?.check.method
+    })
+
+    const latest = Effect.fnUntraced(function* () {
+      const response = yield* Effect.tryPromise({
+        try: () =>
+          fetch(
+            `https://registry.npmjs.org/${encodeURIComponent(packageName)}/${encodeURIComponent(InstallationChannel)}`,
+            { headers: { "User-Agent": `opencode/${InstallationVersion}` }, signal: AbortSignal.timeout(10_000) },
+          ),
+        catch: (cause) => new Error("Failed to check for updates", { cause }),
+      })
+      if (!response.ok) return yield* Effect.fail(new Error(`Update check failed with status ${response.status}`))
+      const data = yield* Effect.tryPromise({
+        try: () => response.json(),
+        catch: (cause) => new Error("Failed to read update information", { cause }),
+      })
+      if (typeof data !== "object" || data === null || !("version" in data) || typeof data.version !== "string") {
+        return yield* Effect.fail(new Error("Update information did not include a version"))
+      }
+      return data.version
+    })
+
+    const upgrade = Effect.fnUntraced(function* (method: Method, version: string) {
+      const target = `${packageName}@${version}`
+      const commands: Record<Method, string[]> = {
+        npm: ["npm", "install", "--global", target],
+        pnpm: ["pnpm", "install", "--global", target],
+        bun: ["bun", "install", "--global", target],
+        yarn: ["yarn", "global", "add", target],
+      }
+      const result = yield* run(commands[method], "5 minutes")
+      if (result.code === 0) return
+      return yield* Effect.fail(new Error(result.stderr.trim() || `Failed to update with ${method}`))
+    })
+
+    const check = Effect.fn("cli.updater.check")(function* () {
+      if (InstallationLocal || Flag.OPENCODE_DISABLE_AUTOUPDATE)
+        return yield* Effect.logInfo("update check skipped", {
+          reason: InstallationLocal ? "local-install" : "disabled",
+          version: InstallationVersion,
+          channel: InstallationChannel,
+        })
+      const policy = yield* readPolicy()
+      if (policy === false) return yield* Effect.logInfo("update check skipped", { reason: "policy-disabled" })
+
+      return yield* Effect.gen(function* () {
+        const version = yield* latest()
+        yield* Effect.logInfo("update check", {
+          current: InstallationVersion,
+          latest: version,
+        })
+        const next = action(InstallationVersion, version, policy)
+        if (next === "none") return yield* Effect.logInfo("update check done", { action: "up-to-date" })
+        const detected = yield* method()
+        if (!detected) return yield* Effect.logWarning("automatic update skipped: installation method not found")
+        yield* upgrade(detected, version)
+        yield* Effect.logInfo("updated OpenCode", { from: InstallationVersion, to: version, method: detected })
+      })
+    }, Effect.catchCause((cause) => Effect.logWarning("automatic update failed", { cause })))
+
+    return Service.of({ check })
+  }),
+)
+
+export const defaultLayer = layer.pipe(Layer.provide(AppProcess.defaultLayer), Layer.provide(Global.defaultLayer))
+
+export * as Updater from "./updater"
@@ -2,35 +2,45 @@ import { run } from "@opencode-ai/tui"
 import { TuiConfig } from "@opencode-ai/tui/config"
 import { Effect } from "effect"
 import { Global } from "@opencode-ai/core/global"
+import { loadBuiltinPlugins } from "@opencode-ai/tui/builtins"
+import { createOpencodeClient } from "@opencode-ai/sdk/v2/client"

-export function runTui(transport: { url: string; headers: RequestInit["headers"] }) {
+type Transport = { url: string; headers: RequestInit["headers"] }
+
+export function runTui(transport: Transport, reload?: () => Promise<Transport>) {
  const config = TuiConfig.resolve({}, { terminalSuspend: false })
-  return run({
-    ...transport,
-    args: {},
-    config,
-    fetch: gracefulFetch,
-    pluginHost: {
-      async start() {},
-      async dispose() {},
-    },
+  let disposeSlots: (() => void) | undefined
+  return Effect.gen(function* () {
+    const options = { baseUrl: transport.url, headers: transport.headers }
+    const client = createOpencodeClient(options)
+    const directory = yield* Effect.tryPromise(() =>
+      client.v2.fs.list({ location: { directory: process.cwd() } }, { throwOnError: true }),
+    ).pipe(
+      Effect.map((response) => response.data.location.directory),
+      Effect.catch(() =>
+        Effect.tryPromise(() => client.v2.location.get(undefined, { throwOnError: true })).pipe(
+          Effect.map((response) => response.data.directory),
+        ),
+      ),
+    )
+    return yield* run({
+      client: createOpencodeClient({ ...options, directory }),
+      reload: reload
+        ? async () => {
+            const next = await reload()
+            return createOpencodeClient({ baseUrl: next.url, headers: next.headers, directory })
+          }
+        : undefined,
+      args: {},
+      config,
+      pluginHost: {
+        async start(input) {
+          disposeSlots = await loadBuiltinPlugins(input.api, input.runtime)
+        },
+        async dispose() {
+          disposeSlots?.()
+        },
+      },
+    })
  }).pipe(Effect.provide(Global.defaultLayer))
 }
-
-const legacyDefaults: Record<string, unknown> = {
-  "/config/providers": { providers: [], default: {} },
-  "/provider": { all: [], default: {}, connected: [] },
-  "/agent": [],
-  "/config": {},
-}
-
-const gracefulFetch = Object.assign(
-  async (input: RequestInfo | URL, init?: RequestInit) => {
-    const response = await fetch(input, init)
-    if (response.status !== 404) return response
-    const fallback = legacyDefaults[new URL(input instanceof Request ? input.url : input).pathname]
-    if (fallback === undefined) return response
-    return Response.json(fallback)
-  },
-  { preconnect: fetch.preconnect },
-)
@@ -0,0 +1,15 @@
+import { Effect } from "effect"
+import path from "node:path"
+import { Standalone } from "../../src/services/standalone"
+
+process.argv[1] = path.join(import.meta.dir, "../../src/index.ts")
+
+await Effect.runPromise(
+  Effect.scoped(
+    Effect.gen(function* () {
+      const transport = yield* Standalone.transport()
+      console.log(`${transport.pid} ${transport.url}`)
+      return yield* Effect.never
+    }),
+  ),
+)
@@ -0,0 +1,65 @@
+import { expect, test } from "bun:test"
+import path from "node:path"
+
+test("standalone server exits when its owner is killed", async () => {
+  const owner = Bun.spawn([process.execPath, path.join(import.meta.dir, "fixture/standalone-owner.ts")], {
+    cwd: path.join(import.meta.dir, ".."),
+    env: process.env,
+    stdin: "ignore",
+    stdout: "pipe",
+    stderr: "pipe",
+  })
+  const line = await Promise.race([readLine(owner.stdout), Bun.sleep(10_000).then(() => undefined)])
+  const [rawPID, url] = line?.split(" ") ?? []
+  const pid = Number(rawPID)
+
+  try {
+    expect(pid).toBeGreaterThan(0)
+    expect(url).toStartWith("http://127.0.0.1:")
+    expect(running(pid)).toBe(true)
+
+    owner.kill("SIGKILL")
+    await owner.exited
+
+    expect(await waitForExit(pid)).toBe(true)
+  } finally {
+    owner.kill("SIGKILL")
+    if (running(pid)) process.kill(pid, "SIGKILL")
+  }
+})
+
+async function readLine(stream: ReadableStream<Uint8Array>) {
+  const reader = stream.getReader()
+  const decoder = new TextDecoder()
+  const chunks: string[] = []
+  while (true) {
+    const result = await reader.read()
+    if (result.done) break
+    chunks.push(decoder.decode(result.value, { stream: true }))
+    const output = chunks.join("")
+    const newline = output.indexOf("\n")
+    if (newline !== -1) {
+      reader.releaseLock()
+      return output.slice(0, newline)
+    }
+  }
+  reader.releaseLock()
+  return chunks.join("") + decoder.decode()
+}
+
+async function waitForExit(pid: number, attempts = 100): Promise<boolean> {
+  if (!running(pid)) return true
+  if (attempts === 0) return false
+  await Bun.sleep(50)
+  return waitForExit(pid, attempts - 1)
+}
+
+function running(pid: number) {
+  if (!Number.isSafeInteger(pid) || pid <= 0) return false
+  try {
+    process.kill(pid, 0)
+    return true
+  } catch {
+    return false
+  }
+}
@@ -106,15 +106,25 @@ const Endpoint3_5 = (raw: RawClient["server.session"]) => (input: Endpoint3_5Inp
    Effect.mapError(mapClientError),
  )

-type Endpoint3_6Request = Parameters<RawClient["server.session"]["session.prompt"]>[0]
+type Endpoint3_6Request = Parameters<RawClient["server.session"]["session.rename"]>[0]
 type Endpoint3_6Input = {
  readonly sessionID: Endpoint3_6Request["params"]["sessionID"]
-  readonly id?: Endpoint3_6Request["payload"]["id"]
-  readonly prompt: Endpoint3_6Request["payload"]["prompt"]
-  readonly delivery?: Endpoint3_6Request["payload"]["delivery"]
-  readonly resume?: Endpoint3_6Request["payload"]["resume"]
+  readonly title: Endpoint3_6Request["payload"]["title"]
 }
 const Endpoint3_6 = (raw: RawClient["server.session"]) => (input: Endpoint3_6Input) =>
+  raw["session.rename"]({ params: { sessionID: input["sessionID"] }, payload: { title: input["title"] } }).pipe(
+    Effect.mapError(mapClientError),
+  )
+
+type Endpoint3_7Request = Parameters<RawClient["server.session"]["session.prompt"]>[0]
+type Endpoint3_7Input = {
+  readonly sessionID: Endpoint3_7Request["params"]["sessionID"]
+  readonly id?: Endpoint3_7Request["payload"]["id"]
+  readonly prompt: Endpoint3_7Request["payload"]["prompt"]
+  readonly delivery?: Endpoint3_7Request["payload"]["delivery"]
+  readonly resume?: Endpoint3_7Request["payload"]["resume"]
+}
+const Endpoint3_7 = (raw: RawClient["server.session"]) => (input: Endpoint3_7Input) =>
  raw["session.prompt"]({
    params: { sessionID: input["sessionID"] },
    payload: { id: input["id"], prompt: input["prompt"], delivery: input["delivery"], resume: input["resume"] },
@@ -123,23 +133,23 @@ const Endpoint3_6 = (raw: RawClient["server.session"]) => (input: Endpoint3_6Inp
    Effect.map((value) => value.data),
  )

-type Endpoint3_7Request = Parameters<RawClient["server.session"]["session.compact"]>[0]
-type Endpoint3_7Input = { readonly sessionID: Endpoint3_7Request["params"]["sessionID"] }
-const Endpoint3_7 = (raw: RawClient["server.session"]) => (input: Endpoint3_7Input) =>
-  raw["session.compact"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError))
-
-type Endpoint3_8Request = Parameters<RawClient["server.session"]["session.wait"]>[0]
+type Endpoint3_8Request = Parameters<RawClient["server.session"]["session.compact"]>[0]
 type Endpoint3_8Input = { readonly sessionID: Endpoint3_8Request["params"]["sessionID"] }
 const Endpoint3_8 = (raw: RawClient["server.session"]) => (input: Endpoint3_8Input) =>
+  raw["session.compact"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError))
+
+type Endpoint3_9Request = Parameters<RawClient["server.session"]["session.wait"]>[0]
+type Endpoint3_9Input = { readonly sessionID: Endpoint3_9Request["params"]["sessionID"] }
+const Endpoint3_9 = (raw: RawClient["server.session"]) => (input: Endpoint3_9Input) =>
  raw["session.wait"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError))

-type Endpoint3_9Request = Parameters<RawClient["server.session"]["session.revert.stage"]>[0]
-type Endpoint3_9Input = {
-  readonly sessionID: Endpoint3_9Request["params"]["sessionID"]
-  readonly messageID: Endpoint3_9Request["payload"]["messageID"]
-  readonly files?: Endpoint3_9Request["payload"]["files"]
+type Endpoint3_10Request = Parameters<RawClient["server.session"]["session.revert.stage"]>[0]
+type Endpoint3_10Input = {
+  readonly sessionID: Endpoint3_10Request["params"]["sessionID"]
+  readonly messageID: Endpoint3_10Request["payload"]["messageID"]
+  readonly files?: Endpoint3_10Request["payload"]["files"]
 }
-const Endpoint3_9 = (raw: RawClient["server.session"]) => (input: Endpoint3_9Input) =>
+const Endpoint3_10 = (raw: RawClient["server.session"]) => (input: Endpoint3_10Input) =>
  raw["session.revert.stage"]({
    params: { sessionID: input["sessionID"] },
    payload: { messageID: input["messageID"], files: input["files"] },
@@ -148,42 +158,42 @@ const Endpoint3_9 = (raw: RawClient["server.session"]) => (input: Endpoint3_9Inp
    Effect.map((value) => value.data),
  )

-type Endpoint3_10Request = Parameters<RawClient["server.session"]["session.revert.clear"]>[0]
-type Endpoint3_10Input = { readonly sessionID: Endpoint3_10Request["params"]["sessionID"] }
-const Endpoint3_10 = (raw: RawClient["server.session"]) => (input: Endpoint3_10Input) =>
-  raw["session.revert.clear"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError))
-
-type Endpoint3_11Request = Parameters<RawClient["server.session"]["session.revert.commit"]>[0]
+type Endpoint3_11Request = Parameters<RawClient["server.session"]["session.revert.clear"]>[0]
 type Endpoint3_11Input = { readonly sessionID: Endpoint3_11Request["params"]["sessionID"] }
 const Endpoint3_11 = (raw: RawClient["server.session"]) => (input: Endpoint3_11Input) =>
-  raw["session.revert.commit"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError))
+  raw["session.revert.clear"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError))

-type Endpoint3_12Request = Parameters<RawClient["server.session"]["session.context"]>[0]
+type Endpoint3_12Request = Parameters<RawClient["server.session"]["session.revert.commit"]>[0]
 type Endpoint3_12Input = { readonly sessionID: Endpoint3_12Request["params"]["sessionID"] }
 const Endpoint3_12 = (raw: RawClient["server.session"]) => (input: Endpoint3_12Input) =>
+  raw["session.revert.commit"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError))
+
+type Endpoint3_13Request = Parameters<RawClient["server.session"]["session.context"]>[0]
+type Endpoint3_13Input = { readonly sessionID: Endpoint3_13Request["params"]["sessionID"] }
+const Endpoint3_13 = (raw: RawClient["server.session"]) => (input: Endpoint3_13Input) =>
  raw["session.context"]({ params: { sessionID: input["sessionID"] } }).pipe(
    Effect.mapError(mapClientError),
    Effect.map((value) => value.data),
  )

-type Endpoint3_13Request = Parameters<RawClient["server.session"]["session.history"]>[0]
-type Endpoint3_13Input = {
-  readonly sessionID: Endpoint3_13Request["params"]["sessionID"]
-  readonly limit?: Endpoint3_13Request["query"]["limit"]
-  readonly after?: Endpoint3_13Request["query"]["after"]
+type Endpoint3_14Request = Parameters<RawClient["server.session"]["session.history"]>[0]
+type Endpoint3_14Input = {
+  readonly sessionID: Endpoint3_14Request["params"]["sessionID"]
+  readonly limit?: Endpoint3_14Request["query"]["limit"]
+  readonly after?: Endpoint3_14Request["query"]["after"]
 }
-const Endpoint3_13 = (raw: RawClient["server.session"]) => (input: Endpoint3_13Input) =>
+const Endpoint3_14 = (raw: RawClient["server.session"]) => (input: Endpoint3_14Input) =>
  raw["session.history"]({
    params: { sessionID: input["sessionID"] },
    query: { limit: input["limit"], after: input["after"] },
  }).pipe(Effect.mapError(mapClientError))

-type Endpoint3_14Request = Parameters<RawClient["server.session"]["session.events"]>[0]
-type Endpoint3_14Input = {
-  readonly sessionID: Endpoint3_14Request["params"]["sessionID"]
-  readonly after?: Endpoint3_14Request["query"]["after"]
+type Endpoint3_15Request = Parameters<RawClient["server.session"]["session.events"]>[0]
+type Endpoint3_15Input = {
+  readonly sessionID: Endpoint3_15Request["params"]["sessionID"]
+  readonly after?: Endpoint3_15Request["query"]["after"]
 }
-const Endpoint3_14 = (raw: RawClient["server.session"]) => (input: Endpoint3_14Input) =>
+const Endpoint3_15 = (raw: RawClient["server.session"]) => (input: Endpoint3_15Input) =>
  Stream.unwrap(
    raw["session.events"]({ params: { sessionID: input["sessionID"] }, query: { after: input["after"] } }).pipe(
      Effect.mapError(mapClientError),
@@ -191,17 +201,17 @@ const Endpoint3_14 = (raw: RawClient["server.session"]) => (input: Endpoint3_14I
    ),
  )

-type Endpoint3_15Request = Parameters<RawClient["server.session"]["session.interrupt"]>[0]
-type Endpoint3_15Input = { readonly sessionID: Endpoint3_15Request["params"]["sessionID"] }
-const Endpoint3_15 = (raw: RawClient["server.session"]) => (input: Endpoint3_15Input) =>
+type Endpoint3_16Request = Parameters<RawClient["server.session"]["session.interrupt"]>[0]
+type Endpoint3_16Input = { readonly sessionID: Endpoint3_16Request["params"]["sessionID"] }
+const Endpoint3_16 = (raw: RawClient["server.session"]) => (input: Endpoint3_16Input) =>
  raw["session.interrupt"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError))

-type Endpoint3_16Request = Parameters<RawClient["server.session"]["session.message"]>[0]
-type Endpoint3_16Input = {
-  readonly sessionID: Endpoint3_16Request["params"]["sessionID"]
-  readonly messageID: Endpoint3_16Request["params"]["messageID"]
+type Endpoint3_17Request = Parameters<RawClient["server.session"]["session.message"]>[0]
+type Endpoint3_17Input = {
+  readonly sessionID: Endpoint3_17Request["params"]["sessionID"]
+  readonly messageID: Endpoint3_17Request["params"]["messageID"]
 }
-const Endpoint3_16 = (raw: RawClient["server.session"]) => (input: Endpoint3_16Input) =>
+const Endpoint3_17 = (raw: RawClient["server.session"]) => (input: Endpoint3_17Input) =>
  raw["session.message"]({ params: { sessionID: input["sessionID"], messageID: input["messageID"] } }).pipe(
    Effect.mapError(mapClientError),
    Effect.map((value) => value.data),
@@ -214,17 +224,18 @@ const adaptGroup3 = (raw: RawClient["server.session"]) => ({
  get: Endpoint3_3(raw),
  switchAgent: Endpoint3_4(raw),
  switchModel: Endpoint3_5(raw),
-  prompt: Endpoint3_6(raw),
-  compact: Endpoint3_7(raw),
-  wait: Endpoint3_8(raw),
-  stage: Endpoint3_9(raw),
-  clear: Endpoint3_10(raw),
-  commit: Endpoint3_11(raw),
-  context: Endpoint3_12(raw),
-  history: Endpoint3_13(raw),
-  events: Endpoint3_14(raw),
-  interrupt: Endpoint3_15(raw),
-  message: Endpoint3_16(raw),
+  rename: Endpoint3_6(raw),
+  prompt: Endpoint3_7(raw),
+  compact: Endpoint3_8(raw),
+  wait: Endpoint3_9(raw),
+  stage: Endpoint3_10(raw),
+  clear: Endpoint3_11(raw),
+  commit: Endpoint3_12(raw),
+  context: Endpoint3_13(raw),
+  history: Endpoint3_14(raw),
+  events: Endpoint3_15(raw),
+  interrupt: Endpoint3_16(raw),
+  message: Endpoint3_17(raw),
 })

 type Endpoint4_0Request = Parameters<RawClient["server.message"]["session.messages"]>[0]
@@ -15,6 +15,8 @@ import type {
  SessionsSwitchAgentOutput,
  SessionsSwitchModelInput,
  SessionsSwitchModelOutput,
+  SessionsRenameInput,
+  SessionsRenameOutput,
  SessionsPromptInput,
  SessionsPromptOutput,
  SessionsCompactInput,
@@ -367,6 +369,18 @@ export function make(options: ClientOptions) {
          },
          requestOptions,
        ),
+      rename: (input: SessionsRenameInput, requestOptions?: RequestOptions) =>
+        request<SessionsRenameOutput>(
+          {
+            method: "POST",
+            path: `/api/session/${encodeURIComponent(input.sessionID)}/rename`,
+            body: { title: input["title"] },
+            successStatus: 204,
+            declaredStatuses: [404, 400, 401],
+            empty: true,
+          },
+          requestOptions,
+        ),
      prompt: (input: SessionsPromptInput, requestOptions?: RequestOptions) =>
        request<{ readonly data: SessionsPromptOutput }>(
          {
@@ -408,7 +422,7 @@ export function make(options: ClientOptions) {
            path: `/api/session/${encodeURIComponent(input.sessionID)}/revert/stage`,
            body: { messageID: input["messageID"], files: input["files"] },
            successStatus: 200,
-            declaredStatuses: [404, 500, 400, 401],
+            declaredStatuses: [404, 409, 500, 400, 401],
            empty: false,
          },
          requestOptions,
@@ -419,7 +433,7 @@ export function make(options: ClientOptions) {
            method: "POST",
            path: `/api/session/${encodeURIComponent(input.sessionID)}/revert/clear`,
            successStatus: 204,
-            declaredStatuses: [404, 500, 400, 401],
+            declaredStatuses: [404, 409, 500, 400, 401],
            empty: true,
          },
          requestOptions,
@@ -430,7 +444,7 @@ export function make(options: ClientOptions) {
            method: "POST",
            path: `/api/session/${encodeURIComponent(input.sessionID)}/revert/commit`,
            successStatus: 204,
-            declaredStatuses: [404, 400, 401],
+            declaredStatuses: [404, 409, 400, 401],
            empty: true,
          },
          requestOptions,
@@ -58,6 +58,14 @@ export type MessageNotFoundError = {
 export const isMessageNotFoundError = (value: unknown): value is MessageNotFoundError =>
  typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "MessageNotFoundError"

+export type SessionBusyError = {
+  readonly _tag: "SessionBusyError"
+  readonly sessionID: string
+  readonly message: string
+}
+export const isSessionBusyError = (value: unknown): value is SessionBusyError =>
+  typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "SessionBusyError"
+
 export type UnknownError = {
  readonly _tag: "UnknownError"
  readonly message: string
@@ -381,6 +389,13 @@ export type SessionsSwitchModelInput = {

 export type SessionsSwitchModelOutput = void

+export type SessionsRenameInput = {
+  readonly sessionID: { readonly sessionID: string }["sessionID"]
+  readonly title: { readonly title: string }["title"]
+}
+
+export type SessionsRenameOutput = void
+
 export type SessionsPromptInput = {
  readonly sessionID: { readonly sessionID: string }["sessionID"]
  readonly id?: {
@@ -397,6 +412,7 @@ export type SessionsPromptInput = {
        readonly name: string
        readonly source?: { readonly start: number; readonly end: number; readonly text: string }
      }>
+      readonly system?: string
    }
    readonly delivery?: "steer" | "queue" | null
    readonly resume?: boolean | null
@@ -415,6 +431,7 @@ export type SessionsPromptInput = {
        readonly name: string
        readonly source?: { readonly start: number; readonly end: number; readonly text: string }
      }>
+      readonly system?: string
    }
    readonly delivery?: "steer" | "queue" | null
    readonly resume?: boolean | null
@@ -433,6 +450,7 @@ export type SessionsPromptInput = {
        readonly name: string
        readonly source?: { readonly start: number; readonly end: number; readonly text: string }
      }>
+      readonly system?: string
    }
    readonly delivery?: "steer" | "queue" | null
    readonly resume?: boolean | null
@@ -451,6 +469,7 @@ export type SessionsPromptInput = {
        readonly name: string
        readonly source?: { readonly start: number; readonly end: number; readonly text: string }
      }>
+      readonly system?: string
    }
    readonly delivery?: "steer" | "queue" | null
    readonly resume?: boolean | null
@@ -475,6 +494,7 @@ export type SessionsPromptOutput = {
        readonly name: string
        readonly source?: { readonly start: number; readonly end: number; readonly text: string }
      }>
+      readonly system?: string
    }
    readonly delivery: "steer" | "queue"
    readonly timeCreated: number
@@ -554,6 +574,7 @@ export type SessionsContextOutput = {
          readonly name: string
          readonly source?: { readonly start: number; readonly end: number; readonly text: string }
        }>
+        readonly system?: string
        readonly type: "user"
      }
    | {
@@ -723,6 +744,14 @@ export type SessionsHistoryOutput = {
          readonly subdirectory?: string
        }
      }
+    | {
+        readonly id: string
+        readonly metadata?: { readonly [x: string]: JsonValue }
+        readonly type: "session.next.renamed"
+        readonly durable?: { readonly aggregateID: string; readonly seq: number; readonly version: number }
+        readonly location?: { readonly directory: string; readonly workspaceID?: string }
+        readonly data: { readonly timestamp: number; readonly sessionID: string; readonly title: string }
+      }
    | {
        readonly id: string
        readonly metadata?: { readonly [x: string]: JsonValue }
@@ -746,6 +775,7 @@ export type SessionsHistoryOutput = {
              readonly name: string
              readonly source?: { readonly start: number; readonly end: number; readonly text: string }
            }>
+            readonly system?: string
          }
          readonly delivery: "steer" | "queue"
        }
@@ -773,6 +803,7 @@ export type SessionsHistoryOutput = {
              readonly name: string
              readonly source?: { readonly start: number; readonly end: number; readonly text: string }
            }>
+            readonly system?: string
          }
          readonly delivery: "steer" | "queue"
        }
@@ -1181,6 +1212,14 @@ export type SessionsEventsOutput =
        readonly subdirectory?: string
      }
    }
+  | {
+      readonly id: string
+      readonly metadata?: { readonly [x: string]: unknown }
+      readonly type: "session.next.renamed"
+      readonly durable?: { readonly aggregateID: string; readonly seq: number; readonly version: number }
+      readonly location?: { readonly directory: string; readonly workspaceID?: string }
+      readonly data: { readonly timestamp: number; readonly sessionID: string; readonly title: string }
+    }
  | {
      readonly id: string
      readonly metadata?: { readonly [x: string]: unknown }
@@ -1204,6 +1243,7 @@ export type SessionsEventsOutput =
            readonly name: string
            readonly source?: { readonly start: number; readonly end: number; readonly text: string }
          }>
+          readonly system?: string
        }
        readonly delivery: "steer" | "queue"
      }
@@ -1231,6 +1271,7 @@ export type SessionsEventsOutput =
            readonly name: string
            readonly source?: { readonly start: number; readonly end: number; readonly text: string }
          }>
+          readonly system?: string
        }
        readonly delivery: "steer" | "queue"
      }
@@ -1632,6 +1673,7 @@ export type SessionsMessageOutput = {
          readonly name: string
          readonly source?: { readonly start: number; readonly end: number; readonly text: string }
        }>
+        readonly system?: string
        readonly type: "user"
      }
    | {
@@ -1804,6 +1846,7 @@ export type MessagesListOutput = {
          readonly name: string
          readonly source?: { readonly start: number; readonly end: number; readonly text: string }
        }>
+        readonly system?: string
        readonly type: "user"
      }
    | {
@@ -3,7 +3,7 @@ import { z } from "zod"
 import { Resource } from "@opencode-ai/console-resource"
 import { safeEqual } from "@opencode-ai/console-core/util/crypto.js"

-const DISCORD_ALERT_ROLE_ID = "1520924666359713863"
+const DISCORD_ALERT_ROLE_ID = "1511795723262365887"

 const basePayload = z.object({
  name: z.string().optional(),
@@ -201,10 +201,7 @@ export async function handler(
            if (v === "$model") return headers.set(k, model)
            if (v === "$request") return headers.set(k, requestId)
            if (v === "$project") return headers.set(k, projectId)
-            if (v === "$workspace") {
-              if (authInfo?.workspaceID) headers.set(k, authInfo.workspaceID)
-              return
-            }
+            if (v === "$workspace" && authInfo?.workspaceID) return headers.set(k, authInfo.workspaceID)
            headers.set(k, v)
          })
          headers.delete("host")
@@ -1,23 +1,24 @@
+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: LayerNode.Replacements = []) {
-  let allReplacements = replacements
+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]))

-  // Only build the location service map if it's actually needed
-  if (LayerNode.hasUnbound(root, LocationServiceMap.node) && !hasReplacement(replacements, LocationServiceMap.node)) {
-    const locationMap = buildLocationServiceMap(replacements)
-    const locationMapNode = makeGlobalNode({ service: LocationServiceMap.Service, layer: locationMap, deps: [] })
-    allReplacements = replacements.concat([[LocationServiceMap.node, locationMapNode]])
+  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)
  }

-  return LayerNode.compile(root, allReplacements)
-}
+  const locationMap = buildLocationServiceMap(replacementMap)
+  const locationMapNode = makeGlobalNode({ service: LocationServiceMap.Service, layer: locationMap, deps: [] })

-function hasReplacement(replacements: LayerNode.Replacements, node: LayerNode.Node<unknown, unknown, any>) {
-  return replacements.some(([source]) => source.name === node.name)
+  const app = LayerNode.bind(root, LocationServiceMap.node, locationMapNode)
+
+  return LayerNode.compile(app, replacementMap)
 }

 export * as AppNodeBuilder from "./app-node-builder"
@@ -1 +0,0 @@
-File to save in: ~/.local/share/opencode/worktree/012780/location-layer-tiers/packages/core/src/effect/
@@ -111,52 +111,20 @@ export function group<const Items extends readonly AnyNode[]>(
  return { kind: "group", name: "group", dependencies }
 }

-export type Replacement = readonly [source: AnyNode, replacement: AnyNode | Layer.Any]
-export type Replacements = readonly Replacement[]
+export type Replacement = {
+  readonly source: Layer.Any
+  readonly replacement: Layer.Any
+}

 type CheckReplacementErrors<SourceError, ReplacementError> = [Exclude<ReplacementError, SourceError>] extends [never]
  ? unknown
  : { readonly "New replacement errors": Exclude<ReplacementError, SourceError> }

-type CheckReplacement<Item> = Item extends readonly [Node<infer A, infer E, infer T>, infer Replacement]
-  ? Replacement extends Node<NoInfer<A>, infer E2, T>
-    ? CheckReplacementErrors<E, NoInfer<E2>>
-    : Replacement extends Layer.Layer<NoInfer<A>, infer E2, never>
-      ? CheckReplacementErrors<E, NoInfer<E2>>
-      : { readonly "Invalid replacement": Replacement }
-  : { readonly "Invalid replacement": Item }
-
-type CheckReplacements<Items extends Replacements> = {
-  readonly [K in keyof Items]: CheckReplacement<Items[K]>
-}
-
-type ValidReplacements<Items extends Replacements> = Items & CheckReplacements<Items>
-
-function replacementNode(source: AnyNode, replacement: AnyNode | Layer.Any) {
-  const replacementNode = isNode(replacement)
-    ? replacement
-    : make({
-        ...nodeMakeIdentity(source),
-        layer: replacement as Layer.Layer<unknown, unknown>,
-        deps: [],
-        tag: source.tag,
-      })
-  if (source.name !== replacementNode.name) {
-    throw new Error(`Cannot replace ${source.name} with ${replacementNode.name}`)
-  }
-  if (source.tag !== replacementNode.tag) {
-    throw new Error(`Cannot replace ${source.name} across tags`)
-  }
-  return replacementNode
-}
-
-function nodeMakeIdentity(node: AnyNode): NodeIdentity {
-  if (node.service !== undefined) return { service: node.service }
-  return { name: node.name }
-}
-
-function isNode(input: Layer.Any | AnyNode): input is AnyNode {
-  return "kind" in input && "dependencies" in input
+export function replace<A, E, R, E2>(
+  source: Layer.Layer<A, E, R>,
+  replacement: Layer.Layer<NoInfer<A>, E2, never> & CheckReplacementErrors<E, NoInfer<E2>>,
+): Replacement {
+  return { source, replacement }
 }

 // Tree -----------------------------------------------------------------------
@@ -208,38 +176,32 @@ function walk<Result>(
  return recur(root)
 }

-export function hoist<A, E, T extends Tag, const Items extends Replacements = readonly []>(
+export function hoist<A, E, T extends Tag>(
  root: Node<A, E, any>,
  tag: T,
-  replacements?: ValidReplacements<Items>,
 ): {
  readonly node: Node<A, E>
  readonly hoisted: Node<unknown, E>
 } {
  const hoisted = new Map<string, AnyNode>()
-  const replacementMap = replacementMapFrom(replacements)

-  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
-      }
+  const node = walk<AnyNode>(root, (node, context) => {
+    if (node.kind === "group") {
      return { ...node, dependencies: node.dependencies.map(context.visit) }
-    },
-    { resolve: (node) => replacementMap.get(node.name) ?? node },
-  )
+    }
+    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>,
@@ -247,11 +209,10 @@ export function hoist<A, E, T extends Tag, const Items extends Replacements = re
  }
 }

-export function compile<A, E, const Items extends Replacements = readonly []>(
+export function compile<A, E>(
  root: Node<A, E, any>,
-  replacements?: ValidReplacements<Items>,
+  replacements?: ReadonlyMap<Layer.Any, Layer.Any>,
 ): Layer.Layer<A, E> {
-  const replacementMap = replacementMapFrom(replacements)
  const cache = new Map<AnyNode, RuntimeLayer>()
  const compileNode = (node: AnyNode) =>
    walk<RuntimeLayer>(
@@ -259,22 +220,18 @@ export function compile<A, E, const Items extends Replacements = readonly []>(
      (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 = node.implementation! as RuntimeLayer
+        const implementation = (replacements?.get(node.implementation!) ?? node.implementation!) as RuntimeLayer
        return dependencies.length === 0
          ? implementation
          : implementation.pipe(Layer.provide(dependencies as [RuntimeLayer, ...RuntimeLayer[]]))
      },
-      { cache, resolve: (node) => replacementMap.get(node.name) ?? node },
+      { 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>
 }

-function replacementMapFrom(replacements?: Replacements) {
-  return new Map(replacements?.map(([source, replacement]) => [source.name, replacementNode(source, replacement)]))
-}
-
 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) => {
@@ -283,6 +240,32 @@ export function hasUnbound(root: Node<unknown, unknown, any>, source: AnyNode):
  })
 }

+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]
 }
@@ -26,6 +26,7 @@ import { Reference } from "./reference"
 import { ReferenceGuidance } from "./reference/guidance"
 import * as SessionRunnerLLM from "./session/runner/llm"
 import { SessionRunnerModel } from "./session/runner/model"
+import { SessionRuntime } from "./session/runtime"
 import { SessionTodo } from "./session/todo"
 import { SkillV2 } from "./skill"
 import { SkillGuidance } from "./skill/guidance"
@@ -75,6 +76,7 @@ export const locationServices = LayerNode.group([
  BuiltInTools.node,
  SessionRunnerModel.node,
  Snapshot.node,
+  SessionRuntime.node,
  SessionRunnerLLM.node,
 ])

@@ -82,16 +84,17 @@ export type LocationServices = LayerNode.Output<typeof locationServices>
 export type LocationError = LayerNode.Error<typeof locationServices>

 export function buildLocationServiceMap(
-  replacements: LayerNode.Replacements = [],
+  replacements?: ReadonlyMap<Layer.Any, Layer.Any>,
 ): Layer.Layer<LocationServiceMap.Service> {
  return Layer.effect(
    LocationServiceMap.Service,
    LayerMap.make(
      (ref: Location.Ref) => {
-        const allReplacements = replacements.concat([[Location.node, Location.boundNode(ref)]])
-        const location = LayerNode.hoist(locationServices, Node.tags.values.global, allReplacements)
-
-        return LayerNode.compile(location.node).pipe(
+        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", {
@@ -99,7 +102,7 @@ export function buildLocationServiceMap(
              workspaceID: ref.workspaceID,
            }),
          ),
-          Layer.provide(LayerNode.compile(location.hoisted)),
+          Layer.provide(LayerNode.compile(location.hoisted, replacements)),
        )
      },
      { idleTimeToLive: "60 minutes" },
@@ -13,7 +13,10 @@ import { Integration } from "./integration"
 import { KeyedMutex } from "./effect/keyed-mutex"
 import { PluginHost } from "./plugin/host"
 import { Reference } from "./reference"
+import { SessionV2 } from "./session"
+import { SessionRuntime } from "./session/runtime"
 import { SkillV2 } from "./skill"
+import { Location } from "./location"
 import { State } from "./state"

 export const ID = Plugin.ID
@@ -149,6 +152,8 @@ export const locationLayer = layer.pipe(
  Layer.provideMerge(CommandV2.locationLayer),
  Layer.provideMerge(Integration.locationLayer),
  Layer.provideMerge(Reference.locationLayer),
+  Layer.provideMerge(SessionV2.defaultLayer),
+  Layer.provideMerge(SessionRuntime.layer),
  Layer.provideMerge(SkillV2.locationLayer),
 )

@@ -163,6 +168,9 @@ export const node = makeLocationNode({
    CommandV2.node,
    Integration.node,
    Reference.node,
+    SessionV2.node,
+    SessionRuntime.node,
    SkillV2.node,
+    Location.node,
  ],
 })
@@ -13,7 +13,11 @@ import { PluginV2 } from "../plugin"
 import { ProviderV2 } from "../provider"
 import { Reference } from "../reference"
 import type { DeepMutable } from "../schema"
+import { SessionV2 } from "../session"
+import { SessionMessage } from "../session/message"
+import { SessionRuntime } from "../session/runtime"
 import { SkillV2 } from "../skill"
+import { Location } from "../location"

 const mutable = <T>(value: T) => value as DeepMutable<T>

@@ -24,7 +28,10 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: PluginV2.Int
  const commands = yield* CommandV2.Service
  const integration = yield* Integration.Service
  const reference = yield* Reference.Service
+  const session = yield* SessionV2.Service
+  const sessionRuntime = yield* SessionRuntime.Service
  const skill = yield* SkillV2.Service
+  const location = yield* Location.Service

  return {
    options: {},
@@ -205,6 +212,60 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: PluginV2.Int
          }),
        ),
    },
+    session: {
+      create: (input) =>
+        session.create(
+          input.parentID
+            ? {
+                id: input.id ? SessionV2.ID.make(input.id) : undefined,
+                parentID: SessionV2.ID.make(input.parentID),
+                title: input.title,
+                agent: input.agent ? AgentV2.ID.make(input.agent) : undefined,
+                model: input.model
+                  ? {
+                      id: ModelV2.ID.make(input.model.id),
+                      providerID: ProviderV2.ID.make(input.model.providerID),
+                      variant: input.model.variant ? ModelV2.VariantID.make(input.model.variant) : undefined,
+                    }
+                  : undefined,
+              }
+            : {
+                id: input.id ? SessionV2.ID.make(input.id) : undefined,
+                location: { directory: location.directory, workspaceID: location.workspaceID },
+                title: input.title,
+                agent: input.agent ? AgentV2.ID.make(input.agent) : undefined,
+                model: input.model
+                  ? {
+                      id: ModelV2.ID.make(input.model.id),
+                      providerID: ProviderV2.ID.make(input.model.providerID),
+                      variant: input.model.variant ? ModelV2.VariantID.make(input.model.variant) : undefined,
+                    }
+                  : undefined,
+              },
+        ),
+      get: (sessionID) => session.get(SessionV2.ID.make(sessionID)),
+      messages: (input) =>
+        session.messages({
+          sessionID: SessionV2.ID.make(input.sessionID),
+          limit: input.limit,
+          order: input.order,
+          cursor: input.cursor
+            ? { id: SessionMessage.ID.make(input.cursor.id), direction: input.cursor.direction }
+            : undefined,
+        }),
+      context: (sessionID) => session.context(SessionV2.ID.make(sessionID)),
+      prompt: (input) =>
+        sessionRuntime.prompt({
+          id: input.id ? SessionMessage.ID.make(input.id) : undefined,
+          sessionID: SessionV2.ID.make(input.sessionID),
+          prompt: input.prompt,
+          delivery: input.delivery,
+          resume: input.resume,
+        }),
+      resume: (sessionID) => sessionRuntime.resume(SessionV2.ID.make(sessionID)),
+      wait: (sessionID) => sessionRuntime.wait(SessionV2.ID.make(sessionID)),
+      interrupt: (sessionID) => sessionRuntime.interrupt(SessionV2.ID.make(sessionID)),
+    },
    skill: {
      reload: skill.reload,
      transform: (callback) =>
@@ -81,6 +81,16 @@ export function fromPromise(plugin: Plugin) {
            transform: transform(host.reference),
            reload: () => run(host.reference.reload()),
          },
+          session: {
+            create: (input) => run(host.session.create(input)),
+            get: (sessionID) => run(host.session.get(sessionID)),
+            messages: (input) => run(host.session.messages(input)),
+            context: (sessionID) => run(host.session.context(sessionID)),
+            prompt: (input) => run(host.session.prompt(input)),
+            resume: (sessionID) => run(host.session.resume(sessionID)),
+            wait: (sessionID) => run(host.session.wait(sessionID)),
+            interrupt: (sessionID) => run(host.session.interrupt(sessionID)),
+          },
          skill: {
            transform: transform(host.skill),
            reload: () => run(host.skill.reload()),
@@ -1,7 +0,0 @@
-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)
@@ -25,10 +25,9 @@ import { ProjectTable } from "./project/sql"
 import path from "path"
 import { fromRow } from "./session/info"
 import { SessionRunner } from "./session/runner/index"
+import { SessionRuntimeCoordinator } from "./session/runtime-coordinator"
 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"
@@ -76,12 +75,14 @@ const ListAllInput = Schema.Struct(ListInputBase)
 export const ListInput = Schema.Union([ListDirectoryInput, ListProjectInput, ListAllInput])
 export type ListInput = typeof ListInput.Type

-type CreateInput = {
+type CreateBaseInput = {
  id?: SessionSchema.ID
+  title?: string
  agent?: AgentV2.ID
  model?: ModelV2.Ref
-  location: Location.Ref
 }
+type CreateInput = CreateBaseInput &
+  ({ location: Location.Ref; parentID?: never } | { parentID: SessionSchema.ID; location?: never })

 type CompactInput = {
  sessionID: SessionSchema.ID
@@ -95,7 +96,7 @@ export class NotFoundError extends Schema.TaggedErrorClass<NotFoundError>()("Ses
 export class OperationUnavailableError extends Schema.TaggedErrorClass<OperationUnavailableError>()(
  "Session.OperationUnavailableError",
  {
-    operation: Schema.Literals(["move", "shell", "skill", "switchAgent", "compact", "wait"]),
+    operation: Schema.Literals(["move", "shell", "skill", "switchAgent", "compact"]),
  },
 ) {}

@@ -105,6 +106,9 @@ export class PromptConflictError extends Schema.TaggedErrorClass<PromptConflictE
  sessionID: SessionSchema.ID,
  messageID: SessionMessage.ID,
 }) {}
+export class BusyError extends Schema.TaggedErrorClass<BusyError>()("Session.BusyError", {
+  sessionID: SessionSchema.ID,
+}) {}
 export const MessageNotFoundError = SessionRevert.MessageNotFoundError
 export type MessageNotFoundError = SessionRevert.MessageNotFoundError

@@ -112,7 +116,7 @@ export type Error = NotFoundError | MessageDecodeError | OperationUnavailableErr

 export interface Interface {
  readonly list: (input?: ListInput) => Effect.Effect<SessionSchema.Info[]>
-  readonly create: (input: CreateInput) => Effect.Effect<SessionSchema.Info>
+  readonly create: (input: CreateInput) => Effect.Effect<SessionSchema.Info, NotFoundError>
  readonly get: (sessionID: SessionSchema.ID) => Effect.Effect<SessionSchema.Info, NotFoundError>
  readonly messages: (input: {
    sessionID: SessionSchema.ID
@@ -144,6 +148,7 @@ export interface Interface {
    sessionID: SessionSchema.ID
    model: ModelV2.Ref
  }) => Effect.Effect<void, NotFoundError>
+  readonly rename: (input: { sessionID: SessionSchema.ID; title: string }) => Effect.Effect<void, NotFoundError>
  readonly prompt: (input: {
    id?: SessionMessage.ID
    sessionID: SessionSchema.ID
@@ -164,7 +169,7 @@ export interface Interface {
    resume?: boolean
  }) => Effect.Effect<void, OperationUnavailableError>
  readonly compact: (input: CompactInput) => Effect.Effect<void, NotFoundError | OperationUnavailableError>
-  readonly wait: (id: SessionSchema.ID) => Effect.Effect<void, NotFoundError | OperationUnavailableError>
+  readonly wait: (id: SessionSchema.ID) => Effect.Effect<void, NotFoundError>
  readonly active: Effect.Effect<ReadonlySet<SessionSchema.ID>>
  readonly resume: (sessionID: SessionSchema.ID) => Effect.Effect<void, NotFoundError | SessionRunner.RunError>
  readonly interrupt: (sessionID: SessionSchema.ID) => Effect.Effect<void>
@@ -173,9 +178,9 @@ export interface Interface {
      sessionID: SessionSchema.ID
      messageID: SessionMessage.ID
      files?: boolean
-    }) => Effect.Effect<Revert.State, NotFoundError | MessageNotFoundError | Snapshot.Error>
-    readonly clear: (sessionID: SessionSchema.ID) => Effect.Effect<void, NotFoundError | Snapshot.Error>
-    readonly commit: (sessionID: SessionSchema.ID) => Effect.Effect<void, NotFoundError>
+    }) => Effect.Effect<Revert.State, NotFoundError | MessageNotFoundError | BusyError | Snapshot.Error>
+    readonly clear: (sessionID: SessionSchema.ID) => Effect.Effect<void, NotFoundError | BusyError | Snapshot.Error>
+    readonly commit: (sessionID: SessionSchema.ID) => Effect.Effect<void, NotFoundError | BusyError>
  }
 }

@@ -188,9 +193,8 @@ export const layer = Layer.effect(
    const db = database.db
    const events = yield* EventV2.Service
    const projects = yield* ProjectV2.Service
-    const execution = yield* SessionExecution.Service
+    const runtimeCoordinator = yield* SessionRuntimeCoordinator.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) =>
@@ -209,7 +213,12 @@ export const layer = Layer.effect(
        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)
+        const parent = input.parentID ? yield* store.get(input.parentID) : undefined
+        if (input.parentID && parent === undefined) return yield* new NotFoundError({ sessionID: input.parentID })
+        const location = parent?.location ?? input.location
+        if (location === undefined)
+          return yield* Effect.die(new Error("V2Session.create requires either location or an existing parentID"))
+        const project = yield* projects.resolve(location.directory)
        yield* db
          .insert(ProjectTable)
          .values({ id: project.id, worktree: project.directory, vcs: project.vcs?.type, sandboxes: [] })
@@ -222,10 +231,11 @@ export const layer = Layer.effect(
          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()}`,
+          parentID: input.parentID,
+          directory: location.directory,
+          path: path.relative(project.directory, location.directory).replaceAll("\\", "/"),
+          workspaceID: location.workspaceID ? WorkspaceV2.ID.make(location.workspaceID) : undefined,
+          title: input.title ?? `New session - ${new Date(now).toISOString()}`,
          agent: input.agent,
          model: input.model
            ? {
@@ -238,24 +248,22 @@ export const layer = Layer.effect(
          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),
-                  ),
-                )
-            }),
-          )
+        const projected = yield* events.publish(SessionV1.Event.Created, { sessionID, info }, { 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)
@@ -379,7 +387,8 @@ export const layer = Layer.effect(
            )
            if (!SessionInput.equivalent(admitted, expected))
              return yield* new PromptConflictError({ sessionID: input.sessionID, messageID })
-            if (input.resume !== false) yield* execution.wake(admitted.sessionID)
+            if (input.resume !== false)
+              return yield* Effect.die("SessionV2.prompt with resume moved to SessionRuntime.Service")
            return admitted
          }),
        ),
@@ -414,41 +423,40 @@ export const layer = Layer.effect(
          model: input.model,
        })
      }),
+      rename: Effect.fn("V2Session.rename")(function* (input) {
+        yield* result.get(input.sessionID)
+        yield* events.publish(SessionEvent.Renamed, {
+          sessionID: input.sessionID,
+          timestamp: yield* DateTime.now,
+          title: input.title,
+        })
+      }),
      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" })
+        return yield* Effect.die("SessionV2.wait moved to SessionRuntime.Service")
      }),
-      active: execution.active,
+      active: runtimeCoordinator.active,
      resume: Effect.fn("V2Session.resume")(function* (sessionID) {
        yield* result.get(sessionID)
-        yield* execution.resume(sessionID)
+        return yield* Effect.die("SessionV2.resume moved to SessionRuntime.Service")
      }),
-      interrupt: Effect.fn("V2Session.interrupt")((sessionID) =>
-        Effect.uninterruptible(execution.interrupt(sessionID)),
-      ),
+      interrupt: Effect.fn("V2Session.interrupt")(() => Effect.die("SessionV2.interrupt moved to SessionRuntime.Service")),
      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)),
-          )
+          yield* result.get(input.sessionID)
+          return yield* Effect.die("SessionV2.revert.stage moved to SessionRuntime.Service")
        }),
        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)),
-          )
+          yield* result.get(sessionID)
+          return yield* Effect.die("SessionV2.revert.clear moved to SessionRuntime.Service")
        }),
        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 yield* SessionRevert.commit(session).pipe(Effect.provideService(EventV2.Service, events))
        }),
      },
    })
@@ -463,6 +471,7 @@ export const defaultLayer = layer.pipe(
  Layer.provide(EventV2.defaultLayer),
  Layer.provide(Database.defaultLayer),
  Layer.provide(ProjectV2.defaultLayer),
+  Layer.provide(SessionRuntimeCoordinator.defaultLayer),
  Layer.orDie,
 )

@@ -470,6 +479,7 @@ const resolvePrompt = (input: PromptInput.Prompt) =>
  Prompt.make({
    text: input.text,
    agents: input.agents,
+    system: input.system,
    files: input.files?.map((file) => {
      const dataMime = file.uri.match(/^data:([^;,]+)[;,]/i)?.[1]
      const target = URL.canParse(file.uri) ? new URL(file.uri).pathname : (file.name ?? file.uri)
@@ -487,9 +497,8 @@ export const node = makeGlobalNode({
    Database.node,
    EventV2.node,
    ProjectV2.node,
-    SessionExecution.node,
+    SessionRuntimeCoordinator.node,
    SessionStore.node,
-    LocationServiceMap.node,
    SessionProjector.node,
  ],
 })
@@ -15,6 +15,8 @@ export interface Interface {
  readonly wake: (sessionID: SessionSchema.ID) => Effect.Effect<void>
  /** Interrupt active work owned by this process. Idle interruption is a no-op. */
  readonly interrupt: (sessionID: SessionSchema.ID) => Effect.Effect<void>
+  /** Resolves once this process owns no active execution for the Session. Returns immediately when idle and never starts work. */
+  readonly awaitIdle: (sessionID: SessionSchema.ID) => Effect.Effect<void>
 }

 /** Routes execution from a Session ID to the runner owned by that Session's Location. */
@@ -30,5 +32,6 @@ export const noopLayer = Layer.succeed(
    resume: () => Effect.void,
    wake: () => Effect.void,
    interrupt: () => Effect.void,
+    awaitIdle: () => Effect.void,
  }),
 )
@@ -33,6 +33,7 @@ export const layer = Layer.effect(
      interrupt: coordinator.interrupt,
      resume: coordinator.run,
      wake: coordinator.wake,
+      awaitIdle: coordinator.awaitIdle,
    })
  }),
 )
@@ -123,6 +123,7 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {
        )
      },
      "session.next.moved": () => Effect.void,
+      "session.next.renamed": () => Effect.void,
      "session.next.prompted": (event) => {
        return adapter.appendMessage(
          SessionMessage.User.make({
@@ -132,6 +133,7 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {
            text: event.data.prompt.text,
            files: event.data.prompt.files,
            agents: event.data.prompt.agents,
+            system: event.data.prompt.system,
            time: { created: event.data.timestamp },
          }),
        )
@@ -347,6 +347,14 @@ export const layer = Layer.effectDiscard(
        yield* run(db, event)
      }),
    )
+    yield* events.project(SessionEvent.Renamed, (event) =>
+      db
+        .update(SessionTable)
+        .set({ title: event.data.title, time_updated: DateTime.toEpochMillis(event.data.timestamp) })
+        .where(eq(SessionTable.id, event.data.sessionID))
+        .run()
+        .pipe(Effect.orDie),
+    )
    yield* events.project(SessionEvent.Prompted, (event) =>
      Effect.gen(function* () {
        if (event.durable === undefined) return yield* Effect.die("Durable Session event is missing aggregate sequence")
@@ -12,6 +12,8 @@ export interface Coordinator<Key, E> {
  readonly wake: (key: Key) => Effect.Effect<void>
  /** Stops active execution and waits for its cleanup. */
  readonly interrupt: (key: Key) => Effect.Effect<void>
+  /** Resolves once no execution is active for the key. Returns immediately when already idle and never starts work. */
+  readonly awaitIdle: (key: Key) => Effect.Effect<void>
 }

 type Entry<E> = {
@@ -100,5 +102,15 @@ export const make = <Key, E>(options: {
        return Fiber.interrupt(entry.owner)
      })

-    return { active: Effect.sync(() => new Set(active.keys())), run, wake, interrupt }
+    // Each successful drain reuses its entry.done across coalesced wakes, so one await
+    // already spans steered and queued continuation. Re-check after it settles to cover a
+    // fresh wake (or a failure/stopping successor) that installs a new entry.
+    const awaitIdle = (key: Key): Effect.Effect<void> =>
+      Effect.suspend(() => {
+        const entry = active.get(key)
+        if (entry === undefined) return Effect.void
+        return Deferred.await(entry.done).pipe(Effect.exit, Effect.andThen(awaitIdle(key)))
+      })
+
+    return { active: Effect.sync(() => new Set(active.keys())), run, wake, interrupt, awaitIdle }
  })
@@ -194,13 +194,16 @@ export const layer = Layer.effect(
      const model = yield* models.resolve(session)
      const entries = yield* SessionHistory.entriesForRunner(db, session.id, system.baselineSeq)
      const context = entries.map((entry) => entry.message)
+      // Mirror V1 (session/llm/request.ts): append the current turn's per-request system string after the
+      // agent prompt and durable baseline. The current turn's user prompt is the latest user message in context.
+      const turnSystem = context.findLast((message) => message.type === "user")?.system
      const isLastStep = agent.info?.steps !== undefined && currentStep >= agent.info.steps
      const toolMaterialization = isLastStep ? undefined : yield* tools.materialize(agent.info?.permissions)
      const promptCacheKey = /^ses_[0-9a-f]{64}$/.test(session.id) ? session.id.slice(4) : session.id
      const request = LLM.request({
        model,
        providerOptions: { openai: { promptCacheKey } },
-        system: [agent.info?.system, system.baseline]
+        system: [agent.info?.system, system.baseline, turnSystem]
          .filter((part): part is string => part !== undefined && part.length > 0)
          .map(SystemPart.make),
        messages: [...toLLMMessages(context, model), ...(isLastStep ? [Message.assistant(MAX_STEPS_PROMPT)] : [])],
@@ -289,19 +292,18 @@ export const layer = Layer.effect(
          }
          if (stream._tag === "Failure" && Cause.hasInterrupts(stream.cause)) yield* FiberSet.clear(toolFibers)
          const settled = yield* restore(awaitToolFibers(toolFibers)).pipe(Effect.exit)
+          const streamInterrupted = stream._tag === "Failure" && Cause.hasInterrupts(stream.cause)
+          const toolsInterrupted = settled._tag === "Failure" && Cause.hasInterrupts(settled.cause)
          if (settled._tag === "Failure" && isQuestionRejected(settled.cause)) {
            yield* FiberSet.clear(toolFibers)
            yield* withPublication(publisher.failUnsettledTools("Tool execution interrupted"))
+            yield* withPublication(publisher.failAssistant("Provider turn interrupted"))
            return yield* Effect.interrupt
          }
-          if (
-            (stream._tag === "Failure" && Cause.hasInterrupts(stream.cause)) ||
-            (settled._tag === "Failure" && Cause.hasInterrupts(settled.cause))
-          ) {
+          if (streamInterrupted || toolsInterrupted) {
            yield* FiberSet.clear(toolFibers)
            yield* withPublication(publisher.failUnsettledTools("Tool execution interrupted"))
-            if (publisher.hasActiveAssistant())
-              yield* withPublication(publisher.failAssistant("Provider turn interrupted"))
+            yield* withPublication(publisher.failAssistant("Provider turn interrupted"))
          }
          if (settled._tag === "Failure" && !Cause.hasInterrupts(settled.cause)) {
            const failure = Cause.squash(settled.cause)
@@ -309,7 +311,7 @@ export const layer = Layer.effect(
            yield* withPublication(publisher.failUnsettledTools(`Tool execution failed: ${message}`))
          }
          const stepSettlement = publisher.stepSettlement()
-          if (stepSettlement && !publisher.hasProviderError()) {
+          if (stepSettlement && !streamInterrupted && !toolsInterrupted && !publisher.hasProviderError()) {
            const endSnapshot = yield* snapshots.capture()
            const files =
              startSnapshot && endSnapshot
@@ -0,0 +1,47 @@
+export * as SessionRuntimeCoordinator from "./runtime-coordinator"
+
+import { Context, Effect, Layer } from "effect"
+import { makeGlobalNode } from "../effect/app-node"
+import { SessionRunner } from "./runner"
+import { SessionRunCoordinator } from "./run-coordinator"
+import { SessionSchema } from "./schema"
+
+type Drain = (force: boolean) => Effect.Effect<void, SessionRunner.RunError>
+
+export interface Interface {
+  readonly active: Effect.Effect<ReadonlySet<SessionSchema.ID>>
+  readonly run: (sessionID: SessionSchema.ID, drain: Drain) => Effect.Effect<void, SessionRunner.RunError>
+  readonly wake: (sessionID: SessionSchema.ID, drain: Drain) => Effect.Effect<void>
+  readonly interrupt: (sessionID: SessionSchema.ID) => Effect.Effect<void>
+  readonly wait: (sessionID: SessionSchema.ID) => Effect.Effect<void>
+}
+
+export class Service extends Context.Service<Service, Interface>()("@opencode/v2/SessionRuntimeCoordinator") {}
+
+export const layer = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    const drains = new Map<SessionSchema.ID, Drain>()
+    const coordinator = yield* SessionRunCoordinator.make<SessionSchema.ID, SessionRunner.RunError>({
+      drain: Effect.fnUntraced(function* (sessionID, force) {
+        const drain = drains.get(sessionID)
+        if (!drain) return yield* Effect.die(`No SessionRuntime drain registered for ${sessionID}`)
+        return yield* drain(force)
+      }),
+    })
+
+    return Service.of({
+      active: coordinator.active,
+      run: (sessionID, drain) =>
+        Effect.sync(() => drains.set(sessionID, drain)).pipe(Effect.andThen(coordinator.run(sessionID))),
+      wake: (sessionID, drain) =>
+        Effect.sync(() => drains.set(sessionID, drain)).pipe(Effect.andThen(coordinator.wake(sessionID))),
+      interrupt: coordinator.interrupt,
+      wait: coordinator.awaitIdle,
+    })
+  }),
+)
+
+export const defaultLayer = layer
+
+export const node = makeGlobalNode({ service: Service, layer, deps: [] })
@@ -0,0 +1,165 @@
+export * as SessionRuntime from "./runtime"
+
+import { Context, Effect, Layer } from "effect"
+import { Database } from "../database/database"
+import { EventV2 } from "../event"
+import { Location } from "../location"
+import { PromptInput } from "@opencode-ai/schema/prompt-input"
+import { SessionMessage } from "./message"
+import { Prompt } from "./prompt"
+import { SessionInput } from "./input"
+import { SessionRevert } from "./revert"
+import { SessionRunner } from "./runner"
+import * as SessionRunnerLLM from "./runner/llm"
+import { SessionRuntimeCoordinator } from "./runtime-coordinator"
+import { SessionSchema } from "./schema"
+import { Snapshot } from "../snapshot"
+import { FSUtil } from "../fs-util"
+import { makeLocationNode } from "../effect/app-node"
+import { SessionV2 } from "../session"
+import {
+  BusyError,
+  MessageNotFoundError,
+  NotFoundError,
+  PromptConflictError,
+  type RevertState,
+} from "../session"
+
+export interface Interface {
+  readonly prompt: (input: {
+    id?: SessionMessage.ID
+    sessionID: SessionSchema.ID
+    prompt: PromptInput.Prompt
+    delivery?: SessionInput.Delivery
+    resume?: boolean
+  }) => Effect.Effect<SessionInput.Admitted, NotFoundError | PromptConflictError>
+  readonly wait: (id: SessionSchema.ID) => Effect.Effect<void, NotFoundError>
+  readonly active: Effect.Effect<ReadonlySet<SessionSchema.ID>>
+  readonly resume: (sessionID: SessionSchema.ID) => Effect.Effect<void, NotFoundError | SessionRunner.RunError>
+  readonly interrupt: (sessionID: SessionSchema.ID) => Effect.Effect<void>
+  readonly revert: {
+    readonly stage: (input: {
+      sessionID: SessionSchema.ID
+      messageID: SessionMessage.ID
+      files?: boolean
+    }) => Effect.Effect<RevertState, NotFoundError | MessageNotFoundError | BusyError | Snapshot.Error>
+    readonly clear: (sessionID: SessionSchema.ID) => Effect.Effect<void, NotFoundError | BusyError | Snapshot.Error>
+    readonly commit: (sessionID: SessionSchema.ID) => Effect.Effect<void, NotFoundError | BusyError>
+  }
+}
+
+export class Service extends Context.Service<Service, Interface>()("@opencode/v2/SessionRuntime") {}
+
+export const layer = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    const database = yield* Database.Service
+    const db = database.db
+    const events = yield* EventV2.Service
+    const location = yield* Location.Service
+    const sessions = yield* SessionV2.Service
+    const runner = yield* SessionRunner.Service
+    const snapshot = yield* Snapshot.Service
+    const coordinator = yield* SessionRuntimeCoordinator.Service
+
+    const local = Effect.fn("SessionRuntime.local")(function* (sessionID: SessionSchema.ID) {
+      const session = yield* sessions.get(sessionID)
+      if (session.location.directory !== location.directory || session.location.workspaceID !== location.workspaceID)
+        return yield* new NotFoundError({ sessionID })
+      return session
+    })
+
+    const drain = (sessionID: SessionSchema.ID) =>
+      Effect.fnUntraced(function* (force: boolean) {
+        yield* local(sessionID).pipe(Effect.orDie)
+        return yield* runner.run({ sessionID, force })
+      })
+
+    return Service.of({
+      prompt: Effect.fn("SessionRuntime.prompt")((input) =>
+        Effect.uninterruptible(
+          Effect.gen(function* () {
+            yield* local(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* coordinator.wake(admitted.sessionID, drain(admitted.sessionID))
+            return admitted
+          }),
+        ),
+      ),
+      wait: Effect.fn("SessionRuntime.wait")(function* (sessionID) {
+        yield* local(sessionID)
+        yield* coordinator.wait(sessionID)
+      }),
+      active: coordinator.active,
+      resume: Effect.fn("SessionRuntime.resume")(function* (sessionID) {
+        yield* local(sessionID)
+        yield* coordinator.run(sessionID, drain(sessionID))
+      }),
+      interrupt: Effect.fn("SessionRuntime.interrupt")(function* (sessionID) {
+        yield* local(sessionID)
+        yield* Effect.uninterruptible(coordinator.interrupt(sessionID))
+      }),
+      revert: {
+        stage: Effect.fn("SessionRuntime.revert.stage")(function* (input) {
+          const session = yield* local(input.sessionID)
+          if ((yield* coordinator.active).has(input.sessionID)) return yield* new BusyError({ sessionID: 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.provideService(Snapshot.Service, snapshot),
+          )
+        }),
+        clear: Effect.fn("SessionRuntime.revert.clear")(function* (sessionID) {
+          const session = yield* local(sessionID)
+          if ((yield* coordinator.active).has(sessionID)) return yield* new BusyError({ sessionID })
+          return yield* SessionRevert.clear(session).pipe(
+            Effect.provideService(EventV2.Service, events),
+            Effect.provideService(Snapshot.Service, snapshot),
+          )
+        }),
+        commit: Effect.fn("SessionRuntime.revert.commit")(function* (sessionID) {
+          const session = yield* local(sessionID)
+          if ((yield* coordinator.active).has(sessionID)) return yield* new BusyError({ sessionID })
+          return yield* SessionRevert.commit(session).pipe(Effect.provideService(EventV2.Service, events))
+        }),
+      },
+    })
+  }),
+)
+
+const resolvePrompt = (input: PromptInput.Prompt) =>
+  Prompt.make({
+    text: input.text,
+    agents: input.agents,
+    files: input.files?.map((file) => {
+      const dataMime = file.uri.match(/^data:([^;,]+)[;,]/i)?.[1]
+      const target = URL.canParse(file.uri) ? new URL(file.uri).pathname : (file.name ?? file.uri)
+      return {
+        ...file,
+        mime: dataMime ?? (target.endsWith("/") ? "application/x-directory" : FSUtil.mimeType(target)),
+      }
+    }),
+  })
+
+export const node = makeLocationNode({
+  service: Service,
+  layer,
+  deps: [Database.node, EventV2.node, Location.node, SessionV2.node, SessionRunnerLLM.node, Snapshot.node, SessionRuntimeCoordinator.node],
+})
@@ -196,8 +196,6 @@ export const defaultLayer = layer.pipe(Layer.provide(FSUtil.defaultLayer), Layer

 export const node = makeLocationNode({ service: Service, layer, deps: [FSUtil.node, Global.node, Config.node] })

-export const nodeWithoutConfig = makeLocationNode({ service: Service, layer, deps: [FSUtil.node, Global.node] })
-
 /** Runs retention scanning once globally rather than once per active Location. */
 export const cleanupLayer = Layer.effectDiscard(
  Effect.gen(function* () {
@@ -2,7 +2,7 @@ export * as ToolRegistry from "./registry"

 import { ToolOutput, type ToolCall, type ToolDefinition, type ToolResultValue } from "@opencode-ai/llm"
 import { Context, Effect, Layer, Scope } from "effect"
-import { AgentV2 } from "../agent"
+import type { AgentV2 } from "../agent"
 import { PermissionV2 } from "../permission"
 import { SessionMessage } from "../session/message"
 import { SessionSchema } from "../session/schema"
@@ -0,0 +1,195 @@
+export * as SubagentTool from "./subagent"
+
+import { ToolFailure } from "@opencode-ai/llm"
+import { DateTime, Effect, Layer, Schema, Scope } from "effect"
+import { AgentV2 } from "../agent"
+import { BackgroundJob } from "../background-job"
+import { EventV2 } from "../event"
+import { LocationServiceMap } from "../location-service-map"
+import { SessionV2 } from "../session"
+import { SessionRuntime } from "../session/runtime"
+import { SessionEvent } from "../session/event"
+import { SessionMessage } from "../session/message"
+import { SessionSchema } from "../session/schema"
+import { makeGlobalNode } from "../effect/app-node"
+import { ApplicationTools } from "./application-tools"
+import { Tool } from "./tool"
+
+export const name = "subagent"
+
+const NO_TEXT = "Subagent completed without a text response."
+const BACKGROUND_STARTED =
+  "The subagent is working in the background. You will be notified automatically when it finishes. DO NOT sleep, poll, or proactively check on its progress."
+
+export const Input = Schema.Struct({
+  agent: Schema.String.annotate({ description: "The configured agent to run as the subagent" }),
+  description: Schema.String.annotate({ description: "A short description of the subagent's task" }),
+  prompt: Schema.String.annotate({ description: "The task for the subagent to perform" }),
+  background: Schema.Boolean.pipe(Schema.optional).annotate({
+    description:
+      "Run the subagent in the background and return immediately. You will be notified when it completes. DO NOT poll its progress.",
+  }),
+})
+
+export const Output = Schema.Struct({
+  sessionID: SessionSchema.ID,
+  status: Schema.Literals(["completed", "running"]),
+  output: Schema.String,
+})
+
+export const description = [
+  "Spawn a subagent: a child session running a configured agent with fresh context.",
+  "Foreground (default) runs the subagent to completion and returns its final response.",
+  "Background mode (background=true) launches it asynchronously and returns immediately; you are notified when it finishes.",
+  "Use background only for independent work that can run while you continue elsewhere.",
+].join("\n")
+
+export const layer = Layer.effectDiscard(
+  Effect.gen(function* () {
+    const tools = yield* ApplicationTools.Service
+    const sessions = yield* SessionV2.Service
+    const jobs = yield* BackgroundJob.Service
+    const events = yield* EventV2.Service
+    const locations = yield* LocationServiceMap.Service
+    const scope = yield* Scope.Scope
+
+    // Concatenate the child's final completed assistant text. Distinguishes "completed with no
+    // text" (generic string) from "failed" (the run effect fails, surfaced as a job error).
+    const latestAssistantText = Effect.fn("SubagentTool.latestAssistantText")(function* (sessionID: SessionSchema.ID) {
+      const messages = yield* sessions.messages({ sessionID, order: "desc", limit: 20 })
+      const assistant = messages.find(
+        (message) =>
+          message.type === "assistant" && message.time.completed !== undefined && message.error === undefined,
+      )
+      if (assistant === undefined || assistant.type !== "assistant") return NO_TEXT
+      const text = assistant.content
+        .filter((part): part is Extract<typeof part, { type: "text" }> => part.type === "text")
+        .map((part) => part.text)
+        .join("")
+      return text.length > 0 ? text : NO_TEXT
+    })
+
+    const injectCompletion = Effect.fn("SubagentTool.injectCompletion")(function* (
+      parentID: SessionSchema.ID,
+      childID: SessionSchema.ID,
+      description: string,
+      state: "completed" | "error" | "cancelled",
+      text: string,
+    ) {
+      yield* events.publish(SessionEvent.Synthetic, {
+        sessionID: parentID,
+        messageID: SessionMessage.ID.create(),
+        timestamp: yield* DateTime.now,
+        text: `<subagent id="${childID}" state="${state}" description="${description}">\n${text}\n</subagent>`,
+      })
+    })
+
+    const injectWhenDone = Effect.fn("SubagentTool.injectWhenDone")(function* (
+      parentID: SessionSchema.ID,
+      childID: SessionSchema.ID,
+      description: string,
+    ) {
+      yield* jobs.wait({ id: childID }).pipe(
+        Effect.flatMap((result) => {
+          if (result.info?.status === "completed")
+            return injectCompletion(parentID, childID, description, "completed", result.info.output ?? NO_TEXT)
+          if (result.info?.status === "error")
+            return injectCompletion(parentID, childID, description, "error", result.info.error ?? "Subagent failed")
+          if (result.info?.status === "cancelled")
+            return injectCompletion(parentID, childID, description, "cancelled", "Subagent cancelled")
+          return Effect.void
+        }),
+        Effect.forkIn(scope, { startImmediately: true }),
+      )
+    })
+
+    yield* tools
+      .register({
+        [name]: Tool.make({
+          description,
+          input: Input,
+          output: Output,
+          toModelOutput: ({ output }) => [{ type: "text", text: output.output }],
+          execute: (input, context) =>
+            Effect.gen(function* () {
+              const parent = yield* sessions
+                .get(context.sessionID)
+                .pipe(
+                  Effect.mapError(() => new ToolFailure({ message: `Parent session not found: ${context.sessionID}` })),
+                )
+              const locationLayer = locations.get(parent.location)
+              const agents = yield* AgentV2.Service.pipe(Effect.provide(locationLayer))
+              const runtime = yield* SessionRuntime.Service.pipe(Effect.provide(locationLayer))
+              const agent = yield* agents.resolve(input.agent)
+              if (agent === undefined) return yield* new ToolFailure({ message: `Unknown agent: ${input.agent}` })
+              if (agent.mode === "primary")
+                return yield* new ToolFailure({ message: `Agent ${input.agent} cannot run as a subagent` })
+
+              // Model selection is policy/config/session state, not an LLM-facing tool argument.
+              const model = agent.model ?? parent.model
+              const child = yield* sessions
+                .create({
+                  parentID: context.sessionID,
+                  title: input.description,
+                  agent: AgentV2.ID.make(input.agent),
+                  model,
+                  // TODO(opencode kkdvxn): derive restricted subagent permissions from the parent
+                  // session (V1 deriveSubagentSessionPermission). MVP uses the agent's own permissions.
+                })
+                .pipe(
+                  Effect.mapError(() => new ToolFailure({ message: `Parent session not found: ${context.sessionID}` })),
+                )
+
+              const background = input.background === true
+
+              const run = Effect.gen(function* () {
+                // The child session owns its agent/model (set at create); prompt only admits input.
+                yield* runtime.prompt({ sessionID: child.id, prompt: { text: input.prompt }, resume: false })
+                yield* runtime.resume(child.id)
+                return yield* latestAssistantText(child.id)
+              })
+
+              const info = yield* jobs.start({
+                id: child.id,
+                type: name,
+                title: input.description,
+                metadata: {},
+                onPromote: injectWhenDone(context.sessionID, child.id, input.description),
+                run,
+              })
+
+              if (background) {
+                if ((yield* jobs.promote(info.id)) === undefined)
+                  yield* injectWhenDone(context.sessionID, child.id, input.description)
+                return { sessionID: child.id, status: "running" as const, output: BACKGROUND_STARTED }
+              }
+
+              const result = yield* Effect.raceFirst(
+                jobs.wait({ id: child.id }).pipe(Effect.map((waited) => waited.info)),
+                jobs.waitForPromotion(child.id),
+              ).pipe(
+                Effect.onInterrupt(() =>
+                  Effect.all([runtime.interrupt(child.id), jobs.cancel(child.id)], { discard: true }),
+                ),
+              )
+              if (result?.metadata?.background === true)
+                return { sessionID: child.id, status: "running" as const, output: BACKGROUND_STARTED }
+              if (result?.status === "error")
+                return yield* new ToolFailure({ message: result.error ?? "Subagent failed" })
+              if (result?.status === "cancelled") return yield* new ToolFailure({ message: "Subagent cancelled" })
+              return { sessionID: child.id, status: "completed" as const, output: result?.output ?? NO_TEXT }
+            }),
+        }),
+      })
+      .pipe(Effect.orDie)
+  }),
+)
+
+// Registered at the app root via ApplicationTools, not as a Location node: SessionV2 sits above
+// LocationServiceMap, so a location-scoped subagent node would create a static dependency cycle.
+// Agent lookup is resolved through the parent Session's location when the tool executes.
+export const node = makeGlobalNode({
+  name: "subagent-tool",
+  layer,
+  deps: [ApplicationTools.node, SessionV2.node, BackgroundJob.node, EventV2.node, LocationServiceMap.node],
+})
@@ -1,8 +1,7 @@
 import { describe, expect } from "bun:test"
 import { Tool } from "@opencode-ai/core/tool/tool"
 import { ApplicationTools } from "@opencode-ai/core/tool/application-tools"
-import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
-import { LayerNode } from "@opencode-ai/core/effect/layer-node"
+import { PermissionV2 } from "@opencode-ai/core/permission"
 import { SessionV2 } from "@opencode-ai/core/session"
 import { SessionMessage } from "@opencode-ai/core/session/message"
 import { AgentV2 } from "@opencode-ai/core/agent"
@@ -10,14 +9,19 @@ import { ToolRegistry } from "@opencode-ai/core/tool/registry"
 import { executeTool, settleTool, toolDefinitions } from "./lib/tool"
 import { ToolOutputStore } from "@opencode-ai/core/tool-output-store"
 import { Tools } from "@opencode-ai/core/tool/tools"
-import { Deferred, Effect, Exit, Fiber, Schema, Scope } from "effect"
+import { Deferred, Effect, Exit, Fiber, Layer, Schema, Scope } from "effect"
 import { testEffect } from "./lib/effect"

-const it = testEffect(
-  AppNodeBuilder.build(LayerNode.group([ApplicationTools.node, ToolRegistry.node, ToolRegistry.toolsNode]), [
-    [ToolOutputStore.node, ToolOutputStore.nodeWithoutConfig],
-  ]),
+const permission = Layer.mock(PermissionV2.Service, {
+  assert: () => Effect.void,
+})
+const applications = ApplicationTools.layer
+const registry = ToolRegistry.layer.pipe(
+  Layer.provide(permission),
+  Layer.provide(applications),
+  Layer.provide(ToolOutputStore.defaultLayer),
 )
+const it = testEffect(Layer.mergeAll(applications, registry))

 const sessionID = SessionV2.ID.make("ses_application_tool")
 const agent = AgentV2.ID.make("build")
@@ -3,8 +3,6 @@ import { Effect, Fiber, Layer, Stream } from "effect"
 import { Catalog } from "@opencode-ai/core/catalog"
 import { Integration } from "@opencode-ai/core/integration"
 import { Credential } from "@opencode-ai/core/credential"
-import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
-import { LayerNode } from "@opencode-ai/core/effect/layer-node"
 import { EventV2 } from "@opencode-ai/core/event"
 import { Location } from "@opencode-ai/core/location"
 import { ModelV2 } from "@opencode-ai/core/model"
@@ -23,11 +21,13 @@ const locationLayer = Layer.succeed(
  Location.Service,
  Location.Service.of(location({ directory: AbsolutePath.make("test") })),
 )
-const catalogLayer = AppNodeBuilder.build(
-  LayerNode.group([Catalog.node, EventV2.node, Credential.node, Integration.node, Policy.node]),
-  [[Location.node, locationLayer]],
+const it = testEffect(
+  Catalog.locationLayer.pipe(
+    Layer.provideMerge(EventV2.defaultLayer),
+    Layer.provideMerge(locationLayer),
+    Layer.provideMerge(Credential.defaultLayer),
+  ),
 )
-const it = testEffect(catalogLayer)

 describe("CatalogV2", () => {
  it.effect("publishes an updated event after catalog changes", () =>
@@ -47,8 +47,11 @@ describe("CatalogV2", () => {

  it.effect("derives availability from active credentials without changing provider state", () => {
    const integrationID = Integration.ID.make("test")
-    const localCatalogLayer = Layer.fresh(
-      AppNodeBuilder.build(LayerNode.group([Catalog.node, Credential.node]), [[Location.node, locationLayer]]),
+    const layer = Catalog.locationLayer.pipe(
+      Layer.fresh,
+      Layer.provideMerge(EventV2.defaultLayer),
+      Layer.provideMerge(locationLayer),
+      Layer.provideMerge(Credential.defaultLayer.pipe(Layer.fresh)),
    )

    return Effect.gen(function* () {
@@ -70,16 +73,17 @@ describe("CatalogV2", () => {
      })
      expect((yield* catalog.provider.available()).map((provider) => provider.id)).toEqual([ProviderV2.ID.make("test")])
      expect(required(yield* catalog.provider.get(ProviderV2.ID.make("test"))).request.body).toEqual({})
-    }).pipe(Effect.provide(localCatalogLayer))
+    }).pipe(Effect.provide(layer))
  })

  it.effect("derives availability from a provider's integration", () => {
    const integrationID = Integration.ID.make("gateway")
    const providerID = ProviderV2.ID.make("remote")
-    const localCatalogLayer = Layer.fresh(
-      AppNodeBuilder.build(LayerNode.group([Catalog.node, Credential.node, Integration.node]), [
-        [Location.node, locationLayer],
-      ]),
+    const layer = Catalog.locationLayer.pipe(
+      Layer.fresh,
+      Layer.provideMerge(EventV2.defaultLayer),
+      Layer.provideMerge(locationLayer),
+      Layer.provideMerge(Credential.defaultLayer.pipe(Layer.fresh)),
    )

    return Effect.gen(function* () {
@@ -98,7 +102,7 @@ describe("CatalogV2", () => {
      })

      expect((yield* catalog.provider.available()).map((provider) => provider.id)).toEqual([providerID])
-    }).pipe(Effect.provide(localCatalogLayer))
+    }).pipe(Effect.provide(layer))
  })

  it.effect("projects environment connections without a catalog plugin", () =>
@@ -1,12 +1,10 @@
 import { describe, expect } from "bun:test"
 import fs from "fs/promises"
 import path from "path"
-import { Effect, Schema } from "effect"
+import { Effect, Layer, Schema } from "effect"
 import { AgentV2 } from "@opencode-ai/core/agent"
 import { Config } from "@opencode-ai/core/config"
 import { ConfigAgentPlugin } from "@opencode-ai/core/config/plugin/agent"
-import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
-import { LayerNode } from "@opencode-ai/core/effect/layer-node"
 import { FSUtil } from "@opencode-ai/core/fs-util"
 import { PermissionV2 } from "@opencode-ai/core/permission"
 import { AbsolutePath } from "@opencode-ai/core/schema"
@@ -14,7 +12,7 @@ import { tmpdir } from "../fixture/tmpdir"
 import { testEffect } from "../lib/effect"
 import { agentHost, host } from "../plugin/host"

-const it = testEffect(AppNodeBuilder.build(LayerNode.group([AgentV2.node, FSUtil.node])))
+const it = testEffect(Layer.mergeAll(AgentV2.locationLayer, FSUtil.defaultLayer))
 const decode = Schema.decodeUnknownSync(Config.Info)

 describe("ConfigAgentPlugin.Plugin", () => {
@@ -1,12 +1,10 @@
 import fs from "fs/promises"
 import path from "path"
 import { describe, expect } from "bun:test"
-import { Effect, Schema } from "effect"
+import { Effect, Layer, Schema } from "effect"
 import { CommandV2 } from "@opencode-ai/core/command"
 import { Config } from "@opencode-ai/core/config"
 import { ConfigCommandPlugin } from "@opencode-ai/core/config/plugin/command"
-import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
-import { LayerNode } from "@opencode-ai/core/effect/layer-node"
 import { FSUtil } from "@opencode-ai/core/fs-util"
 import { ModelV2 } from "@opencode-ai/core/model"
 import { ProviderV2 } from "@opencode-ai/core/provider"
@@ -15,7 +13,7 @@ import { tmpdir } from "../fixture/tmpdir"
 import { testEffect } from "../lib/effect"
 import { host } from "../plugin/host"

-const it = testEffect(AppNodeBuilder.build(LayerNode.group([CommandV2.node, FSUtil.node])))
+const it = testEffect(Layer.mergeAll(CommandV2.locationLayer, FSUtil.defaultLayer))
 const decode = Schema.decodeUnknownSync(Config.Info)

 describe("ConfigCommandPlugin.Plugin", () => {
@@ -5,9 +5,6 @@ import { Effect, Layer, Schema } from "effect"
 import { FastCheck } from "effect/testing"
 import { Config } from "@opencode-ai/core/config"
 import { ConfigProvider } from "@opencode-ai/core/config/provider"
-import { makeLocationNode } from "@opencode-ai/core/effect/app-node"
-import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
-import { LayerNode } from "@opencode-ai/core/effect/layer-node"
 import { ConfigMigrateV1 } from "@opencode-ai/core/v1/config/migrate"
 import { ConfigV1 } from "@opencode-ai/core/v1/config/config"
 import { FSUtil } from "@opencode-ai/core/fs-util"
@@ -28,21 +25,21 @@ function testLayer(
  projectDirectory = directory,
  vcs?: Project.Vcs,
 ) {
-  const configNode = makeLocationNode({
-    service: Config.Service,
-    layer: Layer.fresh(Config.layer.pipe(Layer.provide(Global.layerWith({ config: globalDirectory })))),
-    deps: [FSUtil.node, Location.node, Policy.node],
-  })
-  const locationLayer = Layer.succeed(
-    Location.Service,
-    Location.Service.of(
-      location(
-        { directory: AbsolutePath.make(directory) },
-        { projectDirectory: AbsolutePath.make(projectDirectory), vcs },
+  return Config.locationLayer.pipe(
+    Layer.provide(FSUtil.defaultLayer),
+    Layer.provide(Global.layerWith({ config: globalDirectory })),
+    Layer.provide(
+      Layer.succeed(
+        Location.Service,
+        Location.Service.of(
+          location(
+            { directory: AbsolutePath.make(directory) },
+            { projectDirectory: AbsolutePath.make(projectDirectory), vcs },
+          ),
+        ),
      ),
    ),
  )
-  return AppNodeBuilder.build(LayerNode.group([configNode, Policy.node]), [[Location.node, locationLayer]])
 }

 const provider = {
@@ -1,11 +1,10 @@
 import { describe, expect } from "bun:test"
 import { Effect } from "effect"
 import { Credential } from "@opencode-ai/core/credential"
-import { LayerNode } from "@opencode-ai/core/effect/layer-node"
 import { Integration } from "@opencode-ai/core/integration"
 import { testEffect } from "./lib/effect"

-const it = testEffect(LayerNode.compile(Credential.node))
+const it = testEffect(Credential.defaultLayer)

 describe("Credential", () => {
  it.effect("stores, updates, lists, and removes credentials", () =>
@@ -56,23 +56,16 @@ const checkError: Layer.Layer<B, LayerError, never> = closedWithError
 void checkClosed
 void checkError

-LayerNode.compile(a, [[a, Layer.succeed(A, A.of({}))]])
-LayerNode.compile(a, [[a, make({ service: A, layer: Layer.succeed(A, A.of({})), deps: [] })]])
+LayerNode.replace(aLayer, Layer.succeed(A, A.of({})))

 // @ts-expect-error Replacement must provide A
-LayerNode.compile(a, [[a, Layer.succeed(B, B.of({}))]])
-
-// @ts-expect-error Node replacement must provide A
-const invalidNodeReplacement = () => LayerNode.compile(a, [[a, b]])
-void invalidNodeReplacement
+LayerNode.replace(aLayer, Layer.succeed(B, B.of({})))

 // @ts-expect-error Replacement cannot introduce a new error
-LayerNode.compile(a, [[a, Layer.effect(A, Effect.fail(new OtherError()))]])
+LayerNode.replace(aLayer, Layer.effect(A, Effect.fail(new OtherError())))

-const nodeReplacementWithError = make({ service: A, layer: Layer.effect(A, Effect.fail(new OtherError())), deps: [] })
-
-// @ts-expect-error Node replacement cannot introduce a new error
-LayerNode.compile(a, [[a, nodeReplacementWithError]])
+// @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") {}
@@ -13,7 +13,7 @@ class App extends Context.Service<App, { readonly run: Effect.Effect<string[]> }
 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, replacements) as Layer.Layer<A, E>
+  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,
@@ -63,20 +63,21 @@ describe("layer node", () => {
    expect(await Effect.runPromise(program)).toEqual(["first", "second"])
  })

-  test("requires unbound nodes to be replaced before compilation", async () => {
+  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 layer = LayerNode.compile(tree, [[unbound, value]]) as Layer.Layer<Greeting>
+    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 node with a closed layer", async () => {
+  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]), [[value, replacement]])),
+      Effect.provide(build(LayerNode.group([greeting]), [LayerNode.replace(valueLayer, replacement)])),
    )
    expect(await Effect.runPromise(program)).toBe("hello simulation")
  })
@@ -93,7 +94,7 @@ describe("layer node", () => {
    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]), [[value, replacement]])
+    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))
@@ -102,47 +103,22 @@ describe("layer node", () => {

  test("does not acquire an unused replacement", async () => {
    let acquisitions = 0
-    const other = make({ service: Left, layer: Layer.succeed(Left, Left.of({ value: "other" })), deps: [] })
+    const other = Layer.succeed(Value, Value.of({ value: "other" }))
    const replacement = Layer.effect(
-      Left,
+      Value,
      Effect.sync(() => {
        acquisitions++
-        return Left.of({ value: "replacement" })
+        return Value.of({ value: "replacement" })
      }),
    )
    await Effect.runPromise(
      Effect.map(Greeting, (item) => item.value).pipe(
-        Effect.provide(build(LayerNode.group([greeting]), [[other, replacement]])),
+        Effect.provide(build(LayerNode.group([greeting]), [LayerNode.replace(other, replacement)])),
      ),
    )
    expect(acquisitions).toBe(0)
  })

-  test("replaces a node without acquiring its dependencies", async () => {
-    let acquisitions = 0
-    const dependencyLayer = Layer.effect(
-      Value,
-      Effect.sync(() => {
-        acquisitions++
-        return Value.of({ value: "dependency" })
-      }),
-    )
-    const dependency = make({ service: Value, layer: dependencyLayer, deps: [] })
-    const original = make({ service: Greeting, layer: greetingLayer, deps: [dependency] })
-    const replacement = make({
-      service: Greeting,
-      layer: Layer.succeed(Greeting, Greeting.of({ value: "replacement" })),
-      deps: [],
-    })
-
-    const program = Effect.map(Greeting, (item) => item.value).pipe(
-      Effect.provide(build(LayerNode.group([original]), [[original, replacement]])),
-    )
-
-    expect(await Effect.runPromise(program)).toBe("replacement")
-    expect(acquisitions).toBe(0)
-  })
-
  test("hoists and compiles tagged graphs", async () => {
    const tags = LayerNode.tags({ location: ["global"], global: [] })
    const global = tags.make("global")
@@ -1,8 +1,8 @@
 import { describe, expect, test } from "bun:test"
 import { Context, Effect, Layer, LayerMap, Option } from "effect"
+import { LayerNode } from "@opencode-ai/core/effect/layer-node"
 import { Node } from "@opencode-ai/core/effect/app-node"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
-import { LayerNode } from "@opencode-ai/core/effect/layer-node"
 import { Location } from "@opencode-ai/core/location"
 import { LocationServiceMap } from "@opencode-ai/core/location-service-map"
 import type { LocationError, LocationServices } from "@opencode-ai/core/location-services"
@@ -31,7 +31,7 @@ describe("node build", () => {
    expect(await Effect.runPromise(program)).toBe("plain")
  })

-  test("detects cycles through a replaced location service map", async () => {
+  test("detects cycles through a bound location service map", () => {
    const a = Node.makeGlobalNode({
      service: CycleA,
      layer: Layer.effect(CycleA, Effect.as(LocationServiceMap.Service, CycleA.of({}))),
@@ -45,28 +45,26 @@ describe("node build", () => {
      ),
      deps: [a],
    })
-    const mapLayer = Layer.effect(
-      LocationServiceMap.Service,
-      Effect.gen(function* () {
-        const service = yield* CycleB
-        return yield* LayerMap.make(
-          (ref: Location.Ref) =>
-            Layer.succeed(
-              Location.Service,
-              Location.Service.of({
-                directory: ref.directory,
-                workspaceID: ref.workspaceID,
-                project: { id: Project.ID.global, directory: service.directory },
-              }),
-            ),
-          { idleTimeToLive: "1 minute" },
-        )
-      }) as unknown as Effect.Effect<LayerMap.LayerMap<Location.Ref, LocationServices, LocationError>, never, CycleB>,
-    )
+    const mapEffect = Effect.gen(function* () {
+      const service = yield* CycleB
+      return yield* LayerMap.make(
+        (ref: Location.Ref) =>
+          Layer.succeed(
+            Location.Service,
+            Location.Service.of({
+              directory: ref.directory,
+              workspaceID: ref.workspaceID,
+              project: { id: Project.ID.global, directory: service.directory },
+            }),
+          ),
+        { idleTimeToLive: "1 minute" },
+      )
+    }) as unknown as Effect.Effect<LayerMap.LayerMap<Location.Ref, LocationServices, LocationError>, never, CycleB>
+    const mapLayer = Layer.effect(LocationServiceMap.Service, mapEffect)
    const map = Node.makeGlobalNode({ service: LocationServiceMap.Service, layer: mapLayer, deps: [b] })
-    expect(() => AppNodeBuilder.build(LayerNode.group([a]), [[LocationServiceMap.node, map]])).toThrow(
-      "Cycle detected in layer tree",
-    )
+    const graph = LayerNode.bind(LayerNode.group([a]), LocationServiceMap.node, map)
+
+    expect(() => AppNodeBuilder.build(graph)).toThrow("Cycle detected in layer tree")
  })

  test("shares top-level project with location services", async () => {
@@ -83,10 +81,10 @@ describe("node build", () => {
        })
      }),
    )
-    const ref = Location.Ref.make({ directory: AbsolutePath.make(tmp.path) })
    const layer = AppNodeBuilder.build(LayerNode.group([Project.node, LocationServiceMap.node]), [
-      [Project.node, projectLayer],
+      LayerNode.replace(Project.layer, projectLayer),
    ])
+    const ref = Location.Ref.make({ directory: AbsolutePath.make(tmp.path) })
    const program = Effect.gen(function* () {
      yield* Project.Service
      const locations = yield* LocationServiceMap.Service
@@ -1,12 +1,11 @@
 import { describe, test, expect } from "bun:test"
-import { Effect, FileSystem } from "effect"
-import { LayerNodePlatform } from "@opencode-ai/core/effect/app-node-platform"
-import { LayerNode } from "@opencode-ai/core/effect/layer-node"
+import { Effect, Layer, FileSystem } from "effect"
+import { NodeFileSystem } from "@effect/platform-node"
 import { FSUtil } from "@opencode-ai/core/fs-util"
 import { testEffect } from "../lib/effect"
 import path from "path"

-const live = LayerNode.compile(LayerNode.group([FSUtil.node, LayerNodePlatform.filesystem]))
+const live = Layer.merge(FSUtil.defaultLayer, NodeFileSystem.layer)
 const { effect: it } = testEffect(live)

 describe("FSUtil", () => {
@@ -2,6 +2,7 @@ import fs from "fs/promises"
 import path from "path"
 import { describe, expect } from "bun:test"
 import { Effect, Exit, Layer } from "effect"
+import { makeLocationNode } from "@opencode-ai/core/effect/app-node"
 import { LayerNode } from "@opencode-ai/core/effect/layer-node"
 import { FileSystem } from "@opencode-ai/core/filesystem"
 import { Location } from "@opencode-ai/core/location"
@@ -12,12 +13,20 @@ import { it } from "./lib/effect"

 const provide = (directory: string) =>
  Effect.provide(
-    LayerNode.compile(FileSystem.node, [
-      [
+    LayerNode.compile(
+      LayerNode.bind(
+        FileSystem.node,
        Location.node,
-        Layer.succeed(Location.Service, Location.Service.of(location({ directory: AbsolutePath.make(directory) }))),
-      ],
-    ]),
+        makeLocationNode({
+          service: Location.Service,
+          layer: Layer.succeed(
+            Location.Service,
+            Location.Service.of(location({ directory: AbsolutePath.make(directory) })),
+          ),
+          deps: [],
+        }),
+      ),
+    ),
  )

 const withTmp = <A, E, R>(f: (directory: string) => Effect.Effect<A, E, R>) =>
@@ -2,6 +2,7 @@ import fs from "fs/promises"
 import path from "path"
 import { describe, expect, test } from "bun:test"
 import { Effect, Layer, Schema } from "effect"
+import { makeLocationNode } from "@opencode-ai/core/effect/app-node"
 import { LayerNode } from "@opencode-ai/core/effect/layer-node"
 import { Location } from "@opencode-ai/core/location"
 import { LocationMutation } from "@opencode-ai/core/location-mutation"
@@ -12,12 +13,20 @@ import { it } from "./lib/effect"

 function provide(directory: string) {
  return Effect.provide(
-    LayerNode.compile(LocationMutation.node, [
-      [
+    LayerNode.compile(
+      LayerNode.bind(
+        LocationMutation.node,
        Location.node,
-        Layer.succeed(Location.Service, Location.Service.of(location({ directory: AbsolutePath.make(directory) }))),
-      ],
-    ]),
+        makeLocationNode({
+          service: Location.Service,
+          layer: Layer.succeed(
+            Location.Service,
+            Location.Service.of(location({ directory: AbsolutePath.make(directory) })),
+          ),
+          deps: [],
+        }),
+      ),
+    ),
  )
 }

@@ -1,12 +1,11 @@
 import { describe, expect, beforeAll, beforeEach, afterAll } from "bun:test"
 import { Effect, Layer, Ref } from "effect"
 import { HttpClient, HttpClientResponse } from "effect/unstable/http"
-import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
-import { LayerNodePlatform } from "@opencode-ai/core/effect/app-node-platform"
-import { LayerNode } from "@opencode-ai/core/effect/layer-node"
+import { FSUtil } from "@opencode-ai/core/fs-util"
 import { Flag } from "@opencode-ai/core/flag/flag"
 import { Global } from "@opencode-ai/core/global"
 import { ModelsDev } from "@opencode-ai/core/models-dev"
+import { EventV2 } from "@opencode-ai/core/event"
 import { it } from "./lib/effect"
 import { readFile, rm, writeFile, utimes, mkdir } from "fs/promises"
 import path from "path"
@@ -91,10 +90,10 @@ const buildLayer = (state: Ref.Ref<MockState>) =>
  // Layer.fresh is required: ModelsDev.layer is a module-level Layer constant,
  // and Effect.provide uses a process-global MemoMap by default — without fresh,
  // every test would reuse the cachedInvalidateWithTTL state from the first run.
-  Layer.fresh(
-    AppNodeBuilder.build(ModelsDev.node, [
-      [LayerNodePlatform.httpClient, Layer.succeed(HttpClient.HttpClient, makeMockClient(state))],
-    ]),
+  Layer.fresh(ModelsDev.layer).pipe(
+    Layer.provide(Layer.succeed(HttpClient.HttpClient, makeMockClient(state))),
+    Layer.provide(FSUtil.defaultLayer),
+    Layer.provide(EventV2.defaultLayer),
  )

 const writeCacheText = (text: string, mtimeMs?: number) =>
@@ -3,25 +3,30 @@ import { describe, expect } from "bun:test"
 import { Effect, Layer } from "effect"
 import { Catalog } from "@opencode-ai/core/catalog"
 import { Integration } from "@opencode-ai/core/integration"
-import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
-import { LayerNode } from "@opencode-ai/core/effect/layer-node"
+import { Credential } from "@opencode-ai/core/credential"
 import { EventV2 } from "@opencode-ai/core/event"
 import { Flag } from "@opencode-ai/core/flag/flag"
 import { Location } from "@opencode-ai/core/location"
 import { ModelsDev } from "@opencode-ai/core/models-dev"
 import { ModelsDevPlugin } from "@opencode-ai/core/plugin/models-dev"
+import { Policy } from "@opencode-ai/core/policy"
 import { AbsolutePath } from "@opencode-ai/core/schema"
 import { location } from "../fixture/location"
 import { testEffect } from "../lib/effect"
 import { catalogHost, host, integrationHost } from "./host"

+const events = EventV2.defaultLayer
 const locationLayer = Layer.succeed(
  Location.Service,
  Location.Service.of(location({ directory: AbsolutePath.make(import.meta.dir) })),
 )
-const layer = AppNodeBuilder.build(LayerNode.group([Catalog.node, Integration.node, EventV2.node]), [
-  [Location.node, locationLayer],
-])
+const policy = Policy.layer.pipe(Layer.provide(locationLayer))
+const connections = Credential.defaultLayer.pipe(Layer.fresh)
+const integrations = Integration.locationLayer.pipe(Layer.provide(events), Layer.provide(connections))
+const catalog = Catalog.layer.pipe(
+  Layer.provide(Layer.mergeAll(events, locationLayer, policy, connections, integrations)),
+)
+const layer = Layer.mergeAll(catalog.pipe(Layer.provide(connections)), integrations, connections, events, locationLayer)
 const it = testEffect(layer)

 describe("ModelsDevPlugin", () => {
@@ -60,7 +65,7 @@ describe("ModelsDevPlugin", () => {
              connections: [],
            }),
          ])
-        }).pipe(Effect.provide(AppNodeBuilder.build(ModelsDev.node))),
+        }).pipe(Effect.provide(ModelsDev.defaultLayer)),
      (previous) =>
        Effect.sync(() => {
          Flag.OPENCODE_MODELS_PATH = previous.path
@@ -1,9 +1,11 @@
 import { describe, expect } from "bun:test"
 import { Catalog } from "@opencode-ai/core/catalog"
-import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
-import { LayerNode } from "@opencode-ai/core/effect/layer-node"
+import { Credential } from "@opencode-ai/core/credential"
+import { EventV2 } from "@opencode-ai/core/event"
+import { Integration } from "@opencode-ai/core/integration"
 import { Location } from "@opencode-ai/core/location"
 import { ModelV2 } from "@opencode-ai/core/model"
+import { Policy } from "@opencode-ai/core/policy"
 import { VariantPlugin } from "@opencode-ai/core/plugin/variant"
 import { ProviderV2 } from "@opencode-ai/core/provider"
 import { AbsolutePath } from "@opencode-ai/core/schema"
@@ -12,11 +14,21 @@ import { location } from "../fixture/location"
 import { testEffect } from "../lib/effect"
 import { catalogHost, host } from "./host"

+const events = EventV2.defaultLayer
 const locationLayer = Layer.succeed(
  Location.Service,
  Location.Service.of(location({ directory: AbsolutePath.make(import.meta.dir) })),
 )
-const it = testEffect(AppNodeBuilder.build(Catalog.node, [[Location.node, locationLayer]]))
+const connections = Credential.defaultLayer.pipe(Layer.fresh)
+const integrations = Integration.locationLayer.pipe(Layer.provide(events), Layer.provide(connections))
+const catalog = Catalog.layer.pipe(
+  Layer.provide(
+    Layer.mergeAll(events, locationLayer, Policy.layer.pipe(Layer.provide(locationLayer)), connections, integrations),
+  ),
+)
+const it = testEffect(
+  Layer.mergeAll(catalog.pipe(Layer.provide(connections)), integrations, connections, events, locationLayer),
+)

 describe("VariantPlugin", () => {
  it.effect("adds GLM 5.2 variants after catalog sources", () =>
@@ -3,10 +3,9 @@ import { $ } from "bun"
 import fs from "fs/promises"
 import path from "path"
 import { eq } from "drizzle-orm"
-import { Effect, Fiber, Stream } from "effect"
-import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
-import { LayerNode } from "@opencode-ai/core/effect/layer-node"
+import { Effect, Fiber, Layer, Stream } from "effect"
 import { AbsolutePath } from "@opencode-ai/core/schema"
+import { FSUtil } from "@opencode-ai/core/fs-util"
 import { Git } from "@opencode-ai/core/git"
 import { Database } from "@opencode-ai/core/database/database"
 import { EventV2 } from "@opencode-ai/core/event"
@@ -17,8 +16,15 @@ import { ProjectDirectories } from "@opencode-ai/core/project/directories"
 import { tmpdir } from "./fixture/tmpdir"
 import { testEffect } from "./lib/effect"

+const copyLayer = ProjectCopy.layer.pipe(
+  Layer.provide(Database.defaultLayer),
+  Layer.provide(ProjectDirectories.defaultLayer),
+  Layer.provide(EventV2.defaultLayer),
+  Layer.provide(FSUtil.defaultLayer),
+  Layer.provide(Git.defaultLayer),
+)
 const it = testEffect(
-  AppNodeBuilder.build(LayerNode.group([ProjectCopy.node, Database.node, EventV2.node, ProjectDirectories.node])),
+  Layer.mergeAll(copyLayer, Database.defaultLayer, EventV2.defaultLayer, ProjectDirectories.defaultLayer),
 )

 function abs(input: string) {
@@ -1,18 +1,16 @@
 import { describe, expect } from "bun:test"
 import { Effect, Exit, Layer, Scope } from "effect"
-import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
-import { LayerNode } from "@opencode-ai/core/effect/layer-node"
 import { AbsolutePath } from "@opencode-ai/core/schema"
 import { Global } from "@opencode-ai/core/global"
 import { Reference } from "@opencode-ai/core/reference"
 import { Repository } from "@opencode-ai/core/repository"
 import { RepositoryCache } from "@opencode-ai/core/repository-cache"
+import { EventV2 } from "@opencode-ai/core/event"
 import { it } from "./lib/effect"

 const cache = Layer.mock(RepositoryCache.Service, {
  ensure: () => Effect.die("unexpected Git materialization"),
 })
-const referenceLayer = AppNodeBuilder.build(Reference.node, [[RepositoryCache.node, cache]])

 describe("Reference", () => {
  it.effect("registers normalized sources for the owning scope", () =>
@@ -34,7 +32,12 @@ describe("Reference", () => {

      yield* Scope.close(scope, Exit.void)
      expect(yield* references.list()).toEqual([])
-    }).pipe(Effect.provide(referenceLayer)),
+    }).pipe(
+      Effect.provide(Reference.layer),
+      Effect.provide(cache),
+      Effect.provide(EventV2.defaultLayer),
+      Effect.provide(Global.defaultLayer),
+    ),
  )

  it.effect("derives Git paths without exposing cache operations", () =>
@@ -51,7 +54,13 @@ describe("Reference", () => {
          source,
        }),
      ])
-    }).pipe(Effect.scoped, Effect.provide(referenceLayer)),
+    }).pipe(
+      Effect.scoped,
+      Effect.provide(Reference.layer),
+      Effect.provide(cache),
+      Effect.provide(EventV2.defaultLayer),
+      Effect.provide(Global.defaultLayer),
+    ),
  )

  it.effect("preserves configured Git descriptions", () =>
@@ -73,6 +82,12 @@ describe("Reference", () => {
          source,
        }),
      ])
-    }).pipe(Effect.scoped, Effect.provide(referenceLayer)),
+    }).pipe(
+      Effect.scoped,
+      Effect.provide(Reference.layer),
+      Effect.provide(cache),
+      Effect.provide(EventV2.defaultLayer),
+      Effect.provide(Global.defaultLayer),
+    ),
  )
 })
@@ -3,11 +3,12 @@ import fs from "fs/promises"
 import path from "path"
 import { pathToFileURL } from "url"
 import { Effect, Layer } from "effect"
-import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
-import { LayerNode } from "@opencode-ai/core/effect/layer-node"
+import { FSUtil } from "@opencode-ai/core/fs-util"
+import { Git } from "@opencode-ai/core/git"
 import { Global } from "@opencode-ai/core/global"
 import { Repository } from "@opencode-ai/core/repository"
 import { RepositoryCache } from "@opencode-ai/core/repository-cache"
+import { EffectFlock } from "@opencode-ai/core/util/effect-flock"
 import { git, gitRemote } from "./fixture/git"
 import { tmpdir } from "./fixture/tmpdir"
 import { testEffect } from "./lib/effect"
@@ -88,9 +89,15 @@ describe("RepositoryCache", () => {
 })

 function cacheLayer(root: string) {
-  return AppNodeBuilder.build(RepositoryCache.node, [
-    [Global.node, Global.layerWith({ state: path.join(root, "state"), repos: path.join(root, "repos") })],
-  ])
+  const dependencies = Layer.mergeAll(
+    Global.layerWith({ state: path.join(root, "state"), repos: path.join(root, "repos") }),
+    FSUtil.defaultLayer,
+  )
+  return RepositoryCache.layer.pipe(
+    Layer.provide(EffectFlock.layer.pipe(Layer.provide(dependencies))),
+    Layer.provide(Git.defaultLayer),
+    Layer.provide(dependencies),
+  )
 }

 function withRemote<A, E, R>(body: (fixture: Awaited<ReturnType<typeof gitRemote>>) => Effect.Effect<A, E, R>) {
@@ -56,6 +56,14 @@ const it = testEffect(
 const location = Location.Ref.make({ directory: AbsolutePath.make("/project") })
 const id = SessionV2.ID.create()

+const assertCreateInputTypes = (session: SessionV2.Interface) => {
+  // @ts-expect-error location or parentID is required.
+  session.create({})
+  // @ts-expect-error child sessions inherit their parent's location.
+  session.create({ parentID: SessionV2.ID.create(), location })
+}
+void assertCreateInputTypes
+
 describe("SessionV2.create", () => {
  it.effect("creates a fresh projected session when the ID is omitted", () =>
    Effect.gen(function* () {
@@ -102,6 +110,27 @@ describe("SessionV2.create", () => {
    }),
  )

+  it.effect("inherits location from an existing parent when omitted", () =>
+    Effect.gen(function* () {
+      const session = yield* SessionV2.Service
+      const parent = yield* session.create({ location })
+      const child = yield* session.create({ parentID: parent.id, title: "child" })
+
+      expect(child).toMatchObject({ parentID: parent.id, location })
+    }),
+  )
+
+  it.effect("rejects child creation when the parent does not exist", () =>
+    Effect.gen(function* () {
+      const session = yield* SessionV2.Service
+      const missing = SessionV2.ID.create()
+
+      expect(yield* Effect.flip(session.create({ parentID: missing, title: "child" }))).toEqual(
+        new SessionV2.NotFoundError({ sessionID: missing }),
+      )
+    }),
+  )
+
  it.effect("returns the existing Session when one ID is reused with different create arguments", () =>
    Effect.gen(function* () {
      const session = yield* SessionV2.Service
@@ -4,6 +4,7 @@ import { asc, eq } from "drizzle-orm"
 import { Database } from "@opencode-ai/core/database/database"
 import { LayerNode } from "@opencode-ai/core/effect/layer-node"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
+import { makeGlobalNode } from "@opencode-ai/core/effect/app-node"
 import { EventV2 } from "@opencode-ai/core/event"
 import { EventTable } from "@opencode-ai/core/event/sql"
 import { ModelV2 } from "@opencode-ai/core/model"
@@ -24,7 +25,13 @@ import { testEffect } from "./lib/effect"
 import { Snapshot } from "@opencode-ai/core/snapshot"

 const it = testEffect(AppNodeBuilder.build(LayerNode.group([Database.node, EventV2.node, SessionProjector.node])))
-const sessionsLayer = AppNodeBuilder.build(SessionV2.node, [[SessionExecution.node, SessionExecution.noopLayer]])
+const sessionsLayer = AppNodeBuilder.build(
+  LayerNode.bind(
+    SessionV2.node,
+    SessionExecution.node,
+    makeGlobalNode({ service: SessionExecution.Service, layer: SessionExecution.noopLayer, deps: [] }),
+  ),
+)
 const sessionID = SessionV2.ID.make("ses_projector_test")
 const created = DateTime.makeUnsafe(0)
 const model = { id: ModelV2.ID.make("model"), providerID: ProviderV2.ID.make("provider") }
@@ -39,6 +39,7 @@ const execution = Layer.succeed(
      Effect.sync(() => {
        wakeCalls.push(sessionID)
      }),
+    awaitIdle: () => Effect.void,
  }),
 )
 const sessions = SessionV2.layer.pipe(
@@ -173,6 +174,33 @@ describe("SessionV2.prompt", () => {
    }),
  )

+  it.effect("preserves an optional per-request system string through admission and projection", () =>
+    Effect.gen(function* () {
+      yield* setup
+      const { db } = yield* Database.Service
+      const session = yield* SessionV2.Service
+      const events = yield* EventV2.Service
+
+      const message = yield* session.prompt({
+        sessionID,
+        prompt: Prompt.make({ text: "Fix the failing tests", system: "Per-request override" }),
+        resume: false,
+      })
+
+      expect(message.prompt.system).toBe("Per-request override")
+      expect(yield* admitted(message.id)).toMatchObject({
+        id: message.id,
+        prompt: { text: "Fix the failing tests", system: "Per-request override" },
+      })
+
+      yield* SessionInput.promoteSteers(db, events, sessionID, Number.MAX_SAFE_INTEGER)
+
+      expect(yield* session.messages({ sessionID })).toMatchObject([
+        { id: message.id, type: "user", text: "Fix the failing tests", system: "Per-request override" },
+      ])
+    }),
+  )
+
  it.effect("resolves attachment MIME before admission", () =>
    Effect.gen(function* () {
      yield* setup
@@ -99,6 +99,7 @@ const execution = Layer.effect(
      resume: coordinator.run,
      wake: coordinator.wake,
      interrupt: coordinator.interrupt,
+      awaitIdle: coordinator.awaitIdle,
    })
  }),
 ).pipe(Layer.provide(runner))
@@ -258,6 +258,7 @@ const execution = Layer.effect(
      resume: coordinator.run,
      wake: coordinator.wake,
      interrupt: coordinator.interrupt,
+      awaitIdle: coordinator.awaitIdle,
    })
  }),
 ).pipe(Layer.provide(runner))
@@ -371,6 +372,21 @@ const messageTexts = (request: LLMRequest, role: "user" | "system") =>
 const userTexts = (request: LLMRequest) => messageTexts(request, "user")
 const systemTexts = (request: LLMRequest) => messageTexts(request, "system")

+const recordedEventTypes = (id: SessionV2.ID) =>
+  Effect.gen(function* () {
+    const { db } = yield* Database.Service
+    return yield* db
+      .select({ type: EventTable.type })
+      .from(EventTable)
+      .where(eq(EventTable.aggregate_id, id))
+      .orderBy(asc(EventTable.seq))
+      .all()
+      .pipe(
+        Effect.orDie,
+        Effect.map((rows) => rows.map((row) => row.type)),
+      )
+  })
+
 const replaySessionProjection = (id: SessionV2.ID) =>
  Effect.gen(function* () {
    const { db } = yield* Database.Service
@@ -831,6 +847,59 @@ describe("SessionRunnerLLM", () => {
    }),
  )

+  it.effect("appends the per-request prompt system after the agent prompt and durable baseline", () =>
+    Effect.gen(function* () {
+      yield* setup
+      const agent = yield* AgentV2.Service
+      yield* agent.transform((editor) =>
+        editor.update(AgentV2.ID.make("build"), (agent) => {
+          agent.system = "Build agent instructions"
+          agent.mode = "primary"
+        }),
+      )
+      const session = yield* SessionV2.Service
+      yield* session.prompt({
+        sessionID,
+        prompt: Prompt.make({ text: "First", system: "Per-request override" }),
+        resume: false,
+      })
+
+      requests.length = 0
+      response = fragmentFixture("text", "text-system", ["Done"]).completeEvents
+      yield* session.resume(sessionID)
+
+      expect(requests.at(-1)?.system.map((part) => part.text)).toEqual([
+        "Build agent instructions",
+        "Initial context",
+        "Per-request override",
+      ])
+    }),
+  )
+
+  it.effect("omits the per-request system part when the prompt has no system string", () =>
+    Effect.gen(function* () {
+      yield* setup
+      const agent = yield* AgentV2.Service
+      yield* agent.transform((editor) =>
+        editor.update(AgentV2.ID.make("build"), (agent) => {
+          agent.system = "Build agent instructions"
+          agent.mode = "primary"
+        }),
+      )
+      const session = yield* SessionV2.Service
+      yield* session.prompt({ sessionID, prompt: Prompt.make({ text: "First" }), resume: false })
+
+      requests.length = 0
+      response = fragmentFixture("text", "text-no-system", ["Done"]).completeEvents
+      yield* session.resume(sessionID)
+
+      expect(requests.at(-1)?.system.map((part) => part.text)).toEqual([
+        "Build agent instructions",
+        "Initial context",
+      ])
+    }),
+  )
+
  it.effect("uses an explicitly selected non-build agent system", () =>
    Effect.gen(function* () {
      yield* setup
@@ -2772,6 +2841,11 @@ describe("SessionRunnerLLM", () => {

      expect(Exit.isFailure(exit) && Cause.hasInterruptsOnly(exit.cause)).toBeTrue()
      expect(requests).toHaveLength(1)
+      expect(yield* session.context(sessionID)).toMatchObject([
+        { type: "user", text: "Interrupt provider" },
+        { type: "assistant", finish: "error", error: { type: "unknown", message: "Provider turn interrupted" } },
+      ])
+      expect(yield* recordedEventTypes(sessionID)).toContain("session.next.step.failed.2")
      yield* session.interrupt(sessionID)
    }),
  )
@@ -2801,6 +2875,8 @@ describe("SessionRunnerLLM", () => {
        { type: "user", text: "Interrupt tool settlement" },
        {
          type: "assistant",
+          finish: "error",
+          error: { type: "unknown", message: "Provider turn interrupted" },
          content: [
            {
              type: "tool",
@@ -2810,6 +2886,9 @@ describe("SessionRunnerLLM", () => {
          ],
        },
      ])
+      const eventTypes = yield* recordedEventTypes(sessionID)
+      expect(eventTypes).toContain("session.next.step.failed.2")
+      expect(eventTypes).not.toContain("session.next.step.ended.2")
    }),
  )

@@ -1,8 +1,7 @@
 import { describe, expect } from "bun:test"
 import { asc, eq } from "drizzle-orm"
-import { DateTime, Effect, Schema } from "effect"
+import { DateTime, Effect, Layer, Schema } from "effect"
 import { Database } from "@opencode-ai/core/database/database"
-import { LayerNode } from "@opencode-ai/core/effect/layer-node"
 import { EventV2 } from "@opencode-ai/core/event"
 import { EventTable } from "@opencode-ai/core/event/sql"
 import { ModelV2 } from "@opencode-ai/core/model"
@@ -17,7 +16,7 @@ import { SessionProjector } from "@opencode-ai/core/session/projector"
 import { SessionTable, SessionMessageTable } from "@opencode-ai/core/session/sql"
 import { testEffect } from "./lib/effect"

-const it = testEffect(LayerNode.compile(LayerNode.group([Database.node, EventV2.node, SessionProjector.node])))
+const it = testEffect(Layer.mergeAll(Database.defaultLayer, EventV2.defaultLayer, SessionProjector.defaultLayer))
 const timestamp = DateTime.makeUnsafe(1)
 const model = { id: ModelV2.ID.make("model"), providerID: ProviderV2.ID.make("provider") }

@@ -0,0 +1,54 @@
+import { describe, expect } from "bun:test"
+import { Effect, Layer } from "effect"
+import { Database } from "@opencode-ai/core/database/database"
+import { EventV2 } from "@opencode-ai/core/event"
+import { Location } from "@opencode-ai/core/location"
+import { ProjectV2 } from "@opencode-ai/core/project"
+import { AbsolutePath } from "@opencode-ai/core/schema"
+import { SessionV2 } from "@opencode-ai/core/session"
+import { SessionProjector } from "@opencode-ai/core/session/projector"
+import { SessionExecution } from "@opencode-ai/core/session/execution"
+import { SessionStore } from "@opencode-ai/core/session/store"
+import { locationServiceMapLayer } from "@opencode-ai/core/location-services"
+import { testEffect } from "./lib/effect"
+
+const location = Location.Ref.make({ directory: AbsolutePath.make("/project") })
+const awaited: SessionV2.ID[] = []
+const projects = Layer.mock(ProjectV2.Service, {
+  resolve: (directory) => Effect.succeed({ id: ProjectV2.ID.global, directory }),
+})
+const execution = Layer.mock(SessionExecution.Service, {
+  awaitIdle: (sessionID) => Effect.sync(() => awaited.push(sessionID)),
+})
+const sessions = SessionV2.layer.pipe(
+  Layer.provide(locationServiceMapLayer),
+  Layer.provide(EventV2.defaultLayer),
+  Layer.provide(Database.defaultLayer),
+  Layer.provide(SessionStore.defaultLayer),
+  Layer.provide(projects),
+  Layer.provide(execution),
+)
+const it = testEffect(
+  Layer.mergeAll(
+    Database.defaultLayer,
+    EventV2.defaultLayer,
+    projects,
+    SessionProjector.defaultLayer,
+    SessionStore.defaultLayer,
+    sessions,
+  ),
+)
+
+describe("SessionV2.wait", () => {
+  it.effect("delegates to SessionExecution.awaitIdle", () =>
+    Effect.gen(function* () {
+      awaited.length = 0
+      const sessions = yield* SessionV2.Service
+      const session = yield* sessions.create({ location })
+
+      yield* sessions.wait(session.id)
+
+      expect(awaited).toEqual([session.id])
+    }),
+  )
+})
@@ -3,9 +3,7 @@ import path from "path"
 import { describe, expect, test } from "bun:test"
 import { Effect, Layer } from "effect"
 import { HttpClient, HttpClientResponse } from "effect/unstable/http"
-import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
-import { LayerNodePlatform } from "@opencode-ai/core/effect/app-node-platform"
-import { LayerNode } from "@opencode-ai/core/effect/layer-node"
+import { FSUtil } from "@opencode-ai/core/fs-util"
 import { Global } from "@opencode-ai/core/global"
 import { SkillDiscovery } from "@opencode-ai/core/skill/discovery"
 import { tmpdir } from "./fixture/tmpdir"
@@ -29,14 +27,15 @@ async function pull(skills: unknown[], files: Record<string, string> = {}, cache
      ),
    ),
  )
-  const skillDiscoveryLayer = AppNodeBuilder.build(SkillDiscovery.node, [
-    [LayerNodePlatform.httpClient, http],
-    [Global.node, Global.layerWith({ cache: tmp.path })],
-  ])
+  const layer = SkillDiscovery.layer.pipe(
+    Layer.provide(http),
+    Layer.provide(FSUtil.defaultLayer),
+    Layer.provide(Global.layerWith({ cache: tmp.path })),
+  )
  const directories = await Effect.runPromise(
    Effect.gen(function* () {
      return yield* (yield* SkillDiscovery.Service).pull(base)
-    }).pipe(Effect.provide(skillDiscoveryLayer)),
+    }).pipe(Effect.provide(layer)),
  )
  return { tmp, requests, directories }
 }
@@ -24,7 +24,9 @@ const discovery = Layer.succeed(
  }),
 )
 const it = testEffect(
-  AppNodeBuilder.build(LayerNode.group([SkillV2.node, AgentV2.node]), [[SkillDiscovery.node, discovery]]),
+  AppNodeBuilder.build(LayerNode.group([SkillV2.node, AgentV2.node]), [
+    LayerNode.replace(SkillDiscovery.layer, discovery),
+  ]),
 )

 function write(directory: string, name: string, description: string) {
@@ -1,6 +1,7 @@
 import { describe, expect } from "bun:test"
 import { Effect, Layer } from "effect"
 import * as TestClock from "effect/testing/TestClock"
+import { makeLocationNode } from "@opencode-ai/core/effect/app-node"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { LayerNode } from "@opencode-ai/core/effect/layer-node"
 import { Location } from "@opencode-ai/core/location"
@@ -27,12 +28,14 @@ const locationLayer = Layer.succeed(
    ),
  ),
 )
-const builtInsNode = LayerNode.group([SystemContextBuiltIns.node, SystemContextRegistry.node])
+const locationNode = makeLocationNode({ service: Location.Service, layer: locationLayer, deps: [] })
+const builtInsNode = LayerNode.bind(
+  LayerNode.group([SystemContextBuiltIns.node, SystemContextRegistry.node]),
+  Location.node,
+  locationNode,
+)
 const it = testEffect(
-  AppNodeBuilder.build(builtInsNode, [
-    [Location.node, locationLayer],
-    [Global.node, Global.layerWith({ config: "/global" })],
-  ]),
+  AppNodeBuilder.build(builtInsNode, [LayerNode.replace(Global.layer, Global.layerWith({ config: "/global" }))]),
 )
 const instructionFS = Layer.effect(
  FSUtil.Service,
@@ -48,9 +51,8 @@ const instructionFS = Layer.effect(
 ).pipe(Layer.provide(LayerNode.compile(FSUtil.node)))
 const itWithInstructions = testEffect(
  AppNodeBuilder.build(builtInsNode, [
-    [Location.node, locationLayer],
-    [FSUtil.node, instructionFS],
-    [Global.node, Global.layerWith({ config: "/global" })],
+    LayerNode.replace(FSUtil.layer, instructionFS),
+    LayerNode.replace(Global.layer, Global.layerWith({ config: "/global" })),
  ]),
 )

@@ -1,8 +1,6 @@
 import { describe, expect } from "bun:test"
 import path from "path"
 import { Cause, Effect, Exit, Fiber, Layer, Option } from "effect"
-import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
-import { LayerNode } from "@opencode-ai/core/effect/layer-node"
 import { FSUtil } from "@opencode-ai/core/fs-util"
 import { Global } from "@opencode-ai/core/global"
 import { Config } from "@opencode-ai/core/config"
@@ -30,14 +28,14 @@ const withStore = <A, E, R>(
            }),
          )
        : Layer.empty
-
-      const store = AppNodeBuilder.build(LayerNode.group([ToolOutputStore.node, FSUtil.node]), [
-        [Global.node, global],
-        [Config.node, configured],
-      ])
+      const store = ToolOutputStore.layer.pipe(
+        Layer.provide(FSUtil.defaultLayer),
+        Layer.provide(global),
+        Layer.provide(configured),
+      )
      return Effect.gen(function* () {
        return yield* body({ root: tmp.path, store: yield* ToolOutputStore.Service, fs: yield* FSUtil.Service })
-      }).pipe(Effect.provide(store))
+      }).pipe(Effect.provide(Layer.mergeAll(store, FSUtil.defaultLayer)))
    },
    (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
  )
@@ -187,11 +185,11 @@ describe("ToolOutputStore", () => {
            writeFileString: () => Effect.never,
          })
        }),
-      ).pipe(Layer.provide(LayerNode.compile(FSUtil.node)))
-      const store = AppNodeBuilder.build(ToolOutputStore.nodeWithoutConfig, [
-        [Global.node, Global.layerWith({ data: root.path })],
-        [FSUtil.node, blockedFilesystem],
-      ])
+      ).pipe(Layer.provide(FSUtil.defaultLayer))
+      const store = ToolOutputStore.layer.pipe(
+        Layer.provide(blockedFilesystem),
+        Layer.provide(Global.layerWith({ data: root.path })),
+      )
      const exit = yield* Effect.gen(function* () {
        const service = yield* ToolOutputStore.Service
        const fiber = yield* service
@@ -1,13 +1,10 @@
 import { describe, expect } from "bun:test"
 import { Effect, Exit, Fiber, Layer } from "effect"
-import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
-import { LayerNode } from "@opencode-ai/core/effect/layer-node"
 import { PermissionV2 } from "@opencode-ai/core/permission"
 import { QuestionV2 } from "@opencode-ai/core/question"
 import { SessionV2 } from "@opencode-ai/core/session"
 import { ToolRegistry } from "@opencode-ai/core/tool/registry"
 import { QuestionTool } from "@opencode-ai/core/tool/question"
-import { ToolOutputStore } from "@opencode-ai/core/tool-output-store"
 import { testEffect } from "./lib/effect"
 import { toolIdentity, executeTool, settleTool, toolDefinitions } from "./lib/tool"

@@ -31,9 +28,7 @@ const permission = Layer.succeed(
    list: () => Effect.die("unused"),
  }),
 )
-const registry = AppNodeBuilder.build(LayerNode.group([ToolRegistry.node, ToolRegistry.toolsNode]), [
-  [ToolOutputStore.node, ToolOutputStore.nodeWithoutConfig],
-])
+const registry = ToolRegistry.defaultLayer.pipe(Layer.provide(permission))
 const question = Layer.succeed(
  QuestionV2.Service,
  QuestionV2.Service.of({
@@ -1,13 +1,12 @@
 import { describe, expect } from "bun:test"
+import { NodeFileSystem } from "@effect/platform-node"
 import path from "path"
-import { Effect, FileSystem } from "effect"
-import { LayerNodePlatform } from "@opencode-ai/core/effect/app-node-platform"
-import { LayerNode } from "@opencode-ai/core/effect/layer-node"
+import { Effect, FileSystem, Layer } from "effect"
 import { FSUtil } from "@opencode-ai/core/fs-util"
 import { ReadToolFileSystem } from "@opencode-ai/core/tool/read-filesystem"
 import { testEffect } from "./lib/effect"

-const it = testEffect(LayerNode.compile(LayerNode.group([FSUtil.node, LayerNodePlatform.filesystem])))
+const it = testEffect(Layer.merge(FSUtil.defaultLayer, NodeFileSystem.layer))
 const fixture = Effect.gen(function* () {
  const fs = yield* FSUtil.Service
  const files = yield* FileSystem.FileSystem
@@ -2,8 +2,6 @@ import fs from "fs/promises"
 import path from "path"
 import { describe, expect } from "bun:test"
 import { Effect, Layer } from "effect"
-import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
-import { LayerNode } from "@opencode-ai/core/effect/layer-node"
 import { FSUtil } from "@opencode-ai/core/fs-util"
 import { PermissionV2 } from "@opencode-ai/core/permission"
 import { AbsolutePath } from "@opencode-ai/core/schema"
@@ -11,7 +9,6 @@ import { SessionV2 } from "@opencode-ai/core/session"
 import { SkillV2 } from "@opencode-ai/core/skill"
 import { SkillTool } from "@opencode-ai/core/tool/skill"
 import { ToolRegistry } from "@opencode-ai/core/tool/registry"
-import { ToolOutputStore } from "@opencode-ai/core/tool-output-store"
 import { tmpdir } from "./fixture/tmpdir"
 import { it } from "./lib/effect"
 import { toolIdentity, executeTool, settleTool, toolDefinitions } from "./lib/tool"
@@ -66,13 +63,11 @@ describe("SkillTool", () => {
              list: () => Effect.succeed(current),
            }),
          )
-          const registry = AppNodeBuilder.build(LayerNode.group([ToolRegistry.node, ToolRegistry.toolsNode]), [
-            [ToolOutputStore.node, ToolOutputStore.nodeWithoutConfig],
-          ])
+          const registry = ToolRegistry.defaultLayer.pipe(Layer.provide(permission))
          const tool = SkillTool.layer.pipe(
            Layer.provide(registry),
            Layer.provide(permission),
-            Layer.provide(LayerNode.compile(FSUtil.node)),
+            Layer.provide(FSUtil.defaultLayer),
            Layer.provide(skills),
          )
          const layer = Layer.mergeAll(permission, skills, registry, tool)
@@ -0,0 +1,283 @@
+import { describe, expect } from "bun:test"
+import { DateTime, Effect, Layer, Schema } from "effect"
+import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
+import { LayerNode } from "@opencode-ai/core/effect/layer-node"
+import { makeGlobalNode } from "@opencode-ai/core/effect/app-node"
+import { Database } from "@opencode-ai/core/database/database"
+import { EventV2 } from "@opencode-ai/core/event"
+import { Location } from "@opencode-ai/core/location"
+import { ModelV2 } from "@opencode-ai/core/model"
+import { ProviderV2 } from "@opencode-ai/core/provider"
+import { AbsolutePath } from "@opencode-ai/core/schema"
+import { AgentV2 } from "@opencode-ai/core/agent"
+import { BackgroundJob } from "@opencode-ai/core/background-job"
+import { LocationServiceMap } from "@opencode-ai/core/location-service-map"
+import { SessionV2 } from "@opencode-ai/core/session"
+import { SessionEvent } from "@opencode-ai/core/session/event"
+import { SessionExecution } from "@opencode-ai/core/session/execution"
+import { SessionMessage } from "@opencode-ai/core/session/message"
+import { SessionRunnerModel } from "@opencode-ai/core/session/runner/model"
+import { SessionStore } from "@opencode-ai/core/session/store"
+import { SubagentTool } from "@opencode-ai/core/tool/subagent"
+import { ToolRegistry } from "@opencode-ai/core/tool/registry"
+import { ToolOutputStore } from "@opencode-ai/core/tool-output-store"
+import { tmpdir } from "./fixture/tmpdir"
+import { testEffect } from "./lib/effect"
+import { executeTool, settleTool, toolIdentity } from "./lib/tool"
+
+const childText = "child final response"
+const childModel = ModelV2.Ref.make({ id: ModelV2.ID.make("child"), providerID: ProviderV2.ID.make("test") })
+const parentModel = ModelV2.Ref.make({ id: ModelV2.ID.make("parent"), providerID: ProviderV2.ID.make("test") })
+const tokens = { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } }
+
+const outputSessionID = (value: unknown) => Schema.decodeUnknownSync(SubagentTool.Output)(value).sessionID
+
+const executionNode = makeGlobalNode({
+  service: SessionExecution.Service,
+  layer: Layer.effect(
+    SessionExecution.Service,
+    Effect.gen(function* () {
+      const events = yield* EventV2.Service
+      const store = yield* SessionStore.Service
+      const completed = new Set<SessionV2.ID>()
+      const complete = Effect.fn("SubagentTest.complete")(function* (sessionID: SessionV2.ID) {
+        if (completed.has(sessionID)) return
+        if ((yield* store.get(sessionID))?.title.includes("fail")) {
+          yield* new SessionRunnerModel.ModelNotSelectedError({ sessionID })
+          return
+        }
+        completed.add(sessionID)
+        const assistantMessageID = SessionMessage.ID.create()
+        const textID = "text_subagent_test"
+        yield* events.publish(SessionEvent.Step.Started, {
+          sessionID,
+          assistantMessageID,
+          timestamp: yield* DateTime.now,
+          agent: AgentV2.ID.make("reviewer"),
+          model: childModel,
+        })
+        yield* events.publish(SessionEvent.Text.Started, {
+          sessionID,
+          assistantMessageID,
+          timestamp: yield* DateTime.now,
+          textID,
+        })
+        yield* events.publish(SessionEvent.Text.Ended, {
+          sessionID,
+          assistantMessageID,
+          timestamp: yield* DateTime.now,
+          textID,
+          text: childText,
+        })
+        yield* events.publish(SessionEvent.Step.Ended, {
+          sessionID,
+          assistantMessageID,
+          timestamp: yield* DateTime.now,
+          finish: "stop",
+          cost: 0,
+          tokens,
+        })
+      })
+      return SessionExecution.Service.of({
+        active: Effect.succeed(new Set()),
+        resume: complete,
+        wake: () => Effect.void,
+        interrupt: () => Effect.void,
+        awaitIdle: (sessionID) => complete(sessionID).pipe(Effect.exit, Effect.asVoid),
+      })
+    }),
+  ),
+  deps: [EventV2.node, SessionStore.node],
+})
+
+const layer = AppNodeBuilder.build(
+  LayerNode.bind(
+    LayerNode.group([
+      Database.node,
+      EventV2.node,
+      BackgroundJob.node,
+      ToolOutputStore.cleanupNode,
+      SessionV2.node,
+      SubagentTool.node,
+      LocationServiceMap.node,
+    ]),
+    SessionExecution.node,
+    executionNode,
+  ),
+)
+
+const it = testEffect(layer)
+
+const withSubagent = (location: Location.Ref) =>
+  Effect.gen(function* () {
+    const locations = yield* LocationServiceMap.Service
+    yield* AgentV2.Service.use((agents) =>
+      agents.transform((draft) => {
+        draft.update(AgentV2.ID.make("reviewer"), (agent) => {
+          agent.mode = "subagent"
+          agent.model = childModel
+        })
+        draft.update(AgentV2.ID.make("fallback"), (agent) => {
+          agent.mode = "subagent"
+        })
+        draft.update(AgentV2.ID.make("primary"), (agent) => {
+          agent.mode = "primary"
+        })
+      }),
+    ).pipe(Effect.provide(locations.get(location)))
+  })
+
+describe("SubagentTool", () => {
+  it.live("registers globally while resolving agents from the caller location", () =>
+    Effect.acquireRelease(
+      Effect.promise(() => tmpdir()),
+      (dir) => Effect.promise(() => dir[Symbol.asyncDispose]()),
+    ).pipe(
+      Effect.flatMap((dir) =>
+        Effect.gen(function* () {
+          const location = Location.Ref.make({ directory: AbsolutePath.make(dir.path) })
+          const session = yield* SessionV2.Service
+          const parent = yield* session.create({ location })
+          yield* withSubagent(parent.location)
+
+          const locations = yield* LocationServiceMap.Service
+          const registry = yield* ToolRegistry.Service.pipe(Effect.provide(locations.get(parent.location)))
+          expect((yield* registry.materialize()).definitions.map((tool) => tool.name)).toContain(SubagentTool.name)
+          expect(
+            yield* executeTool(registry, {
+              sessionID: parent.id,
+              ...toolIdentity,
+              call: {
+                type: "tool-call",
+                id: "call-primary",
+                name: SubagentTool.name,
+                input: { agent: "primary", description: "primary", prompt: "should fail" },
+              },
+            }),
+          ).toEqual({ type: "error", value: "Agent primary cannot run as a subagent" })
+        }),
+      ),
+    ),
+  )
+
+  it.live("runs a foreground child session and returns the final assistant text", () =>
+    Effect.acquireRelease(
+      Effect.promise(() => tmpdir()),
+      (dir) => Effect.promise(() => dir[Symbol.asyncDispose]()),
+    ).pipe(
+      Effect.flatMap((dir) =>
+        Effect.gen(function* () {
+          const location = Location.Ref.make({ directory: AbsolutePath.make(dir.path) })
+          const sessions = yield* SessionV2.Service
+          const parent = yield* sessions.create({ location, model: parentModel })
+          yield* withSubagent(parent.location)
+          const locations = yield* LocationServiceMap.Service
+          const registry = yield* ToolRegistry.Service.pipe(Effect.provide(locations.get(parent.location)))
+
+          const settled = yield* settleTool(registry, {
+            sessionID: parent.id,
+            ...toolIdentity,
+            call: {
+              type: "tool-call",
+              id: "call-subagent",
+              name: SubagentTool.name,
+              input: { agent: "reviewer", description: "review", prompt: "review this" },
+            },
+          })
+
+          expect(settled.output?.structured).toMatchObject({ status: "completed", output: childText })
+          const child = yield* sessions.get(outputSessionID(settled.output?.structured))
+          expect(child).toMatchObject({
+            parentID: parent.id,
+            location: parent.location,
+            agent: "reviewer",
+            model: childModel,
+          })
+
+          const fallback = yield* settleTool(registry, {
+            sessionID: parent.id,
+            ...toolIdentity,
+            call: {
+              type: "tool-call",
+              id: "call-subagent-fallback",
+              name: SubagentTool.name,
+              input: { agent: "fallback", description: "fallback", prompt: "fallback" },
+            },
+          })
+          const fallbackChild = yield* sessions.get(outputSessionID(fallback.output?.structured))
+          expect(fallbackChild).toMatchObject({ parentID: parent.id, model: parentModel })
+        }),
+      ),
+    ),
+  )
+
+  it.live("returns child runner failures as tool errors", () =>
+    Effect.acquireRelease(
+      Effect.promise(() => tmpdir()),
+      (dir) => Effect.promise(() => dir[Symbol.asyncDispose]()),
+    ).pipe(
+      Effect.flatMap((dir) =>
+        Effect.gen(function* () {
+          const location = Location.Ref.make({ directory: AbsolutePath.make(dir.path) })
+          const sessions = yield* SessionV2.Service
+          const parent = yield* sessions.create({ location })
+          yield* withSubagent(parent.location)
+          const locations = yield* LocationServiceMap.Service
+          const registry = yield* ToolRegistry.Service.pipe(Effect.provide(locations.get(parent.location)))
+
+          expect(
+            yield* executeTool(registry, {
+              sessionID: parent.id,
+              ...toolIdentity,
+              call: {
+                type: "tool-call",
+                id: "call-subagent-failure",
+                name: SubagentTool.name,
+                input: { agent: "reviewer", description: "fail review", prompt: "please fail" },
+              },
+            }),
+          ).toEqual({ type: "error", value: expect.stringContaining("No model is available for session") })
+        }),
+      ),
+    ),
+  )
+
+  it.live("promotes background work and injects one synthetic parent completion", () =>
+    Effect.acquireRelease(
+      Effect.promise(() => tmpdir()),
+      (dir) => Effect.promise(() => dir[Symbol.asyncDispose]()),
+    ).pipe(
+      Effect.flatMap((dir) =>
+        Effect.gen(function* () {
+          const location = Location.Ref.make({ directory: AbsolutePath.make(dir.path) })
+          const sessions = yield* SessionV2.Service
+          const jobs = yield* BackgroundJob.Service
+          const parent = yield* sessions.create({ location })
+          yield* withSubagent(parent.location)
+          const locations = yield* LocationServiceMap.Service
+          const registry = yield* ToolRegistry.Service.pipe(Effect.provide(locations.get(parent.location)))
+
+          const settled = yield* settleTool(registry, {
+            sessionID: parent.id,
+            ...toolIdentity,
+            call: {
+              type: "tool-call",
+              id: "call-background-subagent",
+              name: SubagentTool.name,
+              input: { agent: "reviewer", description: "background review", prompt: "review", background: true },
+            },
+          })
+          const childID = outputSessionID(settled.output?.structured)
+          expect(settled.output?.structured).toMatchObject({ status: "running" })
+
+          yield* jobs.promote(childID)
+          yield* Effect.yieldNow
+          const synthetic = (yield* sessions.context(parent.id)).filter((message) => message.type === "synthetic")
+          expect(synthetic).toHaveLength(1)
+          expect(synthetic[0]?.text).toContain(`<subagent id="${childID}" state="completed"`)
+          expect(synthetic[0]?.text).toContain(childText)
+        }),
+      ),
+    ),
+  )
+})
@@ -3,10 +3,9 @@ import { spawn } from "child_process"
 import fs from "fs/promises"
 import path from "path"
 import os from "os"
-import { Cause, Effect, Exit } from "effect"
+import { Cause, Effect, Exit, Layer } from "effect"
 import { testEffect } from "../lib/effect"
-import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
-import { LayerNode } from "@opencode-ai/core/effect/layer-node"
+import { FSUtil } from "@opencode-ai/core/fs-util"
 import { EffectFlock } from "@opencode-ai/core/util/effect-flock"
 import { Global } from "@opencode-ai/core/global"
 import { Hash } from "@opencode-ai/core/util/hash"
@@ -110,7 +109,7 @@ const testGlobal = Global.layerWith({
  log: os.tmpdir(),
 })

-const testLayer = AppNodeBuilder.build(EffectFlock.node, [[Global.node, testGlobal]])
+const testLayer = EffectFlock.layer.pipe(Layer.provide(testGlobal), Layer.provide(FSUtil.defaultLayer))

 // ---------------------------------------------------------------------------
 // Tests
@@ -1,131 +1,5 @@
-# opencode database guide
+# opencode package guidance

-## Database
+`packages/opencode` is the V1 version of this project.

- **Schema**: Drizzle schema lives in `packages/core/src/**/*.sql.ts`.
- **Migrations**: database migrations live in `packages/core` and are applied by core.
-
-## Development server
-
- Running `bun dev` from `packages/opencode` starts the live interactive TUI. Do not run it as a blocking foreground command when you need to inspect the result.
- Start it in `tmux` instead: `tmux new-session -d -s opencode-dev 'bun dev'`.
- Capture the current TUI output with: `tmux capture-pane -pt opencode-dev`.
- Stop the session explicitly when done: `tmux kill-session -t opencode-dev`.
-
-# Module shape
-
-Do not use `export namespace Foo { ... }` for module organization. It is not
-standard ESM, it prevents tree-shaking, and it breaks Node's native TypeScript
-runner. Use flat top-level exports combined with a self-reexport at the bottom
-of the file:
-
-```ts
-// src/foo/foo.ts
-export interface Interface { ... }
-export class Service extends Context.Service<Service, Interface>()("@opencode/Foo") {}
-export const layer = Layer.effect(Service, ...)
-export const defaultLayer = layer.pipe(...)
-
-export * as Foo from "./foo"
-```
-
-Consumers import the namespace projection:
-
-```ts
-import { Foo } from "@/foo/foo"
-
-yield * Foo.Service
-Foo.layer
-Foo.defaultLayer
-```
-
-Namespace-private helpers stay as non-exported top-level declarations in the
-same file — they remain inaccessible to consumers (they are not projected by
-`export * as`) but are usable by the file's own code.
-
-## When the file is an `index.ts`
-
-If the module is `foo/index.ts` (single-namespace directory), use `"."` for
-the self-reexport source rather than `"./index"`:
-
-```ts
-// src/foo/index.ts
-export const thing = ...
-
-export * as Foo from "."
-```
-
-## Multi-sibling directories
-
-For directories with several independent modules (e.g. `src/session/`,
-`src/config/`), keep each sibling as its own file with its own self-reexport,
-and do not add a barrel `index.ts`. Consumers import the specific sibling:
-
-```ts
-import { SessionRetry } from "@/session/retry"
-import { SessionStatus } from "@/session/status"
-```
-
-Barrels in multi-sibling directories force every import through the barrel to
-evaluate every sibling, which defeats tree-shaking and slows module load.
-
-# opencode Effect rules
-
-Use these rules when writing or migrating Effect code.
-
-See `specs/effect/migration.md` for the compact pattern reference and examples.
-
-## Core
-
- Use `Effect.gen(function* () { ... })` for composition.
- Use `Effect.fn("Domain.method")` for named/traced effects and `Effect.fnUntraced` for internal helpers.
- `Effect.fn` / `Effect.fnUntraced` accept pipeable operators as extra arguments, so avoid unnecessary outer `.pipe()` wrappers.
- Use `Effect.callback` for callback-based APIs.
- Use `Effect.void` instead of `Effect.succeed(undefined)` or `Effect.succeed(void 0)`.
- Prefer `DateTime.nowAsDate` over `new Date(yield* Clock.currentTimeMillis)` when you need a `Date`.
-
-## Module conventions
-
- In `src/config`, follow the existing self-export pattern at the top of the file (for example `export * as ConfigAgent from "./agent"`) when adding a new config module.
-
-## Schemas and errors
-
- Use `Schema.Class` for multi-field data.
- Use branded schemas (`Schema.brand`) for single-value types.
- Use `Schema.TaggedErrorClass` for typed errors.
- Use `Schema.Defect` instead of `unknown` for defect-like causes.
- In `Effect.gen` / `Effect.fn`, prefer `yield* new MyError(...)` over `yield* Effect.fail(new MyError(...))` for direct early-failure branches.
-
-## Runtime vs InstanceState
-
- Use `makeRuntime` (from `src/effect/run-service.ts`) for all services. It returns `{ runPromise, runFork, runCallback }` backed by a shared `memoMap` that deduplicates layers.
- Use `InstanceState` (from `src/effect/instance-state.ts`) for per-directory or per-project state that needs per-instance cleanup. It uses `ScopedCache` keyed by directory — each open project gets its own state, automatically cleaned up on disposal.
- If two open directories should not share one copy of the service, it needs `InstanceState`.
- Do the work directly in the `InstanceState.make` closure — `ScopedCache` handles run-once semantics. Don't add fibers, `ensure()` callbacks, or `started` flags on top.
- Use `Effect.addFinalizer` or `Effect.acquireRelease` inside the `InstanceState.make` closure for cleanup (subscriptions, process teardown, etc.).
- Use `Effect.forkScoped` inside the closure for background stream consumers — the fiber is interrupted when the instance is disposed.
- To make a service's `init()` non-blocking, fork `InstanceState.get(state)` at the `init()` call site (e.g. `Effect.forkIn(scope)`), not by forking work inside the `InstanceState.make` closure. Forking inside the closure leaves state incomplete for other methods that read it.
- `src/project/bootstrap.ts` already wraps every service `init()` in `Effect.forkDetach`, so `init()` is fire-and-forget in production. Keep `init()` methods synchronous internally; the caller controls concurrency.
-
-## Effect v4 beta API
-
- `Effect.fork` and `Effect.forkDaemon` do not exist. Use `Effect.forkIn(scope)` to fork a fiber into a specific scope.
-
-## Preferred Effect services
-
- In effectified services, prefer yielding existing Effect services over dropping down to ad hoc platform APIs.
- Prefer `FileSystem.FileSystem` instead of raw `fs/promises` for effectful file I/O.
- Prefer `ChildProcessSpawner.ChildProcessSpawner` with `ChildProcess.make(...)` instead of custom process wrappers.
- Prefer `HttpClient.HttpClient` instead of raw `fetch`.
- Prefer `Path.Path`, `Config`, `Clock`, and `DateTime` when those concerns are already inside Effect code.
- For background loops or scheduled tasks, use `Effect.repeat` or `Effect.schedule` with `Effect.forkScoped` in the layer definition.
-
-## Effect.cached for deduplication
-
-Use `Effect.cached` when multiple concurrent callers should share a single in-flight computation rather than storing `Fiber | undefined` or `Promise | undefined` manually. See `specs/effect/migration.md` for the full pattern.
-
-## Callback boundaries
-
-Use `EffectBridge` for native or external callbacks (`@parcel/watcher`, `node-pty`, native `fs.watch`, plugin callbacks, etc.) that need to re-enter Effect services with instance/workspace context.
-
-Plain async code should pass explicit context or stay inside an Effect fiber; do not add ambient instance context shims.
+We are moving to V2, which is split across the `core`, `tui`, and `cli` packages. It is okay to read code in this package to understand how V1 worked, but do not make changes here unless explicitly instructed.
@@ -3,6 +3,7 @@ import { UI } from "@/cli/ui"
 import { errorMessage } from "@opencode-ai/tui/util/error"
 import { validateSession } from "../tui/validate-session"
 import { ServerAuth } from "@/server/auth"
+import { createOpencodeClient } from "@opencode-ai/sdk/v2"

 export const AttachCommand = cmd({
  command: "attach <url>",
@@ -132,7 +133,7 @@ export const AttachCommand = cmd({
    const { createLegacyTuiPluginHost } = await import("@/plugin/tui/runtime")
    await Effect.runPromise(
      run({
-        url: args.url,
+        client: createOpencodeClient({ baseUrl: args.url, headers, directory }),
        config,
        pluginHost: createLegacyTuiPluginHost(),
        args: {
@@ -140,8 +141,6 @@ export const AttachCommand = cmd({
          sessionID: args.session,
          fork: args.fork,
        },
-        directory,
-        headers,
      }),
    )
  },
@@ -761,7 +761,7 @@ export const McpDebugCommand = effectCmd({
        }

        if (response.status === 401) {
-          prompts.log.info("Initial unauthenticated check returned 401, so this server requires OAuth")
+          prompts.log.warn("Server returned 401 Unauthorized")

          // Try to discover OAuth metadata
          const oauthConfig = typeof serverConfig.oauth === "object" ? serverConfig.oauth : undefined
@@ -338,7 +338,6 @@ export function turnSummaryWriter(input: { agent: string; model: string; duratio
    () => (
      <box width="100%" height={1}>
        <text wrapMode="none" truncate>
-          <span style={{ fg: input.theme.block.highlight }}>▣ </span>
          <span style={{ fg: input.theme.block.text }}>{input.agent}</span>
          <span style={{ fg: input.theme.block.muted }}>
            {" "}
@@ -10,7 +10,7 @@ export function turnSummaryCommit(input: {
 }): StreamCommit {
  return {
    kind: "system",
-    text: `▣ ${input.agent} · ${input.model} · ${input.duration}`,
+    text: `${input.agent} · ${input.model} · ${input.duration}`,
    phase: "final",
    source: "system",
    summary: {
@@ -6,12 +6,10 @@ import { fileURLToPath } from "url"
 import { UI } from "@/cli/ui"
 import { errorMessage } from "@opencode-ai/tui/util/error"
 import { withTimeout } from "@/util/timeout"
-import { withNetworkOptions, resolveNetworkOptionsNoConfig, hasArg } from "@/cli/network"
+import { withNetworkOptions, resolveNetworkOptionsNoConfig } from "@/cli/network"
 import { Filesystem } from "@/util/filesystem"
-import type { GlobalEvent } from "@opencode-ai/sdk/v2"
-import type { EventSource } from "@opencode-ai/tui/context/sdk"
+import { createOpencodeClient } from "@opencode-ai/sdk/v2"
 import { writeHeapSnapshot } from "v8"
-import { ServerAuth } from "@/server/auth"
 import { validateSession } from "../tui/validate-session"
 import { win32InstallCtrlCGuard } from "@opencode-ai/tui/terminal-win32"

@@ -19,36 +17,6 @@ declare global {
  const OPENCODE_WORKER_PATH: string
 }

-type RpcClient = ReturnType<typeof Rpc.client<typeof rpc>>
-
-function createWorkerFetch(client: RpcClient): typeof fetch {
-  const fn = async (input: RequestInfo | URL, init?: RequestInit): Promise<Response> => {
-    const request = new Request(input, init)
-    const body = request.body ? await request.text() : undefined
-    const result = await client.call("fetch", {
-      url: request.url,
-      method: request.method,
-      headers: Object.fromEntries(request.headers.entries()),
-      body,
-    })
-    return new Response(result.body, {
-      status: result.status,
-      headers: result.headers,
-    })
-  }
-  return fn as typeof fetch
-}
-
-function createEventSource(client: RpcClient): EventSource {
-  return {
-    subscribe: async (handler) => {
-      return client.on<GlobalEvent>("global.event", (e) => {
-        handler(e)
-      })
-    },
-  }
-}
-
 async function target() {
  if (typeof OPENCODE_WORKER_PATH !== "undefined") return OPENCODE_WORKER_PATH
  const dist = new URL("./cli/tui/worker.js", import.meta.url)
@@ -212,30 +180,13 @@ export const TuiThreadCommand = cmd({
      const config = await TuiConfig.get()

      const network = resolveNetworkOptionsNoConfig(args)
-      const external = hasArg("--port") || hasArg("--hostname") || network.mdns === true
-
-      const headers = external ? ServerAuth.headers() : undefined
-
-      const transport = external
-        ? {
-            url: (await client.call("server", network)).url,
-            fetch: undefined,
-            events: undefined,
-            headers,
-          }
-        : {
-            url: "http://opencode.internal",
-            fetch: createWorkerFetch(client),
-            events: createEventSource(client),
-          }
+      const url = (await client.call("server", network)).url

      try {
        await validateSession({
-          url: transport.url,
+          url,
          sessionID: args.session,
          directory: cwd,
-          fetch: transport.fetch,
-          headers,
        })
      } catch (error) {
        UI.error(errorMessage(error))
@@ -253,7 +204,7 @@ export const TuiThreadCommand = cmd({
        const { createLegacyTuiPluginHost } = await import("@/plugin/tui/runtime")
        await Effect.runPromise(
          run({
-            url: transport.url,
+            client: createOpencodeClient({ baseUrl: url, directory: cwd }),
            async onSnapshot() {
              const tui = writeHeapSnapshot("tui.heapsnapshot")
              const server = await client.call("snapshot", undefined)
@@ -261,10 +212,6 @@ export const TuiThreadCommand = cmd({
            },
            config,
            pluginHost: createLegacyTuiPluginHost(),
-            directory: cwd,
-            fetch: transport.fetch,
-            headers: transport.headers,
-            events: transport.events,
            args: {
              continue: args.continue,
              sessionID: args.session,
@@ -37,22 +37,6 @@ export type NetworkOptions = InferredOptionTypes<typeof options>
 export function withNetworkOptions<T>(yargs: Argv<T>) {
  return yargs.options(options)
 }
-
-export function hasArg(name: string) {
-  return networkArgs().some((arg) => arg === name || arg.startsWith(name + "="))
-}
-
-function hasBooleanArg(name: string) {
-  return networkArgs().some(
-    (arg) => arg === name || arg === name + "=true" || arg === name + "=false" || arg === "--no-" + name.slice(2),
-  )
-}
-
-function networkArgs() {
-  const separator = process.argv.indexOf("--")
-  return process.argv.slice(2, separator === -1 ? undefined : separator)
-}
-
 export const resolveNetworkOptions = Effect.fn("Cli.resolveNetworkOptions")(function* (args: NetworkOptions) {
  const { Config } = yield* Effect.promise(() => import("@/config/config"))
  const config = yield* Config.Service.use((cfg) => cfg.getGlobal())
@@ -60,10 +44,10 @@ export const resolveNetworkOptions = Effect.fn("Cli.resolveNetworkOptions")(func
 })

 export function resolveNetworkOptionsNoConfig(args: NetworkOptions, config?: ConfigV1.Info) {
-  const portExplicitlySet = hasArg("--port")
-  const hostnameExplicitlySet = hasArg("--hostname")
-  const mdnsExplicitlySet = hasBooleanArg("--mdns")
-  const mdnsDomainExplicitlySet = hasArg("--mdns-domain")
+  const portExplicitlySet = process.argv.includes("--port")
+  const hostnameExplicitlySet = process.argv.includes("--hostname")
+  const mdnsExplicitlySet = process.argv.includes("--mdns")
+  const mdnsDomainExplicitlySet = process.argv.includes("--mdns-domain")
  const mdns = mdnsExplicitlySet ? args.mdns : (config?.server?.mdns ?? args.mdns)
  const mdnsDomain = mdnsDomainExplicitlySet ? args["mdns-domain"] : (config?.server?.mdnsDomain ?? args["mdns-domain"])
  const port = portExplicitlySet ? args.port : (config?.server?.port ?? args.port)
@@ -3,8 +3,6 @@ import { InstanceRuntime } from "@/project/instance-runtime"
 import { Rpc } from "@/util/rpc"
 import { upgrade } from "@/cli/upgrade"
 import { Config } from "@/config/config"
-import { GlobalBus } from "@/bus/global"
-import { ServerAuth } from "@/server/auth"
 import { writeHeapSnapshot } from "node:v8"
 import { Heap } from "@/cli/heap"
 import { AppRuntime } from "@/effect/app-runtime"
@@ -20,33 +18,9 @@ const onUncaughtException = (_error: Error) => {}
 process.on("unhandledRejection", onUnhandledRejection)
 process.on("uncaughtException", onUncaughtException)

-// Subscribe to global events and forward them via RPC
-GlobalBus.on("event", (event) => {
-  Rpc.emit("global.event", event)
-})
-
 let server: Awaited<ReturnType<typeof Server.listen>> | undefined

 export const rpc = {
-  async fetch(input: { url: string; method: string; headers: Record<string, string>; body?: string }) {
-    const headers = { ...input.headers }
-    const auth = ServerAuth.header()
-    if (auth && !headers["authorization"] && !headers["Authorization"]) {
-      headers["Authorization"] = auth
-    }
-    const request = new Request(input.url, {
-      method: input.method,
-      headers,
-      body: input.body,
-    })
-    const response = await Server.Default().app.fetch(request)
-    const body = await response.text()
-    return {
-      status: response.status,
-      headers: Object.fromEntries(response.headers.entries()),
-      body,
-    }
-  },
  snapshot() {
    const result = writeHeapSnapshot("server.heapsnapshot")
    return result
@@ -51,7 +51,6 @@ export class Service extends ConfigService.Service<Service>()("@opencode/Runtime
  outputTokenMax: positiveInteger("OPENCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX"),
  bashDefaultTimeoutMs: positiveInteger("OPENCODE_EXPERIMENTAL_BASH_DEFAULT_TIMEOUT_MS"),
  experimentalNativeLlm: bool("OPENCODE_EXPERIMENTAL_NATIVE_LLM"),
-  experimentalToolSearch: enabledByExperimental("OPENCODE_EXPERIMENTAL_TOOL_SEARCH"),
  experimentalWebSockets: bool("OPENCODE_EXPERIMENTAL_WEBSOCKETS"),
  client: Config.string("OPENCODE_CLIENT").pipe(Config.withDefault("cli")),
 }) {}
@@ -946,7 +946,7 @@ export const layer = Layer.effect(

      const mcpConfig = yield* requireMcpConfig(mcpName)

-      return yield* createAndStore(mcpName, { ...mcpConfig, enabled: true })
+      return yield* createAndStore(mcpName, mcpConfig)
    })

    const removeAuth = Effect.fn("MCP.removeAuth")(function* (mcpName: string) {
@@ -1,10 +1,7 @@
 import { createBuiltinPlugins, type BuiltinTuiPlugin } from "@opencode-ai/tui/builtins"
-import type { RuntimeFlags } from "@/effect/runtime-flags"

 export type InternalTuiPlugin = BuiltinTuiPlugin

-export function internalTuiPlugins(flags: Pick<RuntimeFlags.Info, "experimentalEventSystem">): InternalTuiPlugin[] {
-  return createBuiltinPlugins({
-    experimentalEventSystem: flags.experimentalEventSystem,
-  })
+export function internalTuiPlugins(): InternalTuiPlugin[] {
+  return createBuiltinPlugins()
 }
@@ -1089,7 +1089,7 @@ async function load(input: {
    if (Flag.OPENCODE_PURE && pluginOrigins.length) {
    }

-    for (const item of internalTuiPlugins(flags)) {
+    for (const item of internalTuiPlugins()) {
      const entry = loadInternalPlugin(item)
      const meta = createMeta(entry.source, entry.spec, entry.target, undefined, entry.id)
      addPluginEntry(next, {
@@ -1,787 +0,0 @@
-import { Agent } from "@/agent/agent"
-import { EffectBridge } from "@/effect/bridge"
-import { RuntimeFlags } from "@/effect/runtime-flags"
-import { MCP } from "@/mcp"
-import { McpCatalog } from "@/mcp/catalog"
-import { Permission } from "@/permission"
-import { Provider } from "@/provider/provider"
-import { ProviderTransform } from "@/provider/transform"
-import { ToolJsonSchema } from "@/tool/json-schema"
-import { Truncate } from "@/tool/truncate"
-import { isRecord } from "@/util/record"
-import { Token } from "@/util/token"
-import { SessionV1 } from "@opencode-ai/core/v1/session"
-import { asSchema, jsonSchema, tool, type Tool, type ToolExecutionOptions } from "ai"
-import { Effect, Schema } from "effect"
-import { Plugin } from "@/plugin"
-import type { TaskPromptOps } from "@/tool/task"
-import type { Context } from "@/tool/tool"
-import { Session } from "./session"
-import { SessionProcessor } from "./processor"
-import { PartID } from "./schema"
-
-const DEFERRED_TOOL_TOOLS = {
-  search: "search_deferred_tools",
-  call: "call_deferred_tool",
-} as const
-const MIN_DEFERRED_MCP_SCHEMA_TOKENS = 8_000
-const DEFAULT_DEFERRED_TOOL_LIMIT = 10
-const MAX_DEFERRED_TOOL_LIMIT = 20
-const MAX_MCP_RESOURCE_BLOB_BYTES = 10 * 1024 * 1024
-const SUPPORTED_MCP_RESOURCE_ATTACHMENT_MIMES = new Set([
-  "application/pdf",
-  "image/gif",
-  "image/jpeg",
-  "image/png",
-  "image/webp",
-])
-
-export const DEFERRED_TOOL_SYSTEM_PROMPT = `Deferred tools are separate from direct tools.
- Some MCP server tools may be hidden behind \`search_deferred_tools\` and \`call_deferred_tool\` to keep provider tool schemas small.
- Use \`search_deferred_tools\` to find deferred tools by purpose, tool ID, description, or parameter names.
- \`search_deferred_tools\` returns full schemas by default. For broad searches, omit schemas and search again with schemas if needed.
- Use \`call_deferred_tool\` only with a \`tool_id\` copied from \`search_deferred_tools\` results.
- Never use deferred tools for direct tools already listed in the current tool list, including shell, file, search, edit, web, task, LSP, question, or apply_patch tools.`
-
-interface Input extends DeferredInput {
-  model: Provider.Model
-  processor: Pick<SessionProcessor.Handle, "message" | "updateToolCall" | "completeToolCall">
-  bypassAgentCheck: boolean
-  promptOps: TaskPromptOps
-}
-
-interface DeferredInput {
-  agent: Agent.Info
-  session: Session.Info
-  messages: SessionV1.WithParts[]
-}
-
-interface DeferredToolDescriptor {
-  id: string
-  description: string
-  inputSchema: unknown
-  searchText: string
-}
-
-const SearchDeferredToolsParameters = Schema.Struct({
-  query: Schema.String.annotate({
-    description:
-      "Words describing the external capability to find. Use an empty string to list the top deferred tools.",
-  }),
-  limit: Schema.optional(
-    Schema.Int.check(Schema.isGreaterThan(0), Schema.isLessThanOrEqualTo(MAX_DEFERRED_TOOL_LIMIT)),
-  ).annotate({
-    description: `Maximum number of matches to return. Defaults to ${DEFAULT_DEFERRED_TOOL_LIMIT}; maximum ${MAX_DEFERRED_TOOL_LIMIT}.`,
-  }),
-  include_schema: Schema.optional(Schema.Boolean).annotate({
-    description:
-      "Whether to include input_schema for each match. Defaults to true. Set false for broad searches to return only tool_id and description.",
-  }),
-})
-
-const CallDeferredToolParameters = Schema.Struct({
-  tool_id: Schema.String.annotate({
-    description: "Exact deferred tool_id copied from search_deferred_tools results.",
-  }),
-  arguments: Schema.Record(Schema.String, Schema.Unknown).annotate({
-    description: "JSON arguments for the deferred tool, matching its input_schema from search_deferred_tools.",
-  }),
-})
-const decodeSearchDeferredToolsParameters = Schema.decodeUnknownEffect(SearchDeferredToolsParameters)
-const decodeCallDeferredToolParameters = Schema.decodeUnknownEffect(CallDeferredToolParameters)
-
-type McpToolContent =
-  | { type: "text"; text: string }
-  | { type: "image"; mimeType: string; data: string }
-  | { type: "resource"; resource: Record<string, unknown> }
-
-export const resolve = Effect.fn("SessionMcpTools.resolve")(function* (input: Input) {
-  const tools: Record<string, Tool> = {}
-  const run = yield* EffectBridge.make()
-  const plugin = yield* Plugin.Service
-  const permission = yield* Permission.Service
-  const mcp = yield* MCP.Service
-  const truncate = yield* Truncate.Service
-
-  const context = (args: Record<string, unknown>, options: ToolExecutionOptions): Context => ({
-    sessionID: input.session.id,
-    abort: options.abortSignal!,
-    messageID: input.processor.message.id,
-    callID: options.toolCallId,
-    extra: { model: input.model, bypassAgentCheck: input.bypassAgentCheck, promptOps: input.promptOps },
-    agent: input.agent.name,
-    messages: input.messages,
-    metadata: (val) =>
-      input.processor.updateToolCall(options.toolCallId, (match) => {
-        if (!["running", "pending"].includes(match.state.status)) return match
-        return {
-          ...match,
-          state: {
-            title: val.title,
-            metadata: val.metadata,
-            status: "running",
-            input: args,
-            time: { start: Date.now() },
-          },
-        }
-      }),
-    ask: (req) =>
-      permission
-        .ask({
-          ...req,
-          sessionID: input.session.id,
-          tool: { messageID: input.processor.message.id, callID: options.toolCallId },
-          ruleset: Permission.merge(input.agent.permission, input.session.permission ?? []),
-        })
-        .pipe(Effect.orDie),
-  })
-
-  const executeMcpTool = Effect.fnUntraced(function* (
-    key: string,
-    execute: NonNullable<Tool["execute"]>,
-    args: unknown,
-    opts: ToolExecutionOptions,
-  ) {
-    const ctx = context(toRecord(args), opts)
-    yield* plugin.trigger(
-      "tool.execute.before",
-      { tool: key, sessionID: ctx.sessionID, callID: opts.toolCallId },
-      { args },
-    )
-    const rawResult = yield* Effect.gen(function* () {
-      yield* ctx.ask({ permission: key, metadata: {}, patterns: ["*"], always: ["*"] })
-      return yield* Effect.promise(() => Promise.resolve(execute(args, opts)))
-    }).pipe(
-      Effect.withSpan("Tool.execute", {
-        attributes: {
-          "tool.name": key,
-          "tool.call_id": opts.toolCallId,
-          "session.id": ctx.sessionID,
-          "message.id": input.processor.message.id,
-        },
-      }),
-    )
-    yield* plugin.trigger(
-      "tool.execute.after",
-      { tool: key, sessionID: ctx.sessionID, callID: opts.toolCallId, args },
-      rawResult,
-    )
-
-    const content = mcpToolContent(rawResult)
-    const textParts: string[] = []
-    const attachments: Omit<SessionV1.FilePart, "id" | "sessionID" | "messageID">[] = []
-    for (const contentItem of content) {
-      if (contentItem.type === "text") textParts.push(contentItem.text)
-      else if (contentItem.type === "image") {
-        attachments.push({
-          type: "file",
-          mime: contentItem.mimeType,
-          url: `data:${contentItem.mimeType};base64,${contentItem.data}`,
-        })
-      } else if (contentItem.type === "resource") {
-        const resource = contentItem.resource
-        if (typeof resource.text === "string") textParts.push(resource.text)
-        if (typeof resource.blob === "string") {
-          const uri = typeof resource.uri === "string" ? resource.uri : "resource"
-          const mime = typeof resource.mimeType === "string" ? resource.mimeType : "application/octet-stream"
-          const size = base64Size(resource.blob)
-          if (!SUPPORTED_MCP_RESOURCE_ATTACHMENT_MIMES.has(mime)) {
-            textParts.push(
-              `[Binary MCP resource omitted: ${uri} (${mime}, ${formatBytes(size)}) is not a supported attachment type]`,
-            )
-            continue
-          }
-          if (size > MAX_MCP_RESOURCE_BLOB_BYTES) {
-            textParts.push(
-              `[Binary MCP resource omitted: ${uri} (${mime}, ${formatBytes(size)}) exceeds ${formatBytes(MAX_MCP_RESOURCE_BLOB_BYTES)}]`,
-            )
-            continue
-          }
-          attachments.push({
-            type: "file",
-            mime,
-            url: `data:${mime};base64,${resource.blob}`,
-            filename: uri,
-          })
-        }
-      }
-    }
-
-    const truncated = yield* truncate.output(textParts.join("\n\n"), {}, input.agent)
-    const output = {
-      title: "",
-      metadata: {
-        ...(isRecord(rawResult) && isRecord(rawResult.metadata) ? rawResult.metadata : {}),
-        truncated: truncated.truncated,
-        ...(truncated.truncated && { outputPath: truncated.outputPath }),
-      },
-      output: truncated.content,
-      attachments: attachments.map((attachment) => ({
-        ...attachment,
-        id: PartID.ascending(),
-        sessionID: ctx.sessionID,
-        messageID: input.processor.message.id,
-      })),
-      content,
-    }
-    if (opts.abortSignal?.aborted) {
-      yield* input.processor.completeToolCall(opts.toolCallId, output)
-    }
-    return output
-  })
-
-  const clients = yield* mcp.clients()
-  const hasMcpResourceServer = Object.values(clients).some((client) => !!client.getServerCapabilities()?.resources)
-  if (hasMcpResourceServer) addResourceTools(tools, { input, run, mcp, plugin, truncate, context })
-
-  const mcpTools = yield* mcp.tools()
-  const deferred = yield* deferredState(input, mcpTools)
-
-  if (deferred) {
-    addDeferredTools(tools, {
-      input,
-      run,
-      plugin,
-      truncate,
-      context,
-      deferredDescriptors: deferred.descriptors,
-      allowedMcpTools: deferred.allowedMcpTools,
-      executeMcpTool,
-    })
-    return tools
-  }
-
-  for (const [key, item] of Object.entries(mcpTools)) {
-    const execute = item.execute
-    if (!execute) continue
-
-    const schema = yield* Effect.promise(() => Promise.resolve(asSchema(item.inputSchema).jsonSchema))
-    const transformed = ProviderTransform.schema(input.model, { ...schema, properties: schema.properties ?? {} })
-    item.inputSchema = jsonSchema(transformed)
-    item.execute = (args, opts) => run.promise(executeMcpTool(key, execute, args, opts))
-    tools[key] = item
-  }
-
-  return tools
-})
-
-export const systemPrompt = Effect.fn("SessionMcpTools.systemPrompt")(function* (input: DeferredInput) {
-  const mcp = yield* MCP.Service
-  const deferred = yield* deferredState(input, yield* mcp.tools())
-  if (!deferred) return undefined
-  return deferredSystemPrompt(deferred.allowedMcpTools, yield* mcp.clients())
-})
-
-function deferredState(input: DeferredInput, mcpTools: Record<string, Tool>) {
-  return Effect.gen(function* () {
-    const flags = yield* RuntimeFlags.Service
-    if (!flags.experimentalToolSearch) return undefined
-
-    const mcpDisabled = Permission.disabled(
-      Object.keys(mcpTools),
-      Permission.merge(input.agent.permission, input.session.permission ?? []),
-    )
-    const userTools = currentUserToolOverrides(input.messages)
-    const allowedMcpTools = Object.fromEntries(
-      Object.entries(mcpTools).filter(([key]) => userTools?.[key] !== false && !mcpDisabled.has(key)),
-    )
-    if (Object.keys(allowedMcpTools).length === 0) return undefined
-
-    const descriptors = yield* deferredToolDescriptors(allowedMcpTools)
-    if (deferredToolSchemaTokens(descriptors) < MIN_DEFERRED_MCP_SCHEMA_TOKENS) return undefined
-    return { allowedMcpTools, descriptors }
-  })
-}
-
-function deferredSystemPrompt(allowedMcpTools: Record<string, Tool>, clients: Record<string, unknown>) {
-  const servers = deferredServerSummaries(Object.keys(allowedMcpTools), Object.keys(clients))
-  return [
-    DEFERRED_TOOL_SYSTEM_PROMPT,
-    servers.length === 0
-      ? undefined
-      : [
-          "Deferred MCP servers available through `search_deferred_tools`:",
-          ...servers.map((server) => `- ${server.name}: ${server.count} tool${server.count === 1 ? "" : "s"}`),
-        ].join("\n"),
-  ]
-    .filter((part): part is string => part !== undefined)
-    .join("\n\n")
-}
-
-function addResourceTools(
-  tools: Record<string, Tool>,
-  deps: {
-    input: Input
-    run: EffectBridge.Shape
-    mcp: MCP.Interface
-    plugin: Plugin.Interface
-    truncate: Truncate.Interface
-    context: (args: Record<string, unknown>, options: ToolExecutionOptions) => Context
-  },
-) {
-  const addListTool = (spec: {
-    id: string
-    description: string
-    serverDescription: string
-    title: string
-    resultKey: "resources" | "resourceTemplates"
-    sortKey: "uri" | "uriTemplate"
-    list: (server?: string) => Effect.Effect<Record<string, Record<string, unknown> & { client: string; name: string }>>
-  }) => {
-    tools[spec.id] = tool({
-      description: spec.description,
-      inputSchema: jsonSchema(
-        ProviderTransform.schema(deps.input.model, {
-          type: "object",
-          properties: { server: { type: "string", description: spec.serverDescription } },
-          additionalProperties: false,
-        }),
-      ),
-      execute(args, opts) {
-        return deps.run.promise(
-          Effect.gen(function* () {
-            const server = optionalString(toRecord(args), "server")
-            const ctx = deps.context(toRecord(args), opts)
-            const resourceServers = Object.entries(yield* deps.mcp.clients())
-              .filter((entry) => !!entry[1].getServerCapabilities()?.resources)
-              .map((entry) => entry[0])
-              .sort((a, b) => a.localeCompare(b))
-            if (server && !resourceServers.includes(server)) {
-              throw new Error(
-                resourceServers.length === 0
-                  ? `MCP server "${server}" does not support resources`
-                  : `MCP server "${server}" does not support resources. Available resource servers: ${resourceServers.join(", ")}`,
-              )
-            }
-            const permissionPatterns = server ? [`mcp:${server}:*`] : resourceServers.map((item) => `mcp:${item}:*`)
-            yield* deps.plugin.trigger(
-              "tool.execute.before",
-              { tool: spec.id, sessionID: ctx.sessionID, callID: opts.toolCallId },
-              { args },
-            )
-            yield* ctx.ask({
-              permission: "read",
-              metadata: server ? { server } : {},
-              patterns: permissionPatterns,
-              always: permissionPatterns,
-            })
-
-            const filtered = Object.values(yield* spec.list(server))
-              .filter((item) => !server || item.client === server)
-              .toSorted((a, b) =>
-                (a.client + "\u0000" + a.name + "\u0000" + String(a[spec.sortKey] ?? "")).localeCompare(
-                  b.client + "\u0000" + b.name + "\u0000" + String(b[spec.sortKey] ?? ""),
-                ),
-              )
-            const truncated = yield* deps.truncate.output(
-              JSON.stringify(
-                {
-                  [spec.resultKey]: filtered.map((item) => {
-                    const result = Object.fromEntries(Object.entries(item).filter((entry) => entry[0] !== "client"))
-                    return { ...result, server: item.client }
-                  }),
-                },
-                null,
-                2,
-              ),
-              {},
-              deps.input.agent,
-            )
-            const output = {
-              title: server ? `${spec.title}: ${server}` : spec.title,
-              metadata: {
-                count: filtered.length,
-                servers: resourceServers,
-                ...(server ? { server } : {}),
-                truncated: truncated.truncated,
-                ...(truncated.truncated && { outputPath: truncated.outputPath }),
-              },
-              output: truncated.content,
-            }
-            yield* deps.plugin.trigger(
-              "tool.execute.after",
-              { tool: spec.id, sessionID: ctx.sessionID, callID: opts.toolCallId, args },
-              output,
-            )
-            if (opts.abortSignal?.aborted) yield* deps.input.processor.completeToolCall(opts.toolCallId, output)
-            return output
-          }),
-        )
-      },
-    })
-  }
-
-  addListTool({
-    id: "list_mcp_resources",
-    description:
-      "Lists resources provided by connected MCP servers. Resources provide context such as files, database schemas, or application-specific information.",
-    serverDescription: "Optional MCP server name. When omitted, lists resources from every connected server.",
-    title: "MCP resources",
-    resultKey: "resources",
-    sortKey: "uri",
-    list: deps.mcp.resources,
-  })
-  addListTool({
-    id: "list_mcp_resource_templates",
-    description:
-      "Lists resource templates provided by connected MCP servers. Resource templates are parameterized resources that can be read after filling in their URI template.",
-    serverDescription: "Optional MCP server name. When omitted, lists resource templates from every connected server.",
-    title: "MCP resource templates",
-    resultKey: "resourceTemplates",
-    sortKey: "uriTemplate",
-    list: deps.mcp.resourceTemplates,
-  })
-
-  tools.read_mcp_resource = tool({
-    description:
-      "Read a specific resource from an MCP server using the server name and resource URI. The URI is an MCP identifier and does not need to be a file URL.",
-    inputSchema: jsonSchema(
-      ProviderTransform.schema(deps.input.model, {
-        type: "object",
-        properties: {
-          server: {
-            type: "string",
-            description: "MCP server name exactly as returned by list_mcp_resources.",
-          },
-          uri: {
-            type: "string",
-            description: "Resource URI to read. Use the exact URI string returned by list_mcp_resources.",
-          },
-        },
-        required: ["server", "uri"],
-        additionalProperties: false,
-      }),
-    ),
-    execute(args, opts) {
-      return deps.run.promise(
-        Effect.gen(function* () {
-          const argRecord = toRecord(args)
-          const server = requiredString(argRecord, "server")
-          const uri = requiredString(argRecord, "uri")
-          const ctx = deps.context(argRecord, opts)
-          const client = (yield* deps.mcp.clients())[server]
-          if (!client) throw new Error(`MCP server "${server}" is not connected`)
-          if (!client.getServerCapabilities()?.resources)
-            throw new Error(`MCP server "${server}" does not support resources`)
-          yield* deps.plugin.trigger(
-            "tool.execute.before",
-            { tool: "read_mcp_resource", sessionID: ctx.sessionID, callID: opts.toolCallId },
-            { args },
-          )
-          yield* ctx.ask({
-            permission: "read",
-            metadata: { server, uri },
-            patterns: [`mcp:${server}:${uri}`],
-            always: [`mcp:${server}:*`],
-          })
-
-          const content = yield* deps.mcp.readResource(server, uri)
-          if (!content) throw new Error(`Failed to read MCP resource: ${server}/${uri}`)
-
-          const items = (Array.isArray(content.contents) ? content.contents : [content.contents]).filter(isRecord)
-          const textParts: string[] = []
-          const attachments: Omit<SessionV1.FilePart, "id" | "sessionID" | "messageID">[] = []
-          for (const item of items) {
-            const itemUri = typeof item.uri === "string" ? item.uri : uri
-            const mime = typeof item.mimeType === "string" ? item.mimeType : "application/octet-stream"
-            if ("text" in item && typeof item.text === "string") {
-              textParts.push(`Resource: ${itemUri}\nMIME: ${mime}\n${item.text}`)
-              continue
-            }
-            if (!("blob" in item) || typeof item.blob !== "string") {
-              textParts.push(`[MCP resource content without text or blob: ${itemUri}]`)
-              continue
-            }
-            const size = base64Size(item.blob)
-            if (!SUPPORTED_MCP_RESOURCE_ATTACHMENT_MIMES.has(mime)) {
-              textParts.push(
-                `[Binary MCP resource omitted: ${itemUri} (${mime}, ${formatBytes(size)}) is not a supported attachment type]`,
-              )
-              continue
-            }
-            if (size > MAX_MCP_RESOURCE_BLOB_BYTES) {
-              textParts.push(
-                `[Binary MCP resource omitted: ${itemUri} (${mime}, ${formatBytes(size)}) exceeds ${formatBytes(MAX_MCP_RESOURCE_BLOB_BYTES)}]`,
-              )
-              continue
-            }
-            textParts.push(`[Binary MCP resource attached: ${itemUri} (${mime})]`)
-            attachments.push({
-              type: "file",
-              mime,
-              url: `data:${mime};base64,${item.blob}`,
-              filename: itemUri,
-            })
-          }
-
-          const truncated = yield* deps.truncate.output(
-            textParts.join("\n\n") || `MCP resource ${uri} from ${server} returned no contents.`,
-            {},
-            deps.input.agent,
-          )
-          const output = {
-            title: `MCP resource: ${uri}`,
-            metadata: {
-              server,
-              uri,
-              contents: items.length,
-              attachments: attachments.length,
-              truncated: truncated.truncated,
-              ...(truncated.truncated && { outputPath: truncated.outputPath }),
-            },
-            output: truncated.content,
-            attachments: attachments.map((attachment) => ({
-              ...attachment,
-              id: PartID.ascending(),
-              sessionID: ctx.sessionID,
-              messageID: deps.input.processor.message.id,
-            })),
-          }
-          yield* deps.plugin.trigger(
-            "tool.execute.after",
-            { tool: "read_mcp_resource", sessionID: ctx.sessionID, callID: opts.toolCallId, args },
-            output,
-          )
-          if (opts.abortSignal?.aborted) yield* deps.input.processor.completeToolCall(opts.toolCallId, output)
-          return output
-        }),
-      )
-    },
-  })
-}
-
-function addDeferredTools(
-  tools: Record<string, Tool>,
-  deps: {
-    input: Input
-    run: EffectBridge.Shape
-    plugin: Plugin.Interface
-    truncate: Truncate.Interface
-    context: (args: Record<string, unknown>, options: ToolExecutionOptions) => Context
-    deferredDescriptors: DeferredToolDescriptor[]
-    allowedMcpTools: Record<string, Tool>
-    executeMcpTool: (
-      key: string,
-      execute: NonNullable<Tool["execute"]>,
-      args: unknown,
-      opts: ToolExecutionOptions,
-    ) => Effect.Effect<unknown>
-  },
-) {
-  tools[DEFERRED_TOOL_TOOLS.search] = tool({
-    description:
-      "Search only deferred tools. Deferred tools are not listed as direct tools; currently they are MCP server tools hidden to keep the provider tool list small. Do not use this for direct tools such as shell, file, edit, grep, glob, web, task, LSP, question, or apply_patch tools.",
-    inputSchema: jsonSchema(
-      ProviderTransform.schema(deps.input.model, ToolJsonSchema.fromSchema(SearchDeferredToolsParameters)),
-    ),
-    execute(args, opts) {
-      return deps.run.promise(
-        Effect.gen(function* () {
-          const params = yield* decodeSearchDeferredToolsParameters(args)
-          const ctx = deps.context(toRecord(args), opts)
-          yield* deps.plugin.trigger(
-            "tool.execute.before",
-            { tool: DEFERRED_TOOL_TOOLS.search, sessionID: ctx.sessionID, callID: opts.toolCallId },
-            { args },
-          )
-          const matches = searchDeferredTools(
-            deps.deferredDescriptors,
-            params.query,
-            params.limit ?? DEFAULT_DEFERRED_TOOL_LIMIT,
-          )
-          const truncated = yield* deps.truncate.output(
-            JSON.stringify(
-              {
-                tools: matches.map((descriptor) => ({
-                  tool_id: descriptor.id,
-                  description: descriptor.description,
-                  ...((params.include_schema ?? true) ? { input_schema: descriptor.inputSchema } : {}),
-                })),
-              },
-              null,
-              2,
-            ),
-            {},
-            deps.input.agent,
-          )
-          const output = {
-            title: "Deferred tools search",
-            metadata: {
-              query: params.query,
-              includeSchema: params.include_schema ?? true,
-              count: matches.length,
-              total: deps.deferredDescriptors.length,
-              truncated: truncated.truncated,
-              ...(truncated.truncated && { outputPath: truncated.outputPath }),
-            },
-            output: truncated.content,
-          }
-          yield* deps.plugin.trigger(
-            "tool.execute.after",
-            { tool: DEFERRED_TOOL_TOOLS.search, sessionID: ctx.sessionID, callID: opts.toolCallId, args },
-            output,
-          )
-          if (opts.abortSignal?.aborted) yield* deps.input.processor.completeToolCall(opts.toolCallId, output)
-          return output
-        }),
-      )
-    },
-  })
-
-  tools[DEFERRED_TOOL_TOOLS.call] = tool({
-    description:
-      "Call one deferred tool by tool_id after finding it with search_deferred_tools. Do not use this for direct tools such as shell, file, edit, grep, glob, web, task, LSP, question, or apply_patch tools.",
-    inputSchema: jsonSchema(
-      ProviderTransform.schema(deps.input.model, ToolJsonSchema.fromSchema(CallDeferredToolParameters)),
-    ),
-    execute(args, opts) {
-      return deps.run.promise(
-        Effect.gen(function* () {
-          const params = yield* decodeCallDeferredToolParameters(args)
-          const item = deps.allowedMcpTools[params.tool_id]
-          const execute = item?.execute
-          if (!item || !execute) {
-            throw new Error(
-              `Deferred tool "${params.tool_id}" is not available. Use search_deferred_tools and copy a tool_id from the results.`,
-            )
-          }
-          return yield* deps.executeMcpTool(params.tool_id, execute, params.arguments, opts)
-        }),
-      )
-    },
-  })
-}
-
-function toRecord(value: unknown) {
-  if (isRecord(value)) return value
-  return {}
-}
-
-function optionalString(args: Record<string, unknown>, key: string) {
-  const value = args[key]
-  if (value === undefined || value === null || value === "") return undefined
-  if (typeof value !== "string") throw new Error(`${key} must be a string`)
-  return value
-}
-
-function requiredString(args: Record<string, unknown>, key: string) {
-  const value = optionalString(args, key)
-  if (value) return value
-  throw new Error(`${key} is required`)
-}
-
-function deferredToolDescriptors(tools: Record<string, Tool>) {
-  return Effect.forEach(
-    Object.entries(tools).toSorted(([a], [b]) => a.localeCompare(b)),
-    ([id, item]) =>
-      Effect.gen(function* () {
-        const schema = yield* Effect.promise(() => Promise.resolve(asSchema(item.inputSchema).jsonSchema))
-        return {
-          id,
-          description: item.description ?? "",
-          inputSchema: schema,
-          searchText: [
-            id,
-            item.description ?? "",
-            ...(isRecord(schema) && isRecord(schema.properties)
-              ? Object.entries(schema.properties).flatMap(([name, property]) =>
-                  isRecord(property) && typeof property.description === "string"
-                    ? [name, property.description]
-                    : [name],
-                )
-              : []),
-          ].join("\n"),
-        }
-      }),
-    { concurrency: "unbounded" },
-  )
-}
-
-function deferredToolSchemaTokens(descriptors: DeferredToolDescriptor[]) {
-  return Token.estimate(
-    JSON.stringify(
-      descriptors.map((descriptor) => ({
-        id: descriptor.id,
-        description: descriptor.description,
-        input_schema: descriptor.inputSchema,
-      })),
-    ),
-  )
-}
-
-function deferredServerSummaries(toolIDs: string[], serverNames: string[]) {
-  const prefixes = serverNames
-    .map((name) => ({ name, prefix: McpCatalog.sanitize(name) + "_" }))
-    .toSorted((a, b) => b.prefix.length - a.prefix.length || a.name.localeCompare(b.name))
-  const counts = new Map<string, number>()
-  for (const toolID of toolIDs) {
-    const server = prefixes.find((candidate) => toolID.startsWith(candidate.prefix))
-    if (!server) continue
-    counts.set(server.name, (counts.get(server.name) ?? 0) + 1)
-  }
-  return Array.from(counts.entries())
-    .map(([name, count]) => ({ name, count }))
-    .toSorted((a, b) => a.name.localeCompare(b.name))
-}
-
-function searchDeferredTools(descriptors: DeferredToolDescriptor[], query: string, limit: number) {
-  const terms = query
-    .toLowerCase()
-    .split(/[^a-z0-9_-]+/)
-    .map((term) => term.trim())
-    .filter((term) => term.length > 0 && term !== "*")
-  return descriptors
-    .map((descriptor) => {
-      const id = descriptor.id.toLowerCase()
-      const description = descriptor.description.toLowerCase()
-      const searchText = descriptor.searchText.toLowerCase()
-      return {
-        descriptor,
-        score: terms.reduce(
-          (score, term) =>
-            score +
-            (id === term ? 20 : 0) +
-            (id.includes(term) ? 8 : 0) +
-            (description.includes(term) ? 4 : 0) +
-            (searchText.includes(term) ? 2 : 0),
-          0,
-        ),
-      }
-    })
-    .filter((item) => terms.length === 0 || item.score > 0)
-    .toSorted((a, b) => b.score - a.score || a.descriptor.id.localeCompare(b.descriptor.id))
-    .slice(0, limit)
-    .map((item) => item.descriptor)
-}
-
-function currentUserToolOverrides(messages: SessionV1.WithParts[]) {
-  const user = messages.findLast((message) => message.info.role === "user")
-  return user?.info.role === "user" ? user.info.tools : undefined
-}
-
-function mcpToolContent(result: unknown): McpToolContent[] {
-  if (!isRecord(result) || !Array.isArray(result.content)) return []
-  return result.content.flatMap((item): McpToolContent[] => {
-    if (!isRecord(item) || typeof item.type !== "string") return []
-    if (item.type === "text" && typeof item.text === "string") return [{ type: "text", text: item.text }]
-    if (item.type === "image" && typeof item.mimeType === "string" && typeof item.data === "string") {
-      return [{ type: "image", mimeType: item.mimeType, data: item.data }]
-    }
-    if (item.type === "resource" && isRecord(item.resource)) return [{ type: "resource", resource: item.resource }]
-    return []
-  })
-}
-
-function base64Size(value: string) {
-  const trimmed = value.replace(/\s/g, "")
-  const padding = trimmed.endsWith("==") ? 2 : trimmed.endsWith("=") ? 1 : 0
-  return Math.max(0, Math.floor((trimmed.length * 3) / 4) - padding)
-}
-
-function formatBytes(value: number) {
-  if (value < 1024) return `${value} B`
-  if (value < 1024 * 1024) return `${Math.ceil(value / 1024)} KB`
-  return `${Math.ceil(value / (1024 * 1024))} MB`
-}
-
-export * as SessionMcpTools from "./mcp-tools"
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Kit Langton	d3ace428d6	fix(core): share session runtime coordination	2026-06-28 19:47:17 +00:00
Kit Langton	8a819da177	fix(core): route subagent through session runtime	2026-06-28 19:39:07 +00:00
Kit Langton	89ef53537e	refactor(core): add location session runtime	2026-06-28 19:34:35 +00:00
Kit Langton	70cecc6ba1	docs(core): prototype plugin session architecture	2026-06-28 19:21:34 +00:00
Kit Langton	04c6bed240	feat(core): restore per-request system prompt (#34335 )	2026-06-28 14:02:46 -04:00
Kit Langton	94e3a29d2f	feat(core): wire v2 subagent tool (#34320 )	2026-06-28 12:52:39 -04:00
Kit Langton	41283933ff	chore: merge dev into v2 (#34317 ) Co-authored-by: Brendan Allan <14191578+Brendonovich@users.noreply.github.com> Co-authored-by: opencode-agent[bot] <opencode-agent[bot]@users.noreply.github.com> Co-authored-by: Affan Ali <93028901+affanali2k3@users.noreply.github.com> Co-authored-by: affanali2k3 <affanalikhanxx@gmail.com> Co-authored-by: Frank <frank@anoma.ly> Co-authored-by: opencode-agent[bot] <219766164+opencode-agent[bot]@users.noreply.github.com> Co-authored-by: James Long <longster@gmail.com> Co-authored-by: Aiden Cline <63023139+rekram1-node@users.noreply.github.com> Co-authored-by: Jay V <air@live.ca> Co-authored-by: Dax Raad <d@ironbay.co> Co-authored-by: Aarav Sareen <96787824+arvsrn@users.noreply.github.com> Co-authored-by: OpeOginni <107570612+OpeOginni@users.noreply.github.com> Co-authored-by: Luke Parker <10430890+Hona@users.noreply.github.com> Co-authored-by: Ben Guthrie <benjee.012@gmail.com> Co-authored-by: Dax <mail@thdxr.com> Co-authored-by: Filip <34747899+neriousy@users.noreply.github.com>	2026-06-28 11:30:38 -04:00
Dax Raad	11bf8d8a42	refactor(cli): simplify updater, remove cache and confirmation publish / version (push) Has been cancelled Details publish / build-cli (push) Has been cancelled Details publish / sign-cli-windows (push) Has been cancelled Details publish / build-electron (map[bun_install_flags:--os=darwin --cpu=arm64 host:macos-26 platform_flag:--mac --arm64 target:aarch64-apple-darwin]) (push) Has been cancelled Details publish / build-electron (map[bun_install_flags:--os=darwin --cpu=x64 host:macos-26-intel platform_flag:--mac --x64 target:x86_64-apple-darwin]) (push) Has been cancelled Details publish / build-electron (map[host:blacksmith-4vcpu-ubuntu-2404 platform_flag:--linux target:x86_64-unknown-linux-gnu]) (push) Has been cancelled Details publish / build-electron (map[host:blacksmith-4vcpu-ubuntu-2404-arm platform_flag:--linux --arm64 target:aarch64-unknown-linux-gnu]) (push) Has been cancelled Details publish / build-electron (map[host:blacksmith-4vcpu-windows-2025 platform_flag:--win target:x86_64-pc-windows-msvc]) (push) Has been cancelled Details publish / build-electron (map[host:windows-2025 platform_flag:--win --arm64 target:aarch64-pc-windows-msvc]) (push) Has been cancelled Details publish / publish (push) Has been cancelled Details - Remove the 24h disk cache (State, readState/writeState, checkInterval) that served stale latest versions within the TTL window - Remove file lock (Flock) and confirmation prompt (Prompt/Terminal) - Every check now hits the npm registry directly - Updates always auto-install on any version mismatch within the same major, including rollbacks where the registry version is lower - Drop the interactive option from check() and the confirm/declined/ dismissed action concepts	2026-06-27 20:52:03 -04:00
Dax Raad	c22973ab9f	fix(server): log undo revert operations	2026-06-27 20:32:58 -04:00
Dax Raad	612009e0f1	fix(tui): use span for inline styled hotkey in revert footer	2026-06-27 20:32:14 -04:00
Dax Raad	a0a6c9545e	fix(tui): style redo hotkey as normal text in revert footer	2026-06-27 20:30:52 -04:00
Dax Raad	bceb6d0a9e	feat(tui): add redo hotkey footer and pad file list in revert banner	2026-06-27 20:30:26 -04:00
Dax Raad	49e7dc191f	fix(tui): make undo inclusive of last user message and simplify revert banner	2026-06-27 20:25:08 -04:00
Dax	f4720be08e	feat(tui): add session rename (#34264 )	2026-06-27 20:07:23 -04:00
Dax	d1d7ebc2c6	feat(tui): wire up undo/redo and revert for V2 sessions (#34263 )	2026-06-28 00:04:53 +00:00
Dax Raad	cd942d0669	fix(tui): normalize abbreviated home paths to forward slashes	2026-06-27 18:54:06 -04:00
Dax Raad	4741e3ee6b	fix(tui): remove redundant top spacer in session history	2026-06-27 13:54:16 -04:00
Dax Raad	4673bfbaa0	feat(cli): log startup info Emit a log entry on CLI startup with version, channel, and local flag so every CLI process is visible in opencode.log from the start.	2026-06-27 13:45:42 -04:00
Dax Raad	b458dd8c63	feat(cli): log updater check decisions Add Effect.logInfo at every previously-silent path in the updater check so each run is observable in opencode.log: skip reasons (local install, disabled, policy), the resolved version with source (cached vs registry), and the final action (up-to-date, dismissed, declined).	2026-06-27 13:29:46 -04:00
Dax Raad	7edd6c3a1d	feat(cli): use installation version and document API debugging - Replace hardcoded "local" version string with InstallationVersion - Document DESCRIPTION Make a request to the running server USAGE opencode api [flags] <operation \| method path...> ARGUMENTS operation \| method path... stringOpenAPI operation ID, or an HTTP method followed by a path FLAGS --data, -d string Request body --header, -H string Request header in name:value form --param key=value OpenAPI path or query parameter GLOBAL FLAGS --help, -h Show help information --version, -v Show version information --completions <bash\|zsh\|fish\|sh> Print shell completion script (choices: bash, zsh, fish, sh) --log-level <all\|trace\|debug\|info\|warn\|warning\|error\|fatal\|none> Sets the minimum log level (choices: all, trace, debug, info, warn, warning, error, fatal, none) server/API debugging command in AGENTS.md	2026-06-27 13:18:22 -04:00
Dax Raad	f43f066741	fix(tui): stop bash spinner when tool errors before command received	2026-06-27 13:17:21 -04:00
Dax Raad	b6553d14e1	fix(core): fail interrupted session steps publish / version (push) Has been cancelled Details publish / build-cli (push) Has been cancelled Details publish / sign-cli-windows (push) Has been cancelled Details publish / build-electron (map[bun_install_flags:--os=darwin --cpu=arm64 host:macos-26 platform_flag:--mac --arm64 target:aarch64-apple-darwin]) (push) Has been cancelled Details publish / build-electron (map[bun_install_flags:--os=darwin --cpu=x64 host:macos-26-intel platform_flag:--mac --x64 target:x86_64-apple-darwin]) (push) Has been cancelled Details publish / build-electron (map[host:blacksmith-4vcpu-ubuntu-2404 platform_flag:--linux target:x86_64-unknown-linux-gnu]) (push) Has been cancelled Details publish / build-electron (map[host:blacksmith-4vcpu-ubuntu-2404-arm platform_flag:--linux --arm64 target:aarch64-unknown-linux-gnu]) (push) Has been cancelled Details publish / build-electron (map[host:blacksmith-4vcpu-windows-2025 platform_flag:--win target:x86_64-pc-windows-msvc]) (push) Has been cancelled Details publish / build-electron (map[host:windows-2025 platform_flag:--win --arm64 target:aarch64-pc-windows-msvc]) (push) Has been cancelled Details publish / publish (push) Has been cancelled Details	2026-06-27 01:16:30 -04:00
Dax Raad	ab0042a666	docs(opencode): mark package as v1	2026-06-27 01:16:30 -04:00
Dax Raad	5df049d081	feat(cli): add self-update service Check the npm registry (at most once per 24h, file-locked) for newer @opencode-ai/cli releases and act on a host-level autoupdate policy read from config. Apply patch updates automatically, confirm minor updates interactively, and never auto-update across majors. Skip local installs and honor the disable flag. Wired into the default TUI command (interactive) and serve (background).	2026-06-27 00:51:45 -04:00
Dax Raad	573ab9c24b	fix(tui): interrupt v2 sessions with escape	2026-06-26 22:32:21 -04:00
Dax Raad	6a16c41e8f	fix(core): continue after tool defects	2026-06-26 22:02:30 -04:00
Dax Raad	a491cbee64	fix(tui): hide prompt for running shell commands	2026-06-26 21:35:20 -04:00
Dax Raad	658cbe9caf	fix(core): load OpenCode provider config asynchronously	2026-06-26 21:16:15 -04:00
Dax Raad	62b2bc39df	test(ci): skip v2 end-to-end checks	2026-06-26 21:04:10 -04:00
Dax Raad	beb2c52c3f	fix(cli): publish scoped package	2026-06-26 21:01:10 -04:00
Dax Raad	655adbf46e	fix: stabilize v2 runtime behavior	2026-06-26 20:56:36 -04:00
Dax Raad	ac2a78391f	fix(ci): publish v2 as next	2026-06-26 15:55:04 -04:00
Dax Raad	9a9bdaba95	test(ci): drop legacy opencode tests	2026-06-26 14:58:40 -04:00
Dax Raad	8b682c42b6	refactor(tui): use v2 client transport	2026-06-26 14:57:01 -04:00
Dax Raad	ad4f1c1018	refactor(ci): use branch npm tag	2026-06-26 14:54:35 -04:00
Dax Raad	a0afb63ed0	fix(ci): use v2 npm tag	2026-06-26 14:53:35 -04:00
Dax Raad	df9ecb8f6a	fix(cli): publish v2 package	2026-06-26 14:52:30 -04:00
Dax Raad	e6f660fecf	feat(tui): add v2 terminal interface	2026-06-26 14:38:25 -04:00
				`@@ -1 +0,0 @@`
				`File to save in: ~/.local/share/opencode/worktree/012780/location-layer-tiers/packages/core/src/effect/`