fix(core): close background shutdown races

fix(core): notify background jobs on shutdown
chore: update nix node_modules hashes
2026-08-26 11:36:14 +00:00 · 2026-08-24 11:43:50 -04:00 · 2026-08-24 10:51:23 -04:00 · 2026-08-24 14:29:37 +00:00 · 2026-08-24 19:39:04 +05:30 · 2026-08-24 19:32:38 +05:30
39 changed files with 827 additions and 438 deletions
@@ -1,5 +0,0 @@
---
-"@opencode-ai/plugin": patch
---
-
-Export the Effect runtime used by Effect plugins and safely adapt its tool schemas across host module instances.
@@ -89,6 +89,12 @@ jobs:
        working-directory: packages/codemode
        run: bun run script/publish.ts --dry-run

+      - name: Verify packed workerd SDK
+        if: runner.os == 'Linux'
+        timeout-minutes: 15
+        working-directory: packages/sdk
+        run: bun run verify:package
+
      - name: Verify compiled service lifecycle
        if: always()
        timeout-minutes: 10
@@ -595,8 +595,8 @@
      },
      "peerDependencies": {
        "@opencode-ai/theme": "workspace:*",
-        "@opentui/core": ">=0.5.7",
-        "@opentui/solid": ">=0.5.7",
+        "@opentui/core": ">=0.5.8",
+        "@opentui/solid": ">=0.5.8",
        "solid-js": ">=1.9.0",
      },
      "optionalPeers": [
@@ -1090,9 +1090,9 @@
    "@npmcli/arborist": "9.4.0",
    "@octokit/rest": "22.0.0",
    "@openauthjs/openauth": "0.0.0-20250322224806",
-    "@opentui/core": "0.5.7",
-    "@opentui/keymap": "0.5.7",
-    "@opentui/solid": "0.5.7",
+    "@opentui/core": "0.5.8",
+    "@opentui/keymap": "0.5.8",
+    "@opentui/solid": "0.5.8",
    "@pierre/diffs": "1.2.10",
    "@playwright/test": "1.59.1",
    "@sentry/solid": "10.36.0",
@@ -2218,27 +2218,27 @@

    "@opentelemetry/semantic-conventions": ["@opentelemetry/semantic-conventions@1.43.0", "", {}, "sha512-eSYWTm620tTk45EKSedaUL8MFYI8hW164hIXsgIHyxu3VobUB3fFCu5t0hQby6OoWRPsG1KkKUG2M5UadiLiVg=="],

-    "@opentui/core": ["@opentui/core@0.5.7", "", { "dependencies": { "bun-ffi-structs": "0.3.1", "diff": "9.0.0", "marked": "17.0.1", "string-width": "7.2.0", "strip-ansi": "7.1.2" }, "optionalDependencies": { "@opentui/core-darwin-arm64": "0.5.7", "@opentui/core-darwin-x64": "0.5.7", "@opentui/core-linux-arm64": "0.5.7", "@opentui/core-linux-arm64-musl": "0.5.7", "@opentui/core-linux-x64": "0.5.7", "@opentui/core-linux-x64-musl": "0.5.7", "@opentui/core-win32-arm64": "0.5.7", "@opentui/core-win32-x64": "0.5.7" }, "peerDependencies": { "web-tree-sitter": "0.25.10" } }, "sha512-/XDabTkfBs2Wy2FhlC4jvzbpphYAs4SlnCRKYEvi+metlXNTSAshSs43wqZ9O4IPd0E4EcQqdfeQ0sdc3yPpYw=="],
+    "@opentui/core": ["@opentui/core@0.5.8", "", { "dependencies": { "bun-ffi-structs": "0.3.1", "diff": "9.0.0", "marked": "17.0.1", "string-width": "7.2.0", "strip-ansi": "7.1.2" }, "optionalDependencies": { "@opentui/core-darwin-arm64": "0.5.8", "@opentui/core-darwin-x64": "0.5.8", "@opentui/core-linux-arm64": "0.5.8", "@opentui/core-linux-arm64-musl": "0.5.8", "@opentui/core-linux-x64": "0.5.8", "@opentui/core-linux-x64-musl": "0.5.8", "@opentui/core-win32-arm64": "0.5.8", "@opentui/core-win32-x64": "0.5.8" }, "peerDependencies": { "web-tree-sitter": "0.25.10" } }, "sha512-GbZ+nSLYZqxj2Z5TU19Mx6IsAvVsn2+7WEXz+6OlMGoootvt3TxP3vWwfGI0jWk9qp1ftRlML1JPNEkzy+9I8g=="],

-    "@opentui/core-darwin-arm64": ["@opentui/core-darwin-arm64@0.5.7", "", { "os": "darwin", "cpu": "arm64" }, "sha512-75TDJgFD6hDoCElIX35Yg3TIRF/jhrtVQO/9snhjGuTsZ7bd0W88jUlvSXSNhqB3CX431rwgi47B+asWPDI1lQ=="],
+    "@opentui/core-darwin-arm64": ["@opentui/core-darwin-arm64@0.5.8", "", { "os": "darwin", "cpu": "arm64" }, "sha512-c9Y1FBrSnA4sKUCMETsrLYOmsMTyJae8mU9cE6M4o9rXcr3ZLPA7o9AkPA3S0+kH+kZ0o1Fn0wLejgNxvEp5mg=="],

-    "@opentui/core-darwin-x64": ["@opentui/core-darwin-x64@0.5.7", "", { "os": "darwin", "cpu": "x64" }, "sha512-j+Dwu2yV8zahBFjnVIssYdPrHz/+pkd7xWxI+nHjV41V3c+scvH6vJY1U85VCVaoQs/zCH5xAJbmAAn7Sgeh8g=="],
+    "@opentui/core-darwin-x64": ["@opentui/core-darwin-x64@0.5.8", "", { "os": "darwin", "cpu": "x64" }, "sha512-oZ/6Iz1KN+4volMFKmmvziYJhMgyyJ99LfK1S+uPRyIRqzT3CESoJ58D4h04M1g0dHeHE4PvkU1p3uQKrXiP3g=="],

-    "@opentui/core-linux-arm64": ["@opentui/core-linux-arm64@0.5.7", "", { "os": "linux", "cpu": "arm64" }, "sha512-gWO9NWaivXRPc0XhEbxehj3ApyC1SW8Bf1cnHnME1zhw/EZNCNE3TQHgKwOnnNKtvlbhzLQjOI4OqyPYV8UcEQ=="],
+    "@opentui/core-linux-arm64": ["@opentui/core-linux-arm64@0.5.8", "", { "os": "linux", "cpu": "arm64" }, "sha512-N6i/ocrsTjIq9aUQyrfJkqUo+tc4P5ZS6xz38Cm1MhtDzwBE+CrNIJdHfoJfmRLhJkYHlw6Z0ToICn8ZNj4Bpw=="],

-    "@opentui/core-linux-arm64-musl": ["@opentui/core-linux-arm64-musl@0.5.7", "", { "os": "linux", "cpu": "arm64" }, "sha512-RumSHTasIAWU7jPBKiTuEZG/m+prfQKCHhL3JAQnBLgp7eAB20XZGfSLVWDBgxkyKq1rHCUgLtZktC5ZAyKfTA=="],
+    "@opentui/core-linux-arm64-musl": ["@opentui/core-linux-arm64-musl@0.5.8", "", { "os": "linux", "cpu": "arm64" }, "sha512-eFMB41AWODaYf8PsCx3vtTMX33tFgtSpR9tKNnUErCXlcnZ+WCRHVaJ9F6DrVNX3ir6HmgbwAmaWXvaVF+kLtg=="],

-    "@opentui/core-linux-x64": ["@opentui/core-linux-x64@0.5.7", "", { "os": "linux", "cpu": "x64" }, "sha512-fXDmrIlfp9xaoVkk3BNn3yUO/b7plBSOfUh2oWOezRA6E/g5z+hTO1alGFQCy+VV+1kfA6iuYadAww0xNtfACg=="],
+    "@opentui/core-linux-x64": ["@opentui/core-linux-x64@0.5.8", "", { "os": "linux", "cpu": "x64" }, "sha512-/2QM7/wMnML/sxchzbwgoU5tUu/7k836/kSOKMti8opjuecv1K+WWNKGXufhTNeRcXFZaba5rsCdYrf3VqnVsQ=="],

-    "@opentui/core-linux-x64-musl": ["@opentui/core-linux-x64-musl@0.5.7", "", { "os": "linux", "cpu": "x64" }, "sha512-1opDV+W7C1F4iWivCNKuYl5Hen+IeFXAuUPm3hVyN0UtdcP8LESpFJTr8QRwHpGSE9Jz1K2g2S2ipzI3u5mhgw=="],
+    "@opentui/core-linux-x64-musl": ["@opentui/core-linux-x64-musl@0.5.8", "", { "os": "linux", "cpu": "x64" }, "sha512-YXo+qUHYmep2uvv3ECvTeqr10aD7+lBsavYmsTLBzS5hHabbzlQ10oX/99nIRPC3Au1BMWD6d6zQP5czPx23eg=="],

-    "@opentui/core-win32-arm64": ["@opentui/core-win32-arm64@0.5.7", "", { "os": "win32", "cpu": "arm64" }, "sha512-gbiZUyttjq8s+bsnsaopygWN7LTS/RyzD6GOmpgOB2TVitvo0P6mxM+AebBGuu/7xri17Rqaxf3uqrgdKiJAeg=="],
+    "@opentui/core-win32-arm64": ["@opentui/core-win32-arm64@0.5.8", "", { "os": "win32", "cpu": "arm64" }, "sha512-7qBdhEAlh4tLFzW7nWLPlREtNiF6NZMDMi+4uDpUlAMhRavLr6wjcIcgfhNAF/puq06DjuZlPTwaMCgB3qOuwA=="],

-    "@opentui/core-win32-x64": ["@opentui/core-win32-x64@0.5.7", "", { "os": "win32", "cpu": "x64" }, "sha512-bDwon45lUxbV3rMcekTCg4mXcBu9uhdG6HLeLK5TVZf05/h+Ibkf2UeZ8A2jjQt+MK6jpYmxWwDCVCTzZ7EU7Q=="],
+    "@opentui/core-win32-x64": ["@opentui/core-win32-x64@0.5.8", "", { "os": "win32", "cpu": "x64" }, "sha512-Z76YaTKnmRDSHKdKa7iTBCXBQdInQLq7UG3qIE84nvyHCDtkhYtPWOaCzDisSgXC8Y6hJt6NiFbaNjQyxPkfpQ=="],

-    "@opentui/keymap": ["@opentui/keymap@0.5.7", "", { "dependencies": { "@opentui/core": "0.5.7" }, "peerDependencies": { "@opentui/react": "0.5.7", "@opentui/solid": "0.5.7", "react": ">=19.2.0", "solid-js": "1.9.12" }, "optionalPeers": ["@opentui/react", "@opentui/solid", "react", "solid-js"] }, "sha512-BqfSbjlLuctnew2aoPPdK3wpzJfEPp7ttLBkTu1wJTkps9AcfUgXqwloqvY4DUKjUBNFYYEpU/0CPxI4Blj4MA=="],
+    "@opentui/keymap": ["@opentui/keymap@0.5.8", "", { "dependencies": { "@opentui/core": "0.5.8" }, "peerDependencies": { "@opentui/react": "0.5.8", "@opentui/solid": "0.5.8", "react": ">=19.2.0", "solid-js": "1.9.12" }, "optionalPeers": ["@opentui/react", "@opentui/solid", "react", "solid-js"] }, "sha512-KQHKRnLZroSZIbHmGmSeDPsXi7Yykdu9x9ACmDzBFkgPGx0EIuXHqRcmrqmUaX485MQEZuCD9t6FdDsOMGyIFg=="],

-    "@opentui/solid": ["@opentui/solid@0.5.7", "", { "dependencies": { "@babel/core": "7.28.0", "@babel/preset-typescript": "7.27.1", "@opentui/core": "0.5.7", "babel-plugin-module-resolver": "5.0.2", "babel-preset-solid": "1.9.12", "entities": "7.0.1", "s-js": "^0.4.9" }, "peerDependencies": { "solid-js": "1.9.12" } }, "sha512-qrKAZd9xt4D67LXZUARg1Aw0dwEWi29GyOxpM6abqmyExGPMS7jih5Z9oMQJ9EXsouDKpW7Mejjq7WbX2AaecQ=="],
+    "@opentui/solid": ["@opentui/solid@0.5.8", "", { "dependencies": { "@babel/core": "7.28.0", "@babel/preset-typescript": "7.27.1", "@opentui/core": "0.5.8", "babel-plugin-module-resolver": "5.0.2", "babel-preset-solid": "1.9.12", "entities": "7.0.1", "s-js": "^0.4.9" }, "peerDependencies": { "solid-js": "1.9.12" } }, "sha512-L0NxuAU8XT+jlE5G90oA3kspqkof48b0hmzi5XLw+1gxnkxrkTb+YfKys+GzVK4UqhgwY9aW+TeDfrKbnfwCMw=="],

    "@oslojs/asn1": ["@oslojs/asn1@1.0.0", "", { "dependencies": { "@oslojs/binary": "1.0.0" } }, "sha512-zw/wn0sj0j0QKbIXfIlnEcTviaCzYOY3V5rAyjR6YtOByFtJiT574+8p9Wlach0lZH9fddD4yb9laEAIl4vXQA=="],

@@ -1,8 +1,8 @@
 {
  "nodeModules": {
-    "x86_64-linux": "sha256-LvDHCOm8OAZfvb0I0L6AbdOevRoQmEJnnqrSgAiNHv8=",
-    "aarch64-linux": "sha256-O0L0iHjb4cwl9xWHIna8VFHyQzoAKzfY8oMpVNayMOg=",
-    "aarch64-darwin": "sha256-ETP8FE71NqufYDUbR7tBdsMEOVQ44wLmsZBeZiSRBRY=",
-    "x86_64-darwin": "sha256-WUcoLldDriT3QxcdlnBQhuPrxDNub0EDvvZXk/pDMpY="
+    "x86_64-linux": "sha256-phyTF0/jQZ3L0B66PSLdpH//kyPc1M6j5a40wCSx7TA=",
+    "aarch64-linux": "sha256-1Zb/Is0ujIslCbPPusAVhcuzAPyIauQyeIIRRGtzpAk=",
+    "aarch64-darwin": "sha256-DDsVm7z+PSDry6QqrwVDFSmEnq6jIKb709Y4ymAv9f8=",
+    "x86_64-darwin": "sha256-S+5LI2J+WRhRP7jp2PAv6AesXk238wEYoyIO1oKdF3w="
  }
 }
@@ -49,9 +49,9 @@
      "@octokit/rest": "22.0.0",
      "@hono/standard-validator": "0.2.0",
      "@hono/zod-validator": "0.4.2",
-      "@opentui/core": "0.5.7",
-      "@opentui/keymap": "0.5.7",
-      "@opentui/solid": "0.5.7",
+      "@opentui/core": "0.5.8",
+      "@opentui/keymap": "0.5.8",
+      "@opentui/solid": "0.5.8",
      "@tanstack/solid-virtual": "3.13.37",
      "@shikijs/stream": "4.2.0",
      "@standard-schema/spec": "1.1.0",
@@ -1,7 +1,14 @@
-import { Argument, Flag } from "effect/unstable/cli"
+import { Argument, Flag, GlobalFlag } from "effect/unstable/cli"
 import { Schema } from "effect"
 import { Spec } from "../framework/spec"

+export const PrintLogs = GlobalFlag.setting("print-logs")({
+  flag: Flag.boolean("print-logs").pipe(
+    Flag.withDescription("Print logs to stderr (server logs require --standalone)"),
+    Flag.withDefault(false),
+  ),
+})
+
 declare const OPENCODE_CLI_NAME: string | undefined

 const ServerParams = {
@@ -1,5 +1,6 @@
 import { Effect, FileSystem, Scope } from "effect"
 import { Command } from "effect/unstable/cli"
+import { PrintLogs } from "../commands/commands"
 import { Spec } from "./spec"
 import { Global } from "@opencode-ai/util/global"
 import { Updater } from "../services/updater"
@@ -77,7 +78,11 @@ export function handlers<const Root extends Spec.Any>(root: Root, handlers: Hand
 }

 export function run(commands: Spec.Any, handlers: ReadonlyArray<LazyHandler>, options: { readonly version: string }) {
-  return Command.run(provide(commands, handlers), options) as Effect.Effect<void, unknown, Command.Environment>
+  return Command.run(provide(commands, handlers).pipe(Command.withGlobalFlags([PrintLogs])), options) as Effect.Effect<
+    void,
+    unknown,
+    Command.Environment
+  >
 }

 function provide(node: Spec.Any, handlers: ReadonlyArray<LazyHandler>): ProvidedCommand {
@@ -86,6 +91,7 @@ function provide(node: Spec.Any, handlers: ReadonlyArray<LazyHandler>): Provided
    ? node.spec.pipe(
        Command.withHandler((input) =>
          Effect.gen(function* () {
+            if (yield* PrintLogs) process.env.OPENCODE_PRINT_LOGS = "1"
            const module = yield* Effect.promise(handler.load)
            return yield* module.default(input)
          }),
@@ -3,16 +3,12 @@ import {
  Command,
  Connection,
  Credential,
-  Effect,
  Integration,
-  Mcp,
  Model,
  Plugin,
  Provider,
  Reference,
-  Schema,
  Skill,
-  WebSearch,
 } from "@opencode-ai/plugin/effect"
 import { Tool } from "@opencode-ai/schema/tool"

@@ -22,15 +18,11 @@ const key = Symbol.for("opencode.plugin.v2.effect")
  Command,
  Connection,
  Credential,
-  Effect,
  Integration,
-  Mcp,
  Model,
  Plugin,
  Provider,
  Reference,
-  Schema,
  Skill,
-  WebSearch,
  Tool: { Error: Tool.Error },
 }
@@ -4,13 +4,11 @@ import {
  Connection,
  Credential,
  Integration,
-  Mcp,
  Model,
  Plugin,
  Provider,
  Reference,
  Skill,
-  WebSearch,
 } from "@opencode-ai/plugin"

 const key = Symbol.for("opencode.plugin.v2.promise")
@@ -20,11 +18,9 @@ const key = Symbol.for("opencode.plugin.v2.promise")
  Connection,
  Credential,
  Integration,
-  Mcp,
  Model,
  Plugin,
  Provider,
  Reference,
  Skill,
-  WebSearch,
 }
@@ -27,7 +27,7 @@ function command(password: string, options: Options) {
    // The server treats EOF on this pipe as the end of its ownership lease.
    // The OS closes it even when the TUI is killed before Effect finalizers run.
    stdin: "pipe",
-    stderr: "ignore",
+    stderr: process.env.OPENCODE_PRINT_LOGS === "1" ? "inherit" : "ignore",
    killSignal: "SIGTERM",
    forceKillAfter: "3 seconds",
  })
@@ -127,17 +127,14 @@ export const Command = sdk.Command
 export const Connection = sdk.Connection
 export const Credential = sdk.Credential
 export const Integration = sdk.Integration
-export const Mcp = sdk.Mcp
 export const Model = sdk.Model
 export const Plugin = sdk.Plugin
 export const Provider = sdk.Provider
 export const Reference = sdk.Reference
-export const Skill = sdk.Skill
-export const WebSearch = sdk.WebSearch`
+export const Skill = sdk.Skill`
  const effectModule = promiseModule
    .replace("opencode.plugin.v2.promise", "opencode.plugin.v2.effect")
    .replace("Promise plugin", "Effect plugin")
-    .concat("\nexport const Effect = sdk.Effect\nexport const Schema = sdk.Schema")
  const promisePluginModule = `const sdk = globalThis[Symbol.for("opencode.plugin.v2.promise")]
 if (!sdk) throw new Error("OpenCode Promise plugin SDK is unavailable")
 export const define = sdk.Plugin.define`
@@ -32,3 +32,38 @@ const result = await Bun.build({
  },
 })
 if (!result.success) throw new AggregateError(result.logs, "Failed to build Core")
+
+// Bun's Node target eagerly creates its shared require helper, so every split
+// entry evaluates import.meta.url even when it never requires a module. Keep
+// the helper lazy until Bun stops hoisting it into workerd-reachable chunks.
+// https://github.com/oven-sh/bun/issues/12615
+const eagerRequire = "var __require = /* @__PURE__ */ createRequire(import.meta.url);"
+const lazyRequire = `var __require = (specifier) => createRequire(import.meta.url ?? "file:///worker.js")(specifier);
+__require.resolve = (specifier, options) => createRequire(import.meta.url ?? "file:///worker.js").resolve(specifier, options);`
+const rewritten = await Promise.all(
+  result.outputs.map(async (output) => {
+    if (!output.path.endsWith(".js")) return false
+    const source = await output.text()
+
+    const generatedUses = source
+      .replace(/import\s*\{[^}]*\b__require\b[^}]*\}\s*from\s*["'][^"']+["'];/g, "")
+      .replace(/export\s*\{[^}]*\b__require\b[^}]*\};/g, "")
+      .replace(eagerRequire, "")
+    if (/\bnew\s+__require\s*\(/.test(generatedUses))
+      throw new Error(`Unsupported generated require constructor in ${output.path}`)
+    const unsupported = generatedUses
+      .replace(/\b__require\.resolve\s*\(/g, "")
+      .replace(/\b__require\s*\(/g, "")
+    if (/\b__require\b/.test(unsupported)) throw new Error(`Unsupported generated require usage in ${output.path}`)
+
+    if (!source.includes(eagerRequire)) return false
+    if (source.indexOf(eagerRequire) !== source.lastIndexOf(eagerRequire))
+      throw new Error(`Multiple eager require helpers in ${output.path}`)
+    const rewrittenSource = source.replace(eagerRequire, lazyRequire)
+    if (rewrittenSource.includes(eagerRequire)) throw new Error(`Failed to rewrite eager require helper in ${output.path}`)
+    await Bun.write(output.path, rewrittenSource)
+    return true
+  }),
+)
+if (rewritten.filter(Boolean).length !== 1)
+  throw new Error("Expected exactly one eager require helper; Bun may have fixed #12615 and made this shim removable")
@@ -19,10 +19,17 @@ export type Info = {
  metadata?: Record<string, unknown>
 }

