refactor(desktop): move IPC to Effect RPC

.changeset/steer-resume-simplified.md

@@ -1,5 +0,0 @@
----
-"@opencode-ai/core": patch
----
-
-Simplify interrupt continuation: the steer-scoped resume decision now lives in SessionExecution as a post-cleanup inbox check, and the run coordinator drops its continuation state machine. Wakes arriving during cancellation cleanup now restart a normal full drain, and interrupting an idle session with continue now resumes pending steering input. Recovery-applied moves now end with the same full wake as inbox-admitted moves, retrying any stranded inbox work at the new location.

.changeset/websocket-request-hooks.md

@@ -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.

.github/workflows/publish.yml

@@ -82,7 +82,6 @@ jobs:
   build-cli:
     needs: version
     runs-on: blacksmith-4vcpu-ubuntu-2404
-    timeout-minutes: 30
     if: github.repository == 'anomalyco/opencode'
     steps:
       - uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 # v3.6.0

bun.lock

@@ -119,7 +119,6 @@
       },
       "dependencies": {
         "@agentclientprotocol/sdk": "1.2.1",
-        "@clack/prompts": "1.0.0-alpha.1",
         "@effect/platform-node": "catalog:",
         "@opencode-ai/client": "workspace:*",
         "@opencode-ai/plugin": "workspace:*",
@@ -590,9 +589,9 @@
       },
       "peerDependencies": {
         "@opencode-ai/theme": "workspace:*",
-        "@opentui/core": ">=0.5.4",
-        "@opentui/keymap": ">=0.5.4",
-        "@opentui/solid": ">=0.5.4",
+        "@opentui/core": ">=0.5.3",
+        "@opentui/keymap": ">=0.5.3",
+        "@opentui/solid": ">=0.5.3",
         "solid-js": ">=1.9.0",
       },
       "optionalPeers": [
@@ -1088,9 +1087,9 @@
     "@npmcli/arborist": "9.4.0",
     "@octokit/rest": "22.0.0",
     "@openauthjs/openauth": "0.0.0-20250322224806",
-    "@opentui/core": "0.5.4",
-    "@opentui/keymap": "0.5.4",
-    "@opentui/solid": "0.5.4",
+    "@opentui/core": "0.5.3",
+    "@opentui/keymap": "0.5.3",
+    "@opentui/solid": "0.5.3",
     "@pierre/diffs": "1.2.10",
     "@playwright/test": "1.59.1",
     "@sentry/solid": "10.36.0",
@@ -2112,27 +2111,27 @@
 
     "@opentelemetry/semantic-conventions": ["@opentelemetry/semantic-conventions@1.43.0", "", {}, "sha512-eSYWTm620tTk45EKSedaUL8MFYI8hW164hIXsgIHyxu3VobUB3fFCu5t0hQby6OoWRPsG1KkKUG2M5UadiLiVg=="],
 
-    "@opentui/core": ["@opentui/core@0.5.4", "", { "dependencies": { "bun-ffi-structs": "0.3.1", "diff": "9.0.0", "marked": "17.0.1", "string-width": "7.2.0", "strip-ansi": "7.1.2" }, "optionalDependencies": { "@opentui/core-darwin-arm64": "0.5.4", "@opentui/core-darwin-x64": "0.5.4", "@opentui/core-linux-arm64": "0.5.4", "@opentui/core-linux-arm64-musl": "0.5.4", "@opentui/core-linux-x64": "0.5.4", "@opentui/core-linux-x64-musl": "0.5.4", "@opentui/core-win32-arm64": "0.5.4", "@opentui/core-win32-x64": "0.5.4" }, "peerDependencies": { "web-tree-sitter": "0.25.10" } }, "sha512-czcJKQ72QhTWvu1eWfKg4EPN1GLLND6cP9MOhDyqYzCdIZgxQSJVWYzz6c4/CQGOu/qQLRyce2y1efVu4lgQ0w=="],
+    "@opentui/core": ["@opentui/core@0.5.3", "", { "dependencies": { "bun-ffi-structs": "0.3.1", "diff": "9.0.0", "marked": "17.0.1", "string-width": "7.2.0", "strip-ansi": "7.1.2" }, "optionalDependencies": { "@opentui/core-darwin-arm64": "0.5.3", "@opentui/core-darwin-x64": "0.5.3", "@opentui/core-linux-arm64": "0.5.3", "@opentui/core-linux-arm64-musl": "0.5.3", "@opentui/core-linux-x64": "0.5.3", "@opentui/core-linux-x64-musl": "0.5.3", "@opentui/core-win32-arm64": "0.5.3", "@opentui/core-win32-x64": "0.5.3" }, "peerDependencies": { "web-tree-sitter": "0.25.10" } }, "sha512-K8EQu44cx0rhnn3v3baCQW18Bpci3GltZayOwVpGGsbiAGL1WUYqwQjuaWsmS0c4dCa9rQ5xCEoHB1C4936nDg=="],
 
-    "@opentui/core-darwin-arm64": ["@opentui/core-darwin-arm64@0.5.4", "", { "os": "darwin", "cpu": "arm64" }, "sha512-oETbn6tg/0g+mOvGXy3iot+1Zv7CGr65U1lRaPJ7kpsKGnOxftCpDD1qA0I6eQwfPJa9k7h9D/9yGB3IbweGcg=="],
+    "@opentui/core-darwin-arm64": ["@opentui/core-darwin-arm64@0.5.3", "", { "os": "darwin", "cpu": "arm64" }, "sha512-R39YeUqaMb/rH1h6G4MkB4MLVKIrRaUaXLfVqorZM4xgU5BxnfPetRk1vWR9vuLCvDwskg+kQ589kULw0o6AWA=="],
 
-    "@opentui/core-darwin-x64": ["@opentui/core-darwin-x64@0.5.4", "", { "os": "darwin", "cpu": "x64" }, "sha512-TIeqCNfAV8xvNAv6oVBYsoGBz/p8CxcYm668OQIeBPUO+irqbQ72vJJa/SwFZrUEAHFmsDELaB6y80oHU5Jm6g=="],
+    "@opentui/core-darwin-x64": ["@opentui/core-darwin-x64@0.5.3", "", { "os": "darwin", "cpu": "x64" }, "sha512-1pmUas/chTVFGeiN19kaOx+5Xbte/DLhcgKyACwWO0M3+xE3z1v/6QGSyX6CoP5HBpmDroiX+JHv1ic/JlGd/g=="],
 
-    "@opentui/core-linux-arm64": ["@opentui/core-linux-arm64@0.5.4", "", { "os": "linux", "cpu": "arm64" }, "sha512-UrOsX3D5BOO9TI30WvRwEK/lyPPhY75+LwSqeRRe8SV2ON+Ez5QqY4oryTyYC6+yNahTJufz34n0YgwnQaxTNA=="],
+    "@opentui/core-linux-arm64": ["@opentui/core-linux-arm64@0.5.3", "", { "os": "linux", "cpu": "arm64" }, "sha512-0nMo9Q9VIaQVdw2SNKlwIEWMmf3z+cI4jRdCkh36e2RU1FO7LrIBAEmV1ZuRp1CIFVGPkqCXIizCeckZHTr4yQ=="],
 
-    "@opentui/core-linux-arm64-musl": ["@opentui/core-linux-arm64-musl@0.5.4", "", { "os": "linux", "cpu": "arm64" }, "sha512-8vFWd1dsPZj9fHQKlsGHue3ukp7MRjTSpmIrdneIruOcoK2etccHfd6bqIo4FcNr+HA0eI2FP4ZIL9xhE3r9/w=="],
+    "@opentui/core-linux-arm64-musl": ["@opentui/core-linux-arm64-musl@0.5.3", "", { "os": "linux", "cpu": "arm64" }, "sha512-QOYAxbbWrhYo27Cd6m0ATzpEx9YCAKAq82LgfUn0xu+VKXLNu+Q3hMNSVbG0SepUQQZil5rz228R9o9Cs8995w=="],
 
-    "@opentui/core-linux-x64": ["@opentui/core-linux-x64@0.5.4", "", { "os": "linux", "cpu": "x64" }, "sha512-1RXzSl6d347O7mUXviXFWlFFyILr7qsVt4jwD3k0UiKtENeEDNi+glM1bKHbXwCdQjfA835QgFA2mbILybK+aQ=="],
+    "@opentui/core-linux-x64": ["@opentui/core-linux-x64@0.5.3", "", { "os": "linux", "cpu": "x64" }, "sha512-hdAYLriLpTj3lvpMyL25GPBzvM2w/n2KCSbIwTmgS2F/dPZYCKJxHEETj2lCvtStSp7KuY8tkg3Xl5RAq1v7gA=="],
 
-    "@opentui/core-linux-x64-musl": ["@opentui/core-linux-x64-musl@0.5.4", "", { "os": "linux", "cpu": "x64" }, "sha512-YYREqUB3v5K0qWij3A5YWzJkkVXp/EqIiuHZKsAjrUAY/0+Bp8Hn0baLvvvkuklpG9whW+GfwIeUsmp4fxqmCA=="],
+    "@opentui/core-linux-x64-musl": ["@opentui/core-linux-x64-musl@0.5.3", "", { "os": "linux", "cpu": "x64" }, "sha512-BkVIiPQ1TOf5/FfmIpf7DQU5rT/FO6ASW5R/o/wonI5Pdul7XiDCu86gzGyk1x5k9Sbh6GLeq1fe8/tPmI7IaA=="],
 
-    "@opentui/core-win32-arm64": ["@opentui/core-win32-arm64@0.5.4", "", { "os": "win32", "cpu": "arm64" }, "sha512-F9sB6suPJmwkLF2MwKEC+OtwP6cn5QspIm4MCh2hmu3mVqSz9GDpYID1X3sAh9/V79EVocqiOSqI3KeCTRouKQ=="],
+    "@opentui/core-win32-arm64": ["@opentui/core-win32-arm64@0.5.3", "", { "os": "win32", "cpu": "arm64" }, "sha512-AjObTyZPU0xsK3Yk8GmhkboK6OcMoHBbydqYAybeHD4+v6axScSuZ3OEI9J05JJ9T7H2nZNky75tsdnjsvZJmg=="],
 
-    "@opentui/core-win32-x64": ["@opentui/core-win32-x64@0.5.4", "", { "os": "win32", "cpu": "x64" }, "sha512-2/6dPPPJ9xL/bWz9jh+lZeV2g/tbxZ9N4FBIqwhnqSfIYy5jOnscsPZpcN4X6PstfJAo2yf0Ebk/tLTOzOS6TQ=="],
+    "@opentui/core-win32-x64": ["@opentui/core-win32-x64@0.5.3", "", { "os": "win32", "cpu": "x64" }, "sha512-e3nRlF2nSkLKCUPBF32OL9EDgtQDIh2pBo7tjhumpTyJ3qoNOa3us7DsM290Vw4xnakM6jpk9r9NzRf72CuMVg=="],
 
-    "@opentui/keymap": ["@opentui/keymap@0.5.4", "", { "dependencies": { "@opentui/core": "0.5.4" }, "peerDependencies": { "@opentui/react": "0.5.4", "@opentui/solid": "0.5.4", "react": ">=19.2.0", "solid-js": "1.9.12" }, "optionalPeers": ["@opentui/react", "@opentui/solid", "react", "solid-js"] }, "sha512-WAB6EH6C7SicmK/ycvx+mUu00sQ755gToZqBx8vgLhS7qZ07s/WLi88Ys0D6AA0i8lOiSIPA4uqei1jkV8UnBQ=="],
+    "@opentui/keymap": ["@opentui/keymap@0.5.3", "", { "dependencies": { "@opentui/core": "0.5.3" }, "peerDependencies": { "@opentui/react": "0.5.3", "@opentui/solid": "0.5.3", "react": ">=19.2.0", "solid-js": "1.9.12" }, "optionalPeers": ["@opentui/react", "@opentui/solid", "react", "solid-js"] }, "sha512-VdvUabUDWnmgolzp1qiO55wz1zv0mMu5Z6tv+UQk9JqZRfKt5Q8XTDi0uQzhBb6qeLsHvXtRFOsnn6EFAcLixA=="],
 
-    "@opentui/solid": ["@opentui/solid@0.5.4", "", { "dependencies": { "@babel/core": "7.28.0", "@babel/preset-typescript": "7.27.1", "@opentui/core": "0.5.4", "babel-plugin-module-resolver": "5.0.2", "babel-preset-solid": "1.9.12", "entities": "7.0.1", "s-js": "^0.4.9" }, "peerDependencies": { "solid-js": "1.9.12" } }, "sha512-1injDvieTyYXD3RLC2EclaJK8XZ2+qyJ7wGeQPSzpcYEEcanb7G79KVWFlN7YUzqVAhTIictZDoQ6SRvIwL4Ww=="],
+    "@opentui/solid": ["@opentui/solid@0.5.3", "", { "dependencies": { "@babel/core": "7.28.0", "@babel/preset-typescript": "7.27.1", "@opentui/core": "0.5.3", "babel-plugin-module-resolver": "5.0.2", "babel-preset-solid": "1.9.12", "entities": "7.0.1", "s-js": "^0.4.9" }, "peerDependencies": { "solid-js": "1.9.12" } }, "sha512-IB6YC3ajucQeo06BMSNYRD7LHf8ndm6G5ETcYsS+51Mli5yW0ioyUr+6+qgqVtaQyOcJvaD1KWmK23pXLhsiwg=="],
 
     "@orama/orama": ["@orama/orama@3.1.18", "", {}, "sha512-a61ljmRVVyG5MC/698C8/FfFDw5a8LOIvyOLW5fztgUXqUpc1jOfQzOitSCbge657OgXXThmY3Tk8fpiDb4UcA=="],
 

package.json

@@ -47,9 +47,9 @@
       "@octokit/rest": "22.0.0",
       "@hono/standard-validator": "0.2.0",
       "@hono/zod-validator": "0.4.2",
-      "@opentui/core": "0.5.4",
-      "@opentui/keymap": "0.5.4",
-      "@opentui/solid": "0.5.4",
+      "@opentui/core": "0.5.3",
+      "@opentui/keymap": "0.5.3",
+      "@opentui/solid": "0.5.3",
       "@tanstack/solid-virtual": "3.13.32",
       "@shikijs/stream": "4.2.0",
       "@standard-schema/spec": "1.1.0",

packages/ai/src/protocols/anthropic-messages.ts

@@ -905,7 +905,6 @@ const onContentBlockDelta = Effect.fn("AnthropicMessages.onContentBlockDelta")(f
 
   if (delta?.type === "input_json_delta" && event.index !== undefined) {
     if (!delta.partial_json) return [state, NO_EVENTS] satisfies StepResult
-    if (!state.tools[event.index]) return [state, NO_EVENTS] satisfies StepResult
     const result = ToolStream.appendExisting(
       ADAPTER,
       state.tools,

packages/ai/test/provider/anthropic-messages.test.ts

@@ -1010,34 +1010,6 @@ describe("Anthropic Messages route", () => {
     }),
   )
 
-  it.effect("ignores tool input deltas without a matching tool start", () =>
-    Effect.gen(function* () {
-      const response = yield* LLMClient.generate(request).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents(
-              { type: "message_start", message: { usage: { input_tokens: 5 } } },
-              { type: "content_block_start", index: 0, content_block: { type: "text", text: "" } },
-              { type: "content_block_delta", index: 0, delta: { type: "text_delta", text: "Hello" } },
-              {
-                type: "content_block_delta",
-                index: 1,
-                delta: { type: "input_json_delta", partial_json: '{"query":"orphaned"}' },
-              },
-              { type: "content_block_stop", index: 0 },
-              { type: "message_delta", delta: { stop_reason: "end_turn" }, usage: { output_tokens: 1 } },
-              { type: "message_stop" },
-            ),
-          ),
-        ),
-      )
-
-      expect(response.text).toBe("Hello")
-      expect(response.toolCalls).toEqual([])
-      expect(response.finishReason).toEqual({ normalized: "stop", raw: "end_turn" })
-    }),
-  )
-
   it.effect("settles pending tool calls at message_stop", () =>
     Effect.gen(function* () {
       const response = yield* LLMClient.generate(request).pipe(

packages/app/src/components/project-settings-extensions.tsx

@@ -7,7 +7,6 @@ import { useMcpToggle } from "@/context/mcp"
 import { useWorkspaceLocation } from "@/context/location"
 import { useServerSDK } from "@/context/server-sdk"
 import { useData } from "@/context/server"
-import { pluginLabel } from "@/utils/plugin"
 import { ExternalLink } from "./external-link"
 
 type SkillItem = {
@@ -102,10 +101,10 @@ export const ProjectSettingsExtensions: Component = () => {
     () => (serverSDK.connection.status() === "connected" ? directorySDK().directory : undefined),
     (directory) => serverSDK.api.plugin.list({ location: { directory } }).then((result) => result.data),
   )
-  const globalPlugins = createMemo(() => (globalPluginList.latest ?? []).map(pluginLabel))
+  const globalPlugins = createMemo(() => (globalPluginList.latest ?? []).map((item) => item.id))
   const projectPlugins = createMemo(() => {
     const shared = new Set(globalPlugins())
-    return (projectPluginList.latest ?? []).map(pluginLabel).filter((name) => !shared.has(name))
+    return (projectPluginList.latest ?? []).map((item) => item.id).filter((name) => !shared.has(name))
   })
 
   const serverSkills = createMemo(() => data.location.skill.list() ?? [])

packages/app/src/components/settings-v2/extensions.tsx

@@ -6,7 +6,6 @@ import { useLanguage } from "@/context/language"
 import { useData } from "@/context/server"
 import { useServerSDK } from "@/context/server-sdk"
 import { useMcpToggle } from "@/context/mcp"
-import { pluginLabel } from "@/utils/plugin"
 import { ExternalLink } from "../external-link"
 import { InlineServerSelect } from "./parts/server-select"
 import "./settings-v2.css"
@@ -45,9 +44,7 @@ export const SettingsExtensionsV2: Component = () => {
     () => serverSdk.connection.status() === "connected",
     () => serverSdk.api.plugin.list().then((result) => result.data),
   )
-  const plugins = createMemo<PluginRowItem[]>(() =>
-    (pluginList.latest ?? []).map((item) => ({ name: pluginLabel(item) })),
-  )
+  const plugins = createMemo<PluginRowItem[]>(() => (pluginList.latest ?? []).map((item) => ({ name: item.id })))
 
   createEffect(() => {
     if (serverSdk.connection.status() !== "connected") return

packages/app/src/components/status-popover-body.tsx

@@ -6,7 +6,6 @@ import { useMcpToggle } from "@/context/mcp"
 import { useWorkspaceLocation } from "@/context/location"
 import { useData } from "@/context/server"
 import { useServerSDK } from "@/context/server-sdk"
-import { pluginLabel } from "@/utils/plugin"
 
 const pluginEmptyMessage = (value: string, file: string): JSXElement => {
   const parts = value.split(file)
@@ -39,7 +38,7 @@ export function StatusPopoverBody(props: { shown: boolean }) {
     () => (props.shown ? sdk().directory : undefined),
     (directory) => serverSDK.api.plugin.list({ location: { directory } }).then((result) => result.data),
   )
-  const plugins = createMemo(() => (pluginList.latest ?? []).map(pluginLabel))
+  const plugins = createMemo(() => (pluginList.latest ?? []).map((item) => item.id))
   const pluginCount = createMemo(() => plugins().length)
   const pluginEmpty = createMemo(() => pluginEmptyMessage(language.t("dialog.plugins.empty"), "opencode.json"))
 

packages/app/src/utils/plugin.ts

@@ -1,8 +0,0 @@
-import type { PluginInfo } from "@opencode-ai/client"
-
-export function pluginLabel(plugin: PluginInfo) {
-  if (plugin.id) return plugin.id
-  if (plugin.source.type === "package") return plugin.source.package
-  if (plugin.source.type === "local") return plugin.source.path
-  return plugin.source.type
-}

packages/cli/package.json

@@ -23,7 +23,6 @@
   },
   "dependencies": {
     "@agentclientprotocol/sdk": "1.2.1",
-    "@clack/prompts": "1.0.0-alpha.1",
     "@effect/platform-node": "catalog:",
     "@opencode-ai/client": "workspace:*",
     "@opencode-ai/plugin": "workspace:*",
@@ -42,8 +41,8 @@
     "solid-js": "catalog:",
     "tree-sitter-bash": "0.25.0",
     "tree-sitter-powershell": "0.25.10",
-    "uqr": "0.1.3",
     "web-tree-sitter": "0.25.10",
+    "uqr": "0.1.3",
     "ws": "8.21.0"
   },
   "devDependencies": {

packages/cli/script/build.ts

@@ -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,

packages/cli/script/service-smoke.ts

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

packages/cli/src/commands/commands.ts

@@ -86,37 +86,12 @@ const Root = Spec.make(typeof OPENCODE_CLI_NAME === "string" ? OPENCODE_CLI_NAME
       ],
     }),
     Spec.make("auth", {
-      description: "manage AI providers and credentials",
+      description: "Manage authentication",
       commands: [
-        Spec.make("list", {
-          description: "list providers and credentials",
-          params: {
-            ...ServerParams,
-            format: Flag.choice("format", ["default", "json"]).pipe(
-              Flag.withDescription("Output format"),
-              Flag.withDefault("default"),
-            ),
-          },
-        }),
         Spec.make("login", {
-          description: "log in to a provider",
+          description: "Log in to a well-known authentication provider",
           params: {
-            ...ServerParams,
-            target: Argument.string("target").pipe(
-              Argument.withDescription("Integration ID, name, or well-known provider URL"),
-              Argument.optional,
-            ),
-            method: Flag.string("method").pipe(Flag.withDescription("Authentication method ID"), Flag.optional),
-          },
-        }),
-        Spec.make("logout", {
-          description: "log out from a configured provider",
-          params: {
-            ...ServerParams,
-            target: Argument.string("target").pipe(
-              Argument.withDescription("Integration ID or name"),
-              Argument.optional,
-            ),
+            url: Argument.string("url").pipe(Argument.withDescription("Well-known provider URL")),
           },
         }),
       ],
@@ -170,7 +145,11 @@ const Root = Spec.make(typeof OPENCODE_CLI_NAME === "string" ? OPENCODE_CLI_NAME
       description: "Export session data as JSON",
       params: {
         ...ServerParams,
-        session: Argument.string("session").pipe(Argument.withDescription("Session ID to export"), Argument.optional),
+        session: Flag.string("session").pipe(
+          Flag.withAlias("s"),
+          Flag.withDescription("Session ID to export to stdout"),
+          Flag.optional,
+        ),
         sanitize: Flag.boolean("sanitize").pipe(
           Flag.withDescription("Redact sensitive transcript and file data"),
           Flag.withDefault(false),
@@ -275,36 +254,15 @@ const Root = Spec.make(typeof OPENCODE_CLI_NAME === "string" ? OPENCODE_CLI_NAME
         Spec.make("stop", { description: "Stop the background server" }),
         Spec.make("get", {
           description: "Get service configuration",
-          params: {
-            key: Argument.string("key").pipe(Argument.withDescription("Service setting or env"), Argument.optional),
-            name: Argument.string("name").pipe(
-              Argument.withDescription("Environment variable name"),
-              Argument.optional,
-            ),
-          },
+          params: { key: Argument.string("key").pipe(Argument.optional) },
         }),
         Spec.make("set", {
           description: "Set service configuration",
-          params: {
-            key: Argument.string("key").pipe(Argument.withDescription("Service setting or env")),
-            value: Argument.string("value").pipe(
-              Argument.withDescription("Setting value or environment variable name"),
-            ),
-            nestedValue: Argument.string("env-value").pipe(
-              Argument.withDescription("Environment variable value"),
-              Argument.optional,
-            ),
-          },
+          params: { key: Argument.string("key"), value: Argument.string("value") },
         }),
         Spec.make("unset", {
           description: "Unset service configuration",
-          params: {
-            key: Argument.string("key").pipe(Argument.withDescription("Service setting or env")),
-            name: Argument.string("name").pipe(
-              Argument.withDescription("Environment variable name"),
-              Argument.optional,
-            ),
-          },
+          params: { key: Argument.string("key") },
         }),
       ],
     }),

packages/cli/src/commands/handlers/auth/form.ts

@@ -1,153 +0,0 @@
-import { confirm, log, multiselect, password, select, text, type Option } from "@clack/prompts"
-import { Effect } from "effect"
-import type { FormAnswer, FormField, FormFields } from "@opencode-ai/client"
-import { openUrl, prompt, requireInteractive } from "../../../ui/prompt"
-
-const skip = Symbol("skip")
-const custom = Symbol("custom")
-
-export const answerForm = Effect.fn("cli.auth.form")(function* (fields: FormFields | undefined) {
-  if (!fields) return undefined
-  yield* requireInteractive("Authentication form input requires an interactive terminal")
-  const answer: FormAnswer = {}
-  for (const field of fields) {
-    if (!active(field, answer)) continue
-    const value = yield* answerField(field)
-    if (value !== undefined) answer[field.key] = value
-  }
-  return answer
-})
-
-export const secret = Effect.fn("cli.auth.secret")(function* (message: string) {
-  yield* requireInteractive("API key input requires an interactive terminal")
-  return yield* prompt<string>(() => password({ message, validate: (value) => (!value ? "Required" : undefined) }))
-})
-
-const answerField = Effect.fn("cli.auth.form.field")(function* (field: FormField) {
-  const message = field.title ?? field.key
-  if (field.description) log.info(field.description)
-  if (field.type === "external") {
-    log.info(field.url)
-    yield* openUrl(field.url)
-    const acknowledged = yield* prompt<boolean>(() =>
-      confirm({ message: message || "Continue after completing this step?", initialValue: true }),
-    )
-    if (!acknowledged) return yield* Effect.fail(new Error(`${message || "External step"} is required`))
-    return true
-  }
-  if (field.type === "boolean") {
-    if (field.required) return yield* prompt<boolean>(() => confirm({ message, initialValue: field.default ?? true }))
-    const options: Array<Option<boolean | typeof skip>> = [
-      { value: true, label: "Yes" },
-      { value: false, label: "No" },
-      { value: skip, label: "Skip" },
-    ]
-    const value = yield* prompt<boolean | typeof skip>(() =>
-      select<boolean | typeof skip>({
-        message,
-        options,
-        initialValue: field.default ?? skip,
-      }),
-    )
-    if (value === skip) return undefined
-    return value
-  }
-  if (field.type === "multiselect") {
-    const options: Array<Option<string | typeof custom>> = field.options.map((option) => ({
-      value: option.value,
-      label: option.label,
-      hint: option.description,
-    }))
-    if (field.custom) options.push({ value: custom, label: "Type another value" })
-    const values = yield* prompt<Array<string | typeof custom>>(() =>
-      multiselect<string | typeof custom>({
-        message,
-        options,
-        initialValues: field.default,
-        required: field.required || (field.minItems ?? 0) > 0,
-      }),
-    )
-    const selected = values.filter((value): value is string => value !== custom)
-    if (values.includes(custom)) {
-      selected.push(yield* prompt<string>(() => text({ message: "Enter value", validate: required })))
-    }
-    if (field.minItems !== undefined && selected.length < field.minItems) {
-      return yield* Effect.fail(new Error(`Select at least ${field.minItems}`))
-    }
-    if (field.maxItems !== undefined && selected.length > field.maxItems) {
-      return yield* Effect.fail(new Error(`Select at most ${field.maxItems}`))
-    }
-    return selected
-  }
-  if (field.type === "string" && field.options) {
-    const options: Array<Option<string | typeof custom | typeof skip>> = field.options.map((option) => ({
-      value: option.value,
-      label: option.label,
-      hint: option.description,
-    }))
-    if (field.custom) options.push({ value: custom, label: "Type your own answer" })
-    if (!field.required) options.push({ value: skip, label: "Skip" })
-    const value = yield* prompt<string | typeof custom | typeof skip>(() =>
-      select<string | typeof custom | typeof skip>({ message, options, initialValue: field.default }),
-    )
-    if (value === skip) return undefined
-    if (value !== custom) return value
-  }
-  const value = yield* prompt<string>(() =>
-    text({
-      message,
-      placeholder: field.type === "string" ? field.placeholder : undefined,
-      initialValue: field.default === undefined ? undefined : String(field.default),
-      validate: (input) => validateText(field, input),
-    }),
-  )
-  if (!value && !field.required) return undefined
-  if (field.type === "string") return value
-  return Number(value)
-})
-
-function active(field: FormField, answer: FormAnswer) {
-  if (field.type === "external" || !field.when) return true
-  return field.when.every((condition) => {
-    const value = answer[condition.key]
-    if (value === undefined) return false
-    const matches = Array.isArray(value) ? value.includes(String(condition.value)) : value === condition.value
-    return condition.op === "eq" ? matches : !matches
-  })
-}
-
-function required(value: string | undefined) {
-  return value ? undefined : "Required"
-}
-
-function validateText(field: Exclude<FormField, { type: "boolean" | "external" | "multiselect" }>, value?: string) {
-  if (!value) return field.required ? "Required" : undefined
-  if (field.type === "number" || field.type === "integer") {
-    const number = Number(value)
-    if (!Number.isFinite(number)) return "Expected a number"
-    if (field.type === "integer" && !Number.isInteger(number)) return "Expected an integer"
-    if (typeof field.minimum === "number" && number < field.minimum) return `Must be at least ${field.minimum}`
-    if (typeof field.maximum === "number" && number > field.maximum) return `Must be at most ${field.maximum}`
-    return undefined
-  }
-  if (field.minLength !== undefined && value.length < field.minLength)
-    return `Must be at least ${field.minLength} characters`
-  if (field.maxLength !== undefined && value.length > field.maxLength)
-    return `Must be at most ${field.maxLength} characters`
-  if (field.pattern) {
-    try {
-      if (!new RegExp(field.pattern).test(value)) return "Invalid format"
-    } catch {
-      return "Invalid format"
-    }
-  }
-  if (field.format === "uri" && !URL.canParse(value)) return "Expected a URL"
-  if (field.format === "email" && !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value)) return "Expected an email address"
-  if (field.format === "date") {
-    if (!/^\d{4}-\d{2}-\d{2}$/.test(value)) return "Expected a date"
-    const date = new Date(`${value}T00:00:00.000Z`)
-    if (Number.isNaN(date.getTime()) || date.toISOString().slice(0, 10) !== value) return "Expected a date"
-  }
-  if (field.format === "date-time" && Number.isNaN(Date.parse(value))) return "Expected a date and time"
-  return undefined
-}

packages/cli/src/commands/handlers/auth/list.ts

@@ -1,51 +0,0 @@
-import { EOL } from "node:os"
-import { Effect, Option } from "effect"
-import { Commands } from "../../commands"
-import { Runtime } from "../../../framework/runtime"
-import { createClient, loadIntegrations } from "./shared"
-import { errorMessage } from "../../../ui/prompt"
-
-export default Runtime.handler(Commands.commands.auth.commands.list, (input) =>
-  list(input).pipe(
-    Effect.catch((error) =>
-      Effect.sync(() => {
-        process.stderr.write(errorMessage(error) + EOL)
-        process.exitCode = 1
-      }),
-    ),
-  ),
-)
-
-const list = Effect.fn("cli.auth.list")(function* (input) {
-  const client = yield* createClient({ server: Option.getOrUndefined(input.server), standalone: input.standalone })
-  const integrations = (yield* loadIntegrations(client)).filter((integration) => integration.connections.length > 0)
-  if (input.format === "json") {
-    process.stdout.write(
-      JSON.stringify(
-        integrations.map((integration) => ({
-          id: integration.id,
-          name: integration.name,
-          connections: integration.connections,
-        })),
-        null,
-        2,
-      ) + EOL,
-    )
-    return
-  }
-  const rows = integrations.flatMap((integration) =>
-    integration.connections.map((connection) => ({
-      integration: integration.name,
-      source: connection.type === "credential" ? connection.label : connection.name,
-      type: connection.type === "credential" ? "stored" : "environment",
-    })),
-  )
-  if (rows.length === 0) {
-    process.stdout.write("No authenticated integrations" + EOL)
-    return
-  }
-  const width = Math.max(...rows.map((row) => row.integration.length)) + 2
-  process.stdout.write(
-    rows.map((row) => row.integration.padEnd(width) + row.source.padEnd(28) + row.type).join(EOL) + EOL,
-  )
-})

packages/cli/src/commands/handlers/auth/login.ts

@@ -1,267 +1,52 @@
-import { autocomplete, intro, log, outro, select, spinner, text } from "@clack/prompts"
-import { Effect, Option } from "effect"
-import type { FormAnswer, IntegrationInfo, OpenCodeClient } from "@opencode-ai/client"
+import { EOL } from "node:os"
+import { Effect } from "effect"
+import { Service } from "@opencode-ai/client/effect/service"
+import { OpenCode, type IntegrationCommandStatusOutput, type OpenCodeClient } from "@opencode-ai/client/promise"
 import { Commands } from "../../commands"
 import { Runtime } from "../../../framework/runtime"
-import { handlePromptErrors, openUrl, prompt, requireInteractive } from "../../../ui/prompt"
-import { answerForm, secret } from "./form"
-import {
-  createClient,
-  connectMethods,
-  loadIntegrations,
-  location,
-  request,
-  resolveIntegration,
-  resolveMethod,
-  type ConnectMethod,
-} from "./shared"
+import { ServiceConfig } from "../../../services/service-config"
 
-const integrationPriority = new Map([
-  ["opencode", 0],
-  ["opencode-go", 1],
-  ["openai", 2],
-  ["github-copilot", 3],
-  ["google", 4],
-  ["anthropic", 5],
-  ["openrouter", 6],
-  ["vercel", 7],
-])
+const location = { directory: process.cwd() }
 
 export default Runtime.handler(
   Commands.commands.auth.commands.login,
-  Effect.fn("cli.auth.login")((input) =>
-    login({
-      target: Option.getOrUndefined(input.target),
-      method: Option.getOrUndefined(input.method),
-      server: Option.getOrUndefined(input.server),
-      standalone: input.standalone,
-    }).pipe(handlePromptErrors),
-  ),
+  Effect.fn("cli.auth.login")(function* (input) {
+    process.stdout.write("Logging in..." + EOL + EOL)
+    const endpoint = yield* Service.ensure(yield* ServiceConfig.options())
+    const client = OpenCode.make({ baseUrl: endpoint.url, headers: Service.headers(endpoint) })
+    yield* request(() => client.integration.wellknown.add({ url: input.url, location }))
+    const integrationID = input.url.replace(/\/+$/, "")
+    const started = yield* request(() =>
+      client.integration.command.connect({ integrationID, methodID: "login", location }),
+    )
+    yield* Effect.addFinalizer(() =>
+      request(() =>
+        client.integration.command.cancel({ integrationID, attemptID: started.data.attemptID, location }),
+      ).pipe(Effect.ignore),
+    )
+
+    const status = yield* wait(client, integrationID, started.data.attemptID)
+    if (status.status === "failed") return yield* Effect.fail(new Error(status.message))
+    if (status.status === "expired") return yield* Effect.fail(new Error("Authentication expired"))
+    process.stdout.write("Logged in" + EOL)
+  }),
 )
 
-const login = Effect.fn("cli.auth.login.run")(function* (input: {
-  target?: string
-  method?: string
-  server?: string
-  standalone: boolean
-}) {
-  if (!input.target)
-    yield* requireInteractive("Pass an integration ID or name when running without an interactive terminal")
-  intro("Connect an integration")
-  const client = yield* createClient({ server: input.server, standalone: input.standalone })
-  const integration = yield* findIntegration(client, input.target)
-  const methods = connectMethods(integration)
-  if (methods.length === 0) yield* Effect.fail(new Error(`${integration.name} has no interactive login methods`))
-  const method = yield* chooseMethod(methods, input.method)
-  const answer = method.type === "command" ? undefined : yield* answerForm(method.form)
-  yield* authenticate(client, integration, method, answer)
-  outro("Done")
-})
-
-const findIntegration = Effect.fn("cli.auth.login.integration")(function* (client: OpenCodeClient, target?: string) {
-  if (target && URL.canParse(target)) {
-    const protocol = new URL(target).protocol
-    if (protocol === "http:" || protocol === "https:") {
-      const progress = spinner()
-      progress.start("Discovering authentication provider...")
-      yield* request((signal) => client.integration.wellknown.add({ url: target, location }, { signal })).pipe(
-        Effect.tap(() => Effect.sync(() => progress.stop("Authentication provider discovered"))),
-        Effect.tapCause(() => Effect.sync(() => progress.stop("Discovery failed", 1))),
-      )
-    }
-  }
-  const integrations = yield* loadIntegrations(client)
-  if (target) return yield* resolveIntegration(integrations, target)
-  const available = integrations
-    .filter((integration) => connectMethods(integration).length > 0)
-    .toSorted(
-      (a, b) =>
-        (integrationPriority.get(a.id) ?? integrationPriority.size) -
-          (integrationPriority.get(b.id) ?? integrationPriority.size) ||
-        a.name.localeCompare(b.name) ||
-        a.id.localeCompare(b.id),
-    )
-  if (available.length === 0) return yield* Effect.fail(new Error("No authentication integrations are available"))
-  const id = yield* prompt<string>(() =>
-    autocomplete({
-      message: "Select integration",
-      maxItems: 8,
-      options: available.map((integration) => {
-        const option = { value: integration.id, label: integration.name, hint: integration.id }
-        if (integration.connections.length > 0) return { ...option, hint: "connected" }
-        if (integration.id === "opencode") return { ...option, hint: "recommended" }
-        return option
-      }),
-    }),
-  )
-  return yield* resolveIntegration(available, id)
-})
-
-const chooseMethod = Effect.fn("cli.auth.login.method")(function* (methods: ConnectMethod[], target?: string) {
-  if (target) return yield* resolveMethod(methods, target)
-  if (methods.length === 1) return methods[0]
-  yield* requireInteractive("Pass --method when running without an interactive terminal")
-  const id = yield* prompt<string>(() =>
-    select({
-      message: "Select login method",
-      options: methods.map((method) => {
-        if (method.type === "key") return { value: "key", label: method.label ?? "API key" }
-        return { value: method.id, label: method.label }
-      }),
-    }),
-  )
-  return yield* resolveMethod(methods, id)
-})
-
-const authenticate = Effect.fn("cli.auth.login.authenticate")(function* (
-  client: OpenCodeClient,
-  integration: IntegrationInfo,
-  method: ConnectMethod,
-  answer?: FormAnswer,
-) {
-  if (method.type === "key") return yield* keyLogin(client, integration, method, answer)
-  if (method.type === "command") return yield* commandLogin(client, integration, method)
-  return yield* oauthLogin(client, integration, method, answer)
-})
-
-const keyLogin = Effect.fn("cli.auth.login.key")(function* (
-  client: OpenCodeClient,
-  integration: IntegrationInfo,
-  method: Extract<ConnectMethod, { type: "key" }>,
-  answer?: FormAnswer,
-) {
-  const key = yield* secret(method.label ?? `Enter your ${integration.name} API key`)
-  const progress = spinner()
-  progress.start("Saving credential...")
-  yield* request((signal) =>
-    client.integration.connect.key({ integrationID: integration.id, key, answer, location }, { signal }),
-  ).pipe(
-    Effect.tap(() => Effect.sync(() => progress.stop(`Connected to ${integration.name}`))),
-    Effect.tapCause(() => Effect.sync(() => progress.stop("Authentication failed", 1))),
-  )
-})
-
-const oauthLogin = Effect.fn("cli.auth.login.oauth")(function* (
-  client: OpenCodeClient,
-  integration: IntegrationInfo,
-  method: Extract<ConnectMethod, { type: "oauth" }>,
-  answer?: FormAnswer,
-) {
-  const progress = spinner()
-  progress.start("Starting authorization...")
-  const started = yield* request((signal) =>
-    client.integration.oauth.connect(
-      { integrationID: integration.id, methodID: method.id, answer, location },
-      { signal },
-    ),
-  ).pipe(Effect.tapCause(() => Effect.sync(() => progress.stop("Authentication failed", 1))))
-  const attempt = started.data
-  yield* Effect.addFinalizer(() =>
-    request(() =>
-      client.integration.oauth.cancel(
-        { integrationID: integration.id, attemptID: attempt.attemptID, location },
-        { signal: AbortSignal.timeout(5_000) },
-      ),
-    ).pipe(Effect.ignore),
-  )
-  progress.stop("Authorization started")
-  log.info(attempt.instructions)
-  log.info(attempt.url)
-  if (process.stdin.isTTY && process.stdout.isTTY) yield* openUrl(attempt.url)
-
-  if (attempt.mode === "code") {
-    yield* requireInteractive("This login requires an interactive terminal to enter the authorization code")
-    const code = yield* prompt<string>(() =>
-      text({ message: "Paste the authorization code", validate: (value) => (!value ? "Required" : undefined) }),
-    )
-    const completing = spinner()
-    completing.start("Completing authorization...")
-    yield* request((signal) =>
-      client.integration.oauth.complete(
-        { integrationID: integration.id, attemptID: attempt.attemptID, code, location },
-        { signal },
-      ),
-    ).pipe(
-      Effect.tap(() => Effect.sync(() => completing.stop(`Connected to ${integration.name}`))),
-      Effect.tapCause(() => Effect.sync(() => completing.stop("Authentication failed", 1))),
-    )
-    return
-  }
-
-  const waiting = spinner()
-  waiting.start("Waiting for authorization...")
-  const status = yield* waitForOAuth(client, integration.id, attempt.attemptID).pipe(
-    Effect.tapCause(() => Effect.sync(() => waiting.stop("Authentication failed", 1))),
-  )
-  if (status.status === "complete") {
-    waiting.stop(`Connected to ${integration.name}`)
-    return
-  }
-  waiting.stop("Authentication failed", 1)
-  if (status.status === "failed") yield* Effect.fail(new Error(status.message))
-  yield* Effect.fail(new Error("Authorization expired"))
-})
-
-const commandLogin = Effect.fn("cli.auth.login.command")(function* (
-  client: OpenCodeClient,
-  integration: IntegrationInfo,
-  method: Extract<ConnectMethod, { type: "command" }>,
-) {
-  const progress = spinner()
-  progress.start("Starting authentication command...")
-  const started = yield* request((signal) =>
-    client.integration.command.connect({ integrationID: integration.id, methodID: method.id, location }, { signal }),
-  ).pipe(Effect.tapCause(() => Effect.sync(() => progress.stop("Authentication failed", 1))))
-  yield* Effect.addFinalizer(() =>
-    request(() =>
-      client.integration.command.cancel(
-        {
-          integrationID: integration.id,
-          attemptID: started.data.attemptID,
-          location,
-        },
-        { signal: AbortSignal.timeout(5_000) },
-      ),
-    ).pipe(Effect.ignore),
-  )
-  const status = yield* waitForCommand(client, integration.id, started.data.attemptID, (message) =>
-    progress.message(message.trim() || "Waiting for authentication command..."),
-  ).pipe(Effect.tapCause(() => Effect.sync(() => progress.stop("Authentication failed", 1))))
-  if (status.status === "complete") {
-    progress.stop(`Connected to ${integration.name}`)
-    return
-  }
-  progress.stop("Authentication failed", 1)
-  if (status.status === "failed") yield* Effect.fail(new Error(status.message))
-  yield* Effect.fail(new Error("Authentication expired"))
-})
-
-const waitForOAuth = Effect.fn("cli.auth.login.oauth.wait")(function* (
+const wait = (
   client: OpenCodeClient,
   integrationID: string,
   attemptID: string,
-) {
-  while (true) {
-    const response = yield* request((signal) =>
-      client.integration.oauth.status({ integrationID, attemptID, location }, { signal }),
-    )
+  shown = false,
+): Effect.Effect<Exclude<IntegrationCommandStatusOutput["data"], { status: "pending" }>, unknown> =>
+  Effect.gen(function* () {
+    const response = yield* request(() => client.integration.command.status({ integrationID, attemptID, location }))
     if (response.data.status !== "pending") return response.data
+    const output = response.data.message?.trim()
+    if (!shown && output) process.stdout.write(output + EOL + EOL)
     yield* Effect.sleep(500)
-  }
-})
+    return yield* wait(client, integrationID, attemptID, shown || !!output)
+  })
 
-const waitForCommand = Effect.fn("cli.auth.login.command.wait")(function* (
-  client: OpenCodeClient,
-  integrationID: string,
-  attemptID: string,
-  update: (message: string) => void,
-) {
-  while (true) {
-    const response = yield* request((signal) =>
-      client.integration.command.status({ integrationID, attemptID, location }, { signal }),
-    )
-    if (response.data.status !== "pending") return response.data
-    if (response.data.message) update(response.data.message)
-    yield* Effect.sleep(500)
-  }
-})
+function request<A>(task: () => Promise<A>) {
+  return Effect.tryPromise({ try: task, catch: (cause) => cause })
+}

packages/cli/src/commands/handlers/auth/logout.ts

@@ -1,83 +0,0 @@
-import { autocomplete, intro, outro, spinner } from "@clack/prompts"
-import { Effect, Option } from "effect"
-import type { IntegrationInfo } from "@opencode-ai/client"
-import { Commands } from "../../commands"
-import { Runtime } from "../../../framework/runtime"
-import { handlePromptErrors, prompt, requireInteractive } from "../../../ui/prompt"
-import { createClient, loadIntegrations, location, request, resolveIntegration } from "./shared"
-
-export default Runtime.handler(
-  Commands.commands.auth.commands.logout,
-  Effect.fn("cli.auth.logout")((input) =>
-    logout({
-      target: Option.getOrUndefined(input.target),
-      server: Option.getOrUndefined(input.server),
-      standalone: input.standalone,
-    }).pipe(handlePromptErrors),
-  ),
-)
-
-const logout = Effect.fn("cli.auth.logout.run")(function* (input: {
-  target?: string
-  server?: string
-  standalone: boolean
-}) {
-  if (!input.target)
-    yield* requireInteractive("Pass an integration ID or name when running without an interactive terminal")
-  intro("Remove credential")
-  const client = yield* createClient({ server: input.server, standalone: input.standalone })
-  const integrations = yield* loadIntegrations(client)
-  const integration = yield* chooseIntegration(integrations, input.target)
-  const credentials = integration.connections.filter((connection) => connection.type === "credential")
-  if (credentials.length === 0) {
-    const environment = integration.connections
-      .filter((connection) => connection.type === "env")
-      .map((connection) => connection.name)
-    if (environment.length) {
-      yield* Effect.fail(
-        new Error(
-          `${integration.name} is authenticated through ${environment.join(", ")}; unset the environment variable to disconnect`,
-        ),
-      )
-    }
-    yield* Effect.fail(new Error(`No stored credentials for ${integration.name}`))
-  }
-  const progress = spinner()
-  progress.start("Removing credential...")
-  yield* Effect.forEach(
-    credentials,
-    (connection) =>
-      request((signal) => client.credential.remove({ credentialID: connection.id, location }, { signal })),
-    { concurrency: "unbounded", discard: true },
-  ).pipe(
-    Effect.tap(() => Effect.sync(() => progress.stop(`Disconnected from ${integration.name}`))),
-    Effect.tapCause(() => Effect.sync(() => progress.stop("Failed to remove credential", 1))),
-  )
-  outro("Done")
-})
-
-const chooseIntegration = Effect.fn("cli.auth.logout.integration")(function* (
-  integrations: IntegrationInfo[],
-  target?: string,
-) {
-  if (target) return yield* resolveIntegration(integrations, target)
-  const configured = integrations.filter((integration) =>
-    integration.connections.some((connection) => connection.type === "credential"),
-  )
-  if (configured.length === 0) return yield* Effect.fail(new Error("No stored credentials found"))
-  const id = yield* prompt<string>(() =>
-    autocomplete({
-      message: "Select integration",
-      maxItems: 8,
-      options: configured.map((integration) => ({
-        value: integration.id,
-        label: integration.name,
-        hint: integration.connections
-          .filter((connection) => connection.type === "credential")
-          .map((connection) => connection.label)
-          .join(", "),
-      })),
-    }),
-  )
-  return yield* resolveIntegration(configured, id)
-})

packages/cli/src/commands/handlers/auth/shared.ts

@@ -1,64 +0,0 @@
-import { Effect } from "effect"
-import { OpenCode, type IntegrationInfo, type IntegrationMethod, type OpenCodeClient } from "@opencode-ai/client"
-import { Service } from "@opencode-ai/client/effect/service"
-import { ServerConnection } from "../../../services/server-connection"
-
-export const location = { directory: process.cwd() }
-
-export const createClient = Effect.fn("cli.auth.client")(function* (input: ServerConnection.Args) {
-  const server = yield* ServerConnection.resolve(input)
-  return OpenCode.make({ baseUrl: server.endpoint.url, headers: Service.headers(server.endpoint) })
-})
-
-export function request<A>(run: (signal: AbortSignal) => Promise<A>) {
-  return Effect.tryPromise({ try: run, catch: (cause) => cause })
-}
-
-export const loadIntegrations = Effect.fn("cli.auth.integrations")(function* (client: OpenCodeClient) {
-  // The model endpoint is the existing public readiness boundary for the initial plugin generation.
-  yield* request((signal) => client.model.default({ location }, { signal }))
-  return yield* request((signal) => client.integration.list({ location }, { signal })).pipe(
-    Effect.map((response) => response.data),
-  )
-})
-
-export const resolveIntegration = Effect.fn("cli.auth.resolve-integration")(function* (
-  integrations: IntegrationInfo[],
-  target: string,
-) {
-  const normalized = target.replace(/\/+$/, "")
-  const byID = integrations.find((integration) => integration.id === normalized)
-  if (byID) return byID
-  const matches = integrations.filter((integration) => integration.name.toLowerCase() === normalized.toLowerCase())
-  if (matches.length === 1) return matches[0]
-  if (matches.length > 1) {
-    return yield* Effect.fail(
-      new Error(
-        `Integration name "${target}" is ambiguous: ${matches.map((integration) => integration.id).join(", ")}`,
-      ),
-    )
-  }
-  return yield* Effect.fail(new Error(`Integration not found: ${target}`))
-})
-
-export type ConnectMethod = Exclude<IntegrationMethod, { type: "env" }>
-
-export function connectMethods(integration: IntegrationInfo) {
-  return integration.methods
-    .filter((method): method is ConnectMethod => method.type !== "env")
-    .toSorted((a, b) => Number(a.type === "key") - Number(b.type === "key"))
-}
-
-export const resolveMethod = Effect.fn("cli.auth.resolve-method")(function* (methods: ConnectMethod[], target: string) {
-  const normalized = target.toLowerCase()
-  const matches = methods.filter((method) => {
-    if (method.type === "key") return normalized === "key" || method.label?.toLowerCase() === normalized
-    return method.id === target || method.label.toLowerCase() === normalized
-  })
-  if (matches.length === 1) return matches[0]
-  if (matches.length > 1) return yield* Effect.fail(new Error(`Authentication method "${target}" is ambiguous`))
-  const available = methods.map((method) => (method.type === "key" ? "key" : method.id)).join(", ")
-  return yield* Effect.fail(
-    new Error(`Authentication method not found: ${target}${available ? `. Available: ${available}` : ""}`),
-  )
-})

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

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

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

@@ -1,88 +1,140 @@
-import { autocomplete, cancel, intro, isCancel, log, outro } from "@clack/prompts"
-import { OpenCode } from "@opencode-ai/client"
+import { OpenCode, type SessionInfo } from "@opencode-ai/client"
 import { Service } from "@opencode-ai/client/effect/service"
 import { Effect, Option } from "effect"
-import { EOL } from "node:os"
+import { EOL, tmpdir } from "node:os"
+import path from "node:path"
+import { emitKeypressEvents, type Key } from "node:readline"
 import { Commands } from "../commands"
 import { Runtime } from "../../framework/runtime"
 import { ServerConnection } from "../../services/server-connection"
-import { errorMessage } from "../../ui/prompt"
 
 export default Runtime.handler(
   Commands.commands.export,
-  Effect.fn("cli.export")((input) =>
-    Effect.gen(function* () {
-      const requested = Option.getOrUndefined(input.session)
-      if (!requested && !process.stdin.isTTY) {
-        yield* Effect.fail(new Error("Pass a session ID when running without an interactive terminal"))
-      }
-      const server = yield* ServerConnection.resolve({
-        server: Option.getOrUndefined(input.server),
-        standalone: input.standalone,
-      })
-      const client = OpenCode.make({
-        baseUrl: server.endpoint.url,
-        headers: Service.headers(server.endpoint),
-      })
-      const sessionID = requested
-        ? requested
-        : yield* Effect.gen(function* () {
-            intro("Export session", { output: process.stderr })
-            const location = yield* Effect.tryPromise({
-              try: () => client.location.get({ location: { directory: process.cwd() } }),
-              catch: (cause) => cause,
-            })
-            const page = yield* Effect.tryPromise({
-              try: () =>
-                client.session.list({
-                  directory: location.directory,
-                  workspace: location.workspaceID,
-                  parentID: null,
-                  order: "desc",
-                  limit: 50,
-                }),
-              catch: (cause) => cause,
-            })
-            if (page.data.length === 0) {
-              log.error("No sessions found", { output: process.stderr })
-              outro("Done", { output: process.stderr })
-              return undefined
-            }
-            const selected = yield* Effect.tryPromise({
-              try: () =>
-                autocomplete({
-                  message: "Select session to export",
-                  maxItems: 10,
-                  options: page.data.map((session) => ({
-                    label: session.title,
-                    value: session.id,
-                    hint: `${new Date(session.time.updated).toLocaleString()} - ${session.id.slice(-8)}`,
-                  })),
-                  output: process.stderr,
-                }),
-              catch: (cause) => cause,
-            })
-            if (isCancel(selected)) {
-              cancel("Cancelled", { output: process.stderr })
-              process.exitCode = 130
-              return undefined
-            }
-            outro("Exporting session...", { output: process.stderr })
-            return selected
+  Effect.fn("cli.export")(function* (input) {
+    const server = yield* ServerConnection.resolve({
+      server: Option.getOrUndefined(input.server),
+      standalone: input.standalone,
+    })
+    const client = OpenCode.make({
+      baseUrl: server.endpoint.url,
+      headers: Service.headers(server.endpoint),
+    })
+    const requested = Option.getOrUndefined(input.session)
+    const selected = requested
+      ? undefined
+      : yield* Effect.promise(async () => {
+          const location = await client.location.get({ location: { directory: process.cwd() } })
+          const page = await client.session.list({
+            directory: location.directory,
+            workspace: location.workspaceID,
+            parentID: null,
+            order: "desc",
+            limit: 50,
           })
-      if (!sessionID) return
-      const data = yield* Effect.tryPromise({
-        try: () => client.session.export({ sessionID, sanitize: input.sanitize }),
-        catch: (cause) => cause,
-      })
-      process.stdout.write(JSON.stringify(data, null, 2) + EOL)
-    }).pipe(
-      Effect.catch((error) =>
-        Effect.sync(() => {
-          process.stderr.write(errorMessage(error) + EOL)
-          process.exitCode = 1
-        }),
-      ),
-    ),
-  ),
+          if (page.data.length === 0) {
+            process.stderr.write(`No sessions found${EOL}`)
+            return undefined
+          }
+          return selectSession(page.data, input.sanitize)
+        })
+    const sessionID = requested ?? selected?.session.id
+    if (!sessionID) return
+    const data = yield* Effect.promise(() =>
+      client.session.export({ sessionID, sanitize: selected?.sanitize ?? input.sanitize }),
+    )
+    process.stdout.write(yield* Effect.promise(() => writeExport(data, sessionID, requested !== undefined)))
+  }),
 )
+
+type Selection = { session: SessionInfo; sanitize: boolean }
+
+function selectSession(sessions: SessionInfo[], initialSanitize: boolean) {
+  if (!process.stdin.isTTY) return Promise.reject(new Error("Session ID is required when stdin is not interactive"))
+  const input = process.stdin
+  const output = process.stderr
+  const wasRaw = input.isRaw
+  const wasPaused = input.isPaused()
+  const date = new Intl.DateTimeFormat(undefined, {
+    month: "short",
+    day: "numeric",
+    hour: "numeric",
+    minute: "2-digit",
+  })
+  const columns = output.columns ?? 100
+  const titleWidth = Math.max(8, Math.min(48, columns - 34))
+  let selected = 0
+  let offset = 0
+  let sanitize = initialSanitize
+  let height = 0
+
+  const render = () => {
+    const visible = sessions.slice(offset, offset + 10)
+    const lines = ["  \x1b[36mExport session\x1b[0m", ""]
+    lines.push(
+      ...visible.map((session) => {
+        const index = sessions.indexOf(session)
+        const title = (session.title ?? "Untitled session").slice(0, titleWidth).padEnd(titleWidth)
+        const updated = date.format(session.time.updated).slice(0, 18).padEnd(18)
+        const row = `${index === selected ? ">" : " "} ${title}  ${updated}  ${session.id.slice(-8)}`
+        return index === selected ? `\x1b[1m${row}\x1b[0m` : row
+      }),
+      "",
+      `  [${sanitize ? "x" : " "}] sanitize sensitive data`,
+      "",
+      "  navigate \x1b[2mup/down\x1b[0m   sanitize \x1b[2mspace\x1b[0m   export \x1b[2menter\x1b[0m   cancel \x1b[2mesc\x1b[0m",
+    )
+    if (height > 0) output.write(`\x1b[${height}F\x1b[J`)
+    output.write(lines.join(EOL) + EOL)
+    height = lines.length
+  }
+  const clear = () => {
+    if (height > 0) output.write(`\x1b[${height}F\x1b[J`)
+    output.write("\x1b[?25h")
+    input.removeListener("keypress", onKeypress)
+    input.setRawMode(wasRaw ?? false)
+    if (wasPaused) input.pause()
+  }
+  const onKeypress = (value: string | undefined, key: Key) => {
+    if (key.name === "up") {
+      selected = (selected - 1 + sessions.length) % sessions.length
+      if (selected === sessions.length - 1) offset = Math.max(0, sessions.length - 10)
+      if (selected < offset) offset = selected
+    }
+    if (key.name === "down") {
+      selected = (selected + 1) % sessions.length
+      if (selected === 0) offset = 0
+      if (selected >= offset + 10) offset = selected - 9
+    }
+    if (key.name === "space" || value === " ") sanitize = !sanitize
+    if (key.name === "return") return finish(sessions[selected])
+    if (key.name === "escape" || (key.ctrl && key.name === "c")) return cancel()
+    render()
+  }
+  const finish = (session: SessionInfo) => {
+    clear()
+    resolveSelection?.({ session, sanitize })
+  }
+  const cancel = () => {
+    clear()
+    resolveSelection?.()
+  }
+  let resolveSelection: ((selection?: Selection) => void) | undefined
+
+  emitKeypressEvents(input)
+  input.setRawMode(true)
+  input.resume()
+  input.on("keypress", onKeypress)
+  output.write("\x1b[?25l")
+  render()
+  return new Promise<Selection | undefined>((resolve) => {
+    resolveSelection = resolve
+  })
+}
+
+export async function writeExport(data: unknown, sessionID: string, stdout: boolean) {
+  const json = JSON.stringify(data, null, 2) + EOL
+  if (stdout) return json
+  const file = path.join(tmpdir(), `opencode-session-${sessionID}-${crypto.randomUUID().slice(0, 8)}.json`)
+  await Bun.write(file, json)
+  return file + EOL
+}

packages/cli/src/commands/handlers/plugin/list.ts

@@ -1,6 +1,6 @@
 import { EOL } from "node:os"
 import { Effect } from "effect"
-import { OpenCode, type PluginInfo } from "@opencode-ai/client"
+import { OpenCode } from "@opencode-ai/client"
 import { Service } from "@opencode-ai/client/effect/service"
 import { Commands } from "../../commands"
 import { Runtime } from "../../../framework/runtime"
@@ -14,18 +14,11 @@ export default Runtime.handler(
     const endpoint = found ?? (yield* Service.ensure(options))
     const client = OpenCode.make({ baseUrl: endpoint.url, headers: Service.headers(endpoint) })
     const response = yield* Effect.promise(() => client.plugin.list({ location: { directory: process.cwd() } }))
-    const plugins = response.data.toSorted((a, b) => name(a).localeCompare(name(b)))
+    const plugins = response.data.toSorted((a, b) => a.id.localeCompare(b.id))
     if (plugins.length === 0) {
       process.stdout.write("No plugins loaded" + EOL)
       return
     }
-    process.stdout.write(plugins.map(name).join(EOL) + EOL)
+    process.stdout.write(plugins.map((plugin) => plugin.id).join(EOL) + EOL)
   }),
 )
-
-function name(plugin: PluginInfo) {
-  if (plugin.id) return plugin.id
-  if (plugin.source.type === "package") return plugin.source.package
-  if (plugin.source.type === "local") return plugin.source.path
-  return plugin.source.type
-}

packages/cli/src/commands/handlers/service/get.ts

@@ -7,8 +7,6 @@ import { ServiceConfig } from "../../../services/service-config"
 export default Runtime.handler(
   Commands.commands.service.commands.get,
   Effect.fn("cli.service.get")(function* (input) {
-    process.stdout.write(
-      (yield* ServiceConfig.get(Option.getOrUndefined(input.key), Option.getOrUndefined(input.name))) + EOL,
-    )
+    process.stdout.write((yield* ServiceConfig.get(Option.getOrUndefined(input.key))) + EOL)
   }),
 )

packages/cli/src/commands/handlers/service/set.ts

@@ -1,4 +1,4 @@
-import { Effect, Option } from "effect"
+import { Effect } from "effect"
 import { Commands } from "../../commands"
 import { Runtime } from "../../../framework/runtime"
 import { ServiceConfig } from "../../../services/service-config"
@@ -6,6 +6,6 @@ import { ServiceConfig } from "../../../services/service-config"
 export default Runtime.handler(
   Commands.commands.service.commands.set,
   Effect.fn("cli.service.set")(function* (input) {
-    yield* ServiceConfig.set(input.key, input.value, Option.getOrUndefined(input.nestedValue))
+    yield* ServiceConfig.set(input.key, input.value)
   }),
 )

packages/cli/src/commands/handlers/service/unset.ts

@@ -1,4 +1,4 @@
-import { Effect, Option } from "effect"
+import { Effect } from "effect"
 import { Commands } from "../../commands"
 import { Runtime } from "../../../framework/runtime"
 import { ServiceConfig } from "../../../services/service-config"
@@ -6,6 +6,6 @@ import { ServiceConfig } from "../../../services/service-config"
 export default Runtime.handler(
   Commands.commands.service.commands.unset,
   Effect.fn("cli.service.unset")(function* (input) {
-    yield* ServiceConfig.unset(input.key, Option.getOrUndefined(input.name))
+    yield* ServiceConfig.unset(input.key)
   }),
 )

packages/cli/src/index.ts

@@ -19,9 +19,7 @@ const Handlers = Runtime.handlers(Commands, {
   acp: () => import("./commands/handlers/acp"),
   api: () => import("./commands/handlers/api"),
   auth: {
-    list: () => import("./commands/handlers/auth/list"),
     login: () => import("./commands/handlers/auth/login"),
-    logout: () => import("./commands/handlers/auth/logout"),
   },
   debug: {
     agents: () => import("./commands/handlers/debug/agents"),
@@ -59,21 +57,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 +65,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),

packages/cli/src/server-process.ts

@@ -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,36 +180,18 @@ 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,
-        serviceID: id,
-        servicePID: process.pid,
-        registration: file,
-      }).pipe(Effect.andThen(Effect.failCause(cause))),
-    ),
-    Effect.tap((found) =>
-      owns(found)
-        ? Effect.void
-        : Effect.logWarning("managed service registration replaced; shutting down", {
-            serviceID: id,
-            servicePID: process.pid,
-            registration: file,
-            observedServiceID: found.id,
-            observedServicePID: found.pid,
-            observedVersion: found.version,
-            observedURL: found.url,
-          }),
-    ),
     Effect.filterOrFail(owns),
     Effect.repeat(Schedule.spaced("5 seconds")),
     Effect.ignore,

packages/cli/src/services/service-config.ts

@@ -15,11 +15,10 @@ export const Info = Schema.Struct({
   hostname: Schema.optional(Schema.String),
   port: Schema.optional(Schema.Int.check(Schema.isGreaterThanOrEqualTo(1), Schema.isLessThanOrEqualTo(65_535))),
   password: Schema.optional(Schema.String),
-  env: Schema.optional(Schema.Record(Schema.String, Schema.String)),
 })
 export type Info = typeof Info.Type
 
-const keys = ["hostname", "port", "password", "env"] as const
+const keys = ["hostname", "port", "password"] as const
 type Key = (typeof keys)[number]
 
 const decodeInfo = Schema.decodeUnknownEffect(Schema.fromJsonString(Info))
@@ -77,7 +76,7 @@ export const migrateConfig = Effect.fnUntraced(function* (legacy: string, file:
 })
 
 function configKey(key: string): Key {
-  if (key === "hostname" || key === "port" || key === "password" || key === "env") return key
+  if (key === "hostname" || key === "port" || key === "password") return key
   throw new Error(`Unknown service config key: ${key}`)
 }
 
@@ -105,7 +104,6 @@ export const options = Effect.fnUntraced(function* (input: { readonly checkVersi
   return {
     file,
     version: input.checkVersion ? OPENCODE_VERSION : undefined,
-    env: (yield* read()).env,
     command: [
       ...selfCommand(),
       "serve",
@@ -143,14 +141,12 @@ export const password = Effect.fn("cli.service-config.password")(function* (valu
   return next
 })
 
-export const get = Effect.fn("cli.service-config.get")(function* (key?: string, name?: string) {
+export const get = Effect.fn("cli.service-config.get")(function* (key?: string) {
   if (key === undefined) {
     const { password: _password, ...safe } = yield* read()
     return JSON.stringify(safe, null, 2)
   }
-  const selected = configKey(key)
-  if (selected !== "env" && name !== undefined) throw new Error(`Usage: opencode service get ${selected}`)
-  switch (selected) {
+  switch (configKey(key)) {
     case "hostname": {
       return (yield* read()).hostname ?? ""
     }
@@ -161,19 +157,12 @@ export const get = Effect.fn("cli.service-config.get")(function* (key?: string,
     case "password": {
       return yield* password()
     }
-    case "env": {
-      const env = (yield* read()).env ?? {}
-      return name === undefined ? JSON.stringify(env, null, 2) : (env[name] ?? "")
-    }
   }
   throw new Error(`Unknown service config key: ${key}`)
 })
 
-export const set = Effect.fn("cli.service-config.set")(function* (key: string, value: string, nestedValue?: string) {
-  const selected = configKey(key)
-  if (selected !== "env" && nestedValue !== undefined)
-    throw new Error(`Usage: opencode service set ${selected} <value>`)
-  switch (selected) {
+export const set = Effect.fn("cli.service-config.set")(function* (key: string, value: string) {
+  switch (configKey(key)) {
     case "hostname": {
       yield* Service.stop(yield* options())
       yield* write({ ...(yield* read()), hostname: value })
@@ -191,20 +180,11 @@ export const set = Effect.fn("cli.service-config.set")(function* (key: string, v
       yield* password(value)
       return
     }
-    case "env": {
-      if (nestedValue === undefined) throw new Error("Usage: opencode service set env <key> <value>")
-      yield* Service.stop(yield* options())
-      const existing = yield* read()
-      yield* write({ ...existing, env: { ...existing.env, [value]: nestedValue } })
-      return
-    }
   }
 })
 
-export const unset = Effect.fn("cli.service-config.unset")(function* (key: string, name?: string) {
-  const selected = configKey(key)
-  if (selected !== "env" && name !== undefined) throw new Error(`Usage: opencode service unset ${selected}`)
-  switch (selected) {
+export const unset = Effect.fn("cli.service-config.unset")(function* (key: string) {
+  switch (configKey(key)) {
     case "hostname": {
       yield* Service.stop(yield* options())
       const { hostname: _hostname, ...next } = yield* read()
@@ -223,15 +203,6 @@ export const unset = Effect.fn("cli.service-config.unset")(function* (key: strin
       yield* write(next)
       return
     }
-    case "env": {
-      if (name === undefined) throw new Error("Usage: opencode service unset env <key>")
-      yield* Service.stop(yield* options())
-      const existing = yield* read()
-      const { [name]: _removed, ...env } = existing.env ?? {}
-      const { env: _existingEnv, ...rest } = existing
-      yield* write(Object.keys(env).length === 0 ? rest : { ...rest, env })
-      return
-    }
   }
 })
 

packages/cli/src/ui/prompt.ts

@@ -1,48 +0,0 @@
-import { cancel, isCancel, log, outro } from "@clack/prompts"
-import { Effect } from "effect"
-
-const cancelled = Symbol("cancelled")
-
-export function prompt<A>(run: () => Promise<A | symbol>) {
-  return Effect.tryPromise({ try: run, catch: (cause) => cause }).pipe(
-    Effect.flatMap((value) => (isCancel(value) ? Effect.fail(cancelled) : Effect.succeed(value))),
-  )
-}
-
-export function requireInteractive(message: string) {
-  if (process.stdin.isTTY && process.stdout.isTTY) return Effect.void
-  return Effect.fail(new Error(message))
-}
-
-export const openUrl = Effect.fn("cli.prompt.open-url")(function* (url: string) {
-  const { default: open } = yield* Effect.promise(() => import("open"))
-  yield* Effect.promise(() => open(url)).pipe(Effect.ignore)
-})
-
-export function handlePromptErrors<A, E, R>(effect: Effect.Effect<A, E, R>) {
-  return effect.pipe(
-    Effect.catchIf(
-      (error) => error === cancelled,
-      () =>
-        Effect.sync(() => {
-          cancel("Cancelled")
-          process.exitCode = 130
-        }),
-    ),
-    Effect.catch((error) =>
-      Effect.sync(() => {
-        log.error(errorMessage(error))
-        outro("Failed")
-        process.exitCode = 1
-      }),
-    ),
-  )
-}
-
-export function errorMessage(error: unknown) {
-  if (error instanceof Error) return error.message
-  if (typeof error === "object" && error !== null && "message" in error && typeof error.message === "string") {
-    return error.message
-  }
-  return String(error)
-}

packages/cli/test/auth.test.ts

@@ -1,267 +1,20 @@
 import { describe, expect, test } from "bun:test"
 import path from "node:path"
-import { OPENCODE_VERSION } from "../src/version"
 
 describe("auth command", () => {
-  test("registers authentication commands", async () => {
-    const [auth, list, login, logout] = await Promise.all([
-      cli(["auth", "--help"]),
-      cli(["auth", "list", "--help"]),
-      cli(["auth", "login", "--help"]),
-      cli(["auth", "logout", "--help"]),
-    ])
+  test("registers login", async () => {
+    const [auth, login] = await Promise.all([cli(["auth", "--help"]), cli(["auth", "login", "--help"])])
 
     expect(auth.exitCode).toBe(0)
-    expect(auth.stdout).toContain("list")
     expect(auth.stdout).toContain("login")
-    expect(auth.stdout).toContain("logout")
-    expect(auth.stdout).toContain("manage AI providers and credentials")
-    expect(auth.stdout).toContain("list providers and credentials")
-    expect(auth.stdout).toContain("log in to a provider")
-    expect(auth.stdout).toContain("log out from a configured provider")
+    expect(auth.stdout).toContain("Log in to a well-known authentication provider")
     expect(auth.stdout).not.toContain("connect")
-    expect(list.exitCode).toBe(0)
-    expect(list.stdout).toContain("opencode auth list [flags]")
-    expect(list.stdout).toContain("--format")
     expect(login.exitCode).toBe(0)
-    expect(login.stdout).toContain("opencode auth login [flags] [<target>]")
-    expect(login.stdout).toContain("Integration ID, name, or well-known provider URL")
-    expect(login.stdout).toContain("--method")
-    expect(logout.exitCode).toBe(0)
-    expect(logout.stdout).toContain("opencode auth logout [flags] [<target>]")
-  })
-
-  test("lists stored and environment connections", async () => {
-    const requests: string[] = []
-    using server = authServer((request, url) => {
-      if (url.pathname === "/api/integration") {
-        return Response.json(
-          located([
-            {
-              id: "anthropic",
-              name: "Anthropic",
-              methods: [],
-              connections: [
-                { type: "credential", id: "cred_test", label: "default" },
-                { type: "env", name: "ANTHROPIC_API_KEY" },
-              ],
-            },
-            { id: "openai", name: "OpenAI", methods: [], connections: [] },
-          ]),
-        )
-      }
-      return new Response("Not found", { status: 404 })
-    }, requests)
-
-    const result = await cli(["auth", "list", "--format", "json", "--server", server.url.toString()])
-    expect({ exitCode: result.exitCode, stderr: result.stderr }).toEqual({ exitCode: 0, stderr: "" })
-    expect(JSON.parse(result.stdout)).toEqual([
-      {
-        id: "anthropic",
-        name: "Anthropic",
-        connections: [
-          { type: "credential", id: "cred_test", label: "default" },
-          { type: "env", name: "ANTHROPIC_API_KEY" },
-        ],
-      },
-    ])
-    expect(requests.indexOf("/api/model/default")).toBeLessThan(requests.indexOf("/api/integration"))
-  })
-
-  test("runs command authentication without interactive input", async () => {
-    const requests: Array<{ method: string; path: string }> = []
-    using server = authServer((request, url) => {
-      requests.push({ method: request.method, path: url.pathname })
-      if (url.pathname === "/api/integration") {
-        return Response.json(
-          located([
-            {
-              id: "company",
-              name: "Company",
-              methods: [{ id: "login", type: "command", label: "Company login", command: ["company", "login"] }],
-              connections: [],
-            },
-          ]),
-        )
-      }
-      if (url.pathname === "/api/integration/company/connect/command" && request.method === "POST") {
-        return Response.json(located({ attemptID: "con_test", time: { created: 1, expires: 2 } }))
-      }
-      if (url.pathname === "/api/integration/company/connect/command/con_test" && request.method === "GET") {
-        return Response.json(located({ status: "complete", time: { created: 1, expires: 2 } }))
-      }
-      if (url.pathname === "/api/integration/company/connect/command/con_test" && request.method === "DELETE") {
-        return new Response(null, { status: 204 })
-      }
-      return new Response("Not found", { status: 404 })
-    })
-
-    const result = await cli(["auth", "login", "company", "--server", server.url.toString()])
-    expect({ exitCode: result.exitCode, stderr: result.stderr }).toEqual({ exitCode: 0, stderr: "" })
-    expect(result.stdout).toContain("Connected to Company")
-    expect(requests).toContainEqual({ method: "POST", path: "/api/integration/company/connect/command" })
-    expect(requests).toContainEqual({ method: "GET", path: "/api/integration/company/connect/command/con_test" })
-    expect(requests).toContainEqual({ method: "DELETE", path: "/api/integration/company/connect/command/con_test" })
-  })
-
-  test("completes automatic OAuth authentication", async () => {
-    const requests: Array<{ method: string; path: string }> = []
-    using server = authServer((request, url) => {
-      requests.push({ method: request.method, path: url.pathname })
-      if (url.pathname === "/api/integration") {
-        return Response.json(
-          located([
-            {
-              id: "openai",
-              name: "OpenAI",
-              methods: [{ id: "browser", type: "oauth", label: "Browser" }],
-              connections: [],
-            },
-          ]),
-        )
-      }
-      if (url.pathname === "/api/integration/openai/connect/oauth" && request.method === "POST") {
-        return Response.json(
-          located({
-            attemptID: "con_oauth",
-            url: "https://example.com/authorize",
-            instructions: "Authorize OpenAI",
-            mode: "auto",
-            time: { created: 1, expires: 2 },
-          }),
-        )
-      }
-      if (url.pathname === "/api/integration/openai/connect/oauth/con_oauth" && request.method === "GET") {
-        return Response.json(located({ status: "complete", time: { created: 1, expires: 2 } }))
-      }
-      if (url.pathname === "/api/integration/openai/connect/oauth/con_oauth" && request.method === "DELETE") {
-        return new Response(null, { status: 204 })
-      }
-      return new Response("Not found", { status: 404 })
-    })
-
-    const result = await cli(["auth", "login", "openai", "--server", server.url.toString()])
-    expect({ exitCode: result.exitCode, stderr: result.stderr }).toEqual({ exitCode: 0, stderr: "" })
-    expect(result.stdout).toContain("https://example.com/authorize")
-    expect(result.stdout).toContain("Connected to OpenAI")
-    expect(requests).toContainEqual({ method: "POST", path: "/api/integration/openai/connect/oauth" })
-    expect(requests).toContainEqual({ method: "GET", path: "/api/integration/openai/connect/oauth/con_oauth" })
-    expect(requests).toContainEqual({ method: "DELETE", path: "/api/integration/openai/connect/oauth/con_oauth" })
-  })
-
-  test("settles the OAuth spinner when status polling fails", async () => {
-    using server = authServer((request, url) => {
-      if (url.pathname === "/api/integration") {
-        return Response.json(
-          located([
-            {
-              id: "openai",
-              name: "OpenAI",
-              methods: [{ id: "browser", type: "oauth", label: "Browser" }],
-              connections: [],
-            },
-          ]),
-        )
-      }
-      if (url.pathname === "/api/integration/openai/connect/oauth" && request.method === "POST") {
-        return Response.json(
-          located({
-            attemptID: "con_oauth",
-            url: "https://example.com/authorize",
-            instructions: "Authorize OpenAI",
-            mode: "auto",
-            time: { created: 1, expires: 2 },
-          }),
-        )
-      }
-      if (url.pathname === "/api/integration/openai/connect/oauth/con_oauth" && request.method === "GET") {
-        return new Response("Unavailable", { status: 500 })
-      }
-      if (url.pathname === "/api/integration/openai/connect/oauth/con_oauth" && request.method === "DELETE") {
-        return new Response(null, { status: 204 })
-      }
-      return new Response("Not found", { status: 404 })
-    })
-
-    const result = await cli(["auth", "login", "openai", "--server", server.url.toString()])
-    expect(result.exitCode).toBe(1)
-    expect(result.stdout).toContain("Authentication failed")
-    expect(result.stdout).toContain("Failed")
-    expect(result.stdout).not.toContain("\n    at ")
-  })
-
-  test("removes stored credentials", async () => {
-    const removed: string[] = []
-    using server = authServer((request, url) => {
-      if (url.pathname === "/api/integration") {
-        return Response.json(
-          located([
-            {
-              id: "anthropic",
-              name: "Anthropic",
-              methods: [{ type: "key" }],
-              connections: [{ type: "credential", id: "cred_test", label: "default" }],
-            },
-          ]),
-        )
-      }
-      if (url.pathname === "/api/credential/cred_test" && request.method === "DELETE") {
-        removed.push("cred_test")
-        return new Response(null, { status: 204 })
-      }
-      return new Response("Not found", { status: 404 })
-    })
-
-    const result = await cli(["auth", "logout", "anthropic", "--server", server.url.toString()])
-    expect({ exitCode: result.exitCode, stderr: result.stderr }).toEqual({ exitCode: 0, stderr: "" })
-    expect(result.stdout).toContain("Disconnected from Anthropic")
-    expect(removed).toEqual(["cred_test"])
-  })
-
-  test("requires a target outside an interactive terminal", async () => {
-    const result = await cli(["auth", "login"])
-    expect(result.exitCode).toBe(1)
-    expect(result.stdout).toContain("Pass an integration ID or name")
-    expect(result.stdout).not.toContain("Background service failed to start")
-  })
-
-  test("reports list connection failures without a stack trace", async () => {
-    using server = Bun.serve({ port: 0, fetch: () => new Response("Unavailable", { status: 503 }) })
-    const result = await cli(["auth", "list", "--server", server.url.toString()])
-    expect(result.exitCode).toBe(1)
-    expect(result.stdout).toBe("")
-    expect(result.stderr).toContain("did not provide a compatible V2 health response")
-    expect(result.stderr).not.toContain("\n    at ")
+    expect(login.stdout).toContain("opencode auth login [flags] <url>")
+    expect(login.stdout).toContain("Well-known provider URL")
   })
 })
 
-function authServer(fetch: (request: Request, url: URL) => Response | Promise<Response>, requests?: string[]) {
-  return Bun.serve({
-    port: 0,
-    fetch(request) {
-      const url = new URL(request.url)
-      requests?.push(url.pathname)
-      if (url.pathname === "/api/health") return health()
-      if (url.pathname === "/api/model/default") return Response.json(located(null))
-      return fetch(request, url)
-    },
-  })
-}
-
-function health() {
-  return Response.json({ healthy: true, version: OPENCODE_VERSION, pid: process.pid })
-}
-
-function located<T>(data: T) {
-  return {
-    location: {
-      directory: process.cwd(),
-      project: { id: "project", directory: process.cwd(), canonical: process.cwd() },
-    },
-    data,
-  }
-}
-
 async function cli(args: string[]) {
   const child = Bun.spawn([process.execPath, "run", "src/index.ts", ...args], {
     cwd: path.join(import.meta.dir, ".."),

packages/cli/test/import-export.test.ts

@@ -3,6 +3,7 @@ import fs from "node:fs/promises"
 import os from "node:os"
 import path from "node:path"
 import { OPENCODE_VERSION } from "../src/version"
+import { writeExport } from "../src/commands/handlers/export"
 
 const info = {
   id: "ses_export_test",
@@ -71,7 +72,7 @@ test("export is raw by default and supports explicit sanitization", async () =>
   })
 
   try {
-    const [stdout, , exitCode] = await run(["export", info.id, "--server", server.url.toString()])
+    const [stdout, , exitCode] = await run(["export", "-s", info.id, "--server", server.url.toString()])
     const exported = JSON.parse(stdout)
 
     expect(exitCode).toBe(0)
@@ -79,6 +80,7 @@ test("export is raw by default and supports explicit sanitization", async () =>
 
     const [sanitized, , sanitizedExitCode] = await run([
       "export",
+      "-s",
       info.id,
       "--sanitize",
       "--server",
@@ -92,7 +94,7 @@ test("export is raw by default and supports explicit sanitization", async () =>
   }
 }, 15_000)
 
-test("export requires a session outside an interactive terminal", async () => {
+test("export reports an empty session list without a stack trace", async () => {
   const server = Bun.serve({
     port: 0,
     fetch(request) {
@@ -112,39 +114,23 @@ test("export requires a session outside an interactive terminal", async () => {
   try {
     const [stdout, stderr, exitCode] = await run(["export", "--server", server.url.toString()])
 
-    expect(exitCode).toBe(1)
+    expect(exitCode).toBe(0)
     expect(stdout).toBe("")
-    expect(stderr).toBe(`Pass a session ID when running without an interactive terminal${os.EOL}`)
+    expect(stderr).toBe(`No sessions found${os.EOL}`)
   } finally {
     await server.stop(true)
   }
 })
 
-test("export reports a missing session without a stack trace", async () => {
-  const sessionID = "ses_missing"
-  const server = Bun.serve({
-    port: 0,
-    fetch(request) {
-      const url = new URL(request.url)
-      if (url.pathname === "/api/health") return health()
-      if (url.pathname === `/api/session/${sessionID}/export`) {
-        return Response.json(
-          { _tag: "SessionNotFoundError", sessionID, message: `Session not found: ${sessionID}` },
-          { status: 404 },
-        )
-      }
-      return new Response("Not found", { status: 404 })
-    },
-  })
+test("interactive export writes a temporary JSON file", async () => {
+  const output = await writeExport(transfer, info.id, false)
+  const file = output.trim()
 
   try {
-    const [stdout, stderr, exitCode] = await run(["export", sessionID, "--server", server.url.toString()])
-
-    expect(exitCode).toBe(1)
-    expect(stdout).toBe("")
-    expect(stderr).toBe(`Session not found: ${sessionID}${os.EOL}`)
+    expect(path.dirname(file)).toBe(os.tmpdir())
+    expect(await Bun.file(file).json()).toEqual(transfer)
   } finally {
-    await server.stop(true)
+    await fs.rm(file, { force: true })
   }
 })
 

packages/cli/test/service.test.ts

@@ -60,44 +60,6 @@ test("local channel stores service config with the local service filename", asyn
   }
 })
 
-test("service config manages environment variables", async () => {
-  const root = await fs.mkdtemp(path.join(os.tmpdir(), "opencode-service-env-"))
-  const layer = Global.layerWith({ config: path.join(root, "config"), state: path.join(root, "state") })
-  try {
-    await Effect.runPromise(
-      ServiceConfig.set("env", "OPENCODE_SERVICE_ENV_TEST", "configured").pipe(
-        Effect.provide(layer),
-        Effect.provide(NodeFileSystem.layer),
-      ),
-    )
-    expect(
-      await Effect.runPromise(
-        ServiceConfig.get("env", "OPENCODE_SERVICE_ENV_TEST").pipe(
-          Effect.provide(layer),
-          Effect.provide(NodeFileSystem.layer),
-        ),
-      ),
-    ).toBe("configured")
-    expect(
-      (
-        await Effect.runPromise(
-          ServiceConfig.options().pipe(Effect.provide(layer), Effect.provide(NodeFileSystem.layer)),
-        )
-      ).env,
-    ).toEqual({ OPENCODE_SERVICE_ENV_TEST: "configured" })
-
-    await Effect.runPromise(
-      ServiceConfig.unset("env", "OPENCODE_SERVICE_ENV_TEST").pipe(
-        Effect.provide(layer),
-        Effect.provide(NodeFileSystem.layer),
-      ),
-    )
-    expect(await Bun.file(path.join(root, "config", "service-local.json")).json()).toEqual({})
-  } finally {
-    await fs.rm(root, { recursive: true, force: true })
-  }
-})
-
 test("service filenames share release channels and identify preview channels", () => {
   expect(ServiceConfig.filename("latest")).toBe("service.json")
   expect(ServiceConfig.filename("dev")).toBe("service.json")

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

@@ -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> }

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

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

packages/client/src/effect/service.ts

@@ -71,7 +71,7 @@ export const ensure = Effect.fn("service.ensure")(function* (options: EnsureOpti
     if (command === undefined) return yield* Effect.fail(new Error("Missing service command"))
     return yield* Effect.try({
       try: () => {
-        return spawnServiceContender(command, args, options.env)
+        return spawnServiceContender(command, args)
       },
       catch: (cause) => new Error("Failed to start server", { cause }),
     })
@@ -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. */

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

@@ -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) =>

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

@@ -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 }
@@ -10,11 +12,7 @@ export type AgentColor = string
 
 export type PermissionEffect = "allow" | "deny" | "ask"
 
-export type PluginSource =
-  | { type: "builtin" }
-  | { type: "package"; package: string }
-  | { type: "local"; path: string }
-  | { type: "sdk" }
+export type PluginInfo = { id: string }
 
 export type SessionForkBoundary = { type: "before"; messageID: string } | { type: "through"; messageID: string }
 
@@ -200,10 +198,6 @@ export type ProviderRequest = {
 
 export type PermissionRule = { action: string; resource: string; effect: PermissionEffect }
 
-export type PluginInfo =
-  | { id: string; source: PluginSource; status: "active"; tui: boolean }
-  | { id?: string; source: PluginSource; status: "failed"; error: string; tui: boolean }
-
 export type TokenUsageInfo = {
   input: number
   output: number
@@ -2279,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 = {

packages/client/src/promise/service.ts

@@ -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"
 
@@ -51,7 +51,7 @@ export async function ensure(options: EnsureOptions = {}): Promise<Endpoint> {
     const [command, ...args] = options.command ?? ["opencode", "serve", "--service"]
     if (command === undefined) throw new Error("Missing service command")
     try {
-      return spawnServiceContender(command, args, options.env)
+      return spawnServiceContender(command, args)
     } catch (cause) {
       throw new Error("Failed to start server", { cause })
     }
@@ -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) {

packages/client/src/service-contender.ts

@@ -10,16 +10,8 @@ export type ServiceContender = {
 
 const stderrLimit = 8 * 1024
 
-export function spawnServiceContender(
-  command: string,
-  args: ReadonlyArray<string>,
-  env?: Readonly<Record<string, string>>,
-): ServiceContender {
-  const child = spawn(command, args, {
-    detached: true,
-    stdio: ["ignore", "ignore", "pipe"],
-    env: { ...process.env, ...env },
-  })
+export function spawnServiceContender(command: string, args: ReadonlyArray<string>): ServiceContender {
+  const child = spawn(command, args, { detached: true, stdio: ["ignore", "ignore", "pipe"] })
   let error: Error | undefined
   let closed = false
   let stderr = Buffer.alloc(0)

packages/client/src/service.ts

@@ -28,8 +28,6 @@ export type EnsureReason = "missing" | "version-mismatch"
 export type EnsureOptions = DiscoverOptions & {
   /** Service command and arguments. Defaults to `opencode serve --service`. */
   readonly command?: ReadonlyArray<string>
-  /** Environment variables added to the inherited service process environment. */
-  readonly env?: Readonly<Record<string, string>>
   /** Called once before spawning a new service process. */
   readonly onStart?: (reason: EnsureReason, previousVersion?: string) => void
 }

packages/client/test/fixture/service.ts

@@ -11,8 +11,6 @@ if (mode === "record-start") {
   await writeFile(registration + ".started", "")
   process.exit(1)
 }
-if (mode === "environment")
-  await writeFile(registration + ".environment", process.env.OPENCODE_SERVICE_ENV_TEST ?? "")
 if (mode === "signal") process.kill(process.pid, process.platform === "win32" ? "SIGTERM" : "SIGKILL")
 
 if (mode === "delayed" || mode === "delayed-failed" || mode === "coordinated" || mode === "coordinated-failed-loser") {
@@ -30,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()
@@ -38,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", "")
@@ -54,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 })
   },
@@ -72,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)

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

@@ -59,26 +59,6 @@ test("ensures a missing service with native promises", async () => {
   }
 })
 
-test("adds configured environment variables with native promises", async () => {
-  const directory = await temp()
-  const registration = join(directory, "service.json")
-  const endpoint = await ensure({
-    file: registration,
-    version: "test",
-    command: [process.execPath, fixture, registration, "environment"],
-    env: { OPENCODE_SERVICE_ENV_TEST: "configured" },
-  })
-  const info = await Bun.file(registration).json()
-
-  try {
-    expect(endpoint.url).toBe(info.url)
-    expect(await Bun.file(registration + ".environment").text()).toBe("configured")
-  } finally {
-    process.kill(info.pid, "SIGTERM")
-    await waitForExit(info.pid)
-  }
-})
-
 test("waits for a live contender when another native contender fails", async () => {
   const directory = await temp()
   const registration = join(directory, "service.json")
@@ -146,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) {

packages/client/test/promise.test.ts

@@ -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({

packages/client/test/service.test.ts

@@ -68,28 +68,6 @@ test("reuses a compatible registered service", async () => {
   expect(existing.exitCode).toBe(null)
 })
 
-test("adds configured environment variables when starting a service", async () => {
-  const directory = await temp()
-  const registration = join(directory, "service.json")
-  const endpoint = await run(
-    ensure({
-      file: registration,
-      version: "test",
-      command: [process.execPath, fixture, registration, "environment"],
-      env: { OPENCODE_SERVICE_ENV_TEST: "configured" },
-    }),
-  )
-  const info = await Bun.file(registration).json()
-
-  try {
-    expect(endpoint.url).toBe(info.url)
-    expect(await Bun.file(registration + ".environment").text()).toBe("configured")
-  } finally {
-    process.kill(info.pid, "SIGTERM")
-    await waitForExit(info.pid)
-  }
-})
-
 test("replaces an incompatible registered service", async () => {
   const directory = await temp()
   const registration = join(directory, "service.json")
@@ -165,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 () => {
@@ -362,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())
 }

packages/core/src/agent.ts

@@ -109,7 +109,7 @@ const layer = Layer.effect(
       get: Effect.fn("Agent.get")(function* (id) {
         return state.get().agents.get(id)
       }),
-      resolve: Effect.fnUntraced(function* (id) {
+      resolve: Effect.fn("Agent.resolve")(function* (id) {
         if (id !== undefined) return state.get().agents.get(ID.make(id))
         return selectedDefault()
       }),

packages/core/src/config.ts

@@ -426,7 +426,7 @@ export const layer = (options?: Options) =>
       )
 
       return Service.of({
-        entries: Effect.fnUntraced(function* () {
+        entries: Effect.fn("Config.entries")(function* () {
           return configs
         }),
         update,

packages/core/src/config/normalize.ts

@@ -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,
   )
 

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

@@ -1,70 +0,0 @@
-export * as ConfigFormatterPlugin from "./formatter.js"
-
-import { define } from "@opencode-ai/plugin/effect/plugin"
-import { FSUtil } from "@opencode-ai/util/fs-util"
-import { Global } from "@opencode-ai/util/global"
-import { Npm } from "@opencode-ai/util/npm"
-import { AppProcess } from "@opencode-ai/util/process"
-import { Effect, Stream } from "effect"
-import { Config } from "../../config.js"
-import { Formatter } from "../../formatter.js"
-import { make, type Info } from "../../formatter/builtins.js"
-import { Location } from "../../location.js"
-
-export const Plugin = define({
-  id: "opencode.config.formatter",
-  effect: Effect.fn(function* (ctx) {
-    const config = yield* Config.Service
-    const formatter = yield* Formatter.Service
-    const fs = yield* FSUtil.Service
-    const global = yield* Global.Service
-    const location = yield* Location.Service
-    const npm = yield* Npm.Service
-    const processes = yield* AppProcess.Service
-    const loaded = { entries: yield* config.entries() }
-    const reload = config.entries().pipe(
-      Effect.tap((entries) => Effect.sync(() => (loaded.entries = entries))),
-      Effect.andThen(formatter.reload()),
-    )
-
-    yield* ctx.event.subscribe().pipe(
-      Stream.filter((event) => event.type === "config.updated"),
-      Stream.runForEach(() => reload),
-      Effect.forkScoped({ startImmediately: true }),
-    )
-    // Refetch after subscribing so a config update between the first read and
-    // the live subscription cannot leave the transform on a stale snapshot.
-    loaded.entries = yield* config.entries()
-
-    yield* formatter.transform((draft) => {
-      const configured = Config.latest(loaded.entries, "formatter")
-      if (!configured) return
-      const builtIns = make({
-        directory: location.directory,
-        worktree: location.project.directory,
-        fs,
-        npm,
-        processes,
-        bin: global.bin,
-      })
-      builtIns.forEach(draft.set)
-      if (configured === true) return
-
-      for (const [name, entry] of Object.entries(configured)) {
-        if (entry.disabled) {
-          draft.remove(name)
-          continue
-        }
-        const builtIn = builtIns.find((formatter) => formatter.name === name)
-        const current: Info = {
-          name,
-          extensions: entry.extensions ?? builtIn?.extensions ?? [],
-          environment: { ...builtIn?.environment, ...entry.environment },
-          enabled:
-            builtIn && !entry.command ? builtIn.enabled : Effect.succeed(entry.command ? [...entry.command] : false),
-        }
-        draft.set(current)
-      }
-    })
-  }),
-})

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

@@ -1,40 +0,0 @@
-export * as ConfigImagePlugin from "./image.js"
-
-import { define } from "@opencode-ai/plugin/effect/plugin"
-import { Effect, Stream } from "effect"
-import { Config } from "../../config.js"
-import { Image } from "../../image.js"
-
-export const Plugin = define({
-  id: "opencode.config.image",
-  effect: Effect.fn(function* (ctx) {
-    const config = yield* Config.Service
-    const image = yield* Image.Service
-    const loaded = { entries: yield* config.entries() }
-    const reload = config.entries().pipe(
-      Effect.tap((entries) => Effect.sync(() => (loaded.entries = entries))),
-      Effect.andThen(image.reload()),
-    )
-    yield* ctx.event.subscribe().pipe(
-      Stream.filter((event) => event.type === "config.updated"),
-      Stream.runForEach(() => reload),
-      Effect.forkScoped({ startImmediately: true }),
-    )
-    // Refetch after subscribing so a config update between the first read and
-    // the live subscription cannot leave the transform on a stale snapshot.
-    loaded.entries = yield* config.entries()
-    yield* image.transform((draft) => {
-      for (const entry of loaded.entries) {
-        if (entry.type !== "document") continue
-        const configured = entry.info.media?.image
-        if (!configured) continue
-        draft.configure({
-          ...(configured.auto_resize === undefined ? {} : { autoResize: configured.auto_resize }),
-          ...(configured.max_width === undefined ? {} : { maxWidth: configured.max_width }),
-          ...(configured.max_height === undefined ? {} : { maxHeight: configured.max_height }),
-          ...(configured.max_base64_bytes === undefined ? {} : { maxBase64Bytes: configured.max_base64_bytes }),
-        })
-      }
-    })
-  }),
-})

packages/core/src/database/drizzle/effect-sqlite/session.ts

@@ -120,13 +120,9 @@ export class EffectSQLiteSession<TRelations extends AnyRelations> extends SQLite
 
   private execute(query: Query, params: unknown[], method: SQLiteExecuteMethod | "values") {
     const statement = this.client.unsafe(query.sql, params)
-    if (method === "values") return statement.values.pipe(Effect.withTracerEnabled(false))
-    if (method === "get")
-      return statement.withoutTransform.pipe(
-        Effect.map((rows) => rows[0]),
-        Effect.withTracerEnabled(false),
-      )
-    return statement.withoutTransform.pipe(Effect.withTracerEnabled(false))
+    if (method === "values") return statement.values
+    if (method === "get") return statement.withoutTransform.pipe(Effect.map((rows) => rows[0]))
+    return statement.withoutTransform
   }
 
   private isInTransaction() {

packages/core/src/formatter.ts

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

packages/core/src/image.ts

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

packages/core/src/job.ts

@@ -138,7 +138,7 @@ export const make = Effect.gen(function* () {
     scope: yield* Scope.Scope,
   }
 
-  const settle = Effect.fnUntraced(function* (id: string, token: object, exit: Exit.Exit<string, unknown>) {
+  const settle = Effect.fn("Job.settle")(function* (id: string, token: object, exit: Exit.Exit<string, unknown>) {
     const completed_at = yield* Clock.currentTimeMillis
     const result = yield* SynchronizedRef.modify(state.jobs, (jobs): readonly [FinishResult, Map<string, Active>] => {
       const job = jobs.get(id)
@@ -170,7 +170,7 @@ export const make = Effect.gen(function* () {
     return result.info
   })
 
-  const fork = Effect.fnUntraced(function* (
+  const fork = Effect.fn("Job.fork")(function* (
     scope: Scope.Scope,
     id: string,
     token: object,
@@ -192,7 +192,7 @@ export const make = Effect.gen(function* () {
     return snapshot(job)
   })
 
-  const start: Interface["start"] = Effect.fnUntraced(function* (input) {
+  const start: Interface["start"] = Effect.fn("Job.start")(function* (input) {
     return yield* Effect.uninterruptibleMask((restore) =>
       Effect.gen(function* () {
         const id = input.id ?? Identifier.ascending("job")
@@ -247,7 +247,7 @@ export const make = Effect.gen(function* () {
     return { info: snapshot(job), timedOut: true }
   })
 
-  const removeBlock = Effect.fnUntraced(function* (input: BlockInput) {
+  const removeBlock = Effect.fn("Job.removeBlock")(function* (input: BlockInput) {
     yield* SynchronizedRef.update(state.jobs, (jobs) => {
       const job = jobs.get(input.id)
       if (!job || job.info.status !== "running" || job.isBackgrounded) return jobs
@@ -258,7 +258,7 @@ export const make = Effect.gen(function* () {
     })
   })
 
-  const block: Interface["block"] = Effect.fnUntraced(function* (input) {
+  const block: Interface["block"] = Effect.fn("Job.block")(function* (input) {
     const result = yield* SynchronizedRef.modify(state.jobs, (jobs): readonly [BlockStart, Map<string, Active>] => {
       const job = jobs.get(input.id)
       if (!job) return [{ type: "missing" }, jobs]

packages/core/src/location-mutation.ts

@@ -65,7 +65,7 @@ const layer = Layer.effect(
     const fs = yield* FSUtil.Service
     const location = yield* Location.Service
 
-    const resolve = Effect.fnUntraced(function* (input: ResolveInput) {
+    const resolve = Effect.fn("LocationMutation.resolve")(function* (input: ResolveInput) {
       const absolute = path.resolve(location.directory, input.path)
       if (FSUtil.contains(location.directory, absolute)) {
         return {

packages/core/src/permission.ts

@@ -152,14 +152,14 @@ const layer = Layer.effect(
       )
     })
 
-    const configured = Effect.fnUntraced(function* (sessionID: SessionSchema.ID, agentID?: Agent.ID) {
+    const configured = Effect.fn("Permission.configured")(function* (sessionID: SessionSchema.ID, agentID?: Agent.ID) {
       const session = yield* sessions.get(sessionID)
       if (!session) return yield* new SessionErrors.NotFoundError({ sessionID })
       const agent = yield* agents.resolve(agentID ?? session.agent)
       return agent?.permissions ?? missingAgentPermissions
     })
 
-    const allowsAll = Effect.fnUntraced(function* (input: {
+    const allowsAll = Effect.fn("Permission.allowsAll")(function* (input: {
       readonly sessionID: SessionSchema.ID
       readonly action: string
       readonly agent?: Agent.ID

packages/core/src/permission/saved.ts

@@ -39,7 +39,7 @@ const layer = Layer.effect(
   Effect.gen(function* () {
     const { db } = yield* Database.Service
 
-    const list = Effect.fnUntraced(function* (input?: ListInput) {
+    const list = Effect.fn("PermissionSaved.list")(function* (input?: ListInput) {
       const rows = yield* db
         .select()
         .from(PermissionTable)

packages/core/src/plugin.ts

@@ -1,10 +1,10 @@
 export * as Plugin from "./plugin.js"
-export { Event, ID, Info, Source } from "@opencode-ai/schema/plugin"
+export { Event, ID, Info } from "@opencode-ai/schema/plugin"
 
 import { Plugin } from "@opencode-ai/schema/plugin"
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
 import { App } from "./app.js"
-import { Cause, Context, Effect, Exit, Layer, Logger, References, Scope, Semaphore } from "effect"
+import { Context, Effect, Exit, Layer, Logger, References, Scope, Semaphore } from "effect"
 import { Agent } from "./agent.js"
 import { AISDK } from "./aisdk.js"
 import { Catalog } from "./catalog.js"
@@ -23,17 +23,11 @@ import { Tool } from "./tool.js"
 import { PluginHooks } from "./plugin/hooks.js"
 
 export interface Interface {
-  readonly activate: (
-    plugins: readonly Versioned[],
-    failures?: readonly Extract<Plugin.Info, { readonly status: "failed" }>[],
-  ) => Effect.Effect<void>
+  readonly activate: (plugins: readonly Versioned[]) => Effect.Effect<void>
   readonly list: () => Effect.Effect<Plugin.Info[]>
 }
 
-export type Versioned = import("@opencode-ai/plugin/effect/plugin").Plugin & {
-  readonly version: string
-  readonly source?: Plugin.Source
-}
+export type Versioned = import("@opencode-ai/plugin/effect/plugin").Plugin & { readonly version: string }
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/Plugin") {}
 
@@ -44,7 +38,6 @@ const layer = Layer.effect(
     const scope = yield* Scope.make()
     const active = new Map<Plugin.ID, { readonly plugin: Versioned; readonly scope: Scope.Closeable }>()
     const lock = Semaphore.makeUnsafe(1)
-    let inventory: Plugin.Info[] = []
     let host: Parameters<import("@opencode-ai/plugin/effect/plugin").Plugin["effect"]>[0]
 
     const load = Effect.fnUntraced(function* (plugin: Versioned) {
@@ -63,18 +56,15 @@ const layer = Layer.effect(
         Effect.onExit((exit) => (Exit.isFailure(exit) ? Scope.close(child, exit) : Effect.void)),
         Effect.exit,
       )
-      if (Exit.isSuccess(loaded)) return { scope: child } as const
+      if (Exit.isSuccess(loaded)) return child
       yield* Effect.logWarning("failed to load plugin", {
         "plugin.id": plugin.id,
         cause: loaded.cause,
       })
-      return { error: Cause.pretty(loaded.cause) } as const
+      return undefined
     })
 
-    const activate = Effect.fn("Plugin.activate")(function* (
-      plugins: readonly Versioned[],
-      failures: readonly Extract<Plugin.Info, { readonly status: "failed" }>[] = [],
-    ) {
+    const activate = Effect.fn("Plugin.activate")(function* (plugins: readonly Versioned[]) {
       const definitions = plugins.map((plugin) => ({ ...plugin, id: Plugin.ID.make(plugin.id) }))
       const ids = new Set<Plugin.ID>()
       for (const definition of definitions) {
@@ -95,40 +85,26 @@ const layer = Layer.effect(
               const candidate = next[index]
               return definition.id === candidate?.id && definition.version === candidate.version
             })
-          ) {
-            const nextInventory = [...Array.from(active.values(), (entry) => activeInfo(entry.plugin)), ...failures]
-            if (JSON.stringify(inventory) === JSON.stringify(nextInventory)) return
-            inventory = nextInventory
-            yield* bus.publish(Plugin.Event.Updated, {})
+          )
             return
-          }
 
           yield* State.batch(
             Effect.gen(function* () {
-              const nextInventory: Plugin.Info[] = []
               for (const definition of definitions) {
                 const previous = active.get(definition.id)
                 active.delete(definition.id)
                 if (previous) yield* Scope.close(previous.scope, Exit.void).pipe(Effect.ignore)
 
                 const loaded = yield* load(definition)
-                if (loaded.scope !== undefined) {
-                  active.set(definition.id, { plugin: definition, scope: loaded.scope })
-                  nextInventory.push(activeInfo(definition))
+                if (loaded) {
+                  active.set(definition.id, { plugin: definition, scope: loaded })
                   continue
                 }
-                nextInventory.push({
-                  id: definition.id,
-                  source: definition.source ?? { type: "builtin" },
-                  status: "failed",
-                  error: loaded.error,
-                  tui: definition.tui ?? false,
-                })
 
                 if (!previous) continue
                 const restored = yield* load(previous.plugin)
-                if (restored.scope !== undefined) {
-                  active.set(definition.id, { plugin: previous.plugin, scope: restored.scope })
+                if (restored) {
+                  active.set(definition.id, { plugin: previous.plugin, scope: restored })
                   continue
                 }
                 yield* Effect.logError("failed to restore plugin; deactivating", {
@@ -143,7 +119,6 @@ const layer = Layer.effect(
               yield* Effect.forEach(removed, ([, entry]) => Scope.close(entry.scope, Exit.void).pipe(Effect.ignore), {
                 discard: true,
               })
-              inventory = [...nextInventory, ...failures]
             }),
           )
           yield* bus.publish(Plugin.Event.Updated, {})
@@ -161,7 +136,7 @@ const layer = Layer.effect(
     const service = Service.of({
       activate,
       list: Effect.fn("Plugin.list")(function* () {
-        return inventory
+        return Array.from(active.keys()).map((id) => ({ id }))
       }),
     })
     host = yield* PluginHost.make(service)
@@ -169,15 +144,6 @@ const layer = Layer.effect(
   }),
 )
 
-function activeInfo(plugin: Versioned): Plugin.Info {
-  return {
-    id: Plugin.ID.make(plugin.id),
-    source: plugin.source ?? { type: "builtin" },
-    status: "active",
-    tui: plugin.tui ?? false,
-  }
-}
-
 export const node = makeLocationNode({
   service: Service,
   layer,

packages/core/src/plugin/hooks.ts

@@ -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.fnUntraced(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],
-        )
+    const trigger: Interface["trigger"] = Effect.fn("PluginHooks.trigger")(function* (domain, name, 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 })
   }),

packages/core/src/plugin/host.ts

@@ -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,

packages/core/src/plugin/internal.ts

@@ -3,7 +3,6 @@ export * as PluginInternal from "./internal.js"
 import type { Plugin } from "@opencode-ai/plugin/effect/plugin"
 import { LayerNode } from "@opencode-ai/util/effect/layer-node"
 import { httpClient } from "@opencode-ai/util/effect/app-node-platform"
-import { AppProcess } from "@opencode-ai/util/process"
 import { Context, Effect, Scope } from "effect"
 import { HttpClient } from "effect/unstable/http"
 import { Agent } from "../agent.js"
@@ -13,8 +12,6 @@ import { Config } from "../config.js"
 import { Credential } from "../credential.js"
 import { ConfigAgentPlugin } from "../config/plugin/agent.js"
 import { ConfigCommandPlugin } from "../config/plugin/command.js"
-import { ConfigFormatterPlugin } from "../config/plugin/formatter.js"
-import { ConfigImagePlugin } from "../config/plugin/image.js"
 import { ConfigInstructionPlugin } from "../config/plugin/instruction.js"
 import { ConfigMCPPlugin } from "../config/plugin/mcp.js"
 import { ConfigProviderPlugin } from "../config/plugin/provider.js"
@@ -80,7 +77,6 @@ import { WellKnownPlugin } from "../wellknown/plugin.js"
 
 const services = Effect.fn("PluginInternal.services")(function* () {
   const agent = yield* Agent.Service
-  const processes = yield* AppProcess.Service
   const catalog = yield* Catalog.Service
   const command = yield* Command.Service
   const config = yield* Config.Service
@@ -119,7 +115,6 @@ const services = Effect.fn("PluginInternal.services")(function* () {
   const wellknown = yield* WellKnown.Service
   return Context.mergeAll(
     Context.make(Agent.Service, agent),
-    Context.make(AppProcess.Service, processes),
     Context.make(Catalog.Service, catalog),
     Context.make(Command.Service, command),
     Context.make(Config.Service, config),
@@ -165,7 +160,6 @@ export type Requirements = ContextServices<Effect.Success<ReturnType<typeof serv
 
 export const requirements = LayerNode.group([
   Agent.node,
-  AppProcess.node,
   Catalog.node,
   Command.node,
   Config.node,
@@ -238,8 +232,6 @@ const post = [
   ConfigReferencePlugin.Plugin,
   ConfigAgentPlugin.Plugin,
   ConfigCommandPlugin.Plugin,
-  ConfigFormatterPlugin.Plugin,
-  ConfigImagePlugin.Plugin,
   ConfigSkillPlugin.Plugin,
   ConfigProviderPlugin.Plugin,
   ConfigWebSearchPlugin.Plugin,

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

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

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

@@ -6,7 +6,7 @@ import { ModelsDev } from "../models-dev.js"
 import { Provider } from "../provider.js"
 
 export const ModelsDevPlugin = define({
-  id: "opencode.models.dev",
+  id: "opencode.models-dev",
   effect: Effect.fn(function* (ctx) {
     const modelsDev = yield* ModelsDev.Service
     const bus = yield* Bus.Service
@@ -55,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[]) {

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

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

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

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

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

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

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

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

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

@@ -55,7 +55,7 @@ function authFetch(fetchWithRuntimeOptions?: unknown) {
 }
 
 export const GoogleVertexPlugin = define({
-  id: "opencode.provider.google.vertex",
+  id: "opencode.provider.google-vertex",
   effect: Effect.fn(function* (ctx) {
     yield* ctx.catalog.transform((evt) => {
       for (const item of evt.provider.list()) {
@@ -71,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 } : {}),

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

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

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

@@ -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(

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

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

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

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

packages/core/src/plugin/sdk.ts

@@ -35,7 +35,7 @@ export const layer = Layer.effect(
     return Service.of({
       register: (plugin) =>
         Effect.sync(() => {
-          plugins.set(plugin.id, { ...plugin, version: String(++revision), source: { type: "sdk" } })
+          plugins.set(plugin.id, { ...plugin, version: String(++revision) })
         }).pipe(Effect.andThen(bus.publish(Updated, {})), Effect.asVoid),
       all: () => [...plugins.values()],
     })

packages/core/src/plugin/supervisor-service.ts

@@ -1,14 +0,0 @@
-export * as PluginSupervisor from "./supervisor-service.js"
-
-import { Context, Effect } from "effect"
-
-/**
- * Dependency-only supervisor seam. Keep this module free of implementation
- * imports: the supervisor reaches PluginRuntime, which depends on Session.
- */
-export interface Interface {
-  /** Wait for the initial plugin generation and startup updates to settle. */
-  readonly flush: Effect.Effect<void>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/PluginSupervisor") {}

packages/core/src/plugin/supervisor.ts

@@ -1,9 +1,8 @@
 export * as PluginSupervisor from "./supervisor.js"
-export { Service, type Interface } from "./supervisor-service.js"
 
 import type { Plugin as PluginDefinition } from "@opencode-ai/plugin/effect/plugin"
 import { Event } from "@opencode-ai/schema/config"
-import { Cause, Deferred, Effect, Layer, Schema, Stream } from "effect"
+import { Context, Deferred, Effect, Layer, Schema, Stream } from "effect"
 import path from "path"
 import { pathToFileURL } from "url"
 import { ConfigPluginSource } from "../config/plugin/source.js"
@@ -15,20 +14,17 @@ import { PluginPromise } from "../plugin/promise.js"
 import { PluginInternal } from "./internal.js"
 import { SdkPlugins } from "./sdk.js"
 import { importModule } from "@opencode-ai/util/runtime-import"
-import { Service } from "./supervisor-service.js"
 
 const PluginModule = Schema.Struct({
   default: Schema.Union([
     Schema.Struct({
       id: Schema.String,
-      tui: Schema.optional(Schema.Boolean),
       effect: Schema.declare<PluginDefinition["effect"]>(
         (input): input is PluginDefinition["effect"] => typeof input === "function",
       ),
     }),
     Schema.Struct({
       id: Schema.String,
-      tui: Schema.optional(Schema.Boolean),
       setup: Schema.declare<Parameters<typeof PluginPromise.fromPromise>[0]["setup"]>(
         (input): input is Parameters<typeof PluginPromise.fromPromise>[0]["setup"] => typeof input === "function",
       ),
@@ -46,12 +42,10 @@ const resolve = Effect.fn("PluginSupervisor.resolve")(function* (
   const definitions = [...pre, ...post]
   const enabled = new Set(definitions.map((plugin) => plugin.id))
   const packages = new Map<string, Plugin.Versioned>()
-  const failures = new Map<string, Extract<Plugin.Info, { readonly status: "failed" }>>()
   const plugins = () => [...definitions, ...packages.values()]
 
   for (const operation of operations) {
     if (operation.type === "remove") {
-      if (operation.target === "*") failures.clear()
       plugins()
         .filter((plugin) => matches(operation.target, plugin.id))
         .forEach((plugin) => enabled.delete(plugin.id))
@@ -71,35 +65,21 @@ const resolve = Effect.fn("PluginSupervisor.resolve")(function* (
 
     const plugin = yield* load(operation).pipe(
       Effect.catchCause((cause) =>
-        Effect.logWarning("failed to load plugin", { target: operation.target, cause }).pipe(
-          Effect.as({ error: Cause.pretty(cause) }),
-        ),
+        Effect.logWarning("failed to load plugin", { target: operation.target, cause }).pipe(Effect.as(undefined)),
       ),
     )
-    if ("error" in plugin) {
-      failures.set(operation.target, {
-        source: pluginSource(operation.target),
-        status: "failed",
-        error: plugin.error,
-        tui: false,
-      })
-      continue
-    }
-    failures.delete(operation.target)
+    if (!plugin) continue
     const previous = packages.get(operation.target)
     if (previous) enabled.delete(previous.id)
     packages.set(operation.target, plugin)
     enabled.add(plugin.id)
   }
 
-  return {
-    plugins: [
-      ...pre.filter((plugin) => enabled.has(plugin.id)),
-      ...Array.from(packages.values()).filter((plugin) => enabled.has(plugin.id)),
-      ...post.filter((plugin) => enabled.has(plugin.id)),
-    ],
-    failures: [...failures.values()],
-  }
+  return [
+    ...pre.filter((plugin) => enabled.has(plugin.id)),
+    ...Array.from(packages.values()).filter((plugin) => enabled.has(plugin.id)),
+    ...post.filter((plugin) => enabled.has(plugin.id)),
+  ]
 })
 
 const load = Effect.fn("PluginSupervisor.load")(function* (
@@ -109,7 +89,7 @@ const load = Effect.fn("PluginSupervisor.load")(function* (
   const entrypoint = path.isAbsolute(operation.target)
     ? pathToFileURL(operation.target).href
     : (yield* npm.add(operation.target, { subpaths: ["server", ""] })).entrypoint
-  if (!entrypoint) return yield* Effect.fail(new Error(`Plugin entrypoint not found: ${operation.target}`))
+  if (!entrypoint) return
   // Bun currently ignores query parameters when caching file:// imports.
   const source =
     operation.mtime === undefined
@@ -123,13 +103,18 @@ const load = Effect.fn("PluginSupervisor.load")(function* (
   const plugin = "effect" in value ? value : PluginPromise.fromPromise(value)
   return {
     id: plugin.id,
-    tui: plugin.tui,
     version: JSON.stringify(operation),
-    source: pluginSource(operation.target),
     effect: (host) => plugin.effect({ ...host, options: operation.options }),
   } satisfies Plugin.Versioned
 })
 
+export interface Interface {
+  /** Wait for the initial plugin generation and startup updates to settle. */
+  readonly flush: Effect.Effect<void>
+}
+
+export class Service extends Context.Service<Service, Interface>()("@opencode/PluginSupervisor") {}
+
 export const layer = Layer.effect(
   Service,
   Effect.gen(function* () {
@@ -144,20 +129,13 @@ export const layer = Layer.effect(
       // Resolve OpenCode's internal plugins with their privileged Location services.
       const internal = yield* PluginInternal.list()
       // Combine internal plugins with host-contributed SDK plugins in boot order.
-      const pre = [
-        ...internal.pre.map((plugin) => ({ ...plugin, version: "internal", source: { type: "builtin" as const } })),
-        ...sdk.all(),
-      ]
-      const post = internal.post.map((plugin) => ({
-        ...plugin,
-        version: "internal",
-        source: { type: "builtin" as const },
-      }))
+      const pre = [...internal.pre.map((plugin) => ({ ...plugin, version: "internal" })), ...sdk.all()]
+      const post = internal.post.map((plugin) => ({ ...plugin, version: "internal" }))
       const operations = yield* sources.operations()
       // Apply config operations and load enabled package plugins into one ordered generation.
-      const resolved = yield* resolve(pre, post, operations)
+      const plugins = yield* resolve(pre, post, operations)
       // Replace the active generation in one scoped, batched activation.
-      yield* registry.activate(resolved.plugins, resolved.failures)
+      yield* registry.activate(plugins)
     })
     const updates = Stream.merge(sources.changes(), bus.subscribe([Event.Updated, SdkPlugins.Updated])).pipe(
       // Make accepted work visible to flush before coalescing the burst.
@@ -194,9 +172,4 @@ const nodeDeps = [
   PluginInternal.requirements,
 ] as const
 
-function pluginSource(target: string): Plugin.Source {
-  if (path.isAbsolute(target)) return { type: "local", path: target }
-  return { type: "package", package: target }
-}
-
 export const node = makeLocationNode({ service: Service, layer, deps: nodeDeps })

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

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

packages/core/src/provider.ts

@@ -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")],

packages/core/src/session.ts

@@ -40,7 +40,6 @@ import { SessionRevert } from "./session/revert.js"
 import { Session } from "@opencode-ai/schema/session"
 import { FSUtil } from "@opencode-ai/util/fs-util"
 import { Image } from "./image.js"
-import { PluginSupervisor } from "./plugin/supervisor-service.js"
 import { Mime } from "./mime.js"
 import type { EventLog } from "@opencode-ai/schema/event-log"
 import { Event } from "@opencode-ai/schema/event"
@@ -580,11 +579,7 @@ const layer = Layer.effect(
             if (session.revert) yield* SessionRevert.commit(session).pipe(Effect.provideService(Bus.Service, bus))
             // Resolved lazily so prompt admission only boots location services when an
             // image attachment actually needs the resizer.
-            const image = Effect.gen(function* () {
-              const plugins = yield* PluginSupervisor.Service
-              yield* plugins.flush
-              return yield* Image.Service
-            }).pipe(Effect.provide(locations.get(session.location)))
+            const image = Image.Service.pipe(Effect.provide(locations.get(session.location)))
             const skills = Skill.Service.pipe(Effect.provide(locations.get(session.location)))
             const prompt = yield* resolvePrompt(
               { text: input.text, files: input.files, agents: input.agents, skills: input.skills },
@@ -785,7 +780,7 @@ const layer = Layer.effect(
           payload,
           delivery: input.delivery ?? "steer",
         })
-        yield* SessionInbox.serialized(
+        const recovered = yield* SessionInbox.serialized(
           input.sessionID,
           Effect.gen(function* () {
             const latest = yield* result.get(input.sessionID)
@@ -796,16 +791,25 @@ const layer = Layer.effect(
               )
               const moved = [SessionEvent.Moved, { sessionID: input.sessionID, ...payload }] as const
               const first = cancellations[0]
-              if (!first) return yield* bus.publish(...moved).pipe(Effect.asVoid)
-              return yield* bus.publishAll([first, ...cancellations.slice(1), moved])
+              if (!first) {
+                yield* bus.publish(...moved)
+                return true
+              }
+              yield* bus.publishAll([first, ...cancellations.slice(1), moved])
+              return true
             }
             yield* SessionInbox.admit(db, bus, {
               id: SessionMessage.ID.create(),
               sessionID: input.sessionID,
               item,
             })
+            return false
           }),
         )
+        if (recovered) {
+          yield* execution.wakeActive(input.sessionID)
+          return
+        }
         yield* execution.wake(input.sessionID)
       }),
       compact: Effect.fn("Session.compact")(function* (input) {

packages/core/src/session/compaction.ts

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

packages/core/src/session/execution.ts

@@ -21,6 +21,8 @@ export interface Interface {
   readonly resume: (sessionID: SessionSchema.ID) => Effect.Effect<void, SessionRunner.RunError>
   /** Registers newly recorded work. Repeated wakeups may coalesce. */
   readonly wake: (sessionID: SessionSchema.ID) => Effect.Effect<void>
+  /** Wakes only an active execution, preserving its current input eligibility. */
+  readonly wakeActive: (sessionID: SessionSchema.ID) => Effect.Effect<void>
   /** Interrupt active work owned by this process. Idle interruption is a no-op. */
   readonly interrupt: (sessionID: SessionSchema.ID, options?: { readonly continue?: boolean }) => Effect.Effect<void>
   /** Resolves once this process owns no active execution for the Session. Returns immediately when idle and never starts work. */
@@ -135,15 +137,16 @@ export const layer = Layer.effect(
     return Service.of({
       active: coordinator.active,
       interrupt: (sessionID, options) =>
-        Effect.gen(function* () {
-          yield* coordinator.interrupt(sessionID, "user")
-          if (!options?.continue) return
-          // Resume only steering input from the interrupted intent. Queued next-turn work
-          // stays parked: a steer-scoped drain never promotes queue-delivery rows.
-          if (yield* SessionInbox.has(db, sessionID, "steer")) yield* coordinator.wake(sessionID, "steer")
-        }),
+        coordinator.interrupt(
+          sessionID,
+          "user",
+          options?.continue
+            ? { continue: { request: "steer", when: SessionInbox.has(db, sessionID, "steer") } }
+            : undefined,
+        ),
       resume: coordinator.run,
       wake: coordinator.wake,
+      wakeActive: coordinator.wakeActive,
       awaitIdle: coordinator.awaitIdle,
     })
   }),
@@ -162,6 +165,7 @@ export const noopLayer = Layer.succeed(
     active: Effect.succeed(new Set()),
     resume: () => Effect.void,
     wake: () => Effect.void,
+    wakeActive: () => Effect.void,
     interrupt: () => Effect.void,
     awaitIdle: () => Effect.void,
   }),

packages/core/src/session/generate-node.ts

@@ -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
       }),

packages/core/src/session/inbox.ts

@@ -180,27 +180,13 @@ export const admitCompaction = Effect.fn("SessionInbox.admitCompaction")(functio
   bus: Bus.Interface,
   input: { readonly id: SessionMessage.ID; readonly sessionID: SessionSchema.ID; readonly delivery: Delivery },
 ) {
-  return yield* serialized(
-    input.sessionID,
-    Effect.gen(function* () {
-      const exact = yield* find(db, input.id)
-      if (exact) {
-        if (exact.type === "compaction" && exact.sessionID === input.sessionID) return exact
-        return yield* Effect.die(new LifecycleConflict({ id: input.id }))
-      }
-      if (yield* promotedFromMessage(db, input.sessionID, input.id, input.delivery))
-        return yield* Effect.die(new LifecycleConflict({ id: input.id }))
-      const pending = (yield* list(db, input.sessionID)).find((item) => item.type === "compaction")
-      if (pending) return pending
-      const admitted = yield* admit(db, bus, {
-        id: input.id,
-        sessionID: input.sessionID,
-        item: Item.make({ type: "compaction", payload: {}, delivery: input.delivery }),
-      })
-      if (admitted.type === "compaction") return admitted
-      return yield* Effect.die(new LifecycleConflict({ id: input.id }))
-    }),
-  )
+  const admitted = yield* admit(db, bus, {
+    id: input.id,
+    sessionID: input.sessionID,
+    item: Item.make({ type: "compaction", payload: {}, delivery: input.delivery }),
+  })
+  if (admitted.type === "compaction") return admitted
+  return yield* Effect.die(new LifecycleConflict({ id: input.id }))
 })
 
 export const projectAdmitted = Effect.fn("SessionInbox.projectAdmitted")(function* (

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

@@ -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,
-      }),
-    })
-  })

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

@@ -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) }
           : {}),
       }

packages/core/src/session/run-coordinator.ts

@@ -10,17 +10,25 @@ export interface Coordinator<Key, E, Reason = never> {
   /** Starts an execution while idle, or joins the active execution and returns its exit. */
   readonly run: (key: Key) => Effect.Effect<void, E>
   /** Rings the doorbell: an idle key starts an execution; an active one drains again before settling. */
-  readonly wake: (key: Key, scope?: Promotable) => Effect.Effect<void>
+  readonly wake: (key: Key, request?: Request) => Effect.Effect<void>
+  /** Rings the current execution's doorbell with its existing request. Idle keys remain idle. */
+  readonly wakeActive: (key: Key) => Effect.Effect<void>
   /** Stops the active execution, clears its doorbell, and waits for cleanup. No-op when idle. */
-  readonly interrupt: (key: Key, reason?: Reason) => Effect.Effect<void>
+  readonly interrupt: (
+    key: Key,
+    reason?: Reason,
+    options?: { readonly continue?: { readonly request: Request; readonly when: Effect.Effect<boolean> } },
+  ) => Effect.Effect<void>
   /** Resolves once no execution is active for the key. Returns immediately when already idle and never starts work. */
   readonly awaitIdle: (key: Key) => Effect.Effect<void>
 }
 
+export type Request = Promotable
+
 /**
  * One execution is a busy period for one key: one fiber that drains from the first wake
  * until the key would stay idle. `pendingWake` is the doorbell: work recorded during the
- * execution rings it with the scope that work needs, and the execution loop drains again
+ * execution rings it with its eligibility request, and the execution loop drains again
  * instead of ending. The doorbell closes the gap between a drain's last eligibility check
  * and the idle transition, since those cannot be one atomic step. `done` resolves joiners
  * with this execution's exit.
@@ -28,10 +36,15 @@ export interface Coordinator<Key, E, Reason = never> {
 type Execution<E, Reason> = {
   readonly done: Deferred.Deferred<void, E>
   owner?: Fiber.Fiber<void>
-  scope: Promotable
-  pendingWake?: Promotable
+  request: Request
+  pendingWake?: Request
   stopping: boolean
   interruptionReason?: Reason
+  continuation?: {
+    readonly request: Request
+    readonly when: Effect.Effect<boolean>
+    signaled: boolean
+  }
 }
 
 /**
@@ -46,7 +59,7 @@ type Execution<E, Reason> = {
  * ```
  */
 export const make = <Key, E, Reason = never>(options: {
-  readonly drain: (key: Key, force: boolean, scope: Promotable) => Effect.Effect<void, E>
+  readonly drain: (key: Key, force: boolean, request: Request) => Effect.Effect<void, E>
   /** Runs once when a process-local busy period begins, before its first drain. */
   readonly started?: (key: Key) => Effect.Effect<void>
   /**
@@ -60,11 +73,11 @@ export const make = <Key, E, Reason = never>(options: {
     const fork = yield* FiberSet.makeRuntime<never, void, never>()
 
     const loop = (key: Key, execution: Execution<E, Reason>, force: boolean): Effect.Effect<void, E> =>
-      Effect.suspend(() => options.drain(key, force, execution.scope)).pipe(
+      Effect.suspend(() => options.drain(key, force, execution.request)).pipe(
         Effect.flatMap(() =>
           Effect.suspend(() => {
             if (execution.stopping || execution.pendingWake === undefined) return Effect.void
-            execution.scope = execution.pendingWake
+            execution.request = execution.pendingWake
             execution.pendingWake = undefined
             // Trampoline so drains that complete synchronously cannot grow the stack.
             return Effect.yieldNow.pipe(Effect.andThen(loop(key, execution, false)))
@@ -72,10 +85,10 @@ export const make = <Key, E, Reason = never>(options: {
         ),
       )
 
-    const start = (key: Key, force: boolean, scope: Promotable) => {
+    const start = (key: Key, force: boolean, request: Request) => {
       const execution: Execution<E, Reason> = {
         done: Deferred.makeUnsafe<void, E>(),
-        scope,
+        request,
         stopping: false,
       }
       executions.set(key, execution)
@@ -91,7 +104,7 @@ export const make = <Key, E, Reason = never>(options: {
               execution.owner = undefined
             }).pipe(Effect.andThen(options.settled?.(key, exit, execution.interruptionReason) ?? Effect.void)),
           ),
-          Effect.onExit((exit) => Effect.sync(() => settle(key, execution, exit))),
+          Effect.onExit((exit) => finish(key, execution, exit)),
           Effect.exit,
           Effect.asVoid,
         ),
@@ -101,12 +114,22 @@ export const make = <Key, E, Reason = never>(options: {
 
     // A doorbell that survives the execution loop (rung after the loop decided to end, or
     // during failure or interruption cleanup) starts a fresh execution for the remaining work.
-    const settle = (key: Key, execution: Execution<E, Reason>, exit: Exit.Exit<void, E>) => {
-      if (execution.pendingWake) start(key, false, execution.pendingWake)
+    const settle = (key: Key, execution: Execution<E, Reason>, exit: Exit.Exit<void, E>, resume: boolean) => {
+      if (resume && execution.continuation) start(key, false, execution.continuation.request)
+      else if (execution.pendingWake) start(key, false, execution.pendingWake)
       else executions.delete(key)
       Deferred.doneUnsafe(execution.done, exit)
     }
 
+    const finish = (key: Key, execution: Execution<E, Reason>, exit: Exit.Exit<void, E>) => {
+      if (!execution.continuation) return Effect.sync(() => settle(key, execution, exit, false))
+      return execution.continuation.when.pipe(
+        Effect.flatMap((ready) =>
+          Effect.sync(() => settle(key, execution, exit, ready || execution.continuation?.signaled === true)),
+        ),
+      )
+    }
+
     const run = (key: Key): Effect.Effect<void, E> =>
       Effect.suspend(() => {
         const execution = executions.get(key)
@@ -118,26 +141,55 @@ export const make = <Key, E, Reason = never>(options: {
         return Deferred.await(start(key, true, "input").done)
       })
 
-    const wake = (key: Key, scope: Promotable = "input") =>
+    const wake = (key: Key, request: Request = "input") =>
       Effect.sync(() => {
         const execution = executions.get(key)
         if (execution !== undefined) {
-          // Coalesced wakes keep the widest scope: "input" subsumes "steer".
-          execution.pendingWake = execution.pendingWake === "input" ? "input" : scope
+          if (execution.stopping) {
+            if (execution.continuation) execution.continuation.signaled = true
+            else execution.continuation = { request, when: Effect.succeed(true), signaled: true }
+            return
+          }
+          // Coalesced wakes keep the widest request: "input" subsumes "steer".
+          execution.pendingWake = execution.pendingWake === "input" ? "input" : request
           return
         }
-        start(key, false, scope)
+        start(key, false, request)
       })
 
-    const interrupt = (key: Key, reason?: Reason): Effect.Effect<void> =>
+    const wakeActive = (key: Key) =>
       Effect.suspend(() => {
         const execution = executions.get(key)
-        if (execution?.owner === undefined || execution.stopping) return Effect.void
+        return execution ? wake(key, execution.request) : Effect.void
+      })
+
+    const interrupt = (
+      key: Key,
+      reason?: Reason,
+      options?: { readonly continue?: { readonly request: Request; readonly when: Effect.Effect<boolean> } },
+    ): Effect.Effect<void> =>
+      Effect.suspend(() => {
+        const execution = executions.get(key)
+        if (execution === undefined) return Effect.void
+        if (execution.stopping) {
+          if (options?.continue)
+            execution.continuation = {
+              ...options.continue,
+              signaled: execution.continuation?.signaled ?? false,
+            }
+          return Deferred.await(execution.done).pipe(Effect.exit, Effect.asVoid)
+        }
+        if (execution.owner === undefined) {
+          if (!options?.continue) return Effect.void
+          execution.stopping = true
+          execution.pendingWake = undefined
+          execution.continuation = { ...options.continue, signaled: false }
+          return Deferred.await(execution.done).pipe(Effect.exit, Effect.asVoid)
+        }
         execution.stopping = true
-        // Wakes recorded so far belong to the interrupted intent; the interrupt claims them.
-        // Wakes arriving during cleanup are new admissions and restart normally at settle.
         execution.pendingWake = undefined
         execution.interruptionReason = reason
+        if (options?.continue) execution.continuation = { ...options.continue, signaled: false }
         return Fiber.interrupt(execution.owner)
       })
 
@@ -150,5 +202,5 @@ export const make = <Key, E, Reason = never>(options: {
         return Deferred.await(execution.done).pipe(Effect.exit, Effect.andThen(awaitIdle(key)))
       })
 
-    return { active: Effect.sync(() => new Set(executions.keys())), run, wake, interrupt, awaitIdle }
+    return { active: Effect.sync(() => new Set(executions.keys())), run, wake, wakeActive, interrupt, awaitIdle }
   })

packages/core/src/session/store.ts

@@ -54,7 +54,7 @@ const layer = Layer.effect(
     const decodeMessage = Schema.decodeUnknownEffect(SessionMessage.Info)
 
     return Service.of({
-      get: Effect.fnUntraced(function* (sessionID) {
+      get: Effect.fn("SessionStore.get")(function* (sessionID) {
         const row = yield* db.select().from(SessionTable).where(eq(SessionTable.id, sessionID)).get().pipe(Effect.orDie)
         return row ? fromRow(row) : undefined
       }),

packages/core/src/session/title.ts

@@ -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

packages/core/src/session/usage.ts

@@ -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,
   )
 }

packages/core/src/shell.ts

@@ -101,7 +101,7 @@ export const layer = (options?: ShellSelect.Options) =>
         }),
       )
 
-      const require = Effect.fnUntraced(function* (id: Shell.ID) {
+      const require = Effect.fn("Shell.require")(function* (id: Shell.ID) {
         const session = sessions.get(id)
         if (!session) return yield* new NotFoundError({ id })
         return session
@@ -153,7 +153,7 @@ export const layer = (options?: ShellSelect.Options) =>
 
       const name = () => resolve().pipe(Effect.map(ShellSelect.name))
 
-      const output = Effect.fnUntraced(function* (id: Shell.ID, input?: Shell.OutputInput) {
+      const output = Effect.fn("Shell.output")(function* (id: Shell.ID, input?: Shell.OutputInput) {
         const session = yield* require(id)
         const cursor = input?.cursor ?? 0
         const limit = input?.limit ?? 65536

packages/core/src/shell/parse.ts

@@ -153,7 +153,7 @@ const ARITY: Record<string, number> = {
   "yarn run": 3,
 }
 
-export const scan = Effect.fnUntraced(function* (
+export const scan = Effect.fn("ShellParse.scan")(function* (
   command: string,
   shell: string,
   cwd: string,
@@ -163,7 +163,7 @@ export const scan = Effect.fnUntraced(function* (
   return yield* scanLegacy(command, shell, cwd)
 })
 
-const scanLegacy = Effect.fnUntraced(function* (command: string, shell: string, cwd: string) {
+const scanLegacy = Effect.fn("ShellParse.scanLegacy")(function* (command: string, shell: string, cwd: string) {
   const parsers = yield* Effect.promise(load)
   const powershell = ShellSelect.ps(shell)
   const tree = (powershell ? parsers.ps : parsers.bash).parse(command)

packages/core/src/state.ts

@@ -97,7 +97,10 @@ export function create<State, DraftApi>(options: Options<State, DraftApi>): Inte
   const materialize = Effect.fnUntraced(function* () {
     const next = options.initial()
     const api = options.draft(next)
-    for (const transform of transforms) yield* apply(transform.run, api)
+    for (const transform of transforms)
+      yield* apply(transform.run, api).pipe(
+        Effect.withSpan("State.reload.update", { attributes: { state: options.name ?? "anonymous" } }),
+      )
     yield* commit(next)
   })
 

packages/core/src/tool-output.ts

@@ -51,7 +51,7 @@ const layer = Layer.effect(
     const global = yield* Global.Service
     const directory = path.join(global.data, DIRECTORY)
 
-    const truncate = Effect.fnUntraced(function* (result: Result) {
+    const truncate = Effect.fn("ToolOutput.truncate")(function* (result: Result) {
       if (result.metadata?.truncated !== undefined) return result
       const content =
         typeof result.content === "string" ? [{ type: "text" as const, text: result.content }] : (result.content ?? [])

packages/core/src/tool.ts

@@ -50,7 +50,7 @@ const layer = Layer.effect(
     const image = yield* Image.Service
 
     type NormalizedItem = Tool.Content | "decode" | "size"
-    const normalizeImages = Effect.fnUntraced(function* (content: ReadonlyArray<Tool.Content>) {
+    const normalizeImages = Effect.fn("Tool.normalizeImages")(function* (content: ReadonlyArray<Tool.Content>) {
       const normalized = yield* Effect.forEach(content, (item): Effect.Effect<NormalizedItem> => {
         if (item.type !== "file" || !item.mime.startsWith("image/")) return Effect.succeed(item)
         const base64 = /^data:[^,]*;base64,(.*)$/s.exec(item.uri)?.[1]

packages/core/src/tool/plugin/shell.ts

@@ -208,7 +208,7 @@ export const Plugin = {
               )
               yield* context.progress({ shellID: info.id })
 
-              const captureShell = Effect.fnUntraced(function* () {
+              const captureShell = Effect.fn("ShellTool.captureShell")(function* () {
                 const configured = Config.latest(yield* config.entries(), "tool_output")
                 const maxLines = configured?.max_lines ?? ToolOutput.MAX_LINES
                 const maxBytes = configured?.max_bytes ?? ToolOutput.MAX_BYTES
@@ -228,7 +228,7 @@ export const Plugin = {
                 }
               })
 
-              const settleShell = Effect.fnUntraced(function* () {
+              const settleShell = Effect.fn("ShellTool.settleShell")(function* () {
                 const final = yield* shell.wait(info.id)
                 const capture = yield* captureShell()
 

packages/core/src/tool/plugin/websearch.ts

@@ -4,6 +4,7 @@ import type { Context as PluginContext } from "@opencode-ai/plugin/effect/plugin
 import { ToolFailure } from "@opencode-ai/ai"
 import { Effect, Schema, Semaphore } from "effect"
 import { HttpClientError } from "effect/unstable/http"
+import { Config } from "../../config.js"
 import { Form } from "../../form.js"
 import { Permission } from "../../permission.js"
 import { WebSearch } from "../../websearch.js"
@@ -29,6 +30,7 @@ export const Plugin = {
   effect: Effect.fn("WebSearchTool.Plugin")(function* (ctx: PluginContext) {
     const permission = yield* Permission.Service
     const forms = yield* Form.Service
+    const config = yield* Config.Service
     const websearch = yield* WebSearch.Service
 
     yield* ctx.tool
@@ -95,7 +97,9 @@ export const Plugin = {
                           if (response.status === "cancelled")
                             return yield* Effect.fail(new Error("Web search cancelled"))
                           if (response.answer.choice === "disable") {
-                            yield* websearch.select(false)
+                            yield* config.update((draft) => {
+                              draft.websearch = false
+                            })
                             return yield* new WebSearch.DisabledError()
                           }
                           const selection =
@@ -127,7 +131,11 @@ export const Plugin = {
                             (providerID !== "random" && !providers.some((provider) => provider.id === providerID))
                           )
                             return yield* new WebSearch.ProviderRequiredError()
-                          yield* websearch.select(providerID === "random" ? "random" : WebSearch.ID.make(providerID))
+                          yield* config.update((draft) => {
+                            draft.websearch = {
+                              provider: providerID === "random" ? "random" : WebSearch.ID.make(providerID),
+                            }
+                          })
                           if (providerID !== "random") return WebSearch.ID.make(providerID)
                           return providers[Math.floor(Math.random() * providers.length)]?.id
                         }),
@@ -198,10 +206,7 @@ export const Plugin = {
 
     yield* ctx.session.hook("context", (event) =>
       Effect.gen(function* () {
-        const disabled = yield* websearch.default().pipe(
-          Effect.as(false),
-          Effect.catchTag("WebSearch.Disabled", () => Effect.succeed(true)),
-        )
+        const disabled = Config.latest(yield* config.entries(), "websearch") === false
         if (disabled) delete event.tools[name]
       }),
     )

packages/core/src/websearch.ts

@@ -1,10 +1,9 @@
 export * as WebSearch from "./websearch.js"
 
 import { WebSearch } from "@opencode-ai/schema/websearch"
-import { Context, Effect, Layer, Option, Schema } from "effect"
+import { Context, Effect, Layer, Schema } from "effect"
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
 import { Bus } from "./bus.js"
-import { KV } from "./kv.js"
 import { State } from "./state.js"
 
 export const ID = WebSearch.ID
@@ -25,10 +24,6 @@ export type Result = WebSearch.Result
 export const Response = WebSearch.Response
 export type Response = WebSearch.Response
 
-export const ProviderKey = "websearch:provider"
-export const Selection = Schema.Union([ID, Schema.Literal("random"), Schema.Literal(false)])
-export type Selection = typeof Selection.Type
-
 export interface ProviderImplementation extends Provider {
   readonly execute: (input: ProviderInput) => Effect.Effect<readonly Result[], unknown>
 }
@@ -54,7 +49,6 @@ export type Error = ProviderRequiredError | ProviderNotFoundError | DisabledErro
 export interface Interface extends State.Transformable<Draft> {
   readonly providers: () => Effect.Effect<readonly Provider[]>
   readonly default: () => Effect.Effect<Provider | undefined, DisabledError>
-  readonly select: (selection: Selection) => Effect.Effect<void>
   readonly query: (input: Input) => Effect.Effect<Response, Error>
 }
 
@@ -62,14 +56,14 @@ export class Service extends Context.Service<Service, Interface>()("@opencode/We
 
 type Data = {
   readonly providers: Map<ID, ProviderImplementation>
-  selection?: Selection
+  selection?: ID | "random" | false
 }
 
 export type Draft = {
   add: (provider: ProviderImplementation) => void
   default: {
-    get: () => Selection | undefined
-    set: (selection: Selection) => void
+    get: () => ID | "random" | false | undefined
+    set: (selection: ID | "random" | false) => void
   }
 }
 
@@ -77,7 +71,6 @@ const layer = Layer.effect(
   Service,
   Effect.gen(function* () {
     const bus = yield* Bus.Service
-    const kv = yield* KV.Service
     const decodeResults = Schema.decodeUnknownEffect(Schema.Array(Result))
     const state = State.create<Data, Draft>({
       initial: () => ({ providers: new Map() }),
@@ -98,16 +91,12 @@ const layer = Layer.effect(
 
     const defaultProvider = Effect.fn("WebSearch.default")(function* () {
       const data = state.get()
-      const stored = data.selection === undefined ? yield* kv.get(ProviderKey) : undefined
-      const decoded = Schema.decodeUnknownOption(Selection)(stored)
-      if (stored !== undefined && Option.isNone(decoded)) yield* kv.remove(ProviderKey)
-      const selection = data.selection ?? Option.getOrUndefined(decoded)
-      if (selection === false) return yield* new DisabledError()
-      if (selection === "random") {
+      if (data.selection === false) return yield* new DisabledError()
+      if (data.selection === "random") {
         const providers = Array.from(data.providers.values())
         return providers[Math.floor(Math.random() * providers.length)]
       }
-      return selection ? data.providers.get(selection) : undefined
+      return data.selection ? data.providers.get(data.selection) : undefined
     })
 
     const resolve = Effect.fn("WebSearch.resolve")(function* (input: Input) {
@@ -131,9 +120,6 @@ const layer = Layer.effect(
         const provider = yield* defaultProvider()
         return provider && { id: provider.id, name: provider.name }
       }),
-      select: Effect.fn("WebSearch.select")(function* (selection) {
-        yield* kv.set(ProviderKey, selection)
-      }),
       query: Effect.fn("WebSearch.query")(function* (input) {
         const provider = yield* resolve(input)
         const results = yield* provider.execute({ query: input.query }).pipe(
@@ -149,5 +135,5 @@ const layer = Layer.effect(
 export const node = makeLocationNode({
   service: Service,
   layer,
-  deps: [Bus.node, KV.node],
+  deps: [Bus.node],
 })

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

@@ -1,86 +0,0 @@
-import { describe, expect } from "bun:test"
-import { Bus } from "@opencode-ai/core/bus"
-import { Config } from "@opencode-ai/core/config"
-import { ConfigImagePlugin } from "@opencode-ai/core/config/plugin/image"
-import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
-import { Image } from "@opencode-ai/core/image"
-import { Plugin } from "@opencode-ai/core/plugin"
-import { PluginHost } from "@opencode-ai/core/plugin/host"
-import { Document, Event, Info, type Entry } from "@opencode-ai/schema/config"
-import { Effect, Layer, Schema, Stream } from "effect"
-import { testEffect } from "../lib/effect"
-import { PluginTestLayer } from "../plugin/fixture"
-
-const it = testEffect(Layer.merge(PluginTestLayer, AppNodeBuilder.build(Image.node)))
-const decode = Schema.decodeUnknownSync(Info)
-const content = {
-  uri: "file:///pixel.png",
-  content: "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+A8AAQUBAScY42YAAAAASUVORK5CYII=",
-  encoding: "base64" as const,
-  mime: "image/png",
-}
-
-describe("ConfigImagePlugin.Plugin", () => {
-  it.live("merges image limits and reloads changed config", () =>
-    Effect.gen(function* () {
-      const image = yield* Image.Service
-      const bus = yield* Bus.Service
-      const config = yield* Config.Test
-      const plugins = yield* Plugin.Service
-      yield* ConfigImagePlugin.Plugin.effect(yield* PluginHost.make(plugins))
-
-      expect(yield* limits(image)).toEqual({ maxWidth: 1_200, maxHeight: 900, maxBytes: 1 })
-
-      yield* config.setEntries([document({ auto_resize: false, max_width: 700, max_base64_bytes: 1 })])
-      yield* bus.publish(Event.Updated, {})
-      yield* waitUntil(
-        limits(image).pipe(
-          Effect.map((current) => current.maxWidth === 700 && current.maxHeight === 2_000 && current.maxBytes === 1),
-        ),
-      )
-    }).pipe(
-      Effect.provide(
-        Config.testLayer([
-          document({ auto_resize: false, max_width: 1_200 }),
-          document({ max_height: 900, max_base64_bytes: 1 }),
-        ]),
-      ),
-    ),
-  )
-
-  it.live("refetches config after subscribing to updates", () =>
-    Effect.gen(function* () {
-      const image = yield* Image.Service
-      const plugins = yield* Plugin.Service
-      let reads = 0
-      const config = Config.Service.of({
-        entries: () => Effect.sync(() => [document({ max_width: reads++ === 0 ? 1_200 : 700, max_base64_bytes: 1 })]),
-        update: () => Effect.die(new Error("Config update is unavailable")),
-        changes: () => Stream.empty,
-      })
-      yield* ConfigImagePlugin.Plugin.effect(yield* PluginHost.make(plugins)).pipe(
-        Effect.provideService(Config.Service, config),
-      )
-
-      expect(yield* limits(image)).toEqual({ maxWidth: 700, maxHeight: 2_000, maxBytes: 1 })
-    }),
-  )
-})
-
-function document(image: NonNullable<typeof Info.Encoded.media>["image"]): Entry {
-  return new Document({ type: "document", info: decode({ media: { image } }) })
-}
-
-const limits = Effect.fnUntraced(function* (image: Image.Interface) {
-  const error = yield* image.normalize("pixel.png", content).pipe(Effect.flip, Effect.orDie)
-  if (error._tag !== "Image.SizeError") return yield* Effect.die(error)
-  return { maxWidth: error.maxWidth, maxHeight: error.maxHeight, maxBytes: error.maxBytes }
-})
-
-const waitUntil = Effect.fnUntraced(function* (condition: Effect.Effect<boolean>) {
-  for (let attempt = 0; attempt < 200; attempt++) {
-    if (yield* condition) return
-    yield* Effect.sleep("10 millis")
-  }
-  yield* Effect.die(new Error("Timed out waiting for image config reload"))
-})

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

@@ -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" } },

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

@@ -44,9 +44,7 @@ describe("PluginSupervisor config", () => {
         const plugins = yield* Plugin.Service
         yield* ready()
         expect(
-          (yield* plugins.list())
-            .flatMap((plugin) => (plugin.id ? [plugin.id] : []))
-            .filter((id) => id.startsWith("opencode.provider.")),
+          (yield* plugins.list()).map((plugin) => plugin.id).filter((id) => id.startsWith("opencode.provider.")),
         ).toEqual([Plugin.ID.make("opencode.provider.openai")])
       }),
     ),
@@ -66,20 +64,10 @@ describe("PluginSupervisor config", () => {
       Effect.gen(function* () {
         yield* ready()
         const agents = yield* Agent.Service
-        const plugins = yield* Plugin.Service
         expect(yield* agents.get(Agent.ID.make("configured"))).toMatchObject({
           description: "Loaded from config",
           mode: "subagent",
         })
-        expect((yield* plugins.list()).find((plugin) => plugin.id === "config-promise-plugin")).toEqual({
-          id: Plugin.ID.make("config-promise-plugin"),
-          source: {
-            type: "local",
-            path: path.join(import.meta.dir, "../plugin/fixtures/config-promise-plugin.ts"),
-          },
-          status: "active",
-          tui: true,
-        })
       }),
     ),
   )
@@ -155,7 +143,6 @@ describe("PluginSupervisor config", () => {
       Effect.gen(function* () {
         yield* ready()
         const agents = yield* Agent.Service
-        const plugins = yield* Plugin.Service
         expect(yield* agents.get(Agent.ID.make("configured"))).toMatchObject({
           description: "Loaded after invalid plugins",
         })
@@ -163,12 +150,6 @@ describe("PluginSupervisor config", () => {
           path.join(import.meta.dir, "../plugin/fixtures/missing-plugin.ts"),
           path.join(import.meta.dir, "../plugin/fixtures/invalid-plugin.ts"),
         ])
-        expect(
-          (yield* plugins.list()).filter((plugin) => plugin.status === "failed").map((plugin) => plugin.source),
-        ).toEqual([
-          { type: "local", path: path.join(import.meta.dir, "../plugin/fixtures/missing-plugin.ts") },
-          { type: "local", path: path.join(import.meta.dir, "../plugin/fixtures/invalid-plugin.ts") },
-        ])
       }),
     ).pipe(Effect.provide(Logger.layer([logger])))
   })
@@ -265,12 +246,10 @@ describe("PluginSupervisor config", () => {
         Effect.gen(function* () {
           yield* ready()
           const plugins = yield* Plugin.Service
-          const inventory = yield* plugins.list()
-          const ids = inventory.map((plugin) => String(plugin.id))
+          const ids = (yield* plugins.list()).map((plugin) => String(plugin.id))
           expect(ids).toContain("opencode.agent")
           expect(ids).toContain("static-sdk")
           expect(ids).not.toContain("config-promise-plugin")
-          expect(inventory.find((plugin) => plugin.id === "static-sdk")?.source).toEqual({ type: "sdk" })
 
           const agents = yield* Agent.Service
           expect(yield* agents.get(Agent.ID.make("directory"))).toBeUndefined()

packages/core/test/database-drizzle.test.ts

@@ -6,7 +6,7 @@ import { expect, test } from "bun:test"
 import { SqliteClient } from "@effect/sql-sqlite-bun"
 import { eq, sql } from "drizzle-orm"
 import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core"
-import { Effect, Tracer } from "effect"
+import { Effect } from "effect"
 import type { SqlClient as SqlClientService } from "effect/unstable/sql/SqlClient"
 import { isSqlError } from "effect/unstable/sql/SqlError"
 import { EffectDrizzleSqlite } from "@opencode-ai/core/database/drizzle"
@@ -49,31 +49,6 @@ test("selects rows through Effect-yieldable query builders", async () => {
   )
 })
 
-test("suppresses statement spans", async () => {
-  const spans: Tracer.NativeSpan[] = []
-  const tracer = Tracer.make({
-    span(options) {
-      const span = new Tracer.NativeSpan(options)
-      spans.push(span)
-      return span
-    },
-  })
-
-  await Effect.runPromise(
-    Effect.gen(function* () {
-      const db = yield* makeDb
-      yield* db.transaction((tx) => tx.insert(users).values({ name: "Grace" }))
-      yield* db.select().from(users)
-    }).pipe(
-      Effect.provideService(Tracer.Tracer, tracer),
-      Effect.provide(SqliteClient.layer({ filename: ":memory:", disableWAL: true })),
-      Effect.scoped,
-    ),
-  )
-
-  expect(spans.map((span) => span.name)).not.toContain("sql.execute")
-})
-
 test("commits successful transactions", async () => {
   await run(
     Effect.gen(function* () {