refactor(cli): own Code Mode host wiring

bun.lock

@@ -101,6 +101,7 @@
       "dependencies": {
         "@effect/platform-node": "catalog:",
         "@opencode-ai/client": "workspace:*",
+        "@opencode-ai/codemode": "workspace:*",
         "@opencode-ai/core": "workspace:*",
         "@opencode-ai/plugin": "workspace:*",
         "@opencode-ai/schema": "workspace:*",

packages/cli/package.json

@@ -33,6 +33,7 @@
   "dependencies": {
     "@effect/platform-node": "catalog:",
     "@opencode-ai/client": "workspace:*",
+    "@opencode-ai/codemode": "workspace:*",
     "@opencode-ai/core": "workspace:*",
     "@opencode-ai/plugin": "workspace:*",
     "@opencode-ai/schema": "workspace:*",

packages/cli/src/code-mode.ts

@@ -0,0 +1,66 @@
+export * as CodeModeHost from "./code-mode"
+
+import { NodeHttpClient } from "@effect/platform-node"
+import { LayerNode } from "@opencode-ai/core/effect/layer-node"
+import { ToolRegistry } from "@opencode-ai/core/tool/registry"
+import { OpenAPI, Tool } from "@opencode-ai/codemode"
+import { Api } from "@opencode-ai/server/api"
+import { ServerAuth } from "@opencode-ai/server/auth"
+import { Effect, Layer } from "effect"
+import { HttpClient, HttpClientRequest } from "effect/unstable/http"
+import { OpenApi } from "effect/unstable/httpapi"
+import type { Server } from "node:http"
+
+export function replacements(server: Server, password: string): LayerNode.Replacements {
+  return [ToolRegistry.codeModeReplacement(makeTools(client(server), password))]
+}
+
+export function makeTools(client: Layer.Layer<HttpClient.HttpClient>, password: string): ToolRegistry.CodeModeTools {
+  return {
+    opencode: bindTools(
+      OpenAPI.fromSpec({
+        spec: { ...OpenApi.fromApi(Api) },
+        baseUrl: "http://opencode.local",
+        headers: ServerAuth.headers({ username: "opencode", password }),
+      }).tools,
+      client,
+    ),
+  }
+}
+
+function client(server: Server) {
+  return Layer.effect(
+    HttpClient.HttpClient,
+    Effect.gen(function* () {
+      const client = yield* HttpClient.HttpClient
+      return HttpClient.mapRequest(client, (request) => {
+        const address = server.address()
+        if (!address || typeof address === "string") throw new Error("OpenCode server is not listening")
+        const local =
+          address.address === "0.0.0.0" ? "127.0.0.1" : address.address === "::" ? "::1" : address.address
+        const host = local.includes(":") && !local.startsWith("[") ? `[${local}]` : local
+        const url = new URL(request.url)
+        return HttpClientRequest.setUrl(
+          request,
+          new URL(`${url.pathname}${url.search}${url.hash}`, `http://${host}:${address.port}`),
+        )
+      })
+    }),
+  ).pipe(Layer.provide(NodeHttpClient.layerNodeHttp))
+}
+
+function bindTools(tools: OpenAPI.Tools, client: Layer.Layer<HttpClient.HttpClient>): ToolRegistry.CodeModeTools {
+  return Object.fromEntries(
+    Object.entries(tools).map(([name, value]) => [
+      name,
+      Tool.isDefinition<HttpClient.HttpClient>(value)
+        ? Tool.make({
+            description: value.description,
+            input: value.input,
+            output: value.output,
+            run: (input) => value.run(input).pipe(Effect.provide(client)),
+          })
+        : bindTools(value, client),
+    ]),
+  )
+}

packages/cli/src/server-process.ts

@@ -13,6 +13,7 @@ import { randomBytes, randomUUID } from "node:crypto"
 import path from "node:path"
 import { Effect, FileSystem, Logger, Option, Redacted, Schedule, Schema } from "effect"
 import { HttpServer } from "effect/unstable/http"
+import { CodeModeHost } from "./code-mode"
 import { Env } from "./env"
 import { ServiceConfig } from "./services/service-config"
 import { Updater } from "./services/updater"
@@ -63,6 +64,7 @@ const processEffect = Effect.fnUntraced(function* (options: Options) {
         hostname: options.hostname ?? config.hostname ?? "127.0.0.1",
         port: Option.fromNullishOr(options.port ?? config.port),
         password,
+        replacements: (server) => CodeModeHost.replacements(server, password),
       }).pipe(Effect.provide(Logger.layer([], { mergeWithExisting: false })))
       if (options.mode === "service") yield* register(address, password)
       const url = HttpServer.formatAddress(address)

packages/cli/test/code-mode.test.ts

@@ -0,0 +1,39 @@
+import { expect, test } from "bun:test"
+import { CodeMode } from "@opencode-ai/codemode"
+import { Effect, Layer } from "effect"
+import { HttpClient, HttpClientResponse } from "effect/unstable/http"
+import { CodeModeHost } from "../src/code-mode"
+
+test("exposes the authenticated OpenCode API through CodeMode", async () => {
+  const requests: Array<{ readonly url: string; readonly authorization?: string }> = []
+  const client = Layer.succeed(
+    HttpClient.HttpClient,
+    HttpClient.make((request) => {
+      requests.push({ url: request.url, authorization: request.headers.authorization })
+      return Effect.succeed(
+        HttpClientResponse.fromWeb(
+          request,
+          Response.json(
+            { healthy: true, version: "test", pid: 1 },
+            { headers: { "content-type": "application/json" } },
+          ),
+        ),
+      )
+    }),
+  )
+  const result = await CodeMode.make({ tools: CodeModeHost.makeTools(client, "secret") })
+    .execute("return await tools.opencode.v2.health.get({})")
+    .pipe(Effect.runPromise)
+
+  expect(result).toEqual({
+    ok: true,
+    value: { healthy: true, version: "test", pid: 1 },
+    toolCalls: [{ name: "opencode.v2.health.get" }],
+  })
+  expect(requests).toEqual([
+    {
+      url: "http://opencode.local/api/health",
+      authorization: `Basic ${Buffer.from("opencode:secret").toString("base64")}`,
+    },
+  ])
+})

packages/client/src/effect/api/api.ts

@@ -890,14 +890,8 @@ export interface VcsApi<E = never> {
 export type Endpoint25_0Output = EffectValue<ReturnType<RawClient["server.debug"]["debug.location"]>>
 export type DebugLocationOperation<E = never> = () => Effect.Effect<Endpoint25_0Output, E>
 
-type Endpoint25_1Request = Parameters<RawClient["server.debug"]["debug.location.evict"]>[0]
-export type Endpoint25_1Input = { readonly location?: Endpoint25_1Request["query"]["location"] }
-export type Endpoint25_1Output = EffectValue<ReturnType<RawClient["server.debug"]["debug.location.evict"]>>
-export type DebugEvictLocationOperation<E = never> = (input?: Endpoint25_1Input) => Effect.Effect<Endpoint25_1Output, E>
-
 export interface DebugApi<E = never> {
   readonly location: DebugLocationOperation<E>
-  readonly evictLocation: DebugEvictLocationOperation<E>
 }
 
 export interface AppApi<E = never> {

packages/client/src/effect/generated/client.ts

@@ -1069,15 +1069,7 @@ const adaptGroup24 = (raw: RawClient["server.vcs"]) => ({ status: Endpoint24_0(r
 const Endpoint25_0 = (raw: RawClient["server.debug"]) => () =>
   raw["debug.location"]({}).pipe(Effect.mapError(mapClientError))
 
-type Endpoint25_1Request = Parameters<RawClient["server.debug"]["debug.location.evict"]>[0]
-type Endpoint25_1Input = { readonly location?: Endpoint25_1Request["query"]["location"] }
-const Endpoint25_1 = (raw: RawClient["server.debug"]) => (input?: Endpoint25_1Input) =>
-  raw["debug.location.evict"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError))
-
-const adaptGroup25 = (raw: RawClient["server.debug"]) => ({
-  location: Endpoint25_0(raw),
-  evictLocation: Endpoint25_1(raw),
-})
+const adaptGroup25 = (raw: RawClient["server.debug"]) => ({ location: Endpoint25_0(raw) })
 
 const adaptClient = (raw: RawClient) => ({
   health: adaptGroup0(raw["server.health"]),

packages/client/src/promise/generated/client.ts

@@ -178,8 +178,6 @@ import type {
   VcsDiffInput,
   VcsDiffOutput,
   DebugLocationOutput,
-  DebugEvictLocationInput,
-  DebugEvictLocationOutput,
 } from "./types"
 import { ClientError } from "./client-error"
 
@@ -1496,18 +1494,6 @@ export function make(options: ClientOptions) {
           },
           requestOptions,
         ),
-      evictLocation: (input?: DebugEvictLocationInput, requestOptions?: RequestOptions) =>
-        request<DebugEvictLocationOutput>(
-          {
-            method: "DELETE",
-            path: `/api/debug/location`,
-            query: { location: input?.["location"] },
-            successStatus: 204,
-            declaredStatuses: [401, 400],
-            empty: true,
-          },
-          requestOptions,
-        ),
     },
   }
 }

packages/client/src/promise/generated/types.ts

@@ -6130,11 +6130,3 @@ export type VcsDiffOutput = {
 }
 
 export type DebugLocationOutput = ReadonlyArray<{ readonly directory: string; readonly workspaceID?: string }>
-
-export type DebugEvictLocationInput = {
-  readonly location?: {
-    readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
-  }["location"]
-}
-
-export type DebugEvictLocationOutput = void

packages/codemode/codemode.md

@@ -153,7 +153,8 @@ current omissions to implement, not intentional product boundaries.
       shims. Consider `Promise.any` in the same pass.
 - [ ] Support async iteration and `for await...of`. Define behavior first for the runtime's supported promise and
       collection values, then extend it to bounded host streams when a stream boundary exists.
-- [ ] Support the mapper argument to `Array.from(...)`, including Effect-aware callbacks.
+- [ ] Support callback-bearing standard-library variants that models commonly generate: the mapper argument to
+      `Array.from(...)` and replacers for `JSON.stringify(...)`, including Effect-aware callbacks where needed.
 - [ ] Add `Object.is` after runtime method and tool references have stable identity semantics.
 - [ ] Add deterministic modern collection conveniences where they improve orchestration: `Object.groupBy`, Set
       composition methods, and `Array.prototype.toSpliced`.

packages/codemode/src/interpreter/runtime.ts

@@ -5,7 +5,6 @@ import {
   copyIn,
   copyOut,
   isBlockedMember,
-  MAX_VALUE_DEPTH,
   ToolReference,
   ToolRuntime,
   ToolRuntimeError,
@@ -2028,7 +2027,6 @@ class Interpreter<R> {
       }
       if (callable instanceof GlobalMethodReference) {
         if (callable.namespace === "console") return self.invokeConsole(callable.name, args, node)
-        if (callable.namespace === "JSON") return yield* self.invokeJsonMethod(callable.name, args, node)
         if (callable.namespace === "Object" && args[0] instanceof ToolReference) {
           return self.invokeObjectMethodOnTools(callable.name, args[0], node)
         }
@@ -2494,129 +2492,6 @@ class Interpreter<R> {
     })
   }
 
-  private invokeJsonMethod(
-    name: string,
-    args: Array<unknown>,
-    node: AstNode,
-  ): Effect.Effect<unknown, unknown, R> {
-    const callback = args[1]
-    const callable =
-      callback instanceof CodeModeFunction ||
-      callback instanceof CoercionFunction ||
-      callback instanceof GlobalMethodReference ||
-      callback instanceof UriFunction
-    if (name === "parse" && callable) return this.parseJsonWithReviver(args, node)
-    if (name === "stringify" && (callable || Array.isArray(callback))) {
-      return this.stringifyJsonWithReplacer(args, node)
-    }
-    return Effect.sync(() => invokeJsonMethod(name, args, node))
-  }
-
-  private parseJsonWithReviver(args: Array<unknown>, node: AstNode): Effect.Effect<unknown, unknown, R> {
-    const apply = this.applySettledCollectionCallback(args[1], "JSON.parse", node)
-    const visit = (key: string, item: unknown): Effect.Effect<unknown, unknown, R> =>
-      Effect.gen(function* () {
-        if (Array.isArray(item)) {
-          for (let index = 0; index < item.length; index += 1) {
-            if (!(index in item)) continue
-            const revived = yield* visit(String(index), item[index])
-            if (revived === undefined) {
-              delete item[index]
-              continue
-            }
-            item[index] = revived
-          }
-          return yield* apply([key, item])
-        }
-        if (item !== null && typeof item === "object" && !isSandboxValue(item)) {
-          const object = item as SafeObject
-          for (const childKey of Object.keys(object)) {
-            const revived = yield* visit(childKey, object[childKey])
-            if (revived === undefined) {
-              delete object[childKey]
-              continue
-            }
-            object[childKey] = revived
-          }
-        }
-        return yield* apply([key, item])
-      })
-    return visit("", invokeJsonMethod("parse", [args[0]], node))
-  }
-
-  private stringifyJsonWithReplacer(args: Array<unknown>, node: AstNode): Effect.Effect<unknown, unknown, R> {
-    const callback = args[1]
-    const apply = Array.isArray(callback)
-      ? undefined
-      : this.applySettledCollectionCallback(callback, "JSON.stringify", node)
-    const ancestors = new Set<object>()
-    const propertyList = Array.isArray(callback)
-      ? Array.from(
-          new Set(
-            callback
-              .filter((item): item is string | number => typeof item === "string" || typeof item === "number")
-              .map(String),
-          ),
-        )
-      : undefined
-    const visit = (key: string, item: unknown, depth: number): Effect.Effect<unknown, unknown, R> =>
-      Effect.gen(function* () {
-        const resolved = yield* (() => {
-          if (apply === undefined) return Effect.succeed(item)
-          return apply([
-            key,
-            item instanceof SandboxDate || item instanceof SandboxURL
-              ? copyIn(item, "JSON.stringify value")
-              : item,
-          ])
-        })()
-        if (typeofValue(resolved) === "function") return undefined
-        if (resolved === null || typeof resolved !== "object") return resolved
-        if (isSandboxValue(resolved)) {
-          return apply === undefined
-            ? copyIn(resolved, "JSON.stringify replacer result")
-            : (Object.create(null) as SafeObject)
-        }
-        if (!Array.isArray(resolved)) {
-          const prototype = Object.getPrototypeOf(resolved)
-          if (prototype !== Object.prototype && prototype !== null) {
-            return copyIn(resolved, "JSON.stringify replacer result")
-          }
-        }
-        if (depth > MAX_VALUE_DEPTH) {
-          throw new ToolRuntimeError(
-            "InvalidDataValue",
-            `JSON.stringify replacer result exceeds the maximum value depth of ${MAX_VALUE_DEPTH}.`,
-          )
-        }
-        if (ancestors.has(resolved)) {
-          throw new ToolRuntimeError("InvalidDataValue", "JSON.stringify replacer result contains a circular value.")
-        }
-        ancestors.add(resolved)
-        return yield* Effect.gen(function* () {
-          if (Array.isArray(resolved)) {
-            const output: Array<unknown> = []
-            const length = resolved.length
-            for (let index = 0; index < length; index += 1) {
-              output[index] = yield* visit(String(index), resolved[index], depth + 1)
-            }
-            return output
-          }
-          const output: SafeObject = Object.create(null) as SafeObject
-          for (const childKey of propertyList ?? Object.keys(resolved)) {
-            if (isBlockedMember(childKey)) continue
-            if (apply === undefined && !Object.hasOwn(resolved, childKey)) continue
-            const child = yield* visit(childKey, (resolved as SafeObject)[childKey], depth + 1)
-            if (child !== undefined) output[childKey] = child
-          }
-          return output
-        }).pipe(Effect.ensuring(Effect.sync(() => ancestors.delete(resolved))))
-      })
-    return Effect.map(visit("", args[0], 0), (value) =>
-      invokeJsonMethod("stringify", [value, propertyList, args[2]], node),
-    )
-  }
-
   // Runs a collection callback accepting a user function or supported builtin callable,
   // mirroring the array-method callback contract.
   private applyCollectionCallback(
@@ -2627,7 +2502,6 @@ class Interpreter<R> {
     if (
       !(callback instanceof CodeModeFunction) &&
       !(callback instanceof CoercionFunction) &&
-      !(callback instanceof GlobalMethodReference) &&
       !(callback instanceof UriFunction)
     ) {
       throw new InterpreterRuntimeError(`${name} expects a function callback.`, node)
@@ -2635,23 +2509,9 @@ class Interpreter<R> {
     return (callbackArgs) =>
       callback instanceof CoercionFunction
         ? Effect.succeed(invokeCoercion(callback, callbackArgs, node))
-        : callback instanceof GlobalMethodReference
-          ? Effect.succeed(invokeGlobalMethod(callback, callbackArgs, node))
-          : callback instanceof UriFunction
-            ? Effect.succeed(invokeUriFunction(callback, callbackArgs, node))
-            : this.invokeFunction(callback, callbackArgs)
-  }
-
-  private applySettledCollectionCallback(
-    callback: unknown,
-    name: string,
-    node: AstNode,
-  ): (args: Array<unknown>) => Effect.Effect<unknown, unknown, R> {
-    const apply = this.applyCollectionCallback(callback, name, node)
-    return (args) =>
-      Effect.flatMap(apply(args), (value) =>
-        value instanceof SandboxPromise ? this.settlePromise(value, node) : Effect.succeed(value),
-      )
+        : callback instanceof UriFunction
+          ? Effect.succeed(invokeUriFunction(callback, callbackArgs, node))
+          : this.invokeFunction(callback, callbackArgs)
   }
 
   private invokeMapMethod(

packages/codemode/src/stdlib/json.ts

@@ -1,4 +1,9 @@
-import { type AstNode, InterpreterRuntimeError } from "../interpreter/model.js"
+import {
+  type AstNode,
+  CodeModeFunction,
+  InterpreterRuntimeError,
+  supportedSyntaxMessage,
+} from "../interpreter/model.js"
 import { copyIn, copyOut } from "../tool-runtime.js"
 
 export const jsonStatics = new Set(["stringify", "parse"])
@@ -7,13 +12,18 @@ export const invokeJsonMethod = (name: string, args: Array<unknown>, node: AstNo
   if (!jsonStatics.has(name)) throw new InterpreterRuntimeError(`JSON.${name} is not available in CodeMode.`, node)
   switch (name) {
     case "stringify": {
+      const replacer = args[1]
+      if (Array.isArray(replacer) || replacer instanceof CodeModeFunction) {
+        throw new InterpreterRuntimeError(
+          "JSON.stringify replacers are not supported in CodeMode.",
+          node,
+          "UnsupportedSyntax",
+          [supportedSyntaxMessage],
+        )
+      }
       const space = args[2]
       const indent = typeof space === "number" || typeof space === "string" ? space : undefined
-      return JSON.stringify(
-        copyOut(copyIn(args[0], "JSON.stringify value")),
-        Array.isArray(args[1]) ? args[1] : null,
-        indent,
-      )
+      return JSON.stringify(copyOut(copyIn(args[0], "JSON.stringify value")), null, indent)
     }
     case "parse": {
       const text = args[0]

packages/codemode/src/tool-runtime.ts

@@ -119,7 +119,7 @@ export class ToolReference {
  * limit) purely because it produces a clearer diagnostic than a native stack-overflow
  * RangeError would.
  */
-export const MAX_VALUE_DEPTH = 32
+const MAX_VALUE_DEPTH = 32
 
 export class ToolRuntimeError extends Error {
   constructor(

packages/codemode/test/stdlib.test.ts

@@ -19,161 +19,6 @@ const error = async (code: string) => {
   return result.error
 }
 
-describe("JSON", () => {
-  test("parse revivers run post-order including the root", async () => {
-    expect(
-      await value(`
-        const order = []
-        const parsed = JSON.parse('{"item":{"count":2}}', (key, item) => {
-          order.push(key)
-          if (key === "count") return item + 1
-          if (key === "") return { parsed: item }
-          return item
-        })
-        return { parsed, order }
-      `),
-    ).toEqual({ parsed: { parsed: { item: { count: 3 } } }, order: ["count", "item", ""] })
-    expect(await value(`return JSON.parse("1", (key, value) => undefined) === undefined`)).toBe(true)
-  })
-
-  test("parse reviver deletion removes properties and creates array holes", async () => {
-    expect(
-      await value(`
-        const parsed = JSON.parse('{"keep":1,"drop":2,"items":[1,2,3]}', (key, item) =>
-          key === "drop" || key === "1" ? undefined : item
-        )
-        return { json: JSON.stringify(parsed), hasSecond: 1 in parsed.items, length: parsed.items.length }
-      `),
-    ).toEqual({ json: '{"keep":1,"items":[1,null,3]}', hasSecond: false, length: 3 })
-  })
-
-  test("stringify function replacers run root-first and apply JSON deletion rules", async () => {
-    expect(
-      await value(`
-        const order = []
-        const json = JSON.stringify({ keep: 1, drop: 2, items: [1, 2] }, (key, item) => {
-          order.push(key)
-          if (key === "drop" || key === "1") return undefined
-          return item
-        })
-        return { json, order }
-      `),
-    ).toEqual({ json: '{"keep":1,"items":[1,null]}', order: ["", "keep", "drop", "items", "0", "1"] })
-    expect(
-      await value(`
-        return [
-          JSON.stringify(1, (key, item) => key === "" ? new Date(0) : item),
-          JSON.stringify(1, (key, item) => key === "" ? new URL("https://example.test") : item),
-        ]
-      `),
-    ).toEqual(["{}", "{}"])
-  })
-
-  test("stringify function replacers observe live mutations and sandbox values", async () => {
-    expect(
-      await value(`
-        const item = { a: 1, b: 2 }
-        const visited = []
-        const mutated = JSON.stringify(item, (key, value) => {
-          visited.push(key)
-          if (key === "a") item.b = 3
-          return value
-        })
-        const mapped = JSON.stringify(new Map([["x", 1]]), (key, value) =>
-          value instanceof Map ? Object.fromEntries(value) : value
-        )
-        const removed = { a: 1, b: 2 }
-        const deleted = JSON.stringify(removed, (key, value) => {
-          if (key === "a") removed.b = undefined
-          if (key === "b") visited.push(value === undefined ? "missing" : "present")
-          return value
-        })
-        return { mutated, mapped, deleted, visited }
-      `),
-    ).toEqual({
-      mutated: '{"a":1,"b":3}',
-      mapped: '{"x":1}',
-      deleted: '{"a":1}',
-      visited: ["", "a", "b", "missing"],
-    })
-  })
-
-  test("stringify replacer arrays coerce, dedupe, and recursively filter object keys", async () => {
-    expect(
-      await value(`
-        return JSON.stringify(
-          { 1: "one", keep: { keep: 2, drop: 3 }, drop: 4, list: [{ keep: 5, drop: 6 }] },
-          ["keep", 1, "keep", null, {}, "list"],
-        )
-      `),
-    ).toBe('{"keep":{"keep":2},"1":"one","list":[{"keep":5}]}')
-  })
-
-  test("JSON callbacks settle async tool calls sequentially", async () => {
-    const calls: Array<number> = []
-    const transform = Tool.make({
-      description: "Transform a number",
-      input: Schema.Number,
-      output: Schema.Number,
-      run: (input) =>
-        Effect.sync(() => {
-          calls.push(input)
-          return input * 10
-        }),
-    })
-    const parse = await Effect.runPromise(
-      CodeMode.execute({
-        tools: { host: { transform } },
-        code: `return JSON.parse("[1,2]", async (key, item) => key === "" ? item : await tools.host.transform(item))`,
-      }),
-    )
-    expect(parse.ok && parse.value).toEqual([10, 20])
-    const stringify = await Effect.runPromise(
-      CodeMode.execute({
-        tools: { host: { transform } },
-        code: `return JSON.stringify([1,2], async (key, item) => key === "" ? item : await tools.host.transform(item))`,
-      }),
-    )
-    expect(stringify.ok && stringify.value).toBe("[10,20]")
-    expect(calls).toEqual([1, 2, 1, 2])
-  })
-
-  test("non-callable JSON callback arguments are ignored", async () => {
-    expect(await value(`return [JSON.parse("{\\"a\\":1}", 42), JSON.stringify({ a: 1 }, { nope: true })]`)).toEqual([
-      { a: 1 },
-      '{"a":1}',
-    ])
-    expect(await value(`return [JSON.parse("1", Boolean), JSON.stringify({ a: 1 }, String)]`)).toEqual([false, '""'])
-  })
-
-  test("supported global methods work as JSON callbacks", async () => {
-    expect(
-      await value(`return [JSON.parse("[1,2]", Number.isFinite), JSON.stringify({ a: 1 }, Number.isFinite)]`),
-    ).toEqual([false, "false"])
-  })
-
-  test("stringify replacers can prune values before the depth limit", async () => {
-    expect(
-      await value(`
-        let item = 1
-        for (let index = 0; index < 33; index++) item = { x: item }
-        let calls = 0
-        return JSON.stringify(item, (key, value) => ++calls === 34 ? undefined : value)
-      `),
-    ).toBe(`${'{"x":'.repeat(32)}{}${"}".repeat(32)}`)
-  })
-
-  test("stringify omits callable replacer results", async () => {
-    expect(
-      await value(`
-        return JSON.stringify({ object: 1, array: [1] }, (key, value) =>
-          key === "object" || key === "0" ? Number.isFinite : value
-        )
-      `),
-    ).toBe('{"array":[null]}')
-  })
-})
-
 describe("Date", () => {
   test("Date.now() returns a number", async () => {
     expect(await value(`return typeof Date.now()`)).toBe("number")

packages/core/src/plugin/sdk.ts

@@ -7,6 +7,14 @@ import { EventV2 } from "../event"
 
 export const Updated = EventV2.ephemeral({ type: "sdk.plugin.updated", schema: {} })
 
+export interface Store {
+  readonly plugins: Map<string, Plugin>
+}
+
+export const makeStore = (): Store => ({ plugins: new Map() })
+
+const defaultStore = makeStore()
+
 /**
  * Holds the plugins an embedder (the `@opencode-ai/sdk-next` host) contributes,
  * so `PluginSupervisor` can add them on every Location boot through the ordinary
@@ -14,9 +22,10 @@ export const Updated = EventV2.ephemeral({ type: "sdk.plugin.updated", schema: {
  * config. Registration publishes an unlocated update so every booted Location
  * reloads its plugin generation from the shared store.
  *
- * Each host-global layer owns one private store. Location graphs reuse that
- * layer through Effect's memoization, so separate hosts remain isolated while
- * every Location in one host sees the same registrations.
+ * The store is shared explicitly between the SDK construction graph and the
+ * embedded route graph because `LocationServiceMap` builds Location layers lazily
+ * in a nested graph. Each embedded SDK creates its own store, so instances do not
+ * see each other's contributions.
  */
 export interface Interface {
   readonly register: (plugin: Plugin) => Effect.Effect<void>
@@ -25,19 +34,26 @@ export interface Interface {
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/SdkPlugins") {}
 
-export const layer = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const events = yield* EventV2.Service
-    const plugins = new Map<string, Plugin>()
-    return Service.of({
-      register: (plugin) =>
+export const layerWithStore = (store: Store) =>
+  Layer.effect(
+    Service,
+    Effect.gen(function* () {
+      const events = yield* EventV2.Service
+      yield* Effect.addFinalizer(() =>
         Effect.sync(() => {
-          plugins.set(plugin.id, plugin)
-        }).pipe(Effect.andThen(events.publish(Updated, {})), Effect.asVoid),
-      all: () => [...plugins.values()],
-    })
-  }),
-)
+          store.plugins.clear()
+        }),
+      )
+      return Service.of({
+        register: (plugin) =>
+          Effect.sync(() => {
+            store.plugins.set(plugin.id, plugin)
+          }).pipe(Effect.andThen(events.publish(Updated, {})), Effect.asVoid),
+        all: () => [...store.plugins.values()],
+      })
+    }),
+  )
+
+export const layer = layerWithStore(defaultStore)
 
 export const node = makeGlobalNode({ service: Service, layer, deps: [EventV2.node] })

packages/core/src/session/compaction.ts

@@ -25,27 +25,20 @@ const SUMMARY_TEMPLATE = `Output exactly the Markdown structure shown inside <te
 - [constraints/preferences, decisions and why, important facts/assumptions, exact context needed to continue, or "(none)"]
 
 ## Work State
-### Completed
-- [finished work, verified facts, or changes made; otherwise "(none)"]
-
-### Active
-- [current work, partial changes, or investigation state; otherwise "(none)"]
-
-### Blocked
-- [blockers, failing commands, or unknowns; otherwise "(none)"]
+- Completed: [finished work, verified facts, or changes made; otherwise "(none)"]
+- Active: [current work, partial changes, or investigation state; otherwise "(none)"]
+- Blocked: [blockers, failing commands, or unknowns; otherwise "(none)"]
 
 ## Next Move
 1. [immediate concrete action, or "(none)"]
 2. [next action if known, or "(none)"]
-
-## Relevant Files
-- [file or directory path: why it matters, or "(none)"]
 </template>
 
 Rules:
 - Keep every section, even when empty.
 - Use terse bullets, not prose paragraphs.
 - Preserve exact file paths, symbols, commands, error strings, URLs, and identifiers when known.
+- Put relevant files and symbols inside the section where they matter; do not add extra sections.
 - Do not mention the summary process or that context was compacted.`
 
 type Settings = {

packages/core/src/session/runner/to-llm-message.ts

@@ -120,12 +120,12 @@ const assistant = (message: SessionMessage.Assistant, model: ModelV2.Ref) => {
   const content = message.content.flatMap((item): ContentPart[] => {
     if (item.type === "text") return [{ type: "text", text: item.text }]
     if (item.type === "reasoning")
-      return reuseProviderMetadata
+      return sameModel
         ? [
             {
               type: "reasoning",
               text: item.text,
-              providerMetadata: providerMetadata(model.providerID, item.state),
+              providerMetadata: reuseProviderMetadata ? providerMetadata(model.providerID, item.state) : undefined,
             },
           ]
         : item.text.length > 0

packages/core/src/tool/execute.ts

@@ -43,15 +43,20 @@ export interface Registration {
   readonly group?: string
 }
 
+export interface CodeModeTools {
+  [name: string]: Tool.Definition<never> | CodeModeTools
+}
+
 export const create = (options: {
   readonly registrations: ReadonlyMap<string, Registration>
   readonly current: (name: string) => Registration | undefined
+  readonly tools: CodeModeTools
 }) => {
   const runtime = (
     invoke: (name: string, registration: Registration, input: unknown) => Effect.Effect<unknown, unknown>,
     hooks?: CodeMode.ToolCallHooks,
   ) => {
-    const tools: Record<string, Tool.Definition<never> | Record<string, Tool.Definition<never>>> = {}
+    const tools = cloneTools(options.tools)
     for (const [name, registration] of options.registrations) {
       const child = definition(name, registration.tool)
       const value = Tool.make({
@@ -163,6 +168,15 @@ export const create = (options: {
   })
 }
 
+function cloneTools(tools: CodeModeTools): CodeModeTools {
+  return Object.assign(
+    Object.create(null),
+    Object.fromEntries(
+      Object.entries(tools).map(([name, value]) => [name, Tool.isDefinition(value) ? value : cloneTools(value)]),
+    ),
+  )
+}
+
 function displayInput(input: unknown): Record<string, unknown> | undefined {
   if (input === null || input === undefined) return
   if (typeof input !== "object" || Array.isArray(input)) return { input }

packages/core/src/tool/registry.ts

@@ -1,4 +1,5 @@
 export * as ToolRegistry from "./registry"
+export type { CodeModeTools } from "./execute"
 
 import { ToolOutput, type ToolCall, type ToolDefinition, type ToolResultValue } from "@opencode-ai/llm"
 import { Context, Effect, Layer, Scope } from "effect"
@@ -9,11 +10,12 @@ import { SessionMessage } from "../session/message"
 import { SessionSchema } from "../session/schema"
 import { ToolOutputStore } from "../tool-output-store"
 import { Wildcard } from "../util/wildcard"
-import { ExecuteTool } from "./execute"
+import { ExecuteTool, type CodeModeTools } from "./execute"
 import { definition, permission, registrationEntries, RegistrationError, settle, type AnyTool } from "./tool"
 import { Tools } from "./tools"
 import { ToolHooks } from "./hooks"
 import { makeLocationNode } from "../effect/app-node"
+import { LayerNode } from "../effect/layer-node"
 import { SessionError } from "@opencode-ai/schema/session-error"
 import { toSessionError } from "../session/to-session-error"
 
@@ -51,10 +53,20 @@ export interface Settlement {
 }
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/v2/ToolRegistry") {}
+class CodeModeCatalog extends Context.Service<CodeModeCatalog, { readonly tools: CodeModeTools }>()(
+  "@opencode/v2/CodeModeCatalog",
+) {}
+
+const codeModeCatalogNode = makeLocationNode({
+  service: CodeModeCatalog,
+  layer: Layer.succeed(CodeModeCatalog, CodeModeCatalog.of({ tools: {} })),
+  deps: [],
+})
 
 const registryLayer = Layer.effect(
   Service,
   Effect.gen(function* () {
+    const codeModeTools = (yield* CodeModeCatalog).tools
     const resources = yield* ToolOutputStore.Service
     const toolHooks = yield* ToolHooks.Service
     type Registration = {
@@ -204,11 +216,13 @@ const registryLayer = Layer.effect(
         }
         const direct = new Map(Array.from(registrations).filter(([, registration]) => !registration.deferred))
         const deferred = new Map(Array.from(registrations).filter(([, registration]) => registration.deferred))
+        const tools = Flag.CODEMODE_ENABLED ? codeModeTools : {}
         const execute =
-          deferred.size > 0 && !whollyDisabled("execute", input.permissions ?? [])
+          (deferred.size > 0 || Object.keys(tools).length > 0) && !whollyDisabled("execute", input.permissions ?? [])
             ? ExecuteTool.create({
                 registrations: deferred,
                 current: (name) => local.get(name)?.at(-1)?.registration,
+                tools,
               })
             : undefined
         return {
@@ -241,14 +255,18 @@ function whollyDisabled(action: string, rules: PermissionV2.Ruleset) {
   return rule?.resource === "*" && rule.effect === "deny"
 }
 
+export function codeModeReplacement(tools: CodeModeTools): LayerNode.Replacement {
+  return [codeModeCatalogNode, Layer.succeed(CodeModeCatalog, CodeModeCatalog.of({ tools }))]
+}
+
 export const node = makeLocationNode({
   service: Service,
   layer,
-  deps: [ToolOutputStore.node, ToolHooks.node],
+  deps: [ToolOutputStore.node, ToolHooks.node, codeModeCatalogNode],
 })
 
 export const toolsNode = makeLocationNode({
   service: Tools.Service,
   layer,
-  deps: [ToolOutputStore.node, ToolHooks.node],
+  deps: [ToolOutputStore.node, ToolHooks.node, codeModeCatalogNode],
 })

packages/core/test/location-layer.test.ts

@@ -12,7 +12,6 @@ import { LayerNode } from "@opencode-ai/core/effect/layer-node"
 import { LocationServiceMap } from "@opencode-ai/core/location-services"
 import { Location } from "@opencode-ai/core/location"
 import { PluginV2 } from "@opencode-ai/core/plugin"
-import { SdkPlugins } from "@opencode-ai/core/plugin/sdk"
 import { PluginSupervisor } from "@opencode-ai/core/plugin/supervisor"
 import { ModelV2 } from "@opencode-ai/core/model"
 import { ProjectV2 } from "@opencode-ai/core/project"
@@ -29,43 +28,8 @@ import { Reference } from "../src/reference"
 import { ToolRegistry } from "../src/tool/registry"
 
 const it = testEffect(AppNodeBuilder.build(LayerNode.group([Database.node, EventV2.node, LocationServiceMap.node])))
-const itWithSdk = testEffect(
-  AppNodeBuilder.build(LayerNode.group([Database.node, EventV2.node, SdkPlugins.node, LocationServiceMap.node])),
-)
 
 describe("LocationServiceMap", () => {
-  itWithSdk.live("preserves embedded SDK plugins after Location eviction", () =>
-    Effect.acquireRelease(
-      Effect.promise(() => tmpdir()),
-      (dir) => Effect.promise(() => dir[Symbol.asyncDispose]()),
-    ).pipe(
-      Effect.flatMap((dir) =>
-        Effect.gen(function* () {
-          const sdk = yield* SdkPlugins.Service
-          const locations = yield* LocationServiceMap.Service
-          const id = AgentV2.ID.make("persistent-sdk-agent")
-          const plugin = define({
-            id: "persistent-sdk-plugin",
-            effect: (ctx) => ctx.agent.transform((agents) => agents.update(id, () => {})),
-          })
-          yield* sdk.register(plugin)
-
-          const ref = Location.Ref.make({ directory: AbsolutePath.make(dir.path) })
-          const read = Effect.gen(function* () {
-            const supervisor = yield* PluginSupervisor.Service
-            yield* supervisor.ready
-            const agents = yield* AgentV2.Service
-            return yield* agents.get(id)
-          })
-
-          expect(yield* read.pipe(Effect.scoped, Effect.provide(locations.get(ref)))).toBeDefined()
-          yield* locations.invalidate(ref)
-          expect(yield* read.pipe(Effect.scoped, Effect.provide(locations.get(ref)))).toBeDefined()
-        }),
-      ),
-    ),
-  )
-
   it.live("applies ordered plugin config operations during boot", () =>
     Effect.acquireRelease(
       Effect.promise(() => tmpdir()),

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

@@ -52,15 +52,6 @@ const it = testEffect(
   ),
 )
 
-test("compaction prompt preserves detailed work state and relevant files", () => {
-  const prompt = SessionCompaction.buildPrompt({ context: ["conversation history"] })
-
-  expect(prompt).toContain("## Work State\n### Completed")
-  expect(prompt).toContain("### Active")
-  expect(prompt).toContain("### Blocked")
-  expect(prompt).toContain("## Relevant Files")
-})
-
 test("compaction describes tool media without embedding base64", () => {
   const base64 = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAAB"
   const serialized = SessionCompaction.serializeToolContent([
@@ -83,14 +74,13 @@ test("compaction prompt requires the checkpoint headings in order", () => {
     "## Objective",
     "## Important Details",
     "## Work State",
-    "### Completed",
-    "### Active",
-    "### Blocked",
     "## Next Move",
-    "## Relevant Files",
   ])
   expect(prompt).toContain("one or two brief sentences")
   expect(prompt).toContain("constraints/preferences, decisions and why")
+  expect(prompt).toContain("Completed:")
+  expect(prompt).toContain("Active:")
+  expect(prompt).toContain("Blocked:")
   expect(prompt).toContain("immediate concrete action")
   expect(prompt).toContain("next action if known")
   expect(prompt).toContain("Keep every section, even when empty.")

packages/core/test/session-runner-message.test.ts

@@ -461,7 +461,7 @@ Recent work
     ])
   })
 
-  test("lowers failed assistant reasoning to text", () => {
+  test("drops provider-native continuation metadata from failed assistant turns", () => {
     const messages = toLLMMessages(
       [
         SessionMessage.Assistant.make({
@@ -501,7 +501,7 @@ Recent work
     )
 
     expect(messages[0]?.content).toEqual([
-      { type: "text", text: "Partial thought" },
+      { type: "reasoning", text: "Partial thought", providerMetadata: undefined },
       {
         type: "tool-call",
         id: "hosted-failed",

packages/core/test/session-runner-tool-registry.test.ts

@@ -30,6 +30,27 @@ const outputStore = Layer.mock(ToolOutputStore.Service, {
 })
 const registryLayer = AppNodeBuilder.build(ToolRegistry.node, [[ToolOutputStore.node, outputStore]])
 const it = testEffect(registryLayer)
+const codeModeTools: ToolRegistry.CodeModeTools = {
+  opencode: {
+    v2: {
+      health: {
+        get: {
+          _tag: "CodeModeTool" as const,
+          description: "Get server health",
+          input: Schema.Struct({}),
+          output: Schema.Struct({ healthy: Schema.Boolean }),
+          run: () => Effect.succeed({ healthy: true }),
+        },
+      },
+    },
+  },
+}
+const codeModeIt = testEffect(
+  AppNodeBuilder.build(ToolRegistry.node, [
+    [ToolOutputStore.node, outputStore],
+    ToolRegistry.codeModeReplacement(codeModeTools),
+  ]),
+)
 const identity = {
   agent: AgentV2.ID.make("build"),
   assistantMessageID: SessionMessage.ID.make("msg_registry"),
@@ -53,6 +74,50 @@ const make = (permission?: string) => {
 }
 
 describe("ToolRegistry", () => {
+  codeModeIt.effect("includes host Code Mode trees without hosted tool registration", () =>
+    Effect.gen(function* () {
+      const service = yield* ToolRegistry.Service
+      const definitions = yield* toolDefinitions(service)
+      expect(definitions.map((tool) => tool.name)).toEqual(["execute"])
+      expect(definitions[0]?.description).toContain("tools.opencode.v2.health.get")
+
+      expect(
+        yield* executeTool(service, {
+          sessionID,
+          ...identity,
+          call: {
+            type: "tool-call",
+            id: "call-opencode-health",
+            name: "execute",
+            input: { code: "return await tools.opencode.v2.health.get({})" },
+          },
+        }),
+      ).toEqual({ type: "text", value: '{\n  "healthy": true\n}' })
+    }),
+  )
+
+  codeModeIt.effect("keeps host Code Mode trees immutable while merging deferred tools", () =>
+    Effect.gen(function* () {
+      const service = yield* ToolRegistry.Service
+      yield* service.register({ echo: make() }, { group: "opencode", deferred: true })
+
+      expect((yield* toolDefinitions(service))[0]?.description).toContain("tools.opencode.echo")
+      expect((yield* toolDefinitions(service))[0]?.description).toContain("tools.opencode.echo")
+      expect(
+        yield* executeTool(service, {
+          sessionID,
+          ...identity,
+          call: {
+            type: "tool-call",
+            id: "call-opencode-echo",
+            name: "execute",
+            input: { code: 'return await tools.opencode.echo({ text: "hello" })' },
+          },
+        }),
+      ).toEqual({ type: "text", value: '{\n  "text": "hello"\n}' })
+    }),
+  )
+
   it.effect("filters disabled tools with edit aliases and ordered wildcard precedence", () =>
     Effect.gen(function* () {
       const service = yield* ToolRegistry.Service

packages/llm/src/provider-error.ts

@@ -6,7 +6,6 @@ const patterns = [
   /input is too long for requested model/i,
   /exceeds the context window/i,
   /input token count.*exceeds the maximum/i,
-  /tokens in request more than max tokens allowed/i,
   /maximum prompt length is \d+/i,
   /reduce the length of the messages/i,
   /maximum context length is \d+ tokens/i,

packages/llm/test/provider-error.test.ts

@@ -1,8 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { isContextOverflow } from "../src"
-
-describe("provider error classification", () => {
-  test("classifies Z.AI GLM token limit messages as context overflow", () => {
-    expect(isContextOverflow("tokens in request more than max tokens allowed")).toBe(true)
-  })
-})

packages/opencode/test/session/message-v2.test.ts

@@ -1448,7 +1448,6 @@ describe("session.message-v2.fromError", () => {
       "prompt is too long: 213462 tokens > 200000 maximum",
       "Your input exceeds the context window of this model",
       "The input token count (1196265) exceeds the maximum number of tokens allowed (1048575)",
-      "tokens in request more than max tokens allowed",
       "Please reduce the length of the messages or completion",
       "400 status code (no body)",
       "413 status code (no body)",

packages/protocol/src/client.ts

@@ -61,7 +61,6 @@ export const groupNames = {
 } as const
 
 export const endpointNames = {
-  "debug.location.evict": "evictLocation",
   "session.messages": "list",
   "integration.connect.key": "connectKey",
   "integration.connect.oauth": "connectOauth",

packages/protocol/src/groups/debug.ts

@@ -1,7 +1,6 @@
 import { Location } from "@opencode-ai/schema/location"
 import { Schema } from "effect"
-import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi"
-import { LocationQuery, locationQueryOpenApi } from "./location.js"
+import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi"
 
 export const DebugGroup = HttpApiGroup.make("server.debug")
   .add(
@@ -15,18 +14,4 @@ export const DebugGroup = HttpApiGroup.make("server.debug")
       }),
     ),
   )
-  .add(
-    HttpApiEndpoint.delete("debug.location.evict", "/api/debug/location", {
-      query: LocationQuery,
-      success: HttpApiSchema.NoContent,
-    })
-      .annotateMerge(locationQueryOpenApi)
-      .annotateMerge(
-        OpenApi.annotations({
-          identifier: "v2.debug.location.evict",
-          summary: "Evict a loaded location",
-          description: "Dispose the requested location's cached services so its next use boots them fresh.",
-        }),
-      ),
-  )
   .annotateMerge(OpenApi.annotations({ title: "debug" }))

packages/sdk-next/src/opencode.ts

@@ -1,23 +1,47 @@
 import { OpenCode } from "@opencode-ai/client/effect"
+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 { PermissionSaved } from "@opencode-ai/core/permission/saved"
 import { SdkPlugins } from "@opencode-ai/core/plugin/sdk"
+import { Project } from "@opencode-ai/core/project"
 import { createEmbeddedRoutes } from "@opencode-ai/server/routes"
-import { Context, Effect, Layer, ManagedRuntime } from "effect"
-import { FetchHttpClient, HttpEffect, HttpRouter, HttpServer } from "effect/unstable/http"
+import { Context, Effect, Layer, Scope } from "effect"
+import { FetchHttpClient, HttpRouter, HttpServer } from "effect/unstable/http"
 
 export const create = Effect.fn("OpenCode.create")(function* () {
-  const runtime = yield* Effect.acquireRelease(
-    Effect.sync(() => ManagedRuntime.make(createEmbeddedRoutes().pipe(Layer.provide(HttpServer.layerServices)))),
-    (runtime) => runtime.disposeEffect,
+  const scope = yield* Scope.Scope
+  const memoMap = yield* Layer.makeMemoMap
+  const sdkPlugins = SdkPlugins.makeStore()
+  const context = yield* Layer.buildWithMemoMap(
+    AppNodeBuilder.build(LayerNode.group([EventV2.node, PermissionSaved.node, Project.node, SdkPlugins.node]), [
+      [SdkPlugins.node, SdkPlugins.layerWithStore(sdkPlugins)],
+    ]),
+    memoMap,
+    scope,
   )
-  const context = yield* runtime.contextEffect
   const plugins = Context.get(context, SdkPlugins.Service)
-  const router = Context.get(context, HttpRouter.HttpRouter)
-  const handler = HttpEffect.toWebHandler(router.asHttpEffect())
-  const fetch = Object.assign((input: RequestInfo | URL, init?: RequestInit) => handler(new Request(input, init)), {
+  const permissions = Context.get(context, PermissionSaved.Service)
+  const project = Context.get(context, Project.Service)
+  const web = yield* Effect.acquireRelease(
+    Effect.sync(() =>
+      HttpRouter.toWebHandler(
+        createEmbeddedRoutes(sdkPlugins).pipe(
+          HttpRouter.provideRequest(Layer.succeed(PermissionSaved.Service, permissions)),
+          HttpRouter.provideRequest(Layer.succeed(Project.Service, project)),
+          Layer.provide(HttpServer.layerServices),
+        ),
+        { disableLogger: true, memoMap },
+      ),
+    ),
+    (web) => Effect.promise(web.dispose),
+  )
+  const fetch = Object.assign((input: RequestInfo | URL, init?: RequestInit) => web.handler(new Request(input, init)), {
     preconnect: () => undefined,
   }) satisfies typeof globalThis.fetch
   const client = yield* OpenCode.make({ baseUrl: "http://opencode.local" }).pipe(
-    Effect.provide(FetchHttpClient.layer.pipe(Layer.provide(Layer.succeed(FetchHttpClient.Fetch, fetch)), Layer.fresh)),
+    Effect.provide(FetchHttpClient.layer),
+    Effect.provideService(FetchHttpClient.Fetch, fetch),
   )
   return {
     ...client,

packages/sdk-next/test/embedded.test.ts

@@ -105,50 +105,6 @@ it.live(
   25_000,
 )
 
-it.live(
-  "preserves SDK plugins across Location eviction",
-  () =>
-    withEmbedded("opencode-embedded-plugin-eviction-", (fixture) =>
-      Effect.gen(function* () {
-        const opencode = yield* fixture.sdk.OpenCode.create()
-        const ref = location(fixture)
-        const connected = yield* Latch.make(false)
-        const booted = yield* Deferred.make<void>()
-        // The rebooted Location commits its second plugin generation.
-        const recommitted = yield* Deferred.make<void>()
-        const generations = yield* Ref.make(0)
-        const id = `evicted-sdk-${crypto.randomUUID()}`
-
-        yield* opencode.events.subscribe().pipe(
-          Stream.runForEach((event) => {
-            if (event.type === "server.connected") return connected.open
-            if (event.type !== "plugin.updated" || event.location?.directory !== fixture.directory) return Effect.void
-            return Ref.updateAndGet(generations, (total) => total + 1).pipe(
-              Effect.flatMap((total) => {
-                if (total === 1) return Deferred.succeed(booted, undefined)
-                if (total === 2) return Deferred.succeed(recommitted, undefined)
-                return Effect.void
-              }),
-              Effect.asVoid,
-            )
-          }),
-          Effect.forkScoped,
-        )
-        yield* connected.await
-        yield* opencode.plugin({ id, effect: () => Effect.void })
-
-        yield* opencode.plugin.list({ location: ref })
-        yield* Deferred.await(booted).pipe(Effect.timeout("5 seconds"))
-        yield* opencode.debug.evictLocation({ location: ref })
-        yield* opencode.plugin.list({ location: ref })
-        yield* Deferred.await(recommitted).pipe(Effect.timeout("5 seconds"))
-
-        expect((yield* opencode.plugin.list({ location: ref })).data.map((plugin) => String(plugin.id))).toContain(id)
-      }),
-    ),
-  15_000,
-)
-
 it.live(
   "keeps SDK plugin registration isolated between embedded hosts",
   () =>

packages/server/src/handlers/debug.ts

@@ -2,24 +2,13 @@ import { LocationServiceMap } from "@opencode-ai/core/location-service-map"
 import { Effect, Option, RcMap } from "effect"
 import { HttpApiBuilder } from "effect/unstable/httpapi"
 import { Api } from "../api"
-import { requestRef } from "../location"
 
 export const DebugHandler = HttpApiBuilder.group(Api, "server.debug", (handlers) =>
-  handlers
-    .handle(
-      "debug.location",
-      Effect.fn(function* () {
-        const locations = Option.getOrThrow(yield* Effect.serviceOption(LocationServiceMap.Service))
-        return Array.from(yield* RcMap.keys(locations.rcMap))
-      }),
-    )
-    .handle(
-      "debug.location.evict",
-      Effect.fn(function* (ctx) {
-        const locations = Option.getOrThrow(yield* Effect.serviceOption(LocationServiceMap.Service))
-        // Resolve through requestRef so the key matches the shape the location
-        // middleware cached the services under.
-        yield* locations.invalidate(requestRef(ctx.request))
-      }),
-    ),
+  handlers.handle(
+    "debug.location",
+    Effect.fn(function* () {
+      const locations = Option.getOrThrow(yield* Effect.serviceOption(LocationServiceMap.Service))
+      return Array.from(yield* RcMap.keys(locations.rcMap))
+    }),
+  ),
 )

packages/server/src/process.ts

@@ -1,11 +1,16 @@
 export * as ServerProcess from "./process"
 
 import { NodeHttpClient, NodeHttpServer } from "@effect/platform-node"
+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 { PermissionSaved } from "@opencode-ai/core/permission/saved"
+import { Project } from "@opencode-ai/core/project"
 import { HealthGroup } from "@opencode-ai/protocol/groups/health"
 import { Context, Effect, Layer, Option } from "effect"
-import { HttpClient, HttpClientRequest, HttpMiddleware, HttpRouter, HttpServer } from "effect/unstable/http"
+import { HttpClient, HttpClientRequest, HttpRouter, HttpServer } from "effect/unstable/http"
 import { HttpApi, HttpApiClient } from "effect/unstable/httpapi"
-import { createServer } from "node:http"
+import { createServer, type Server } from "node:http"
 import { ServerAuth } from "./auth"
 import { createRoutes } from "./routes"
 
@@ -13,6 +18,7 @@ export type Options = {
   readonly hostname: string
   readonly port: Option.Option<number>
   readonly password: string
+  readonly replacements?: (server: Server) => LayerNode.Replacements
 }
 
 const ReadinessApi = HttpApi.make("readiness").add(HealthGroup)
@@ -37,22 +43,22 @@ export const start = Effect.fn("ServerProcess.start")(function* (options: Option
 })
 
 function listen(options: Options) {
-  if (Option.isSome(options.port)) return bind(options.hostname, options.port.value, options.password)
+  if (Option.isSome(options.port)) return bind(options, options.port.value)
   const next = (port: number): ReturnType<typeof bind> =>
-    bind(options.hostname, port, options.password).pipe(
+    bind(options, port).pipe(
       Effect.catch((error) => (port === 65_535 ? Effect.fail(error) : next(port + 1))),
     )
   return next(4096)
 }
 
-function bind(hostname: string, port: number, password: string) {
+function bind(options: Options, port: number) {
   const server = createServer()
   return Layer.build(
-    createRoutes(password).pipe(
-      Layer.flatMap((context) =>
-        HttpServer.serve(Context.get(context, HttpRouter.HttpRouter).asHttpEffect(), HttpMiddleware.logger),
-      ),
-      Layer.provideMerge(NodeHttpServer.layer(() => server, { port, host: hostname })),
+    HttpRouter.serve(createRoutes(options.password, options.replacements?.(server)), {
+      disableListenLog: true,
+    }).pipe(
+      Layer.provideMerge(NodeHttpServer.layer(() => server, { port, host: options.hostname })),
+      Layer.provide(AppNodeBuilder.build(LayerNode.group([Credential.node, PermissionSaved.node, Project.node]))),
     ),
   ).pipe(
     Effect.tap(() => Effect.addFinalizer(() => Effect.sync(() => server.closeAllConnections()))),

packages/server/src/routes.ts

@@ -19,7 +19,7 @@ import { SdkPlugins } from "@opencode-ai/core/plugin/sdk"
 import { ToolOutputStore } from "@opencode-ai/core/tool-output-store"
 import { HttpRouter, HttpServer } from "effect/unstable/http"
 import { HttpApiBuilder } from "effect/unstable/httpapi"
-import { Context, Effect, Layer, Option } from "effect"
+import { Effect, Layer, Option } from "effect"
 import { Api } from "./api"
 import { ServerAuth } from "./auth"
 import { handlers } from "./handlers"
@@ -40,7 +40,6 @@ const applicationServices = LayerNode.group([
   Project.node,
   SessionV2.node,
   PluginRuntime.providerNode,
-  SdkPlugins.node,
   PermissionSaved.node,
   PtyTicket.node,
   Credential.node,
@@ -48,30 +47,42 @@ const applicationServices = LayerNode.group([
   LocationServiceMap.node,
 ])
 
-export function createRoutes(password?: string) {
+export function createRoutes(password?: string, replacements: LayerNode.Replacements = []) {
   return makeRoutes(
     password
       ? ServerAuth.Config.configLayer({ username: "opencode", password: Option.some(password) })
       : ServerAuth.Config.layer,
+    undefined,
+    replacements,
   )
 }
 
-export function createEmbeddedRoutes() {
-  return makeRoutes(ServerAuth.Config.configLayer({ username: "opencode", password: Option.none() }))
+export function createEmbeddedRoutes(sdkPlugins?: SdkPlugins.Store, replacements: LayerNode.Replacements = []) {
+  return makeRoutes(
+    ServerAuth.Config.configLayer({ username: "opencode", password: Option.none() }),
+    sdkPlugins,
+    replacements,
+  )
 }
 
-function makeRoutes<AuthError, AuthServices>(auth: Layer.Layer<ServerAuth.Config, AuthError, AuthServices>) {
+function makeRoutes<AuthError, AuthServices>(
+  auth: Layer.Layer<ServerAuth.Config, AuthError, AuthServices>,
+  sdkPlugins?: SdkPlugins.Store,
+  hostReplacements: LayerNode.Replacements = [],
+) {
   const pluginRuntimeCell = PluginRuntime.makeCell()
   const replacements: LayerNode.Replacements = [
     [SessionExecution.node, SessionExecutionLocal.node],
     [PluginRuntime.node, PluginRuntime.layerWithCell(pluginRuntimeCell)],
     [PluginRuntime.providerNode, PluginRuntime.providerNodeWithCell(pluginRuntimeCell)],
+    ...(sdkPlugins ? [[SdkPlugins.node, SdkPlugins.layerWithStore(sdkPlugins)] as const] : []),
+    ...hostReplacements,
   ]
   const serviceLayer = simulateEnabled()
     ? Layer.unwrap(
         Effect.gen(function* () {
-          const { simulationReplacements, startDriveServer } = yield* Effect.promise(
-            () => import("@opencode-ai/simulation/backend"),
+          const { simulationReplacements, startDriveServer } = yield* Effect.promise(() =>
+            import("@opencode-ai/simulation/backend"),
           )
           if (driveEnabled()) startDriveServer()
           return AppNodeBuilder.build(applicationServices, [
@@ -82,24 +93,16 @@ function makeRoutes<AuthError, AuthServices>(auth: Layer.Layer<ServerAuth.Config
       )
     : AppNodeBuilder.build(applicationServices, replacements)
 
-  return serviceLayer.pipe(
-    Layer.flatMap((context) => {
-      const services = Layer.succeedContext(context)
-      const requestServices = Layer.succeedContext(Context.pick(PermissionSaved.Service, Project.Service)(context))
-      return HttpApiBuilder.layer(Api, { openapiPath: "/openapi.json" }).pipe(
-        Layer.provide(handlers.pipe(Layer.provide(services))),
-        Layer.provide(formLocationLayer),
-        Layer.provide(sessionLocationLayer),
-        Layer.provide(layer),
-        Layer.provide(authorizationLayer),
-        Layer.provide(schemaErrorLayer),
-        Layer.provide(auth),
-        Layer.provide(Observability.layer),
-        HttpRouter.provideRequest(requestServices),
-        Layer.provideMerge(services),
-        Layer.provideMerge(HttpRouter.layer),
-      )
-    }),
+  return HttpApiBuilder.layer(Api, { openapiPath: "/openapi.json" }).pipe(
+    Layer.provide(handlers.pipe(Layer.provide(serviceLayer))),
+    Layer.provide(formLocationLayer),
+    Layer.provide(sessionLocationLayer),
+    Layer.provide(layer),
+    Layer.provide(authorizationLayer),
+    Layer.provide(schemaErrorLayer),
+    Layer.provide(auth),
+    Layer.provide(serviceLayer),
+    Layer.provide(Observability.layer),
   )
 }
 
@@ -113,4 +116,5 @@ function driveEnabled() {
 
 export const routes = createRoutes()
 
-export const webHandler = () => HttpRouter.toWebHandler(routes.pipe(Layer.provide(HttpServer.layerServices)))
+export const webHandler = () =>
+  HttpRouter.toWebHandler(routes.pipe(Layer.provide(HttpServer.layerServices)))

packages/simulation/src/backend/control.ts

@@ -25,10 +25,10 @@ import { SimulationNetwork } from "./network"
 type ControlSocket = Bun.ServerWebSocket<{ unsubscribe?: () => void }>
 
 function parseRequest(input: string | Buffer) {
-  return SimulationProtocol.Backend.decodeRequest(JSON.parse(typeof input === "string" ? input : input.toString()))
+  return SimulationProtocol.JsonRpc.decodeRequest(JSON.parse(typeof input === "string" ? input : input.toString()))
 }
 
-async function handle(socket: ControlSocket, request: SimulationProtocol.Backend.Request): Promise<unknown> {
+async function handle(socket: ControlSocket, request: SimulationProtocol.JsonRpc.Request): Promise<unknown> {
   switch (request.method) {
     case "llm.attach": {
       socket.data.unsubscribe?.()
@@ -38,22 +38,23 @@ async function handle(socket: ControlSocket, request: SimulationProtocol.Backend
       return { attached: true }
     }
     case "llm.chunk": {
+      const params = await SimulationProtocol.Backend.decodeChunkParams(request.params)
       await Effect.runPromise(
         SimulationLLMExchange.push(
-          request.params.id,
-          request.params.items.map((item) => ({ type: "item", item }) as const),
+          params.id,
+          params.items.map((item) => ({ type: "item", item }) as const),
         ),
       )
       return { ok: true }
     }
     case "llm.finish": {
-      await Effect.runPromise(
-        SimulationLLMExchange.push(request.params.id, [{ type: "finish", reason: request.params.reason }]),
-      )
+      const params = await SimulationProtocol.Backend.decodeFinishParams(request.params)
+      await Effect.runPromise(SimulationLLMExchange.push(params.id, [{ type: "finish", reason: params.reason }]))
       return { ok: true }
     }
     case "llm.disconnect": {
-      await Effect.runPromise(SimulationLLMExchange.disconnect(request.params.id))
+      const params = await SimulationProtocol.Backend.decodeDisconnectParams(request.params)
+      await Effect.runPromise(SimulationLLMExchange.disconnect(params.id))
       return { ok: true }
     }
     case "llm.pending":
@@ -61,6 +62,7 @@ async function handle(socket: ControlSocket, request: SimulationProtocol.Backend
     case "network.log":
       return { entries: SimulationNetwork.log() }
   }
+  throw new Error(`Unknown simulation control method: ${request.method}`)
 }
 
 export function start(endpoint: string) {
@@ -77,7 +79,7 @@ export function start(endpoint: string) {
         socket.data.unsubscribe?.()
       },
       async message(socket, message) {
-        let request: SimulationProtocol.Backend.Request | undefined
+        let request: SimulationProtocol.JsonRpc.Request | undefined
         try {
           request = parseRequest(message)
           const result = await handle(socket, request)

packages/simulation/src/frontend/actions.ts

@@ -47,7 +47,7 @@ function hit(renderer: CliRenderer, renderable: Renderable) {
 /**
  * Builds the harness the simulation server drives.
  *
- * When the renderer is the headless simulation renderer, its TestRendererSetup
+ * When the renderer is the fake simulation renderer, its TestRendererSetup
  * provides the supported testing APIs. For the visible terminal renderer the
  * harness falls back to `requestRender` + `idle` and reading the private
  * `currentRenderBuffer`.

packages/simulation/src/frontend/renderer.ts

@@ -4,7 +4,7 @@ import { createTestRenderer, type TestRendererSetup } from "@opentui/core/testin
 const setups = new WeakMap<CliRenderer, TestRendererSetup>()
 
 /**
- * Creates the headless simulation renderer: a real CliRenderer backed by an
+ * Creates the fake simulation renderer: a real CliRenderer backed by an
  * in-memory screen buffer instead of a terminal. The TestRendererSetup is
  * kept module-side (keyed by renderer) so the harness can use the supported
  * testing APIs without app code carrying it around.

packages/simulation/src/frontend/server.ts

@@ -7,20 +7,29 @@ export interface Server {
   readonly stop: () => void
 }
 
-function parseRequest(input: string | Buffer) {
-  return SimulationProtocol.Frontend.decodeRequest(JSON.parse(typeof input === "string" ? input : input.toString()))
+function actionParam(params: unknown) {
+  return SimulationProtocol.Frontend.decodeActionParams(params).action
 }
 
-async function handle(harness: Harness, request: SimulationProtocol.Frontend.Request, headless: boolean) {
+function parseRequest(input: string | Buffer) {
+  return SimulationProtocol.JsonRpc.decodeRequest(JSON.parse(typeof input === "string" ? input : input.toString()))
+}
+
+async function handle(harness: Harness, request: SimulationProtocol.JsonRpc.Request) {
   switch (request.method) {
     case "ui.state": {
-      if (headless) await harness.renderOnce()
       const result = SimulationActions.state(harness)
       SimulationTrace.add("ui.state", { elements: result.elements.length, actions: result.actions.length })
       return result
     }
     case "ui.action":
-      return SimulationActions.execute(harness, request.params.action)
+      return SimulationActions.execute(harness, actionParam(request.params))
+    case "ui.render": {
+      await harness.renderOnce()
+      const result = SimulationActions.state(harness)
+      SimulationTrace.add("ui.render", { elements: result.elements.length, actions: result.actions.length })
+      return result
+    }
     case "trace.list":
       return { records: SimulationTrace.list() }
     case "trace.clear":
@@ -29,9 +38,10 @@ async function handle(harness: Harness, request: SimulationProtocol.Frontend.Req
     case "trace.export":
       return SimulationTrace.exportTrace()
   }
+  throw new Error(`Unknown simulation method: ${request.method}`)
 }
 
-export function start(harness: Harness, endpoint: string, headless: boolean): Server {
+export function start(harness: Harness, endpoint: string): Server {
   const url = new URL(endpoint)
   const server = Bun.serve<{ readonly drive: true }>({
     hostname: url.hostname,
@@ -48,10 +58,10 @@ export function start(harness: Harness, endpoint: string, headless: boolean): Se
         SimulationTrace.add("control.disconnect")
       },
       async message(socket, message) {
-        let request: SimulationProtocol.Frontend.Request | undefined
+        let request: SimulationProtocol.JsonRpc.Request | undefined
         try {
           request = parseRequest(message)
-          const result = await handle(harness, request, headless)
+          const result = await handle(harness, request)
           const next = SimulationProtocol.JsonRpc.success(request.id, result)
           if (next) socket.send(JSON.stringify(next))
         } catch (error) {

packages/simulation/src/frontend/simulation.ts

@@ -7,18 +7,19 @@ import { SimulationServer } from "./server"
 /**
  * Drive-mode renderer entry point.
  *
- * Creates the renderer (headless when OPENCODE_DRIVE_RENDERER=headless, the normal
+ * Creates the renderer (fake when OPENCODE_DRIVE_RENDERER=fake, the normal
  * visible renderer otherwise) and starts the UI control
  * server against it. The server stops when the renderer is destroyed, so the
  * caller only manages the renderer lifecycle.
  */
 export async function create(options: CliRendererConfig): Promise<CliRenderer> {
-  const headless = process.env.OPENCODE_DRIVE_RENDERER === "headless"
-  const renderer = headless ? await SimulationRenderer.create(options) : await createCliRenderer(options)
+  const renderer =
+    process.env.OPENCODE_DRIVE_RENDERER === "fake"
+      ? await SimulationRenderer.create(options)
+      : await createCliRenderer(options)
   const server = SimulationServer.start(
     SimulationActions.createHarness(renderer),
     DriveManifest.resolve().endpoints.ui,
-    headless,
   )
   process.stderr.write(`opencode drive ui websocket: ${server.url}\n`)
   renderer.once("destroy", () => server.stop())

packages/simulation/src/protocol/index.ts

@@ -4,12 +4,9 @@ const JsonRpcID = Schema.Union([Schema.String, Schema.Number, Schema.Null])
 type Json = Schema.Schema.Type<typeof Schema.Json>
 
 export namespace JsonRpc {
-  export const RequestFields = {
+  export const Request = Schema.Struct({
     jsonrpc: Schema.Literal("2.0"),
     id: Schema.optional(JsonRpcID),
-  }
-  export const Request = Schema.Struct({
-    ...RequestFields,
     method: Schema.String,
     params: Schema.optional(Schema.Json),
   })
@@ -95,16 +92,7 @@ export namespace Frontend {
 
   export const ActionParams = Schema.Struct({ action: Action })
   export interface ActionParams extends Schema.Schema.Type<typeof ActionParams> {}
-
-  export const Request = Schema.Union([
-    Schema.Struct({ ...JsonRpc.RequestFields, method: Schema.Literal("ui.action"), params: ActionParams }),
-    Schema.Struct({
-      ...JsonRpc.RequestFields,
-      method: Schema.Literals(["ui.state", "trace.list", "trace.clear", "trace.export"]),
-    }),
-  ])
-  export type Request = Schema.Schema.Type<typeof Request>
-  export const decodeRequest = Schema.decodeUnknownSync(Request)
+  export const decodeActionParams = Schema.decodeUnknownSync(ActionParams)
 
   export const TraceRecord = Schema.Struct({
     id: Schema.Number,
@@ -142,18 +130,6 @@ export namespace Backend {
   export const DisconnectParams = Schema.Struct({ id: Schema.String })
   export interface DisconnectParams extends Schema.Schema.Type<typeof DisconnectParams> {}
 
-  export const Request = Schema.Union([
-    Schema.Struct({ ...JsonRpc.RequestFields, method: Schema.Literal("llm.chunk"), params: ChunkParams }),
-    Schema.Struct({ ...JsonRpc.RequestFields, method: Schema.Literal("llm.finish"), params: FinishParams }),
-    Schema.Struct({ ...JsonRpc.RequestFields, method: Schema.Literal("llm.disconnect"), params: DisconnectParams }),
-    Schema.Struct({
-      ...JsonRpc.RequestFields,
-      method: Schema.Literals(["llm.attach", "llm.pending", "network.log"]),
-    }),
-  ])
-  export type Request = Schema.Schema.Type<typeof Request>
-  export const decodeRequest = Schema.decodeUnknownSync(Request)
-
   export const OpenedExchange = Schema.Struct({ id: Schema.String, url: Schema.String, body: Schema.Json })
   export interface OpenedExchange extends Schema.Schema.Type<typeof OpenedExchange> {}
 
@@ -165,6 +141,9 @@ export namespace Backend {
   })
   export interface NetworkLogEntry extends Schema.Schema.Type<typeof NetworkLogEntry> {}
 
+  export const decodeChunkParams = Schema.decodeUnknownPromise(ChunkParams)
+  export const decodeFinishParams = Schema.decodeUnknownPromise(FinishParams)
+  export const decodeDisconnectParams = Schema.decodeUnknownPromise(DisconnectParams)
 }
 
 export * as SimulationProtocol from "./index"