+export type SettledInfo = Info & {
+  status: Exclude<Status, "running">
+  completed_at: number
+}
+
 type Active = {
  info: Info
  done: Deferred.Deferred<Info>
  backgrounded: Deferred.Deferred<Info>
+  onBackgroundSettled?: (info: SettledInfo) => Effect.Effect<void>
+  backgroundNotification?: Deferred.Deferred<void>
  scope: Scope.Closeable
  token: object
  blockingSessions: Map<SessionSchema.ID, number>
@@ -31,18 +38,29 @@ type Active = {

 type State = {
  jobs: SynchronizedRef.SynchronizedRef<Map<string, Active>>
+  notifications: Set<Deferred.Deferred<void>>
  scope: Scope.Scope
+  shuttingDown: boolean
+}
+
+type Notification = {
+  jobID: string
+  effect: Effect.Effect<void>
+  done: Deferred.Deferred<void>
 }

 type FinishResult = {
  info?: Info
  done?: Deferred.Deferred<Info>
+  notify?: Notification
  scope?: Scope.Closeable
 }

 type BackgroundResult = {
  info?: Info
  backgrounded?: Deferred.Deferred<Info>
+  notify?: Notification
+  cancel?: { id: string; token: object }
 }

 type StartResult = { info: Info } | { info: Info; scope: Scope.Closeable; token: object }
@@ -64,6 +82,7 @@ export type StartInput = {
  title?: string
  metadata?: Record<string, unknown>
  run: Effect.Effect<string, unknown>
+  onBackgroundSettled?: (info: SettledInfo) => Effect.Effect<void>
 }

 export type WaitInput = {
@@ -96,6 +115,8 @@ export interface Interface {
  readonly background: (id: string) => Effect.Effect<Info | undefined>
  readonly backgroundAll: (input: BackgroundAllInput) => Effect.Effect<Info[]>
  readonly cancel: (id: string) => Effect.Effect<Info | undefined>
+  /** Cancels detached work and awaits its terminal callbacks before application teardown. */
+  readonly shutdown: Effect.Effect<void>
 }

 export class Service extends Context.Service<Service, Interface>()("@opencode/Job") {}
@@ -125,6 +146,23 @@ function decrementSession(input: Map<SessionSchema.ID, number>, sessionID: Sessi
  return next
 }

+function clearNotification(job: Active) {
+  if (!job.onBackgroundSettled && !job.backgroundNotification) return job
+  return { ...job, onBackgroundSettled: undefined, backgroundNotification: undefined }
+}
+
+function claimNotification(job: Active, info: SettledInfo) {
+  if (!job.isBackgrounded || !job.onBackgroundSettled || !job.backgroundNotification) return { job }
+  return {
+    job: clearNotification(job),
+    notify: {
+      jobID: info.id,
+      effect: job.onBackgroundSettled(info),
+      done: job.backgroundNotification,
+    },
+  }
+}
+
 /**
 * Makes one scoped, process-local registry. Entries are intentionally not
 * durable: process restart or owner-scope closure loses status and interrupts
@@ -135,9 +173,28 @@ function decrementSession(input: Map<SessionSchema.ID, number>, sessionID: Sessi
 export const make = Effect.gen(function* () {
  const state: State = {
    jobs: yield* SynchronizedRef.make(new Map()),
+    notifications: new Set(),
    scope: yield* Scope.Scope,
+    shuttingDown: false,
  }

+  const notify = Effect.fnUntraced(function* (notification: Notification) {
+    yield* notification.effect.pipe(
+      Effect.catchCause((cause) =>
+        Effect.logError("Failed to notify background Job settlement", { jobID: notification.jobID, cause }),
+      ),
+      Effect.ensuring(
+        Effect.sync(() => state.notifications.delete(notification.done)).pipe(
+          Effect.andThen(Deferred.succeed(notification.done, undefined)),
+        ),
+      ),
+    )
+  })
+
+  const launchNotification = Effect.fnUntraced(function* (notification: Notification) {
+    yield* notify(notification).pipe(Effect.forkIn(state.scope, { startImmediately: true }))
+  })
+
  const settle = Effect.fnUntraced(function* (id: string, token: object, exit: Exit.Exit<string, unknown>) {
    const completed_at = yield* Clock.currentTimeMillis
    const result = yield* SynchronizedRef.modify(state.jobs, (jobs): readonly [FinishResult, Map<string, Active>] => {
@@ -150,22 +207,37 @@ export const make = Effect.gen(function* () {
        : Cause.hasInterruptsOnly(exit.cause)
          ? "cancelled"
          : "error"
+      const info = {
+        ...job.info,
+        status,
+        completed_at,
+        ...(Exit.isSuccess(exit) ? { output: exit.value } : {}),
+        ...(Exit.isFailure(exit) ? { error: errorText(Cause.squash(exit.cause)) } : {}),
+        ...(job.info.metadata ? { metadata: { ...job.info.metadata } } : {}),
+      } satisfies SettledInfo
      const next = {
        ...job,
        blockingSessions: new Map<SessionSchema.ID, number>(),
-        info: {
-          ...job.info,
-          status,
-          completed_at,
-          ...(Exit.isSuccess(exit) ? { output: exit.value } : {}),
-          ...(Exit.isFailure(exit) ? { error: errorText(Cause.squash(exit.cause)) } : {}),
-        },
+        info,
      }
-      return [{ info: snapshot(next), done: job.done, scope: job.scope }, new Map(jobs).set(id, next)]
+      const notification = claimNotification(next, info)
+      return [
+        {
+          info,
+          done: job.done,
+          notify: notification.notify,
+          scope: job.scope,
+        },
+        new Map(jobs).set(id, notification.job),
+      ]
    })
    if (result.info && result.done) yield* Deferred.succeed(result.done, result.info).pipe(Effect.ignore)
+    if (result.notify) yield* launchNotification(result.notify)
    if (result.scope) {
-      yield* Scope.close(result.scope, Exit.void).pipe(Effect.forkIn(state.scope, { startImmediately: true }))
+      yield* Scope.close(result.scope, Exit.void).pipe(
+        Effect.catchCause((cause) => Effect.logError("Failed to close settled Job scope", { id, cause })),
+        Effect.forkIn(state.scope, { startImmediately: true }),
+      )
    }
    return result.info
  })
@@ -197,15 +269,43 @@ export const make = Effect.gen(function* () {
      Effect.gen(function* () {
        const id = input.id ?? Identifier.ascending("job")
        const started_at = yield* Clock.currentTimeMillis
-        const done = yield* Deferred.make<Info>()
-        const backgrounded = yield* Deferred.make<Info>()
        const result = yield* SynchronizedRef.modifyEffect(
          state.jobs,
          Effect.fnUntraced(function* (jobs) {
+            if (state.shuttingDown)
+              return [
+                {
+                  info: {
+                    id,
+                    type: input.type,
+                    title: input.title,
+                    status: "cancelled",
+                    started_at,
+                    completed_at: started_at,
+                    metadata: input.metadata,
+                  },
+                },
+                jobs,
+              ] as readonly [StartResult, Map<string, Active>]
            const existing = jobs.get(id)
            if (existing?.info.status === "running") {
-              return [{ info: snapshot(existing) }, jobs] as readonly [StartResult, Map<string, Active>]
+              if (existing.onBackgroundSettled || !input.onBackgroundSettled)
+                return [{ info: snapshot(existing) }, jobs] as readonly [StartResult, Map<string, Active>]
+              const backgroundNotification = yield* Deferred.make<void>()
+              const adopted = {
+                ...existing,
+                onBackgroundSettled: input.onBackgroundSettled,
+                backgroundNotification,
+              }
+              if (adopted.isBackgrounded) state.notifications.add(backgroundNotification)
+              return [{ info: snapshot(adopted) }, new Map(jobs).set(id, adopted)] as readonly [
+                StartResult,
+                Map<string, Active>,
+              ]
            }
+            const done = yield* Deferred.make<Info>()
+            const backgrounded = yield* Deferred.make<Info>()
+            const backgroundNotification = input.onBackgroundSettled ? yield* Deferred.make<void>() : undefined
            const scope = yield* Scope.fork(state.scope, "parallel")
            const token = {}
            const job = {
@@ -219,6 +319,8 @@ export const make = Effect.gen(function* () {
              },
              done,
              backgrounded,
+              onBackgroundSettled: input.onBackgroundSettled,
+              backgroundNotification,
              scope,
              token,
              blockingSessions: new Map<SessionSchema.ID, number>(),
@@ -250,7 +352,11 @@ export const make = Effect.gen(function* () {
  const removeBlock = Effect.fnUntraced(function* (input: BlockInput) {
    yield* SynchronizedRef.update(state.jobs, (jobs) => {
      const job = jobs.get(input.id)
-      if (!job || job.info.status !== "running" || job.isBackgrounded) return jobs
+      if (!job || job.isBackgrounded) return jobs
+      if (job.info.status !== "running") {
+        if (!job.onBackgroundSettled) return jobs
+        return new Map(jobs).set(input.id, clearNotification(job))
+      }
      return new Map(jobs).set(input.id, {
        ...job,
        blockingSessions: decrementSession(job.blockingSessions, input.sessionID),
@@ -262,7 +368,11 @@ export const make = Effect.gen(function* () {
    const result = yield* SynchronizedRef.modify(state.jobs, (jobs): readonly [BlockStart, Map<string, Active>] => {
      const job = jobs.get(input.id)
      if (!job) return [{ type: "missing" }, jobs]
-      if (job.info.status !== "running") return [{ type: "finished", info: snapshot(job) }, jobs]
+      if (job.info.status !== "running")
+        return [
+          { type: "finished", info: snapshot(job) },
+          job.onBackgroundSettled ? new Map(jobs).set(input.id, clearNotification(job)) : jobs,
+        ]
      if (job.isBackgrounded) return [{ type: "backgrounded", info: snapshot(job) }, jobs]
      return [
        { type: "wait", wait: { done: job.done, backgrounded: job.backgrounded } },
@@ -286,16 +396,38 @@ export const make = Effect.gen(function* () {
      state.jobs,
      (jobs): readonly [BackgroundResult, Map<string, Active>] => {
        const job = jobs.get(id)
-        if (!job || job.info.status !== "running") return [{}, jobs]
+        if (!job) return [{}, jobs]
+        if (state.shuttingDown) {
+          if (job.info.status === "running") return [{ info: snapshot(job), cancel: { id, token: job.token } }, jobs]
+          return [
+            { info: snapshot(job) },
+            job.onBackgroundSettled ? new Map(jobs).set(id, clearNotification(job)) : jobs,
+          ]
+        }
+        if (job.info.status !== "running") {
+          if (!job.onBackgroundSettled || !job.backgroundNotification) return [{}, jobs]
+          const info = {
+            ...snapshot(job),
+            status: job.info.status,
+            completed_at: job.info.completed_at ?? job.info.started_at,
+          } satisfies SettledInfo
+          const next = { ...job, info, isBackgrounded: true }
+          state.notifications.add(job.backgroundNotification)
+          const notification = claimNotification(next, info)
+          return [{ info, notify: notification.notify }, new Map(jobs).set(id, notification.job)]
+        }
        if (job.isBackgrounded) return [{ info: snapshot(job) }, jobs]
        const next = {
          ...job,
          isBackgrounded: true,
          blockingSessions: new Map<SessionSchema.ID, number>(),
        }
+        if (job.backgroundNotification) state.notifications.add(job.backgroundNotification)
        return [{ info: snapshot(next), backgrounded: job.backgrounded }, new Map(jobs).set(id, next)]
      },
    )
+    if (result.cancel) return yield* cancelGeneration(result.cancel.id, result.cancel.token)
+    if (result.notify) yield* launchNotification(result.notify)
    if (result.info && result.backgrounded)
      yield* Deferred.succeed(result.backgrounded, result.info).pipe(Effect.ignore)
    return result.info
@@ -305,6 +437,7 @@ export const make = Effect.gen(function* () {
    const result = yield* SynchronizedRef.modify(
      state.jobs,
      (jobs): readonly [BackgroundResult[], Map<string, Active>] => {
+        if (state.shuttingDown) return [[], jobs]
        const results: BackgroundResult[] = []
        const next = new Map(jobs)
        for (const [id, job] of jobs) {
@@ -317,6 +450,7 @@ export const make = Effect.gen(function* () {
            isBackgrounded: true,
            blockingSessions: new Map<SessionSchema.ID, number>(),
          }
+          if (job.backgroundNotification) state.notifications.add(job.backgroundNotification)
          results.push({ info: snapshot(updated), backgrounded: job.backgrounded })
          next.set(id, updated)
        }
@@ -331,29 +465,65 @@ export const make = Effect.gen(function* () {
    return result.flatMap((item) => (item.info ? [item.info] : []))
  })

-  const cancel: Interface["cancel"] = Effect.fn("Job.cancel")(function* (id) {
+  const cancelGeneration = Effect.fnUntraced(function* (id: string, token?: object) {
    const completed_at = yield* Clock.currentTimeMillis
    const result = yield* SynchronizedRef.modify(state.jobs, (jobs): readonly [FinishResult, Map<string, Active>] => {
      const job = jobs.get(id)
      if (!job) return [{}, jobs]
+      if (token && job.token !== token) return [{}, jobs]
      if (job.info.status !== "running") return [{ info: snapshot(job) }, jobs]
+      const info = {
+        ...job.info,
+        status: "cancelled" as const,
+        completed_at,
+        ...(job.info.metadata ? { metadata: { ...job.info.metadata } } : {}),
+      } satisfies SettledInfo
      const next = {
        ...job,
        blockingSessions: new Map<SessionSchema.ID, number>(),
-        info: {
-          ...job.info,
-          status: "cancelled" as const,
-          completed_at,
-        },
+        info,
      }
-      return [{ info: snapshot(next), done: job.done, scope: job.scope }, new Map(jobs).set(id, next)]
+      const notification = claimNotification(next, info)
+      return [
+        {
+          info,
+          done: job.done,
+          notify: notification.notify,
+          scope: job.scope,
+        },
+        new Map(jobs).set(id, notification.notify ? notification.job : clearNotification(notification.job)),
+      ]
    })
+    if (result.scope)
+      yield* Scope.close(result.scope, Exit.void).pipe(
+        Effect.catchCause((cause) => Effect.logError("Failed to close cancelled Job scope", { id, cause })),
+      )
    if (result.info && result.done) yield* Deferred.succeed(result.done, result.info).pipe(Effect.ignore)
-    if (result.scope) yield* Scope.close(result.scope, Exit.void)
+    if (result.notify) yield* launchNotification(result.notify)
    return result.info
  })

-  return Service.of({ get, start, wait, block, background, backgroundAll, cancel })
+  const cancel: Interface["cancel"] = Effect.fn("Job.cancel")((id) => cancelGeneration(id))
+
+  const shutdown: Interface["shutdown"] = Effect.gen(function* () {
+    const drain = yield* SynchronizedRef.modify(state.jobs, (jobs) => {
+      state.shuttingDown = true
+      return [
+        {
+          running: Array.from(jobs.values()).filter((job) => job.info.status === "running" && job.isBackgrounded),
+          notifications: Array.from(state.notifications),
+        },
+        jobs,
+      ] as const
+    })
+    yield* Effect.forEach(drain.running, (job) => cancelGeneration(job.info.id, job.token), {
+      concurrency: "unbounded",
+      discard: true,
+    })
+    yield* Effect.forEach(drain.notifications, Deferred.await, { concurrency: "unbounded", discard: true })
+  }).pipe(Effect.withSpan("Job.shutdown"))
+
+  return Service.of({ get, start, wait, block, background, backgroundAll, cancel, shutdown })
 })

 const layer = Layer.effect(Service, make)
@@ -572,7 +572,7 @@ function cacheKey(source: string) {
 }

 export function bodyDigest(text: string) {
-  return new Bun.CryptoHasher("sha256").update(text).digest("hex")
+  return Hash.sha256(text)
 }

 export const layer = (options?: Options) =>
@@ -156,9 +156,13 @@ export const providerLayerWithCell = (cell: Cell) =>
      }
      cell.runtime = runtime
      yield* Effect.addFinalizer(() =>
-        Effect.sync(() => {
-          if (cell.runtime === runtime) cell.runtime = undefined
-        }),
+        jobs.shutdown.pipe(
+          Effect.ensuring(
+            Effect.sync(() => {
+              if (cell.runtime === runtime) cell.runtime = undefined
+            }),
+          ),
+        ),
      )
    }),
  )
@@ -2,7 +2,6 @@ export * as PluginSupervisor from "./supervisor.js"
 export { Service, type Interface } from "./supervisor-service.js"

 import type { Plugin as PluginDefinition } from "@opencode-ai/plugin/effect/plugin"
-import { instanceSafeContext } from "@opencode-ai/plugin/effect/tool-schema"
 import { Event } from "@opencode-ai/schema/config"
 import { Cause, Effect, Latch, Layer, Schema, Stream } from "effect"
 import path from "path"
@@ -127,7 +126,7 @@ const load = Effect.fn("PluginSupervisor.load")(function* (
    tui: plugin.tui,
    version: JSON.stringify(operation),
    source: pluginSource(operation.target),
-    effect: (host) => plugin.effect(instanceSafeContext({ ...host, options: operation.options })),
+    effect: (host) => plugin.effect({ ...host, options: operation.options }),
  } satisfies Plugin.Versioned
 })

@@ -1,2 +1,2 @@
-export * as SessionMessage from "./message.js"
+export * as SessionMessage from "@opencode-ai/schema/session-message"
 export * from "@opencode-ai/schema/session-message"
@@ -1,4 +1,4 @@
-export * as SessionSchema from "./schema.js"
+export * as SessionSchema from "@opencode-ai/schema/session"

 import { Session } from "@opencode-ai/schema/session"

@@ -49,7 +49,12 @@ type ToolRow = {
  duration: number | null
 }

-type ToolSummaryRow = { status: string | null; count: number }
+type ToolSummaryRow = {
+  calls: number
+  succeeded: number
+  failed: number
+  unfinished: number
+}

 type ModelAggregate = {
  model: Model.Ref
@@ -188,25 +193,38 @@ export const get = Effect.fn("SessionStats.get")(function* (input: Input = {}) {
      (range) => {
        if (toolMode === "summary")
          return db
-            .all<ToolSummaryRow>(
+            .get<ToolSummaryRow>(
              sql`
-            SELECT json_extract(content.value, '$.state.status') AS status, count(*) AS count
-            FROM ${SessionMessageTable} AS message
-            JOIN ${SessionTable} AS session ON session.id = message.session_id,
-              json_each(message.data, '$.content') AS content
-            WHERE message.type = 'assistant'
-              AND message.time_created >= ${range.from}
-              AND message.time_created < ${range.to}
-              AND (session.fork_session_id IS NULL OR message.time_created >= session.time_created)
-              AND json_extract(content.value, '$.type') = 'tool'
-              ${project}
-            GROUP BY status
+            WITH calls AS MATERIALIZED (
+              SELECT json_extract(content.value, '$.state.status') AS status
+              FROM ${SessionMessageTable} AS message
+              JOIN ${SessionTable} AS session ON session.id = message.session_id,
+                json_each(message.data, '$.content') AS content
+              WHERE message.type = 'assistant'
+                AND message.time_created >= ${range.from}
+                AND message.time_created < ${range.to}
+                AND (session.fork_session_id IS NULL OR message.time_created >= session.time_created)
+                AND json_extract(content.value, '$.type') = 'tool'
+                ${project}
+            )
+            SELECT
+              count(*) AS calls,
+              count(*) FILTER (WHERE status = 'completed') AS succeeded,
+              count(*) FILTER (WHERE status = 'error') AS failed,
+              count(*) FILTER (WHERE status IS NULL OR status NOT IN ('completed', 'error')) AS unfinished
+            FROM calls
          `,
            )
            .pipe(
              Effect.orDie,
-              Effect.tap((rows) =>
-                Effect.sync(() => rows.forEach((row) => addToolStatus(toolTotals, row.status, row.count))),
+              Effect.tap((row) =>
+                Effect.sync(() => {
+                  if (!row) return
+                  toolTotals.calls += row.calls
+                  toolTotals.succeeded += row.succeeded
+                  toolTotals.failed += row.failed
+                  toolTotals.unfinished += row.unfinished
+                }),
              ),
              Effect.asVoid,
            )
@@ -3,9 +3,10 @@ export * as ShellTool from "./shell.js"
 import path from "path"
 import { ToolFailure } from "@opencode-ai/ai"
 import type { Context as PluginContext } from "@opencode-ai/plugin/effect/plugin"
-import { Deferred, Effect, Schema, Scope } from "effect"
+import { Deferred, Effect, Schema } from "effect"
 import { Config } from "../../config.js"
 import { Environment } from "../../environment/index.js"
+import { Job } from "../../job.js"
 import { LocationMutation } from "../../location-mutation.js"
 import { Permission } from "../../permission.js"
 import { PluginRuntime } from "../../plugin/runtime.js"
@@ -105,62 +106,49 @@ export const Plugin = {
  id: "opencode.tool.shell",
  effect: Effect.fn("ShellTool.Plugin")(function* (ctx: PluginContext) {
    const runtime = yield* PluginRuntime.Service
-    const scope = yield* Scope.Scope
    const environment = yield* Environment.Service
    const mutation = yield* LocationMutation.Service
    const shell = yield* Shell.Service
    const permission = yield* Permission.Service
    const config = yield* Config.Service

-    const notifyWhenDone = Effect.fn("ShellTool.notifyWhenDone")(function* (
-      sessionID: SessionSchema.ID,
-      id: string,
-      shellID: string,
-      command: string,
-      settled: Deferred.Deferred<Output>,
+    const notifyWhenSettled = Effect.fn("ShellTool.notifyWhenSettled")(function* (
+      input: {
+        sessionID: SessionSchema.ID
+        id: string
+        shellID: string
+        command: string
+        settled: Deferred.Deferred<Output>
+      },
+      info: Job.SettledInfo,
    ) {
-      yield* runtime.job.wait({ id: id }).pipe(
-        Effect.flatMap((result) =>
-          Effect.gen(function* () {
-            const info = result.info
-            if (!info) return
-            const state =
-              info.status === "completed"
-                ? "completed"
-                : info.status === "error"
-                  ? "error"
-                  : info.status === "cancelled"
-                    ? "cancelled"
-                    : undefined
-            if (state === undefined) return
-            const output = state === "completed" ? yield* Deferred.await(settled) : undefined
-            const text = output
-              ? resultMessages(output).join("\n\n")
-              : state === "error"
-                ? (info.error ?? "Command failed")
-                : "Command cancelled"
-            yield* runtime.session.synthetic({
-              sessionID,
-              text: `<shell id="${id}" state="${state}" command="${command}">\n${text}\n</shell>`,
-              description: command,
-              metadata: {
-                source: "shell",
-                jobID: id,
-                shellID,
-                state,
-                ...(output
-                  ? {
-                      truncated: output.truncated,
-                      ...(output.exit !== undefined ? { exit: output.exit } : {}),
-                      ...(output.timeout !== undefined ? { timeout: output.timeout } : {}),
-                    }
-                  : {}),
-              },
-            })
-          }),
-        ),
-        Effect.forkIn(scope, { startImmediately: true }),
-      )
+      const output = info.status === "completed" ? yield* Deferred.await(input.settled) : undefined
+      const text = output
+        ? resultMessages(output).join("\n\n")
+        : info.status === "error"
+          ? (info.error ?? "Command failed")
+          : "Command cancelled"
+      yield* runtime.session
+        .synthetic({
+          sessionID: input.sessionID,
+          text: `<shell id="${input.id}" state="${info.status}" command="${input.command}">\n${text}\n</shell>`,
+          description: input.command,
+          metadata: {
+            source: "shell",
+            jobID: input.id,
+            shellID: input.shellID,
+            state: info.status,
+            ...(output
+              ? {
+                  truncated: output.truncated,
+                  ...(output.exit !== undefined ? { exit: output.exit } : {}),
+                  ...(output.timeout !== undefined ? { timeout: output.timeout } : {}),
+                }
+              : {}),
+          },
+          ...(info.status === "cancelled" ? { resume: false } : {}),
+        })
+        .pipe(Effect.ignore)
    })

    yield* ctx.tool
@@ -294,6 +282,13 @@ export const Plugin = {
              })

              const settled = yield* Deferred.make<Output>()
+              const notification = {
+                sessionID: context.sessionID,
+                id: context.id,
+                shellID: info.id,
+                command: info.command,
+                settled,
+              }
              const run = settleShell().pipe(
                Effect.tap((output) => Deferred.succeed(settled, output)),
                Effect.map((output) => output.output),
@@ -305,11 +300,16 @@ export const Plugin = {
                title: info.command,
                metadata: { sessionID: context.sessionID, shellID: info.id },
                run,
+                onBackgroundSettled: (result) => notifyWhenSettled(notification, result),
              })
+              if (job.status === "cancelled") {
+                yield* shell.remove(info.id).pipe(Effect.ignore)
+                return yield* Effect.fail(new Error("Command cancelled"))
+              }

              if (input.background === true) {
-                yield* runtime.job.background(job.id)
-                yield* notifyWhenDone(context.sessionID, context.id, info.id, info.command, settled)
+                const background = yield* runtime.job.background(job.id)
+                if (background?.status === "cancelled") return yield* Effect.fail(new Error("Command cancelled"))
                return backgroundResult(info.id)
              }

@@ -318,7 +318,6 @@ export const Plugin = {
                .pipe(Effect.onInterrupt(() => runtime.job.cancel(job.id).pipe(Effect.ignore)))
              if (result?.type === "backgrounded") {
                yield* shell.timeout(info.id, 0)
-                yield* notifyWhenDone(context.sessionID, context.id, info.id, info.command, settled)
                return backgroundResult(info.id)
              }
              if (result?.info.status === "error")
@@ -2,7 +2,7 @@ export * as SubagentTool from "./subagent.js"

 import { ToolFailure } from "@opencode-ai/ai"
 import type { Context as PluginContext } from "@opencode-ai/plugin/effect/plugin"
-import { Effect, Schema, Scope } from "effect"
+import { Effect, Schema } from "effect"
 import { Agent } from "../../agent.js"
 import { Config } from "../../config.js"
 import { PluginRuntime } from "../../plugin/runtime.js"
@@ -57,11 +57,6 @@ export const Plugin = {
    const agents = yield* Agent.Service
    const config = yield* Config.Service
    const permission = yield* Permission.Service
-    const scope = yield* Scope.Scope
-    // One completion observer per job generation. Keyed by child plus start time so a fresh
-    // continuation job is observable even while a settled generation's observer is finalizing.
-    const notifications = new Set<string>()
-
    // Concatenate the child's final completed assistant text. Distinguishes "completed with no
    // text" (generic string) from "failed" (the run effect fails, surfaced as a job error).
    const latestAssistantText = Effect.fn("SubagentTool.latestAssistantText")(function* (sessionID: SessionSchema.ID) {
@@ -86,44 +81,15 @@ export const Plugin = {
      state: "completed" | "error" | "cancelled",
      text: string,
    ) {
-      yield* runtime.session.synthetic({
-        sessionID: parentID,
-        text: `<subagent sessionID="${childID}" state="${state}" description="${description}">\n${text}\n</subagent>`,
-        description,
-        metadata: { source: "subagent", childID, agent, state },
-      })
-    })
-
-    const notifyWhenDone = Effect.fn("SubagentTool.notifyWhenDone")(function* (
-      parentID: SessionSchema.ID,
-      childID: SessionSchema.ID,
-      agent: string,
-      description: string,
-      startedAt: number,
-    ) {
-      const key = `${childID}:${startedAt}`
-      if (notifications.has(key)) return
-      notifications.add(key)
-      yield* runtime.job.wait({ id: childID }).pipe(
-        Effect.flatMap((result) => {
-          if (result.info?.status === "completed")
-            return injectCompletion(parentID, childID, agent, description, "completed", result.info.output ?? NO_TEXT)
-          if (result.info?.status === "error")
-            return injectCompletion(
-              parentID,
-              childID,
-              agent,
-              description,
-              "error",
-              result.info.error ?? "Subagent failed",
-            )
-          if (result.info?.status === "cancelled")
-            return injectCompletion(parentID, childID, agent, description, "cancelled", "Subagent cancelled")
-          return Effect.void
-        }),
-        Effect.ensuring(Effect.sync(() => notifications.delete(key))),
-        Effect.forkIn(scope, { startImmediately: true }),
-      )
+      yield* runtime.session
+        .synthetic({
+          sessionID: parentID,
+          text: `<subagent sessionID="${childID}" state="${state}" description="${description}">\n${text}\n</subagent>`,
+          description,
+          metadata: { source: "subagent", childID, agent, state },
+          ...(state === "cancelled" ? { resume: false } : {}),
+        })
+        .pipe(Effect.ignore)
    })

    yield* ctx.tool
@@ -257,11 +223,32 @@ export const Plugin = {
                title: input.description,
                metadata: {},
                run,
+                onBackgroundSettled: (result) => {
+                  const text =
+                    result.status === "completed"
+                      ? (result.output ?? NO_TEXT)
+                      : result.status === "error"
+                        ? (result.error ?? "Subagent failed")
+                        : "Subagent cancelled"
+                  return injectCompletion(
+                    context.sessionID,
+                    child.id,
+                    agent.name,
+                    input.description,
+                    result.status,
+                    text,
+                  )
+                },
              })
+              if (info.status === "cancelled") {
+                yield* runtime.session.interrupt(child.id)
+                return yield* new ToolFailure({ message: `Subagent cancelled (sessionID: ${child.id})` })
+              }

              if (background) {
-                yield* runtime.job.background(info.id)
-                yield* notifyWhenDone(context.sessionID, child.id, agent.name, input.description, info.started_at)
+                const result = yield* runtime.job.background(info.id)
+                if (result?.status === "cancelled")
+                  return yield* new ToolFailure({ message: `Subagent cancelled (sessionID: ${child.id})` })
                return backgroundResult(child.id)
              }

@@ -273,13 +260,6 @@ export const Plugin = {
                ),
              )
              if (result?.type === "backgrounded") {
-                yield* notifyWhenDone(
-                  context.sessionID,
-                  child.id,
-                  agent.name,
-                  input.description,
-                  result.info.started_at,
-                )
                return backgroundResult(child.id)
              }
              // Failure surfaces keep the sessionID visible so the model can continue the child.
@@ -3,25 +3,25 @@ import { Global } from "@opencode-ai/util/global"
 import { Effect, Layer } from "effect"
 import { tmpdir } from "./tmpdir"

+export function globalLayer(root: string) {
+  const data = path.join(root, "data")
+  const cache = path.join(root, "cache")
+  return Global.layerWith({
+    home: path.join(root, "home"),
+    data,
+    cache,
+    config: path.join(root, "config"),
+    state: path.join(root, "state"),
+    tmp: path.join(root, "tmp"),
+    bin: path.join(cache, "bin"),
+    log: path.join(data, "log"),
+    repos: path.join(data, "repos"),
+  })
+}
+
 export const tempGlobalLayer = Layer.unwrap(
  Effect.acquireRelease(
    Effect.promise(() => tmpdir()),
    (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
-  ).pipe(
-    Effect.map((tmp) => {
-      const data = path.join(tmp.path, "data")
-      const cache = path.join(tmp.path, "cache")
-      return Global.layerWith({
-        home: path.join(tmp.path, "home"),
-        data,
-        cache,
-        config: path.join(tmp.path, "config"),
-        state: path.join(tmp.path, "state"),
-        tmp: path.join(tmp.path, "tmp"),
-        bin: path.join(cache, "bin"),
-        log: path.join(data, "log"),
-        repos: path.join(data, "repos"),
-      })
-    }),
-  ),
+  ).pipe(Effect.map((tmp) => globalLayer(tmp.path))),
 )
@@ -145,6 +145,111 @@ describe("Job", () => {
    }),
  )

+  it.live("shutdown cancels only background jobs and awaits their terminal callbacks", () =>
+    Effect.gen(function* () {
+      const jobs = yield* Job.Service
+      const foregroundWork = yield* Deferred.make<void>()
+      const interrupted = yield* Deferred.make<void>()
+      const callbackStarted = yield* Deferred.make<Job.SettledInfo>()
+      const releaseCallback = yield* Deferred.make<void>()
+      const background = yield* jobs.start({
+        id: "job_background_shutdown",
+        type: "test",
+        run: Effect.never.pipe(Effect.ensuring(Deferred.succeed(interrupted, undefined))),
+        onBackgroundSettled: (info) =>
+          Deferred.await(interrupted).pipe(
+            Effect.andThen(Deferred.succeed(callbackStarted, info)),
+            Effect.andThen(Deferred.await(releaseCallback)),
+          ),
+      })
+      const foreground = yield* jobs.start({
+        id: "job_foreground_shutdown",
+        type: "test",
+        run: Deferred.await(foregroundWork).pipe(Effect.as("foreground")),
+      })
+      yield* jobs.background(background.id)
+
+      const shutdown = yield* jobs.shutdown.pipe(Effect.forkIn(yield* Scope.Scope, { startImmediately: true }))
+      expect(yield* Deferred.await(callbackStarted)).toMatchObject({
+        id: background.id,
+        status: "cancelled",
+      })
+      expect(shutdown.pollUnsafe()).toBeUndefined()
+      expect(yield* jobs.get(foreground.id)).toMatchObject({ status: "running" })
+
+      yield* Deferred.succeed(releaseCallback, undefined)
+      yield* Fiber.join(shutdown)
+      expect(yield* jobs.get(background.id)).toMatchObject({ status: "cancelled" })
+      expect(yield* jobs.get(foreground.id)).toMatchObject({ status: "running" })
+      expect(yield* jobs.background(foreground.id)).toMatchObject({ status: "cancelled" })
+      expect(yield* jobs.start({ id: "job_started_during_shutdown", type: "test", run: Effect.never })).toMatchObject({
+        status: "cancelled",
+      })
+      expect(yield* jobs.get("job_started_during_shutdown")).toBeUndefined()
+    }),
+  )
+
+  it.live("shutdown awaits a background callback already running after completion", () =>
+    Effect.gen(function* () {
+      const jobs = yield* Job.Service
+      const work = yield* Deferred.make<void>()
+      const callbackStarted = yield* Deferred.make<void>()
+      const releaseCallback = yield* Deferred.make<void>()
+      const job = yield* jobs.start({
+        id: "job_completed_before_shutdown",
+        type: "test",
+        run: Deferred.await(work).pipe(Effect.as("done")),
+        onBackgroundSettled: () =>
+          Deferred.succeed(callbackStarted, undefined).pipe(Effect.andThen(Deferred.await(releaseCallback))),
+      })
+      yield* jobs.background(job.id)
+      yield* Deferred.succeed(work, undefined)
+      yield* Deferred.await(callbackStarted)
+      expect(yield* jobs.get(job.id)).toMatchObject({ status: "completed" })
+
+      const shutdown = yield* jobs.shutdown.pipe(Effect.forkIn(yield* Scope.Scope, { startImmediately: true }))
+      yield* Effect.yieldNow
+      expect(shutdown.pollUnsafe()).toBeUndefined()
+
+      yield* Deferred.succeed(releaseCallback, undefined)
+      yield* Fiber.join(shutdown)
+    }),
+  )
+
+  it.live("shutdown rejects late background notification registration", () =>
+    Effect.gen(function* () {
+      const jobs = yield* Job.Service
+      const callback = yield* Deferred.make<void>()
+      const job = yield* jobs.start({
+        id: "job_completed_before_background_shutdown",
+        type: "test",
+        run: Effect.succeed("done"),
+        onBackgroundSettled: () => Deferred.succeed(callback, undefined),
+      })
+      expect(yield* jobs.wait({ id: job.id })).toMatchObject({ info: { status: "completed" } })
+
+      yield* jobs.shutdown
+      expect(yield* jobs.background(job.id)).toMatchObject({ status: "completed" })
+      expect((yield* Deferred.poll(callback))._tag).toBe("None")
+    }),
+  )
+
+  it.live("shutdown completes when a background callback defects", () =>
+    Effect.gen(function* () {
+      const jobs = yield* Job.Service
+      const job = yield* jobs.start({
+        id: "job_defective_shutdown_callback",
+        type: "test",
+        run: Effect.never,
+        onBackgroundSettled: () => Effect.die("callback defect"),
+      })
+      yield* jobs.background(job.id)
+
+      yield* jobs.shutdown.pipe(Effect.timeout("1 second"))
+      expect(yield* jobs.get(job.id)).toMatchObject({ status: "cancelled" })
+    }),
+  )
+
  it.live("interrupts live work without promising settlement after the owning process-local scope closes", () =>
    Effect.gen(function* () {
      const scope = yield* Scope.make()
@@ -1,4 +1,5 @@
-import { Effect, Plugin } from "@opencode-ai/plugin/effect"
+import { Plugin } from "@opencode-ai/plugin/effect"
+import { Effect } from "effect"

 export default Plugin.define({
  id: "config-effect-plugin",
@@ -113,6 +113,13 @@ describe("SessionStats", () => {
                  completed: DateTime.makeUnsafe(Date.UTC(2026, 0, 2, 10, 0, 2)),
                },
              }),
+              SessionMessage.AssistantTool.make({
+                type: "tool",
+                id: "call_pending",
+                name: "pending",
+                state: SessionMessage.ToolStateRunning.make({ status: "running", input: {}, metadata: {} }),
+                time: { created: DateTime.makeUnsafe(Date.UTC(2026, 0, 2, 10)) },
+              }),
            ]),
          ),
          messageRow(childID, 1, assistant("msg_stats_child", Date.UTC(2026, 0, 3, 10), [], "large", 2)),
@@ -210,7 +217,7 @@ describe("SessionStats", () => {
      expect(stats.cost).toBe(Money.USD.make(6.25))
      expect(stats.tools).toMatchObject({
        mode: "detail",
-        totals: { calls: 2, succeeded: 1, failed: 1, unfinished: 0 },
+        totals: { calls: 3, succeeded: 1, failed: 1, unfinished: 1 },
      })
      expect(stats.activity).toEqual([
        { date: "2026-01-02", steps: 1 },
@@ -224,6 +231,7 @@ describe("SessionStats", () => {
      expect(stats.tools.usage).toMatchObject([
        { name: "read", calls: 1, succeeded: 1, failed: 0, durationP50: 250 },
        { name: "edit", calls: 1, succeeded: 0, failed: 1, durationP50: 2_000 },
+        { name: "pending", calls: 1, succeeded: 0, failed: 0, unfinished: 1 },
      ])

      const summary = yield* SessionStats.get({
@@ -234,7 +242,7 @@ describe("SessionStats", () => {
      expect(summary.models.map((model) => String(model.model.id))).toEqual(["large", "sonnet", "fork-new"])
      expect(summary.tools).toEqual({
        mode: "summary",
-        totals: { calls: 2, succeeded: 1, failed: 1, unfinished: 0 },
+        totals: { calls: 3, succeeded: 1, failed: 1, unfinished: 1 },
      })

      const withoutTools = yield* SessionStats.get({
@@ -3,7 +3,7 @@ import { realpathSync } from "node:fs"
 import os from "os"
 import path from "path"
 import { describe, expect } from "bun:test"
-import { Deferred, Duration, Effect, Fiber, Layer, Scope, Stream } from "effect"
+import { Context, Deferred, Duration, Effect, Exit, Fiber, Layer, Scope, Stream } from "effect"
 import { Money } from "@opencode-ai/schema/money"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { LayerNode } from "@opencode-ai/util/effect/layer-node"
@@ -26,6 +26,7 @@ import { Job } from "@opencode-ai/core/job"
 import { Session } from "@opencode-ai/core/session"
 import { SessionEvent } from "@opencode-ai/core/session/event"
 import { SessionExecution } from "@opencode-ai/core/session/execution"
+import { SessionInbox } from "@opencode-ai/core/session/inbox"
 import { SessionMessage } from "@opencode-ai/core/session/message"
 import { SessionStore } from "@opencode-ai/core/session/store"
 import { Permission } from "@opencode-ai/core/permission"
@@ -37,7 +38,7 @@ import { ShellTool } from "@opencode-ai/core/tool/plugin/shell"
 import { ToolOutput } from "@opencode-ai/core/tool-output"
 import { Tool } from "@opencode-ai/core/tool"
 import { tmpdir } from "./fixture/tmpdir"
-import { tempGlobalLayer } from "./fixture/global"
+import { globalLayer, tempGlobalLayer } from "./fixture/global"
 import { testEffect } from "./lib/effect"
 import { permissionLayer } from "./lib/permission"
 import { toolIdentity, executeTool, registerToolPlugin, toolDefinitions } from "./lib/tool"
@@ -159,6 +160,7 @@ const replacements = [
 ] satisfies LayerNode.Replacements
 const productionIt = testEffect(AppNodeBuilder.build(nodes, replacements))
 const it = testEffect(AppNodeBuilder.build(nodes, [...replacements, [PluginSupervisor.node, shellPluginSupervisor]]))
+const lifecycleIt = testEffect(Layer.empty)

 const call = (input: typeof ShellTool.Input.Type, id = "call-shell") => ({
  sessionID,
@@ -777,6 +779,83 @@ describe("ShellTool", () => {
    ),
  )

+  lifecycleIt.live("notifies the session when application shutdown cancels a background command", () =>
+    Effect.acquireUseRelease(
+      Effect.all([Effect.promise(() => tmpdir()), Scope.make()]),
+      ([tmp, applicationScope]) =>
+        Effect.gen(function* () {
+          reset()
+          const databasePath = path.join(tmp.path, "opencode.sqlite")
+          const testGlobalLayer = globalLayer(tmp.path)
+          const context = yield* Layer.buildWithScope(
+            AppNodeBuilder.build(nodes, [
+              [SessionExecution.node, executionNode],
+              [Permission.node, permission],
+              [PluginSupervisor.node, shellPluginSupervisor],
+              [Database.node, Database.configured({ path: databasePath })],
+              [Bus.node, Bus.configured({ persist: true })],
+              [Global.node, testGlobalLayer],
+            ]),
+            applicationScope,
+          )
+          const sessions = Context.get(context, Session.Service)
+          const location = Location.Ref.make({ directory: AbsolutePath.make(tmp.path) })
+          yield* sessions.create({
+            id: sessionID,
+            title: "shell shutdown test",
+            location,
+            model: sessionModel,
+          })
+          const locations = Context.get(context, LocationServiceMap.Service)
+          const settled = yield* Effect.gen(function* () {
+            yield* (yield* PluginSupervisor.Service).flush
+            return yield* executeTool(
+              yield* Tool.Service,
+              call({ command: idleCommand, background: true }, "call-shutdown-background"),
+            )
+          }).pipe(Effect.provide(locations.get(location)))
+
+          expect(settled.metadata).toMatchObject({ status: "running" })
+          yield* Scope.close(applicationScope, Exit.void)
+
+          const pending = yield* Layer.build(
+            AppNodeBuilder.build(Database.node, [
+              [Database.node, Database.configured({ path: databasePath })],
+              [Global.node, testGlobalLayer],
+            ]),
+          ).pipe(
+            Effect.flatMap((verification) =>
+              SessionInbox.list(Context.get(verification, Database.Service).db, sessionID),
+            ),
+            Effect.scoped,
+          )
+          const cancellation = pending.find(
+            (item) =>
+              item.type === "synthetic" &&
+              item.payload.metadata?.source === "shell" &&
+              item.payload.metadata.jobID === "call-shutdown-background",
+          )
+          expect(cancellation).toMatchObject({
+            type: "synthetic",
+            payload: {
+              text: expect.stringContaining("Command cancelled"),
+              description: idleCommand,
+              metadata: {
+                source: "shell",
+                jobID: "call-shutdown-background",
+                shellID: settled.metadata?.shellID,
+                state: "cancelled",
+              },
+            },
+          })
+        }),
+      ([tmp, applicationScope]) =>
+        Scope.close(applicationScope, Exit.void).pipe(
+          Effect.andThen(Effect.promise(() => tmp[Symbol.asyncDispose]().then(() => undefined))),
+        ),
+    ),
+  )
+
  it.live("preserves a background command's non-zero exit", () =>
    Effect.acquireUseRelease(
      Effect.promise(() => tmpdir()),
@@ -30,8 +30,8 @@
  },
  "peerDependencies": {
    "@opencode-ai/theme": "workspace:*",
-    "@opentui/core": ">=0.5.7",
-    "@opentui/solid": ">=0.5.7",
+    "@opentui/core": ">=0.5.8",
+    "@opentui/solid": ">=0.5.8",
    "solid-js": ">=1.9.0"
  },
  "peerDependenciesMeta": {
@@ -8,7 +8,8 @@ The Effect plugin API grants plugins two in-process capabilities:
 ## Defining A Plugin

 ```ts
-import { Effect, Plugin } from "@opencode-ai/plugin/effect"
+import { Plugin } from "@opencode-ai/plugin/effect"
+import { Effect } from "effect"

 export default Plugin.define({
  id: "example",
@@ -1,6 +1,5 @@
 export * as Plugin from "./plugin.js"
 export type { StorageEntry, StorageScanOptions, StorageScanResult } from "../storage.js"
-export { Effect, Schema } from "effect"

 export { Agent } from "@opencode-ai/schema/agent"
 export { Command } from "@opencode-ai/schema/command"
@@ -43,6 +43,6 @@ export interface Plugin<R = Scope.Scope> {
  readonly effect: (context: Context) => Effect.Effect<void, never, R>
 }

-export function define<R = Scope.Scope>(plugin: Plugin<R>): Plugin<R> {
+export function define<R = Scope.Scope>(plugin: Plugin<R>) {
  return plugin
 }
@@ -1,48 +0,0 @@
-import type { Tool } from "@opencode-ai/schema/tool"
-import { Schema, SchemaAST } from "effect"
-import type { Context } from "./plugin.js"
-
-export function instanceSafeContext(context: Context): Context {
-  return {
-    ...context,
-    tool: {
-      ...context.tool,
-      transform: (callback) =>
-        context.tool.transform((draft) => callback({ add: (tool) => draft.add(instanceSafeTool(tool)) })),
-    },
-  }
-}
-
-export function instanceSafeTool(tool: Tool.Info<any, any>): Tool.Info<any, any> {
-  const input = instanceSafeValueSchema(tool.input, "input")
-  const output = tool.output === undefined ? undefined : instanceSafeValueSchema(tool.output, "output")
-  if (input === tool.input && output === tool.output) return tool
-  return { ...tool, input, ...(output === undefined ? {} : { output }) }
-}
-
-function instanceSafeValueSchema(schema: Tool.ValueSchema<any>, direction: "input" | "output"): Tool.ValueSchema<any> {
-  if (typeof schema === "object" && schema !== null && "~standard" in schema) {
-    const standard = schema["~standard"] as Record<string, any>
-    if (
-      typeof standard.validate !== "function" ||
-      typeof standard.jsonSchema?.input !== "function" ||
-      typeof standard.jsonSchema?.output !== "function"
-    )
-      throw new Error("Tool schemas must implement Standard Schema validation and JSON Schema generation")
-    return { "~standard": standard } as Tool.ValueSchema<any>
-  }
-  if (!Schema.isSchema(schema)) return schema
-  // Native codecs can only be compiled by the Effect instance that authored their AST.
-  if (!(schema.ast instanceof SchemaAST.Base)) {
-    throw new Error(
-      "Effect tool schemas must use Schema from @opencode-ai/plugin/effect or be converted to Standard Schema by their authoring Effect instance",
-    )
-  }
-  const codec = schema as Schema.Codec<unknown, unknown>
-  // Standard Schema validates Encoded -> Type, so flip outputs to run Type -> Encoded.
-  const oriented = direction === "input" ? codec : Schema.flip(codec)
-  const augmented = Schema.toStandardJSONSchemaV1(Schema.toStandardSchemaV1(oriented)) as unknown as {
-    readonly "~standard": Record<string, unknown>
-  }
-  return { "~standard": augmented["~standard"] } as Tool.ValueSchema<any>
-}
@@ -1,5 +1,4 @@
 import { expect, test } from "bun:test"
-import { Effect, Schema } from "effect"
 import { Agent } from "@opencode-ai/schema/agent"
 import { Command } from "@opencode-ai/schema/command"
 import { Connection } from "@opencode-ai/schema/connection"
@@ -31,10 +30,7 @@ test.each([
  expect(entrypoint.Reference).toBe(Reference)
  expect(entrypoint.Skill).toBe(Skill)
  expect(entrypoint.WebSearch).toBe(WebSearch)
-})
-
-test("promise entrypoint exposes its public contract", () => {
-  expect(Object.keys(PromisePlugin).sort()).toEqual([
+  expect(Object.keys(entrypoint).sort()).toEqual([
    "Agent",
    "Command",
    "Connection",
@@ -50,32 +46,6 @@ test("promise entrypoint exposes its public contract", () => {
  ])
 })

-test("effect entrypoint owns its Effect runtime", () => {
-  expect(Plugin.Effect).toBe(Effect)
-  expect(Plugin.Schema).toBe(Schema)
-  expect(Object.keys(Plugin).sort()).toEqual([
-    "Agent",
-    "Command",
-    "Connection",
-    "Credential",
-    "Effect",
-    "Integration",
-    "Mcp",
-    "Model",
-    "Plugin",
-    "Provider",
-    "Reference",
-    "Schema",
-    "Skill",
-    "WebSearch",
-  ])
-})
-
-test("effect plugin definition preserves identity", () => {
-  const definition = { id: "demo", effect: () => Effect.void }
-  expect(Plugin.Plugin.define(definition)).toBe(definition)
-})
-
 test("tui entrypoint exposes the plugin definition", () => {
  const plugin = TuiPlugin.Plugin.define({ id: "demo", setup() {} })
  expect(plugin.id).toBe("demo")
@@ -1,121 +0,0 @@
-import { afterAll, expect, test } from "bun:test"
-import { cp, mkdtemp, rm } from "node:fs/promises"
-import { tmpdir } from "node:os"
-import path from "node:path"
-import { fileURLToPath, pathToFileURL } from "node:url"
-import type { Tool } from "@opencode-ai/schema/tool"
-import type { StandardJSONSchemaV1, StandardSchemaV1 } from "@standard-schema/spec"
-import { Effect, Schema } from "effect"
-import { instanceSafeContext } from "../src/effect/tool-schema.js"
-
-const fixture = prepareAdapter()
-
-afterAll(async () => rm((await fixture).directory, { recursive: true, force: true }))
-
-test("prepares tools at the host plugin boundary", async () => {
-  const registered: Array<Tool.Info> = []
-  const context = {
-    tool: {
-      transform: (callback: (draft: { add: (tool: Tool.Info) => void }) => void) => {
-        callback({ add: (tool) => registered.push(tool) })
-        return Effect.succeed({ dispose: Effect.void })
-      },
-    },
-  } as unknown as Parameters<typeof instanceSafeContext>[0]
-
-  await Effect.runPromise(
-    Effect.scoped(
-      instanceSafeContext(context).tool.transform((draft) =>
-        draft.add({
-          name: "create",
-          description: "Create",
-          input: Schema.Struct({ title: Schema.String }),
-          execute: () => Effect.succeed({ content: "ok" }),
-        }),
-      ),
-    ),
-  )
-  expect(registered).toHaveLength(1)
-  expect(Schema.isSchema(registered[0]?.input)).toBe(false)
-})
-
-test("converts schemas authored by the plugin Effect runtime", async () => {
-  const prepared = await fixture
-  const tool = prepared.instanceSafeTool({
-    name: "create",
-    description: "Create",
-    input: prepared.Schema.FiniteFromString,
-    output: prepared.Schema.FiniteFromString,
-    execute: () => prepared.Effect.succeed({ output: 42 }),
-  })
-
-  expect(Schema.isSchema(tool.input)).toBe(false)
-  const input = tool.input as StandardSchemaV1
-  expect(await input["~standard"].validate("42")).toEqual({ value: 42 })
-  expect(await input["~standard"].validate(42)).toHaveProperty("issues")
-  expect((input as StandardJSONSchemaV1)["~standard"].jsonSchema.input({ target: "draft-2020-12" })).toMatchObject({
-    type: "string",
-  })
-  const output = tool.output as StandardSchemaV1 & StandardJSONSchemaV1
-  expect(await output["~standard"].validate(42)).toEqual({ value: "42" })
-  expect(output["~standard"].jsonSchema.output({ target: "draft-2020-12" })).toMatchObject({ type: "string" })
-})
-
-test("rejects an unprepared schema from another Effect runtime", async () => {
-  const prepared = await fixture
-  expect(() =>
-    prepared.instanceSafeTool({
-      name: "create",
-      description: "Create",
-      input: Schema.Struct({ title: Schema.String }),
-      execute: () => prepared.Effect.succeed({ content: "ok" }),
-    }),
-  ).toThrow("must use Schema from @opencode-ai/plugin/effect")
-})
-
-test("accepts a foreign schema prepared by its authoring runtime", async () => {
-  const prepared = await fixture
-  const schema = Schema.Struct({ title: Schema.String })
-  const augmented = Schema.toStandardJSONSchemaV1(Schema.toStandardSchemaV1(schema))
-  const detached = { "~standard": augmented["~standard"] }
-  const tool = prepared.instanceSafeTool({
-    name: "create",
-    description: "Create",
-    input: detached,
-    execute: () => prepared.Effect.succeed({ content: "ok" }),
-  })
-
-  expect(Schema.isSchema(tool.input)).toBe(false)
-  const input = tool.input as StandardSchemaV1 & StandardJSONSchemaV1
-  expect(await input["~standard"].validate({ title: "probe" })).toEqual({ value: { title: "probe" } })
-  expect(input["~standard"].jsonSchema.input({ target: "draft-2020-12" })).toMatchObject({ type: "object" })
-})
-
-test("rejects incomplete Standard Schema implementations", async () => {
-  const prepared = await fixture
-  expect(() =>
-    prepared.instanceSafeTool({
-      name: "create",
-      description: "Create",
-      input: { "~standard": { version: 1, vendor: "test", validate: () => ({ value: {} }) } } as Tool.ValueSchema,
-      execute: () => prepared.Effect.succeed({ content: "ok" }),
-    }),
-  ).toThrow("must implement Standard Schema validation and JSON Schema generation")
-})
-
-async function prepareAdapter() {
-  const directory = await mkdtemp(path.join(tmpdir(), "opencode-plugin-effect-"))
-  const source = path.dirname(fileURLToPath(import.meta.resolve("effect/package.json")))
-  await cp(source, path.join(directory, "node_modules", "effect"), { recursive: true })
-  await cp(new URL("../src/effect/tool-schema.ts", import.meta.url), path.join(directory, "tool-schema.ts"))
-  const adapter = (await import(pathToFileURL(path.join(directory, "tool-schema.ts")).href)) as {
-    instanceSafeTool: (tool: Tool.Info) => Tool.Info
-  }
-  const runtime = (await import(
-    pathToFileURL(path.join(directory, "node_modules", "effect", "dist", "index.js")).href
-  )) as {
-    Effect: typeof Effect
-    Schema: typeof Schema
-  }
-  return { directory, instanceSafeTool: adapter.instanceSafeTool, Effect: runtime.Effect, Schema: runtime.Schema }
-}
@@ -22,7 +22,8 @@
  "scripts": {
    "build": "bun run script/build.ts",
    "test": "bun test --timeout 5000",
-    "typecheck": "tsgo -b"
+    "typecheck": "tsgo -b",
+    "verify:package": "bun run script/verify-package.ts"
  },
  "dependencies": {
    "@opencode-ai/client": "workspace:*",
@@ -0,0 +1,179 @@
+#!/usr/bin/env bun
+
+import { $ } from "bun"
+import { mkdtemp, rm } from "node:fs/promises"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+import { fileURLToPath } from "node:url"
+
+const root = fileURLToPath(new URL("../../..", import.meta.url))
+const names = ["schema", "codemode", "ai", "util", "protocol", "client", "plugin", "core", "simulation", "server", "sdk"]
+const temporary = await mkdtemp(join(tmpdir(), "opencode-sdk-package-"))
+const archives = new Map<string, string>()
+
+try {
+  for (const name of names) {
+    const directory = join(root, "packages", name)
+    await $`bun run build`.cwd(directory)
+    const original = await Bun.file(join(directory, "package.json")).text()
+    // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- package manifests are validated by their package builds.
+    const pkg = JSON.parse(original) as {
+      name: string
+      dependencies?: Record<string, string>
+      exports?: Record<string, string | { import: string; types: string }>
+      imports?: Record<string, Record<string, string>>
+    }
+    const archive = join(temporary, `${name}.tgz`)
+
+    if (pkg.dependencies) {
+      const unpacked = Object.keys(pkg.dependencies).filter(
+        (dependency) => dependency.startsWith("@opencode-ai/") && !archives.has(dependency),
+      )
+      if (unpacked.length > 0) throw new Error(`${pkg.name} has unpacked workspace dependencies: ${unpacked.join(", ")}`)
+      pkg.dependencies = Object.fromEntries(
+        Object.entries(pkg.dependencies).map(([dependency, version]) => {
+          const local = archives.get(dependency)
+          return [dependency, local ? `file:${local}` : version]
+        }),
+      )
+    }
+    if (pkg.exports) {
+      pkg.exports = Object.fromEntries(
+        Object.entries(pkg.exports).map(([key, value]) => {
+          if (typeof value !== "string") return [key, value]
+          return [key, { import: output(name, value), types: output(name, value, true) }]
+        }),
+      )
+    }
+    if (pkg.imports) {
+      pkg.imports = Object.fromEntries(
+        Object.entries(pkg.imports).map(([key, conditions]) => [
+          key,
+          Object.fromEntries(
+            Object.entries(conditions).map(([condition, value]) => [condition, output(name, value, condition === "types")]),
+          ),
+        ]),
+      )
+    }
+
+    await Bun.write(join(directory, "package.json"), JSON.stringify(pkg, null, 2) + "\n")
+    try {
+      await $`bun pm pack --filename ${archive} --ignore-scripts --quiet`.cwd(directory)
+    } finally {
+      await Bun.write(join(directory, "package.json"), original)
+    }
+    archives.set(pkg.name, archive)
+  }
+
+  const consumer = join(temporary, "consumer")
+  await Bun.write(
+    join(consumer, "package.json"),
+    JSON.stringify({ name: "opencode-sdk-consumer", private: true, type: "module" }),
+  )
+  await Promise.all([
+    Bun.write(
+      join(consumer, "wrangler.jsonc"),
+      JSON.stringify({
+        name: "opencode-sdk-packed-consumer",
+        main: "worker.js",
+        compatibility_date: "2026-07-15",
+        compatibility_flags: ["nodejs_compat"],
+        durable_objects: { bindings: [{ name: "OPENCODE", class_name: "OpenCodeDO" }] },
+        migrations: [{ tag: "v1", new_sqlite_classes: ["OpenCodeDO"] }],
+      }),
+    ),
+    Bun.write(
+      join(consumer, "worker.js"),
+      `import { bodyDigest } from "@opencode-ai/core/models-dev"
+import { OpenCodeWorkerd } from "@opencode-ai/sdk/workerd"
+import { Effect } from "effect"
+
+export class OpenCodeDO {
+  constructor(state) {
+    this.state = state
+  }
+
+  fetch() {
+    if (bodyDigest("packed-workerd") !== "5fc174bf63e8dd108ebb6c53d85e7bbc4525b2f4c1c43280364cdbfd9b37aaf5") {
+      throw new Error("Packed workerd SHA-256 mismatch")
+    }
+    const storage = this.state.storage
+    return Effect.runPromise(
+      Effect.gen(function* () {
+        const sdk = yield* OpenCodeWorkerd.create({
+          storage,
+          app: { version: "packed-workerd" },
+          config: { content: "{}" },
+        })
+        return Response.json(yield* sdk.health.get())
+      }).pipe(Effect.scoped),
+    )
+  }
+}
+
+export default {
+  fetch(request, env) {
+    return env.OPENCODE.get(env.OPENCODE.idFromName("packed-consumer")).fetch(request)
+  },
+}
+`,
+    ),
+    Bun.write(
+      join(consumer, "boot.mjs"),
+      `import { Miniflare } from "miniflare"
+
+const miniflare = new Miniflare({
+  compatibilityDate: "2026-07-15",
+  compatibilityFlags: ["nodejs_compat"],
+  modules: true,
+  scriptPath: new URL("./dist/worker.js", import.meta.url).pathname,
+  durableObjects: { OPENCODE: { className: "OpenCodeDO", useSQLite: true } },
+})
+
+try {
+  const response = await miniflare.dispatchFetch("http://opencode.local/health")
+  if (response.status !== 200) throw new Error(
+    "Packed workerd health returned " + response.status + ": " + await response.text(),
+  )
+  const body = await response.json()
+  if (body.healthy !== true || body.version !== "packed-workerd") {
+    throw new Error("Unexpected packed workerd health: " + JSON.stringify(body))
+  }
+} finally {
+  await miniflare.dispose()
+}
+`,
+    ),
+  ])
+
+  const sdk = archives.get("@opencode-ai/sdk")
+  if (!sdk) throw new Error("Packed SDK archive was not created")
+  await $`npm install --ignore-scripts --no-audit --no-fund --package-lock=false ${sdk} wrangler@4.110.0`.cwd(consumer)
+  await $`node_modules/.bin/wrangler deploy --dry-run --config wrangler.jsonc --outdir dist`.cwd(consumer)
+
+  const transpiler = new Bun.Transpiler({ loader: "js" })
+  const bundled = await Bun.file(join(consumer, "dist/worker.js")).text()
+  if (/createRequire\s*\(\s*import\.meta\.url\s*\)/.test(bundled)) {
+    throw new Error("Packed workerd bundle contains Bun's eager Node require initializer")
+  }
+  const bunGlobals = Array.from(new Set(bundled.match(/\bBun\.[A-Za-z_$][\w$]*/g) ?? []))
+  if (bunGlobals.length > 0) throw new Error(`Packed workerd bundle references Bun globals: ${bunGlobals.join(", ")}`)
+  const leaked = [
+    ...transpiler.scanImports(bundled)
+      .filter((imported) => imported.kind !== "dynamic-import")
+      .map((imported) => imported.path),
+    ...Array.from(bundled.matchAll(/\brequire\(\s*["']([^"']+)["']\s*\)/g), (match) => match[1]),
+  ]
+    .filter((specifier) => specifier === "bun" || specifier.startsWith("bun:"))
+  if (leaked.length > 0) throw new Error(`Packed workerd bundle statically imports Bun builtins: ${leaked.join(", ")}`)
+
+  await $`node boot.mjs`.cwd(consumer)
+  console.log("packed SDK consumer OK")
+} finally {
+  await rm(temporary, { recursive: true, force: true })
+}
+
+function output(name: string, value: string, types = false) {
+  const root = name === "core" && types ? "./dist/types/" : "./dist/"
+  return value.replace("./src/", root).replace(/\.ts$/, types ? ".d.ts" : ".js")
+}
@@ -25,7 +25,7 @@
      "default": "./src/global-roots.ts"
    },
    "#runtime-import": {
-      "workerd": "./src/runtime/import.bun.ts",
+      "workerd": "./src/runtime/import.workerd.ts",
      "bun": "./src/runtime/import.bun.ts",
      "node": "./src/runtime/import.node.ts",
      "default": "./src/runtime/import.bun.ts"
@@ -60,7 +60,10 @@ export function fileLogger(target = file(), id: string = runID()) {
  })
 }

