fix(tui): follow agent model selection

2026-08-18 13:49:25 -04:00 · 2026-08-18 14:29:55 +00:00
65 changed files with 813 additions and 788 deletions
@@ -1,6 +0,0 @@
---
-"@opencode-ai/plugin": patch
-"@opencode-ai/core": patch
---
-
-Add transport-neutral Session model request hooks and provider-scoped hook registration so eligible OpenAI Responses requests can prefer WebSocket without bypassing HTTP-only middleware.
@@ -109,7 +109,7 @@ for (const item of targets) {
    external: ["node-gyp"],
    format: "esm",
    minify: true,
-    sourcemap: Script.channel === "dev" || Script.channel === "local" ? "inline" : "none",
+    sourcemap: "inline",
    splitting: true,
    compile: {
      autoloadBunfig: false,
@@ -1,9 +1,8 @@
 #!/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 { Effect, Schema } from "effect"
+import { Schema } from "effect"
 import fs from "node:fs/promises"
 import os from "node:os"
 import path from "node:path"
@@ -64,22 +63,28 @@ try {
  })
  if (unauthorizedOpenApi.status !== 401)
    throw new Error("Compiled service exposed application routes without authentication")
-  const stopRoute = await fetch(new URL("/api/service/stop", info.url), {
+  const unauthorizedStop = await fetch(new URL("/api/service/stop", info.url), {
    method: "POST",
-    headers: { ...headers, "content-type": "application/json" },
+    headers: { "content-type": "application/json" },
    body: JSON.stringify({ instanceID: info.id }),
    signal: AbortSignal.timeout(5_000),
  })
-  if (stopRoute.status !== 404) throw new Error("Compiled service exposed the removed HTTP stop route")
+  if (unauthorizedStop.status !== 401) throw new Error("Compiled service accepted unauthenticated stop")

  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")

-  await Effect.runPromise(
-    Service.stop({ file: registration }).pipe(Effect.provide(NodeFileSystem.layer)),
+  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()),
  )
+  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")
@@ -59,21 +59,6 @@ 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,
@@ -82,12 +67,6 @@ 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),
@@ -117,6 +117,7 @@ const processEffect = Effect.fnUntraced(function* (options: Options) {
        serviceOptions === undefined
          ? undefined
          : {
+              instanceID,
              onListen: (address, shutdown) =>
                Effect.gen(function* () {
                  if (!config.password) yield* ServiceConfig.password(password)
@@ -179,38 +180,27 @@ const register = Effect.fnUntraced(function* (
    password,
  }
  const encoded = yield* encodeInfo(info)
-  const current = fs.readFileString(file).pipe(Effect.flatMap(decodeInfo))
-  const owns = (found: Info) =>
-    found.id === info.id &&
+  const current = fs.readFileString(file).pipe(
+    Effect.flatMap(decodeInfo),
+    Effect.orElseSucceed(() => undefined),
+  )
+  const owns = (found: Info | undefined) =>
+    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,
+    Effect.filterOrFail(owns),
+    Effect.repeat(Schedule.spaced("5 seconds")),
+    Effect.tapError(() =>
+      Effect.logWarning("managed service registration lost; shutting down", {
        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,
    Effect.andThen(shutdown),
    Effect.forkScoped,
@@ -41,8 +41,13 @@ 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> }
@@ -6,6 +6,8 @@ import { HttpApiClient } from "effect/unstable/httpapi"
 import { ClientApi } from "../../contract"
 import type {
  Endpoint0_0Output,
+  Endpoint0_1Input,
+  Endpoint0_1Output,
  Endpoint1_0Output,
  Endpoint2_0Input,
  Endpoint2_0Output,
@@ -246,7 +248,12 @@ const preserveStream =
 const Endpoint0_0 = (raw: RawClient["server.health"]) => () =>
  preserveEffect<Endpoint0_0Output>()(raw["health.get"]({}).pipe(Effect.mapError(mapClientError)))

-const adaptGroup0 = (raw: RawClient["server.health"]) => ({ get: Endpoint0_0(raw) })
+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 Endpoint1_0 = (raw: RawClient["server.server"]) => () =>
  preserveEffect<Endpoint1_0Output>()(raw["server.get"]({}).pipe(Effect.mapError(mapClientError)))
@@ -87,7 +87,7 @@ export const ensure = Effect.fn("service.ensure")(function* (options: EnsureOpti
      }
      if (timeouts.count >= 3) {
        yield* announce("missing")
-        yield* terminate(info, options, timing)
+        yield* evict(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* terminate(service.info, options, timing).pipe(Effect.ignore)
+      yield* kill(service, 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 info = yield* read(options.file)
-  if (info !== undefined) yield* terminate(info, options, defaultEnsureTiming)
+  const existing = yield* find(options)
+  if (existing !== undefined) yield* kill(existing, options, defaultEnsureTiming)
 })

 function fallback() {
@@ -243,6 +243,12 @@ 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) =>
@@ -263,21 +269,59 @@ function same(left: Info, right: Info) {
  return left.id === right.id && left.version === right.version && left.url === right.url && left.pid === right.pid
 }

-const terminate = Effect.fnUntraced(function* (info: Info, options: { readonly file?: string }, timing: EnsureTiming) {
+const evict = 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.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)))
-  }
+  if (Option.isSome(done)) return
+
  const latest = yield* read(options.file)
  if (latest === undefined || !same(latest, info)) return
-  const fs = yield* FileSystem.FileSystem
-  yield* fs.remove(options.file ?? fallback()).pipe(Effect.ignore)
+  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
 })

 /** Effect-based local service lifecycle operations. */
@@ -1,5 +1,7 @@
 import type {
  HealthGetOutput,
+  HealthStopInput,
+  HealthStopOutput,
  ServerGetOutput,
  LocationGetInput,
  LocationGetOutput,
@@ -365,6 +367,18 @@ 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) =>
@@ -2,6 +2,8 @@ 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 }
@@ -2271,6 +2273,10 @@ 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 = {
@@ -1,4 +1,4 @@
-import { readFile, rm } from "node:fs/promises"
+import { readFile } 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 } from "./generated/types.js"
+import type { ServiceHealth, ServiceStopResponse } 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 terminate(registration.info, options, timing)
+          await evict(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 terminate(service.info, options, timing).catch(() => undefined)
+          await kill(service, 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 info = await read(options.file)
-  if (info !== undefined) await terminate(info, options, defaultEnsureTiming)
+  const existing = await find(options)
+  if (existing !== undefined) await kill(existing, options, defaultEnsureTiming)
 }

 function fallback() {
@@ -199,6 +199,10 @@ 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)
@@ -226,19 +230,47 @@ 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 terminate(info: Info, options: { readonly file?: string }, timing: EnsureTiming) {
+async function evict(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))) {
-    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`)
-  }
+  if (await waitUntilStopped(info.pid, timing)) return
+
  const latest = await read(options.file)
  if (latest === undefined || !same(latest, info)) return
-  await rm(options.file ?? fallback(), { force: true })
+  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
 }

 function delay(milliseconds: number) {
@@ -28,7 +28,7 @@ if (mode === "delayed" || mode === "delayed-failed" || mode === "coordinated" ||

 let requests = 0
 let version = "test"
-if (mode === "old") version = "old"
+if (mode === "old" || mode === "reject-stop") 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,6 +36,17 @@ 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", "")
@@ -52,7 +63,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")
+    if (mode === "starting" || mode === "graceful" || mode === "reject-stop")
      return Response.json({ healthy: true, version, pid: process.pid })
    return Response.json({ healthy: true, version, pid: process.pid })
  },
@@ -70,10 +81,9 @@ await writeFile(
 )
 await rename(registration + ".tmp", registration)

-async function shutdown(signal?: NodeJS.Signals) {
-  if (signal !== undefined) await writeFile(registration + ".signal", signal)
+function shutdown() {
  server.stop(true)
  process.exit()
 }
-process.on("SIGTERM", () => void shutdown("SIGTERM"))
-process.on("SIGINT", () => void shutdown("SIGINT"))
+process.on("SIGTERM", shutdown)
+process.on("SIGINT", shutdown)
@@ -126,13 +126,13 @@ test("evicts an unresponsive registered service before starting its replacement"
  await waitForExit(replacement.pid)
 })

-test("signals the registered service process", async () => {
+test("requests graceful stop of the exact service instance", async () => {
  const registration = await setup("graceful")
+  const info = await Bun.file(registration).json()

  await Service.stop({ file: registration })

-  expect(await Bun.file(registration + ".signal").text()).toBe("SIGTERM")
-  expect(await Bun.file(registration).exists()).toBe(false)
+  expect(await Bun.file(registration + ".stop").json()).toEqual({ instanceID: info.id })
 })

 async function setup(mode: string) {
@@ -191,6 +191,22 @@ 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({
@@ -143,36 +143,40 @@ test("evicts an unresponsive registered service before starting its replacement"
  await waitForExit(replacement.pid)
 })

-test("signals an unresponsive registered service process", async () => {
+test("requests graceful stop of the exact service instance", async () => {
  const directory = await temp()
  const registration = join(directory, "service.json")
-  const process = spawn(registration, "hanging")
+  const process = spawn(registration, "graceful")
  await waitForFile(registration)
+  const info = await Bun.file(registration).json()

  await run(Service.stop({ file: registration }))
  await process.exited
-  expect(await Bun.file(registration + ".signal").text()).toBe("SIGTERM")
-  expect(await Bun.file(registration).exists()).toBe(false)
+  expect(await Bun.file(registration + ".stop").json()).toEqual({ instanceID: info.id })
 })

-test("signals an incompatible service before starting its replacement", async () => {
+test("does not spawn contenders while an incompatible service rejects replacement", async () => {
  const directory = await temp()
  const registration = join(directory, "service.json")
-  const existing = spawn(registration, "old")
+  const contender = join(directory, "contender.json")
+  const existing = spawn(registration, "reject-stop")
  await waitForFile(registration)
-  const endpoint = await run(
+  const controller = new AbortController()
+  const starting = Effect.runPromise(
    ensure({
      file: registration,
      version: "test",
-      command: [process.execPath, fixture, registration, "delayed", "10"],
-    }),
+      command: [process.execPath, fixture, contender, "record-start"],
+    }).pipe(Effect.provide(NodeFileSystem.layer)),
+    { signal: controller.signal },
  )
-  const replacement = await Bun.file(registration).json()

-  expect(await existing.exited).toBe(0)
-  expect(endpoint.url).toBe(replacement.url)
-  process.kill(replacement.pid, "SIGTERM")
-  await waitForExit(replacement.pid)
+  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)
 })

 test("a legacy health response is still replaced", async () => {
@@ -340,6 +344,17 @@ 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())
 }
@@ -149,7 +149,7 @@ export function normalize(input: unknown): Result {
    "agents",
    migratedAgents,
    nativeAgents,
-    migratedSmallModel !== undefined || isRecord(input.agent) || isRecord(input.mode) || isRecord(input.agents),
+    isRecord(input.agent) || isRecord(input.mode) || isRecord(input.agents),
    diagnostics,
  )

@@ -4,7 +4,6 @@ import type { AISDKHooks } from "@opencode-ai/plugin/effect/aisdk"
 import type { SessionHooks } from "@opencode-ai/plugin/effect/session"
 import type { ShellHooks } from "@opencode-ai/plugin/effect/shell"
 import type { ToolFailures, ToolHooks } from "@opencode-ai/plugin/effect/tool"
-import type { ModelHookOptions } from "@opencode-ai/plugin/effect/registration"
 import { Context, Effect, Layer, Scope } from "effect"
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
 import { State } from "../state.js"
@@ -27,26 +26,16 @@ interface Failures extends Record<keyof Domains, unknown> {
 }

 type Callback<Event, Error> = (event: Event) => Effect.Effect<void, Error>
-type Entry = { readonly callback: Function; readonly options?: ModelHookOptions }
-
-const eventProviderID = (event: unknown) => {
-  if (typeof event !== "object" || event === null || !("model" in event)) return undefined
-  const model = event.model
-  if (typeof model !== "object" || model === null || !("providerID" in model)) return undefined
-  return typeof model.providerID === "string" ? model.providerID : undefined
-}

 export interface Interface {
  readonly has: <Domain extends keyof Domains>(
    domain: Domain,
    name: keyof Domains[Domain] & keyof Failures[Domain],
-    providerID?: string,
  ) => Effect.Effect<boolean>
  readonly register: <Domain extends keyof Domains, Name extends keyof Domains[Domain] & keyof Failures[Domain]>(
    domain: Domain,
    name: Name,
    callback: Callback<Domains[Domain][Name], Failures[Domain][Name]>,
-    options?: ModelHookOptions,
  ) => Effect.Effect<State.Registration, never, Scope.Scope>
  readonly trigger: <Domain extends keyof Domains, Name extends keyof Domains[Domain] & keyof Failures[Domain]>(
    domain: Domain,
@@ -60,47 +49,36 @@ export class Service extends Context.Service<Service, Interface>()("@opencode/Pl
 const layer = Layer.effect(
  Service,
  Effect.gen(function* () {
-    const callbacks = new Map<string, Entry[]>()
+    const callbacks = new Map<string, Function[]>()
    const key = (domain: keyof Domains, name: PropertyKey) => `${domain}.${String(name)}`

-    const register: Interface["register"] = Effect.fn("PluginHooks.register")(
-      function* (domain, name, callback, options) {
-        const scope = yield* Scope.Scope
-        const id = key(domain, name)
-        let active = true
-        const entry = { callback, options }
-        callbacks.set(id, [...(callbacks.get(id) ?? []), entry])
-        const dispose = Effect.sync(() => {
-          if (!active) return
-          active = false
-          const next = (callbacks.get(id) ?? []).filter((item) => item !== entry)
-          if (next.length === 0) callbacks.delete(id)
-          else callbacks.set(id, next)
-        })
-        yield* Scope.addFinalizer(scope, dispose)
-        return { dispose }
-      },
-    )
+    const register: Interface["register"] = Effect.fn("PluginHooks.register")(function* (domain, name, callback) {
+      const scope = yield* Scope.Scope
+      const id = key(domain, name)
+      let active = true
+      callbacks.set(id, [...(callbacks.get(id) ?? []), callback])
+      const dispose = Effect.sync(() => {
+        if (!active) return
+        active = false
+        const next = (callbacks.get(id) ?? []).filter((item) => item !== callback)
+        if (next.length === 0) callbacks.delete(id)
+        else callbacks.set(id, next)
+      })
+      yield* Scope.addFinalizer(scope, dispose)
+      return { dispose }
+    })

    const trigger: Interface["trigger"] = Effect.fn("PluginHooks.trigger")(function* (domain, name, event) {
-      for (const entry of callbacks.get(key(domain, name)) ?? []) {
-        if (entry.options?.providerID !== undefined && entry.options.providerID !== eventProviderID(event)) continue
-        const result: Effect.Effect<void, Failures[typeof domain][typeof name]> = Reflect.apply(
-          entry.callback,
-          undefined,
-          [event],
-        )
+      for (const callback of callbacks.get(key(domain, name)) ?? []) {
+        const result: Effect.Effect<void, Failures[typeof domain][typeof name]> = Reflect.apply(callback, undefined, [
+          event,
+        ])
        yield* result
      }
      return event
    })

-    const has: Interface["has"] = (domain, name, providerID) =>
-      Effect.sync(() =>
-        (callbacks.get(key(domain, name)) ?? []).some(
-          (entry) => entry.options?.providerID === undefined || entry.options.providerID === providerID,
-        ),
-      )
+    const has: Interface["has"] = (domain, name) => Effect.sync(() => callbacks.has(key(domain, name)))

    return Service.of({ has, register, trigger })
  }),
@@ -104,10 +104,9 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: import("../p
        }),
    },
    aisdk: {
-      hook: (name, callback, options) => {
+      hook: (name, callback) => {
        if (name === "sdk") {
          return aisdk.hook.sdk((event) => {
-            if (options?.providerID !== undefined && options.providerID !== event.model.providerID) return Effect.void
            const output = {
              model: mutable(event.model),
              package: event.package,
@@ -120,7 +119,6 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: import("../p
          })
        }
        return aisdk.hook.language((event) => {
-          if (options?.providerID !== undefined && options.providerID !== event.model.providerID) return Effect.void
          const output = {
            model: mutable(event.model),
            options: event.options,
@@ -384,7 +382,7 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: import("../p
        }),
    },
    session: {
-      hook: (name, callback, options) => hooks.register("session", name, callback, options),
+      hook: (name, callback) => hooks.register("session", name, callback),
      create: (input) =>
        runtime.session.create({
          id: input?.id,
@@ -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()) {
@@ -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,13 +55,8 @@ export const ModelsDevPlugin = define({
 })

 function environmentNames(provider: ModelsDev.Snapshot) {
-  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]
+  if (provider.info.id !== Provider.ID.azure) return [...provider.environment]
+  return [...provider.environment.filter((name) => name.endsWith("_API_KEY")), "AZURE_COGNITIVE_SERVICES_API_KEY"]
 }

 function snapshots(data: readonly ModelsDev.Snapshot[]) {
@@ -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()) {
@@ -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(() => {
@@ -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(() => {
@@ -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
@@ -241,22 +241,19 @@ export const GithubCopilotPlugin = define({
        evt.sdk = mod.createOpenaiCompatible(evt.options)
      }),
    )
-    yield* ctx.session.hook(
-      "http.request",
-      (evt) =>
-        Effect.gen(function* () {
-          if (evt.model.providerID !== Provider.ID.githubCopilot) return
-          if (evt.agent === Agent.ID.make("title"))
-            evt.request.headers.set("X-Interaction-Type", "conversation-background")
-          if (evt.agent === Agent.ID.make("compaction"))
-            evt.request.headers.set("X-Interaction-Type", "conversation-compaction")
-          const token = evt.request.headers.get("x-api-key")
-          if (!token) return
-          const text = yield* Effect.promise(() => evt.request.clone().text())
-          const body = Option.getOrUndefined(decodeBody(text))
-          applyHeaders(evt.request.headers, token, ctx.app, requestMetadata(evt.request.url, body), true)
-        }),
-      { providerID: Provider.ID.githubCopilot },
+    yield* ctx.session.hook("http.request", (evt) =>
+      Effect.gen(function* () {
+        if (evt.model.providerID !== Provider.ID.githubCopilot) return
+        if (evt.agent === Agent.ID.make("title"))
+          evt.request.headers.set("X-Interaction-Type", "conversation-background")
+        if (evt.agent === Agent.ID.make("compaction"))
+          evt.request.headers.set("X-Interaction-Type", "conversation-compaction")
+        const token = evt.request.headers.get("x-api-key")
+        if (!token) return
+        const text = yield* Effect.promise(() => evt.request.clone().text())
+        const body = Option.getOrUndefined(decodeBody(text))
+        applyHeaders(evt.request.headers, token, ctx.app, requestMetadata(evt.request.url, body), true)
+      }),
    )
    yield* ctx.aisdk.hook(
      "language",
@@ -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,9 +71,6 @@ 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 } : {}),
@@ -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",
@@ -5,6 +5,7 @@ import { App } from "../../app.js"
 import { Credential } from "../../credential.js"
 import { Bus } from "../../bus.js"
 import { Integration } from "../../integration.js"
+import { Model } from "../../model.js"
 import { OauthCallbackPage } from "../../oauth/page.js"
 import { Provider } from "../../provider.js"
 import type { PluginInternal } from "../internal.js"
@@ -229,17 +230,15 @@ export const OpenAIPlugin = define({
        })
      }
    })
-    yield* ctx.session.hook(
-      "model.request",
-      (evt) =>
-        Effect.sync(() => {
-          if (!chatgpt) return
-          if (evt.baseURL && URL.canParse(evt.baseURL) && new URL(evt.baseURL).origin === "https://api.openai.com")
-            evt.baseURL = codexBaseURL
-          evt.headers.originator = "opencode"
-          evt.headers["session-id"] = evt.sessionID
-        }),
-      { providerID: Provider.ID.openai },
+    yield* ctx.session.hook("http.request", (evt) =>
+      Effect.sync(() => {
+        if (!chatgpt || evt.model.providerID !== Provider.ID.openai) return
+        const url = new URL(evt.request.url)
+        evt.request.headers.set("originator", "opencode")
+        evt.request.headers.set("session-id", evt.sessionID)
+        if (url.origin !== "https://api.openai.com") return
+        evt.request = new Request(`${codexBaseURL}${url.pathname.replace(/^\/v1/, "")}${url.search}`, evt.request)
+      }),
    )
    const refresh = () => loading.withPermit(load().pipe(Effect.andThen(ctx.catalog.reload())))
    yield* bus.subscribe(Integration.Event.ConnectionUpdated).pipe(
@@ -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(
@@ -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",
@@ -33,7 +33,7 @@ export const Plugins = [OpenAIPlugin, GooglePlugin, AnthropicPlugin, KimiPlugin,

 function make(id: string, select: (modelID: string) => string | undefined) {
  return define({
-    id: `opencode.prompt.${id}`,
+    id: `opencode.system-prompt.${id}`,
    effect: Effect.fn(`SystemPromptPlugin.${id}`)(function* (ctx) {
      yield* ctx.session.hook("context", (event) =>
        Effect.gen(function* () {
@@ -48,17 +48,6 @@ 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")],
@@ -12,7 +12,6 @@ import { llmClient } from "../effect/app-node-platform.js"
 import { SessionEvent } from "./event.js"
 import type { SessionMessage } from "./message.js"
 import { SessionModelHeaders } from "./model-headers.js"
-import { SessionModelHook } from "./model-hook.js"
 import { SessionModelHttp } from "./model-http.js"
 import { SessionPromptCacheKey } from "./prompt-cache-key.js"
 import { App } from "../app.js"
@@ -271,25 +270,23 @@ const make = (dependencies: Dependencies) => {
          })
        : Effect.void,
    )
-    const request = yield* SessionModelHook.apply(
-      dependencies.hooks,
-      { sessionID: plan.session.id, agent: Agent.ID.make("compaction"), model: plan.ref },
-      LLM.request({
-        model: plan.model,
-        promptCacheKey: SessionPromptCacheKey.make(plan.session.id),
-        http: { headers: SessionModelHeaders.make(plan.session, dependencies.app) },
-        messages: [Message.user(plan.prompt)],
-        tools: [],
-      }),
-    )
    yield* dependencies.llm
-      .stream(request, {
-        http: SessionModelHttp.middleware(dependencies.hooks, {
-          sessionID: plan.session.id,
-          agent: Agent.ID.make("compaction"),
-          model: plan.ref,
+      .stream(
+        LLM.request({
+          model: plan.model,
+          promptCacheKey: SessionPromptCacheKey.make(plan.session.id),
+          http: { headers: SessionModelHeaders.make(plan.session, dependencies.app) },
+          messages: [Message.user(plan.prompt)],
+          tools: [],
        }),
-      })
+        {
+          http: SessionModelHttp.middleware(dependencies.hooks, {
+            sessionID: plan.session.id,
+            agent: Agent.ID.make("compaction"),
+            model: plan.ref,
+          }),
+        },
+      )
      .pipe(
        Stream.runForEach((event) => {
          if (LLMEvent.is.providerError(event))
@@ -11,7 +11,6 @@ import { SessionContext } from "./context.js"
 import { SessionGenerate } from "./generate.js"
 import { SessionHistory } from "./history.js"
 import { SessionModelHeaders } from "./model-headers.js"
-import { SessionModelHook } from "./model-hook.js"
 import { SessionModelHttp } from "./model-http.js"
 import { SessionPromptCacheKey } from "./prompt-cache-key.js"
 import { SessionRunnerModel } from "./runner/model.js"
@@ -72,9 +71,7 @@ export const layer = Layer.effect(
          providerID: model.ref.providerID,
          modelID: model.ref.id,
        })
-        const request = yield* SessionModelHook.apply(
-          hooks,
-          { sessionID: selection.session.id, agent: selection.agent.id, model: model.ref },
+        const response = yield* llm.generate(
          LLM.request({
            model: model.model,
            http: { headers: SessionModelHeaders.make(selection.session, app) },
@@ -83,14 +80,14 @@ export const layer = Layer.effect(
            messages: contextEvent.messages,
            tools: hookedTools,
          }),
+          {
+            http: SessionModelHttp.middleware(hooks, {
+              sessionID: selection.session.id,
+              agent: selection.agent.id,
+              model: model.ref,
+            }),
+          },
        )
-        const response = yield* llm.generate(request, {
-          http: SessionModelHttp.middleware(hooks, {
-            sessionID: selection.session.id,
-            agent: selection.agent.id,
-            model: model.ref,
-          }),
-        })
        yield* Effect.logInfo("session generation usage diagnostic", { usage: response.usage })
        return response.text
      }),
@@ -1,34 +0,0 @@
-export * as SessionModelHook from "./model-hook.js"
-
-import { HttpOptions, LanguageModel, LLMRequest } from "@opencode-ai/ai"
-import type { Agent } from "@opencode-ai/schema/agent"
-import type { Model } from "@opencode-ai/schema/model"
-import type { Session } from "@opencode-ai/schema/session"
-import { Effect } from "effect"
-import { PluginHooks } from "../plugin/hooks.js"
-
-export const apply = (
-  hooks: PluginHooks.Interface,
-  input: { readonly sessionID: Session.ID; readonly agent: Agent.ID; readonly model: Model.Ref },
-  request: LLMRequest,
-) =>
-  Effect.gen(function* () {
-    const currentBaseURL = request.model.route.endpoint.baseURL
-    const event = yield* hooks.trigger("session", "model.request", {
-      ...input,
-      baseURL: typeof currentBaseURL === "string" ? currentBaseURL : undefined,
-      headers: { ...request.http?.headers },
-    })
-    const route =
-      event.baseURL !== undefined && event.baseURL !== currentBaseURL
-        ? request.model.route.with({ endpoint: { baseURL: event.baseURL } })
-        : request.model.route
-    return LLMRequest.update(request, {
-      model: route === request.model.route ? request.model : LanguageModel.update(request.model, { route }),
-      http: new HttpOptions({
-        body: request.http?.body,
-        headers: Object.keys(event.headers).length === 0 ? undefined : event.headers,
-        query: request.http?.query,
-      }),
-    })
-  })
@@ -14,7 +14,6 @@ import { QuestionTool } from "../tool/plugin/question.js"
 import { Tool } from "../tool.js"
 import { SessionContext } from "./context.js"
 import { SessionModelHeaders } from "./model-headers.js"
-import { SessionModelHook } from "./model-hook.js"
 import { SessionModelHttp } from "./model-http.js"
 import { SessionModelTransport } from "./model-transport.js"
 import { SessionPromptCacheKey } from "./prompt-cache-key.js"
@@ -227,25 +226,19 @@ export const layer = Layer.effect(
          return [[name, { ...tool, description: definition.description, inputSchema: definition.input }] as const]
        }),
      )
-      const request = yield* SessionModelHook.apply(
-        hooks,
-        { sessionID: session.id, agent: agent.id, model: resolved.ref },
-        LLM.request({
-          model,
-          http: {
-            headers: SessionModelHeaders.make(session, app),
-          },
-          // 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 })),
-          toolChoice: stepLimitReached ? "none" : undefined,
-        }),
-      )
+      const request = LLM.request({
+        model,
+        http: {
+          headers: SessionModelHeaders.make(session, app),
+        },
+        promptCacheKey: SessionPromptCacheKey.make(session.id),
+        system: context.system,
+        messages: boundImages(unsupportedParts(context.messages, resolved.capabilities)),
+        tools: Array.from(hooked, ([name, tool]) => ({ ...tool, name })),
+        toolChoice: stepLimitReached ? "none" : undefined,
+      })
      const webSocketEligible =
-        !(yield* hooks.has("session", "http.request", resolved.ref.providerID)) &&
-        !(yield* hooks.has("session", "http.response", resolved.ref.providerID))
+        !(yield* hooks.has("session", "http.request")) && !(yield* hooks.has("session", "http.response"))
      const http = webSocketEligible
        ? undefined
        : SessionModelHttp.middleware(hooks, {
@@ -258,7 +251,7 @@ export const layer = Layer.effect(
        ...(webSocket &&
        webSocketEligible &&
        resolved.ref.providerID === Provider.ID.openai &&
-        request.model.route.id === "openai-responses"
+        model.route.id === "openai-responses"
          ? { webSocket: transport.bind(session.id) }
          : {}),
      }
@@ -14,7 +14,6 @@ import { PluginHooks } from "../plugin/hooks.js"
 import { SessionEvent } from "./event.js"
 import { SessionHistory } from "./history.js"
 import { SessionModelHeaders } from "./model-headers.js"
-import { SessionModelHook } from "./model-hook.js"
 import { SessionModelHttp } from "./model-http.js"
 import { SessionRunnerModel } from "./runner/model.js"
 import { SessionSchema } from "./schema.js"
@@ -81,25 +80,23 @@ const make = (dependencies: Dependencies) => {
          })
        : Effect.void,
    )
-    const request = yield* SessionModelHook.apply(
-      dependencies.hooks,
-      { sessionID: session.id, agent: agent.id, model: resolved.ref },
-      LLM.request({
-        model: resolved.model,
-        http: { headers: SessionModelHeaders.make(session, dependencies.app) },
-        system: agent.system,
-        messages: [Message.user(firstUser.text)],
-        tools: [],
-      }),
-    )
    const streamed = yield* dependencies.llm
-      .stream(request, {
-        http: SessionModelHttp.middleware(dependencies.hooks, {
-          sessionID: session.id,
-          agent: agent.id,
-          model: resolved.ref,
+      .stream(
+        LLM.request({
+          model: resolved.model,
+          http: { headers: SessionModelHeaders.make(session, dependencies.app) },
+          system: agent.system,
+          messages: [Message.user(firstUser.text)],
+          tools: [],
        }),
-      })
+        {
+          http: SessionModelHttp.middleware(dependencies.hooks, {
+            sessionID: session.id,
+            agent: agent.id,
+            model: resolved.ref,
+          }),
+        },
+      )
      .pipe(
        Stream.runForEach((event) => {
          if (LLMEvent.is.providerError(event)) failed = true
@@ -5,8 +5,7 @@ import { Money } from "@opencode-ai/schema/money"
 import type { TokenUsage } from "@opencode-ai/schema/token-usage"
 import type { Model } from "../model.js"

-const finite = (value: number) => (Number.isFinite(value) ? value : 0)
-const safe = (value: number | undefined) => Math.max(0, finite(value ?? 0))
+const safe = (value: number | undefined) => Math.max(0, Number.isFinite(value) ? (value ?? 0) : 0)

 export const tokens = (usage: Usage | undefined): TokenUsage.Info => ({
  input: safe(usage?.nonCachedInputTokens),
@@ -27,10 +26,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 * finite(cost.input) +
-      (usage.output + usage.reasoning) * finite(cost.output) +
-      usage.cache.read * finite(cost.cache.read) +
-      usage.cache.write * finite(cost.cache.write)) /
+    (usage.input * cost.input +
+      (usage.output + usage.reasoning) * cost.output +
+      usage.cache.read * cost.cache.read +
+      usage.cache.write * cost.cache.write) /
      1_000_000,
  )
 }
@@ -150,16 +150,6 @@ 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" } },
@@ -421,48 +421,8 @@ 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")
-    }),
-  )
-
-  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"] }],
-      })
+      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")
    }),
  )

@@ -320,14 +320,10 @@ describe("fromPromise", () => {
        define({
          id: "promise-session-http",
          setup: async (ctx) => {
-            await ctx.session.hook(
-              "http.request",
-              (event) => {
-                event.request = new Request("https://provider.test/changed", event.request)
-                event.request.headers.set("x-hook", "promise")
-              },
-              { providerID: "test" },
-            )
+            await ctx.session.hook("http.request", (event) => {
+              event.request = new Request("https://provider.test/changed", event.request)
+              event.request.headers.set("x-hook", "promise")
+            })
            await ctx.session.hook("http.response", async (event) => {
              event.response = new Response(`${await event.response.text()}-response`, {
                status: event.response.status,
@@ -346,11 +342,6 @@ describe("fromPromise", () => {
        ...context,
        request: new Request("https://provider.test", { method: "POST", body: "payload" }),
      })
-      const ignored = yield* hooks.trigger("session", "http.request", {
-        ...context,
-        model: Model.Ref.make({ providerID: Provider.ID.make("other"), id: Model.ID.make("model") }),
-        request: new Request("https://other.test"),
-      })
      const response = yield* hooks.trigger("session", "http.response", {
        ...context,
        request: request.request,
@@ -358,9 +349,6 @@ describe("fromPromise", () => {
      })

      expect(request.request.url).toBe("https://provider.test/changed")
-      expect(ignored.request.url).toBe("https://other.test/")
-      expect(yield* hooks.has("session", "http.request", Provider.ID.make("test"))).toBe(true)
-      expect(yield* hooks.has("session", "http.request", Provider.ID.make("other"))).toBe(false)
      expect(yield* Effect.promise(() => response.response.text())).toBe("promise-response")
    }),
  )
@@ -141,52 +141,6 @@ 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(
      {
@@ -1,25 +1,17 @@
 import { Money } from "@opencode-ai/schema/money"
 import { Agent } from "@opencode-ai/schema/agent"
 import { Session } from "@opencode-ai/schema/session"
-import { OpenAIResponses } from "@opencode-ai/ai/protocols/openai-responses"
 import { describe, expect } from "bun:test"
-import { ConfigProvider, DateTime, Effect } from "effect"
+import { Effect } from "effect"
 import { Catalog } from "@opencode-ai/core/catalog"
 import { Credential } from "@opencode-ai/core/credential"
 import { Integration } from "@opencode-ai/core/integration"
-import { Location } from "@opencode-ai/core/location"
 import { Model } from "@opencode-ai/core/model"
 import { Plugin } from "@opencode-ai/core/plugin"
 import { PluginHost } from "@opencode-ai/core/plugin/host"
 import { PluginHooks } from "@opencode-ai/core/plugin/hooks"
-import { GithubCopilotPlugin } from "@opencode-ai/core/plugin/provider/github-copilot"
 import { OpenAIPlugin } from "@opencode-ai/core/plugin/provider/openai"
-import { Project } from "@opencode-ai/core/project"
 import { Provider } from "@opencode-ai/core/provider"
-import { AbsolutePath } from "@opencode-ai/core/schema"
-import { SessionModelRequest } from "@opencode-ai/core/session/model-request"
-import { SessionModelTransport } from "@opencode-ai/core/session/model-transport"
-import { SessionRunnerModel } from "@opencode-ai/core/session/runner/model"
 import { testEffect } from "../lib/effect"
 import { PluginTestLayer } from "./fixture"

@@ -32,33 +24,19 @@ const addPlugin = Effect.fn(function* () {
  yield* OpenAIPlugin.effect(host).pipe(Effect.provideService(Integration.Service, integrations))
 })

-const addGithubCopilotPlugin = Effect.fn(function* () {
-  const plugin = yield* Plugin.Service
-  const host = yield* PluginHost.make(plugin)
-  yield* GithubCopilotPlugin.effect(host)
-})
-
 function required<T>(value: T | undefined): T {
  if (value === undefined) throw new Error("Expected value")
  return value
 }

-const request = Effect.fn(function* (providerID: Provider.ID, baseURL: string) {
-  const hooks = yield* PluginHooks.Service
-  const event = yield* hooks.trigger("session", "model.request", {
+const http = Effect.fn(function* (providerID: Provider.ID, url: string) {
+  const event = yield* (yield* PluginHooks.Service).trigger("session", "http.request", {
    sessionID: Session.ID.make("ses_test"),
    agent: Agent.ID.make("build"),
    model: Model.Ref.make({ providerID, id: Model.ID.make("gpt-5.5") }),
-    baseURL,
-    headers: {},
+    request: new Request(url, { method: "POST", body: "{}" }),
  })
-  return {
-    baseURL: event.baseURL,
-    headers: event.headers,
-    hasHttpHooks:
-      (yield* hooks.has("session", "http.request", providerID)) ||
-      (yield* hooks.has("session", "http.response", providerID)),
-  }
+  return { url: event.request.url, headers: Object.fromEntries(event.request.headers.entries()) }
 })

 describe("OpenAIPlugin", () => {
@@ -132,19 +110,18 @@ describe("OpenAIPlugin", () => {
      })
      yield* addPlugin()

-      const direct = yield* request(Provider.ID.openai, "https://api.openai.com/v1")
-      const custom = yield* request(Provider.ID.make("custom-openai"), "https://custom.example/v1")
-      const proxy = yield* request(Provider.ID.openai, "https://proxy.example/v1?region=us")
+      const request = yield* http(Provider.ID.openai, "https://api.openai.com/v1/responses")
+      const custom = yield* http(Provider.ID.make("custom-openai"), "https://custom.example/v1/responses")
+      const proxy = yield* http(Provider.ID.openai, "https://proxy.example/v1/responses?region=us")

      const provider = required(yield* catalog.provider.get(Provider.ID.openai))
      expect(provider.package).toBe("@opencode-ai/ai/providers/openai")
      expect(provider.settings).toMatchObject({ baseURL: "https://chatgpt.com/backend-api/codex" })
      expect(provider.headers).toMatchObject({ originator: "opencode", "chatgpt-account-id": "acct_123" })
-      expect(direct.baseURL).toBe("https://chatgpt.com/backend-api/codex")
-      expect(direct.headers).toMatchObject({ originator: "opencode", "session-id": "ses_test" })
-      expect(direct.hasHttpHooks).toBe(false)
+      expect(request.url).toBe("https://chatgpt.com/backend-api/codex/responses")
+      expect(request.headers).toMatchObject({ originator: "opencode", "session-id": "ses_test" })
      expect(custom.headers).not.toHaveProperty("originator")
-      expect(proxy.baseURL).toBe("https://proxy.example/v1?region=us")
+      expect(proxy.url).toBe("https://proxy.example/v1/responses?region=us")
      expect(proxy.headers).toMatchObject({ originator: "opencode", "session-id": "ses_test" })
      const eligible = required(yield* catalog.model.get(Provider.ID.openai, Model.ID.make("gpt-5.5")))
      expect(eligible.package).toBe("@opencode-ai/ai/providers/openai")
@@ -190,77 +167,16 @@ describe("OpenAIPlugin", () => {
      })
      yield* addPlugin()

-      const direct = yield* request(Provider.ID.openai, "https://api.openai.com/v1")
+      const request = yield* http(Provider.ID.openai, "https://api.openai.com/v1/responses")

      const provider = required(yield* catalog.provider.get(Provider.ID.openai))
      const model = required(yield* catalog.model.get(Provider.ID.openai, Model.ID.make("gpt-5.5")))
      expect(model.package).toBe("@opencode-ai/ai/providers/openai")
      expect(model.enabled).toBe(true)
      expect(model.limit).toEqual({ context: 1_050_000, input: 922_000, output: 128_000 })
-      expect(direct.headers).not.toHaveProperty("originator")
-      expect(direct.hasHttpHooks).toBe(false)
+      expect(request.headers).not.toHaveProperty("originator")
      expect(provider.headers).not.toHaveProperty("originator")
      expect(required(yield* catalog.model.get(Provider.ID.openai, Model.ID.make("gpt-4.1"))).enabled).toBe(true)
    }),
  )
-
-  it.effect("selects WebSocket with the built-in provider hooks enabled", () =>
-    Effect.gen(function* () {
-      const credentials = yield* Credential.Service
-      yield* credentials.create({
-        integrationID: Integration.ID.make("openai"),
-        value: Credential.Key.make({ type: "key", key: "sk-test" }),
-      })
-      yield* addPlugin()
-      yield* addGithubCopilotPlugin()
-      const executor = { execute: () => Effect.die("unused WebSocket execution") }
-      const transport = SessionModelTransport.Service.of({
-        bind: () => executor,
-        close: () => Effect.void,
-        closeAll: Effect.void,
-      })
-      const sessionID = Session.ID.make("ses_websocket_hooks")
-      const agentID = Agent.ID.make("build")
-      const agent = Agent.Info.make(Agent.Info.default(agentID))
-      const model = SessionRunnerModel.resolved(OpenAIResponses.route.model({ id: "gpt-5.5" }), {
-        capabilities: { tools: true, input: ["text"], output: ["text"] },
-        cost: [],
-      })
-      const program = Effect.gen(function* () {
-        const requests = yield* SessionModelRequest.Service
-        return yield* requests.prepare({
-          context: {
-            session: Session.Info.make({
-              id: sessionID,
-              projectID: Project.ID.global,
-              cost: Money.USD.zero,
-              tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
-              time: { created: DateTime.makeUnsafe(0), updated: DateTime.makeUnsafe(0) },
-              location: Location.Ref.make({ directory: AbsolutePath.make("/project") }),
-            }),
-            agent: { id: agentID, info: agent },
-            model,
-            initial: "",
-            messages: [],
-            tools: { definitions: [], execute: () => Effect.die("unused tool execution") },
-          },
-          step: 1,
-        })
-      }).pipe(
-        Effect.provide(SessionModelRequest.layer),
-        Effect.provideService(SessionModelTransport.Service, transport),
-        Effect.provide(
-          ConfigProvider.layer(
-            ConfigProvider.fromEnv({ env: { OPENCODE_EXPERIMENTAL_OPENAI_RESPONSES_WEBSOCKET: "true" } }),
-          ),
-        ),
-      )
-
-      const prepared = yield* program
-
-      expect(prepared.webSocketEligible).toBe(true)
-      expect(prepared.options.webSocket).toBe(executor)
-      expect(prepared.options.http).toBeUndefined()
-    }),
-  )
 })
@@ -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"),
      )
    }),
  )
@@ -48,12 +48,12 @@ describe("SystemPromptPlugin", () => {

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

@@ -1,20 +0,0 @@
-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()
-    }
-  })
-})
@@ -291,25 +291,18 @@ it.effect(
      instruction = "Changed context"
      const before = yield* durableState(db, sessionID)
      const hooks = yield* PluginHooks.Service
-      let modelRequestHook = false
      yield* hooks.register("session", "context", (event) =>
        Effect.sync(() => {
          event.system = [SystemPart.make("Hooked system"), ...event.system]
          if (event.tools.lookup) event.tools.lookup.description = "Hooked lookup"
        }),
      )
-      yield* hooks.register("session", "model.request", () =>
-        Effect.sync(() => {
-          modelRequestHook = true
-        }),
-      )

      const generate = yield* SessionGenerate.Service
      const result = yield* generate.generate({ sessionID, prompt: "Summarize privately" })

      expect(result).toBe("Transient answer")
      expect(requests).toHaveLength(1)
-      expect(modelRequestHook).toBe(true)
      expect(hasHttpMiddleware).toBe(true)
      expect(requests[0]?.model).toBe(model)
      expect(requests[0]?.system[0]?.text).toBe("Hooked system")
@@ -197,29 +197,6 @@ 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(
@@ -1020,36 +997,6 @@ describe("SessionRunnerLLM", () => {
    }),
  )

-  it.effect("keeps WebSocket eligibility after model request hooks", () =>
-    Effect.gen(function* () {
-      yield* setup
-      const hooks = yield* PluginHooks.Service
-      yield* hooks.register("session", "model.request", (event) =>
-        Effect.sync(() => {
-          event.headers["x-model-request-hook"] = "active"
-        }),
-      )
-      yield* hooks.register("session", "http.request", () => Effect.die("Other-provider HTTP hook should not apply"), {
-        providerID: Provider.ID.githubCopilot,
-      })
-      const context = yield* SessionContext.Service
-      const modelRequests = yield* SessionModelRequest.Service
-      const selected = yield* context.select(sessionID)
-      const database = yield* Database.Service
-      const bus = yield* Bus.Service
-      yield* InstructionState.prepare(database.db, bus, selected.instructions, sessionID)
-
-      const prepared = yield* modelRequests.prepare({
-        context: yield* context.load(selected),
-        step: 1,
-      })
-
-      expect(prepared.request.http?.headers?.["x-model-request-hook"]).toBe("active")
-      expect(prepared.webSocketEligible).toBe(true)
-      expect(prepared.options.http).toBeUndefined()
-    }),
-  )
-
  it.effect("forces HTTP and triggers active request and response hooks once", () =>
    Effect.gen(function* () {
      yield* setup
@@ -1,6 +1,6 @@
 import type { LanguageModelV3 } from "@ai-sdk/provider"
 import type { Model } from "@opencode-ai/schema/model"
-import type { ModelHooks } from "./registration.js"
+import type { Hooks } from "./registration.js"

 export interface AISDKHooks {
  sdk: {
@@ -18,5 +18,5 @@ export interface AISDKHooks {
 }

 export interface AISDKDomain {
-  readonly hook: ModelHooks<AISDKHooks>
+  readonly hook: Hooks<AISDKHooks>
 }
@@ -4,11 +4,6 @@ export interface Registration {
  readonly dispose: Effect.Effect<void>
 }

-export interface ModelHookOptions {
-  /** Limits the hook to one provider. Unscoped hooks apply to every provider. */
-  readonly providerID?: string
-}
-
 export type Hooks<Spec, Failures extends Record<keyof Spec, unknown> = Record<keyof Spec, never>> = <
  Name extends keyof Spec,
 >(
@@ -16,12 +11,4 @@ export type Hooks<Spec, Failures extends Record<keyof Spec, unknown> = Record<ke
  callback: (input: Spec[Name]) => Effect.Effect<void, Failures[Name]>,
 ) => Effect.Effect<Registration, never, Scope.Scope>

-export type ModelHooks<Spec, Failures extends Record<keyof Spec, unknown> = Record<keyof Spec, never>> = <
-  Name extends keyof Spec,
->(
-  name: Name,
-  callback: (input: Spec[Name]) => Effect.Effect<void, Failures[Name]>,
-  options?: ModelHookOptions,
-) => Effect.Effect<Registration, never, Scope.Scope>
-
 export type Transform<Input> = (callback: (input: Input) => void) => Effect.Effect<Registration, never, Scope.Scope>
@@ -4,7 +4,7 @@ import type { Agent } from "@opencode-ai/schema/agent"
 import type { Model } from "@opencode-ai/schema/model"
 import type { Session } from "@opencode-ai/schema/session"
 import type { JsonSchema } from "effect"
-import type { ModelHooks } from "./registration.js"
+import type { Hooks } from "./registration.js"

 export interface SessionContext {
  readonly sessionID: Session.ID
@@ -15,14 +15,6 @@ export interface SessionContext {
  tools: Record<string, { description: string; input: JsonSchema.JsonSchema }>
 }

-export interface SessionModelRequest {
-  readonly sessionID: Session.ID
-  readonly agent: Agent.ID
-  readonly model: Model.Ref
-  baseURL?: string
-  headers: Record<string, string>
-}
-
 export interface SessionHttpRequest {
  readonly sessionID: Session.ID
  readonly agent: Agent.ID
@@ -40,7 +32,6 @@ export interface SessionHttpResponse {

 export interface SessionHooks {
  readonly context: SessionContext
-  readonly "model.request": SessionModelRequest
  readonly "http.request": SessionHttpRequest
  readonly "http.response": SessionHttpResponse
 }
@@ -49,5 +40,5 @@ export type SessionDomain = Pick<
  SessionApi<unknown>,
  "create" | "get" | "prompt" | "generate" | "command" | "synthetic" | "interrupt" | "rename" | "wait"
 > & {
-  readonly hook: ModelHooks<SessionHooks>
+  readonly hook: Hooks<SessionHooks>
 }
@@ -129,10 +129,8 @@ export function fromPromise(plugin: Plugin) {
            reload: () => run(host.agent.reload()),
          },
          aisdk: {
-            hook: (name, callback, options) =>
-              register(
-                host.aisdk.hook(name, (event) => Effect.promise(() => Promise.resolve(callback(event))), options),
-              ),
+            hook: (name, callback) =>
+              register(host.aisdk.hook(name, (event) => Effect.promise(() => Promise.resolve(callback(event))))),
          },
          catalog: {
            provider: {
@@ -296,10 +294,8 @@ export function fromPromise(plugin: Plugin) {
              ),
          },
          session: {
-            hook: (name, callback, options) =>
-              register(
-                host.session.hook(name, (event) => Effect.promise(() => Promise.resolve(callback(event))), options),
-              ),
+            hook: (name, callback) =>
+              register(host.session.hook(name, (event) => Effect.promise(() => Promise.resolve(callback(event))))),
            create: adaptApiMethod(SessionEndpoints["session.create"], host.session.create),
            get: adaptApiMethod(SessionEndpoints["session.get"], host.session.get),
            prompt: adaptApiMethod(SessionEndpoints["session.prompt"], host.session.prompt),
@@ -1,6 +1,6 @@
 import type { LanguageModelV3 } from "@ai-sdk/provider"
 import type { Model } from "@opencode-ai/schema/model"
-import type { ModelHooks } from "./registration.js"
+import type { Hooks } from "./registration.js"

 export interface AISDKHooks {
  sdk: {
@@ -18,5 +18,5 @@ export interface AISDKHooks {
 }

 export interface AISDKDomain {
-  readonly hook: ModelHooks<AISDKHooks>
+  readonly hook: Hooks<AISDKHooks>
 }
@@ -2,20 +2,9 @@ export interface Registration {
  readonly dispose: () => Promise<void>
 }

-export interface ModelHookOptions {
-  /** Limits the hook to one provider. Unscoped hooks apply to every provider. */
-  readonly providerID?: string
-}
-
 export type Hooks<Spec> = <Name extends keyof Spec>(
  name: Name,
  callback: (input: Spec[Name]) => Promise<void> | void,
 ) => Promise<Registration>

-export type ModelHooks<Spec> = <Name extends keyof Spec>(
-  name: Name,
-  callback: (input: Spec[Name]) => Promise<void> | void,
-  options?: ModelHookOptions,
-) => Promise<Registration>
-
 export type Transform<Input> = (callback: (input: Input) => void) => Promise<Registration>
@@ -4,7 +4,7 @@ import type { Agent } from "@opencode-ai/schema/agent"
 import type { Model } from "@opencode-ai/schema/model"
 import type { Session } from "@opencode-ai/schema/session"
 import type { JsonSchema } from "effect"
-import type { ModelHooks } from "./registration.js"
+import type { Hooks } from "./registration.js"

 export interface SessionContext {
  readonly sessionID: Session.ID
@@ -15,14 +15,6 @@ export interface SessionContext {
  tools: Record<string, { description: string; input: JsonSchema.JsonSchema }>
 }

-export interface SessionModelRequest {
-  readonly sessionID: Session.ID
-  readonly agent: Agent.ID
-  readonly model: Model.Ref
-  baseURL?: string
-  headers: Record<string, string>
-}
-
 export interface SessionHttpRequest {
  readonly sessionID: Session.ID
  readonly agent: Agent.ID
@@ -40,7 +32,6 @@ export interface SessionHttpResponse {

 export interface SessionHooks {
  readonly context: SessionContext
-  readonly "model.request": SessionModelRequest
  readonly "http.request": SessionHttpRequest
  readonly "http.response": SessionHttpResponse
 }
@@ -49,5 +40,5 @@ export type SessionDomain = Pick<
  SessionApi,
  "create" | "get" | "prompt" | "generate" | "command" | "synthetic" | "interrupt" | "rename" | "wait"
 > & {
-  readonly hook: ModelHooks<SessionHooks>
+  readonly hook: Hooks<SessionHooks>
 }
@@ -48,6 +48,58 @@
        "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"],
@@ -9731,6 +9783,26 @@
        "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": [
          {
@@ -9,6 +9,16 @@ 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")
@@ -23,4 +33,16 @@ 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" }))
@@ -4,15 +4,17 @@ 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,
-      }
-    }),
-  ),
+  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 })),
 )
@@ -1,10 +1,12 @@
 export * as ServerProcess from "./process"

-import { NodeHttpServer } from "@effect/platform-node"
+import { NodeHttpServer, NodeHttpServerRequest } 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, Scope } from "effect"
+import { Cause, Context, Deferred, Effect, Exit, Layer, Option, Ref, Schema, 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"
@@ -16,6 +18,7 @@ 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>,
@@ -48,13 +51,16 @@ 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()
+  const status = yield* Status.make({
+    instanceID: lifecycle?.instanceID ?? randomUUID(),
+    managed: lifecycle !== undefined,
+  })
  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, options.app?.version ?? "unknown").pipe(
+      dispatch(password, status, application, shutdown, options.app?.version ?? "unknown").pipe(
        HttpMiddleware.cors({ allowedOrigins: isAllowedCorsOrigin, maxAge: 86_400 }),
      ),
      errorResponseLogger,
@@ -157,15 +163,22 @@ 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")
-    if (request.method === "GET" && url.pathname === "/api/health") {
+    const lifecycle =
+      request.method === "GET" && url.pathname === "/api/health"
+        ? "health"
+        : request.method === "POST" && url.pathname === "/api/service/stop"
+          ? "stop"
+          : undefined
+    if (lifecycle !== undefined) {
      if (!(yield* authorizedRequest(request, auth))) return unauthorized()
-      return yield* healthResponse(status, version)
+      return yield* control(request, lifecycle, status, () => Deferred.doneUnsafe(shutdown, Effect.void), version)
    }
    const state = yield* status.current
    const app = yield* Ref.get(application)
@@ -183,6 +196,33 @@ 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(
@@ -1,5 +1,6 @@
 export * as Status from "./service-status"

+import { ServiceStatus } from "@opencode-ai/protocol/groups/health"
 import { Effect, Ref } from "effect"

 export type State =
@@ -13,9 +14,14 @@ 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 initial?: State } = {}) {
+export const make = Effect.fnUntraced(function* (options: {
+  readonly instanceID: string
+  readonly managed: boolean
+  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),
@@ -26,5 +32,9 @@ export const make = Effect.fnUntraced(function* (options: { readonly initial?: S
    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
 })
@@ -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()
+    const status = yield* Status.make({ instanceID: "one", managed: false })
    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()
+    const status = yield* Status.make({ instanceID: "one", managed: true })
    yield* status.fail
    yield* status.ready
    yield* status.fail
@@ -22,13 +22,24 @@ it.effect("keeps a startup failure until shutdown", () =>
  }),
 )

-it.effect("keeps stopping after shutdown begins", () =>
+it.effect("stops only the addressed managed instance", () =>
  Effect.gen(function* () {
-    const status = yield* Status.make()
+    const status = yield* Status.make({ instanceID: "one", managed: true })

-    yield* status.beginStopping
-    expect(yield* status.current).toEqual({ type: "stopping" })
-    yield* status.beginStopping
+    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 })
+
+    yield* status.beginStopping
+    expect(yield* status.current).toEqual({ type: "stopping" })
+    expect(yield* status.requestStop({ instanceID: "one" })).toBe(true)
    expect(yield* status.current).toEqual({ type: "stopping" })
  }),
 )
@@ -1232,7 +1232,6 @@ export function Prompt(props: PromptProps) {
    } else if (slashHead && isCommand) {
      move.startSubmit()
      const model = { providerID: selection.providerID, id: selection.modelID, variant }
-      const cancelCommit = local.model.trackSessionCommit(sessionID, model)

      void client.api.session
        .command({
@@ -1247,7 +1246,6 @@ export function Prompt(props: PromptProps) {
          delivery,
        })
        .catch((error) => {
-          cancelCommit()
          toast.show({ title: "Failed to run command", message: errorMessage(error), variant: "error" })
        })
    } else if (isSkill) {
@@ -1271,11 +1269,7 @@ export function Prompt(props: PromptProps) {
        (session.model.variant ?? "default") !== (variant ?? "default")
      ) {
        const model = { providerID: selection.providerID, id: selection.modelID, variant }
-        const cancelCommit = local.model.trackSessionCommit(sessionID, model)
-        await client.api.session.switchModel({ sessionID, model }).catch((error) => {
-          cancelCommit()
-          throw error
-        })
+        await client.api.session.switchModel({ sessionID, model })
      }
      if (session?.revert) {
        const error = await client.api.session.revert.commit({ sessionID }).then(
@@ -45,6 +45,39 @@ export function recentModels(model: ModelPreferenceModel, recent: ModelPreferenc
    .map((item) => ({ providerID: item.providerID, modelID: item.modelID }))
 }

+type ModelSelection = ModelPreferenceModel & { variant?: string }
+
+type AgentSelection = {
+  id: string
+  model?: { providerID: string; id: string; variant?: string }
+}
+
+type SessionSelection = {
+  agent?: string
+  model?: { providerID: string; id: string; variant?: string }
+}
+
+export function resolveAgentModelSelection(input: {
+  selected?: ModelSelection
+  agent?: AgentSelection
+  session?: SessionSelection
+  available: (model: ModelPreferenceModel) => boolean
+}) {
+  const model = (value: SessionSelection["model"]): ModelSelection | undefined =>
+    value && {
+      providerID: value.providerID,
+      modelID: value.id,
+      variant: normalizeModelVariant(value.variant),
+    }
+  const candidates = [
+    input.selected,
+    input.session?.agent === input.agent?.id ? model(input.session?.model) : undefined,
+    model(input.agent?.model),
+    model(input.session?.model),
+  ]
+  return candidates.find((item): item is ModelSelection => !!item && input.available(item))
+}
+
 export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
  name: "Local",
  init: () => {
@@ -67,13 +100,6 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
      return !!models()?.some((item) => item.providerID === model.providerID && item.id === model.modelID)
    }

-    function getFirstValidModel(...modelFns: (() => ModelPreferenceModel | undefined)[]) {
-      for (const modelFn of modelFns) {
-        const model = modelFn()
-        if (model && isModelValid(model)) return model
-      }
-    }
-
    function createAgent() {
      const agents = createMemo(() =>
        (data.location.agent.list(location.ref) ?? []).filter((agent) => agent.mode !== "subagent" && !agent.hidden),
@@ -132,7 +158,6 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
    const agent = createAgent()

    function createModel() {
-      type ModelSelection = ModelPreferenceModel & { variant?: string }
      const [preferences, setPreferences] = createStore<ModelPreference & { ready: boolean }>({
        ready: false,
        recent: [],
@@ -141,16 +166,13 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
      })
      const [selectionState, setSelectionState] = createStore<{
        newSessionModelByLocationAgent: Record<string, ModelPreferenceModel | undefined>
-        draftBySession: Record<string, ModelSelection | undefined>
+        modelBySessionAgent: Record<string, Record<string, ModelSelection | undefined> | undefined>
      }>({
        newSessionModelByLocationAgent: {},
-        draftBySession: {},
+        modelBySessionAgent: {},
      })

      const repository = createModelPreferenceRepository(path.join(paths.state, "model.json"))
-      const pendingSelectionCommits = new Map<string, string>()
-      const selectionKey = (value: ModelSelection) =>
-        `${modelPreferenceKey(value)}:${normalizeModelVariant(value.variant) ?? "default"}`
      const saveState = {
        pending: false,
      }
@@ -208,20 +230,19 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
        }
      })

-      const newSessionModel = createMemo(() => {
+      const newSessionSelection = createMemo<ModelSelection | undefined>(() => {
        const a = agent.current()
-        return getFirstValidModel(
-          () => a && selectionState.newSessionModelByLocationAgent[locationAgentKey(a.id)],
-          () => a?.model && { providerID: a.model.providerID, modelID: a.model.id },
-          fallbackModel,
-        )
+        const selected = a && selectionState.newSessionModelByLocationAgent[locationAgentKey(a.id)]
+        const resolved = resolveAgentModelSelection({ selected, agent: a, available: isModelValid }) ?? fallbackModel()
+        if (!resolved) return
+        if (selected || !a?.model || resolved.providerID !== a.model.providerID || resolved.modelID !== a.model.id)
+          return { ...resolved, variant: normalizeModelVariant(preferences.variant[modelPreferenceKey(resolved)]) }
+        return resolved
      })

      const currentSelection = createMemo<ModelSelection | undefined>(() => {
        if (route.data.type === "session") return sessionSelection(route.data.sessionID)
-        const model = newSessionModel()
-        if (!model) return
-        return { ...model, variant: normalizeModelVariant(preferences.variant[modelPreferenceKey(model)]) }
+        return newSessionSelection()
      })

      const currentModel = createMemo(() => {
@@ -235,27 +256,23 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
        return `${JSON.stringify([ref.directory, ref.workspaceID])}:${agentID}`
      }

-      function durableSelection(sessionID: string): ModelSelection | undefined {
-        const model = data.session.get(sessionID)?.model
-        if (!model) return
-        return {
-          providerID: model.providerID,
-          modelID: model.id,
-          variant: normalizeModelVariant(model.variant),
-        }
-      }
-
      function sessionSelection(sessionID: string) {
-        return selectionState.draftBySession[sessionID] ?? durableSelection(sessionID)
+        const current = agent.current()
+        return resolveAgentModelSelection({
+          selected: current && selectionState.modelBySessionAgent[sessionID]?.[current.id],
+          agent: current,
+          session: data.session.get(sessionID),
+          available: isModelValid,
+        })
      }

-      function setSessionDraft(sessionID: string, selection: ModelSelection) {
-        const durable = durableSelection(sessionID)
-        setSelectionState(
-          "draftBySession",
-          sessionID,
-          durable && selectionKey(durable) === selectionKey(selection) ? undefined : selection,
-        )
+      function setSessionSelection(sessionID: string, selection: ModelSelection) {
+        const current = agent.current()
+        if (!current) return
+        setSelectionState("modelBySessionAgent", sessionID, {
+          ...selectionState.modelBySessionAgent[sessionID],
+          [current.id]: selection,
+        })
      }

      function selectModel(model: ModelPreferenceModel) {
@@ -269,7 +286,7 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
          )
          const info = models()?.find((item) => item.providerID === model.providerID && item.id === model.modelID)
          const variant = preferred && info?.variants?.some((item) => item.id === preferred) ? preferred : undefined
-          setSessionDraft(sessionID, { ...model, variant })
+          setSessionSelection(sessionID, { ...model, variant })
          return true
        }
        const current = agent.current()
@@ -278,27 +295,9 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
        return true
      }

-      onCleanup(
-        event.on("session.model.selected", (evt) => {
-          const expected = pendingSelectionCommits.get(evt.data.sessionID)
-          if (!expected) return
-          const committed = selectionKey({
-            providerID: evt.data.model.providerID,
-            modelID: evt.data.model.id,
-            variant: evt.data.model.variant,
-          })
-          if (committed !== expected) return
-          pendingSelectionCommits.delete(evt.data.sessionID)
-          const draft = selectionState.draftBySession[evt.data.sessionID]
-          if (draft && selectionKey(draft) === committed)
-            setSelectionState("draftBySession", evt.data.sessionID, undefined)
-        }),
-      )
-
      onCleanup(
        event.on("session.deleted", (evt) => {
-          pendingSelectionCommits.delete(evt.data.sessionID)
-          setSelectionState("draftBySession", evt.data.sessionID, undefined)
+          setSelectionState("modelBySessionAgent", evt.data.sessionID, undefined)
        }),
      )

@@ -308,20 +307,6 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
        available(model = currentModel()) {
          return model ? isModelValid(model) : false
        },
-        trackSessionCommit(
-          sessionID: string,
-          value: {
-            providerID: string
-            id: string
-            variant?: string
-          },
-        ) {
-          const committed = selectionKey({ providerID: value.providerID, modelID: value.id, variant: value.variant })
-          pendingSelectionCommits.set(sessionID, committed)
-          return () => {
-            if (pendingSelectionCommits.get(sessionID) === committed) pendingSelectionCommits.delete(sessionID)
-          }
-        },
        get ready() {
          return preferences.ready
        },
@@ -436,7 +421,7 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
            const m = currentSelection()
            if (!m) return
            if (route.data.type === "session") {
-              setSessionDraft(route.data.sessionID, { ...m, variant: normalizeModelVariant(value) })
+              setSessionSelection(route.data.sessionID, { ...m, variant: normalizeModelVariant(value) })
            }
            setPreferences("variant", modelPreferenceKey(m), normalizeModelVariant(value))
            savePreferences()
@@ -1,5 +1,5 @@
 import { expect, test } from "bun:test"
-import { parseModel, recentModels } from "../../src/context/local"
+import { parseModel, recentModels, resolveAgentModelSelection } from "../../src/context/local"

 test("parses model IDs containing slashes", () => {
  expect(parseModel("provider/family/model")).toEqual({
@@ -20,3 +20,47 @@ test("moves a model to the front, deduplicates, and limits recents", () => {
    ...recent.slice(6, 10),
  ])
 })
+
+test("uses the configured model when switching agents", () => {
+  expect(
+    resolveAgentModelSelection({
+      agent: { id: "build", model: { providerID: "provider", id: "build-model", variant: "max" } },
+      session: {
+        agent: "plan",
+        model: { providerID: "provider", id: "plan-model", variant: "high" },
+      },
+      available: () => true,
+    }),
+  ).toEqual({ providerID: "provider", modelID: "build-model", variant: "max" })
+})
+
+test("keeps a manual model selection for each session agent", () => {
+  expect(
+    resolveAgentModelSelection({
+      selected: { providerID: "provider", modelID: "manual-model", variant: "high" },
+      agent: { id: "build", model: { providerID: "provider", id: "build-model", variant: "max" } },
+      session: { agent: "plan", model: { providerID: "provider", id: "plan-model" } },
+      available: () => true,
+    }),
+  ).toEqual({ providerID: "provider", modelID: "manual-model", variant: "high" })
+})
+
+test("keeps the durable model while the active agent is unchanged", () => {
+  expect(
+    resolveAgentModelSelection({
+      agent: { id: "plan", model: { providerID: "provider", id: "configured-model", variant: "max" } },
+      session: { agent: "plan", model: { providerID: "provider", id: "manual-model", variant: "high" } },
+      available: () => true,
+    }),
+  ).toEqual({ providerID: "provider", modelID: "manual-model", variant: "high" })
+})
+
+test("keeps the session model when the next agent has no configured model", () => {
+  expect(
+    resolveAgentModelSelection({
+      agent: { id: "review" },
+      session: { agent: "plan", model: { providerID: "provider", id: "plan-model", variant: "high" } },
+      available: () => true,
+    }),
+  ).toEqual({ providerID: "provider", modelID: "plan-model", variant: "high" })
+})
@@ -48,6 +48,58 @@
        "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"],
@@ -9731,6 +9783,26 @@
        "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": [
          {
@@ -48,6 +48,58 @@
        "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"],
@@ -9731,6 +9783,26 @@
        "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": [
          {