fix(tui): resolve move session project

bun.lock

@@ -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:",
@@ -694,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:*",

packages/app/src/components/dialog-custom-provider.tsx

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

packages/app/src/components/settings-providers.tsx

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

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

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

packages/app/src/context/file/watcher.test.ts

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

packages/app/src/context/file/watcher.ts

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

packages/app/src/pages/session.tsx

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

packages/client/package.json

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

packages/client/script/build-package.ts

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

packages/client/script/build.ts

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

packages/client/script/publish.ts

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

packages/client/src/effect/api.ts

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

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

@@ -133,15 +133,27 @@ const Endpoint4_7 = (raw: RawClient["server.session"]) => (input: Endpoint4_7Inp
     Effect.mapError(mapClientError),
   )
 
-type Endpoint4_8Request = Parameters<RawClient["server.session"]["session.prompt"]>[0]
+type Endpoint4_8Request = Parameters<RawClient["server.session"]["session.move"]>[0]
 type Endpoint4_8Input = {
   readonly sessionID: Endpoint4_8Request["params"]["sessionID"]
-  readonly id?: Endpoint4_8Request["payload"]["id"]
-  readonly prompt: Endpoint4_8Request["payload"]["prompt"]
-  readonly delivery?: Endpoint4_8Request["payload"]["delivery"]
-  readonly resume?: Endpoint4_8Request["payload"]["resume"]
+  readonly destination: Endpoint4_8Request["payload"]["destination"]
+  readonly moveChanges?: Endpoint4_8Request["payload"]["moveChanges"]
 }
 const Endpoint4_8 = (raw: RawClient["server.session"]) => (input: Endpoint4_8Input) =>