-const stderrLogger = Logger.make((options) => process.stderr.write(formatter().log(options) + "\n"))
+const stderrLogger = Logger.make((options) => {
+  if (process.env.OPENCODE_PRINT_LOGS !== "1") return
+  process.stderr.write(formatter().log(options) + "\n")
+})

 export function minimumLogLevel() {
  const value = process.env.OPENCODE_LOG_LEVEL?.toUpperCase()
@@ -74,8 +77,7 @@ export function minimumLogLevel() {
 }

 export function loggers(local = true, channel = "local") {
-  const logger = fileLogger(file(local, channel))
-  return process.env.OPENCODE_PRINT_LOGS === "1" ? [logger, stderrLogger] : [logger]
+  return [fileLogger(file(local, channel)), stderrLogger]
 }

 export * as Logging from "./logging.js"
@@ -0,0 +1,9 @@
+const unavailable = () => new Error("Dynamic module loading is unavailable on workerd")
+
+export function importModule(_specifier: string): Promise<unknown> {
+  return Promise.reject(unavailable())
+}
+
+export function resolveModule(_specifier: string, _directory: string): string {
+  throw unavailable()
+}
@@ -459,16 +459,16 @@ being resolved.
 ## Effect

 OpenCode provides a first-class Effect API for plugins through the
-`@opencode-ai/plugin/effect` entrypoint. It exports the compatible `Effect` and
-`Schema` modules alongside the plugin API. Use those exports instead of a separate
-`effect` installation so values crossing the plugin boundary share one runtime:
+`@opencode-ai/plugin/effect` entrypoint. Install `effect` alongside the
+plugin package and export an `effect` function instead of `setup`:

 ```sh
-bun add @opencode-ai/plugin@beta
+bun add @opencode-ai/plugin@beta effect
 ```

 ```ts title=".opencode/plugins/reviewer-effect.ts"
-import { Effect, Plugin } from "@opencode-ai/plugin/effect"
+import { Plugin } from "@opencode-ai/plugin/effect"
+import { Effect } from "effect"

 export default Plugin.define({
  id: "acme.reviewer-effect",
@@ -489,6 +489,6 @@ fibers, and registrations are released when the plugin reloads or unloads.
 OpenCode does not expose its private Core services to the plugin; use the
 capabilities on `ctx`.

-Typed tools can use `Schema` from `@opencode-ai/plugin/effect`. Effect and Promise plugins use the
+Typed tools can use `Schema` from `effect`. Effect and Promise plugins use the
 same `tools.add(name, tool, options?)` registration shape. Effect executors
 return an Effect and may fail with the typed tool failure channel.
Author	SHA1	Message	Date
Kit Langton	e342333eea	fix(core): close background shutdown races	2026-08-24 11:43:50 -04:00
Kit Langton	40f11b9956	fix(core): notify background jobs on shutdown	2026-08-24 10:51:23 -04:00
opencode-agent[bot]	50a8539e4b	chore: update nix node_modules hashes	2026-08-24 14:29:37 +00:00
Shoubhit Dash	7b47589225	refactor(core): optimize stats tool summary (#44690 )	2026-08-24 19:39:04 +05:30
OpeOginniandShoubhit Dash	84275c6e9d	fix(cli): restore print-logs flag for `--standalone` runs (#44112 ) Co-authored-by: Shoubhit Dash <shoubhit2005@gmail.com>	2026-08-24 19:32:38 +05:30
Kit Langton	793ea52fa7	fix(core): make packed SDK boot on workerd (#44703 )	2026-08-24 14:02:26 +00:00
Simon Klee	40380ad9b5	tui: update OpenTUI to 0.5.8 (#44698 )	2026-08-24 15:42:27 +02:00