refactor(core): decouple state domains from config

Signed-off-by: Major Hayden <major@mhtx.net>

packages/cli/script/build.ts

@@ -109,7 +109,7 @@ for (const item of targets) {
     external: ["node-gyp"],
     format: "esm",
     minify: true,
-    sourcemap: "inline",
+    sourcemap: Script.channel === "dev" || Script.channel === "local" ? "inline" : "none",
     splitting: true,
     compile: {
       autoloadBunfig: false,

packages/cli/script/service-smoke.ts

@@ -1,8 +1,9 @@
 #!/usr/bin/env bun
 
+import { NodeFileSystem } from "@effect/platform-node"
 import { Service } from "@opencode-ai/client/effect/service"
 import { ServiceStatus } from "@opencode-ai/protocol/groups/health"
-import { Schema } from "effect"
+import { Effect, Schema } from "effect"
 import fs from "node:fs/promises"
 import os from "node:os"
 import path from "node:path"
@@ -63,28 +64,22 @@ try {
   })
   if (unauthorizedOpenApi.status !== 401)
     throw new Error("Compiled service exposed application routes without authentication")
-  const unauthorizedStop = await fetch(new URL("/api/service/stop", info.url), {
+  const stopRoute = await fetch(new URL("/api/service/stop", info.url), {
     method: "POST",
-    headers: { "content-type": "application/json" },
+    headers: { ...headers, "content-type": "application/json" },
     body: JSON.stringify({ instanceID: info.id }),
     signal: AbortSignal.timeout(5_000),
   })
-  if (unauthorizedStop.status !== 401) throw new Error("Compiled service accepted unauthenticated stop")
+  if (stopRoute.status !== 404) throw new Error("Compiled service exposed the removed HTTP stop route")
 
   const winner = processes.find((process) => process.pid === info.pid)
   const loser = processes.find((process) => process.pid !== info.pid)
   if (!winner || !loser) throw new Error("Compiled contenders did not elect one registered owner")
   if (!(await exitsWithin(loser, 10_000))) throw new Error("Losing compiled contender did not exit")
 
-  const stopped = await Schema.decodeUnknownPromise(ServiceStatus.StopResponse)(
-    await fetch(new URL("/api/service/stop", info.url), {
-      method: "POST",
-      headers: { ...headers, "content-type": "application/json" },
-      body: JSON.stringify({ instanceID: info.id }),
-      signal: AbortSignal.timeout(5_000),
-    }).then((response) => response.json()),
+  await Effect.runPromise(
+    Service.stop({ file: registration }).pipe(Effect.provide(NodeFileSystem.layer)),
   )
-  if (!stopped.accepted) throw new Error("Compiled service rejected exact-instance stop")
   if (!(await exitsWithin(winner, 10_000))) throw new Error("Compiled service did not stop")
   for (let attempt = 0; attempt < 200 && (await Bun.file(registration).exists()); attempt++) await Bun.sleep(25)
   if (await Bun.file(registration).exists()) throw new Error("Compiled service registration was not removed")

packages/cli/src/commands/handlers/default.ts

@@ -4,7 +4,7 @@ import { run } from "@opencode-ai/tui"
 import { Commands } from "../commands"
 import { Runtime } from "../../framework/runtime"
 import { Config } from "../../config"
-import { Context, Effect, FileSystem, Option } from "effect"
+import { Context, Effect, FileSystem, Option, Queue } from "effect"
 import { ServerConnection } from "../../services/server-connection"
 import { Updater } from "../../services/updater"
 import { UpdatePreflight } from "../../services/update-preflight"
@@ -19,11 +19,21 @@ export default Runtime.handler(Commands, (input) =>
     if (requestedDirectory !== undefined) process.chdir(requestedDirectory)
     const preflight = UpdatePreflight.make()
     yield* Effect.addFinalizer(() => Effect.promise(() => preflight.close()))
+    const serviceStarts = yield* Queue.unbounded<{
+      readonly reason: "missing" | "version-mismatch"
+      readonly previousVersion?: string
+    }>()
+    yield* Queue.take(serviceStarts).pipe(
+      Effect.flatMap((event) => Effect.logInfo("background service starting", event)),
+      Effect.forever,
+      Effect.forkScoped,
+    )
     const server = yield* ServerConnection.resolve({
       server: requestedServer,
       standalone: input.standalone,
       mismatch: "replace",
       onStart: (reason, previousVersion) => {
+        Queue.offerUnsafe(serviceStarts, { reason, previousVersion })
         if (reason === "version-mismatch" && preflight.begin(previousVersion)) return
         process.stderr.write(
           reason === "version-mismatch"

packages/cli/src/index.ts

@@ -59,6 +59,21 @@ const Handlers = Runtime.handlers(Commands, {
 
 Effect.gen(function* () {
   yield* Heap.listen
+  const runFork = Effect.runForkWith(yield* Effect.context<never>())
+  const uncaughtException = (cause: Error, origin: "uncaughtException" | "unhandledRejection") => {
+    runFork(Effect.logError("uncaught exception", { cause, origin }))
+  }
+  const unhandledRejection = (cause: unknown) => {
+    runFork(Effect.logError("unhandled rejection", { cause }))
+  }
+  process.on("uncaughtException", uncaughtException)
+  process.on("unhandledRejection", unhandledRejection)
+  yield* Effect.addFinalizer(() =>
+    Effect.sync(() => {
+      process.off("uncaughtException", uncaughtException)
+      process.off("unhandledRejection", unhandledRejection)
+    }),
+  )
   yield* Effect.logInfo("cli starting", {
     version: OPENCODE_VERSION,
     channel: OPENCODE_CHANNEL,
@@ -67,6 +82,12 @@ Effect.gen(function* () {
   })
   return yield* Runtime.run(Commands, Handlers, { version: OPENCODE_VERSION })
 }).pipe(
+  Effect.catchCause((cause) =>
+    Effect.logError("cli process failed", {
+      cause,
+      args: process.argv.slice(2),
+    }).pipe(Effect.andThen(Effect.failCause(cause))),
+  ),
   Effect.annotateLogs({ role: "cli" }),
   Effect.provide(Config.layer),
   Effect.provide(Updater.layer),

packages/cli/src/server-process.ts

@@ -117,7 +117,6 @@ const processEffect = Effect.fnUntraced(function* (options: Options) {
         serviceOptions === undefined
           ? undefined
           : {
-              instanceID,
               onListen: (address, shutdown) =>
                 Effect.gen(function* () {
                   if (!config.password) yield* ServiceConfig.password(password)
@@ -180,18 +179,36 @@ const register = Effect.fnUntraced(function* (
     password,
   }
   const encoded = yield* encodeInfo(info)
-  const current = fs.readFileString(file).pipe(
-    Effect.flatMap(decodeInfo),
-    Effect.orElseSucceed(() => undefined),
-  )
-  const owns = (found: Info | undefined) =>
-    found?.id === info.id &&
+  const current = fs.readFileString(file).pipe(Effect.flatMap(decodeInfo))
+  const owns = (found: Info) =>
+    found.id === info.id &&
     found.version === info.version &&
     found.url === info.url &&
     found.pid === info.pid &&
     found.password === info.password
   yield* fs.writeFileString(temp, encoded, { mode: 0o600 }).pipe(Effect.andThen(fs.rename(temp, file)))
   yield* current.pipe(
+    Effect.catchCause((cause) =>
+      Effect.logWarning("managed service registration check failed; shutting down", {
+        cause,
+        serviceID: id,
+        servicePID: process.pid,
+        registration: file,
+      }).pipe(Effect.andThen(Effect.failCause(cause))),
+    ),
+    Effect.tap((found) =>
+      owns(found)
+        ? Effect.void
+        : Effect.logWarning("managed service registration replaced; shutting down", {
+            serviceID: id,
+            servicePID: process.pid,
+            registration: file,
+            observedServiceID: found.id,
+            observedServicePID: found.pid,
+            observedVersion: found.version,
+            observedURL: found.url,
+          }),
+    ),
     Effect.filterOrFail(owns),
     Effect.repeat(Schedule.spaced("5 seconds")),
     Effect.ignore,

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

@@ -41,13 +41,8 @@ import type { Config } from "@opencode-ai/schema/config"
 export type Endpoint0_0Output = { readonly healthy: true; readonly version: string; readonly pid: number }
 export type HealthGetOperation<E = never> = () => Effect.Effect<Endpoint0_0Output, E>
 
-export type Endpoint0_1Input = { readonly instanceID: string }
-export type Endpoint0_1Output = { readonly accepted: boolean }
-export type HealthStopOperation<E = never> = (input: Endpoint0_1Input) => Effect.Effect<Endpoint0_1Output, E>
-
 export interface HealthApi<E = never> {
   readonly get: HealthGetOperation<E>
-  readonly stop: HealthStopOperation<E>
 }
 
 export type Endpoint1_0Output = { readonly urls: ReadonlyArray<string> }

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

@@ -6,8 +6,6 @@ import { HttpApiClient } from "effect/unstable/httpapi"
 import { ClientApi } from "../../contract"
 import type {
   Endpoint0_0Output,
-  Endpoint0_1Input,
-  Endpoint0_1Output,
   Endpoint1_0Output,
   Endpoint2_0Input,
   Endpoint2_0Output,
@@ -248,12 +246,7 @@ const preserveStream =
 const Endpoint0_0 = (raw: RawClient["server.health"]) => () =>
   preserveEffect<Endpoint0_0Output>()(raw["health.get"]({}).pipe(Effect.mapError(mapClientError)))
 
-const Endpoint0_1 = (raw: RawClient["server.health"]) => (input: Endpoint0_1Input) =>
-  preserveEffect<Endpoint0_1Output>()(
-    raw["health.stop"]({ payload: { instanceID: input["instanceID"] } }).pipe(Effect.mapError(mapClientError)),
-  )
-
-const adaptGroup0 = (raw: RawClient["server.health"]) => ({ get: Endpoint0_0(raw), stop: Endpoint0_1(raw) })
+const adaptGroup0 = (raw: RawClient["server.health"]) => ({ get: Endpoint0_0(raw) })
 
 const Endpoint1_0 = (raw: RawClient["server.server"]) => () =>
   preserveEffect<Endpoint1_0Output>()(raw["server.get"]({}).pipe(Effect.mapError(mapClientError)))

packages/client/src/effect/service.ts

@@ -87,7 +87,7 @@ export const ensure = Effect.fn("service.ensure")(function* (options: EnsureOpti
       }
       if (timeouts.count >= 3) {
         yield* announce("missing")
-        yield* evict(info, options, timing)
+        yield* terminate(info, options, timing)
         timeouts = undefined
         lastSpawn = Date.now() - spawnDelay
       }
@@ -100,7 +100,7 @@ export const ensure = Effect.fn("service.ensure")(function* (options: EnsureOpti
         return yield* Effect.fail(new Error("Background service failed to start"))
       if (compatible) return Option.none<LocalService>()
       yield* announce("version-mismatch", service.version)
-      yield* kill(service, options, timing).pipe(Effect.ignore)
+      yield* terminate(service.info, options, timing).pipe(Effect.ignore)
       lastSpawn = 0
       return Option.none<LocalService>()
     } else if (lastSpawn === 0 && info !== undefined) lastSpawn = Date.now()
@@ -133,8 +133,8 @@ export const ensure = Effect.fn("service.ensure")(function* (options: EnsureOpti
 
 /** Stop the registered local service. */
 export const stop = Effect.fn("service.stop")(function* (options: StopOptions = {}) {
-  const existing = yield* find(options)
-  if (existing !== undefined) yield* kill(existing, options, defaultEnsureTiming)
+  const info = yield* read(options.file)
+  if (info !== undefined) yield* terminate(info, options, defaultEnsureTiming)
 })
 
 function fallback() {
@@ -243,12 +243,6 @@ const registered = Effect.fnUntraced(function* (file?: string, allowLegacy = fal
   return { info, ...(yield* probeResult(info, allowLegacy, timeout)) }
 })
 
-// Health-checked lookup without the version gate: lifecycle operations must be
-// able to see (and replace or stop) a server from a different version.
-const find = Effect.fnUntraced(function* (options: { readonly file?: string }) {
-  return (yield* registered(options.file, true)).service
-})
-
 // 50ms cadence bounded at ~5s, shared by stop escalation and each ensure
 // discovery window.
 const poll = (timing: EnsureTiming) =>
@@ -269,59 +263,21 @@ function same(left: Info, right: Info) {
   return left.id === right.id && left.version === right.version && left.url === right.url && left.pid === right.pid
 }
 
-const evict = Effect.fnUntraced(function* (info: Info, options: { readonly file?: string }, timing: EnsureTiming) {
+const terminate = Effect.fnUntraced(function* (info: Info, options: { readonly file?: string }, timing: EnsureTiming) {
   const current = yield* read(options.file)
   if (current === undefined || !same(current, info)) return
   yield* signal(info.pid, "SIGTERM")
   const done = yield* stopped(info.pid).pipe(Effect.retry(poll(timing)), Effect.option)
-  if (Option.isSome(done)) return
-
+  if (Option.isNone(done)) {
+    const latest = yield* read(options.file)
+    if (latest === undefined || !same(latest, info)) return
+    yield* signal(info.pid, "SIGKILL")
+    yield* stopped(info.pid).pipe(Effect.retry(poll(timing)))
+  }
   const latest = yield* read(options.file)
   if (latest === undefined || !same(latest, info)) return
-  yield* signal(info.pid, "SIGKILL")
-  yield* stopped(info.pid).pipe(Effect.retry(poll(timing)))
-})
-
-const kill = Effect.fnUntraced(function* (
-  service: LocalService,
-  options: { readonly file?: string },
-  timing: EnsureTiming,
-) {
-  const requested = yield* requestStop(service, timing.requestTimeout)
-  if (requested === "rejected") return
-  if (requested === "unsupported") {
-    // A stale registration may point at a reused PID. Authenticate again
-    // immediately before the legacy signal fallback.
-    const current = yield* find(options)
-    if (current === undefined || !same(current.info, service.info)) return
-    yield* signal(service.info.pid, "SIGTERM")
-  }
-  const done = yield* stopped(service.info.pid).pipe(Effect.retry(poll(timing)), Effect.option)
-  if (Option.isSome(done)) return
-
-  const latest = yield* find(options)
-  if (latest === undefined || !same(latest.info, service.info)) return
-  yield* signal(service.info.pid, "SIGKILL")
-  yield* stopped(service.info.pid).pipe(Effect.retry(poll(timing)))
-})
-
-const decodeStopResponse = Schema.decodeUnknownOption(ServiceStatus.StopResponse)
-
-const requestStop = Effect.fnUntraced(function* (service: LocalService, timeout = defaultEnsureTiming.requestTimeout) {
-  if (service.info.id === undefined || service.legacy) return "unsupported" as const
-  const response = yield* Effect.tryPromise(() =>
-    fetch(new URL("/api/service/stop", service.info.url), {
-      method: "POST",
-      headers: { ...headers(service.endpoint), "content-type": "application/json" },
-      body: JSON.stringify({ instanceID: service.info.id }),
-      signal: AbortSignal.timeout(timeout),
-    }),
-  ).pipe(Effect.option, Effect.map(Option.getOrUndefined))
-  if (response === undefined || response.status === 404 || response.status === 405) return "unsupported" as const
-  const body = yield* Effect.tryPromise(() => response.json()).pipe(Effect.option, Effect.map(Option.getOrUndefined))
-  const decoded = decodeStopResponse(body)
-  if (!response.ok || Option.isNone(decoded) || !decoded.value.accepted) return "rejected" as const
-  return "accepted" as const
+  const fs = yield* FileSystem.FileSystem
+  yield* fs.remove(options.file ?? fallback()).pipe(Effect.ignore)
 })
 
 /** Effect-based local service lifecycle operations. */

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

@@ -1,7 +1,5 @@
 import type {
   HealthGetOutput,
-  HealthStopInput,
-  HealthStopOutput,
   ServerGetOutput,
   LocationGetInput,
   LocationGetOutput,
@@ -367,18 +365,6 @@ export function make(options: ClientOptions) {
           { method: "GET", path: `/api/health`, successStatus: 200, declaredStatuses: [401, 400], empty: false },
           requestOptions,
         ),
-      stop: (input: HealthStopInput, requestOptions?: RequestOptions) =>
-        request<HealthStopOutput>(
-          {
-            method: "POST",
-            path: `/api/service/stop`,
-            body: { instanceID: input["instanceID"] },
-            successStatus: 200,
-            declaredStatuses: [401, 400],
-            empty: false,
-          },
-          requestOptions,
-        ),
     },
     server: {
       get: (requestOptions?: RequestOptions) =>

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

@@ -2,8 +2,6 @@ export type JsonValue = null | boolean | number | string | Array<JsonValue> | {
 
 export type ServiceHealth = { healthy: true; version: string; pid: number }
 
-export type ServiceStopResponse = { accepted: boolean }
-
 export type ModelRef = { id: string; providerID: string; variant?: string }
 
 export type ProviderSettings = { [x: string]: any }
@@ -2273,10 +2271,6 @@ export const isWorktreeError = (value: unknown): value is WorktreeError =>
 
 export type HealthGetOutput = ServiceHealth
 
-export type HealthStopInput = { readonly instanceID: { readonly instanceID: string }["instanceID"] }
-
-export type HealthStopOutput = ServiceStopResponse
-
 export type ServerGetOutput = { urls: Array<string> }
 
 export type LocationGetInput = {

packages/client/src/promise/service.ts

@@ -1,4 +1,4 @@
-import { readFile } from "node:fs/promises"
+import { readFile, rm } from "node:fs/promises"
 import { homedir } from "node:os"
 import { join } from "node:path"
 import type { DiscoverOptions, Endpoint, Info, EnsureOptions, StopOptions } from "../service.js"
@@ -10,7 +10,7 @@ import {
 } from "../service-contender.js"
 import { defaultEnsureTiming, ensureTiming, type EnsureTiming } from "../service-timing.js"
 import { matchesVersion } from "../service-version.js"
-import type { ServiceHealth, ServiceStopResponse } from "./generated/types.js"
+import type { ServiceHealth } from "./generated/types.js"
 
 export * from "../service.js"
 
@@ -68,7 +68,7 @@ export async function ensure(options: EnsureOptions = {}): Promise<Endpoint> {
         }
         if (timeouts.count >= 3) {
           announce("missing")
-          await evict(registration.info, options, timing)
+          await terminate(registration.info, options, timing)
           timeouts = undefined
           lastSpawn = Date.now() - spawnDelay
         }
@@ -82,7 +82,7 @@ export async function ensure(options: EnsureOptions = {}): Promise<Endpoint> {
         if (compatible && service.state === "failed") throw new Error("Background service failed to start")
         if (!compatible) {
           announce("version-mismatch", service.version)
-          await kill(service, options, timing).catch(() => undefined)
+          await terminate(service.info, options, timing).catch(() => undefined)
           lastSpawn = 0
         }
       } else {
@@ -110,8 +110,8 @@ export async function ensure(options: EnsureOptions = {}): Promise<Endpoint> {
 
 /** Stop the registered local service. */
 export async function stop(options: StopOptions = {}) {
-  const existing = await find(options)
-  if (existing !== undefined) await kill(existing, options, defaultEnsureTiming)
+  const info = await read(options.file)
+  if (info !== undefined) await terminate(info, options, defaultEnsureTiming)
 }
 
 function fallback() {
@@ -199,10 +199,6 @@ async function registered(file?: string, allowLegacy = false, timeout?: number)
   return { info, ...(await probeResult(info, allowLegacy, timeout)) }
 }
 
-async function find(options: { readonly file?: string }) {
-  return (await registered(options.file, true)).service
-}
-
 function signal(pid: number, name: NodeJS.Signals) {
   try {
     process.kill(pid, name)
@@ -230,47 +226,19 @@ function same(left: Info, right: Info) {
   return left.id === right.id && left.version === right.version && left.url === right.url && left.pid === right.pid
 }
 
-async function evict(info: Info, options: { readonly file?: string }, timing: EnsureTiming) {
+async function terminate(info: Info, options: { readonly file?: string }, timing: EnsureTiming) {
   const current = await read(options.file)
   if (current === undefined || !same(current, info)) return
   signal(info.pid, "SIGTERM")
-  if (await waitUntilStopped(info.pid, timing)) return
-
+  if (!(await waitUntilStopped(info.pid, timing))) {
+    const latest = await read(options.file)
+    if (latest === undefined || !same(latest, info)) return
+    signal(info.pid, "SIGKILL")
+    if (!(await waitUntilStopped(info.pid, timing))) throw new Error(`Server process ${info.pid} is still running`)
+  }
   const latest = await read(options.file)
   if (latest === undefined || !same(latest, info)) return
-  signal(info.pid, "SIGKILL")
-  if (!(await waitUntilStopped(info.pid, timing))) throw new Error(`Server process ${info.pid} is still running`)
-}
-
-async function kill(service: LocalService, options: { readonly file?: string }, timing: EnsureTiming) {
-  const requested = await requestStop(service, timing.requestTimeout)
-  if (requested === "rejected") return
-  if (requested === "unsupported") {
-    const current = await find(options)
-    if (current === undefined || !same(current.info, service.info)) return
-    signal(service.info.pid, "SIGTERM")
-  }
-  if (await waitUntilStopped(service.info.pid, timing)) return
-
-  const latest = await find(options)
-  if (latest === undefined || !same(latest.info, service.info)) return
-  signal(service.info.pid, "SIGKILL")
-  if (!(await waitUntilStopped(service.info.pid, timing)))
-    throw new Error(`Server process ${service.info.pid} is still running`)
-}
-
-async function requestStop(service: LocalService, timeout = defaultEnsureTiming.requestTimeout) {
-  if (service.info.id === undefined || service.legacy) return "unsupported" as const
-  const response = await fetch(new URL("/api/service/stop", service.info.url), {
-    method: "POST",
-    headers: { ...headers(service.endpoint), "content-type": "application/json" },
-    body: JSON.stringify({ instanceID: service.info.id }),
-    signal: AbortSignal.timeout(timeout),
-  }).catch(() => undefined)
-  if (response === undefined || response.status === 404 || response.status === 405) return "unsupported" as const
-  const body = (await response.json().catch(() => undefined)) as ServiceStopResponse | undefined
-  if (!response.ok || body?.accepted !== true) return "rejected" as const
-  return "accepted" as const
+  await rm(options.file ?? fallback(), { force: true })
 }
 
 function delay(milliseconds: number) {

packages/client/test/fixture/service.ts

@@ -28,7 +28,7 @@ if (mode === "delayed" || mode === "delayed-failed" || mode === "coordinated" ||
 
 let requests = 0
 let version = "test"
-if (mode === "old" || mode === "reject-stop") version = "old"
+if (mode === "old") version = "old"
 if (mode === "incompatible") version = "1.9.0"
 if (mode === "compatible" || mode === "delayed-compatible") version = "2.1.0-next.1"
 const id = crypto.randomUUID()
@@ -36,17 +36,6 @@ const server = Bun.serve({
   port: 0,
   async fetch(request) {
     const pathname = new URL(request.url).pathname
-    if (pathname === "/api/service/stop" && mode === "reject-stop") {
-      await appendFile(registration + ".stop-attempts", process.pid + "\n")
-      return Response.json({ accepted: false })
-    }
-    if (pathname === "/api/service/stop" && mode === "graceful") {
-      const body = await request.json()
-      if (typeof body !== "object" || body === null || body.instanceID !== id) return Response.json({ accepted: false })
-      await writeFile(registration + ".stop", JSON.stringify(body))
-      setTimeout(shutdown, 25)
-      return Response.json({ accepted: true })
-    }
     if (pathname !== "/api/health") return new Response(null, { status: 404 })
     requests += 1
     if (mode === "starting") await writeFile(registration + ".health-request", "")
@@ -63,7 +52,7 @@ const server = Bun.serve({
     if (mode === "starting" && !(await Bun.file(registration + ".release").exists()))
       return Response.json({ healthy: true, version, pid: process.pid }, { status: 503 })
     if (mode === "failed-owner") return Response.json({ healthy: true, version, pid: process.pid }, { status: 500 })
-    if (mode === "starting" || mode === "graceful" || mode === "reject-stop")
+    if (mode === "starting" || mode === "graceful")
       return Response.json({ healthy: true, version, pid: process.pid })
     return Response.json({ healthy: true, version, pid: process.pid })
   },
@@ -81,9 +70,10 @@ await writeFile(
 )
 await rename(registration + ".tmp", registration)
 
-function shutdown() {
+async function shutdown(signal?: NodeJS.Signals) {
+  if (signal !== undefined) await writeFile(registration + ".signal", signal)
   server.stop(true)
   process.exit()
 }
-process.on("SIGTERM", shutdown)
-process.on("SIGINT", shutdown)
+process.on("SIGTERM", () => void shutdown("SIGTERM"))
+process.on("SIGINT", () => void shutdown("SIGINT"))

packages/client/test/promise-service.test.ts

@@ -126,13 +126,13 @@ test("evicts an unresponsive registered service before starting its replacement"
   await waitForExit(replacement.pid)
 })
 
-test("requests graceful stop of the exact service instance", async () => {
+test("signals the registered service process", async () => {
   const registration = await setup("graceful")
-  const info = await Bun.file(registration).json()
 
   await Service.stop({ file: registration })
 
-  expect(await Bun.file(registration + ".stop").json()).toEqual({ instanceID: info.id })
+  expect(await Bun.file(registration + ".signal").text()).toBe("SIGTERM")
+  expect(await Bun.file(registration).exists()).toBe(false)
 })
 
 async function setup(mode: string) {

packages/client/test/promise.test.ts

@@ -191,22 +191,6 @@ test("integration connections optionally submit a form answer", async () => {
   expect(await requests[3].json()).toEqual({ methodID: "device" })
 })
 
-test("health.stop sends exact replacement identity", async () => {
-  let request: Request | undefined
-  const client = OpenCode.make({
-    baseUrl: "http://localhost:3000",
-    fetch: async (input, init) => {
-      request = input instanceof Request ? input : new Request(input, init)
-      return Response.json({ accepted: true })
-    },
-  })
-
-  expect(await client.health.stop({ instanceID: "instance" })).toEqual({ accepted: true })
-  expect(request?.method).toBe("POST")
-  expect(request?.url).toBe("http://localhost:3000/api/service/stop")
-  expect(await request?.json()).toEqual({ instanceID: "instance" })
-})
-
 test("MCP resource catalog uses the public HTTP contract", async () => {
   let request: Request | undefined
   const client = OpenCode.make({

packages/client/test/service.test.ts

@@ -143,40 +143,36 @@ test("evicts an unresponsive registered service before starting its replacement"
   await waitForExit(replacement.pid)
 })
 
-test("requests graceful stop of the exact service instance", async () => {
+test("signals an unresponsive registered service process", async () => {
   const directory = await temp()
   const registration = join(directory, "service.json")
-  const process = spawn(registration, "graceful")
+  const process = spawn(registration, "hanging")
   await waitForFile(registration)
-  const info = await Bun.file(registration).json()
 
   await run(Service.stop({ file: registration }))
   await process.exited
-  expect(await Bun.file(registration + ".stop").json()).toEqual({ instanceID: info.id })
+  expect(await Bun.file(registration + ".signal").text()).toBe("SIGTERM")
+  expect(await Bun.file(registration).exists()).toBe(false)
 })
 
-test("does not spawn contenders while an incompatible service rejects replacement", async () => {
+test("signals an incompatible service before starting its replacement", async () => {
   const directory = await temp()
   const registration = join(directory, "service.json")
-  const contender = join(directory, "contender.json")
-  const existing = spawn(registration, "reject-stop")
+  const existing = spawn(registration, "old")
   await waitForFile(registration)
-  const controller = new AbortController()
-  const starting = Effect.runPromise(
+  const endpoint = await run(
     ensure({
       file: registration,
       version: "test",
-      command: [process.execPath, fixture, contender, "record-start"],
-    }).pipe(Effect.provide(NodeFileSystem.layer)),
-    { signal: controller.signal },
+      command: [process.execPath, fixture, registration, "delayed", "10"],
+    }),
   )
+  const replacement = await Bun.file(registration).json()
 
-  await waitForLines(registration + ".stop-attempts", 2)
-  controller.abort()
-  await starting.catch(() => undefined)
-
-  expect(await Bun.file(contender + ".started").exists()).toBe(false)
-  expect(existing.exitCode).toBe(null)
+  expect(await existing.exited).toBe(0)
+  expect(endpoint.url).toBe(replacement.url)
+  process.kill(replacement.pid, "SIGTERM")
+  await waitForExit(replacement.pid)
 })
 
 test("a legacy health response is still replaced", async () => {
@@ -344,17 +340,6 @@ async function waitForFile(file: string) {
   throw new Error(`Timed out waiting for ${file}`)
 }
 
-async function waitForLines(file: string, count: number) {
-  for (let attempt = 0; attempt < 600; attempt++) {
-    const text = await Bun.file(file)
-      .text()
-      .catch(() => "")
-    if (text.trim().split("\n").length >= count) return
-    await Bun.sleep(5)
-  }
-  throw new Error(`Timed out waiting for ${count} lines in ${file}`)
-}
-
 async function health(url: string) {
   return fetch(new URL("/api/health", url), { signal: AbortSignal.timeout(1_000) }).then((response) => response.json())
 }

packages/core/src/config/normalize.ts

@@ -149,7 +149,7 @@ export function normalize(input: unknown): Result {
     "agents",
     migratedAgents,
     nativeAgents,
-    isRecord(input.agent) || isRecord(input.mode) || isRecord(input.agents),
+    migratedSmallModel !== undefined || isRecord(input.agent) || isRecord(input.mode) || isRecord(input.agents),
     diagnostics,
   )
 

packages/core/src/config/plugin/formatter.ts

@@ -0,0 +1,55 @@
+export * as ConfigFormatterPlugin from "./formatter.js"
+
+import { define } from "@opencode-ai/plugin/effect/plugin"
+import type { Entry } from "@opencode-ai/schema/config"
+import { Effect, Stream } from "effect"
+import { Config } from "../../config.js"
+import { Formatter } from "../../formatter.js"
+
+export const Plugin = define({
+  id: "opencode.config.formatter",
+  effect: Effect.fn(function* (ctx) {
+    const config = yield* Config.Service
+    const formatter = yield* Formatter.Service
+    const loaded = { entries: [] as Entry[] }
+    yield* ctx.event
+      .subscribe()
+      .pipe(
+        Stream.filter((event) => event.type === "config.updated"),
+        Stream.runForEach(() =>
+          config.entries().pipe(
+            Effect.tap((entries) => Effect.sync(() => (loaded.entries = entries))),
+            Effect.andThen(formatter.reload()),
+          ),
+        ),
+        Effect.forkScoped({ startImmediately: true }),
+      )
+    loaded.entries = yield* config.entries()
+    yield* formatter.transform((draft) => {
+      const configured = Config.latest(loaded.entries, "formatter")
+      if (configured === false) {
+        draft.clear()
+        return
+      }
+      if (configured === undefined) {
+        for (const item of draft.list()) if (item.builtIn) draft.remove(item.name)
+        return
+      }
+      if (configured === true) return
+      for (const [name, entry] of Object.entries(configured)) {
+        if (entry.disabled) {
+          draft.remove(name)
+          continue
+        }
+        const current = draft.get(name)
+        draft.set(name, {
+          name,
+          extensions: entry.extensions ?? current?.extensions ?? [],
+          environment: { ...current?.environment, ...entry.environment },
+          enabled:
+            current && !entry.command ? current.enabled : Effect.succeed(entry.command ? [...entry.command] : false),
+        })
+      }
+    })
+  }),
+})

packages/core/src/config/plugin/image.ts

@@ -0,0 +1,42 @@
+export * as ConfigImagePlugin from "./image.js"
+
+import { define } from "@opencode-ai/plugin/effect/plugin"
+import type { Entry } from "@opencode-ai/schema/config"
+import { Effect, Stream } from "effect"
+import { Config } from "../../config.js"
+import { Image } from "../../image.js"
+
+export const Plugin = define({
+  id: "opencode.config.image",
+  effect: Effect.fn(function* (ctx) {
+    const config = yield* Config.Service
+    const image = yield* Image.Service
+    const loaded = { entries: [] as Entry[] }
+    yield* ctx.event
+      .subscribe()
+      .pipe(
+        Stream.filter((event) => event.type === "config.updated"),
+        Stream.runForEach(() =>
+          config.entries().pipe(
+            Effect.tap((entries) => Effect.sync(() => (loaded.entries = entries))),
+            Effect.andThen(image.reload()),
+          ),
+        ),
+        Effect.forkScoped({ startImmediately: true }),
+      )
+    loaded.entries = yield* config.entries()
+    yield* image.transform((draft) => {
+      for (const entry of loaded.entries) {
+        if (entry.type !== "document" || !entry.info.media?.image) continue
+        draft.update((policy) => {
+          const configured = entry.info.media?.image
+          if (!configured) return
+          if (configured.auto_resize !== undefined) policy.autoResize = configured.auto_resize
+          if (configured.max_width !== undefined) policy.maxWidth = configured.max_width
+          if (configured.max_height !== undefined) policy.maxHeight = configured.max_height
+          if (configured.max_base64_bytes !== undefined) policy.maxBase64Bytes = configured.max_base64_bytes
+        })
+      }
+    })
+  }),
+})

packages/core/src/config/plugin/tool-output.ts

@@ -0,0 +1,37 @@
+export * as ConfigToolOutputPlugin from "./tool-output.js"
+
+import { define } from "@opencode-ai/plugin/effect/plugin"
+import type { Entry } from "@opencode-ai/schema/config"
+import { Effect, Stream } from "effect"
+import { Config } from "../../config.js"
+import { ToolOutput } from "../../tool-output.js"
+
+export const Plugin = define({
+  id: "opencode.config.tool-output",
+  effect: Effect.fn(function* (ctx) {
+    const config = yield* Config.Service
+    const output = yield* ToolOutput.Service
+    const loaded = { entries: [] as Entry[] }
+    yield* ctx.event
+      .subscribe()
+      .pipe(
+        Stream.filter((event) => event.type === "config.updated"),
+        Stream.runForEach(() =>
+          config.entries().pipe(
+            Effect.tap((entries) => Effect.sync(() => (loaded.entries = entries))),
+            Effect.andThen(output.reload()),
+          ),
+        ),
+        Effect.forkScoped({ startImmediately: true }),
+      )
+    loaded.entries = yield* config.entries()
+    yield* output.transform((draft) => {
+      const configured = Config.latest(loaded.entries, "tool_output")
+      if (!configured) return
+      draft.update((policy) => {
+        if (configured.max_lines !== undefined) policy.maxLines = configured.max_lines
+        if (configured.max_bytes !== undefined) policy.maxBytes = configured.max_bytes
+      })
+    })
+  }),
+})

packages/core/src/formatter.ts

@@ -8,11 +8,23 @@ import { FSUtil } from "@opencode-ai/util/fs-util"
 import { Npm } from "@opencode-ai/util/npm"
 import { AppProcess } from "@opencode-ai/util/process"
 import { Global } from "@opencode-ai/util/global"
-import { Config } from "./config.js"
 import { Location } from "./location.js"
 import { make, type Info } from "./formatter/builtins.js"
+import { State } from "./state.js"
 
-export interface Interface {
+type Data = {
+  readonly formatters: Map<string, Info>
+}
+
+export interface Draft {
+  readonly list: () => readonly Info[]
+  readonly get: (name: string) => Info | undefined
+  readonly set: (name: string, formatter: Info) => void
+  readonly remove: (name: string) => void
+  readonly clear: () => void
+}
+
+export interface Interface extends State.Transformable<Draft> {
   readonly file: (filepath: string) => Effect.Effect<boolean>
 }
 
@@ -21,66 +33,48 @@ export class Service extends Context.Service<Service, Interface>()("@opencode/v2
 const layer = Layer.effect(
   Service,
   Effect.gen(function* () {
-    const config = yield* Config.Service
     const fs = yield* FSUtil.Service
     const location = yield* Location.Service
     const npm = yield* Npm.Service
     const processes = yield* AppProcess.Service
     const global = yield* Global.Service
-    const commands = new Map<string, string[] | false>()
-    let formatters: Info[] = []
-
-    const load = yield* Effect.cached(
-      Effect.gen(function* () {
-        const configured = Config.latest(yield* config.entries(), "formatter")
-        if (!configured) {
-          yield* Effect.logInfo("all formatters are disabled")
-          return
-        }
-
-        const builtIns = make({
-          directory: location.directory,
-          worktree: location.project.directory,
-          fs,
-          npm,
-          processes,
-          bin: global.bin,
-        })
-        formatters = builtIns
-        if (configured === true) return
-
-        for (const [name, entry] of Object.entries(configured)) {
-          const index = formatters.findIndex((formatter) => formatter.name === name)
-          if (entry.disabled) {
-            if (index !== -1) formatters.splice(index, 1)
-            continue
-          }
-
-          const builtIn = builtIns.find((formatter) => formatter.name === name)
-          const formatter: Info = {
-            name,
-            extensions: entry.extensions ?? builtIn?.extensions ?? [],
-            environment: { ...builtIn?.environment, ...entry.environment },
-            enabled:
-              builtIn && !entry.command ? builtIn.enabled : Effect.succeed(entry.command ? [...entry.command] : false),
-          }
-          if (index === -1) formatters.push(formatter)
-          else formatters[index] = formatter
-        }
-      }).pipe(Effect.withSpan("Formatter.load")),
-    )
+    const commands = new WeakMap<Info, string[] | false>()
+    const builtIns = make({
+      directory: location.directory,
+      worktree: location.project.directory,
+      fs,
+      npm,
+      processes,
+      bin: global.bin,
+    })
+    const state = State.create<Data, Draft>({
+      name: "formatter",
+      initial: () => ({
+        formatters: new Map(builtIns.map((formatter) => [formatter.name, { ...formatter, builtIn: true }])),
+      }),
+      draft: (data) => ({
+        list: () => Array.from(data.formatters.values()),
+        get: (name) => data.formatters.get(name),
+        set: (name, formatter) => data.formatters.set(name, { ...formatter, name }),
+        remove: (name) => {
+          data.formatters.delete(name)
+        },
+        clear: () => data.formatters.clear(),
+      }),
+    })
 
     const command = Effect.fnUntraced(function* (formatter: Info) {
-      const cached = commands.get(formatter.name)
+      const cached = commands.get(formatter)
       if (cached !== undefined) return cached
       const result = yield* formatter.enabled
-      if (result !== false) commands.set(formatter.name, result)
+      if (result !== false) commands.set(formatter, result)
       return result
     })
 
     const file = Effect.fn("Formatter.file")(function* (filepath: string) {
-      yield* load
-      const matching = formatters.filter((formatter) => formatter.extensions.includes(path.extname(filepath)))
+      const matching = Array.from(state.get().formatters.values()).filter((formatter) =>
+        formatter.extensions.includes(path.extname(filepath)),
+      )
 
       for (const formatter of matching) {
         const enabled = yield* command(formatter)
@@ -118,12 +112,12 @@ const layer = Layer.effect(
       return false
     })
 
-    return Service.of({ file })
+    return Service.of({ file, transform: state.transform, reload: state.reload })
   }),
 )
 
 export const node = makeLocationNode({
   service: Service,
   layer,
-  deps: [Config.node, FSUtil.node, Location.node, Npm.node, AppProcess.node, Global.node],
+  deps: [FSUtil.node, Location.node, Npm.node, AppProcess.node, Global.node],
 })

packages/core/src/formatter/builtins.ts

@@ -7,6 +7,7 @@ import { which } from "../util/which.js"
 
 export interface Info {
   readonly name: string
+  readonly builtIn?: boolean
   readonly environment?: Record<string, string>
   readonly extensions: readonly string[]
   readonly enabled: Effect.Effect<string[] | false>

packages/core/src/image.ts

@@ -2,8 +2,9 @@ export * as Image from "./image.js"
 
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
 import { Context, Effect, Layer, Schema } from "effect"
-import { Config } from "./config.js"
 import { FileSystem } from "./filesystem.js"
+import type { DeepMutable } from "./schema.js"
+import { State } from "./state.js"
 
 export class ResizerUnavailableError extends Schema.TaggedError<ResizerUnavailableError>()(
   "Image.ResizerUnavailableError",
@@ -32,7 +33,18 @@ export class SizeError extends Schema.TaggedError<SizeError>()("Image.SizeError"
   }
 }
 
-export interface Interface {
+export interface Policy {
+  readonly autoResize: boolean
+  readonly maxWidth: number
+  readonly maxHeight: number
+  readonly maxBase64Bytes: number
+}
+
+export interface Draft {
+  readonly update: (update: (policy: DeepMutable<Policy>) => void) => void
+}
+
+export interface Interface extends State.Transformable<Draft> {
   readonly normalize: (
     resource: string,
     content: FileSystem.Content & { readonly encoding: "base64" },
@@ -47,7 +59,18 @@ export class Service extends Context.Service<Service, Interface>()("@opencode/Im
 const layer = Layer.effect(
   Service,
   Effect.gen(function* () {
-    const config = yield* Config.Service
+    const state = State.create<DeepMutable<Policy>, Draft>({
+      name: "image",
+      initial: () => ({
+        autoResize: true,
+        maxWidth: 2_000,
+        maxHeight: 2_000,
+        maxBase64Bytes: 5 * 1024 * 1024,
+      }),
+      draft: (policy) => ({
+        update: (update) => update(policy),
+      }),
+    })
     const loadAdapter = yield* Effect.cached(
       Effect.tryPromise({
         try: () => import("./image/photon.js"),
@@ -58,22 +81,17 @@ const layer = Layer.effect(
       resource: string,
       content: FileSystem.Content & { readonly encoding: "base64" },
     ) {
-      const image = Object.assign(
-        {},
-        ...(yield* config.entries()).flatMap((entry) =>
-          entry.type === "document" && entry.info.media?.image ? [entry.info.media.image] : [],
-        ),
-      )
+      const policy = state.get()
       const normalize = yield* loadAdapter
       return yield* normalize(resource, content, {
-        autoResize: image.auto_resize ?? true,
-        maxWidth: image.max_width ?? 2_000,
-        maxHeight: image.max_height ?? 2_000,
-        maxBase64Bytes: image.max_base64_bytes ?? 5 * 1024 * 1024,
+        autoResize: policy.autoResize,
+        maxWidth: policy.maxWidth,
+        maxHeight: policy.maxHeight,
+        maxBase64Bytes: policy.maxBase64Bytes,
       })
     })
-    return Service.of({ normalize })
+    return Service.of({ normalize, transform: state.transform, reload: state.reload })
   }),
 )
 
-export const node = makeLocationNode({ service: Service, layer, deps: [Config.node] })
+export const node = makeLocationNode({ service: Service, layer, deps: [] })

packages/core/src/plugin.ts

@@ -9,6 +9,7 @@ import { Agent } from "./agent.js"
 import { AISDK } from "./aisdk.js"
 import { Catalog } from "./catalog.js"
 import { Command } from "./command.js"
+import { Formatter } from "./formatter.js"
 import { Bus } from "./bus.js"
 import { Integration } from "./integration.js"
 import { MCP } from "./mcp/index.js"
@@ -154,6 +155,7 @@ export const node = makeLocationNode({
     AISDK.node,
     Catalog.node,
     Command.node,
+    Formatter.node,
     Integration.node,
     MCP.node,
     Location.node,

packages/core/src/plugin/host.ts

@@ -12,6 +12,7 @@ import { AISDK } from "../aisdk.js"
 import { Catalog } from "../catalog.js"
 import { Command } from "../command.js"
 import { Credential } from "../credential.js"
+import { Formatter } from "../formatter.js"
 import { Bus } from "../bus.js"
 import { Integration } from "../integration.js"
 import { Location } from "../location.js"
@@ -36,6 +37,7 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: import("../p
   const commands = yield* Command.Service
   const bus = yield* Bus.Service
   const integration = yield* Integration.Service
+  const formatter = yield* Formatter.Service
   const mcp = yield* MCP.Service
   const location = yield* Location.Service
   const reference = yield* Reference.Service
@@ -185,6 +187,22 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: import("../p
     event: {
       subscribe: () => bus.subscribe().pipe(Stream.filter(EventManifest.isServer)),
     },
+    formatter: {
+      reload: formatter.reload,
+      transform: (callback) =>
+        formatter.transform((draft) => {
+          callback({
+            add: (definition) =>
+              draft.set(definition.name, {
+                name: definition.name,
+                extensions: [...definition.extensions],
+                environment: definition.environment === undefined ? undefined : { ...definition.environment },
+                enabled: Effect.succeed([...definition.command]),
+              }),
+            remove: draft.remove,
+          })
+        }),
+    },
     integration: {
       list: () => response(integration.list()),
       get: (input) => response(integration.get(Integration.ID.make(input.integrationID))),

packages/core/src/plugin/internal.ts

@@ -12,6 +12,8 @@ import { Config } from "../config.js"
 import { Credential } from "../credential.js"
 import { ConfigAgentPlugin } from "../config/plugin/agent.js"
 import { ConfigCommandPlugin } from "../config/plugin/command.js"
+import { ConfigFormatterPlugin } from "../config/plugin/formatter.js"
+import { ConfigImagePlugin } from "../config/plugin/image.js"
 import { ConfigInstructionPlugin } from "../config/plugin/instruction.js"
 import { ConfigMCPPlugin } from "../config/plugin/mcp.js"
 import { ConfigProviderPlugin } from "../config/plugin/provider.js"
@@ -20,6 +22,7 @@ import { ConfigReferencePlugin } from "../config/plugin/reference.js"
 import { ConfigSkillPlugin } from "../config/plugin/skill.js"
 import { ConfigPluginSource } from "../config/plugin/source.js"
 import { ConfigWebSearchPlugin } from "../config/plugin/websearch.js"
+import { ConfigToolOutputPlugin } from "../config/plugin/tool-output.js"
 import { Bus } from "../bus.js"
 import { Environment } from "../environment/index.js"
 import { FileMutation } from "../file-mutation.js"
@@ -57,6 +60,7 @@ import { ShellTool } from "../tool/plugin/shell.js"
 import { SkillTool } from "../tool/plugin/skill.js"
 import { SubagentTool } from "../tool/plugin/subagent.js"
 import { Tool } from "../tool.js"
+import { ToolOutput } from "../tool-output.js"
 import { WebFetchTool } from "../tool/plugin/webfetch.js"
 import { WebSearchTool } from "../tool/plugin/websearch.js"
 import { WellKnown } from "../wellknown.js"
@@ -111,6 +115,7 @@ const services = Effect.fn("PluginInternal.services")(function* () {
   const skill = yield* Skill.Service
   const skillDiscovery = yield* SkillDiscovery.Service
   const tools = yield* Tool.Service
+  const toolOutput = yield* ToolOutput.Service
   const watcher = yield* Watcher.Service
   const wellknown = yield* WellKnown.Service
   return Context.mergeAll(
@@ -149,6 +154,7 @@ const services = Effect.fn("PluginInternal.services")(function* () {
     Context.make(Skill.Service, skill),
     Context.make(SkillDiscovery.Service, skillDiscovery),
     Context.make(Tool.Service, tools),
+    Context.make(ToolOutput.Service, toolOutput),
     Context.make(Watcher.Service, watcher),
     Context.make(WellKnown.Service, wellknown),
   )
@@ -194,6 +200,7 @@ export const requirements = LayerNode.group([
   Skill.node,
   SkillDiscovery.node,
   Tool.node,
+  ToolOutput.node,
   Watcher.node,
   WellKnown.node,
 ])
@@ -232,6 +239,9 @@ const post = [
   ConfigReferencePlugin.Plugin,
   ConfigAgentPlugin.Plugin,
   ConfigCommandPlugin.Plugin,
+  ConfigFormatterPlugin.Plugin,
+  ConfigImagePlugin.Plugin,
+  ConfigToolOutputPlugin.Plugin,
   ConfigSkillPlugin.Plugin,
   ConfigProviderPlugin.Plugin,
   ConfigWebSearchPlugin.Plugin,

packages/core/src/plugin/mcp-codemode-exclusion.ts

@@ -7,7 +7,7 @@ import { Effect } from "effect"
 const urls = [/^https:\/\/mcp\.cloudflare\.com\/mcp$/, /^https:\/\/executor\.sh\/[^/]+\/mcp$/]
 
 export const Plugin = define({
-  id: "opencode.mcp.codemode-exclusion",
+  id: "opencode.mcp.codemode.exclusion",
   effect: Effect.fn(function* (ctx) {
     yield* ctx.mcp.transform((draft) => {
       for (const [, server] of draft.list()) {

packages/core/src/plugin/models-dev.ts

@@ -6,7 +6,7 @@ import { ModelsDev } from "../models-dev.js"
 import { Provider } from "../provider.js"
 
 export const ModelsDevPlugin = define({
-  id: "opencode.models-dev",
+  id: "opencode.models.dev",
   effect: Effect.fn(function* (ctx) {
     const modelsDev = yield* ModelsDev.Service
     const bus = yield* Bus.Service
@@ -55,8 +55,13 @@ export const ModelsDevPlugin = define({
 })
 
 function environmentNames(provider: ModelsDev.Snapshot) {
-  if (provider.info.id !== Provider.ID.azure) return [...provider.environment]
-  return [...provider.environment.filter((name) => name.endsWith("_API_KEY")), "AZURE_COGNITIVE_SERVICES_API_KEY"]
+  if (provider.info.id === Provider.ID.azure)
+    return [...provider.environment.filter((name) => name.endsWith("_API_KEY")), "AZURE_COGNITIVE_SERVICES_API_KEY"]
+  // models.dev advertises project, location, and the ADC credentials file path for
+  // Vertex. Those configure Google auth rather than carrying a key, so only the
+  // Express Mode key may become a credential; GoogleVertexPlugin handles activation.
+  if (provider.info.id === Provider.ID.googleVertex) return ["GOOGLE_VERTEX_API_KEY"]
+  return [...provider.environment]
 }
 
 function snapshots(data: readonly ModelsDev.Snapshot[]) {

packages/core/src/plugin/provider/amazon-bedrock.ts

@@ -60,7 +60,7 @@ function selectMantleModel(sdk: MantleSDK, modelID: string) {
 }
 
 export const AmazonBedrockPlugin = define({
-  id: "opencode.provider.amazon-bedrock",
+  id: "opencode.provider.amazon.bedrock",
   effect: Effect.fn(function* (ctx) {
     yield* ctx.catalog.transform((evt) => {
       for (const item of evt.provider.list()) {

packages/core/src/plugin/provider/cloudflare-ai-gateway.ts

@@ -10,7 +10,7 @@ import { configuredSettings } from "./configured.js"
 const providerID = Provider.ID.make("cloudflare-ai-gateway")
 
 export const CloudflareAIGatewayPlugin = define({
-  id: "opencode.provider.cloudflare-ai-gateway",
+  id: "opencode.provider.cloudflare.ai.gateway",
   effect: Effect.fn(function* (ctx) {
     const configured = yield* configuredSettings(providerID)
     const form = iife(() => {

packages/core/src/plugin/provider/cloudflare-workers-ai.ts

@@ -10,7 +10,7 @@ import { configuredSettings } from "./configured.js"
 const providerID = Provider.ID.make("cloudflare-workers-ai")
 
 export const CloudflareWorkersAIPlugin = define({
-  id: "opencode.provider.cloudflare-workers-ai",
+  id: "opencode.provider.cloudflare.workers.ai",
   effect: Effect.fn(function* (ctx) {
     const configured = yield* configuredSettings(providerID)
     const form = iife(() => {

packages/core/src/plugin/provider/github-copilot.ts

@@ -146,7 +146,7 @@ const oauth = (app: App.Info) =>
   }) satisfies IntegrationOAuthMethodRegistration
 
 export const GithubCopilotPlugin = define({
-  id: "opencode.provider.github-copilot",
+  id: "opencode.provider.github.copilot",
   effect: Effect.fn(function* (ctx) {
     const catalog = yield* Catalog.Service
     const bus = yield* Bus.Service

packages/core/src/plugin/provider/google-vertex.ts

@@ -55,7 +55,7 @@ function authFetch(fetchWithRuntimeOptions?: unknown) {
 }
 
 export const GoogleVertexPlugin = define({
-  id: "opencode.provider.google-vertex",
+  id: "opencode.provider.google.vertex",
   effect: Effect.fn(function* (ctx) {
     yield* ctx.catalog.transform((evt) => {
       for (const item of evt.provider.list()) {
@@ -71,6 +71,9 @@ export const GoogleVertexPlugin = define({
         const project = resolveProject(item.provider.settings ?? {})
         const location = String(resolveLocation(item.provider.settings ?? {}))
         evt.provider.update(item.provider.id, (provider) => {
+          // Vertex authenticates through ADC rather than a key credential, so a
+          // resolvable project is what makes the provider usable.
+          if (project && provider.activation === "auto") provider.activation = "enabled"
           provider.settings = {
             ...provider.settings,
             ...(project ? { project } : {}),

packages/core/src/plugin/provider/openai-compatible.ts

@@ -2,7 +2,7 @@ import { Effect } from "effect"
 import { define } from "@opencode-ai/plugin/effect/plugin"
 
 export const OpenAICompatiblePlugin = define({
-  id: "opencode.provider.openai-compatible",
+  id: "opencode.provider.openai.compatible",
   effect: Effect.fn(function* (ctx) {
     yield* ctx.aisdk.hook(
       "sdk",

packages/core/src/plugin/provider/sap-ai-core.ts

@@ -6,7 +6,7 @@ import { Provider } from "../../provider.js"
 import { importModule } from "@opencode-ai/util/runtime-import"
 
 export const SapAICorePlugin = define({
-  id: "opencode.provider.sap-ai-core",
+  id: "opencode.provider.sap.ai.core",
   effect: Effect.fn(function* (ctx) {
     const npm = yield* Npm.Service
     yield* ctx.aisdk.hook(

packages/core/src/plugin/provider/snowflake-cortex.ts

@@ -65,7 +65,7 @@ export function cortexFetch(upstream: FetchLike = fetch) {
 }
 
 export const SnowflakeCortexPlugin = define({
-  id: "opencode.provider.snowflake-cortex",
+  id: "opencode.provider.snowflake.cortex",
   effect: Effect.fn(function* (ctx) {
     yield* ctx.aisdk.hook(
       "sdk",

packages/core/src/plugin/system-prompt.ts

@@ -33,7 +33,7 @@ export const Plugins = [OpenAIPlugin, GooglePlugin, AnthropicPlugin, KimiPlugin,
 
 function make(id: string, select: (modelID: string) => string | undefined) {
   return define({
-    id: `opencode.system-prompt.${id}`,
+    id: `opencode.prompt.${id}`,
     effect: Effect.fn(`SystemPromptPlugin.${id}`)(function* (ctx) {
       yield* ctx.session.hook("context", (event) =>
         Effect.gen(function* () {

packages/core/src/provider.ts

@@ -48,6 +48,17 @@ const builtins = new Map<string, () => Promise<unknown>>([
   ["@opencode-ai/ai/providers/azure/chat", () => import("@opencode-ai/ai/providers/azure/chat")],
   ["@opencode-ai/ai/providers/azure/responses", () => import("@opencode-ai/ai/providers/azure/responses")],
   ["@opencode-ai/ai/providers/google", () => import("@opencode-ai/ai/providers/google")],
+  ["@opencode-ai/ai/providers/google-vertex", () => import("@opencode-ai/ai/providers/google-vertex")],
+  ["@opencode-ai/ai/providers/google-vertex/gemini", () => import("@opencode-ai/ai/providers/google-vertex/gemini")],
+  ["@opencode-ai/ai/providers/google-vertex/chat", () => import("@opencode-ai/ai/providers/google-vertex/chat")],
+  [
+    "@opencode-ai/ai/providers/google-vertex/responses",
+    () => import("@opencode-ai/ai/providers/google-vertex/responses"),
+  ],
+  [
+    "@opencode-ai/ai/providers/google-vertex/messages",
+    () => import("@opencode-ai/ai/providers/google-vertex/messages"),
+  ],
   ["@opencode-ai/ai/providers/openai", () => import("@opencode-ai/ai/providers/openai")],
   ["@opencode-ai/ai/providers/openai/chat", () => import("@opencode-ai/ai/providers/openai/chat")],
   ["@opencode-ai/ai/providers/openai/responses", () => import("@opencode-ai/ai/providers/openai/responses")],

packages/core/src/session/model-request.ts

@@ -231,7 +231,8 @@ export const layer = Layer.effect(
         http: {
           headers: SessionModelHeaders.make(session, app),
         },
-        promptCacheKey: SessionPromptCacheKey.make(session.id),
+        // TODO: Persist cache lineage so nested forks reuse the root session's cache key.
+        promptCacheKey: SessionPromptCacheKey.make(session.fork?.sessionID ?? session.id),
         system: context.system,
         messages: boundImages(unsupportedParts(context.messages, resolved.capabilities)),
         tools: Array.from(hooked, ([name, tool]) => ({ ...tool, name })),

packages/core/src/session/usage.ts

@@ -5,7 +5,8 @@ import { Money } from "@opencode-ai/schema/money"
 import type { TokenUsage } from "@opencode-ai/schema/token-usage"
 import type { Model } from "../model.js"
 
-const safe = (value: number | undefined) => Math.max(0, Number.isFinite(value) ? (value ?? 0) : 0)
+const finite = (value: number) => (Number.isFinite(value) ? value : 0)
+const safe = (value: number | undefined) => Math.max(0, finite(value ?? 0))
 
 export const tokens = (usage: Usage | undefined): TokenUsage.Info => ({
   input: safe(usage?.nonCachedInputTokens),
@@ -26,10 +27,10 @@ export function calculateCost(costs: Model.Info["cost"], usage: TokenUsage.Info)
   const cost = tier ?? costs.find((cost) => cost.tier === undefined)
   if (!cost) return Money.USD.zero
   return Money.USD.make(
-    (usage.input * cost.input +
-      (usage.output + usage.reasoning) * cost.output +
-      usage.cache.read * cost.cache.read +
-      usage.cache.write * cost.cache.write) /
+    (usage.input * finite(cost.input) +
+      (usage.output + usage.reasoning) * finite(cost.output) +
+      usage.cache.read * finite(cost.cache.read) +
+      usage.cache.write * finite(cost.cache.write)) /
       1_000_000,
   )
 }

packages/core/src/tool-output.ts

@@ -6,8 +6,9 @@ import { Context, Duration, Effect, Layer, Option, Schedule } from "effect"
 import { makeGlobalNode, makeLocationNode } from "@opencode-ai/util/effect/app-node"
 import { FSUtil } from "@opencode-ai/util/fs-util"
 import { Global } from "@opencode-ai/util/global"
-import { Config } from "./config.js"
 import { Identifier } from "./id/id.js"
+import type { DeepMutable } from "./schema.js"
+import { State } from "./state.js"
 
 export const MAX_LINES = 2_000
 export const MAX_BYTES = 50 * 1024 // 50 KiB
@@ -16,7 +17,16 @@ export const DIRECTORY = "tool-output"
 
 type Result = Tool.Result
 
-export interface Interface {
+export interface Policy {
+  readonly maxLines: number
+  readonly maxBytes: number
+}
+
+export interface Draft {
+  readonly update: (update: (policy: DeepMutable<Policy>) => void) => void
+}
+
+export interface Interface extends State.Transformable<Draft> {
   readonly truncate: (result: Result) => Effect.Effect<Result>
   readonly cleanup: () => Effect.Effect<void>
 }
@@ -46,19 +56,23 @@ const cleanup = Effect.fn("ToolOutput.cleanup")(function* (fs: FSUtil.Interface,
 const layer = Layer.effect(
   Service,
   Effect.gen(function* () {
-    const config = yield* Config.Service
     const fs = yield* FSUtil.Service
     const global = yield* Global.Service
     const directory = path.join(global.data, DIRECTORY)
+    const state = State.create<DeepMutable<Policy>, Draft>({
+      name: "tool-output",
+      initial: () => ({ maxLines: MAX_LINES, maxBytes: MAX_BYTES }),
+      draft: (policy) => ({
+        update: (update) => update(policy),
+      }),
+    })
 
     const truncate = Effect.fn("ToolOutput.truncate")(function* (result: Result) {
       if (result.metadata?.truncated !== undefined) return result
       const content =
         typeof result.content === "string" ? [{ type: "text" as const, text: result.content }] : (result.content ?? [])
       const text = content.flatMap((item) => (item.type === "text" ? [item.text] : [])).join("\n")
-      const configured = Config.latest(yield* config.entries(), "tool_output")
-      const maxLines = configured?.max_lines ?? MAX_LINES
-      const maxBytes = configured?.max_bytes ?? MAX_BYTES
+      const { maxLines, maxBytes } = state.get()
       const lines = text.split("\n")
       if (text.endsWith("\n")) lines.pop()
       const totalBytes = Buffer.byteLength(text, "utf-8")
@@ -113,7 +127,12 @@ const layer = Layer.effect(
       }
     })
 
-    return Service.of({ truncate, cleanup: () => cleanup(fs, directory) })
+    return Service.of({
+      truncate,
+      cleanup: () => cleanup(fs, directory),
+      transform: state.transform,
+      reload: state.reload,
+    })
   }),
 )
 
@@ -137,5 +156,5 @@ const cleanupNode = makeGlobalNode({
 export const node = makeLocationNode({
   service: Service,
   layer,
-  deps: [Config.node, FSUtil.node, Global.node, cleanupNode],
+  deps: [FSUtil.node, Global.node, cleanupNode],
 })

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

@@ -0,0 +1,58 @@
+import { describe, expect } from "bun:test"
+import { Config } from "@opencode-ai/core/config"
+import { ConfigImagePlugin } from "@opencode-ai/core/config/plugin/image"
+import { Image } from "@opencode-ai/core/image"
+import { Document, Info } from "@opencode-ai/schema/config"
+import { ConfigMedia } from "@opencode-ai/schema/config/media"
+import { Effect, Layer } from "effect"
+import { host } from "../plugin/host"
+import { it } from "../lib/effect"
+
+describe("ConfigImagePlugin.Plugin", () => {
+  it.live("materializes image policy from config", () =>
+    Effect.gen(function* () {
+      const policy = {
+        autoResize: true,
+        maxWidth: 2_000,
+        maxHeight: 2_000,
+        maxBase64Bytes: 5 * 1024 * 1024,
+      }
+      const image = Image.Service.of({
+        normalize: () => Effect.die("unused image.normalize"),
+        reload: () => Effect.void,
+        transform: (callback) =>
+          Effect.sync(() => {
+            callback({ update: (update) => update(policy) })
+            return { dispose: Effect.void }
+          }),
+      })
+      yield* ConfigImagePlugin.Plugin.effect(host()).pipe(
+        Effect.provideService(Image.Service, image),
+        Effect.provide(
+          Config.testLayer([
+            new Document({
+              type: "document",
+              info: new Info({
+                media: new ConfigMedia.Info({
+                  image: new ConfigMedia.Image({
+                    auto_resize: false,
+                    max_width: 1_000,
+                    max_height: 800,
+                    max_base64_bytes: 123_456,
+                  }),
+                }),
+              }),
+            }),
+          ]),
+        ),
+      )
+
+      expect(policy).toEqual({
+        autoResize: false,
+        maxWidth: 1_000,
+        maxHeight: 800,
+        maxBase64Bytes: 123_456,
+      })
+    }),
+  )
+})

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

@@ -150,6 +150,16 @@ describe("ConfigNormalize", () => {
   })
 
   test("migrates the legacy small model to the title agent", () => {
+    const result = normalized({ small_model: "anthropic/claude-haiku-4-5" })
+    expect(result.encoded.agents).toEqual({
+      title: {
+        model: { providerID: "anthropic", model: "claude-haiku-4-5" },
+      },
+    })
+    expect(result.diagnostics).toEqual([])
+  })
+
+  test("merges the legacy small model with the title agent", () => {
     const result = normalized({
       small_model: "anthropic/claude-haiku-4-5",
       agent: { title: { prompt: "Custom title prompt" } },

packages/core/test/formatter.test.ts

@@ -7,33 +7,32 @@ import { AbsolutePath } from "@opencode-ai/core/schema"
 import { Npm } from "@opencode-ai/util/npm"
 import { Document, Info } from "@opencode-ai/schema/config"
 import { Config } from "../src/config"
+import { ConfigFormatterPlugin } from "../src/config/plugin/formatter"
 import { Formatter } from "../src/formatter"
 import { Location } from "../src/location"
 import { location } from "./fixture/location"
 import { tmpdir } from "./fixture/tmpdir"
 import { testEffect } from "./lib/effect"
+import { host } from "./plugin/host"
 
 const it = testEffect(Layer.empty)
 type ConfigInput = typeof Info.Encoded
 
 function formatterLayer(directory: string, configured?: ConfigInput["formatter"]) {
-  const entries =
-    configured === undefined
-      ? []
-      : [
-          new Document({
-            type: "document",
-            info: Schema.decodeUnknownSync(Info)({ formatter: configured }),
-          }),
-        ]
-  return AppNodeBuilder.build(Formatter.node, [
-    [Config.node, Config.testLayer(entries)],
+  const layer = AppNodeBuilder.build(Formatter.node, [
     [
       Location.node,
       Layer.succeed(Location.Service, Location.Service.of(location({ directory: AbsolutePath.make(directory) }))),
     ],
     [Npm.node, Layer.mock(Npm.Service, { which: () => Effect.succeed(undefined) })],
   ])
+  const entries =
+    configured === undefined
+      ? []
+      : [new Document({ type: "document", info: Schema.decodeUnknownSync(Info)({ formatter: configured }) })]
+  return Layer.effectDiscard(ConfigFormatterPlugin.Plugin.effect(host()).pipe(Effect.provide(Config.testLayer(entries)))).pipe(
+    Layer.provideMerge(layer),
+  )
 }
 
 function withTemp<A, E, R>(body: (directory: string) => Effect.Effect<A, E, R>) {
@@ -162,4 +161,34 @@ describe("Formatter", () => {
       ),
     ),
   )
+
+  it.live("resolves a replacement formatter command independently", () =>
+    withTemp((directory) =>
+      Effect.gen(function* () {
+        const formatter = yield* Formatter.Service
+        const file = path.join(directory, "test.replaced")
+        const register = (content: string) =>
+          formatter.transform((draft) => {
+            draft.set("replacement", {
+              name: "replacement",
+              extensions: [".replaced"],
+              enabled: Effect.succeed([
+                process.execPath,
+                "-e",
+                `require('fs').writeFileSync(process.argv.at(-1), '${content}')`,
+                "$FILE",
+              ]),
+            })
+          })
+
+        yield* register("first")
+        expect(yield* formatter.file(file)).toBe(true)
+        expect(yield* Effect.promise(() => fs.readFile(file, "utf8"))).toBe("first")
+
+        yield* register("second")
+        expect(yield* formatter.file(file)).toBe(true)
+        expect(yield* Effect.promise(() => fs.readFile(file, "utf8"))).toBe("second")
+      }).pipe(Effect.provide(formatterLayer(directory, false))),
+    ),
+  )
 })

packages/core/test/lib/image.ts

@@ -4,4 +4,6 @@ import { Effect, Layer } from "effect"
 /** Passthrough resizer for tests that build Tool.node without a Location. */
 export const imagePassthrough = Layer.mock(Image.Service, {
   normalize: (_resource, content) => Effect.succeed(content),
+  transform: () => Effect.die("unused image.transform"),
+  reload: () => Effect.die("unused image.reload"),
 })

packages/core/test/plugin.test.ts

@@ -8,6 +8,7 @@ import { Bus } from "@opencode-ai/core/bus"
 import { Plugin } from "@opencode-ai/core/plugin"
 import { PluginHost } from "@opencode-ai/core/plugin/host"
 import { PluginRuntime } from "@opencode-ai/core/plugin/runtime"
+import { Formatter } from "@opencode-ai/core/formatter"
 import { Location } from "@opencode-ai/core/location"
 import { Project } from "@opencode-ai/core/project"
 import { AbsolutePath } from "@opencode-ai/core/schema"
@@ -16,6 +17,8 @@ import { SessionMessage } from "@opencode-ai/core/session/message"
 import { Tool } from "@opencode-ai/core/tool"
 import { testEffect } from "./lib/effect"
 import { PluginTestLayer } from "./plugin/fixture"
+import fs from "fs/promises"
+import path from "path"
 
 const it = testEffect(PluginTestLayer)
 
@@ -99,6 +102,34 @@ describe("Plugin", () => {
     }),
   )
 
+  it.effect("registers formatters through the plugin context", () =>
+    Effect.gen(function* () {
+      const plugins = yield* Plugin.Service
+      const formatter = yield* Formatter.Service
+      const location = yield* Location.Service
+      const host = yield* PluginHost.make(plugins)
+      const file = path.join(location.directory, "plugin.formatter-test")
+      yield* Effect.promise(() => fs.writeFile(file, "before"))
+      const registration = yield* host.formatter.transform((draft) => {
+        draft.add({
+          name: "plugin",
+          command: [
+            process.execPath,
+            "-e",
+            "const fs = require('fs'); fs.writeFileSync(process.argv.at(-1), 'after')",
+            "$FILE",
+          ],
+          extensions: [".formatter-test"],
+        })
+      })
+
+      expect(yield* formatter.file(file)).toBe(true)
+      expect(yield* Effect.promise(() => fs.readFile(file, "utf8"))).toBe("after")
+      yield* registration.dispose
+      expect(yield* formatter.file(file)).toBe(false)
+    }),
+  )
+
   it.effect("replaces plugins by ID and version", () =>
     Effect.gen(function* () {
       const plugins = yield* Plugin.Service

packages/core/test/plugin/fixture.ts

@@ -10,6 +10,7 @@ import { Bus } from "@opencode-ai/core/bus"
 import { FileSystem } from "@opencode-ai/core/filesystem"
 import { FSUtil } from "@opencode-ai/util/fs-util"
 import { Form } from "@opencode-ai/core/form"
+import { Formatter } from "@opencode-ai/core/formatter"
 import { Integration } from "@opencode-ai/core/integration"
 import { Location } from "@opencode-ai/core/location"
 import { MCP } from "@opencode-ai/core/mcp/index"
@@ -44,6 +45,7 @@ export const PluginTestLayer = LayerNode.compile(
     Credential.node,
     Bus.node,
     Form.node,
+    Formatter.node,
     LayerNodePlatform.httpClient,
     Plugin.node,
     Agent.node,

packages/core/test/plugin/host.ts

@@ -48,6 +48,10 @@ export function host(overrides: Overrides = {}): Plugin.Context {
     event: overrides.event ?? {
       subscribe: () => Stream.empty,
     },
+    formatter: overrides.formatter ?? {
+      transform: () => Effect.die("unused formatter.transform"),
+      reload: () => Effect.die("unused formatter.reload"),
+    },
     integration: overrides.integration ?? {
       list: () => Effect.die("unused integration.list"),
       get: () => Effect.die("unused integration.get"),

packages/core/test/plugin/models-dev.test.ts

@@ -421,8 +421,48 @@ describe("ModelsDevPlugin", () => {
       expect(yield* integrations.get(Integration.ID.make("google-vertex"))).toBeDefined()
       expect(yield* integrations.get(Integration.ID.make("azure-cognitive-services"))).toBeUndefined()
       expect(yield* integrations.get(Integration.ID.make("google-vertex-anthropic"))).toBeUndefined()
-      expect(ProviderPlugins.map((plugin) => plugin.id)).not.toContain("opencode.provider.azure-cognitive-services")
-      expect(ProviderPlugins.map((plugin) => plugin.id)).not.toContain("opencode.provider.google-vertex-anthropic")
+      expect(ProviderPlugins.map((plugin) => plugin.id)).not.toContain("opencode.provider.azure.cognitive.services")
+      expect(ProviderPlugins.map((plugin) => plugin.id)).not.toContain("opencode.provider.google.vertex.anthropic")
+    }),
+  )
+
+  it.effect("advertises only key-bearing Google Vertex environment variables", () =>
+    Effect.gen(function* () {
+      const integrations = yield* Integration.Service
+      const catalog = yield* Catalog.Service
+
+      yield* ModelsDevPlugin.effect(
+        host({
+          catalog: catalogHost(catalog),
+          integration: integrationHost(integrations),
+        }),
+      ).pipe(
+        Effect.provideService(
+          ModelsDev.Service,
+          ModelsDev.Service.of({
+            get: () =>
+              Effect.succeed([
+                {
+                  info: {
+                    id: Provider.ID.make("google-vertex"),
+                    name: "Google Vertex",
+                    activation: "auto",
+                    package: Provider.aisdk("@ai-sdk/google-vertex"),
+                  },
+                  environment: ["GOOGLE_VERTEX_PROJECT", "GOOGLE_VERTEX_LOCATION", "GOOGLE_APPLICATION_CREDENTIALS"],
+                  models: [],
+                },
+              ] satisfies readonly ModelsDev.Snapshot[]),
+            refresh: () => Effect.void,
+          }),
+        ),
+      )
+
+      // Vertex authenticates through ADC; project, location, and the credentials
+      // file path are configuration, not API keys.
+      expect(yield* integrations.get(Integration.ID.make("google-vertex"))).toMatchObject({
+        methods: [{ type: "key" }, { type: "env", names: ["GOOGLE_VERTEX_API_KEY"] }],
+      })
     }),
   )
 

packages/core/test/plugin/provider-google-vertex.test.ts

@@ -141,6 +141,52 @@ describe("GoogleVertexPlugin", () => {
     ),
   )
 
+  it.effect("enables the provider when a project resolves and leaves it automatic otherwise", () =>
+    withEnv(
+      {
+        GOOGLE_VERTEX_PROJECT: undefined,
+        GOOGLE_CLOUD_PROJECT: undefined,
+        GCP_PROJECT: undefined,
+        GCLOUD_PROJECT: undefined,
+      },
+      () =>
+        Effect.gen(function* () {
+          const catalog = yield* Catalog.Service
+          yield* catalog.transform((catalog) =>
+            catalog.provider.update(Provider.ID.make("google-vertex"), (provider) => {
+              provider.package = Provider.aisdk("@ai-sdk/google-vertex")
+            }),
+          )
+          yield* addPlugin()
+
+          expect(required(yield* catalog.provider.get(Provider.ID.make("google-vertex"))).activation).toBe("auto")
+        }),
+    ),
+  )
+
+  it.effect("enables the provider when a project resolves from env", () =>
+    withEnv(
+      {
+        GOOGLE_VERTEX_PROJECT: undefined,
+        GOOGLE_CLOUD_PROJECT: "adc-project",
+        GCP_PROJECT: undefined,
+        GCLOUD_PROJECT: undefined,
+      },
+      () =>
+        Effect.gen(function* () {
+          const catalog = yield* Catalog.Service
+          yield* catalog.transform((catalog) =>
+            catalog.provider.update(Provider.ID.make("google-vertex"), (provider) => {
+              provider.package = Provider.aisdk("@ai-sdk/google-vertex")
+            }),
+          )
+          yield* addPlugin()
+
+          expect(required(yield* catalog.provider.get(Provider.ID.make("google-vertex"))).activation).toBe("enabled")
+        }),
+    ),
+  )
+
   it.effect("resolves the advertised GOOGLE_VERTEX_PROJECT env for provider updates and SDKs", () =>
     withEnv(
       {

packages/core/test/plugin/provider-snowflake-cortex.test.ts

@@ -43,10 +43,10 @@ function withEnv<A, E, R>(vars: Record<string, string | undefined>, effect: () =
 describe("SnowflakeCortexPlugin", () => {
   it.effect("is registered in ProviderPlugins before OpenAICompatiblePlugin", () =>
     Effect.sync(() => {
-      expect(ProviderPlugins.map((item) => item.id)).toContain("opencode.provider.snowflake-cortex")
+      expect(ProviderPlugins.map((item) => item.id)).toContain("opencode.provider.snowflake.cortex")
       const ids = ProviderPlugins.map((p) => p.id)
-      expect(ids.indexOf("opencode.provider.snowflake-cortex")).toBeLessThan(
-        ids.indexOf("opencode.provider.openai-compatible"),
+      expect(ids.indexOf("opencode.provider.snowflake.cortex")).toBeLessThan(
+        ids.indexOf("opencode.provider.openai.compatible"),
       )
     }),
   )

packages/core/test/plugin/system-prompt.test.ts

@@ -48,12 +48,12 @@ describe("SystemPromptPlugin", () => {
 
   test("uses granular IDs with a common prefix", () => {
     expect(SystemPromptPlugin.Plugins.map((plugin) => plugin.id)).toEqual([
-      "opencode.system-prompt.openai",
-      "opencode.system-prompt.google",
-      "opencode.system-prompt.anthropic",
-      "opencode.system-prompt.kimi",
-      "opencode.system-prompt.arcee",
-      "opencode.system-prompt.meta",
+      "opencode.prompt.openai",
+      "opencode.prompt.google",
+      "opencode.prompt.anthropic",
+      "opencode.prompt.kimi",
+      "opencode.prompt.arcee",
+      "opencode.prompt.meta",
     ])
   })
 

packages/core/test/provider.test.ts

@@ -0,0 +1,20 @@
+import { describe, expect, test } from "bun:test"
+import { Effect } from "effect"
+import { Provider } from "@opencode-ai/core/provider"
+
+describe("Provider", () => {
+  test("loads Vertex native provider entrypoints", async () => {
+    const packages = [
+      "@opencode-ai/ai/providers/google-vertex",
+      "@opencode-ai/ai/providers/google-vertex/gemini",
+      "@opencode-ai/ai/providers/google-vertex/chat",
+      "@opencode-ai/ai/providers/google-vertex/responses",
+      "@opencode-ai/ai/providers/google-vertex/messages",
+    ]
+
+    for (const specifier of packages) {
+      const loaded = await Effect.runPromise(Provider.loadPackage(specifier))
+      expect(loaded.model).toBeFunction()
+    }
+  })
+})

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

@@ -197,6 +197,29 @@ test("calculates step cost using the matching context tier", () => {
   ).toBeCloseTo(0.0002926)
 })
 
+test("ignores malformed model cost fields", () => {
+  const costs = [
+    {
+      input: Money.USDPerMillionTokens.make(3),
+      output: Money.USDPerMillionTokens.make(15),
+      cache: {
+        read: Money.USDPerMillionTokens.make(0.3),
+        write: Money.USDPerMillionTokens.make(3.75),
+      },
+    },
+  ]
+  Object.assign(costs[0], { input: {} })
+
+  expect(
+    SessionUsage.calculateCost(costs, {
+      input: 1_000_000,
+      output: 100_000,
+      reasoning: 0,
+      cache: { read: 0, write: 0 },
+    }),
+  ).toBe(Money.USD.make(1.5))
+})
+
 test("does not apply an ineligible tier without base pricing", () => {
   expect(
     SessionUsage.calculateCost(

packages/core/test/tool-output.test.ts

@@ -1,7 +1,8 @@
 import { describe, expect } from "bun:test"
 import path from "path"
-import { Effect } from "effect"
+import { Effect, Layer } from "effect"
 import { Config } from "@opencode-ai/core/config"
+import { ConfigToolOutputPlugin } from "@opencode-ai/core/config/plugin/tool-output"
 import { Document, Info } from "@opencode-ai/schema/config"
 import { ConfigToolOutput } from "@opencode-ai/schema/config/tool-output"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
@@ -12,6 +13,7 @@ import { Global } from "@opencode-ai/util/global"
 import { Identifier } from "@opencode-ai/core/id/id"
 import { tmpdir } from "./fixture/tmpdir"
 import { it } from "./lib/effect"
+import { host } from "./plugin/host"
 
 const withStore = <A, E, R>(
   body: (output: ToolOutput.Interface, fs: FSUtil.Interface, root: string) => Effect.Effect<A, E, R>,
@@ -21,10 +23,12 @@ const withStore = <A, E, R>(
     Effect.promise(() => tmpdir()),
     (tmp) => {
       const config = Config.testLayer([new Document({ type: "document", info })])
-      const layer = AppNodeBuilder.build(LayerNode.group([ToolOutput.node, FSUtil.node]), [
-        [Config.node, config],
+      const base = AppNodeBuilder.build(LayerNode.group([ToolOutput.node, FSUtil.node]), [
         [Global.node, Global.layerWith({ data: tmp.path })],
       ])
+      const layer = Layer.effectDiscard(
+        ConfigToolOutputPlugin.Plugin.effect(host()).pipe(Effect.provide(config)),
+      ).pipe(Layer.provideMerge(base))
       return Effect.gen(function* () {
         return yield* body(yield* ToolOutput.Service, yield* FSUtil.Service, tmp.path)
       }).pipe(Effect.provide(layer))

packages/core/test/tool-read.test.ts

@@ -2,6 +2,7 @@ import { beforeEach, describe, expect } from "bun:test"
 import path from "path"
 import { Effect, Exit, Layer, Stream } from "effect"
 import { Config } from "@opencode-ai/core/config"
+import { ConfigImagePlugin } from "@opencode-ai/core/config/plugin/image"
 import { Document, Info } from "@opencode-ai/schema/config"
 import { ConfigMedia } from "@opencode-ai/schema/config/media"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
@@ -25,6 +26,7 @@ import { Environment } from "@opencode-ai/core/environment/index"
 import { testEffect } from "./lib/effect"
 import { permissionLayer } from "./lib/permission"
 import { toolIdentity, executeTool, registerToolPlugin, toolDefinitions } from "./lib/tool"
+import { host } from "./plugin/host"
 
 const readToolNode = makeLocationNode({
   name: "test/read-tool-plugin",
@@ -90,7 +92,8 @@ const permission = permissionLayer({
     ),
 })
 const config = Config.testLayer()
-const imageLayer = AppNodeBuilder.build(Image.node, [[Config.node, config]])
+const imageLayer = AppNodeBuilder.build(Image.node)
+const configureImage = ConfigImagePlugin.Plugin.effect(host())
 const testFileSystem = Layer.effect(
   FSUtil.Service,
   FSUtil.Service.use((fs) =>
@@ -132,11 +135,15 @@ const mutation = Layer.succeed(
 )
 const unavailableImage = Layer.succeed(
   Image.Service,
-  Image.Service.of({ normalize: () => Effect.fail(new Image.ResizerUnavailableError()) }),
+  Image.Service.of({
+    normalize: () => Effect.fail(new Image.ResizerUnavailableError()),
+    transform: () => Effect.die("unused image.transform"),
+    reload: () => Effect.die("unused image.reload"),
+  }),
 )
 const readLayer = (imageLayer: Layer.Layer<Image.Service>) =>
   Layer.mergeAll(
-    AppNodeBuilder.build(LayerNode.group([Tool.node, readToolNode]), [
+    AppNodeBuilder.build(LayerNode.group([Tool.node, readToolNode, Image.node]), [
       [ReadToolFileSystem.node, reader],
       [Permission.node, permission],
       [Config.node, config],
@@ -395,6 +402,7 @@ describe("ReadTool", () => {
           }),
         }),
       ])
+      yield* configureImage
       const registry = yield* Tool.Service
 
       expect(
@@ -436,6 +444,7 @@ describe("ReadTool", () => {
           }),
         }),
       ])
+      yield* configureImage
       const registry = yield* Tool.Service
       const result = yield* executeTool(registry, {
         sessionID,
@@ -477,6 +486,7 @@ describe("ReadTool", () => {
           }),
         }),
       ])
+      yield* configureImage
       const registry = yield* Tool.Service
 
       expect(

packages/plugin/src/effect/formatter.ts

@@ -0,0 +1,19 @@
+import type { Effect } from "effect"
+import type { Transform } from "./registration.js"
+
+export interface FormatterDefinition {
+  readonly name: string
+  readonly command: readonly string[]
+  readonly extensions: readonly string[]
+  readonly environment?: Readonly<Record<string, string>>
+}
+
+export interface FormatterDraft {
+  readonly add: (formatter: FormatterDefinition) => void
+  readonly remove: (name: string) => void
+}
+
+export interface FormatterDomain {
+  readonly transform: Transform<FormatterDraft>
+  readonly reload: () => Effect.Effect<void>
+}

packages/plugin/src/effect/plugin.ts

@@ -7,6 +7,7 @@ import type { AISDKDomain } from "./aisdk.js"
 import type { CatalogDomain } from "./catalog.js"
 import type { CommandDomain } from "./command.js"
 import type { EventDomain } from "./event.js"
+import type { FormatterDomain } from "./formatter.js"
 import type { IntegrationDomain } from "./integration.js"
 import type { MCPDomain } from "./mcp.js"
 import type { ReferenceDomain } from "./reference.js"
@@ -24,6 +25,7 @@ export interface Context {
   readonly catalog: CatalogDomain
   readonly command: CommandDomain
   readonly event: EventDomain
+  readonly formatter: FormatterDomain
   readonly integration: IntegrationDomain
   readonly mcp: MCPDomain
   readonly plugin: PluginApi<unknown>

packages/plugin/src/promise/adapter.ts

@@ -158,6 +158,10 @@ export function fromPromise(plugin: Plugin) {
                 ),
               ),
           },
+          formatter: {
+            transform: transform(host.formatter),
+            reload: () => run(host.formatter.reload()),
+          },
           integration: {
             list: adaptApiMethod(IntegrationEndpoints["integration.list"], host.integration.list),
             get: adaptApiMethod(IntegrationEndpoints["integration.get"], host.integration.get),

packages/plugin/src/promise/formatter.ts

@@ -0,0 +1,18 @@
+import type { Transform } from "./registration.js"
+
+export interface FormatterDefinition {
+  readonly name: string
+  readonly command: readonly string[]
+  readonly extensions: readonly string[]
+  readonly environment?: Readonly<Record<string, string>>
+}
+
+export interface FormatterDraft {
+  readonly add: (formatter: FormatterDefinition) => void
+  readonly remove: (name: string) => void
+}
+
+export interface FormatterDomain {
+  readonly transform: Transform<FormatterDraft>
+  readonly reload: () => Promise<void>
+}

packages/plugin/src/promise/plugin.ts

@@ -6,6 +6,7 @@ import type { AISDKDomain } from "./aisdk.js"
 import type { CatalogDomain } from "./catalog.js"
 import type { CommandDomain } from "./command.js"
 import type { EventDomain } from "./event.js"
+import type { FormatterDomain } from "./formatter.js"
 import type { IntegrationDomain } from "./integration.js"
 import type { MCPDomain } from "./mcp.js"
 import type { ReferenceDomain } from "./reference.js"
@@ -23,6 +24,7 @@ export interface Context {
   readonly catalog: CatalogDomain
   readonly command: CommandDomain
   readonly event: EventDomain
+  readonly formatter: FormatterDomain
   readonly integration: IntegrationDomain
   readonly mcp: MCPDomain
   readonly plugin: PluginApi

packages/protocol/openapi.json

@@ -48,58 +48,6 @@
         "summary": "Check server health"
       }
     },
-    "/api/service/stop": {
-      "post": {
-        "tags": ["health"],
-        "operationId": "v2.health.stop",
-        "parameters": [],
-        "security": [],
-        "responses": {
-          "200": {
-            "description": "ServiceStopResponse",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/ServiceStopResponse"
-                }
-              }
-            }
-          },
-          "400": {
-            "description": "InvalidRequestError",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/InvalidRequestErrorEncoded"
-                }
-              }
-            }
-          },
-          "401": {
-            "description": "UnauthorizedError",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/UnauthorizedErrorEncoded"
-                }
-              }
-            }
-          }
-        },
-        "description": "Request graceful shutdown of one exact managed server instance.",
-        "summary": "Stop the managed server",
-        "requestBody": {
-          "content": {
-            "application/json": {
-              "schema": {
-                "$ref": "#/components/schemas/ServiceStopRequest"
-              }
-            }
-          },
-          "required": true
-        }
-      }
-    },
     "/api/server": {
       "get": {
         "tags": ["server"],
@@ -9783,26 +9731,6 @@
         "required": ["_tag", "message"],
         "additionalProperties": false
       },
-      "ServiceStopRequest": {
-        "type": "object",
-        "properties": {
-          "instanceID": {
-            "type": "string"
-          }
-        },
-        "required": ["instanceID"],
-        "additionalProperties": false
-      },
-      "ServiceStopResponse": {
-        "type": "object",
-        "properties": {
-          "accepted": {
-            "type": "boolean"
-          }
-        },
-        "required": ["accepted"],
-        "additionalProperties": false
-      },
       "Union_1": {
         "anyOf": [
           {

packages/protocol/src/groups/health.ts

@@ -9,16 +9,6 @@ export namespace ServiceStatus {
     pid: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
   }).annotate({ identifier: "ServiceHealth" })
   export type Health = typeof Health.Type
-
-  export const StopRequest = Schema.Struct({
-    instanceID: Schema.String,
-  }).annotate({ identifier: "ServiceStopRequest" })
-  export type StopRequest = typeof StopRequest.Type
-
-  export const StopResponse = Schema.Struct({
-    accepted: Schema.Boolean,
-  }).annotate({ identifier: "ServiceStopResponse" })
-  export type StopResponse = typeof StopResponse.Type
 }
 
 export const HealthGroup = HttpApiGroup.make("server.health")
@@ -33,16 +23,4 @@ export const HealthGroup = HttpApiGroup.make("server.health")
       }),
     ),
   )
-  .add(
-    HttpApiEndpoint.post("health.stop", "/api/service/stop", {
-      payload: ServiceStatus.StopRequest,
-      success: ServiceStatus.StopResponse,
-    }).annotateMerge(
-      OpenApi.annotations({
-        identifier: "v2.health.stop",
-        summary: "Stop the managed server",
-        description: "Request graceful shutdown of one exact managed server instance.",
-      }),
-    ),
-  )
   .annotateMerge(OpenApi.annotations({ title: "health" }))

packages/server/src/handlers/health.ts

@@ -4,17 +4,15 @@ import { Api } from "../api"
 import { ServerInfo } from "../server-info"
 
 export const HealthHandler = HttpApiBuilder.group(Api, "server.health", (handlers) =>
-  handlers
-    .handle("health.get", () =>
-      Effect.gen(function* () {
-        const info = yield* ServerInfo.Service
-        return {
-          healthy: true as const,
-          version: info.app.version ?? "unknown",
-          // Runtimes without OS process identity (workerd) report 0.
-          pid: process.pid ?? 0,
-        }
-      }),
-    )
-    .handle("health.stop", () => Effect.succeed({ accepted: false })),
+  handlers.handle("health.get", () =>
+    Effect.gen(function* () {
+      const info = yield* ServerInfo.Service
+      return {
+        healthy: true as const,
+        version: info.app.version ?? "unknown",
+        // Runtimes without OS process identity (workerd) report 0.
+        pid: process.pid ?? 0,
+      }
+    }),
+  ),
 )

packages/server/src/process.ts

@@ -1,12 +1,10 @@
 export * as ServerProcess from "./process"
 
-import { NodeHttpServer, NodeHttpServerRequest } from "@effect/platform-node"
+import { NodeHttpServer } from "@effect/platform-node"
 import { SessionRestart } from "@opencode-ai/core/session/execution/restart"
-import { ServiceStatus } from "@opencode-ai/protocol/groups/health"
 import { hasPtyConnectTicketURL } from "@opencode-ai/protocol/groups/pty"
-import { Cause, Context, Deferred, Effect, Exit, Layer, Option, Ref, Schema, Scope } from "effect"
+import { Cause, Context, Deferred, Effect, Exit, Layer, Option, Ref, Scope } from "effect"
 import { HttpMiddleware, HttpRouter, HttpServer, HttpServerRequest, HttpServerResponse } from "effect/unstable/http"
-import { randomUUID } from "node:crypto"
 import { createServer } from "node:http"
 import { ServerAuth } from "./auth"
 import { isAllowedCorsOrigin } from "./cors"
@@ -18,7 +16,6 @@ import { Status } from "./service-status"
 import type { ServerOptions } from "./options"
 
 export interface Lifecycle<E = never, R = never> {
-  readonly instanceID: string
   readonly onListen: (
     address: HttpServer.Address,
     shutdown: Effect.Effect<void>,
@@ -51,16 +48,13 @@ export const start = Effect.fn("ServerProcess.start")(function* <E, R>(
   const hostname = options.hostname ?? "127.0.0.1"
   const port = Option.fromNullishOr(options.port)
   const shutdown = yield* Deferred.make<void>()
-  const status = yield* Status.make({
-    instanceID: lifecycle?.instanceID ?? randomUUID(),
-    managed: lifecycle !== undefined,
-  })
+  const status = yield* Status.make()
   const bound = yield* listen({ hostname, port })
   const application = yield* Ref.make(Option.none<App>())
   // Request fibers may continue inbound trace context, but must not inherit the server startup parent.
   yield* bound.http
     .serve(
-      dispatch(password, status, application, shutdown, options.app?.version ?? "unknown").pipe(
+      dispatch(password, status, application, options.app?.version ?? "unknown").pipe(
         HttpMiddleware.cors({ allowedOrigins: isAllowedCorsOrigin, maxAge: 86_400 }),
       ),
       errorResponseLogger,
@@ -163,22 +157,15 @@ function dispatch(
   password: string,
   status: Status.Interface,
   application: Ref.Ref<Option.Option<App>>,
-  shutdown: Deferred.Deferred<void>,
   version: string,
 ): App {
   const auth = ServerAuth.Config.of({ password: Option.some(password), username: "opencode" })
   return Effect.gen(function* () {
     const request = yield* HttpServerRequest.HttpServerRequest
     const url = new URL(request.url, "http://localhost")
-    const lifecycle =
-      request.method === "GET" && url.pathname === "/api/health"
-        ? "health"
-        : request.method === "POST" && url.pathname === "/api/service/stop"
-          ? "stop"
-          : undefined
-    if (lifecycle !== undefined) {
+    if (request.method === "GET" && url.pathname === "/api/health") {
       if (!(yield* authorizedRequest(request, auth))) return unauthorized()
-      return yield* control(request, lifecycle, status, () => Deferred.doneUnsafe(shutdown, Effect.void), version)
+      return yield* healthResponse(status, version)
     }
     const state = yield* status.current
     const app = yield* Ref.get(application)
@@ -196,33 +183,6 @@ function unauthorized() {
   })
 }
 
-const control = Effect.fnUntraced(function* (
-  request: HttpServerRequest.HttpServerRequest,
-  route: "health" | "stop",
-  status: Status.Interface,
-  stop: () => void,
-  version: string,
-) {
-  if (route === "health") return yield* healthResponse(status, version)
-  const body = yield* request.json.pipe(Effect.option)
-  const input = Option.isSome(body) ? Schema.decodeUnknownOption(ServiceStatus.StopRequest)(body.value) : Option.none()
-  if (Option.isNone(input)) return HttpServerResponse.jsonUnsafe({ code: "invalid_request" }, { status: 400 })
-  const accepted = yield* status.requestStop(input.value)
-  if (accepted) {
-    const response = NodeHttpServerRequest.toServerResponse(request)
-    yield* Effect.sync(() => {
-      const complete = () => {
-        response.off("finish", complete)
-        response.off("close", complete)
-        stop()
-      }
-      response.once("finish", complete)
-      response.once("close", complete)
-    })
-  }
-  return HttpServerResponse.jsonUnsafe({ accepted })
-})
-
 const healthResponse = Effect.fnUntraced(function* (status: Status.Interface, version: string) {
   const state = yield* status.current
   return HttpServerResponse.jsonUnsafe(

packages/server/src/service-status.ts

@@ -1,6 +1,5 @@
 export * as Status from "./service-status"
 
-import { ServiceStatus } from "@opencode-ai/protocol/groups/health"
 import { Effect, Ref } from "effect"
 
 export type State =
@@ -14,14 +13,9 @@ export interface Interface {
   readonly ready: Effect.Effect<void>
   readonly fail: Effect.Effect<void>
   readonly beginStopping: Effect.Effect<void>
-  readonly requestStop: (request: ServiceStatus.StopRequest) => Effect.Effect<boolean>
 }
 
-export const make = Effect.fnUntraced(function* (options: {
-  readonly instanceID: string
-  readonly managed: boolean
-  readonly initial?: State
-}) {
+export const make = Effect.fnUntraced(function* (options: { readonly initial?: State } = {}) {
   const current = yield* Ref.make(options.initial ?? ({ type: "starting" } satisfies State))
   const beginStopping = Ref.update(current, (status) =>
     status.type === "stopping" ? status : ({ type: "stopping" } satisfies State),
@@ -32,9 +26,5 @@ export const make = Effect.fnUntraced(function* (options: {
     ready: Ref.update(current, (status) => (status.type === "starting" ? ({ type: "ready" } satisfies State) : status)),
     fail: Ref.update(current, (status) => (status.type === "starting" ? ({ type: "failed" } satisfies State) : status)),
     beginStopping,
-    requestStop: (request) => {
-      if (!options.managed || request.instanceID !== options.instanceID) return Effect.succeed(false)
-      return beginStopping.pipe(Effect.as(true))
-    },
   } satisfies Interface
 })

packages/server/test/service-status.test.ts

@@ -5,7 +5,7 @@ import { Status } from "../src/service-status"
 
 it.effect("moves from starting to ready", () =>
   Effect.gen(function* () {
-    const status = yield* Status.make({ instanceID: "one", managed: false })
+    const status = yield* Status.make()
     expect(yield* status.current).toEqual({ type: "starting" })
     yield* status.ready
     expect(yield* status.current).toEqual({ type: "ready" })
@@ -14,7 +14,7 @@ it.effect("moves from starting to ready", () =>
 
 it.effect("keeps a startup failure until shutdown", () =>
   Effect.gen(function* () {
-    const status = yield* Status.make({ instanceID: "one", managed: true })
+    const status = yield* Status.make()
     yield* status.fail
     yield* status.ready
     yield* status.fail
@@ -22,24 +22,13 @@ it.effect("keeps a startup failure until shutdown", () =>
   }),
 )
 
-it.effect("stops only the addressed managed instance", () =>
-  Effect.gen(function* () {
-    const status = yield* Status.make({ instanceID: "one", managed: true })
-
-    expect(yield* status.requestStop({ instanceID: "other" })).toBe(false)
-    expect(yield* status.current).toEqual({ type: "starting" })
-    expect(yield* status.requestStop({ instanceID: "one" })).toBe(true)
-    expect(yield* status.current).toEqual({ type: "stopping" })
-  }),
-)
-
 it.effect("keeps stopping after shutdown begins", () =>
   Effect.gen(function* () {
-    const status = yield* Status.make({ instanceID: "one", managed: true })
+    const status = yield* Status.make()
 
     yield* status.beginStopping
     expect(yield* status.current).toEqual({ type: "stopping" })
-    expect(yield* status.requestStop({ instanceID: "one" })).toBe(true)
+    yield* status.beginStopping
     expect(yield* status.current).toEqual({ type: "stopping" })
   }),
 )

packages/tui/src/feature-plugins/home/footer.tsx

@@ -99,7 +99,7 @@ function View(props: { context: Plugin.Context }) {
 }
 
 export default Plugin.define({
-  id: "opencode.home-footer",
+  id: "opencode.home.footer",
   setup(context) {
     // Root takeover: an external plugin replacing home.footer wins (last-
     // enabled) and this builtin shows as suppressed, not silently gone.

packages/tui/src/feature-plugins/prompt/footer.tsx

@@ -83,7 +83,7 @@ export function PromptFooter(props: { context: Plugin.Context; sessionID?: strin
 }
 
 export default Plugin.define({
-  id: "opencode.prompt-footer",
+  id: "opencode.prompt.footer",
   setup(context) {
     context.ui.slot({
       append: "prompt.footer",

packages/tui/src/feature-plugins/sidebar/context.tsx

@@ -42,7 +42,7 @@ export function SidebarContext(props: { context: Plugin.Context; sessionID: stri
 }
 
 export default Plugin.define({
-  id: "internal:sidebar-context",
+  id: "opencode.sidebar.context",
   setup(context) {
     context.ui.slot({
       append: "sidebar.content",

packages/tui/src/feature-plugins/sidebar/footer.tsx

@@ -40,7 +40,7 @@ function View(props: { context: Plugin.Context; sessionID: string }) {
 }
 
 export default Plugin.define({
-  id: "opencode.sidebar-footer",
+  id: "opencode.sidebar.footer",
   setup(context) {
     // Append keeps the path open to additive plugin claims; an external
     // replace still takes the boundary over.

packages/tui/src/feature-plugins/sidebar/mcp.tsx

@@ -71,7 +71,7 @@ function View(props: { context: Plugin.Context; sessionID: string }) {
 }
 
 export default Plugin.define({
-  id: "internal:sidebar-mcp",
+  id: "opencode.sidebar.mcp",
   setup(context) {
     context.ui.slot({
       append: "sidebar.content",

packages/tui/src/feature-plugins/system/diff-viewer.tsx

@@ -1079,7 +1079,7 @@ function Commands(props: { context: Plugin.Context }) {
 }
 
 export default Plugin.define({
-  id: "diff-viewer",
+  id: "opencode.diffs",
   setup(context) {
     context.ui.router.register({
       name: ROUTE,

packages/tui/src/routes/session/form.tsx

@@ -523,18 +523,6 @@ export function FormPrompt(props: {
           textarea?.setText("")
         },
       },
-      {
-        id: "prompt.paste",
-        title: "Paste into answer",
-        group: "Form",
-        async run(_input, event) {
-          event?.preventDefault()
-          event?.stopPropagation()
-          const content = await clipboard.read()
-          if (content?.mime !== "text/plain") return
-          textarea?.insertText(content.data)
-        },
-      },
       {
         bind: "escape",
         title: textual() ? "Dismiss form" : "Close answer edit",

packages/tui/test/cli/tui/diff-viewer.test.tsx

@@ -29,7 +29,7 @@ test("closing the diff viewer returns to the route it opened from", async () =>
   try {
     expect(viewer.current()).toEqual({
       type: "plugin",
-      id: "diff-viewer",
+      id: "opencode.diffs",
       name: "diff",
       data: { mode: "working", sessionID: "session-1", returnRoute: startRoute },
     })
@@ -207,7 +207,7 @@ async function renderDiffViewer(
             navigate(destination: Destination) {
               setCurrent(
                 destination.type === "plugin" && !("id" in destination)
-                  ? { ...destination, id: "diff-viewer" }
+                  ? { ...destination, id: "opencode.diffs" }
                   : destination,
               )
             },
@@ -334,7 +334,7 @@ test("branch diff source requests branch VCS diff", async () => {
   const viewer = await renderDiffViewer([], {
     initialRoute: {
       type: "plugin",
-      id: "diff-viewer",
+      id: "opencode.diffs",
       name: "diff",
       data: { mode: "branch", sessionID: "session-1", returnRoute: startRoute },
     },
@@ -342,7 +342,7 @@ test("branch diff source requests branch VCS diff", async () => {
   try {
     expect(viewer.current()).toEqual({
       type: "plugin",
-      id: "diff-viewer",
+      id: "opencode.diffs",
       name: "diff",
       data: { mode: "branch", sessionID: "session-1", returnRoute: startRoute },
     })

packages/tui/test/cli/tui/form.test.tsx

@@ -14,7 +14,7 @@ import { TestTuiContexts } from "../../fixture/tui-environment"
 import { createTuiResolvedConfig } from "../../fixture/tui-runtime"
 import { createApi, createEventStream, createFetch } from "../../fixture/tui-client"
 
-async function mountForm(root: string, width = 80, fields?: FormWithLocation["fields"], height = 20, pasted?: string) {
+async function mountForm(root: string, width = 80, fields?: FormWithLocation["fields"], height = 20) {
   const state = path.join(root, "state")
   await mkdir(state, { recursive: true })
 
@@ -58,7 +58,7 @@ async function mountForm(root: string, width = 80, fields?: FormWithLocation["fi
         }}
         clipboard={{
           async read() {
-            return pasted ? { data: pasted, mime: "text/plain" } : undefined
+            return undefined
           },
           write(text) {
             copied.push(text)
@@ -217,34 +217,6 @@ test("pasting on a custom choice opens its editor without submitting", async ()
   }
 })
 
-test("ctrl-v pastes clipboard text into a custom answer", async () => {
-  await using tmp = await tmpdir()
-  const prompt = await mountForm(
-    tmp.path,
-    80,
-    [
-      {
-        key: "target",
-        type: "string",
-        options: [{ value: "staging", label: "Staging" }],
-        custom: true,
-      },
-    ],
-    20,
-    "production west",
-  )
-  try {
-    prompt.app.mockInput.pressArrow("down")
-    prompt.app.mockInput.pressEnter()
-    await prompt.app.waitFor(() => prompt.app.renderer.currentFocusedEditor !== null)
-
-    prompt.app.mockInput.pressKey("v", { ctrl: true })
-    await prompt.app.waitFor(() => prompt.app.renderer.currentFocusedEditor?.plainText === "production west")
-  } finally {
-    prompt.app.renderer.destroy()
-  }
-})
-
 test("typing a custom multiselect answer selects it before commit", async () => {
   await using tmp = await tmpdir()
   const prompt = await mountForm(tmp.path, 80, [

packages/www/openapi.json

@@ -48,58 +48,6 @@
         "summary": "Check server health"
       }
     },
-    "/api/service/stop": {
-      "post": {
-        "tags": ["health"],
-        "operationId": "v2.health.stop",
-        "parameters": [],
-        "security": [],
-        "responses": {
-          "200": {
-            "description": "ServiceStopResponse",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/ServiceStopResponse"
-                }
-              }
-            }
-          },
-          "400": {
-            "description": "InvalidRequestError",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/InvalidRequestErrorEncoded"
-                }
-              }
-            }
-          },
-          "401": {
-            "description": "UnauthorizedError",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/UnauthorizedErrorEncoded"
-                }
-              }
-            }
-          }
-        },
-        "description": "Request graceful shutdown of one exact managed server instance.",
-        "summary": "Stop the managed server",
-        "requestBody": {
-          "content": {
-            "application/json": {
-              "schema": {
-                "$ref": "#/components/schemas/ServiceStopRequest"
-              }
-            }
-          },
-          "required": true
-        }
-      }
-    },
     "/api/server": {
       "get": {
         "tags": ["server"],
@@ -9783,26 +9731,6 @@
         "required": ["_tag", "message"],
         "additionalProperties": false
       },
-      "ServiceStopRequest": {
-        "type": "object",
-        "properties": {
-          "instanceID": {
-            "type": "string"
-          }
-        },
-        "required": ["instanceID"],
-        "additionalProperties": false
-      },
-      "ServiceStopResponse": {
-        "type": "object",
-        "properties": {
-          "accepted": {
-            "type": "boolean"
-          }
-        },
-        "required": ["accepted"],
-        "additionalProperties": false
-      },
       "Union_1": {
         "anyOf": [
           {

packages/www/public/openapi.json

@@ -48,58 +48,6 @@
         "summary": "Check server health"
       }
     },
-    "/api/service/stop": {
-      "post": {
-        "tags": ["health"],
-        "operationId": "v2.health.stop",
-        "parameters": [],
-        "security": [],
-        "responses": {
-          "200": {
-            "description": "ServiceStopResponse",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/ServiceStopResponse"
-                }
-              }
-            }
-          },
-          "400": {
-            "description": "InvalidRequestError",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/InvalidRequestErrorEncoded"
-                }
-              }
-            }
-          },
-          "401": {
-            "description": "UnauthorizedError",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/UnauthorizedErrorEncoded"
-                }
-              }
-            }
-          }
-        },
-        "description": "Request graceful shutdown of one exact managed server instance.",
-        "summary": "Stop the managed server",
-        "requestBody": {
-          "content": {
-            "application/json": {
-              "schema": {
-                "$ref": "#/components/schemas/ServiceStopRequest"
-              }
-            }
-          },
-          "required": true
-        }
-      }
-    },
     "/api/server": {
       "get": {
         "tags": ["server"],
@@ -9783,26 +9731,6 @@
         "required": ["_tag", "message"],
         "additionalProperties": false
       },
-      "ServiceStopRequest": {
-        "type": "object",
-        "properties": {
-          "instanceID": {
-            "type": "string"
-          }
-        },
-        "required": ["instanceID"],
-        "additionalProperties": false
-      },
-      "ServiceStopResponse": {
-        "type": "object",
-        "properties": {
-          "accepted": {
-            "type": "boolean"
-          }
-        },
-        "required": ["accepted"],
-        "additionalProperties": false
-      },
       "Union_1": {
         "anyOf": [
           {