+  raw["session.move"]({
+    params: { sessionID: input["sessionID"] },
+    payload: { destination: input["destination"], moveChanges: input["moveChanges"] },
+  }).pipe(Effect.mapError(mapClientError))
+
+type Endpoint4_9Request = Parameters<RawClient["server.session"]["session.prompt"]>[0]
+type Endpoint4_9Input = {
+  readonly sessionID: Endpoint4_9Request["params"]["sessionID"]
+  readonly id?: Endpoint4_9Request["payload"]["id"]
+  readonly prompt: Endpoint4_9Request["payload"]["prompt"]
+  readonly delivery?: Endpoint4_9Request["payload"]["delivery"]
+  readonly resume?: Endpoint4_9Request["payload"]["resume"]
+}
+const Endpoint4_9 = (raw: RawClient["server.session"]) => (input: Endpoint4_9Input) =>
   raw["session.prompt"]({
     params: { sessionID: input["sessionID"] },
     payload: { id: input["id"], prompt: input["prompt"], delivery: input["delivery"], resume: input["resume"] },
@@ -150,20 +162,20 @@ const Endpoint4_8 = (raw: RawClient["server.session"]) => (input: Endpoint4_8Inp
     Effect.map((value) => value.data),
   )
 
-type Endpoint4_9Request = Parameters<RawClient["server.session"]["session.command"]>[0]
-type Endpoint4_9Input = {
-  readonly sessionID: Endpoint4_9Request["params"]["sessionID"]
-  readonly id?: Endpoint4_9Request["payload"]["id"]
-  readonly command: Endpoint4_9Request["payload"]["command"]
-  readonly arguments?: Endpoint4_9Request["payload"]["arguments"]
-  readonly agent?: Endpoint4_9Request["payload"]["agent"]
-  readonly model?: Endpoint4_9Request["payload"]["model"]
-  readonly files?: Endpoint4_9Request["payload"]["files"]
-  readonly agents?: Endpoint4_9Request["payload"]["agents"]
-  readonly delivery?: Endpoint4_9Request["payload"]["delivery"]
-  readonly resume?: Endpoint4_9Request["payload"]["resume"]
+type Endpoint4_10Request = Parameters<RawClient["server.session"]["session.command"]>[0]
+type Endpoint4_10Input = {
+  readonly sessionID: Endpoint4_10Request["params"]["sessionID"]
+  readonly id?: Endpoint4_10Request["payload"]["id"]
+  readonly command: Endpoint4_10Request["payload"]["command"]
+  readonly arguments?: Endpoint4_10Request["payload"]["arguments"]
+  readonly agent?: Endpoint4_10Request["payload"]["agent"]
+  readonly model?: Endpoint4_10Request["payload"]["model"]
+  readonly files?: Endpoint4_10Request["payload"]["files"]
+  readonly agents?: Endpoint4_10Request["payload"]["agents"]
+  readonly delivery?: Endpoint4_10Request["payload"]["delivery"]
+  readonly resume?: Endpoint4_10Request["payload"]["resume"]
 }
-const Endpoint4_9 = (raw: RawClient["server.session"]) => (input: Endpoint4_9Input) =>
+const Endpoint4_10 = (raw: RawClient["server.session"]) => (input: Endpoint4_10Input) =>
   raw["session.command"]({
     params: { sessionID: input["sessionID"] },
     payload: {
@@ -182,61 +194,61 @@ const Endpoint4_9 = (raw: RawClient["server.session"]) => (input: Endpoint4_9Inp
     Effect.map((value) => value.data),
   )
 
-type Endpoint4_10Request = Parameters<RawClient["server.session"]["session.skill"]>[0]
-type Endpoint4_10Input = {
-  readonly sessionID: Endpoint4_10Request["params"]["sessionID"]
-  readonly id?: Endpoint4_10Request["payload"]["id"]
-  readonly skill: Endpoint4_10Request["payload"]["skill"]
-  readonly resume?: Endpoint4_10Request["payload"]["resume"]
+type Endpoint4_11Request = Parameters<RawClient["server.session"]["session.skill"]>[0]
+type Endpoint4_11Input = {
+  readonly sessionID: Endpoint4_11Request["params"]["sessionID"]
+  readonly id?: Endpoint4_11Request["payload"]["id"]
+  readonly skill: Endpoint4_11Request["payload"]["skill"]
+  readonly resume?: Endpoint4_11Request["payload"]["resume"]
 }
-const Endpoint4_10 = (raw: RawClient["server.session"]) => (input: Endpoint4_10Input) =>
+const Endpoint4_11 = (raw: RawClient["server.session"]) => (input: Endpoint4_11Input) =>
   raw["session.skill"]({
     params: { sessionID: input["sessionID"] },
     payload: { id: input["id"], skill: input["skill"], resume: input["resume"] },
   }).pipe(Effect.mapError(mapClientError))
 
-type Endpoint4_11Request = Parameters<RawClient["server.session"]["session.synthetic"]>[0]
-type Endpoint4_11Input = {
-  readonly sessionID: Endpoint4_11Request["params"]["sessionID"]
-  readonly text: Endpoint4_11Request["payload"]["text"]
-  readonly description?: Endpoint4_11Request["payload"]["description"]
-  readonly metadata?: Endpoint4_11Request["payload"]["metadata"]
+type Endpoint4_12Request = Parameters<RawClient["server.session"]["session.synthetic"]>[0]
+type Endpoint4_12Input = {
+  readonly sessionID: Endpoint4_12Request["params"]["sessionID"]
+  readonly text: Endpoint4_12Request["payload"]["text"]
+  readonly description?: Endpoint4_12Request["payload"]["description"]
+  readonly metadata?: Endpoint4_12Request["payload"]["metadata"]
 }
-const Endpoint4_11 = (raw: RawClient["server.session"]) => (input: Endpoint4_11Input) =>
+const Endpoint4_12 = (raw: RawClient["server.session"]) => (input: Endpoint4_12Input) =>
   raw["session.synthetic"]({
     params: { sessionID: input["sessionID"] },
     payload: { text: input["text"], description: input["description"], metadata: input["metadata"] },
   }).pipe(Effect.mapError(mapClientError))
 
-type Endpoint4_12Request = Parameters<RawClient["server.session"]["session.shell"]>[0]
-type Endpoint4_12Input = {
-  readonly sessionID: Endpoint4_12Request["params"]["sessionID"]
-  readonly id?: Endpoint4_12Request["payload"]["id"]
-  readonly command: Endpoint4_12Request["payload"]["command"]
+type Endpoint4_13Request = Parameters<RawClient["server.session"]["session.shell"]>[0]
+type Endpoint4_13Input = {
+  readonly sessionID: Endpoint4_13Request["params"]["sessionID"]
+  readonly id?: Endpoint4_13Request["payload"]["id"]
+  readonly command: Endpoint4_13Request["payload"]["command"]
 }
-const Endpoint4_12 = (raw: RawClient["server.session"]) => (input: Endpoint4_12Input) =>
+const Endpoint4_13 = (raw: RawClient["server.session"]) => (input: Endpoint4_13Input) =>
   raw["session.shell"]({
     params: { sessionID: input["sessionID"] },
     payload: { id: input["id"], command: input["command"] },
   }).pipe(Effect.mapError(mapClientError))
 
-type Endpoint4_13Request = Parameters<RawClient["server.session"]["session.compact"]>[0]
-type Endpoint4_13Input = { readonly sessionID: Endpoint4_13Request["params"]["sessionID"] }
-const Endpoint4_13 = (raw: RawClient["server.session"]) => (input: Endpoint4_13Input) =>
-  raw["session.compact"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError))
-
-type Endpoint4_14Request = Parameters<RawClient["server.session"]["session.wait"]>[0]
+type Endpoint4_14Request = Parameters<RawClient["server.session"]["session.compact"]>[0]
 type Endpoint4_14Input = { readonly sessionID: Endpoint4_14Request["params"]["sessionID"] }
 const Endpoint4_14 = (raw: RawClient["server.session"]) => (input: Endpoint4_14Input) =>
+  raw["session.compact"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError))
+
+type Endpoint4_15Request = Parameters<RawClient["server.session"]["session.wait"]>[0]
+type Endpoint4_15Input = { readonly sessionID: Endpoint4_15Request["params"]["sessionID"] }
+const Endpoint4_15 = (raw: RawClient["server.session"]) => (input: Endpoint4_15Input) =>
   raw["session.wait"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError))
 
-type Endpoint4_15Request = Parameters<RawClient["server.session"]["session.revert.stage"]>[0]
-type Endpoint4_15Input = {
-  readonly sessionID: Endpoint4_15Request["params"]["sessionID"]
-  readonly messageID: Endpoint4_15Request["payload"]["messageID"]
-  readonly files?: Endpoint4_15Request["payload"]["files"]
+type Endpoint4_16Request = Parameters<RawClient["server.session"]["session.revert.stage"]>[0]
+type Endpoint4_16Input = {
+  readonly sessionID: Endpoint4_16Request["params"]["sessionID"]
+  readonly messageID: Endpoint4_16Request["payload"]["messageID"]
+  readonly files?: Endpoint4_16Request["payload"]["files"]
 }
-const Endpoint4_15 = (raw: RawClient["server.session"]) => (input: Endpoint4_15Input) =>
+const Endpoint4_16 = (raw: RawClient["server.session"]) => (input: Endpoint4_16Input) =>
   raw["session.revert.stage"]({
     params: { sessionID: input["sessionID"] },
     payload: { messageID: input["messageID"], files: input["files"] },
@@ -245,61 +257,61 @@ const Endpoint4_15 = (raw: RawClient["server.session"]) => (input: Endpoint4_15I
     Effect.map((value) => value.data),
   )
 
-type Endpoint4_16Request = Parameters<RawClient["server.session"]["session.revert.clear"]>[0]
-type Endpoint4_16Input = { readonly sessionID: Endpoint4_16Request["params"]["sessionID"] }
-const Endpoint4_16 = (raw: RawClient["server.session"]) => (input: Endpoint4_16Input) =>
-  raw["session.revert.clear"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError))
-
-type Endpoint4_17Request = Parameters<RawClient["server.session"]["session.revert.commit"]>[0]
+type Endpoint4_17Request = Parameters<RawClient["server.session"]["session.revert.clear"]>[0]
 type Endpoint4_17Input = { readonly sessionID: Endpoint4_17Request["params"]["sessionID"] }
 const Endpoint4_17 = (raw: RawClient["server.session"]) => (input: Endpoint4_17Input) =>
-  raw["session.revert.commit"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError))
+  raw["session.revert.clear"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError))
 
-type Endpoint4_18Request = Parameters<RawClient["server.session"]["session.context"]>[0]
+type Endpoint4_18Request = Parameters<RawClient["server.session"]["session.revert.commit"]>[0]
 type Endpoint4_18Input = { readonly sessionID: Endpoint4_18Request["params"]["sessionID"] }
 const Endpoint4_18 = (raw: RawClient["server.session"]) => (input: Endpoint4_18Input) =>
+  raw["session.revert.commit"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError))
+
+type Endpoint4_19Request = Parameters<RawClient["server.session"]["session.context"]>[0]
+type Endpoint4_19Input = { readonly sessionID: Endpoint4_19Request["params"]["sessionID"] }
+const Endpoint4_19 = (raw: RawClient["server.session"]) => (input: Endpoint4_19Input) =>
   raw["session.context"]({ params: { sessionID: input["sessionID"] } }).pipe(
     Effect.mapError(mapClientError),
     Effect.map((value) => value.data),
   )
 
-type Endpoint4_19Request = Parameters<RawClient["server.session"]["session.context.entry.list"]>[0]
-type Endpoint4_19Input = { readonly sessionID: Endpoint4_19Request["params"]["sessionID"] }
-const Endpoint4_19 = (raw: RawClient["server.session"]) => (input: Endpoint4_19Input) =>
+type Endpoint4_20Request = Parameters<RawClient["server.session"]["session.context.entry.list"]>[0]
+type Endpoint4_20Input = { readonly sessionID: Endpoint4_20Request["params"]["sessionID"] }
+const Endpoint4_20 = (raw: RawClient["server.session"]) => (input: Endpoint4_20Input) =>
   raw["session.context.entry.list"]({ params: { sessionID: input["sessionID"] } }).pipe(
     Effect.mapError(mapClientError),
     Effect.map((value) => value.data),
   )
 
-type Endpoint4_20Request = Parameters<RawClient["server.session"]["session.context.entry.put"]>[0]
-type Endpoint4_20Input = {
-  readonly sessionID: Endpoint4_20Request["params"]["sessionID"]
-  readonly key: Endpoint4_20Request["params"]["key"]
-  readonly value: Endpoint4_20Request["payload"]["value"]
+type Endpoint4_21Request = Parameters<RawClient["server.session"]["session.context.entry.put"]>[0]
+type Endpoint4_21Input = {
+  readonly sessionID: Endpoint4_21Request["params"]["sessionID"]
+  readonly key: Endpoint4_21Request["params"]["key"]
+  readonly value: Endpoint4_21Request["payload"]["value"]
 }
-const Endpoint4_20 = (raw: RawClient["server.session"]) => (input: Endpoint4_20Input) =>
+const Endpoint4_21 = (raw: RawClient["server.session"]) => (input: Endpoint4_21Input) =>
   raw["session.context.entry.put"]({
     params: { sessionID: input["sessionID"], key: input["key"] },
     payload: { value: input["value"] },
   }).pipe(Effect.mapError(mapClientError))
 
-type Endpoint4_21Request = Parameters<RawClient["server.session"]["session.context.entry.remove"]>[0]
-type Endpoint4_21Input = {
-  readonly sessionID: Endpoint4_21Request["params"]["sessionID"]
-  readonly key: Endpoint4_21Request["params"]["key"]
+type Endpoint4_22Request = Parameters<RawClient["server.session"]["session.context.entry.remove"]>[0]
+type Endpoint4_22Input = {
+  readonly sessionID: Endpoint4_22Request["params"]["sessionID"]
+  readonly key: Endpoint4_22Request["params"]["key"]
 }
-const Endpoint4_21 = (raw: RawClient["server.session"]) => (input: Endpoint4_21Input) =>
+const Endpoint4_22 = (raw: RawClient["server.session"]) => (input: Endpoint4_22Input) =>
   raw["session.context.entry.remove"]({ params: { sessionID: input["sessionID"], key: input["key"] } }).pipe(
     Effect.mapError(mapClientError),
   )
 
-type Endpoint4_22Request = Parameters<RawClient["server.session"]["session.log"]>[0]
-type Endpoint4_22Input = {
-  readonly sessionID: Endpoint4_22Request["params"]["sessionID"]
-  readonly after?: Endpoint4_22Request["query"]["after"]
-  readonly follow?: Endpoint4_22Request["query"]["follow"]
+type Endpoint4_23Request = Parameters<RawClient["server.session"]["session.log"]>[0]
+type Endpoint4_23Input = {
+  readonly sessionID: Endpoint4_23Request["params"]["sessionID"]
+  readonly after?: Endpoint4_23Request["query"]["after"]
+  readonly follow?: Endpoint4_23Request["query"]["follow"]
 }
-const Endpoint4_22 = (raw: RawClient["server.session"]) => (input: Endpoint4_22Input) =>
+const Endpoint4_23 = (raw: RawClient["server.session"]) => (input: Endpoint4_23Input) =>
   Stream.unwrap(
     raw["session.log"]({
       params: { sessionID: input["sessionID"] },
@@ -310,22 +322,22 @@ const Endpoint4_22 = (raw: RawClient["server.session"]) => (input: Endpoint4_22I
     ),
   )
 
-type Endpoint4_23Request = Parameters<RawClient["server.session"]["session.interrupt"]>[0]
-type Endpoint4_23Input = { readonly sessionID: Endpoint4_23Request["params"]["sessionID"] }
-const Endpoint4_23 = (raw: RawClient["server.session"]) => (input: Endpoint4_23Input) =>
-  raw["session.interrupt"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError))
-
-type Endpoint4_24Request = Parameters<RawClient["server.session"]["session.background"]>[0]
+type Endpoint4_24Request = Parameters<RawClient["server.session"]["session.interrupt"]>[0]
 type Endpoint4_24Input = { readonly sessionID: Endpoint4_24Request["params"]["sessionID"] }
 const Endpoint4_24 = (raw: RawClient["server.session"]) => (input: Endpoint4_24Input) =>
+  raw["session.interrupt"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError))
+
+type Endpoint4_25Request = Parameters<RawClient["server.session"]["session.background"]>[0]
+type Endpoint4_25Input = { readonly sessionID: Endpoint4_25Request["params"]["sessionID"] }
+const Endpoint4_25 = (raw: RawClient["server.session"]) => (input: Endpoint4_25Input) =>
   raw["session.background"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError))
 
-type Endpoint4_25Request = Parameters<RawClient["server.session"]["session.message"]>[0]
-type Endpoint4_25Input = {
-  readonly sessionID: Endpoint4_25Request["params"]["sessionID"]
-  readonly messageID: Endpoint4_25Request["params"]["messageID"]
+type Endpoint4_26Request = Parameters<RawClient["server.session"]["session.message"]>[0]
+type Endpoint4_26Input = {
+  readonly sessionID: Endpoint4_26Request["params"]["sessionID"]
+  readonly messageID: Endpoint4_26Request["params"]["messageID"]
 }
-const Endpoint4_25 = (raw: RawClient["server.session"]) => (input: Endpoint4_25Input) =>
+const Endpoint4_26 = (raw: RawClient["server.session"]) => (input: Endpoint4_26Input) =>
   raw["session.message"]({ params: { sessionID: input["sessionID"], messageID: input["messageID"] } }).pipe(
     Effect.mapError(mapClientError),
     Effect.map((value) => value.data),
@@ -340,24 +352,25 @@ const adaptGroup4 = (raw: RawClient["server.session"]) => ({
   switchAgent: Endpoint4_5(raw),
   switchModel: Endpoint4_6(raw),
   rename: Endpoint4_7(raw),
-  prompt: Endpoint4_8(raw),
-  command: Endpoint4_9(raw),
-  skill: Endpoint4_10(raw),
-  synthetic: Endpoint4_11(raw),
-  shell: Endpoint4_12(raw),
-  compact: Endpoint4_13(raw),
-  wait: Endpoint4_14(raw),
-  revertStage: Endpoint4_15(raw),
-  revertClear: Endpoint4_16(raw),
-  revertCommit: Endpoint4_17(raw),
-  context: Endpoint4_18(raw),
-  listContextEntries: Endpoint4_19(raw),
-  putContextEntry: Endpoint4_20(raw),
-  removeContextEntry: Endpoint4_21(raw),
-  log: Endpoint4_22(raw),
-  interrupt: Endpoint4_23(raw),
-  background: Endpoint4_24(raw),
-  message: Endpoint4_25(raw),
+  move: Endpoint4_8(raw),
+  prompt: Endpoint4_9(raw),
+  command: Endpoint4_10(raw),
+  skill: Endpoint4_11(raw),
+  synthetic: Endpoint4_12(raw),
+  shell: Endpoint4_13(raw),
+  compact: Endpoint4_14(raw),
+  wait: Endpoint4_15(raw),
+  revertStage: Endpoint4_16(raw),
+  revertClear: Endpoint4_17(raw),
+  revertCommit: Endpoint4_18(raw),
+  context: Endpoint4_19(raw),
+  listContextEntries: Endpoint4_20(raw),
+  putContextEntry: Endpoint4_21(raw),
+  removeContextEntry: Endpoint4_22(raw),
+  log: Endpoint4_23(raw),
+  interrupt: Endpoint4_24(raw),
+  background: Endpoint4_25(raw),
+  message: Endpoint4_26(raw),
 })
 
 type Endpoint5_0Request = Parameters<RawClient["server.message"]["session.messages"]>[0]

packages/client/src/effect/index.ts

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

packages/client/src/promise/api.ts

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

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

@@ -21,6 +21,8 @@ import type {
   SessionSwitchModelOutput,
   SessionRenameInput,
   SessionRenameOutput,
+  SessionMoveInput,
+  SessionMoveOutput,
   SessionPromptInput,
   SessionPromptOutput,
   SessionCommandInput,
@@ -469,6 +471,18 @@ export function make(options: ClientOptions) {
           },
           requestOptions,
         ),
+      move: (input: SessionMoveInput, requestOptions?: RequestOptions) =>
+        request<SessionMoveOutput>(
+          {
+            method: "POST",
+            path: `/api/session/${encodeURIComponent(input.sessionID)}/move`,
+            body: { destination: input["destination"], moveChanges: input["moveChanges"] },
+            successStatus: 204,
+            declaredStatuses: [404, 400, 401],
+            empty: true,
+          },
+          requestOptions,
+        ),
       prompt: (input: SessionPromptInput, requestOptions?: RequestOptions) =>
         request<{ readonly data: SessionPromptOutput }>(
           {

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

@@ -522,6 +522,20 @@ export type SessionRenameInput = {
 
 export type SessionRenameOutput = void
 
+export type SessionMoveInput = {
+  readonly sessionID: { readonly sessionID: string }["sessionID"]
+  readonly destination: {
+    readonly destination: { readonly directory: string }
+    readonly moveChanges?: boolean | undefined
+  }["destination"]
+  readonly moveChanges?: {
+    readonly destination: { readonly directory: string }
+    readonly moveChanges?: boolean | undefined
+  }["moveChanges"]
+}
+
+export type SessionMoveOutput = void
+
 export type SessionPromptInput = {
   readonly sessionID: { readonly sessionID: string }["sessionID"]
   readonly id?: {
@@ -976,27 +990,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
@@ -1006,20 +1002,23 @@ export type SessionContextOutput = {
         readonly agent: string
         readonly model: { readonly id: string; readonly providerID: string; readonly variant?: string }
         readonly content: ReadonlyArray<
-          | { readonly type: "text"; readonly text: string }
+          | { readonly type: "text"; readonly id: string; readonly text: string }
           | {
               readonly type: "reasoning"
+              readonly id: string
               readonly text: string
-              readonly state?: { readonly [x: string]: JsonValue }
+              readonly providerMetadata?: { readonly [x: string]: { readonly [x: string]: JsonValue } }
               readonly time?: { readonly created: number; readonly completed?: number }
             }
           | {
               readonly type: "tool"
               readonly id: string
               readonly name: string
-              readonly executed?: boolean
-              readonly providerState?: { readonly [x: string]: JsonValue }
-              readonly providerResultState?: { readonly [x: string]: JsonValue }
+              readonly provider?: {
+                readonly executed: boolean
+                readonly metadata?: { readonly [x: string]: { readonly [x: string]: JsonValue } }
+                readonly resultMetadata?: { readonly [x: string]: { readonly [x: string]: JsonValue } }
+              }
               readonly state:
                 | { readonly status: "pending"; readonly input: string }
                 | {
@@ -1057,37 +1056,7 @@ export type SessionContextOutput = {
                       | { readonly type: "file"; readonly uri: string; readonly mime: string; readonly name?: string }
                     >
                     readonly structured: { readonly [x: string]: JsonValue }
-                    readonly error:
-                      | {
-                          readonly type: "provider.rate-limit"
-                          readonly message: string
-                          readonly retryAfterMs?: number
-                        }
-                      | { readonly type: "provider.auth"; readonly message: string }
-                      | { readonly type: "provider.quota"; readonly message: string }
-                      | { readonly type: "provider.content-filter"; readonly message: string }
-                      | { readonly type: "provider.transport"; readonly message: string }
-                      | { readonly type: "provider.internal"; readonly message: string }
-                      | { readonly type: "provider.invalid-output"; readonly message: string }
-                      | { readonly type: "provider.invalid-request"; readonly message: string }
-                      | { readonly type: "provider.no-route"; readonly message: string }
-                      | { readonly type: "provider.unknown"; readonly message: string }
-                      | {
-                          readonly type: "permission.rejected"
-                          readonly message: string
-                          readonly permission: string
-                          readonly resources: ReadonlyArray<string>
-                        }
-                      | { readonly type: "tool.unknown"; readonly message: string; readonly name: string }
-                      | { readonly type: "tool.stale"; readonly message: string; readonly name?: string }
-                      | { readonly type: "tool.execution"; readonly message: string }
-                      | { readonly type: "tool.result-missing"; readonly message: string; readonly callID?: string }
-                      | {
-                          readonly type: "aborted"
-                          readonly message: string
-                          readonly reason?: "user" | "shutdown" | "timeout"
-                        }
-                      | { readonly type: "unknown"; readonly message: string; readonly agent?: string }
+                    readonly error: { readonly type: "unknown"; readonly message: string }
                     readonly result?: JsonValue
                   }
               readonly time: {
@@ -1099,7 +1068,7 @@ export type SessionContextOutput = {
             }
         >
         readonly snapshot?: { readonly start?: string; readonly end?: string; readonly files?: ReadonlyArray<string> }
-        readonly finish?: "stop" | "length" | "tool-calls" | "content-filter" | "error" | "unknown"
+        readonly finish?: string
         readonly cost?: number
         readonly tokens?: {
           readonly input: number
@@ -1107,56 +1076,7 @@ export type SessionContextOutput = {
           readonly reasoning: number
           readonly cache: { readonly read: number; readonly write: number }
         }
-        readonly error?:
-          | { readonly type: "provider.rate-limit"; readonly message: string; readonly retryAfterMs?: number }
-          | { readonly type: "provider.auth"; readonly message: string }
-          | { readonly type: "provider.quota"; readonly message: string }
-          | { readonly type: "provider.content-filter"; readonly message: string }
-          | { readonly type: "provider.transport"; readonly message: string }
-          | { readonly type: "provider.internal"; readonly message: string }
-          | { readonly type: "provider.invalid-output"; readonly message: string }
-          | { readonly type: "provider.invalid-request"; readonly message: string }
-          | { readonly type: "provider.no-route"; readonly message: string }
-          | { readonly type: "provider.unknown"; readonly message: string }
-          | {
-              readonly type: "permission.rejected"
-              readonly message: string
-              readonly permission: string
-              readonly resources: ReadonlyArray<string>
-            }
-          | { readonly type: "tool.unknown"; readonly message: string; readonly name: string }
-          | { readonly type: "tool.stale"; readonly message: string; readonly name?: string }
-          | { readonly type: "tool.execution"; readonly message: string }
-          | { readonly type: "tool.result-missing"; readonly message: string; readonly callID?: string }
-          | { readonly type: "aborted"; readonly message: string; readonly reason?: "user" | "shutdown" | "timeout" }
-          | { readonly type: "unknown"; readonly message: string; readonly agent?: string }
-        readonly retry?: {
-          readonly attempt: number
-          readonly at: number
-          readonly error:
-            | { readonly type: "provider.rate-limit"; readonly message: string; readonly retryAfterMs?: number }
-            | { readonly type: "provider.auth"; readonly message: string }
-            | { readonly type: "provider.quota"; readonly message: string }
-            | { readonly type: "provider.content-filter"; readonly message: string }
-            | { readonly type: "provider.transport"; readonly message: string }
-            | { readonly type: "provider.internal"; readonly message: string }
-            | { readonly type: "provider.invalid-output"; readonly message: string }
-            | { readonly type: "provider.invalid-request"; readonly message: string }
-            | { readonly type: "provider.no-route"; readonly message: string }
-            | { readonly type: "provider.unknown"; readonly message: string }
-            | {
-                readonly type: "permission.rejected"
-                readonly message: string
-                readonly permission: string
-                readonly resources: ReadonlyArray<string>
-              }
-            | { readonly type: "tool.unknown"; readonly message: string; readonly name: string }
-            | { readonly type: "tool.stale"; readonly message: string; readonly name?: string }
-            | { readonly type: "tool.execution"; readonly message: string }
-            | { readonly type: "tool.result-missing"; readonly message: string; readonly callID?: string }
-            | { readonly type: "aborted"; readonly message: string; readonly reason?: "user" | "shutdown" | "timeout" }
-            | { readonly type: "unknown"; readonly message: string; readonly agent?: string }
-        }
+        readonly error?: { readonly type: "unknown"; readonly message: string }
       }
     | {
         readonly type: "compaction"
@@ -1203,7 +1123,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 }
@@ -1212,7 +1132,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: {
@@ -1237,7 +1157,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 }
@@ -1246,7 +1166,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 }
@@ -1255,7 +1175,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 }
@@ -1264,7 +1184,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: {
@@ -1287,71 +1207,6 @@ export type SessionLogOutput =
             readonly delivery: "steer" | "queue"
           }
         }
-      | {
-          readonly id: string
-          readonly created: number
-          readonly metadata?: { readonly [x: string]: unknown }
-          readonly type: "session.execution.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 id: string
-          readonly created: number
-          readonly metadata?: { readonly [x: string]: unknown }
-          readonly type: "session.execution.succeeded"
-          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 id: string
-          readonly created: number
-          readonly metadata?: { readonly [x: string]: unknown }
-          readonly type: "session.execution.failed"
-          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 error:
-              | { readonly type: "provider.rate-limit"; readonly message: string; readonly retryAfterMs?: number }
-              | { readonly type: "provider.auth"; readonly message: string }
-              | { readonly type: "provider.quota"; readonly message: string }
-              | { readonly type: "provider.content-filter"; readonly message: string }
-              | { readonly type: "provider.transport"; readonly message: string }
-              | { readonly type: "provider.internal"; readonly message: string }
-              | { readonly type: "provider.invalid-output"; readonly message: string }
-              | { readonly type: "provider.invalid-request"; readonly message: string }
-              | { readonly type: "provider.no-route"; readonly message: string }
-              | { readonly type: "provider.unknown"; readonly message: string }
-              | {
-                  readonly type: "permission.rejected"
-                  readonly message: string
-                  readonly permission: string
-                  readonly resources: ReadonlyArray<string>
-                }
-              | { readonly type: "tool.unknown"; readonly message: string; readonly name: string }
-              | { readonly type: "tool.stale"; readonly message: string; readonly name?: string }
-              | { readonly type: "tool.execution"; readonly message: string }
-              | { readonly type: "tool.result-missing"; readonly message: string; readonly callID?: string }
-              | {
-                  readonly type: "aborted"
-                  readonly message: string
-                  readonly reason?: "user" | "shutdown" | "timeout"
-                }
-              | { readonly type: "unknown"; readonly message: string; readonly agent?: string }
-          }
-        }
-      | {
-          readonly id: string
-          readonly created: number
-          readonly metadata?: { readonly [x: string]: unknown }
-          readonly type: "session.execution.interrupted"
-          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: "user" | "shutdown" | "superseded" }
-        }
       | {
           readonly id: string
           readonly created: number
@@ -1365,7 +1220,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: {
@@ -1379,7 +1234,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 }
@@ -1388,59 +1243,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: {
@@ -1455,13 +1276,13 @@ 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: {
             readonly sessionID: string
             readonly assistantMessageID: string
-            readonly finish: "stop" | "length" | "tool-calls" | "content-filter" | "error" | "unknown"
+            readonly finish: string
             readonly cost: number
             readonly tokens: {
               readonly input: number
@@ -1477,91 +1298,72 @@ 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: {
             readonly sessionID: string
             readonly assistantMessageID: string
-            readonly error:
-              | { readonly type: "provider.rate-limit"; readonly message: string; readonly retryAfterMs?: number }
-              | { readonly type: "provider.auth"; readonly message: string }
-              | { readonly type: "provider.quota"; readonly message: string }
-              | { readonly type: "provider.content-filter"; readonly message: string }
-              | { readonly type: "provider.transport"; readonly message: string }
-              | { readonly type: "provider.internal"; readonly message: string }
-              | { readonly type: "provider.invalid-output"; readonly message: string }
-              | { readonly type: "provider.invalid-request"; readonly message: string }
-              | { readonly type: "provider.no-route"; readonly message: string }
-              | { readonly type: "provider.unknown"; readonly message: string }
-              | {
-                  readonly type: "permission.rejected"
-                  readonly message: string
-                  readonly permission: string
-                  readonly resources: ReadonlyArray<string>
-                }
-              | { readonly type: "tool.unknown"; readonly message: string; readonly name: string }
-              | { readonly type: "tool.stale"; readonly message: string; readonly name?: string }
-              | { readonly type: "tool.execution"; readonly message: string }
-              | { readonly type: "tool.result-missing"; readonly message: string; readonly callID?: string }
-              | {
-                  readonly type: "aborted"
-                  readonly message: string
-                  readonly reason?: "user" | "shutdown" | "timeout"
-                }
-              | { readonly type: "unknown"; readonly message: string; readonly agent?: string }
+            readonly error: { readonly type: "unknown"; readonly message: string }
           }
         }
       | {
           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 data: { readonly sessionID: string; readonly assistantMessageID: string; readonly textID: string }
         }
       | {
           readonly id: string
           readonly created: number
           readonly metadata?: { readonly [x: string]: unknown }
-          readonly type: "session.text.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 assistantMessageID: string; readonly text: string }
-        }
-      | {
-          readonly id: string
-          readonly created: number
-          readonly metadata?: { readonly [x: string]: unknown }
-          readonly type: "session.reasoning.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 state?: { readonly [x: string]: unknown }
-          }
-        }
-      | {
-          readonly id: string
-          readonly created: number
-          readonly metadata?: { readonly [x: string]: unknown }
-          readonly type: "session.reasoning.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: {
             readonly sessionID: string
             readonly assistantMessageID: string
+            readonly textID: string
             readonly text: string
-            readonly state?: { readonly [x: string]: unknown }
           }
         }
       | {
           readonly id: string
           readonly created: number
           readonly metadata?: { readonly [x: string]: unknown }
-          readonly type: "session.tool.input.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: {
+            readonly sessionID: string
+            readonly assistantMessageID: string
+            readonly reasoningID: string
+            readonly providerMetadata?: { readonly [x: string]: { readonly [x: string]: unknown } }
+          }
+        }
+      | {
+          readonly id: string
+          readonly created: number
+          readonly metadata?: { readonly [x: string]: unknown }
+          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: {
+            readonly sessionID: string
+            readonly assistantMessageID: string
+            readonly reasoningID: string
+            readonly text: string
+            readonly providerMetadata?: { readonly [x: string]: { readonly [x: string]: unknown } }
+          }
+        }
+      | {
+          readonly id: string
+          readonly created: number
+          readonly metadata?: { readonly [x: string]: unknown }
+          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: {
@@ -1575,7 +1377,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: {
@@ -1589,23 +1391,26 @@ 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: {
             readonly sessionID: string
             readonly assistantMessageID: string
             readonly callID: string
+            readonly tool: string
             readonly input: { readonly [x: string]: unknown }
-            readonly executed: boolean
-            readonly state?: { readonly [x: string]: unknown }
+            readonly provider: {
+              readonly executed: boolean
+              readonly metadata?: { readonly [x: string]: { readonly [x: string]: unknown } }
+            }
           }
         }
       | {
           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: {
@@ -1623,7 +1428,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: {
@@ -1637,99 +1442,56 @@ export type SessionLogOutput =
             >
             readonly outputPaths?: ReadonlyArray<string>
             readonly result?: unknown
-            readonly executed: boolean
-            readonly resultState?: { readonly [x: string]: unknown }
+            readonly provider: {
+              readonly executed: boolean
+              readonly metadata?: { readonly [x: string]: { readonly [x: string]: unknown } }
+            }
           }
         }
       | {
           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: {
             readonly sessionID: string
             readonly assistantMessageID: string
             readonly callID: string
-            readonly error:
-              | { readonly type: "provider.rate-limit"; readonly message: string; readonly retryAfterMs?: number }
-              | { readonly type: "provider.auth"; readonly message: string }
-              | { readonly type: "provider.quota"; readonly message: string }
-              | { readonly type: "provider.content-filter"; readonly message: string }
-              | { readonly type: "provider.transport"; readonly message: string }
-              | { readonly type: "provider.internal"; readonly message: string }
-              | { readonly type: "provider.invalid-output"; readonly message: string }
-              | { readonly type: "provider.invalid-request"; readonly message: string }
-              | { readonly type: "provider.no-route"; readonly message: string }
-              | { readonly type: "provider.unknown"; readonly message: string }
-              | {
-                  readonly type: "permission.rejected"
-                  readonly message: string
-                  readonly permission: string
-                  readonly resources: ReadonlyArray<string>
-                }
-              | { readonly type: "tool.unknown"; readonly message: string; readonly name: string }
-              | { readonly type: "tool.stale"; readonly message: string; readonly name?: string }
-              | { readonly type: "tool.execution"; readonly message: string }
-              | { readonly type: "tool.result-missing"; readonly message: string; readonly callID?: string }
-              | {
-                  readonly type: "aborted"
-                  readonly message: string
-                  readonly reason?: "user" | "shutdown" | "timeout"
-                }
-              | { readonly type: "unknown"; readonly message: string; readonly agent?: string }
+            readonly error: { readonly type: "unknown"; readonly message: string }
             readonly result?: unknown
-            readonly executed: boolean
-            readonly resultState?: { readonly [x: string]: unknown }
+            readonly provider: {
+              readonly executed: boolean
+              readonly metadata?: { readonly [x: string]: { readonly [x: string]: unknown } }
+            }
           }
         }
       | {
           readonly id: string
           readonly created: number
           readonly metadata?: { readonly [x: string]: unknown }
-          readonly type: "session.retry.scheduled"
+          readonly type: "retried"
           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 attempt: number
-            readonly at: number
-            readonly error:
-              | { readonly type: "provider.rate-limit"; readonly message: string; readonly retryAfterMs?: number }
-              | { readonly type: "provider.auth"; readonly message: string }
-              | { readonly type: "provider.quota"; readonly message: string }
-              | { readonly type: "provider.content-filter"; readonly message: string }
-              | { readonly type: "provider.transport"; readonly message: string }
-              | { readonly type: "provider.internal"; readonly message: string }
-              | { readonly type: "provider.invalid-output"; readonly message: string }
-              | { readonly type: "provider.invalid-request"; readonly message: string }
-              | { readonly type: "provider.no-route"; readonly message: string }
-              | { readonly type: "provider.unknown"; readonly message: string }
-              | {
-                  readonly type: "permission.rejected"
-                  readonly message: string
-                  readonly permission: string
-                  readonly resources: ReadonlyArray<string>
-                }
-              | { readonly type: "tool.unknown"; readonly message: string; readonly name: string }
-              | { readonly type: "tool.stale"; readonly message: string; readonly name?: string }
-              | { readonly type: "tool.execution"; readonly message: string }
-              | { readonly type: "tool.result-missing"; readonly message: string; readonly callID?: string }
-              | {
-                  readonly type: "aborted"
-                  readonly message: string
-                  readonly reason?: "user" | "shutdown" | "timeout"
-                }
-              | { readonly type: "unknown"; readonly message: string; readonly agent?: string }
+            readonly error: {
+              readonly message: string
+              readonly statusCode?: number
+              readonly isRetryable: boolean
+              readonly responseHeaders?: { readonly [x: string]: string }
+              readonly responseBody?: string
+              readonly metadata?: { readonly [x: string]: string }
+            }
           }
         }
       | {
           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" }
@@ -1738,7 +1500,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: {
@@ -1752,7 +1514,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: {
@@ -1776,7 +1538,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 }
@@ -1785,10 +1547,10 @@ 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 to: string }
+          readonly data: { readonly sessionID: string; readonly messageID: string }
         }
     )
   | { readonly type: "log.synced"; readonly aggregateID: string; readonly seq?: number }
@@ -1869,27 +1631,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
@@ -1899,20 +1643,23 @@ export type SessionMessageOutput = {
         readonly agent: string
         readonly model: { readonly id: string; readonly providerID: string; readonly variant?: string }
         readonly content: ReadonlyArray<
-          | { readonly type: "text"; readonly text: string }
+          | { readonly type: "text"; readonly id: string; readonly text: string }
           | {
               readonly type: "reasoning"
+              readonly id: string
               readonly text: string
-              readonly state?: { readonly [x: string]: JsonValue }
+              readonly providerMetadata?: { readonly [x: string]: { readonly [x: string]: JsonValue } }
               readonly time?: { readonly created: number; readonly completed?: number }
             }
           | {
               readonly type: "tool"
               readonly id: string
               readonly name: string
-              readonly executed?: boolean
-              readonly providerState?: { readonly [x: string]: JsonValue }
-              readonly providerResultState?: { readonly [x: string]: JsonValue }
+              readonly provider?: {
+                readonly executed: boolean
+                readonly metadata?: { readonly [x: string]: { readonly [x: string]: JsonValue } }
+                readonly resultMetadata?: { readonly [x: string]: { readonly [x: string]: JsonValue } }
+              }
               readonly state:
                 | { readonly status: "pending"; readonly input: string }
                 | {
@@ -1950,37 +1697,7 @@ export type SessionMessageOutput = {
                       | { readonly type: "file"; readonly uri: string; readonly mime: string; readonly name?: string }
                     >
                     readonly structured: { readonly [x: string]: JsonValue }
-                    readonly error:
-                      | {
-                          readonly type: "provider.rate-limit"
-                          readonly message: string
-                          readonly retryAfterMs?: number
-                        }
-                      | { readonly type: "provider.auth"; readonly message: string }
-                      | { readonly type: "provider.quota"; readonly message: string }
-                      | { readonly type: "provider.content-filter"; readonly message: string }
-                      | { readonly type: "provider.transport"; readonly message: string }
-                      | { readonly type: "provider.internal"; readonly message: string }
-                      | { readonly type: "provider.invalid-output"; readonly message: string }
-                      | { readonly type: "provider.invalid-request"; readonly message: string }
-                      | { readonly type: "provider.no-route"; readonly message: string }
-                      | { readonly type: "provider.unknown"; readonly message: string }
-                      | {
-                          readonly type: "permission.rejected"
-                          readonly message: string
-                          readonly permission: string
-                          readonly resources: ReadonlyArray<string>
-                        }
-                      | { readonly type: "tool.unknown"; readonly message: string; readonly name: string }
-                      | { readonly type: "tool.stale"; readonly message: string; readonly name?: string }
-                      | { readonly type: "tool.execution"; readonly message: string }
-                      | { readonly type: "tool.result-missing"; readonly message: string; readonly callID?: string }
-                      | {
-                          readonly type: "aborted"
-                          readonly message: string
-                          readonly reason?: "user" | "shutdown" | "timeout"
-                        }
-                      | { readonly type: "unknown"; readonly message: string; readonly agent?: string }
+                    readonly error: { readonly type: "unknown"; readonly message: string }
                     readonly result?: JsonValue
                   }
               readonly time: {
@@ -1992,7 +1709,7 @@ export type SessionMessageOutput = {
             }
         >
         readonly snapshot?: { readonly start?: string; readonly end?: string; readonly files?: ReadonlyArray<string> }
-        readonly finish?: "stop" | "length" | "tool-calls" | "content-filter" | "error" | "unknown"
+        readonly finish?: string
         readonly cost?: number
         readonly tokens?: {
           readonly input: number
@@ -2000,56 +1717,7 @@ export type SessionMessageOutput = {
           readonly reasoning: number
           readonly cache: { readonly read: number; readonly write: number }
         }
-        readonly error?:
-          | { readonly type: "provider.rate-limit"; readonly message: string; readonly retryAfterMs?: number }
-          | { readonly type: "provider.auth"; readonly message: string }
-          | { readonly type: "provider.quota"; readonly message: string }
-          | { readonly type: "provider.content-filter"; readonly message: string }
-          | { readonly type: "provider.transport"; readonly message: string }
-          | { readonly type: "provider.internal"; readonly message: string }
-          | { readonly type: "provider.invalid-output"; readonly message: string }
-          | { readonly type: "provider.invalid-request"; readonly message: string }
-          | { readonly type: "provider.no-route"; readonly message: string }
-          | { readonly type: "provider.unknown"; readonly message: string }
-          | {
-              readonly type: "permission.rejected"
-              readonly message: string
-              readonly permission: string
-              readonly resources: ReadonlyArray<string>
-            }
-          | { readonly type: "tool.unknown"; readonly message: string; readonly name: string }
-          | { readonly type: "tool.stale"; readonly message: string; readonly name?: string }
-          | { readonly type: "tool.execution"; readonly message: string }
-          | { readonly type: "tool.result-missing"; readonly message: string; readonly callID?: string }
-          | { readonly type: "aborted"; readonly message: string; readonly reason?: "user" | "shutdown" | "timeout" }
-          | { readonly type: "unknown"; readonly message: string; readonly agent?: string }
-        readonly retry?: {
-          readonly attempt: number
-          readonly at: number
-          readonly error:
-            | { readonly type: "provider.rate-limit"; readonly message: string; readonly retryAfterMs?: number }
-            | { readonly type: "provider.auth"; readonly message: string }
-            | { readonly type: "provider.quota"; readonly message: string }
-            | { readonly type: "provider.content-filter"; readonly message: string }
-            | { readonly type: "provider.transport"; readonly message: string }
-            | { readonly type: "provider.internal"; readonly message: string }
-            | { readonly type: "provider.invalid-output"; readonly message: string }
-            | { readonly type: "provider.invalid-request"; readonly message: string }
-            | { readonly type: "provider.no-route"; readonly message: string }
-            | { readonly type: "provider.unknown"; readonly message: string }
-            | {
-                readonly type: "permission.rejected"
-                readonly message: string
-                readonly permission: string
-                readonly resources: ReadonlyArray<string>
-              }
-            | { readonly type: "tool.unknown"; readonly message: string; readonly name: string }
-            | { readonly type: "tool.stale"; readonly message: string; readonly name?: string }
-            | { readonly type: "tool.execution"; readonly message: string }
-            | { readonly type: "tool.result-missing"; readonly message: string; readonly callID?: string }
-            | { readonly type: "aborted"; readonly message: string; readonly reason?: "user" | "shutdown" | "timeout" }
-            | { readonly type: "unknown"; readonly message: string; readonly agent?: string }
-        }
+        readonly error?: { readonly type: "unknown"; readonly message: string }
       }
     | {
         readonly type: "compaction"
@@ -2144,27 +1812,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
@@ -2174,20 +1824,23 @@ export type MessageListOutput = {
         readonly agent: string
         readonly model: { readonly id: string; readonly providerID: string; readonly variant?: string }
         readonly content: ReadonlyArray<
-          | { readonly type: "text"; readonly text: string }
+          | { readonly type: "text"; readonly id: string; readonly text: string }
           | {
               readonly type: "reasoning"
+              readonly id: string
               readonly text: string
-              readonly state?: { readonly [x: string]: JsonValue }
+              readonly providerMetadata?: { readonly [x: string]: { readonly [x: string]: JsonValue } }
               readonly time?: { readonly created: number; readonly completed?: number }
             }
           | {
               readonly type: "tool"
               readonly id: string
               readonly name: string
-              readonly executed?: boolean
-              readonly providerState?: { readonly [x: string]: JsonValue }
-              readonly providerResultState?: { readonly [x: string]: JsonValue }
+              readonly provider?: {
+                readonly executed: boolean
+                readonly metadata?: { readonly [x: string]: { readonly [x: string]: JsonValue } }
+                readonly resultMetadata?: { readonly [x: string]: { readonly [x: string]: JsonValue } }
+              }
               readonly state:
                 | { readonly status: "pending"; readonly input: string }
                 | {
@@ -2225,37 +1878,7 @@ export type MessageListOutput = {
                       | { readonly type: "file"; readonly uri: string; readonly mime: string; readonly name?: string }
                     >
                     readonly structured: { readonly [x: string]: JsonValue }
-                    readonly error:
-                      | {
-                          readonly type: "provider.rate-limit"
-                          readonly message: string
-                          readonly retryAfterMs?: number
-                        }
-                      | { readonly type: "provider.auth"; readonly message: string }
-                      | { readonly type: "provider.quota"; readonly message: string }
-                      | { readonly type: "provider.content-filter"; readonly message: string }
-                      | { readonly type: "provider.transport"; readonly message: string }
-                      | { readonly type: "provider.internal"; readonly message: string }
-                      | { readonly type: "provider.invalid-output"; readonly message: string }
-                      | { readonly type: "provider.invalid-request"; readonly message: string }
-                      | { readonly type: "provider.no-route"; readonly message: string }
-                      | { readonly type: "provider.unknown"; readonly message: string }
-                      | {
-                          readonly type: "permission.rejected"
-                          readonly message: string
-                          readonly permission: string
-                          readonly resources: ReadonlyArray<string>
-                        }
-                      | { readonly type: "tool.unknown"; readonly message: string; readonly name: string }
-                      | { readonly type: "tool.stale"; readonly message: string; readonly name?: string }
-                      | { readonly type: "tool.execution"; readonly message: string }
-                      | { readonly type: "tool.result-missing"; readonly message: string; readonly callID?: string }
-                      | {
-                          readonly type: "aborted"
-                          readonly message: string
-                          readonly reason?: "user" | "shutdown" | "timeout"
-                        }
-                      | { readonly type: "unknown"; readonly message: string; readonly agent?: string }
+                    readonly error: { readonly type: "unknown"; readonly message: string }
                     readonly result?: JsonValue
                   }
               readonly time: {
@@ -2267,7 +1890,7 @@ export type MessageListOutput = {
             }
         >
         readonly snapshot?: { readonly start?: string; readonly end?: string; readonly files?: ReadonlyArray<string> }
-        readonly finish?: "stop" | "length" | "tool-calls" | "content-filter" | "error" | "unknown"
+        readonly finish?: string
         readonly cost?: number
         readonly tokens?: {
           readonly input: number
@@ -2275,56 +1898,7 @@ export type MessageListOutput = {
           readonly reasoning: number
           readonly cache: { readonly read: number; readonly write: number }
         }
-        readonly error?:
-          | { readonly type: "provider.rate-limit"; readonly message: string; readonly retryAfterMs?: number }
-          | { readonly type: "provider.auth"; readonly message: string }
-          | { readonly type: "provider.quota"; readonly message: string }
-          | { readonly type: "provider.content-filter"; readonly message: string }
-          | { readonly type: "provider.transport"; readonly message: string }
-          | { readonly type: "provider.internal"; readonly message: string }
-          | { readonly type: "provider.invalid-output"; readonly message: string }
-          | { readonly type: "provider.invalid-request"; readonly message: string }
-          | { readonly type: "provider.no-route"; readonly message: string }
-          | { readonly type: "provider.unknown"; readonly message: string }
-          | {
-              readonly type: "permission.rejected"
-              readonly message: string
-              readonly permission: string
-              readonly resources: ReadonlyArray<string>
-            }
-          | { readonly type: "tool.unknown"; readonly message: string; readonly name: string }
-          | { readonly type: "tool.stale"; readonly message: string; readonly name?: string }
-          | { readonly type: "tool.execution"; readonly message: string }
-          | { readonly type: "tool.result-missing"; readonly message: string; readonly callID?: string }
-          | { readonly type: "aborted"; readonly message: string; readonly reason?: "user" | "shutdown" | "timeout" }
-          | { readonly type: "unknown"; readonly message: string; readonly agent?: string }
-        readonly retry?: {
-          readonly attempt: number
-          readonly at: number
-          readonly error:
-            | { readonly type: "provider.rate-limit"; readonly message: string; readonly retryAfterMs?: number }
-            | { readonly type: "provider.auth"; readonly message: string }
-            | { readonly type: "provider.quota"; readonly message: string }
-            | { readonly type: "provider.content-filter"; readonly message: string }
-            | { readonly type: "provider.transport"; readonly message: string }
-            | { readonly type: "provider.internal"; readonly message: string }
-            | { readonly type: "provider.invalid-output"; readonly message: string }
-            | { readonly type: "provider.invalid-request"; readonly message: string }
-            | { readonly type: "provider.no-route"; readonly message: string }
-            | { readonly type: "provider.unknown"; readonly message: string }
-            | {
-                readonly type: "permission.rejected"
-                readonly message: string
-                readonly permission: string
-                readonly resources: ReadonlyArray<string>
-              }
-            | { readonly type: "tool.unknown"; readonly message: string; readonly name: string }
-            | { readonly type: "tool.stale"; readonly message: string; readonly name?: string }
-            | { readonly type: "tool.execution"; readonly message: string }
-            | { readonly type: "tool.result-missing"; readonly message: string; readonly callID?: string }
-            | { readonly type: "aborted"; readonly message: string; readonly reason?: "user" | "shutdown" | "timeout" }
-            | { readonly type: "unknown"; readonly message: string; readonly agent?: string }
-        }
+        readonly error?: { readonly type: "unknown"; readonly message: string }
       }
     | {
         readonly type: "compaction"
@@ -2779,7 +2353,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" }
@@ -4749,7 +4323,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 }
@@ -4758,7 +4332,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: {
@@ -4783,7 +4357,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 }
@@ -4792,7 +4366,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 }
@@ -4801,7 +4375,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 }
@@ -4810,7 +4384,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: {
@@ -4837,63 +4411,14 @@ export type EventSubscribeOutput =
       readonly id: string
       readonly created: number
       readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "session.execution.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 id: string
-      readonly created: number
-      readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "session.execution.succeeded"
-      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 id: string
-      readonly created: number
-      readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "session.execution.failed"
-      readonly durable: { readonly aggregateID: string; readonly seq: number; readonly version: number }
+      readonly type: "execution.settled"
       readonly location?: { readonly directory: string; readonly workspaceID?: string }
       readonly data: {
         readonly sessionID: string
-        readonly error:
-          | { readonly type: "provider.rate-limit"; readonly message: string; readonly retryAfterMs?: number }
-          | { readonly type: "provider.auth"; readonly message: string }
-          | { readonly type: "provider.quota"; readonly message: string }
-          | { readonly type: "provider.content-filter"; readonly message: string }
-          | { readonly type: "provider.transport"; readonly message: string }
-          | { readonly type: "provider.internal"; readonly message: string }
-          | { readonly type: "provider.invalid-output"; readonly message: string }
-          | { readonly type: "provider.invalid-request"; readonly message: string }
-          | { readonly type: "provider.no-route"; readonly message: string }
-          | { readonly type: "provider.unknown"; readonly message: string }
-          | {
-              readonly type: "permission.rejected"
-              readonly message: string
-              readonly permission: string
-              readonly resources: ReadonlyArray<string>
-            }
-          | { readonly type: "tool.unknown"; readonly message: string; readonly name: string }
-          | { readonly type: "tool.stale"; readonly message: string; readonly name?: string }
-          | { readonly type: "tool.execution"; readonly message: string }
-          | { readonly type: "tool.result-missing"; readonly message: string; readonly callID?: string }
-          | { readonly type: "aborted"; readonly message: string; readonly reason?: "user" | "shutdown" | "timeout" }
-          | { readonly type: "unknown"; readonly message: string; readonly agent?: string }
+        readonly outcome: "success" | "failure" | "interrupted"
+        readonly error?: { readonly type: "unknown"; readonly message: string }
       }
     }
-  | {
-      readonly id: string
-      readonly created: number
-      readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "session.execution.interrupted"
-      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: "user" | "shutdown" | "superseded" }
-    }
   | {
       readonly id: string
       readonly created: number
@@ -4907,7 +4432,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: {
@@ -4921,7 +4446,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 }
@@ -4930,59 +4455,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: {
@@ -4997,13 +4488,13 @@ 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: {
         readonly sessionID: string
         readonly assistantMessageID: string
-        readonly finish: "stop" | "length" | "tool-calls" | "content-filter" | "error" | "unknown"
+        readonly finish: string
         readonly cost: number
         readonly tokens: {
           readonly input: number
@@ -5019,103 +4510,98 @@ 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: {
         readonly sessionID: string
         readonly assistantMessageID: string
-        readonly error:
-          | { readonly type: "provider.rate-limit"; readonly message: string; readonly retryAfterMs?: number }
-          | { readonly type: "provider.auth"; readonly message: string }
-          | { readonly type: "provider.quota"; readonly message: string }
-          | { readonly type: "provider.content-filter"; readonly message: string }
-          | { readonly type: "provider.transport"; readonly message: string }
-          | { readonly type: "provider.internal"; readonly message: string }
-          | { readonly type: "provider.invalid-output"; readonly message: string }
-          | { readonly type: "provider.invalid-request"; readonly message: string }
-          | { readonly type: "provider.no-route"; readonly message: string }
-          | { readonly type: "provider.unknown"; readonly message: string }
-          | {
-              readonly type: "permission.rejected"
-              readonly message: string
-              readonly permission: string
-              readonly resources: ReadonlyArray<string>
-            }
-          | { readonly type: "tool.unknown"; readonly message: string; readonly name: string }
-          | { readonly type: "tool.stale"; readonly message: string; readonly name?: string }
-          | { readonly type: "tool.execution"; readonly message: string }
-          | { readonly type: "tool.result-missing"; readonly message: string; readonly callID?: string }
-          | { readonly type: "aborted"; readonly message: string; readonly reason?: "user" | "shutdown" | "timeout" }
-          | { readonly type: "unknown"; readonly message: string; readonly agent?: string }
+        readonly error: { readonly type: "unknown"; readonly message: string }
       }
     }
   | {
       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 data: { readonly sessionID: string; readonly assistantMessageID: string; readonly textID: string }
     }
   | {
       readonly id: string
       readonly created: number
       readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "session.text.delta"
-      readonly location?: { readonly directory: string; readonly workspaceID?: string }
-      readonly data: { readonly sessionID: string; readonly assistantMessageID: string; readonly delta: string }
-    }
-  | {
-      readonly id: string
-      readonly created: number
-      readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "session.text.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 assistantMessageID: string; readonly text: string }
-    }
-  | {
-      readonly id: string
-      readonly created: number
-      readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "session.reasoning.started"
-      readonly durable: { readonly aggregateID: string; readonly seq: number; readonly version: number }
+      readonly type: "text.delta"
       readonly location?: { readonly directory: string; readonly workspaceID?: string }
       readonly data: {
         readonly sessionID: string
         readonly assistantMessageID: string
-        readonly state?: { readonly [x: string]: unknown }
+        readonly textID: string
+        readonly delta: string
       }
     }
   | {
       readonly id: string
       readonly created: number
       readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "session.reasoning.delta"
-      readonly location?: { readonly directory: string; readonly workspaceID?: string }
-      readonly data: { readonly sessionID: string; readonly assistantMessageID: string; readonly delta: string }
-    }
-  | {
-      readonly id: string
-      readonly created: number
-      readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "session.reasoning.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: {
         readonly sessionID: string
         readonly assistantMessageID: string
+        readonly textID: string
         readonly text: string
-        readonly state?: { readonly [x: string]: unknown }
       }
     }
   | {
       readonly id: string
       readonly created: number
       readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "session.tool.input.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: {
+        readonly sessionID: string
+        readonly assistantMessageID: string
+        readonly reasoningID: string
+        readonly providerMetadata?: { readonly [x: string]: { readonly [x: string]: unknown } }
+      }
+    }
+  | {
+      readonly id: string
+      readonly created: number
+      readonly metadata?: { readonly [x: string]: unknown }
+      readonly type: "reasoning.delta"
+      readonly location?: { readonly directory: string; readonly workspaceID?: string }
+      readonly data: {
+        readonly sessionID: string
+        readonly assistantMessageID: string
+        readonly reasoningID: string
+        readonly delta: string
+      }
+    }
+  | {
+      readonly id: string
+      readonly created: number
+      readonly metadata?: { readonly [x: string]: unknown }
+      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: {
+        readonly sessionID: string
+        readonly assistantMessageID: string
+        readonly reasoningID: string
+        readonly text: string
+        readonly providerMetadata?: { readonly [x: string]: { readonly [x: string]: unknown } }
+      }
+    }
+  | {
+      readonly id: string
+      readonly created: number
+      readonly metadata?: { readonly [x: string]: unknown }
+      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: {
@@ -5129,7 +4615,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
@@ -5142,7 +4628,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: {
@@ -5156,23 +4642,26 @@ 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: {
         readonly sessionID: string
         readonly assistantMessageID: string
         readonly callID: string
+        readonly tool: string
         readonly input: { readonly [x: string]: unknown }
-        readonly executed: boolean
-        readonly state?: { readonly [x: string]: unknown }
+        readonly provider: {
+          readonly executed: boolean
+          readonly metadata?: { readonly [x: string]: { readonly [x: string]: unknown } }
+        }
       }
     }
   | {
       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: {
@@ -5190,7 +4679,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: {
@@ -5204,91 +4693,56 @@ export type EventSubscribeOutput =
         >
         readonly outputPaths?: ReadonlyArray<string>
         readonly result?: unknown
-        readonly executed: boolean
-        readonly resultState?: { readonly [x: string]: unknown }
+        readonly provider: {
+          readonly executed: boolean
+          readonly metadata?: { readonly [x: string]: { readonly [x: string]: unknown } }
+        }
       }
     }
   | {
       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: {
         readonly sessionID: string
         readonly assistantMessageID: string
         readonly callID: string
-        readonly error:
-          | { readonly type: "provider.rate-limit"; readonly message: string; readonly retryAfterMs?: number }
-          | { readonly type: "provider.auth"; readonly message: string }
-          | { readonly type: "provider.quota"; readonly message: string }
-          | { readonly type: "provider.content-filter"; readonly message: string }
-          | { readonly type: "provider.transport"; readonly message: string }
-          | { readonly type: "provider.internal"; readonly message: string }
-          | { readonly type: "provider.invalid-output"; readonly message: string }
-          | { readonly type: "provider.invalid-request"; readonly message: string }
-          | { readonly type: "provider.no-route"; readonly message: string }
-          | { readonly type: "provider.unknown"; readonly message: string }
-          | {
-              readonly type: "permission.rejected"
-              readonly message: string
-              readonly permission: string
-              readonly resources: ReadonlyArray<string>
-            }
-          | { readonly type: "tool.unknown"; readonly message: string; readonly name: string }
-          | { readonly type: "tool.stale"; readonly message: string; readonly name?: string }
-          | { readonly type: "tool.execution"; readonly message: string }
-          | { readonly type: "tool.result-missing"; readonly message: string; readonly callID?: string }
-          | { readonly type: "aborted"; readonly message: string; readonly reason?: "user" | "shutdown" | "timeout" }
-          | { readonly type: "unknown"; readonly message: string; readonly agent?: string }
+        readonly error: { readonly type: "unknown"; readonly message: string }
         readonly result?: unknown
-        readonly executed: boolean
-        readonly resultState?: { readonly [x: string]: unknown }
+        readonly provider: {
+          readonly executed: boolean
+          readonly metadata?: { readonly [x: string]: { readonly [x: string]: unknown } }
+        }
       }
     }
   | {
       readonly id: string
       readonly created: number
       readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "session.retry.scheduled"
+      readonly type: "retried"
       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 attempt: number
-        readonly at: number
-        readonly error:
-          | { readonly type: "provider.rate-limit"; readonly message: string; readonly retryAfterMs?: number }
-          | { readonly type: "provider.auth"; readonly message: string }
-          | { readonly type: "provider.quota"; readonly message: string }
-          | { readonly type: "provider.content-filter"; readonly message: string }
-          | { readonly type: "provider.transport"; readonly message: string }
-          | { readonly type: "provider.internal"; readonly message: string }
-          | { readonly type: "provider.invalid-output"; readonly message: string }
-          | { readonly type: "provider.invalid-request"; readonly message: string }
-          | { readonly type: "provider.no-route"; readonly message: string }
-          | { readonly type: "provider.unknown"; readonly message: string }
-          | {
-              readonly type: "permission.rejected"
-              readonly message: string
-              readonly permission: string
-              readonly resources: ReadonlyArray<string>
-            }
-          | { readonly type: "tool.unknown"; readonly message: string; readonly name: string }
-          | { readonly type: "tool.stale"; readonly message: string; readonly name?: string }
-          | { readonly type: "tool.execution"; readonly message: string }
-          | { readonly type: "tool.result-missing"; readonly message: string; readonly callID?: string }
-          | { readonly type: "aborted"; readonly message: string; readonly reason?: "user" | "shutdown" | "timeout" }
-          | { readonly type: "unknown"; readonly message: string; readonly agent?: string }
+        readonly error: {
+          readonly message: string
+          readonly statusCode?: number
+          readonly isRetryable: boolean
+          readonly responseHeaders?: { readonly [x: string]: string }
+          readonly responseBody?: string
+          readonly metadata?: { readonly [x: string]: string }
+        }
       }
     }
   | {
       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" }
@@ -5297,7 +4751,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 }
     }
@@ -5305,7 +4759,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: {
@@ -5319,7 +4773,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: {
@@ -5343,7 +4797,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 }
@@ -5352,18 +4806,18 @@ 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 to: string }
+      readonly data: { readonly sessionID: string; readonly messageID: string }
     }
   | {
       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
@@ -5429,7 +4883,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: {}
     }
@@ -5437,9 +4891,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

packages/client/src/promise/index.ts

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

packages/client/test/api.types.ts

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

packages/client/test/effect.test.ts

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

packages/client/test/promise.test.ts

@@ -160,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 () => {
@@ -329,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",

packages/client/tsconfig.build.json

@@ -1,11 +0,0 @@
-{
-  "$schema": "https://json.schemastore.org/tsconfig",
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "rootDir": "src",
-    "outDir": "dist",
-    "noEmit": false,
-    "declaration": true
-  },
-  "include": ["src"]
-}

packages/client/tsconfig.json

@@ -3,8 +3,6 @@
   "extends": "@tsconfig/bun/tsconfig.json",
   "compilerOptions": {
     "lib": ["ESNext", "DOM", "DOM.Iterable"],
-    "allowImportingTsExtensions": false,
-    "allowJs": false,
     "noUncheckedIndexedAccess": false
   },
   "include": ["src"]

packages/codemode/src/tool-runtime.ts

@@ -458,8 +458,8 @@ export const discoveryPlan = <R>(
 
   // Section order is deliberate: workflow first (the top is the least likely part of a long
   // description to be truncated or skimmed away), then rules, then syntax, with the budgeted
-  // catalog at the bottom. Example call forms use placeholders - never a real or fabricated
-  // tool name - and show both dot and bracket notation so non-identifier names are not normalized.
+  // catalog at the bottom. Example call forms use explicit `<namespace>.<tool>` placeholders -
+  // never a real or fabricated tool name.
   const intro = [
     "Write a CodeMode program to answer the request. Return code only.",
     empty
@@ -467,7 +467,6 @@ export const discoveryPlan = <R>(
       : complete
         ? "Execute JavaScript in a confined runtime. Inside this program, `tools` contains only the host-provided tools listed below; surrounding agent tools are not available unless listed here."
         : "Execute JavaScript in a confined runtime. Inside this program, `tools` contains only the host-provided tools listed or searchable below; surrounding agent tools are not available unless listed here.",
-    ...(empty ? [] : ["Do not infer or normalize tool names; use only exact signatures shown below or returned by search."]),
   ]
 
   // The search step exists only when search is advertised (PARTIAL catalog); a COMPLETE
@@ -481,14 +480,14 @@ export const discoveryPlan = <R>(
         ...(complete
           ? [
               "1. Pick a tool from the list under `## Available tools` - each line is the exact call signature; use it as-is rather than guessing segments.",
-              '2. Call it using the exact signature shown; bracket notation and quotes are part of the path.',
+              "2. Call it using the exact signature shown: `const res = await tools.<namespace>.<tool>(input)` - bracket notation may appear for names that are not JavaScript identifiers.",
               '3. Parse text results: `const data = typeof res === "string" ? JSON.parse(res) : res` - most tools return JSON as a string.',
               "4. Return only the fields you need: `return { <field>: data.<field> }` - raw payloads get truncated and waste context.",
             ]
           : [
-              '1. If the exact signature is not listed below, first search: `const { items } = await tools.$codemode.search({ query: "<intent + key nouns>" })`.',
+              '1. Find a tool (skip when it is already listed below): `const { items } = await tools.$codemode.search({ query: "<intent + key nouns>" })` - short phrases like "list issues" work best.',
               "2. Read the matches: each item is `{ path, description, signature }` - read the description before using an unfamiliar tool.",
-              "3. Call the result's `path` as-is; bracket notation and quotes are part of the path.",
+              "3. Call it with the result's `path` as-is (never guess segments): `const res = await tools.<namespace>.<tool>(input)` - bracket notation may appear for names that are not JavaScript identifiers.",
               '4. Parse text results: `const data = typeof res === "string" ? JSON.parse(res) : res` - most tools return JSON as a string.',
               "5. Return only the fields you need: `return { <field>: data.<field> }` - raw payloads get truncated and waste context.",
             ]),
@@ -505,7 +504,7 @@ export const discoveryPlan = <R>(
           : "- Only tools listed here or returned by `tools.$codemode.search` are available inside `tools`; tools from the surrounding agent/runtime are not implicitly exposed.",
         "- Filter, aggregate, and transform collections in code - never return them raw or call a tool per item across messages.",
         "- A result typed `Promise<unknown>` has no guaranteed shape - verify what actually came back before relying on its fields.",
-        '- Run independent calls in parallel: `await Promise.all(items.map((item) => tools.<namespace>.<tool>(item)))`, or use `tools.<namespace>["tool-name"](item)` when the listed signature uses bracket notation.',
+        "- Run independent calls in parallel: `await Promise.all(items.map((item) => tools.<namespace>.<tool>(item)))`.",
         "- `Object.keys(tools)` lists namespaces; `Object.keys(tools.<namespace>)` lists its tools; `for...in` works on both.",
         ...(complete
           ? []

packages/codemode/test/codemode.test.ts

@@ -622,12 +622,12 @@ describe("CodeMode public contract", () => {
     )
     expect(instructions).toContain("Return only the fields you need")
     expect(instructions).toContain("raw payloads get truncated and waste context")
-    expect(instructions).toContain("Do not infer or normalize tool names")
-    expect(instructions).toContain("bracket notation and quotes are part of the path")
+    expect(instructions).toContain("`const res = await tools.<namespace>.<tool>(input)`")
     expect(instructions).toContain("surrounding agent tools are not available unless listed here")
     expect(instructions).toContain("Only tools listed here are available inside `tools`")
-    // Placeholders use generic namespace/tool/field names only - no fabricated real tools
-    // and no real catalog tools cherry-picked into example lines.
+    expect(instructions).toContain("bracket notation may appear for names that are not JavaScript identifiers")
+    // Placeholders use the <namespace>.<tool>/<field> style ONLY - no fabricated tool
+    // names, and no real catalog tools cherry-picked into example lines.
     expect(instructions).toContain("`return { <field>: data.<field> }`")
     expect(instructions).not.toContain("total_count")
     expect(instructions).not.toContain("list_issues")
@@ -640,7 +640,7 @@ describe("CodeMode public contract", () => {
     // PARTIAL: the workflow starts with search (with query-style guidance that is clearly
     // a query string, never a tool name) and the browse-namespace rule appears.
     expect(partial).toContain(
-      '1. If the exact signature is not listed below, first search: `const { items } = await tools.$codemode.search({ query: "<intent + key nouns>" })`.',
+      '1. Find a tool (skip when it is already listed below): `const { items } = await tools.$codemode.search({ query: "<intent + key nouns>" })` - short phrases like "list issues" work best.',
     )
     expect(partial).toContain(
       "Only tools listed here or returned by `tools.$codemode.search` are available inside `tools`",

packages/codemode/test/signature.test.ts

@@ -339,43 +339,3 @@ describe("pretty signatures in search results", () => {
     expect(instructions).not.toContain("/**")
   })
 })
-
-describe("non-identifier tool paths", () => {
-  const resolveLibrary = Tool.make({
-    description: "Resolve a Context7 library ID",
-    input: {
-      type: "object",
-      properties: {
-        query: { type: "string" },
-        libraryName: { type: "string" },
-      },
-      required: ["query", "libraryName"],
-    } as const,
-    run: () => Effect.succeed("/reactjs/react.dev"),
-  })
-  const runtime = CodeMode.make({ tools: { context7: { "resolve-library-id": resolveLibrary } } })
-
-  test("inline catalog uses bracket notation for dashed tool names", () => {
-    const instructions = runtime.instructions()
-
-    expect(instructions).toContain(
-      'tools.context7["resolve-library-id"](input: { query: string; libraryName: string }): Promise<unknown>',
-    )
-    expect(instructions).toContain("Do not infer or normalize tool names")
-    expect(instructions).toContain("bracket notation and quotes are part of the path")
-    expect(instructions).not.toContain("tools.context7.resolve-library-id")
-    expect(instructions).not.toContain("tools.context7.resolve_library_id")
-  })
-
-  test("search results return callable bracket-notation paths and signatures", async () => {
-    const result = await Effect.runPromise(
-      runtime.execute(`return await tools.$codemode.search({ query: "resolve library" })`),
-    )
-    expect(result.ok).toBe(true)
-    if (!result.ok) throw new Error("search failed")
-
-    const value = result.value as { items: Array<{ path: string; signature: string }> }
-    expect(value.items[0]?.path).toBe('tools.context7["resolve-library-id"]')
-    expect(value.items[0]?.signature).toContain('tools.context7["resolve-library-id"](input: {')
-  })
-})

packages/core/src/catalog.ts

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

packages/core/src/config.ts

@@ -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"
@@ -104,6 +102,7 @@ export class Info extends Schema.Class<Info>("Config.Info")({
   plugins: ConfigPlugin.Plugins.pipe(Schema.optional).annotate({
     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],
 })

packages/core/src/config/experimental.ts

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

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

@@ -2,7 +2,7 @@ export * as ConfigAgentPlugin from "./agent"
 
 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"
@@ -38,75 +38,64 @@ export const Plugin = define({
   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)
+            })
+          }
+        }
+      }),
     )
   }),
 })

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

@@ -2,7 +2,7 @@ export * as ConfigCommandPlugin from "./command"
 
 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"
@@ -17,45 +17,34 @@ export const Plugin = define({
   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 }),
+      }),
     )
   }),
 })

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

@@ -2,8 +2,7 @@ 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, Stream } from "effect"
-import { createRequire } from "node:module"
+import { Effect, Schema } from "effect"
 import path from "path"
 import { fileURLToPath, pathToFileURL } from "url"
 import { Config } from "../../config"
@@ -36,9 +35,6 @@ const PluginPackage = Schema.Struct({
   module: Schema.optional(Schema.String),
 })
 
-let importGeneration = 0
-const moduleCache = createRequire(import.meta.url).cache
-
 export const Plugin = define({
   id: "config-plugin",
   effect: Effect.fn(function* (ctx) {
@@ -46,9 +42,8 @@ export const Plugin = define({
     const fs = yield* FSUtil.Service
     const location = yield* Location.Service
     const npm = yield* Npm.Service
-    const active = new Set<string>()
-    const load = Effect.fn("ConfigExternalPlugin.load")(function* () {
-      const configured: { package: string; options?: Record<string, unknown> }[] = []
+    yield* Effect.gen(function* () {
+      const configured: { package: string; options?: Record<string, any> }[] = []
 
       for (const entry of yield* config.entries()) {
         if (entry.type === "document") {
@@ -103,55 +98,26 @@ export const Plugin = define({
         }
       }
 
-      return yield* Effect.forEach(configured, (ref) =>
-        Effect.gen(function* () {
+      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(cacheBust(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)
-          return {
+          yield* ctx.plugin.add({
             id: plugin.id,
-            effect: (host: Parameters<typeof plugin.effect>[0]) =>
-              plugin.effect({ ...host, options: ref.options ?? {} }),
-          }
-        }).pipe(
-          Effect.catchCause((cause) =>
-            Effect.logError("failed to load plugin", { package: ref.package, cause }).pipe(Effect.as(undefined)),
-          ),
-        ),
-      ).pipe(Effect.map((plugins) => plugins.filter((plugin) => plugin !== undefined)))
-    })
-    const reconcile = Effect.fn("ConfigExternalPlugin.reconcile")(function* () {
-      const plugins = yield* load()
-      const next = new Set(plugins.map((plugin) => plugin.id))
-      for (const id of active) {
-        if (!next.has(id)) yield* ctx.plugin.remove(id)
+            effect: (host) => plugin.effect({ ...host, options: ref.options ?? {} }),
+          })
+        }).pipe(Effect.ignoreCause)
       }
-      for (const plugin of plugins) yield* ctx.plugin.add(plugin)
-      active.clear()
-      for (const id of next) active.add(id)
     })
-
-    yield* reconcile()
-    yield* ctx.event.subscribe().pipe(
-      Stream.filter((event) => event.type === "config.updated"),
-      Stream.runForEach(() => reconcile()),
-      Effect.forkScoped({ startImmediately: true }),
-    )
   }),
 })
 
-function cacheBust(entrypoint: string) {
-  const url = path.isAbsolute(entrypoint) ? pathToFileURL(entrypoint) : new URL(entrypoint)
-  if (url.protocol === "file:") delete moduleCache[fileURLToPath(url)]
-  url.searchParams.set("opencode-reload", String(++importGeneration))
-  return url.href
-}
-
 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)),

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

@@ -1,7 +1,7 @@
 export * as ConfigProviderPlugin from "./provider"
 
 import { define } from "../../plugin/internal"
-import { Effect, Stream } from "effect"
+import { Effect } from "effect"
 import { Config } from "../../config"
 import { ModelV2 } from "../../model"
 
@@ -9,115 +9,108 @@ export const Plugin = define({
   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 }
+              })
+            }
+          }
+        }
+      }),
     )
   }),
 })

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

@@ -2,7 +2,7 @@ export * as ConfigReferencePlugin from "./reference"
 
 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"
@@ -16,47 +16,40 @@ export const Plugin = define({
     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)
+      }),
     )
   }),
 })

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

