refactor(core): classify step settlement once

refactor(core): derive continuation and held overflow from step ledger
refactor(core): rename LLM event publisher to step ledger
2026-07-30 15:11:11 -04:00 · 2026-07-03 16:52:52 -04:00 · 2026-07-03 16:46:17 -04:00 · 2026-07-03 16:44:55 -04:00
295 changed files with 4937 additions and 39666 deletions
@@ -0,0 +1,36 @@
+export default {
+  id: "Orchestrator",
+  setup: async (ctx) => {
+    await ctx.agent.transform((agents) => {
+      agents.update("orchestrator", (agent) => {
+        agent.description = "Coordinates work by delegating implementation tasks to the minion subagent."
+        agent.mode = "primary"
+        agent.system = [
+          "You are Orchestrator, the primary coordinating agent for this repository. You do meta work only: you coordinate, brief, and synthesize — you do not perform the work itself.",
+          "Delegate ALL actual work to the minion subagent — implementation, exploration, discovery, searching the codebase, reading files to understand a problem, and even trivial one-line edits. Task size is never a reason to do it yourself, and there is no 'final integration' exception.",
+          "You are not hard-banned from tools, but direct tool use is reserved for coordination overhead: a quick peek to phrase a better brief, a fast read-only check to verify a minion's reported result, or answering a question about coordination state. If a tool call is producing the answer or the artifact the user asked for, that call belongs to a minion, not you.",
+          "Exploration is work. If the user asks how something works or where something lives, delegate the investigation to a minion rather than exploring yourself.",
+          "Always start minion subagents in the background. Even if you have nothing else to coordinate right now, the user may assign you new work while a Minion runs, and you must stay free to receive it. Never poll; you will be notified when they finish.",
+          "Give each minion a clear, self-contained brief: the goal, constraints, expected output, and any files or context already known from the user or previous minion reports.",
+          "Synthesize minion results, decide next steps, and report back concisely.",
+        ].join("\n")
+      })
+
+      agents.update("minion", (agent) => {
+        agent.description = "Subagent that executes focused tasks delegated by Orchestrator."
+        agent.mode = "subagent"
+        agent.model = { providerID: "opencode", id: "glm-5.2" }
+        agent.system = [
+          "You are minion, a focused execution subagent for this repository.",
+          "Complete the specific task delegated to you by Orchestrator using the available tools.",
+          "Inspect the codebase before making assumptions, make targeted changes when requested, and verify your work when feasible.",
+          "Follow the repository's AGENTS.md conventions: respect the style guide, run `bun typecheck` from the affected package directory after code changes, never run tests from the repo root, and do not modify packages/opencode unless the task explicitly says V1 work.",
+          "If the task is ambiguous or you hit a blocker, stop and report your findings instead of guessing.",
+          "Keep your final response concise: summarize what you did, list important files changed or findings, and call out blockers or verification gaps.",
+          "Do not delegate to other subagents; execute the assigned work yourself.",
+        ].join("\n")
+        agent.permissions.push({ action: "subagent", resource: "*", effect: "deny" })
+      })
+    })
+  },
+}
@@ -104,25 +104,6 @@ bun dev api <operationId> --param key=value
 - If no compatible background server is registered, `bun dev api` starts one through the daemon service. Use `bun dev service status`, `bun dev service restart`, and `bun dev service stop` when you need explicit lifecycle control.
 - Prefer raw method/path calls for quick server debugging and operation IDs when exercising documented OpenAPI routes with path or query parameters.

-## Auditing installed `opencode2` sessions
-
-Installed next-channel sessions normally use `~/.local/share/opencode/opencode-next.db` and `~/.local/share/opencode/log/opencode.log`; `OPENCODE_DB` can override the database. Before calling `opencode2 api`, inspect `~/.local/state/opencode/service.json` because the command may start a daemon when none is healthy.
-
-For a supplied `ses_...` ID, compare three sources:
-
- `opencode2 api get /api/session/active` and the Session/message endpoints for live server state.
- The database's ordered `event` rows for durable history.
- `packages/tui/src/context/data.tsx` and the relevant route for client projection and rendering.
-
-Locate an uncertain database without modifying it:
-
-```bash
-SESSION=ses_...
-for db in ~/.local/share/opencode/*.db; do
-  sqlite3 "file:$db?mode=ro" "select 1 from session where id='$SESSION' limit 1" 2>/dev/null | grep -q 1 && printf '%s\n' "$db"
-done
-```
-
 ## Logs

 - Log files live under `~/.local/share/opencode/log/`. In a local/dev checkout the active file is `opencode-local.log`; `opencode.log` is used for non-local (released) channel installs. Both are append-only, shared across every CLI and server process on the machine.
@@ -151,7 +151,6 @@ const table = sqliteTable("session", {

 ## V2 Session Core

- Keep durable events minimal: record irreducible new facts and do not repeat state derivable by folding the ordered aggregate history. Enrich projections and read models with previous or derived state when consumers need self-contained views.
 - Keep durable prompt admission separate from model execution. `SessionV2.prompt(...)` admits one durable `session_input` row before scheduling advisory `SessionExecution.wake(sessionID)` unless `resume: false` requests admit-only behavior. The serialized runner promotes admitted inputs into visible user messages at safe boundaries.
 - Reusing a Session ID adopts the existing Session. Reusing a prompt message ID reconciles an exact retry only when Session, prompt, and delivery mode match; conflicting reuse fails. Historical projected prompts lazily synthesize promoted inbox records during exact retry.
 - Keep `SessionExecution` process-global and Session-ID based. Its local implementation owns the process-local Session coordinator and discovers placement through `SessionStore` plus `LocationServiceMap.get(session.location)` only when a drain starts; no layer should take a Session ID. V2 interruption targets the active process-local ownership chain for that Session; idle or missing interruption is a no-op.
@@ -122,14 +122,15 @@
    },
    "packages/client": {
      "name": "@opencode-ai/client",
-      "version": "1.17.13",
      "dependencies": {
        "@opencode-ai/protocol": "workspace:*",
        "@opencode-ai/schema": "workspace:*",
      },
      "devDependencies": {
        "@effect/platform-node": "catalog:",
+        "@opencode-ai/core": "workspace:*",
        "@opencode-ai/httpapi-codegen": "workspace:*",
+        "@opencode-ai/server": "workspace:*",
        "@tsconfig/bun": "catalog:",
        "@types/bun": "catalog:",
        "@typescript/native-preview": "catalog:",
@@ -321,7 +322,6 @@
        "@modelcontextprotocol/sdk": "1.29.0",
        "@npmcli/arborist": "9.4.0",
        "@npmcli/config": "10.8.1",
-        "@opencode-ai/codemode": "workspace:*",
        "@opencode-ai/effect-drizzle-sqlite": "workspace:*",
        "@opencode-ai/effect-sqlite-node": "workspace:*",
        "@opencode-ai/llm": "workspace:*",
@@ -530,7 +530,6 @@
    },
    "packages/httpapi-codegen": {
      "name": "@opencode-ai/httpapi-codegen",
-      "version": "0.0.0",
      "dependencies": {
        "effect": "catalog:",
        "prettier": "3.6.2",
@@ -696,7 +695,6 @@
      "version": "1.17.13",
      "dependencies": {
        "@ai-sdk/provider": "3.0.8",
-        "@opencode-ai/client": "workspace:*",
        "@opencode-ai/llm": "workspace:*",
        "@opencode-ai/protocol": "workspace:*",
        "@opencode-ai/schema": "workspace:*",
@@ -177,7 +177,7 @@ export function DialogCustomProvider(props: Props) {
    >
      <div class="flex flex-col gap-6 px-2.5 pb-3 overflow-y-auto max-h-[60vh]">
        <div class="px-2.5 flex gap-4 items-center">
-          <ProviderIcon id="session.synthetic" class="size-5 shrink-0 icon-strong-base" />
+          <ProviderIcon id="synthetic" class="size-5 shrink-0 icon-strong-base" />
          <div class="text-16-medium text-text-strong">{language.t("provider.custom.title")}</div>
        </div>

@@ -226,7 +226,7 @@ const SettingsProvidersContent: Component = () => {
            >
              <div class="flex flex-col min-w-0">
                <div class="flex flex-wrap items-center gap-x-3 gap-y-1">
-                  <ProviderIcon id="session.synthetic" class="size-5 shrink-0 icon-strong-base" />
+                  <ProviderIcon id="synthetic" class="size-5 shrink-0 icon-strong-base" />
                  <span class="text-14-medium text-text-strong">{language.t("provider.custom.title")}</span>
                  <Tag>{language.t("settings.providers.tag.custom")}</Tag>
                </div>
@@ -223,7 +223,7 @@ export const SettingsProvidersV2: Component = () => {
            <div class="settings-v2-provider-row" data-component="custom-provider-section">
              <div class="settings-v2-provider-lead">
                <ProviderIcon
-                  id="session.synthetic"
+                  id="synthetic"
                  width={PROVIDER_ICON_SIZE}
                  height={PROVIDER_ICON_SIZE}
                  class="settings-v2-provider-icon shrink-0"
@@ -7,7 +7,7 @@ describe("file watcher invalidation", () => {
    const refresh: string[] = []
    invalidateFromWatcher(
      {
-        type: "filesystem.changed",
+        type: "file.watcher.updated",
        properties: {
          file: "src/new.ts",
          event: "add",
@@ -32,7 +32,7 @@ describe("file watcher invalidation", () => {

    invalidateFromWatcher(
      {
-        type: "filesystem.changed",
+        type: "file.watcher.updated",
        properties: {
          file: "src/open.ts",
          event: "change",
@@ -63,7 +63,7 @@ describe("file watcher invalidation", () => {

    invalidateFromWatcher(
      {
-        type: "filesystem.changed",
+        type: "file.watcher.updated",
        properties: {
          file: "src",
          event: "change",
@@ -81,7 +81,7 @@ describe("file watcher invalidation", () => {

    invalidateFromWatcher(
      {
-        type: "filesystem.changed",
+        type: "file.watcher.updated",
        properties: {
          file: "src/file.ts",
          event: "change",
@@ -111,7 +111,7 @@ describe("file watcher invalidation", () => {

    invalidateFromWatcher(
      {
-        type: "filesystem.changed",
+        type: "file.watcher.updated",
        properties: {
          file: ".git/index.lock",
          event: "change",
@@ -16,7 +16,7 @@ type WatcherOps = {
 }

 export function invalidateFromWatcher(event: WatcherEvent, ops: WatcherOps) {
-  if (event.type !== "filesystem.changed") return
+  if (event.type !== "file.watcher.updated") return
  const props =
    typeof event.properties === "object" && event.properties ? (event.properties as Record<string, unknown>) : undefined
  const rawPath = typeof props?.file === "string" ? props.file : undefined
@@ -820,7 +820,7 @@ export default function Page() {
  )

  const stopVcs = sdk().event.listen((evt) => {
-    if (evt.details.type !== "filesystem.changed") return
+    if (evt.details.type !== "file.watcher.updated") return
    const props =
      typeof evt.details.properties === "object" && evt.details.properties
        ? (evt.details.properties as Record<string, unknown>)
@@ -1,30 +1,16 @@
 {
  "$schema": "https://json.schemastore.org/package.json",
  "name": "@opencode-ai/client",
-  "version": "1.17.13",
+  "private": true,
  "type": "module",
  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/anomalyco/opencode.git",
-    "directory": "packages/client"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "files": [
-    "dist"
-  ],
  "exports": {
    "./promise": "./src/promise/index.ts",
-    "./promise/api": "./src/promise/api.ts",
-    "./effect": "./src/effect/index.ts",
-    "./effect/api": "./src/effect/api.ts"
+    "./effect": "./src/effect/index.ts"
  },
  "scripts": {
-    "build": "bun run script/build-package.ts",
    "generate": "bun run script/build.ts",
-    "check:generated": "bun run generate && git diff --exit-code -- src/promise/generated src/effect/generated src/effect/api",
+    "check:generated": "bun run generate && git diff --exit-code -- src/promise/generated src/effect/generated",
    "test": "bun test --timeout 5000",
    "typecheck": "tsgo --noEmit"
  },
@@ -42,7 +28,9 @@
  },
  "devDependencies": {
    "@effect/platform-node": "catalog:",
+    "@opencode-ai/core": "workspace:*",
    "@opencode-ai/httpapi-codegen": "workspace:*",
+    "@opencode-ai/server": "workspace:*",
    "@tsconfig/bun": "catalog:",
    "@types/bun": "catalog:",
    "@typescript/native-preview": "catalog:",
@@ -1,9 +0,0 @@
-#!/usr/bin/env bun
-
-import { $ } from "bun"
-import { fileURLToPath } from "node:url"
-
-process.chdir(fileURLToPath(new URL("..", import.meta.url)))
-
-await $`rm -rf dist`
-await $`bun tsc -p tsconfig.build.json`
@@ -32,8 +32,8 @@ await Effect.runPromise(
        fileURLToPath(new URL("../src/effect/generated", import.meta.url)),
      ),
      write(
-        emitEffectShape(effectContract, { module: "../../contract", api: "ClientApi" }),
-        fileURLToPath(new URL("../src/effect/api", import.meta.url)),
+        emitEffectShape(effectContract, { module: "@opencode-ai/protocol/client", api: "ClientApi" }),
+        fileURLToPath(new URL("../../plugin/src/v2/effect/generated", import.meta.url)),
      ),
    ],
    { concurrency: 3, discard: true },
@@ -1,45 +0,0 @@
-#!/usr/bin/env bun
-
-import { Script } from "@opencode-ai/script"
-import { $ } from "bun"
-import { rm } from "node:fs/promises"
-import { fileURLToPath } from "node:url"
-
-process.chdir(fileURLToPath(new URL("..", import.meta.url)))
-
-const originalText = await Bun.file("package.json").text()
-const pkg = JSON.parse(originalText) as {
-  name: string
-  version: string
-  exports: Record<string, string | { import: string; types: string }>
-}
-const tarball = `${pkg.name.replace("@", "").replace("/", "-")}-${pkg.version}.tgz`
-
-if ((await $`npm view ${pkg.name}@${pkg.version} version`.nothrow()).exitCode === 0) {
-  console.log(`already published ${pkg.name}@${pkg.version}`)
-  process.exit(0)
-}
-
-try {
-  await $`bun run typecheck`
-  await $`bun run build`
-  pkg.exports = Object.fromEntries(
-    Object.entries(pkg.exports).map(([key, value]) => {
-      if (typeof value !== "string") return [key, value]
-      return [
-        key,
-        {
-          import: value.replace("./src/", "./dist/").replace(/\.ts$/, ".js"),
-          types: value.replace("./src/", "./dist/").replace(/\.ts$/, ".d.ts"),
-        },
-      ]
-    }),
-  )
-  await Bun.write("package.json", JSON.stringify(pkg, null, 2) + "\n")
-  await rm(tarball, { force: true })
-  await $`bun pm pack`
-  await $`npm publish ${tarball} --tag ${Script.channel} --access public`
-} finally {
-  await Bun.write("package.json", originalText)
-  await rm(tarball, { force: true })
-}
@@ -1,8 +0,0 @@
-import type { ModelApi, ProviderApi } from "./api/api.js"
-
-export type * from "./api/api.js"
-
-export interface CatalogApi<E = never> {
-  readonly provider: ProviderApi<E>
-  readonly model: ModelApi<E>
-}
@@ -1043,11 +1043,6 @@ const Endpoint24_1 = (raw: RawClient["server.vcs"]) => (input: Endpoint24_1Input

 const adaptGroup24 = (raw: RawClient["server.vcs"]) => ({ status: Endpoint24_0(raw), diff: Endpoint24_1(raw) })

-const Endpoint25_0 = (raw: RawClient["server.debug"]) => () =>
-  raw["debug.location"]({}).pipe(Effect.mapError(mapClientError))
-
-const adaptGroup25 = (raw: RawClient["server.debug"]) => ({ location: Endpoint25_0(raw) })
-
 const adaptClient = (raw: RawClient) => ({
  health: adaptGroup0(raw["server.health"]),
  location: adaptGroup1(raw["server.location"]),
@@ -1074,7 +1069,6 @@ const adaptClient = (raw: RawClient) => ({
  reference: adaptGroup22(raw["server.reference"]),
  projectCopy: adaptGroup23(raw["server.projectCopy"]),
  vcs: adaptGroup24(raw["server.vcs"]),
-  debug: adaptGroup25(raw["server.debug"]),
 })

 export const make = (options?: { readonly baseUrl?: URL | string }) =>
@@ -1,22 +1,6 @@
 // TODO: Keep additional network capabilities inside Schema and Protocol as the client grows; /effect must never import
 // Core or Server. Preserve these datatype exports so internal model reorganizations do not require caller migrations.
-import type { Effect } from "effect"
-
 export * from "./generated/index"
-export type {
-  AgentApi,
-  AppApi,
-  CatalogApi,
-  CommandApi,
-  EventApi,
-  IntegrationApi,
-  ModelApi,
-  PluginApi,
-  ProviderApi,
-  ReferenceApi,
-  SessionApi,
-  SkillApi,
-} from "./api.js"
 export { Service } from "./service.js"
 export { Agent } from "@opencode-ai/schema/agent"
 export { Command } from "@opencode-ai/schema/command"
@@ -43,4 +27,3 @@ export { SessionMessage } from "@opencode-ai/schema/session-message"
 export { Skill } from "@opencode-ai/schema/skill"
 export { Prompt } from "@opencode-ai/schema/prompt"
 export type { OpenCodeEvent } from "@opencode-ai/protocol/groups/event"
-export type OpenCodeClient = Effect.Success<ReturnType<typeof import("./generated/client").make>>
@@ -1,41 +0,0 @@
-import type {
-  AgentApi as EffectAgentApi,
-  CommandApi as EffectCommandApi,
-  EventApi as EffectEventApi,
-  IntegrationApi as EffectIntegrationApi,
-  ModelApi as EffectModelApi,
-  PluginApi as EffectPluginApi,
-  ProviderApi as EffectProviderApi,
-  ReferenceApi as EffectReferenceApi,
-  SessionApi as EffectSessionApi,
-  SkillApi as EffectSkillApi,
-} from "../effect/api/api.js"
-import type { Effect, Stream } from "effect"
-
-type PromisifyOperation<Operation> = Operation extends (
-  ...args: infer Args
-) => Effect.Effect<infer Success, unknown, unknown>
-  ? (...args: Args) => Promise<Success>
-  : Operation extends (...args: infer Args) => Stream.Stream<infer Success, unknown, unknown>
-    ? (...args: Args) => AsyncIterable<Success>
-    : Operation
-
-type PromisifyApi<Api> = {
-  readonly [Name in keyof Api]: PromisifyOperation<Api[Name]>
-}
-
-export type AgentApi = PromisifyApi<EffectAgentApi<unknown>>
-export type CommandApi = PromisifyApi<EffectCommandApi<unknown>>
-export type EventApi = PromisifyApi<EffectEventApi<unknown>>
-export type IntegrationApi = PromisifyApi<EffectIntegrationApi<unknown>>
-export type ModelApi = PromisifyApi<EffectModelApi<unknown>>
-export type PluginApi = PromisifyApi<EffectPluginApi<unknown>>
-export type ProviderApi = PromisifyApi<EffectProviderApi<unknown>>
-export type ReferenceApi = PromisifyApi<EffectReferenceApi<unknown>>
-export type SessionApi = PromisifyApi<EffectSessionApi<unknown>>
-export type SkillApi = PromisifyApi<EffectSkillApi<unknown>>
-
-export interface CatalogApi {
-  readonly provider: ProviderApi
-  readonly model: ModelApi
-}
@@ -173,7 +173,6 @@ import type {
  VcsStatusOutput,
  VcsDiffInput,
  VcsDiffOutput,
-  DebugLocationOutput,
 } from "./types"
 import { ClientError } from "./client-error"

@@ -1449,19 +1448,6 @@ export function make(options: ClientOptions) {
          requestOptions,
        ),
    },
-    debug: {
-      location: (requestOptions?: RequestOptions) =>
-        request<DebugLocationOutput>(
-          {
-            method: "GET",
-            path: `/api/debug/location`,
-            successStatus: 200,
-            declaredStatuses: [401, 400],
-            empty: false,
-          },
-          requestOptions,
-        ),
-    },
  }
 }

@@ -928,7 +928,6 @@ export type SessionContextOutput = {
        readonly time: { readonly created: number }
        readonly type: "model-switched"
        readonly model: { readonly id: string; readonly providerID: string; readonly variant?: string }
-        readonly previous?: { readonly id: string; readonly providerID: string; readonly variant?: string }
      }
    | {
        readonly id: string
@@ -977,27 +976,9 @@ export type SessionContextOutput = {
        readonly metadata?: { readonly [x: string]: JsonValue }
        readonly time: { readonly created: number; readonly completed?: number }
        readonly type: "shell"
-        readonly shell: {
-          readonly id: string
-          readonly status: "running" | "exited" | "timeout" | "killed"
-          readonly command: string
-          readonly cwd: string
-          readonly shell: string
-          readonly file: string
-          readonly pid?: number
-          readonly exit?: number | "Infinity" | "-Infinity" | "NaN"
-          readonly metadata: { readonly [x: string]: JsonValue }
-          readonly time: {
-            readonly started: number | "Infinity" | "-Infinity" | "NaN"
-            readonly completed?: number | "Infinity" | "-Infinity" | "NaN"
-          }
-        }
-        readonly output?: {
-          readonly output: string
-          readonly cursor: number
-          readonly size: number
-          readonly truncated: boolean
-        }
+        readonly callID: string
+        readonly command: string
+        readonly output: string
      }
    | {
        readonly id: string
@@ -1128,7 +1109,7 @@ export type SessionLogOutput =
          readonly id: string
          readonly created: number
          readonly metadata?: { readonly [x: string]: unknown }
-          readonly type: "session.agent.selected"
+          readonly type: "agent.selected"
          readonly durable: { readonly aggregateID: string; readonly seq: number; readonly version: number }
          readonly location?: { readonly directory: string; readonly workspaceID?: string }
          readonly data: { readonly sessionID: string; readonly agent: string }
@@ -1137,7 +1118,7 @@ export type SessionLogOutput =
          readonly id: string
          readonly created: number
          readonly metadata?: { readonly [x: string]: unknown }
-          readonly type: "session.model.selected"
+          readonly type: "model.selected"
          readonly durable: { readonly aggregateID: string; readonly seq: number; readonly version: number }
          readonly location?: { readonly directory: string; readonly workspaceID?: string }
          readonly data: {
@@ -1162,7 +1143,7 @@ export type SessionLogOutput =
          readonly id: string
          readonly created: number
          readonly metadata?: { readonly [x: string]: unknown }
-          readonly type: "session.renamed"
+          readonly type: "renamed"
          readonly durable: { readonly aggregateID: string; readonly seq: number; readonly version: number }
          readonly location?: { readonly directory: string; readonly workspaceID?: string }
          readonly data: { readonly sessionID: string; readonly title: string }
@@ -1171,7 +1152,7 @@ export type SessionLogOutput =
          readonly id: string
          readonly created: number
          readonly metadata?: { readonly [x: string]: unknown }
-          readonly type: "session.forked"
+          readonly type: "forked"
          readonly durable: { readonly aggregateID: string; readonly seq: number; readonly version: number }
          readonly location?: { readonly directory: string; readonly workspaceID?: string }
          readonly data: { readonly sessionID: string; readonly parentID: string; readonly from?: string }
@@ -1180,7 +1161,7 @@ export type SessionLogOutput =
          readonly id: string
          readonly created: number
          readonly metadata?: { readonly [x: string]: unknown }
-          readonly type: "session.prompt.promoted"
+          readonly type: "prompt.promoted"
          readonly durable: { readonly aggregateID: string; readonly seq: number; readonly version: number }
          readonly location?: { readonly directory: string; readonly workspaceID?: string }
          readonly data: { readonly sessionID: string; readonly inputID: string }
@@ -1189,7 +1170,7 @@ export type SessionLogOutput =
          readonly id: string
          readonly created: number
          readonly metadata?: { readonly [x: string]: unknown }
-          readonly type: "session.prompt.admitted"
+          readonly type: "prompt.admitted"
          readonly durable: { readonly aggregateID: string; readonly seq: number; readonly version: number }
          readonly location?: { readonly directory: string; readonly workspaceID?: string }
          readonly data: {
@@ -1225,7 +1206,7 @@ export type SessionLogOutput =
          readonly id: string
          readonly created: number
          readonly metadata?: { readonly [x: string]: unknown }
-          readonly type: "session.synthetic"
+          readonly type: "synthetic"
          readonly durable: { readonly aggregateID: string; readonly seq: number; readonly version: number }
          readonly location?: { readonly directory: string; readonly workspaceID?: string }
          readonly data: {
@@ -1239,7 +1220,7 @@ export type SessionLogOutput =
          readonly id: string
          readonly created: number
          readonly metadata?: { readonly [x: string]: unknown }
-          readonly type: "session.skill.activated"
+          readonly type: "skill.activated"
          readonly durable: { readonly aggregateID: string; readonly seq: number; readonly version: number }
          readonly location?: { readonly directory: string; readonly workspaceID?: string }
          readonly data: { readonly sessionID: string; readonly name: string; readonly text: string }
@@ -1248,59 +1229,25 @@ export type SessionLogOutput =
          readonly id: string
          readonly created: number
          readonly metadata?: { readonly [x: string]: unknown }
-          readonly type: "session.shell.started"
+          readonly type: "shell.started"
          readonly durable: { readonly aggregateID: string; readonly seq: number; readonly version: number }
          readonly location?: { readonly directory: string; readonly workspaceID?: string }
-          readonly data: {
-            readonly sessionID: string
-            readonly shell: {
-              readonly id: string
-              readonly status: "running" | "exited" | "timeout" | "killed"
-              readonly command: string
-              readonly cwd: string
-              readonly shell: string
-              readonly file: string
-              readonly pid?: number
-              readonly exit?: number
-              readonly metadata: { readonly [x: string]: unknown }
-              readonly time: { readonly started: number; readonly completed?: number }
-            }
-          }
+          readonly data: { readonly sessionID: string; readonly callID: string; readonly command: string }
        }
      | {
          readonly id: string
          readonly created: number
          readonly metadata?: { readonly [x: string]: unknown }
-          readonly type: "session.shell.ended"
+          readonly type: "shell.ended"
          readonly durable: { readonly aggregateID: string; readonly seq: number; readonly version: number }
          readonly location?: { readonly directory: string; readonly workspaceID?: string }
-          readonly data: {
-            readonly sessionID: string
-            readonly shell: {
-              readonly id: string
-              readonly status: "running" | "exited" | "timeout" | "killed"
-              readonly command: string
-              readonly cwd: string
-              readonly shell: string
-              readonly file: string
-              readonly pid?: number
-              readonly exit?: number
-              readonly metadata: { readonly [x: string]: unknown }
-              readonly time: { readonly started: number; readonly completed?: number }
-            }
-            readonly output: {
-              readonly output: string
-              readonly cursor: number
-              readonly size: number
-              readonly truncated: boolean
-            }
-          }
+          readonly data: { readonly sessionID: string; readonly callID: string; readonly output: string }
        }
      | {
          readonly id: string
          readonly created: number
          readonly metadata?: { readonly [x: string]: unknown }
-          readonly type: "session.step.started"
+          readonly type: "step.started"
          readonly durable: { readonly aggregateID: string; readonly seq: number; readonly version: number }
          readonly location?: { readonly directory: string; readonly workspaceID?: string }
          readonly data: {
@@ -1315,7 +1262,7 @@ export type SessionLogOutput =
          readonly id: string
          readonly created: number
          readonly metadata?: { readonly [x: string]: unknown }
-          readonly type: "session.step.ended"
+          readonly type: "step.ended"
          readonly durable: { readonly aggregateID: string; readonly seq: number; readonly version: number }
          readonly location?: { readonly directory: string; readonly workspaceID?: string }
          readonly data: {
@@ -1337,7 +1284,7 @@ export type SessionLogOutput =
          readonly id: string
          readonly created: number
          readonly metadata?: { readonly [x: string]: unknown }
-          readonly type: "session.step.failed"
+          readonly type: "step.failed"
          readonly durable: { readonly aggregateID: string; readonly seq: number; readonly version: number }
          readonly location?: { readonly directory: string; readonly workspaceID?: string }
          readonly data: {
@@ -1350,7 +1297,7 @@ export type SessionLogOutput =
          readonly id: string
          readonly created: number
          readonly metadata?: { readonly [x: string]: unknown }
-          readonly type: "session.text.started"
+          readonly type: "text.started"
          readonly durable: { readonly aggregateID: string; readonly seq: number; readonly version: number }
          readonly location?: { readonly directory: string; readonly workspaceID?: string }
          readonly data: { readonly sessionID: string; readonly assistantMessageID: string; readonly textID: string }
@@ -1359,7 +1306,7 @@ export type SessionLogOutput =
          readonly id: string
          readonly created: number
          readonly metadata?: { readonly [x: string]: unknown }
-          readonly type: "session.text.ended"
+          readonly type: "text.ended"
          readonly durable: { readonly aggregateID: string; readonly seq: number; readonly version: number }
          readonly location?: { readonly directory: string; readonly workspaceID?: string }
          readonly data: {
@@ -1373,7 +1320,7 @@ export type SessionLogOutput =
          readonly id: string
          readonly created: number
          readonly metadata?: { readonly [x: string]: unknown }
-          readonly type: "session.reasoning.started"
+          readonly type: "reasoning.started"
          readonly durable: { readonly aggregateID: string; readonly seq: number; readonly version: number }
          readonly location?: { readonly directory: string; readonly workspaceID?: string }
          readonly data: {
@@ -1387,7 +1334,7 @@ export type SessionLogOutput =
          readonly id: string
          readonly created: number
          readonly metadata?: { readonly [x: string]: unknown }
-          readonly type: "session.reasoning.ended"
+          readonly type: "reasoning.ended"
          readonly durable: { readonly aggregateID: string; readonly seq: number; readonly version: number }
          readonly location?: { readonly directory: string; readonly workspaceID?: string }
          readonly data: {
@@ -1402,7 +1349,7 @@ export type SessionLogOutput =
          readonly id: string
          readonly created: number
          readonly metadata?: { readonly [x: string]: unknown }
-          readonly type: "session.tool.input.started"
+          readonly type: "tool.input.started"
          readonly durable: { readonly aggregateID: string; readonly seq: number; readonly version: number }
          readonly location?: { readonly directory: string; readonly workspaceID?: string }
          readonly data: {
@@ -1416,7 +1363,7 @@ export type SessionLogOutput =
          readonly id: string
          readonly created: number
          readonly metadata?: { readonly [x: string]: unknown }
-          readonly type: "session.tool.input.ended"
+          readonly type: "tool.input.ended"
          readonly durable: { readonly aggregateID: string; readonly seq: number; readonly version: number }
          readonly location?: { readonly directory: string; readonly workspaceID?: string }
          readonly data: {
@@ -1430,7 +1377,7 @@ export type SessionLogOutput =
          readonly id: string
          readonly created: number
          readonly metadata?: { readonly [x: string]: unknown }
-          readonly type: "session.tool.called"
+          readonly type: "tool.called"
          readonly durable: { readonly aggregateID: string; readonly seq: number; readonly version: number }
          readonly location?: { readonly directory: string; readonly workspaceID?: string }
          readonly data: {
@@ -1449,7 +1396,7 @@ export type SessionLogOutput =
          readonly id: string
          readonly created: number
          readonly metadata?: { readonly [x: string]: unknown }
-          readonly type: "session.tool.progress"
+          readonly type: "tool.progress"
          readonly durable: { readonly aggregateID: string; readonly seq: number; readonly version: number }
          readonly location?: { readonly directory: string; readonly workspaceID?: string }
          readonly data: {
@@ -1467,7 +1414,7 @@ export type SessionLogOutput =
          readonly id: string
          readonly created: number
          readonly metadata?: { readonly [x: string]: unknown }
-          readonly type: "session.tool.success"
+          readonly type: "tool.success"
          readonly durable: { readonly aggregateID: string; readonly seq: number; readonly version: number }
          readonly location?: { readonly directory: string; readonly workspaceID?: string }
          readonly data: {
@@ -1491,7 +1438,7 @@ export type SessionLogOutput =
          readonly id: string
          readonly created: number
          readonly metadata?: { readonly [x: string]: unknown }
-          readonly type: "session.tool.failed"
+          readonly type: "tool.failed"
          readonly durable: { readonly aggregateID: string; readonly seq: number; readonly version: number }
          readonly location?: { readonly directory: string; readonly workspaceID?: string }
          readonly data: {
@@ -1510,7 +1457,7 @@ export type SessionLogOutput =
          readonly id: string
          readonly created: number
          readonly metadata?: { readonly [x: string]: unknown }
-          readonly type: "session.retried"
+          readonly type: "retried"
          readonly durable: { readonly aggregateID: string; readonly seq: number; readonly version: number }
          readonly location?: { readonly directory: string; readonly workspaceID?: string }
          readonly data: {
@@ -1530,7 +1477,7 @@ export type SessionLogOutput =
          readonly id: string
          readonly created: number
          readonly metadata?: { readonly [x: string]: unknown }
-          readonly type: "session.compaction.started"
+          readonly type: "compaction.started"
          readonly durable: { readonly aggregateID: string; readonly seq: number; readonly version: number }
          readonly location?: { readonly directory: string; readonly workspaceID?: string }
          readonly data: { readonly sessionID: string; readonly reason: "auto" | "manual" }
@@ -1539,7 +1486,7 @@ export type SessionLogOutput =
          readonly id: string
          readonly created: number
          readonly metadata?: { readonly [x: string]: unknown }
-          readonly type: "session.compaction.ended"
+          readonly type: "compaction.ended"
          readonly durable: { readonly aggregateID: string; readonly seq: number; readonly version: number }
          readonly location?: { readonly directory: string; readonly workspaceID?: string }
          readonly data: {
@@ -1553,7 +1500,7 @@ export type SessionLogOutput =
          readonly id: string
          readonly created: number
          readonly metadata?: { readonly [x: string]: unknown }
-          readonly type: "session.revert.staged"
+          readonly type: "revert.staged"
          readonly durable: { readonly aggregateID: string; readonly seq: number; readonly version: number }
          readonly location?: { readonly directory: string; readonly workspaceID?: string }
          readonly data: {
@@ -1577,7 +1524,7 @@ export type SessionLogOutput =
          readonly id: string
          readonly created: number
          readonly metadata?: { readonly [x: string]: unknown }
-          readonly type: "session.revert.cleared"
+          readonly type: "revert.cleared"
          readonly durable: { readonly aggregateID: string; readonly seq: number; readonly version: number }
          readonly location?: { readonly directory: string; readonly workspaceID?: string }
          readonly data: { readonly sessionID: string }
@@ -1586,7 +1533,7 @@ export type SessionLogOutput =
          readonly id: string
          readonly created: number
          readonly metadata?: { readonly [x: string]: unknown }
-          readonly type: "session.revert.committed"
+          readonly type: "revert.committed"
          readonly durable: { readonly aggregateID: string; readonly seq: number; readonly version: number }
          readonly location?: { readonly directory: string; readonly workspaceID?: string }
          readonly data: { readonly sessionID: string; readonly messageID: string }
@@ -1622,7 +1569,6 @@ export type SessionMessageOutput = {
        readonly time: { readonly created: number }
        readonly type: "model-switched"
        readonly model: { readonly id: string; readonly providerID: string; readonly variant?: string }
-        readonly previous?: { readonly id: string; readonly providerID: string; readonly variant?: string }
      }
    | {
        readonly id: string
@@ -1671,27 +1617,9 @@ export type SessionMessageOutput = {
        readonly metadata?: { readonly [x: string]: JsonValue }
        readonly time: { readonly created: number; readonly completed?: number }
        readonly type: "shell"
-        readonly shell: {
-          readonly id: string
-          readonly status: "running" | "exited" | "timeout" | "killed"
-          readonly command: string
-          readonly cwd: string
-          readonly shell: string
-          readonly file: string
-          readonly pid?: number
-          readonly exit?: number | "Infinity" | "-Infinity" | "NaN"
-          readonly metadata: { readonly [x: string]: JsonValue }
-          readonly time: {
-            readonly started: number | "Infinity" | "-Infinity" | "NaN"
-            readonly completed?: number | "Infinity" | "-Infinity" | "NaN"
-          }
-        }
-        readonly output?: {
-          readonly output: string
-          readonly cursor: number
-          readonly size: number
-          readonly truncated: boolean
-        }
+        readonly callID: string
+        readonly command: string
+        readonly output: string
      }
    | {
        readonly id: string
@@ -1822,7 +1750,6 @@ export type MessageListOutput = {
        readonly time: { readonly created: number }
        readonly type: "model-switched"
        readonly model: { readonly id: string; readonly providerID: string; readonly variant?: string }
-        readonly previous?: { readonly id: string; readonly providerID: string; readonly variant?: string }
      }
    | {
        readonly id: string
@@ -1871,27 +1798,9 @@ export type MessageListOutput = {
        readonly metadata?: { readonly [x: string]: JsonValue }
        readonly time: { readonly created: number; readonly completed?: number }
        readonly type: "shell"
-        readonly shell: {
-          readonly id: string
-          readonly status: "running" | "exited" | "timeout" | "killed"
-          readonly command: string
-          readonly cwd: string
-          readonly shell: string
-          readonly file: string
-          readonly pid?: number
-          readonly exit?: number | "Infinity" | "-Infinity" | "NaN"
-          readonly metadata: { readonly [x: string]: JsonValue }
-          readonly time: {
-            readonly started: number | "Infinity" | "-Infinity" | "NaN"
-            readonly completed?: number | "Infinity" | "-Infinity" | "NaN"
-          }
-        }
-        readonly output?: {
-          readonly output: string
-          readonly cursor: number
-          readonly size: number
-          readonly truncated: boolean
-        }
+        readonly callID: string
+        readonly command: string
+        readonly output: string
      }
    | {
        readonly id: string
@@ -2430,7 +2339,7 @@ export type ServerMcpListOutput = {
    readonly name: string
    readonly status:
      | { readonly status: "connected" }
-      | { readonly status: "pending" }
+      | { readonly status: "disconnected" }
      | { readonly status: "disabled" }
      | { readonly status: "failed"; readonly error: string }
      | { readonly status: "needs_auth" }
@@ -4400,7 +4309,7 @@ export type EventSubscribeOutput =
      readonly id: string
      readonly created: number
      readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "session.agent.selected"
+      readonly type: "agent.selected"
      readonly durable: { readonly aggregateID: string; readonly seq: number; readonly version: number }
      readonly location?: { readonly directory: string; readonly workspaceID?: string }
      readonly data: { readonly sessionID: string; readonly agent: string }
@@ -4409,7 +4318,7 @@ export type EventSubscribeOutput =
      readonly id: string
      readonly created: number
      readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "session.model.selected"
+      readonly type: "model.selected"
      readonly durable: { readonly aggregateID: string; readonly seq: number; readonly version: number }
      readonly location?: { readonly directory: string; readonly workspaceID?: string }
      readonly data: {
@@ -4434,7 +4343,7 @@ export type EventSubscribeOutput =
      readonly id: string
      readonly created: number
      readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "session.renamed"
+      readonly type: "renamed"
      readonly durable: { readonly aggregateID: string; readonly seq: number; readonly version: number }
      readonly location?: { readonly directory: string; readonly workspaceID?: string }
      readonly data: { readonly sessionID: string; readonly title: string }
@@ -4443,7 +4352,7 @@ export type EventSubscribeOutput =
      readonly id: string
      readonly created: number
      readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "session.forked"
+      readonly type: "forked"
      readonly durable: { readonly aggregateID: string; readonly seq: number; readonly version: number }
      readonly location?: { readonly directory: string; readonly workspaceID?: string }
      readonly data: { readonly sessionID: string; readonly parentID: string; readonly from?: string }
@@ -4452,7 +4361,7 @@ export type EventSubscribeOutput =
      readonly id: string
      readonly created: number
      readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "session.prompt.promoted"
+      readonly type: "prompt.promoted"
      readonly durable: { readonly aggregateID: string; readonly seq: number; readonly version: number }
      readonly location?: { readonly directory: string; readonly workspaceID?: string }
      readonly data: { readonly sessionID: string; readonly inputID: string }
@@ -4461,7 +4370,7 @@ export type EventSubscribeOutput =
      readonly id: string
      readonly created: number
      readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "session.prompt.admitted"
+      readonly type: "prompt.admitted"
      readonly durable: { readonly aggregateID: string; readonly seq: number; readonly version: number }
      readonly location?: { readonly directory: string; readonly workspaceID?: string }
      readonly data: {
@@ -4488,7 +4397,7 @@ export type EventSubscribeOutput =
      readonly id: string
      readonly created: number
      readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "session.execution.settled"
+      readonly type: "execution.settled"
      readonly location?: { readonly directory: string; readonly workspaceID?: string }
      readonly data: {
        readonly sessionID: string
@@ -4509,7 +4418,7 @@ export type EventSubscribeOutput =
      readonly id: string
      readonly created: number
      readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "session.synthetic"
+      readonly type: "synthetic"
      readonly durable: { readonly aggregateID: string; readonly seq: number; readonly version: number }
      readonly location?: { readonly directory: string; readonly workspaceID?: string }
      readonly data: {
@@ -4523,7 +4432,7 @@ export type EventSubscribeOutput =
      readonly id: string
      readonly created: number
      readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "session.skill.activated"
+      readonly type: "skill.activated"
      readonly durable: { readonly aggregateID: string; readonly seq: number; readonly version: number }
      readonly location?: { readonly directory: string; readonly workspaceID?: string }
      readonly data: { readonly sessionID: string; readonly name: string; readonly text: string }
@@ -4532,59 +4441,25 @@ export type EventSubscribeOutput =
      readonly id: string
      readonly created: number
      readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "session.shell.started"
+      readonly type: "shell.started"
      readonly durable: { readonly aggregateID: string; readonly seq: number; readonly version: number }
      readonly location?: { readonly directory: string; readonly workspaceID?: string }
-      readonly data: {
-        readonly sessionID: string
-        readonly shell: {
-          readonly id: string
-          readonly status: "running" | "exited" | "timeout" | "killed"
-          readonly command: string
-          readonly cwd: string
-          readonly shell: string
-          readonly file: string
-          readonly pid?: number
-          readonly exit?: number
-          readonly metadata: { readonly [x: string]: unknown }
-          readonly time: { readonly started: number; readonly completed?: number }
-        }
-      }
+      readonly data: { readonly sessionID: string; readonly callID: string; readonly command: string }
    }
  | {
      readonly id: string
      readonly created: number
      readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "session.shell.ended"
+      readonly type: "shell.ended"
      readonly durable: { readonly aggregateID: string; readonly seq: number; readonly version: number }
      readonly location?: { readonly directory: string; readonly workspaceID?: string }
-      readonly data: {
-        readonly sessionID: string
-        readonly shell: {
-          readonly id: string
-          readonly status: "running" | "exited" | "timeout" | "killed"
-          readonly command: string
-          readonly cwd: string
-          readonly shell: string
-          readonly file: string
-          readonly pid?: number
-          readonly exit?: number
-          readonly metadata: { readonly [x: string]: unknown }
-          readonly time: { readonly started: number; readonly completed?: number }
-        }
-        readonly output: {
-          readonly output: string
-          readonly cursor: number
-          readonly size: number
-          readonly truncated: boolean
-        }
-      }
+      readonly data: { readonly sessionID: string; readonly callID: string; readonly output: string }
    }
  | {
      readonly id: string
      readonly created: number
      readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "session.step.started"
+      readonly type: "step.started"
      readonly durable: { readonly aggregateID: string; readonly seq: number; readonly version: number }
      readonly location?: { readonly directory: string; readonly workspaceID?: string }
      readonly data: {
@@ -4599,7 +4474,7 @@ export type EventSubscribeOutput =
      readonly id: string
      readonly created: number
      readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "session.step.ended"
+      readonly type: "step.ended"
      readonly durable: { readonly aggregateID: string; readonly seq: number; readonly version: number }
      readonly location?: { readonly directory: string; readonly workspaceID?: string }
      readonly data: {
@@ -4621,7 +4496,7 @@ export type EventSubscribeOutput =
      readonly id: string
      readonly created: number
      readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "session.step.failed"
+      readonly type: "step.failed"
      readonly durable: { readonly aggregateID: string; readonly seq: number; readonly version: number }
      readonly location?: { readonly directory: string; readonly workspaceID?: string }
      readonly data: {
@@ -4634,7 +4509,7 @@ export type EventSubscribeOutput =
      readonly id: string
      readonly created: number
      readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "session.text.started"
+      readonly type: "text.started"
      readonly durable: { readonly aggregateID: string; readonly seq: number; readonly version: number }
      readonly location?: { readonly directory: string; readonly workspaceID?: string }
      readonly data: { readonly sessionID: string; readonly assistantMessageID: string; readonly textID: string }
@@ -4643,7 +4518,7 @@ export type EventSubscribeOutput =
      readonly id: string
      readonly created: number
      readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "session.text.delta"
+      readonly type: "text.delta"
      readonly location?: { readonly directory: string; readonly workspaceID?: string }
      readonly data: {
        readonly sessionID: string
@@ -4656,7 +4531,7 @@ export type EventSubscribeOutput =
      readonly id: string
      readonly created: number
      readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "session.text.ended"
+      readonly type: "text.ended"
      readonly durable: { readonly aggregateID: string; readonly seq: number; readonly version: number }
      readonly location?: { readonly directory: string; readonly workspaceID?: string }
      readonly data: {
@@ -4670,7 +4545,7 @@ export type EventSubscribeOutput =
      readonly id: string
      readonly created: number
      readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "session.reasoning.started"
+      readonly type: "reasoning.started"
      readonly durable: { readonly aggregateID: string; readonly seq: number; readonly version: number }
      readonly location?: { readonly directory: string; readonly workspaceID?: string }
      readonly data: {
@@ -4684,7 +4559,7 @@ export type EventSubscribeOutput =
      readonly id: string
      readonly created: number
      readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "session.reasoning.delta"
+      readonly type: "reasoning.delta"
      readonly location?: { readonly directory: string; readonly workspaceID?: string }
      readonly data: {
        readonly sessionID: string
@@ -4697,7 +4572,7 @@ export type EventSubscribeOutput =
      readonly id: string
      readonly created: number
      readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "session.reasoning.ended"
+      readonly type: "reasoning.ended"
      readonly durable: { readonly aggregateID: string; readonly seq: number; readonly version: number }
      readonly location?: { readonly directory: string; readonly workspaceID?: string }
      readonly data: {
@@ -4712,7 +4587,7 @@ export type EventSubscribeOutput =
      readonly id: string
      readonly created: number
      readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "session.tool.input.started"
+      readonly type: "tool.input.started"
      readonly durable: { readonly aggregateID: string; readonly seq: number; readonly version: number }
      readonly location?: { readonly directory: string; readonly workspaceID?: string }
      readonly data: {
@@ -4726,7 +4601,7 @@ export type EventSubscribeOutput =
      readonly id: string
      readonly created: number
      readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "session.tool.input.delta"
+      readonly type: "tool.input.delta"
      readonly location?: { readonly directory: string; readonly workspaceID?: string }
      readonly data: {
        readonly sessionID: string
@@ -4739,7 +4614,7 @@ export type EventSubscribeOutput =
      readonly id: string
      readonly created: number
      readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "session.tool.input.ended"
+      readonly type: "tool.input.ended"
      readonly durable: { readonly aggregateID: string; readonly seq: number; readonly version: number }
      readonly location?: { readonly directory: string; readonly workspaceID?: string }
      readonly data: {
@@ -4753,7 +4628,7 @@ export type EventSubscribeOutput =
      readonly id: string
      readonly created: number
      readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "session.tool.called"
+      readonly type: "tool.called"
      readonly durable: { readonly aggregateID: string; readonly seq: number; readonly version: number }
      readonly location?: { readonly directory: string; readonly workspaceID?: string }
      readonly data: {
@@ -4772,7 +4647,7 @@ export type EventSubscribeOutput =
      readonly id: string
      readonly created: number
      readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "session.tool.progress"
+      readonly type: "tool.progress"
      readonly durable: { readonly aggregateID: string; readonly seq: number; readonly version: number }
      readonly location?: { readonly directory: string; readonly workspaceID?: string }
      readonly data: {
@@ -4790,7 +4665,7 @@ export type EventSubscribeOutput =
      readonly id: string
      readonly created: number
      readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "session.tool.success"
+      readonly type: "tool.success"
      readonly durable: { readonly aggregateID: string; readonly seq: number; readonly version: number }
      readonly location?: { readonly directory: string; readonly workspaceID?: string }
      readonly data: {
@@ -4814,7 +4689,7 @@ export type EventSubscribeOutput =
      readonly id: string
      readonly created: number
      readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "session.tool.failed"
+      readonly type: "tool.failed"
      readonly durable: { readonly aggregateID: string; readonly seq: number; readonly version: number }
      readonly location?: { readonly directory: string; readonly workspaceID?: string }
      readonly data: {
@@ -4833,7 +4708,7 @@ export type EventSubscribeOutput =
      readonly id: string
      readonly created: number
      readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "session.retried"
+      readonly type: "retried"
      readonly durable: { readonly aggregateID: string; readonly seq: number; readonly version: number }
      readonly location?: { readonly directory: string; readonly workspaceID?: string }
      readonly data: {
@@ -4853,7 +4728,7 @@ export type EventSubscribeOutput =
      readonly id: string
      readonly created: number
      readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "session.compaction.started"
+      readonly type: "compaction.started"
      readonly durable: { readonly aggregateID: string; readonly seq: number; readonly version: number }
      readonly location?: { readonly directory: string; readonly workspaceID?: string }
      readonly data: { readonly sessionID: string; readonly reason: "auto" | "manual" }
@@ -4862,7 +4737,7 @@ export type EventSubscribeOutput =
      readonly id: string
      readonly created: number
      readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "session.compaction.delta"
+      readonly type: "compaction.delta"
      readonly location?: { readonly directory: string; readonly workspaceID?: string }
      readonly data: { readonly sessionID: string; readonly text: string }
    }
@@ -4870,7 +4745,7 @@ export type EventSubscribeOutput =
      readonly id: string
      readonly created: number
      readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "session.compaction.ended"
+      readonly type: "compaction.ended"
      readonly durable: { readonly aggregateID: string; readonly seq: number; readonly version: number }
      readonly location?: { readonly directory: string; readonly workspaceID?: string }
      readonly data: {
@@ -4884,7 +4759,7 @@ export type EventSubscribeOutput =
      readonly id: string
      readonly created: number
      readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "session.revert.staged"
+      readonly type: "revert.staged"
      readonly durable: { readonly aggregateID: string; readonly seq: number; readonly version: number }
      readonly location?: { readonly directory: string; readonly workspaceID?: string }
      readonly data: {
@@ -4908,7 +4783,7 @@ export type EventSubscribeOutput =
      readonly id: string
      readonly created: number
      readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "session.revert.cleared"
+      readonly type: "revert.cleared"
      readonly durable: { readonly aggregateID: string; readonly seq: number; readonly version: number }
      readonly location?: { readonly directory: string; readonly workspaceID?: string }
      readonly data: { readonly sessionID: string }
@@ -4917,7 +4792,7 @@ export type EventSubscribeOutput =
      readonly id: string
      readonly created: number
      readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "session.revert.committed"
+      readonly type: "revert.committed"
      readonly durable: { readonly aggregateID: string; readonly seq: number; readonly version: number }
      readonly location?: { readonly directory: string; readonly workspaceID?: string }
      readonly data: { readonly sessionID: string; readonly messageID: string }
@@ -4926,9 +4801,9 @@ export type EventSubscribeOutput =
      readonly id: string
      readonly created: number
      readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "filesystem.changed"
+      readonly type: "file.edited"
      readonly location?: { readonly directory: string; readonly workspaceID?: string }
-      readonly data: { readonly file: string; readonly event: "add" | "change" | "unlink" }
+      readonly data: { readonly file: string }
    }
  | {
      readonly id: string
@@ -4974,14 +4849,6 @@ export type EventSubscribeOutput =
      readonly location?: { readonly directory: string; readonly workspaceID?: string }
      readonly data: { readonly id: string }
    }
-  | {
-      readonly id: string
-      readonly created: number
-      readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "plugin.updated"
-      readonly location?: { readonly directory: string; readonly workspaceID?: string }
-      readonly data: {}
-    }
  | {
      readonly id: string
      readonly created: number
@@ -5002,7 +4869,7 @@ export type EventSubscribeOutput =
      readonly id: string
      readonly created: number
      readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "config.updated"
+      readonly type: "skill.updated"
      readonly location?: { readonly directory: string; readonly workspaceID?: string }
      readonly data: {}
    }
@@ -5010,9 +4877,9 @@ export type EventSubscribeOutput =
      readonly id: string
      readonly created: number
      readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "skill.updated"
+      readonly type: "file.watcher.updated"
      readonly location?: { readonly directory: string; readonly workspaceID?: string }
-      readonly data: {}
+      readonly data: { readonly file: string; readonly event: "add" | "change" | "unlink" }
    }
  | {
      readonly id: string
@@ -6011,5 +5878,3 @@ export type VcsDiffOutput = {
    readonly status?: "added" | "deleted" | "modified"
  }>
 }
-
-export type DebugLocationOutput = ReadonlyArray<{ readonly directory: string; readonly workspaceID?: string }>
@@ -1,16 +1,3 @@
 export * from "./generated/index"
-export type {
-  AgentApi,
-  CatalogApi,
-  CommandApi,
-  EventApi,
-  IntegrationApi,
-  ModelApi,
-  PluginApi,
-  ProviderApi,
-  ReferenceApi,
-  SessionApi,
-  SkillApi,
-} from "./api.js"
 export type { EventSubscribeOutput as OpenCodeEvent } from "./generated/types"
 export type OpenCodeClient = ReturnType<typeof import("./generated/client").make>
@@ -1,10 +0,0 @@
-import { Effect } from "effect"
-import { OpenCode as EffectOpenCode, type AppApi as EffectApi } from "../src/effect"
-
-type EffectClient = Effect.Success<ReturnType<typeof EffectOpenCode.make>>
-
-declare const effectClient: EffectClient
-
-const effectApi: EffectApi<unknown> = effectClient
-
-void effectApi
@@ -45,9 +45,9 @@ test("event.subscribe exposes and decodes the native Effect event stream", async
    return yield* client.event.subscribe().pipe(Stream.runCollect)
  }).pipe(Effect.provideService(HttpClient.HttpClient, httpClient), Effect.runPromise)

-  expect(Array.from(events).map((event) => event.type)).toEqual(["server.connected", "session.model.selected"])
+  expect(Array.from(events).map((event) => event.type)).toEqual(["server.connected", "model.selected"])
  const durable = events[1]
-  if (durable?.type !== "session.model.selected") throw new Error("Expected model event")
+  if (durable?.type !== "model.selected") throw new Error("Expected model event")
  expect(DateTime.toEpochMillis(durable.created)).toBe(1_717_171_717_000)
  expect(durable.durable).toEqual({ aggregateID: "ses_test", seq: 1, version: 1 })
 })
@@ -159,8 +159,8 @@ test("session methods retain decoded Effect inputs and outputs", async () => {
  expect(result.context).toEqual([])
  expect(logQueries[0]).toEqual({ after: "0" })
  const logged = Array.from(result.log)
-  expect(logged.map((item) => item.type)).toEqual(["session.model.selected", "log.synced"])
-  expect(logged[0]?.type === "session.model.selected" && DateTime.toEpochMillis(logged[0].created)).toBe(
+  expect(logged.map((item) => item.type)).toEqual(["model.selected", "log.synced"])
+  expect(logged[0]?.type === "model.selected" && DateTime.toEpochMillis(logged[0].created)).toBe(
    1_717_171_717_000,
  )
  expect(logged.at(-1)).toEqual(synced)
@@ -228,7 +228,7 @@ const modelSwitchedMessage = {
 const modelSwitchedEvent = {
  id: "evt_model",
  created: 1_717_171_717_000,
-  type: "session.model.selected",
+  type: "model.selected",
  durable: { aggregateID: "ses_test", seq: 1, version: 1 },
  data: {
    sessionID: "ses_test",
@@ -30,9 +30,7 @@ test("exposes every standard HTTP API group", () => {
    "reference",
    "projectCopy",
    "vcs",
-    "debug",
  ])
-  expect(Object.keys(client.debug)).toEqual(["location"])
  expect(Object.keys(client.message)).toEqual(["list"])
  expect(Object.keys(client.integration)).toEqual([
    "list",
@@ -162,7 +160,7 @@ test("event.subscribe exposes the Promise event stream wire projection", async (
  for await (const event of client.event.subscribe()) events.push(event)

  expect(events).toEqual([{ id: "evt_connected", created: 0, type: "server.connected", data: {} }, modelSwitchedEvent])
-  expect(events[1]?.type === "session.model.selected" && events[1].created).toBe(1_717_171_717_000)
+  expect(events[1]?.type === "model.selected" && events[1].created).toBe(1_717_171_717_000)
 })

 test("event.subscribe terminates on malformed Promise SSE data", async () => {
@@ -331,7 +329,7 @@ const synced = { type: "log.synced", aggregateID: "ses_test", seq: 1 }
 const modelSwitchedEvent = {
  id: "evt_model",
  created: 1_717_171_717_000,
-  type: "session.model.selected",
+  type: "model.selected",
  durable: { aggregateID: "ses_test", seq: 1, version: 1 },
  data: {
    sessionID: "ses_test",
@@ -1,11 +0,0 @@
-{
-  "$schema": "https://json.schemastore.org/tsconfig",
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "rootDir": "src",
-    "outDir": "dist",
-    "noEmit": false,
-    "declaration": true
-  },
-  "include": ["src"]
-}
@@ -3,8 +3,6 @@
  "extends": "@tsconfig/bun/tsconfig.json",
  "compilerOptions": {
    "lib": ["ESNext", "DOM", "DOM.Iterable"],
-    "allowImportingTsExtensions": false,
-    "allowJs": false,
    "noUncheckedIndexedAccess": false
  },
  "include": ["src"]
@@ -5,14 +5,6 @@
 - Keep Code Mode unaware of host session, channel, and conversation models. The hosting application supplies trusted execution scope around it.
 - Tool schemas are the model-facing Interface. Keep arguments minimal and natural to the operation; never add unrelated IDs as ambient capability tokens.

-## OpenAPI
-
- Generate an operation only when its transport semantics are supported; otherwise return a precise `skipped` reason.
- Never guess parameter serialization or malformed security semantics. Unsupported serialization is skipped and malformed security fails closed.
- Render unresolved schema constructs as `unknown`, never as invented TypeScript names.
- Keep network reads bounded and map expected encoding, transport, and decoding failures to model-safe `ToolError` values.
- Test supported behavior directly; do not reproduce adapter algorithms in tests.
-
 ## Future Design Notes

 - If a captured user-visible output channel returns (an earlier `output.text`/`output.file`/`output.image` API was removed from v1), keep `output` as its name, distinct from the program return value: `return` stays the structured result for the model, while `output.*` describes artifacts the host may render into a conversation or UI after execution. Keep this host-neutral and let applications decide how captured output is delivered. In v1, hosts collect media host-side (outside the sandbox) instead.
@@ -4,7 +4,7 @@ Effect-native confined code execution over explicit, schema-described tools.

 CodeMode lets a model write a small JavaScript program that can call only the tools supplied by the host. The program can sequence calls, transform plain data, branch, loop, and run independent calls in parallel without receiving ambient filesystem, process, network, module, or application authority.

-The package is currently private to this workspace. Its API is designed around one-shot and reusable execution:
+The package is currently private to this workspace. Its API is designed around three uses:

 ```ts
 // One execution
@@ -13,6 +13,9 @@ yield * CodeMode.execute({ tools, code })
 // A reusable runtime
 const runtime = CodeMode.make({ tools, limits })
 yield * runtime.execute(code)
+
+// One agent-facing code tool
+const codeTool = runtime.agentTool()
 ```

 ## Install
@@ -60,7 +63,7 @@ const result =
 `)
 ```

-`result` is always a `CodeMode.Result`. Program, validation, limit, and tool failures are returned as diagnostics rather than failing the Effect. Host interruption remains interruption.
+`result` is always an `ExecuteResult`. Program, validation, limit, and tool failures are returned as diagnostics rather than failing the Effect. Host interruption remains interruption.

 Successful result values are JSON-safe data. A program that returns `undefined`, including by reaching the end without `return`, produces `null`; nested `undefined` values are normalized to `null` as well.

@@ -83,8 +86,6 @@ const tool = Tool.make({

 The description and schemas are part of the model-visible tool contract. Keep descriptions concrete and put authorization in `run` or in the service it calls.

-Public tool types are grouped under the same namespace: `Tool.Definition`, `Tool.Options`, `Tool.SchemaType`, and `Tool.JsonSchema`.
-
 ### `CodeMode.execute`

 Use `CodeMode.execute` for a single execution:
@@ -115,32 +116,31 @@ const runtime = CodeMode.make({

 runtime.catalog() // structured tool descriptions
 runtime.instructions() // model-facing syntax and tool guide
-runtime.execute(source) // CodeMode.Result
+runtime.execute(source) // ExecuteResult
+runtime.agentTool() // { name, description, input, output, execute }
 ```

-`CodeMode.Input`, `CodeMode.Result`, `CodeMode.Success`, `CodeMode.Failure`, `CodeMode.Diagnostic`, and `CodeMode.DiagnosticKind` are both Effect schemas and their inferred TypeScript types. Hosts can combine `CodeMode.Input` and `CodeMode.Result` with `runtime.instructions()` and `runtime.execute()` when constructing a framework-specific agent tool.
-
-All other CodeMode types use the same namespace: `CodeMode.Options`, `CodeMode.ExecuteOptions`, `CodeMode.Runtime`, `CodeMode.ExecutionLimits`, `CodeMode.DiscoveryOptions`, `CodeMode.DataValue`, `CodeMode.ToolDescription`, and the `CodeMode.ToolCall*` observation types.
+`catalog`, `instructions`, and `agentTool` are projections of the same configured tool tree. `agentTool().description` is exactly `instructions()`.

 ### Results

 ```ts
-type Result = Success | Failure
+type ExecuteResult = ExecuteSuccess | ExecuteFailure

-interface Success {
+interface ExecuteSuccess {
  readonly ok: true
-  readonly value: CodeMode.DataValue
+  readonly value: Schema.Json
  readonly logs?: ReadonlyArray<string>
  readonly truncated?: boolean
-  readonly toolCalls: ReadonlyArray<CodeMode.ToolCall>
+  readonly toolCalls: ReadonlyArray<ToolCall>
 }

-interface Failure {
+interface ExecuteFailure {
  readonly ok: false
-  readonly error: CodeMode.Diagnostic
+  readonly error: Diagnostic
  readonly logs?: ReadonlyArray<string>
  readonly truncated?: boolean
-  readonly toolCalls: ReadonlyArray<CodeMode.ToolCall>
+  readonly toolCalls: ReadonlyArray<ToolCall>
 }
 ```

@@ -152,31 +152,6 @@ interface Failure {

 `onToolCallEnd` receives `{ index, name, input, durationMs, outcome, message? }` when an admitted call settles. `outcome` is `"success"` or `"failure"`; `message` is the model-safe failure message and is present only on failure. Interrupted calls (for example when the execution timeout fires) do not produce an end event. Both hooks are Effect-returning and must not fail.

-### OpenAPI tools
-
-`OpenAPI.fromSpec` turns an OpenAPI 3.x document into a tool subtree - one tool per operation. Dotted `operationId` values form namespaces such as `v2.session.get`. Missing IDs receive a flat method/path fallback such as `getUsersById`; names are sanitized and deduplicated. The host places the subtree under a key in its `tools` tree; that key is the model-visible namespace.
-
-```ts
-import { CodeMode, OpenAPI } from "@opencode-ai/codemode"
-import { Effect } from "effect"
-import { FetchHttpClient } from "effect/unstable/http"
-
-const api = OpenAPI.fromSpec({
-  spec: await Bun.file("openapi.json").json(), // parsed document (no YAML)
-  auth: {
-    resolve: ({ name, scopes, operation }) =>
-      name === "BearerAuth" ? Effect.succeed({ type: "bearer", token }) : Effect.succeed(undefined),
-  },
-})
-
-const runtime = CodeMode.make({ tools: { opencode: api.tools } })
-const result = await Effect.runPromise(runtime.execute(code).pipe(Effect.provide(FetchHttpClient.layer)))
-```
-
-`fromSpec` is synchronous and returns `{ tools, skipped }`. The initial adapter supports query `form`/`deepObject`, path/header `simple`, JSON request bodies, JSON responses, and text responses; unsupported parameter encodings, non-JSON request bodies, binary responses, and streaming operations land in `skipped` instead of producing broken tools. Operation and path servers take precedence over document servers unless `baseUrl` explicitly overrides all of them. Tool inputs flatten path, query, header, and closed object-body fields into one model-facing object while retaining their HTTP locations internally. Cross-location name collisions receive a location prefix such as `path_id` and `query_id`; composed, nullable, dictionary, conditionally-required, and non-object JSON bodies remain under `body`. Auth is never model-visible. Responses are limited to 50 MiB, and non-2xx responses become safe tool failures carrying the status and a size-capped body summary. Deferred capabilities are tracked in `src/openapi/TODO.md`.
-
-Supported bearer, basic, header, and query authentication follows OpenAPI `security` semantics and is resolved host-side via `auth.resolve` - credential storage, OAuth flows, and token refresh never enter the compiler. Cookie authentication alternatives are discarded; an operation is skipped when it has no supported alternative. See the option docstrings in `src/openapi/types.ts` for the full semantics. Generated tools require `HttpClient.HttpClient` (from `effect/unstable/http`) in the Effect environment - provide `FetchHttpClient.layer` or a custom/test client layer at execution. The supplied client owns redirect policy; credentialed hosts should reject redirects or strip credentials when the origin changes.
-
 ## Discovery

 The agent-tool instructions use a budgeted catalog. Every tool namespace is always listed with its tool count regardless of budget, and as many complete tool signatures (each with a one-line description) as fit an estimated-token budget are inlined. Selection is round-robin across namespaces for fairness: in each round (namespaces alphabetical), every namespace still holding un-inlined tools attempts to place its next-cheapest signature line against the shared budget, and a namespace whose next line does not fit drops out while the others keep going - so every namespace gets some representation before any namespace gets everything. The instructions state exactly how comprehensive the list is, both overall (`COMPLETE list` vs `PARTIAL - N of M shown`) and per namespace (`(3 tools)`, `(3 tools, 1 shown)`, `(3 tools, none shown)`).
@@ -304,7 +279,7 @@ import { toolError } from "@opencode-ai/codemode"
 run: ({ id }) => (authorized(id) ? loadOrder(id) : Effect.fail(toolError("Order is unavailable")))
 ```

-Only the supplied message is model-visible. The optional cause is never returned in `CodeMode.Result`; hosts should perform any required internal logging before crossing this boundary.
+Only the supplied message is model-visible. The optional cause is never returned in `ExecuteResult`; hosts should perform any required internal logging before crossing this boundary.

 ## Authority Boundary

@@ -333,10 +308,12 @@ A program cannot gain authority through prose or generated code. It can only exe
 The public contract is guided by these equivalences:

 - `CodeMode.execute({ ...options, code })` is equivalent to `CodeMode.make(options).execute(code)`.
+- `CodeMode.make(options).agentTool().execute({ code })` is equivalent to `CodeMode.make(options).execute(code)`.
+- `CodeMode.make(options).agentTool().description` equals `CodeMode.make(options).instructions()`.
 - A tool implementation is not invoked unless its input has decoded successfully.
 - A tool result is not visible to the program unless its output has decoded and crossed the plain-data boundary successfully.
 - Unknown host failures do not become model-visible diagnostics; `ToolError` is the explicit safe-message channel.
- Host interruption remains interruption rather than a `CodeMode.Failure`.
+- Host interruption remains interruption rather than an `ExecuteFailure`.

 ## Non-Goals

@@ -220,9 +220,9 @@ wave; both packages typecheck clean.
  (render-only - no validation, values pass through; rendering handles `$defs`/`definitions`
  - `$ref`). `output` is **optional** -> signature renders `Promise<unknown>` and the host
    result is exposed as-is. Discrimination via `Schema.isSchema`. New helpers exported from
-    `tool-schema.ts`: `inputTypeScript`/`outputTypeScript`/`decodeInput`/`decodeOutput`/
+    `tool.ts`: `inputTypeScript`/`outputTypeScript`/`decodeInput`/`decodeOutput`/
    `jsonSchemaToTypeScript`; `tool-runtime.ts` consumes them (no direct `Schema.*` use there
-    anymore). Types `Tool.JsonSchema`/`Tool.SchemaType` exported from the index. Note: an empty
+    anymore). Types `JsonSchema`/`ToolSchema` exported from the index. Note: an empty
    `Schema.Struct({})` renders as `{  } | Array<unknown>` (effect's JSON Schema emission) -
    cosmetic, fixed in Wave 4.
 - **`output.*` API deleted**: `OutputItem`(+Schema), result `output` fields, the `output`
@@ -237,7 +237,7 @@ wave; both packages typecheck clean.
  so failures are typed and observable). `message` is the model-safe failure message
  (`ToolError`/`ToolRuntimeError` message, else "Tool execution failed"). Interrupted calls
  fire no end event (timeout kills the whole execution anyway).
- **Limits collapse**: public `CodeMode.ExecutionLimits` = `{ timeoutMs?, maxToolCalls?,
+- **Limits collapse**: public `ExecutionLimits` = `{ timeoutMs?, maxToolCalls?,
 maxOutputBytes? }` (defaults 10_000 / 100 / 32_000). This wave kept the other knobs as
  internal defaults reachable through an `@internal` `InternalExecutionLimits` type; Fix 5
  later deleted that type and the internal limit system entirely.
@@ -246,7 +246,7 @@ maxOutputBytes? }` (defaults 10_000 / 100 / 32_000). This wave kept the other kn
  serialized values become truncated text + ` [result truncated: N bytes exceeds the M-byte
 output limit; return a smaller value]`; logs keep leading lines within the remaining budget
  - `[logs truncated: showing K of N lines]`; result gains `truncated: true` (also added to
-    `CodeMode.Result`). UTF-8-safe truncation (no split code points). (The in-sandbox
+    `ExecuteResultSchema`). UTF-8-safe truncation (no split code points). (The in-sandbox
    `maxDataBytes` check that used to throw first on oversized raw values died in Fix 5 -
    truncation is now the only result-size mechanism.)
 - **Search polish**: default limit 12 -> **10** (`defaultSearchLimit`); exact-path lookup - a
@@ -313,7 +313,7 @@ real MCP config. Package still 101 tests / 0 fail; opencode adapter suites still
 packages typecheck clean.

 - **Budgeted catalog** (`discoveryPlan` in `tool-runtime.ts`): the all-or-nothing
-  inline/search modes are gone - `DiscoveryMode` deleted, `CodeMode.DiscoveryOptions` is just
+  inline/search modes are gone - `DiscoveryMode` deleted, `DiscoveryOptions` is just
  `{ maxInlineCatalogBytes? }` (default 16,000 UTF-8 bytes; later converted to
  `maxInlineCatalogTokens`, default 4,000 estimated tokens - see Post-wave fixes). Port of
  the old opencode
@@ -340,7 +340,7 @@ packages typecheck clean.
  read-the-description-before-calling guidance. (The flat prose layout this wave produced
  was later replaced wholesale by the markdown-section restructure - see Post-wave fixes -
  which also deleted this wave's worked example.)
- **Cosmetic renderer fixes** (`renderSchema` in `tool-schema.ts`): an object schema with no
+- **Cosmetic renderer fixes** (`renderSchema` in `tool.ts`): an object schema with no
  properties renders `{}` (was `{  }`), and the empty `Schema.Struct({})` emission
  (`anyOf: [{ type: "object" }, { type: "array" }]`, no properties/items) collapses to `{}`
  (was `{  } | Array<unknown>`).
@@ -469,7 +469,7 @@ adapter needed **no changes**.
    `rankTools` algorithm in `packages/opencode/src/session/code-mode.ts` at git HEAD),
    replacing the word-set ranker in `tool-runtime.ts`. Searchable text per tool = path +
    description + input-schema property names + their `description` strings - extracted by
-    the new `inputProperties` helper in `tool-schema.ts` (Effect Schemas via
+    the new `inputProperties` helper in `tool.ts` (Effect Schemas via
    `Schema.toJsonSchemaDocument`, the same emission signature rendering uses; JSON Schemas
    read `properties` directly, resolving a trivial top-level `$ref`; try/catch falls back to
    path + description). Queries tokenize on camelCase boundaries + non-alphanumeric
@@ -542,7 +542,7 @@ budget; namespaces must always be present):

 - `src/token.ts` added: copy of `@opencode-ai/core/util/token` (`round(chars / 4)`), so
  the package stays dependency-free; keep in sync if the core heuristic changes.
- `CodeMode.DiscoveryOptions.maxInlineCatalogBytes` -> `maxInlineCatalogTokens` (default 4,000
+- `DiscoveryOptions.maxInlineCatalogBytes` -> `maxInlineCatalogTokens` (default 4,000
  estimated tokens ~ the old 16,000 bytes at 4 chars/token - behavior parity, not a size
  reduction). `discoveryPlan` charges `estimate(catalogLine(tool))` per line; cheapest-first
  - stop-on-first-miss unchanged at the time (stop-on-first-miss replaced by round-robin in
@@ -558,7 +558,7 @@ budget; namespaces must always be present):
 **Fix 5 - internal limits removed** (user direction: only the three PUBLIC limits survive as
 configurable knobs; the internal limit system dies):

- `CodeMode.ExecutionLimits` (`timeoutMs` 10_000 / `maxToolCalls` 100 / `maxOutputBytes` 32_000 at
+- `ExecutionLimits` (`timeoutMs` 10_000 / `maxToolCalls` 100 / `maxOutputBytes` 32_000 at
  the time; Fix 6 later removed the first two defaults. Same validation: safe integers,
  timeoutMs >= 1, others >= 0, RangeError otherwise) is now
  the ENTIRE limit surface - exactly the shape section 2's original locked spec named.
@@ -575,7 +575,7 @@ configurable knobs; the internal limit system dies):
  `maxCollectionLength` (every array-length/object-field-count check - this knob was
  actively harmful: an MCP tool returning 20k rows failed). The `OperationLimitExceeded`
  and `AuditLimitExceeded` diagnostic kinds are gone from the `DiagnosticKind` union and
-  `CodeMode.Result` (fine - the package is unreleased).
+  `ExecuteResultSchema` (fine - the package is unreleased).
 - **Fixed constants, not knobs**: `TOOL_CALL_CONCURRENCY = 8` (codemode.ts; the fork
  semaphore) and `MAX_VALUE_DEPTH = 32` (tool-runtime.ts; the `copyIn` depth check - kept
  only because it produces a clearer error than a native stack-overflow RangeError; still
@@ -602,7 +602,7 @@ configurable knobs; the internal limit system dies):
  enumeration operation-budget, codemode maxDataBytes/maxSourceBytes/maxOperations/
  maxConcurrency-RangeError assertions, and the adapter's runaway-loop-via-operation-limit
  test - superseded by the package timeout regression test); rewrote the helpers that used
-  `InternalExecutionLimits` as a convenience to plain `CodeMode.ExecutionLimits`
+  `InternalExecutionLimits` as a convenience to plain `ExecutionLimits`
  (promise/enumeration/stdlib run helpers). Package suite: 154 pass / 0 fail; adapter
  suites: 34 + 16.

@@ -633,7 +633,7 @@ Semantics: each described input/output field carries its schema `description` as
 express surface as JSDoc tags - `@deprecated`, `@default <json>` (unserializable defaults
 skipped), `@format`, `@minItems`/`@maxItems`; `*/` inside text is neutralized to `* /`;
 multiline descriptions become `*`-prefixed blocks with blank edges trimmed; undescribed,
-untagged fields get no comment. Implementation: `renderSchema` in `tool-schema.ts` grew a
+untagged fields get no comment. Implementation: `renderSchema` in `tool.ts` grew a
 `RenderContext` (`{ definitions, pretty }`), a `MAX_RENDER_DEPTH = 8` recursion ceiling plus
 a `$ref` `seen` guard (the renderer previously had neither - a cyclic `$defs` would have
 looped; it now degrades to the ref name/`unknown`), and try/catch totality on the public
@@ -849,7 +849,7 @@ section 4 outer-truncation item the OPPOSITE way from "kill the outer one"):
  that relied on the old default now asserts the oversized result reaches the shared
  wrapper un-truncated. Suites: 210 + 50, tsgo clean both.

-**Docs polish** (post-API-review): stale `CodeMode.DiscoveryOptions` JSDoc fixed (claimed default
+**Docs polish** (post-API-review): stale `DiscoveryOptions` JSDoc fixed (claimed default
 4,000 and alphabetical cheapest-first - now 2,000 and round-robin, matching Fix 8/9 reality)
 and the README's incorrect "`effect` as a peer dependency" line corrected (`effect` is a
 regular dependency; hosts depend on it themselves because the API surface is Effect-typed).
@@ -949,16 +949,16 @@ child calls" gap):
 **Signature rendering + compound-assignment parity fixes** (externally reported, both
 verified real with failing tests before fixing):

- **Non-identifier property names in rendered signatures** (`src/tool-schema.ts`): `renderSchema`
+- **Non-identifier property names in rendered signatures** (`src/tool.ts`): `renderSchema`
  emitted raw property names, so schema properties like `foo-bar`/`@type`/`x.y`/`123`
  rendered invalid TypeScript (`{ foo-bar?: string }`). Fixed with a `renderKey` helper -
  bare identifiers stay bare, everything else is `JSON.stringify`-quoted - applied in the
  single `field` closure both the compact and pretty renderings share. The
-  `identifierSegment` regex now lives in `tool-schema.ts` (internal) and `tool-runtime.ts`'s
+  `identifierSegment` regex now lives in `tool.ts` (exported) and `tool-runtime.ts`'s
  bracket-notation `toolExpression` imports it: one source of truth for "is this a bare
  identifier" across object keys and tool paths. Tests: `signature.test.ts` +4 (compact,
  pretty with JSDoc on a quoted key, JSON Schema input+output, Effect Schema struct).
- **Numeric schema unions keep their real alternatives** (`src/tool-schema.ts`): the old
+- **Numeric schema unions keep their real alternatives** (`src/tool.ts`): the old
  `anyOf`/`oneOf` renderer collapsed any union containing `{ type: "number" }` to just
  `number`, dropping real JSON Schema alternatives (`string | number`, `number | null`,
  etc.). The collapse is now restricted to Effect's number-schema artifact
@@ -1132,12 +1132,6 @@ Post-MVP (logged, not blocking an experimental flag):
 - [ ] Reviewer observation worth keeping: MCP server instructions (`sys.mcp`,
      `session/system.ts:110-126`) still inject prose referencing server-native tool
      names that are no longer directly callable under code mode.
- [ ] Tool-tree path segments named `__proto__`, `constructor`, or `prototype` are included
-      in discovery but rejected by `ToolRuntime` resolution even when supplied as safe own
-      properties on null-prototype host records. Hosts should preserve registered names rather
-      than invent incompatible aliases. CodeMode should own a consistent policy: safely admit
-      these names as own tool-tree members, reject them before catalog generation with a clear
-      diagnostic, or define one canonical escaping contract.

 ### Backlog / loose ends (non-blocking, any order)

@@ -1209,8 +1203,7 @@ Post-MVP (logged, not blocking an experimental flag):
  the workspace is the implementation source of truth for v4 behavior questions.
 - File map (this package): `src/codemode.ts` - types/limits/parser/Interpreter/execute/make;
  `src/tool-runtime.ts` - tool tree, `copyIn`/`copyOut`, search/discovery, invoke path;
-  `src/tool.ts` - public `Tool` definitions; `src/tool-schema.ts` - schema rendering and decoding;
-  `src/values.ts` - sandbox value
+  `src/tool.ts` - `Tool.make` + JSON-Schema->TS rendering; `src/values.ts` - sandbox value
  types; `src/tool-error.ts` - `ToolError`; tests in `test/{codemode,parity,stdlib}.test.ts`.
 - OpenCode file map (integration points): `src/tool/code-mode.ts` (the adapter, now a
  registry tool service - `CodeModeTool` + `catalogInstructions`; formerly
@@ -19,7 +19,8 @@ import { ToolError } from "./tool-error.js"
 import { isSandboxValue, SandboxDate, SandboxMap, SandboxPromise, SandboxRegExp, SandboxSet } from "./values.js"

 /** A tool call admitted during an execution. */
-export type { ToolCall, ToolCallEnded, ToolCallHooks, ToolCallStarted, ToolDescription } from "./tool-runtime.js"
+export type { ToolCall, ToolCallStarted, ToolDescription } from "./tool-runtime.js"
+export { ToolError, toolError } from "./tool-error.js"

 /** Resource budgets enforced independently during each CodeMode program execution. */
 export type ExecutionLimits = {
@@ -73,20 +74,50 @@ export type ExecuteOptions<Tools extends Record<string, unknown> = {}> = {
  onToolCallEnd?: (call: ToolRuntime.ToolCallEnded) => Effect.Effect<void, never, Services<Tools>>
 }

+/** A normalized program diagnostic safe to return across an agent tool boundary. */
+export type Diagnostic = {
+  readonly kind: DiagnosticKind
+  readonly message: string
+  readonly location?: { readonly line: number; readonly column: number }
+  readonly suggestions?: ReadonlyArray<string>
+}
+
 /** A JSON value that can cross the confined interpreter boundary. */
 export type DataValue = Schema.Json

-/** Configuration shared by `CodeMode.make` and `CodeMode.execute`. */
-export type Options<Tools extends Record<string, unknown> = {}> = Omit<ExecuteOptions<Tools>, "code"> & {
+/** Successful execution after the result has crossed the plain-data boundary. */
+export type ExecuteSuccess = {
+  readonly ok: true
+  readonly value: DataValue
+  readonly logs?: ReadonlyArray<string>
+  /** Present when the value or logs were truncated to fit `maxOutputBytes`. */
+  readonly truncated?: boolean
+  readonly toolCalls: ReadonlyArray<ToolCall>
+}
+
+/** Failed execution with calls admitted before the diagnostic was produced. */
+export type ExecuteFailure = {
+  readonly ok: false
+  readonly error: Diagnostic
+  readonly logs?: ReadonlyArray<string>
+  /** Present when the logs were truncated to fit `maxOutputBytes`. */
+  readonly truncated?: boolean
+  readonly toolCalls: ReadonlyArray<ToolCall>
+}
+
+/** Result of executing a CodeMode program. Program failures are data, not Effect failures. */
+export type ExecuteResult = ExecuteSuccess | ExecuteFailure
+
+/** Reusable CodeMode configuration shared by `execute` and `agentTool`. */
+export type CodeModeOptions<Tools extends Record<string, unknown> = {}> = Omit<ExecuteOptions<Tools>, "code"> & {
  /** Progressive-disclosure configuration for the agent-facing tool catalog. */
  readonly discovery?: DiscoveryOptions
 }

-/** Schema for a host tool input containing CodeMode source. */
-export const Input = Schema.Struct({ code: Schema.String })
-export type Input = typeof Input.Type
+/** Input schema for the single agent-facing tool produced by `runtime.agentTool()`. */
+export const ExecuteInputSchema = Schema.Struct({ code: Schema.String })

-export const DiagnosticKind = Schema.Literals([
+const DiagnosticKindSchema = Schema.Literals([
  "ParseError",
  "UnsupportedSyntax",
  "UnknownTool",
@@ -98,52 +129,49 @@ export const DiagnosticKind = Schema.Literals([
  "ToolFailure",
  "ExecutionFailure",
 ])
-/** Stable categories produced by program, schema, tool, and limit failures. */
-export type DiagnosticKind = typeof DiagnosticKind.Type

-export const Diagnostic = Schema.Struct({
-  kind: DiagnosticKind,
-  message: Schema.String,
-  location: Schema.optionalKey(Schema.Struct({ line: Schema.Number, column: Schema.Number })),
-  suggestions: Schema.optionalKey(Schema.Array(Schema.String)),
-})
-/** A normalized program diagnostic safe to return across an agent tool boundary. */
-export type Diagnostic = typeof Diagnostic.Type
+/** Structured success or diagnostic result schema returned by CodeMode execution. */
+export const ExecuteResultSchema = Schema.Union([
+  Schema.Struct({
+    ok: Schema.Literal(true),
+    value: Schema.Json,
+    logs: Schema.optionalKey(Schema.Array(Schema.String)),
+    truncated: Schema.optionalKey(Schema.Boolean),
+    toolCalls: Schema.Array(Schema.Struct({ name: Schema.String })),
+  }),
+  Schema.Struct({
+    ok: Schema.Literal(false),
+    error: Schema.Struct({
+      kind: DiagnosticKindSchema,
+      message: Schema.String,
+      location: Schema.optionalKey(Schema.Struct({ line: Schema.Number, column: Schema.Number })),
+      suggestions: Schema.optionalKey(Schema.Array(Schema.String)),
+    }),
+    logs: Schema.optionalKey(Schema.Array(Schema.String)),
+    truncated: Schema.optionalKey(Schema.Boolean),
+    toolCalls: Schema.Array(Schema.Struct({ name: Schema.String })),
+  }),
+])

-const ToolCallSchema = Schema.Struct({ name: Schema.String })
-export const Success = Schema.Struct({
-  ok: Schema.Literal(true),
-  value: Schema.Json,
-  logs: Schema.optionalKey(Schema.Array(Schema.String)),
-  truncated: Schema.optionalKey(Schema.Boolean),
-  toolCalls: Schema.Array(ToolCallSchema),
-})
-/** Successful execution after the result has crossed the plain-data boundary. */
-export type Success = typeof Success.Type
-
-export const Failure = Schema.Struct({
-  ok: Schema.Literal(false),
-  error: Diagnostic,
-  logs: Schema.optionalKey(Schema.Array(Schema.String)),
-  truncated: Schema.optionalKey(Schema.Boolean),
-  toolCalls: Schema.Array(ToolCallSchema),
-})
-/** Failed execution with calls admitted before the diagnostic was produced. */
-export type Failure = typeof Failure.Type
-
-/** Schema for the structured success or diagnostic returned by CodeMode execution. */
-export const Result = Schema.Union([Success, Failure])
-/** Result of executing a CodeMode program. Program failures are data, not Effect failures. */
-export type Result = typeof Result.Type
+/** Agent-facing projection of a configured CodeMode runtime. */
+export type AgentToolDefinition<R = never> = {
+  readonly name: "code"
+  readonly description: string
+  readonly input: typeof ExecuteInputSchema
+  readonly output: typeof ExecuteResultSchema
+  readonly execute: (input: { readonly code: string }) => Effect.Effect<ExecuteResult, never, R>
+}

 /** Reusable confined runtime over one explicit tool tree. */
-export type Runtime<R = never> = {
+export type CodeModeRuntime<R = never> = {
  /** Lists schema-described tool paths provided by the host. */
  readonly catalog: () => ReadonlyArray<ToolDescription>
  /** Builds model-facing syntax guidance and visible tool signatures. */
  readonly instructions: () => string
+  /** Projects the configured runtime as one agent-facing `code` tool. */
+  readonly agentTool: () => AgentToolDefinition<R>
  /** Executes a program using this runtime's configured host tools. */
-  readonly execute: (code: string) => Effect.Effect<Result, never, R>
+  readonly execute: (code: string) => Effect.Effect<ExecuteResult, never, R>
 }

 type SourcePosition = {
@@ -258,6 +286,19 @@ const errorBrandName = (value: unknown): string | undefined =>
    ? ((value as Record<PropertyKey, unknown>)[ErrorBrand] as string | undefined)
    : undefined

+/** Stable categories produced by program, schema, tool, and limit failures. */
+export type DiagnosticKind =
+  | "ParseError"
+  | "UnsupportedSyntax"
+  | "UnknownTool"
+  | "InvalidToolInput"
+  | "InvalidToolOutput"
+  | "InvalidDataValue"
+  | "ToolCallLimitExceeded"
+  | "TimeoutExceeded"
+  | "ToolFailure"
+  | "ExecutionFailure"
+
 const arrayMethods = new Set([
  "map",
  "filter",
@@ -3913,7 +3954,7 @@ const executeWithLimits = <const Tools extends Record<string, unknown>>(
  options: ExecuteOptions<Tools>,
  limits: ResolvedExecutionLimits,
  searchIndex: ToolRuntime.DiscoveryPlan["searchIndex"],
-): Effect.Effect<Result, never, Services<Tools>> => {
+): Effect.Effect<ExecuteResult, never, Services<Tools>> => {
  const hooks = {
    ...(options.onToolCallStart === undefined ? {} : { onToolCallStart: options.onToolCallStart }),
    ...(options.onToolCallEnd === undefined ? {} : { onToolCallEnd: options.onToolCallEnd }),
@@ -3945,7 +3986,7 @@ const executeWithLimits = <const Tools extends Record<string, unknown>>(
      value: result,
      ...logged(),
      toolCalls: tools.calls,
-    } satisfies Result
+    } satisfies ExecuteResult
  }).pipe((program) => {
    const timeoutMs = limits.timeoutMs
    if (timeoutMs === undefined) return program
@@ -3958,7 +3999,7 @@ const executeWithLimits = <const Tools extends Record<string, unknown>>(
            error: { kind: "TimeoutExceeded", message: `Execution timed out after ${timeoutMs}ms.` },
            ...logged(),
            toolCalls: tools.calls,
-          } satisfies Result),
+          } satisfies ExecuteResult),
      }),
    )
  })
@@ -3972,7 +4013,7 @@ const executeWithLimits = <const Tools extends Record<string, unknown>>(
            error: normalizeError(Cause.squash(cause)),
            ...logged(),
            toolCalls: tools.calls,
-          } satisfies Result),
+          } satisfies ExecuteResult),
    ),
    Effect.map((result) => (limits.maxOutputBytes === undefined ? result : boundOutput(result, limits.maxOutputBytes))),
  )
@@ -3996,7 +4037,7 @@ const utf8Truncate = (value: string, maxBytes: number): string => {
 * fails the execution; `truncated: true` marks affected results. Only runs when the host set
 * `maxOutputBytes` - with the limit absent, output passes through unbounded.
 */
-const boundOutput = (result: Result, maxOutputBytes: number): Result => {
+const boundOutput = (result: ExecuteResult, maxOutputBytes: number): ExecuteResult => {
  let truncated = false

  let value: DataValue = null
@@ -4038,7 +4079,7 @@ const boundOutput = (result: Result, maxOutputBytes: number): Result => {

 export const execute = <const Tools extends Record<string, unknown>>(
  options: ExecuteOptions<Tools>,
-): Effect.Effect<Result, never, Services<Tools>> => {
+): Effect.Effect<ExecuteResult, never, Services<Tools>> => {
  const tools = (options.tools ?? {}) as HostTools<Services<Tools>>
  ToolRuntime.assertValidTools(tools)
  return executeWithLimits(options, resolveExecutionLimits(options.limits), ToolRuntime.searchIndex(tools))
@@ -4047,17 +4088,18 @@ export const execute = <const Tools extends Record<string, unknown>>(
 /**
 * Creates an Effect-native runtime over explicit, schema-described tools.
 *
- * Use `execute` for host-driven execution. Tool requirements remain in the returned Effect environment.
+ * Use `execute` for host-driven execution or `agentTool` to expose one confined code tool to an
+ * agent framework. Tool requirements remain in the returned Effect environment.
 *
 * @example
 * ```ts
 * const runtime = CodeMode.make({ tools: { orders: { lookup } } })
- * const result = runtime.execute("return await tools.orders.lookup({ id: 'order_42' })")
+ * const code = runtime.agentTool()
 * ```
 */
 export const make = <const Tools extends Record<string, unknown> = {}>(
-  options: Options<Tools> = {} as Options<Tools>,
-): Runtime<Services<Tools>> => {
+  options: CodeModeOptions<Tools> = {} as CodeModeOptions<Tools>,
+): CodeModeRuntime<Services<Tools>> => {
  const tools = (options.tools ?? {}) as HostTools<Services<Tools>>
  ToolRuntime.assertValidTools(tools)
  const limits = resolveExecutionLimits(options.limits)
@@ -4069,6 +4111,16 @@ export const make = <const Tools extends Record<string, unknown> = {}>(
  return {
    catalog: () => catalog,
    instructions: () => instructions,
+    agentTool: () => ({
+      name: "code",
+      description: instructions,
+      input: ExecuteInputSchema,
+      output: ExecuteResultSchema,
+      execute: ({ code }) => executeProgram(code),
+    }),
    execute: executeProgram,
  }
 }
+
+/** Constructors for one-shot and reusable CodeMode execution. */
+export const CodeMode = { make, execute }
@@ -1,4 +1,21 @@
-export * as CodeMode from "./codemode.js"
-export * as Tool from "./tool.js"
-export * as OpenAPI from "./openapi/index.js"
-export { ToolError, toolError } from "./tool-error.js"
+export { ToolError, CodeMode, ExecuteInputSchema, ExecuteResultSchema, toolError } from "./codemode.js"
+export { Tool } from "./tool.js"
+export type { Definition as ToolDefinition, JsonSchema, ToolSchema } from "./tool.js"
+export type { ToolCallEnded, ToolCallHooks } from "./tool-runtime.js"
+export type {
+  AgentToolDefinition,
+  CodeModeOptions,
+  CodeModeRuntime,
+  DataValue,
+  Diagnostic,
+  DiagnosticKind,
+  DiscoveryOptions,
+  ExecuteFailure,
+  ExecuteOptions,
+  ExecuteResult,
+  ExecuteSuccess,
+  ExecutionLimits,
+  ToolCall,
+  ToolCallStarted,
+  ToolDescription,
+} from "./codemode.js"
@@ -1,19 +0,0 @@
-# OpenAPI Follow-ups
-
-The initial adapter intentionally skips operations it cannot execute correctly. Future work may add:
-
- Cookie parameters, authentication, and cookie-header merging.
- Matrix, label, space-delimited, pipe-delimited, `allowReserved`, and parameter `content` serialization.
- External references and complete nested `$defs` support.
- Relative or templated server URLs and server variables.
- Base URLs containing query strings or fragments.
- Runtime response-schema validation and full content negotiation.
- Binary response values and explicit byte-oriented return types.
- Request/response projection for `readOnly` and `writeOnly` properties.
- SSE, WebSocket, and other streaming transports.
- Recovery of responses rejected by a status-filtering `HttpClient`.
- Configurable request and response size limits.
- Adapter-enforced redirect policy independent of the supplied `HttpClient`.
- Strict UTF-8 and empty-body validation for JSON responses.
- Compile-time rejection of parameter schemas with nested values unsupported by their serialization style; runtime rejects them before auth resolution.
- Complete malformed-security-scheme validation and broader auth-combination coverage.
@@ -1,130 +0,0 @@
-import { HttpClient } from "effect/unstable/http"
-import { make, type Definition } from "../tool.js"
-import { invoke } from "./runtime.js"
-import {
-  componentDefinitions,
-  inputSchema,
-  isRecord,
-  methods,
-  nonEmptyString,
-  operationInput,
-  operationOutput,
-  operationPath,
-  operationSecurityRequirements,
-  securityRequirements,
-  securitySchemes,
-  specServerUrl,
-  validateBaseUrl,
-} from "./spec.js"
-import type { Operation, Options, Result, Skipped, Tools } from "./types.js"
-
-export type {
-  AuthResolver,
-  Credential,
-  Document,
-  Operation,
-  Options,
-  Result,
-  SecurityScheme,
-  Skipped,
-  Tools,
-} from "./types.js"
-
-/**
- * Builds a CodeMode tool subtree from an OpenAPI 3.x document, one tool per
- * operation. Auth is resolved host-side via `auth.resolve` and never
- * model-visible. Tools require `HttpClient.HttpClient`; unrepresentable
- * operations land in `skipped`.
- */
-export const fromSpec = (options: Options): Result => {
-  const document = options.spec
-  const schemes = securitySchemes(document)
-  const defaultSecurity = securityRequirements(document.security)
-  const definitions = componentDefinitions(document)
-  const paths = isRecord(document.paths) ? document.paths : {}
-  const used = new Set<string>()
-  const namespaces = new Set<string>()
-  const skipped: Array<Skipped> = []
-  const tools = Object.create(null) as Tools
-
-  for (const [path, pathValue] of Object.entries(paths)) {
-    if (!isRecord(pathValue)) continue
-    for (const [method, operationValue] of Object.entries(pathValue)) {
-      if (!methods.has(method) || !isRecord(operationValue)) continue
-      const segments = operationPath(method, path, operationValue, used, namespaces)
-      const operation: Operation = {
-        operationId: nonEmptyString(operationValue.operationId),
-        method: method.toUpperCase(),
-        path,
-        summary: nonEmptyString(operationValue.summary),
-        description: nonEmptyString(operationValue.description),
-      }
-      const output = operationOutput(document, operationValue, definitions)
-      if (!output.ok) {
-        skipped.push({ method: operation.method, path, reason: output.reason })
-        continue
-      }
-
-      const resolvedBaseUrl = (() => {
-        if (options.baseUrl !== undefined) return validateBaseUrl(options.baseUrl)
-        if (operationValue.servers !== undefined) return specServerUrl(operationValue)
-        if (pathValue.servers !== undefined) return specServerUrl(pathValue)
-        return specServerUrl(document)
-      })()
-      if (!resolvedBaseUrl.ok) {
-        skipped.push({ method: operation.method, path, reason: resolvedBaseUrl.reason })
-        continue
-      }
-      const parsedInput = operationInput(document, pathValue, operationValue)
-      if (!parsedInput.ok) {
-        skipped.push({ method: operation.method, path, reason: parsedInput.reason })
-        continue
-      }
-      const input = parsedInput.value
-
-      const security = operationSecurityRequirements(operationValue.security, defaultSecurity, schemes)
-      if (!security.ok) {
-        skipped.push({ method: operation.method, path, reason: security.reason })
-        continue
-      }
-      const plan = {
-        operation,
-        url: `${resolvedBaseUrl.value.replace(/\/+$/, "")}${path}`,
-        fields: input.fields,
-        body: input.body,
-        security: security.value,
-        schemes,
-        auth: options.auth,
-        headers: options.headers ?? {},
-      }
-      used.add(segments.join("."))
-      for (const index of segments.slice(0, -1).keys()) namespaces.add(segments.slice(0, index + 1).join("."))
-      setTool(
-        tools,
-        segments,
-        make({
-          description: operation.description ?? operation.summary ?? `${operation.method} ${path}`,
-          input: inputSchema(input.fields, definitions),
-          output: output.value,
-          run: (input) => invoke(plan, input),
-        }),
-      )
-    }
-  }
-
-  return { tools, skipped }
-}
-
-const setTool = (tools: Tools, path: ReadonlyArray<string>, definition: Definition<HttpClient.HttpClient>): void => {
-  const [head, ...rest] = path
-  if (head === undefined) return
-  if (rest.length === 0) {
-    tools[head] = definition
-    return
-  }
-  const child = tools[head]
-  if (child === undefined || !isRecord(child) || child._tag === "CodeModeTool") {
-    tools[head] = Object.create(null) as Tools
-  }
-  setTool(tools[head] as Tools, rest, definition)
-}
@@ -1,324 +0,0 @@
-import { Effect, Option, Schema, Stream } from "effect"
-import { HttpClient, HttpClientRequest, HttpClientResponse, type HttpMethod } from "effect/unstable/http"
-import { ToolError, toolError } from "../tool-error.js"
-import { isRecord, own } from "./spec.js"
-import type { AppliedAuth, Credential, Plan, SecurityScheme } from "./types.js"
-
-const decodeJson = Schema.decodeUnknownOption(Schema.UnknownFromJsonString)
-const maxErrorBodyChars = 1_024
-const maxResponseBodyBytes = 50 * 1024 * 1024
-
-export const invoke = (plan: Plan, input: unknown): Effect.Effect<unknown, unknown, HttpClient.HttpClient> =>
-  Effect.gen(function* () {
-    const value = isRecord(input) ? input : {}
-
-    let request = yield* buildRequest(plan, value)
-
-    const auth = yield* resolveAuth(plan)
-    for (const [name, item] of Object.entries(auth.query)) {
-      request = HttpClientRequest.setUrlParam(request, name, item)
-    }
-    request = HttpClientRequest.setHeaders(request, auth.headers)
-
-    const client = yield* HttpClient.HttpClient
-    const response = yield* client
-      .execute(request)
-      .pipe(
-        Effect.catch((cause) =>
-          Effect.fail(toolError(`${plan.operation.method} ${plan.operation.path} failed: transport error`, cause)),
-        ),
-      )
-    const text = yield* readResponseBody(response, plan)
-    const mediaType = response.headers["content-type"]?.split(";")[0]?.trim().toLowerCase()
-    const json = mediaType === "application/json" || mediaType?.endsWith("+json") === true
-    const decoded = text === "" ? Option.some(null) : json ? decodeJson(text) : Option.none()
-    const parsed = json ? Option.getOrElse(decoded, () => text) : text === "" ? null : text
-    if (response.status < 200 || response.status >= 300) {
-      const rendered = typeof parsed === "string" ? parsed : (JSON.stringify(parsed) ?? "")
-      const summary =
-        rendered === "" || rendered === "null"
-          ? "no response body"
-          : rendered.length > maxErrorBodyChars
-            ? `${rendered.slice(0, maxErrorBodyChars)}...`
-            : rendered
-      return yield* Effect.fail(
-        toolError(`${plan.operation.method} ${plan.operation.path} failed with HTTP ${response.status}: ${summary}`),
-      )
-    }
-    if (json && Option.isNone(decoded)) {
-      return yield* Effect.fail(
-        toolError(`${plan.operation.method} ${plan.operation.path} returned malformed JSON.`),
-      )
-    }
-    return parsed
-  })
-
-const buildRequest = (
-  plan: Plan,
-  input: Readonly<Record<string, unknown>>,
-): Effect.Effect<HttpClientRequest.HttpClientRequest, ToolError> =>
-  Effect.gen(function* () {
-    // Validate every model-controlled value before auth resolution, which may refresh tokens.
-    const url = buildUrl(plan, input)
-    if (url instanceof ToolError) return yield* Effect.fail(url)
-    const missing = plan.fields.find(
-      (field) => field.required && field.location !== "path" && own(input, field.inputName) === undefined,
-    )
-    if (missing !== undefined) {
-      const label = missing.location === "body" ? "body field" : `${missing.location} parameter`
-      return yield* Effect.fail(toolError(`Missing required ${label} '${missing.inputName}'.`))
-    }
-
-    let request = HttpClientRequest.make(plan.operation.method as HttpMethod.HttpMethod)(url)
-    for (const field of plan.fields) {
-      if (field.location !== "query") continue
-      const item = own(input, field.inputName)
-      if (item === undefined) continue
-      const serialized = serializeQuery(request, field, item)
-      if (serialized instanceof ToolError) return yield* Effect.fail(serialized)
-      request = serialized
-    }
-
-    // Host headers first, then declared header parameters.
-    request = HttpClientRequest.setHeaders(request, plan.headers)
-    for (const field of plan.fields) {
-      if (field.location !== "header") continue
-      const item = own(input, field.inputName)
-      if (item === undefined) continue
-      const serialized = serializeSimple(field, item, String)
-      if (serialized instanceof ToolError) return yield* Effect.fail(serialized)
-      request = HttpClientRequest.setHeader(request, field.name, serialized)
-    }
-
-    const setBody = (value: unknown, mediaType: string) =>
-      HttpClientRequest.bodyJson(request, value).pipe(
-        Effect.map((next) => HttpClientRequest.setHeader(next, "content-type", mediaType)),
-        Effect.mapError((cause) =>
-          toolError(`Invalid JSON body for ${plan.operation.method} ${plan.operation.path}.`, cause),
-        ),
-      )
-    if (plan.body?.mode === "value") {
-      const field = plan.fields.find((field) => field.location === "body")
-      const body = field === undefined ? undefined : own(input, field.inputName)
-      if (body !== undefined) request = yield* setBody(body, plan.body.mediaType)
-    }
-    if (plan.body?.mode === "object") {
-      const entries = plan.fields.flatMap((field) => {
-        if (field.location !== "body") return []
-        const item = own(input, field.inputName)
-        return item === undefined ? [] : [[field.name, item] as const]
-      })
-      if (plan.body.required || entries.length > 0) {
-        request = yield* setBody(Object.fromEntries(entries), plan.body.mediaType)
-      }
-    }
-    return request
-  })
-
-const resolveAuth = (plan: Plan): Effect.Effect<AppliedAuth, unknown> =>
-  Effect.gen(function* () {
-    const none: AppliedAuth = { headers: {}, query: {} }
-    if (plan.security.length === 0) return none
-
-    const unavailable: Array<string> = []
-    alternatives: for (const requirement of plan.security) {
-      const names = Object.keys(requirement)
-      if (names.length === 0) return none
-      const credentials: Array<readonly [string, SecurityScheme, Credential]> = []
-      for (const name of names) {
-        const scheme = own(plan.schemes, name)
-        if (scheme === undefined || plan.auth === undefined) {
-          unavailable.push(name)
-          continue alternatives
-        }
-        const credential = yield* plan.auth.resolve({
-          name,
-          definition: scheme,
-          scopes: requirement[name] ?? [],
-          operation: plan.operation,
-        })
-        if (credential === undefined) {
-          unavailable.push(name)
-          continue alternatives
-        }
-        credentials.push([name, scheme, credential])
-      }
-      const applied = applyCredentials(credentials)
-      return applied instanceof ToolError ? yield* Effect.fail(applied) : applied
-    }
-
-    return yield* Effect.fail(
-      toolError(
-        `${plan.operation.method} ${plan.operation.path} requires authentication; no credential available for: ${[...new Set(unavailable)].join(", ")}.`,
-      ),
-    )
-  })
-
-const applyCredentials = (
-  credentials: ReadonlyArray<readonly [string, SecurityScheme, Credential]>,
-): AppliedAuth | ToolError => {
-  const headers = new Map<string, string>()
-  const query = new Map<string, string>()
-  const add = (carrier: "header" | "query", name: string, value: string): ToolError | undefined => {
-    const target = carrier === "header" ? headers : query
-    if (target.has(name)) return toolError(`Authentication resolves multiple credentials for ${carrier} '${name}'.`)
-    target.set(name, value)
-  }
-  for (const [name, definition, credential] of credentials) {
-    if (credential.type === "bearer") {
-      const duplicate = add("header", "authorization", `Bearer ${credential.token}`)
-      if (duplicate !== undefined) return duplicate
-      continue
-    }
-    if (credential.type === "basic") {
-      // Buffer instead of btoa: btoa throws on non-Latin-1 credentials.
-      const duplicate = add(
-        "header",
-        "authorization",
-        `Basic ${Buffer.from(`${credential.username}:${credential.password}`, "utf8").toString("base64")}`,
-      )
-      if (duplicate !== undefined) return duplicate
-      continue
-    }
-    if (credential.type === "header") {
-      const duplicate = add("header", credential.name.toLowerCase(), credential.value)
-      if (duplicate !== undefined) return duplicate
-      continue
-    }
-    // apiKey: the carrier comes from the scheme declaration.
-    if (definition.type !== "apiKey") {
-      return toolError(
-        `Security scheme '${name}' is not an apiKey scheme; resolve a bearer, basic, or header credential for it.`,
-      )
-    }
-    if (definition.in === "cookie") return toolError(`Cookie authentication '${name}' is not supported.`)
-    const parameter = definition.in === "header" ? definition.name.toLowerCase() : definition.name
-    const duplicate = add(definition.in, parameter, credential.value)
-    if (duplicate !== undefined) return duplicate
-  }
-  return { headers: Object.fromEntries(headers), query: Object.fromEntries(query) }
-}
-
-const buildUrl = (plan: Plan, input: Readonly<Record<string, unknown>>): string | ToolError => {
-  let url = plan.url
-  for (const field of plan.fields) {
-    if (field.location !== "path") continue
-    const item = own(input, field.inputName)
-    if (item === undefined) {
-      return toolError(`Missing required path parameter '${field.inputName}'.`)
-    }
-    const fieldValue = serializeSimple(field, item, (value) =>
-      encodeURIComponent(value).replace(/[!'()*]/g, (character) =>
-        `%${character.charCodeAt(0).toString(16).toUpperCase()}`,
-      ),
-    )
-    if (fieldValue instanceof ToolError) return fieldValue
-    // '.'/'..' survive encoding and URL normalization collapses them, letting a
-    // model-supplied value retarget the request to a different endpoint.
-    if (fieldValue === "" || fieldValue === "." || fieldValue === "..") {
-      return toolError(`Invalid path parameter '${field.inputName}'.`)
-    }
-    url = url.replaceAll(`{${field.name}}`, fieldValue)
-  }
-  const unresolved = url.match(/\{[^{}]+\}/)
-  if (unresolved !== null) return toolError(`Unresolved path parameter ${unresolved[0]}.`)
-  return url
-}
-
-const serializeSimple = (
-  field: Plan["fields"][number],
-  value: unknown,
-  encode: (value: string) => string,
-): string | ToolError => {
-  const scalar = (item: unknown): string | ToolError =>
-    item !== null && typeof item !== "string" && typeof item !== "number" && typeof item !== "boolean"
-      ? toolError(`Parameter '${field.inputName}' contains an unsupported nested value.`)
-      : encode(String(item))
-  if (Array.isArray(value)) {
-    const items = value.map(scalar)
-    const invalid = items.find((item): item is ToolError => item instanceof ToolError)
-    return invalid ?? items.join(",")
-  }
-  if (!isRecord(value)) return scalar(value)
-  const entries = Object.entries(value).flatMap<string | ToolError>(([name, item]) => {
-    const rendered = scalar(item)
-    if (rendered instanceof ToolError) return [rendered]
-    return field.explode ? [`${encode(name)}=${rendered}`] : [encode(name), rendered]
-  })
-  const invalid = entries.find((item): item is ToolError => item instanceof ToolError)
-  return invalid ?? entries.join(",")
-}
-
-const serializeQuery = (
-  request: HttpClientRequest.HttpClientRequest,
-  field: Plan["fields"][number],
-  value: unknown,
-): HttpClientRequest.HttpClientRequest | ToolError => {
-  if (field.style === "deepObject") {
-    if (!isRecord(value)) return toolError(`Deep-object parameter '${field.inputName}' must be an object.`)
-    return Object.entries(value).reduce<HttpClientRequest.HttpClientRequest | ToolError>((current, [name, item]) => {
-      if (current instanceof ToolError) return current
-      if (item === undefined || (item !== null && typeof item === "object")) {
-        return toolError(`Deep-object parameter '${field.inputName}' contains an unsupported nested value.`)
-      }
-      return HttpClientRequest.appendUrlParam(current, `${field.name}[${name}]`, String(item))
-    }, request)
-  }
-  if (Array.isArray(value)) {
-    const rendered = serializeSimple(field, value, String)
-    if (rendered instanceof ToolError) return rendered
-    if (!field.explode) return HttpClientRequest.appendUrlParam(request, field.name, rendered)
-    if (value.some((item) => item === undefined || (item !== null && typeof item === "object"))) {
-      return toolError(`Query parameter '${field.inputName}' contains an unsupported nested value.`)
-    }
-    return value.reduce(
-      (current, item) => HttpClientRequest.appendUrlParam(current, field.name, String(item)),
-      request,
-    )
-  }
-  if (isRecord(value) && field.explode) {
-    return Object.entries(value).reduce<HttpClientRequest.HttpClientRequest | ToolError>((current, [name, item]) => {
-      if (current instanceof ToolError) return current
-      if (item === undefined || (item !== null && typeof item === "object")) {
-        return toolError(`Query parameter '${field.inputName}' contains an unsupported nested value.`)
-      }
-      return HttpClientRequest.appendUrlParam(current, name, String(item))
-    }, request)
-  }
-  const rendered = serializeSimple(field, value, String)
-  return rendered instanceof ToolError ? rendered : HttpClientRequest.appendUrlParam(request, field.name, rendered)
-}
-
-const readResponseBody = (response: HttpClientResponse.HttpClientResponse, plan: Plan): Effect.Effect<string, ToolError> =>
-  Effect.gen(function* () {
-    const contentLength = response.headers["content-length"]
-    const parsedSize = contentLength === undefined ? undefined : Number.parseInt(contentLength, 10)
-    const declaredSize = parsedSize !== undefined && Number.isSafeInteger(parsedSize) && parsedSize >= 0 ? parsedSize : undefined
-    if (declaredSize !== undefined && declaredSize > maxResponseBodyBytes) {
-      return yield* Effect.fail(toolError(`${plan.operation.method} ${plan.operation.path} response exceeds 50 MiB.`))
-    }
-    let body = Buffer.allocUnsafe(Math.min(maxResponseBodyBytes, declaredSize ?? 64 * 1024))
-    let size = 0
-    yield* Stream.runForEach(response.stream, (chunk) => {
-      if (size + chunk.byteLength > maxResponseBodyBytes) {
-        return Effect.fail(toolError(`${plan.operation.method} ${plan.operation.path} response exceeds 50 MiB.`))
-      }
-      if (size + chunk.byteLength > body.byteLength) {
-        const grown = Buffer.allocUnsafe(Math.min(maxResponseBodyBytes, Math.max(size + chunk.byteLength, body.byteLength * 2)))
-        body.copy(grown, 0, 0, size)
-        body = grown
-      }
-      body.set(chunk, size)
-      size += chunk.byteLength
-      return Effect.void
-    }).pipe(
-      Effect.catch((cause) => {
-        if (cause instanceof ToolError) return Effect.fail(cause)
-        if (cause.reason._tag === "EmptyBodyError") return Effect.void
-        return Effect.fail(
-          toolError(`${plan.operation.method} ${plan.operation.path} failed while reading the response body.`, cause),
-        )
-      }),
-    )
-    return new TextDecoder().decode(body.subarray(0, size))
-  })
@@ -1,507 +0,0 @@
-import { fromSchemaOpenApi3_0, fromSchemaOpenApi3_1 } from "effect/JsonSchema"
-import type { JsonSchema } from "../tool.js"
-import { isBlockedMember } from "../tool-runtime.js"
-import type {
-  Body,
-  Document,
-  InputField,
-  OperationInput,
-  Parsed,
-  SecurityRequirement,
-  SecurityScheme,
-} from "./types.js"
-
-export const methods = new Set(["get", "put", "post", "delete", "options", "head", "patch", "trace"])
-const parameterLocations = ["path", "query", "header"] as const
-const ignoredHeaderParameters = new Set(["accept", "content-type", "authorization"])
-
-export const isRecord = (value: unknown): value is Record<string, unknown> =>
-  typeof value === "object" && value !== null && !Array.isArray(value)
-
-const asArray = (value: unknown): ReadonlyArray<unknown> => (Array.isArray(value) ? value : [])
-
-export const nonEmptyString = (value: unknown): string | undefined =>
-  typeof value === "string" && value !== "" ? value : undefined
-
-// Guards record lookups keyed by spec- or model-controlled names against
-// prototype-inherited values (e.g. a parameter named `toString`).
-export const own = <T>(record: Readonly<Record<string, T>>, key: string): T | undefined =>
-  Object.hasOwn(record, key) ? record[key] : undefined
-
-export const resolve = (document: Document, value: unknown): unknown => {
-  const next = (current: unknown, seen: ReadonlySet<string>): unknown => {
-    if (!isRecord(current)) return current
-    const ref = nonEmptyString(current.$ref)
-    if (ref === undefined || !ref.startsWith("#/") || seen.has(ref)) return current
-    const target = ref
-      .slice(2)
-      .split("/")
-      .map((segment) => segment.replaceAll("~1", "/").replaceAll("~0", "~"))
-      .reduce<unknown>((item, segment) => (isRecord(item) ? own(item, segment) : undefined), document)
-    return target === undefined ? current : next(target, new Set([...seen, ref]))
-  }
-  return next(value, new Set())
-}
-
-const projectSchema = (document: Document, value: unknown): JsonSchema => {
-  if (!isRecord(value)) return {}
-  const normalized = nonEmptyString(document.openapi)?.startsWith("3.0")
-    ? fromSchemaOpenApi3_0(value)
-    : fromSchemaOpenApi3_1(value)
-  return Object.keys(normalized.definitions).length === 0
-    ? normalized.schema
-    : { ...normalized.schema, $defs: normalized.definitions }
-}
-
-export const componentDefinitions = (document: Document): Readonly<Record<string, JsonSchema>> => {
-  const components = isRecord(document.components) ? document.components : {}
-  const schemas = isRecord(components.schemas) ? components.schemas : {}
-  return Object.fromEntries(Object.entries(schemas).map(([name, value]) => [name, projectSchema(document, value)]))
-}
-
-const withDefinitions = (schema: JsonSchema, definitions: Readonly<Record<string, JsonSchema>>): JsonSchema => {
-  if (Object.keys(definitions).length === 0) return schema
-  const local = isRecord(schema.$defs) ? schema.$defs : {}
-  return { ...schema, $defs: { ...definitions, ...local } }
-}
-
-const isJsonMediaType = (mediaType: string): boolean => {
-  const normalized = mediaType.split(";")[0]?.trim().toLowerCase() ?? ""
-  return normalized === "application/json" || normalized.endsWith("+json")
-}
-
-const isBinaryMediaType = (document: Document, mediaType: string, value: unknown): boolean => {
-  const normalized = mediaType.split(";")[0]?.trim().toLowerCase() ?? ""
-  if (!isJsonMediaType(normalized) && !normalized.startsWith("text/")) return true
-  if (!isRecord(value)) return false
-  const schema = resolve(document, value.schema)
-  return isRecord(schema) && schema.format === "binary"
-}
-
-const jsonContent = (content: Record<string, unknown>): { readonly mediaType: string; readonly schema: unknown } | undefined => {
-  const entry = Object.entries(content).find(([mediaType]) => isJsonMediaType(mediaType))
-  return entry !== undefined && isRecord(entry[1]) ? { mediaType: entry[0], schema: entry[1].schema } : undefined
-}
-
-const isFlattenableObjectBody = (
-  schema: unknown,
-  requestRequired: boolean,
-): schema is Record<string, unknown> & { readonly properties: Record<string, unknown> } =>
-  isRecord(schema) &&
-  requestRequired &&
-  schema.type === "object" &&
-  isRecord(schema.properties) &&
-  schema.additionalProperties === false &&
-  schema.nullable !== true &&
-  schema.allOf === undefined &&
-  schema.anyOf === undefined &&
-  schema.oneOf === undefined
-
-type PlannedField = Omit<InputField, "inputName">
-
-const operationParameters = (
-  document: Document,
-  pathItem: Record<string, unknown>,
-  operation: Record<string, unknown>,
-): Parsed<ReadonlyArray<PlannedField>> => {
-  // Operation-level parameters override path-level ones sharing (location, name).
-  const declared = new Map<
-    string,
-    { readonly name: string; readonly location: string; readonly parameter: Record<string, unknown> }
-  >()
-  for (const raw of [...asArray(pathItem.parameters), ...asArray(operation.parameters)]) {
-    const resolved = resolve(document, raw)
-    if (!isRecord(resolved)) return { ok: false, reason: "parameter declaration is invalid or unresolved" }
-    const name = nonEmptyString(resolved.name)
-    const location = nonEmptyString(resolved.in)
-    if (name === undefined || location === undefined)
-      return { ok: false, reason: "parameter declaration is missing name or location" }
-    declared.set(`${location}:${name}`, { name, location, parameter: resolved })
-  }
-  const unordered: Array<PlannedField> = []
-  for (const item of declared.values()) {
-    const name = item.name
-    const location = item.location
-    const resolved = item.parameter
-    if (location === "cookie") return { ok: false, reason: `cookie parameter '${name}' is not supported` }
-    if (location !== "path" && location !== "query" && location !== "header") {
-      return { ok: false, reason: `parameter '${name}' uses unsupported location '${location}'` }
-    }
-    if (location === "header" && ignoredHeaderParameters.has(name.toLowerCase())) continue
-    if (resolved.schema === undefined && resolved.content === undefined) {
-      return { ok: false, reason: `parameter '${name}' declares neither schema nor content` }
-    }
-    if (resolved.content !== undefined)
-      return { ok: false, reason: `parameter '${name}' uses unsupported content encoding` }
-    if (resolved.style !== undefined && nonEmptyString(resolved.style) === undefined) {
-      return { ok: false, reason: `parameter '${name}' has an invalid style` }
-    }
-    if (resolved.explode !== undefined && typeof resolved.explode !== "boolean") {
-      return { ok: false, reason: `parameter '${name}' has an invalid explode value` }
-    }
-    if (resolved.allowReserved !== undefined && typeof resolved.allowReserved !== "boolean") {
-      return { ok: false, reason: `parameter '${name}' has an invalid allowReserved value` }
-    }
-    if (resolved.allowReserved === true)
-      return { ok: false, reason: `parameter '${name}' uses unsupported allowReserved encoding` }
-    const declaredStyle = nonEmptyString(resolved.style) ?? (location === "query" ? "form" : "simple")
-    if (location === "query" && declaredStyle !== "form" && declaredStyle !== "deepObject") {
-      return { ok: false, reason: `query parameter '${name}' uses unsupported style '${declaredStyle}'` }
-    }
-    if (location !== "query" && declaredStyle !== "simple") {
-      return { ok: false, reason: `${location} parameter '${name}' uses unsupported style '${declaredStyle}'` }
-    }
-    const style = declaredStyle === "deepObject" ? "deepObject" : declaredStyle === "form" ? "form" : "simple"
-    const explode = typeof resolved.explode === "boolean" ? resolved.explode : style === "form"
-    if (style === "deepObject" && !explode) {
-      return { ok: false, reason: `query parameter '${name}' uses deepObject with explode=false` }
-    }
-    const base = projectSchema(document, resolved.schema)
-    const description = nonEmptyString(resolved.description)
-    unordered.push({
-      name,
-      location,
-      required: resolved.required === true || location === "path",
-      style,
-      explode,
-      schema: {
-        ...base,
-        ...(base.description === undefined && description !== undefined ? { description } : {}),
-      },
-    })
-  }
-  return {
-    ok: true,
-    value: parameterLocations.flatMap((location) => unordered.filter((field) => field.location === location)),
-  }
-}
-
-const operationBody = (
-  document: Document,
-  operation: Record<string, unknown>,
-): Parsed<{ readonly fields: ReadonlyArray<PlannedField>; readonly body: Body | undefined }> => {
-  const resolved = resolve(document, operation.requestBody)
-  if (!isRecord(resolved)) return { ok: true, value: { fields: [], body: undefined } }
-  const content = isRecord(resolved.content) ? resolved.content : {}
-  const selected = jsonContent(content)
-  if (selected === undefined) {
-    return {
-      ok: false,
-      reason: `request body has no JSON content (declared: ${Object.keys(content).join(", ") || "none"})`,
-    }
-  }
-  const schema = resolve(document, selected.schema)
-  const required = resolved.required === true
-  if (!isFlattenableObjectBody(schema, required)) {
-    return {
-      ok: true,
-      value: {
-        fields: [
-          {
-            name: "body",
-            location: "body",
-            required,
-            schema: projectSchema(document, selected.schema),
-            style: undefined,
-            explode: undefined,
-          },
-        ],
-        body: { required, mode: "value", mediaType: selected.mediaType },
-      },
-    }
-  }
-  const requiredProperties = new Set(
-    Array.isArray(schema.required) ? schema.required.filter((item): item is string => typeof item === "string") : [],
-  )
-  return {
-    ok: true,
-    value: {
-      fields: Object.entries(schema.properties).map(([name, value]) => ({
-        name,
-        location: "body" as const,
-        required: required && requiredProperties.has(name),
-        schema: projectSchema(document, value),
-        style: undefined,
-        explode: undefined,
-      })),
-      body: { required, mode: "object", mediaType: selected.mediaType },
-    },
-  }
-}
-
-export const operationInput = (
-  document: Document,
-  pathItem: Record<string, unknown>,
-  operation: Record<string, unknown>,
-): Parsed<OperationInput> => {
-  const parameters = operationParameters(document, pathItem, operation)
-  if (!parameters.ok) return parameters
-  const requestBody = operationBody(document, operation)
-  if (!requestBody.ok) return requestBody
-  const fields = [...parameters.value, ...requestBody.value.fields]
-
-  const conflicts = new Set(
-    [...Map.groupBy(fields, (field) => field.name)]
-      .filter(([, matches]) => new Set(matches.map((field) => field.location)).size > 1)
-      .map(([name]) => name),
-  )
-  const used = new Set<string>()
-  return {
-    ok: true,
-    value: {
-      fields: fields.map((field) => {
-        const visibleName = isBlockedMember(field.name) ? `${field.name}_2` : field.name
-        const base = conflicts.has(field.name) ? `${field.location}_${visibleName}` : visibleName
-        const next = (index: number): string => {
-          const candidate = index === 1 ? base : `${base}_${index}`
-          return used.has(candidate) ? next(index + 1) : candidate
-        }
-        const inputName = next(1)
-        used.add(inputName)
-        return { ...field, inputName }
-      }),
-      body: requestBody.value.body,
-    },
-  }
-}
-
-export const inputSchema = (
-  fields: ReadonlyArray<InputField>,
-  definitions: Readonly<Record<string, JsonSchema>>,
-): JsonSchema => {
-  const required = fields.filter((field) => field.required).map((field) => field.inputName)
-  return withDefinitions(
-    {
-      type: "object",
-      properties: Object.fromEntries(fields.map((field) => [field.inputName, field.schema])),
-      ...(required.length === 0 ? {} : { required }),
-    },
-    definitions,
-  )
-}
-
-const successfulResponses = (
-  document: Document,
-  operation: Record<string, unknown>,
-): Parsed<ReadonlyArray<Record<string, unknown>>> => {
-  if (!isRecord(operation.responses)) return { ok: true, value: [] }
-  const entries = Object.entries(operation.responses)
-  const selected = [
-    ...entries.filter(([status]) => /^2\d\d$/.test(status)).sort(([a], [b]) => a.localeCompare(b)),
-    ...entries.filter(([status]) => status.toUpperCase() === "2XX"),
-  ]
-  const responses: Array<Record<string, unknown>> = []
-  for (const [, value] of selected) {
-    const resolved = resolve(document, value)
-    if (!isRecord(resolved) || nonEmptyString(resolved.$ref) !== undefined) {
-      return { ok: false, reason: "successful response declaration is invalid or unresolved" }
-    }
-    responses.push(resolved)
-  }
-  return { ok: true, value: responses }
-}
-
-export const operationOutput = (
-  document: Document,
-  operation: Record<string, unknown>,
-  definitions: Readonly<Record<string, JsonSchema>>,
-): Parsed<JsonSchema | undefined> => {
-  if (operation["x-websocket"] === true) return { ok: false, reason: "WebSocket operations are not supported" }
-  const responses = successfulResponses(document, operation)
-  if (!responses.ok) return responses
-  const streams = responses.value.some(
-    (response) =>
-      isRecord(response.content) &&
-      Object.keys(response.content).some(
-        (mediaType) => mediaType.split(";")[0]?.trim().toLowerCase() === "text/event-stream",
-      ),
-  )
-  if (streams) return { ok: false, reason: "SSE operations are not supported" }
-  const binary = responses.value.some(
-    (response) =>
-      isRecord(response.content) &&
-      Object.entries(response.content).some(([mediaType, value]) => isBinaryMediaType(document, mediaType, value)),
-  )
-  if (binary) return { ok: false, reason: "binary responses are not supported" }
-
-  const outcomes: Array<JsonSchema> = []
-  for (const response of responses.value) {
-    if (response.content !== undefined && !isRecord(response.content)) return { ok: true, value: undefined }
-    const content = isRecord(response.content) ? response.content : {}
-    if (Object.keys(content).length === 0) {
-      outcomes.push({ type: "null" })
-      continue
-    }
-    for (const [mediaType, value] of Object.entries(content)) {
-      if (!isJsonMediaType(mediaType)) {
-        outcomes.push({ type: "string" })
-        continue
-      }
-      if (!isRecord(value) || value.schema === undefined) return { ok: true, value: undefined }
-      outcomes.push(projectSchema(document, value.schema))
-    }
-  }
-  if (outcomes.length === 0) return { ok: true, value: undefined }
-  return {
-    ok: true,
-    value: withDefinitions(outcomes.length === 1 ? outcomes[0] ?? {} : { anyOf: outcomes }, definitions),
-  }
-}
-
-const sanitizeOperationSegment = (raw: string): string => {
-  const base =
-    raw
-      .replaceAll(/[^A-Za-z0-9_$]+/g, "_")
-      .replace(/^_+|_+$/g, "")
-      .replace(/^([0-9])/, "_$1") || "operation"
-  return isBlockedMember(base) ? `${base}_2` : base
-}
-
-const fallbackOperationId = (method: string, path: string): string =>
-  [
-    method,
-    ...path
-      .split("/")
-      .filter((part) => part !== "")
-      .flatMap((part) => (part.startsWith("{") && part.endsWith("}") ? ["by", part.slice(1, -1)] : [part]))
-      .flatMap((part) => part.split(/[^A-Za-z0-9]+/).filter((word) => word !== "")),
-  ]
-    .map((word, index) => {
-      const lower = word.toLowerCase()
-      return index === 0 ? lower : `${lower.charAt(0).toUpperCase()}${lower.slice(1)}`
-    })
-    .join("")
-
-export const operationPath = (
-  method: string,
-  path: string,
-  operation: Record<string, unknown>,
-  used: ReadonlySet<string>,
-  namespaces: ReadonlySet<string>,
-): ReadonlyArray<string> => {
-  const raw = nonEmptyString(operation.operationId)
-  const segments = (raw === undefined ? [fallbackOperationId(method, path)] : raw.split(".")).map(sanitizeOperationSegment)
-  if (isOperationPathAvailable(segments, used, namespaces)) return segments
-  const conflict = segments.slice(0, -1).findIndex((_, index) => used.has(segments.slice(0, index + 1).join(".")))
-  if (conflict >= 0 && conflict + 1 < segments.length) {
-    const collapsed = segments.flatMap((segment, index) => {
-      if (index === conflict) {
-        const next = segments[index + 1] ?? ""
-        return [`${segment}${next.charAt(0).toUpperCase()}${next.slice(1)}`]
-      }
-      return index === conflict + 1 ? [] : [segment]
-    })
-    if (isOperationPathAvailable(collapsed, used, namespaces)) return collapsed
-  }
-  const fallback = segments.join("_")
-  const next = (index: number): string => {
-    const candidate = `${fallback}_${index}`
-    return isOperationPathAvailable([candidate], used, namespaces) ? candidate : next(index + 1)
-  }
-  return [next(2)]
-}
-
-const isOperationPathAvailable = (
-  segments: ReadonlyArray<string>,
-  used: ReadonlySet<string>,
-  namespaces: ReadonlySet<string>,
-): boolean => {
-  const key = segments.join(".")
-  if (used.has(key) || namespaces.has(key)) return false
-  return segments.slice(0, -1).every((_, index) => !used.has(segments.slice(0, index + 1).join(".")))
-}
-
-export const specServerUrl = (source: Record<string, unknown>): Parsed<string> => {
-  const server = asArray(source.servers).find(isRecord)
-  const url = server === undefined ? undefined : nonEmptyString(server.url)
-  if (url === undefined) return { ok: false, reason: "spec declares no servers; pass baseUrl" }
-  if (/\{[^{}]+\}/.test(url)) {
-    return { ok: false, reason: `server URL '${url}' is not an absolute URL; pass baseUrl` }
-  }
-  return validateBaseUrl(url)
-}
-
-export const validateBaseUrl = (value: string): Parsed<string> => {
-  if (!/^https?:\/\//i.test(value)) return { ok: false, reason: `server URL '${value}' is not an absolute HTTP(S) URL` }
-  const url = URL.parse(value)
-  if (url === null || (url.protocol !== "http:" && url.protocol !== "https:")) {
-    return { ok: false, reason: `server URL '${value}' is not an absolute HTTP(S) URL` }
-  }
-  if (url.search !== "" || url.hash !== "") {
-    return { ok: false, reason: `server URL '${value}' contains an unsupported query string or fragment` }
-  }
-  return { ok: true, value }
-}
-
-export const securityRequirements = (value: unknown): Parsed<ReadonlyArray<SecurityRequirement>> => {
-  if (value === undefined) return { ok: true, value: [] }
-  if (!Array.isArray(value)) return { ok: false, reason: "security declaration is not an array" }
-  const requirements: Array<SecurityRequirement> = []
-  for (const item of value) {
-    if (!isRecord(item)) return { ok: false, reason: "security requirement is not an object" }
-    const requirement = Object.create(null) as Record<string, ReadonlyArray<string>>
-    for (const [name, scopes] of Object.entries(item)) {
-      if (!Array.isArray(scopes)) return { ok: false, reason: "security requirement scopes are not string arrays" }
-      const parsed = scopes.filter((scope): scope is string => typeof scope === "string")
-      if (parsed.length !== scopes.length) {
-        return { ok: false, reason: "security requirement scopes are not string arrays" }
-      }
-      requirement[name] = parsed
-    }
-    requirements.push(requirement)
-  }
-  return { ok: true, value: requirements }
-}
-
-export const operationSecurityRequirements = (
-  value: unknown,
-  defaults: Parsed<ReadonlyArray<SecurityRequirement>>,
-  schemes: Readonly<Record<string, SecurityScheme>>,
-): Parsed<ReadonlyArray<SecurityRequirement>> => {
-  const parsed = value === undefined ? defaults : securityRequirements(value)
-  if (!parsed.ok) return parsed
-  const supported = parsed.value.filter((requirement) =>
-    Object.keys(requirement).every((name) => {
-      const scheme = own(schemes, name)
-      return scheme !== undefined && !(scheme.type === "apiKey" && scheme.in === "cookie")
-    }),
-  )
-  if (parsed.value.length === 0 || supported.length > 0) return { ok: true, value: supported }
-
-  const names = [...new Set(parsed.value.flatMap((requirement) => Object.keys(requirement)))]
-  const cookieScheme = names.find((name) => {
-    const definition = own(schemes, name)
-    return definition?.type === "apiKey" && definition.in === "cookie"
-  })
-  return {
-    ok: false,
-    reason:
-      cookieScheme === undefined
-        ? `security requirement references missing or malformed scheme: ${names.join(", ")}`
-        : `cookie authentication '${cookieScheme}' is not supported`,
-  }
-}
-
-export const securitySchemes = (document: Document): Readonly<Record<string, SecurityScheme>> => {
-  const components = isRecord(document.components) ? document.components : {}
-  const declared = isRecord(components.securitySchemes) ? components.securitySchemes : {}
-  return Object.fromEntries(
-    Object.entries(declared).flatMap<readonly [string, SecurityScheme]>(([name, value]) => {
-      const resolved = resolve(document, value)
-      if (!isRecord(resolved)) return []
-      const type = nonEmptyString(resolved.type)
-      if (type === "apiKey") {
-        const carrier = nonEmptyString(resolved.in)
-        const parameter = nonEmptyString(resolved.name)
-        if (parameter === undefined || (carrier !== "header" && carrier !== "query" && carrier !== "cookie")) return []
-        return [[name, { type, name: parameter, in: carrier }] as const]
-      }
-      if (type === "http") {
-        const scheme = nonEmptyString(resolved.scheme)?.toLowerCase()
-        return scheme === undefined ? [] : [[name, { type, scheme }] as const]
-      }
-      if (type === "oauth2" || type === "openIdConnect") return [[name, { type }] as const]
-      return []
-    }),
-  )
-}
@@ -1,112 +0,0 @@
-import { Effect } from "effect"
-import { HttpClient } from "effect/unstable/http"
-import type { Definition, JsonSchema } from "../tool.js"
-
-/** A parsed OpenAPI 3.x document. YAML must be parsed by the host. */
-export type Document = Record<string, unknown>
-
-/** The operation identity handed to auth resolution and errors. */
-export type Operation = {
-  readonly operationId: string | undefined
-  readonly method: string
-  readonly path: string
-  readonly summary: string | undefined
-  readonly description: string | undefined
-}
-
-/** A resolved OpenAPI security scheme from `components.securitySchemes`. */
-export type SecurityScheme =
-  | { readonly type: "apiKey"; readonly name: string; readonly in: "header" | "query" | "cookie" }
-  | { readonly type: "http"; readonly scheme: string }
-  | { readonly type: "oauth2" }
-  | { readonly type: "openIdConnect" }
-
-/**
- * Credential material returned by a host auth resolver. The carrier for `apiKey`
- * comes from the scheme definition, not the credential. `header` is the escape
- * hatch for nonstandard schemes.
- */
-export type Credential =
-  | { readonly type: "bearer"; readonly token: string }
-  | { readonly type: "basic"; readonly username: string; readonly password: string }
-  | { readonly type: "apiKey"; readonly value: string }
-  | { readonly type: "header"; readonly name: string; readonly value: string }
-
-/**
- * Resolves credential material for one named security scheme at call time.
- * `undefined` means unavailable, try the next OR alternative; a failure aborts
- * the call rather than falling through.
- */
-export type AuthResolver = (context: {
-  readonly name: string
-  readonly definition: SecurityScheme
-  readonly scopes: ReadonlyArray<string>
-  readonly operation: Operation
-}) => Effect.Effect<Credential | undefined, unknown>
-
-export type Options = {
-  readonly spec: Document
-  /** Overrides all document, path, and operation `servers`. Required when no applicable absolute server URL exists. */
-  readonly baseUrl?: string | undefined
-  /** Host credential resolution, keyed by security scheme name. */
-  readonly auth?: { readonly resolve: AuthResolver } | undefined
-  /** Static headers on every request. Not model-visible; declared header params may override them, auth always wins. */
-  readonly headers?: Readonly<Record<string, string>> | undefined
-}
-
-/** An operation that could not be represented as a tool, and why. */
-export type Skipped = {
-  readonly method: string
-  readonly path: string
-  readonly reason: string
-}
-
-export type Tools = { [name: string]: Definition<HttpClient.HttpClient> | Tools }
-
-export type Result = {
-  /** Tool subtree; the host places it under a key in its `tools` tree. */
-  readonly tools: Tools
-  readonly skipped: ReadonlyArray<Skipped>
-}
-
-export type Parsed<T> = { readonly ok: true; readonly value: T } | { readonly ok: false; readonly reason: string }
-
-export type InputLocation = "path" | "query" | "header" | "body"
-
-export type InputField = {
-  /** Model-visible field name after cross-location collision handling. */
-  readonly inputName: string
-  /** Original parameter or body-property name used on the wire. */
-  readonly name: string
-  readonly location: InputLocation
-  readonly required: boolean
-  readonly schema: JsonSchema
-  readonly style: "simple" | "form" | "deepObject" | undefined
-  readonly explode: boolean | undefined
-}
-
-export type Body = { readonly required: boolean; readonly mode: "object" | "value"; readonly mediaType: string }
-
-export type OperationInput = {
-  readonly fields: ReadonlyArray<InputField>
-  readonly body: Body | undefined
-}
-
-/** One OR alternative: scheme name -> required scopes. Empty object = unauthenticated is acceptable. */
-export type SecurityRequirement = Readonly<Record<string, ReadonlyArray<string>>>
-
-export type Plan = {
-  readonly operation: Operation
-  readonly url: string
-  readonly fields: ReadonlyArray<InputField>
-  readonly body: Body | undefined
-  readonly security: ReadonlyArray<SecurityRequirement>
-  readonly schemes: Readonly<Record<string, SecurityScheme>>
-  readonly auth: { readonly resolve: AuthResolver } | undefined
-  readonly headers: Readonly<Record<string, string>>
-}
-
-export type AppliedAuth = {
-  readonly headers: Readonly<Record<string, string>>
-  readonly query: Readonly<Record<string, string>>
-}
@@ -0,0 +1,10 @@
+/**
+ * Token estimation for budgeting model-facing text. Copied from
+ * `@opencode-ai/core/util/token` (chars / 4) so this package stays
+ * dependency-free; keep the two in sync if the heuristic ever changes.
+ */
+export * as Token from "./token.js"
+
+const CHARS_PER_TOKEN = 4
+
+export const estimate = (input: string) => Math.max(0, Math.round(input.length / CHARS_PER_TOKEN))
@@ -6,35 +6,31 @@ import {
  identifierSegment,
  inputProperties,
  inputTypeScript,
+  isDefinition as isToolDefinition,
  outputTypeScript,
-} from "./tool-schema.js"
-import { isDefinition as isToolDefinition, type Definition } from "./tool.js"
+  type Definition,
+} from "./tool.js"
+import { estimate } from "./token.js"
 import { SandboxDate, SandboxMap, SandboxPromise, SandboxRegExp, SandboxSet } from "./values.js"

-const estimateTokens = (input: string) => Math.max(0, Math.round(input.length / 4))
-
 export type HostTool<R = never> = (...args: Array<unknown>) => Effect.Effect<unknown, unknown, R>

 export type HostTools<R = never> = {
  [name: string]: HostTool<R> | Definition<R> | HostTools<R>
 }

-export type Services<Tools> = ServicesOf<Tools, []>
-
-type ServicesOf<Tools, Depth extends ReadonlyArray<unknown>> = Depth["length"] extends 8
-  ? never
-  : Tools extends (...args: Array<unknown>) => Effect.Effect<unknown, unknown, infer R>
+export type Services<Tools> = Tools extends (...args: Array<unknown>) => Effect.Effect<unknown, unknown, infer R>
+  ? R
+  : Tools extends {
+        readonly _tag: "CodeModeTool"
+        readonly run: (input: unknown) => Effect.Effect<unknown, unknown, infer R>
+      }
    ? R
-    : Tools extends {
-          readonly _tag: "CodeModeTool"
-          readonly run: (input: unknown) => Effect.Effect<unknown, unknown, infer R>
-        }
-      ? R
-      : Tools extends object
-        ? string extends keyof Tools
-          ? ServicesOf<Tools[string], [...Depth, unknown]>
-          : ServicesOf<Tools[keyof Tools], [...Depth, unknown]>
-        : never
+    : Tools extends object
+      ? string extends keyof Tools
+        ? never
+        : Services<Tools[keyof Tools]>
+      : never

 /** Minimal audit record retained for each admitted tool call. */
 export type ToolCall = {
@@ -294,16 +290,17 @@ const definitions = <R>(
  return entries
 }

+const describeDefinition = <R>(path: string, definition: Definition<R>): ToolDescription => ({
+  path,
+  description: definition.description,
+  signature: `${toolExpression(path)}(input: ${inputTypeScript(definition)}): Promise<${outputTypeScript(definition)}>`,
+})
+
 const visibleDefinitions = <R>(tools: HostTools<R>) =>
-  definitions(tools).map(({ path, definition }) => ({
-    path,
-    definition,
-    description: {
-      path,
-      description: definition.description,
-      signature: `${toolExpression(path)}(input: ${inputTypeScript(definition)}): Promise<${outputTypeScript(definition)}>`,
-    },
-  }))
+  definitions(tools).flatMap(({ path, definition }) => {
+    const description = describeDefinition(path, definition)
+    return [{ path, definition, description }]
+  })

 export const catalog = <R>(tools: HostTools<R>): ReadonlyArray<ToolDescription> =>
  visibleDefinitions(tools).map(({ description }) => description)
@@ -354,10 +351,16 @@ const termForms = (term: string): Array<string> => {
  return forms
 }

+const firstLine = (text: string) => text.split("\n", 1)[0]!.trim()
+
+/** One-line description used on inline catalog lines; the full text stays in search results. */
+const brief = (text: string, max = 120) => {
+  const line = firstLine(text)
+  return line.length > max ? line.slice(0, max - 1) + "..." : line
+}
+
 const catalogLine = (tool: ToolDescription) => {
-  // Inline catalog lines use only a compact first line; full text stays in search results.
-  const line = tool.description.split("\n", 1)[0]!.trim()
-  const description = line.length > 120 ? line.slice(0, 119) + "..." : line
+  const description = brief(tool.description)
  return description === "" ? `  - ${tool.signature}` : `  - ${tool.signature} // ${description}`
 }

@@ -427,7 +430,7 @@ export const discoveryPlan = <R>(
    picked: new Set<ToolDescription>(),
    queue: [...group].sort(
      (left, right) =>
-        estimateTokens(catalogLine(left)) - estimateTokens(catalogLine(right)) || left.path.localeCompare(right.path),
+        estimate(catalogLine(left)) - estimate(catalogLine(right)) || left.path.localeCompare(right.path),
    ),
  }))
  let used = 0
@@ -436,7 +439,7 @@ export const discoveryPlan = <R>(
    const stillActive: typeof active = []
    for (const selection of active) {
      const tool = selection.queue[0]!
-      const cost = estimateTokens(catalogLine(tool))
+      const cost = estimate(catalogLine(tool))
      if (used + cost > maxInlineCatalogTokens) continue
      selection.queue.shift()
      selection.picked.add(tool)
@@ -633,6 +636,9 @@ export type ToolRuntime<R = never> = {
  readonly keys: (path: ReadonlyArray<string>) => ReadonlyArray<string>
 }

+const failureMessage = (error: unknown): string =>
+  error instanceof ToolError || error instanceof ToolRuntimeError ? error.message : "Tool execution failed"
+
 export const make = <R>(
  tools: HostTools<R>,
  /** Undefined means unlimited tool calls. */
@@ -651,16 +657,9 @@ export const make = <R>(
    const startedAt = Date.now()
    return effect.pipe(
      Effect.tap(() => onEnd({ ...call, durationMs: Date.now() - startedAt, outcome: "success" })),
-      Effect.tapError((error) => {
-        const message =
-          error instanceof ToolError || error instanceof ToolRuntimeError ? error.message : "Tool execution failed"
-        return onEnd({
-          ...call,
-          durationMs: Date.now() - startedAt,
-          outcome: "failure",
-          message,
-        })
-      }),
+      Effect.tapError((error) =>
+        onEnd({ ...call, durationMs: Date.now() - startedAt, outcome: "failure", message: failureMessage(error) }),
+      ),
    )
  }

@@ -1,301 +0,0 @@
-import { JsonPointer, Schema } from "effect"
-import type { Definition, JsonSchema, SchemaType } from "./tool.js"
-
-const isEffectSchema = (schema: SchemaType): schema is Schema.Decoder<unknown> & Schema.Top => Schema.isSchema(schema)
-
-const renderLiteral = (value: unknown): string => JSON.stringify(value) ?? "unknown"
-
-/**
- * Bare TypeScript identifier - usable unquoted as an object key (and, in the tool runtime,
- * with dot access as a tool-path segment). Anything else must be quoted/bracketed.
- */
-export const identifierSegment = /^[A-Za-z_$][A-Za-z0-9_$]*$/
-
-/** Renders a property name as a valid TS object key: bare when an identifier, quoted otherwise. */
-const renderKey = (name: string): string => (identifierSegment.test(name) ? name : JSON.stringify(name))
-
-const effectNumberSentinel = (schema: JsonSchema) =>
-  schema.type === "string" &&
-  Array.isArray(schema.enum) &&
-  schema.enum.length === 1 &&
-  (schema.enum[0] === "NaN" || schema.enum[0] === "Infinity" || schema.enum[0] === "-Infinity")
-
-const intersection = (members: ReadonlyArray<string>): string => {
-  const concrete = members.filter((member) => member !== "unknown")
-  if (concrete.length === 0) return "unknown"
-  if (concrete.length === 1) return concrete[0] ?? "unknown"
-  return concrete.map((member) => (member.includes(" | ") ? `(${member})` : member)).join(" & ")
-}
-
-/**
- * Recursion ceiling for schema rendering. Object, array, and union recursion all increment
- * depth, so this bounds every recursion path - pathological or structurally cyclic schemas
- * degrade to `unknown` instead of overflowing the stack (rendering must never throw).
- */
-const MAX_RENDER_DEPTH = 8
-
-type RenderContext = {
-  readonly definitions: Readonly<Record<string, JsonSchema>>
-  /** Indented, JSDoc-annotated multiline rendering (search results); compact single line otherwise. */
-  readonly pretty: boolean
-}
-
-const hasUnresolvedRef = (
-  schema: JsonSchema,
-  definitions: Readonly<Record<string, JsonSchema>>,
-  seen: ReadonlySet<string> = new Set(),
-  visited: ReadonlySet<JsonSchema> = new Set(),
-): boolean => {
-  if (visited.has(schema)) return false
-  const nextVisited = new Set([...visited, schema])
-  if (schema.$ref !== undefined) {
-    const segment = schema.$ref.match(/^#\/(?:\$defs|definitions)\/([^/]+)$/)?.[1]
-    const name = segment === undefined ? undefined : JsonPointer.unescapeToken(segment)
-    if (name === undefined || definitions[name] === undefined || seen.has(name)) return true
-    if (hasUnresolvedRef(definitions[name], definitions, new Set([...seen, name]), nextVisited)) return true
-  }
-  return [
-    ...(schema.anyOf ?? []),
-    ...(schema.oneOf ?? []),
-    ...(schema.allOf ?? []),
-    ...Object.values(schema.properties ?? {}),
-    ...(schema.items === undefined ? [] : [schema.items]),
-    ...(typeof schema.additionalProperties === "object" ? [schema.additionalProperties] : []),
-  ].some((item) => hasUnresolvedRef(item, definitions, seen, nextVisited))
-}
-
-/**
- * Schema constraints a TypeScript type cannot express natively but a model benefits from,
- * surfaced as JSDoc tags (`@deprecated`, `@default`, `@format`, `@minItems`, `@maxItems`).
- */
-const docTags = (schema: JsonSchema): Array<string> => {
-  const tags: Array<string> = []
-  if (schema.deprecated === true) tags.push("@deprecated")
-  if (schema.default !== undefined) {
-    try {
-      const rendered = JSON.stringify(schema.default)
-      if (rendered !== undefined) tags.push(`@default ${rendered}`)
-    } catch {
-      // unserializable default: skip rather than emit a broken tag
-    }
-  }
-  if (typeof schema.format === "string") tags.push(`@format ${schema.format}`)
-  if (typeof schema.minItems === "number") tags.push(`@minItems ${schema.minItems}`)
-  if (typeof schema.maxItems === "number") tags.push(`@maxItems ${schema.maxItems}`)
-  return tags
-}
-
-/**
- * Format a schema `description` plus `tags` as a JSDoc comment at the given indent,
- * preserving multi-line text (a single line stays `/** ... *\/`; multiple lines become a
- * `*`-prefixed block). `*\/` is neutralized so nothing can close the comment early, and
- * blank leading/trailing lines are trimmed. Returns "" (else a trailing newline) so
- * callers can prepend it directly to the field line.
- */
-const jsdoc = (description: string | undefined, tags: ReadonlyArray<string>, pad: string): string => {
-  const lines = [...(description === undefined ? [] : description.split("\n")), ...tags].map((line) =>
-    line.replaceAll("*/", "* /").replace(/\s+$/, ""),
-  )
-  while (lines.length > 0 && lines[0]!.trim() === "") lines.shift()
-  while (lines.length > 0 && lines[lines.length - 1]!.trim() === "") lines.pop()
-  if (lines.length === 0) return ""
-  if (lines.length === 1) return `${pad}/** ${lines[0]} */\n`
-  const body = lines.map((line) => `${pad} *${line === "" ? "" : ` ${line}`}`).join("\n")
-  return `${pad}/**\n${body}\n${pad} */\n`
-}
-
-const renderSchema = (
-  schema: JsonSchema,
-  ctx: RenderContext,
-  depth = 0,
-  seen: ReadonlySet<string> = new Set(),
-): string => {
-  if (depth > MAX_RENDER_DEPTH) return "unknown"
-  const nested =
-    schema.definitions === undefined && schema.$defs === undefined
-      ? ctx
-      : { ...ctx, definitions: { ...ctx.definitions, ...(schema.definitions ?? {}), ...(schema.$defs ?? {}) } }
-  if (schema.$ref) {
-    const segment = schema.$ref.match(/^#\/(?:\$defs|definitions)\/([^/]+)$/)?.[1]
-    const name = segment === undefined ? undefined : JsonPointer.unescapeToken(segment)
-    if (!name || !nested.definitions[name] || seen.has(name)) return "unknown"
-    return intersection([
-      renderSchema(nested.definitions[name], nested, depth, new Set([...seen, name])),
-      renderSchema({ ...schema, $ref: undefined }, nested, depth + 1, seen),
-    ])
-  }
-  if (schema.const !== undefined) return renderLiteral(schema.const)
-  if (schema.enum) return schema.enum.map(renderLiteral).join(" | ")
-  const alternatives = schema.anyOf ?? schema.oneOf
-  if (alternatives) {
-    // Effect's number schema emits `anyOf: [{ type: "number" }, { const: "NaN" },
-    // { const: "Infinity" }, { const: "-Infinity" }]`. Collapse only that artifact;
-    // real JSON Schema unions such as `string | number` or `number | null` must keep
-    // every branch.
-    if (
-      alternatives.some((item) => item.type === "number") &&
-      alternatives.every((item) => item.type === "number" || effectNumberSentinel(item))
-    )
-      return "number"
-    // An empty Schema.Struct({}) emits `anyOf: [{ type: "object" }, { type: "array" }]`
-    // (no properties/items); render the bare shape as {} instead of `{} | Array<unknown>`.
-    if (
-      alternatives.length === 2 &&
-      alternatives[0]?.type === "object" &&
-      alternatives[0].properties === undefined &&
-      alternatives[1]?.type === "array" &&
-      alternatives[1].items === undefined
-    ) {
-      return "{}"
-    }
-    const members = alternatives.map((item) => renderSchema(item, nested, depth + 1, seen))
-    if (members.some((member) => member === "unknown")) return "unknown"
-    return intersection([
-      members.join(" | "),
-      renderSchema({ ...schema, anyOf: undefined, oneOf: undefined }, nested, depth + 1, seen),
-    ])
-  }
-  if (schema.allOf) {
-    const members = schema.allOf.map((item) => renderSchema(item, nested, depth + 1, seen))
-    if (schema.allOf.some((item) => hasUnresolvedRef(item, nested.definitions))) return "unknown"
-    return intersection([renderSchema({ ...schema, allOf: undefined }, nested, depth + 1, seen), ...members])
-  }
-  if (Array.isArray(schema.type)) {
-    return schema.type.map((item) => renderSchema({ ...schema, type: item }, nested, depth + 1, seen)).join(" | ")
-  }
-  if (schema.type === "string") return "string"
-  if (schema.type === "number" || schema.type === "integer") return "number"
-  if (schema.type === "boolean") return "boolean"
-  if (schema.type === "null") return "null"
-  if (schema.type === "array") return `Array<${renderSchema(schema.items ?? {}, nested, depth + 1, seen)}>`
-  if (schema.type === "object" || schema.properties) {
-    const required = new Set(schema.required ?? [])
-    const properties = Object.entries(schema.properties ?? {})
-    const additional = schema.additionalProperties
-    const indexType =
-      additional && typeof additional === "object" ? renderSchema(additional, nested, depth + 1, seen) : undefined
-    const field = ([name, value]: readonly [string, JsonSchema]) =>
-      `${renderKey(name)}${required.has(name) ? "" : "?"}: ${renderSchema(value, nested, depth + 1, seen)}`
-
-    if (!ctx.pretty) {
-      const fields = properties.map(field)
-      if (indexType !== undefined) fields.push(`[key: string]: ${indexType}`)
-      return fields.length === 0 ? "{}" : `{ ${fields.join("; ")} }`
-    }
-
-    // Pretty: an indented block, each described field preceded by its JSDoc comment.
-    if (properties.length === 0 && indexType === undefined) return "{}"
-    const pad = "  ".repeat(depth + 1)
-    const lines = properties.map(
-      (entry) => `${jsdoc(entry[1].description, docTags(entry[1]), pad)}${pad}${field(entry)}`,
-    )
-    if (indexType !== undefined) lines.push(`${pad}[key: string]: ${indexType}`)
-    return `{\n${lines.join("\n")}\n${"  ".repeat(depth)}}`
-  }
-  return "unknown"
-}
-
-export const toTypeScript = (schema: Schema.Top, decoded = false, pretty = false): string => {
-  try {
-    const visible = decoded ? Schema.toType(schema) : schema
-    const document = Schema.toJsonSchemaDocument(visible) as {
-      readonly schema: JsonSchema
-      readonly definitions?: Readonly<Record<string, JsonSchema>>
-    }
-    return renderSchema(document.schema, { definitions: document.definitions ?? {}, pretty })
-  } catch {
-    return "unknown"
-  }
-}
-
-/** Renders a raw JSON Schema document as a TypeScript type string. */
-export const jsonSchemaToTypeScript = (schema: JsonSchema, pretty = false): string => {
-  try {
-    return renderSchema(schema, { definitions: { ...(schema.definitions ?? {}), ...(schema.$defs ?? {}) }, pretty })
-  } catch {
-    return "unknown"
-  }
-}
-
-/** One input property of a tool, extracted best-effort from its input schema. */
-export type InputProperty = {
-  readonly name: string
-  readonly description: string | undefined
-  readonly required: boolean
-}
-
-/**
- * The property names, descriptions, and required flags of a tool's input schema - the raw
- * material for search text. Best-effort: Effect Schemas go through their
- * JSON Schema document (the same emission signature rendering uses); JSON Schemas are read
- * directly, resolving a trivial top-level `$ref` into `$defs`/`definitions` when present.
- * Anything unresolvable yields `[]` (search falls back to path + description).
- */
-export const inputProperties = <R>(definition: Definition<R>): Array<InputProperty> => {
-  try {
-    const document = isEffectSchema(definition.input)
-      ? (Schema.toJsonSchemaDocument(definition.input) as {
-          readonly schema: JsonSchema
-          readonly definitions?: Readonly<Record<string, JsonSchema>>
-        })
-      : {
-          schema: definition.input,
-          definitions: { ...(definition.input.definitions ?? {}), ...(definition.input.$defs ?? {}) },
-        }
-    const definitions = document.definitions ?? {}
-    let schema = document.schema
-    if (schema.$ref !== undefined) {
-      const segment = schema.$ref.match(/^#\/(?:\$defs|definitions)\/([^/]+)$/)?.[1]
-      const name = segment === undefined ? undefined : JsonPointer.unescapeToken(segment)
-      const resolved = name === undefined ? undefined : definitions[name]
-      if (resolved === undefined) return []
-      schema = resolved
-    }
-    const required = new Set(schema.required ?? [])
-    return Object.entries(schema.properties ?? {}).map(([name, value]) => ({
-      name,
-      description: typeof value.description === "string" ? value.description : undefined,
-      required: required.has(name),
-    }))
-  } catch {
-    return []
-  }
-}
-
-/**
- * The model-visible TypeScript type of a tool's input. `pretty` renders an indented
- * multiline block with schema descriptions and constraints as JSDoc comments on the
- * fields; the default stays the compact single-line form.
- */
-export const inputTypeScript = <R>(definition: Definition<R>, pretty = false): string =>
-  isEffectSchema(definition.input)
-    ? toTypeScript(definition.input, false, pretty)
-    : jsonSchemaToTypeScript(definition.input, pretty)
-
-/**
- * The model-visible TypeScript type of a tool's result; tools without an output schema
- * return `unknown`. `pretty` renders the JSDoc-annotated multiline form, as for inputs.
- */
-export const outputTypeScript = <R>(definition: Definition<R>, pretty = false): string =>
-  definition.output === undefined
-    ? "unknown"
-    : isEffectSchema(definition.output)
-      ? toTypeScript(definition.output, true, pretty)
-      : jsonSchemaToTypeScript(definition.output, pretty)
-
-/**
- * Decodes tool input before `run` is invoked. Effect Schemas validate (throwing on failure);
- * JSON-Schema-described inputs pass through unvalidated (render-only).
- */
-export const decodeInput = <R>(definition: Definition<R>, value: unknown): unknown =>
-  isEffectSchema(definition.input) ? Schema.decodeUnknownSync(definition.input)(value) : value
-
-/**
- * Decodes a tool result before it is exposed to the program. Effect Schemas validate and
- * transform (throwing on failure); JSON Schema outputs and tools without an output schema pass
- * the host value through unchanged.
- */
-export const decodeOutput = <R>(definition: Definition<R>, value: unknown): unknown =>
-  definition.output !== undefined && isEffectSchema(definition.output)
-    ? Schema.decodeUnknownSync(definition.output)(value)
-    : value
@@ -13,7 +13,6 @@ export type JsonSchema = {
  readonly const?: unknown
  readonly anyOf?: ReadonlyArray<JsonSchema>
  readonly oneOf?: ReadonlyArray<JsonSchema>
-  readonly allOf?: ReadonlyArray<JsonSchema>
  readonly properties?: Readonly<Record<string, JsonSchema>>
  readonly required?: ReadonlyArray<string>
  readonly items?: JsonSchema
@@ -30,25 +29,25 @@ export type JsonSchema = {
 }

 /** Either a validating Effect Schema or a render-only JSON Schema document. */
-export type SchemaType = Schema.Decoder<unknown> | JsonSchema
+export type ToolSchema = Schema.Decoder<unknown> | JsonSchema

 /** Schema-backed tool definition consumed by a CodeMode tool tree. */
 export type Definition<R = never> = {
  readonly _tag: "CodeModeTool"
  readonly description: string
-  readonly input: SchemaType
-  readonly output: SchemaType | undefined
+  readonly input: ToolSchema
+  readonly output: ToolSchema | undefined
  readonly run: (input: unknown) => Effect.Effect<unknown, unknown, R>
 }

 /** The value `run` receives: the decoded type for Effect Schemas, `unknown` for JSON Schemas. */
-type InputType<S> = S extends Schema.Decoder<unknown> ? S["Type"] : unknown
+export type InputType<S> = S extends Schema.Decoder<unknown> ? S["Type"] : unknown

 /** The value `run` returns: the encoded type for Effect Schemas, `unknown` otherwise. */
-type ResultType<S> = S extends Schema.Decoder<unknown> ? S["Encoded"] : unknown
+export type ResultType<S> = S extends Schema.Decoder<unknown> ? S["Encoded"] : unknown

 /** Options for defining one CodeMode tool. */
-export type Options<I extends SchemaType, O extends SchemaType | undefined, R = never> = {
+export type Options<I extends ToolSchema, O extends ToolSchema | undefined, R = never> = {
  readonly description: string
  readonly input: I
  readonly output?: O
@@ -58,6 +57,256 @@ export type Options<I extends SchemaType, O extends SchemaType | undefined, R =
 export const isDefinition = <R = never>(value: unknown): value is Definition<R> =>
  typeof value === "object" && value !== null && "_tag" in value && value._tag === "CodeModeTool"

+const isEffectSchema = (schema: ToolSchema): schema is Schema.Decoder<unknown> & Schema.Top => Schema.isSchema(schema)
+
+const renderLiteral = (value: unknown): string => JSON.stringify(value) ?? "unknown"
+
+/**
+ * Bare TypeScript identifier - usable unquoted as an object key (and, in the tool runtime,
+ * with dot access as a tool-path segment). Anything else must be quoted/bracketed.
+ */
+export const identifierSegment = /^[A-Za-z_$][A-Za-z0-9_$]*$/
+
+/** Renders a property name as a valid TS object key: bare when an identifier, quoted otherwise. */
+const renderKey = (name: string): string => (identifierSegment.test(name) ? name : JSON.stringify(name))
+
+const effectNumberSentinel = (schema: JsonSchema) =>
+  schema.type === "string" &&
+  Array.isArray(schema.enum) &&
+  schema.enum.length === 1 &&
+  (schema.enum[0] === "NaN" || schema.enum[0] === "Infinity" || schema.enum[0] === "-Infinity")
+
+/**
+ * Recursion ceiling for schema rendering. Object, array, and union recursion all increment
+ * depth, so this bounds every recursion path - pathological or structurally cyclic schemas
+ * degrade to `unknown` instead of overflowing the stack (rendering must never throw).
+ */
+const MAX_RENDER_DEPTH = 8
+
+type RenderContext = {
+  readonly definitions: Readonly<Record<string, JsonSchema>>
+  /** Indented, JSDoc-annotated multiline rendering (search results); compact single line otherwise. */
+  readonly pretty: boolean
+}
+
+/**
+ * Schema constraints a TypeScript type cannot express natively but a model benefits from,
+ * surfaced as JSDoc tags (`@deprecated`, `@default`, `@format`, `@minItems`, `@maxItems`).
+ */
+const docTags = (schema: JsonSchema): Array<string> => {
+  const tags: Array<string> = []
+  if (schema.deprecated === true) tags.push("@deprecated")
+  if (schema.default !== undefined) {
+    try {
+      const rendered = JSON.stringify(schema.default)
+      if (rendered !== undefined) tags.push(`@default ${rendered}`)
+    } catch {
+      // unserializable default: skip rather than emit a broken tag
+    }
+  }
+  if (typeof schema.format === "string") tags.push(`@format ${schema.format}`)
+  if (typeof schema.minItems === "number") tags.push(`@minItems ${schema.minItems}`)
+  if (typeof schema.maxItems === "number") tags.push(`@maxItems ${schema.maxItems}`)
+  return tags
+}
+
+/**
+ * Format a schema `description` plus `tags` as a JSDoc comment at the given indent,
+ * preserving multi-line text (a single line stays `/** ... *\/`; multiple lines become a
+ * `*`-prefixed block). `*\/` is neutralized so nothing can close the comment early, and
+ * blank leading/trailing lines are trimmed. Returns "" (else a trailing newline) so
+ * callers can prepend it directly to the field line.
+ */
+const jsdoc = (description: string | undefined, tags: ReadonlyArray<string>, pad: string): string => {
+  const lines = [...(description === undefined ? [] : description.split("\n")), ...tags].map((line) =>
+    line.replaceAll("*/", "* /").replace(/\s+$/, ""),
+  )
+  while (lines.length > 0 && lines[0]!.trim() === "") lines.shift()
+  while (lines.length > 0 && lines[lines.length - 1]!.trim() === "") lines.pop()
+  if (lines.length === 0) return ""
+  if (lines.length === 1) return `${pad}/** ${lines[0]} */\n`
+  const body = lines.map((line) => `${pad} *${line === "" ? "" : ` ${line}`}`).join("\n")
+  return `${pad}/**\n${body}\n${pad} */\n`
+}
+
+const renderSchema = (
+  schema: JsonSchema,
+  ctx: RenderContext,
+  depth = 0,
+  seen: ReadonlySet<string> = new Set(),
+): string => {
+  if (depth > MAX_RENDER_DEPTH) return "unknown"
+  if (schema.$ref) {
+    const name = schema.$ref.split("/").pop()
+    if (!name || !ctx.definitions[name]) return name ?? "unknown"
+    if (seen.has(name)) return name // recursive type: reference by name rather than loop
+    return renderSchema(ctx.definitions[name], ctx, depth, new Set([...seen, name]))
+  }
+  if (schema.const !== undefined) return renderLiteral(schema.const)
+  if (schema.enum) return schema.enum.map(renderLiteral).join(" | ")
+  const alternatives = schema.anyOf ?? schema.oneOf
+  if (alternatives) {
+    // Effect's number schema emits `anyOf: [{ type: "number" }, { const: "NaN" },
+    // { const: "Infinity" }, { const: "-Infinity" }]`. Collapse only that artifact;
+    // real JSON Schema unions such as `string | number` or `number | null` must keep
+    // every branch.
+    if (
+      alternatives.some((item) => item.type === "number") &&
+      alternatives.every((item) => item.type === "number" || effectNumberSentinel(item))
+    )
+      return "number"
+    // An empty Schema.Struct({}) emits `anyOf: [{ type: "object" }, { type: "array" }]`
+    // (no properties/items); render the bare shape as {} instead of `{} | Array<unknown>`.
+    if (
+      alternatives.length === 2 &&
+      alternatives[0]?.type === "object" &&
+      alternatives[0].properties === undefined &&
+      alternatives[1]?.type === "array" &&
+      alternatives[1].items === undefined
+    ) {
+      return "{}"
+    }
+    return alternatives.map((item) => renderSchema(item, ctx, depth + 1, seen)).join(" | ")
+  }
+  if (Array.isArray(schema.type)) {
+    return schema.type.map((item) => renderSchema({ type: item }, ctx, depth + 1, seen)).join(" | ")
+  }
+  if (schema.type === "string") return "string"
+  if (schema.type === "number" || schema.type === "integer") return "number"
+  if (schema.type === "boolean") return "boolean"
+  if (schema.type === "null") return "null"
+  if (schema.type === "array") return `Array<${renderSchema(schema.items ?? {}, ctx, depth + 1, seen)}>`
+  if (schema.type === "object" || schema.properties) {
+    const required = new Set(schema.required ?? [])
+    const properties = Object.entries(schema.properties ?? {})
+    const additional = schema.additionalProperties
+    const indexType =
+      additional && typeof additional === "object" ? renderSchema(additional, ctx, depth + 1, seen) : undefined
+    const field = ([name, value]: readonly [string, JsonSchema]) =>
+      `${renderKey(name)}${required.has(name) ? "" : "?"}: ${renderSchema(value, ctx, depth + 1, seen)}`
+
+    if (!ctx.pretty) {
+      const fields = properties.map(field)
+      if (indexType !== undefined) fields.push(`[key: string]: ${indexType}`)
+      return fields.length === 0 ? "{}" : `{ ${fields.join("; ")} }`
+    }
+
+    // Pretty: an indented block, each described field preceded by its JSDoc comment.
+    if (properties.length === 0 && indexType === undefined) return "{}"
+    const pad = "  ".repeat(depth + 1)
+    const lines = properties.map(
+      (entry) => `${jsdoc(entry[1].description, docTags(entry[1]), pad)}${pad}${field(entry)}`,
+    )
+    if (indexType !== undefined) lines.push(`${pad}[key: string]: ${indexType}`)
+    return `{\n${lines.join("\n")}\n${"  ".repeat(depth)}}`
+  }
+  return "unknown"
+}
+
+export const toTypeScript = (schema: Schema.Top, decoded = false, pretty = false): string => {
+  try {
+    const visible = decoded ? Schema.toType(schema) : schema
+    const document = Schema.toJsonSchemaDocument(visible) as {
+      readonly schema: JsonSchema
+      readonly definitions?: Readonly<Record<string, JsonSchema>>
+    }
+    return renderSchema(document.schema, { definitions: document.definitions ?? {}, pretty })
+  } catch {
+    return "unknown"
+  }
+}
+
+/** Renders a raw JSON Schema document as a TypeScript type string. */
+export const jsonSchemaToTypeScript = (schema: JsonSchema, pretty = false): string => {
+  try {
+    return renderSchema(schema, { definitions: { ...(schema.definitions ?? {}), ...(schema.$defs ?? {}) }, pretty })
+  } catch {
+    return "unknown"
+  }
+}
+
+/** One input property of a tool, extracted best-effort from its input schema. */
+export type InputProperty = {
+  readonly name: string
+  readonly description: string | undefined
+  readonly required: boolean
+}
+
+/**
+ * The property names, descriptions, and required flags of a tool's input schema - the raw
+ * material for search text. Best-effort: Effect Schemas go through their
+ * JSON Schema document (the same emission signature rendering uses); JSON Schemas are read
+ * directly, resolving a trivial top-level `$ref` into `$defs`/`definitions` when present.
+ * Anything unresolvable yields `[]` (search falls back to path + description).
+ */
+export const inputProperties = <R>(definition: Definition<R>): Array<InputProperty> => {
+  try {
+    const document = isEffectSchema(definition.input)
+      ? (Schema.toJsonSchemaDocument(definition.input) as {
+          readonly schema: JsonSchema
+          readonly definitions?: Readonly<Record<string, JsonSchema>>
+        })
+      : {
+          schema: definition.input,
+          definitions: { ...(definition.input.definitions ?? {}), ...(definition.input.$defs ?? {}) },
+        }
+    const definitions = document.definitions ?? {}
+    let schema = document.schema
+    if (schema.$ref !== undefined) {
+      const name = schema.$ref.split("/").pop()
+      const resolved = name === undefined ? undefined : definitions[name]
+      if (resolved === undefined) return []
+      schema = resolved
+    }
+    const required = new Set(schema.required ?? [])
+    return Object.entries(schema.properties ?? {}).map(([name, value]) => ({
+      name,
+      description: typeof value.description === "string" ? value.description : undefined,
+      required: required.has(name),
+    }))
+  } catch {
+    return []
+  }
+}
+
+/**
+ * The model-visible TypeScript type of a tool's input. `pretty` renders an indented
+ * multiline block with schema descriptions and constraints as JSDoc comments on the
+ * fields; the default stays the compact single-line form.
+ */
+export const inputTypeScript = <R>(definition: Definition<R>, pretty = false): string =>
+  isEffectSchema(definition.input)
+    ? toTypeScript(definition.input, false, pretty)
+    : jsonSchemaToTypeScript(definition.input, pretty)
+
+/**
+ * The model-visible TypeScript type of a tool's result; tools without an output schema
+ * return `unknown`. `pretty` renders the JSDoc-annotated multiline form, as for inputs.
+ */
+export const outputTypeScript = <R>(definition: Definition<R>, pretty = false): string =>
+  definition.output === undefined
+    ? "unknown"
+    : isEffectSchema(definition.output)
+      ? toTypeScript(definition.output, true, pretty)
+      : jsonSchemaToTypeScript(definition.output, pretty)
+
+/**
+ * Decodes tool input before `run` is invoked. Effect Schemas validate (throwing on failure);
+ * JSON-Schema-described inputs pass through unvalidated (render-only).
+ */
+export const decodeInput = <R>(definition: Definition<R>, value: unknown): unknown =>
+  isEffectSchema(definition.input) ? Schema.decodeUnknownSync(definition.input)(value) : value
+
+/**
+ * Decodes a tool result before it is exposed to the program. Effect Schemas validate and
+ * transform (throwing on failure); JSON Schema outputs and tools without an output schema pass
+ * the host value through unchanged.
+ */
+export const decodeOutput = <R>(definition: Definition<R>, value: unknown): unknown =>
+  definition.output !== undefined && isEffectSchema(definition.output)
+    ? Schema.decodeUnknownSync(definition.output)(value)
+    : value
+
 /**
 * Defines one schema-described tool available to a CodeMode program through `tools.*`.
 *
@@ -85,7 +334,7 @@ export const isDefinition = <R = never>(value: unknown): value is Definition<R>
 * })
 * ```
 */
-export const make = <I extends SchemaType, const O extends SchemaType | undefined = undefined, R = never>(
+export const make = <I extends ToolSchema, const O extends ToolSchema | undefined = undefined, R = never>(
  options: Options<I, O, R>,
 ): Definition<R> => ({
  _tag: "CodeModeTool",
@@ -94,3 +343,6 @@ export const make = <I extends SchemaType, const O extends SchemaType | undefine
  output: options.output,
  run: (input) => options.run(input as InputType<I>),
 })
+
+/** Constructors for schema-backed tools exposed inside CodeMode programs. */
+export const Tool = { make, isDefinition }
@@ -1,8 +1,16 @@
 import { describe, expect, test } from "bun:test"
 import { Cause, Effect, Schema } from "effect"
-import { CodeMode, Tool, toolError } from "../src/index.js"
+import {
+  CodeMode,
+  ExecuteInputSchema,
+  ExecuteResultSchema,
+  Tool,
+  toolError,
+  type ExecutionLimits,
+} from "../src/index.js"
+import type { Definition } from "../src/tool.js"

-const run = (tool: Tool.Definition<never>) =>
+const run = (tool: Definition<never>) =>
  Effect.runPromise(CodeMode.make({ tools: { host: { call: tool } } }).execute("return await tools.host.call({})"))

 class UnsafeHostError extends Schema.TaggedErrorClass<UnsafeHostError>()("UnsafeHostError", {
@@ -227,7 +235,7 @@ describe("CodeMode console capture", () => {
      logs: ['Thread info: {"name":"Demo","count":2}', "[warn] careful"],
      toolCalls: [],
    })
-    expect(Schema.decodeUnknownSync(CodeMode.Result)(JSON.parse(JSON.stringify(result)))).toStrictEqual(result)
+    expect(Schema.decodeUnknownSync(ExecuteResultSchema)(JSON.parse(JSON.stringify(result)))).toStrictEqual(result)
  })

  test("keeps logs captured before failures", async () => {
@@ -348,7 +356,7 @@ describe("CodeMode output budget", () => {
  })

  test("truncates an oversized result value with a marker instead of failing", async () => {
-    const limits: CodeMode.ExecutionLimits = { maxOutputBytes: 40 }
+    const limits: ExecutionLimits = { maxOutputBytes: 40 }
    const result = await Effect.runPromise(
      CodeMode.execute({
        code: `return { data: "${"x".repeat(200)}" }`,
@@ -363,11 +371,11 @@ describe("CodeMode output budget", () => {
    expect(result.value).toMatch(
      /^\{"data":"x+ \[result truncated: \d+ bytes exceeds the 40-byte output limit; return a smaller value\]$/,
    )
-    expect(Schema.decodeUnknownSync(CodeMode.Result)(JSON.parse(JSON.stringify(result)))).toStrictEqual(result)
+    expect(Schema.decodeUnknownSync(ExecuteResultSchema)(JSON.parse(JSON.stringify(result)))).toStrictEqual(result)
  })

  test("keeps leading logs within the remaining budget and marks the cut", async () => {
-    const limits: CodeMode.ExecutionLimits = { maxOutputBytes: 40 }
+    const limits: ExecutionLimits = { maxOutputBytes: 40 }
    const result = await Effect.runPromise(
      CodeMode.execute({
        code: `
@@ -493,17 +501,24 @@ describe("CodeMode public contract", () => {
  const tools = { orders: { lookup } }
  const source = `return await tools.orders.lookup({ id: "order_42" })`

-  test("keeps one-shot and reusable execution equivalent", async () => {
+  test("keeps one-shot, reusable, and agent-tool execution equivalent", async () => {
    const runtime = CodeMode.make({ tools })
-    const [oneShot, reusable] = await Promise.all([
+    const agentTool = runtime.agentTool()
+    const [oneShot, reusable, projected] = await Promise.all([
      Effect.runPromise(CodeMode.execute({ tools, code: source })),
      Effect.runPromise(runtime.execute(source)),
+      Effect.runPromise(agentTool.execute({ code: source })),
    ])

    expect(reusable).toStrictEqual(oneShot)
-    const input: CodeMode.Input = { code: source }
-    expect(Schema.decodeUnknownSync(CodeMode.Input)(input)).toStrictEqual(input)
-    expect(Schema.decodeUnknownSync(CodeMode.Result)(JSON.parse(JSON.stringify(reusable)))).toStrictEqual(reusable)
+    expect(projected).toStrictEqual(oneShot)
+    expect(agentTool.name).toBe("code")
+    expect(agentTool.input).toBe(ExecuteInputSchema)
+    expect(agentTool.output).toBe(ExecuteResultSchema)
+    expect(agentTool.description).toBe(runtime.instructions())
+    expect(Schema.decodeUnknownSync(ExecuteResultSchema)(JSON.parse(JSON.stringify(projected)))).toStrictEqual(
+      projected,
+    )
  })

  test("inlines a COMPLETE small catalog and keeps search registered but unadvertised", async () => {
@@ -1020,7 +1035,7 @@ describe("CodeMode public contract", () => {
      value: { top: null, nested: [1, null] },
      toolCalls: [],
    })
-    expect(Schema.decodeUnknownSync(CodeMode.Result)(JSON.parse(JSON.stringify(result)))).toStrictEqual(result)
+    expect(Schema.decodeUnknownSync(ExecuteResultSchema)(JSON.parse(JSON.stringify(result)))).toStrictEqual(result)
  })

  test("rejects invalid configuration and discovery limits", async () => {
@@ -1,245 +0,0 @@
-{
-  "openapi": "3.1.0",
-  "info": {
-    "title": "CodeMode Happy Path",
-    "version": "1.0.0"
-  },
-  "servers": [
-    {
-      "url": "https://api.example.test/v1"
-    }
-  ],
-  "security": [
-    {
-      "BearerAuth": []
-    }
-  ],
-  "paths": {
-    "/users/{userId}": {
-      "parameters": [
-        {
-          "$ref": "#/components/parameters/UserId"
-        }
-      ],
-      "get": {
-        "operationId": "users.get",
-        "summary": "Get a user",
-        "parameters": [
-          {
-            "name": "include",
-            "in": "query",
-            "style": "form",
-            "explode": false,
-            "schema": {
-              "type": "array",
-              "items": {
-                "type": "string"
-              }
-            }
-          },
-          {
-            "name": "verbose",
-            "in": "query",
-            "schema": {
-              "type": "boolean"
-            }
-          },
-          {
-            "name": "X-Trace-ID",
-            "in": "header",
-            "schema": {
-              "type": "string"
-            }
-          }
-        ],
-        "responses": {
-          "200": {
-            "$ref": "#/components/responses/UserResponse"
-          }
-        }
-      },
-      "delete": {
-        "operationId": "users.remove",
-        "summary": "Remove a user",
-        "responses": {
-          "204": {
-            "description": "Removed"
-          }
-        }
-      }
-    },
-    "/users": {
-      "post": {
-        "operationId": "users.create",
-        "summary": "Create a user",
-        "security": [
-          {
-            "ApiKey": []
-          }
-        ],
-        "requestBody": {
-          "required": true,
-          "content": {
-            "application/json": {
-              "schema": {
-                "type": "object",
-                "properties": {
-                  "name": {
-                    "type": "string"
-                  },
-                  "email": {
-                    "type": "string",
-                    "format": "email"
-                  },
-                  "role": {
-                    "type": "string",
-                    "enum": [
-                      "admin",
-                      "member"
-                    ]
-                  }
-                },
-                "required": [
-                  "name",
-                  "email"
-                ],
-                "additionalProperties": false
-              }
-            }
-          }
-        },
-        "responses": {
-          "201": {
-            "description": "Created",
-            "content": {
-              "application/vnd.example+json": {
-                "schema": {
-                  "$ref": "#/components/schemas/User"
-                }
-              }
-            }
-          }
-        }
-      }
-    },
-    "/search": {
-      "get": {
-        "operationId": "search.run",
-        "summary": "Search users",
-        "security": [],
-        "parameters": [
-          {
-            "name": "filter",
-            "in": "query",
-            "style": "deepObject",
-            "explode": true,
-            "schema": {
-              "type": "object",
-              "properties": {
-                "query": {
-                  "type": "string"
-                },
-                "page": {
-                  "type": "integer"
-                }
-              },
-              "required": [
-                "query"
-              ],
-              "additionalProperties": false
-            }
-          },
-          {
-            "name": "tags",
-            "in": "query",
-            "style": "form",
-            "explode": true,
-            "schema": {
-              "type": "array",
-              "items": {
-                "type": "string"
-              }
-            }
-          }
-        ],
-        "responses": {
-          "200": {
-            "description": "Summary",
-            "content": {
-              "text/plain": {
-                "schema": {
-                  "type": "string"
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  },
-  "components": {
-    "parameters": {
-      "UserId": {
-        "name": "userId",
-        "in": "path",
-        "required": true,
-        "schema": {
-          "type": "string"
-        }
-      }
-    },
-    "responses": {
-      "UserResponse": {
-        "description": "A user",
-        "content": {
-          "application/json": {
-            "schema": {
-              "$ref": "#/components/schemas/User"
-            }
-          }
-        }
-      }
-    },
-    "schemas": {
-      "User": {
-        "type": "object",
-        "properties": {
-          "id": {
-            "type": "string"
-          },
-          "name": {
-            "type": "string"
-          },
-          "email": {
-            "type": "string",
-            "format": "email"
-          },
-          "role": {
-            "type": "string",
-            "enum": [
-              "admin",
-              "member"
-            ]
-          }
-        },
-        "required": [
-          "id",
-          "name",
-          "email"
-        ],
-        "additionalProperties": false
-      }
-    },
-    "securitySchemes": {
-      "BearerAuth": {
-        "type": "http",
-        "scheme": "bearer"
-      },
-      "ApiKey": {
-        "type": "apiKey",
-        "in": "query",
-        "name": "api_key"
-      }
-    }
-  }
-}
@@ -1,958 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { Effect, Layer, Option } from "effect"
-import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http"
-import { CodeMode, OpenAPI, Tool } from "../src/index.js"
-import { inputTypeScript, outputTypeScript } from "../src/tool-schema.js"
-
-const baseUrl = "http://localhost:4096"
-type Document = OpenAPI.Document
-
-type Recorded = {
-  readonly method: string
-  readonly url: string
-  readonly headers: Record<string, string>
-  readonly body: unknown
-}
-
-const opencodeSpec = async (): Promise<Document> => {
-  return Bun.file(new URL("./fixtures/opencode-v2-openapi.json", import.meta.url)).json() as Promise<Document>
-}
-
-const happyPathSpec = async (): Promise<Document> => {
-  return Bun.file(new URL("./fixtures/openapi-happy-path.json", import.meta.url)).json() as Promise<Document>
-}
-
-const isRecord = (value: unknown): value is Record<string, unknown> =>
-  typeof value === "object" && value !== null && !Array.isArray(value)
-
-const toolAt = (tools: unknown, name: string) =>
-  name.split(".").reduce<unknown>((current, segment) => (isRecord(current) ? current[segment] : undefined), tools)
-
-const recordingClient = (respond: (request: HttpClientRequest.HttpClientRequest) => Response) => {
-  const requests: Array<Recorded> = []
-  const layer = Layer.succeed(HttpClient.HttpClient)(
-    HttpClient.make((request) =>
-      Effect.gen(function* () {
-        const body =
-          request.body._tag === "Uint8Array" ? JSON.parse(new TextDecoder().decode(request.body.body)) : undefined
-        const url = Option.map(HttpClientRequest.toUrl(request), (resolved) => resolved.toString())
-        requests.push({
-          method: request.method,
-          url: Option.getOrElse(url, () => request.url),
-          headers: { ...request.headers },
-          body,
-        })
-        return HttpClientResponse.fromWeb(request, respond(request))
-      }),
-    ),
-  )
-  return { requests, layer }
-}
-
-const json = (value: unknown, status = 200) =>
-  new Response(JSON.stringify(value), { status, headers: { "content-type": "application/json" } })
-
-const singleOperation = (operation: Record<string, unknown>, method = "get"): Document => ({
-  openapi: "3.1.0",
-  paths: { "/test": { [method]: { operationId: "test", responses: { 200: { description: "Success" } }, ...operation } } },
-})
-
-describe("OpenAPI.fromSpec", () => {
-  test("covers a representative API from generation through execution", async () => {
-    const resolutions: Array<string> = []
-    const client = recordingClient((request) => {
-      const url = Option.getOrElse(HttpClientRequest.toUrl(request), () => new URL(request.url))
-      if (request.method === "POST") {
-        return new Response(
-          JSON.stringify({ id: "user-2", name: "Grace", email: "grace@example.test", role: "admin" }),
-          { status: 201, headers: { "content-type": "application/vnd.example+json" } },
-        )
-      }
-      if (request.method === "DELETE") return new Response(null, { status: 204 })
-      if (url.pathname === "/search") {
-        return new Response("2 matches", { headers: { "content-type": "text/plain" } })
-      }
-      return json({ id: "user-1", name: "Ada", email: "ada@example.test", role: "member" })
-    })
-    const api = OpenAPI.fromSpec({
-      spec: await happyPathSpec(),
-      baseUrl,
-      auth: {
-        resolve: ({ name }) => {
-          resolutions.push(name)
-          return Effect.succeed(
-            name === "BearerAuth"
-              ? { type: "bearer", token: "bearer-secret" }
-              : { type: "apiKey", value: "api-secret" },
-          )
-        },
-      },
-    })
-    const get = toolAt(api.tools, "users.get")
-    const create = toolAt(api.tools, "users.create")
-    const search = toolAt(api.tools, "search.run")
-    const remove = toolAt(api.tools, "users.remove")
-
-    expect(api.skipped).toEqual([])
-    if (!Tool.isDefinition(get) || !Tool.isDefinition(create) || !Tool.isDefinition(search) || !Tool.isDefinition(remove)) {
-      throw new Error("happy-path fixture did not generate every operation")
-    }
-    expect(inputTypeScript(get)).toBe(
-      '{ userId: string; include?: Array<string>; verbose?: boolean; "X-Trace-ID"?: string }',
-    )
-    expect(inputTypeScript(create)).toBe('{ name: string; email: string; role?: "admin" | "member" }')
-    expect(inputTypeScript(search)).toBe("{ filter?: { query: string; page?: number }; tags?: Array<string> }")
-    expect(inputTypeScript(remove)).toBe("{ userId: string }")
-    expect(outputTypeScript(get)).toContain("id: string")
-    expect(outputTypeScript(create)).toContain('role?: "admin" | "member"')
-    expect(outputTypeScript(search)).toBe("string")
-    expect(outputTypeScript(remove)).toBe("null")
-
-    const result = await Effect.runPromise(
-      CodeMode.make({ tools: { api: api.tools } })
-        .execute(`
-          const user = await tools.api.users.get({
-            userId: "user-1",
-            include: ["profile", "permissions"],
-            verbose: true,
-            "X-Trace-ID": "trace-1",
-          })
-          const created = await tools.api.users.create({
-            name: "Grace",
-            email: "grace@example.test",
-            role: "admin",
-          })
-          const summary = await tools.api.search.run({
-            filter: { query: "effect", page: 2 },
-            tags: ["typescript", "runtime"],
-          })
-          const removed = await tools.api.users.remove({ userId: "user-1" })
-          return { user, created, summary, removed }
-        `)
-        .pipe(Effect.provide(client.layer)),
-    )
-
-    expect(result).toMatchObject({
-      ok: true,
-      value: {
-        user: { id: "user-1", name: "Ada" },
-        created: { id: "user-2", name: "Grace" },
-        summary: "2 matches",
-        removed: null,
-      },
-    })
-    expect(resolutions).toEqual(["BearerAuth", "ApiKey", "BearerAuth"])
-    expect(client.requests).toHaveLength(4)
-
-    const getUrl = new URL(client.requests[0]!.url)
-    expect(getUrl.pathname).toBe("/users/user-1")
-    expect(getUrl.searchParams.get("include")).toBe("profile,permissions")
-    expect(getUrl.searchParams.get("verbose")).toBe("true")
-    expect(client.requests[0]!.headers["x-trace-id"]).toBe("trace-1")
-    expect(client.requests[0]!.headers.authorization).toBe("Bearer bearer-secret")
-
-    const createUrl = new URL(client.requests[1]!.url)
-    expect(createUrl.searchParams.get("api_key")).toBe("api-secret")
-    expect(client.requests[1]!.body).toEqual({ name: "Grace", email: "grace@example.test", role: "admin" })
-
-    const searchUrl = new URL(client.requests[2]!.url)
-    expect(searchUrl.searchParams.get("filter[query]")).toBe("effect")
-    expect(searchUrl.searchParams.get("filter[page]")).toBe("2")
-    expect(searchUrl.searchParams.getAll("tags")).toEqual(["typescript", "runtime"])
-    expect(client.requests[2]!.headers.authorization).toBeUndefined()
-    expect(new URL(client.requests[3]!.url).pathname).toBe("/users/user-1")
-    expect(client.requests[3]!.headers.authorization).toBe("Bearer bearer-secret")
-  })
-
-  test("converts representative opencode operations into the expected tool shape", async () => {
-    const spec = await opencodeSpec()
-    const result = OpenAPI.fromSpec({ spec, baseUrl })
-
-    expect(result.skipped).toHaveLength(5)
-    expect(result.skipped).toContainEqual({
-      method: "GET",
-      path: "/api/pty/{ptyID}/connect",
-      reason: "WebSocket operations are not supported",
-    })
-    expect(result.skipped.filter((item) => item.reason === "SSE operations are not supported")).toHaveLength(3)
-    expect(result.skipped).toContainEqual({
-      method: "GET",
-      path: "/api/fs/read/*",
-      reason: "binary responses are not supported",
-    })
-    expect(toolAt(result.tools, "v2.health.get")).not.toBeUndefined()
-    expect(toolAt(result.tools, "v2.session.get")).not.toBeUndefined()
-    expect(toolAt(result.tools, "v2.session.create")).not.toBeUndefined()
-
-    const sessionGet = toolAt(result.tools, "v2.session.get")
-    expect(Tool.isDefinition(sessionGet)).toBe(true)
-    if (!Tool.isDefinition(sessionGet)) throw new Error("v2.session.get was not generated")
-    expect(inputTypeScript(sessionGet)).toBe("{ sessionID: string }")
-    expect(outputTypeScript(sessionGet)).toContain("id: string")
-    expect(outputTypeScript(sessionGet)).toContain("additions: number")
-
-    const switchAgent = toolAt(result.tools, "v2.session.switchAgent")
-    expect(Tool.isDefinition(switchAgent)).toBe(true)
-    if (!Tool.isDefinition(switchAgent)) throw new Error("v2.session.switchAgent was not generated")
-    expect(inputTypeScript(switchAgent)).toBe("{ sessionID: string; agent: string }")
-
-    const contextEntryPut = toolAt(result.tools, "v2.session.contextEntry.put")
-    expect(Tool.isDefinition(contextEntryPut)).toBe(true)
-    if (!Tool.isDefinition(contextEntryPut)) throw new Error("v2.session.contextEntry.put was not generated")
-    expect(inputTypeScript(contextEntryPut)).toBe("{ sessionID: string; key: string; value: unknown }")
-    expect(toolAt(result.tools, "v2_session_context_entry_put_2")).toBeUndefined()
-    expect(toolAt(result.tools, "v2.pty.connect")).toBeUndefined()
-    expect(toolAt(result.tools, "v2.session.log")).toBeUndefined()
-    expect(toolAt(result.tools, "v2.event.subscribe")).toBeUndefined()
-    expect(toolAt(result.tools, "v2.event.changes")).toBeUndefined()
-    expect(toolAt(result.tools, "v2.fs.read")).toBeUndefined()
-    expect(toolAt(result.tools, "v2.pty.connectToken")).not.toBeUndefined()
-  })
-
-  test("preserves operation path sanitization and collision handling", () => {
-    const response = { responses: { 200: { description: "Success" } } }
-    const result = OpenAPI.fromSpec({
-      baseUrl,
-      spec: {
-        openapi: "3.1.0",
-        paths: {
-          "/first": { get: { ...response, operationId: "group.item" } },
-          "/second": { get: { ...response, operationId: "group.item" } },
-          "/third": { get: { ...response, operationId: "group..other" } },
-        },
-      },
-    })
-
-    expect(Tool.isDefinition(toolAt(result.tools, "group.item"))).toBe(true)
-    expect(Tool.isDefinition(toolAt(result.tools, "group_item_2"))).toBe(true)
-    expect(Tool.isDefinition(toolAt(result.tools, "group.operation.other"))).toBe(true)
-  })
-
-  test("synthesizes flat operation IDs from methods and paths", () => {
-    const response = { responses: { 200: { description: "Success" } } }
-    const tools = OpenAPI.fromSpec({
-      baseUrl,
-      spec: {
-        openapi: "3.1.0",
-        paths: {
-          "/users": { get: response, post: response },
-          "/users/{id}": { get: response, patch: response, delete: response },
-          "/organizations/{organizationId}/users/{id}": { get: response },
-        },
-      },
-    }).tools
-
-    for (const path of [
-      "getUsers",
-      "postUsers",
-      "getUsersById",
-      "patchUsersById",
-      "deleteUsersById",
-      "getOrganizationsByOrganizationidUsersById",
-    ]) {
-      expect(Tool.isDefinition(toolAt(tools, path))).toBe(true)
-    }
-  })
-
-  test("lets operation parameters override matching path parameters", () => {
-    const tool = toolAt(
-      OpenAPI.fromSpec({
-        baseUrl,
-        spec: {
-          openapi: "3.1.0",
-          paths: {
-            "/test": {
-              parameters: [{ name: "limit", in: "query", schema: { type: "string" } }],
-              get: {
-                operationId: "test",
-                parameters: [{ name: "limit", in: "query", required: true, schema: { type: "number" } }],
-                responses: { 200: { description: "Success" } },
-              },
-            },
-          },
-        },
-      }).tools,
-      "test",
-    )
-
-    if (!Tool.isDefinition(tool)) throw new Error("test was not generated")
-    expect(inputTypeScript(tool)).toBe("{ limit: number }")
-  })
-
-  test("normalizes OpenAPI 3.0 schemas with Effect", () => {
-    const result = OpenAPI.fromSpec({
-      baseUrl,
-      spec: {
-        openapi: "3.0.3",
-        paths: {
-          "/search": {
-            get: {
-              operationId: "search",
-              parameters: [
-                {
-                  in: "query",
-                  name: "value",
-                  schema: { type: "string", nullable: true, minLength: 2 },
-                },
-              ],
-              responses: { 200: { description: "Success" } },
-            },
-          },
-        },
-      },
-    })
-    const search = toolAt(result.tools, "search")
-
-    expect(Tool.isDefinition(search)).toBe(true)
-    if (!Tool.isDefinition(search)) throw new Error("search was not generated")
-    expect(inputTypeScript(search)).toBe("{ value?: string | null }")
-    const schema: unknown = search.input
-    const input = isRecord(schema) ? schema : {}
-    const properties = isRecord(input.properties) ? input.properties : {}
-    const value = isRecord(properties.value) ? properties.value : {}
-    expect(value.minLength).toBe(2)
-  })
-
-  test("preserves schema-local definitions alongside component definitions", () => {
-    const tool = toolAt(
-      OpenAPI.fromSpec({
-        baseUrl,
-        spec: {
-          openapi: "3.1.0",
-          paths: {
-            "/test": {
-              get: {
-                operationId: "test",
-                responses: {
-                  200: {
-                    description: "Success",
-                    content: {
-                      "application/json": {
-                        schema: { $ref: "#/$defs/Local", $defs: { Local: { type: "string" } } },
-                      },
-                    },
-                  },
-                },
-              },
-            },
-          },
-          components: { schemas: { Global: { type: "number" } } },
-        },
-      }).tools,
-      "test",
-    )
-
-    if (!Tool.isDefinition(tool) || !isRecord(tool.output)) throw new Error("test output was not generated")
-    expect(tool.output.$defs).toMatchObject({ Local: { type: "string" }, Global: { type: "number" } })
-  })
-
-  test("documents that the opencode fixture is unauthenticated", async () => {
-    const spec = await opencodeSpec()
-    const components = isRecord(spec.components) ? spec.components : {}
-    const result = OpenAPI.fromSpec({ spec, baseUrl })
-
-    expect(spec.security).toStrictEqual([])
-    expect(isRecord(components.securitySchemes) ? Object.keys(components.securitySchemes) : []).toStrictEqual([])
-    const health = toolAt(result.tools, "v2.health.get")
-    const healthInput = isRecord(health) ? health.input : undefined
-    expect(healthInput).toMatchObject({ type: "object", properties: {} })
-    const input = isRecord(healthInput) ? healthInput : {}
-    expect(Object.keys(isRecord(input.properties) ? input.properties : {})).toStrictEqual([])
-  })
-
-  test("exposes real opencode operations through CodeMode discovery", async () => {
-    const { layer } = recordingClient(() => json({}))
-    const runtime = CodeMode.make({
-      tools: { opencode: OpenAPI.fromSpec({ spec: await opencodeSpec(), baseUrl }).tools },
-    })
-    const result = await Effect.runPromise(
-      runtime
-        .execute(
-          `
-        return await tools.$codemode.search({ query: "global health", namespace: "opencode", limit: 1 })
-      `,
-        )
-        .pipe(Effect.provide(layer)),
-    )
-
-    expect(result).toMatchObject({ ok: true })
-    if (!result.ok) return
-    expect(result.value).toMatchObject({
-      items: [
-        {
-          path: "tools.opencode.v2.health.get",
-          description: "Check whether the API server is ready to accept requests.",
-        },
-      ],
-    })
-    expect(JSON.stringify(result.value)).toContain("healthy: true")
-  })
-
-  test("invokes real opencode path parameters and JSON request bodies", async () => {
-    const { requests, layer } = recordingClient((request) => {
-      if (request.method === "GET") return json({ id: "ses_123" })
-      return json({ id: "ses_456" })
-    })
-    const runtime = CodeMode.make({
-      tools: { opencode: OpenAPI.fromSpec({ spec: await opencodeSpec(), baseUrl }).tools },
-    })
-
-    const result = await Effect.runPromise(
-      runtime
-        .execute(
-          `
-          const existing = await tools.opencode.v2.session.get({ sessionID: "ses_123" })
-          const created = await tools.opencode.v2.session.create({ id: "ses_456" })
-          return { existing, created }
-        `,
-        )
-        .pipe(Effect.provide(layer)),
-    )
-
-    expect(result).toMatchObject({ ok: true })
-    expect(requests).toHaveLength(2)
-    expect(requests[0]).toMatchObject({ method: "GET", body: undefined })
-    expect(new URL(requests[0]!.url).pathname).toBe("/api/session/ses_123")
-    expect(requests[1]).toMatchObject({
-      method: "POST",
-      url: "http://localhost:4096/api/session",
-      body: { id: "ses_456" },
-    })
-  })
-
-  test("serializes deep-object query parameters from the opencode fixture", async () => {
-    const client = recordingClient(() => json({ directory: "/tmp" }))
-    const location = toolAt(OpenAPI.fromSpec({ spec: await opencodeSpec(), baseUrl }).tools, "v2.location.get")
-    if (!Tool.isDefinition(location)) throw new Error("v2.location.get was not generated")
-
-    await Effect.runPromise(
-      location.run({ location: { directory: "/tmp", workspace: "workspace-1" } }).pipe(Effect.provide(client.layer)),
-    )
-
-    const url = new URL(client.requests[0]!.url)
-    expect(url.searchParams.get("location[directory]")).toBe("/tmp")
-    expect(url.searchParams.get("location[workspace]")).toBe("workspace-1")
-  })
-
-  test("serializes supported simple and form parameter shapes", async () => {
-    const client = recordingClient(() => json({ ok: true }))
-    const result = OpenAPI.fromSpec({
-      baseUrl,
-      spec: {
-        openapi: "3.1.0",
-        paths: {
-          "/items/{keys}": {
-            get: {
-              operationId: "items",
-              parameters: [
-                { name: "keys", in: "path", required: true, schema: { type: "array", items: { type: "string" } } },
-                { name: "tags", in: "query", style: "form", explode: false, schema: { type: "array" } },
-                { name: "filter", in: "query", style: "form", explode: true, schema: { type: "object" } },
-                { name: "nullable", in: "query", required: true, schema: { type: ["string", "null"] } },
-                { name: "constructor", in: "query", schema: { type: "string" } },
-                { name: "meta", in: "header", style: "simple", explode: true, schema: { type: "object" } },
-              ],
-              responses: { 200: { description: "Success" } },
-            },
-          },
-        },
-      },
-    })
-    const tool = toolAt(result.tools, "items")
-    if (!Tool.isDefinition(tool)) throw new Error("items was not generated")
-
-    await Effect.runPromise(
-      tool
-        .run({
-          keys: ["a!", "b*"],
-          tags: ["x", "y"],
-          filter: { state: "open", page: 2 },
-          nullable: null,
-          constructor_2: "safe",
-          meta: { a: "b", c: "d" },
-        })
-        .pipe(Effect.provide(client.layer)),
-    )
-
-    const url = new URL(client.requests[0]!.url)
-    expect(url.pathname).toBe("/items/a%21,b%2A")
-    expect(url.searchParams.get("tags")).toBe("x,y")
-    expect(url.searchParams.get("state")).toBe("open")
-    expect(url.searchParams.get("page")).toBe("2")
-    expect(url.searchParams.get("nullable")).toBe("null")
-    expect(url.searchParams.get("constructor")).toBe("safe")
-    expect(client.requests[0]!.headers.meta).toBe("a=b,c=d")
-    await expect(
-      Effect.runPromise(tool.run({ keys: [undefined] }).pipe(Effect.provide(client.layer))),
-    ).rejects.toThrow("unsupported nested value")
-  })
-
-  test("skips unsupported parameter encodings and malformed security", () => {
-    const result = OpenAPI.fromSpec({
-      baseUrl,
-      spec: {
-        openapi: "3.1.0",
-        security: [{ bearer: [] }],
-        paths: {
-          "/cookie": {
-            get: {
-              operationId: "cookie",
-              parameters: [{ name: "session", in: "cookie", schema: { type: "string" } }],
-              responses: { 200: { description: "Success" } },
-            },
-          },
-          "/reserved": {
-            get: {
-              operationId: "reserved",
-              parameters: [{ name: "query", in: "query", allowReserved: true, schema: { type: "string" } }],
-              responses: { 200: { description: "Success" } },
-            },
-          },
-          "/invalid-style": {
-            get: {
-              operationId: "invalidStyle",
-              parameters: [{ name: "query", in: "query", style: 42, schema: { type: "string" } }],
-              responses: { 200: { description: "Success" } },
-            },
-          },
-          "/security": {
-            get: { operationId: "security", security: null, responses: { 200: { description: "Success" } } },
-          },
-        },
-      },
-    })
-
-    expect(result.tools).toEqual({})
-    expect(result.skipped.map((item) => item.reason)).toEqual([
-      "cookie parameter 'session' is not supported",
-      "parameter 'query' uses unsupported allowReserved encoding",
-      "parameter 'query' has an invalid style",
-      "security declaration is not an array",
-    ])
-  })
-
-  test("fails closed on prototype-named missing security schemes", () => {
-    const result = OpenAPI.fromSpec({
-      baseUrl,
-      spec: singleOperation({ security: [JSON.parse('{"__proto__":[]}')] }),
-    })
-
-    expect(result.tools).toEqual({})
-    expect(result.skipped[0]?.reason).toBe("security requirement references missing or malformed scheme: __proto__")
-  })
-
-  test("resolves bearer authentication without exposing it as input", async () => {
-    const contexts: Array<Parameters<OpenAPI.AuthResolver>[0]> = []
-    const client = recordingClient(() => json({ ok: true }))
-    const spec = {
-      ...singleOperation({ operationId: undefined }),
-      security: [{ bearer: [] }],
-      components: { securitySchemes: { bearer: { type: "http", scheme: "bearer" } } },
-    } satisfies Document
-    const tool = toolAt(
-      OpenAPI.fromSpec({
-        baseUrl,
-        spec,
-        auth: {
-          resolve: (context) => {
-            contexts.push(context)
-            return Effect.succeed({ type: "bearer", token: "secret" })
-          },
-        },
-      }).tools,
-      "getTest",
-    )
-    if (!Tool.isDefinition(tool)) throw new Error("test was not generated")
-
-    await Effect.runPromise(tool.run({}).pipe(Effect.provide(client.layer)))
-
-    expect(inputTypeScript(tool)).toBe("{}")
-    expect(client.requests[0]!.headers.authorization).toBe("Bearer secret")
-    expect(contexts).toEqual([
-      {
-        name: "bearer",
-        definition: { type: "http", scheme: "bearer" },
-        scopes: [],
-        operation: {
-          operationId: undefined,
-          method: "GET",
-          path: "/test",
-          summary: undefined,
-          description: undefined,
-        },
-      },
-    ])
-  })
-
-  test("applies authentication carriers without prototype or collision loss", async () => {
-    const client = recordingClient(() => json({ ok: true }))
-    const authenticated = (security: ReadonlyArray<Record<string, ReadonlyArray<string>>>, schemes: Record<string, unknown>) =>
-      OpenAPI.fromSpec({
-        baseUrl,
-        spec: { ...singleOperation({}), security, components: { securitySchemes: schemes } },
-        auth: { resolve: () => Effect.succeed({ type: "apiKey", value: "secret" }) },
-      })
-    const prototype = toolAt(
-      authenticated([{ key: [] }], { key: { type: "apiKey", in: "query", name: "__proto__" } }).tools,
-      "test",
-    )
-    if (!Tool.isDefinition(prototype)) throw new Error("prototype auth tool was not generated")
-
-    await Effect.runPromise(prototype.run({}).pipe(Effect.provide(client.layer)))
-    expect(new URL(client.requests[0]!.url).searchParams.get("__proto__")).toBe("secret")
-
-    const duplicate = toolAt(
-      authenticated(
-        [{ first: [], second: [] }],
-        {
-          first: { type: "apiKey", in: "header", name: "x-key" },
-          second: { type: "apiKey", in: "header", name: "x-key" },
-        },
-      ).tools,
-      "test",
-    )
-    if (!Tool.isDefinition(duplicate)) throw new Error("duplicate auth tool was not generated")
-    await expect(Effect.runPromise(duplicate.run({}).pipe(Effect.provide(client.layer)))).rejects.toThrow(
-      "multiple credentials",
-    )
-
-    const cookie = authenticated([{ key: [] }], { key: { type: "apiKey", in: "cookie", name: "session" } })
-    expect(cookie.tools).toEqual({})
-    expect(cookie.skipped[0]?.reason).toBe("cookie authentication 'key' is not supported")
-
-    const alternative = OpenAPI.fromSpec({
-      baseUrl,
-      spec: {
-        ...singleOperation({}),
-        security: [{ cookie: [] }, { bearer: [] }],
-        components: {
-          securitySchemes: {
-            cookie: { type: "apiKey", in: "cookie", name: "session" },
-            bearer: { type: "http", scheme: "bearer" },
-          },
-        },
-      },
-      auth: {
-        resolve: ({ name }) =>
-          Effect.succeed(name === "bearer" ? { type: "bearer", token: "secret" } : undefined),
-      },
-    })
-    const alternativeTool = toolAt(alternative.tools, "test")
-    if (!Tool.isDefinition(alternativeTool)) throw new Error("supported auth alternative was not generated")
-    await Effect.runPromise(alternativeTool.run({}).pipe(Effect.provide(client.layer)))
-    expect(client.requests.at(-1)?.headers.authorization).toBe("Bearer secret")
-  })
-
-  test("honors server precedence and rejects ambiguous base URLs", async () => {
-    const client = recordingClient(() => json({ ok: true }))
-    const spec = {
-      ...singleOperation({ servers: [{ url: "https://operation.example/v1" }] }),
-      servers: [{ url: "https://document.example" }],
-    } satisfies Document
-    const tool = toolAt(OpenAPI.fromSpec({ spec }).tools, "test")
-    if (!Tool.isDefinition(tool)) throw new Error("test was not generated")
-
-    await Effect.runPromise(tool.run({}).pipe(Effect.provide(client.layer)))
-    expect(client.requests[0]?.url).toBe("https://operation.example/v1/test")
-
-    const invalid = OpenAPI.fromSpec({ spec, baseUrl: "https://example.com/api?tenant=one" })
-    expect(invalid.tools).toEqual({})
-    expect(invalid.skipped[0]?.reason).toContain("unsupported query string or fragment")
-
-    const malformed = OpenAPI.fromSpec({ spec, baseUrl: "https:/example.com" })
-    expect(malformed.tools).toEqual({})
-    expect(malformed.skipped[0]?.reason).toContain("not an absolute HTTP(S) URL")
-  })
-
-  test("resolves chained response refs before detecting unsupported transports", () => {
-    const result = OpenAPI.fromSpec({
-      baseUrl,
-      spec: {
-        ...singleOperation({ responses: { 200: { $ref: "#/components/responses/First" } } }),
-        components: {
-          responses: {
-            First: { $ref: "#/components/responses/Stream" },
-            Stream: { content: { "text/event-stream": { schema: { type: "string" } } } },
-          },
-        },
-      },
-    })
-
-    expect(result.tools).toEqual({})
-    expect(result.skipped[0]?.reason).toBe("SSE operations are not supported")
-  })
-
-  test("resolves response schemas before detecting binary output", () => {
-    const result = OpenAPI.fromSpec({
-      baseUrl,
-      spec: {
-        ...singleOperation({
-          responses: {
-            200: {
-              content: { "text/plain": { schema: { $ref: "#/components/schemas/File" } } },
-            },
-          },
-        }),
-        components: { schemas: { File: { type: "string", format: "binary" } } },
-      },
-    })
-
-    expect(result.tools).toEqual({})
-    expect(result.skipped[0]?.reason).toBe("binary responses are not supported")
-  })
-
-  test("validates composite parameters before resolving auth", async () => {
-    const resolutions: Array<string> = []
-    const client = recordingClient(() => json({ ok: true }))
-    const tool = toolAt(
-      OpenAPI.fromSpec({
-        baseUrl,
-        spec: {
-          ...singleOperation({
-            parameters: [{ name: "filter", in: "query", style: "form", explode: true, schema: { type: "object" } }],
-          }),
-          security: [{ bearer: [] }],
-          components: { securitySchemes: { bearer: { type: "http", scheme: "bearer" } } },
-        },
-        auth: {
-          resolve: ({ name }) => {
-            resolutions.push(name)
-            return Effect.succeed({ type: "bearer", token: "secret" })
-          },
-        },
-      }).tools,
-      "test",
-    )
-    if (!Tool.isDefinition(tool)) throw new Error("test was not generated")
-
-    await expect(
-      Effect.runPromise(tool.run({ filter: { value: undefined } }).pipe(Effect.provide(client.layer))),
-    ).rejects.toThrow("unsupported nested value")
-    expect(resolutions).toEqual([])
-    expect(client.requests).toEqual([])
-  })
-
-  test("preserves JSON media types and rejects unencodable bodies", async () => {
-    const client = recordingClient(() => json({ ok: true }))
-    const tool = toolAt(
-      OpenAPI.fromSpec({
-        baseUrl,
-        spec: singleOperation(
-          {
-            requestBody: {
-              required: true,
-              content: { "application/merge-patch+json": { schema: { type: "object" } } },
-            },
-          },
-          "post",
-        ),
-      }).tools,
-      "test",
-    )
-    if (!Tool.isDefinition(tool)) throw new Error("test was not generated")
-
-    await Effect.runPromise(tool.run({ body: { name: "updated" } }).pipe(Effect.provide(client.layer)))
-    expect(client.requests[0]!.headers["content-type"]).toBe("application/merge-patch+json")
-    const cyclic: Record<string, unknown> = {}
-    cyclic.self = cyclic
-    await expect(Effect.runPromise(tool.run({ body: cyclic }).pipe(Effect.provide(client.layer)))).rejects.toThrow(
-      "Invalid JSON body",
-    )
-  })
-
-  test("rejects oversized and malformed JSON responses", async () => {
-    const tool = toolAt(OpenAPI.fromSpec({ baseUrl, spec: singleOperation({}) }).tools, "test")
-    if (!Tool.isDefinition(tool)) throw new Error("test was not generated")
-    const oversized = recordingClient(
-      () => new Response(null, { headers: { "content-length": String(50 * 1024 * 1024 + 1) } }),
-    )
-    const malformed = recordingClient(
-      () => new Response("{", { headers: { "content-type": "application/json" } }),
-    )
-    const chunked = recordingClient(() => new Response(new Uint8Array(50 * 1024 * 1024 + 1)))
-
-    await expect(Effect.runPromise(tool.run({}).pipe(Effect.provide(oversized.layer)))).rejects.toThrow(
-      "response exceeds 50 MiB",
-    )
-    await expect(Effect.runPromise(tool.run({}).pipe(Effect.provide(malformed.layer)))).rejects.toThrow(
-      "returned malformed JSON",
-    )
-    await expect(Effect.runPromise(tool.run({}).pipe(Effect.provide(chunked.layer)))).rejects.toThrow(
-      "response exceeds 50 MiB",
-    )
-  })
-
-  test("keeps non-JSON responses raw and unions every success output", async () => {
-    const spec = singleOperation({
-      responses: {
-        200: { description: "Text", content: { "text/plain": { schema: { type: "string" } } } },
-        204: { description: "Empty" },
-      },
-    })
-    const tool = toolAt(OpenAPI.fromSpec({ baseUrl, spec }).tools, "test")
-    if (!Tool.isDefinition(tool)) throw new Error("test was not generated")
-    const client = recordingClient(() => new Response("123", { headers: { "content-type": "text/plain" } }))
-
-    expect(outputTypeScript(tool)).toBe("string | null")
-    await expect(Effect.runPromise(tool.run({}).pipe(Effect.provide(client.layer)))).resolves.toBe("123")
-  })
-
-  test("fails missing required parameters before auth and network", async () => {
-    const { requests, layer } = recordingClient(() => json({}))
-    const runtime = CodeMode.make({
-      tools: { opencode: OpenAPI.fromSpec({ spec: await opencodeSpec(), baseUrl }).tools },
-    })
-
-    const result = await Effect.runPromise(
-      runtime.execute("return await tools.opencode.v2.session.get({})").pipe(Effect.provide(layer)),
-    )
-
-    expect(result).toMatchObject({ ok: false })
-    expect(JSON.stringify(result)).toContain("Missing required path parameter 'sessionID'")
-    expect(requests).toHaveLength(0)
-  })
-
-  test("prefixes cross-location collisions and reconstructs the HTTP request", async () => {
-    const spec = {
-      openapi: "3.1.0",
-      info: { title: "collision", version: "1.0.0" },
-      paths: {
-        "/echo": {
-          post: {
-            operationId: "echo",
-            requestBody: {
-              required: true,
-              content: { "application/json": { schema: { type: "string" } } },
-            },
-            responses: { "204": { description: "Echoed" } },
-          },
-        },
-        "/things/{id}": {
-          post: {
-            operationId: "things.update",
-            parameters: [
-              { name: "id", in: "path", required: true, schema: { type: "string" } },
-              { name: "id", in: "query", required: true, schema: { type: "string" } },
-              { name: "path_id", in: "query", schema: { type: "string" } },
-              { name: "id", in: "header", required: true, schema: { type: "string" } },
-            ],
-            requestBody: {
-              required: true,
-              content: {
-                "application/json": {
-                  schema: {
-                    type: "object",
-                    properties: { id: { type: "string" } },
-                    required: ["id"],
-                    additionalProperties: false,
-                  },
-                },
-              },
-            },
-            responses: { "204": { description: "Updated" } },
-          },
-        },
-      },
-    } satisfies Document
-    const { requests, layer } = recordingClient(() => new Response(null, { status: 204 }))
-    const tools = OpenAPI.fromSpec({ spec, baseUrl }).tools
-    const update = toolAt(tools, "things.update")
-    const echo = toolAt(tools, "echo")
-
-    expect(Tool.isDefinition(update)).toBe(true)
-    if (!Tool.isDefinition(update)) throw new Error("things.update was not generated")
-    expect(inputTypeScript(update)).toBe(
-      "{ path_id: string; query_id: string; path_id_2?: string; header_id: string; body_id: string }",
-    )
-    expect(Tool.isDefinition(echo)).toBe(true)
-    if (!Tool.isDefinition(echo)) throw new Error("echo was not generated")
-    expect(inputTypeScript(echo)).toBe("{ body: string }")
-
-    const runtime = CodeMode.make({ tools })
-    const result = await Effect.runPromise(
-      runtime
-        .execute(
-          `
-            const updated = await tools.things.update({ path_id: "path", query_id: "query", path_id_2: "literal", header_id: "header", body_id: "body" })
-            const echoed = await tools.echo({ body: "hello" })
-            return { updated, echoed }
-          `,
-        )
-        .pipe(Effect.provide(layer)),
-    )
-
-    expect(result).toMatchObject({ ok: true })
-    expect(requests).toHaveLength(2)
-    expect(new URL(requests[0]!.url).pathname).toBe("/things/path")
-    expect(new URL(requests[0]!.url).searchParams.get("id")).toBe("query")
-    expect(new URL(requests[0]!.url).searchParams.get("path_id")).toBe("literal")
-    expect(requests[0]!.headers.id).toBe("header")
-    expect(requests[0]!.body).toStrictEqual({ id: "body" })
-    expect(requests[1]!.body).toBe("hello")
-  })
-
-  test("keeps bodies nested when flattening would lose schema semantics", () => {
-    const body = (schema: Record<string, unknown>, required = true) => ({
-      required,
-      content: { "application/json": { schema } },
-    })
-    const spec = {
-      openapi: "3.1.0",
-      info: { title: "bodies", version: "1.0.0" },
-      paths: Object.fromEntries(
-        [
-          [
-            "optional",
-            body(
-              {
-                type: "object",
-                properties: { name: { type: "string" } },
-                required: ["name"],
-                additionalProperties: false,
-              },
-              false,
-            ),
-          ],
-          ["dictionary", body({ type: "object", additionalProperties: { type: "string" } })],
-          [
-            "composed",
-            body({
-              type: "object",
-              allOf: [{ type: "object", properties: { name: { type: "string" } }, required: ["name"] }],
-              additionalProperties: false,
-            }),
-          ],
-          [
-            "nullable",
-            body({
-              type: ["object", "null"],
-              properties: { name: { type: "string" } },
-              additionalProperties: false,
-            }),
-          ],
-        ].map(([name, requestBody]) => [
-          `/body/${name}`,
-          {
-            post: {
-              operationId: `body.${name}`,
-              requestBody,
-              responses: { "204": { description: "Accepted" } },
-            },
-          },
-        ]),
-      ),
-    } satisfies Document
-    const tools = OpenAPI.fromSpec({ spec, baseUrl }).tools
-
-    for (const name of ["optional", "dictionary", "composed", "nullable"]) {
-      const tool = toolAt(tools, `body.${name}`)
-      expect(Tool.isDefinition(tool)).toBe(true)
-      if (!Tool.isDefinition(tool)) throw new Error(`body.${name} was not generated`)
-      const input = isRecord(tool.input) ? tool.input : {}
-      expect(Object.keys(isRecord(input.properties) ? input.properties : {})).toStrictEqual(["body"])
-    }
-    const optional = toolAt(tools, "body.optional")
-    if (!Tool.isDefinition(optional)) throw new Error("body.optional was not generated")
-    expect(inputTypeScript(optional)).toBe("{ body?: { name: string } }")
-  })
-})
@@ -3,7 +3,7 @@ import { Effect } from "effect"
 import { CodeMode } from "../src/index.js"
 import { ToolRuntime } from "../src/tool-runtime.js"

-// Runs a CodeMode program with no host tools and returns the CodeMode.Result. These tests pin the
+// Runs a CodeMode program with no host tools and returns the ExecuteResult. These tests pin the
 // JS-parity behaviors for the "99% of ordinary defensive JavaScript just works" goal: cases where
 // a strict interpreter would throw but idiomatic JS yields undefined / succeeds.
 //
@@ -1,6 +1,6 @@
 import { describe, expect, test } from "bun:test"
 import { Effect, Schema } from "effect"
-import { CodeMode, Tool, toolError } from "../src/index.js"
+import { CodeMode, Tool, toolError, type ExecuteResult, type ExecutionLimits } from "../src/index.js"

 // Wave 5 acceptance suite: first-class promise values. Un-awaited tool calls start eagerly on
 // supervised fibers, `await` settles them, and Promise.all/allSettled/race/resolve/reject are
@@ -48,10 +48,7 @@ const failingTool = Tool.make({
  run: () => Effect.fail(toolError("Lookup refused")),
 })

-const run = (
-  code: string,
-  options: { trace?: Trace; limits?: CodeMode.ExecutionLimits } = {},
-): Promise<CodeMode.Result> => {
+const run = (code: string, options: { trace?: Trace; limits?: ExecutionLimits } = {}): Promise<ExecuteResult> => {
  const trace = options.trace ?? makeTrace()
  return Effect.runPromise(
    CodeMode.execute({
@@ -62,13 +59,13 @@ const run = (
  )
 }

-const value = async (code: string, options: { trace?: Trace; limits?: CodeMode.ExecutionLimits } = {}) => {
+const value = async (code: string, options: { trace?: Trace; limits?: ExecutionLimits } = {}) => {
  const result = await run(code, options)
  if (!result.ok) throw new Error(`expected success, got ${result.error.kind}: ${result.error.message}`)
  return result.value
 }

-const error = async (code: string, options: { trace?: Trace; limits?: CodeMode.ExecutionLimits } = {}) => {
+const error = async (code: string, options: { trace?: Trace; limits?: ExecutionLimits } = {}) => {
  const result = await run(code, options)
  if (result.ok) throw new Error(`expected failure, got value ${JSON.stringify(result.value)}`)
  return result.error
@@ -1,7 +1,7 @@
 import { describe, expect, test } from "bun:test"
 import { Effect, Schema } from "effect"
-import { CodeMode, Tool } from "../src/index.js"
-import { inputTypeScript, jsonSchemaToTypeScript, outputTypeScript } from "../src/tool-schema.js"
+import { CodeMode } from "../src/index.js"
+import { Tool, inputTypeScript, jsonSchemaToTypeScript, outputTypeScript } from "../src/tool.js"

 // A raw JSON Schema tool in the shape an MCP adapter produces: render-only input schema
 // whose property descriptions and constraints must surface as JSDoc in pretty signatures.
@@ -159,8 +159,8 @@ describe("pretty signature rendering", () => {
      $ref: "#/$defs/Node",
      $defs: { Node: { type: "object", properties: { child: { $ref: "#/$defs/Node" }, name: { type: "string" } } } },
    } as const
-    expect(jsonSchemaToTypeScript(cyclic)).toBe("{ child?: unknown; name?: string }")
-    expect(jsonSchemaToTypeScript(cyclic, true)).toContain("child?: unknown")
+    expect(jsonSchemaToTypeScript(cyclic)).toBe("{ child?: Node; name?: string }")
+    expect(jsonSchemaToTypeScript(cyclic, true)).toContain("child?: Node")

    let deep: Record<string, unknown> = { type: "string" }
    for (let level = 0; level < 12; level += 1) deep = { type: "object", properties: { next: deep } }
@@ -170,43 +170,6 @@ describe("pretty signature rendering", () => {
      expect(rendered).toContain("next?:")
    }
  })
-
-  test("intersects ref and union siblings instead of discarding them", () => {
-    expect(
-      jsonSchemaToTypeScript({
-        $ref: "#/$defs/User",
-        properties: { active: { type: "boolean" } },
-        required: ["active"],
-        $defs: {
-          User: { type: "object", properties: { id: { type: "string" } }, required: ["id"] },
-        },
-      }),
-    ).toBe("{ id: string } & { active: boolean }")
-    expect(
-      jsonSchemaToTypeScript({
-        type: "object",
-        properties: { common: { type: "boolean" } },
-        required: ["common"],
-        anyOf: [
-          { type: "object", properties: { name: { type: "string" } }, required: ["name"] },
-          { type: "object", properties: { count: { type: "number" } }, required: ["count"] },
-        ],
-      }),
-    ).toBe("({ name: string } | { count: number }) & { common: boolean }")
-    expect(jsonSchemaToTypeScript({ $ref: "https://example.com/schema.json" })).toBe("unknown")
-    expect(
-      jsonSchemaToTypeScript({
-        $ref: "#/$defs/User/properties/id",
-        $defs: { User: { type: "object" }, id: { type: "string" } },
-      }),
-    ).toBe("unknown")
-    expect(
-      jsonSchemaToTypeScript({
-        type: ["object", "null"],
-        properties: { name: { type: "string" } },
-      }),
-    ).toBe("{ name?: string } | null")
-  })
 })

 describe("non-identifier property names render as quoted keys", () => {
@@ -305,32 +268,6 @@ describe("union schemas render every alternative", () => {
    expect(inputTypeScript(tool)).toBe("{ value?: string | number }")
    expect(outputTypeScript(tool)).toBe("number | boolean")
  })
-
-  test("allOf renders intersections with parenthesized union members", () => {
-    const schema = {
-      allOf: [
-        { type: "object", properties: { id: { type: "string" } } },
-        { type: ["string", "null"] },
-      ],
-    } as const
-    expect(jsonSchemaToTypeScript(schema)).toBe("{ id?: string } & (string | null)")
-  })
-
-  test("allOf does not discard an unresolved constraint", () => {
-    expect(jsonSchemaToTypeScript({ allOf: [{ type: "string" }, { $ref: "https://example.com/external.json" }] })).toBe(
-      "unknown",
-    )
-    expect(
-      jsonSchemaToTypeScript({ allOf: [{ type: "string" }, { allOf: [{ $ref: "https://example.com/external.json" }] }] }),
-    ).toBe("unknown")
-    expect(
-      jsonSchemaToTypeScript({
-        type: "string",
-        allOf: [{ $ref: "#/$defs/Constraint" }],
-        $defs: { Constraint: { description: "TypeScript-neutral constraint" } },
-      }),
-    ).toBe("string")
-  })
 })

 describe("pretty signatures in search results", () => {
@@ -90,7 +90,6 @@
    "@ff-labs/fff-bun": "0.9.4",
    "@npmcli/arborist": "9.4.0",
    "@npmcli/config": "10.8.1",
-    "@opencode-ai/codemode": "workspace:*",
    "@opencode-ai/effect-drizzle-sqlite": "workspace:*",
    "@opencode-ai/effect-sqlite-node": "workspace:*",
    "@opencode-ai/llm": "workspace:*",
@@ -1,11 +1,12 @@
 export * as Catalog from "./catalog"

 import { makeLocationNode } from "./effect/app-node"
-import { Array, Context, Effect, Layer, Option, Order, pipe } from "effect"
+import { Array, Context, Effect, Layer, Option, Order, pipe, Schema } from "effect"
 import { Catalog } from "@opencode-ai/schema/catalog"
 import { ModelV2 } from "./model"
 import { ProviderV2 } from "./provider"
 import { EventV2 } from "./event"
+import { Policy } from "./policy"
 import { State } from "./state"
 import { Integration } from "./integration"

@@ -16,6 +17,8 @@ export type ProviderRecord = {

 export type DefaultModel = { providerID: ProviderV2.ID; modelID: ModelV2.ID }

+export const PolicyActions = Schema.Literals(["provider.use"])
+
 export const Event = Catalog.Event

 type Data = {
@@ -62,6 +65,7 @@ const layer = Layer.effect(
  Service,
  Effect.gen(function* () {
    const events = yield* EventV2.Service
+    const policy = yield* Policy.Service
    const integrations = yield* Integration.Service

    const available = (provider: ProviderV2.Info, integration: Integration.Info | undefined) => {
@@ -155,6 +159,13 @@ const layer = Layer.effect(
        return result
      },
      finalize: Effect.fn("CatalogV2.finalize")(function* (catalog) {
+        if (policy.hasStatements()) {
+          for (const record of [...catalog.provider.list()]) {
+            if ((yield* policy.evaluate("provider.use", record.provider.id, "allow")) === "deny") {
+              catalog.provider.remove(record.provider.id)
+            }
+          }
+        }
        yield* events.publish(Event.Updated, {})
      }),
    })
@@ -283,4 +294,4 @@ const layer = Layer.effect(

 const SMALL_MODEL_RE = /\b(nano|flash|lite|mini|haiku|small|fast)\b/

-export const node = makeLocationNode({ service: Service, layer, deps: [EventV2.node, Integration.node] })
+export const node = makeLocationNode({ service: Service, layer, deps: [EventV2.node, Policy.node, Integration.node] })
@@ -3,19 +3,18 @@ export * as Config from "./config"
 import { makeLocationNode } from "./effect/app-node"
 import path from "path"
 import { type ParseError, parse } from "jsonc-parser"
-import { Context, Effect, Fiber, Layer, Option, PubSub, Schema, Stream } from "effect"
+import { Context, Effect, Layer, Option, Schema } from "effect"
 import { Permission } from "@opencode-ai/schema/permission"
-import { Config as ConfigSchema } from "@opencode-ai/schema/config"
-import { EventV2 } from "./event"
-import { Watcher } from "./filesystem/watcher"
 import { FSUtil } from "./fs-util"
 import { Global } from "./global"
 import { Location } from "./location"
+import { Policy } from "./policy"
 import { AbsolutePath } from "./schema"
 import { ConfigAgent } from "./config/agent"
 import { ConfigAttachments } from "./config/attachments"
 import { ConfigCompaction } from "./config/compaction"
 import { ConfigCommand } from "./config/command"
+import { ConfigExperimental } from "./config/experimental"
 import { ConfigFormatter } from "./config/formatter"
 import { ConfigLSP } from "./config/lsp"
 import { ConfigMCP } from "./config/mcp"
@@ -23,7 +22,6 @@ import { ConfigPlugin } from "./config/plugin"
 import { ConfigProvider } from "./config/provider"
 import { ConfigReference } from "./config/reference"
 import { ConfigToolOutput } from "./config/tool-output"
-import { ConfigVariable } from "./config/variable"
 import { ConfigWatcher } from "./config/watcher"
 import { ConfigV1 } from "./v1/config/config"
 import { ConfigMigrateV1 } from "./v1/config/migrate"
@@ -102,8 +100,9 @@ export class Info extends Schema.Class<Info>("Config.Info")({
    description: "Named local directories or Git repositories available as external context",
  }),
  plugins: ConfigPlugin.Plugins.pipe(Schema.optional).annotate({
-    description: "Ordered plugin enablement directives and external package declarations",
+    description: "Ordered external plugin packages to load",
  }),
+  experimental: ConfigExperimental.Experimental.pipe(Schema.optional),
  providers: Schema.Record(Schema.String, ConfigProvider.Info).pipe(Schema.optional),
 }) {}

@@ -139,8 +138,7 @@ const layer = Layer.effect(
    const fs = yield* FSUtil.Service
    const global = yield* Global.Service
    const location = yield* Location.Service
-    const watcher = yield* Watcher.Service
-    const events = yield* EventV2.Service
+    const policy = yield* Policy.Service
    const names = ["opencode.json", "opencode.jsonc"]
    const decodeOptions = { errors: "all", onExcessProperty: "ignore", propertyOrder: "original" } as const
    const decodeInfo = Schema.decodeUnknownOption(Info, decodeOptions)
@@ -149,10 +147,9 @@ const layer = Layer.effect(
    const loadFile = Effect.fnUntraced(function* (filepath: string) {
      const text = yield* fs.readFileStringSafe(filepath)
      if (!text) return
-      const substituted = yield* ConfigVariable.substitute({ type: "path", path: filepath, text })

      const errors: ParseError[] = []
-      const input: unknown = parse(substituted, errors, { allowTrailingComma: true })
+      const input: unknown = parse(text, errors, { allowTrailingComma: true })
      if (errors.length) return

      const info = Option.getOrUndefined(
@@ -173,78 +170,45 @@ const layer = Layer.effect(
      ]
    })

-    const discover = Effect.fn("Config.discover")(function* () {
-      const globalDirectory = AbsolutePath.make(global.config)
-      const locationIsGlobal = path.resolve(location.directory) === path.resolve(global.config)
-      const discovered = locationIsGlobal
-        ? []
-        : yield* fs
-            .up({
-              targets: [".opencode", ...names.toReversed()],
-              start: location.directory,
-              stop: location.project.directory,
-            })
-            .pipe(Effect.orDie)
-      const directories = [
-        globalDirectory,
-        ...discovered
-          .filter((item) => path.basename(item) === ".opencode")
-          .toReversed()
-          .map((directory) => AbsolutePath.make(directory)),
-      ]
-      const directPaths = discovered.filter((item) => path.basename(item) !== ".opencode").toReversed()
-      const direct = yield* Effect.forEach(directPaths, loadFile).pipe(
-        Effect.orDie,
-        Effect.map((configs) => configs.filter((config): config is Document => config !== undefined)),
-      )
-      const supplementary = yield* Effect.forEach(directories, loadDirectory).pipe(Effect.orDie)
-      return {
-        entries: [...(supplementary[0] ?? []), ...direct, ...supplementary.slice(1).flat()],
-        directories,
-        files: directPaths,
-      }
-    })
-
-    const initial = yield* discover()
-    let configs = initial.entries
-    const updates = yield* PubSub.unbounded<Watcher.Update>()
-    const subscriptions = new Map<string, Effect.Effect<unknown>>()
-    const targets = (snapshot: typeof initial) => [
-      ...snapshot.directories.map((path) => ({ path, type: "directory" as const })),
-      ...snapshot.files
-        .filter((file) => !snapshot.directories.some((directory) => FSUtil.contains(directory, file)))
-        .map((path) => ({ path, type: "file" as const })),
+    const globalDirectory = AbsolutePath.make(global.config)
+    const locationIsGlobal = path.resolve(location.directory) === path.resolve(global.config)
+    // Read configuration once when this location opens. Later calls reuse these
+    // values until the location is reopened.
+    const discovered = locationIsGlobal
+      ? []
+      : yield* fs
+          .up({
+            targets: [".opencode", ...names.toReversed()],
+            start: location.directory,
+            stop: location.project.directory,
+          })
+          .pipe(Effect.orDie)
+    const directories = [
+      globalDirectory,
+      ...discovered
+        .filter((item) => path.basename(item) === ".opencode")
+        .toReversed()
+        .map((directory) => AbsolutePath.make(directory)),
    ]
-    const reconcile = Effect.fn("Config.reconcileWatches")(function* (snapshot: typeof initial) {
-      const next = new Map(targets(snapshot).map((target) => [JSON.stringify(target), target]))
-      for (const [key, stop] of subscriptions) {
-        if (next.has(key)) continue
-        yield* stop
-        subscriptions.delete(key)
-      }
-      for (const [key, target] of next) {
-        if (subscriptions.has(key)) continue
-        const fiber = yield* watcher.subscribe(target).pipe(
-          Stream.runForEach((update) => PubSub.publish(updates, update)),
-          Effect.forkScoped({ startImmediately: true }),
-        )
-        subscriptions.set(key, Fiber.interrupt(fiber))
-      }
-    })
-
-    yield* Stream.fromPubSub(updates).pipe(
-      Stream.debounce("100 millis"),
-      Stream.runForEach((update) =>
-        Effect.gen(function* () {
-          const next = yield* discover()
-          configs = next.entries
-          yield* reconcile(next)
-          yield* events.publish(ConfigSchema.Event.Updated, {})
-        }).pipe(Effect.catchCause((cause) => Effect.logError("failed to reload config", { path: update.path, cause }))),
-      ),
-      Effect.forkScoped({ startImmediately: true }),
+    // A config closer to the opened directory should win over one higher up.
+    // Search starts nearby, so reverse the results before applying them.
+    const directPaths = discovered.filter((item) => path.basename(item) !== ".opencode").toReversed()
+    const direct = yield* Effect.forEach(directPaths, loadFile).pipe(
+      Effect.orDie,
+      Effect.map((configs) => configs.filter((config): config is Document => config !== undefined)),
+    )
+    const supplementary = yield* Effect.forEach(directories, loadDirectory).pipe(Effect.orDie)
+    // Apply general settings first and more specific settings last:
+    // global config, project files, then `.opencode` files.
+    const configs = [...(supplementary[0] ?? []), ...direct, ...supplementary.slice(1).flat()]
+    // Rules use the opposite order so a user-global rule can override a
+    // repository rule. Statement order inside each file stays unchanged.
+    yield* policy.load(
+      configs
+        .filter((config): config is Document => config.type === "document")
+        .toReversed()
+        .flatMap((config) => config.info.experimental?.policies ?? []),
    )
-    yield* reconcile(initial)

    return Service.of({
      entries: Effect.fn("Config.entries")(function* () {
@@ -257,5 +221,5 @@ const layer = Layer.effect(
 export const node = makeLocationNode({
  service: Service,
  layer,
-  deps: [Watcher.node, EventV2.node, FSUtil.node, Global.node, Location.node],
+  deps: [FSUtil.node, Global.node, Location.node, Policy.node],
 })
@@ -0,0 +1,20 @@
+export * as ConfigExperimental from "./experimental"
+
+import { Schema } from "effect"
+import { Catalog } from "../catalog"
+import { Policy } from "../policy"
+
+// Each core domain exports the policy actions it supports. Adding an action to
+// this union makes it valid in authored config while keeping Policy generic.
+export const PolicyAction = Schema.Union([Catalog.PolicyActions])
+
+class PolicyConfig extends Schema.Class<PolicyConfig>("ConfigV2.Experimental.Policy")({
+  ...Policy.Info.fields,
+  action: PolicyAction,
+}) {}
+
+export { PolicyConfig as Policy }
+
+export class Experimental extends Schema.Class<Experimental>("ConfigV2.Experimental")({
+  policies: PolicyConfig.pipe(Schema.Array, Schema.optional),
+}) {}
@@ -1,8 +1,8 @@
 export * as ConfigAgentPlugin from "./agent"

-import { define } from "@opencode-ai/plugin/v2/effect/plugin"
+import { define } from "../../plugin/internal"
 import path from "path"
-import { Effect, Option, Schema, Stream } from "effect"
+import { Effect, Option, Schema } from "effect"
 import { AgentV2 } from "../../agent"
 import { Config } from "../../config"
 import { ConfigAgent } from "../agent"
@@ -34,79 +34,68 @@ const agentKeys = new Set([
 ])

 export const Plugin = define({
-  id: "opencode.config.agent",
+  id: "config-agent",
  effect: Effect.fn(function* (ctx) {
    const config = yield* Config.Service
    const fs = yield* FSUtil.Service
-    const load = Effect.fn("ConfigAgentPlugin.load")(function* () {
-      return yield* Effect.forEach(yield* config.entries(), (entry) => {
-        if (entry.type === "document") return Effect.succeed([entry])
-        return Effect.gen(function* () {
-          const files = yield* discover(fs, entry.path)
-          return yield* Effect.forEach(files, (file) =>
-            fs.readFileStringSafe(file.filepath).pipe(
-              Effect.map((content) => content && decode(file, content)),
-              Effect.catch(() => Effect.succeed(undefined)),
-            ),
-          ).pipe(
-            Effect.map((documents) =>
-              documents.filter((document): document is Config.Document => document !== undefined),
-            ),
-          )
-        })
-      }).pipe(Effect.map((documents) => documents.flat()))
-    })
-    const loaded = { documents: yield* load() }
-    yield* ctx.agent.transform((draft) => {
-      const global = loaded.documents.flatMap((document) => document.info.permissions ?? [])
-      const configuredDefault = Config.latest(loaded.documents, "default_agent")
-      if (configuredDefault !== undefined) draft.default(AgentV2.ID.make(configuredDefault))
-      for (const current of draft.list()) {
-        draft.update(current.id, (agent) => agent.permissions.push(...global))
-      }
-
-      for (const document of loaded.documents) {
-        for (const [id, item] of Object.entries(document.info.agents ?? {})) {
-          const agentID = AgentV2.ID.make(id)
-          if (item.disabled) {
-            draft.remove(agentID)
-            continue
-          }
-
-          const exists = draft.get(agentID) !== undefined
-          draft.update(agentID, (agent) => {
-            if (!exists) agent.permissions.push(...global)
-            if (item.model !== undefined) {
-              const model = ModelV2.parse(item.model)
-              agent.model = { id: model.modelID, providerID: model.providerID, variant: agent.model?.variant }
-            }
-            if (item.variant !== undefined && agent.model !== undefined) {
-              agent.model.variant = ModelV2.VariantID.make(item.variant)
-            }
-            if (item.request !== undefined) {
-              Object.assign(agent.request.headers, item.request.headers ?? {})
-              Object.assign(agent.request.body, item.request.body ?? {})
-            }
-            if (item.system !== undefined) agent.system = item.system
-            if (item.description !== undefined) agent.description = item.description
-            if (item.mode !== undefined) agent.mode = item.mode
-            if (item.hidden !== undefined) agent.hidden = item.hidden
-            if (item.color !== undefined) agent.color = item.color
-            if (item.steps !== undefined) agent.steps = item.steps
-            if (item.permissions !== undefined) agent.permissions.push(...item.permissions)
+    yield* ctx.agent.transform(
+      Effect.fn(function* (draft) {
+        const documents = yield* Effect.forEach(yield* config.entries(), (entry) => {
+          if (entry.type === "document") return Effect.succeed([entry])
+          return Effect.gen(function* () {
+            const files = yield* discover(fs, entry.path)
+            return yield* Effect.forEach(files, (file) =>
+              fs.readFileStringSafe(file.filepath).pipe(
+                Effect.map((content) => content && decode(file, content)),
+                Effect.catch(() => Effect.succeed(undefined)),
+              ),
+            ).pipe(
+              Effect.map((documents) =>
+                documents.filter((document): document is Config.Document => document !== undefined),
+              ),
+            )
          })
+        }).pipe(Effect.map((documents) => documents.flat()))
+        const global = documents.flatMap((document) => document.info.permissions ?? [])
+        const configuredDefault = Config.latest(documents, "default_agent")
+        if (configuredDefault !== undefined) draft.default(AgentV2.ID.make(configuredDefault))
+        for (const current of draft.list()) {
+          draft.update(current.id, (agent) => agent.permissions.push(...global))
        }
-      }
-    })
-    yield* ctx.event.subscribe().pipe(
-      Stream.filter((event) => event.type === "config.updated"),
-      Stream.runForEach(() =>
-        load().pipe(
-          Effect.tap((documents) => Effect.sync(() => (loaded.documents = documents))),
-          Effect.andThen(ctx.agent.reload()),
-        ),
-      ),
-      Effect.forkScoped({ startImmediately: true }),
+
+        for (const document of documents) {
+          for (const [id, item] of Object.entries(document.info.agents ?? {})) {
+            const agentID = AgentV2.ID.make(id)
+            if (item.disabled) {
+              draft.remove(agentID)
+              continue
+            }
+
+            const exists = draft.get(agentID) !== undefined
+            draft.update(agentID, (agent) => {
+              if (!exists) agent.permissions.push(...global)
+              if (item.model !== undefined) {
+                const model = ModelV2.parse(item.model)
+                agent.model = { id: model.modelID, providerID: model.providerID, variant: agent.model?.variant }
+              }
+              if (item.variant !== undefined && agent.model !== undefined) {
+                agent.model.variant = ModelV2.VariantID.make(item.variant)
+              }
+              if (item.request !== undefined) {
+                Object.assign(agent.request.headers, item.request.headers ?? {})
+                Object.assign(agent.request.body, item.request.body ?? {})
+              }
+              if (item.system !== undefined) agent.system = item.system
+              if (item.description !== undefined) agent.description = item.description
+              if (item.mode !== undefined) agent.mode = item.mode
+              if (item.hidden !== undefined) agent.hidden = item.hidden
+              if (item.color !== undefined) agent.color = item.color
+              if (item.steps !== undefined) agent.steps = item.steps
+              if (item.permissions !== undefined) agent.permissions.push(...item.permissions)
+            })
+          }
+        }
+      }),
    )
  }),
 })
@@ -1,8 +1,8 @@
 export * as ConfigCommandPlugin from "./command"

-import { define } from "@opencode-ai/plugin/v2/effect/plugin"
+import { define } from "../../plugin/internal"
 import path from "path"
-import { Effect, Option, Schema, Stream } from "effect"
+import { Effect, Option, Schema } from "effect"
 import { CommandV2 } from "../../command"
 import { Config } from "../../config"
 import { FSUtil } from "../../fs-util"
@@ -13,49 +13,38 @@ import { ConfigMarkdown } from "../markdown"
 const decodeCommand = Schema.decodeUnknownOption(ConfigCommand.Info)

 export const Plugin = define({
-  id: "opencode.config.command",
+  id: "config-command",
  effect: Effect.fn(function* (ctx) {
    const config = yield* Config.Service
    const fs = yield* FSUtil.Service
-    const load = Effect.fn("ConfigCommandPlugin.load")(function* () {
-      return yield* Effect.forEach(yield* config.entries(), (entry) => {
-        if (entry.type === "document") return Effect.succeed([{ commands: entry.info.commands }])
-        return loadDirectory(fs, entry.path).pipe(
-          Effect.map((commands) => [
-            { commands: Object.fromEntries(commands.map((command) => [command.name, command.info])) },
-          ]),
-        )
-      }).pipe(Effect.map((documents) => documents.flat()))
-    })
-    const loaded = { documents: yield* load() }
-    yield* ctx.command.transform((draft) => {
-      for (const document of loaded.documents) {
-        for (const [name, command] of Object.entries(document.commands ?? {})) {
-          draft.update(name, (item) => {
-            item.template = command.template
-            if (command.description !== undefined) item.description = command.description
-            if (command.agent !== undefined) item.agent = command.agent
-            if (command.model !== undefined) {
-              const model = ModelV2.parse(command.model)
-              item.model = { id: model.modelID, providerID: model.providerID, variant: item.model?.variant }
-            }
-            if (command.variant !== undefined && item.model !== undefined) {
-              item.model.variant = ModelV2.VariantID.make(command.variant)
-            }
-            if (command.subtask !== undefined) item.subtask = command.subtask
-          })
+    yield* ctx.command.transform(
+      Effect.fn(function* (draft) {
+        const documents = yield* Effect.forEach(yield* config.entries(), (entry) => {
+          if (entry.type === "document") return Effect.succeed([{ commands: entry.info.commands }])
+          return loadDirectory(fs, entry.path).pipe(
+            Effect.map((commands) => [
+              { commands: Object.fromEntries(commands.map((command) => [command.name, command.info])) },
+            ]),
+          )
+        }).pipe(Effect.map((documents) => documents.flat()))
+        for (const document of documents) {
+          for (const [name, command] of Object.entries(document.commands ?? {})) {
+            draft.update(name, (item) => {
+              item.template = command.template
+              if (command.description !== undefined) item.description = command.description
+              if (command.agent !== undefined) item.agent = command.agent
+              if (command.model !== undefined) {
+                const model = ModelV2.parse(command.model)
+                item.model = { id: model.modelID, providerID: model.providerID, variant: item.model?.variant }
+              }
+              if (command.variant !== undefined && item.model !== undefined) {
+                item.model.variant = ModelV2.VariantID.make(command.variant)
+              }
+              if (command.subtask !== undefined) item.subtask = command.subtask
+            })
+          }
        }
-      }
-    })
-    yield* ctx.event.subscribe().pipe(
-      Stream.filter((event) => event.type === "config.updated"),
-      Stream.runForEach(() =>
-        load().pipe(
-          Effect.tap((documents) => Effect.sync(() => (loaded.documents = documents))),
-          Effect.andThen(ctx.command.reload()),
-        ),
-      ),
-      Effect.forkScoped({ startImmediately: true }),
+      }),
    )
  }),
 })
@@ -0,0 +1,134 @@
+export * as ConfigExternalPlugin from "./external"
+
+import type { Plugin as EffectPlugin } from "@opencode-ai/plugin/v2/effect"
+import type { Plugin as PromisePlugin } from "@opencode-ai/plugin/v2/promise"
+import { Effect, Schema } from "effect"
+import path from "path"
+import { fileURLToPath, pathToFileURL } from "url"
+import { Config } from "../../config"
+import { FSUtil } from "../../fs-util"
+import { Location } from "../../location"
+import { Npm } from "../../npm"
+import { define } from "../../plugin/internal"
+import { PluginPromise } from "../../plugin/promise"
+
+const PluginModule = Schema.Struct({
+  default: Schema.Union([
+    Schema.Struct({
+      id: Schema.String,
+      effect: Schema.declare<EffectPlugin["effect"]>(
+        (input): input is EffectPlugin["effect"] => typeof input === "function",
+      ),
+    }),
+    Schema.Struct({
+      id: Schema.String,
+      setup: Schema.declare<PromisePlugin["setup"]>(
+        (input): input is PromisePlugin["setup"] => typeof input === "function",
+      ),
+    }),
+  ]),
+})
+
+const PluginPackage = Schema.Struct({
+  exports: Schema.optional(Schema.Unknown),
+  main: Schema.optional(Schema.String),
+  module: Schema.optional(Schema.String),
+})
+
+export const Plugin = define({
+  id: "config-plugin",
+  effect: Effect.fn(function* (ctx) {
+    const config = yield* Config.Service
+    const fs = yield* FSUtil.Service
+    const location = yield* Location.Service
+    const npm = yield* Npm.Service
+    yield* Effect.gen(function* () {
+      const configured: { package: string; options?: Record<string, any> }[] = []
+
+      for (const entry of yield* config.entries()) {
+        if (entry.type === "document") {
+          const directory = entry.path ? path.dirname(entry.path) : location.directory
+          for (const item of entry.info.plugins ?? []) {
+            const ref = typeof item === "string" ? { package: item } : item
+            const packageName = (() => {
+              if (ref.package.startsWith("file://")) return fileURLToPath(ref.package)
+              if (ref.package.startsWith("./") || ref.package.startsWith("../")) {
+                return path.resolve(directory, ref.package)
+              }
+              return ref.package
+            })()
+            configured.push({ package: packageName, options: ref.options })
+          }
+        }
+
+        if (entry.type === "directory") {
+          const files = yield* fs
+            .glob("{plugin,plugins}/*.{ts,js}", {
+              cwd: entry.path,
+              absolute: true,
+              include: "file",
+              dot: true,
+              symlink: true,
+            })
+            .pipe(Effect.orElseSucceed(() => []))
+          const directories = yield* fs
+            .glob("{plugin,plugins}/*", {
+              cwd: entry.path,
+              absolute: true,
+              include: "all",
+              dot: true,
+              symlink: true,
+            })
+            .pipe(
+              Effect.flatMap((items) =>
+                Effect.filter(items, (item) => fs.isDir(item), {
+                  concurrency: "unbounded",
+                }),
+              ),
+              Effect.orElseSucceed(() => []),
+            )
+          const packages = yield* Effect.forEach(
+            directories.sort(),
+            (directory) => resolvePackageEntrypoint(fs, directory),
+            { concurrency: "unbounded" },
+          ).pipe(Effect.map((items) => items.filter((item): item is string => item !== undefined)))
+          files.sort()
+          for (const file of files) configured.push({ package: file })
+          for (const file of packages) configured.push({ package: file })
+        }
+      }
+
+      for (const ref of configured) {
+        yield* Effect.gen(function* () {
+          const entrypoint = path.isAbsolute(ref.package)
+            ? pathToFileURL(ref.package).href
+            : (yield* npm.add(ref.package)).entrypoint
+          if (!entrypoint) return
+          yield* Effect.log({ msg: "loading plugin", id: ref.package, entrypoint })
+          const mod = yield* Effect.promise(() => import(entrypoint))
+          const value = (yield* Schema.decodeUnknownEffect(PluginModule)(mod)).default
+          const plugin = "effect" in value ? value : PluginPromise.fromPromise(value)
+          yield* ctx.plugin.add({
+            id: plugin.id,
+            effect: (host) => plugin.effect({ ...host, options: ref.options ?? {} }),
+          })
+        }).pipe(Effect.ignoreCause)
+      }
+    })
+  }),
+})
+
+const resolvePackageEntrypoint = Effect.fnUntraced(function* (fs: FSUtil.Interface, directory: string) {
+  const pkg = yield* fs.readJson(path.join(directory, "package.json")).pipe(
+    Effect.flatMap(Schema.decodeUnknownEffect(PluginPackage)),
+    Effect.catch(() => Effect.succeed(undefined)),
+  )
+  const exported = typeof pkg?.exports === "string" ? pkg.exports : undefined
+  const entries = [exported, pkg?.module, pkg?.main, "index.ts", "index.js"]
+
+  return yield* Effect.forEach(entries, (entry) => {
+    if (!entry) return Effect.succeed(undefined)
+    const file = path.resolve(directory, entry)
+    return fs.isFile(file).pipe(Effect.map((exists) => (exists ? file : undefined)))
+  }).pipe(Effect.map((items) => items.find((item): item is string => item !== undefined)))
+})
@@ -1,123 +1,116 @@
 export * as ConfigProviderPlugin from "./provider"

-import { define } from "@opencode-ai/plugin/v2/effect/plugin"
-import { Effect, Stream } from "effect"
+import { define } from "../../plugin/internal"
+import { Effect } from "effect"
 import { Config } from "../../config"
 import { ModelV2 } from "../../model"

 export const Plugin = define({
-  id: "opencode.config.provider",
+  id: "config-provider",
  effect: Effect.fn(function* (ctx) {
    const config = yield* Config.Service
-    const loaded = { entries: yield* config.entries() }
-    yield* ctx.integration.transform((integrations) => {
-      const files = loaded.entries.filter((entry): entry is Config.Document => entry.type === "document")
-      const configuredIntegrations = new Set(
-        files.flatMap((file) =>
-          Object.entries(file.info.providers ?? {}).flatMap(([id, provider]) =>
-            provider.env === undefined ? [] : [id],
+    yield* ctx.integration.transform(
+      Effect.fn(function* (integrations) {
+        const files = (yield* config.entries()).filter((entry): entry is Config.Document => entry.type === "document")
+        const configuredIntegrations = new Set(
+          files.flatMap((file) =>
+            Object.entries(file.info.providers ?? {}).flatMap(([id, provider]) =>
+              provider.env === undefined ? [] : [id],
+            ),
          ),
-        ),
-      )
-      for (const file of files) {
-        for (const [id, item] of Object.entries(file.info.providers ?? {})) {
-          const integrationID = id
-          if (!configuredIntegrations.has(id) && !integrations.get(integrationID)) continue
-          integrations.update(integrationID, (integration) => {
-            integration.name = item.name ?? integration.name
-          })
-          if (item.env !== undefined) {
-            integrations.method.update({
-              integrationID,
-              method: { type: "env", names: [...item.env] },
+        )
+        for (const file of files) {
+          for (const [id, item] of Object.entries(file.info.providers ?? {})) {
+            const integrationID = id
+            if (!configuredIntegrations.has(id) && !integrations.get(integrationID)) continue
+            integrations.update(integrationID, (integration) => {
+              integration.name = item.name ?? integration.name
            })
-          }
-        }
-      }
-    })
-
-    yield* ctx.catalog.transform((catalog) => {
-      const files = loaded.entries.filter((entry): entry is Config.Document => entry.type === "document")
-      const configuredDefault = Config.latest(loaded.entries, "model")
-      if (configuredDefault !== undefined) {
-        const model = ModelV2.parse(configuredDefault)
-        catalog.model.default.set(model.providerID, model.modelID)
-      }
-      for (const file of files) {
-        for (const [id, item] of Object.entries(file.info.providers ?? {})) {
-          const providerID = id
-          catalog.provider.update(providerID, (provider) => {
-            if (item.name !== undefined) provider.name = item.name
-            if (item.api !== undefined) provider.api = { ...item.api }
-            if (item.request !== undefined) {
-              Object.assign(provider.request.settings, item.request.settings)
-              Object.assign(provider.request.headers, item.request.headers)
-              Object.assign(provider.request.body, item.request.body)
+            if (item.env !== undefined) {
+              integrations.method.update({
+                integrationID,
+                method: { type: "env", names: [...item.env] },
+              })
            }
-          })
-          for (const [id, config] of Object.entries(item.models ?? {})) {
-            catalog.model.update(providerID, id, (model) => {
-              if (config.family !== undefined) model.family = config.family
-              if (config.name !== undefined) model.name = config.name
-              if (config.api !== undefined) model.api = { ...model.api, ...config.api }
-              if (config.capabilities !== undefined) {
-                model.capabilities = {
-                  tools: config.capabilities.tools,
-                  input: [...config.capabilities.input],
-                  output: [...config.capabilities.output],
-                }
-              }
-              if (config.request !== undefined) {
-                Object.assign(model.request.settings, config.request.settings)
-                Object.assign(model.request.headers, config.request.headers)
-                Object.assign(model.request.body, config.request.body)
-                if (config.request.variant !== undefined) model.request.variant = config.request.variant
-              }
-              if (config.variants !== undefined) {
-                for (const variant of config.variants) {
-                  let existing = model.variants.find((item) => item.id === variant.id)
-                  if (!existing) {
-                    existing = {
-                      id: variant.id,
-                      settings: {},
-                      headers: {},
-                      body: {},
-                    }
-                    model.variants.push(existing)
-                  }
-                  Object.assign(existing.settings, variant.settings)
-                  Object.assign(existing.headers, variant.headers)
-                  Object.assign(existing.body, variant.body)
-                }
-              }
-              if (config.cost !== undefined) {
-                model.cost = (Array.isArray(config.cost) ? config.cost : [config.cost]).map((cost) => ({
-                  tier: cost.tier && { ...cost.tier },
-                  input: cost.input,
-                  output: cost.output,
-                  cache: {
-                    read: cost.cache?.read ?? 0,
-                    write: cost.cache?.write ?? 0,
-                  },
-                }))
-              }
-              if (config.disabled !== undefined) model.enabled = !config.disabled
-              if (config.limit !== undefined) model.limit = { ...model.limit, ...config.limit }
-            })
          }
        }
-      }
-    })
-    yield* ctx.event.subscribe().pipe(
-      Stream.filter((event) => event.type === "config.updated"),
-      Stream.runForEach(() =>
-        config.entries().pipe(
-          Effect.tap((entries) => Effect.sync(() => (loaded.entries = entries))),
-          Effect.andThen(ctx.integration.reload()),
-          Effect.andThen(ctx.catalog.reload()),
-        ),
-      ),
-      Effect.forkScoped({ startImmediately: true }),
+      }),
+    )
+
+    yield* ctx.catalog.transform(
+      Effect.fn(function* (catalog) {
+        const entries = yield* config.entries()
+        const files = entries.filter((entry): entry is Config.Document => entry.type === "document")
+        const configuredDefault = Config.latest(entries, "model")
+        if (configuredDefault !== undefined) {
+          const model = ModelV2.parse(configuredDefault)
+          catalog.model.default.set(model.providerID, model.modelID)
+        }
+        for (const file of files) {
+          for (const [id, item] of Object.entries(file.info.providers ?? {})) {
+            const providerID = id
+            catalog.provider.update(providerID, (provider) => {
+              if (item.name !== undefined) provider.name = item.name
+              if (item.api !== undefined) provider.api = { ...item.api }
+              if (item.request !== undefined) {
+                Object.assign(provider.request.settings, item.request.settings)
+                Object.assign(provider.request.headers, item.request.headers)
+                Object.assign(provider.request.body, item.request.body)
+              }
+            })
+            for (const [id, config] of Object.entries(item.models ?? {})) {
+              catalog.model.update(providerID, id, (model) => {
+                if (config.family !== undefined) model.family = config.family
+                if (config.name !== undefined) model.name = config.name
+                if (config.api !== undefined) model.api = { ...model.api, ...config.api }
+                if (config.capabilities !== undefined) {
+                  model.capabilities = {
+                    tools: config.capabilities.tools,
+                    input: [...config.capabilities.input],
+                    output: [...config.capabilities.output],
+                  }
+                }
+                if (config.request !== undefined) {
+                  Object.assign(model.request.settings, config.request.settings)
+                  Object.assign(model.request.headers, config.request.headers)
+                  Object.assign(model.request.body, config.request.body)
+                  if (config.request.variant !== undefined) model.request.variant = config.request.variant
+                }
+                if (config.variants !== undefined) {
+                  for (const variant of config.variants) {
+                    let existing = model.variants.find((item) => item.id === variant.id)
+                    if (!existing) {
+                      existing = {
+                        id: variant.id,
+                        settings: {},
+                        headers: {},
+                        body: {},
+                      }
+                      model.variants.push(existing)
+                    }
+                    Object.assign(existing.settings, variant.settings)
+                    Object.assign(existing.headers, variant.headers)
+                    Object.assign(existing.body, variant.body)
+                  }
+                }
+                if (config.cost !== undefined) {
+                  model.cost = (Array.isArray(config.cost) ? config.cost : [config.cost]).map((cost) => ({
+                    tier: cost.tier && { ...cost.tier },
+                    input: cost.input,
+                    output: cost.output,
+                    cache: {
+                      read: cost.cache?.read ?? 0,
+                      write: cost.cache?.write ?? 0,
+                    },
+                  }))
+                }
+                if (config.disabled !== undefined) model.enabled = !config.disabled
+                if (config.limit !== undefined) model.limit = { ...model.limit, ...config.limit }
+              })
+            }
+          }
+        }
+      }),
    )
  }),
 })
@@ -1,8 +1,8 @@
 export * as ConfigReferencePlugin from "./reference"

-import { define } from "@opencode-ai/plugin/v2/effect/plugin"
+import { define } from "../../plugin/internal"
 import path from "path"
-import { Effect, Stream } from "effect"
+import { Effect } from "effect"
 import { Config } from "../../config"
 import { ConfigReference } from "../reference"
 import { Reference } from "../../reference"
@@ -11,52 +11,45 @@ import { Global } from "../../global"
 import { Location } from "../../location"

 export const Plugin = define({
-  id: "opencode.config.reference",
+  id: "core/config-reference",
  effect: Effect.fn(function* (ctx) {
    const config = yield* Config.Service
    const location = yield* Location.Service
    const global = yield* Global.Service
-    const loaded = { entries: yield* config.entries() }
-    yield* ctx.reference.transform((draft) => {
-      const entries = new Map<string, Reference.Source>()
-      for (const doc of loaded.entries.filter((entry): entry is Config.Document => entry.type === "document")) {
-        const directory = doc.path ? path.dirname(doc.path) : location.directory
-        for (const [name, entry] of Object.entries(doc.info.references ?? {})) {
-          if (!validAlias(name)) continue
-          const description = typeof entry === "string" ? undefined : entry.description
-          const hidden = typeof entry === "string" ? undefined : entry.hidden
-          entries.set(
-            name,
-            local(entry)
-              ? Reference.LocalSource.make({
-                  type: "local",
-                  path: AbsolutePath.make(
-                    localPath(directory, global.home, typeof entry === "string" ? entry : entry.path),
-                  ),
-                  ...(description === undefined ? {} : { description }),
-                  ...(hidden === undefined ? {} : { hidden }),
-                })
-              : Reference.GitSource.make({
-                  type: "git",
-                  repository: typeof entry === "string" ? entry : entry.repository,
-                  ...(entry.branch === undefined ? {} : { branch: entry.branch }),
-                  ...(description === undefined ? {} : { description }),
-                  ...(hidden === undefined ? {} : { hidden }),
-                }),
-          )
+    yield* ctx.reference.transform(
+      Effect.fn(function* (draft) {
+        const entries = new Map<string, Reference.Source>()
+        for (const doc of (yield* config.entries()).filter(
+          (entry): entry is Config.Document => entry.type === "document",
+        )) {
+          const directory = doc.path ? path.dirname(doc.path) : location.directory
+          for (const [name, entry] of Object.entries(doc.info.references ?? {})) {
+            if (!validAlias(name)) continue
+            const description = typeof entry === "string" ? undefined : entry.description
+            const hidden = typeof entry === "string" ? undefined : entry.hidden
+            entries.set(
+              name,
+              local(entry)
+                ? Reference.LocalSource.make({
+                    type: "local",
+                    path: AbsolutePath.make(
+                      localPath(directory, global.home, typeof entry === "string" ? entry : entry.path),
+                    ),
+                    ...(description === undefined ? {} : { description }),
+                    ...(hidden === undefined ? {} : { hidden }),
+                  })
+                : Reference.GitSource.make({
+                    type: "git",
+                    repository: typeof entry === "string" ? entry : entry.repository,
+                    ...(entry.branch === undefined ? {} : { branch: entry.branch }),
+                    ...(description === undefined ? {} : { description }),
+                    ...(hidden === undefined ? {} : { hidden }),
+                  }),
+            )
+          }
        }
-      }
-      for (const [name, source] of entries) draft.add(name, source)
-    })
-    yield* ctx.event.subscribe().pipe(
-      Stream.filter((event) => event.type === "config.updated"),
-      Stream.runForEach(() =>
-        config.entries().pipe(
-          Effect.tap((entries) => Effect.sync(() => (loaded.entries = entries))),
-          Effect.andThen(ctx.reference.reload()),
-        ),
-      ),
-      Effect.forkScoped({ startImmediately: true }),
+        for (const [name, source] of entries) draft.add(name, source)
+      }),
    )
  }),
 })
@@ -1,8 +1,8 @@
 export * as ConfigSkillPlugin from "./skill"

-import { define } from "@opencode-ai/plugin/v2/effect/plugin"
+import { define } from "../../plugin/internal"
 import path from "path"
-import { Effect, Stream } from "effect"
+import { Effect } from "effect"
 import { Config } from "../../config"
 import { AbsolutePath } from "../../schema"
 import { SkillV2 } from "../../skill"
@@ -10,49 +10,41 @@ import { Global } from "../../global"
 import { Location } from "../../location"

 export const Plugin = define({
-  id: "opencode.config.skill",
+  id: "config-skill",
  effect: Effect.fn(function* (ctx) {
    const config = yield* Config.Service
    const global = yield* Global.Service
    const location = yield* Location.Service
-    const loaded = { entries: yield* config.entries() }
-    yield* ctx.skill.transform((draft) => {
-      const directories = loaded.entries.flatMap((entry) => (entry.type === "directory" ? [entry.path] : []))
-      const items = loaded.entries.flatMap((entry) => (entry.type === "document" ? (entry.info.skills ?? []) : []))
-      for (const directory of directories) {
-        draft.source(
-          SkillV2.DirectorySource.make({ type: "directory", path: AbsolutePath.make(path.join(directory, "skill")) }),
-        )
-        draft.source(
-          SkillV2.DirectorySource.make({
-            type: "directory",
-            path: AbsolutePath.make(path.join(directory, "skills")),
-          }),
-        )
-      }
-      for (const item of items) {
-        if (URL.canParse(item) && /^(https?:)$/.test(new URL(item).protocol)) {
-          draft.source(SkillV2.UrlSource.make({ type: "url", url: item }))
-          continue
+    yield* ctx.skill.transform(
+      Effect.fn(function* (draft) {
+        const entries = yield* config.entries()
+        const directories = entries.flatMap((entry) => (entry.type === "directory" ? [entry.path] : []))
+        const items = entries.flatMap((entry) => (entry.type === "document" ? (entry.info.skills ?? []) : []))
+        for (const directory of directories) {
+          draft.source(
+            SkillV2.DirectorySource.make({ type: "directory", path: AbsolutePath.make(path.join(directory, "skill")) }),
+          )
+          draft.source(
+            SkillV2.DirectorySource.make({
+              type: "directory",
+              path: AbsolutePath.make(path.join(directory, "skills")),
+            }),
+          )
        }
-        const expanded = item.startsWith("~/") ? path.join(global.home, item.slice(2)) : item
-        draft.source(
-          SkillV2.DirectorySource.make({
-            type: "directory",
-            path: AbsolutePath.make(path.isAbsolute(expanded) ? expanded : path.join(location.directory, expanded)),
-          }),
-        )
-      }
-    })
-    yield* ctx.event.subscribe().pipe(
-      Stream.filter((event) => event.type === "config.updated"),
-      Stream.runForEach(() =>
-        config.entries().pipe(
-          Effect.tap((entries) => Effect.sync(() => (loaded.entries = entries))),
-          Effect.andThen(ctx.skill.reload()),
-        ),
-      ),
-      Effect.forkScoped({ startImmediately: true }),
+        for (const item of items) {
+          if (URL.canParse(item) && /^(https?:)$/.test(new URL(item).protocol)) {
+            draft.source(SkillV2.UrlSource.make({ type: "url", url: item }))
+            continue
+          }
+          const expanded = item.startsWith("~/") ? path.join(global.home, item.slice(2)) : item
+          draft.source(
+            SkillV2.DirectorySource.make({
+              type: "directory",
+              path: AbsolutePath.make(path.isAbsolute(expanded) ? expanded : path.join(location.directory, expanded)),
+            }),
+          )
+        }
+      }),
    )
  }),
 })
@@ -1,85 +0,0 @@
-export * as ConfigVariable from "./variable"
-
-import os from "os"
-import path from "path"
-import { Effect } from "effect"
-import { FSUtil } from "../fs-util"
-import { InvalidError } from "../v1/config/error"
-
-type ParseSource =
-  | {
-      type: "path"
-      path: string
-    }
-  | {
-      type: "virtual"
-      source: string
-      dir: string
-    }
-
-type SubstituteInput = ParseSource & {
-  text: string
-  missing?: "error" | "empty"
-  env?: Record<string, string>
-}
-
-/** Apply {env:VAR} and {file:path} substitutions to config text. */
-export const substitute = Effect.fn("ConfigVariable.substitute")(function* (input: SubstituteInput) {
-  const text = input.text.replace(
-    /\{env:([^}]+)\}/g,
-    (_, varName: string) => (input.env?.[varName] ?? process.env[varName]) || "",
-  )
-  if (!text.includes("{file:")) return text
-  return yield* substituteFiles(input, text)
-})
-
-const substituteFiles = Effect.fnUntraced(function* (input: SubstituteInput, text: string) {
-  const fs = yield* FSUtil.Service
-  const configDir = input.type === "path" ? path.dirname(input.path) : input.dir
-  const configSource = input.type === "path" ? input.path : input.source
-  const matches = Array.from(text.matchAll(/\{file:[^}]+\}/g))
-  let out = ""
-  let cursor = 0
-
-  for (const match of matches) {
-    const token = match[0]
-    const index = match.index
-    out += text.slice(cursor, index)
-
-    const lineStart = text.lastIndexOf("\n", index - 1) + 1
-    const prefix = text.slice(lineStart, index).trimStart()
-    if (prefix.startsWith("//")) {
-      out += token
-      cursor = index + token.length
-      continue
-    }
-
-    const filePath = token.replace(/^\{file:/, "").replace(/\}$/, "")
-    const expandedPath = filePath.startsWith("~/") ? path.join(os.homedir(), filePath.slice(2)) : filePath
-    const resolvedPath = path.isAbsolute(expandedPath) ? expandedPath : path.resolve(configDir, expandedPath)
-    const fileContent = yield* fs.readFileString(resolvedPath).pipe(
-      Effect.catch((error) => {
-        if (input.missing === "empty") return Effect.succeed("")
-
-        const message = `bad file reference: "${token}"`
-        return Effect.fail(
-          new InvalidError(
-            {
-              path: configSource,
-              message:
-                error._tag === "PlatformError" && error.reason._tag === "NotFound"
-                  ? `${message} ${resolvedPath} does not exist`
-                  : message,
-            },
-            { cause: error },
-          ),
-        )
-      }),
-    )
-
-    out += JSON.stringify(fileContent.trim()).slice(1, -1)
-    cursor = index + token.length
-  }
-
-  return out + text.slice(cursor)
-})
@@ -43,6 +43,5 @@ export const migrations = (
    import("./migration/20260702134641_add_session_context_entry"),
    import("./migration/20260703090000_reset_v2_event_rename_sweep"),
    import("./migration/20260703181610_event_created_column"),
-    import("./migration/20260703190000_reset_v2_shell_event_payloads"),
  ])
 ).map((module) => module.default) satisfies DatabaseMigration.Migration[]
@@ -1,14 +0,0 @@
-import { Effect } from "effect"
-import type { DatabaseMigration } from "../migration"
-
-export default {
-  id: "20260703190000_reset_v2_shell_event_payloads",
-  up(tx) {
-    return Effect.gen(function* () {
-      yield* tx.run(`DELETE FROM \`session_input\`;`)
-      yield* tx.run(`DELETE FROM \`session_message\`;`)
-      yield* tx.run(`DELETE FROM \`event\`;`)
-      yield* tx.run(`DELETE FROM \`event_sequence\`;`)
-    })
-  },
-} satisfies DatabaseMigration.Migration
@@ -1,24 +0,0 @@
-export * as EventLogger from "./event-logger"
-
-import { Effect, Layer } from "effect"
-import { makeGlobalNode } from "./effect/app-node"
-import { EventV2 } from "./event"
-
-const Types = new Set([
-  "agent.updated",
-  "catalog.updated",
-  "command.updated",
-  "config.updated",
-])
-
-export const layer = Layer.effectDiscard(
-  Effect.gen(function* () {
-    const events = yield* EventV2.Service
-    const unsubscribe = yield* events.listen((event) =>
-      Types.has(event.type) ? Effect.logInfo("event", { event }) : Effect.void,
-    )
-    yield* Effect.addFinalizer(() => unsubscribe)
-  }),
-)
-
-export const node = makeGlobalNode({ name: "event-logger", layer, deps: [EventV2.node] })
@@ -160,22 +160,15 @@ export interface Interface {

 export class Service extends Context.Service<Service, Interface>()("@opencode/Event") {}

-export const liveBounded = (
-  events: Interface,
-  options: { readonly capacity: number; readonly accept?: (event: Payload) => boolean },
-) =>
+export const liveBounded = (events: Interface, capacity: number) =>
  Effect.gen(function* () {
-    const queue = yield* Queue.dropping<Payload, SubscriberOverflowError>(options.capacity)
+    const queue = yield* Queue.dropping<Payload, SubscriberOverflowError>(capacity)
    const unsubscribe = yield* events.listen((event) =>
-      options.accept && !options.accept(event)
-        ? Effect.void
-        : Queue.offer(queue, event).pipe(
-            Effect.flatMap((accepted) =>
-              accepted
-                ? Effect.void
-                : Queue.fail(queue, new SubscriberOverflowError({ capacity: options.capacity })).pipe(Effect.asVoid),
-            ),
-          ),
+      Queue.offer(queue, event).pipe(
+        Effect.flatMap((accepted) =>
+          accepted ? Effect.void : Queue.fail(queue, new SubscriberOverflowError({ capacity })).pipe(Effect.asVoid),
+        ),
+      ),
    )
    yield* Effect.addFinalizer(() => unsubscribe.pipe(Effect.andThen(Queue.shutdown(queue)), Effect.asVoid))
    return Stream.fromQueue(queue)
@@ -583,32 +576,12 @@ export const layerWith = (options?: LayerOptions) =>
          .pipe(Effect.orDie)
      }

-      const local = <A extends Payload>(stream: Stream.Stream<A>) =>
-        Stream.unwrap(
-          Effect.serviceOption(Location.Service).pipe(
-            Effect.map((location) =>
-              Option.match(location, {
-                onNone: () => stream,
-                onSome: (location) =>
-                  stream.pipe(
-                    Stream.filter(
-                      (event) =>
-                        !event.location ||
-                        (event.location.directory === location.directory &&
-                          event.location.workspaceID === location.workspaceID),
-                    ),
-                  ),
-              }),
-            ),
-          ),
-        )
-
      const subscribe = <D extends Definition>(definition: D): Stream.Stream<Payload<D>> =>
-        local(Stream.unwrap(getOrCreate(definition).pipe(Effect.map((pubsub) => Stream.fromPubSub(pubsub))))).pipe(
+        Stream.unwrap(getOrCreate(definition).pipe(Effect.map((pubsub) => Stream.fromPubSub(pubsub)))).pipe(
          Stream.map((event) => event as Payload<D>),
        )

-      const streamLive = (): Stream.Stream<Payload> => local(Stream.fromPubSub(pubsub.live))
+      const streamLive = (): Stream.Stream<Payload> => Stream.fromPubSub(pubsub.live)

      const readAfter = (
        aggregateID: string,
@@ -45,7 +45,7 @@ const FILES = [
  "**/.nyc_output/**",
 ]

-export const PATTERNS = [...FILES, ...FOLDERS, `**/{${Array.from(FOLDERS).join(",")}}/**`]
+export const PATTERNS = [...FILES, ...FOLDERS]

 export function match(filepath: string, opts?: { extra?: string[]; whitelist?: string[] }) {
  for (const pattern of opts?.whitelist || []) {
@@ -1,90 +0,0 @@
-export * as LocationWatcher from "./location-watcher"
-
-import { makeLocationNode } from "../effect/app-node"
-import { Context, Effect, Layer, Stream } from "effect"
-import { FileSystem } from "@opencode-ai/schema/filesystem"
-import os from "os"
-import path from "path"
-import { Config } from "../config"
-import { EventV2 } from "../event"
-import { FSUtil } from "../fs-util"
-import { Git } from "../git"
-import { Location } from "../location"
-import { Watcher } from "./watcher"
-import { Ignore } from "./ignore"
-import { Protected } from "./protected"
-
-function protecteds(dir: string) {
-  return Protected.paths().filter((item) => {
-    const relative = path.relative(dir, item)
-    return relative !== "" && !relative.startsWith("..") && !path.isAbsolute(relative)
-  })
-}
-
-export interface Interface {}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/LocationWatcher") {}
-
-const layer = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const location = yield* Location.Service
-    const watcher = yield* Watcher.Service
-    const events = yield* EventV2.Service
-    const fs = yield* FSUtil.Service
-    const git = yield* Git.Service
-    const configService = yield* Config.Service
-    const publish = (update: { type: "create" | "update" | "delete"; path: string }) =>
-      events.publish(FileSystem.Event.Changed, {
-        file: update.path,
-        event: update.type === "create" ? "add" : update.type === "update" ? "change" : "unlink",
-      })
-
-    yield* Effect.gen(function* () {
-      const config = (yield* configService.entries())
-        .filter((entry): entry is Config.Document => entry.type === "document")
-        .flatMap((item) => item.info.watcher?.ignore ?? [])
-      const home = path.resolve(location.directory) === path.resolve(os.homedir())
-
-      if (!home) {
-        yield* watcher
-          .subscribe({
-            path: location.directory,
-            type: "directory",
-            ignore: [...Ignore.PATTERNS, ...config, ...protecteds(location.directory)],
-          })
-          .pipe(Stream.runForEach(publish), Effect.forkScoped)
-      }
-      if (home) {
-        yield* Effect.logInfo("location watcher skipped home directory", { directory: location.directory })
-      }
-
-      if (location.vcs?.type === "git") {
-        const resolved = (yield* git.repo.discover(location.directory))?.gitDirectory
-        const vcs = resolved
-          ? yield* fs.realPath(resolved).pipe(Effect.catch(() => Effect.succeed(resolved)))
-          : undefined
-        if (vcs && !config.includes(".git") && !config.includes(vcs) && (!resolved || !config.includes(resolved))) {
-          const ignore = (yield* fs.readDirectoryEntries(vcs).pipe(Effect.catch(() => Effect.succeed([])))).flatMap(
-            (entry) => (entry.name === "HEAD" ? [] : [entry.name]),
-          )
-          yield* watcher
-            .subscribe({ path: vcs, type: "directory", ignore })
-            .pipe(Stream.runForEach(publish), Effect.forkScoped)
-        }
-      }
-    }).pipe(
-      Effect.withSpan("LocationWatcher.start", { attributes: { directory: location.directory } }),
-      Effect.catchCause((cause) => Effect.logError("failed to init location watcher service", { cause })),
-      Effect.forkScoped,
-    )
-
-    return Service.of({})
-  }),
-)
-
-export const node = makeLocationNode({
-  service: Service,
-  layer,
-  deps: [Watcher.node, FSUtil.node, Location.node, Config.node, Git.node, EventV2.node],
-})
@@ -3,20 +3,26 @@ export * as Watcher from "./watcher"
 // @ts-ignore
 import { createWrapper } from "@parcel/watcher/wrapper"
 import type ParcelWatcher from "@parcel/watcher"
-import { FileSystem } from "@opencode-ai/schema/filesystem"
-import { makeGlobalNode } from "../effect/app-node"
-import { Cause, Context, Effect, Layer, PubSub, Scope, Stream } from "effect"
-import { KeyedMutex } from "../effect/keyed-mutex"
-import { Flag } from "../flag/flag"
-import { lazy } from "../util/lazy"
-import { watch as watchFileSystem } from "node:fs"
+import { makeLocationNode } from "../effect/app-node"
+import { Cause, Context, Effect, Layer } from "effect"
+import { FileSystemWatcher } from "@opencode-ai/schema/filesystem-watcher"
+import os from "os"
 import path from "path"
+import { Config } from "../config"
+import { EventV2 } from "../event"
+import { Flag } from "../flag/flag"
+import { FSUtil } from "../fs-util"
+import { Git } from "../git"
+import { Location } from "../location"
+import { lazy } from "../util/lazy"
+import { Ignore } from "./ignore"
+import { Protected } from "./protected"

 declare const OPENCODE_LIBC: string | undefined

 const SUBSCRIBE_TIMEOUT_MS = 10_000

-export const Event = { Updated: FileSystem.Event.Changed }
+export const Event = FileSystemWatcher.Event

 const watcher = lazy((): typeof import("@parcel/watcher") | undefined => {
  try {
@@ -36,134 +42,108 @@ function getBackend() {
  if (process.platform === "linux") return "inotify"
 }

-export const hasNativeBinding = () => !!watcher()
-export type Update = ParcelWatcher.Event
-
-export type WatchInput =
-  | { readonly path: string; readonly type: "file" }
-  | { readonly path: string; readonly type: "directory"; readonly ignore?: readonly string[] }
-
-export interface Interface {
-  readonly subscribe: (input: WatchInput) => Stream.Stream<Update>
+function protecteds(dir: string) {
+  return Protected.paths().filter((item) => {
+    const relative = path.relative(dir, item)
+    return relative !== "" && !relative.startsWith("..") && !path.isAbsolute(relative)
+  })
 }

-export class Service extends Context.Service<Service, Interface>()("@opencode/Watcher") {}
+export const hasNativeBinding = () => !!watcher()
+
+export interface Interface {}
+
+export class Service extends Context.Service<Service, Interface>()("@opencode/v2/FileWatcher") {}

 const layer = Layer.effect(
  Service,
  Effect.gen(function* () {
+    if (Flag.OPENCODE_DISABLE_FILEWATCHER) return Service.of({})
+
    const backend = getBackend()
-    const native = watcher()
-    if (Flag.OPENCODE_DISABLE_FILEWATCHER) {
-      return Service.of({ subscribe: () => Stream.empty })
+    const location = yield* Location.Service
+    if (path.resolve(location.directory) === path.resolve(os.homedir())) {
+      yield* Effect.logInfo("watcher skipped home directory", { directory: location.directory })
+      return Service.of({})
+    }
+    if (!backend) {
+      yield* Effect.logError("watcher backend not supported", {
+        directory: location.directory,
+        platform: process.platform,
+      })
+      return Service.of({})
    }

-    type Entry = {
-      readonly pubsub: PubSub.PubSub<Update>
-      readonly subscription: { readonly unsubscribe: () => Promise<void> }
-      refs: number
-    }
-    const entries = new Map<string, Entry>()
-    const locks = KeyedMutex.makeUnsafe<string>()
+    const w = watcher()
+    if (!w) return Service.of({})

-    const acquire = Effect.fn("Watcher.acquire")(function* (input: WatchInput) {
-      const scope = yield* Scope.Scope
-      const target = path.resolve(input.path)
-      const directory = input.type === "file" ? path.dirname(target) : target
-      const ignore = [...new Set(input.type === "directory" ? (input.ignore ?? []) : [])].toSorted()
-      const id = JSON.stringify([input.type, target, ignore])
-      const pubsub = yield* locks.withLock(id)(
-        Effect.gen(function* () {
-          const existing = entries.get(id)
-          if (existing) {
-            existing.refs++
-            return existing.pubsub
-          }
-          const pubsub = yield* PubSub.unbounded<Update>()
-          const subscription = yield* input.type === "file"
-            ? Effect.sync(() => {
-                const subscription = watchFileSystem(directory, { recursive: false }, (_event, file) => {
-                  if (file && path.resolve(directory, file.toString()) !== target) return
-                  PubSub.publishUnsafe(pubsub, {
-                    path: target,
-                    type: "update",
-                  } satisfies Update)
-                })
-                if ("on" in subscription && typeof subscription.on === "function") {
-                  subscription.on("error", (error: unknown) =>
-                    Effect.runFork(Effect.logError("watcher callback failed", { path: target, error })),
-                  )
-                }
-                return { unsubscribe: () => Promise.resolve(subscription.close()) }
-              })
-            : subscribeDirectory(native, backend, directory, ignore, pubsub)
-          if (subscription) {
-            entries.set(id, { pubsub, subscription, refs: 1 })
-            yield* Effect.logInfo("watcher started", {
-              path: target,
-              type: input.type,
-              backend: input.type === "file" ? "node" : backend,
-              ignores: ignore.length,
-            })
-            return pubsub
-          }
-          yield* PubSub.shutdown(pubsub)
-          return pubsub
+    yield* Effect.logInfo("watcher backend", { directory: location.directory, platform: process.platform, backend })
+    const events = yield* EventV2.Service
+    const fs = yield* FSUtil.Service
+    const git = yield* Git.Service
+    const context = yield* Effect.context()
+    const runFork = Effect.runForkWith(context)
+    const subscriptions: ParcelWatcher.AsyncSubscription[] = []
+    yield* Effect.addFinalizer(() =>
+      Effect.promise(() => Promise.allSettled(subscriptions.map((subscription) => subscription.unsubscribe()))),
+    )
+
+    const callback: ParcelWatcher.SubscribeCallback = (_error, updates) => {
+      if (_error) runFork(Effect.logError("watcher callback failed", { error: _error }))
+      for (const update of updates) {
+        if (update.type === "create") runFork(events.publish(Event.Updated, { file: update.path, event: "add" }))
+        if (update.type === "update") runFork(events.publish(Event.Updated, { file: update.path, event: "change" }))
+        if (update.type === "delete") runFork(events.publish(Event.Updated, { file: update.path, event: "unlink" }))
+      }
+    }
+
+    const subscribe = (directory: string, ignore: string[]) => {
+      const pending = w.subscribe(directory, callback, { ignore, backend })
+      return Effect.promise(() => pending).pipe(
+        Effect.tap((subscription) =>
+          Effect.sync(() => subscriptions.push(subscription)).pipe(
+            Effect.andThen(Effect.logInfo("watcher subscribed", { directory, backend, ignores: ignore.length })),
+          ),
+        ),
+        Effect.timeout(SUBSCRIBE_TIMEOUT_MS),
+        Effect.catchCause((cause) => {
+          pending.then((subscription) => subscription.unsubscribe()).catch(() => {})
+          return Effect.logError("failed to subscribe", { directory, cause: Cause.pretty(cause) })
        }),
      )
+    }

-      yield* Scope.addFinalizer(
-        scope,
-        locks.withLock(id)(
-          Effect.gen(function* () {
-            const entry = entries.get(id)
-            if (!entry) return
-            entry.refs--
-            if (entry.refs > 0) return
-            entries.delete(id)
-            yield* Effect.promise(() => entry.subscription.unsubscribe()).pipe(Effect.ignore)
-            yield* PubSub.shutdown(entry.pubsub)
-            yield* Effect.logInfo("watcher stopped", { path: target, type: input.type })
-          }),
-        ),
+    const configService = yield* Config.Service
+    const config = (yield* configService.entries())
+      .filter((entry): entry is Config.Document => entry.type === "document")
+      .flatMap((item) => item.info.watcher?.ignore ?? [])
+    yield* Effect.forkScoped(
+      subscribe(location.directory, [...Ignore.PATTERNS, ...config, ...protecteds(location.directory)]),
+    )
+
+    if (location.vcs?.type === "git") {
+      const resolved = (yield* git.repo.discover(location.directory))?.gitDirectory
+      const vcs = resolved ? yield* fs.realPath(resolved).pipe(Effect.catch(() => Effect.succeed(resolved))) : undefined
+      if (vcs && !config.includes(".git") && !config.includes(vcs) && (!resolved || !config.includes(resolved))) {
+        const ignore = (yield* fs.readDirectoryEntries(vcs).pipe(Effect.catch(() => Effect.succeed([])))).flatMap(
+          (entry) => (entry.name === "HEAD" ? [] : [entry.name]),
+        )
+        yield* Effect.forkScoped(subscribe(vcs, ignore))
+      }
+    }
+
+    return Service.of({})
+  }).pipe(
+    Effect.catchCause((cause) => {
+      return Effect.logError("failed to init watcher service", { cause: Cause.pretty(cause) }).pipe(
+        Effect.as(Service.of({})),
      )
-      return pubsub
-    })
-
-    const subscribe = (input: WatchInput) =>
-      Stream.unwrap(acquire(input).pipe(Effect.map((pubsub) => Stream.fromPubSub(pubsub))))
-
-    return Service.of({ subscribe })
-  }),
+    }),
+  ),
 )

-export const node = makeGlobalNode({ service: Service, layer, deps: [] })
-
-function subscribeDirectory(
-  native: typeof import("@parcel/watcher") | undefined,
-  backend: ParcelWatcher.BackendType | undefined,
-  directory: string,
-  ignore: string[],
-  pubsub: PubSub.PubSub<Update>,
-) {
-  if (!native || !backend) {
-    return Effect.logError("watcher backend not supported", { directory, platform: process.platform }).pipe(
-      Effect.as(undefined),
-    )
-  }
-  const callback: ParcelWatcher.SubscribeCallback = (error, updates) => {
-    if (error) Effect.runFork(Effect.logError("watcher callback failed", { error }))
-    for (const update of updates) PubSub.publishUnsafe(pubsub, update)
-  }
-  const pending = native.subscribe(directory, callback, { ignore, backend })
-  return Effect.promise(() => pending).pipe(
-    Effect.timeout(SUBSCRIBE_TIMEOUT_MS),
-    Effect.catchCause((cause) => {
-      pending.then((subscription) => subscription.unsubscribe()).catch(() => {})
-      return Effect.logError("failed to subscribe", {
-        directory,
-        cause: Cause.pretty(cause),
-      }).pipe(Effect.as(undefined))
-    }),
-  )
-}
+export const node = makeLocationNode({
+  service: Service,
+  layer,
+  deps: [FSUtil.node, Location.node, Config.node, Git.node, EventV2.node],
+})
@@ -52,9 +52,6 @@ export const Flag = {
  get OPENCODE_EXPERIMENTAL_REFERENCES() {
    return enabledByExperimental("OPENCODE_EXPERIMENTAL_REFERENCES")
  },
-  get CODEMODE_ENABLED() {
-    return process.env["CODEMODE_ENABLED"] === undefined || truthy("CODEMODE_ENABLED")
-  },
  get OPENCODE_TUI_CONFIG() {
    return process.env["OPENCODE_TUI_CONFIG"]
  },
@@ -21,7 +21,6 @@ export type When = Form.When

 export const State = Form.State
 export type State = typeof State.Type
-export type TerminalState = Exclude<State, { readonly status: "pending" }>

 export const Answer = Form.Answer
 export type Answer = typeof Answer.Type
@@ -79,7 +78,7 @@ export interface ListInput {

 export interface Interface {
  readonly create: (input: CreateInput) => Effect.Effect<Info, AlreadyExistsError | InvalidFormError>
-  readonly ask: (input: CreateInput) => Effect.Effect<TerminalState, AlreadyExistsError | InvalidFormError>
+  readonly ask: (input: CreateInput) => Effect.Effect<State, AlreadyExistsError | InvalidFormError>
  readonly get: (id: ID) => Effect.Effect<Info, NotFoundError>
  readonly list: (input?: ListInput) => Effect.Effect<ReadonlyArray<Info>>
  readonly state: (id: ID) => Effect.Effect<State, NotFoundError>
@@ -92,7 +91,7 @@ export class Service extends Context.Service<Service, Interface>()("@opencode/Fo
 interface Entry {
  readonly form: Info
  readonly state: State
-  readonly deferred: Deferred.Deferred<TerminalState>
+  readonly deferred: Deferred.Deferred<State>
 }

 export const layer = Layer.effect(
@@ -142,7 +141,7 @@ export const layer = Layer.effect(
          const entry: Entry = {
            form,
            state: { status: "pending" },
-            deferred: yield* Deferred.make<TerminalState>(),
+            deferred: yield* Deferred.make<State>(),
          }
          yield* Cache.set(forms, id, entry)
          yield* events.publish(Event.Created, { form }).pipe(Effect.onError(() => Cache.invalidate(forms, id)))
@@ -186,7 +185,7 @@ export const layer = Layer.effect(
          if (entry.state.status !== "pending") return yield* new AlreadySettledError({ id: input.id })
          const invalid = validateAnswer(entry.form, input.answer)
          if (invalid) return yield* new InvalidAnswerError({ id: input.id, message: invalid })
-          const next: TerminalState = { status: "answered", answer: input.answer }
+          const next: State = { status: "answered", answer: input.answer }
          yield* events.publish(Event.Replied, { id: input.id, sessionID: entry.form.sessionID, answer: input.answer })
          yield* Cache.set(forms, input.id, { ...entry, state: next })
          yield* Deferred.succeed(entry.deferred, next)
@@ -199,7 +198,7 @@ export const layer = Layer.effect(
        Effect.gen(function* () {
          const entry = yield* find(id)
          if (entry.state.status !== "pending") return yield* new AlreadySettledError({ id })
-          const next: TerminalState = { status: "cancelled" }
+          const next: State = { status: "cancelled" }
          yield* events.publish(Event.Cancelled, { id, sessionID: entry.form.sessionID })
          yield* Cache.set(forms, id, { ...entry, state: next })
          yield* Deferred.succeed(entry.deferred, next)
@@ -5,37 +5,29 @@ import { Catalog } from "./catalog"
 import { CommandV2 } from "./command"
 import { Config } from "./config"
 import { LayerNode } from "./effect/layer-node"
-import { makeLocationNode, Node } from "./effect/app-node"
-import { httpClient } from "./effect/app-node-platform"
-import { EventV2 } from "./event"
+import { Node } from "./effect/app-node"
 import { FileMutation } from "./file-mutation"
 import { FileSystem } from "./filesystem"
 import { FileSystemSearch } from "./filesystem/search"
-import { FSUtil } from "./fs-util"
 import { Generate } from "./generate"
 import { Form } from "./form"
-import { Global } from "./global"
-import { LocationWatcher } from "./filesystem/location-watcher"
+import { Watcher } from "./filesystem/watcher"
 import { Image } from "./image"
 import { Integration } from "./integration"
 import { Location } from "./location"
 import { LocationMutation } from "./location-mutation"
 import { LocationServiceMap } from "./location-service-map"
 import { MCP } from "./mcp/index"
-import { ModelsDev } from "./models-dev"
-import { Npm } from "./npm"
 import { PermissionV2 } from "./permission"
 import { PluginV2 } from "./plugin"
-import { PluginRuntime } from "./plugin/runtime"
-import { SdkPlugins } from "./plugin/sdk"
-import { PluginSupervisor } from "./plugin/supervisor"
+import { PluginInternal } from "./plugin/internal"
+import { Policy } from "./policy"
 import { ProjectCopy } from "./project/copy"
 import { Pty } from "./pty"
 import { QuestionV2 } from "./question"
 import { Shell } from "./shell"
 import { Reference } from "./reference"
 import { ReferenceGuidance } from "./reference/guidance"
-import { Ripgrep } from "./ripgrep"
 import { SessionRunnerLLM } from "./session/runner/llm"
 import { SessionRunnerModel } from "./session/runner/model"
 import { SessionCompaction } from "./session/compaction"
@@ -51,51 +43,14 @@ import { SessionInstructions } from "./session/instructions"
 import { McpTool } from "./tool/mcp"
 import { ReadToolFileSystem } from "./tool/read-filesystem"
 import { ToolRegistry } from "./tool/registry"
-import { WebSearchTool } from "./tool/websearch"
 import { ToolOutputStore } from "./tool-output-store"
 import { Vcs } from "./vcs"

 export { LocationServiceMap } from "./location-service-map"

-const pluginSupervisorNode = makeLocationNode({
-  service: PluginSupervisor.Service,
-  layer: PluginSupervisor.layer,
-  deps: [
-    PluginV2.node,
-    SdkPlugins.node,
-    AgentV2.node,
-    Catalog.node,
-    CommandV2.node,
-    Config.node,
-    EventV2.node,
-    FileMutation.node,
-    FileSystem.node,
-    FSUtil.node,
-    Global.node,
-    httpClient,
-    Image.node,
-    Integration.node,
-    Location.node,
-    LocationMutation.node,
-    ModelsDev.node,
-    Npm.node,
-    PermissionV2.node,
-    PluginRuntime.node,
-    Form.node,
-    ReadToolFileSystem.node,
-    Reference.node,
-    Ripgrep.node,
-    SessionInstructions.node,
-    SessionTodo.node,
-    Shell.node,
-    SkillV2.node,
-    ToolRegistry.toolsNode,
-    WebSearchTool.configNode,
-  ],
-})
-
 const locationServiceNodes = [
  Location.node,
+  Policy.node,
  Config.node,
  AgentV2.node,
  CommandV2.node,
@@ -104,11 +59,12 @@ const locationServiceNodes = [
  Catalog.node,
  AISDK.node,
  PluginV2.node,
-  pluginSupervisorNode,
+  PluginInternal.node,
  ProjectCopy.node,
  ProjectCopy.refreshNode,
  FileSystemSearch.node,
  FileSystem.node,
+  Watcher.node,
  Pty.node,
  Shell.node,
  SkillV2.node,
@@ -138,8 +94,6 @@ const locationServiceNodes = [
  Snapshot.node,
  SessionRunnerLLM.node,
  Vcs.node,
-  // Start repository watches only after boot-critical filesystem and Git work.
-  LocationWatcher.node,
 ] as const satisfies readonly Node.LocationNode<unknown, unknown>[]

 export const locationServices = LayerNode.group<typeof locationServiceNodes>(locationServiceNodes)
@@ -154,7 +108,6 @@ export function buildLocationServiceMap(
    LocationServiceMap.Service,
    LayerMap.make(
      (ref: Location.Ref) => {
-        const startedAt = performance.now()
        const allReplacements = replacements.concat([[Location.node, Location.boundNode(ref)]])
        // Apply replacements during hoist, not afterward: replacements can
        // introduce new tagged dependencies (Location.boundNode depends on
@@ -165,10 +118,9 @@ export function buildLocationServiceMap(
        return LayerNode.compile(location.node).pipe(
          Layer.fresh,
          Layer.tap(() =>
-            Effect.logInfo("location services booted", {
+            Effect.logInfo("booting location services", {
              directory: ref.directory,
              workspaceID: ref.workspaceID,
-              durationMs: Math.round(performance.now() - startedAt),
            }),
          ),
          Layer.provide(LayerNode.compile(location.hoisted)),
@@ -1,7 +1,6 @@
 export * as McpGuidance from "./guidance"

 import { makeLocationNode } from "../effect/app-node"
-import { Flag } from "../flag/flag"
 import { Context, Effect, Layer, Schema } from "effect"
 import { AgentV2 } from "../agent"
 import { PermissionV2 } from "../permission"
@@ -18,11 +17,6 @@ type Summary = typeof Summary.Type
 const entries = (servers: ReadonlyArray<Summary>) =>
  servers.flatMap((server) => [
    `  <server name="${server.server}">`,
-    ...(Flag.CODEMODE_ENABLED
-      ? [
-          `    Use tools from this server through \`execute\` under \`tools[${JSON.stringify(McpTool.group(server.server))}]\`.`,
-        ]
-      : []),
    ...server.instructions.split("\n").map((line) => `    ${line}`),
    "  </server>",
  ])
@@ -70,17 +64,15 @@ export const layer = Layer.effect(
      load: Effect.fn("McpGuidance.load")(function* (selection) {
        const agent = selection.info
        if (!agent) return SystemContext.empty
-        if (Flag.CODEMODE_ENABLED && PermissionV2.evaluate("execute", "*", agent.permissions).effect === "deny")
-          return SystemContext.empty
        const [instructions, tools] = yield* Effect.all([mcp.instructions(), mcp.tools()], {
          concurrency: "unbounded",
        })
-        // Instructions are useful only when this agent can reach at least one server tool.
+        // Hide a server only when every tool it contributes is wholly denied for this agent.
        const visible = instructions
          .filter((item) => {
            const owned = tools.filter((tool) => tool.server === item.server)
            return (
-              (!Flag.CODEMODE_ENABLED && owned.length === 0) ||
+              owned.length === 0 ||
              owned.some(
                (tool) =>
                  PermissionV2.evaluate(McpTool.name(tool.server, tool.name), "*", agent.permissions).effect !== "deny",
@@ -205,7 +205,7 @@ export const layer = Layer.effect(
      for (const [name, server] of Object.entries(entry.info.mcp?.servers ?? {})) {
        runtime.set(ServerName.make(name), {
          config: { ...server, timeout: { ...timeout, ...server.timeout } },
-          status: { status: "pending" },
+          status: { status: "disconnected" },
          startup: Deferred.makeUnsafe<void>(),
        })
      }
@@ -8,12 +8,6 @@ import { OtlpSerialization } from "effect/unstable/observability"
 import { Logging } from "./observability/logging"
 import { Otlp } from "./observability/otlp"

-const local = Logger.layer(Logging.loggers(), { mergeWithExisting: false }).pipe(
-  Layer.provide(NodeFileSystem.layer),
-  Layer.orDie,
-  Layer.merge(Layer.succeed(References.MinimumLogLevel, Logging.minimumLogLevel())),
-)
-
 export const layer = Layer.unwrap(
  Effect.gen(function* () {
    const logs = Logger.layer([...Logging.loggers(), ...Otlp.loggers()], { mergeWithExisting: false }).pipe(
@@ -25,6 +19,6 @@ export const layer = Layer.unwrap(
    )
    return Layer.merge(logs, yield* Effect.promise(Otlp.tracingLayer))
  }),
-).pipe(Layer.catchCause(() => local))
+)

 export const node = LayerNode.make({ name: "observability", layer, deps: [] })
@@ -1,15 +1,16 @@
 export * as PluginV2 from "./plugin"

-import type { Plugin } from "@opencode-ai/plugin/v2/effect"
-import { Event, ID, type Info } from "@opencode-ai/schema/plugin"
 import { makeLocationNode } from "./effect/app-node"
-import { Context, Effect, Exit, Layer, Scope, Semaphore } from "effect"
+import { Context, Deferred, Effect, Exit, Layer, Scope } from "effect"
+import type { Plugin as PluginDefinition } from "@opencode-ai/plugin/v2/effect"
+import { Plugin } from "@opencode-ai/schema/plugin"
 import { AgentV2 } from "./agent"
 import { AISDK } from "./aisdk"
 import { Catalog } from "./catalog"
 import { CommandV2 } from "./command"
 import { EventV2 } from "./event"
 import { Integration } from "./integration"
+import { KeyedMutex } from "./effect/keyed-mutex"
 import { Location } from "./location"
 import { PluginHost } from "./plugin/host"
 import { PluginRuntime } from "./plugin/runtime"
@@ -19,8 +20,16 @@ import { State } from "./state"
 import { ToolRegistry } from "./tool/registry"
 import { ToolHooks } from "./tool/hooks"

+export const ID = Plugin.ID
+export type ID = typeof ID.Type
+export const Info = Plugin.Info
+export type Info = Plugin.Info
+export const Event = Plugin.Event
+
 export interface Interface {
-  readonly activate: (plugins: readonly { readonly plugin: Plugin; readonly version?: string }[]) => Effect.Effect<void>
+  readonly add: (id: ID, effect: PluginDefinition["effect"]) => Effect.Effect<void>
+  readonly remove: (id: ID) => Effect.Effect<void>
+  readonly wait: (id: ID) => Effect.Effect<void>
  readonly list: () => Effect.Effect<Info[]>
 }

@@ -30,83 +39,110 @@ const layer = Layer.effect(
  Service,
  Effect.gen(function* () {
    const events = yield* EventV2.Service
+    const locks = KeyedMutex.makeUnsafe<ID>()
    const scope = yield* Scope.make()
-    const active = new Map<typeof ID.Type, Scope.Closeable>()
-    const lock = Semaphore.makeUnsafe(1)
-    let generation: readonly { readonly id: typeof ID.Type; readonly version?: string }[] | undefined = []
-    let host: Parameters<Plugin["effect"]>[0]
+    const active = new Map<ID, Scope.Closeable>()
+    const loading = new Set<ID>()
+    const waiters = new Map<ID, Set<Deferred.Deferred<void>>>()
+    const failures = new Map<ID, Exit.Exit<void, never>>()
+    let host: Parameters<PluginDefinition["effect"]>[0]

-    const activate = Effect.fn("Plugin.activate")(function* (
-      plugins: readonly { readonly plugin: Plugin; readonly version?: string }[],
-    ) {
-      const definitions = plugins.map((entry) => ({
-        ...entry.plugin,
-        id: ID.make(entry.plugin.id),
-        ...(entry.version === undefined ? {} : { version: entry.version }),
-      }))
-      const ids = new Set<typeof ID.Type>()
-      for (const definition of definitions) {
-        if (ids.has(definition.id)) return yield* Effect.die(new Error(`Duplicate plugin ID: ${definition.id}`))
-        ids.add(definition.id)
-      }
+    const add = Effect.fn("Plugin.add")(function* (id: ID, effect: PluginDefinition["effect"]) {
+      if (loading.has(id)) return yield* Effect.die(new Error(`Plugin load cycle detected for ${id}`))

-      yield* lock.withPermit(
-        Effect.gen(function* () {
-          if (
-            generation !== undefined &&
-            generation.length === definitions.length &&
-            generation.every(
-              (plugin, index) => plugin.id === definitions[index]?.id && plugin.version === definitions[index]?.version,
-            )
-          ) {
-            return
-          }
-          generation = undefined
-          const exit = yield* State.batch(
-            Effect.gen(function* () {
-              const scopes = Array.from(active.values()).toReversed()
-              active.clear()
-              const inherit = yield* State.inherit()
-              yield* Effect.forEach(scopes, (scope) => Scope.close(scope, Exit.void).pipe(Effect.ignore), {
-                discard: true,
-              })
+      yield* locks.withLock(id)(
+        Effect.sync(() => {
+          loading.add(id)
+          failures.delete(id)
+        }).pipe(
+          Effect.andThen(
+            State.batch(
+              Effect.gen(function* () {
+                const existing = active.get(id)
+                active.delete(id)
+                if (existing) yield* Scope.close(existing, Exit.void).pipe(Effect.ignore)

-              for (const definition of definitions) {
                const child = yield* Scope.fork(scope)
-                const loaded = yield* Effect.suspend(() => definition.effect(host)).pipe(
-                  inherit,
-                  Effect.updateContext((_context: Context.Context<never>) => Context.make(Scope.Scope, child)),
-                  Effect.withSpan("Plugin.load", { attributes: { "plugin.id": definition.id } }),
-                  Effect.andThen(events.publish(Event.Added, { id: definition.id })),
+                yield* effect(host).pipe(
+                  Scope.provide(child),
+                  Effect.withSpan("Plugin.load", { attributes: { "plugin.id": id } }),
                  Effect.onExit((exit) => (Exit.isFailure(exit) ? Scope.close(child, exit) : Effect.void)),
-                  Effect.exit,
                )
-                if (Exit.isFailure(loaded)) return loaded
-                active.set(definition.id, child)
-              }
-              return Exit.void
-            }),
-          )
-          if (Exit.isFailure(exit)) return yield* exit
-          generation = definitions.map((definition) => ({
-            id: definition.id,
-            ...(definition.version === undefined ? {} : { version: definition.version }),
-          }))
-          yield* events.publish(Event.Updated, {})
+                yield* events.publish(Event.Added, { id })
+                active.set(id, child)
+                yield* Effect.forEach(waiters.get(id) ?? [], (waiter) => Deferred.succeed(waiter, undefined), {
+                  discard: true,
+                })
+                waiters.delete(id)
+              }),
+            ),
+          ),
+          Effect.onExit((exit) => {
+            if (Exit.isSuccess(exit)) return Effect.void
+            failures.set(id, exit)
+            return Effect.forEach(waiters.get(id) ?? [], (waiter) => Deferred.done(waiter, exit), {
+              discard: true,
+            }).pipe(Effect.ensuring(Effect.sync(() => waiters.delete(id))))
+          }),
+          Effect.ensuring(Effect.sync(() => loading.delete(id))),
+        ),
+      )
+    })
+
+    const remove = Effect.fn("Plugin.remove")(function* (id: ID) {
+      if (loading.has(id)) return yield* Effect.die(new Error(`Cannot remove plugin ${id} while it is loading`))
+
+      yield* locks.withLock(id)(
+        State.batch(
+          Effect.gen(function* () {
+            const current = active.get(id)
+            active.delete(id)
+            failures.delete(id)
+            if (current) yield* Scope.close(current, Exit.void).pipe(Effect.ignore)
+          }),
+        ),
+      )
+    })
+
+    const wait = Effect.fn("Plugin.wait")(function* (id: ID) {
+      const waiter = yield* Deferred.make<void>()
+      const pending = yield* locks.withLock(id)(
+        Effect.sync(() => {
+          if (active.has(id)) return false
+          const failure = failures.get(id)
+          if (failure) return failure
+          const current = waiters.get(id) ?? new Set()
+          current.add(waiter)
+          waiters.set(id, current)
+          return true
        }),
      )
+      if (!pending) return
+      if (typeof pending !== "boolean") return yield* pending
+      yield* Deferred.await(waiter).pipe(
+        Effect.ensuring(
+          locks.withLock(id)(
+            Effect.sync(() => {
+              const current = waiters.get(id)
+              current?.delete(waiter)
+              if (current?.size === 0) waiters.delete(id)
+            }),
+          ),
+        ),
+      )
    })

    yield* Effect.addFinalizer((exit) =>
      Effect.gen(function* () {
        active.clear()
-        generation = []
        yield* State.batch(Scope.close(scope, exit))
      }),
    )

    const service = Service.of({
-      activate,
+      add,
+      remove,
+      wait,
      list: Effect.fn("Plugin.list")(function* () {
        return Array.from(active.keys()).map((id) => ({ id }))
      }),
@@ -1,7 +1,7 @@
 export * as AgentPlugin from "./agent"

 import path from "path"
-import { define } from "@opencode-ai/plugin/v2/effect/plugin"
+import { define } from "./internal"
 import { Effect } from "effect"
 import { AgentV2 } from "../agent"
 import { Global } from "../global"
@@ -100,7 +100,7 @@ Rules:
 - If the conversation ends with an imperative statement or request to the user (e.g. "Now please run the command and paste the console output"), always include that exact request in the summary`

 export const Plugin = define({
-  id: "opencode.agent",
+  id: "agent",
  effect: Effect.fn(function* (ctx) {
    const location = yield* Location.Service
    const worktree = location.directory
@@ -1,13 +1,13 @@
 export * as CommandPlugin from "./command"

-import { define } from "@opencode-ai/plugin/v2/effect/plugin"
+import { define } from "./internal"
 import { Effect } from "effect"
 import { Location } from "../location"
 import PROMPT_INITIALIZE from "./command/initialize.txt"
 import PROMPT_REVIEW from "./command/review.txt"

 export const Plugin = define({
-  id: "opencode.command",
+  id: "command",
  effect: Effect.fn(function* (ctx) {
    const location = yield* Location.Service
    yield* ctx.command.transform((draft) => {
@@ -1,14 +1,12 @@
 export * as PluginHost from "./host"

 import type { PluginContext } from "@opencode-ai/plugin/v2/effect"
-import { EventManifest } from "@opencode-ai/schema/event-manifest"
-import { Effect, Schema, Stream } from "effect"
+import { Effect, Schema } from "effect"
 import { AgentV2 } from "../agent"
 import { AISDK } from "../aisdk"
 import { Catalog } from "../catalog"
 import { CommandV2 } from "../command"
 import { Credential } from "../credential"
-import { EventV2 } from "../event"
 import { Integration } from "../integration"
 import { Location } from "../location"
 import { ModelV2 } from "../model"
@@ -23,12 +21,12 @@ import { ToolHooks } from "../tool/hooks"
 import { WorkspaceV2 } from "../workspace"

 const mutable = <T>(value: T) => value as DeepMutable<T>
+
 export const make = Effect.fn("PluginHost.make")(function* (plugin: PluginV2.Interface) {
  const agents = yield* AgentV2.Service
  const aisdk = yield* AISDK.Service
  const catalog = yield* Catalog.Service
  const commands = yield* CommandV2.Service
-  const events = yield* EventV2.Service
  const integration = yield* Integration.Service
  const location = yield* Location.Service
  const reference = yield* Reference.Service
@@ -54,8 +52,6 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: PluginV2.Int
        })
  const isCurrentLocation = (ref: Location.Ref) =>
    ref.directory === location.directory && ref.workspaceID === location.workspaceID
-  const response = <A, E, R>(effect: Effect.Effect<A, E, R>) =>
-    effect.pipe(Effect.map((data) => ({ location: locationInfo(), data })))

  return {
    options: {},
@@ -67,15 +63,15 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: PluginV2.Int
      },
      reload: agents.reload,
      transform: (callback) =>
-        agents.transform((draft) => {
+        agents.transform((draft) =>
          callback({
            list: () => mutable(draft.list()),
            get: (id) => mutable(draft.get(AgentV2.ID.make(id))),
            default: (id) => draft.default(id === undefined ? undefined : AgentV2.ID.make(id)),
            update: (id, update) => draft.update(AgentV2.ID.make(id), update),
            remove: (id) => draft.remove(AgentV2.ID.make(id)),
-          })
-        }),
+          }),
+        ),
    },
    aisdk: {
      sdk: (callback) =>
@@ -106,26 +102,9 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: PluginV2.Int
        }),
    },
    catalog: {
-      provider: {
-        list: () => response(catalog.provider.available()),
-        get: (input) =>
-          catalog.provider
-            .get(ProviderV2.ID.make(input.providerID))
-            .pipe(
-              Effect.flatMap((provider) =>
-                provider === undefined
-                  ? Effect.fail(new Error(`Provider not found: ${input.providerID}`))
-                  : response(Effect.succeed(provider)),
-              ),
-            ),
-      },
-      model: {
-        list: () => response(catalog.model.available()),
-        default: () => response(catalog.model.default()),
-      },
      reload: catalog.reload,
      transform: (callback) =>
-        catalog.transform((draft) => {
+        catalog.transform((draft) =>
          callback({
            provider: {
              list: () => mutable(draft.provider.list()),
@@ -146,42 +125,14 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: PluginV2.Int
                  draft.model.default.set(ProviderV2.ID.make(providerID), ModelV2.ID.make(modelID)),
              },
            },
-          })
-        }),
-    },
-    command: {
-      list: () => response(commands.list()),
-      reload: commands.reload,
-      transform: (callback) =>
-        commands.transform((draft) => {
-          callback(draft)
-        }),
-    },
-    event: {
-      subscribe: () => events.live().pipe(Stream.filter(EventManifest.isServer)),
-    },
-    integration: {
-      list: () => response(integration.list()),
-      get: (input) => response(integration.get(Integration.ID.make(input.integrationID))),
-      connectKey: (input) =>
-        integration.connection.key({
-          integrationID: Integration.ID.make(input.integrationID),
-          key: input.key,
-          label: input.label,
-        }),
-      connectOauth: (input) =>
-        response(
-          integration.connection.oauth({
-            integrationID: Integration.ID.make(input.integrationID),
-            methodID: Integration.MethodID.make(input.methodID),
-            inputs: input.inputs,
-            label: input.label,
          }),
        ),
-      attemptStatus: (input) => response(integration.attempt.status(Integration.AttemptID.make(input.attemptID))),
-      attemptComplete: (input) =>
-        integration.attempt.complete({ attemptID: Integration.AttemptID.make(input.attemptID), code: input.code }),
-      attemptCancel: (input) => integration.attempt.cancel(Integration.AttemptID.make(input.attemptID)),
+    },
+    command: {
+      reload: commands.reload,
+      transform: commands.transform,
+    },
+    integration: {
      reload: integration.reload,
      connection: {
        active: (id) => integration.connection.active(Integration.ID.make(id)),
@@ -191,7 +142,7 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: PluginV2.Int
          ),
      },
      transform: (callback) =>
-        integration.transform((draft) => {
+        integration.transform((draft) =>
          callback({
            list: () => mutable(draft.list()),
            get: (id) => mutable(draft.get(Integration.ID.make(id))),
@@ -268,37 +219,36 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: PluginV2.Int
              remove: (id, method) =>
                draft.method.remove(Integration.ID.make(id), Schema.decodeUnknownSync(Integration.Method)(method)),
            },
-          })
-        }),
+          }),
+        ),
    },
    plugin: {
-      list: () => response(plugin.list()),
+      add: (input) => plugin.add(PluginV2.ID.make(input.id), input.effect),
+      remove: (id) => plugin.remove(PluginV2.ID.make(id)),
    },
    reference: {
-      list: () => response(reference.list()),
      reload: reference.reload,
      transform: (callback) =>
-        reference.transform((draft) => {
+        reference.transform((draft) =>
          callback({
            add: (name, source) => draft.add(name, Schema.decodeUnknownSync(Reference.Source)(source)),
            remove: draft.remove,
            list: draft.list,
-          })
-        }),
+          }),
+        ),
    },
    skill: {
-      list: () => response(skill.list()),
      reload: skill.reload,
      transform: (callback) =>
-        skill.transform((draft) => {
+        skill.transform((draft) =>
          callback({
            source: (source) => draft.source(Schema.decodeUnknownSync(SkillV2.Source)(source)),
            list: draft.list,
-          })
-        }),
+          }),
+        ),
    },
    tool: {
-      register: (input, options) => tools.register(input, options),
+      register: (input) => tools.register(input),
      execute: {
        before: (callback) =>
          toolHooks.hook.before((event) => {
@@ -1,20 +1,21 @@
 export * as PluginInternal from "./internal"

-import type { Plugin } from "@opencode-ai/plugin/v2/effect"
-import { Context, Effect, Scope } from "effect"
-import { HttpClient } from "effect/unstable/http"
+import { makeLocationNode } from "../effect/app-node"
+import { httpClient } from "../effect/app-node-platform"
+import type { PluginContext } from "@opencode-ai/plugin/v2/effect"
+import { Context, Effect, Layer, Scope } from "effect"
 import { AgentV2 } from "../agent"
 import { Catalog } from "../catalog"
 import { CommandV2 } from "../command"
 import { Config } from "../config"
 import { ConfigAgentPlugin } from "../config/plugin/agent"
 import { ConfigCommandPlugin } from "../config/plugin/command"
+import { ConfigExternalPlugin } from "../config/plugin/external"
 import { ConfigProviderPlugin } from "../config/plugin/provider"
 import { ConfigReferencePlugin } from "../config/plugin/reference"
 import { ConfigSkillPlugin } from "../config/plugin/skill"
 import { EventV2 } from "../event"
 import { FileMutation } from "../file-mutation"
-import { Form } from "../form"
 import { FileSystem } from "../filesystem"
 import { FSUtil } from "../fs-util"
 import { Global } from "../global"
@@ -24,144 +25,187 @@ import { Location } from "../location"
 import { LocationMutation } from "../location-mutation"
 import { ModelsDev } from "../models-dev"
 import { Npm } from "../npm"
+import { PluginV2 } from "../plugin"
+import { PluginRuntime } from "../plugin/runtime"
 import { PermissionV2 } from "../permission"
+import { QuestionV2 } from "../question"
 import { Reference } from "../reference"
 import { Ripgrep } from "../ripgrep"
 import { SessionInstructions } from "../session/instructions"
 import { SessionTodo } from "../session/todo"
 import { Shell } from "../shell"
 import { SkillV2 } from "../skill"
+import { State } from "../state"
+import { ToolRegistry } from "../tool/registry"
+import { Tools } from "../tool/tools"
+import { HttpClient } from "effect/unstable/http"
+import { AgentPlugin } from "./agent"
+import { CommandPlugin } from "./command"
+import { ModelsDevPlugin } from "./models-dev"
+import { ProviderPlugins } from "./provider"
+import { SdkPlugins } from "./sdk"
+import { SkillPlugin } from "./skill"
+import { VariantPlugin } from "./variant"
 import { ApplyPatchTool } from "../tool/apply-patch"
 import { EditTool } from "../tool/edit"
 import { GlobTool } from "../tool/glob"
 import { GrepTool } from "../tool/grep"
 import { QuestionTool } from "../tool/question"
-import { ReadToolFileSystem } from "../tool/read-filesystem"
 import { ReadTool } from "../tool/read"
+import { ReadToolFileSystem } from "../tool/read-filesystem"
 import { ShellTool } from "../tool/shell"
 import { SkillTool } from "../tool/skill"
 import { SubagentTool } from "../tool/subagent"
 import { TodoWriteTool } from "../tool/todowrite"
-import { Tools } from "../tool/tools"
 import { WebFetchTool } from "../tool/webfetch"
 import { WebSearchTool } from "../tool/websearch"
 import { WriteTool } from "../tool/write"
-import { AgentPlugin } from "./agent"
-import { CommandPlugin } from "./command"
-import { ModelsDevPlugin } from "./models-dev"
-import { ProviderPlugins } from "./provider"
-import { PluginRuntime } from "./runtime"
-import { SkillPlugin } from "./skill"
-import { VariantPlugin } from "./variant"

-const services = Effect.fn("PluginInternal.services")(function* () {
-  const agent = yield* AgentV2.Service
-  const catalog = yield* Catalog.Service
-  const command = yield* CommandV2.Service
-  const config = yield* Config.Service
-  const events = yield* EventV2.Service
-  const mutation = yield* FileMutation.Service
-  const filesystem = yield* FileSystem.Service
-  const fs = yield* FSUtil.Service
-  const global = yield* Global.Service
-  const http = yield* HttpClient.HttpClient
-  const image = yield* Image.Service
-  const integration = yield* Integration.Service
-  const location = yield* Location.Service
-  const locationMutation = yield* LocationMutation.Service
-  const models = yield* ModelsDev.Service
-  const npm = yield* Npm.Service
-  const permission = yield* PermissionV2.Service
-  const runtime = yield* PluginRuntime.Service
-  const form = yield* Form.Service
-  const read = yield* ReadToolFileSystem.Service
-  const reference = yield* Reference.Service
-  const ripgrep = yield* Ripgrep.Service
-  const instructions = yield* SessionInstructions.Service
-  const todo = yield* SessionTodo.Service
-  const shell = yield* Shell.Service
-  const skill = yield* SkillV2.Service
-  const tools = yield* Tools.Service
-  const websearch = yield* WebSearchTool.ConfigService
-  return Context.mergeAll(
-    Context.make(AgentV2.Service, agent),
-    Context.make(Catalog.Service, catalog),
-    Context.make(CommandV2.Service, command),
-    Context.make(Config.Service, config),
-    Context.make(EventV2.Service, events),
-    Context.make(FileMutation.Service, mutation),
-    Context.make(FileSystem.Service, filesystem),
-    Context.make(FSUtil.Service, fs),
-    Context.make(Global.Service, global),
-    Context.make(HttpClient.HttpClient, http),
-    Context.make(Image.Service, image),
-    Context.make(Integration.Service, integration),
-    Context.make(Location.Service, location),
-    Context.make(LocationMutation.Service, locationMutation),
-    Context.make(ModelsDev.Service, models),
-    Context.make(Npm.Service, npm),
-    Context.make(PermissionV2.Service, permission),
-    Context.make(PluginRuntime.Service, runtime),
-    Context.make(Form.Service, form),
-    Context.make(ReadToolFileSystem.Service, read),
-    Context.make(Reference.Service, reference),
-    Context.make(Ripgrep.Service, ripgrep),
-    Context.make(SessionInstructions.Service, instructions),
-    Context.make(SessionTodo.Service, todo),
-    Context.make(Shell.Service, shell),
-    Context.make(SkillV2.Service, skill),
-    Context.make(Tools.Service, tools),
-    Context.make(WebSearchTool.ConfigService, websearch),
-  )
-})
+export type Requirements =
+  | AgentV2.Service
+  | Catalog.Service
+  | CommandV2.Service
+  | Config.Service
+  | EventV2.Service
+  | FileMutation.Service
+  | FileSystem.Service
+  | FSUtil.Service
+  | Global.Service
+  | HttpClient.HttpClient
+  | Image.Service
+  | Integration.Service
+  | Location.Service
+  | LocationMutation.Service
+  | ModelsDev.Service
+  | Npm.Service
+  | PermissionV2.Service
+  | PluginRuntime.Service
+  | QuestionV2.Service
+  | ReadToolFileSystem.Service
+  | Reference.Service
+  | Ripgrep.Service
+  | SessionInstructions.Service
+  | SessionTodo.Service
+  | Shell.Service
+  | SkillV2.Service
+  | Tools.Service
+  | WebSearchTool.ConfigService

-type ContextServices<A> = A extends Context.Context<infer R> ? R : never
+export interface Plugin<R = never> {
+  readonly id: string
+  readonly effect: (context: PluginContext) => Effect.Effect<void, never, R | Scope.Scope>
+}

-export type Requirements = ContextServices<Effect.Success<ReturnType<typeof services>>>
+export function define<R>(plugin: Plugin<R>) {
+  return plugin
+}

-export type InternalPlugin = Plugin<Requirements | Scope.Scope>
-
-const pre = [
-  AgentPlugin.Plugin,
-  CommandPlugin.Plugin,
-  SkillPlugin.Plugin,
-  ModelsDevPlugin,
-  ...ProviderPlugins,
-  ApplyPatchTool.Plugin,
-  EditTool.Plugin,
-  GlobTool.Plugin,
-  GrepTool.Plugin,
-  QuestionTool.Plugin,
-  ReadTool.Plugin,
-  ShellTool.Plugin,
-  SkillTool.Plugin,
-  SubagentTool.Plugin,
-  TodoWriteTool.Plugin,
-  WebFetchTool.Plugin,
-  WebSearchTool.Plugin,
-  WriteTool.Plugin,
-] as const satisfies readonly InternalPlugin[]
-
-const post = [
-  ConfigReferencePlugin.Plugin,
-  ConfigAgentPlugin.Plugin,
-  ConfigCommandPlugin.Plugin,
-  ConfigSkillPlugin.Plugin,
-  ConfigProviderPlugin.Plugin,
-  VariantPlugin.Plugin,
-] as const satisfies readonly InternalPlugin[]
-
-export const list = Effect.fn("PluginInternal.list")(function* () {
-  const context = yield* services()
-  const resolve = (plugins: readonly InternalPlugin[]) =>
-    plugins.map(
-      (plugin): Plugin => ({
-        id: plugin.id,
-        effect: (host) => plugin.effect(host).pipe(Effect.provide(context)),
-      }),
+const layer = Layer.effectDiscard(
+  Effect.gen(function* () {
+    const plugin = yield* PluginV2.Service
+    const sdkPlugins = yield* SdkPlugins.Service
+    const services = Context.mergeAll(
+      Context.make(Catalog.Service, yield* Catalog.Service),
+      Context.make(CommandV2.Service, yield* CommandV2.Service),
+      Context.make(Integration.Service, yield* Integration.Service),
+      Context.make(AgentV2.Service, yield* AgentV2.Service),
+      Context.make(Config.Service, yield* Config.Service),
+      Context.make(Location.Service, yield* Location.Service),
+      Context.make(ModelsDev.Service, yield* ModelsDev.Service),
+      Context.make(Npm.Service, yield* Npm.Service),
+      Context.make(EventV2.Service, yield* EventV2.Service),
+      Context.make(FSUtil.Service, yield* FSUtil.Service),
+      Context.make(FileSystem.Service, yield* FileSystem.Service),
+      Context.make(Global.Service, yield* Global.Service),
+      Context.make(HttpClient.HttpClient, yield* HttpClient.HttpClient),
+      Context.make(LocationMutation.Service, yield* LocationMutation.Service),
+      Context.make(FileMutation.Service, yield* FileMutation.Service),
+      Context.make(Image.Service, yield* Image.Service),
+      Context.make(PermissionV2.Service, yield* PermissionV2.Service),
+      Context.make(QuestionV2.Service, yield* QuestionV2.Service),
+      Context.make(ReadToolFileSystem.Service, yield* ReadToolFileSystem.Service),
+      Context.make(SessionInstructions.Service, yield* SessionInstructions.Service),
+      Context.make(SessionTodo.Service, yield* SessionTodo.Service),
+      Context.make(SkillV2.Service, yield* SkillV2.Service),
+      Context.make(Reference.Service, yield* Reference.Service),
+      Context.make(Ripgrep.Service, yield* Ripgrep.Service),
+      Context.make(Shell.Service, yield* Shell.Service),
+      Context.make(Tools.Service, yield* Tools.Service),
+      Context.make(PluginRuntime.Service, yield* PluginRuntime.Service),
+      Context.make(WebSearchTool.ConfigService, yield* WebSearchTool.ConfigService),
    )
-  return {
-    pre: resolve(pre),
-    post: resolve(post),
-  }
+    const add = (input: Plugin<Requirements | Scope.Scope>) =>
+      plugin.add(PluginV2.ID.make(input.id), (context: PluginContext) =>
+        input.effect(context).pipe(Effect.provide(services)),
+      )
+
+    yield* State.batch(
+      Effect.gen(function* () {
+        yield* add(ConfigReferencePlugin.Plugin)
+        yield* add(AgentPlugin.Plugin)
+        yield* add(CommandPlugin.Plugin)
+        yield* add(SkillPlugin.Plugin)
+        yield* add(ModelsDevPlugin)
+        yield* add(ConfigExternalPlugin.Plugin)
+        yield* add(ApplyPatchTool.Plugin)
+        yield* add(EditTool.Plugin)
+        yield* add(GlobTool.Plugin)
+        yield* add(GrepTool.Plugin)
+        yield* add(QuestionTool.Plugin)
+        yield* add(ReadTool.Plugin)
+        yield* add(ShellTool.Plugin)
+        yield* add(SkillTool.Plugin)
+        yield* add(SubagentTool.Plugin)
+        yield* add(TodoWriteTool.Plugin)
+        yield* add(WebFetchTool.Plugin)
+        yield* add(WebSearchTool.Plugin)
+        yield* add(WriteTool.Plugin)
+        yield* add(ConfigAgentPlugin.Plugin)
+        yield* add(ConfigCommandPlugin.Plugin)
+        yield* add(ConfigSkillPlugin.Plugin)
+        for (const item of ProviderPlugins) yield* add(item)
+        yield* add(ConfigProviderPlugin.Plugin)
+        yield* add(VariantPlugin.Plugin)
+        // Embedder-contributed plugins are added last so they layer over config.
+        for (const plugin of sdkPlugins.all()) yield* add(plugin)
+      }),
+    ).pipe(Effect.withSpan("PluginInternal.boot"), Effect.forkScoped({ startImmediately: true }))
+  }),
+)
+
+export const node = makeLocationNode({
+  name: "plugin-internal",
+  layer,
+  deps: [
+    Catalog.node,
+    CommandV2.node,
+    PluginV2.node,
+    Integration.node,
+    AgentV2.node,
+    Config.node,
+    Location.node,
+    LocationMutation.node,
+    FileMutation.node,
+    Image.node,
+    ModelsDev.node,
+    Npm.node,
+    EventV2.node,
+    FSUtil.node,
+    FileSystem.node,
+    Global.node,
+    httpClient,
+    PermissionV2.node,
+    QuestionV2.node,
+    ReadToolFileSystem.node,
+    SessionInstructions.node,
+    SessionTodo.node,
+    SkillV2.node,
+    Reference.node,
+    Ripgrep.node,
+    Shell.node,
+    ToolRegistry.toolsNode,
+    PluginRuntime.node,
+    SdkPlugins.node,
+    WebSearchTool.configNode,
+  ],
 })
@@ -1,4 +1,4 @@
-import { define } from "@opencode-ai/plugin/v2/effect/plugin"
+import { define } from "./internal"
 import type { ModelV2Info } from "@opencode-ai/sdk/v2/types"
 import { Effect, Stream } from "effect"
 import { EventV2 } from "../event"
@@ -197,69 +197,68 @@ function applyModel(
 }

 export const ModelsDevPlugin = define({
-  id: "opencode.models-dev",
+  id: "models-dev",
  effect: Effect.fn(function* (ctx) {
    const modelsDev = yield* ModelsDev.Service
    const events = yield* EventV2.Service
-    const loaded = { data: yield* modelsDev.get() }
-    yield* ctx.integration.transform((integrations) => {
-      for (const item of Object.values(loaded.data)) {
-        if (item.env.length === 0) continue
-        const integrationID = item.id
-        integrations.update(integrationID, (integration) => (integration.name = item.name))
-        integrations.method.update({
-          integrationID,
-          method: { type: "key" },
-        })
-        integrations.method.update({
-          integrationID,
-          method: { type: "env", names: [...item.env] },
-        })
-      }
-    })
-    yield* ctx.catalog.transform((catalog) => {
-      for (const item of Object.values(loaded.data)) {
-        const providerID = ProviderV2.ID.make(item.id)
-        catalog.provider.update(providerID, (provider) => {
-          provider.name = item.name
-          provider.api = item.npm
-            ? {
-                type: "aisdk",
-                package: item.npm,
-                url: item.api,
-              }
-            : {
-                type: "native",
-                url: item.api,
-                settings: {},
-              }
-        })
+    yield* ctx.integration.transform(
+      Effect.fn(function* (integrations) {
+        const data = yield* modelsDev.get()
+        for (const item of Object.values(data)) {
+          if (item.env.length === 0) continue
+          const integrationID = item.id
+          integrations.update(integrationID, (integration) => (integration.name = item.name))
+          integrations.method.update({
+            integrationID,
+            method: { type: "key" },
+          })
+          integrations.method.update({
+            integrationID,
+            method: { type: "env", names: [...item.env] },
+          })
+        }
+      }),
+    )
+    yield* ctx.catalog.transform(
+      Effect.fn(function* (catalog) {
+        const data = yield* modelsDev.get()
+        for (const item of Object.values(data)) {
+          const providerID = ProviderV2.ID.make(item.id)
+          catalog.provider.update(providerID, (provider) => {
+            provider.name = item.name
+            provider.api = item.npm
+              ? {
+                  type: "aisdk",
+                  package: item.npm,
+                  url: item.api,
+                }
+              : {
+                  type: "native",
+                  url: item.api,
+                  settings: {},
+                }
+          })

-        for (const model of Object.values(item.models)) {
-          const baseCost = cost(model.cost)
-          const variants = reasoningVariants(item, model)
-          catalog.model.update(providerID, model.id, (draft) => applyModel(draft, model, { cost: baseCost, variants }))
-          for (const [mode, options] of Object.entries(model.experimental?.modes ?? {})) {
-            catalog.model.update(providerID, `${model.id}-${mode}`, (draft) =>
-              applyModel(draft, model, {
-                name: modeName(model, mode),
-                cost: mergeCost(baseCost, options.cost),
-                request: options.provider,
-                variants,
-              }),
-            )
+          for (const model of Object.values(item.models)) {
+            const baseCost = cost(model.cost)
+            const variants = reasoningVariants(item, model)
+            catalog.model.update(providerID, model.id, (draft) => applyModel(draft, model, { cost: baseCost, variants }))
+            for (const [mode, options] of Object.entries(model.experimental?.modes ?? {})) {
+              catalog.model.update(providerID, `${model.id}-${mode}`, (draft) =>
+                applyModel(draft, model, {
+                  name: modeName(model, mode),
+                  cost: mergeCost(baseCost, options.cost),
+                  request: options.provider,
+                  variants,
+                }),
+              )
+            }
          }
        }
-      }
-    })
+      }),
+    )
    yield* events.subscribe(ModelsDev.Event.Refreshed).pipe(
-      Stream.runForEach(() =>
-        modelsDev.get().pipe(
-          Effect.tap((data) => Effect.sync(() => (loaded.data = data))),
-          Effect.andThen(ctx.integration.reload()),
-          Effect.andThen(ctx.catalog.reload()),
-        ),
-      ),
+      Stream.runForEach(() => ctx.integration.reload().pipe(Effect.andThen(ctx.catalog.reload()))),
      Effect.forkScoped({ startImmediately: true }),
    )
  }),
@@ -1,15 +1,16 @@
 export * as PluginPromise from "./promise"

 import { define } from "@opencode-ai/plugin/v2/effect"
-import type { Plugin, PluginContext } from "@opencode-ai/plugin/v2/promise"
-import { Effect, Scope, Stream } from "effect"
+import type { Plugin, PluginContext, Registration } from "@opencode-ai/plugin/v2/promise"
+import { Effect, Scope } from "effect"

+// The Effect host hands back this registration shape; mirror it structurally so
+// we do not have to alias the Effect package's `Registration` against the Promise one.
 type HostRegistration = { readonly dispose: Effect.Effect<void> }
-type Registration = { readonly dispose: () => Promise<void> }

 /**
 * Adapts a Promise plugin into an Effect plugin so the existing Effect-only
- * loader (`PluginV2` / `PluginSupervisor`) can run it unchanged.
+ * loader (`PluginV2` / `PluginInternal`) can run it unchanged.
 *
 * Hook registrations created during the async `setup` attach to the plugin's
 * scope, so unloading the plugin disposes them. The captured fiber context
@@ -30,23 +31,20 @@ export function fromPromise(plugin: Plugin) {
            dispose: () => Effect.runPromiseWith(context)(registration.dispose),
          }))

-        const run = <A, E>(effect: Effect.Effect<A, E>) => Effect.runPromiseWith(context)(effect)
+        const run = (effect: Effect.Effect<void>) => Effect.runPromiseWith(context)(effect)

        const transform =
          <Draft>(domain: {
-            transform: (callback: (draft: Draft) => void) => Effect.Effect<HostRegistration, never, Scope.Scope>
+            transform: (
+              callback: (draft: Draft) => Effect.Effect<void> | void,
+            ) => Effect.Effect<HostRegistration, never, Scope.Scope>
          }) =>
-          (callback: (draft: Draft) => void) =>
-            register(
-              domain.transform((draft) => {
-                callback(draft)
-              }),
-            )
+          (callback: (draft: Draft) => Promise<void> | void) =>
+            register(domain.transform((draft) => Effect.promise(() => Promise.resolve(callback(draft)))))

        const context2: PluginContext = {
          options: host.options,
          agent: {
-            list: (input) => run(host.agent.list(input)),
            transform: transform(host.agent),
            reload: () => run(host.agent.reload()),
          },
@@ -57,33 +55,14 @@ export function fromPromise(plugin: Plugin) {
              register(host.aisdk.language((event) => Effect.promise(() => Promise.resolve(callback(event))))),
          },
          catalog: {
-            provider: {
-              list: (input) => run(host.catalog.provider.list(input)),
-              get: (input) => run(host.catalog.provider.get(input)),
-            },
-            model: {
-              list: (input) => run(host.catalog.model.list(input)),
-              default: (input) => run(host.catalog.model.default(input)),
-            },
            transform: transform(host.catalog),
            reload: () => run(host.catalog.reload()),
          },
          command: {
-            list: (input) => run(host.command.list(input)),
            transform: transform(host.command),
            reload: () => run(host.command.reload()),
          },
-          event: {
-            subscribe: () => Stream.toAsyncIterable(host.event.subscribe()),
-          },
          integration: {
-            list: (input) => run(host.integration.list(input)),
-            get: (input) => run(host.integration.get(input)),
-            connectKey: (input) => run(host.integration.connectKey(input)),
-            connectOauth: (input) => run(host.integration.connectOauth(input)),
-            attemptStatus: (input) => run(host.integration.attemptStatus(input)),
-            attemptComplete: (input) => run(host.integration.attemptComplete(input)),
-            attemptCancel: (input) => run(host.integration.attemptCancel(input)),
            transform: transform(host.integration),
            reload: () => run(host.integration.reload()),
            connection: {
@@ -92,25 +71,20 @@ export function fromPromise(plugin: Plugin) {
            },
          },
          plugin: {
-            list: (input) => run(host.plugin.list(input)),
+            add: (input) => {
+              const child = fromPromise(input)
+              return run(host.plugin.add(child))
+            },
+            remove: (id) => run(host.plugin.remove(id)),
          },
          reference: {
-            list: (input) => run(host.reference.list(input)),
            transform: transform(host.reference),
            reload: () => run(host.reference.reload()),
          },
          skill: {
-            list: (input) => run(host.skill.list(input)),
            transform: transform(host.skill),
            reload: () => run(host.skill.reload()),
          },
-          session: {
-            create: (input) => run(host.session.create(input)),
-            get: (input) => run(host.session.get(input)),
-            prompt: (input) => run(host.session.prompt(input)),
-            command: (input) => run(host.session.command(input)),
-            interrupt: (input) => run(host.session.interrupt(input)),
-          },
        }

        yield* Effect.promise(() => Promise.resolve(plugin.setup(context2)))
@@ -31,8 +31,9 @@ import { VenicePlugin } from "./provider/venice"
 import { XAIPlugin } from "./provider/xai"
 import { ZenmuxPlugin } from "./provider/zenmux"
 import type { PluginInternal } from "./internal"
+import type { Scope } from "effect"

-export const ProviderPlugins: PluginInternal.InternalPlugin[] = [
+export const ProviderPlugins: PluginInternal.Plugin<PluginInternal.Requirements | Scope.Scope>[] = [
  AlibabaPlugin,
  AmazonBedrockPlugin,
  AnthropicPlugin,
@@ -1,8 +1,8 @@
 import { Effect } from "effect"
-import { define } from "@opencode-ai/plugin/v2/effect/plugin"
+import { define } from "../internal"

 export const AlibabaPlugin = define({
-  id: "opencode.provider.alibaba",
+  id: "alibaba",
  effect: Effect.fn(function* (ctx) {
    yield* ctx.aisdk.sdk(
      Effect.fn(function* (evt) {
@@ -1,6 +1,6 @@
 import { Effect } from "effect"
 import type { LanguageModelV3 } from "@ai-sdk/provider"
-import { define } from "@opencode-ai/plugin/v2/effect/plugin"
+import { define } from "../internal"
 import { ProviderV2 } from "../../provider"

 type MantleSDK = {
@@ -60,22 +60,24 @@ function selectMantleModel(sdk: MantleSDK, modelID: string) {
 }

 export const AmazonBedrockPlugin = define({
-  id: "opencode.provider.amazon-bedrock",
+  id: "amazon-bedrock",
  effect: Effect.fn(function* (ctx) {
-    yield* ctx.catalog.transform((evt) => {
-      for (const item of evt.provider.list()) {
-        if (item.provider.api.type !== "aisdk") continue
-        if (item.provider.api.package !== "@ai-sdk/amazon-bedrock") continue
-        evt.provider.update(item.provider.id, (provider) => {
-          if (provider.api.type !== "aisdk") return
-          if (typeof provider.request.body.endpoint !== "string") return
-          // The AI SDK expects a base URL, but users configure Bedrock private/VPC
-          // endpoints as `endpoint`; move it into the catalog endpoint URL once.
-          provider.api.url = provider.request.body.endpoint
-          delete provider.request.body.endpoint
-        })
-      }
-    })
+    yield* ctx.catalog.transform(
+      Effect.fn(function* (evt) {
+        for (const item of evt.provider.list()) {
+          if (item.provider.api.type !== "aisdk") continue
+          if (item.provider.api.package !== "@ai-sdk/amazon-bedrock") continue
+          evt.provider.update(item.provider.id, (provider) => {
+            if (provider.api.type !== "aisdk") return
+            if (typeof provider.request.body.endpoint !== "string") return
+            // The AI SDK expects a base URL, but users configure Bedrock private/VPC
+            // endpoints as `endpoint`; move it into the catalog endpoint URL once.
+            provider.api.url = provider.request.body.endpoint
+            delete provider.request.body.endpoint
+          })
+        }
+      }),
+    )
    yield* ctx.aisdk.sdk(
      Effect.fn(function* (evt) {
        if (!["@ai-sdk/amazon-bedrock", "@ai-sdk/amazon-bedrock/mantle"].includes(evt.package)) return
@@ -1,19 +1,21 @@
 import { Effect } from "effect"
-import { define } from "@opencode-ai/plugin/v2/effect/plugin"
+import { define } from "../internal"

 export const AnthropicPlugin = define({
-  id: "opencode.provider.anthropic",
+  id: "anthropic",
  effect: Effect.fn(function* (ctx) {
-    yield* ctx.catalog.transform((evt) => {
-      for (const item of evt.provider.list()) {
-        if (item.provider.api.type !== "aisdk") continue
-        if (item.provider.api.package !== "@ai-sdk/anthropic") continue
-        evt.provider.update(item.provider.id, (provider) => {
-          provider.request.headers["anthropic-beta"] =
-            "interleaved-thinking-2025-05-14,fine-grained-tool-streaming-2025-05-14"
-        })
-      }
-    })
+    yield* ctx.catalog.transform(
+      Effect.fn(function* (evt) {
+        for (const item of evt.provider.list()) {
+          if (item.provider.api.type !== "aisdk") continue
+          if (item.provider.api.package !== "@ai-sdk/anthropic") continue
+          evt.provider.update(item.provider.id, (provider) => {
+            provider.request.headers["anthropic-beta"] =
+              "interleaved-thinking-2025-05-14,fine-grained-tool-streaming-2025-05-14"
+          })
+        }
+      }),
+    )
    yield* ctx.aisdk.sdk(
      Effect.fn(function* (evt) {
        if (evt.package !== "@ai-sdk/anthropic") return
@@ -1,5 +1,5 @@
 import { Effect } from "effect"
-import { define } from "@opencode-ai/plugin/v2/effect/plugin"
+import { define } from "../internal"
 import { ProviderV2 } from "../../provider"

 function selectLanguage(sdk: any, modelID: string, useChat: boolean) {
@@ -11,21 +11,23 @@ function selectLanguage(sdk: any, modelID: string, useChat: boolean) {
 }

 export const AzurePlugin = define({
-  id: "opencode.provider.azure",
+  id: "azure",
  effect: Effect.fn(function* (ctx) {
-    yield* ctx.catalog.transform((evt) => {
-      for (const item of evt.provider.list()) {
-        if (item.provider.api.type !== "aisdk") continue
-        if (item.provider.api.package !== "@ai-sdk/azure") continue
-        const configured = item.provider.request.body.resourceName
-        const resourceName =
-          typeof configured === "string" && configured.trim() !== "" ? configured : process.env.AZURE_RESOURCE_NAME
-        if (!resourceName) continue
-        evt.provider.update(item.provider.id, (provider) => {
-          provider.request.body.resourceName = resourceName
-        })
-      }
-    })
+    yield* ctx.catalog.transform(
+      Effect.fn(function* (evt) {
+        for (const item of evt.provider.list()) {
+          if (item.provider.api.type !== "aisdk") continue
+          if (item.provider.api.package !== "@ai-sdk/azure") continue
+          const configured = item.provider.request.body.resourceName
+          const resourceName =
+            typeof configured === "string" && configured.trim() !== "" ? configured : process.env.AZURE_RESOURCE_NAME
+          if (!resourceName) continue
+          evt.provider.update(item.provider.id, (provider) => {
+            provider.request.body.resourceName = resourceName
+          })
+        }
+      }),
+    )
    yield* ctx.aisdk.sdk(
      Effect.fn(function* (evt) {
        if (evt.package !== "@ai-sdk/azure") return
@@ -54,20 +56,22 @@ export const AzurePlugin = define({
 })

 export const AzureCognitiveServicesPlugin = define({
-  id: "opencode.provider.azure-cognitive-services",
+  id: "azure-cognitive-services",
  effect: Effect.fn(function* (ctx) {
-    yield* ctx.catalog.transform((evt) => {
-      const resourceName = process.env.AZURE_COGNITIVE_SERVICES_RESOURCE_NAME
-      if (!resourceName) return
-      for (const item of evt.provider.list()) {
-        if (item.provider.api.type !== "aisdk") continue
-        if (item.provider.api.package !== "@ai-sdk/openai-compatible") continue
-        if (!item.provider.id.includes("azure-cognitive-services")) continue
-        evt.provider.update(item.provider.id, (provider) => {
-          provider.request.body.baseURL = `https://${resourceName}.cognitiveservices.azure.com/openai`
-        })
-      }
-    })
+    yield* ctx.catalog.transform(
+      Effect.fn(function* (evt) {
+        const resourceName = process.env.AZURE_COGNITIVE_SERVICES_RESOURCE_NAME
+        if (!resourceName) return
+        for (const item of evt.provider.list()) {
+          if (item.provider.api.type !== "aisdk") continue
+          if (item.provider.api.package !== "@ai-sdk/openai-compatible") continue
+          if (!item.provider.id.includes("azure-cognitive-services")) continue
+          evt.provider.update(item.provider.id, (provider) => {
+            provider.request.body.baseURL = `https://${resourceName}.cognitiveservices.azure.com/openai`
+          })
+        }
+      }),
+    )
    yield* ctx.aisdk.language(
      Effect.fn(function* (evt) {
        if (evt.model.providerID !== ProviderV2.ID.make("azure-cognitive-services")) return
@@ -1,18 +1,20 @@
 import { Effect } from "effect"
-import { define } from "@opencode-ai/plugin/v2/effect/plugin"
+import { define } from "../internal"

 export const CerebrasPlugin = define({
-  id: "opencode.provider.cerebras",
+  id: "cerebras",
  effect: Effect.fn(function* (ctx) {
-    yield* ctx.catalog.transform((evt) => {
-      for (const item of evt.provider.list()) {
-        if (item.provider.api.type !== "aisdk") continue
-        if (item.provider.api.package !== "@ai-sdk/cerebras") continue
-        evt.provider.update(item.provider.id, (provider) => {
-          provider.request.headers["X-Cerebras-3rd-Party-Integration"] = "opencode"
-        })
-      }
-    })
+    yield* ctx.catalog.transform(
+      Effect.fn(function* (evt) {
+        for (const item of evt.provider.list()) {
+          if (item.provider.api.type !== "aisdk") continue
+          if (item.provider.api.package !== "@ai-sdk/cerebras") continue
+          evt.provider.update(item.provider.id, (provider) => {
+            provider.request.headers["X-Cerebras-3rd-Party-Integration"] = "opencode"
+          })
+        }
+      }),
+    )
    yield* ctx.aisdk.sdk(
      Effect.fn(function* (evt) {
        if (evt.package !== "@ai-sdk/cerebras") return
@@ -1,10 +1,10 @@
 import os from "os"
 import { InstallationVersion } from "../../installation/version"
 import { Effect, Option, Schema } from "effect"
-import { define } from "@opencode-ai/plugin/v2/effect/plugin"
+import { define } from "../internal"

 export const CloudflareAIGatewayPlugin = define({
-  id: "opencode.provider.cloudflare-ai-gateway",
+  id: "cloudflare-ai-gateway",
  effect: Effect.fn(function* (ctx) {
    yield* ctx.aisdk.sdk(
      Effect.fn(function* (evt) {
@@ -1,24 +1,26 @@
 import os from "os"
 import { InstallationVersion } from "../../installation/version"
 import { Effect } from "effect"
-import { define } from "@opencode-ai/plugin/v2/effect/plugin"
+import { define } from "../internal"
 import { ProviderV2 } from "../../provider"

 const providerID = ProviderV2.ID.make("cloudflare-workers-ai")

 export const CloudflareWorkersAIPlugin = define({
-  id: "opencode.provider.cloudflare-workers-ai",
+  id: "cloudflare-workers-ai",
  effect: Effect.fn(function* (ctx) {
-    yield* ctx.catalog.transform((evt) => {
-      const item = evt.provider.get(providerID)
-      if (!item) return
-      evt.provider.update(item.provider.id, (provider) => {
-        if (provider.api.type !== "aisdk") return
-        if (provider.api.url) return
-        const accountId = resolveAccountId(provider.request.body)
-        if (accountId) provider.api.url = workersEndpoint(accountId)
-      })
-    })
+    yield* ctx.catalog.transform(
+      Effect.fn(function* (evt) {
+        const item = evt.provider.get(providerID)
+        if (!item) return
+        evt.provider.update(item.provider.id, (provider) => {
+          if (provider.api.type !== "aisdk") return
+          if (provider.api.url) return
+          const accountId = resolveAccountId(provider.request.body)
+          if (accountId) provider.api.url = workersEndpoint(accountId)
+        })
+      }),
+    )
    yield* ctx.aisdk.sdk(
      Effect.fn(function* (evt) {
        if (evt.model.providerID !== providerID) return
@@ -1,8 +1,8 @@
 import { Effect } from "effect"
-import { define } from "@opencode-ai/plugin/v2/effect/plugin"
+import { define } from "../internal"

 export const CoherePlugin = define({
-  id: "opencode.provider.cohere",
+  id: "cohere",
  effect: Effect.fn(function* (ctx) {
    yield* ctx.aisdk.sdk(
      Effect.fn(function* (evt) {
@@ -1,8 +1,8 @@
 import { Effect } from "effect"
-import { define } from "@opencode-ai/plugin/v2/effect/plugin"
+import { define } from "../internal"

 export const DeepInfraPlugin = define({
-  id: "opencode.provider.deepinfra",
+  id: "deepinfra",
  effect: Effect.fn(function* (ctx) {
    yield* ctx.aisdk.sdk(
      Effect.fn(function* (evt) {
@@ -1,10 +1,10 @@
 import { Effect } from "effect"
 import { pathToFileURL } from "url"
-import { define } from "@opencode-ai/plugin/v2/effect/plugin"
+import { define } from "../internal"
 import { Npm } from "../../npm"

 export const DynamicProviderPlugin = define({
-  id: "opencode.provider.dynamic",
+  id: "dynamic-provider",
  effect: Effect.fn(function* (ctx) {
    const npm = yield* Npm.Service
    yield* ctx.aisdk.sdk(
@@ -1,8 +1,8 @@
 import { Effect } from "effect"
-import { define } from "@opencode-ai/plugin/v2/effect/plugin"
+import { define } from "../internal"

 export const GatewayPlugin = define({
-  id: "opencode.provider.gateway",
+  id: "gateway",
  effect: Effect.fn(function* (ctx) {
    yield* ctx.aisdk.sdk(
      Effect.fn(function* (evt) {
@@ -1,6 +1,6 @@
 import { Effect } from "effect"
 import { ModelV2 } from "../../model"
-import { define } from "@opencode-ai/plugin/v2/effect/plugin"
+import { define } from "../internal"
 import { ProviderV2 } from "../../provider"

 function shouldUseResponses(modelID: string) {
@@ -12,17 +12,19 @@ function shouldUseResponses(modelID: string) {
 }

 export const GithubCopilotPlugin = define({
-  id: "opencode.provider.github-copilot",
+  id: "github-copilot",
  effect: Effect.fn(function* (ctx) {
-    yield* ctx.catalog.transform((evt) => {
-      const item = evt.provider.get(ProviderV2.ID.githubCopilot)
-      if (!item || !item.models.has(ModelV2.ID.make("gpt-5-chat-latest"))) return
-      evt.model.update(item.provider.id, ModelV2.ID.make("gpt-5-chat-latest"), (model) => {
-        // This chat-only alias conflicts with the Copilot GPT-5 Responses route,
-        // so hide it only for Copilot rather than for every provider catalog.
-        model.enabled = false
-      })
-    })
+    yield* ctx.catalog.transform(
+      Effect.fn(function* (evt) {
+        const item = evt.provider.get(ProviderV2.ID.githubCopilot)
+        if (!item || !item.models.has(ModelV2.ID.make("gpt-5-chat-latest"))) return
+        evt.model.update(item.provider.id, ModelV2.ID.make("gpt-5-chat-latest"), (model) => {
+          // This chat-only alias conflicts with the Copilot GPT-5 Responses route,
+          // so hide it only for Copilot rather than for every provider catalog.
+          model.enabled = false
+        })
+      }),
+    )
    yield* ctx.aisdk.sdk(
      Effect.fn(function* (evt) {
        if (evt.package !== "@ai-sdk/github-copilot") return
@@ -1,11 +1,11 @@
 import os from "os"
 import { InstallationVersion } from "../../installation/version"
 import { Effect } from "effect"
-import { define } from "@opencode-ai/plugin/v2/effect/plugin"
+import { define } from "../internal"
 import { ProviderV2 } from "../../provider"

 export const GitLabPlugin = define({
-  id: "opencode.provider.gitlab",
+  id: "gitlab",
  effect: Effect.fn(function* (ctx) {
    yield* ctx.aisdk.sdk(
      Effect.fn(function* (evt) {
@@ -1,5 +1,5 @@
 import { Effect } from "effect"
-import { define } from "@opencode-ai/plugin/v2/effect/plugin"
+import { define } from "../internal"
 import { ProviderV2 } from "../../provider"

 function resolveProject(options: Record<string, any>) {
@@ -55,33 +55,35 @@ function authFetch(fetchWithRuntimeOptions?: unknown) {
 }

 export const GoogleVertexPlugin = define({
-  id: "opencode.provider.google-vertex",
+  id: "google-vertex",
  effect: Effect.fn(function* (ctx) {
-    yield* ctx.catalog.transform((evt) => {
-      for (const item of evt.provider.list()) {
-        if (item.provider.api.type !== "aisdk") continue
-        if (
-          item.provider.api.package !== "@ai-sdk/google-vertex" &&
-          !(
-            item.provider.id === ProviderV2.ID.googleVertex &&
-            item.provider.api.package.includes("@ai-sdk/openai-compatible")
+    yield* ctx.catalog.transform(
+      Effect.fn(function* (evt) {
+        for (const item of evt.provider.list()) {
+          if (item.provider.api.type !== "aisdk") continue
+          if (
+            item.provider.api.package !== "@ai-sdk/google-vertex" &&
+            !(
+              item.provider.id === ProviderV2.ID.googleVertex &&
+              item.provider.api.package.includes("@ai-sdk/openai-compatible")
+            )
          )
-        )
-          continue
-        const project = resolveProject(item.provider.request.body)
-        const location = String(resolveLocation(item.provider.request.body))
-        evt.provider.update(item.provider.id, (provider) => {
-          if (project) provider.request.body.project = project
-          provider.request.body.location = location
-          if (provider.api.type === "aisdk" && provider.api.url) {
-            provider.api.url = replaceVertexVars(provider.api.url, project, location)
-          }
-          if (provider.api.type === "aisdk" && provider.api.package.includes("@ai-sdk/openai-compatible")) {
-            provider.request.body.fetch = authFetch(provider.request.body.fetch)
-          }
-        })
-      }
-    })
+            continue
+          const project = resolveProject(item.provider.request.body)
+          const location = String(resolveLocation(item.provider.request.body))
+          evt.provider.update(item.provider.id, (provider) => {
+            if (project) provider.request.body.project = project
+            provider.request.body.location = location
+            if (provider.api.type === "aisdk" && provider.api.url) {
+              provider.api.url = replaceVertexVars(provider.api.url, project, location)
+            }
+            if (provider.api.type === "aisdk" && provider.api.package.includes("@ai-sdk/openai-compatible")) {
+              provider.request.body.fetch = authFetch(provider.request.body.fetch)
+            }
+          })
+        }
+      }),
+    )
    yield* ctx.aisdk.sdk(
      Effect.fn(function* (evt) {
        if (evt.model.providerID === ProviderV2.ID.googleVertex && evt.package.includes("@ai-sdk/openai-compatible")) {
@@ -111,28 +113,30 @@ export const GoogleVertexPlugin = define({
 })

 export const GoogleVertexAnthropicPlugin = define({
-  id: "opencode.provider.google-vertex-anthropic",
+  id: "google-vertex-anthropic",
  effect: Effect.fn(function* (ctx) {
-    yield* ctx.catalog.transform((evt) => {
-      for (const item of evt.provider.list()) {
-        if (item.provider.api.type !== "aisdk") continue
-        if (item.provider.api.package !== "@ai-sdk/google-vertex/anthropic") continue
-        const project =
-          item.provider.request.body.project ??
-          process.env.GOOGLE_CLOUD_PROJECT ??
-          process.env.GCP_PROJECT ??
-          process.env.GCLOUD_PROJECT
-        const location =
-          item.provider.request.body.location ??
-          process.env.GOOGLE_CLOUD_LOCATION ??
-          process.env.VERTEX_LOCATION ??
-          "global"
-        evt.provider.update(item.provider.id, (provider) => {
-          if (project) provider.request.body.project = project
-          provider.request.body.location = location
-        })
-      }
-    })
+    yield* ctx.catalog.transform(
+      Effect.fn(function* (evt) {
+        for (const item of evt.provider.list()) {
+          if (item.provider.api.type !== "aisdk") continue
+          if (item.provider.api.package !== "@ai-sdk/google-vertex/anthropic") continue
+          const project =
+            item.provider.request.body.project ??
+            process.env.GOOGLE_CLOUD_PROJECT ??
+            process.env.GCP_PROJECT ??
+            process.env.GCLOUD_PROJECT
+          const location =
+            item.provider.request.body.location ??
+            process.env.GOOGLE_CLOUD_LOCATION ??
+            process.env.VERTEX_LOCATION ??
+            "global"
+          evt.provider.update(item.provider.id, (provider) => {
+            if (project) provider.request.body.project = project
+            provider.request.body.location = location
+          })
+        }
+      }),
+    )
    yield* ctx.aisdk.sdk(
      Effect.fn(function* (evt) {
        if (evt.package !== "@ai-sdk/google-vertex/anthropic") return
@@ -1,8 +1,8 @@
 import { Effect } from "effect"
-import { define } from "@opencode-ai/plugin/v2/effect/plugin"
+import { define } from "../internal"

 export const GooglePlugin = define({
-  id: "opencode.provider.google",
+  id: "google",
  effect: Effect.fn(function* (ctx) {
    yield* ctx.aisdk.sdk(
      Effect.fn(function* (evt) {
@@ -1,8 +1,8 @@
 import { Effect } from "effect"
-import { define } from "@opencode-ai/plugin/v2/effect/plugin"
+import { define } from "../internal"

 export const GroqPlugin = define({
-  id: "opencode.provider.groq",
+  id: "groq",
  effect: Effect.fn(function* (ctx) {
    yield* ctx.aisdk.sdk(
      Effect.fn(function* (evt) {
@@ -1,19 +1,21 @@
 import { Effect } from "effect"
-import { define } from "@opencode-ai/plugin/v2/effect/plugin"
+import { define } from "../internal"

 export const KiloPlugin = define({
-  id: "opencode.provider.kilo",
+  id: "kilo",
  effect: Effect.fn(function* (ctx) {
-    yield* ctx.catalog.transform((evt) => {
-      for (const item of evt.provider.list()) {
-        if (item.provider.api.type !== "aisdk") continue
-        if (item.provider.api.package !== "@ai-sdk/openai-compatible") continue
-        if (item.provider.api.url !== "https://api.kilo.ai/api/gateway") continue
-        evt.provider.update(item.provider.id, (provider) => {
-          provider.request.headers["HTTP-Referer"] = "https://opencode.ai/"
-          provider.request.headers["X-Title"] = "opencode"
-        })
-      }
-    })
+    yield* ctx.catalog.transform(
+      Effect.fn(function* (evt) {
+        for (const item of evt.provider.list()) {
+          if (item.provider.api.type !== "aisdk") continue
+          if (item.provider.api.package !== "@ai-sdk/openai-compatible") continue
+          if (item.provider.api.url !== "https://api.kilo.ai/api/gateway") continue
+          evt.provider.update(item.provider.id, (provider) => {
+            provider.request.headers["HTTP-Referer"] = "https://opencode.ai/"
+            provider.request.headers["X-Title"] = "opencode"
+          })
+        }
+      }),
+    )
  }),
 })
@@ -1,25 +1,26 @@
 import { Effect } from "effect"
-import { define } from "@opencode-ai/plugin/v2/effect/plugin"
+import { define } from "../internal"
 import { Integration } from "../../integration"

 export const LLMGatewayPlugin = define({
-  id: "opencode.provider.llmgateway",
+  id: "llmgateway",
  effect: Effect.fn(function* (ctx) {
    const integrations = yield* Integration.Service
-    const configured = new Set((yield* integrations.list()).map((integration) => integration.id))
-    yield* ctx.catalog.transform((evt) => {
-      for (const item of evt.provider.list()) {
-        if (item.provider.disabled) continue
-        if (item.provider.api.type !== "aisdk") continue
-        if (item.provider.api.package !== "@ai-sdk/openai-compatible") continue
-        if (item.provider.api.url !== "https://api.llmgateway.io/v1") continue
-        if (!configured.has(Integration.ID.make(item.provider.id))) continue
-        evt.provider.update(item.provider.id, (provider) => {
-          provider.request.headers["HTTP-Referer"] = "https://opencode.ai/"
-          provider.request.headers["X-Title"] = "opencode"
-          provider.request.headers["X-Source"] = "opencode"
-        })
-      }
-    })
+    yield* ctx.catalog.transform(
+      Effect.fn(function* (evt) {
+        for (const item of evt.provider.list()) {
+          if (item.provider.disabled) continue
+          if (item.provider.api.type !== "aisdk") continue
+          if (item.provider.api.package !== "@ai-sdk/openai-compatible") continue
+          if (item.provider.api.url !== "https://api.llmgateway.io/v1") continue
+          if (!(yield* integrations.get(Integration.ID.make(item.provider.id)))) continue
+          evt.provider.update(item.provider.id, (provider) => {
+            provider.request.headers["HTTP-Referer"] = "https://opencode.ai/"
+            provider.request.headers["X-Title"] = "opencode"
+            provider.request.headers["X-Source"] = "opencode"
+          })
+        }
+      }),
+    )
  }),
 })
@@ -1,8 +1,8 @@
 import { Effect } from "effect"
-import { define } from "@opencode-ai/plugin/v2/effect/plugin"
+import { define } from "../internal"

 export const MistralPlugin = define({
-  id: "opencode.provider.mistral",
+  id: "mistral",
  effect: Effect.fn(function* (ctx) {
    yield* ctx.aisdk.sdk(
      Effect.fn(function* (evt) {
@@ -1,20 +1,22 @@
 import { Effect } from "effect"
-import { define } from "@opencode-ai/plugin/v2/effect/plugin"
+import { define } from "../internal"

 export const NvidiaPlugin = define({
-  id: "opencode.provider.nvidia",
+  id: "nvidia",
  effect: Effect.fn(function* (ctx) {
-    yield* ctx.catalog.transform((evt) => {
-      for (const item of evt.provider.list()) {
-        if (item.provider.api.type !== "aisdk") continue
-        if (item.provider.api.package !== "@ai-sdk/openai-compatible") continue
-        if (item.provider.api.url !== "https://integrate.api.nvidia.com/v1") continue
-        evt.provider.update(item.provider.id, (provider) => {
-          provider.request.headers["HTTP-Referer"] = "https://opencode.ai/"
-          provider.request.headers["X-Title"] = "opencode"
-          provider.request.headers["X-BILLING-INVOKE-ORIGIN"] ??= "OpenCode"
-        })
-      }
-    })
+    yield* ctx.catalog.transform(
+      Effect.fn(function* (evt) {
+        for (const item of evt.provider.list()) {
+          if (item.provider.api.type !== "aisdk") continue
+          if (item.provider.api.package !== "@ai-sdk/openai-compatible") continue
+          if (item.provider.api.url !== "https://integrate.api.nvidia.com/v1") continue
+          evt.provider.update(item.provider.id, (provider) => {
+            provider.request.headers["HTTP-Referer"] = "https://opencode.ai/"
+            provider.request.headers["X-Title"] = "opencode"
+            provider.request.headers["X-BILLING-INVOKE-ORIGIN"] ??= "OpenCode"
+          })
+        }
+      }),
+    )
  }),
 })
@@ -1,8 +1,8 @@
 import { Effect } from "effect"
-import { define } from "@opencode-ai/plugin/v2/effect/plugin"
+import { define } from "../internal"

 export const OpenAICompatiblePlugin = define({
-  id: "opencode.provider.openai-compatible",
+  id: "openai-compatible",
  effect: Effect.fn(function* (ctx) {
    yield* ctx.aisdk.sdk(
      Effect.fn(function* (evt) {
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Kit Langton	fe64ef154c	refactor(core): classify step settlement once	2026-07-03 16:52:52 -04:00
Kit Langton	f57e0a2134	refactor(core): derive continuation and held overflow from step ledger	2026-07-03 16:46:17 -04:00
Kit Langton	d89a0d0bf7	refactor(core): rename LLM event publisher to step ledger	2026-07-03 16:44:55 -04:00