@@ -2,7 +2,7 @@ export * as ConfigSkillPlugin from "./skill"
 
 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"
@@ -15,44 +15,36 @@ export const Plugin = define({
     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)),
+            }),
+          )
+        }
+      }),
     )
   }),
 })

packages/core/src/config/variable.ts

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

packages/core/src/database/migration.gen.ts

@@ -43,8 +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"),
-    import("./migration/20260703200000_reset_v2_event_fragments"),
-    import("./migration/20260703210000_reset_v2_execution_errors"),
   ])
 ).map((module) => module.default) satisfies DatabaseMigration.Migration[]

packages/core/src/database/migration/20260703190000_reset_v2_shell_event_payloads.ts

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

packages/core/src/database/migration/20260703200000_reset_v2_event_fragments.ts

@@ -1,14 +0,0 @@
-import { Effect } from "effect"
-import type { DatabaseMigration } from "../migration"
-
-export default {
-  id: "20260703200000_reset_v2_event_fragments",
-  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

packages/core/src/database/migration/20260703210000_reset_v2_execution_errors.ts

@@ -1,14 +0,0 @@
-import { Effect } from "effect"
-import type { DatabaseMigration } from "../migration"
-
-export default {
-  id: "20260703210000_reset_v2_execution_errors",
-  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

packages/core/src/filesystem/location-watcher.ts

@@ -1,83 +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 config = (yield* configService.entries())
-      .filter((entry): entry is Config.Document => entry.type === "document")
-      .flatMap((item) => item.info.watcher?.ignore ?? [])
-    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",
-      })
-
-    if (path.resolve(location.directory) !== path.resolve(os.homedir())) {
-      yield* watcher
-        .subscribe({
-          path: location.directory,
-          type: "directory",
-          ignore: [...Ignore.PATTERNS, ...config, ...protecteds(location.directory)],
-        })
-        .pipe(Stream.runForEach(publish), Effect.forkScoped({ startImmediately: true }))
-    } else {
-      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({ startImmediately: true }))
-      }
-    }
-
-    return Service.of({})
-  }).pipe(
-    Effect.catchCause((cause) =>
-      Effect.logError("failed to init location watcher service", { cause }).pipe(Effect.as(Service.of({}))),
-    ),
-  ),
-)
-
-export const node = makeLocationNode({
-  service: Service,
-  layer,
-  deps: [Watcher.node, FSUtil.node, Location.node, Config.node, Git.node, EventV2.node],
-})

packages/core/src/filesystem/watcher.ts

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

packages/core/src/location-services.ts

@@ -11,7 +11,7 @@ import { FileSystem } from "./filesystem"
 import { FileSystemSearch } from "./filesystem/search"
 import { Generate } from "./generate"
 import { Form } from "./form"
-import { LocationWatcher } from "./filesystem/location-watcher"
+import { Watcher } from "./filesystem/watcher"
 import { Image } from "./image"
 import { Integration } from "./integration"
 import { Location } from "./location"
@@ -21,6 +21,7 @@ import { MCP } from "./mcp/index"
 import { PermissionV2 } from "./permission"
 import { PluginV2 } from "./plugin"
 import { PluginInternal } from "./plugin/internal"
+import { Policy } from "./policy"
 import { ProjectCopy } from "./project/copy"
 import { Pty } from "./pty"
 import { QuestionV2 } from "./question"
@@ -49,6 +50,7 @@ export { LocationServiceMap } from "./location-service-map"
 
 const locationServiceNodes = [
   Location.node,
+  Policy.node,
   Config.node,
   AgentV2.node,
   CommandV2.node,
@@ -62,7 +64,7 @@ const locationServiceNodes = [
   ProjectCopy.refreshNode,
   FileSystemSearch.node,
   FileSystem.node,
-  LocationWatcher.node,
+  Watcher.node,
   Pty.node,
   Shell.node,
   SkillV2.node,

packages/core/src/mcp/index.ts

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

packages/core/src/permission.ts

@@ -59,14 +59,7 @@ export type AskResult = typeof AskResult.Type
 
 export const Event = Permission.Event
 
-export class RejectedError extends Schema.TaggedErrorClass<RejectedError>()("PermissionV2.RejectedError", {
-  permission: Schema.String,
-  resources: Schema.Array(Schema.String),
-}) {
-  override get message() {
-    return `Permission rejected: ${this.permission}`
-  }
-}
+export class RejectedError extends Schema.TaggedErrorClass<RejectedError>()("PermissionV2.RejectedError", {}) {}
 
 export class CorrectedError extends Schema.TaggedErrorClass<CorrectedError>()("PermissionV2.CorrectedError", {
   feedback: Schema.String,
@@ -74,13 +67,7 @@ export class CorrectedError extends Schema.TaggedErrorClass<CorrectedError>()("P
 
 export class DeniedError extends Schema.TaggedErrorClass<DeniedError>()("PermissionV2.DeniedError", {
   rules: Permission.Ruleset,
-  permission: Schema.String,
-  resources: Schema.Array(Schema.String),
-}) {
-  override get message() {
-    return `Permission denied: ${this.permission}`
-  }
-}
+}) {}
 
 export class NotFoundError extends Schema.TaggedErrorClass<NotFoundError>()("PermissionV2.NotFoundError", {
   requestID: ID,
@@ -132,17 +119,9 @@ const layer = Layer.effect(
     const pending = new Map<ID, Pending>()
 
     yield* Effect.addFinalizer(() =>
-      Effect.forEach(
-        pending.values(),
-        (item) =>
-          Deferred.fail(
-            item.deferred,
-            new RejectedError({ permission: item.request.action, resources: [...item.request.resources] }),
-          ),
-        {
-          discard: true,
-        },
-      ).pipe(
+      Effect.forEach(pending.values(), (item) => Deferred.fail(item.deferred, new RejectedError()), {
+        discard: true,
+      }).pipe(
         Effect.ensuring(
           Effect.sync(() => {
             pending.clear()
@@ -222,8 +201,6 @@ const layer = Layer.effect(
           if (result.effect === "deny") {
             return yield* new DeniedError({
               rules: relevant(input, result.rules),
-              permission: input.action,
-              resources: input.resources,
             })
           }
           if (result.effect === "allow") return
@@ -253,12 +230,7 @@ const layer = Layer.effect(
           if (input.reply === "reject") {
             yield* Deferred.fail(
               existing.deferred,
-              input.message
-                ? new CorrectedError({ feedback: input.message })
-                : new RejectedError({
-                    permission: existing.request.action,
-                    resources: [...existing.request.resources],
-                  }),
+              input.message ? new CorrectedError({ feedback: input.message }) : new RejectedError(),
             )
             pending.delete(input.requestID)
             for (const [id, item] of pending) {
@@ -268,10 +240,7 @@ const layer = Layer.effect(
                 requestID: item.request.id,
                 reply: "reject",
               })
-              yield* Deferred.fail(
-                item.deferred,
-                new RejectedError({ permission: item.request.action, resources: [...item.request.resources] }),
-              )
+              yield* Deferred.fail(item.deferred, new RejectedError())
               pending.delete(id)
             }
             return

packages/core/src/plugin/host.ts

@@ -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,14 +21,12 @@ import { ToolHooks } from "../tool/hooks"
 import { WorkspaceV2 } from "../workspace"
 
 const mutable = <T>(value: T) => value as DeepMutable<T>
-const isEvent = Schema.is(Schema.Union(EventManifest.ServerDefinitions))
 
 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
@@ -56,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: {},
@@ -69,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) =>
@@ -108,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()),
@@ -148,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(isEvent)),
-    },
-    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)),
@@ -193,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))),
@@ -270,36 +219,33 @@ 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) => tools.register(input),

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

@@ -201,65 +201,64 @@ export const ModelsDevPlugin = define({
   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 }),
     )
   }),

packages/core/src/plugin/promise.ts

@@ -1,11 +1,12 @@
 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
@@ -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,7 +71,6 @@ 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))
@@ -100,22 +78,13 @@ export function fromPromise(plugin: Plugin) {
             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)))

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

@@ -62,20 +62,22 @@ function selectMantleModel(sdk: MantleSDK, modelID: string) {
 export const AmazonBedrockPlugin = define({
   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

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

@@ -4,16 +4,18 @@ import { define } from "../internal"
 export const AnthropicPlugin = define({
   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

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

@@ -13,19 +13,21 @@ function selectLanguage(sdk: any, modelID: string, useChat: boolean) {
 export const AzurePlugin = define({
   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
@@ -56,18 +58,20 @@ export const AzurePlugin = define({
 export const AzureCognitiveServicesPlugin = define({
   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

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

@@ -4,15 +4,17 @@ import { define } from "../internal"
 export const CerebrasPlugin = define({
   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

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

@@ -9,16 +9,18 @@ const providerID = ProviderV2.ID.make("cloudflare-workers-ai")
 export const CloudflareWorkersAIPlugin = define({
   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

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

@@ -14,15 +14,17 @@ function shouldUseResponses(modelID: string) {
 export const GithubCopilotPlugin = define({
   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

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

@@ -57,31 +57,33 @@ function authFetch(fetchWithRuntimeOptions?: unknown) {
 export const GoogleVertexPlugin = define({
   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")) {
@@ -113,26 +115,28 @@ export const GoogleVertexPlugin = define({
 export const GoogleVertexAnthropicPlugin = define({
   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

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

@@ -4,16 +4,18 @@ import { define } from "../internal"
 export const KiloPlugin = define({
   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"
+          })
+        }
+      }),
+    )
   }),
 })

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

@@ -6,20 +6,21 @@ export const LLMGatewayPlugin = define({
   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"
+          })
+        }
+      }),
+    )
   }),
 })

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

@@ -4,17 +4,19 @@ import { define } from "../internal"
 export const NvidiaPlugin = define({
   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"
+          })
+        }
+      }),
+    )
   }),
 })

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

@@ -177,32 +177,34 @@ export const OpenAIPlugin = define({
       draft.method.update(browser)
       draft.method.update(headless)
     })
-    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") continue
-        if (!item.models.has(ModelV2.ID.make("gpt-5-chat-latest"))) continue
-        evt.model.update(item.provider.id, ModelV2.ID.make("gpt-5-chat-latest"), (model) => {
-          // OpenAIPlugin sends OpenAI models through Responses; this alias is a
-          // chat-completions-only model, so hide it only from OpenAI's catalog.
-          model.enabled = false
-        })
-      }
-      if (!chatgpt) return
-      const item = evt.provider.get(ProviderV2.ID.openai)
-      if (!item) return
-      for (const model of item.models.values()) {
-        // ChatGPT-plan tokens only authorize codex-eligible models, and the
-        // subscription covers usage, so hide the rest and zero the cost.
-        evt.model.update(item.provider.id, model.id, (draft) => {
-          if (!OpenAICodex.eligible(draft.api.id)) {
-            draft.enabled = false
-            return
-          }
-          draft.cost = []
-        })
-      }
-    })
+    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") continue
+          if (!item.models.has(ModelV2.ID.make("gpt-5-chat-latest"))) continue
+          evt.model.update(item.provider.id, ModelV2.ID.make("gpt-5-chat-latest"), (model) => {
+            // OpenAIPlugin sends OpenAI models through Responses; this alias is a
+            // chat-completions-only model, so hide it only from OpenAI's catalog.
+            model.enabled = false
+          })
+        }
+        if (!chatgpt) return
+        const item = evt.provider.get(ProviderV2.ID.openai)
+        if (!item) return
+        for (const model of item.models.values()) {
+          // ChatGPT-plan tokens only authorize codex-eligible models, and the
+          // subscription covers usage, so hide the rest and zero the cost.
+          evt.model.update(item.provider.id, model.id, (draft) => {
+            if (!OpenAICodex.eligible(draft.api.id)) {
+              draft.enabled = false
+              return
+            }
+            draft.cost = []
+          })
+        }
+      }),
+    )
 
     const refresh = () => loading.withPermit(load().pipe(Effect.andThen(ctx.catalog.reload())))
     yield* events.subscribe(Integration.Event.ConnectionUpdated).pipe(

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

@@ -5,24 +5,26 @@ import { define } from "../internal"
 export const OpenRouterPlugin = define({
   id: "openrouter",
   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 !== "@openrouter/ai-sdk-provider") continue
-        evt.provider.update(item.provider.id, (provider) => {
-          provider.request.headers["HTTP-Referer"] = "https://opencode.ai/"
-          provider.request.headers["X-Title"] = "opencode"
-        })
-        for (const modelID of [ModelV2.ID.make("gpt-5-chat-latest"), ModelV2.ID.make("openai/gpt-5-chat")]) {
-          if (!item.models.has(modelID)) continue
-          evt.model.update(item.provider.id, modelID, (model) => {
-            // These are OpenRouter-specific OpenAI chat aliases that do not work
-            // on the generic path. Keep custom providers with matching IDs untouched.
-            model.enabled = false
+    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 !== "@openrouter/ai-sdk-provider") continue
+          evt.provider.update(item.provider.id, (provider) => {
+            provider.request.headers["HTTP-Referer"] = "https://opencode.ai/"
+            provider.request.headers["X-Title"] = "opencode"
           })
+          for (const modelID of [ModelV2.ID.make("gpt-5-chat-latest"), ModelV2.ID.make("openai/gpt-5-chat")]) {
+            if (!item.models.has(modelID)) continue
+            evt.model.update(item.provider.id, modelID, (model) => {
+              // These are OpenRouter-specific OpenAI chat aliases that do not work
+              // on the generic path. Keep custom providers with matching IDs untouched.
+              model.enabled = false
+            })
+          }
         }
-      }
-    })
+      }),
+    )
     yield* ctx.aisdk.sdk(
       Effect.fn(function* (evt) {
         if (evt.package !== "@openrouter/ai-sdk-provider") return

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

@@ -4,16 +4,18 @@ import { define } from "../internal"
 export const VercelPlugin = define({
   id: "vercel",
   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/vercel") 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/vercel") continue
+          evt.provider.update(item.provider.id, (provider) => {
+            provider.request.headers["http-referer"] = "https://opencode.ai/"
+            provider.request.headers["x-title"] = "opencode"
+          })
+        }
+      }),
+    )
     yield* ctx.aisdk.sdk(
       Effect.fn(function* (evt) {
         if (evt.package !== "@ai-sdk/vercel") return

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

@@ -4,16 +4,18 @@ import { define } from "../internal"
 export const ZenmuxPlugin = define({
   id: "zenmux",
   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://zenmux.ai/api/v1") 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://zenmux.ai/api/v1") continue
+          evt.provider.update(item.provider.id, (provider) => {
+            provider.request.headers["HTTP-Referer"] ??= "https://opencode.ai/"
+            provider.request.headers["X-Title"] ??= "opencode"
+          })
+        }
+      }),
+    )
   }),
 })

packages/core/src/policy.ts

@@ -0,0 +1,48 @@
+export * as Policy from "./policy"
+
+import { makeLocationNode } from "./effect/app-node"
+import { Context, Effect, Layer, Schema } from "effect"
+import { Wildcard } from "./util/wildcard"
+import { Location } from "./location"
+
+const PolicyEffect = Schema.Literals(["allow", "deny"]).annotate({ identifier: "Policy.Effect" })
+export { PolicyEffect as Effect }
+export type Effect = typeof PolicyEffect.Type
+
+export class Info extends Schema.Class<Info>("Policy.Info")({
+  action: Schema.String,
+  effect: PolicyEffect,
+  resource: Schema.String,
+}) {}
+
+export interface Interface {
+  readonly load: (statements: Info[]) => Effect.Effect<void>
+  readonly evaluate: (action: string, resource: string, fallback: Effect) => Effect.Effect<Effect>
+  readonly hasStatements: () => boolean
+}
+
+export class Service extends Context.Service<Service, Interface>()("@opencode/v2/Policy") {}
+
+const layer = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    let statements: Info[] = []
+    yield* Location.Service
+
+    return Service.of({
+      load: Effect.fn("Policy.load")(function* (input) {
+        statements = input
+      }),
+      hasStatements: () => statements.length > 0,
+      evaluate: Effect.fn("Policy.evaluate")(function* (action, resource, fallback) {
+        return (
+          statements.findLast(
+            (statement) => Wildcard.match(action, statement.action) && Wildcard.match(resource, statement.resource),
+          )?.effect ?? fallback
+        )
+      }),
+    })
+  }),
+)
+
+export const node = makeLocationNode({ service: Service, layer, deps: [Location.node] })

packages/core/src/session.ts

@@ -41,8 +41,8 @@ import type { EventLog } from "@opencode-ai/schema/event-log"
 import { SkillV2 } from "./skill"
 import { Job } from "./job"
 import { CommandV2 } from "./command"
+import { Identifier } from "./util/identifier"
 import { Shell } from "./shell"
-import { Shell as ShellSchema } from "@opencode-ai/schema/shell"
 import { KeyedMutex } from "./effect/keyed-mutex"
 
 export const RevertState = Revert.State
@@ -272,6 +272,19 @@ const layer = Layer.effect(
         ),
       )
 
+    // Session shell is user-initiated and synchronous at the API boundary, while
+    // the Location shell service owns process lifecycle and file-backed output.
+    const runShellCommand = (command: string, cwd: string) =>
+      Effect.gen(function* () {
+        const shell = yield* Shell.Service
+        const info = yield* shell.create({ command, cwd })
+        yield* shell.wait(info.id)
+        const output = yield* shell.output(info.id, { limit: SHELL_MAX_CAPTURE_BYTES })
+        return output.output || "(no output)"
+      }).pipe(
+        Effect.catchTag("Shell.NotFoundError", () => Effect.succeed("Shell command output is no longer available.")),
+      )
+
     const result = Service.of({
       create: Effect.fn("V2Session.create")(function* (input) {
         const sessionID = input.id ?? SessionSchema.ID.create()
@@ -537,38 +550,23 @@ const layer = Layer.effect(
           Effect.gen(function* () {
             activeShells.add(input.sessionID)
             if ((yield* execution.active).has(input.sessionID)) yield* execution.awaitIdle(input.sessionID)
-            const started = yield* Effect.gen(function* () {
-              const shell = yield* Shell.Service
-              return yield* shell.create({ command: input.command, cwd: session.location.directory })
-            }).pipe(Effect.provide(locations.get(session.location)))
+            const callID = Identifier.ascending()
             yield* events.publish(
               SessionEvent.Shell.Started,
               {
                 sessionID: input.sessionID,
-                shell: started,
+                callID,
+                command: input.command,
               },
               { id: input.id },
             )
-            const completed = yield* Effect.gen(function* () {
-              const shell = yield* Shell.Service
-              const terminal = yield* shell.wait(started.id).pipe(
-                Effect.map((info) => ({ info, retained: true as const })),
-                Effect.catchTag("Shell.NotFoundError", () =>
-                  Effect.succeed({ info: synthesizeTerminalShellInfo(started), retained: false as const }),
-                ),
-              )
-              const output = terminal.retained
-                ? yield* shell
-                    .output(started.id, { limit: SHELL_MAX_CAPTURE_BYTES })
-                    .pipe(Effect.catchTag("Shell.NotFoundError", () => Effect.succeed(missingShellOutput())))
-                : missingShellOutput()
-              return { shell: terminal.info, output }
-            })
-              .pipe(Effect.provide(locations.get(session.location)))
+            const output = yield* runShellCommand(input.command, session.location.directory).pipe(
+              Effect.provide(locations.get(session.location)),
+            )
             yield* events.publish(SessionEvent.Shell.Ended, {
               sessionID: input.sessionID,
-              shell: completed.shell,
-              output: completed.output,
+              callID,
+              output,
             })
           }).pipe(
             Effect.ensuring(
@@ -708,26 +706,6 @@ const layer = Layer.effect(
   }),
 )
 
-function missingShellOutput() {
-  const output = "Shell command output is no longer available."
-  return {
-    output,
-    cursor: Buffer.byteLength(output),
-    size: Buffer.byteLength(output),
-    truncated: false,
-  }
-}
-
-function synthesizeTerminalShellInfo(started: ShellSchema.Info): ShellSchema.Info {
-  return {
-    ...started,
-    // The Shell record was removed before waiters could observe it; publish a terminal
-    // boundary instead of leaving the Session shell message permanently running.
-    status: "killed",
-    time: { ...started.time, completed: Date.now() },
-  }
-}
-
 const resolvePrompt = (input: PromptInput.Prompt) =>
   Prompt.make({
     text: input.text,

packages/core/src/session/compaction.ts

@@ -129,7 +129,7 @@ const serialize = (message: SessionMessage.Message) => {
   if (message.type === "system") return `[System update]: ${message.text}`
   if (message.type === "synthetic") return `[Synthetic context]: ${message.text}`
   if (message.type === "skill") return `[Skill activated: ${message.name}]\n${message.text}`
-  if (message.type === "shell") return `[Shell]: ${message.shell.command}\n${truncate(message.output?.output ?? "")}`
+  if (message.type === "shell") return `[Shell]: ${message.command}\n${truncate(message.output)}`
   return ""
 }
 
@@ -225,13 +225,7 @@ const make = (dependencies: Dependencies) => {
       .pipe(
         Stream.runForEach((event) => {
           if (LLMEvent.is.providerError(event)) failed = true
-          if (LLMEvent.is.textDelta(event)) {
-            chunks.push(event.text)
-            return dependencies.events.publish(SessionEvent.Compaction.Delta, {
-              sessionID: input.sessionID,
-              text: event.text,
-            })
-          }
+          if (LLMEvent.is.textDelta(event)) chunks.push(event.text)
           return Effect.void
         }),
         Effect.as(true),

packages/core/src/session/context-checkpoint.ts

@@ -18,7 +18,7 @@ const decodeApplied = Schema.decodeUnknownOption(SystemContext.Applied)
  * Loads or creates the session's durable context checkpoint, narrating any
  * drift since the model was last told as a chronological update. Completed
  * compaction rebaselines; nothing else rewrites the baseline. Runs before
- * input promotion so a blocked first step leaves pending inputs untouched.
+ * input promotion so a blocked first turn leaves pending inputs untouched.
  */
 export const prepare = Effect.fn("SessionContextCheckpoint.prepare")(function* (
   db: DatabaseService,

packages/core/src/session/error.ts

@@ -1,7 +1,6 @@
 import { Schema } from "effect"
 import { SessionMessage } from "./message"
 import { SessionSchema } from "./schema"
-import { SessionError } from "@opencode-ai/schema/session-error"
 
 export class MessageDecodeError extends Schema.TaggedErrorClass<MessageDecodeError>()("Session.MessageDecodeError", {
   sessionID: SessionSchema.ID,
@@ -11,20 +10,3 @@ export class MessageDecodeError extends Schema.TaggedErrorClass<MessageDecodeErr
     return `Failed to decode message ${this.messageID} in session ${this.sessionID}`
   }
 }
-
-export class StepFailedError extends Schema.TaggedErrorClass<StepFailedError>()("Session.StepFailedError", {
-  error: SessionError.Error,
-}) {
-  override get message() {
-    return this.error.message
-  }
-}
-
-export class UserInterruptedError extends Schema.TaggedErrorClass<UserInterruptedError>()(
-  "Session.UserInterruptedError",
-  {},
-) {
-  override get message() {
-    return "Session interrupted by user"
-  }
-}

packages/core/src/session/execution/local.ts

@@ -1,4 +1,4 @@
-import { Cause, Effect, Exit, Layer } from "effect"
+import { Cause, DateTime, Effect, Exit, Layer } from "effect"
 import { EventV2 } from "../../event"
 import { LocationServiceMap } from "../../location-service-map"
 import { makeGlobalNode } from "../../effect/app-node"
@@ -8,16 +8,6 @@ import { SessionRunner } from "../runner"
 import { SessionSchema } from "../schema"
 import { SessionStore } from "../store"
 import { SessionExecution } from "../execution"
-import { toSessionError } from "../to-session-error"
-import { UserInterruptedError } from "../error"
-
-export function terminal(exit: Exit.Exit<void, SessionRunner.RunError>, reason?: "user" | "shutdown" | "superseded") {
-  if (Exit.isSuccess(exit)) return { type: "succeeded" as const }
-  if (Cause.hasInterrupts(exit.cause)) return { type: "interrupted" as const, reason: reason ?? "shutdown" }
-  const failure = Cause.squash(exit.cause)
-  if (failure instanceof UserInterruptedError) return { type: "interrupted" as const, reason: "user" as const }
-  return { type: "failed" as const, error: toSessionError(failure) }
-}
 
 /** Current-process routing for implicit-local Locations. Future remote placement belongs here. */
 const layer = Layer.effect(
@@ -26,27 +16,11 @@ const layer = Layer.effect(
     const store = yield* SessionStore.Service
     const locations = yield* LocationServiceMap.Service
     const events = yield* EventV2.Service
-    const reportLifecycle = <A>(sessionID: SessionSchema.ID, effect: Effect.Effect<A>) =>
-      effect.pipe(
-        Effect.tapCause((cause) =>
-          Cause.hasInterruptsOnly(cause)
-            ? Effect.void
-            : Effect.logError("Failed to publish Session execution lifecycle", cause).pipe(
-                Effect.annotateLogs({ sessionID }),
-              ),
-        ),
-        Effect.asVoid,
-      )
-    const coordinator = yield* SessionRunCoordinator.make<
-      SessionSchema.ID,
-      SessionRunner.RunError,
-      "user" | "shutdown" | "superseded"
-    >({
-      started: (sessionID) => reportLifecycle(sessionID, events.publish(SessionEvent.Execution.Started, { sessionID })),
+    const coordinator = yield* SessionRunCoordinator.make<SessionSchema.ID, SessionRunner.RunError>({
       drain: Effect.fnUntraced(function* (sessionID: SessionSchema.ID, force) {
         const session = yield* store.get(sessionID)
         if (!session) return yield* Effect.die(new Error(`Session not found: ${sessionID}`))
-        return yield* SessionRunner.Service.use((runner) => runner.drain({ sessionID, force })).pipe(
+        return yield* SessionRunner.Service.use((runner) => runner.run({ sessionID, force })).pipe(
           Effect.provide(locations.get(session.location)),
           Effect.tapCause((cause) =>
             Cause.hasInterruptsOnly(cause)
@@ -55,31 +29,28 @@ const layer = Layer.effect(
           ),
         )
       }),
-      // One terminal observation per busy period, covering every coalesced drain.
-      settled: (sessionID, exit, reason) =>
-        reportLifecycle(
-          sessionID,
-          Effect.gen(function* () {
-            const outcome = terminal(exit, reason)
-            if (outcome.type === "succeeded") {
-              yield* events.publish(SessionEvent.Execution.Succeeded, { sessionID })
-              return
-            }
-            if (outcome.type === "interrupted") {
-              yield* events.publish(SessionEvent.Execution.Interrupted, { sessionID, reason: outcome.reason })
-              return
-            }
-            yield* events.publish(SessionEvent.Execution.Failed, {
-              sessionID,
-              error: outcome.error,
-            })
-          }),
+      // One ExecutionSettled per execution (busy period), covering every coalesced drain.
+      settled: (sessionID, exit) =>
+        Effect.gen(function* () {
+          const failure =
+            Exit.isFailure(exit) && !Cause.hasInterrupts(exit.cause) ? Cause.squash(exit.cause) : undefined
+          yield* events.publish(SessionEvent.ExecutionSettled, {
+            sessionID,
+            outcome: Exit.isSuccess(exit) ? "success" : Cause.hasInterrupts(exit.cause) ? "interrupted" : "failure",
+            error:
+              failure !== undefined
+                ? { type: "unknown", message: failure instanceof Error ? failure.message : String(failure) }
+                : undefined,
+          })
+        }).pipe(
+          Effect.catchCause(() => Effect.void),
+          Effect.asVoid,
         ),
     })
 
     return SessionExecution.Service.of({
       active: coordinator.active,
-      interrupt: (sessionID) => coordinator.interrupt(sessionID, "user"),
+      interrupt: coordinator.interrupt,
       resume: coordinator.run,
       wake: coordinator.wake,
       awaitIdle: coordinator.awaitIdle,

packages/core/src/session/history.ts

@@ -34,7 +34,7 @@ const messageRows = Effect.fnUntraced(function* (
       and(
         eq(SessionMessageTable.session_id, sessionID),
         // Keep system updates visible in the gap between a completed compaction
-        // and the next prepared step's rebaseline, when their content is not yet
+        // and the next prepared turn's rebaseline, when their content is not yet
         // folded into a new baseline.
         compaction
           ? or(

packages/core/src/session/instructions.ts

@@ -36,9 +36,9 @@ const layer = Layer.effect(
     // absolute paths, but the human-facing description shows paths relative to the project
     // root so opening a subdirectory still describes paths from the project root.
     const root = yield* fs.resolve(location.project.directory)
-    // Same-step parallel reads settle concurrently, so an in-memory claim guards each
+    // Same-turn parallel reads settle concurrently, so an in-memory claim guards each
     // Session/path pair before any filesystem work. The durable history check below covers
-    // paths injected in earlier steps after this Location layer was reopened.
+    // paths injected in earlier turns after this Location layer was reopened.
     const injected = yield* Ref.make<Map<SessionSchema.ID, Set<string>>>(new Map())
 
     const load = Effect.fn("SessionInstructions.load")(function* (input: {

packages/core/src/session/message-updater.ts

@@ -1,5 +1,5 @@
 import { castDraft, produce, type WritableDraft } from "immer"
-import { DateTime, Effect } from "effect"
+import { Effect } from "effect"
 import { SessionEvent } from "./event"
 import { SessionMessage } from "./message"
 
@@ -8,25 +8,21 @@ export type MemoryState = {
 }
 
 export interface Adapter {
-  readonly getCurrentAssistant: () => Effect.Effect<SessionMessage.Assistant | undefined, never, never>
-  readonly getAssistant: (
-    messageID: SessionMessage.ID,
-  ) => Effect.Effect<SessionMessage.Assistant | undefined, never, never>
-  readonly getShell: (
-    shellID: SessionMessage.Shell["shell"]["id"],
-  ) => Effect.Effect<SessionMessage.Shell | undefined, never, never>
-  readonly updateAssistant: (assistant: SessionMessage.Assistant) => Effect.Effect<void, never, never>
-  readonly updateShell: (shell: SessionMessage.Shell) => Effect.Effect<void, never, never>
-  readonly appendMessage: (message: SessionMessage.Message) => Effect.Effect<void, never, never>
+  readonly getCurrentAssistant: () => Effect.Effect<SessionMessage.Assistant | undefined>
+  readonly getAssistant: (messageID: SessionMessage.ID) => Effect.Effect<SessionMessage.Assistant | undefined>
+  readonly getCurrentShell: (callID: string) => Effect.Effect<SessionMessage.Shell | undefined>
+  readonly updateAssistant: (assistant: SessionMessage.Assistant) => Effect.Effect<void>
+  readonly updateShell: (shell: SessionMessage.Shell) => Effect.Effect<void>
+  readonly appendMessage: (message: SessionMessage.Message) => Effect.Effect<void>
 }
 
 export function memory(state: MemoryState): Adapter {
   const assistantIndex = (messageID: SessionMessage.ID) =>
     state.messages.findLastIndex((message) => message.id === messageID)
-  const shellIndex = (messageID: SessionMessage.ID) =>
-    state.messages.findLastIndex((message) => message.id === messageID)
-  // A newer step supersedes stale incomplete rows; never resume an older assistant projection.
+  // A newer turn supersedes stale incomplete rows; never resume an older assistant projection.
   const latestAssistantIndex = () => state.messages.findLastIndex((message) => message.type === "assistant")
+  const activeShellIndex = (callID: string) =>
+    state.messages.findLastIndex((message) => message.type === "shell" && message.callID === callID)
 
   return {
     getCurrentAssistant() {
@@ -45,11 +41,12 @@ export function memory(state: MemoryState): Adapter {
         return assistant?.type === "assistant" ? assistant : undefined
       })
     },
-    getShell(shellID) {
+    getCurrentShell(callID) {
       return Effect.sync(() => {
-        return state.messages.find((message): message is SessionMessage.Shell => {
-          return message.type === "shell" && message.shell.id === shellID
-        })
+        const index = activeShellIndex(callID)
+        if (index < 0) return
+        const shell = state.messages[index]
+        return shell?.type === "shell" ? shell : undefined
       })
     },
     updateAssistant(assistant) {
@@ -63,7 +60,7 @@ export function memory(state: MemoryState): Adapter {
     },
     updateShell(shell) {
       return Effect.sync(() => {
-        const index = shellIndex(shell.id)
+        const index = activeShellIndex(shell.callID)
         if (index < 0) return
         const current = state.messages[index]
         if (current?.type !== "shell") return
@@ -89,11 +86,11 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {
       (item): item is DraftTool => item.type === "tool" && (callID === undefined || item.id === callID),
     )
 
-  const latestText = (assistant: DraftAssistant | undefined) =>
-    assistant?.content.findLast((item): item is DraftText => item.type === "text")
+  const latestText = (assistant: DraftAssistant | undefined, textID: string) =>
+    assistant?.content.findLast((item): item is DraftText => item.type === "text" && item.id === textID)
 
-  const latestReasoning = (assistant: DraftAssistant | undefined) =>
-    assistant?.content.findLast((item): item is DraftReasoning => item.type === "reasoning" && !item.time?.completed)
+  const latestReasoning = (assistant: DraftAssistant | undefined, reasoningID: string) =>
+    assistant?.content.findLast((item): item is DraftReasoning => item.type === "reasoning" && item.id === reasoningID)
 
   const updateOwnedAssistant = (messageID: SessionMessage.ID, recipe: (draft: DraftAssistant) => void) =>
     Effect.gen(function* () {
@@ -101,20 +98,9 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {
       if (assistant) yield* adapter.updateAssistant(produce(assistant, recipe))
     })
 
-  const clearCurrentRetry = Effect.gen(function* () {
-    const assistant = yield* adapter.getCurrentAssistant()
-    if (assistant?.retry) {
-      yield* adapter.updateAssistant(
-        produce(assistant, (draft) => {
-          draft.retry = undefined
-        }),
-      )
-    }
-  })
-
   return Effect.gen(function* () {
     yield* SessionEvent.All.match(event, {
-      "session.agent.selected": (event) => {
+      "agent.selected": (event) => {
         return adapter.appendMessage(
           SessionMessage.AgentSelected.make({
             id: SessionMessage.ID.fromEvent(event.id),
@@ -125,7 +111,7 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {
           }),
         )
       },
-      "session.model.selected": (event) => {
+      "model.selected": (event) => {
         return adapter.appendMessage(
           SessionMessage.ModelSelected.make({
             id: SessionMessage.ID.fromEvent(event.id),
@@ -137,14 +123,11 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {
         )
       },
       "session.moved": () => Effect.void,
-      "session.renamed": () => Effect.void,
-      "session.forked": () => Effect.void,
-      "session.prompt.promoted": () => Effect.void,
-      "session.prompt.admitted": () => Effect.void,
-      "session.execution.started": () => Effect.void,
-      "session.execution.succeeded": () => clearCurrentRetry,
-      "session.execution.failed": () => clearCurrentRetry,
-      "session.execution.interrupted": () => clearCurrentRetry,
+      renamed: () => Effect.void,
+      forked: () => Effect.void,
+      "prompt.promoted": () => Effect.void,
+      "prompt.admitted": () => Effect.void,
+      "execution.settled": () => Effect.void,
       "session.context.updated": (event) =>
         adapter.appendMessage(
           SessionMessage.System.make({
@@ -154,7 +137,7 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {
             time: { created: event.created },
           }),
         ),
-      "session.synthetic": (event) => {
+      synthetic: (event) => {
         return adapter.appendMessage(
           SessionMessage.Synthetic.make({
             sessionID: event.data.sessionID,
@@ -167,7 +150,7 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {
           }),
         )
       },
-      "session.skill.activated": (event) => {
+      "skill.activated": (event) => {
         return adapter.appendMessage(
           SessionMessage.Skill.make({
             id: SessionMessage.ID.fromEvent(event.id),
@@ -178,24 +161,25 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {
           }),
         )
       },
-      "session.shell.started": (event) => {
+      "shell.started": (event) => {
         return adapter.appendMessage(
           SessionMessage.Shell.make({
             id: SessionMessage.ID.fromEvent(event.id),
             type: "shell",
             metadata: event.metadata,
-            shell: event.data.shell,
+            callID: event.data.callID,
+            command: event.data.command,
+            output: "",
             time: { created: event.created },
           }),
         )
       },
-      "session.shell.ended": (event) => {
+      "shell.ended": (event) => {
         return Effect.gen(function* () {
-          const currentShell = yield* adapter.getShell(event.data.shell.id)
+          const currentShell = yield* adapter.getCurrentShell(event.data.callID)
           if (currentShell) {
             yield* adapter.updateShell(
               produce(currentShell, (draft) => {
-                draft.shell = castDraft(event.data.shell)
                 draft.output = event.data.output
                 draft.time.completed = event.created
               }),
@@ -203,28 +187,12 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {
           }
         })
       },
-      "session.step.started": (event) => {
+      "step.started": (event) => {
         return Effect.gen(function* () {
-          const existing = yield* adapter.getAssistant(event.data.assistantMessageID)
-          if (existing) {
-            yield* adapter.updateAssistant(
-              produce(existing, (draft) => {
-                draft.agent = event.data.agent
-                draft.model = castDraft(event.data.model)
-                draft.retry = undefined
-                draft.error = undefined
-                draft.finish = undefined
-                draft.time.completed = undefined
-                if (event.data.snapshot) draft.snapshot = { ...draft.snapshot, start: event.data.snapshot }
-              }),
-            )
-            return
-          }
           const currentAssistant = yield* adapter.getCurrentAssistant()
           if (currentAssistant) {
             yield* adapter.updateAssistant(
               produce(currentAssistant, (draft) => {
-                draft.retry = undefined
                 draft.time.completed = event.created
               }),
             )
@@ -242,7 +210,7 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {
           )
         })
       },
-      "session.step.ended": (event) => {
+      "step.ended": (event) => {
         return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
           draft.time.completed = event.created
           draft.finish = event.data.finish
@@ -256,32 +224,33 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {
             }
         })
       },
-      "session.step.failed": (event) => {
+      "step.failed": (event) => {
         return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
           draft.time.completed = event.created
           draft.finish = "error"
-          draft.error = castDraft(event.data.error)
-          draft.retry = undefined
+          draft.error = event.data.error
         })
       },
-      "session.text.started": (event) => {
+      "text.started": (event) => {
         return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
-          draft.content.push(castDraft(SessionMessage.AssistantText.make({ type: "text", text: "" })))
+          draft.content.push(
+            castDraft(SessionMessage.AssistantText.make({ type: "text", id: event.data.textID, text: "" })),
+          )
         })
       },
-      "session.text.delta": (event) => {
+      "text.delta": (event) => {
         return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
-          const match = latestText(draft)
+          const match = latestText(draft, event.data.textID)
           if (match) match.text += event.data.delta
         })
       },
-      "session.text.ended": (event) => {
+      "text.ended": (event) => {
         return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
-          const match = latestText(draft)
+          const match = latestText(draft, event.data.textID)
           if (match) match.text = event.data.text
         })
       },
-      "session.tool.input.started": (event) => {
+      "tool.input.started": (event) => {
         return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
           draft.content.push(
             castDraft(
@@ -296,19 +265,18 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {
           )
         })
       },
-      "session.tool.input.delta": () => Effect.void,
-      "session.tool.input.ended": (event) => {
+      "tool.input.delta": () => Effect.void,
+      "tool.input.ended": (event) => {
         return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
           const match = latestTool(draft, event.data.callID)
           if (match && match.state.status === "pending") match.state.input = event.data.text
         })
       },
-      "session.tool.called": (event) => {
+      "tool.called": (event) => {
         return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
           const match = latestTool(draft, event.data.callID)
           if (match) {
-            match.executed = event.data.executed
-            match.providerState = event.data.state
+            match.provider = event.data.provider
             match.time.ran = event.created
             match.state = castDraft(
               SessionMessage.ToolStateRunning.make({
@@ -321,7 +289,7 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {
           }
         })
       },
-      "session.tool.progress": (event) => {
+      "tool.progress": (event) => {
         return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
           const match = latestTool(draft, event.data.callID)
           if (match && match.state.status === "running") {
@@ -330,12 +298,15 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {
           }
         })
       },
-      "session.tool.success": (event) => {
+      "tool.success": (event) => {
         return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
           const match = latestTool(draft, event.data.callID)
           if (match && match.state.status === "running") {
-            match.executed = event.data.executed || match.executed === true
-            match.providerResultState = event.data.resultState
+            match.provider = {
+              executed: event.data.provider.executed || match.provider?.executed === true,
+              metadata: match.provider?.metadata,
+              resultMetadata: event.data.provider.metadata,
+            }
             match.time.completed = event.created
             match.state = castDraft(
               SessionMessage.ToolStateCompleted.make({
@@ -350,12 +321,15 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {
           }
         })
       },
-      "session.tool.failed": (event) => {
+      "tool.failed": (event) => {
         return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
           const match = latestTool(draft, event.data.callID)
           if (match && (match.state.status === "pending" || match.state.status === "running")) {
-            match.executed = event.data.executed || match.executed === true
-            match.providerResultState = event.data.resultState
+            match.provider = {
+              executed: event.data.provider.executed || match.provider?.executed === true,
+              metadata: match.provider?.metadata,
+              resultMetadata: event.data.provider.metadata,
+            }
             match.time.completed = event.created
             match.state = castDraft(
               SessionMessage.ToolStateError.make({
@@ -370,48 +344,41 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {
           }
         })
       },
-      "session.reasoning.started": (event) => {
+      "reasoning.started": (event) => {
         return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
           draft.content.push(
             castDraft(
               SessionMessage.AssistantReasoning.make({
                 type: "reasoning",
+                id: event.data.reasoningID,
                 text: "",
-                state: event.data.state,
+                providerMetadata: event.data.providerMetadata,
                 time: { created: event.created },
               }),
             ),
           )
         })
       },
-      "session.reasoning.delta": (event) => {
+      "reasoning.delta": (event) => {
         return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
-          const match = latestReasoning(draft)
+          const match = latestReasoning(draft, event.data.reasoningID)
           if (match) match.text += event.data.delta
         })
       },
-      "session.reasoning.ended": (event) => {
+      "reasoning.ended": (event) => {
         return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
-          const match = latestReasoning(draft)
+          const match = latestReasoning(draft, event.data.reasoningID)
           if (match) {
             match.text = event.data.text
             match.time = { created: match.time?.created ?? event.created, completed: event.created }
-            if (event.data.state !== undefined) match.state = event.data.state
+            if (event.data.providerMetadata !== undefined) match.providerMetadata = event.data.providerMetadata
           }
         })
       },
-      "session.retry.scheduled": (event) => {
-        return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
-          draft.retry = {
-            attempt: event.data.attempt,
-            at: DateTime.makeUnsafe(event.data.at),
-            error: castDraft(event.data.error),
-          }
-        })
-      },
-      "session.compaction.started": () => Effect.void,
-      "session.compaction.delta": () => Effect.void,
-      "session.compaction.ended": (event) => {
+      retried: () => Effect.void,
+      "compaction.started": () => Effect.void,
+      "compaction.delta": () => Effect.void,
+      "compaction.ended": (event) => {
         return adapter.appendMessage(
           SessionMessage.Compaction.make({
             id: SessionMessage.ID.fromEvent(event.id),
@@ -424,9 +391,9 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {
           }),
         )
       },
-      "session.revert.staged": () => Effect.void,
-      "session.revert.cleared": () => Effect.void,
-      "session.revert.committed": () => Effect.void,
+      "revert.staged": () => Effect.void,
+      "revert.cleared": () => Effect.void,
+      "revert.committed": () => Effect.void,
     })
   })
 }

packages/core/src/session/projector.ts

@@ -168,8 +168,7 @@ const projectFork = Effect.fn("SessionProjector.projectFork")(function* (
         .get()
         .pipe(Effect.orDie)
     : undefined
-  if (event.data.from && !boundary)
-    return yield* Effect.die(new Error(`Fork boundary message not found: ${event.data.from}`))
+  if (event.data.from && !boundary) return yield* Effect.die(new Error(`Fork boundary message not found: ${event.data.from}`))
   const copied = yield* db
     .select({ seq: SessionMessageTable.seq })
     .from(SessionMessageTable)
@@ -358,7 +357,7 @@ function run(db: DatabaseService, event: MessageEvent) {
     const adapter: SessionMessageUpdater.Adapter = {
       getCurrentAssistant() {
         return Effect.gen(function* () {
-          // A newer step supersedes stale incomplete rows; never resume an older assistant projection.
+          // A newer turn supersedes stale incomplete rows; never resume an older assistant projection.
           const row = yield* db
             .select()
             .from(SessionMessageTable)
@@ -393,25 +392,18 @@ function run(db: DatabaseService, event: MessageEvent) {
           return message.type === "assistant" ? message : undefined
         })
       },
-      getShell(shellID) {
+      getCurrentShell(callID) {
         return Effect.gen(function* () {
-          const row = yield* db
+          const rows = yield* db
             .select()
             .from(SessionMessageTable)
-            .where(
-              and(
-                eq(SessionMessageTable.session_id, event.data.sessionID),
-                eq(SessionMessageTable.type, "shell"),
-                sql`json_extract(${SessionMessageTable.data}, '$.shell.id') = ${shellID}`,
-              ),
-            )
+            .where(and(eq(SessionMessageTable.session_id, event.data.sessionID), eq(SessionMessageTable.type, "shell")))
             .orderBy(desc(SessionMessageTable.seq))
-            .limit(1)
-            .get()
+            .all()
             .pipe(Effect.orDie)
-          if (!row) return
-          const message = decodeRow(row)
-          return message.type === "shell" ? message : undefined
+          return rows
+            .map(decodeRow)
+            .find((message): message is SessionMessage.Shell => message.type === "shell" && message.callID === callID)
         })
       },
       updateAssistant: updateMessage,
@@ -622,9 +614,6 @@ const layer = Layer.effectDiscard(
         })
       }),
     )
-    yield* events.project(SessionEvent.Execution.Succeeded, (event) => run(db, event))
-    yield* events.project(SessionEvent.Execution.Failed, (event) => run(db, event))
-    yield* events.project(SessionEvent.Execution.Interrupted, (event) => run(db, event))
     yield* events.project(SessionEvent.ContextUpdated, (event) => run(db, event))
     yield* events.project(SessionEvent.Synthetic, (event) => run(db, event))
     yield* events.project(SessionEvent.Skill.Activated, (event) =>
@@ -651,7 +640,7 @@ const layer = Layer.effectDiscard(
     yield* events.project(SessionEvent.Tool.Failed, (event) => run(db, event))
     yield* events.project(SessionEvent.Reasoning.Started, (event) => run(db, event))
     yield* events.project(SessionEvent.Reasoning.Ended, (event) => run(db, event))
-    yield* events.project(SessionEvent.RetryScheduled, (event) => run(db, event))
+    // yield* events.project(SessionEvent.Retried, (event) => run(db, event))
     yield* events.project(SessionEvent.Compaction.Ended, (event) => run(db, event))
     yield* events.project(SessionEvent.RevertEvent.Staged, (event) =>
       db
@@ -678,11 +667,14 @@ const layer = Layer.effectDiscard(
           .select({ seq: SessionMessageTable.seq })
           .from(SessionMessageTable)
           .where(
-            and(eq(SessionMessageTable.session_id, event.data.sessionID), eq(SessionMessageTable.id, event.data.to)),
+            and(
+              eq(SessionMessageTable.session_id, event.data.sessionID),
+              eq(SessionMessageTable.id, event.data.messageID),
+            ),
           )
           .get()
           .pipe(Effect.orDie)
-        if (!boundary) return yield* Effect.die(new Error(`Revert boundary message not found: ${event.data.to}`))
+        if (!boundary) return yield* Effect.die(new Error(`Revert boundary message not found: ${event.data.messageID}`))
         yield* db
           .delete(SessionMessageTable)
           .where(

packages/core/src/session/revert.ts

@@ -113,6 +113,6 @@ export const commit = Effect.fn("SessionRevert.commit")(function* (session: Sess
   const events = yield* EventV2.Service
   yield* events.publish(SessionEvent.RevertEvent.Committed, {
     sessionID: session.id,
-    to: session.revert.messageID,
+    messageID: session.revert.messageID,
   })
 })

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

@@ -3,7 +3,7 @@ export * as SessionRunCoordinator from "./run-coordinator"
 import { Deferred, Effect, Exit, Fiber, FiberSet, Scope } from "effect"
 
 /** Serializes execution for each key while allowing different keys to run concurrently. */
-export interface Coordinator<Key, E, Reason = never> {
+export interface Coordinator<Key, E> {
   /** Snapshots keys with an execution owned by this coordinator. */
   readonly active: Effect.Effect<ReadonlySet<Key>>
   /** Starts an execution while idle, or joins the active execution and returns its exit. */
@@ -11,7 +11,7 @@ export interface Coordinator<Key, E, Reason = never> {
   /** Rings the doorbell: an idle key starts an execution; an active one drains again before settling. */
   readonly wake: (key: Key) => Effect.Effect<void>
   /** Stops the active execution, clears its doorbell, and waits for cleanup. No-op when idle. */
-  readonly interrupt: (key: Key, reason?: Reason) => Effect.Effect<void>
+  readonly interrupt: (key: Key) => Effect.Effect<void>
   /** Resolves once no execution is active for the key. Returns immediately when already idle and never starts work. */
   readonly awaitIdle: (key: Key) => Effect.Effect<void>
 }
@@ -23,13 +23,11 @@ export interface Coordinator<Key, E, Reason = never> {
  * closes the gap between a drain's last eligibility check and the idle transition, since
  * those cannot be one atomic step. `done` resolves joiners with this execution's exit.
  */
-type Execution<E, Reason> = {
+type Execution<E> = {
   readonly done: Deferred.Deferred<void, E>
   owner?: Fiber.Fiber<void>
   pendingWake: boolean
   stopping: boolean
-  settling: boolean
-  interruptionReason?: Reason
 }
 
 /**
@@ -43,21 +41,19 @@ type Execution<E, Reason> = {
  *                                      waiters get this exit
  * ```
  */
-export const make = <Key, E, Reason = never>(options: {
+export const make = <Key, E>(options: {
   readonly drain: (key: Key, force: boolean) => Effect.Effect<void, E>
-  /** Runs once when a process-local busy period begins, before its first drain. */
-  readonly started?: (key: Key) => Effect.Effect<void>
   /**
    * Runs in the execution fiber for every exit, including interruption, after the final
    * drain and before the execution settles (waiters resolve after it completes).
    */
-  readonly settled?: (key: Key, exit: Exit.Exit<void, E>, reason?: Reason) => Effect.Effect<void>
-}): Effect.Effect<Coordinator<Key, E, Reason>, never, Scope.Scope> =>
+  readonly settled?: (key: Key, exit: Exit.Exit<void, E>) => Effect.Effect<void>
+}): Effect.Effect<Coordinator<Key, E>, never, Scope.Scope> =>
   Effect.gen(function* () {
-    const executions = new Map<Key, Execution<E, Reason>>()
+    const executions = new Map<Key, Execution<E>>()
     const fork = yield* FiberSet.makeRuntime<never, void, never>()
 
-    const loop = (key: Key, execution: Execution<E, Reason>, force: boolean): Effect.Effect<void, E> =>
+    const loop = (key: Key, execution: Execution<E>, force: boolean): Effect.Effect<void, E> =>
       Effect.suspend(() => options.drain(key, force)).pipe(
         Effect.flatMap(() =>
           Effect.suspend(() => {
@@ -70,25 +66,15 @@ export const make = <Key, E, Reason = never>(options: {
       )
 
     const start = (key: Key, force: boolean) => {
-      const execution: Execution<E, Reason> = {
-        done: Deferred.makeUnsafe<void, E>(),
-        pendingWake: false,
-        stopping: false,
-        settling: false,
-      }
+      const execution: Execution<E> = { done: Deferred.makeUnsafe<void, E>(), pendingWake: false, stopping: false }
       executions.set(key, execution)
       // The leading yield lets `owner` be assigned before the drain can settle, and keeps
       // failing self-waking executions from growing the stack across successor starts.
       // Drains start one tick after wake; callers observe progress through events or run.
       execution.owner = fork(
         Effect.yieldNow.pipe(
-          Effect.andThen(Effect.uninterruptible(options.started?.(key) ?? Effect.void)),
           Effect.andThen(loop(key, execution, force)),
-          Effect.onExit((exit) =>
-            Effect.sync(() => {
-              execution.settling = true
-            }).pipe(Effect.andThen(options.settled?.(key, exit, execution.interruptionReason) ?? Effect.void)),
-          ),
+          Effect.onExit((exit) => options.settled?.(key, exit) ?? Effect.void),
           Effect.onExit((exit) => Effect.sync(() => settle(key, execution, exit))),
           Effect.exit,
           Effect.asVoid,
@@ -99,7 +85,7 @@ export const make = <Key, E, Reason = never>(options: {
 
     // A doorbell that survives the execution loop (rung after the loop decided to end, or
     // during failure or interruption cleanup) starts a fresh execution for the remaining work.
-    const settle = (key: Key, execution: Execution<E, Reason>, exit: Exit.Exit<void, E>) => {
+    const settle = (key: Key, execution: Execution<E>, exit: Exit.Exit<void, E>) => {
       if (execution.pendingWake) start(key, false)
       else executions.delete(key)
       Deferred.doneUnsafe(execution.done, exit)
@@ -126,13 +112,12 @@ export const make = <Key, E, Reason = never>(options: {
         start(key, false)
       })
 
-    const interrupt = (key: Key, reason?: Reason): Effect.Effect<void> =>
+    const interrupt = (key: Key): Effect.Effect<void> =>
       Effect.suspend(() => {
         const execution = executions.get(key)
-        if (execution?.owner === undefined || execution.stopping || execution.settling) return Effect.void
+        if (execution?.owner === undefined) return Effect.void
         execution.stopping = true
         execution.pendingWake = false
-        execution.interruptionReason = reason
         return Fiber.interrupt(execution.owner)
       })
 

packages/core/src/session/runner/index.ts

@@ -3,7 +3,7 @@ export * as SessionRunner from "./index"
 import type { LLMError } from "@opencode-ai/llm"
 import { Context, Effect } from "effect"
 import { SessionSchema } from "../schema"
-import type { MessageDecodeError, StepFailedError, UserInterruptedError } from "../error"
+import type { MessageDecodeError } from "../error"
 import { SessionRunnerModel } from "./model"
 import type { SystemContext } from "../../system-context/index"
 import type { ToolOutputStore } from "../../tool-output-store"
@@ -12,15 +12,13 @@ export type RunError =
   | LLMError
   | SessionRunnerModel.Error
   | MessageDecodeError
-  | StepFailedError
-  | UserInterruptedError
   | SystemContext.InitializationBlocked
   | ToolOutputStore.Error
 
 /** Runs one local continuation from already-recorded Session history. */
 export interface Interface {
-  /** Drains eligible durable work. Explicit runs perform one physical attempt even when no work is eligible. */
-  readonly drain: (input: {
+  /** Drains eligible durable work. Explicit runs perform one provider attempt even when no work is eligible. */
+  readonly run: (input: {
     readonly sessionID: SessionSchema.ID
     readonly force: boolean
   }) => Effect.Effect<void, RunError>

packages/core/src/session/runner/llm.ts

@@ -10,8 +10,7 @@ import {
   isContextOverflowFailure,
   type ProviderErrorEvent,
 } from "@opencode-ai/llm"
-import { SessionError } from "@opencode-ai/schema/session-error"
-import { Cause, Effect, Exit, FiberSet, Layer, Option, Semaphore, Stream } from "effect"
+import { Cause, DateTime, Effect, Exit, FiberSet, Layer, Option, Semaphore, Stream } from "effect"
 import { AgentV2 } from "../../agent"
 import { Config } from "../../config"
 import { Database } from "../../database/database"
@@ -32,7 +31,6 @@ import { SessionCompaction } from "../compaction"
 import { SessionEvent } from "../event"
 import { SessionHistory } from "../history"
 import { SessionInput } from "../input"
-import { SessionMessage } from "../message"
 import { SessionSchema } from "../schema"
 import { SessionStore } from "../store"
 import { SessionTitle } from "../title"
@@ -45,9 +43,6 @@ import { SessionRunnerSystemPrompt } from "./system-prompt"
 import { Snapshot } from "../../snapshot"
 import { makeLocationNode } from "../../effect/app-node"
 import { llmClient } from "../../effect/app-node-platform"
-import { StepFailedError, UserInterruptedError } from "../error"
-import { toSessionError } from "../to-session-error"
-import { SessionRunnerRetry } from "./retry"
 
 /**
  * Runs one durable coding-agent Session until it settles.
@@ -58,19 +53,19 @@ import { SessionRunnerRetry } from "./retry"
  * - Session ownership and controls
  *   - [x] Coordinate one local active drain per Session; explicit resumes join and prompt wakeups coalesce.
  *   - [ ] Replace local ownership with durable multi-node ownership when clustered.
- *   - [x] Publish durable historical execution lifecycle and bounded retry observations.
+ *   - [ ] Mark busy, retrying, idle, interrupted, or terminal-failure status durably.
  *   - [ ] Honor interruption and reject stale work after runtime attachment replacement.
  *   - [x] Honor optional agent step limits.
- *   - [ ] Bound repeated identical tool calls (provider retries are bounded).
+ *   - [ ] Bound provider retries and repeated identical tool calls.
  *
  * - Runtime context assembly
  *   - Track V1 runtime-context parity canonically in `specs/v2/session.md`.
  *
- * - One step
+ * - One provider turn
  *   - [x] Translate every projected V2 Session message variant into canonical
  *     `@opencode-ai/llm` messages.
  *   - [ ] Resolve policy-filtered built-in, MCP, plugin, and structured-output tool definitions.
- *   - [x] Stream exactly one `llm.stream(request)` call per attempt.
+ *   - [x] Stream exactly one `llm.stream(request)` provider turn.
  *   - [x] Persist assistant text and usage events incrementally as they arrive.
  *   - [ ] Persist snapshots, patches, and retry notices incrementally as they arrive.
  *   - [x] Persist reasoning, provider errors, and tool-call events incrementally as they arrive.
@@ -82,8 +77,8 @@ import { SessionRunnerRetry } from "./retry"
  *   - [x] Start each recorded local call eagerly and await all settlements before continuation.
  *   - [ ] Add scoped runtime context, progress updates, attachment normalization,
  *     plugins, and cancellation settlement.
- *   - [x] Reload projected history and start the next explicit step after local tool results.
- *   - [x] Continue for durable user steering accepted during an active step.
+ *   - [x] Reload projected history and start the next explicit provider turn after local tool results.
+ *   - [x] Continue for durable user steering accepted during an active provider turn.
  *   - [ ] Continue for compaction or another continuation condition when required.
  *
  * - Post-run maintenance
@@ -91,12 +86,12 @@ import { SessionRunnerRetry } from "./retry"
  *   - [ ] Coalesce streamed deltas and add covering projected-history indexes.
  *   - [ ] Update title, summaries, compaction state, and cleanup in bounded background work.
  *
- * Use `llm.stream(request)` for each attempt. Keep tool execution and continuation here.
+ * Use `llm.stream(request)` for each provider turn. Keep tool execution and continuation here.
  * Durable continuation recovery remains a separate future slice with an explicit retry policy.
  *
  * The current slice loads V2 history, translates it, resolves a model through a core service, and persists one
- * step. Registry definitions are advertised, local tool calls are settled durably, and an
- * explicit loop starts the next step after local settlement. Configured agent step limits bound the loop.
+ * provider turn. Registry definitions are advertised, local tool calls are settled durably, and an
+ * explicit loop starts the next provider turn after local settlement. Configured agent step limits bound the loop.
  */
 
 const layer = Layer.effect(
@@ -119,7 +114,7 @@ const layer = Layer.effect(
     const db = (yield* Database.Service).db
     const compaction = yield* SessionCompaction.Service
     const title = yield* SessionTitle.Service
-    // Title generation is a side effect of the first step; it must not delay step continuation.
+    // Title generation is a side effect of the first turn; it must not delay turn continuation.
     // Tracked per process so repeated wakes before the second user message arrives don't
     // re-fire a redundant LLM call; `SessionTitle` itself is idempotent based on durable history.
     const titleAttempted = new Set<SessionSchema.ID>()
@@ -141,14 +136,17 @@ const layer = Layer.effect(
             sessionID,
             assistantMessageID: message.id,
             callID: tool.id,
-            error: { type: "tool.stale", message: "Tool execution interrupted", name: tool.name },
-            executed: tool.executed === true,
+            error: { type: "unknown", message: "Tool execution interrupted" },
+            provider: {
+              executed: tool.provider?.executed === true,
+              ...(tool.provider?.metadata === undefined ? {} : { metadata: tool.provider.metadata }),
+            },
           })
         }
       }
     })
 
-    const awaitToolFibers = (fibers: FiberSet.FiberSet<void, ToolOutputStore.Error | UserInterruptedError>) =>
+    const awaitToolFibers = (fibers: FiberSet.FiberSet<void, ToolOutputStore.Error>) =>
       Effect.raceFirst(FiberSet.join(fibers), FiberSet.awaitEmpty(fibers))
 
     // Match V1: dismissing a question halts the loop instead of becoming model-facing tool output.
@@ -168,26 +166,25 @@ const layer = Layer.effect(
         { concurrency: "unbounded" },
       ).pipe(Effect.map(SystemContext.combine))
 
-    const attemptStep = Effect.fn("SessionRunner.attemptStep")(function* (
+    const runTurnAttempt = Effect.fn("SessionRunner.runTurnAttempt")(function* (
       sessionID: SessionSchema.ID,
       promotion: SessionInput.Delivery | undefined,
       step: number,
       recoverOverflow?: typeof compaction.compactAfterOverflow,
-      assistantMessageID?: SessionMessage.ID,
     ) {
       const session = yield* getSession(sessionID)
       if (session.location.directory !== location.directory || session.location.workspaceID !== location.workspaceID)
         return yield* Effect.interrupt
       const agent = yield* agents.select(session.agent)
       // Establish what the model knows before admitting what the user said, so
-      // a blocked first step leaves pending inputs untouched.
+      // a blocked first turn leaves pending inputs untouched.
       const checkpoint = yield* SessionContextCheckpoint.prepare(
         db,
         events,
         loadSystemContext(agent, session.id),
         session.id,
       )
-      const toolFibers = yield* FiberSet.make<void, ToolOutputStore.Error | UserInterruptedError>()
+      const toolFibers = yield* FiberSet.make<void, ToolOutputStore.Error>()
       let needsContinuation = false
       let currentStep = step
       if (promotion) {
@@ -231,23 +228,21 @@ const layer = Layer.effect(
         // The selected catalog identity, not model.id: route-level ids are provider API
         // model ids (for example gpt-5.5-fast resolves to api id gpt-5.5).
         model: resolved.ref,
-        provider: model.provider,
         snapshot: startSnapshot,
-        assistantMessageID,
       })
       const publication = Semaphore.makeUnsafe(1)
-      // Durable publishes are serialized so tool fibers and step settlement never interleave
+      // Durable publishes are serialized so tool fibers and turn settlement never interleave
       // mid-event.
       const serialized = <A, E, R>(effect: Effect.Effect<A, E, R>) => publication.withPermit(effect)
-      const publish = (event: LLMEvent, outputPaths: ReadonlyArray<string> = [], error?: SessionError.Error) =>
-        serialized(publisher.publish(event, outputPaths, error))
+      const publish = (event: LLMEvent, outputPaths: ReadonlyArray<string> = []) =>
+        serialized(publisher.publish(event, outputPaths))
       let overflowFailure: ProviderErrorEvent | undefined
       const providerStream = llm.stream(request).pipe(
         Stream.runForEach((event) =>
           Effect.gen(function* () {
             if (overflowFailure || publisher.hasProviderError()) return
             if (LLMEvent.is.providerError(event)) {
-              if (isContextOverflowFailure(event) && !publisher.hasRetryEvidence()) {
+              if (isContextOverflowFailure(event) && !publisher.hasAssistantStarted()) {
                 overflowFailure = event
                 return
               }
@@ -255,12 +250,7 @@ const layer = Layer.effect(
             yield* publish(event)
             if (event.type !== "tool-call" || event.providerExecuted) return
             if (!toolMaterialization) {
-              yield* serialized(
-                publisher.failUnsettledTools({
-                  type: "tool.execution",
-                  message: "Tools are disabled after the maximum agent steps",
-                }),
-              )
+              yield* serialized(publisher.failUnsettledTools("Tools are disabled after the maximum agent steps"))
               return
             }
             needsContinuation = true
@@ -283,15 +273,6 @@ const layer = Layer.effect(
                       output: settlement.output,
                     }),
                     settlement.outputPaths ?? [],
-                    settlement.error,
-                  ).pipe(
-                    Effect.andThen(
-                      settlement.error?.type === "permission.rejected"
-                        ? serialized(publisher.failAssistant(settlement.error)).pipe(
-                            Effect.andThen(Effect.fail(new UserInterruptedError())),
-                          )
-                        : Effect.void,
-                    ),
                   ),
                 ),
               ),
@@ -301,7 +282,7 @@ const layer = Layer.effect(
         Effect.ensuring(serialized(publisher.flush())),
       )
 
-      // Captures the end snapshot, diffs it against the step's start, and durably ends the
+      // Captures the end snapshot, diffs it against the turn's start, and durably ends the
       // assistant step.
       const publishStepEnd = (settlement: NonNullable<ReturnType<typeof publisher.stepSettlement>>) =>
         Effect.gen(function* () {
@@ -335,41 +316,23 @@ const layer = Layer.effect(
           const streamInterrupted = stream._tag === "Failure" && Cause.hasInterrupts(stream.cause)
 
           // A context overflow before any assistant output is recoverable: compact and
-          // restart the step instead of surfacing the provider error.
+          // restart the turn instead of surfacing the provider error.
           if (
             recoverOverflow &&
-            !publisher.hasRetryEvidence() &&
+            !publisher.hasAssistantStarted() &&
             isContextOverflowFailure(overflowFailure ?? streamFailure) &&
             (yield* restore(recoverOverflow({ sessionID: session.id, messages: context, request })))
           )
             return { _tag: "RestartAfterOverflowCompaction", step: currentStep } as const
 
-          // An unrecovered held-back overflow becomes the step's durable provider error. A
+          // An unrecovered held-back overflow becomes the turn's durable provider error. A
           // thrown LLM failure fails hosted tool calls and the assistant unless a provider
           // error was already recorded from the stream.
           if (overflowFailure) yield* publish(overflowFailure)
           const llmFailure = streamFailure instanceof LLMError ? streamFailure : undefined
           if (llmFailure && !publisher.hasProviderError()) {
-            const error = toSessionError(llmFailure)
-            if (
-              SessionRunnerRetry.isRetryable(llmFailure) &&
-              !publisher.hasRetryEvidence() &&
-              (agent.info?.steps === undefined || currentStep < agent.info.steps)
-            ) {
-              return yield* new SessionRunnerRetry.RetryableFailure({
-                cause: llmFailure,
-                assistantMessageID: yield* publisher.startAssistant(),
-                error,
-                step: currentStep,
-              })
-            }
-            yield* serialized(
-              publisher.failUnsettledTools(
-                { type: "tool.result-missing", message: "Provider did not return a tool result" },
-                true,
-              ),
-            )
-            yield* serialized(publisher.failAssistant(error))
+            yield* serialized(publisher.failUnsettledTools("Provider did not return a tool result", true))
+            yield* serialized(publisher.failAssistant(llmFailure.reason.message))
           }
           // Provider error events only arrive from the stream, so the flag is final here.
           const providerFailed = publisher.hasProviderError()
@@ -379,30 +342,27 @@ const layer = Layer.effect(
           const settled = yield* restore(awaitToolFibers(toolFibers)).pipe(Effect.exit)
           const toolsInterrupted = settled._tag === "Failure" && Cause.hasInterrupts(settled.cause)
           const questionDismissed = settled._tag === "Failure" && isQuestionRejected(settled.cause)
-          const settledError =
-            settled._tag === "Failure" ? Option.getOrUndefined(Cause.findErrorOption(settled.cause)) : undefined
-          const permissionRejected = settledError instanceof UserInterruptedError
 
-          if (questionDismissed || permissionRejected || streamInterrupted || toolsInterrupted) {
+          if (questionDismissed || streamInterrupted || toolsInterrupted) {
             yield* FiberSet.clear(toolFibers)
-            yield* serialized(publisher.failUnsettledTools({ type: "aborted", message: "Tool execution interrupted" }))
-            yield* serialized(publisher.failAssistant({ type: "aborted", message: "Step interrupted" }))
+            yield* serialized(publisher.failUnsettledTools("Tool execution interrupted"))
+            yield* serialized(publisher.failAssistant("Provider turn interrupted"))
             // Match V1: dismissing a question halts the loop like an interruption.
-            if (questionDismissed || permissionRejected) return yield* new UserInterruptedError()
+            if (questionDismissed) return yield* Effect.interrupt
           }
           // A settled tool fiber failure is one of two things. A defect from a tool
-          // implementation becomes a failed tool call the model can read, and the step still
+          // implementation becomes a failed tool call the model can read, and the turn still
           // settles so the model may recover. A typed infrastructure failure (tool output
           // could not be persisted) also fails the assistant and then fails the drain.
-          const settledFailure =
-            settled._tag === "Failure" && !toolsInterrupted && !permissionRejected ? settled.cause : undefined
+          const settledFailure = settled._tag === "Failure" && !toolsInterrupted ? settled.cause : undefined
           const infraError =
             settledFailure === undefined ? undefined : Option.getOrUndefined(Cause.findErrorOption(settledFailure))
           if (settledFailure !== undefined) {
             const failure = infraError ?? Cause.squash(settledFailure)
-            const error = toSessionError(failure)
-            yield* serialized(publisher.failUnsettledTools(error))
-            if (infraError !== undefined) yield* serialized(publisher.failAssistant(error))
+            const message = failure instanceof Error ? failure.message : String(failure)
+            yield* serialized(publisher.failUnsettledTools(`Tool execution failed: ${message}`))
+            if (infraError !== undefined)
+              yield* serialized(publisher.failAssistant(`Tool execution failed: ${message}`))
           }
 
           const stepSettlement = publisher.stepSettlement()
@@ -411,21 +371,13 @@ const layer = Layer.effect(
           if (stepSettlement && stepEndedCleanly) yield* publishStepEnd(stepSettlement)
           // A provider error orphans recorded local calls; a clean stream can still leave
           // hosted calls without results.
-          if (providerFailed)
-            yield* serialized(publisher.failUnsettledTools({ type: "aborted", message: "Tool execution interrupted" }))
+          if (providerFailed) yield* serialized(publisher.failUnsettledTools("Tool execution interrupted"))
           if (stream._tag === "Success" && !providerFailed)
-            yield* serialized(
-              publisher.failUnsettledTools(
-                { type: "tool.result-missing", message: "Provider did not return a tool result" },
-                true,
-              ),
-            )
+            yield* serialized(publisher.failUnsettledTools("Provider did not return a tool result", true))
 
           if (stream._tag === "Failure") return yield* Effect.failCause(stream.cause)
           if (settled._tag === "Failure" && (toolsInterrupted || infraError !== undefined))
             return yield* Effect.failCause(settled.cause)
-          const stepFailure = publisher.stepFailure()
-          if (stepFailure) return yield* new StepFailedError({ error: stepFailure })
           return {
             _tag: "Completed",
             needsContinuation: !providerFailed && needsContinuation,
@@ -435,7 +387,7 @@ const layer = Layer.effect(
       )
     }, Effect.scoped)
 
-    const runStep = Effect.fnUntraced(function* (
+    const runTurn = Effect.fnUntraced(function* (
       sessionID: SessionSchema.ID,
       promotion: SessionInput.Delivery | undefined,
       step: number,
@@ -446,31 +398,8 @@ const layer = Layer.effect(
       let recoverOverflow: typeof compaction.compactAfterOverflow | undefined = compaction.compactAfterOverflow
       let currentPromotion = promotion
       let currentStep = step
-      let assistantMessageID: SessionMessage.ID | undefined
       while (true) {
-        const attempt = yield* Effect.suspend(() =>
-          attemptStep(sessionID, currentPromotion, currentStep, recoverOverflow, assistantMessageID),
-        ).pipe(
-          Effect.tapError((error) =>
-            error instanceof SessionRunnerRetry.RetryableFailure
-              ? Effect.sync(() => {
-                  currentStep = error.step + 1
-                  assistantMessageID = error.assistantMessageID
-                  currentPromotion = undefined
-                })
-              : Effect.void,
-          ),
-          Effect.retryOrElse(SessionRunnerRetry.schedule(events, sessionID), (error) => {
-            if (!(error instanceof SessionRunnerRetry.RetryableFailure)) return Effect.fail(error)
-            return events
-              .publish(SessionEvent.Step.Failed, {
-                sessionID,
-                assistantMessageID: error.assistantMessageID,
-                error: error.error,
-              })
-              .pipe(Effect.andThen(Effect.fail(error.cause)))
-          }),
-        )
+        const attempt = yield* runTurnAttempt(sessionID, currentPromotion, currentStep, recoverOverflow)
         if (attempt._tag === "Completed") return { needsContinuation: attempt.needsContinuation, step: attempt.step }
         if (attempt._tag === "RestartAfterOverflowCompaction") recoverOverflow = undefined
         yield* Effect.yieldNow
@@ -479,8 +408,9 @@ const layer = Layer.effect(
       }
     })
 
-    // Execution lifecycle is published per busy period by SessionExecution, not per drain here.
-    const drain = Effect.fn("SessionRunner.drain")(function* (input: {
+    // ExecutionSettled is published per execution (busy period) by SessionExecution, not per
+    // drain here.
+    const run = Effect.fn("SessionRunner.run")(function* (input: {
       readonly sessionID: SessionSchema.ID
       readonly force: boolean
     }) {
@@ -498,8 +428,8 @@ const layer = Layer.effect(
         // a provider error suppresses it. Pending steers also continue the loop so
         // interjections are answered before the session goes idle.
         while (needsContinuation) {
-          const result = yield* runStep(input.sessionID, promotion, step)
-          // Steer/queue promotion inside runStep has already made the pending input a visible
+          const result = yield* runTurn(input.sessionID, promotion, step)
+          // Steer/queue promotion inside runTurn has already made the pending input a visible
           // user message by this point, so the first-user-message check below is reliable.
           if (!titleAttempted.has(input.sessionID)) {
             titleAttempted.add(input.sessionID)
@@ -515,7 +445,7 @@ const layer = Layer.effect(
       }
     })
 
-    return Service.of({ drain })
+    return Service.of({ run })
   }),
 )
 

packages/core/src/session/runner/publish-llm-event.ts

@@ -1,19 +1,16 @@
 import { ToolOutput, type LLMEvent, type ProviderMetadata, type ToolResultValue, type Usage } from "@opencode-ai/llm"
-import { Effect } from "effect"
+import { DateTime, Effect } from "effect"
 import { EventV2 } from "../../event"
 import { ModelV2 } from "../../model"
 import { SessionEvent } from "../event"
 import { SessionMessage } from "../message"
 import { SessionSchema } from "../schema"
-import { SessionError } from "@opencode-ai/schema/session-error"
 
 type Input = {
   readonly sessionID: SessionSchema.ID
   readonly agent: string
   readonly model: ModelV2.Ref
-  readonly provider: string
   readonly snapshot?: string
-  readonly assistantMessageID?: SessionMessage.ID
 }
 
 const safe = (value: number | undefined) => Math.max(0, Number.isFinite(value) ? (value ?? 0) : 0)
@@ -44,16 +41,16 @@ const message = (value: unknown) => {
 
 type SettledOutput =
   | { readonly structured: Record<string, unknown>; readonly content: ToolOutput["content"] }
-  | { readonly error: SessionError.Error }
+  | { readonly error: { readonly type: "unknown"; readonly message: string } }
 
 const settledOutput = (value: ToolOutput | undefined, result: ToolResultValue): SettledOutput => {
-  if (result.type === "error") return { error: { type: "tool.execution", message: message(result.value) } }
+  if (result.type === "error") return { error: { type: "unknown", message: message(result.value) } }
   const settled = value ?? ToolOutput.fromResultValue(result)
   if (!settled) throw new Error(`Unsupported tool result: ${message(result)}`)
   return { structured: record(settled.structured), content: settled.content }
 }
 
-/** Persist one step without executing tools or starting a continuation step. */
+/** Persist one provider turn without executing tools or starting a continuation turn. */
 export const createLLMEventPublisher = (events: EventV2.Interface, input: Input) => {
   const tools = new Map<
     string,
@@ -64,25 +61,20 @@ export const createLLMEventPublisher = (events: EventV2.Interface, input: Input)
       called: boolean
       settled: boolean
       providerExecuted: boolean
+      providerMetadata?: ProviderMetadata
     }
   >()
-  let assistantMessageID = input.assistantMessageID
-  let stepStarted = false
+  const timestamp = DateTime.now
+  let assistantMessageID: SessionMessage.ID | undefined
+  let assistantActive = false
   let assistantFailed = false
   let providerFailed = false
-  let retryEvidence = false
-  let stepFailure: SessionError.Error | undefined
-  let stepSettlement:
-    | {
-        readonly finish: Extract<LLMEvent, { type: "step-finish" }>["reason"]
-        readonly tokens: ReturnType<typeof tokens>
-      }
-    | undefined
+  let stepSettlement: { readonly finish: string; readonly tokens: ReturnType<typeof tokens> } | undefined
 
   const startAssistant = Effect.fnUntraced(function* () {
-    if (stepStarted && assistantMessageID !== undefined) return assistantMessageID
-    assistantMessageID ??= SessionMessage.ID.create()
-    stepStarted = true
+    if (assistantMessageID !== undefined) return assistantMessageID
+    assistantMessageID = SessionMessage.ID.create()
+    assistantActive = true
     yield* events.publish(SessionEvent.Step.Started, {
       ...input,
       assistantMessageID,
@@ -94,18 +86,15 @@ export const createLLMEventPublisher = (events: EventV2.Interface, input: Input)
     assistantMessageID === undefined
       ? Effect.die(new Error("Tool event before assistant step start"))
       : Effect.succeed(assistantMessageID)
-  const providerState = (metadata: ProviderMetadata | undefined) => metadata?.[input.provider]
 
   const fragments = (
     name: string,
-    ended: (id: string, value: string, state?: Record<string, unknown>) => Effect.Effect<void>,
-    single = false,
+    ended: (id: string, value: string, providerMetadata?: ProviderMetadata) => Effect.Effect<void>,
   ) => {
     const chunks = new Map<string, string[]>()
     const start = (id: string) =>
       Effect.suspend(() => {
         if (chunks.has(id)) return Effect.die(new Error(`Duplicate ${name} start: ${id}`))
-        if (single && chunks.size > 0) return Effect.die(new Error(`${name} start before end: ${id}`))
         chunks.set(id, [])
         return Effect.void
       })
@@ -116,10 +105,10 @@ export const createLLMEventPublisher = (events: EventV2.Interface, input: Input)
         current.push(value)
         return Effect.void
       })
-    const end = Effect.fnUntraced(function* (id: string, state?: Record<string, unknown>) {
+    const end = Effect.fnUntraced(function* (id: string, providerMetadata?: ProviderMetadata) {
       const current = chunks.get(id)
       if (!current) return yield* Effect.die(new Error(`${name} end before start: ${id}`))
-      yield* ended(id, current.join(""), state)
+      yield* ended(id, current.join(""), providerMetadata)
       chunks.delete(id)
     })
     const flush = Effect.fnUntraced(function* () {
@@ -128,30 +117,26 @@ export const createLLMEventPublisher = (events: EventV2.Interface, input: Input)
     return { start, append, end, flush }
   }
 
-  const text = fragments(
-    "text",
-    (_textID, value) =>
-      Effect.gen(function* () {
-        yield* events.publish(SessionEvent.Text.Ended, {
-          sessionID: input.sessionID,
-          assistantMessageID: yield* currentAssistantMessageID(),
-          text: value,
-        })
-      }),
-    true,
+  const text = fragments("text", (textID, value) =>
+    Effect.gen(function* () {
+      yield* events.publish(SessionEvent.Text.Ended, {
+        sessionID: input.sessionID,
+        assistantMessageID: yield* currentAssistantMessageID(),
+        textID,
+        text: value,
+      })
+    }),
   )
-  const reasoning = fragments(
-    "reasoning",
-    (_reasoningID, value, state) =>
-      Effect.gen(function* () {
-        yield* events.publish(SessionEvent.Reasoning.Ended, {
-          sessionID: input.sessionID,
-          assistantMessageID: yield* currentAssistantMessageID(),
-          text: value,
-          state,
-        })
-      }),
-    true,
+  const reasoning = fragments("reasoning", (reasoningID, value, providerMetadata) =>
+    Effect.gen(function* () {
+      yield* events.publish(SessionEvent.Reasoning.Ended, {
+        sessionID: input.sessionID,
+        assistantMessageID: yield* currentAssistantMessageID(),
+        reasoningID,
+        text: value,
+        providerMetadata,
+      })
+    }),
   )
   const toolInput = fragments("tool input", (callID, value) =>
     Effect.gen(function* () {
@@ -206,21 +191,21 @@ export const createLLMEventPublisher = (events: EventV2.Interface, input: Input)
     yield* flushFragments()
   })
 
-  const failAssistant = Effect.fnUntraced(function* (error: SessionError.Error) {
+  const failAssistant = Effect.fnUntraced(function* (message: string) {
     if (assistantFailed) return
     yield* flush()
     const assistantMessageID = yield* startAssistant()
+    assistantActive = false
     assistantFailed = true
-    stepFailure = error
     yield* events.publish(SessionEvent.Step.Failed, {
       sessionID: input.sessionID,
       assistantMessageID,
-      error,
+      error: { type: "unknown", message },
     })
   })
 
   const failUnsettledTools = Effect.fn("SessionRunner.failUnsettledTools")(function* (
-    error: SessionError.Error,
+    message: string,
     hostedOnly = false,
   ) {
     for (const [callID, tool] of tools) {
@@ -230,8 +215,11 @@ export const createLLMEventPublisher = (events: EventV2.Interface, input: Input)
         sessionID: input.sessionID,
         assistantMessageID: tool.assistantMessageID,
         callID,
-        error,
-        executed: tool.providerExecuted,
+        error: { type: "unknown", message },
+        provider: {
+          executed: tool.providerExecuted,
+          ...(tool.providerMetadata === undefined ? {} : { metadata: tool.providerMetadata }),
+        },
       })
     }
   })
@@ -244,18 +232,16 @@ export const createLLMEventPublisher = (events: EventV2.Interface, input: Input)
   const publish = Effect.fn("SessionRunner.publishLLMEvent")(function* (
     event: LLMEvent,
     outputPaths: ReadonlyArray<string> = [],
-    error?: SessionError.Error,
   ) {
     switch (event.type) {
       case "step-start":
-        yield* startAssistant()
         return
       case "text-start":
-        retryEvidence = true
         yield* text.start(event.id)
         yield* events.publish(SessionEvent.Text.Started, {
           sessionID: input.sessionID,
           assistantMessageID: yield* startAssistant(),
+          textID: event.id,
         })
         return
       case "text-delta":
@@ -263,6 +249,7 @@ export const createLLMEventPublisher = (events: EventV2.Interface, input: Input)
         yield* events.publish(SessionEvent.Text.Delta, {
           sessionID: input.sessionID,
           assistantMessageID: yield* currentAssistantMessageID(),
+          textID: event.id,
           delta: event.text,
         })
         return
@@ -270,12 +257,12 @@ export const createLLMEventPublisher = (events: EventV2.Interface, input: Input)
         yield* text.end(event.id)
         return
       case "reasoning-start":
-        retryEvidence = true
         yield* reasoning.start(event.id)
         yield* events.publish(SessionEvent.Reasoning.Started, {
           sessionID: input.sessionID,
           assistantMessageID: yield* startAssistant(),
-          state: providerState(event.providerMetadata),
+          reasoningID: event.id,
+          providerMetadata: event.providerMetadata,
         })
         return
       case "reasoning-delta":
@@ -283,14 +270,14 @@ export const createLLMEventPublisher = (events: EventV2.Interface, input: Input)
         yield* events.publish(SessionEvent.Reasoning.Delta, {
           sessionID: input.sessionID,
           assistantMessageID: yield* currentAssistantMessageID(),
+          reasoningID: event.id,
           delta: event.text,
         })
         return
       case "reasoning-end":
-        yield* reasoning.end(event.id, providerState(event.providerMetadata))
+        yield* reasoning.end(event.id, event.providerMetadata)
         return
       case "tool-input-start":
-        retryEvidence = true
         yield* startToolInput(event)
         return
       case "tool-input-delta": {
@@ -312,7 +299,6 @@ export const createLLMEventPublisher = (events: EventV2.Interface, input: Input)
         yield* endToolInput(event)
         return
       case "tool-call": {
-        retryEvidence = true
         if (!tools.has(event.id)) yield* startToolInput(event)
         const tool = tools.get(event.id)!
         if (!tool.inputEnded) yield* endToolInput(event)
@@ -321,19 +307,21 @@ export const createLLMEventPublisher = (events: EventV2.Interface, input: Input)
         if (tool.called) return yield* Effect.die(new Error(`Duplicate tool call: ${event.id}`))
         tool.called = true
         tool.providerExecuted = event.providerExecuted === true
-        const state = providerState(event.providerMetadata)
+        tool.providerMetadata = event.providerMetadata
         yield* events.publish(SessionEvent.Tool.Called, {
           sessionID: input.sessionID,
           assistantMessageID: tool.assistantMessageID,
           callID: event.id,
+          tool: event.name,
           input: record(event.input),
-          executed: tool.providerExecuted,
-          state,
+          provider: {
+            executed: tool.providerExecuted,
+            ...(event.providerMetadata === undefined ? {} : { metadata: event.providerMetadata }),
+          },
         })
         return
       }
       case "tool-result": {
-        retryEvidence = true
         const tool = tools.get(event.id)
         if (!tool?.called) return yield* Effect.die(new Error(`Tool result before call: ${event.id}`))
         if (tool.name !== event.name)
@@ -343,9 +331,11 @@ export const createLLMEventPublisher = (events: EventV2.Interface, input: Input)
           return yield* Effect.die(new Error(`Duplicate tool result: ${event.id}`))
         }
         tool.settled = true
-        const result = error ? { error } : settledOutput(event.output, event.result)
-        const executed = event.providerExecuted === true || tool.providerExecuted
-        const resultState = providerState(event.providerMetadata)
+        const result = settledOutput(event.output, event.result)
+        const provider = {
+          executed: event.providerExecuted === true || tool.providerExecuted,
+          ...(event.providerMetadata === undefined ? {} : { metadata: event.providerMetadata }),
+        }
         if ("error" in result) {
           yield* events.publish(SessionEvent.Tool.Failed, {
             sessionID: input.sessionID,
@@ -353,8 +343,7 @@ export const createLLMEventPublisher = (events: EventV2.Interface, input: Input)
             callID: event.id,
             error: result.error,
             result: event.result,
-            executed,
-            resultState,
+            provider,
           })
           return
         }
@@ -364,14 +353,12 @@ export const createLLMEventPublisher = (events: EventV2.Interface, input: Input)
           callID: event.id,
           ...result,
           outputPaths,
-          ...(executed ? { result: event.result } : {}),
-          executed,
-          resultState,
+          ...(provider.executed ? { result: event.result } : {}),
+          provider,
         })
         return
       }
       case "tool-error": {
-        retryEvidence = true
         const tool = tools.get(event.id)
         if (!tool?.called) return yield* Effect.die(new Error(`Tool error before call: ${event.id}`))
         if (tool.name !== event.name)
@@ -382,30 +369,25 @@ export const createLLMEventPublisher = (events: EventV2.Interface, input: Input)
           sessionID: input.sessionID,
           assistantMessageID: tool.assistantMessageID,
           callID: event.id,
-          error:
-            event.message === `Unknown tool: ${event.name}`
-              ? { type: "tool.unknown", message: event.message, name: event.name }
-              : { type: "tool.execution", message: event.message },
-          executed: tool.providerExecuted,
-          resultState: providerState(event.providerMetadata),
+          error: { type: "unknown", message: event.message },
+          provider: {
+            executed: tool.providerExecuted,
+            ...(event.providerMetadata === undefined ? {} : { metadata: event.providerMetadata }),
+          },
         })
         return
       }
       case "step-finish":
         yield* flush()
+        assistantActive = false
         if (stepSettlement) return yield* Effect.die(new Error("Duplicate step finish"))
-        if (event.reason === "content-filter") {
-          providerFailed = true
-          yield* failAssistant({ type: "provider.content-filter", message: "Provider blocked the response" })
-          return
-        }
         stepSettlement = { finish: event.reason, tokens: tokens(event.usage) }
         return
       case "finish":
         return
       case "provider-error":
         providerFailed = true
-        yield* failAssistant({ type: "provider.unknown", message: event.message })
+        yield* failAssistant(event.message)
         return
     }
   })
@@ -415,9 +397,9 @@ export const createLLMEventPublisher = (events: EventV2.Interface, input: Input)
     flush,
     failAssistant,
     failUnsettledTools,
+    hasActiveAssistant: () => assistantActive,
+    hasAssistantStarted: () => assistantMessageID !== undefined,
     hasProviderError: () => providerFailed,
-    hasRetryEvidence: () => retryEvidence,
-    stepFailure: () => stepFailure,
     stepSettlement: () => stepSettlement,
     startAssistant,
     assistantMessageID: assistantMessageIDForTool,

packages/core/src/session/runner/retry.ts

@@ -1,67 +0,0 @@
-export * as SessionRunnerRetry from "./retry"
-
-import { LLMError } from "@opencode-ai/llm"
-import { SessionError } from "@opencode-ai/schema/session-error"
-import { Data, Duration, Effect, Schedule } from "effect"
-import { EventV2 } from "../../event"
-import { SessionEvent } from "../event"
-import { SessionMessage } from "../message"
-import { SessionSchema } from "../schema"
-import type { SessionRunner } from "./index"
-
-export class RetryableFailure extends Data.TaggedError("SessionRunner.RetryableFailure")<{
-  readonly cause: LLMError
-  readonly assistantMessageID: SessionMessage.ID
-  readonly error: SessionError.Error
-  readonly step: number
-}> {}
-
-export function isRetryable(error: LLMError) {
-  switch (error.reason._tag) {
-    case "RateLimit":
-    case "ProviderInternal":
-    case "Transport":
-      return true
-    case "Authentication":
-    case "QuotaExceeded":
-    case "ContentPolicy":
-    case "InvalidProviderOutput":
-    case "InvalidRequest":
-    case "NoRoute":
-    case "UnknownProvider":
-      return false
-    default: {
-      const exhaustive: never = error.reason
-      return exhaustive
-    }
-  }
-}
-
-const retryAfter = (failure: RetryableFailure) => {
-  if (failure.cause.reason._tag === "RateLimit" || failure.cause.reason._tag === "ProviderInternal")
-    return failure.cause.reason.retryAfterMs
-  return undefined
-}
-
-export const schedule = (events: EventV2.Interface, sessionID: SessionSchema.ID) =>
-  Schedule.exponential("2 seconds").pipe(
-    Schedule.take(4),
-    Schedule.setInputType<RetryableFailure | SessionRunner.RunError>(),
-    Schedule.passthrough,
-    Schedule.while(({ input }) => input instanceof RetryableFailure),
-    Schedule.modifyDelay((failure, delay) => {
-      const minimum = failure instanceof RetryableFailure ? retryAfter(failure) : undefined
-      return Effect.succeed(minimum === undefined ? delay : Duration.max(delay, Duration.millis(minimum)))
-    }),
-    Schedule.tap((metadata) =>
-      metadata.input instanceof RetryableFailure
-        ? events.publish(SessionEvent.RetryScheduled, {
-            sessionID,
-            assistantMessageID: metadata.input.assistantMessageID,
-            attempt: metadata.attempt + 1,
-            at: metadata.now + Duration.toMillis(metadata.duration),
-            error: metadata.input.error,
-          })
-        : Effect.void,
-    ),
-  )

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

@@ -21,11 +21,6 @@ const media = (file: FileAttachment): ContentPart => ({
 
 const decodeToolInput = Schema.decodeUnknownOption(Schema.UnknownFromJsonString)
 
-const providerMetadata = (
-  provider: string,
-  state: Record<string, unknown> | undefined,
-): ProviderMetadata | undefined => (state === undefined ? undefined : { [provider]: state })
-
 const toolInput = (tool: SessionMessage.AssistantTool) =>
   tool.state.status === "pending"
     ? Option.getOrElse(decodeToolInput(tool.state.input), () => tool.state.input)
@@ -36,7 +31,7 @@ const toolCall = (tool: SessionMessage.AssistantTool, providerMetadata: Provider
     id: tool.id,
     name: tool.name,
     input: toolInput(tool),
-    providerExecuted: tool.executed,
+    providerExecuted: tool.provider?.executed,
     providerMetadata,
   })
 
@@ -45,14 +40,14 @@ const toolResult = (tool: SessionMessage.AssistantTool, providerMetadata: Provid
     // TODO: Materialize remote and managed URIs before provider-history lowering.
     // ToolOutput.toResultValue rejects unresolved URIs rather than treating them as media bytes.
     const result =
-      tool.executed === true && tool.state.result !== undefined
+      tool.provider?.executed === true && tool.state.result !== undefined
         ? tool.state.result
         : ToolOutput.toResultValue({ structured: tool.state.structured, content: tool.state.content })
     return ToolResultPart.make({
       id: tool.id,
       name: tool.name,
       result,
-      providerExecuted: tool.executed,
+      providerExecuted: tool.provider?.executed,
       providerMetadata,
     })
   }
@@ -61,11 +56,11 @@ const toolResult = (tool: SessionMessage.AssistantTool, providerMetadata: Provid
       id: tool.id,
       name: tool.name,
       result:
-        tool.executed === true && tool.state.result !== undefined
+        tool.provider?.executed === true && tool.state.result !== undefined
           ? tool.state.result
           : { error: tool.state.error, content: tool.state.content, structured: tool.state.structured },
       resultType: "error",
-      providerExecuted: tool.executed,
+      providerExecuted: tool.provider?.executed,
       providerMetadata,
     })
   }
@@ -83,22 +78,17 @@ const assistant = (message: SessionMessage.Assistant, model: Model) => {
             {
               type: "reasoning",
               text: item.text,
-              providerMetadata: reuseProviderMetadata ? providerMetadata(model.provider, item.state) : undefined,
+              providerMetadata: reuseProviderMetadata ? item.providerMetadata : undefined,
             },
           ]
         : item.text.length > 0
           ? [{ type: "text", text: item.text }]
           : []
-    const call = toolCall(
-      item,
-      reuseProviderMetadata ? providerMetadata(model.provider, item.providerState) : undefined,
-    )
-    if (item.executed !== true) return [call]
+    const call = toolCall(item, reuseProviderMetadata ? item.provider?.metadata : undefined)
+    if (item.provider?.executed !== true) return [call]
     const result = toolResult(
       item,
-      reuseProviderMetadata
-        ? providerMetadata(model.provider, item.providerResultState ?? item.providerState)
-        : undefined,
+      reuseProviderMetadata ? (item.provider.resultMetadata ?? item.provider.metadata) : undefined,
     )
     return result ? [call, result] : [call]
   })
@@ -108,14 +98,9 @@ const assistant = (message: SessionMessage.Assistant, model: Model) => {
     return part.text !== "" || (part.providerMetadata !== undefined && Object.keys(part.providerMetadata).length > 0)
   })
   const results = message.content
-    .filter((item): item is SessionMessage.AssistantTool => item.type === "tool" && item.executed !== true)
+    .filter((item): item is SessionMessage.AssistantTool => item.type === "tool" && item.provider?.executed !== true)
     .map((item) =>
-      toolResult(
-        item,
-        reuseProviderMetadata
-          ? providerMetadata(model.provider, item.providerResultState ?? item.providerState)
-          : undefined,
-      ),
+      toolResult(item, reuseProviderMetadata ? (item.provider?.resultMetadata ?? item.provider?.metadata) : undefined),
     )
     .filter((message) => message !== undefined)
     .map(Message.tool)
@@ -154,7 +139,7 @@ function toLLMMessage(message: SessionMessage.Message, model: Model): Message[]
         Message.make({
           id: message.id,
           role: "user",
-          content: `Shell command: ${message.shell.command}\n\n${message.output?.output ?? ""}`,
+          content: `Shell command: ${message.command}\n\n${message.output}`,
           metadata: message.metadata,
         }),
       ]

packages/core/src/session/to-session-error.ts

@@ -1,65 +0,0 @@
-import { LLMError, ToolFailure } from "@opencode-ai/llm"
-import { SessionError } from "@opencode-ai/schema/session-error"
-import { PermissionV2 } from "../permission"
-import { QuestionV2 } from "../question"
-import { Integration } from "../integration"
-import { ToolOutputStore } from "../tool-output-store"
-import { StepFailedError, UserInterruptedError } from "./error"
-import { SessionRunnerModel } from "./runner/model"
-
-export function toSessionError(cause: unknown): SessionError.Error {
-  if (cause instanceof LLMError) {
-    switch (cause.reason._tag) {
-      case "RateLimit":
-        return {
-          type: "provider.rate-limit",
-          message: cause.reason.message,
-          retryAfterMs: cause.reason.retryAfterMs,
-        }
-      case "Authentication":
-        return { type: "provider.auth", message: cause.reason.message }
-      case "QuotaExceeded":
-        return { type: "provider.quota", message: cause.reason.message }
-      case "ContentPolicy":
-        return { type: "provider.content-filter", message: cause.reason.message }
-      case "Transport":
-        return { type: "provider.transport", message: cause.reason.message }
-      case "ProviderInternal":
-        return { type: "provider.internal", message: cause.reason.message }
-      case "InvalidProviderOutput":
-        return { type: "provider.invalid-output", message: cause.reason.message }
-      case "InvalidRequest":
-        return { type: "provider.invalid-request", message: cause.reason.message }
-      case "NoRoute":
-        return { type: "provider.no-route", message: cause.reason.message }
-      case "UnknownProvider":
-        return { type: "provider.unknown", message: cause.reason.message }
-      default: {
-        const exhaustive: never = cause.reason
-        return exhaustive
-      }
-    }
-  }
-  if (cause instanceof PermissionV2.DeniedError || cause instanceof PermissionV2.RejectedError)
-    return {
-      type: "permission.rejected",
-      message: cause.message,
-      permission: cause.permission,
-      resources: [...cause.resources],
-    }
-  if (cause instanceof QuestionV2.RejectedError) return { type: "aborted", message: cause.message, reason: "user" }
-  if (cause instanceof ToolFailure)
-    return cause.error === undefined ? { type: "tool.execution", message: cause.message } : toSessionError(cause.error)
-  if (cause instanceof StepFailedError) return cause.error
-  if (cause instanceof UserInterruptedError) return { type: "aborted", message: cause.message, reason: "user" }
-  if (
-    cause instanceof SessionRunnerModel.ModelNotSelectedError ||
-    cause instanceof SessionRunnerModel.ModelUnavailableError ||
-    cause instanceof SessionRunnerModel.VariantUnavailableError ||
-    cause instanceof SessionRunnerModel.UnsupportedApiError
-  )
-    return { type: "provider.no-route", message: cause.message }
-  if (cause instanceof Integration.AuthorizationError) return { type: "provider.auth", message: cause.message }
-  if (cause instanceof ToolOutputStore.StorageError) return { type: "unknown", message: cause.message }
-  return { type: "unknown", message: cause instanceof Error ? cause.message : String(cause) }
-}

packages/core/src/skill.ts

@@ -3,7 +3,7 @@ export * as SkillV2 from "./skill"
 import { makeLocationNode } from "./effect/app-node"
 import path from "path"
 import { Context, Effect, Layer, Schema, Stream, Types } from "effect"
-import { FileSystem } from "@opencode-ai/schema/filesystem"
+import { FileSystemWatcher } from "@opencode-ai/schema/filesystem-watcher"
 import { Skill } from "@opencode-ai/schema/skill"
 import { AgentV2 } from "./agent"
 import { ConfigMarkdown } from "./config/markdown"
@@ -153,7 +153,7 @@ const layer = Layer.effect(
       yield* events.publish(Event.Updated, {}).pipe(Effect.asVoid)
     })
 
-    yield* events.subscribe(FileSystem.Event.Changed).pipe(
+    yield* events.subscribe(FileSystemWatcher.Event.Updated).pipe(
       Stream.runForEach((event) => invalidate(event.data.file)),
       Effect.forkScoped({ startImmediately: true }),
     )

packages/core/src/system-context/index.ts

@@ -12,7 +12,7 @@ import { Effect, Option, Schema } from "effect"
  * The durable `Applied` record tracks what the model was last told, per source:
  * it is the model's current belief. Interpreters uphold one invariant —
  * `reconcile` never rewrites the baseline; it only narrates drift as update
- * text. Only `rebaseline` (compaction) and `initialize` (first step) produce
+ * text. Only `rebaseline` (compaction) and `initialize` (first turn) produce
  * baseline text.
  *
  * Returning `unavailable` means observation failed temporarily. It differs from

packages/core/src/tool/apply-patch.ts

@@ -73,12 +73,12 @@ export const Plugin = {
             toModelOutput: ({ output }) => [{ type: "text", text: toModelOutput(output) }],
             execute: (input, context) => {
               const applied: Array<typeof Applied.Type> = []
-              const fail = (path: string, error?: unknown) => {
+              const fail = (path: string) => {
                 const prefix =
                   applied.length === 0
                     ? `Unable to apply patch at ${path}`
                     : `Patch partially applied before failing at ${path}. Applied: ${applied.map((item) => item.resource).join(", ")}`
-                return new ToolFailure({ message: prefix, error })
+                return new ToolFailure({ message: prefix })
               }
               return Effect.gen(function* () {
                 const source = {
@@ -150,7 +150,7 @@ export const Plugin = {
                       before,
                       after: update.content,
                     })
-                  }).pipe(Effect.mapError((error) => fail(hunk.path, error)))
+                  }).pipe(Effect.mapError(() => fail(hunk.path)))
                 }
 
                 const patchFiles = prepared.map(patchFile)
@@ -180,11 +180,11 @@ export const Plugin = {
                         content: change.content,
                       })
                       applied.push({ type: change.type, resource: result.resource, target: result.target })
-                    }).pipe(Effect.mapError((error) => fail(change.path, error))),
+                    }).pipe(Effect.mapError(() => fail(change.path))),
                   { discard: true },
                 )
                 return { applied, files: patchFiles }
-              }).pipe(Effect.mapError((error) => (error instanceof ToolFailure ? error : fail("patch", error))))
+              }).pipe(Effect.mapError((error) => (error instanceof ToolFailure ? error : fail("patch"))))
             },
           }),
           "edit",

packages/core/src/tool/edit.ts

@@ -111,9 +111,8 @@ export const Plugin = {
                     error instanceof FileMutation.StaleContentError
                       ? new ToolFailure({
                           message: "File changed after permission approval. Read it again before editing.",
-                          error,
                         })
-                      : new ToolFailure({ message: `Unable to edit ${input.path}`, error }),
+                      : new ToolFailure({ message: `Unable to edit ${input.path}` }),
                   ),
                 )
 

packages/core/src/tool/glob.ts

@@ -88,9 +88,7 @@ export const Plugin = {
                   ),
                 )
             }).pipe(
-              Effect.mapError(
-                (error) => new ToolFailure({ message: `Unable to find files matching ${input.pattern}`, error }),
-              ),
+              Effect.mapError(() => new ToolFailure({ message: `Unable to find files matching ${input.pattern}` })),
             ),
         }),
       })

packages/core/src/tool/grep.ts

@@ -121,9 +121,7 @@ export const Plugin = {
                     ),
                   ),
                 )
-            }).pipe(
-              Effect.mapError((error) => new ToolFailure({ message: `Unable to grep for ${input.pattern}`, error })),
-            ),
+            }).pipe(Effect.mapError(() => new ToolFailure({ message: `Unable to grep for ${input.pattern}` }))),
         }),
       })
       .pipe(Effect.orDie)

packages/core/src/tool/question.ts

@@ -67,7 +67,7 @@ export const Plugin = {
                 source: { type: "tool", messageID: context.assistantMessageID, callID: context.toolCallID },
               })
               .pipe(
-                Effect.mapError((error) => new ToolFailure({ message: "Permission denied: question", error })),
+                Effect.mapError(() => new ToolFailure({ message: "Permission denied: question" })),
                 Effect.andThen(
                   question
                     .ask({

packages/core/src/tool/read.ts

@@ -106,9 +106,7 @@ export const Plugin = {
                   start: type === "directory" ? resolved : dirname(resolved),
                   stop: root,
                 })
-                const candidates = (yield* Effect.forEach(discovered, fs.resolve)).filter(
-                  (file) => dirname(file) !== root,
-                )
+                const candidates = (yield* Effect.forEach(discovered, fs.resolve)).filter((file) => dirname(file) !== root)
                 if (candidates.length === 0) return
                 yield* sessionInstructions.load({ sessionID: context.sessionID, paths: candidates })
               }).pipe(
@@ -132,7 +130,7 @@ export const Plugin = {
                   error instanceof Image.SizeError
                     ? error.message
                     : `Unable to read ${input.path}`
-                return new ToolFailure({ message, error })
+                return new ToolFailure({ message })
               }),
             )
           },

packages/core/src/tool/registry.ts

@@ -12,8 +12,6 @@ import { definition, permission, registrationEntries, settle, type AnyTool, type
 import { Tools } from "./tools"
 import { ToolHooks } from "./hooks"
 import { makeLocationNode } from "../effect/app-node"
-import { SessionError } from "@opencode-ai/schema/session-error"
-import { toSessionError } from "../session/to-session-error"
 
 export type ExecuteInput = {
   readonly sessionID: SessionSchema.ID
@@ -42,7 +40,6 @@ export interface Settlement {
   readonly result: ToolResultValue
   readonly output?: ToolOutput
   readonly outputPaths?: ReadonlyArray<string>
-  readonly error?: SessionError.Error
 }
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/v2/ToolRegistry") {}
@@ -63,15 +60,9 @@ const registryLayer = Layer.effect(
             type: "error" as const,
             value: advertised ? `Stale tool call: ${input.call.name}` : `Unknown tool: ${input.call.name}`,
           },
-          error: advertised
-            ? ({ type: "tool.stale", message: `Stale tool call: ${input.call.name}`, name: input.call.name } as const)
-            : ({ type: "tool.unknown", message: `Unknown tool: ${input.call.name}`, name: input.call.name } as const),
         }
       if (advertised && registration.identity !== advertised)
-        return {
-          result: { type: "error" as const, value: `Stale tool call: ${input.call.name}` },
-          error: { type: "tool.stale" as const, message: `Stale tool call: ${input.call.name}`, name: input.call.name },
-        }
+        return { result: { type: "error" as const, value: `Stale tool call: ${input.call.name}` } }
       // Hooks fire only for hosted/local tools; provider-executed calls never reach settleWith.
       const beforeEvent: ToolHooks.BeforeEvent = {
         tool: input.call.name,
@@ -82,33 +73,22 @@ const registryLayer = Layer.effect(
         input: input.call.input,
       }
       yield* toolHooks.runBefore(beforeEvent)
-      const pending = yield* settle(
-        registration.tool,
-        { ...input.call, input: beforeEvent.input },
-        {
-          sessionID: input.sessionID,
-          agent: input.agent,
-          assistantMessageID: input.assistantMessageID,
-          toolCallID: input.call.id,
-        },
-      ).pipe(
+      const pending = yield* settle(registration.tool, { ...input.call, input: beforeEvent.input }, {
+        sessionID: input.sessionID,
+        agent: input.agent,
+        assistantMessageID: input.assistantMessageID,
+        toolCallID: input.call.id,
+      }).pipe(
         Effect.map((output) => ({ output })),
         Effect.catchTag("LLM.ToolFailure", (failure) =>
-          Effect.succeed({
-            result: { type: "error" as const, value: failure.message },
-            error: toSessionError(failure),
-          }),
+          Effect.succeed({ result: { type: "error" as const, value: failure.message } }),
         ),
       )
       let settlement: Settlement
       if ("result" in pending) {
         settlement = pending
       } else {
-        const bounded = yield* resources.bound({
-          sessionID: input.sessionID,
-          toolCallID: input.call.id,
-          output: pending.output,
-        })
+        const bounded = yield* resources.bound({ sessionID: input.sessionID, toolCallID: input.call.id, output: pending.output })
         const result = ToolOutput.toResultValue(bounded.output)
         settlement =
           result.type === "error"
@@ -135,7 +115,6 @@ const registryLayer = Layer.effect(
         result: afterEvent.result,
         ...(afterEvent.output !== undefined ? { output: afterEvent.output } : {}),
         ...(afterEvent.outputPaths !== undefined ? { outputPaths: afterEvent.outputPaths } : {}),
-        ...(settlement.error !== undefined ? { error: settlement.error } : {}),
       }
     })
 
@@ -178,10 +157,7 @@ const registryLayer = Layer.effect(
           settle: (input) => {
             const registration = registrations.get(input.call.name)
             if (registration) return settleWith(input, registration.identity)
-            return Effect.succeed({
-              result: { type: "error", value: `Unknown tool: ${input.call.name}` },
-              error: { type: "tool.unknown", message: `Unknown tool: ${input.call.name}`, name: input.call.name },
-            })
+            return Effect.succeed({ result: { type: "error", value: `Unknown tool: ${input.call.name}` } })
           },
         }
       }),

packages/core/src/tool/shell.ts

@@ -18,7 +18,8 @@ export const DEFAULT_TIMEOUT_MS = 2 * 60 * 1_000
 export const MAX_TIMEOUT_MS = 10 * 60 * 1_000
 export const MAX_CAPTURE_BYTES = 1024 * 1024
 
-const BACKGROUND_STARTED = "The command has not completed; it is now running in the background."
+const BACKGROUND_STARTED =
+  "The command has not completed; it is now running in the background."
 
 export const Input = Schema.Struct({
   command: Schema.String.annotate({ description: "Shell command string to execute" }),
@@ -244,9 +245,9 @@ export const Plugin = {
                 }
               }
 
-              const result = yield* runtime.job
-                .block({ id: job.id, sessionID: context.sessionID })
-                .pipe(Effect.onInterrupt(() => runtime.job.cancel(job.id).pipe(Effect.ignore)))
+              const result = yield* runtime.job.block({ id: job.id, sessionID: context.sessionID }).pipe(
+                Effect.onInterrupt(() => runtime.job.cancel(job.id).pipe(Effect.ignore)),
+              )
               if (result?.type === "backgrounded") {
                 yield* notifyWhenDone(context.sessionID, context.toolCallID, input.command)
                 return {
@@ -257,19 +258,14 @@ export const Plugin = {
                   ...(warnings.length ? { warnings } : {}),
                 }
               }
-              if (result?.info.status === "error")
-                return yield* Effect.fail(new Error(result.info.error ?? "Command failed"))
+              if (result?.info.status === "error") return yield* Effect.fail(new Error(result.info.error ?? "Command failed"))
               if (result?.info.status === "cancelled") return yield* Effect.fail(new Error("Command cancelled"))
 
               return {
                 ...(yield* settleShell()),
                 ...(warnings.length ? { warnings } : {}),
               }
-            }).pipe(
-              Effect.mapError(
-                (error) => new ToolFailure({ message: `Unable to execute command: ${input.command}`, error }),
-              ),
-            ),
+            }).pipe(Effect.mapError(() => new ToolFailure({ message: `Unable to execute command: ${input.command}` }))),
         }),
       })
       .pipe(Effect.orDie)

packages/core/src/tool/subagent.ts

@@ -104,9 +104,7 @@ export const Plugin = {
               const parent = yield* runtime.session
                 .get(context.sessionID)
                 .pipe(
-                  Effect.mapError(
-                    (error) => new ToolFailure({ message: `Parent session not found: ${context.sessionID}`, error }),
-                  ),
+                  Effect.mapError(() => new ToolFailure({ message: `Parent session not found: ${context.sessionID}` })),
                 )
               const agent = yield* agents.resolve(input.agent)
               if (agent === undefined) return yield* new ToolFailure({ message: `Unknown agent: ${input.agent}` })
@@ -125,9 +123,7 @@ export const Plugin = {
                   // session (V1 deriveSubagentSessionPermission). MVP uses the agent's own permissions.
                 })
                 .pipe(
-                  Effect.mapError(
-                    (error) => new ToolFailure({ message: `Parent session not found: ${context.sessionID}`, error }),
-                  ),
+                  Effect.mapError(() => new ToolFailure({ message: `Parent session not found: ${context.sessionID}` })),
                 )
 
               const background = input.background === true

packages/core/src/tool/todowrite.ts

@@ -46,7 +46,7 @@ export const Plugin = {
               })
               yield* todos.update({ sessionID: context.sessionID, todos: input.todos })
               return { todos: input.todos }
-            }).pipe(Effect.mapError((error) => new ToolFailure({ message: "Unable to update todos", error }))),
+            }).pipe(Effect.mapError(() => new ToolFailure({ message: "Unable to update todos" }))),
         }),
       })
       .pipe(Effect.orDie)

packages/core/src/tool/webfetch.ts

@@ -170,7 +170,7 @@ export const Plugin = {
                 format: input.format,
                 output,
               }
-            }).pipe(Effect.mapError((error) => new ToolFailure({ message: `Unable to fetch ${input.url}`, error }))),
+            }).pipe(Effect.mapError(() => new ToolFailure({ message: `Unable to fetch ${input.url}` }))),
         }),
       })
       .pipe(Effect.orDie)

packages/core/src/tool/websearch.ts

@@ -243,11 +243,7 @@ export const Plugin = {
                 provider,
                 text: text ?? NO_RESULTS,
               }
-            }).pipe(
-              Effect.mapError(
-                (error) => new ToolFailure({ message: `Unable to search the web for ${input.query}`, error }),
-              ),
-            )
+            }).pipe(Effect.mapError(() => new ToolFailure({ message: `Unable to search the web for ${input.query}` })))
           },
         }),
       })

packages/core/src/tool/write.ts

@@ -83,7 +83,7 @@ export const Plugin = {
                   source,
                 })
                 return yield* files.writeTextPreservingBom({ target, content: input.content })
-              }).pipe(Effect.mapError((error) => new ToolFailure({ message: `Unable to write ${input.path}`, error }))),
+              }).pipe(Effect.mapError(() => new ToolFailure({ message: `Unable to write ${input.path}` }))),
           }),
           "edit",
         ),

packages/core/src/v1/config/config.ts

@@ -2,6 +2,7 @@ export * as ConfigV1 from "./config"
 
 import { Schema } from "effect"
 import { NonNegativeInt, PositiveInt, type DeepMutable } from "../../schema"
+import { ConfigExperimental } from "../../config/experimental"
 import { ConfigReference } from "../../config/reference"
 import { ConfigAgentV1 } from "./agent"
 import { ConfigAttachmentV1 } from "./attachment"
@@ -178,6 +179,9 @@ export const Info = Schema.Struct({
       mcp_timeout: Schema.optional(PositiveInt).annotate({
         description: "Timeout in milliseconds for model context protocol (MCP) requests",
       }),
+      policies: Schema.optional(Schema.mutable(Schema.Array(ConfigExperimental.Policy))).annotate({
+        description: "Policy statements applied to supported resources, such as provider access",
+      }),
     }),
   ),
 }).annotate({ identifier: "Config" })

packages/core/src/v1/config/migrate.ts

@@ -78,6 +78,7 @@ export function migrate(info: typeof ConfigV1.Info.Type) {
     plugins: info.plugin?.map((plugin) =>
       typeof plugin === "string" ? plugin : { package: plugin[0], options: plugin[1] },
     ),
+    experimental: info.experimental?.policies && { policies: info.experimental.policies },
     providers: providers(info.provider),
   }
 }

packages/core/test/catalog.test.ts

@@ -8,6 +8,7 @@ import { LayerNode } from "@opencode-ai/core/effect/layer-node"
 import { EventV2 } from "@opencode-ai/core/event"
 import { Location } from "@opencode-ai/core/location"
 import { ModelV2 } from "@opencode-ai/core/model"
+import { Policy } from "@opencode-ai/core/policy"
 import { ProviderV2 } from "@opencode-ai/core/provider"
 import { AbsolutePath } from "@opencode-ai/core/schema"
 import { location } from "./fixture/location"
@@ -23,7 +24,7 @@ const locationLayer = Layer.succeed(
   Location.Service.of(location({ directory: AbsolutePath.make("test") })),
 )
 const catalogLayer = AppNodeBuilder.build(
-  LayerNode.group([Catalog.node, EventV2.node, Credential.node, Integration.node]),
+  LayerNode.group([Catalog.node, EventV2.node, Credential.node, Integration.node, Policy.node]),
   [[Location.node, locationLayer]],
 )
 const it = testEffect(catalogLayer)
@@ -332,4 +333,21 @@ describe("CatalogV2", () => {
       expect((yield* catalog.model.small(providerID))?.id).toMatch("expensive-mini")
     }),
   )
+
+  it.effect("removes providers denied by policy after loading", () =>
+    Effect.gen(function* () {
+      const catalog = yield* Catalog.Service
+      const policy = yield* Policy.Service
+      const providerID = ProviderV2.ID.make("blocked")
+      yield* policy.load([new Policy.Info({ effect: "deny", action: "provider.use", resource: "blocked" })])
+      yield* catalog.transform((catalog) => {
+        catalog.provider.update(providerID, () => {})
+        catalog.model.update(providerID, ModelV2.ID.make("model"), () => {})
+      })
+
+      expect(yield* catalog.provider.all()).toEqual([])
+      expect(yield* catalog.model.all()).toEqual([])
+      expect(yield* catalog.provider.get(providerID)).toBeUndefined()
+    }),
+  )
 })

packages/core/test/config/command.test.ts

@@ -1,15 +1,13 @@
 import fs from "fs/promises"
 import path from "path"
 import { describe, expect } from "bun:test"
-import { Effect, PubSub, Schema, Stream } from "effect"
-import { Config as ConfigSchema } from "@opencode-ai/schema/config"
+import { Effect, Schema } from "effect"
 import { CommandV2 } from "@opencode-ai/core/command"
 import { Config } from "@opencode-ai/core/config"
 import { ConfigCommandPlugin } from "@opencode-ai/core/config/plugin/command"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { LayerNode } from "@opencode-ai/core/effect/layer-node"
 import { FSUtil } from "@opencode-ai/core/fs-util"
-import { EventV2 } from "@opencode-ai/core/event"
 import { Location } from "@opencode-ai/core/location"
 import { MCP } from "@opencode-ai/core/mcp/index"
 import { ModelV2 } from "@opencode-ai/core/model"
@@ -21,7 +19,7 @@ import { testEffect } from "../lib/effect"
 import { host } from "../plugin/host"
 
 const it = testEffect(
-  AppNodeBuilder.build(LayerNode.group([CommandV2.node, EventV2.node, FSUtil.node]), [
+  AppNodeBuilder.build(LayerNode.group([CommandV2.node, FSUtil.node]), [
     [MCP.node, emptyMcpLayer],
     [Config.node, emptyConfigLayer],
     [Location.node, testLocationLayer],
@@ -55,19 +53,7 @@ Review files`,
           })
 
           const command = yield* CommandV2.Service
-          const events = yield* EventV2.Service
-          const update = yield* events.publish(ConfigSchema.Event.Updated, {})
-          const updates = yield* PubSub.unbounded<typeof update>()
-          yield* ConfigCommandPlugin.Plugin.effect(
-            host({
-              command: {
-                list: () => Effect.die("unused command.list"),
-                transform: command.transform,
-                reload: command.reload,
-              },
-              event: { subscribe: () => Stream.fromPubSub(updates) },
-            }),
-          ).pipe(
+          yield* ConfigCommandPlugin.Plugin.effect(host({ command: { ...command, reload: command.reload } })).pipe(
             Effect.provideService(
               Config.Service,
               Config.Service.of({
@@ -99,15 +85,6 @@ Review files`,
             CommandV2.Info.make({ name: "empty", template: "" }),
             CommandV2.Info.make({ name: "nested/docs", template: "Write docs" }),
           ])
-
-          yield* Effect.promise(() => fs.writeFile(path.join(tmp.path, "commands", "review.md"), "Review again"))
-          yield* Effect.sleep("10 millis")
-          yield* PubSub.publish(updates, update)
-          for (let attempt = 0; attempt < 100; attempt++) {
-            if ((yield* command.get("review"))?.template === "Review again") break
-            yield* Effect.sleep("10 millis")
-          }
-          expect((yield* command.get("review"))?.template).toBe("Review again")
         }),
       ),
     ),

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

@@ -1,20 +1,18 @@
 import path from "path"
 import fs from "fs/promises"
 import { describe, expect } from "bun:test"
-import { Effect, Fiber, Layer, PubSub, Schema, Stream } from "effect"
+import { Effect, Layer, Schema } from "effect"
 import { FastCheck } from "effect/testing"
 import { Config } from "@opencode-ai/core/config"
-import { Config as ConfigSchema } from "@opencode-ai/schema/config"
 import { ConfigProvider } from "@opencode-ai/core/config/provider"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { LayerNode } from "@opencode-ai/core/effect/layer-node"
 import { ConfigMigrateV1 } from "@opencode-ai/core/v1/config/migrate"
 import { ConfigV1 } from "@opencode-ai/core/v1/config/config"
 import { FSUtil } from "@opencode-ai/core/fs-util"
-import { Watcher } from "@opencode-ai/core/filesystem/watcher"
-import { EventV2 } from "@opencode-ai/core/event"
 import { Global } from "@opencode-ai/core/global"
 import { Location } from "@opencode-ai/core/location"
+import { Policy } from "@opencode-ai/core/policy"
 import { Project } from "@opencode-ai/core/project"
 import { AbsolutePath } from "@opencode-ai/core/schema"
 import { location } from "../fixture/location"
@@ -28,7 +26,6 @@ function testLayer(
   globalDirectory = path.join(directory, "global"),
   projectDirectory = directory,
   vcs?: Project.Vcs,
-  watcher?: Layer.Layer<Watcher.Service>,
 ) {
   const locationLayer = Layer.succeed(
     Location.Service,
@@ -39,10 +36,9 @@ function testLayer(
       ),
     ),
   )
-  return AppNodeBuilder.build(LayerNode.group([Config.node, EventV2.node]), [
+  return AppNodeBuilder.build(LayerNode.group([Config.node, Policy.node]), [
     [Location.node, locationLayer],
     [Global.node, Global.layerWith({ config: globalDirectory })],
-    ...(watcher ? ([[Watcher.node, watcher]] as const) : []),
   ])
 }
 
@@ -56,52 +52,6 @@ const provider = {
 }
 
 describe("Config", () => {
-  it.live("reloads external config and publishes directory updates", () =>
-    Effect.acquireRelease(
-      Effect.promise(() => tmpdir()),
-      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
-    ).pipe(
-      Effect.flatMap((tmp) =>
-        Effect.gen(function* () {
-          const global = path.join(tmp.path, "global")
-          const project = path.join(tmp.path, "project")
-          const file = path.join(global, "opencode.json")
-          yield* Effect.promise(async () => {
-            await fs.mkdir(global, { recursive: true })
-            await fs.mkdir(project, { recursive: true })
-            await fs.writeFile(file, JSON.stringify({ shell: "first" }))
-          })
-          const updates = yield* PubSub.unbounded<Watcher.Update>()
-          const watcher = Layer.succeed(
-            Watcher.Service,
-            Watcher.Service.of({
-              subscribe: () => Stream.fromPubSub(updates),
-            }),
-          )
-
-          return yield* Effect.gen(function* () {
-            const config = yield* Config.Service
-            const events = yield* EventV2.Service
-            const changed = yield* events
-              .subscribe(ConfigSchema.Event.Updated)
-              .pipe(Stream.take(1), Stream.runCollect, Effect.forkScoped)
-            yield* Effect.sleep("10 millis")
-
-            yield* PubSub.publish(updates, {
-              type: "update",
-              path: path.join(global, "commands", "review.md"),
-            } satisfies Watcher.Update)
-            yield* Effect.promise(() => fs.writeFile(file, JSON.stringify({ shell: "second" })))
-            yield* PubSub.publish(updates, { type: "update", path: file } satisfies Watcher.Update)
-
-            expect(yield* Fiber.join(changed)).toHaveLength(1)
-            expect(Config.latest(yield* config.entries(), "shell")).toBe("second")
-          }).pipe(Effect.provide(testLayer(project, global, project, undefined, watcher)))
-        }),
-      ),
-    ),
-  )
-
   it.effect("returns the latest defined scalar from priority-ordered documents", () =>
     Effect.sync(() => {
       const entries = [
@@ -292,72 +242,6 @@ describe("Config", () => {
     ),
   )
 
-  it.live("substitutes environment variables and relative file contents", () =>
-    Effect.acquireUseRelease(
-      Effect.sync(() => {
-        const previous = {
-          token: process.env.OPENCODE_TEST_MCP_TOKEN,
-          missing: process.env.OPENCODE_TEST_MISSING,
-        }
-        process.env.OPENCODE_TEST_MCP_TOKEN = "secret"
-        delete process.env.OPENCODE_TEST_MISSING
-        return previous
-      }),
-      () =>
-        Effect.acquireUseRelease(
-          Effect.promise(() => tmpdir()),
-          (tmp) =>
-            Effect.gen(function* () {
-              yield* Effect.promise(() =>
-                Promise.all([
-                  fs.writeFile(path.join(tmp.path, "token.txt"), 'file\n"token"\n'),
-                  fs.writeFile(
-                    path.join(tmp.path, "opencode.jsonc"),
-                    `{
-                      // Ignored reference: {file:missing.txt}
-                      "username": "user-{env:OPENCODE_TEST_MISSING}",
-                      "mcp": {
-                        "servers": {
-                          "remote": {
-                            "type": "remote",
-                            "url": "https://example.com/mcp",
-                            "headers": {
-                              "Authorization": "Bearer {env:OPENCODE_TEST_MCP_TOKEN}",
-                              "X-Token": "{file:token.txt}"
-                            }
-                          }
-                        }
-                      }
-                    }`,
-                  ),
-                ]),
-              )
-
-              return yield* Effect.gen(function* () {
-                const config = yield* Config.Service
-                const document = (yield* config.entries()).find((entry) => entry.type === "document")
-                expect(document?.info.username).toBe("user-")
-                const remote = document?.info.mcp?.servers?.remote
-                expect(remote?.type).toBe("remote")
-                if (remote?.type !== "remote") return
-                expect(remote.headers).toEqual({
-                  Authorization: "Bearer secret",
-                  "X-Token": 'file\n"token"',
-                })
-              }).pipe(Effect.provide(testLayer(tmp.path)))
-            }),
-          (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
-        ),
-      (previous) =>
-        Effect.sync(() => {
-          if (previous.token === undefined) delete process.env.OPENCODE_TEST_MCP_TOKEN
-          else process.env.OPENCODE_TEST_MCP_TOKEN = previous.token
-          if (previous.missing === undefined) delete process.env.OPENCODE_TEST_MISSING
-          else process.env.OPENCODE_TEST_MISSING = previous.missing
-        }),
-    ),
-  )
-
   it.live("does not load legacy config.json files", () =>
     Effect.acquireRelease(
       Effect.promise(() => tmpdir()),
@@ -390,6 +274,7 @@ describe("Config", () => {
           const file = path.join(tmp.path, "opencode.json")
           const contents = JSON.stringify({
             shell: "/bin/zsh",
+            experimental: { policies: [{ effect: "deny", action: "provider.use", resource: "openai" }] },
             providers: { local: provider },
           })
           yield* Effect.promise(() => fs.writeFile(file, contents))
@@ -400,6 +285,11 @@ describe("Config", () => {
 
             expect(documents[0]?.info.$schema).toBeUndefined()
             expect(documents[0]?.info.shell).toBe("/bin/zsh")
+            expect(documents[0]?.info.experimental?.policies?.[0]).toEqual({
+              effect: "deny",
+              action: "provider.use",
+              resource: "openai",
+            })
             expect(yield* Effect.promise(() => fs.readFile(file, "utf8"))).toBe(contents)
           }).pipe(Effect.provide(testLayer(tmp.path)))
         }),
@@ -833,6 +723,40 @@ describe("Config", () => {
     ),
   )
 
+  it.live("loads policy statements in reverse config order", () =>
+    Effect.acquireRelease(
+      Effect.promise(() => tmpdir()),
+      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
+    ).pipe(
+      Effect.flatMap((tmp) => {
+        const global = path.join(tmp.path, "global")
+        return Effect.gen(function* () {
+          yield* Effect.promise(async () => {
+            await fs.mkdir(global, { recursive: true })
+            await fs.writeFile(
+              path.join(global, "opencode.json"),
+              JSON.stringify({
+                experimental: { policies: [{ effect: "deny", action: "provider.use", resource: "openai" }] },
+              }),
+            )
+            await fs.writeFile(
+              path.join(tmp.path, "opencode.json"),
+              JSON.stringify({
+                experimental: { policies: [{ effect: "allow", action: "provider.use", resource: "openai" }] },
+              }),
+            )
+          })
+
+          return yield* Effect.gen(function* () {
+            const policy = yield* Policy.Service
+
+            expect(yield* policy.evaluate("provider.use", "openai", "allow")).toBe("deny")
+          }).pipe(Effect.provide(testLayer(tmp.path, global)))
+        })
+      }),
+    ),
+  )
+
   it.live("loads global, ancestor, and .opencode configuration up to the project boundary", () =>
     Effect.acquireRelease(
       Effect.promise(() => tmpdir()),