chore: move drive and catalog ownership

Co-authored-by: Aiden Cline <rekram1-node@users.noreply.github.com>

.github/TEAM_MEMBERS

@@ -10,6 +10,7 @@ kitlangton
 kommander
 ludvigrask
 MrMushrooooom
+neriousy
 nexxeln
 R44VC0RP
 rekram1-node

.github/workflows/test.yml

@@ -55,6 +55,12 @@ jobs:
           git config --global user.email "bot@opencode.ai"
           git config --global user.name "opencode"
 
+      - name: Install ffmpeg
+        if: runner.os == 'Linux'
+        run: |
+          sudo apt-get update
+          sudo apt-get install --yes ffmpeg
+
       - name: Cache Turbo
         uses: actions/cache@0057852bfaa89a56745cba8c7296529d2fc39830 # v4.3.0
         with:

.opencode/skills/opencode-drive/SKILL.md

@@ -1,253 +0,0 @@
----
-name: opencode-drive
-description: Use when an agent needs drive OpenCode via a script or interact with an isolated instance
----
-
-# OpenCode Drive
-
-Use `opencode-drive` to launch an isolated OpenCode instance and control it via commands or a script.
-
-There are two modes. Always default to using a script unless specifically directed to be interactive (connect
-to an existing running instance, or start a new one, and make a few changes to the UI and read it, and iterate
-on changes).
-
-Scripts allow you to run a full walkthrough in one run. When the script is done opencode-drive exits,
-stops all processes, and cleans up all artifacts.
-
-# Prepare The Environment
-
-Use `init` when files must be added to the isolated home or project before OpenCode starts. It prints the artifact directory without launching OpenCode. A later `start` with the same name reuses it.
-
-```bash
-artifacts=$(opencode-drive init --name demo)
-cp -R ./fixtures/home/. "$artifacts/"
-cp -R ./fixtures/project/. "$artifacts/files/"
-opencode-drive start --name demo --dev ~/projects/opencode
-```
-
-The simulated project is under `$artifacts/files`. Running `start` without a prior `init` initializes the artifacts automatically.
-
-# Scripted usage
-
-You can write scripts that walk through entire flows, and gives you full access to controlling
-the backend too. See examples of the script API at the bottom of this file.
-
-After creating or editing a script, always typecheck it before running. Never skip this step:
-
-```bash
-opencode-drive check ./reproduce-stale-exploring-empty.ts
-```
-
-Run it by passing `--script` to start:
-
-```bash
-opencode-drive start --name auto-stop-reproduction --script ./reproduce-stale-exploring-empty.ts
-```
-
-It will output information about the run, including paths to log files which you can read
-to inspect what happened. If you need to dig into failures that aren't clear, read those log
-files. If the script is unsuccessful, automatically fix the script and run it again.
-
-Scripts use one typed definition object. `setup` runs before OpenCode starts,
-and `fs.writeFile` always writes inside the simulated project.
-
-You can read the full typed API here: https://raw.githubusercontent.com/jlongster/opencode-drive/refs/heads/main/src/script/types.ts
-
-```ts
-import { defineScript } from "opencode-drive"
-
-export default defineScript({
-  async setup({ fs, config }) {
-    config.autoupdate = false
-    await fs.writeFile("src/example.ts", "export const value = 1\n")
-  },
-
-  async run({ ui, llm }) {
-    await ui.submit("Open src/example.ts")
-    await llm.send(llm.text("The file exports `value`."))
-    await ui.waitFor("The file exports `value`.")
-  },
-})
-```
-
-`setup` receives the current OpenCode config object, which starts from the
-default drive config unless the prepared instance already has one. When a script
-needs custom config, mutate this `config` parameter instead of generating and
-writing a new config object from scratch, so the script keeps the default
-provider/model settings unless it intentionally changes them.
-
-Note that the simulated model is a GPT model type, and opencode uses the `patch` tool for working with files Do not use a `edit` or `write` tool to edit files.
-
-Use `launch: "manual"` when the script needs to launch the server and every TUI
-itself (this is extremely rare, do not use this unless explicitly asked). In this
-mode `ui` is typed as `null`; call `server.launch()` exactly
-once before launching clients. Each `clients.launch(name)` result provides the
-same UI methods as the automatic client. You can see an example of this API
-here: https://raw.githubusercontent.com/jlongster/opencode-drive/refs/heads/main/examples/multiple-clients.ts
-
-Use the exported `wait(milliseconds)` utility for an unconditional delay.
-
-`await llm.send(...)` waits for the next request and resolves after OpenCode
-acknowledges its complete response. `llm.queue(...)` declares responses in
-advance. Chunks may be built with `text`, `reasoning`, `toolCall`, `raw`,
-`finish`, and `disconnect`. A normal response receives `finish("stop")`
-automatically unless it yields or queues an explicit terminal event.
-
-`llm.text(text, { delay, chunkSize })` defaults to a 2 ms delay and a
-15-character target varied by plus or minus 5 per chunk.
-
-`llm.reasoning` accepts the same options, and `llm.pause(milliseconds)` adds a
-delay between any two outputs.
-
-Use `llm.serve` for an ongoing typed response generator:
-
-```ts
-llm.serve(async function* (request, index) {
-  yield llm.reasoning(`Handling request ${index + 1}`)
-  yield llm.text(`Received ${request.id}`)
-  yield llm.finish("stop")
-})
-```
-
-The backend connection, response cleanup, cancellation, and recording
-completion are automatic.
-
-You can see some example scripts here:
-
-- https://raw.githubusercontent.com/jlongster/opencode-drive/refs/heads/main/examples/simple.ts
-- https://raw.githubusercontent.com/jlongster/opencode-drive/refs/heads/main/examples/serve.ts
-
-## Prune
-
-- `prune` removes artifact directories. These are always cleaned up after running a script
-  successfully, but leftover on failed runs. Always call this if a script fails.
-
-```bash
-opencode-drive prune --name demo
-
-// --force cleans up all artifcat directories
-opencode-dirve prune --force
-```
-
-# Live interaction usage
-
-- Always give headless instances a unique `--name`. Visible instances may omit it.
-- A normal headless `start` detaches automatically and returns after the instance is ready.
-- Do not add `&`; the long-running owner already runs in the background.
-- Configure simulated model responses after startup when needed.
-- Send ordered UI commands with `send`.
-- Always stop the instance when finished.
-
-```bash
-opencode-drive start --name demo
-
-opencode-drive send --name demo \
-  --command.ui.type '{"text":"Explain this project"}' \
-  --command.ui.enter
-
-opencode-drive stop --name demo
-```
-
-## Send UI Commands
-
-- Every `send` opens a connection to the named instance, runs its commands in order, and exits.
-- Combine typing and Enter in one command when submitting a prompt.
-- JSON-valued commands require one JSON argument.
-- Multiple command flags execute from left to right.
-
-Commands:
-
-- `--command.ui.type <json>` types into the focused editor. Arguments: `text` string.
-- `--command.ui.press <json>` presses a key. Arguments: `key` string; optional `modifiers` object with boolean `ctrl`, `shift`, `meta`, `super`, or `hyper`.
-- `--command.ui.enter` presses Enter. Arguments: none.
-- `--command.ui.arrow <json>` presses an arrow key. Arguments: `direction` is `up`, `down`, `left`, or `right`.
-- `--command.ui.focus <json>` focuses an element. Arguments: `target` is the numeric element `num` returned by `ui.state`.
-- `--command.ui.click <json>` clicks an element. Arguments: numeric `target`, `x`, and `y`; use the element `num` returned by `ui.state` as `target`.
-- `--command.ui.state` prints focus and interactive element metadata as JSON. Arguments: none.
-- `--command.ui.matches <json>` prints whether literal, case-sensitive text appears on screen. Arguments: `text` string.
-
-```bash
-opencode-drive send --name demo \
-  --command.ui.type '{"text":"Find the relevant code and explain it"}' \
-  --command.ui.enter
-
-opencode-drive send --name demo \
-  --command.ui.press '{"key":"p","modifiers":{"ctrl":true}}'
-
-opencode-drive send --name demo \
-  --command.ui.arrow '{"direction":"down"}'
-
-opencode-drive send --name demo \
-  --command.ui.focus '{"target":12}'
-
-opencode-drive send --name demo \
-  --command.ui.click '{"target":12,"x":4,"y":1}'
-
-opencode-drive send --name demo \
-  --command.ui.matches '{"text":"OpenCode"}'
-```
-
-To read the UI state and see information about interactable elements, use the `ui.state` command:
-
-```bash
-opencode-drive send --name demo --command.ui.state
-```
-
-## Configure LLM Responses
-
-- `responses` controls what the LLM responds with
-- Only use this if you are wanting to reproduce an exact type of response
-- Defaults are `text,reasoning,diff,tool` with `write,apply_patch`.
-- Supported types are `text`, `reasoning`, `diff`, and `tool`.
-- `--tools` limits generated tool calls to names offered by OpenCode.
-
-```bash
-opencode-drive responses --name demo \
-  --types text,reasoning,diff,tool \
-  --tools write,apply_patch
-
-opencode-drive responses --name demo \
-  --types tool \
-  --tools read,glob,grep
-```
-
-## Inspect The UI
-
-- `ui.state` prints focus and interactive element metadata as JSON.
-- `ui.matches` checks for literal, case-sensitive screen text.
-- `screenshot` prints the generated image path.
-
-```bash
-opencode-drive screenshot --name demo
-```
-
-## Lifecycle
-
-- `stop` waits for recording export and owner cleanup before returning.
-
-```bash
-opencode-drive stop --name demo
-```
-
-# Record The UI
-
-- Start with `--record` to capture a headless instance from its first rendered frame.
-- `stop` finishes the recording, exports an MP4, and prints its path.
-
-```bash
-opencode-drive start --name demo --record
-
-opencode-drive send --name demo \
-  --command.ui.type '{"text":"Show me the current architecture"}' \
-  --command.ui.enter
-
-opencode-drive stop --name demo
-```
-
-# Artifacts dir
-
-- `dir` prints the artifact directory for the instance.
-
-```bash
-opencode-drive dir --name demo
-```

.opencode/tool/github-triage.ts

@@ -4,7 +4,7 @@ import { tool } from "@opencode-ai/plugin"
 const TEAM = {
   tui: ["kommander", "simonklee"],
   desktop_web: ["Hona", "Brendonovich"],
-  core: ["jlongster", "rekram1-node", "nexxeln", "kitlangton"],
+  core: ["jlongster", "rekram1-node", "neriousy", "nexxeln", "kitlangton"],
   inference: ["fwang", "MrMushrooooom", "starptech"],
   windows: ["Hona"],
 } as const

AGENTS.md

@@ -1,8 +1,9 @@
 - After changing the public Protocol or Server `HttpApi`, run `bun run generate` from `packages/client`. Do not edit `src/generated` or `src/generated-effect` directly.
 - Keep runtime dependencies directed from Schema to Core and Protocol, then from Core and Protocol to Server. Client runtime code may depend on Schema and Protocol but never Core or Server; `sdk-next` composes Client, Core, and Server.
 - Do not modify `packages/opencode` unless the user explicitly asks for V1 work. `packages/opencode` is the V1 implementation and is present for reference only. New implementation changes should land in the V2 package set: `packages/core`, `packages/cli`, `packages/server`, `packages/protocol`, `packages/schema`, and related generated client surfaces when required.
-- The default branch in this repo is `dev`.
-- Local `main` ref may not exist; use `dev` or `origin/dev` for diffs.
+- The default branch in this repo is `v2`.
+- Base all new branches and worktrees on `v2`, or `origin/v2` when the local `v2` ref is unavailable. Do not base them on `dev`.
+- Local `main` ref may not exist; use `v2` or `origin/v2` for diffs.
 
 ## Live V2 TUI Testing
 

package.json

@@ -46,9 +46,9 @@
       "@octokit/rest": "22.0.0",
       "@hono/standard-validator": "0.2.0",
       "@hono/zod-validator": "0.4.2",
-      "@opentui/core": "0.0.0-20260808-9ecf7c0a",
-      "@opentui/keymap": "0.0.0-20260808-9ecf7c0a",
-      "@opentui/solid": "0.0.0-20260808-9ecf7c0a",
+      "@opentui/core": "0.5.2",
+      "@opentui/keymap": "0.5.2",
+      "@opentui/solid": "0.5.2",
       "@tanstack/solid-virtual": "3.13.32",
       "@shikijs/stream": "4.2.0",
       "@standard-schema/spec": "1.1.0",
@@ -120,7 +120,8 @@
     "prettier": "3.6.2",
     "semver": "^7.6.0",
     "sst": "catalog:",
-    "turbo": "2.10.2"
+    "turbo": "2.10.2",
+    "vitest": "4.1.10"
   },
   "dependencies": {
     "@aws-sdk/client-s3": "3.933.0",
@@ -150,9 +151,9 @@
     "electron"
   ],
   "overrides": {
-    "@opentui/core": "0.0.0-20260808-9ecf7c0a",
-    "@opentui/keymap": "0.0.0-20260808-9ecf7c0a",
-    "@opentui/solid": "0.0.0-20260808-9ecf7c0a",
+    "@opentui/core": "catalog:",
+    "@opentui/keymap": "catalog:",
+    "@opentui/solid": "catalog:",
     "@types/bun": "catalog:",
     "@types/node": "catalog:",
     "effect": "catalog:"
@@ -172,6 +173,7 @@
     "@modelcontextprotocol/sdk@1.29.0": "patches/@modelcontextprotocol%2Fsdk@1.29.0.patch",
     "effect@4.0.0-beta.101": "patches/effect@4.0.0-beta.101.patch",
     "@tanstack/virtual-core@3.17.3": "patches/@tanstack%2Fvirtual-core@3.17.3.patch",
+    "@cloudflare/vitest-pool-workers@0.12.6": "patches/@cloudflare%2Fvitest-pool-workers@0.12.6.patch",
     "@ff-labs/fff-bun@0.10.1": "patches/@ff-labs%2Ffff-bun@0.10.1.patch"
   }
 }

packages/app/src/context/global-sync/event-reducer.ts

@@ -1,4 +1,5 @@
 import { Binary } from "@opencode-ai/core/util/binary"
+import { ProjectDirectories } from "@opencode-ai/schema/project-directories"
 import { produce, reconcile, type SetStoreFunction, type Store } from "solid-js/store"
 import type { Message, Part, Project, Todo } from "@/types"
 import type {
@@ -187,6 +188,18 @@ export function applyDirectoryEvent(input: {
       input.setStore("sessionTotal", (value) => Math.max(0, value - 1))
       break
     }
+    case "project.directory.resolved": {
+      const properties = event.properties as { projectID: string; directory: string; previous: string }
+      input.store.session.forEach((session, index) => {
+        const adopted = ProjectDirectories.adopt(
+          { projectID: session.projectID, directory: session.location.directory },
+          properties,
+        )
+        if (!adopted) return
+        input.setStore("session", index, (current) => ({ ...current, ...adopted }))
+      })
+      break
+    }
     case "session.renamed": {
       const properties = event.properties as { sessionID: string; title: string }
       const result = Binary.search(input.store.session, properties.sessionID, (session) => session.id)

packages/app/src/context/server-session-v2-reducer.test.ts

@@ -18,18 +18,18 @@ describe("v2 session reducer", () => {
     apply({
       ...base,
       id: "evt_admitted",
-      type: "session.input.admitted",
+      type: "session.inbox.enqueued",
       data: {
         sessionID: "ses_1",
-        inputID: "msg_user",
-        input: { type: "user", delivery: "steer", data: { text: "hello" } },
+        inboxID: "msg_user",
+        item: { type: "user", delivery: "steer", payload: { text: "hello" } },
       },
     })
     apply({
       ...base,
       id: "evt_promoted",
-      type: "session.input.promoted",
-      data: { sessionID: "ses_1", inputID: "msg_user" },
+      type: "session.inbox.delivered",
+      data: { sessionID: "ses_1", inboxID: "msg_user" },
     })
     apply({
       ...base,
@@ -203,8 +203,8 @@ describe("v2 session reducer", () => {
       event({
         ...base,
         id: "evt_promoted",
-        type: "session.input.promoted",
-        data: { sessionID: "ses_1", inputID: "msg_user" },
+        type: "session.inbox.delivered",
+        data: { sessionID: "ses_1", inboxID: "msg_user" },
       }),
     )
 
@@ -218,11 +218,11 @@ describe("v2 session reducer", () => {
       event({
         ...base,
         id: "evt_admitted",
-        type: "session.input.admitted",
+        type: "session.inbox.enqueued",
         data: {
           sessionID: "ses_1",
-          inputID: "msg_user",
-          input: { type: "user", delivery: "queue", data: { text: "cancel me" } },
+          inboxID: "msg_user",
+          item: { type: "user", delivery: "queue", payload: { text: "cancel me" } },
         },
       }),
     )
@@ -231,8 +231,8 @@ describe("v2 session reducer", () => {
       event({
         ...base,
         id: "evt_cancelled",
-        type: "session.input.cancelled",
-        data: { sessionID: "ses_1", inputID: "msg_user" },
+        type: "session.inbox.cancelled",
+        data: { sessionID: "ses_1", inboxID: "msg_user" },
       }),
     )
     const result = reducer.reduce(
@@ -240,8 +240,8 @@ describe("v2 session reducer", () => {
       event({
         ...base,
         id: "evt_promoted",
-        type: "session.input.promoted",
-        data: { sessionID: "ses_1", inputID: "msg_user" },
+        type: "session.inbox.delivered",
+        data: { sessionID: "ses_1", inboxID: "msg_user" },
       }),
     )
 
@@ -255,11 +255,11 @@ describe("v2 session reducer", () => {
       event({
         ...base,
         id: "evt_admitted",
-        type: "session.input.admitted",
+        type: "session.inbox.enqueued",
         data: {
           sessionID: "ses_1",
-          inputID: "msg_user",
-          input: { type: "user", delivery: "queue", data: { text: "steer me" } },
+          inboxID: "msg_user",
+          item: { type: "user", delivery: "queue", payload: { text: "steer me" } },
         },
       }),
     )
@@ -268,8 +268,8 @@ describe("v2 session reducer", () => {
       event({
         ...base,
         id: "evt_steered",
-        type: "session.input.steered",
-        data: { sessionID: "ses_1", inputID: "msg_user" },
+        type: "session.inbox.delivery.changed",
+        data: { sessionID: "ses_1", inboxID: "msg_user", delivery: "steer" },
       }),
     )
     reducer.reduce(
@@ -277,8 +277,8 @@ describe("v2 session reducer", () => {
       event({
         ...base,
         id: "evt_queued",
-        type: "session.input.queued",
-        data: { sessionID: "ses_1", inputID: "msg_user" },
+        type: "session.inbox.delivery.changed",
+        data: { sessionID: "ses_1", inboxID: "msg_user", delivery: "queue" },
       }),
     )
 
@@ -287,8 +287,8 @@ describe("v2 session reducer", () => {
       event({
         ...base,
         id: "evt_promoted",
-        type: "session.input.promoted",
-        data: { sessionID: "ses_1", inputID: "msg_user" },
+        type: "session.inbox.delivered",
+        data: { sessionID: "ses_1", inboxID: "msg_user" },
       }),
     )
 

packages/app/src/context/server-session-v2-reducer.ts

@@ -1,4 +1,4 @@
-import type { OpenCodeEvent, SessionMessageInfo, SessionPendingMessage } from "@opencode-ai/client/promise"
+import type { OpenCodeEvent, SessionInboxItem, SessionMessageInfo } from "@opencode-ai/client/promise"
 
 type Assistant = Extract<SessionMessageInfo, { type: "assistant" }>
 type Compaction = Extract<SessionMessageInfo, { type: "compaction" }>
@@ -12,7 +12,7 @@ export type V2SessionReduction = {
 }
 
 export function createV2SessionReducer() {
-  const pending = new Map<string, SessionPendingMessage>()
+  const pending = new Map<string, SessionInboxItem>()
 
   const reduce = (source: readonly SessionMessageInfo[], event: OpenCodeEvent): V2SessionReduction | undefined => {
     if (!("data" in event) || !("sessionID" in event.data) || typeof event.data.sessionID !== "string") return
@@ -26,32 +26,33 @@ export function createV2SessionReducer() {
       result(source.some((item) => item.id === message.id) ? [...source] : [...source, message], [message.id])
 
     switch (event.type) {
-      case "session.input.admitted":
-        pending.set(key(sessionID, event.data.inputID), event.data.input)
+      case "session.inbox.enqueued":
+        pending.set(key(sessionID, event.data.inboxID), event.data.item)
         return result([...source])
-      case "session.input.cancelled":
-        pending.delete(key(sessionID, event.data.inputID))
+      case "session.inbox.cancelled":
+        pending.delete(key(sessionID, event.data.inboxID))
         return
-      case "session.input.promoted": {
-        const input = pending.get(key(sessionID, event.data.inputID))
-        pending.delete(key(sessionID, event.data.inputID))
-        if (!input) return { ...result([...source]), missing: event.data.inputID }
+      case "session.inbox.delivered": {
+        const input = pending.get(key(sessionID, event.data.inboxID))
+        pending.delete(key(sessionID, event.data.inboxID))
+        if (!input) return { ...result([...source]), missing: event.data.inboxID }
         if (input.type === "user")
           return append({
-            id: event.data.inputID,
+            id: event.data.inboxID,
             type: "user",
-            metadata: input.data.metadata,
-            text: input.data.text,
-            files: input.data.files,
-            agents: input.data.agents,
+            metadata: input.payload.metadata,
+            text: input.payload.text,
+            files: input.payload.files,
+            agents: input.payload.agents,
             time: { created: event.created },
           })
+        if (input.type !== "synthetic") return result([...source])
         return append({
-          id: event.data.inputID,
+          id: event.data.inboxID,
           type: "synthetic",
-          metadata: input.data.metadata,
-          text: input.data.text,
-          description: input.data.description,
+          metadata: input.payload.metadata,
+          text: input.payload.text,
+          description: input.payload.description,
           time: { created: event.created },
         })
       }
@@ -351,7 +352,7 @@ export function createV2SessionReducer() {
           metadata: event.metadata,
           reason: event.data.reason,
           summary: "",
-          recent: event.data.recent,
+          recent: event.data.recent ?? "",
           time: { created: event.created },
         })
       case "session.compaction.delta":

packages/app/src/context/server-session.ts

@@ -1,4 +1,5 @@
 import { Binary } from "@opencode-ai/core/util/binary"
+import { ProjectDirectories } from "@opencode-ai/schema/project-directories"
 import { retry } from "@opencode-ai/core/util/retry"
 import type { OpenCodeEvent, SessionApi, SessionInfo, SessionMessageInfo } from "@opencode-ai/client/promise"
 import type { Message, Part, Todo } from "@/types"
@@ -894,6 +895,17 @@ export function createServerSession(
   }
 
   const applyV2 = (event: OpenCodeEvent) => {
+    if (event.type === "project.directory.resolved") {
+      Object.values(data.info).forEach((info) => {
+        if (!info) return
+        const adopted = ProjectDirectories.adopt(
+          { projectID: info.projectID, directory: info.location.directory },
+          event.data,
+        )
+        if (adopted) remember({ ...info, ...adopted })
+      })
+      return
+    }
     if (!("data" in event) || !("sessionID" in event.data) || typeof event.data.sessionID !== "string") return
     const sessionID = event.data.sessionID
     const reduction = v2.reduce(data.session_message[sessionID] ?? [], event)

packages/cli/src/acp/event.ts

@@ -538,9 +538,8 @@ async function replayMessage(
 }
 
 function matchesStart(event: EventSubscribeOutput, start: TurnStart) {
-  if (start.type === "input") return event.type === "session.input.promoted" && event.data.inputID === start.id
-  if (start.type === "compaction")
-    return event.type === "session.compaction.admitted" && event.data.inputID === start.id
+  if (start.type === "input") return event.type === "session.inbox.delivered" && event.data.inboxID === start.id
+  if (start.type === "compaction") return event.type === "session.inbox.delivered" && event.data.inboxID === start.id
   return event.type === "session.skill.activated" && event.id === start.id.replace(/^msg_/, "evt_")
 }
 

packages/cli/src/run/noninteractive.ts

@@ -195,8 +195,8 @@ export async function runNonInteractivePrompt(input: Input) {
       if (!("sessionID" in event.data) || event.data.sessionID !== input.sessionID) continue
       const time = toMillis("created" in event ? event.created : undefined)
 
-      if (event.type === "session.input.promoted") {
-        if (event.data.inputID === messageID) {
+      if (event.type === "session.inbox.delivered") {
+        if (event.data.inboxID === messageID) {
           promoted = true
           prePromotionError = undefined
           continue

packages/cli/src/services/update-preflight.tsx

@@ -447,7 +447,7 @@ function UpdateFooter(props: {
   })
 
   return (
-    <box width="100%" height={4} flexDirection="row" gap={1} live={props.animating()}>
+    <box width="100%" height={4} flexDirection="row" gap={1} paddingLeft={1} live={props.animating()}>
       <Monogram ink={monogramInk} />
       <box flexDirection="column" flexGrow={1} overflow="hidden">
         <CellLine cells={header()} />

packages/cli/test/acp/event-behavior.test.ts

@@ -22,8 +22,8 @@ describe("acp event behavior", () => {
             delta: "before admission",
           }),
         )
-        send(durableEvent("session.input.promoted", { sessionID: "ses_b", inputID: id }))
-        send(durableEvent("session.input.promoted", { sessionID: "ses_a", inputID: "input_other" }))
+        send(durableEvent("session.inbox.delivered", { sessionID: "ses_b", inboxID: id }))
+        send(durableEvent("session.inbox.delivered", { sessionID: "ses_a", inboxID: "input_other" }))
         send(
           ephemeralEvent("session.text.delta", {
             sessionID: "ses_a",
@@ -32,7 +32,7 @@ describe("acp event behavior", () => {
             delta: "wrong input",
           }),
         )
-        send(durableEvent("session.input.promoted", { sessionID: "ses_a", inputID: id }))
+        send(durableEvent("session.inbox.delivered", { sessionID: "ses_a", inboxID: id }))
         send(
           ephemeralEvent("session.text.delta", {
             sessionID: "ses_b",
@@ -68,7 +68,7 @@ describe("acp event behavior", () => {
         fixture,
         connection: recordingConnection(updates),
         sessionID: "ses_a",
-        inputID: "input_a",
+        inboxID: "input_a",
       })
 
       expect(fixture.requests.slice(0, 2).map((request) => request.path)).toEqual([
@@ -99,7 +99,7 @@ describe("acp event behavior", () => {
     const updates: SessionUpdateParams[] = []
     const fixture = createSseFixture({
       async onPrompt({ id, send }) {
-        send(durableEvent("session.input.promoted", { sessionID: "ses_order", inputID: id }))
+        send(durableEvent("session.inbox.delivered", { sessionID: "ses_order", inboxID: id }))
         send(
           ephemeralEvent("session.reasoning.delta", {
             sessionID: "ses_order",
@@ -148,7 +148,7 @@ describe("acp event behavior", () => {
       },
       requestPermission: async () => ({ outcome: { outcome: "cancelled" } }),
     } satisfies Connection
-    const result = turn({ fixture, connection, sessionID: "ses_order", inputID: "input_order" })
+    const result = turn({ fixture, connection, sessionID: "ses_order", inboxID: "input_order" })
 
     try {
       await withTimeout(firstUpdate.promise, "first ordered update was not delivered")
@@ -195,7 +195,7 @@ describe("acp event behavior", () => {
     const updates: SessionUpdateParams[] = []
     const fixture = createSseFixture({
       onPrompt({ id, send }) {
-        send(durableEvent("session.input.promoted", { sessionID: "ses_parent", inputID: id }))
+        send(durableEvent("session.inbox.delivered", { sessionID: "ses_parent", inboxID: id }))
         send(
           durableEvent("session.created", {
             sessionID: "ses_child",
@@ -240,7 +240,7 @@ describe("acp event behavior", () => {
         fixture,
         connection: recordingConnection(updates),
         sessionID: "ses_parent",
-        inputID: "input_parent",
+        inboxID: "input_parent",
       })
 
       expect(updates.map((item) => [item.sessionId, item.update.sessionUpdate])).toEqual([
@@ -276,7 +276,7 @@ describe("acp event behavior", () => {
     const completed = Promise.withResolvers<void>()
     const fixture = createSseFixture({
       onPrompt({ id, send }) {
-        send(durableEvent("session.input.promoted", { sessionID: "ses_parent", inputID: id }))
+        send(durableEvent("session.inbox.delivered", { sessionID: "ses_parent", inboxID: id }))
         send(
           durableEvent("session.created", {
             sessionID: "ses_background",
@@ -292,7 +292,7 @@ describe("acp event behavior", () => {
         fixture,
         connection: recordingConnection(updates),
         sessionID: "ses_parent",
-        inputID: "input_parent",
+        inboxID: "input_parent",
         childSessionUpdate: async (update) => {
           childUpdates.push(update)
           if (update.type === "status" && update.status === "completed") completed.resolve()
@@ -370,7 +370,7 @@ describe("acp event behavior", () => {
     const updates: SessionUpdateParams[] = []
     const fixture = createSseFixture({
       onPrompt({ id, send }) {
-        send(durableEvent("session.input.promoted", { sessionID: "ses_tools", inputID: id }))
+        send(durableEvent("session.inbox.delivered", { sessionID: "ses_tools", inboxID: id }))
         send(
           durableEvent("session.tool.input.started", {
             sessionID: "ses_tools",
@@ -460,7 +460,7 @@ describe("acp event behavior", () => {
         fixture,
         connection: recordingConnection(updates),
         sessionID: "ses_tools",
-        inputID: "input_tools",
+        inboxID: "input_tools",
       })
 
       expect(
@@ -597,7 +597,7 @@ describe("acp event behavior", () => {
     const control: TurnControl = { cancelled: false, admission: new AbortController() }
     const fixture = createSseFixture({
       onPrompt({ id, send }) {
-        send(durableEvent("session.input.promoted", { sessionID: "ses_cancel", inputID: id }))
+        send(durableEvent("session.inbox.delivered", { sessionID: "ses_cancel", inboxID: id }))
       },
       onInterrupt({ sessionID, send }) {
         send(durableEvent("session.execution.interrupted", { sessionID, reason: "user" }))
@@ -680,7 +680,7 @@ describe("acp event behavior", () => {
   test("cancels unsupported session forms so execution can continue", async () => {
     const fixture = createSseFixture({
       onPrompt({ id, send }) {
-        send(durableEvent("session.input.promoted", { sessionID: "ses_form", inputID: id }))
+        send(durableEvent("session.inbox.delivered", { sessionID: "ses_form", inboxID: id }))
         send(
           ephemeralEvent("form.created", {
             form: {
@@ -704,7 +704,7 @@ describe("acp event behavior", () => {
         fixture,
         connection: recordingConnection([]),
         sessionID: "ses_form",
-        inputID: "input_form",
+        inboxID: "input_form",
       })
 
       expect(response.stopReason).toBe("end_turn")
@@ -730,7 +730,7 @@ function turn(input: {
   readonly fixture: Fixture
   readonly connection: Connection
   readonly sessionID: string
-  readonly inputID: string
+  readonly inboxID: string
   readonly childSessionUpdate?: (update: ChildSessionUpdate) => Promise<void>
 }) {
   return streamTurn({
@@ -738,12 +738,12 @@ function turn(input: {
     connection: input.connection,
     sessionID: input.sessionID,
     cwd: "/workspace",
-    start: { type: "input", id: input.inputID },
+    start: { type: "input", id: input.inboxID },
     writeTextFile: false,
     control: { cancelled: false, admission: new AbortController() },
     childSessionUpdate: input.childSessionUpdate,
     submit: (signal) =>
-      input.fixture.client.session.prompt({ sessionID: input.sessionID, id: input.inputID, text: "hello" }, { signal }),
+      input.fixture.client.session.prompt({ sessionID: input.sessionID, id: input.inboxID, text: "hello" }, { signal }),
   })
 }
 

packages/cli/test/acp/event.test.ts

@@ -34,8 +34,8 @@ test("acp prompt resolves after ordered turn updates", async () => {
           send(events, {
             id: "evt_promoted",
             created: 1,
-            type: "session.input.promoted",
-            data: { sessionID: "ses_test", inputID: id },
+            type: "session.inbox.delivered",
+            data: { sessionID: "ses_test", inboxID: id },
           })
           send(events, {
             id: "evt_text",

packages/cli/test/acp/permission-behavior.test.ts

@@ -38,7 +38,7 @@ describe("acp permission behavior", () => {
     const permissionRequests: RequestPermissionRequest[] = []
     const fixture = createSseFixture({
       onPrompt({ id, send }) {
-        send(durableEvent("session.input.promoted", { sessionID: "ses_allow", inputID: id }))
+        send(durableEvent("session.inbox.delivered", { sessionID: "ses_allow", inboxID: id }))
         send(
           permissionAsked("ses_allow", "perm_once", {
             action: "shell",
@@ -112,7 +112,7 @@ describe("acp permission behavior", () => {
     const permissionRequests: RequestPermissionRequest[] = []
     const fixture = createSseFixture({
       onPrompt({ id, send }) {
-        send(durableEvent("session.input.promoted", { sessionID: "ses_external", inputID: id }))
+        send(durableEvent("session.inbox.delivered", { sessionID: "ses_external", inboxID: id }))
         send(
           permissionAsked("ses_external", "perm_external", {
             action: "external_directory",
@@ -157,7 +157,7 @@ describe("acp permission behavior", () => {
     const permissionRequests: RequestPermissionRequest[] = []
     const fixture = createSseFixture({
       onPrompt({ id, send }) {
-        send(durableEvent("session.input.promoted", { sessionID: "ses_parent", inputID: id }))
+        send(durableEvent("session.inbox.delivered", { sessionID: "ses_parent", inboxID: id }))
         send(
           durableEvent("session.created", {
             sessionID: "ses_child",
@@ -219,7 +219,7 @@ describe("acp permission behavior", () => {
     const writes: Parameters<AgentSideConnection["writeTextFile"]>[0][] = []
     const fixture = createSseFixture({
       onPrompt({ id, send }) {
-        send(durableEvent("session.input.promoted", { sessionID: "ses_edit", inputID: id }))
+        send(durableEvent("session.inbox.delivered", { sessionID: "ses_edit", inboxID: id }))
         send(
           durableEvent("session.tool.input.started", {
             sessionID: "ses_edit",
@@ -309,7 +309,7 @@ describe("acp permission behavior", () => {
     const writes: Parameters<AgentSideConnection["writeTextFile"]>[0][] = []
     const fixture = createSseFixture({
       onPrompt({ id, send }) {
-        send(durableEvent("session.input.promoted", { sessionID: "ses_patch", inputID: id }))
+        send(durableEvent("session.inbox.delivered", { sessionID: "ses_patch", inboxID: id }))
         send(
           durableEvent("session.tool.input.started", {
             sessionID: "ses_patch",
@@ -389,7 +389,7 @@ describe("acp permission behavior", () => {
   test("rejects explicit rejection, cancellation, and permission UI failure", async () => {
     const fixture = createSseFixture({
       onPrompt({ id, send }) {
-        send(durableEvent("session.input.promoted", { sessionID: "ses_reject", inputID: id }))
+        send(durableEvent("session.inbox.delivered", { sessionID: "ses_reject", inboxID: id }))
         send(permissionAsked("ses_reject", "perm_selected_reject"))
         send(permissionAsked("ses_reject", "perm_cancelled"))
         send(permissionAsked("ses_reject", "perm_failed"))
@@ -426,7 +426,7 @@ describe("acp permission behavior", () => {
     const permissionRequests: RequestPermissionRequest[] = []
     const fixture = createSseFixture({
       onPrompt({ id, send }) {
-        send(durableEvent("session.input.promoted", { sessionID: "ses_serial", inputID: id }))
+        send(durableEvent("session.inbox.delivered", { sessionID: "ses_serial", inboxID: id }))
         send(permissionAsked("ses_serial", "perm_1"))
         send(permissionAsked("ses_serial", "perm_2"))
         send(durableEvent("session.execution.succeeded", { sessionID: "ses_serial" }))
@@ -477,8 +477,8 @@ describe("acp permission behavior", () => {
         const blockedID = promptIDs.get("ses_blocked")
         const freeID = promptIDs.get("ses_free")
         if (!blockedID || !freeID) throw new Error("both permission test prompts must be registered")
-        send(durableEvent("session.input.promoted", { sessionID: "ses_blocked", inputID: blockedID }))
-        send(durableEvent("session.input.promoted", { sessionID: "ses_free", inputID: freeID }))
+        send(durableEvent("session.inbox.delivered", { sessionID: "ses_blocked", inboxID: blockedID }))
+        send(durableEvent("session.inbox.delivered", { sessionID: "ses_free", inboxID: freeID }))
         send(permissionAsked("ses_blocked", "perm_blocked"))
         send(
           ephemeralEvent("session.text.delta", {
@@ -538,16 +538,16 @@ describe("acp permission behavior", () => {
   })
 })
 
-function startTurn(fixture: Fixture, connection: Connection, sessionID: string, inputID: string, cwd = "/workspace") {
+function startTurn(fixture: Fixture, connection: Connection, sessionID: string, inboxID: string, cwd = "/workspace") {
   return streamTurn({
     client: fixture.client,
     connection,
     sessionID,
     cwd,
-    start: { type: "input", id: inputID },
+    start: { type: "input", id: inboxID },
     writeTextFile: true,
     control: { cancelled: false, admission: new AbortController() },
-    submit: (signal) => fixture.client.session.prompt({ sessionID, id: inputID, text: "hello" }, { signal }),
+    submit: (signal) => fixture.client.session.prompt({ sessionID, id: inboxID, text: "hello" }, { signal }),
   })
 }
 

packages/cli/test/acp/service-usage.test.ts

@@ -15,8 +15,8 @@ describe("acp service prompt routing and usage", () => {
           const id = requestID(request)
           completeTurn(context, "ses_routes", {
             id: `evt_${id}`,
-            type: "session.input.promoted",
-            data: { sessionID: "ses_routes", inputID: id },
+            type: "session.inbox.delivered",
+            data: { sessionID: "ses_routes", inboxID: id },
           })
           return Response.json({ data: {} })
         }
@@ -33,8 +33,8 @@ describe("acp service prompt routing and usage", () => {
           const id = requestID(request)
           completeTurn(context, "ses_routes", {
             id: `evt_${id}`,
-            type: "session.compaction.admitted",
-            data: { sessionID: "ses_routes", inputID: id },
+            type: "session.inbox.delivered",
+            data: { sessionID: "ses_routes", inboxID: id },
           })
           return Response.json({ data: {} })
         }
@@ -95,8 +95,8 @@ describe("acp service prompt routing and usage", () => {
           const id = requestID(request)
           context.send({
             id: `evt_${id}`,
-            type: "session.input.promoted",
-            data: { sessionID: "ses_usage", inputID: id },
+            type: "session.inbox.delivered",
+            data: { sessionID: "ses_usage", inboxID: id },
           })
           context.send({
             id: "evt_step",
@@ -189,8 +189,8 @@ describe("acp service prompt routing and usage", () => {
           const id = requestID(request)
           context.send({
             id: `evt_${id}`,
-            type: "session.input.promoted",
-            data: { sessionID: "ses_usage_failure", inputID: id },
+            type: "session.inbox.delivered",
+            data: { sessionID: "ses_usage_failure", inboxID: id },
           })
           context.send({
             id: "evt_step_failure",

packages/cli/test/drive/mini-interactive.drive.mjs

@@ -1,371 +0,0 @@
-import { Effect } from "effect"
-import { defineScript, Llm } from "opencode-drive"
-import { mkdir } from "node:fs/promises"
-import path from "node:path"
-
-export default defineScript({
-  launch: "manual",
-  config: { autoupdate: false },
-  run: ({ artifacts, llm, server }) =>
-    Effect.gen(function* () {
-      yield* Effect.promise(() => configureServicePort(artifacts))
-      yield* server.launch()
-
-      const registration = yield* Effect.promise(() => serviceRegistration(artifacts))
-      const root = path.resolve(import.meta.dir, "../../../..")
-      const preload = Bun.resolveSync("@opentui/solid/preload", path.join(root, "packages/cli"))
-      const session = `mini-stage2-${process.pid}`
-      const snapshots = path.join(artifacts, "mini-stage2")
-      const explicitDirectory = path.join(artifacts, "explicit-model")
-      yield* Effect.promise(() =>
-        Promise.all([snapshots, explicitDirectory].map((dir) => mkdir(dir, { recursive: true }))),
-      )
-      /** @param {string} directory @param {string | undefined} model */
-      const mini = (directory, model) => [
-        "env",
-        `PWD=${directory}`,
-        `OPENCODE_PASSWORD=${registration.password}`,
-        `OPENCODE_CONFIG_DIR=${path.join(artifacts, "files/.opencode")}`,
-        `OPENCODE_TEST_HOME=${artifacts}`,
-        `XDG_CACHE_HOME=${path.join(artifacts, "home/.cache")}`,
-        `XDG_CONFIG_HOME=${path.join(artifacts, "home/.config")}`,
-        `XDG_DATA_HOME=${path.join(artifacts, "logs")}`,
-        `XDG_STATE_HOME=${path.join(artifacts, "home/.local/state")}`,
-        "OPENCODE_DISABLE_AUTOUPDATE=1",
-        "OPENCODE_DIRECT_TRACE=1",
-        process.execPath,
-        "--conditions=browser",
-        `--preload=${preload}`,
-        path.join(root, "packages/cli/src/index.ts"),
-        "mini",
-        "--server",
-        registration.url,
-        ...(model ? ["--model", model] : []),
-      ]
-
-      yield* llm.queue(
-        Llm.toolCall({
-          index: 0,
-          id: "mini-shell",
-          name: "shell",
-          input: { command: "printf 'drive-mini-tool-output\\n'" },
-        }),
-        Llm.finish("tool-calls"),
-      )
-      yield* llm.queue(Llm.text("drive mini response complete", { delay: 5, chunkSize: 4 }))
-
-      const journey = Effect.gen(function* () {
-        yield* Effect.uninterruptible(
-          Effect.promise(() =>
-            tmux([
-              "new-session",
-              "-d",
-              "-s",
-              session,
-              "-x",
-              "140",
-              "-y",
-              "30",
-              "--",
-              ...mini(path.join(artifacts, "files"), undefined),
-            ]),
-          ),
-        )
-        yield* Effect.promise(() => tmux(["set-option", "-t", session, "remain-on-exit", "on"]))
-
-        const first = yield* Effect.promise(() => waitForPane(session, "OpenCode"))
-        yield* Effect.promise(() => Bun.write(path.join(snapshots, "01-first-paint.txt"), first))
-        if (first.includes("drive mini response complete"))
-          throw new Error("response rendered before prompt submission")
-
-        yield* Effect.promise(() => waitForPane(session, "Default model", 15_000))
-        yield* Effect.promise(() => tmux(["send-keys", "-t", session, "C-p"]))
-        yield* Effect.promise(() => waitForVisiblePane(session, "Commands"))
-        yield* Effect.promise(() => tmux(["send-keys", "-t", session, "-l", "model"]))
-        yield* Effect.promise(() => waitForVisiblePane(session, "Switch model"))
-        yield* Effect.promise(() => tmux(["send-keys", "-H", "-t", session, "0d"]))
-        yield* Effect.promise(() => waitForVisiblePane(session, "Select model"))
-        yield* Effect.promise(() => waitForVisiblePane(session, "Simulated Model", 15_000))
-        yield* Effect.promise(() => tmux(["send-keys", "-t", session, "Escape"]))
-        yield* Effect.promise(() => waitForVisiblePane(session, "Ask anything..."))
-        yield* Effect.promise(() => tmux(["send-keys", "-t", session, "-l", "exercise the mini frontend"]))
-        yield* Effect.sleep(100)
-        yield* Effect.promise(() => tmux(["send-keys", "-H", "-t", session, "0d"]))
-        const completed = yield* Effect.promise(() => waitForPane(session, "drive mini response complete", 20_000))
-        if (!completed.includes("drive-mini-tool-output")) throw new Error("shell tool output was not rendered")
-        yield* Effect.promise(() => Bun.write(path.join(snapshots, "02-tool-and-response.txt"), completed))
-
-        yield* Effect.sleep(500)
-        const resizeOutput = path.join(snapshots, "03-resize-output.ansi")
-        yield* Effect.promise(() => tmux(["pipe-pane", "-t", session, `cat > ${JSON.stringify(resizeOutput)}`]))
-        yield* Effect.promise(() => tmux(["resize-window", "-t", session, "-x", "72", "-y", "22"]))
-        yield* Effect.promise(() =>
-          waitForFile(
-            resizeOutput,
-            (value) => value.includes("drive mini response complete") && value.includes("drive-mini-tool-output"),
-          ),
-        )
-        yield* Effect.promise(() => tmux(["pipe-pane", "-t", session]))
-        const resized = yield* Effect.promise(() => captureVisiblePane(session))
-        if (!resized.includes("drive-mini-tool-output")) throw new Error("resize replay lost shell tool output")
-        yield* Effect.promise(() => Bun.write(path.join(snapshots, "03-resize-replay.txt"), resized))
-
-        yield* llm.queue(
-          Llm.toolCall({
-            index: 0,
-            id: "mini-question",
-            name: "question",
-            input: {
-              questions: [
-                {
-                  header: "Drive form",
-                  question: "Choose the Mini Form answer",
-                  options: [{ label: "Accepted", description: "Continue the run" }],
-                  multiple: false,
-                },
-              ],
-            },
-          }),
-          Llm.finish("tool-calls"),
-        )
-        yield* llm.queue(Llm.text("drive mini form complete"))
-        yield* Effect.promise(() => tmux(["send-keys", "-t", session, "-l", "exercise the form"]))
-        yield* Effect.promise(() => tmux(["send-keys", "-H", "-t", session, "0d"]))
-        yield* Effect.promise(() => waitForPane(session, "Choose the Mini Form answer", 20_000))
-        yield* Effect.promise(() => tmux(["send-keys", "-H", "-t", session, "0d"]))
-        yield* Effect.promise(() => waitForPane(session, "drive mini form complete", 20_000))
-
-        yield* llm.queue(
-          Llm.toolCall({
-            index: 0,
-            id: "mini-slow-shell",
-            name: "shell",
-            input: { command: "sleep 10" },
-          }),
-          Llm.finish("tool-calls"),
-        )
-        yield* Effect.promise(() => tmux(["send-keys", "-t", session, "-l", "interrupt this turn"]))
-        yield* Effect.sleep(100)
-        yield* Effect.promise(() => tmux(["send-keys", "-H", "-t", session, "0d"]))
-        yield* Effect.promise(() => waitForPane(session, "$ sleep 10"))
-        yield* Effect.promise(() => tmux(["send-keys", "-t", session, "Escape"]))
-        const armed = yield* Effect.promise(() => waitForPane(session, "esc again"))
-        yield* Effect.promise(() => Bun.write(path.join(snapshots, "04-interrupt-armed.txt"), armed))
-        yield* Effect.promise(() => tmux(["send-keys", "-t", session, "Escape"]))
-        const interrupted = yield* Effect.promise(() => waitForPane(session, "Step interrupted", 10_000))
-        yield* Effect.promise(() => Bun.write(path.join(snapshots, "05-interrupted.txt"), interrupted))
-
-        yield* Effect.promise(async () => {
-          if (!(await paneAlive(session))) throw new Error("Mini exited while interrupting an active turn")
-        })
-        yield* Effect.promise(() => tmux(["send-keys", "-t", session, "C-c"]))
-        yield* Effect.promise(() => waitForPane(session, "EXIT  Press ctrl+"))
-        yield* Effect.promise(() => tmux(["send-keys", "-t", session, "C-c"]))
-        yield* Effect.promise(() => waitForDeadPane(session))
-        const status = yield* Effect.promise(() => paneDeadStatus(session))
-        if (status !== 0) throw new Error(`Mini exited with status ${status}`)
-        const exited = yield* Effect.promise(() => capturePane(session))
-        if (!exited.includes("Continue") || !exited.includes("opencode mini -s"))
-          throw new Error("Mini exit splash was not rendered before teardown")
-        yield* Effect.promise(() => Bun.write(path.join(snapshots, "06-exit-teardown.txt"), exited))
-
-        yield* Effect.promise(() => tmux(["clear-history", "-t", session]))
-        yield* Effect.promise(() =>
-          tmux(["respawn-pane", "-k", "-t", session, "--", ...mini(explicitDirectory, "simulation/gpt-sim-model")]),
-        )
-        const explicitModel = yield* Effect.promise(() => waitForPane(session, "Simulated Model", 15_000))
-        yield* Effect.promise(() => Bun.write(path.join(snapshots, "07-explicit-model.txt"), explicitModel))
-        yield* Effect.promise(() => tmux(["send-keys", "-t", session, "C-c"]))
-        yield* Effect.promise(() => waitForPane(session, "EXIT  Press ctrl+"))
-        yield* Effect.promise(() => tmux(["send-keys", "-t", session, "C-c"]))
-        yield* Effect.promise(() => waitForDeadPane(session))
-        if ((yield* Effect.promise(() => paneDeadStatus(session))) !== 0)
-          throw new Error("Explicit-model Mini did not exit cleanly")
-
-        yield* Effect.promise(async () => {
-          for (const failure of [
-            {
-              args: ["--model", "simulation/definitely-missing"],
-              capture: "08-unavailable-model.txt",
-              expected: "Model unavailable: simulation/definitely-missing",
-            },
-            {
-              args: ["--agent", "definitely-missing"],
-              capture: "09-unavailable-agent.txt",
-              expected: 'Agent not found: "definitely-missing"',
-            },
-          ]) {
-            const child = Bun.spawn(
-              [
-                process.execPath,
-                path.join(root, "packages/cli/src/index.ts"),
-                "run",
-                "--server",
-                registration.url,
-                ...failure.args,
-                "optimistic selection check",
-              ],
-              {
-                cwd: path.join(root, "packages/cli"),
-                env: {
-                  ...process.env,
-                  PWD: path.join(artifacts, "files"),
-                  OPENCODE_PASSWORD: registration.password,
-                  OPENCODE_CONFIG_DIR: path.join(artifacts, "files/.opencode"),
-                  OPENCODE_DISABLE_AUTOUPDATE: "1",
-                },
-                stdin: "ignore",
-                stdout: "pipe",
-                stderr: "pipe",
-              },
-            )
-            const [exitCode, stdout, stderr] = await Promise.all([
-              child.exited,
-              new Response(child.stdout).text(),
-              new Response(child.stderr).text(),
-            ])
-            await Bun.write(path.join(snapshots, failure.capture), stdout + stderr)
-            if (exitCode !== 1) throw new Error(`${failure.expected} run exited with status ${exitCode}`)
-            if (!stderr.includes(failure.expected))
-              throw new Error(`Selection failure was not diagnosed by execution: ${stderr}`)
-          }
-        })
-      })
-
-      yield* journey.pipe(Effect.ensuring(Effect.promise(() => tmux(["kill-session", "-t", session], true))))
-    }),
-})
-
-/** @param {string[]} args */
-async function tmux(args, allowFailure = false) {
-  const child = Bun.spawn(["tmux", ...args], { stdout: "pipe", stderr: "pipe" })
-  let timedOut = false
-  const timeout = setTimeout(() => {
-    timedOut = true
-    child.kill("SIGKILL")
-  }, 5_000)
-  const [status, stdout, stderr] = await Promise.all([
-    child.exited,
-    new Response(child.stdout).text(),
-    new Response(child.stderr).text(),
-  ])
-  clearTimeout(timeout)
-  if (timedOut) throw new Error(`tmux ${args[0]} timed out`)
-  if (status !== 0 && !allowFailure) throw new Error(`tmux ${args[0]} failed: ${stderr || stdout}`)
-  return stdout
-}
-
-/** @param {string} session */
-function capturePane(session) {
-  return tmux(["capture-pane", "-p", "-t", session, "-S", "-"])
-}
-
-/** @param {string} session */
-function captureVisiblePane(session) {
-  return tmux(["capture-pane", "-p", "-t", session])
-}
-
-/** @param {string} session @param {string} text @param {number} [timeout] */
-async function waitForVisiblePane(session, text, timeout = 5_000) {
-  const deadline = Date.now() + timeout
-  let last = ""
-  while (Date.now() < deadline) {
-    last = await captureVisiblePane(session)
-    if (last.includes(text)) return last
-    if (!(await paneAlive(session))) throw new Error(`Mini exited before rendering ${JSON.stringify(text)}:\n${last}`)
-    await Bun.sleep(50)
-  }
-  throw new Error(`Timed out waiting for visible ${JSON.stringify(text)}:\n${last}`)
-}
-
-/** @param {string} session */
-async function paneAlive(session) {
-  return (await tmux(["display-message", "-p", "-t", session, "#{pane_dead}"], true)).trim() === "0"
-}
-
-/** @param {string} session */
-async function paneDeadStatus(session) {
-  return Number((await tmux(["display-message", "-p", "-t", session, "#{pane_dead_status}"])).trim())
-}
-
-/**
- * @param {string} session
- * @param {string} text
- * @param {number} [timeout]
- * @param {(() => Promise<void>) | undefined} [trigger]
- */
-async function waitForPane(session, text, timeout = 5_000, trigger) {
-  const deadline = Date.now() + timeout
-  let last = ""
-  while (Date.now() < deadline) {
-    await trigger?.()
-    last = await capturePane(session)
-    if (last.includes(text)) return last
-    if (!(await paneAlive(session))) throw new Error(`Mini exited before rendering ${JSON.stringify(text)}:\n${last}`)
-    await Bun.sleep(50)
-  }
-  throw new Error(`Timed out waiting for ${JSON.stringify(text)}:\n${last}`)
-}
-
-/** @param {string} session */
-async function waitForDeadPane(session) {
-  for (let attempt = 0; attempt < 100; attempt++) {
-    if (!(await paneAlive(session))) return
-    await Bun.sleep(50)
-  }
-  throw new Error("Mini did not tear down after the exit sequence")
-}
-
-/**
- * @param {string} file
- * @param {(value: string) => boolean} accept
- */
-async function waitForFile(file, accept) {
-  let value = ""
-  for (let attempt = 0; attempt < 100; attempt++) {
-    value = await Bun.file(file)
-      .text()
-      .catch(() => "")
-    if (accept(value)) return value
-    await Bun.sleep(50)
-  }
-  throw new Error("resize did not replay committed transcript output")
-}
-
-/** @param {string} artifacts */
-async function configureServicePort(artifacts) {
-  const probe = Bun.serve({ hostname: "127.0.0.1", port: 0, fetch: () => new Response() })
-  const port = probe.port
-  await probe.stop(true)
-  if (!port) throw new Error("Failed to allocate a Drive service port")
-  const file = path.join(artifacts, "files/.opencode/service-local.json")
-  await mkdir(path.dirname(file), { recursive: true })
-  await Bun.write(file, JSON.stringify({ port }))
-}
-
-/** @param {string} artifacts */
-async function serviceRegistration(artifacts) {
-  const directory = path.join(artifacts, "home/.local/state/opencode")
-  for (let attempt = 0; attempt < 200; attempt++) {
-    for (const name of ["service-local.json", "service.json"]) {
-      const value = await Bun.file(path.join(directory, name))
-        .json()
-        .catch(() => undefined)
-      if (isRegistration(value)) return value
-    }
-    await Bun.sleep(50)
-  }
-  throw new Error("Drive service registration was not written")
-}
-
-/** @param {unknown} value */
-function isRegistration(value) {
-  return (
-    typeof value === "object" &&
-    value !== null &&
-    "url" in value &&
-    typeof value.url === "string" &&
-    "password" in value &&
-    typeof value.password === "string"
-  )
-}

packages/cli/test/drive/run-smoke.drive.mjs

@@ -1,87 +0,0 @@
-import { defineScript } from "opencode-drive"
-import { mkdir } from "node:fs/promises"
-import path from "node:path"
-
-export default defineScript({
-  launch: "manual",
-  setup({ config }) {
-    config.autoupdate = false
-  },
-  async run({ artifacts, llm, server }) {
-    await configureServicePort(artifacts)
-    llm.queue(llm.text("drive noninteractive smoke ok"))
-    await server.launch()
-
-    const registration = await serviceRegistration(artifacts)
-    const root = path.resolve(import.meta.dir, "../../../..")
-    const directory = path.join(artifacts, "files")
-    const child = Bun.spawn(
-      [
-        process.execPath,
-        path.join(root, "packages/cli/src/index.ts"),
-        "run",
-        "--server",
-        registration.url,
-        "drive smoke",
-      ],
-      {
-        cwd: path.join(root, "packages/cli"),
-        env: {
-          ...process.env,
-          PWD: directory,
-          OPENCODE_PASSWORD: registration.password,
-          OPENCODE_CONFIG_DIR: path.join(directory, ".opencode"),
-          OPENCODE_DISABLE_AUTOUPDATE: "1",
-        },
-        stdin: "ignore",
-        stdout: "pipe",
-        stderr: "pipe",
-      },
-    )
-    const [exitCode, stdout, stderr] = await Promise.all([
-      child.exited,
-      new Response(child.stdout).text(),
-      new Response(child.stderr).text(),
-    ])
-    if (exitCode !== 0) throw new Error(`run exited ${exitCode}: ${stderr}`)
-    if (stdout !== "drive noninteractive smoke ok\n") throw new Error(`unexpected run output: ${stdout}`)
-  },
-})
-
-/** @param {string} artifacts */
-async function configureServicePort(artifacts) {
-  const probe = Bun.serve({ hostname: "127.0.0.1", port: 0, fetch: () => new Response() })
-  const port = probe.port
-  await probe.stop(true)
-  if (!port) throw new Error("Failed to allocate a Drive service port")
-  const file = path.join(artifacts, "files/.opencode/service-local.json")
-  await mkdir(path.dirname(file), { recursive: true })
-  await Bun.write(file, JSON.stringify({ port }))
-}
-
-/** @param {string} artifacts */
-async function serviceRegistration(artifacts) {
-  const directory = path.join(artifacts, "home/.local/state/opencode")
-  for (let attempt = 0; attempt < 200; attempt++) {
-    for (const name of ["service-local.json", "service.json"]) {
-      const value = await Bun.file(path.join(directory, name))
-        .json()
-        .catch(() => undefined)
-      if (isRegistration(value)) return value
-    }
-    await Bun.sleep(50)
-  }
-  throw new Error("Drive service registration was not written")
-}
-
-/** @param {unknown} value */
-function isRegistration(value) {
-  return (
-    typeof value === "object" &&
-    value !== null &&
-    "url" in value &&
-    typeof value.url === "string" &&
-    "password" in value &&
-    typeof value.password === "string"
-  )
-}

packages/cli/test/run/noninteractive.test.ts

@@ -28,13 +28,13 @@ function formCreated(info: FormInfo, eventLocation = location): V2Event {
   return { id: `evt_${info.id}`, created: 0, type: "form.created", location: eventLocation, data: { form: info } }
 }
 
-function prompted(inputID: string): V2Event {
+function prompted(inboxID: string): V2Event {
   return {
     id: "evt_prompted",
     created: 0,
-    type: "session.input.promoted",
+    type: "session.inbox.delivered",
     durable: { aggregateID: "ses_1", seq: 0, version: 1 },
-    data: { sessionID: "ses_1", inputID },
+    data: { sessionID: "ses_1", inboxID },
   }
 }
 
@@ -98,9 +98,9 @@ function executionFailed(message: string): V2Event {
   }
 }
 
-function failedTool(inputID: string): V2Event[] {
+function failedTool(inboxID: string): V2Event[] {
   return [
-    prompted(inputID),
+    prompted(inboxID),
     {
       id: "evt_failed_tool_input",
       created: 1,
@@ -156,10 +156,10 @@ function failedTool(inputID: string): V2Event[] {
   ]
 }
 
-function successfulGrep(inputID: string): V2Event[] {
+function successfulGrep(inboxID: string): V2Event[] {
   const text = "Found 2 matches\n/src/a.ts:\n  Line 1: needle\n/src/b.ts:\n  Line 2: needle"
   return [
-    prompted(inputID),
+    prompted(inboxID),
     {
       id: "evt_grep_input",
       created: 1,
@@ -206,7 +206,7 @@ function successfulGrep(inputID: string): V2Event[] {
 // Runs one non-interactive prompt against a mocked SDK. `turn` produces the
 // live events the prompt admission triggers, keyed by the generated message ID.
 async function run(input: {
-  turn: (inputID: string) => V2Event[]
+  turn: (inboxID: string) => V2Event[]
   pendingForms?: FormInfo[]
   attached?: boolean
   format?: "default" | "json"
@@ -214,7 +214,7 @@ async function run(input: {
   cancel?: (input: { sessionID: string; formID: string }) => Promise<void>
   renderTool?: (part: SessionMessageAssistantTool) => Promise<void>
   renderToolError?: (part: SessionMessageAssistantTool) => Promise<void>
-  messages?: (inputID: string) => SessionMessageInfo[]
+  messages?: (inboxID: string) => SessionMessageInfo[]
   wait?: () => Promise<void>
   terminalDelay?: number
 }) {
@@ -515,7 +515,7 @@ describe("runNonInteractivePrompt", () => {
     const rendered: SessionMessageAssistantTool[] = []
     const failed: SessionMessageAssistantTool[] = []
     await capture({
-      turn: (inputID) => failedTool(inputID).filter((event) => event.type !== "session.tool.progress"),
+      turn: (inboxID) => failedTool(inboxID).filter((event) => event.type !== "session.tool.progress"),
       renderTool: (part) => {
         rendered.push(part)
         return Promise.resolve()

packages/client/script/build.ts

@@ -30,7 +30,7 @@ import { Reference } from "@opencode-ai/schema/reference"
 import { AbsolutePath, PositiveInt, RelativePath } from "@opencode-ai/schema/schema"
 import { Session } from "@opencode-ai/schema/session"
 import { SessionMessage } from "@opencode-ai/schema/session-message"
-import { SessionPending } from "@opencode-ai/schema/session-pending"
+import { SessionInbox } from "@opencode-ai/schema/session-inbox"
 import { Shell } from "@opencode-ai/schema/shell"
 import { Skill } from "@opencode-ai/schema/skill"
 import { Vcs } from "@opencode-ai/schema/vcs"
@@ -69,7 +69,7 @@ const effectTypeReferences = [
   ...namespaceTypes("Reference", "@opencode-ai/schema/reference", Reference),
   ...namespaceTypes("Session", "@opencode-ai/schema/session", Session),
   ...namespaceTypes("SessionMessage", "@opencode-ai/schema/session-message", SessionMessage),
-  ...namespaceTypes("SessionPending", "@opencode-ai/schema/session-pending", SessionPending),
+  ...namespaceTypes("SessionInbox", "@opencode-ai/schema/session-inbox", SessionInbox),
   ...namespaceTypes("Shell", "@opencode-ai/schema/shell", Shell),
   ...namespaceTypes("Skill", "@opencode-ai/schema/skill", Skill),
   ...namespaceTypes("Vcs", "@opencode-ai/schema/vcs", Vcs),

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

@@ -11,9 +11,9 @@ import type { RelativePath } from "@opencode-ai/schema/schema"
 import type { Brand } from "effect"
 import type { Model } from "@opencode-ai/schema/model"
 import type { SessionMessage } from "@opencode-ai/schema/session-message"
+import type { SessionInbox } from "@opencode-ai/schema/session-inbox"
 import type { PromptInput } from "@opencode-ai/schema/prompt-input"
 import type { AgentAttachment } from "@opencode-ai/schema/prompt"
-import type { SessionPending } from "@opencode-ai/schema/session-pending"
 import type { Skill } from "@opencode-ai/schema/skill"
 import type { Event } from "@opencode-ai/schema/event"
 import type { InstructionEntry } from "@opencode-ai/schema/instruction-entry"
@@ -170,6 +170,7 @@ export type Endpoint5_11Input = {
   readonly sessionID: Session.ID
   readonly directory: AbsolutePath
   readonly workspaceID?: Workspace.ID | undefined
+  readonly delivery?: SessionInbox.Delivery | undefined
 }
 export type Endpoint5_11Output = void
 export type SessionMoveOperation<E = never> = (input: Endpoint5_11Input) => Effect.Effect<Endpoint5_11Output, E>
@@ -182,10 +183,10 @@ export type Endpoint5_12Input = {
   readonly agents?: ReadonlyArray<AgentAttachment> | undefined
   readonly skills?: ReadonlyArray<PromptInput.SkillAttachment> | undefined
   readonly metadata?: { readonly [x: string]: unknown } | undefined
-  readonly delivery?: "steer" | "queue" | undefined
+  readonly delivery?: SessionInbox.Delivery | undefined
   readonly resume?: boolean | undefined
 }
-export type Endpoint5_12Output = SessionPending.User
+export type Endpoint5_12Output = SessionInbox.User
 export type SessionPromptOperation<E = never> = (input: Endpoint5_12Input) => Effect.Effect<Endpoint5_12Output, E>
 
 export type Endpoint5_13Input = {
@@ -198,10 +199,10 @@ export type Endpoint5_13Input = {
   readonly files?: ReadonlyArray<PromptInput.FileAttachment> | undefined
   readonly agents?: ReadonlyArray<AgentAttachment> | undefined
   readonly skills?: ReadonlyArray<PromptInput.SkillAttachment> | undefined
-  readonly delivery?: "steer" | "queue" | undefined
+  readonly delivery?: SessionInbox.Delivery | undefined
   readonly resume?: boolean | undefined
 }
-export type Endpoint5_13Output = SessionPending.User
+export type Endpoint5_13Output = SessionInbox.User
 export type SessionCommandOperation<E = never> = (input: Endpoint5_13Input) => Effect.Effect<Endpoint5_13Output, E>
 
 export type Endpoint5_14Input = {
@@ -219,10 +220,10 @@ export type Endpoint5_15Input = {
   readonly text: string
   readonly description?: string | undefined
   readonly metadata?: { readonly [x: string]: unknown } | undefined
-  readonly delivery?: "steer" | "queue" | undefined
+  readonly delivery?: SessionInbox.Delivery | undefined
   readonly resume?: boolean | undefined
 }
-export type Endpoint5_15Output = SessionPending.Synthetic
+export type Endpoint5_15Output = SessionInbox.Synthetic
 export type SessionSyntheticOperation<E = never> = (input: Endpoint5_15Input) => Effect.Effect<Endpoint5_15Output, E>
 
 export type Endpoint5_16Input = {
@@ -233,8 +234,12 @@ export type Endpoint5_16Input = {
 export type Endpoint5_16Output = void
 export type SessionShellOperation<E = never> = (input: Endpoint5_16Input) => Effect.Effect<Endpoint5_16Output, E>
 
-export type Endpoint5_17Input = { readonly sessionID: Session.ID; readonly id?: SessionMessage.ID | undefined }
-export type Endpoint5_17Output = SessionPending.Compaction
+export type Endpoint5_17Input = {
+  readonly sessionID: Session.ID
+  readonly id?: SessionMessage.ID | undefined
+  readonly delivery?: SessionInbox.Delivery | undefined
+}
+export type Endpoint5_17Output = SessionInbox.Compaction
 export type SessionCompactOperation<E = never> = (input: Endpoint5_17Input) => Effect.Effect<Endpoint5_17Output, E>
 
 export type Endpoint5_18Input = { readonly sessionID: Session.ID }
@@ -262,22 +267,20 @@ export type Endpoint5_22Output = ReadonlyArray<SessionMessage.Info>
 export type SessionContextOperation<E = never> = (input: Endpoint5_22Input) => Effect.Effect<Endpoint5_22Output, E>
 
 export type Endpoint5_23Input = { readonly sessionID: Session.ID }
-export type Endpoint5_23Output = ReadonlyArray<SessionPending.Info>
-export type SessionPendingListOperation<E = never> = (input: Endpoint5_23Input) => Effect.Effect<Endpoint5_23Output, E>
+export type Endpoint5_23Output = ReadonlyArray<SessionInbox.Info>
+export type SessionInboxListOperation<E = never> = (input: Endpoint5_23Input) => Effect.Effect<Endpoint5_23Output, E>
 
-export type Endpoint5_24Input = { readonly sessionID: Session.ID; readonly inputID: SessionMessage.ID }
+export type Endpoint5_24Input = { readonly sessionID: Session.ID; readonly inboxID: SessionMessage.ID }
 export type Endpoint5_24Output = void
-export type SessionPendingCancelOperation<E = never> = (
-  input: Endpoint5_24Input,
-) => Effect.Effect<Endpoint5_24Output, E>
+export type SessionInboxCancelOperation<E = never> = (input: Endpoint5_24Input) => Effect.Effect<Endpoint5_24Output, E>
 
-export type Endpoint5_25Input = { readonly sessionID: Session.ID; readonly inputID: SessionMessage.ID }
+export type Endpoint5_25Input = { readonly sessionID: Session.ID; readonly inboxID: SessionMessage.ID }
 export type Endpoint5_25Output = void
-export type SessionPendingSteerOperation<E = never> = (input: Endpoint5_25Input) => Effect.Effect<Endpoint5_25Output, E>
+export type SessionInboxSteerOperation<E = never> = (input: Endpoint5_25Input) => Effect.Effect<Endpoint5_25Output, E>
 
-export type Endpoint5_26Input = { readonly sessionID: Session.ID; readonly inputID: SessionMessage.ID }
+export type Endpoint5_26Input = { readonly sessionID: Session.ID; readonly inboxID: SessionMessage.ID }
 export type Endpoint5_26Output = void
-export type SessionPendingQueueOperation<E = never> = (input: Endpoint5_26Input) => Effect.Effect<Endpoint5_26Output, E>
+export type SessionInboxQueueOperation<E = never> = (input: Endpoint5_26Input) => Effect.Effect<Endpoint5_26Output, E>
 
 export type Endpoint5_27Input = { readonly sessionID: Session.ID }
 export type Endpoint5_27Output = ReadonlyArray<InstructionEntry.Info>
@@ -368,7 +371,7 @@ export type Endpoint5_31Output =
           readonly data: {
             readonly sessionID: Session.ID
             readonly location: Location.Ref
-            readonly projectID?: Project.ID | undefined
+            readonly projectID: Project.ID
             readonly subpath?: RelativePath | undefined
           }
         }
@@ -410,50 +413,45 @@ export type Endpoint5_31Output =
           readonly id: Event.ID
           readonly created: DateTime.Utc
           readonly metadata?: { readonly [x: string]: unknown } | undefined
-          readonly type: "session.input.promoted"
+          readonly type: "session.inbox.delivered"
           readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
           readonly location?: Location.Ref | undefined
-          readonly data: { readonly sessionID: Session.ID; readonly inputID: SessionMessage.ID }
+          readonly data: { readonly sessionID: Session.ID; readonly inboxID: SessionMessage.ID }
         }
       | {
           readonly id: Event.ID
           readonly created: DateTime.Utc
           readonly metadata?: { readonly [x: string]: unknown } | undefined
-          readonly type: "session.input.admitted"
+          readonly type: "session.inbox.enqueued"
           readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
           readonly location?: Location.Ref | undefined
           readonly data: {
             readonly sessionID: Session.ID
-            readonly inputID: SessionMessage.ID
-            readonly input: SessionPending.Message
+            readonly inboxID: SessionMessage.ID
+            readonly item: SessionInbox.Item
           }
         }
       | {
           readonly id: Event.ID
           readonly created: DateTime.Utc
           readonly metadata?: { readonly [x: string]: unknown } | undefined
-          readonly type: "session.input.cancelled"
+          readonly type: "session.inbox.cancelled"
           readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
           readonly location?: Location.Ref | undefined
-          readonly data: { readonly sessionID: Session.ID; readonly inputID: SessionMessage.ID }
+          readonly data: { readonly sessionID: Session.ID; readonly inboxID: SessionMessage.ID }
         }
       | {
           readonly id: Event.ID
           readonly created: DateTime.Utc
           readonly metadata?: { readonly [x: string]: unknown } | undefined
-          readonly type: "session.input.steered"
+          readonly type: "session.inbox.delivery.changed"
           readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
           readonly location?: Location.Ref | undefined
-          readonly data: { readonly sessionID: Session.ID; readonly inputID: SessionMessage.ID }
-        }
-      | {
-          readonly id: Event.ID
-          readonly created: DateTime.Utc
-          readonly metadata?: { readonly [x: string]: unknown } | undefined
-          readonly type: "session.input.queued"
-          readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
-          readonly location?: Location.Ref | undefined
-          readonly data: { readonly sessionID: Session.ID; readonly inputID: SessionMessage.ID }
+          readonly data: {
+            readonly sessionID: Session.ID
+            readonly inboxID: SessionMessage.ID
+            readonly delivery: SessionInbox.Delivery
+          }
         }
       | {
           readonly id: Event.ID
@@ -814,15 +812,6 @@ export type Endpoint5_31Output =
             readonly error: { readonly type: string; readonly message: string; readonly status?: number | undefined }
           }
         }
-      | {
-          readonly id: Event.ID
-          readonly created: DateTime.Utc
-          readonly metadata?: { readonly [x: string]: unknown } | undefined
-          readonly type: "session.compaction.admitted"
-          readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
-          readonly location?: Location.Ref | undefined
-          readonly data: { readonly sessionID: Session.ID; readonly inputID: SessionMessage.ID }
-        }
       | {
           readonly id: Event.ID
           readonly created: DateTime.Utc
@@ -953,11 +942,11 @@ export interface SessionApi<E = never> {
     readonly commit: SessionRevertCommitOperation<E>
   }
   readonly context: SessionContextOperation<E>
-  readonly pending: {
-    readonly list: SessionPendingListOperation<E>
-    readonly cancel: SessionPendingCancelOperation<E>
-    readonly steer: SessionPendingSteerOperation<E>
-    readonly queue: SessionPendingQueueOperation<E>
+  readonly inbox: {
+    readonly list: SessionInboxListOperation<E>
+    readonly cancel: SessionInboxCancelOperation<E>
+    readonly steer: SessionInboxSteerOperation<E>
+    readonly queue: SessionInboxQueueOperation<E>
   }
   readonly instructions: {
     readonly entry: {

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

@@ -399,7 +399,7 @@ const Endpoint5_11 = (raw: RawClient["server.session"]) => (input: Endpoint5_11I
   preserveEffect<Endpoint5_11Output>()(
     raw["session.move"]({
       params: { sessionID: input["sessionID"] },
-      payload: { directory: input["directory"], workspaceID: input["workspaceID"] },
+      payload: { directory: input["directory"], workspaceID: input["workspaceID"], delivery: input["delivery"] },
     }).pipe(Effect.mapError(mapClientError)),
   )
 
@@ -481,7 +481,10 @@ const Endpoint5_16 = (raw: RawClient["server.session"]) => (input: Endpoint5_16I
 
 const Endpoint5_17 = (raw: RawClient["server.session"]) => (input: Endpoint5_17Input) =>
   preserveEffect<Endpoint5_17Output>()(
-    raw["session.compact"]({ params: { sessionID: input["sessionID"] }, payload: { id: input["id"] } }).pipe(
+    raw["session.compact"]({
+      params: { sessionID: input["sessionID"] },
+      payload: { id: input["id"], delivery: input["delivery"] },
+    }).pipe(
       Effect.mapError(mapClientError),
       Effect.map((value) => value.data),
     ),
@@ -523,7 +526,7 @@ const Endpoint5_22 = (raw: RawClient["server.session"]) => (input: Endpoint5_22I
 
 const Endpoint5_23 = (raw: RawClient["server.session"]) => (input: Endpoint5_23Input) =>
   preserveEffect<Endpoint5_23Output>()(
-    raw["session.pending.list"]({ params: { sessionID: input["sessionID"] } }).pipe(
+    raw["session.inbox.list"]({ params: { sessionID: input["sessionID"] } }).pipe(
       Effect.mapError(mapClientError),
       Effect.map((value) => value.data),
     ),
@@ -531,21 +534,21 @@ const Endpoint5_23 = (raw: RawClient["server.session"]) => (input: Endpoint5_23I
 
 const Endpoint5_24 = (raw: RawClient["server.session"]) => (input: Endpoint5_24Input) =>
   preserveEffect<Endpoint5_24Output>()(
-    raw["session.pending.cancel"]({ params: { sessionID: input["sessionID"], inputID: input["inputID"] } }).pipe(
+    raw["session.inbox.cancel"]({ params: { sessionID: input["sessionID"], inboxID: input["inboxID"] } }).pipe(
       Effect.mapError(mapClientError),
     ),
   )
 
 const Endpoint5_25 = (raw: RawClient["server.session"]) => (input: Endpoint5_25Input) =>
   preserveEffect<Endpoint5_25Output>()(
-    raw["session.pending.steer"]({ params: { sessionID: input["sessionID"], inputID: input["inputID"] } }).pipe(
+    raw["session.inbox.steer"]({ params: { sessionID: input["sessionID"], inboxID: input["inboxID"] } }).pipe(
       Effect.mapError(mapClientError),
     ),
   )
 
 const Endpoint5_26 = (raw: RawClient["server.session"]) => (input: Endpoint5_26Input) =>
   preserveEffect<Endpoint5_26Output>()(
-    raw["session.pending.queue"]({ params: { sessionID: input["sessionID"], inputID: input["inputID"] } }).pipe(
+    raw["session.inbox.queue"]({ params: { sessionID: input["sessionID"], inboxID: input["inboxID"] } }).pipe(
       Effect.mapError(mapClientError),
     ),
   )
@@ -637,7 +640,7 @@ const adaptGroup5 = (raw: RawClient["server.session"]) => ({
   wait: Endpoint5_18(raw),
   revert: { stage: Endpoint5_19(raw), clear: Endpoint5_20(raw), commit: Endpoint5_21(raw) },
   context: Endpoint5_22(raw),
-  pending: { list: Endpoint5_23(raw), cancel: Endpoint5_24(raw), steer: Endpoint5_25(raw), queue: Endpoint5_26(raw) },
+  inbox: { list: Endpoint5_23(raw), cancel: Endpoint5_24(raw), steer: Endpoint5_25(raw), queue: Endpoint5_26(raw) },
   instructions: { entry: { list: Endpoint5_27(raw), put: Endpoint5_28(raw), remove: Endpoint5_29(raw) } },
   generate: Endpoint5_30(raw),
   log: Endpoint5_31(raw),

packages/client/src/effect/index.ts

@@ -41,7 +41,7 @@ export { Reference } from "@opencode-ai/schema/reference"
 export { WebSearch } from "@opencode-ai/schema/websearch"
 export { AbsolutePath, RelativePath } from "@opencode-ai/schema/schema"
 export { Session } from "@opencode-ai/schema/session"
-export { SessionPending } from "@opencode-ai/schema/session-pending"
+export { SessionInbox } from "@opencode-ai/schema/session-inbox"
 export { SessionMessage } from "@opencode-ai/schema/session-message"
 export { Skill } from "@opencode-ai/schema/skill"
 export { Prompt } from "@opencode-ai/schema/prompt"

packages/client/src/effect/service.ts

@@ -10,6 +10,7 @@ import {
   spawnServiceContender,
 } from "../service-contender.js"
 import { defaultEnsureTiming, ensureTiming, type EnsureTiming } from "../service-timing.js"
+import { matchesVersion } from "../service-version.js"
 
 export * from "../service.js"
 /** Contents of the local service registration file. */
@@ -37,14 +38,14 @@ export const incumbent = Effect.fn("service.incumbent")(function* (
   const info = yield* read(options.file)
   const found = info === undefined ? undefined : yield* probe({ ...info, url: options.url })
   if (found === undefined || found.legacy) return undefined
-  if (options.version !== undefined && found.version !== options.version) return undefined
+  if (!matchesVersion(found.version, options)) return undefined
   return { endpoint: found.endpoint, state: found.state }
 })
 
 const discoverLocal = Effect.fnUntraced(function* (options: DiscoverOptions) {
   const found = (yield* registered(options.file)).service
   if (found?.state !== "ready") return undefined
-  if (options.version !== undefined && found.version !== options.version) return undefined
+  if (!matchesVersion(found.version, options)) return undefined
   return found
 })
 
@@ -93,7 +94,7 @@ export const ensure = Effect.fn("service.ensure")(function* (options: EnsureOpti
     } else timeouts = undefined
     if (service !== undefined) {
       spawnDelay = timing.spawnDelay
-      const compatible = !service.legacy && (options.version === undefined || service.version === options.version)
+      const compatible = !service.legacy && matchesVersion(service.version, options)
       if (compatible && service.state === "ready") return Option.some(service)
       if (compatible && service.state === "failed")
         return yield* Effect.fail(new Error("Background service failed to start"))

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

@@ -56,14 +56,14 @@ import type {
   SessionRevertCommitOutput,
   SessionContextInput,
   SessionContextOutput,
-  SessionPendingListInput,
-  SessionPendingListOutput,
-  SessionPendingCancelInput,
-  SessionPendingCancelOutput,
-  SessionPendingSteerInput,
-  SessionPendingSteerOutput,
-  SessionPendingQueueInput,
-  SessionPendingQueueOutput,
+  SessionInboxListInput,
+  SessionInboxListOutput,
+  SessionInboxCancelInput,
+  SessionInboxCancelOutput,
+  SessionInboxSteerInput,
+  SessionInboxSteerOutput,
+  SessionInboxQueueInput,
+  SessionInboxQueueOutput,
   SessionInstructionsEntryListInput,
   SessionInstructionsEntryListOutput,
   SessionInstructionsEntryPutInput,
@@ -598,7 +598,7 @@ export function make(options: ClientOptions) {
           {
             method: "POST",
             path: `/api/session/${encodeURIComponent(input.sessionID)}/move`,
-            body: { directory: input["directory"], workspaceID: input["workspaceID"] },
+            body: { directory: input["directory"], workspaceID: input["workspaceID"], delivery: input["delivery"] },
             successStatus: 204,
             declaredStatuses: [404, 400, 401],
             empty: true,
@@ -697,7 +697,7 @@ export function make(options: ClientOptions) {
           {
             method: "POST",
             path: `/api/session/${encodeURIComponent(input.sessionID)}/compact`,
-            body: { id: input["id"] },
+            body: { id: input["id"], delivery: input["delivery"] },
             successStatus: 200,
             declaredStatuses: [409, 404, 400, 401],
             empty: false,
@@ -762,45 +762,45 @@ export function make(options: ClientOptions) {
           },
           requestOptions,
         ).then((value) => value.data),
-      pending: {
-        list: (input: SessionPendingListInput, requestOptions?: RequestOptions) =>
-          request<{ readonly data: SessionPendingListOutput }>(
+      inbox: {
+        list: (input: SessionInboxListInput, requestOptions?: RequestOptions) =>
+          request<{ readonly data: SessionInboxListOutput }>(
             {
               method: "GET",
-              path: `/api/session/${encodeURIComponent(input.sessionID)}/pending`,
+              path: `/api/session/${encodeURIComponent(input.sessionID)}/inbox`,
               successStatus: 200,
               declaredStatuses: [404, 401, 400],
               empty: false,
             },
             requestOptions,
           ).then((value) => value.data),
-        cancel: (input: SessionPendingCancelInput, requestOptions?: RequestOptions) =>
-          request<SessionPendingCancelOutput>(
+        cancel: (input: SessionInboxCancelInput, requestOptions?: RequestOptions) =>
+          request<SessionInboxCancelOutput>(
             {
               method: "DELETE",
-              path: `/api/session/${encodeURIComponent(input.sessionID)}/pending/${encodeURIComponent(input.inputID)}`,
+              path: `/api/session/${encodeURIComponent(input.sessionID)}/inbox/${encodeURIComponent(input.inboxID)}`,
               successStatus: 204,
               declaredStatuses: [409, 404, 401, 400],
               empty: true,
             },
             requestOptions,
           ),
-        steer: (input: SessionPendingSteerInput, requestOptions?: RequestOptions) =>
-          request<SessionPendingSteerOutput>(
+        steer: (input: SessionInboxSteerInput, requestOptions?: RequestOptions) =>
+          request<SessionInboxSteerOutput>(
             {
               method: "POST",
-              path: `/api/session/${encodeURIComponent(input.sessionID)}/pending/${encodeURIComponent(input.inputID)}/steer`,
+              path: `/api/session/${encodeURIComponent(input.sessionID)}/inbox/${encodeURIComponent(input.inboxID)}/steer`,
               successStatus: 204,
               declaredStatuses: [409, 404, 401, 400],
               empty: true,
             },
             requestOptions,
           ),
-        queue: (input: SessionPendingQueueInput, requestOptions?: RequestOptions) =>
-          request<SessionPendingQueueOutput>(
+        queue: (input: SessionInboxQueueInput, requestOptions?: RequestOptions) =>
+          request<SessionInboxQueueOutput>(
             {
               method: "POST",
-              path: `/api/session/${encodeURIComponent(input.sessionID)}/pending/${encodeURIComponent(input.inputID)}/queue`,
+              path: `/api/session/${encodeURIComponent(input.sessionID)}/inbox/${encodeURIComponent(input.inboxID)}/queue`,
               successStatus: 204,
               declaredStatuses: [409, 404, 401, 400],
               empty: true,

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

@@ -130,15 +130,17 @@ export type SessionMessageCompactionCompleted = {
 
 export type SessionActive = { type: "running" }
 
-export type SessionPendingSyntheticData = { text: string; description?: string; metadata?: { [x: string]: JsonValue } }
+export type SessionInboxDelivery = "steer" | "queue"
 
-export type SessionPendingCompaction = { id: string; sessionID: string; timeCreated: number; type: "compaction" }
+export type SessionInboxSyntheticPayload = { text: string; description?: string; metadata?: { [x: string]: JsonValue } }
+
+export type SessionInboxCompactionPayload = {}
 
 export type InstructionEntryKey = string
 
 export type SessionGenerateResponse = { data: { text: string } }
 
-export type SessionPendingSyntheticData1 = { text: string; description?: string; metadata?: { [x: string]: any } }
+export type SessionInboxSyntheticPayload1 = { text: string; description?: string; metadata?: { [x: string]: any } }
 
 export type ShellInfo = {
   id: string
@@ -420,6 +422,8 @@ export type SessionMessageLocationSwitched = {
   previous?: { location: LocationRef; projectID?: string; subpath?: string }
 }
 
+export type SessionInboxMovePayload = { location: LocationRef; projectID: string; subpath?: string }
+
 export type SessionCreated = {
   id: string
   created: number
@@ -468,7 +472,7 @@ export type SessionMoved = {
   type: "session.moved"
   durable: { aggregateID: string; seq: number; version: 1 }
   location?: LocationRef
-  data: { sessionID: string; location: LocationRef; projectID?: string; subpath?: string }
+  data: { sessionID: string; location: LocationRef; projectID: string; subpath?: string }
 }
 
 export type SessionRenamed = {
@@ -501,44 +505,24 @@ export type SessionForked = {
   data: { sessionID: string; parentID: string; boundary: SessionForkBoundary; instructions?: { [x: string]: string } }
 }
 
-export type SessionInputPromoted = {
+export type SessionInboxDelivered = {
   id: string
   created: number
   metadata?: { [x: string]: any }
-  type: "session.input.promoted"
+  type: "session.inbox.delivered"
   durable: { aggregateID: string; seq: number; version: 1 }
   location?: LocationRef
-  data: { sessionID: string; inputID: string }
+  data: { sessionID: string; inboxID: string }
 }
 
-export type SessionInputCancelled = {
+export type SessionInboxCancelled = {
   id: string
   created: number
   metadata?: { [x: string]: any }
-  type: "session.input.cancelled"
+  type: "session.inbox.cancelled"
   durable: { aggregateID: string; seq: number; version: 1 }
   location?: LocationRef
-  data: { sessionID: string; inputID: string }
-}
-
-export type SessionInputSteered = {
-  id: string
-  created: number
-  metadata?: { [x: string]: any }
-  type: "session.input.steered"
-  durable: { aggregateID: string; seq: number; version: 1 }
-  location?: LocationRef
-  data: { sessionID: string; inputID: string }
-}
-
-export type SessionInputQueued = {
-  id: string
-  created: number
-  metadata?: { [x: string]: any }
-  type: "session.input.queued"
-  durable: { aggregateID: string; seq: number; version: 1 }
-  location?: LocationRef
-  data: { sessionID: string; inputID: string }
+  data: { sessionID: string; inboxID: string }
 }
 
 export type SessionExecutionStarted = {
@@ -659,16 +643,6 @@ export type SessionToolInputEnded = {
   data: { sessionID: string; assistantMessageID: string; id: string; text: string }
 }
 
-export type SessionCompactionAdmitted = {
-  id: string
-  created: number
-  metadata?: { [x: string]: any }
-  type: "session.compaction.admitted"
-  durable: { aggregateID: string; seq: number; version: 1 }
-  location?: LocationRef
-  data: { sessionID: string; inputID: string }
-}
-
 export type SessionCompactionStarted = {
   id: string
   created: number
@@ -863,6 +837,16 @@ export type ProjectDirectoriesUpdated = {
   data: { projectID: string }
 }
 
+export type ProjectDirectoryResolved = {
+  id: string
+  created: number
+  metadata?: { [x: string]: any }
+  type: "project.directory.resolved"
+  durable: { aggregateID: string; seq: number; version: 1 }
+  location?: LocationRef
+  data: { projectID: string; directory: string; previous: string }
+}
+
 export type CommandUpdated = {
   id: string
   created: number
@@ -1162,23 +1146,36 @@ export type SessionCompactionFailed = {
   data: { sessionID: string; reason: "auto" | "manual"; error: SessionStructuredError; inputID?: string }
 }
 
-export type SessionPendingSynthetic = {
+export type SessionInboxDeliveryChanged = {
+  id: string
+  created: number
+  metadata?: { [x: string]: any }
+  type: "session.inbox.delivery.changed"
+  durable: { aggregateID: string; seq: number; version: 1 }
+  location?: LocationRef
+  data: { sessionID: string; inboxID: string; delivery: SessionInboxDelivery }
+}
+
+export type SessionInboxSynthetic = {
   id: string
   sessionID: string
   timeCreated: number
   type: "synthetic"
-  data: SessionPendingSyntheticData
-  delivery: "steer" | "queue"
+  payload: SessionInboxSyntheticPayload
+  delivery: SessionInboxDelivery
+}
+
+export type SessionInboxCompaction = {
+  id: string
+  sessionID: string
+  timeCreated: number
+  type: "compaction"
+  payload: SessionInboxCompactionPayload
+  delivery: SessionInboxDelivery
 }
 
 export type InstructionEntryInfo = { key: InstructionEntryKey; value: JsonValue }
 
-export type SessionPendingSyntheticMessage = {
-  type: "synthetic"
-  data: SessionPendingSyntheticData1
-  delivery: "steer" | "queue"
-}
-
 export type SessionShellStarted = {
   id: string
   created: number
@@ -1527,6 +1524,15 @@ export type VcsInfo = { branch: VcsBranch }
 
 export type PermissionRuleset = Array<PermissionRule>
 
+export type SessionInboxMove = {
+  id: string
+  sessionID: string
+  timeCreated: number
+  type: "move"
+  payload: SessionInboxMovePayload
+  delivery: SessionInboxDelivery
+}
+
 export type SessionInfo = {
   id: string
   parentID?: string
@@ -1564,7 +1570,7 @@ export type SessionMessageUser = {
   type: "user"
 }
 
-export type SessionPendingUserData = {
+export type SessionInboxUserPayload = {
   text: string
   files?: Array<PromptFileAttachment>
   agents?: Array<PromptAgentAttachment>
@@ -1572,7 +1578,7 @@ export type SessionPendingUserData = {
   metadata?: { [x: string]: JsonValue }
 }
 
-export type SessionPendingUserData1 = {
+export type SessionInboxUserPayload1 = {
   text: string
   files?: Array<PromptFileAttachment>
   agents?: Array<PromptAgentAttachment>
@@ -1884,16 +1890,20 @@ export type ConfigEntry =
 
 export type SessionsResponse = { data: Array<SessionInfo>; cursor: { previous?: string | null; next?: string | null } }
 
-export type SessionPendingUser = {
+export type SessionInboxUser = {
   id: string
   sessionID: string
   timeCreated: number
   type: "user"
-  data: SessionPendingUserData
-  delivery: "steer" | "queue"
+  payload: SessionInboxUserPayload
+  delivery: SessionInboxDelivery
 }
 
-export type SessionPendingUserMessage = { type: "user"; data: SessionPendingUserData1; delivery: "steer" | "queue" }
+export type SessionInboxItem =
+  | { type: "user"; payload: SessionInboxUserPayload1; delivery: SessionInboxDelivery }
+  | { type: "synthetic"; payload: SessionInboxSyntheticPayload1; delivery: SessionInboxDelivery }
+  | { type: "compaction"; payload: SessionInboxCompactionPayload; delivery: SessionInboxDelivery }
+  | { type: "move"; payload: SessionInboxMovePayload; delivery: SessionInboxDelivery }
 
 export type SessionMessageAssistantTool = {
   type: "tool"
@@ -1914,9 +1924,17 @@ export type FormFields = [FormField, ...Array<FormField>]
 
 export type FormFields3 = [FormField1, ...Array<FormField1>]
 
-export type SessionPendingInfo = SessionPendingUser | SessionPendingSynthetic | SessionPendingCompaction
+export type SessionInboxInfo = SessionInboxUser | SessionInboxSynthetic | SessionInboxCompaction | SessionInboxMove
 
-export type SessionPendingMessage = SessionPendingUserMessage | SessionPendingSyntheticMessage
+export type SessionInboxEnqueued = {
+  id: string
+  created: number
+  metadata?: { [x: string]: any }
+  type: "session.inbox.enqueued"
+  durable: { aggregateID: string; seq: number; version: 1 }
+  location?: LocationRef
+  data: { sessionID: string; inboxID: string; item: SessionInboxItem }
+}
 
 export type SessionMessageAssistant = {
   id: string
@@ -1942,15 +1960,47 @@ export type FormInfo = { id: string; sessionID: string; title: string; metadata?
 
 export type FormInfo1 = { id: string; sessionID: string; title: string; metadata?: FormMetadata1; fields: FormFields3 }
 
-export type SessionInputAdmitted = {
-  id: string
-  created: number
-  metadata?: { [x: string]: any }
-  type: "session.input.admitted"
-  durable: { aggregateID: string; seq: number; version: 1 }
-  location?: LocationRef
-  data: { sessionID: string; inputID: string; input: SessionPendingMessage }
-}
+export type SessionEventDurable =
+  | SessionCreated
+  | SessionAgentSelected
+  | SessionModelSelected
+  | SessionMoved
+  | SessionRenamed
+  | SessionDeleted
+  | SessionForked
+  | SessionInboxDelivered
+  | SessionInboxEnqueued
+  | SessionInboxCancelled
+  | SessionInboxDeliveryChanged
+  | SessionExecutionStarted
+  | SessionExecutionSucceeded
+  | SessionExecutionFailed
+  | SessionExecutionInterrupted
+  | SessionInstructionsUpdated
+  | SessionSynthetic
+  | SessionSkillActivated
+  | SessionShellStarted
+  | SessionShellEnded
+  | SessionStepStarted
+  | SessionStepEnded
+  | SessionStepFailed
+  | SessionTextStarted
+  | SessionTextEnded
+  | SessionReasoningStarted
+  | SessionReasoningEnded
+  | SessionToolInputStarted
+  | SessionToolInputEnded
+  | SessionToolCalled
+  | SessionToolSuccess
+  | SessionToolFailed
+  | SessionRetryScheduled
+  | SessionCompactionStarted
+  | SessionCompactionEnded
+  | SessionCompactionFailed
+  | SessionRevertStaged
+  | SessionRevertCleared
+  | SessionRevertCommitted
+  | SessionUsageRecorded
 
 export type SessionMessageInfo =
   | SessionMessageAgentSelected
@@ -1979,49 +2029,7 @@ export type FormCreated = {
   data: { form: FormInfo1 }
 }
 
-export type SessionEventDurable =
-  | SessionCreated
-  | SessionAgentSelected
-  | SessionModelSelected
-  | SessionMoved
-  | SessionRenamed
-  | SessionDeleted
-  | SessionForked
-  | SessionInputPromoted
-  | SessionInputAdmitted
-  | SessionInputCancelled
-  | SessionInputSteered
-  | SessionInputQueued
-  | SessionExecutionStarted
-  | SessionExecutionSucceeded
-  | SessionExecutionFailed
-  | SessionExecutionInterrupted
-  | SessionInstructionsUpdated
-  | SessionSynthetic
-  | SessionSkillActivated
-  | SessionShellStarted
-  | SessionShellEnded
-  | SessionStepStarted
-  | SessionStepEnded
-  | SessionStepFailed
-  | SessionTextStarted
-  | SessionTextEnded
-  | SessionReasoningStarted
-  | SessionReasoningEnded
-  | SessionToolInputStarted
-  | SessionToolInputEnded
-  | SessionToolCalled
-  | SessionToolSuccess
-  | SessionToolFailed
-  | SessionRetryScheduled
-  | SessionCompactionAdmitted
-  | SessionCompactionStarted
-  | SessionCompactionEnded
-  | SessionCompactionFailed
-  | SessionRevertStaged
-  | SessionRevertCleared
-  | SessionRevertCommitted
-  | SessionUsageRecorded
+export type SessionLogItem = SessionEventDurable | EventLogSynced
 
 export type SessionTransferData = { info: SessionInfo; messages: Array<SessionMessageInfo> }
 
@@ -2051,11 +2059,10 @@ export type V2Event =
   | SessionUsageUpdated
   | SessionDeleted
   | SessionForked
-  | SessionInputPromoted
-  | SessionInputAdmitted
-  | SessionInputCancelled
-  | SessionInputSteered
-  | SessionInputQueued
+  | SessionInboxDelivered
+  | SessionInboxEnqueued
+  | SessionInboxCancelled
+  | SessionInboxDeliveryChanged
   | SessionExecutionStarted
   | SessionExecutionSucceeded
   | SessionExecutionFailed
@@ -2082,7 +2089,6 @@ export type V2Event =
   | SessionToolSuccess
   | SessionToolFailed
   | SessionRetryScheduled
-  | SessionCompactionAdmitted
   | SessionCompactionStarted
   | SessionCompactionDelta
   | SessionCompactionEnded
@@ -2097,6 +2103,7 @@ export type V2Event =
   | PluginAdded
   | PluginUpdated
   | ProjectDirectoriesUpdated
+  | ProjectDirectoryResolved
   | CommandUpdated
   | ConfigUpdated
   | SkillUpdated
@@ -2127,8 +2134,6 @@ export type V2Event =
   | McpResourcesChanged
   | V2EventServerConnected
 
-export type SessionLogItem = SessionEventDurable | EventLogSynced
-
 export type UnauthorizedError = { readonly _tag: "UnauthorizedError"; readonly message: string }
 export const isUnauthorizedError = (value: unknown): value is UnauthorizedError =>
   typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "UnauthorizedError"
@@ -3361,8 +3366,21 @@ export type SessionRenameOutput = void
 
 export type SessionMoveInput = {
   readonly sessionID: { readonly sessionID: string }["sessionID"]
-  readonly directory: { readonly directory: string; readonly workspaceID?: string }["directory"]
-  readonly workspaceID?: { readonly directory: string; readonly workspaceID?: string }["workspaceID"]
+  readonly directory: {
+    readonly directory: string
+    readonly workspaceID?: string
+    readonly delivery?: ("steer" | "queue") | null
+  }["directory"]
+  readonly workspaceID?: {
+    readonly directory: string
+    readonly workspaceID?: string
+    readonly delivery?: ("steer" | "queue") | null
+  }["workspaceID"]
+  readonly delivery?: {
+    readonly directory: string
+    readonly workspaceID?: string
+    readonly delivery?: ("steer" | "queue") | null
+  }["delivery"]
 }
 
 export type SessionMoveOutput = void
@@ -3387,7 +3405,7 @@ export type SessionPromptInput = {
       readonly mention?: { readonly start: number; readonly end: number; readonly text: string }
     }>
     readonly metadata?: { readonly [x: string]: JsonValue }
-    readonly delivery?: "steer" | "queue" | null
+    readonly delivery?: ("steer" | "queue") | null
     readonly resume?: boolean | null
   }["id"]
   readonly text: {
@@ -3408,7 +3426,7 @@ export type SessionPromptInput = {
       readonly mention?: { readonly start: number; readonly end: number; readonly text: string }
     }>
     readonly metadata?: { readonly [x: string]: JsonValue }
-    readonly delivery?: "steer" | "queue" | null
+    readonly delivery?: ("steer" | "queue") | null
     readonly resume?: boolean | null
   }["text"]
   readonly files?: {
@@ -3429,7 +3447,7 @@ export type SessionPromptInput = {
       readonly mention?: { readonly start: number; readonly end: number; readonly text: string }
     }>
     readonly metadata?: { readonly [x: string]: JsonValue }
-    readonly delivery?: "steer" | "queue" | null
+    readonly delivery?: ("steer" | "queue") | null
     readonly resume?: boolean | null
   }["files"]
   readonly agents?: {
@@ -3450,7 +3468,7 @@ export type SessionPromptInput = {
       readonly mention?: { readonly start: number; readonly end: number; readonly text: string }
     }>
     readonly metadata?: { readonly [x: string]: JsonValue }
-    readonly delivery?: "steer" | "queue" | null
+    readonly delivery?: ("steer" | "queue") | null
     readonly resume?: boolean | null
   }["agents"]
   readonly skills?: {
@@ -3471,7 +3489,7 @@ export type SessionPromptInput = {
       readonly mention?: { readonly start: number; readonly end: number; readonly text: string }
     }>
     readonly metadata?: { readonly [x: string]: JsonValue }
-    readonly delivery?: "steer" | "queue" | null
+    readonly delivery?: ("steer" | "queue") | null
     readonly resume?: boolean | null
   }["skills"]
   readonly metadata?: {
@@ -3492,7 +3510,7 @@ export type SessionPromptInput = {
       readonly mention?: { readonly start: number; readonly end: number; readonly text: string }
     }>
     readonly metadata?: { readonly [x: string]: JsonValue }
-    readonly delivery?: "steer" | "queue" | null
+    readonly delivery?: ("steer" | "queue") | null
     readonly resume?: boolean | null
   }["metadata"]
   readonly delivery?: {
@@ -3513,7 +3531,7 @@ export type SessionPromptInput = {
       readonly mention?: { readonly start: number; readonly end: number; readonly text: string }
     }>
     readonly metadata?: { readonly [x: string]: JsonValue }
-    readonly delivery?: "steer" | "queue" | null
+    readonly delivery?: ("steer" | "queue") | null
     readonly resume?: boolean | null
   }["delivery"]
   readonly resume?: {
@@ -3534,12 +3552,12 @@ export type SessionPromptInput = {
       readonly mention?: { readonly start: number; readonly end: number; readonly text: string }
     }>
     readonly metadata?: { readonly [x: string]: JsonValue }
-    readonly delivery?: "steer" | "queue" | null
+    readonly delivery?: ("steer" | "queue") | null
     readonly resume?: boolean | null
   }["resume"]
 }
 
-export type SessionPromptOutput = { data: SessionPendingUser }["data"]
+export type SessionPromptOutput = { data: SessionInboxUser }["data"]
 
 export type SessionCommandInput = {
   readonly sessionID: { readonly sessionID: string }["sessionID"]
@@ -3563,7 +3581,7 @@ export type SessionCommandInput = {
       readonly id: string
       readonly mention?: { readonly start: number; readonly end: number; readonly text: string }
     }>
-    readonly delivery?: "steer" | "queue" | null
+    readonly delivery?: ("steer" | "queue") | null
     readonly resume?: boolean | null
   }["id"]
   readonly command: {
@@ -3586,7 +3604,7 @@ export type SessionCommandInput = {
       readonly id: string
       readonly mention?: { readonly start: number; readonly end: number; readonly text: string }
     }>
-    readonly delivery?: "steer" | "queue" | null
+    readonly delivery?: ("steer" | "queue") | null
     readonly resume?: boolean | null
   }["command"]
   readonly arguments?: {
@@ -3609,7 +3627,7 @@ export type SessionCommandInput = {
       readonly id: string
       readonly mention?: { readonly start: number; readonly end: number; readonly text: string }
     }>
-    readonly delivery?: "steer" | "queue" | null
+    readonly delivery?: ("steer" | "queue") | null
     readonly resume?: boolean | null
   }["arguments"]
   readonly agent?: {
@@ -3632,7 +3650,7 @@ export type SessionCommandInput = {
       readonly id: string
       readonly mention?: { readonly start: number; readonly end: number; readonly text: string }
     }>
-    readonly delivery?: "steer" | "queue" | null
+    readonly delivery?: ("steer" | "queue") | null
     readonly resume?: boolean | null
   }["agent"]
   readonly model?: {
@@ -3655,7 +3673,7 @@ export type SessionCommandInput = {
       readonly id: string
       readonly mention?: { readonly start: number; readonly end: number; readonly text: string }
     }>
-    readonly delivery?: "steer" | "queue" | null
+    readonly delivery?: ("steer" | "queue") | null
     readonly resume?: boolean | null
   }["model"]
   readonly files?: {
@@ -3678,7 +3696,7 @@ export type SessionCommandInput = {
       readonly id: string
       readonly mention?: { readonly start: number; readonly end: number; readonly text: string }
     }>
-    readonly delivery?: "steer" | "queue" | null
+    readonly delivery?: ("steer" | "queue") | null
     readonly resume?: boolean | null
   }["files"]
   readonly agents?: {
@@ -3701,7 +3719,7 @@ export type SessionCommandInput = {
       readonly id: string
       readonly mention?: { readonly start: number; readonly end: number; readonly text: string }
     }>
-    readonly delivery?: "steer" | "queue" | null
+    readonly delivery?: ("steer" | "queue") | null
     readonly resume?: boolean | null
   }["agents"]
   readonly skills?: {
@@ -3724,7 +3742,7 @@ export type SessionCommandInput = {
       readonly id: string
       readonly mention?: { readonly start: number; readonly end: number; readonly text: string }
     }>
-    readonly delivery?: "steer" | "queue" | null
+    readonly delivery?: ("steer" | "queue") | null
     readonly resume?: boolean | null
   }["skills"]
   readonly delivery?: {
@@ -3747,7 +3765,7 @@ export type SessionCommandInput = {
       readonly id: string
       readonly mention?: { readonly start: number; readonly end: number; readonly text: string }
     }>
-    readonly delivery?: "steer" | "queue" | null
+    readonly delivery?: ("steer" | "queue") | null
     readonly resume?: boolean | null
   }["delivery"]
   readonly resume?: {
@@ -3770,12 +3788,12 @@ export type SessionCommandInput = {
       readonly id: string
       readonly mention?: { readonly start: number; readonly end: number; readonly text: string }
     }>
-    readonly delivery?: "steer" | "queue" | null
+    readonly delivery?: ("steer" | "queue") | null
     readonly resume?: boolean | null
   }["resume"]
 }
 
-export type SessionCommandOutput = { data: SessionPendingUser }["data"]
+export type SessionCommandOutput = { data: SessionInboxUser }["data"]
 
 export type SessionSkillInput = {
   readonly sessionID: { readonly sessionID: string }["sessionID"]
@@ -3805,7 +3823,7 @@ export type SessionSyntheticInput = {
     readonly text: string
     readonly description?: string | null
     readonly metadata?: { readonly [x: string]: JsonValue }
-    readonly delivery?: "steer" | "queue" | null
+    readonly delivery?: ("steer" | "queue") | null
     readonly resume?: boolean | null
   }["id"]
   readonly text: {
@@ -3813,7 +3831,7 @@ export type SessionSyntheticInput = {
     readonly text: string
     readonly description?: string | null
     readonly metadata?: { readonly [x: string]: JsonValue }
-    readonly delivery?: "steer" | "queue" | null
+    readonly delivery?: ("steer" | "queue") | null
     readonly resume?: boolean | null
   }["text"]
   readonly description?: {
@@ -3821,7 +3839,7 @@ export type SessionSyntheticInput = {
     readonly text: string
     readonly description?: string | null
     readonly metadata?: { readonly [x: string]: JsonValue }
-    readonly delivery?: "steer" | "queue" | null
+    readonly delivery?: ("steer" | "queue") | null
     readonly resume?: boolean | null
   }["description"]
   readonly metadata?: {
@@ -3829,7 +3847,7 @@ export type SessionSyntheticInput = {
     readonly text: string
     readonly description?: string | null
     readonly metadata?: { readonly [x: string]: JsonValue }
-    readonly delivery?: "steer" | "queue" | null
+    readonly delivery?: ("steer" | "queue") | null
     readonly resume?: boolean | null
   }["metadata"]
   readonly delivery?: {
@@ -3837,7 +3855,7 @@ export type SessionSyntheticInput = {
     readonly text: string
     readonly description?: string | null
     readonly metadata?: { readonly [x: string]: JsonValue }
-    readonly delivery?: "steer" | "queue" | null
+    readonly delivery?: ("steer" | "queue") | null
     readonly resume?: boolean | null
   }["delivery"]
   readonly resume?: {
@@ -3845,12 +3863,12 @@ export type SessionSyntheticInput = {
     readonly text: string
     readonly description?: string | null
     readonly metadata?: { readonly [x: string]: JsonValue }
-    readonly delivery?: "steer" | "queue" | null
+    readonly delivery?: ("steer" | "queue") | null
     readonly resume?: boolean | null
   }["resume"]
 }
 
-export type SessionSyntheticOutput = { data: SessionPendingSynthetic }["data"]
+export type SessionSyntheticOutput = { data: SessionInboxSynthetic }["data"]
 
 export type SessionShellInput = {
   readonly sessionID: { readonly sessionID: string }["sessionID"]
@@ -3862,10 +3880,14 @@ export type SessionShellOutput = void
 
 export type SessionCompactInput = {
   readonly sessionID: { readonly sessionID: string }["sessionID"]
-  readonly id?: { readonly id?: string | undefined }["id"]
+  readonly id?: { readonly id?: string | undefined; readonly delivery?: ("steer" | "queue") | undefined }["id"]
+  readonly delivery?: {
+    readonly id?: string | undefined
+    readonly delivery?: ("steer" | "queue") | undefined
+  }["delivery"]
 }
 
-export type SessionCompactOutput = { data: SessionPendingCompaction }["data"]
+export type SessionCompactOutput = { data: SessionInboxCompaction }["data"]
 
 export type SessionWaitInput = { readonly sessionID: { readonly sessionID: string }["sessionID"] }
 
@@ -3891,30 +3913,30 @@ export type SessionContextInput = { readonly sessionID: { readonly sessionID: st
 
 export type SessionContextOutput = { data: Array<SessionMessageInfo> }["data"]
 
-export type SessionPendingListInput = { readonly sessionID: { readonly sessionID: string }["sessionID"] }
+export type SessionInboxListInput = { readonly sessionID: { readonly sessionID: string }["sessionID"] }
 
-export type SessionPendingListOutput = { data: Array<SessionPendingInfo> }["data"]
+export type SessionInboxListOutput = { data: Array<SessionInboxInfo> }["data"]
 
-export type SessionPendingCancelInput = {
-  readonly sessionID: { readonly sessionID: string; readonly inputID: string }["sessionID"]
-  readonly inputID: { readonly sessionID: string; readonly inputID: string }["inputID"]
+export type SessionInboxCancelInput = {
+  readonly sessionID: { readonly sessionID: string; readonly inboxID: string }["sessionID"]
+  readonly inboxID: { readonly sessionID: string; readonly inboxID: string }["inboxID"]
 }
 
-export type SessionPendingCancelOutput = void
+export type SessionInboxCancelOutput = void
 
-export type SessionPendingSteerInput = {
-  readonly sessionID: { readonly sessionID: string; readonly inputID: string }["sessionID"]
-  readonly inputID: { readonly sessionID: string; readonly inputID: string }["inputID"]
+export type SessionInboxSteerInput = {
+  readonly sessionID: { readonly sessionID: string; readonly inboxID: string }["sessionID"]
+  readonly inboxID: { readonly sessionID: string; readonly inboxID: string }["inboxID"]
 }
 
-export type SessionPendingSteerOutput = void
+export type SessionInboxSteerOutput = void
 
-export type SessionPendingQueueInput = {
-  readonly sessionID: { readonly sessionID: string; readonly inputID: string }["sessionID"]
-  readonly inputID: { readonly sessionID: string; readonly inputID: string }["inputID"]
+export type SessionInboxQueueInput = {
+  readonly sessionID: { readonly sessionID: string; readonly inboxID: string }["sessionID"]
+  readonly inboxID: { readonly sessionID: string; readonly inboxID: string }["inboxID"]
 }
 
-export type SessionPendingQueueOutput = void
+export type SessionInboxQueueOutput = void
 
 export type SessionInstructionsEntryListInput = { readonly sessionID: { readonly sessionID: string }["sessionID"] }
 

packages/client/src/promise/service.ts

@@ -9,6 +9,7 @@ import {
   spawnServiceContender,
 } from "../service-contender.js"
 import { defaultEnsureTiming, ensureTiming, type EnsureTiming } from "../service-timing.js"
+import { matchesVersion } from "../service-version.js"
 import type { ServiceHealth, ServiceStopResponse } from "./generated/types.js"
 
 export * from "../service.js"
@@ -27,7 +28,7 @@ export async function discover(options: DiscoverOptions = {}) {
 async function discoverLocal(options: DiscoverOptions) {
   const found = (await registered(options.file)).service
   if (found?.state !== "ready") return undefined
-  if (options.version !== undefined && found.version !== options.version) return undefined
+  if (!matchesVersion(found.version, options)) return undefined
   return found
 }
 
@@ -76,7 +77,7 @@ export async function ensure(options: EnsureOptions = {}): Promise<Endpoint> {
       if (registration.service !== undefined) {
         spawnDelay = timing.spawnDelay
         const service = registration.service
-        const compatible = !service.legacy && (options.version === undefined || service.version === options.version)
+        const compatible = !service.legacy && matchesVersion(service.version, options)
         if (compatible && service.state === "ready") return service.endpoint
         if (compatible && service.state === "failed") throw new Error("Background service failed to start")
         if (!compatible) {

packages/client/src/service-version.ts

@@ -0,0 +1,8 @@
+import type { DiscoverOptions } from "./service.js"
+
+export function matchesVersion(version: string | undefined, options: DiscoverOptions) {
+  if (options.version === undefined) return true
+  if (version === undefined) return false
+  if (typeof options.version === "function") return options.version(version)
+  return version === options.version
+}

packages/client/src/service.ts

@@ -17,8 +17,8 @@ export type Endpoint = {
 export type DiscoverOptions = {
   /** Absolute registration file path. Defaults to the XDG state directory. */
   readonly file?: string
-  /** Required service version. */
-  readonly version?: string
+  /** Required exact service version or compatibility predicate. */
+  readonly version?: string | ((version: string) => boolean)
 }
 
 /** Reason ensuring the service requires a new process. */

packages/client/test/api.types.ts

@@ -1,6 +1,7 @@
 import { Effect } from "effect"
 import { OpenCode as EffectOpenCode, type AppApi as EffectApi } from "../src/effect"
 import type { Session } from "@opencode-ai/schema/session"
+import type { DiscoverOptions } from "../src/service"
 
 type EffectClient = Effect.Success<ReturnType<typeof EffectOpenCode.make>>
 type PromiseClient = ReturnType<typeof import("../src/promise").OpenCode.make>
@@ -8,6 +9,9 @@ type PromiseClient = ReturnType<typeof import("../src/promise").OpenCode.make>
 declare const effectClient: EffectClient
 declare const promiseClient: PromiseClient
 
+const exactVersion: DiscoverOptions = { version: "2.0.0" }
+const compatibleVersion: DiscoverOptions = { version: (version) => version.startsWith("2.") }
+
 const effectApi: EffectApi<unknown> = effectClient
 
 const effectSession: Effect.Effect<Session.Info, unknown> = effectClient.session.get({
@@ -42,4 +46,14 @@ const promiseRemove: Promise<void> = promiseClient.session.instructions.entry.re
   key: "review-notes",
 })
 
-void [effectSession, effectList, effectPut, effectRemove, promiseList, promisePut, promiseRemove]
+void [
+  effectSession,
+  effectList,
+  effectPut,
+  effectRemove,
+  promiseList,
+  promisePut,
+  promiseRemove,
+  exactVersion,
+  compatibleVersion,
+]

packages/client/test/effect.test.ts

@@ -213,7 +213,7 @@ test("session methods retain decoded Effect inputs and outputs", async () => {
   expect(Object.getPrototypeOf(result.created)).toBe(Object.prototype)
   expect(result.created.id).toBe("ses_test")
   expect(Object.getPrototypeOf(result.admitted)).toBe(Object.prototype)
-  expect(Object.getPrototypeOf(result.admitted.data)).toBe(Object.prototype)
+  expect(Object.getPrototypeOf(result.admitted.payload)).toBe(Object.prototype)
   expect(DateTime.toEpochMillis(result.admitted.timeCreated)).toBe(1_717_171_717_000)
   expect(result.context).toEqual([])
   expect(logQueries[0]).toEqual({ after: "0" })
@@ -271,7 +271,7 @@ const admission = {
     id: "msg_test",
     sessionID: "ses_test",
     type: "user",
-    data: { text: "Hello" },
+    payload: { text: "Hello" },
     delivery: "steer",
     timeCreated: 1_717_171_717_000,
   },
@@ -280,6 +280,8 @@ const admission = {
 const compactionAdmission = {
   data: {
     type: "compaction",
+    payload: {},
+    delivery: "queue",
     id: "msg_compaction",
     sessionID: "ses_test",
     timeCreated: 1_717_171_717_000,

packages/client/test/fixture/service.ts

@@ -27,7 +27,10 @@ if (mode === "delayed" || mode === "delayed-failed" || mode === "coordinated" ||
 }
 
 let requests = 0
-const version = mode === "old" || mode === "reject-stop" ? "old" : "test"
+let version = "test"
+if (mode === "old" || mode === "reject-stop") version = "old"
+if (mode === "incompatible") version = "1.9.0"
+if (mode === "compatible" || mode === "delayed-compatible") version = "2.1.0-next.1"
 const id = crypto.randomUUID()
 const server = Bun.serve({
   port: 0,

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

@@ -25,6 +25,19 @@ test("discovers a registered service", async () => {
   expect(await Service.discover({ file: registration, version: "other" })).toBeUndefined()
 })
 
+test("discovers a compatible registered service", async () => {
+  const registration = await setup("compatible")
+
+  expect(await Service.discover({ file: registration, version: "2.1.0" })).toBeUndefined()
+  expect(await Service.discover({ file: registration, version: "2.1.0-next.1" })).toEqual(
+    expect.objectContaining({ url: expect.stringMatching(/^http:\/\//) }),
+  )
+  expect(await Service.discover({ file: registration, version: (version) => version.startsWith("2.") })).toEqual(
+    expect.objectContaining({ url: expect.stringMatching(/^http:\/\//) }),
+  )
+  expect(await Service.discover({ file: registration, version: (version) => version.startsWith("3.") })).toBeUndefined()
+})
+
 test("ensures a missing service with native promises", async () => {
   const directory = await temp()
   const registration = join(directory, "service.json")

packages/client/test/promise.test.ts

@@ -373,7 +373,7 @@ test("session instructions methods use the public HTTP contract", async () => {
   ])
 })
 
-test("session.pending.list uses the public HTTP contract", async () => {
+test("session.inbox.list uses the public HTTP contract", async () => {
   const requests: Array<{ method: string; url: string }> = []
   const pending = [
     {
@@ -381,7 +381,7 @@ test("session.pending.list uses the public HTTP contract", async () => {
       sessionID: "ses_test",
       timeCreated: 1_717_171_717_000,
       type: "user",
-      data: { text: "Fix the failing tests" },
+      payload: { text: "Fix the failing tests" },
       delivery: "steer",
     },
   ]
@@ -394,13 +394,13 @@ test("session.pending.list uses the public HTTP contract", async () => {
     },
   })
 
-  const result = await client.session.pending.list({ sessionID: "ses_test" })
+  const result = await client.session.inbox.list({ sessionID: "ses_test" })
 
   expect(result).toEqual(pending)
-  expect(requests).toEqual([{ method: "GET", url: "http://localhost:3000/api/session/ses_test/pending" }])
+  expect(requests).toEqual([{ method: "GET", url: "http://localhost:3000/api/session/ses_test/inbox" }])
 })
 
-test("session.pending mutations use the public HTTP contract", async () => {
+test("session.inbox mutations use the public HTTP contract", async () => {
   const requests: Array<{ method: string; url: string }> = []
   const client = OpenCode.make({
     baseUrl: "http://localhost:3000",
@@ -411,14 +411,14 @@ test("session.pending mutations use the public HTTP contract", async () => {
     },
   })
 
-  await client.session.pending.cancel({ sessionID: "ses_test", inputID: "msg_cancel" })
-  await client.session.pending.steer({ sessionID: "ses_test", inputID: "msg_steer" })
-  await client.session.pending.queue({ sessionID: "ses_test", inputID: "msg_queue" })
+  await client.session.inbox.cancel({ sessionID: "ses_test", inboxID: "msg_cancel" })
+  await client.session.inbox.steer({ sessionID: "ses_test", inboxID: "msg_steer" })
+  await client.session.inbox.queue({ sessionID: "ses_test", inboxID: "msg_queue" })
 
   expect(requests).toEqual([
-    { method: "DELETE", url: "http://localhost:3000/api/session/ses_test/pending/msg_cancel" },
-    { method: "POST", url: "http://localhost:3000/api/session/ses_test/pending/msg_steer/steer" },
-    { method: "POST", url: "http://localhost:3000/api/session/ses_test/pending/msg_queue/queue" },
+    { method: "DELETE", url: "http://localhost:3000/api/session/ses_test/inbox/msg_cancel" },
+    { method: "POST", url: "http://localhost:3000/api/session/ses_test/inbox/msg_steer/steer" },
+    { method: "POST", url: "http://localhost:3000/api/session/ses_test/inbox/msg_queue/queue" },
   ])
 })
 

packages/client/test/service.test.ts

@@ -47,6 +47,52 @@ test("a concurrent same-version start cannot invalidate a resolved endpoint", as
   expect(await health(resolved.url)).toEqual({ healthy: true, version: "test", pid: original.pid })
 })
 
+test("reuses a compatible registered service", async () => {
+  const directory = await temp()
+  const registration = join(directory, "service.json")
+  const existing = spawn(registration, "compatible")
+  await waitForFile(registration)
+
+  const starts: EnsureReason[] = []
+  const endpoint = await run(
+    ensure({
+      file: registration,
+      version: (version) => version.startsWith("2."),
+      command: [],
+      onStart: (reason) => starts.push(reason),
+    }),
+  )
+
+  expect(endpoint.url).toBe((await Bun.file(registration).json()).url)
+  expect(starts).toEqual([])
+  expect(existing.exitCode).toBe(null)
+})
+
+test("replaces an incompatible registered service", async () => {
+  const directory = await temp()
+  const registration = join(directory, "service.json")
+  const existing = spawn(registration, "incompatible")
+  await waitForFile(registration)
+
+  const starts: EnsureReason[] = []
+  const endpoint = await run(
+    ensure({
+      file: registration,
+      version: (version) => version.startsWith("2."),
+      command: [process.execPath, fixture, registration, "delayed-compatible", "10"],
+      onStart: (reason) => starts.push(reason),
+    }),
+  )
+  const replacement = await Bun.file(registration).json()
+
+  expect(await existing.exited).toBe(0)
+  expect(replacement.version).toBe("2.1.0-next.1")
+  expect(endpoint.url).toBe(replacement.url)
+  expect(starts).toEqual(["version-mismatch"])
+  process.kill(replacement.pid, "SIGTERM")
+  await waitForExit(replacement.pid)
+})
+
 test("waits for a registered service to finish starting", async () => {
   const directory = await temp()
   const registration = join(directory, "service.json")

packages/codemode/package.json

@@ -19,6 +19,12 @@
   "exports": {
     ".": "./src/index.ts"
   },
+  "imports": {
+    "#transpile": {
+      "workerd": "./src/interpreter/transpile.workerd.ts",
+      "default": "./src/interpreter/transpile.node.ts"
+    }
+  },
   "scripts": {
     "build": "bun run script/build.ts",
     "typecheck": "tsgo --noEmit",

packages/codemode/src/interpreter/execute.ts

@@ -1,6 +1,8 @@
 import { parse } from "acorn"
 import { Cause, Effect, Scope } from "effect"
-import { DiagnosticCategory, ModuleKind, ScriptTarget, flattenDiagnosticMessageText, transpileModule } from "typescript"
+// #transpile: conditional import — full typescript on node/bun, an identity
+// pass-through on workerd (the compiler is ~11 MiB and can't init there).
+import { transpile } from "#transpile"
 import type { DataValue, Diagnostic, ExecuteOptions, ResolvedExecutionLimits, Result } from "../codemode.js"
 import { copyIn, copyOut, ToolRuntime, type Services } from "../tool-runtime.js"
 import type { Tools } from "../tools.js"
@@ -119,21 +121,10 @@ export const executeWithLimits = <const Provided extends Record<string, unknown>
 }
 
 const parseProgram = (code: string): ProgramNode => {
-  const transpiled = transpileModule(`async function __codemode__() {\n${code}\n}`, {
-    reportDiagnostics: true,
-    compilerOptions: {
-      target: ScriptTarget.ESNext,
-      module: ModuleKind.ESNext,
-    },
-  })
-  const diagnostic = transpiled.diagnostics?.find((item) => item.category === DiagnosticCategory.Error)
+  const transpiled = transpile(`async function __codemode__() {\n${code}\n}`)
 
-  if (diagnostic) {
-    throw new InterpreterRuntimeError(
-      `Failed to parse TypeScript: ${flattenDiagnosticMessageText(diagnostic.messageText, "\n")}`,
-      undefined,
-      "ParseError",
-    )
+  if (transpiled.error !== undefined) {
+    throw new InterpreterRuntimeError(`Failed to parse TypeScript: ${transpiled.error}`, undefined, "ParseError")
   }
 
   const bodyStart = transpiled.outputText.indexOf("{") + 1

packages/codemode/src/interpreter/transpile.node.ts

@@ -0,0 +1,25 @@
+import { DiagnosticCategory, ModuleKind, ScriptTarget, flattenDiagnosticMessageText, transpileModule } from "typescript"
+
+export interface TranspileResult {
+  readonly outputText: string
+  readonly error?: string
+}
+
+// Full TypeScript transpilation on node/bun runtimes.
+export const transpile = (source: string): TranspileResult => {
+  const transpiled = transpileModule(source, {
+    reportDiagnostics: true,
+    compilerOptions: {
+      target: ScriptTarget.ESNext,
+      module: ModuleKind.ESNext,
+    },
+  })
+  const diagnostic = transpiled.diagnostics?.find((item) => item.category === DiagnosticCategory.Error)
+  if (diagnostic) {
+    return {
+      outputText: transpiled.outputText,
+      error: flattenDiagnosticMessageText(diagnostic.messageText, "\n"),
+    }
+  }
+  return { outputText: transpiled.outputText }
+}

packages/codemode/src/interpreter/transpile.workerd.ts

@@ -0,0 +1,11 @@
+export interface TranspileResult {
+  readonly outputText: string
+  readonly error?: string
+}
+
+// workerd profile: the typescript compiler is ~11 MiB and probes node
+// internals at module init, so codemode programs are passed through
+// untranspiled. Plain-JS programs (the overwhelmingly common case) parse
+// fine downstream via acorn; TypeScript-only syntax surfaces as a parse
+// error from the interpreter instead of a transpile diagnostic.
+export const transpile = (source: string): TranspileResult => ({ outputText: source })

packages/core/package.json

@@ -36,26 +36,31 @@
       "default": "./src/database/sqlite.node.ts"
     },
     "#pty": {
+      "workerd": "./src/pty/pty.workerd.ts",
       "bun": "./src/pty/pty.bun.ts",
       "node": "./src/pty/pty.node.ts",
       "default": "./src/pty/pty.bun.ts"
     },
     "#fff": {
+      "workerd": "./src/filesystem/fff.workerd.ts",
       "bun": "./src/filesystem/fff.bun.ts",
       "node": "./src/filesystem/fff.node.ts",
       "default": "./src/filesystem/fff.bun.ts"
     },
     "#photon-wasm": {
+      "workerd": "./src/image/photon-wasm.workerd.ts",
       "bun": "./src/image/photon-wasm.bun.ts",
       "node": "./src/image/photon-wasm.node.ts",
       "default": "./src/image/photon-wasm.bun.ts"
     },
     "#shell-parser-wasm": {
+      "workerd": "./src/shell/parser-wasm.workerd.ts",
       "bun": "./src/shell/parser-wasm.bun.ts",
       "node": "./src/shell/parser-wasm.node.ts",
       "default": "./src/shell/parser-wasm.bun.ts"
     },
     "#process-lock-ffi": {
+      "workerd": "./src/util/process-lock-ffi.workerd.ts",
       "bun": "./src/util/process-lock-ffi.bun.ts",
       "node": "./src/util/process-lock-ffi.node.ts",
       "default": "./src/util/process-lock-ffi.bun.ts"

packages/core/schema.json

@@ -1,8 +1,8 @@
 {
   "version": "7",
   "dialect": "sqlite",
-  "id": "00924d88-1842-4d71-ac74-5682ddc47e1c",
-  "prevIds": ["15060ec5-05f7-4b86-b2a5-9108609432b3"],
+  "id": "5c1aa56b-c3ee-4283-9a84-c0bf626dc604",
+  "prevIds": ["00924d88-1842-4d71-ac74-5682ddc47e1c"],
   "ddl": [
     {
       "name": "account_state",
@@ -56,6 +56,10 @@
       "name": "instruction_state",
       "entityType": "tables"
     },
+    {
+      "name": "session_inbox",
+      "entityType": "tables"
+    },
     {
       "name": "session_message",
       "entityType": "tables"
@@ -842,6 +846,76 @@
       "entityType": "columns",
       "table": "instruction_state"
     },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "id",
+      "entityType": "columns",
+      "table": "session_inbox"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "session_id",
+      "entityType": "columns",
+      "table": "session_inbox"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "type",
+      "entityType": "columns",
+      "table": "session_inbox"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "payload",
+      "entityType": "columns",
+      "table": "session_inbox"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "delivery",
+      "entityType": "columns",
+      "table": "session_inbox"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "enqueued_seq",
+      "entityType": "columns",
+      "table": "session_inbox"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "time_created",
+      "entityType": "columns",
+      "table": "session_inbox"
+    },
     {
       "type": "text",
       "notNull": false,
@@ -1428,6 +1502,17 @@
       "entityType": "fks",
       "table": "instruction_state"
     },
+    {
+      "columns": ["session_id"],
+      "tableTo": "session_v2",
+      "columnsTo": ["id"],
+      "onUpdate": "NO ACTION",
+      "onDelete": "CASCADE",
+      "nameExplicit": false,
+      "name": "fk_session_inbox_session_id_session_v2_id_fk",
+      "entityType": "fks",
+      "table": "session_inbox"
+    },
     {
       "columns": ["session_id"],
       "tableTo": "session_v2",
@@ -1552,6 +1637,13 @@
       "table": "instruction_state",
       "entityType": "pks"
     },
+    {
+      "columns": ["id"],
+      "nameExplicit": false,
+      "name": "session_inbox_pk",
+      "table": "session_inbox",
+      "entityType": "pks"
+    },
     {
       "columns": ["id"],
       "nameExplicit": false,
@@ -1642,6 +1734,46 @@
       "entityType": "indexes",
       "table": "permission"
     },
+    {
+      "columns": [
+        {
+          "value": "session_id",
+          "isExpression": false
+        },
+        {
+          "value": "delivery",
+          "isExpression": false
+        },
+        {
+          "value": "enqueued_seq",
+          "isExpression": false
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "origin": "manual",
+      "name": "session_inbox_session_delivery_seq_idx",
+      "entityType": "indexes",
+      "table": "session_inbox"
+    },
+    {
+      "columns": [
+        {
+          "value": "session_id",
+          "isExpression": false
+        },
+        {
+          "value": "enqueued_seq",
+          "isExpression": false
+        }
+      ],
+      "isUnique": true,
+      "where": null,
+      "origin": "manual",
+      "name": "session_inbox_session_enqueued_seq_idx",
+      "entityType": "indexes",
+      "table": "session_inbox"
+    },
     {
       "columns": [
         {

packages/core/src/bus.ts

@@ -6,7 +6,8 @@ import type { EventLog } from "@opencode-ai/schema/event-log"
 import { and, asc, eq, gt, lte, sql } from "drizzle-orm"
 import { Database } from "./database/database.js"
 import { EventSequenceTable, EventTable } from "./event/sql.js"
-import { Location } from "./location.js"
+import type { Location } from "@opencode-ai/schema/location"
+import { KeyedMutex } from "./effect/keyed-mutex.js"
 import { makeGlobalNode } from "@opencode-ai/util/effect/app-node"
 import { isDeepStrictEqual } from "node:util"
 import { Durable } from "@opencode-ai/schema/durable-event-manifest"
@@ -92,6 +93,16 @@ export interface PublishOptions {
   readonly commit?: (seq: number) => Effect.Effect<void>
 }
 
+export type PublishInput<D extends Event.DurableDefinition = Event.DurableDefinition> = readonly [
+  definition: D,
+  data: Event.Data<D>,
+  options?: PublishOptions,
+]
+
+export type PublishResult<I extends readonly PublishInput[]> = {
+  readonly [K in keyof I]: I[K] extends PublishInput<infer D> ? Event.Payload<D> : never
+}
+
 /** Marker/event union emitted by `log`. */
 export type LogItem = Event.Payload | EventLog.Synced
 
@@ -124,6 +135,9 @@ export interface Interface {
     data: Event.Data<D>,
     options?: PublishOptions,
   ) => Effect.Effect<Event.Payload<D>>
+  readonly publishAll: <const I extends readonly [PublishInput, ...PublishInput[]]>(
+    events: I,
+  ) => Effect.Effect<PublishResult<I>>
   readonly subscribe: Subscribe
   /**
    * Durable, ordered per-aggregate log read. Forked aggregates may reserve an
@@ -169,6 +183,9 @@ export function configured(options?: Options) {
     layer: Layer.effect(
       Service,
       Effect.gen(function* () {
+        // Deferred import: a static one would close the module cycle
+        // bus → location → project → bus and hit the node bindings in TDZ.
+        const { Location } = yield* Effect.promise(() => import("./location.js"))
         const pubsub = {
           live: yield* PubSub.unbounded<Event.Payload>(),
           durable: new Map<string, Set<PubSub.PubSub<void>>>(),
@@ -176,6 +193,7 @@ export function configured(options?: Options) {
         }
         const projectors = new Map<string, Subscriber[]>()
         const listeners = new Array<Subscriber>()
+        const durableLocks = KeyedMutex.makeUnsafe<string>()
         const { db } = yield* Database.Service
         const logReadPageSize = options?.logReadPageSize ?? 512
         const persist = options?.persist ?? false
@@ -385,15 +403,23 @@ export function configured(options?: Options) {
                 }),
               )
             if (definition?.durable) {
-              const committed = yield* commitDurableEvent(definition, event as Event.Payload, undefined, commit)
-              if (committed) {
-                event = {
-                  ...event,
-                  durable: envelope(committed.aggregateID, committed.seq, definition.durable.version),
-                }
-                yield* notify(event as Event.Payload, true)
-                return event
-              }
+              const aggregateID = (event.data as Record<string, unknown>)[definition.durable.aggregate]
+              if (typeof aggregateID !== "string")
+                return yield* commitDurableEvent(definition, event as Event.Payload, undefined, commit).pipe(
+                  Effect.as(event),
+                )
+              return yield* durableLocks.withLock(aggregateID)(
+                Effect.gen(function* () {
+                  const committed = yield* commitDurableEvent(definition, event as Event.Payload, undefined, commit)
+                  if (!committed) return event
+                  event = {
+                    ...event,
+                    durable: envelope(committed.aggregateID, committed.seq, definition.durable.version),
+                  }
+                  yield* notify(event as Event.Payload, true)
+                  return event
+                }),
+              )
             }
             yield* notify(event as Event.Payload, false)
             return event
@@ -444,6 +470,144 @@ export function configured(options?: Options) {
           })
         }
 
+        function publishAll<const I extends readonly [PublishInput, ...PublishInput[]]>(events: I) {
+          return Effect.gen(function* () {
+            const serviceLocation = Option.getOrUndefined(yield* Effect.serviceOption(Location.Service))
+            const payloads = yield* Effect.forEach(events, ([definition, data, options]) =>
+              Effect.gen(function* () {
+                const aggregateID = (data as Record<string, unknown>)[definition.durable.aggregate]
+                if (typeof aggregateID !== "string") {
+                  return yield* Effect.die(
+                    new InvalidDurableEventError({
+                      type: definition.type,
+                      message: `Expected string aggregate field ${definition.durable.aggregate}`,
+                    }),
+                  )
+                }
+                const location =
+                  options?.location ??
+                  (serviceLocation
+                    ? { directory: serviceLocation.directory, workspaceID: serviceLocation.workspaceID }
+                    : undefined)
+                return {
+                  definition,
+                  aggregateID,
+                  commit: options?.commit,
+                  event: {
+                    id: options?.id ?? Event.ID.create(),
+                    created: yield* DateTime.now,
+                    ...(options?.metadata ? { metadata: options.metadata } : {}),
+                    type: definition.type,
+                    ...(location ? { location } : {}),
+                    data,
+                  } as Event.Payload,
+                }
+              }),
+            )
+            const aggregateID = payloads[0].aggregateID
+            if (payloads.some((item) => item.aggregateID !== aggregateID)) {
+              return yield* Effect.die(
+                new InvalidDurableEventError({
+                  type: payloads[0].definition.type,
+                  message: "Published events must belong to the same aggregate",
+                }),
+              )
+            }
+            return yield* durableLocks.withLock(aggregateID)(
+              Effect.uninterruptible(
+                Effect.gen(function* () {
+                  const committed = yield* db
+                    .transaction(
+                      () =>
+                        Effect.gen(function* () {
+                          const row = yield* db
+                            .select({ seq: EventSequenceTable.seq })
+                            .from(EventSequenceTable)
+                            .where(eq(EventSequenceTable.aggregate_id, aggregateID))
+                            .get()
+                            .pipe(Effect.orDie)
+                          const firstSeq = (row?.seq ?? -1) + 1
+                          const finalSeq = firstSeq + payloads.length - 1
+                          const result = new Array<Event.Payload>()
+                          const rows = new Array<typeof EventTable.$inferInsert>()
+                          const ids = new Set<Event.ID>()
+                          for (const [index, item] of payloads.entries()) {
+                            const seq = firstSeq + index
+                            const encoded = Schema.encodeUnknownSync(item.definition.data)(item.event.data) as Record<
+                              string,
+                              unknown
+                            >
+                            if (persist) {
+                              if (ids.has(item.event.id))
+                                yield* Effect.die(
+                                  new InvalidDurableEventError({
+                                    type: item.event.type,
+                                    message: `Event ${item.event.id} appears more than once in the batch`,
+                                  }),
+                                )
+                              ids.add(item.event.id)
+                              const stored = yield* db
+                                .select({ aggregateID: EventTable.aggregate_id, seq: EventTable.seq })
+                                .from(EventTable)
+                                .where(eq(EventTable.id, item.event.id))
+                                .get()
+                                .pipe(Effect.orDie)
+                              if (stored)
+                                yield* Effect.die(
+                                  new InvalidDurableEventError({
+                                    type: item.event.type,
+                                    message: `Event ${item.event.id} already exists at aggregate ${stored.aggregateID} sequence ${stored.seq}`,
+                                  }),
+                                )
+                            }
+                            const event = {
+                              ...item.event,
+                              durable: envelope(aggregateID, seq, item.definition.durable.version),
+                            } as Event.Payload
+                            for (const projector of projectors.get(
+                              versionedType(item.definition.type, item.definition.durable.version),
+                            ) ?? []) {
+                              yield* projector(event)
+                            }
+                            if (item.commit) yield* item.commit(seq)
+                            if (persist)
+                              rows.push({
+                                id: event.id,
+                                aggregate_id: aggregateID,
+                                seq,
+                                created: DateTime.toEpochMillis(event.created),
+                                type: versionedType(item.definition.type, item.definition.durable.version),
+                                data: encoded,
+                              })
+                            result.push(event)
+                          }
+                          yield* db
+                            .insert(EventSequenceTable)
+                            .values([{ aggregate_id: aggregateID, seq: finalSeq }])
+                            .onConflictDoUpdate({ target: EventSequenceTable.aggregate_id, set: { seq: finalSeq } })
+                            .run()
+                            .pipe(Effect.orDie)
+                          if (persist) yield* db.insert(EventTable).values(rows).run().pipe(Effect.orDie)
+                          return result
+                        }),
+                      { behavior: "immediate" },
+                    )
+                    .pipe(Effect.orDie)
+                  yield* Effect.forEach(
+                    pubsub.durable.get(aggregateID) ?? [],
+                    (wake) => PubSub.publish(wake, undefined),
+                    {
+                      discard: true,
+                    },
+                  )
+                  yield* Effect.forEach(committed, (event) => notify(event, true), { discard: true })
+                  return committed as PublishResult<I>
+                }),
+              ),
+            )
+          })
+        }
+
         function replay(
           event: SerializedEvent,
           options?: { readonly publish?: boolean; readonly ownerID?: string; readonly strictOwner?: boolean },
@@ -455,27 +619,31 @@ export function configured(options?: Options) {
                 new InvalidDurableEventError({ type: event.type, message: `Unknown durable event type ${event.type}` }),
               )
             } else {
-              const payload = {
-                id: event.id,
-                created: event.created ?? DateTime.makeUnsafe(0),
-                type: definition.type,
-                data: Schema.decodeUnknownSync(definition.data)(event.data),
-              } as Event.Payload
-              const committed = yield* commitDurableEvent(definition, payload, {
-                seq: event.seq,
-                aggregateID: event.aggregateID,
-                ownerID: options?.ownerID,
-                strictOwner: options?.strictOwner,
-              })
-              if (committed && options?.publish) {
-                yield* notify(
-                  {
-                    ...payload,
-                    durable: envelope(committed.aggregateID, committed.seq, definition.durable.version),
-                  },
-                  true,
-                )
-              }
+              yield* durableLocks.withLock(event.aggregateID)(
+                Effect.gen(function* () {
+                  const payload = {
+                    id: event.id,
+                    created: event.created ?? DateTime.makeUnsafe(0),
+                    type: definition.type,
+                    data: Schema.decodeUnknownSync(definition.data)(event.data),
+                  } as Event.Payload
+                  const committed = yield* commitDurableEvent(definition, payload, {
+                    seq: event.seq,
+                    aggregateID: event.aggregateID,
+                    ownerID: options?.ownerID,
+                    strictOwner: options?.strictOwner,
+                  })
+                  if (committed && options?.publish) {
+                    yield* notify(
+                      {
+                        ...payload,
+                        durable: envelope(committed.aggregateID, committed.seq, definition.durable.version),
+                      },
+                      true,
+                    )
+                  }
+                }),
+              )
             }
           })
         }
@@ -692,6 +860,7 @@ export function configured(options?: Options) {
 
         return Service.of({
           publish,
+          publishAll,
           subscribe,
           log,
           listen,

packages/core/src/database/database.ts

@@ -65,4 +65,13 @@ export function configured(options?: Options) {
   return makeGlobalNode({ service: Service, layer: layer(options), deps: [Global.node] })
 }
 
+/** `configured`, but over an injected SqlClient layer instead of a filesystem path. */
+export function configuredClient(client: Layer.Layer<SqlClient.SqlClient>) {
+  return makeGlobalNode({
+    service: Service,
+    layer: layerFromClient.pipe(Layer.provide(client)),
+    deps: [Global.node],
+  })
+}
+
 export const node = configured({ path: ":memory:" })

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

@@ -28,6 +28,20 @@ export interface EffectSQLiteQueryEffectHKT extends QueryEffectHKTBase {
   readonly context: never
 }
 
+/**
+ * A SqlClient whose runtime rejects SQL transaction statements (BEGIN/COMMIT/SAVEPOINT) and
+ * manages transactions natively instead — Cloudflare Durable Object SQLite. Producers set
+ * `transactionStatements: false` (see `database/sqlite.workerd.ts`) and the session delegates
+ * to the client's `withTransaction` rather than issuing transaction statements.
+ */
+export interface NativeTransactionSqlClient extends SqlClient {
+  readonly transactionStatements: false
+}
+
+export function managesTransactionsNatively(client: SqlClient): client is NativeTransactionSqlClient {
+  return (client as SqlClient & { readonly transactionStatements?: boolean }).transactionStatements === false
+}
+
 export type EffectSQLiteRunResult = readonly never[]
 
 export interface EffectSQLiteSessionOptions {
@@ -120,6 +134,7 @@ export class EffectSQLiteSession<TRelations extends AnyRelations> extends SQLite
   }
 
   private withTransaction<A, E, R>(effect: Effect.Effect<A, E, R>, config: SQLiteTransactionConfig | undefined) {
+    if (managesTransactionsNatively(this.client)) return this.client.withTransaction(effect)
     return Effect.uninterruptibleMask((restore) =>
       Effect.withFiber<A, E | SqlError, R>((fiber) => {
         const services = fiber.context

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

@@ -41,6 +41,7 @@ import m38 from "./migration/20260804233008_loose_psylocke.js"
 import m39 from "./migration/20260805200742_import_legacy_credentials.js"
 import m40 from "./migration/20260808023530_workspace_domain.js"
 import m41 from "./migration/20260811161259_execution_claim_attempts.js"
+import m42 from "./migration/20260812181746_session_inbox.js"
 
 export const migrations = [
   m00,
@@ -85,4 +86,5 @@ export const migrations = [
   m39,
   m40,
   m41,
+  m42,
 ] satisfies DatabaseMigration.Migration[]

packages/core/src/database/migration/20260812181746_session_inbox.ts

@@ -0,0 +1,30 @@
+import { Effect } from "effect"
+import type { DatabaseMigration } from "../migration.js"
+
+const migration: DatabaseMigration.Migration = {
+  id: "20260812181746_session_inbox",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`
+        CREATE TABLE \`session_inbox\` (
+          \`id\` text PRIMARY KEY,
+          \`session_id\` text NOT NULL,
+          \`type\` text NOT NULL,
+          \`payload\` text NOT NULL,
+          \`delivery\` text NOT NULL,
+          \`enqueued_seq\` integer NOT NULL,
+          \`time_created\` integer NOT NULL,
+          CONSTRAINT \`fk_session_inbox_session_id_session_v2_id_fk\` FOREIGN KEY (\`session_id\`) REFERENCES \`session_v2\`(\`id\`) ON DELETE CASCADE
+        );
+      `)
+      yield* tx.run(
+        `CREATE INDEX \`session_inbox_session_delivery_seq_idx\` ON \`session_inbox\` (\`session_id\`,\`delivery\`,\`enqueued_seq\`);`,
+      )
+      yield* tx.run(
+        `CREATE UNIQUE INDEX \`session_inbox_session_enqueued_seq_idx\` ON \`session_inbox\` (\`session_id\`,\`enqueued_seq\`);`,
+      )
+    })
+  },
+}
+
+export default migration

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

@@ -142,6 +142,18 @@ const schema: Omit<DatabaseMigration.Migration, "id"> = {
           CONSTRAINT \`fk_instruction_state_session_id_session_v2_id_fk\` FOREIGN KEY (\`session_id\`) REFERENCES \`session_v2\`(\`id\`) ON DELETE CASCADE
         );
       `)
+      yield* tx.run(`
+        CREATE TABLE \`session_inbox\` (
+          \`id\` text PRIMARY KEY,
+          \`session_id\` text NOT NULL,
+          \`type\` text NOT NULL,
+          \`payload\` text NOT NULL,
+          \`delivery\` text NOT NULL,
+          \`enqueued_seq\` integer NOT NULL,
+          \`time_created\` integer NOT NULL,
+          CONSTRAINT \`fk_session_inbox_session_id_session_v2_id_fk\` FOREIGN KEY (\`session_id\`) REFERENCES \`session_v2\`(\`id\`) ON DELETE CASCADE
+        );
+      `)
       yield* tx.run(`
         CREATE TABLE \`session_message\` (
           \`id\` text PRIMARY KEY,
@@ -218,6 +230,12 @@ const schema: Omit<DatabaseMigration.Migration, "id"> = {
       yield* tx.run(
         `CREATE UNIQUE INDEX \`permission_project_action_resource_idx\` ON \`permission\` (\`project_id\`,\`action\`,\`resource\`);`,
       )
+      yield* tx.run(
+        `CREATE INDEX \`session_inbox_session_delivery_seq_idx\` ON \`session_inbox\` (\`session_id\`,\`delivery\`,\`enqueued_seq\`);`,
+      )
+      yield* tx.run(
+        `CREATE UNIQUE INDEX \`session_inbox_session_enqueued_seq_idx\` ON \`session_inbox\` (\`session_id\`,\`enqueued_seq\`);`,
+      )
       yield* tx.run(
         `CREATE UNIQUE INDEX \`session_message_session_seq_idx\` ON \`session_message\` (\`session_id\`,\`seq\`);`,
       )

packages/core/src/database/sqlite.workerd.ts

@@ -4,6 +4,7 @@ import { Reactivity } from "effect/unstable/reactivity"
 import { SqlClient, Statement } from "effect/unstable/sql"
 import type { Connection } from "effect/unstable/sql/SqlConnection"
 import { classifySqliteError, SqlError, UnknownError } from "effect/unstable/sql/SqlError"
+import type { NativeTransactionSqlClient } from "./drizzle/effect-sqlite/session.js"
 import { Sqlite } from "./sqlite.js"
 
 const ATTR_DB_SYSTEM_NAME = "db.system.name"
@@ -215,10 +216,10 @@ const make = (options: Config) =>
         config: options,
         withTransaction: makeWithTransaction(native, connection, semaphore),
         // Durable Object SQLite rejects BEGIN/COMMIT/SAVEPOINT; consumers such
-        // as the drizzle session must route through withTransaction instead.
+        // as the drizzle session detect this and route through withTransaction.
         transactionStatements: false,
-      },
-    )
+      } as const,
+    ) satisfies NativeTransactionSqlClient
 
     return client
   })

packages/core/src/environment/unavailable.ts

@@ -0,0 +1,17 @@
+import { Effect, Layer, PlatformError } from "effect"
+import { ChildProcessSpawner, make } from "effect/unstable/process/ChildProcessSpawner"
+
+export const spawner = make(() =>
+  Effect.fail(
+    PlatformError.systemError({
+      _tag: "Unknown",
+      module: "Environment",
+      method: "spawn",
+      description: "This location has no execution plane: no workspace is attached and the host cannot spawn processes",
+    }),
+  ),
+)
+
+export const layer = Layer.succeed(ChildProcessSpawner, spawner)
+
+export * as EnvironmentUnavailable from "./unavailable.js"

packages/core/src/filesystem/fff.workerd.ts

@@ -0,0 +1,12 @@
+import { bind } from "./fff.js"
+
+export type { Directory, DirSearch, File, Init, Mixed, MixedSearch, Picker, Result, Search } from "./fff.js"
+
+// No fff backend exists on workerd; every create reports unavailability and
+// FileSystemSearch degrades the same way it does on a runtime without the native module.
+const adapter = bind(undefined, "fff unavailable on workerd runtime")
+
+export const available = adapter.available
+export const create = adapter.create
+
+export * as Fff from "./fff.workerd.js"

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

@@ -2,9 +2,10 @@ import { createRequire } from "node:module"
 
 declare const OPENCODE_LIBC: string | undefined
 
-const require = createRequire(import.meta.url)
-
+// Lazy: on workerd import.meta.url is undefined and the watcher is never
+// loaded, so createRequire must not run at module scope.
 export default function load() {
+  const require = createRequire(import.meta.url)
   const libc = typeof OPENCODE_LIBC === "undefined" ? undefined : OPENCODE_LIBC
   return require(
     process.env.OPENCODE_PARCEL_WATCHER_PATH ??

packages/core/src/image/photon-wasm.workerd.ts

@@ -0,0 +1,4 @@
+// workerd has no filesystem path to a photon wasm artifact. Image.Photon only
+// reads this lazily and surfaces a typed ResizerUnavailableError when loading
+// fails, so an empty path degrades cleanly instead of breaking module load.
+export default ""

packages/core/src/mcp/client.ts

@@ -1,11 +1,10 @@
 export * as MCPClient from "./client.js"
 
 import path from "node:path"
-import { execFile } from "node:child_process"
 import { pathToFileURL } from "node:url"
 import { Client } from "@modelcontextprotocol/sdk/client/index.js"
-import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js"
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js"
+import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js"
 import { UnauthorizedError, type OAuthClientProvider } from "@modelcontextprotocol/sdk/client/auth.js"
 import {
   CallToolResultSchema,
@@ -30,13 +29,12 @@ import {
 } from "@modelcontextprotocol/sdk/types.js"
 import { Cause, Effect, Exit, Schema } from "effect"
 import { ConfigMCP } from "@opencode-ai/schema/config/mcp"
+import { MCPStdio } from "./stdio.js"
 
 const DEFAULT_STARTUP_TIMEOUT = 30_000
 const DEFAULT_CATALOG_TIMEOUT = 30_000
 const DEFAULT_EXECUTION_TIMEOUT = 12 * 60 * 60 * 1_000 // 12 hours
 
-type Transport = StdioClientTransport | StreamableHTTPClientTransport
-
 // Some servers advertise tool outputSchemas the SDK's strict validator can't resolve; this drops
 // only that field so a single bad schema doesn't blank out the whole tool list.
 const TolerantListToolsResult = ListToolsResultSchema.extend({
@@ -176,7 +174,12 @@ export interface Connection {
   readonly onResourcesChanged: (callback: () => void) => void
 }
 
-/** Connects an MCP server; closing the calling scope tears down the transport and any spawned process. */
+/**
+ * Connects an MCP server; closing the calling scope tears down the transport and any spawned process.
+ *
+ * A stdio server is spawned through the location's `Environment`, so it runs on the same execution
+ * plane as the location's shell commands rather than always on the host.
+ */
 export const connect = Effect.fnUntraced(function* (
   server: string,
   config: typeof ConfigMCP.Server.Type,
@@ -190,13 +193,12 @@ export const connect = Effect.fnUntraced(function* (
   const transport: Transport = yield* Effect.gen(function* () {
     if (config.type === "local") {
       const [command, ...args] = config.command
-      return new StdioClientTransport({
+      return yield* MCPStdio.make({
+        server,
         command,
         args,
         cwd: config.cwd ? path.resolve(directory, config.cwd) : directory,
-        stderr: "pipe",
-        env: {
-          ...(process.env as Record<string, string>),
+        environment: {
           ...(command === "opencode" ? { BUN_BE_BUN: "1" } : {}),
           ...config.environment,
         },
@@ -233,9 +235,9 @@ export const connect = Effect.fnUntraced(function* (
     catch: (error) => error,
   }).pipe(Effect.exit)
   if (Exit.isSuccess(exit)) {
-    yield* Effect.addFinalizer(() =>
-      cleanupStdioDescendants(transport).pipe(Effect.andThen(Effect.promise(() => client.close())), Effect.ignore),
-    )
+    // Closing the client closes the transport, which ends stdin and then kills through the spawner
+    // handle if the server does not exit cleanly. The process scope remains a final backstop.
+    yield* Effect.addFinalizer(() => Effect.promise(() => client.close()).pipe(Effect.ignore))
     const catalogTimeout = config.timeout?.catalog ?? DEFAULT_CATALOG_TIMEOUT
     const executionTimeout = config.timeout?.execution ?? DEFAULT_EXECUTION_TIMEOUT
     return {
@@ -434,58 +436,12 @@ export const connect = Effect.fnUntraced(function* (
     } satisfies Connection
   }
 
-  yield* cleanupStdioDescendants(transport).pipe(Effect.andThen(Effect.promise(() => transport.close())), Effect.ignore)
+  yield* Effect.promise(() => transport.close()).pipe(Effect.ignore)
   const error = Cause.squash(exit.cause)
   if (error instanceof UnauthorizedError) return yield* new NeedsAuthError({ server })
   return yield* new ConnectError({ server, message: error instanceof Error ? error.message : String(error) })
 })
 
-// SDK close stops the MCP process, but not child processes it spawned.
-const cleanupStdioDescendants = (transport: Transport) =>
-  Effect.gen(function* () {
-    if (!(transport instanceof StdioClientTransport)) return
-    const pid = transport.pid
-    if (typeof pid !== "number") return
-    yield* Effect.forEach(
-      yield* descendantPids(pid),
-      (pid) =>
-        Effect.try({
-          try: () => process.kill(pid, "SIGTERM"),
-          catch: () => undefined,
-        }).pipe(Effect.ignore),
-      { discard: true },
-    )
-  })
-
-const descendantPids = Effect.fnUntraced(function* (root: number) {
-  if (process.platform === "win32") return []
-  const result: number[] = []
-  const queue = [root]
-  for (let index = 0; index < queue.length; index++) {
-    const parent = queue[index]
-    if (parent === undefined) return result
-    const children = (yield* childPids(parent)).filter((pid) => !result.includes(pid))
-    result.push(...children)
-    queue.push(...children)
-  }
-  return result
-})
-
-const childPids = (pid: number) =>
-  Effect.promise(
-    () =>
-      new Promise<number[]>((resolve) => {
-        execFile("pgrep", ["-P", String(pid)], { encoding: "utf8" }, (_error, stdout) => {
-          resolve(
-            stdout
-              .split("\n")
-              .map((line) => Number.parseInt(line, 10))
-              .filter((pid) => Number.isInteger(pid)),
-          )
-        })
-      }),
-  )
-
 async function paginate<R extends { nextCursor?: string }, T>(
   list: (cursor: string | undefined) => Promise<R>,
   items: (result: R) => T[],

packages/core/src/mcp/index.ts

@@ -12,6 +12,7 @@ import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
 import { Config } from "../config.js"
 import { Credential } from "../credential.js"
 import { Bus } from "../bus.js"
+import { Environment } from "../environment/index.js"
 import { Form } from "../form.js"
 import { Integration } from "../integration.js"
 import { KeyedMutex } from "../effect/keyed-mutex.js"
@@ -173,13 +174,13 @@ export const layer = (options?: Options) =>
     Effect.gen(function* () {
       const config = yield* Config.Service
       const location = yield* Location.Service
+      const environment = yield* Environment.Service
       const bus = yield* Bus.Service
       const forms = yield* Form.Service
       const integration = yield* Integration.Service
       const credentials = yield* Credential.Service
-      const root = yield* Scope.make()
+      const root = yield* Effect.scope
       const fork = yield* FiberSet.makeRuntime<never, void, never>()
-      yield* Effect.addFinalizer((exit) => Scope.close(root, exit))
 
       const loadConfig = (entries: readonly Entry[]) => {
         const documents = entries.filter((entry): entry is Document => entry.type === "document")
@@ -459,13 +460,8 @@ export const layer = (options?: Options) =>
         connection.onClose(() =>
           live(
             Effect.gen(function* () {
-              entry.client = undefined
-              entry.tools = undefined
-              entry.prompts = undefined
               entry.status = { status: "failed", error: "Connection closed" }
-              yield* bus.publish(McpEvent.ToolsChanged, { server: name }).pipe(Effect.ignore)
-              yield* bus.publish(McpEvent.ResourcesChanged, { server: name }).pipe(Effect.ignore)
-              yield* bus.publish(Command.Event.Updated, {}).pipe(Effect.ignore)
+              yield* stopServer(name, entry)
               yield* bus.publish(McpEvent.StatusChanged, { server: name }).pipe(Effect.ignore)
             }),
           ),
@@ -520,6 +516,8 @@ export const layer = (options?: Options) =>
             options?.clientInfo,
           ).pipe(
             Effect.flatMap((connection) => connection.tools().pipe(Effect.map((tools) => ({ connection, tools })))),
+            // A stdio server is spawned on this location's execution plane, not the host's.
+            Effect.provideService(Environment.Service, environment),
             Scope.provide(scope),
             Effect.exit,
           )
@@ -828,7 +826,7 @@ export function configured(options?: Options) {
   return makeLocationNode({
     service: Service,
     layer: layer(options),
-    deps: [Config.node, Location.node, Bus.node, Form.node, Integration.node, Credential.node],
+    deps: [Config.node, Location.node, Environment.node, Bus.node, Form.node, Integration.node, Credential.node],
   })
 }
 

packages/core/src/mcp/oauth.ts

@@ -2,7 +2,6 @@ export * as MCPOAuth from "./oauth.js"
 
 import { auth, type OAuthClientProvider } from "@modelcontextprotocol/sdk/client/auth.js"
 import type { OAuthClientInformationMixed, OAuthTokens } from "@modelcontextprotocol/sdk/shared/auth.js"
-import { createServer } from "node:http"
 import { Deferred, Effect } from "effect"
 import { Credential } from "@opencode-ai/schema/credential"
 import { ConfigMCP } from "@opencode-ai/schema/config/mcp"
@@ -152,6 +151,8 @@ export const authorize = (input: {
     const redirectPath = oauth?.redirect_uri ? new URL(oauth.redirect_uri).pathname : "/callback"
     const state = Buffer.from(crypto.getRandomValues(new Uint8Array(32))).toString("base64url")
 
+    // Lazy so runtimes without a loopback listener (workerd) never evaluate node:http.
+    const { createServer } = yield* Effect.promise(() => import("node:http"))
     const server = createServer((request, response) => {
       const url = new URL(request.url ?? "/", "http://127.0.0.1")
       if (url.pathname !== redirectPath) {

packages/core/src/mcp/stdio.ts

@@ -0,0 +1,181 @@
+export * as MCPStdio from "./stdio.js"
+
+import { ReadBuffer, serializeMessage } from "@modelcontextprotocol/sdk/shared/stdio.js"
+import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js"
+import type { JSONRPCMessage } from "@modelcontextprotocol/sdk/types.js"
+import { Cause, Duration, Effect, Queue, Scope, Stream } from "effect"
+import { ChildProcess } from "effect/unstable/process"
+import type { ChildProcessHandle } from "effect/unstable/process/ChildProcessSpawner"
+import { Environment } from "../environment/index.js"
+
+/** Mirrors StdioClientTransport: wait this long for a graceful exit after stdin closes. */
+const CLOSE_GRACE = Duration.seconds(2)
+
+/** Mirrors StdioClientTransport: escalate SIGTERM to SIGKILL after this long. */
+const FORCE_KILL_AFTER = Duration.seconds(2)
+const OUTGOING_CAPACITY = 64
+const MAX_FRAME_BYTES = 16 * 1024 * 1024
+
+export interface Options {
+  /** Server name; only used to attribute logs. */
+  readonly server: string
+  readonly command: string
+  readonly args: ReadonlyArray<string>
+  readonly cwd: string
+  /**
+   * Environment declared by the server config, and nothing else.
+   *
+   * The host environment is merged in by the spawner via `extendEnv`, which keeps the merge on the
+   * side that actually runs the process: the local driver extends with the host's `process.env`
+   * (what the MCP SDK's transport did), while a workspace driver extends with the sandbox's own
+   * environment. Host variables therefore never cross the seam into a remote workspace.
+   */
+  readonly environment: Record<string, string>
+}
+
+/**
+ * MCP stdio transport that spawns its server through the location's `Environment` instead of the
+ * SDK's host-bound `StdioClientTransport`, so a workspace-backed location runs its MCP servers
+ * wherever the rest of its execution happens.
+ *
+ * The process is acquired in the calling scope: closing the scope kills it (the spawner kills the
+ * whole process group, so descendants go too) regardless of whether the transport was closed.
+ */
+export const make = Effect.fnUntraced(function* (options: Options) {
+  const environment = yield* Environment.Service
+  const scope = yield* Effect.scope
+  // Outgoing frames are queued rather than written to `handle.stdin` directly: the sink closes the
+  // stream it is run with, and stdin must stay open across the whole session.
+  const outgoing = yield* Queue.bounded<string, Cause.Done>(OUTGOING_CAPACITY)
+  const buffer = new ReadBuffer()
+  const state: { phase: "ready" | "starting" | "open" | "closed"; handle?: ChildProcessHandle } = { phase: "ready" }
+  let startup: Promise<void> | undefined
+  let closing: Promise<void> | undefined
+  let trailingBytes = 0
+
+  const stop = (handle: ChildProcessHandle) =>
+    Effect.gen(function* () {
+      const exit = yield* Effect.timeoutOption(handle.exitCode, CLOSE_GRACE)
+      if (exit._tag === "Some") return
+      const terminated = yield* Effect.timeoutOption(handle.kill({ killSignal: "SIGTERM" }), FORCE_KILL_AFTER)
+      if (terminated._tag === "None") yield* handle.kill({ killSignal: "SIGKILL" })
+    }).pipe(Effect.ignore)
+
+  const close = () =>
+    (closing ??= Effect.runPromise(
+      Effect.gen(function* () {
+        state.phase = "closed"
+        Queue.endUnsafe(outgoing)
+        if (startup) yield* Effect.promise(() => startup!.catch(() => undefined))
+        const handle = state.handle
+        if (!handle) return
+        state.handle = undefined
+        yield* stop(handle)
+      }).pipe(Effect.ensuring(Queue.shutdown(outgoing)), Effect.ensuring(Effect.sync(() => buffer.clear()))),
+    ))
+
+  const transport: Transport = {
+    start: () => {
+      if (state.phase !== "ready") return Promise.reject(new Error("Stdio transport already started"))
+      state.phase = "starting"
+      startup = Effect.runPromise(
+        Effect.gen(function* () {
+          const handle = yield* environment.spawner.spawn(
+            ChildProcess.make(options.command, [...options.args], {
+              cwd: options.cwd,
+              env: options.environment,
+              extendEnv: true,
+              stdin: { stream: Stream.encodeText(Stream.fromQueue(outgoing)), endOnDone: true },
+              stdout: "pipe",
+              stderr: "pipe",
+              forceKillAfter: FORCE_KILL_AFTER,
+            }),
+          )
+          state.handle = handle
+          if (state.phase === "closed") {
+            state.handle = undefined
+            return yield* stop(handle)
+          }
+          state.phase = "open"
+          yield* startOutput(handle)
+        }).pipe(Scope.provide(scope)),
+      )
+      return startup
+    },
+    send: (message: JSONRPCMessage) =>
+      state.phase !== "open"
+        ? Promise.reject(new Error("Not connected"))
+        : Effect.runPromise(
+            Queue.offer(outgoing, serializeMessage(message)).pipe(
+              Effect.flatMap((offered) => (offered ? Effect.void : Effect.fail(new Error("Not connected")))),
+            ),
+          ),
+    close,
+  }
+
+  const deliver = (chunk: Uint8Array) =>
+    Effect.gen(function* () {
+      for (const byte of chunk) {
+        trailingBytes = byte === 10 ? 0 : trailingBytes + 1
+        if (trailingBytes > MAX_FRAME_BYTES) return yield* Effect.fail(new Error("MCP stdio frame exceeded 16 MiB"))
+      }
+      buffer.append(Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength))
+      while (true) {
+        // `undefined` means the frame failed to parse: the buffer has already advanced past it, so
+        // keep draining. `null` means the buffer holds no complete frame yet.
+        const message = yield* Effect.try({
+          try: () => buffer.readMessage(),
+          catch: (cause) => (cause instanceof Error ? cause : new Error(String(cause))),
+        }).pipe(
+          Effect.catch((error) =>
+            Effect.sync(() => {
+              transport.onerror?.(error)
+              return undefined
+            }),
+          ),
+        )
+        if (message === undefined) continue
+        if (message === null) return
+        transport.onmessage?.(message)
+      }
+    })
+
+  const startOutput = (handle: ChildProcessHandle) =>
+    Effect.gen(function* () {
+      yield* Effect.forkScoped(
+        Stream.runForEach(handle.stdout, deliver).pipe(
+          Effect.tapCause((cause) =>
+            Effect.sync(() => {
+              const error = Cause.squash(cause)
+              transport.onerror?.(error instanceof Error ? error : new Error(String(error)))
+            }),
+          ),
+          Effect.ignore,
+          // stdout ending means the server is gone; the SDK transport reports that the same way.
+          Effect.ensuring(
+            Effect.gen(function* () {
+              const unexpected = state.phase !== "closed"
+              if (unexpected) yield* Effect.promise(close)
+              transport.onclose?.()
+            }),
+          ),
+        ),
+      )
+
+      // StdioClientTransport pipes stderr into a stream nobody reads. Drain chunks into the debug
+      // log so chatty servers cannot stall and newline-free output is not buffered without bound.
+      yield* Effect.forkScoped(
+        handle.stderr.pipe(
+          Stream.decodeText(),
+          Stream.runForEach((output) =>
+            output.trim() === ""
+              ? Effect.void
+              : Effect.logDebug("mcp server stderr", { server: options.server, output }),
+          ),
+          Effect.ignore,
+        ),
+      )
+    })
+
+  return transport
+})

packages/core/src/models-dev.ts

@@ -544,6 +544,24 @@ const Cache = Schema.Struct({
 })
 const defaultSource = "https://models.opencode.ai"
 
+// Bundled snapshot of https://models.opencode.ai/api.json, committed at
+// packages/core/src/models-dev/snapshot.txt and refreshed via
+// `bun run script/update-models-snapshot.ts`. Decoded and normalized once per
+// isolate: the snapshot is a multi-MB module-level constant and one isolate can
+// host many runtimes (Cloudflare colocates Durable Object instances), so
+// per-runtime decoding would multiply the cost.
+let bundledCache: readonly Snapshot[] | undefined
+const bundledSnapshot = Effect.suspend(() =>
+  bundledCache
+    ? Effect.succeed(bundledCache)
+    : decodeCatalog(snapshotText).pipe(
+        Effect.map((catalog) => {
+          bundledCache = normalize(catalog)
+          return bundledCache
+        }),
+      ),
+)
+
 function cacheKey(source: string) {
   if (source === defaultSource) return "models-dev:catalog"
   return `models-dev:catalog:${Hash.fast(source)}`
@@ -607,11 +625,9 @@ export const layer = (options?: Options) =>
           )
         : Effect.succeed(undefined)
 
-      // Bundled snapshot of https://models.opencode.ai/api.json, committed at
-      // packages/core/src/models-dev/snapshot.txt and refreshed via
-      // `bun run script/update-models-snapshot.ts`. It is the boot-time floor
-      // for the catalog; the periodic fetch below still refreshes on top.
-      const loadSnapshot = options?.snapshot === false ? Effect.succeed(undefined) : decodeCatalog(snapshotText)
+      // The bundled snapshot is the boot-time floor for the catalog; the
+      // periodic fetch below still refreshes on top.
+      const loadSnapshot = options?.snapshot === false ? Effect.succeed(undefined) : bundledSnapshot
 
       const fetchAndWrite = Effect.fn("ModelsDev.fetchAndWrite")(function* () {
         const text = yield* fetchApi()
@@ -635,7 +651,7 @@ export const layer = (options?: Options) =>
         const cached = options?.file ? undefined : yield* loadFromCache()
         if (cached) return normalize(cached.catalog)
         const bundled = yield* loadSnapshot
-        if (bundled) return normalize(bundled)
+        if (bundled) return bundled
         if (!fetch) return []
         const catalog = yield* lock.withPermit(
           Effect.gen(function* () {

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

@@ -204,10 +204,11 @@ export const GithubCopilotPlugin = define({
         for (const [id, model] of loaded.models) {
           evt.model.update(item.provider.id, id, (draft) => Object.assign(draft, structuredClone(model)))
         }
-      } else if (loaded.baseURL) {
+      } else {
         for (const id of item.models.keys()) {
           evt.model.update(item.provider.id, id, (model) => {
-            model.settings = Provider.mergeOverlay(model.settings, { baseURL: loaded.baseURL })
+            model.package = "@ai-sdk/github-copilot"
+            if (loaded.baseURL) model.settings = Provider.mergeOverlay(model.settings, { baseURL: loaded.baseURL })
           })
         }
       }

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

@@ -1,4 +1,3 @@
-import { createServer } from "node:http"
 import type { IntegrationOAuthMethodRegistration } from "@opencode-ai/plugin/effect/integration"
 import { define } from "@opencode-ai/plugin/effect/plugin"
 import { Deferred, Effect, Option, Schema, Semaphore, Stream } from "effect"
@@ -58,6 +57,8 @@ const browser = (app: App.Info) =>
         const state = base64UrlEncode(crypto.getRandomValues(new Uint8Array(32)).buffer)
         const code = yield* Deferred.make<string, Error>()
         const redirect = `http://localhost:${callbackPort}/auth/callback`
+        // Lazy so runtimes without a loopback listener (workerd) never evaluate node:http.
+        const { createServer } = yield* Effect.promise(() => import("node:http"))
         const server = createServer((request, response) => {
           const url = new URL(request.url ?? "/", `http://localhost:${callbackPort}`)
           if (url.pathname !== "/auth/callback") {

packages/core/src/project.ts

@@ -5,7 +5,9 @@ import { ChildProcess } from "effect/unstable/process"
 import { asc, desc } from "drizzle-orm"
 import path from "path"
 import { AbsolutePath } from "./schema.js"
+import { Bus } from "./bus.js"
 import { Database } from "./database/database.js"
+import { Event } from "@opencode-ai/schema/project-directories"
 import { FSUtil } from "@opencode-ai/util/fs-util"
 import { Git } from "./git.js"
 import { AppProcess } from "@opencode-ai/util/process"
@@ -91,28 +93,40 @@ const layer = Layer.effect(
     const fs = yield* FSUtil.Service
     const git = yield* Git.Service
     const proc = yield* AppProcess.Service
+    const bus = yield* Bus.Service
     const db = (yield* Database.Service).db
     const projectDirectories = yield* ProjectDirectories.Service
 
+    const announcing = new Set<string>()
     const persist = Effect.fnUntraced(function* (project: Resolved) {
-      yield* db
-        .transaction((tx) =>
-          Effect.gen(function* () {
-            yield* upsertProject(tx, project)
-            if (!project.vcs) return
-            yield* projectDirectories.create({ projectID: project.id, directory: project.canonical }, tx)
-            if (project.directory === project.canonical) return
-            yield* projectDirectories.create(
-              {
-                projectID: project.id,
-                directory: project.directory,
-                strategy: project.vcs.type === "git" ? "git_worktree" : undefined,
-              },
-              tx,
-            )
-          }),
-        )
-        .pipe(Effect.orDie)
+      yield* upsertProject(db, project).pipe(Effect.orDie)
+      if (!project.vcs) return project
+      const directories: ProjectDirectories.CreateInput[] = [{ projectID: project.id, directory: project.canonical }]
+      if (project.directory !== project.canonical)
+        directories.push({
+          projectID: project.id,
+          directory: project.directory,
+          strategy: project.vcs.type === "git" ? "git_worktree" : undefined,
+        })
+      // A missing directory row means this directory's resolution is a new durable
+      // fact (copy.ts registers copy directories directly; those never strand
+      // sessions and never announce). The row insert commits atomically with the
+      // event, so a crash between checks retries on the next resolve instead of
+      // stranding the announcement. The in-flight set keeps concurrent resolves
+      // from publishing the same fact twice.
+      for (const item of directories) {
+        const key = item.projectID + "\u0000" + item.directory
+        if (announcing.has(key)) continue
+        announcing.add(key)
+        yield* Effect.gen(function* () {
+          if (yield* projectDirectories.get({ projectID: item.projectID, directory: item.directory })) return
+          yield* bus.publish(
+            Event.Resolved,
+            { projectID: item.projectID, directory: item.directory, previous: project.previous ?? ID.global },
+            { commit: () => Effect.asVoid(projectDirectories.create(item)) },
+          )
+        }).pipe(Effect.ensuring(Effect.sync(() => announcing.delete(key))))
+      }
       return project
     })
 
@@ -250,5 +264,5 @@ const layer = Layer.effect(
 export const node = makeGlobalNode({
   service: Service,
   layer: layer,
-  deps: [Database.node, FSUtil.node, Git.node, AppProcess.node, ProjectDirectories.node],
+  deps: [Bus.node, Database.node, FSUtil.node, Git.node, AppProcess.node, ProjectDirectories.node],
 })

packages/core/src/pty/pty.workerd.ts

@@ -0,0 +1,9 @@
+import type { Proc } from "./pty.js"
+
+export type { Disp, Exit, Opts, Proc } from "./pty.js"
+
+// workerd cannot spawn processes; the Pty service surfaces this as a defect if
+// a terminal is ever requested on this runtime.
+export function spawn(): Proc {
+  throw new Error("Pseudo-terminals are unavailable on the workerd runtime")
+}

packages/core/src/session.ts

@@ -31,7 +31,7 @@ import { ForkEmptyError, MessageDecodeError, NotFoundError } from "./session/err
 import { makeGlobalNode } from "@opencode-ai/util/effect/app-node"
 import { LocationServiceMap } from "./location-service-map.js"
 import { SessionEvent } from "./session/event.js"
-import { SessionPending } from "./session/pending.js"
+import { SessionInbox } from "./session/inbox.js"
 import { InstructionState } from "./session/instruction-state.js"
 import { SessionGenerate } from "./session/generate.js"
 import { Snapshot } from "./snapshot.js"
@@ -99,6 +99,7 @@ type CreateInput = CreateBaseInput &
 type CompactInput = {
   id?: SessionMessage.ID
   sessionID: SessionSchema.ID
+  delivery?: SessionInbox.Delivery
 }
 
 type ForkInput = {
@@ -133,14 +134,11 @@ export class CompactionConflictError extends Schema.TaggedErrorClass<CompactionC
 export class BusyError extends Schema.TaggedErrorClass<BusyError>()("Session.BusyError", {
   sessionID: SessionSchema.ID,
 }) {}
-export class PendingInputConflictError extends Schema.TaggedErrorClass<PendingInputConflictError>()(
-  "Session.PendingInputConflictError",
-  {
-    sessionID: SessionSchema.ID,
-    inputID: SessionMessage.ID,
-  },
-) {}
-type PendingInputRef = { readonly sessionID: SessionSchema.ID; readonly inputID: SessionMessage.ID }
+export class InboxConflictError extends Schema.TaggedErrorClass<InboxConflictError>()("Session.InboxConflictError", {
+  sessionID: SessionSchema.ID,
+  inboxID: SessionMessage.ID,
+}) {}
+type InboxItemRef = { readonly sessionID: SessionSchema.ID; readonly inboxID: SessionMessage.ID }
 export class SkillNotFoundError extends Schema.TaggedErrorClass<SkillNotFoundError>()("Session.SkillNotFoundError", {
   skill: Skill.ID,
 }) {}
@@ -188,10 +186,10 @@ export interface Interface {
    * ordered by admission. Includes unpromoted user and synthetic inputs and
    * unhandled compaction barriers.
    */
-  readonly pending: (sessionID: SessionSchema.ID) => Effect.Effect<SessionPending.Info[], NotFoundError>
-  readonly cancelPending: (input: PendingInputRef) => Effect.Effect<void, NotFoundError | PendingInputConflictError>
-  readonly steerPending: (input: PendingInputRef) => Effect.Effect<void, NotFoundError | PendingInputConflictError>
-  readonly queuePending: (input: PendingInputRef) => Effect.Effect<void, NotFoundError | PendingInputConflictError>
+  readonly inbox: (sessionID: SessionSchema.ID) => Effect.Effect<SessionInbox.Info[], NotFoundError>
+  readonly cancelInbox: (input: InboxItemRef) => Effect.Effect<void, NotFoundError | InboxConflictError>
+  readonly steerInbox: (input: InboxItemRef) => Effect.Effect<void, NotFoundError | InboxConflictError>
+  readonly queueInbox: (input: InboxItemRef) => Effect.Effect<void, NotFoundError | InboxConflictError>
   /**
    * Durable, ordered session log read. Replays durable session bus after
    * the exclusive `after` cursor, emits a `Synced` marker at the captured
@@ -211,6 +209,7 @@ export interface Interface {
     sessionID: SessionSchema.ID
     directory: AbsolutePath
     workspaceID?: Location.Ref["workspaceID"]
+    delivery?: SessionInbox.Delivery
   }) => Effect.Effect<void, NotFoundError | DestinationNotFoundError | DestinationNotDirectoryError>
   readonly prompt: (input: {
     id?: SessionMessage.ID
@@ -220,9 +219,9 @@ export interface Interface {
     agents?: PromptInput.Prompt["agents"]
     skills?: PromptInput.Prompt["skills"]
     metadata?: Record<string, unknown>
-    delivery?: SessionPending.Delivery
+    delivery?: SessionInbox.Delivery
     resume?: boolean
-  }) => Effect.Effect<SessionPending.User, NotFoundError | PromptConflictError | AttachmentError | SkillNotFoundError>
+  }) => Effect.Effect<SessionInbox.User, NotFoundError | PromptConflictError | AttachmentError | SkillNotFoundError>
   /** Generates text from current Session context without admitting input or mutating history. */
   readonly generate: (input: {
     sessionID: SessionSchema.ID
@@ -238,10 +237,10 @@ export interface Interface {
     files?: PromptInput.Prompt["files"]
     agents?: PromptInput.Prompt["agents"]
     skills?: PromptInput.Prompt["skills"]
-    delivery?: SessionPending.Delivery
+    delivery?: SessionInbox.Delivery
     resume?: boolean
   }) => Effect.Effect<
-    SessionPending.User,
+    SessionInbox.User,
     | NotFoundError
     | PromptConflictError
     | AttachmentError
@@ -262,7 +261,7 @@ export interface Interface {
   }) => Effect.Effect<void, NotFoundError | SkillNotFoundError>
   readonly compact: (
     input: CompactInput,
-  ) => Effect.Effect<SessionPending.Compaction, NotFoundError | CompactionConflictError>
+  ) => Effect.Effect<SessionInbox.Compaction, NotFoundError | CompactionConflictError>
   readonly wait: (id: SessionSchema.ID) => Effect.Effect<void, NotFoundError>
   readonly active: Effect.Effect<ReadonlySet<SessionSchema.ID>>
   readonly background: (sessionID: SessionSchema.ID) => Effect.Effect<void, NotFoundError>
@@ -274,9 +273,9 @@ export interface Interface {
     text: string
     description?: string
     metadata?: Record<string, unknown>
-    delivery?: SessionPending.Delivery
+    delivery?: SessionInbox.Delivery
     resume?: boolean
-  }) => Effect.Effect<SessionPending.Synthetic, NotFoundError | SyntheticConflictError>
+  }) => Effect.Effect<SessionInbox.Synthetic, NotFoundError | SyntheticConflictError>
   readonly revert: {
     readonly stage: (input: {
       sessionID: SessionSchema.ID
@@ -321,12 +320,12 @@ const layer = Layer.effect(
         ),
       )
 
-    const pendingConflict = Effect.fn("Session.pendingConflict")(function* (input: PendingInputRef) {
+    const pendingConflict = Effect.fn("Session.pendingConflict")(function* (input: InboxItemRef) {
       yield* result.get(input.sessionID)
-      return yield* new PendingInputConflictError(input)
+      return yield* new InboxConflictError(input)
     })
     const mutatePending = (
-      input: PendingInputRef,
+      input: InboxItemRef,
       mutation: (
         bus: Bus.Interface,
         input: { readonly id: SessionMessage.ID; readonly sessionID: SessionSchema.ID },
@@ -335,9 +334,9 @@ const layer = Layer.effect(
     ) =>
       Effect.uninterruptible(
         Effect.gen(function* () {
-          yield* mutation(bus, { sessionID: input.sessionID, id: input.inputID }).pipe(
+          yield* mutation(bus, { sessionID: input.sessionID, id: input.inboxID }).pipe(
             Effect.catchDefect((defect) =>
-              defect instanceof SessionPending.LifecycleConflict ? pendingConflict(input) : Effect.die(defect),
+              defect instanceof SessionInbox.LifecycleConflict ? pendingConflict(input) : Effect.die(defect),
             ),
           )
           if (wake) yield* execution.wake(input.sessionID)
@@ -529,13 +528,13 @@ const layer = Layer.effect(
         yield* result.get(sessionID)
         return yield* store.context(sessionID)
       }),
-      pending: Effect.fn("Session.pending")(function* (sessionID) {
+      inbox: Effect.fn("Session.inbox")(function* (sessionID) {
         yield* result.get(sessionID)
-        return yield* SessionPending.list(db, sessionID)
+        return yield* SessionInbox.list(db, sessionID)
       }),
-      cancelPending: Effect.fn("Session.cancelPending")((input) => mutatePending(input, SessionPending.cancel)),
-      steerPending: Effect.fn("Session.steerPending")((input) => mutatePending(input, SessionPending.steer, true)),
-      queuePending: Effect.fn("Session.queuePending")((input) => mutatePending(input, SessionPending.queue)),
+      cancelInbox: Effect.fn("Session.cancelInbox")((input) => mutatePending(input, SessionInbox.cancel)),
+      steerInbox: Effect.fn("Session.steerInbox")((input) => mutatePending(input, SessionInbox.steer, true)),
+      queueInbox: Effect.fn("Session.queueInbox")((input) => mutatePending(input, SessionInbox.queue)),
       log: (input) =>
         Stream.unwrap(
           result
@@ -564,25 +563,25 @@ const layer = Layer.effect(
               skills,
             ).pipe(Effect.provideService(FSUtil.Service, fs))
             const messageID = input.id ?? SessionMessage.ID.create()
-            const admittedInput = SessionPending.Message.make({
+            const admittedInput = SessionInbox.Item.make({
               type: "user",
-              data: { ...prompt, metadata: input.metadata },
+              payload: { ...prompt, metadata: input.metadata },
               delivery: input.delivery ?? "steer",
             })
-            const admitted = yield* SessionPending.admit(db, bus, {
+            const admitted = yield* SessionInbox.admit(db, bus, {
               id: messageID,
               sessionID: input.sessionID,
-              input: admittedInput,
+              item: admittedInput,
             }).pipe(
               Effect.catchDefect((defect) =>
-                defect instanceof SessionPending.LifecycleConflict
+                defect instanceof SessionInbox.LifecycleConflict
                   ? new PromptConflictError({ sessionID: input.sessionID, messageID })
                   : Effect.die(defect),
               ),
             )
             if (
               admitted.type !== "user" ||
-              !SessionPending.equivalent(admitted, { sessionID: input.sessionID, input: admittedInput })
+              !SessionInbox.equivalent(admitted, { sessionID: input.sessionID, item: admittedInput })
             )
               return yield* new PromptConflictError({ sessionID: input.sessionID, messageID })
             if (input.resume !== false) {
@@ -640,7 +639,9 @@ const layer = Layer.effect(
             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, timeout: 0 })
+              return yield* shell
+                .create({ command: input.command, cwd: session.location.directory, timeout: 0 })
+                .pipe(Effect.orDie)
             }).pipe(Effect.provide(locations.get(session.location)))
             yield* bus.publish(
               SessionEvent.Shell.Started,
@@ -738,33 +739,35 @@ const layer = Layer.effect(
         const info = yield* fs.stat(directory).pipe(Effect.catch(() => Effect.succeed(undefined)))
         if (!info) return yield* new DestinationNotFoundError({ directory })
         if (info.type !== "Directory") return yield* new DestinationNotDirectoryError({ directory })
-        if (current.location.directory === directory && current.location.workspaceID === input.workspaceID) return
         const project = yield* projects.resolve(directory)
         yield* persistProject(project)
-        if ((yield* execution.active).has(input.sessionID)) {
-          yield* execution.interrupt(input.sessionID)
-          yield* execution.awaitIdle(input.sessionID)
-        }
-        yield* bus.publish(
-          SessionEvent.Moved,
-          {
-            sessionID: input.sessionID,
+        const item = SessionInbox.Item.make({
+          type: "move",
+          payload: {
             location: Location.Ref.make({ directory, workspaceID: input.workspaceID }),
             projectID: project.id,
             subpath: RelativePath.make(path.relative(project.directory, directory).replaceAll("\\", "/")),
           },
-          { location: current.location },
-        )
+          delivery: input.delivery ?? "steer",
+        })
+        const inboxID = SessionMessage.ID.create()
+        yield* SessionInbox.admit(db, bus, {
+          id: inboxID,
+          sessionID: input.sessionID,
+          item,
+        })
+        yield* execution.wake(input.sessionID)
       }),
       compact: Effect.fn("Session.compact")(function* (input) {
         yield* result.get(input.sessionID)
         const inputID = input.id ?? SessionMessage.ID.create()
-        const admitted = yield* SessionPending.admitCompaction(db, bus, {
+        const admitted = yield* SessionInbox.admitCompaction(db, bus, {
           id: inputID,
           sessionID: input.sessionID,
+          delivery: input.delivery ?? "queue",
         }).pipe(
           Effect.catchDefect((defect) =>
-            defect instanceof SessionPending.LifecycleConflict
+            defect instanceof SessionInbox.LifecycleConflict
               ? new CompactionConflictError({ sessionID: input.sessionID, inputID })
               : Effect.die(defect),
           ),
@@ -804,29 +807,29 @@ const layer = Layer.effect(
           Effect.gen(function* () {
             yield* result.get(input.sessionID)
             const inputID = input.id ?? SessionMessage.ID.create()
-            const admittedInput = SessionPending.Message.make({
+            const admittedInput = SessionInbox.Item.make({
               type: "synthetic",
-              data: {
+              payload: {
                 text: input.text,
                 description: input.description,
                 metadata: input.metadata,
               },
               delivery: input.delivery ?? "steer",
             })
-            const admitted = yield* SessionPending.admit(db, bus, {
+            const admitted = yield* SessionInbox.admit(db, bus, {
               id: inputID,
               sessionID: input.sessionID,
-              input: admittedInput,
+              item: admittedInput,
             }).pipe(
               Effect.catchDefect((defect) =>
-                defect instanceof SessionPending.LifecycleConflict
+                defect instanceof SessionInbox.LifecycleConflict
                   ? new SyntheticConflictError({ sessionID: input.sessionID, inputID })
                   : Effect.die(defect),
               ),
             )
             if (
               admitted.type !== "synthetic" ||
-              !SessionPending.equivalent(admitted, { sessionID: input.sessionID, input: admittedInput })
+              !SessionInbox.equivalent(admitted, { sessionID: input.sessionID, item: admittedInput })
             )
               return yield* new SyntheticConflictError({ sessionID: input.sessionID, inputID })
             if (input.resume !== false && !(yield* result.get(input.sessionID)).revert)
@@ -839,7 +842,7 @@ const layer = Layer.effect(
         Effect.uninterruptible(
           Effect.gen(function* () {
             yield* execution.interrupt(sessionID)
-            if (options?.continue && (yield* SessionPending.has(db, sessionID, "any"))) yield* execution.wake(sessionID)
+            if (options?.continue && (yield* SessionInbox.has(db, sessionID, "any"))) yield* execution.wake(sessionID)
           }),
         ),
       ),

packages/core/src/session/compaction.ts

@@ -89,6 +89,7 @@ export type ManualInput = {
   readonly session: SessionSchema.Info
   readonly messages: readonly SessionMessage.Info[]
   readonly inputID: SessionMessage.ID
+  readonly started?: boolean
 }
 
 type RequiredInput = Omit<AutoInput, "ref">
@@ -102,6 +103,7 @@ type Plan = {
   readonly prompt: string
   readonly recent: string
   readonly inputID?: SessionMessage.ID
+  readonly started?: boolean
 }
 
 export type Outcome =
@@ -248,12 +250,13 @@ const make = (dependencies: Dependencies) => {
     return { status: "failed" as const, error: input.error }
   })
   const execute = Effect.fn("SessionCompaction.execute")(function* (plan: Plan) {
-    yield* dependencies.bus.publish(SessionEvent.Compaction.Started, {
-      sessionID: plan.session.id,
-      reason: plan.reason,
-      recent: plan.recent,
-      inputID: plan.inputID,
-    })
+    if (!plan.started)
+      yield* dependencies.bus.publish(SessionEvent.Compaction.Started, {
+        sessionID: plan.session.id,
+        reason: plan.reason,
+        recent: plan.recent,
+        inputID: plan.inputID,
+      })
 
     const chunks: string[] = []
     let failure: SessionError.Error | undefined
@@ -408,6 +411,7 @@ const make = (dependencies: Dependencies) => {
       cost: resolved.cost,
       reason: "manual",
       inputID: input.inputID,
+      started: input.started,
       ...content,
     })
   })

packages/core/src/session/execution.ts

@@ -1,6 +1,6 @@
 export * as SessionExecution from "./execution.js"
 
-import { Cause, Context, Effect, Exit, Layer } from "effect"
+import { Cause, Context, Effect, Exit, Layer, Stream } from "effect"
 import { Bus } from "../bus.js"
 import { LocationServiceMap } from "../location-service-map.js"
 import { makeGlobalNode } from "@opencode-ai/util/effect/app-node"
@@ -67,16 +67,17 @@ export const layer = Layer.effect(
     const releaseOnCommit = (sessionID: SessionSchema.ID) => ({
       commit: () => store.release(sessionID),
     })
-    const coordinator = yield* SessionRunCoordinator.make<SessionSchema.ID, SessionRunner.RunError, InterruptReason>({
-      started: (sessionID) =>
-        reportLifecycle(
-          sessionID,
-          bus.publish(SessionEvent.Execution.Started, { sessionID }, claimOnCommit(sessionID)),
-        ),
-      drain: Effect.fnUntraced(function* (sessionID: SessionSchema.ID, force) {
+    function drain(
+      sessionID: SessionSchema.ID,
+      force: boolean,
+      continuation?: SessionRunner.Continuation,
+    ): Effect.Effect<void, SessionRunner.RunError> {
+      return Effect.gen(function* () {
         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(
+        const result = yield* SessionRunner.Service.use((runner) =>
+          runner.drain({ sessionID, force, continuation }),
+        ).pipe(
           Effect.provide(locations.get(session.location)),
           Effect.tapCause((cause) =>
             Cause.hasInterruptsOnly(cause)
@@ -84,7 +85,17 @@ export const layer = Layer.effect(
               : Effect.logError("Failed to drain Session", cause).pipe(Effect.annotateLogs({ sessionID })),
           ),
         )
-      }),
+        if (result.type === "complete") return
+        return yield* drain(sessionID, false, result.continuation)
+      })
+    }
+    const coordinator = yield* SessionRunCoordinator.make<SessionSchema.ID, SessionRunner.RunError, InterruptReason>({
+      started: (sessionID) =>
+        reportLifecycle(
+          sessionID,
+          bus.publish(SessionEvent.Execution.Started, { sessionID }, claimOnCommit(sessionID)),
+        ),
+      drain: (sessionID, force) => drain(sessionID, force),
       // One terminal observation per busy period, covering every coalesced drain.
       settled: (sessionID, exit, reason) =>
         reportLifecycle(
@@ -116,6 +127,10 @@ export const layer = Layer.effect(
           }),
         ),
     })
+    yield* bus.subscribe(SessionEvent.Moved).pipe(
+      Stream.runForEach((event) => coordinator.wake(event.data.sessionID)),
+      Effect.forkScoped,
+    )
 
     return Service.of({
       active: coordinator.active,

packages/core/src/session/inbox.ts

@@ -0,0 +1,505 @@
+export * as SessionInbox from "./inbox.js"
+
+import { and, asc, eq, or } from "drizzle-orm"
+import { DateTime, Effect, Schema } from "effect"
+import {
+  Compaction,
+  CompactionPayload,
+  Delivery,
+  Info,
+  Item,
+  Move,
+  MovePayload,
+  Synthetic,
+  SyntheticPayload,
+  User,
+  UserPayload,
+} from "@opencode-ai/schema/session-inbox"
+import type { Database } from "../database/database.js"
+import { Bus } from "../bus.js"
+import { KeyedMutex } from "../effect/keyed-mutex.js"
+import { SessionEvent } from "./event.js"
+import { SessionMessage } from "./message.js"
+import { SessionSchema } from "./schema.js"
+import { SessionInboxTable, SessionMessageTable } from "./sql.js"
+
+type DatabaseService = Database.Interface["db"]
+
+export {
+  Compaction,
+  CompactionPayload,
+  Delivery,
+  Info,
+  Item,
+  Move,
+  MovePayload,
+  Synthetic,
+  SyntheticPayload,
+  User,
+  UserPayload,
+}
+
+/**
+ * Which pending input `promote` may consume: "steer" promotes steers only (a step
+ * boundary mid-work), while "input" also allows one queued input when no steers are
+ * waiting (the idle boundary, where the Session picks up fresh work).
+ */
+export type Promotable = "input" | "steer"
+
+const decodeUser = Schema.decodeUnknownSync(UserPayload)
+const encodeUser = Schema.encodeSync(UserPayload)
+const decodeSynthetic = Schema.decodeUnknownSync(SyntheticPayload)
+const encodeSynthetic = Schema.encodeSync(SyntheticPayload)
+const decodeCompaction = Schema.decodeUnknownSync(CompactionPayload)
+const encodeCompaction = Schema.encodeSync(CompactionPayload)
+const decodeMove = Schema.decodeUnknownSync(MovePayload)
+const encodeMove = Schema.encodeSync(MovePayload)
+const decodeMessage = Schema.decodeUnknownSync(SessionMessage.Info)
+const inboxLocks = KeyedMutex.makeUnsafe<SessionSchema.ID>()
+type PendingRef = { readonly id: SessionMessage.ID; readonly sessionID: SessionSchema.ID }
+
+export const serialized = <A, E, R>(sessionID: SessionSchema.ID, effect: Effect.Effect<A, E, R>) =>
+  inboxLocks.withLock(sessionID)(effect)
+
+export class LifecycleConflict extends Schema.TaggedErrorClass<LifecycleConflict>()("SessionInbox.LifecycleConflict", {
+  id: SessionMessage.ID,
+}) {}
+
+const fromRow = (row: typeof SessionInboxTable.$inferSelect): Info => {
+  const base = {
+    id: SessionMessage.ID.make(row.id),
+    sessionID: SessionSchema.ID.make(row.session_id),
+    timeCreated: DateTime.makeUnsafe(row.time_created),
+  }
+  if (row.type === "compaction")
+    return Compaction.make({
+      ...base,
+      type: "compaction",
+      payload: decodeCompaction(row.payload),
+      delivery: row.delivery,
+    })
+  if (row.type === "move")
+    return Move.make({ ...base, type: "move", payload: decodeMove(row.payload), delivery: row.delivery })
+  if (row.type === "user")
+    return User.make({
+      ...base,
+      type: "user",
+      payload: decodeUser(row.payload),
+      delivery: row.delivery,
+    })
+  if (row.type === "synthetic")
+    return Synthetic.make({
+      ...base,
+      type: "synthetic",
+      payload: decodeSynthetic(row.payload),
+      delivery: row.delivery,
+    })
+  throw new LifecycleConflict({ id: base.id })
+}
+
+export const find = Effect.fn("SessionInbox.find")(function* (db: DatabaseService, id: SessionMessage.ID) {
+  const row = yield* db.select().from(SessionInboxTable).where(eq(SessionInboxTable.id, id)).get().pipe(Effect.orDie)
+  return row === undefined ? undefined : fromRow(row)
+})
+
+const promotedFromMessage = Effect.fn("SessionInbox.promotedFromMessage")(function* (
+  db: DatabaseService,
+  sessionID: SessionSchema.ID,
+  id: SessionMessage.ID,
+  delivery: Delivery,
+) {
+  const row = yield* db
+    .select()
+    .from(SessionMessageTable)
+    .where(eq(SessionMessageTable.id, id))
+    .get()
+    .pipe(Effect.orDie)
+  if (row === undefined) return undefined
+  if (row.session_id !== sessionID || (row.type !== "user" && row.type !== "synthetic"))
+    return yield* Effect.die(new LifecycleConflict({ id }))
+  const message = decodeMessage({ ...row.data, id: row.id, type: row.type })
+  const base = { id, sessionID, timeCreated: message.time.created, delivery }
+  if (message.type === "user")
+    return User.make({
+      ...base,
+      type: "user",
+      payload: decodeUser(message),
+    })
+  if (message.type === "synthetic")
+    return Synthetic.make({
+      ...base,
+      type: "synthetic",
+      payload: decodeSynthetic(message),
+    })
+  return yield* Effect.die(new LifecycleConflict({ id }))
+})
+
+export const admit = Effect.fn("SessionInbox.admit")(function* (
+  db: DatabaseService,
+  bus: Bus.Interface,
+  request: {
+    readonly id: SessionMessage.ID
+    readonly sessionID: SessionSchema.ID
+    readonly item: Item
+  },
+) {
+  const existing = yield* find(db, request.id)
+  if (existing !== undefined) {
+    if (existing.type === "compaction") return yield* Effect.die(new LifecycleConflict({ id: request.id }))
+    return existing
+  }
+  const promoted = yield* promotedFromMessage(db, request.sessionID, request.id, request.item.delivery)
+  if (promoted !== undefined) return promoted
+  return yield* bus
+    .publish(SessionEvent.InboxEnqueued, {
+      inboxID: request.id,
+      sessionID: request.sessionID,
+      item: request.item,
+    })
+    .pipe(
+      Effect.flatMap((event) => {
+        const base = {
+          id: request.id,
+          sessionID: request.sessionID,
+          timeCreated: event.created,
+        }
+        return Effect.succeed(Info.make({ ...base, ...request.item }))
+      }),
+      Effect.catchDefect((defect) =>
+        find(db, request.id).pipe(
+          Effect.flatMap((stored) =>
+            stored?.type === request.item.type ? Effect.succeed(stored) : Effect.die(defect),
+          ),
+        ),
+      ),
+    )
+})
+
+export const admitCompaction = Effect.fn("SessionInbox.admitCompaction")(function* (
+  db: DatabaseService,
+  bus: Bus.Interface,
+  input: { readonly id: SessionMessage.ID; readonly sessionID: SessionSchema.ID; readonly delivery: Delivery },
+) {
+  const admitted = yield* admit(db, bus, {
+    id: input.id,
+    sessionID: input.sessionID,
+    item: Item.make({ type: "compaction", payload: {}, delivery: input.delivery }),
+  })
+  if (admitted.type === "compaction") return admitted
+  return yield* Effect.die(new LifecycleConflict({ id: input.id }))
+})
+
+export const projectAdmitted = Effect.fn("SessionInbox.projectAdmitted")(function* (
+  db: DatabaseService,
+  request: {
+    readonly enqueuedSeq: number
+    readonly id: SessionMessage.ID
+    readonly sessionID: SessionSchema.ID
+    readonly item: Item
+    readonly timeCreated: DateTime.Utc
+  },
+) {
+  const message = yield* db
+    .select({ id: SessionMessageTable.id })
+    .from(SessionMessageTable)
+    .where(eq(SessionMessageTable.id, request.id))
+    .get()
+    .pipe(Effect.orDie)
+  if (message !== undefined) return yield* Effect.die(new LifecycleConflict({ id: request.id }))
+  const stored = yield* db
+    .insert(SessionInboxTable)
+    .values({
+      id: request.id,
+      session_id: request.sessionID,
+      type: request.item.type,
+      payload:
+        request.item.type === "user"
+          ? encodeUser(request.item.payload)
+          : request.item.type === "synthetic"
+            ? encodeSynthetic(request.item.payload)
+            : request.item.type === "compaction"
+              ? encodeCompaction(request.item.payload)
+              : encodeMove(request.item.payload),
+      delivery: request.item.delivery,
+      enqueued_seq: request.enqueuedSeq,
+      time_created: DateTime.toEpochMillis(request.timeCreated),
+    })
+    .onConflictDoNothing()
+    .returning({ id: SessionInboxTable.id })
+    .get()
+    .pipe(Effect.orDie)
+  if (!stored) return yield* Effect.die(new LifecycleConflict({ id: request.id }))
+})
+
+/**
+ * Consume one pending row at promotion. The row's content feeds the projected
+ * message insert inside the same event transaction; the deleted row is what
+ * makes the table pending-only.
+ */
+export const projectDelivered = Effect.fn("SessionInbox.projectDelivered")(function* (
+  db: DatabaseService,
+  input: PendingRef,
+) {
+  const deleted = yield* db
+    .delete(SessionInboxTable)
+    .where(and(eq(SessionInboxTable.id, input.id), eq(SessionInboxTable.session_id, input.sessionID)))
+    .returning()
+    .get()
+    .pipe(Effect.orDie)
+  if (!deleted) return yield* Effect.die(new LifecycleConflict({ id: input.id }))
+  return fromRow(deleted)
+})
+
+export const projectCancelled = Effect.fn("SessionInbox.projectCancelled")(function* (
+  db: DatabaseService,
+  input: PendingRef,
+) {
+  const deleted = yield* db
+    .delete(SessionInboxTable)
+    .where(
+      and(
+        eq(SessionInboxTable.id, input.id),
+        eq(SessionInboxTable.session_id, input.sessionID),
+        or(eq(SessionInboxTable.delivery, "queue"), eq(SessionInboxTable.delivery, "steer")),
+      ),
+    )
+    .returning({ id: SessionInboxTable.id })
+    .get()
+    .pipe(Effect.orDie)
+  if (!deleted) return yield* Effect.die(new LifecycleConflict({ id: input.id }))
+})
+
+const projectDelivery = Effect.fn("SessionInbox.projectDelivery")(function* (
+  db: DatabaseService,
+  input: PendingRef & { readonly from: Delivery; readonly to: Delivery },
+) {
+  const updated = yield* db
+    .update(SessionInboxTable)
+    .set({ delivery: input.to })
+    .where(
+      and(
+        eq(SessionInboxTable.id, input.id),
+        eq(SessionInboxTable.session_id, input.sessionID),
+        eq(SessionInboxTable.delivery, input.from),
+      ),
+    )
+    .returning({ id: SessionInboxTable.id })
+    .get()
+    .pipe(Effect.orDie)
+  if (!updated) return yield* Effect.die(new LifecycleConflict({ id: input.id }))
+})
+
+export const projectDeliveryChanged = Effect.fn("SessionInbox.projectDeliveryChanged")(
+  (db: DatabaseService, input: PendingRef & { readonly delivery: Delivery }) =>
+    projectDelivery(db, {
+      ...input,
+      from: input.delivery === "steer" ? "queue" : "steer",
+      to: input.delivery,
+    }),
+)
+
+export const list = Effect.fn("SessionInbox.list")(function* (db: DatabaseService, sessionID: SessionSchema.ID) {
+  const rows = yield* db
+    .select()
+    .from(SessionInboxTable)
+    .where(eq(SessionInboxTable.session_id, sessionID))
+    .orderBy(asc(SessionInboxTable.enqueued_seq))
+    .all()
+    .pipe(Effect.orDie)
+  return rows.map(fromRow)
+})
+
+export const nextQueued = Effect.fn("SessionInbox.nextQueued")(function* (
+  db: DatabaseService,
+  sessionID: SessionSchema.ID,
+) {
+  const row = yield* db
+    .select()
+    .from(SessionInboxTable)
+    .where(and(eq(SessionInboxTable.session_id, sessionID), eq(SessionInboxTable.delivery, "queue")))
+    .orderBy(asc(SessionInboxTable.enqueued_seq))
+    .limit(1)
+    .get()
+    .pipe(Effect.orDie)
+  return row ? fromRow(row) : undefined
+})
+
+export const nextSteer = Effect.fn("SessionInbox.nextSteer")(function* (
+  db: DatabaseService,
+  sessionID: SessionSchema.ID,
+) {
+  const row = yield* db
+    .select()
+    .from(SessionInboxTable)
+    .where(and(eq(SessionInboxTable.session_id, sessionID), eq(SessionInboxTable.delivery, "steer")))
+    .orderBy(asc(SessionInboxTable.enqueued_seq))
+    .limit(1)
+    .get()
+    .pipe(Effect.orDie)
+  return row ? fromRow(row) : undefined
+})
+
+/**
+ * Which pending rows count: "any" counts every row, while "input" means any
+ * item in either delivery mode.
+ */
+export type Scope = "any" | "input" | Delivery
+
+export const has = Effect.fn("SessionInbox.has")(function* (
+  db: DatabaseService,
+  sessionID: SessionSchema.ID,
+  scope: Scope,
+) {
+  const row = yield* db
+    .select({ id: SessionInboxTable.id })
+    .from(SessionInboxTable)
+    .where(
+      and(
+        eq(SessionInboxTable.session_id, sessionID),
+        scope === "any"
+          ? undefined
+          : scope === "input"
+            ? or(eq(SessionInboxTable.delivery, "steer"), eq(SessionInboxTable.delivery, "queue"))
+            : eq(SessionInboxTable.delivery, scope),
+      ),
+    )
+    .limit(1)
+    .get()
+    .pipe(Effect.orDie)
+  return row !== undefined
+})
+
+export const equivalent = (input: Info, expected: { readonly sessionID: SessionSchema.ID; readonly item: Item }) => {
+  if (
+    input.type !== expected.item.type ||
+    input.delivery !== expected.item.delivery ||
+    input.sessionID !== expected.sessionID
+  )
+    return false
+  if (input.type === "user" && expected.item.type === "user")
+    return JSON.stringify(encodeUser(input.payload)) === JSON.stringify(encodeUser(expected.item.payload))
+  if (input.type === "synthetic" && expected.item.type === "synthetic")
+    return JSON.stringify(encodeSynthetic(input.payload)) === JSON.stringify(encodeSynthetic(expected.item.payload))
+  if (input.type === "compaction" && expected.item.type === "compaction") return true
+  if (input.type === "move" && expected.item.type === "move")
+    return JSON.stringify(encodeMove(input.payload)) === JSON.stringify(encodeMove(expected.item.payload))
+  return false
+}
+
+const publishMutation = <A, E, R>(input: PendingRef, effect: Effect.Effect<A, E, R>) =>
+  serialized(input.sessionID, effect).pipe(Effect.asVoid)
+
+export const cancel = Effect.fn("SessionInbox.cancel")((bus: Bus.Interface, input: PendingRef) =>
+  publishMutation(
+    input,
+    bus.publish(SessionEvent.InboxCancelled, {
+      sessionID: input.sessionID,
+      inboxID: input.id,
+    }),
+  ),
+)
+
+export const steer = Effect.fn("SessionInbox.steer")((bus: Bus.Interface, input: PendingRef) =>
+  publishMutation(
+    input,
+    bus.publish(SessionEvent.InboxDeliveryChanged, {
+      sessionID: input.sessionID,
+      inboxID: input.id,
+      delivery: "steer",
+    }),
+  ),
+)
+
+export const queue = Effect.fn("SessionInbox.queue")((bus: Bus.Interface, input: PendingRef) =>
+  publishMutation(
+    input,
+    bus.publish(SessionEvent.InboxDeliveryChanged, {
+      sessionID: input.sessionID,
+      inboxID: input.id,
+      delivery: "queue",
+    }),
+  ),
+)
+
+const publish = Effect.fn("SessionInbox.publish")(function* (
+  db: DatabaseService,
+  bus: Bus.Interface,
+  sessionID: SessionSchema.ID,
+  rows: ReadonlyArray<typeof SessionInboxTable.$inferSelect>,
+) {
+  yield* Effect.forEach(
+    rows,
+    (row) => {
+      const entry = fromRow(row)
+      if (entry.type === "compaction") return Effect.die(new LifecycleConflict({ id: entry.id }))
+      return bus
+        .publish(SessionEvent.InboxDelivered, {
+          sessionID,
+          inboxID: entry.id,
+        })
+        .pipe(
+          Effect.catchDefect((defect) =>
+            defect instanceof LifecycleConflict
+              ? promotedFromMessage(db, sessionID, entry.id, entry.delivery).pipe(
+                  Effect.flatMap((stored) => (stored !== undefined ? Effect.void : Effect.die(defect))),
+                )
+              : Effect.die(defect),
+          ),
+        )
+    },
+    { discard: true },
+  )
+  return rows.length
+})
+
+/**
+ * Promotes pending input into visible messages and returns the promoted count.
+ * Steers always go first; only the "input" scope may fall through to one queued
+ * input, and it then collects steers that arrived during promotion.
+ */
+export const promote = Effect.fn("SessionInbox.promote")(function* (
+  db: DatabaseService,
+  bus: Bus.Interface,
+  sessionID: SessionSchema.ID,
+  scope: Promotable,
+) {
+  return yield* serialized(
+    sessionID,
+    Effect.gen(function* () {
+      const steers = yield* db
+        .select()
+        .from(SessionInboxTable)
+        .where(and(eq(SessionInboxTable.session_id, sessionID), eq(SessionInboxTable.delivery, "steer")))
+        .orderBy(asc(SessionInboxTable.enqueued_seq))
+        .all()
+        .pipe(Effect.orDie)
+      if (steers.length > 0 || scope === "steer") {
+        const control = steers.findIndex((row) => row.type === "compaction" || row.type === "move")
+        return yield* publish(db, bus, sessionID, control === -1 ? steers : steers.slice(0, control))
+      }
+
+      const queued = yield* db
+        .select()
+        .from(SessionInboxTable)
+        .where(and(eq(SessionInboxTable.session_id, sessionID), eq(SessionInboxTable.delivery, "queue")))
+        .orderBy(asc(SessionInboxTable.enqueued_seq))
+        .limit(1)
+        .get()
+        .pipe(Effect.orDie)
+      if (!queued) return 0
+      const promoted = yield* publish(db, bus, sessionID, [queued])
+      const arrivedSteers = yield* db
+        .select()
+        .from(SessionInboxTable)
+        .where(and(eq(SessionInboxTable.session_id, sessionID), eq(SessionInboxTable.delivery, "steer")))
+        .orderBy(asc(SessionInboxTable.enqueued_seq))
+        .all()
+        .pipe(Effect.orDie)
+      const control = arrivedSteers.findIndex((row) => row.type === "compaction" || row.type === "move")
+      return (
+        promoted +
+        (yield* publish(db, bus, sessionID, control === -1 ? arrivedSteers : arrivedSteers.slice(0, control)))
+      )
+    }),
+  )
+})

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

@@ -109,11 +109,10 @@ export function update(adapter: Adapter, event: SessionEvent.DurableEvent) {
       "session.renamed": () => Effect.void,
       "session.deleted": () => Effect.void,
       "session.forked": () => Effect.void,
-      "session.input.promoted": () => Effect.void,
-      "session.input.admitted": () => Effect.void,
-      "session.input.cancelled": () => Effect.void,
-      "session.input.steered": () => Effect.void,
-      "session.input.queued": () => Effect.void,
+      "session.inbox.delivered": () => Effect.void,
+      "session.inbox.enqueued": () => Effect.void,
+      "session.inbox.cancelled": () => Effect.void,
+      "session.inbox.delivery.changed": () => Effect.void,
       "session.execution.started": () => Effect.void,
       "session.execution.succeeded": () => clearCurrentRetry,
       "session.execution.failed": () => clearCurrentRetry,
@@ -380,7 +379,6 @@ export function update(adapter: Adapter, event: SessionEvent.DurableEvent) {
           }
         })
       },
-      "session.compaction.admitted": () => Effect.void,
       "session.compaction.started": (event) =>
         adapter.appendMessage(
           SessionMessage.CompactionRunning.make({

packages/core/src/session/pending.ts

@@ -1,545 +0,0 @@
-export * as SessionPending from "./pending.js"
-
-import { and, asc, eq, or } from "drizzle-orm"
-import { DateTime, Effect, Schema } from "effect"
-import {
-  Compaction,
-  Delivery,
-  Info,
-  Message,
-  Synthetic,
-  SyntheticData,
-  User,
-  UserData,
-} from "@opencode-ai/schema/session-pending"
-import type { Database } from "../database/database.js"
-import { Bus } from "../bus.js"
-import { KeyedMutex } from "../effect/keyed-mutex.js"
-import { SessionEvent } from "./event.js"
-import { SessionMessage } from "./message.js"
-import { SessionSchema } from "./schema.js"
-import { SessionMessageTable, SessionPendingTable } from "./sql.js"
-
-type DatabaseService = Database.Interface["db"]
-
-export { Compaction, Delivery, Info, Message, Synthetic, SyntheticData, User, UserData }
-
-/**
- * Which pending input `promote` may consume: "steer" promotes steers only (a step
- * boundary mid-work), while "input" also allows one queued input when no steers are
- * waiting (the idle boundary, where the Session picks up fresh work).
- */
-export type Promotable = "input" | "steer"
-
-const decodeUser = Schema.decodeUnknownSync(UserData)
-const encodeUser = Schema.encodeSync(UserData)
-const decodeSynthetic = Schema.decodeUnknownSync(SyntheticData)
-const encodeSynthetic = Schema.encodeSync(SyntheticData)
-const decodeMessage = Schema.decodeUnknownSync(SessionMessage.Info)
-const inboxLocks = KeyedMutex.makeUnsafe<SessionSchema.ID>()
-type PendingRef = { readonly id: SessionMessage.ID; readonly sessionID: SessionSchema.ID }
-
-export class LifecycleConflict extends Schema.TaggedErrorClass<LifecycleConflict>()(
-  "SessionPending.LifecycleConflict",
-  {
-    id: SessionMessage.ID,
-  },
-) {}
-
-const fromRow = (row: typeof SessionPendingTable.$inferSelect): Info => {
-  const base = {
-    id: SessionMessage.ID.make(row.id),
-    sessionID: SessionSchema.ID.make(row.session_id),
-    timeCreated: DateTime.makeUnsafe(row.time_created),
-  }
-  if (row.type === "compaction") return Compaction.make({ ...base, type: "compaction" })
-  if (!row.delivery) throw new LifecycleConflict({ id: base.id })
-  if (row.type === "user")
-    return User.make({
-      ...base,
-      type: "user",
-      data: decodeUser(row.data),
-      delivery: row.delivery,
-    })
-  if (row.type === "synthetic")
-    return Synthetic.make({
-      ...base,
-      type: "synthetic",
-      data: decodeSynthetic(row.data),
-      delivery: row.delivery,
-    })
-  throw new LifecycleConflict({ id: base.id })
-}
-
-export const find = Effect.fn("SessionPending.find")(function* (db: DatabaseService, id: SessionMessage.ID) {
-  const row = yield* db
-    .select()
-    .from(SessionPendingTable)
-    .where(eq(SessionPendingTable.id, id))
-    .get()
-    .pipe(Effect.orDie)
-  return row === undefined ? undefined : fromRow(row)
-})
-
-export const compaction = Effect.fn("SessionPending.compaction")(function* (
-  db: DatabaseService,
-  sessionID: SessionSchema.ID,
-) {
-  const row = yield* db
-    .select()
-    .from(SessionPendingTable)
-    .where(and(eq(SessionPendingTable.session_id, sessionID), eq(SessionPendingTable.type, "compaction")))
-    .orderBy(asc(SessionPendingTable.admitted_seq))
-    .limit(1)
-    .get()
-    .pipe(Effect.orDie)
-  if (!row) return
-  const entry = fromRow(row)
-  return entry.type === "compaction" ? entry : undefined
-})
-
-const promotedFromMessage = Effect.fn("SessionPending.promotedFromMessage")(function* (
-  db: DatabaseService,
-  sessionID: SessionSchema.ID,
-  id: SessionMessage.ID,
-  delivery: Delivery,
-) {
-  const row = yield* db
-    .select()
-    .from(SessionMessageTable)
-    .where(eq(SessionMessageTable.id, id))
-    .get()
-    .pipe(Effect.orDie)
-  if (row === undefined) return undefined
-  if (row.session_id !== sessionID || (row.type !== "user" && row.type !== "synthetic"))
-    return yield* Effect.die(new LifecycleConflict({ id }))
-  const message = decodeMessage({ ...row.data, id: row.id, type: row.type })
-  const base = { id, sessionID, timeCreated: message.time.created, delivery }
-  if (message.type === "user")
-    return User.make({
-      ...base,
-      type: "user",
-      data: decodeUser(message),
-    })
-  if (message.type === "synthetic")
-    return Synthetic.make({
-      ...base,
-      type: "synthetic",
-      data: decodeSynthetic(message),
-    })
-  return yield* Effect.die(new LifecycleConflict({ id }))
-})
-
-export const admit = Effect.fn("SessionPending.admit")(function* (
-  db: DatabaseService,
-  bus: Bus.Interface,
-  request: {
-    readonly id: SessionMessage.ID
-    readonly sessionID: SessionSchema.ID
-    readonly input: Message
-  },
-) {
-  const existing = yield* find(db, request.id)
-  if (existing !== undefined) {
-    if (existing.type === "compaction") return yield* Effect.die(new LifecycleConflict({ id: request.id }))
-    return existing
-  }
-  const promoted = yield* promotedFromMessage(db, request.sessionID, request.id, request.input.delivery)
-  if (promoted !== undefined) return promoted
-  return yield* bus
-    .publish(SessionEvent.InputAdmitted, {
-      inputID: request.id,
-      sessionID: request.sessionID,
-      input: request.input,
-    })
-    .pipe(
-      Effect.flatMap((event) => {
-        const base = {
-          id: request.id,
-          sessionID: request.sessionID,
-          timeCreated: event.created,
-        }
-        return Effect.succeed(
-          request.input.type === "user"
-            ? User.make({ ...base, ...request.input })
-            : Synthetic.make({ ...base, ...request.input }),
-        )
-      }),
-      Effect.catchDefect((defect) =>
-        find(db, request.id).pipe(
-          Effect.flatMap((stored) =>
-            stored?.type === request.input.type ? Effect.succeed(stored) : Effect.die(defect),
-          ),
-        ),
-      ),
-    )
-})
-
-export const admitCompaction = Effect.fn("SessionPending.admitCompaction")(function* (
-  db: DatabaseService,
-  bus: Bus.Interface,
-  input: { readonly id: SessionMessage.ID; readonly sessionID: SessionSchema.ID },
-) {
-  return yield* inboxLocks.withLock(input.sessionID)(
-    Effect.gen(function* () {
-      const exact = yield* find(db, input.id)
-      if (exact) {
-        if (exact.type === "compaction" && exact.sessionID === input.sessionID) return exact
-        return yield* Effect.die(new LifecycleConflict({ id: input.id }))
-      }
-      const pending = yield* compaction(db, input.sessionID)
-      if (pending) return pending
-      return yield* bus
-        .publish(SessionEvent.Compaction.Admitted, {
-          inputID: input.id,
-          sessionID: input.sessionID,
-        })
-        .pipe(
-          Effect.flatMap((event) => {
-            if (event.durable === undefined)
-              return Effect.die(new Error("Compaction admission event is missing aggregate sequence"))
-            return compaction(db, input.sessionID).pipe(
-              Effect.flatMap((stored) =>
-                stored ? Effect.succeed(stored) : Effect.die(new LifecycleConflict({ id: input.id })),
-              ),
-            )
-          }),
-          Effect.catchDefect((defect) =>
-            compaction(db, input.sessionID).pipe(
-              Effect.flatMap((stored) => (stored ? Effect.succeed(stored) : Effect.die(defect))),
-            ),
-          ),
-        )
-    }),
-  )
-})
-
-export const projectAdmitted = Effect.fn("SessionPending.projectAdmitted")(function* (
-  db: DatabaseService,
-  request: {
-    readonly admittedSeq: number
-    readonly id: SessionMessage.ID
-    readonly sessionID: SessionSchema.ID
-    readonly input: Message
-    readonly timeCreated: DateTime.Utc
-  },
-) {
-  const message = yield* db
-    .select({ id: SessionMessageTable.id })
-    .from(SessionMessageTable)
-    .where(eq(SessionMessageTable.id, request.id))
-    .get()
-    .pipe(Effect.orDie)
-  if (message !== undefined) return yield* Effect.die(new LifecycleConflict({ id: request.id }))
-  const stored = yield* db
-    .insert(SessionPendingTable)
-    .values({
-      id: request.id,
-      session_id: request.sessionID,
-      type: request.input.type,
-      data: request.input.type === "user" ? encodeUser(request.input.data) : encodeSynthetic(request.input.data),
-      delivery: request.input.delivery,
-      admitted_seq: request.admittedSeq,
-      time_created: DateTime.toEpochMillis(request.timeCreated),
-    })
-    .onConflictDoNothing()
-    .returning({ id: SessionPendingTable.id })
-    .get()
-    .pipe(Effect.orDie)
-  if (!stored) return yield* Effect.die(new LifecycleConflict({ id: request.id }))
-})
-
-export const projectCompactionAdmitted = Effect.fn("SessionPending.projectCompactionAdmitted")(function* (
-  db: DatabaseService,
-  input: {
-    readonly admittedSeq: number
-    readonly id: SessionMessage.ID
-    readonly sessionID: SessionSchema.ID
-    readonly timeCreated: DateTime.Utc
-  },
-) {
-  const message = yield* db
-    .select({ id: SessionMessageTable.id })
-    .from(SessionMessageTable)
-    .where(eq(SessionMessageTable.id, input.id))
-    .get()
-    .pipe(Effect.orDie)
-  if (message !== undefined) return yield* Effect.die(new LifecycleConflict({ id: input.id }))
-  const stored = yield* db
-    .insert(SessionPendingTable)
-    .values({
-      id: input.id,
-      session_id: input.sessionID,
-      type: "compaction",
-      data: {},
-      admitted_seq: input.admittedSeq,
-      time_created: DateTime.toEpochMillis(input.timeCreated),
-    })
-    .onConflictDoNothing()
-    .returning()
-    .get()
-    .pipe(Effect.orDie)
-  if (stored) {
-    const entry = fromRow(stored)
-    return entry.type === "compaction" ? entry : yield* Effect.die(new LifecycleConflict({ id: entry.id }))
-  }
-  const pending = yield* compaction(db, input.sessionID)
-  if (pending) return pending
-  return yield* Effect.die(new LifecycleConflict({ id: input.id }))
-})
-
-/**
- * Consume one pending row at promotion. The row's content feeds the projected
- * message insert inside the same event transaction; the deleted row is what
- * makes the table pending-only.
- */
-export const projectPromoted = Effect.fn("SessionPending.projectPromoted")(function* (
-  db: DatabaseService,
-  input: PendingRef,
-) {
-  if (yield* compaction(db, input.sessionID)) return yield* Effect.die(new LifecycleConflict({ id: input.id }))
-  const deleted = yield* db
-    .delete(SessionPendingTable)
-    .where(and(eq(SessionPendingTable.id, input.id), eq(SessionPendingTable.session_id, input.sessionID)))
-    .returning()
-    .get()
-    .pipe(Effect.orDie)
-  if (!deleted) return yield* Effect.die(new LifecycleConflict({ id: input.id }))
-  const stored = fromRow(deleted)
-  if (stored.type === "compaction") return yield* Effect.die(new LifecycleConflict({ id: input.id }))
-  return stored
-})
-
-export const projectCancelled = Effect.fn("SessionPending.projectCancelled")(function* (
-  db: DatabaseService,
-  input: PendingRef,
-) {
-  const deleted = yield* db
-    .delete(SessionPendingTable)
-    .where(
-      and(
-        eq(SessionPendingTable.id, input.id),
-        eq(SessionPendingTable.session_id, input.sessionID),
-        or(eq(SessionPendingTable.delivery, "queue"), eq(SessionPendingTable.delivery, "steer")),
-      ),
-    )
-    .returning({ id: SessionPendingTable.id })
-    .get()
-    .pipe(Effect.orDie)
-  if (!deleted) return yield* Effect.die(new LifecycleConflict({ id: input.id }))
-})
-
-const projectDelivery = Effect.fn("SessionPending.projectDelivery")(function* (
-  db: DatabaseService,
-  input: PendingRef & { readonly from: Delivery; readonly to: Delivery },
-) {
-  const updated = yield* db
-    .update(SessionPendingTable)
-    .set({ delivery: input.to })
-    .where(
-      and(
-        eq(SessionPendingTable.id, input.id),
-        eq(SessionPendingTable.session_id, input.sessionID),
-        eq(SessionPendingTable.delivery, input.from),
-      ),
-    )
-    .returning({ id: SessionPendingTable.id })
-    .get()
-    .pipe(Effect.orDie)
-  if (!updated) return yield* Effect.die(new LifecycleConflict({ id: input.id }))
-})
-
-export const projectSteered = Effect.fn("SessionPending.projectSteered")((db: DatabaseService, input: PendingRef) =>
-  projectDelivery(db, { ...input, from: "queue", to: "steer" }),
-)
-
-export const projectQueued = Effect.fn("SessionPending.projectQueued")((db: DatabaseService, input: PendingRef) =>
-  projectDelivery(db, { ...input, from: "steer", to: "queue" }),
-)
-
-export const settleCompaction = Effect.fn("SessionPending.settleCompaction")(function* (
-  db: DatabaseService,
-  input: { readonly sessionID: SessionSchema.ID },
-) {
-  const deleted = yield* db
-    .delete(SessionPendingTable)
-    .where(and(eq(SessionPendingTable.session_id, input.sessionID), eq(SessionPendingTable.type, "compaction")))
-    .returning()
-    .get()
-    .pipe(Effect.orDie)
-  if (deleted) {
-    const stored = fromRow(deleted)
-    return stored.type === "compaction" ? stored : yield* Effect.die(new LifecycleConflict({ id: stored.id }))
-  }
-  return undefined
-})
-
-export const list = Effect.fn("SessionPending.list")(function* (db: DatabaseService, sessionID: SessionSchema.ID) {
-  const rows = yield* db
-    .select()
-    .from(SessionPendingTable)
-    .where(eq(SessionPendingTable.session_id, sessionID))
-    .orderBy(asc(SessionPendingTable.admitted_seq))
-    .all()
-    .pipe(Effect.orDie)
-  return rows.map(fromRow)
-})
-
-/**
- * Which pending rows count: "any" counts every row including compaction, while
- * delivery scopes are blocked behind a pending compaction barrier. "input" means
- * any model-facing input, steered or queued.
- */
-export type Scope = "any" | "input" | Delivery
-
-export const has = Effect.fn("SessionPending.has")(function* (
-  db: DatabaseService,
-  sessionID: SessionSchema.ID,
-  scope: Scope,
-) {
-  if (scope !== "any" && (yield* compaction(db, sessionID))) return false
-  const row = yield* db
-    .select({ id: SessionPendingTable.id })
-    .from(SessionPendingTable)
-    .where(
-      and(
-        eq(SessionPendingTable.session_id, sessionID),
-        scope === "any"
-          ? undefined
-          : scope === "input"
-            ? or(eq(SessionPendingTable.delivery, "steer"), eq(SessionPendingTable.delivery, "queue"))
-            : eq(SessionPendingTable.delivery, scope),
-      ),
-    )
-    .limit(1)
-    .get()
-    .pipe(Effect.orDie)
-  return row !== undefined
-})
-
-export const equivalent = (
-  input: User | Synthetic,
-  expected: { readonly sessionID: SessionSchema.ID; readonly input: Message },
-) => {
-  if (
-    input.type !== expected.input.type ||
-    input.delivery !== expected.input.delivery ||
-    input.sessionID !== expected.sessionID
-  )
-    return false
-  if (input.type === "user" && expected.input.type === "user")
-    return JSON.stringify(encodeUser(input.data)) === JSON.stringify(encodeUser(expected.input.data))
-  if (input.type === "synthetic" && expected.input.type === "synthetic")
-    return JSON.stringify(encodeSynthetic(input.data)) === JSON.stringify(encodeSynthetic(expected.input.data))
-  return false
-}
-
-const publishMutation = <A, E, R>(input: PendingRef, effect: Effect.Effect<A, E, R>) =>
-  inboxLocks.withLock(input.sessionID)(effect).pipe(Effect.asVoid)
-
-export const cancel = Effect.fn("SessionPending.cancel")((bus: Bus.Interface, input: PendingRef) =>
-  publishMutation(
-    input,
-    bus.publish(SessionEvent.InputCancelled, {
-      sessionID: input.sessionID,
-      inputID: input.id,
-    }),
-  ),
-)
-
-export const steer = Effect.fn("SessionPending.steer")((bus: Bus.Interface, input: PendingRef) =>
-  publishMutation(
-    input,
-    bus.publish(SessionEvent.InputSteered, {
-      sessionID: input.sessionID,
-      inputID: input.id,
-    }),
-  ),
-)
-
-export const queue = Effect.fn("SessionPending.queue")((bus: Bus.Interface, input: PendingRef) =>
-  publishMutation(
-    input,
-    bus.publish(SessionEvent.InputQueued, {
-      sessionID: input.sessionID,
-      inputID: input.id,
-    }),
-  ),
-)
-
-const publish = Effect.fn("SessionPending.publish")(function* (
-  db: DatabaseService,
-  bus: Bus.Interface,
-  sessionID: SessionSchema.ID,
-  rows: ReadonlyArray<typeof SessionPendingTable.$inferSelect>,
-) {
-  if (yield* compaction(db, sessionID)) return 0
-  yield* Effect.forEach(
-    rows,
-    (row) => {
-      const entry = fromRow(row)
-      if (entry.type === "compaction") return Effect.die(new LifecycleConflict({ id: entry.id }))
-      return bus
-        .publish(SessionEvent.InputPromoted, {
-          sessionID,
-          inputID: entry.id,
-        })
-        .pipe(
-          Effect.catchDefect((defect) =>
-            defect instanceof LifecycleConflict
-              ? promotedFromMessage(db, sessionID, entry.id, entry.delivery).pipe(
-                  Effect.flatMap((stored) => (stored !== undefined ? Effect.void : Effect.die(defect))),
-                )
-              : Effect.die(defect),
-          ),
-        )
-    },
-    { discard: true },
-  )
-  return rows.length
-})
-
-/**
- * Promotes pending input into visible messages and returns the promoted count.
- * Steers always go first; only the "input" scope may fall through to one queued
- * input, and it then collects steers that arrived during promotion.
- */
-export const promote = Effect.fn("SessionPending.promote")(function* (
-  db: DatabaseService,
-  bus: Bus.Interface,
-  sessionID: SessionSchema.ID,
-  scope: Promotable,
-) {
-  return yield* inboxLocks.withLock(sessionID)(
-    Effect.gen(function* () {
-      if (yield* compaction(db, sessionID)) return 0
-      const steers = yield* db
-        .select()
-        .from(SessionPendingTable)
-        .where(and(eq(SessionPendingTable.session_id, sessionID), eq(SessionPendingTable.delivery, "steer")))
-        .orderBy(asc(SessionPendingTable.admitted_seq))
-        .all()
-        .pipe(Effect.orDie)
-      if (steers.length > 0 || scope === "steer") return yield* publish(db, bus, sessionID, steers)
-
-      const queued = yield* db
-        .select()
-        .from(SessionPendingTable)
-        .where(and(eq(SessionPendingTable.session_id, sessionID), eq(SessionPendingTable.delivery, "queue")))
-        .orderBy(asc(SessionPendingTable.admitted_seq))
-        .limit(1)
-        .get()
-        .pipe(Effect.orDie)
-      if (!queued) return 0
-      const promoted = yield* publish(db, bus, sessionID, [queued])
-      const arrivedSteers = yield* db
-        .select()
-        .from(SessionPendingTable)
-        .where(and(eq(SessionPendingTable.session_id, sessionID), eq(SessionPendingTable.delivery, "steer")))
-        .orderBy(asc(SessionPendingTable.admitted_seq))
-        .all()
-        .pipe(Effect.orDie)
-      return promoted + (yield* publish(db, bus, sessionID, arrivedSteers))
-    }),
-  )
-})

packages/core/src/session/projector.ts

@@ -1,7 +1,8 @@
 export * as SessionProjector from "./projector.js"
 
-import { and, asc, desc, eq, gt, gte, lt, lte, sql } from "drizzle-orm"
+import { and, asc, desc, eq, gt, gte, inArray, lt, lte, sql } from "drizzle-orm"
 import { DateTime, Effect, Layer, Schema, Stream } from "effect"
+import path from "path"
 import { Database } from "../database/database.js"
 import { Bus } from "../bus.js"
 import { makeGlobalNode } from "@opencode-ai/util/effect/app-node"
@@ -10,12 +11,15 @@ import { Model } from "../model.js"
 import { SessionEvent } from "./event.js"
 import { SessionMessage } from "./message.js"
 import { SessionMessageUpdater } from "./message-updater.js"
-import { SessionPending } from "./pending.js"
+import { SessionInbox } from "./inbox.js"
 import { Workspace } from "../workspace.js"
 import { InstructionState } from "./instruction-state.js"
-import { SessionPendingTable, SessionMessageTable, SessionTable } from "./sql.js"
+import { SessionInboxTable, SessionMessageTable, SessionTable } from "./sql.js"
 import { Slug } from "../util/slug.js"
+import { FSUtil } from "@opencode-ai/util/fs-util"
 import { Money } from "@opencode-ai/schema/money"
+import { Event } from "@opencode-ai/schema/project-directories"
+import { Project } from "@opencode-ai/schema/project"
 import { AbsolutePath, RelativePath } from "../schema.js"
 import type { SessionSchema } from "./schema.js"
 
@@ -435,6 +439,47 @@ const layer = Layer.effectDiscard(
         yield* InstructionState.reset(db, event.data.sessionID)
       }),
     )
+    // Sessions whose ownership came from the directory's previous resolution
+    // follow its new identity. Location, transcript, instructions, and recency
+    // are untouched: the session did not move, its directory got identified.
+    yield* bus.project(Event.Resolved, (event) =>
+      Effect.gen(function* () {
+        const stale = [event.data.previous, Project.ID.global].filter((id) => id !== event.data.projectID)
+        if (stale.length === 0) return
+        const rows = yield* db
+          .select({ id: SessionTable.id, directory: SessionTable.directory })
+          .from(SessionTable)
+          .where(
+            and(
+              inArray(SessionTable.project_id, stale),
+              // Lexicographic range narrows the scan to prefix neighbors without
+              // LIKE escaping; FSUtil.contains below decides containment exactly.
+              gte(SessionTable.directory, event.data.directory),
+              lte(SessionTable.directory, AbsolutePath.make(event.data.directory + "\uffff")),
+            ),
+          )
+          .all()
+          .pipe(Effect.orDie)
+        yield* Effect.forEach(
+          rows,
+          (row) => {
+            if (!FSUtil.contains(event.data.directory, row.directory)) return Effect.void
+            return db
+              .update(SessionTable)
+              .set({
+                project_id: event.data.projectID,
+                path: RelativePath.make(path.relative(event.data.directory, row.directory).replaceAll("\\", "/")),
+                // Self-assignment suppresses the column's $onUpdate: adoption is not activity.
+                time_updated: sql`${SessionTable.time_updated}`,
+              })
+              .where(eq(SessionTable.id, row.id))
+              .run()
+              .pipe(Effect.orDie)
+          },
+          { discard: true },
+        )
+      }),
+    )
     yield* bus.project(SessionEvent.Deleted, (event) =>
       db.delete(SessionTable).where(eq(SessionTable.id, event.data.sessionID)).run().pipe(Effect.orDie),
     )
@@ -470,14 +515,15 @@ const layer = Layer.effectDiscard(
     )
     yield* bus.project(SessionEvent.UsageRecorded, (event) => applyUsage(db, event.data.sessionID, event.data))
     yield* bus.project(SessionEvent.Forked, (event) => projectFork(db, event))
-    yield* bus.project(SessionEvent.InputPromoted, (event) =>
+    yield* bus.project(SessionEvent.InboxDelivered, (event) =>
       Effect.gen(function* () {
         if (event.durable === undefined)
           return yield* Effect.die(new Error("Durable Session event is missing aggregate sequence"))
-        const input = yield* SessionPending.projectPromoted(db, {
-          id: event.data.inputID,
+        const input = yield* SessionInbox.projectDelivered(db, {
+          id: event.data.inboxID,
           sessionID: event.data.sessionID,
         })
+        if (input.type === "compaction" || input.type === "move") return
         yield* insertMessage(
           db,
           event,
@@ -485,33 +531,33 @@ const layer = Layer.effectDiscard(
             ? {
                 id: input.id,
                 type: "user",
-                metadata: input.data.metadata,
-                text: input.data.text,
-                files: input.data.files,
-                agents: input.data.agents,
-                skills: input.data.skills,
+                metadata: input.payload.metadata,
+                text: input.payload.text,
+                files: input.payload.files,
+                agents: input.payload.agents,
+                skills: input.payload.skills,
                 time: { created: event.created },
               }
             : {
                 id: input.id,
                 type: "synthetic",
-                text: input.data.text,
-                description: input.data.description,
-                metadata: input.data.metadata,
+                text: input.payload.text,
+                description: input.payload.description,
+                metadata: input.payload.metadata,
                 time: { created: event.created },
               },
         )
       }),
     )
-    yield* bus.project(SessionEvent.InputAdmitted, (event) =>
+    yield* bus.project(SessionEvent.InboxEnqueued, (event) =>
       Effect.gen(function* () {
         if (event.durable === undefined)
           return yield* Effect.die(new Error("Durable Session event is missing aggregate sequence"))
-        yield* SessionPending.projectAdmitted(db, {
-          admittedSeq: event.durable.seq,
-          id: event.data.inputID,
+        yield* SessionInbox.projectAdmitted(db, {
+          enqueuedSeq: event.durable.seq,
+          id: event.data.inboxID,
           sessionID: event.data.sessionID,
-          input: event.data.input,
+          item: event.data.item,
           timeCreated: event.created,
         })
         yield* db
@@ -522,34 +568,17 @@ const layer = Layer.effectDiscard(
           .pipe(Effect.orDie)
       }),
     )
-    yield* bus.project(SessionEvent.InputCancelled, (event) =>
-      SessionPending.projectCancelled(db, {
-        id: event.data.inputID,
+    yield* bus.project(SessionEvent.InboxCancelled, (event) =>
+      SessionInbox.projectCancelled(db, {
+        id: event.data.inboxID,
         sessionID: event.data.sessionID,
       }),
     )
-    yield* bus.project(SessionEvent.InputSteered, (event) =>
-      SessionPending.projectSteered(db, {
-        id: event.data.inputID,
+    yield* bus.project(SessionEvent.InboxDeliveryChanged, (event) =>
+      SessionInbox.projectDeliveryChanged(db, {
+        id: event.data.inboxID,
         sessionID: event.data.sessionID,
-      }),
-    )
-    yield* bus.project(SessionEvent.InputQueued, (event) =>
-      SessionPending.projectQueued(db, {
-        id: event.data.inputID,
-        sessionID: event.data.sessionID,
-      }),
-    )
-    yield* bus.project(SessionEvent.Compaction.Admitted, (event) =>
-      Effect.gen(function* () {
-        if (event.durable === undefined)
-          return yield* Effect.die(new Error("Durable Session event is missing aggregate sequence"))
-        yield* SessionPending.projectCompactionAdmitted(db, {
-          admittedSeq: event.durable.seq,
-          id: event.data.inputID,
-          sessionID: event.data.sessionID,
-          timeCreated: event.created,
-        })
+        delivery: event.data.delivery,
       }),
     )
     yield* bus.project(SessionEvent.Execution.Succeeded, (event) => run(db, event))
@@ -596,8 +625,6 @@ const layer = Layer.effectDiscard(
         yield* InstructionState.advanceEpoch(db, event.data.sessionID, event.durable.seq)
         if (event.durable === undefined)
           return yield* Effect.die(new Error("Durable Session event is missing aggregate sequence"))
-        if (event.data.reason === "manual")
-          yield* SessionPending.settleCompaction(db, { sessionID: event.data.sessionID })
       }),
     )
     yield* bus.project(SessionEvent.Compaction.Failed, (event) =>
@@ -605,8 +632,6 @@ const layer = Layer.effectDiscard(
         yield* run(db, event)
         if (event.durable === undefined)
           return yield* Effect.die(new Error("Durable Session event is missing aggregate sequence"))
-        if (event.data.reason === "manual")
-          yield* SessionPending.settleCompaction(db, { sessionID: event.data.sessionID })
       }),
     )
     yield* bus.project(SessionEvent.RevertEvent.Staged, (event) =>
@@ -650,11 +675,11 @@ const layer = Layer.effectDiscard(
           .run()
           .pipe(Effect.orDie)
         yield* db
-          .delete(SessionPendingTable)
+          .delete(SessionInboxTable)
           .where(
             and(
-              eq(SessionPendingTable.session_id, event.data.sessionID),
-              gte(SessionPendingTable.admitted_seq, boundary.seq),
+              eq(SessionInboxTable.session_id, event.data.sessionID),
+              gte(SessionInboxTable.enqueued_seq, boundary.seq),
             ),
           )
           .run()

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

@@ -16,13 +16,20 @@ export type RunError =
   | UserInterruptedError
   | Instructions.InitializationBlocked
 
+export type Continuation = { readonly step: number }
+
+export type DrainResult =
+  | { readonly type: "complete" }
+  | { readonly type: "moved"; readonly continuation?: Continuation }
+
 /** Runs one local continuation from already-recorded Session history. */
 export interface Interface {
-  /** Drains eligible durable work. Explicit runs make one model call even when no work is eligible. */
+  /** Drains eligible durable work, returning transient state when execution must continue at a new Location. */
   readonly drain: (input: {
     readonly sessionID: SessionSchema.ID
     readonly force: boolean
-  }) => Effect.Effect<void, RunError>
+    readonly continuation?: Continuation
+  }) => Effect.Effect<DrainResult, RunError>
 }
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/SessionRunner") {}

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

@@ -17,13 +17,13 @@ import { InstructionState } from "../instruction-state.js"
 import { SessionCompaction } from "../compaction.js"
 import { SessionContext } from "../context.js"
 import { SessionEvent } from "../event.js"
-import { SessionPending } from "../pending.js"
+import { SessionInbox } from "../inbox.js"
 import { SessionModelRequest } from "../model-request.js"
 import { SessionMessage } from "../message.js"
 import { SessionSchema } from "../schema.js"
 import { SessionStore } from "../store.js"
 import { SessionTitle } from "../title.js"
-import { Service } from "./index.js"
+import { Service, type Continuation } from "./index.js"
 import { createLLMEventPublisher, type StepRecord } from "./publish-llm-event.js"
 import { Snapshot } from "../../snapshot.js"
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
@@ -113,8 +113,8 @@ const layer = Layer.effect(
     const compaction = yield* SessionCompaction.Service
     const title = yield* SessionTitle.Service
     const toolOutput = yield* ToolOutput.Service
-    // Title generation is a side effect of a successful step; it must not delay continuation.
-    // The in-flight set coalesces overlapping steps while title presence records success durably.
+    // Title generation starts once input is visible and must not delay model execution.
+    // The in-flight set coalesces overlapping prompts while title presence records success durably.
     const titlesRunning = new Set<SessionSchema.ID>()
     const forkTitle = yield* FiberSet.makeRuntime<never, void, never>()
     /**
@@ -124,29 +124,47 @@ const layer = Layer.effect(
     const drain = Effect.fn("SessionRunner.drain")(function* (input: {
       readonly sessionID: SessionSchema.ID
       readonly force: boolean
+      readonly continuation?: Continuation
     }) {
-      if (!input.force && !(yield* SessionPending.has(db, input.sessionID, "any"))) return
+      let force = input.force
+      let continuation = input.continuation
+      if (!force && !continuation && !(yield* SessionInbox.has(db, input.sessionID, "any")))
+        return { type: "complete" as const }
       yield* settleStaleToolCalls(input.sessionID)
-      yield* runPendingCompaction(input.sessionID)
-      if (!input.force && !(yield* SessionPending.has(db, input.sessionID, "input"))) return
-      do {
-        yield* runSteps(input.sessionID)
-      } while (yield* SessionPending.has(db, input.sessionID, "input"))
+      while (true) {
+        if (yield* runPendingCompaction(input.sessionID)) {
+          force = false
+          continue
+        }
+        if (yield* runPendingMove(input.sessionID, "input")) return { type: "moved" as const }
+        if (!force && !continuation && !(yield* SessionInbox.has(db, input.sessionID, "input")))
+          return { type: "complete" as const }
+        const result = yield* runSteps(input.sessionID, continuation)
+        if (result.type === "moved") return result
+        force = false
+        continuation = undefined
+      }
     })
 
     /**
      * Runs logical steps until no tool result or newly admitted steer requires another
      * model call. Queued inputs remain pending until the current model work reaches idle.
      */
-    const runSteps = Effect.fn("SessionRunner.runSteps")(function* (sessionID: SessionSchema.ID) {
+    const runSteps = Effect.fn("SessionRunner.runSteps")(function* (
+      sessionID: SessionSchema.ID,
+      continuation?: Continuation,
+    ) {
       // Fresh work may promote queued input; later steps absorb steers only.
-      let promotable: SessionPending.Promotable = "input"
-      let step = 1
+      let promotable: SessionInbox.Promotable = continuation ? "steer" : "input"
+      let step = continuation?.step ?? 1
+      let next = continuation
       while (true) {
+        if (yield* runPendingCompaction(sessionID)) continue
+        if (yield* runPendingMove(sessionID, "steer")) return { type: "moved" as const, continuation: next }
         const result = yield* runStep(sessionID, promotable, step)
-        if (step === 1) yield* startTitle(sessionID)
-        yield* runPendingCompaction(sessionID)
-        if (!result.needsContinuation && !(yield* SessionPending.has(db, sessionID, "steer"))) return
+        next = result.needsContinuation ? { step: result.step + 1 } : undefined
+        if (!result.needsContinuation && !(yield* SessionInbox.has(db, sessionID, "steer")))
+          return { type: "complete" as const }
         promotable = "steer"
         step = result.step + 1
       }
@@ -155,7 +173,7 @@ const layer = Layer.effect(
     /** Completes one logical model step, transparently retrying or rebuilding after compaction. */
     const runStep = Effect.fnUntraced(function* (
       sessionID: SessionSchema.ID,
-      promotable: SessionPending.Promotable,
+      promotable: SessionInbox.Promotable,
       step: number,
     ) {
       // Minting message identity before any attempt lets retries resume the same durable
@@ -183,7 +201,7 @@ const layer = Layer.effect(
               .pipe(Effect.andThen(Effect.fail(failure.cause))),
           ),
         )
-      let currentPromotable: SessionPending.Promotable | undefined = promotable
+      let currentPromotable: SessionInbox.Promotable | undefined = promotable
       let currentStep = step
       // Overflow recovery is one-shot: a call after recovery must not recover another overflow.
       let recoverOverflow = true
@@ -226,7 +244,7 @@ const layer = Layer.effect(
      */
     const callModel = Effect.fn("SessionRunner.callModel")(function* (
       sessionID: SessionSchema.ID,
-      promotable: SessionPending.Promotable | undefined,
+      promotable: SessionInbox.Promotable | undefined,
       step: number,
       recoverOverflow: boolean,
       assistantMessageID: SessionMessage.ID,
@@ -235,7 +253,8 @@ const layer = Layer.effect(
       // Establish what the model knows before admitting what the user said, so
       // a blocked first step leaves pending inputs untouched.
       yield* InstructionState.prepare(db, bus, selected.instructions, selected.session.id)
-      const promoted = promotable ? yield* SessionPending.promote(db, bus, selected.session.id, promotable) : 0
+      const promoted = promotable ? yield* SessionInbox.promote(db, bus, selected.session.id, promotable) : 0
+      if (promoted > 0) yield* startTitle(sessionID)
       // Promoted input opens a fresh step allowance.
       const currentStep = promoted > 0 ? 1 : step
       const loaded = yield* context.load(selected)
@@ -245,7 +264,7 @@ const layer = Layer.effect(
       // Make room: history must fit the context window before the call. A pending manual
       // compaction owns this instead; the runner executes it between steps.
       const compactionInput = { session, messages: loaded.messages, model, ref: resolved.ref, cost: resolved.cost }
-      if (compaction.required(compactionInput) && !(yield* SessionPending.compaction(db, session.id))) {
+      if (compaction.required(compactionInput)) {
         const compacted = yield* compaction.compact(compactionInput)
         if (compacted.status === "completed")
           return CallOutcome.Restart({ step: currentStep, recoveredOverflow: false })
@@ -482,36 +501,75 @@ const layer = Layer.effect(
     const runPendingCompaction = Effect.fn("SessionRunner.runPendingCompaction")(function* (
       sessionID: SessionSchema.ID,
     ) {
-      const pending = yield* SessionPending.compaction(db, sessionID)
-      if (!pending) return
-      const session = yield* getSession(sessionID)
       return yield* Effect.uninterruptibleMask((restore) =>
         Effect.gen(function* () {
+          const pending = yield* SessionInbox.serialized(
+            sessionID,
+            Effect.gen(function* () {
+              const selected =
+                (yield* SessionInbox.nextSteer(db, sessionID)) ?? (yield* SessionInbox.nextQueued(db, sessionID))
+              if (selected?.type !== "compaction") return
+              yield* bus.publishAll([
+                [SessionEvent.InboxDelivered, { sessionID, inboxID: selected.id }],
+                [SessionEvent.Compaction.Started, { sessionID, reason: "manual", recent: "", inputID: selected.id }],
+              ])
+              return selected
+            }),
+          )
+          if (pending?.type !== "compaction") return false
+          const session = yield* getSession(sessionID)
           const compacted = yield* restore(
             Effect.gen(function* () {
               return yield* compaction.compactManual({
                 session,
                 messages: yield* store.context(sessionID),
                 inputID: pending.id,
+                started: true,
               })
             }),
           ).pipe(Effect.exit)
-          if (Exit.isSuccess(compacted)) return
-          const unsettled = yield* SessionPending.compaction(db, sessionID)
-          if (unsettled)
-            yield* bus.publish(SessionEvent.Compaction.Failed, {
-              sessionID,
-              reason: "manual",
-              error: Cause.hasInterruptsOnly(compacted.cause)
-                ? { type: "aborted", message: "Compaction cancelled" }
-                : { type: "compaction.failed", message: Cause.pretty(compacted.cause) },
-              inputID: unsettled.id,
-            })
+          if (Exit.isSuccess(compacted)) return true
+          yield* bus.publish(SessionEvent.Compaction.Failed, {
+            sessionID,
+            reason: "manual",
+            error: Cause.hasInterruptsOnly(compacted.cause)
+              ? { type: "aborted", message: "Compaction cancelled" }
+              : { type: "compaction.failed", message: Cause.pretty(compacted.cause) },
+            inputID: pending.id,
+          })
           return yield* Effect.failCause(compacted.cause)
         }),
       )
     })
 
+    const runPendingMove = Effect.fn("SessionRunner.runPendingMove")(function* (
+      sessionID: SessionSchema.ID,
+      promotable: SessionInbox.Promotable,
+    ) {
+      return yield* SessionInbox.serialized(
+        sessionID,
+        Effect.gen(function* () {
+          const pending =
+            (yield* SessionInbox.nextSteer(db, sessionID)) ??
+            (promotable === "input" ? yield* SessionInbox.nextQueued(db, sessionID) : undefined)
+          if (pending?.type !== "move") return false
+          yield* bus.publishAll([
+            [SessionEvent.InboxDelivered, { sessionID, inboxID: pending.id }],
+            [
+              SessionEvent.Moved,
+              {
+                sessionID,
+                location: pending.payload.location,
+                projectID: pending.payload.projectID,
+                subpath: pending.payload.subpath,
+              },
+            ],
+          ])
+          return true
+        }),
+      )
+    })
+
     /** Closes stale tool calls left active by an earlier interrupted drain. */
     const settleStaleToolCalls = Effect.fn("SessionRunner.settleStaleToolCalls")(function* (
       sessionID: SessionSchema.ID,

packages/core/src/session/sql.ts

@@ -3,7 +3,7 @@ import { sql } from "drizzle-orm"
 import { directoryColumn, pathColumn } from "../database/path.js"
 import { ProjectTable } from "../project/sql.js"
 import type { SessionMessage } from "./message.js"
-import type { SessionPending } from "./pending.js"
+import type { SessionInbox } from "./inbox.js"
 import type { FileDiff } from "@opencode-ai/schema/file-diff"
 import { PermissionV1 } from "../v1/permission.js"
 import { Project } from "../project.js"
@@ -12,7 +12,7 @@ import { Workspace } from "../workspace.js"
 import { Timestamps } from "../database/schema.sql.js"
 import type { Instruction } from "@opencode-ai/schema/instruction"
 import type { Session } from "@opencode-ai/schema/session"
-import type { SyntheticData, UserData } from "@opencode-ai/schema/session-pending"
+import type { CompactionPayload, MovePayload, SyntheticPayload, UserPayload } from "@opencode-ai/schema/session-inbox"
 import type { RevertV1 } from "@opencode-ai/schema/session-revert"
 import type { Schema } from "effect"
 
@@ -101,9 +101,9 @@ export const SessionPendingTable = sqliteTable(
       .$type<SessionSchema.ID>()
       .notNull()
       .references(() => SessionTable.id, { onDelete: "cascade" }),
-    type: text().$type<SessionPending.Info["type"]>().notNull(),
-    data: text({ mode: "json" }).$type<UserData | SyntheticData | Record<string, never>>().notNull(),
-    delivery: text().$type<SessionPending.Delivery>(),
+    type: text().$type<SessionInbox.Info["type"]>().notNull(),
+    data: text({ mode: "json" }).$type<UserPayload | SyntheticPayload | Record<string, never>>().notNull(),
+    delivery: text().$type<SessionInbox.Delivery>(),
     admitted_seq: integer().notNull(),
     time_created: integer()
       .notNull()
@@ -118,6 +118,28 @@ export const SessionPendingTable = sqliteTable(
   ],
 )
 
+export const SessionInboxTable = sqliteTable(
+  "session_inbox",
+  {
+    id: text().$type<SessionMessage.ID>().primaryKey(),
+    session_id: text()
+      .$type<SessionSchema.ID>()
+      .notNull()
+      .references(() => SessionTable.id, { onDelete: "cascade" }),
+    type: text().$type<SessionInbox.Info["type"]>().notNull(),
+    payload: text({ mode: "json" }).$type<UserPayload | SyntheticPayload | CompactionPayload | MovePayload>().notNull(),
+    delivery: text().$type<SessionInbox.Delivery>().notNull(),
+    enqueued_seq: integer().notNull(),
+    time_created: integer()
+      .notNull()
+      .$default(() => Date.now()),
+  },
+  (table) => [
+    index("session_inbox_session_delivery_seq_idx").on(table.session_id, table.delivery, table.enqueued_seq),
+    uniqueIndex("session_inbox_session_enqueued_seq_idx").on(table.session_id, table.enqueued_seq),
+  ],
+)
+
 export const InstructionEntryTable = sqliteTable(
   "instruction_entry",
   {

packages/core/src/shell.ts

@@ -5,6 +5,7 @@ import { Context, Deferred, Duration, Effect, Fiber, Layer, Schema, Stream } fro
 import { ChildProcess } from "effect/unstable/process"
 import { produce } from "immer"
 import { Shell } from "@opencode-ai/schema/shell"
+import { AppProcess } from "@opencode-ai/util/process"
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
 import { Config } from "./config.js"
 import { Bus } from "./bus.js"
@@ -50,7 +51,7 @@ export interface Interface {
   readonly create: <E = never, R = never>(
     input: Shell.CreateInput,
     before?: (input: ShellCreateBefore) => Effect.Effect<void, E, R>,
-  ) => Effect.Effect<Shell.Info, E, R>
+  ) => Effect.Effect<Shell.Info, E | AppProcess.AppProcessError, R>
   // Currently running commands only; exited shells are retained for get/output but excluded here.
   readonly list: () => Effect.Effect<Shell.Info[]>
   readonly get: (id: Shell.ID) => Effect.Effect<Shell.Info, NotFoundError>
@@ -215,19 +216,23 @@ export const layer = (options?: ShellSelect.Options) =>
         // Spawn through the Environment and stream combined output to the file. The handle is scope-bound, so
         // the managing fiber keeps its scope open until the command terminates (it awaits `done` at the
         // end). `create` returns once `ready` resolves with the registered session.
-        const ready = Deferred.makeUnsafe<Active>()
+        const ready = Deferred.makeUnsafe<Active, AppProcess.AppProcessError>()
         runFork(
           Effect.scoped(
             Effect.gen(function* () {
-              const handle = yield* environment.spawner.spawn(
-                ChildProcess.make(invocation.shell, args, {
-                  cwd: invocation.cwd,
-                  env: invocation.env,
-                  stdin: "ignore",
-                  detached: process.platform !== "win32",
-                  forceKillAfter: Duration.seconds(3),
-                }),
-              )
+              const handle = yield* environment.spawner
+                .spawn(
+                  ChildProcess.make(invocation.shell, args, {
+                    cwd: invocation.cwd,
+                    env: invocation.env,
+                    stdin: "ignore",
+                    detached: process.platform !== "win32",
+                    forceKillAfter: Duration.seconds(3),
+                  }),
+                )
+                .pipe(
+                  Effect.mapError((cause) => new AppProcess.AppProcessError({ command: invocation.command, cause })),
+                )
               const session: Active = {
                 info: produce(info, (draft) => {
                   draft.pid = handle.pid
@@ -329,7 +334,7 @@ export const layer = (options?: ShellSelect.Options) =>
               // release (kill) the process before its exit is observed.
               yield* Deferred.await(session.done).pipe(Effect.catch(() => Effect.void))
             }),
-          ).pipe(Effect.catch(() => Effect.void)),
+          ).pipe(Effect.catchTag("AppProcessError", (error) => Deferred.fail(ready, error))),
         )
 
         const session = yield* Deferred.await(ready)

packages/core/src/shell/parser-wasm.workerd.ts

@@ -0,0 +1,4 @@
+// workerd has no filesystem paths to tree-sitter wasm artifacts. ShellParse
+// loads these lazily and degrades when initialization fails, so empty paths
+// keep module load side-effect free instead of resolving from disk.
+export const shellParserWasm = { runtime: "", bash: "", powershell: "" }

packages/core/src/tool.ts

@@ -2,7 +2,7 @@ export * as Tool from "./tool.js"
 export { CallID, Content, Error, FileContent, TextContent } from "@opencode-ai/schema/tool"
 export type { Context, Metadata, Options, Result } from "@opencode-ai/schema/tool"
 
-import type { ToolCall, ToolDefinition } from "@opencode-ai/ai"
+import { ToolDefinition, type ToolCall } from "@opencode-ai/ai"
 import { Tool } from "@opencode-ai/schema/tool"
 import { Context, Effect, Layer, Schema, Scope, Semaphore } from "effect"
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
@@ -165,6 +165,19 @@ const layer = Layer.effect(
           }),
         )
       if (entries.length === 0) return
+      yield* Effect.forEach(
+        entries,
+        (entry) =>
+          Effect.try({
+            try: () => ToolDefinition.make(definition(entry.tool)),
+            catch: (error) =>
+              new RegistrationError({
+                name: entry.key,
+                message: `Invalid tool definition ${entry.key}: ${error instanceof Error ? error.message : String(error)}`,
+              }),
+          }),
+        { discard: true },
+      )
       yield* Effect.uninterruptible(
         lock.withPermit(
           Effect.gen(function* () {

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

@@ -286,7 +286,6 @@ export const Plugin = {
                   output,
                   content,
                   metadata: {
-                    status: output.status,
                     truncated: output.truncated,
                     ...("exit" in output && output.exit !== undefined ? { exit: output.exit } : {}),
                     ...("shellID" in output && output.shellID !== undefined ? { shellID: output.shellID } : {}),

packages/core/src/util/process-lock-ffi.workerd.ts

@@ -0,0 +1,14 @@
+export type LockResult =
+  | { readonly acquired: true }
+  | { readonly acquired: false; readonly held: true }
+  | { readonly acquired: false; readonly held: false; readonly code: number }
+
+// workerd has no FFI and no cross-process file locking; a Durable Object is
+// already single-threaded per instance, so nothing on this runtime should
+// reach these.
+const unavailable = (_fd: number): LockResult => {
+  throw new Error("Process locks are unavailable on the workerd runtime")
+}
+
+export const lockDarwin = unavailable
+export const lockLinux = unavailable

packages/core/test/bus.test.ts

@@ -455,6 +455,120 @@ describe("Bus", () => {
     }),
   )
 
+  it.effect("publishes a durable batch atomically in provided order", () =>
+    Effect.gen(function* () {
+      const bus = yield* Bus.Service
+      const { db } = yield* Database.Service
+      const aggregateID = Event.ID.create()
+      const observed = new Array<string>()
+      yield* bus.project(SyncMessage, (event) =>
+        Effect.sync(() => {
+          observed.push(`project:${event.data.text}`)
+        }),
+      )
+      yield* bus.listen((event) =>
+        event.type === SyncMessage.type
+          ? Effect.gen(function* () {
+              const text = (event.data as { readonly text: string }).text
+              const row = yield* db
+                .select({ seq: EventSequenceTable.seq })
+                .from(EventSequenceTable)
+                .where(eq(EventSequenceTable.aggregate_id, aggregateID))
+                .get()
+                .pipe(Effect.orDie)
+              observed.push(`notify:${text}:${row?.seq}`)
+            })
+          : Effect.void,
+      )
+
+      const events = yield* bus.publishAll([
+        [SyncMessage, { id: aggregateID, text: "first" }],
+        [SyncMessage, { id: aggregateID, text: "second" }],
+      ])
+
+      expect(events.map((event) => event.durable.seq)).toEqual([Event.Seq.make(0), Event.Seq.make(1)])
+      expect(observed).toEqual(["project:first", "project:second", "notify:first:1", "notify:second:1"])
+      expect(
+        (yield* db.select().from(EventTable).where(eq(EventTable.aggregate_id, aggregateID)).all()).map(
+          (row) => row.seq,
+        ),
+      ).toEqual([0, 1])
+    }),
+  )
+
+  it.effect("rolls back every batch event when a projector fails", () =>
+    Effect.gen(function* () {
+      const bus = yield* Bus.Service
+      const { db } = yield* Database.Service
+      const aggregateID = Event.ID.create()
+      const notifications = new Array<string>()
+      yield* db.run("CREATE TABLE IF NOT EXISTS event_batch_probe (value text NOT NULL)")
+      yield* db.run("DELETE FROM event_batch_probe")
+      yield* bus.project(SyncMessage, (event) =>
+        db
+          .run(`INSERT INTO event_batch_probe (value) VALUES ('${event.data.text}')`)
+          .pipe(
+            Effect.orDie,
+            Effect.andThen(event.data.text === "second" ? Effect.die("projector failed") : Effect.void),
+          ),
+      )
+      yield* bus.listen((event) =>
+        Effect.sync(() => {
+          notifications.push(event.type)
+        }),
+      )
+
+      const exit = yield* bus
+        .publishAll([
+          [SyncMessage, { id: aggregateID, text: "first" }],
+          [SyncMessage, { id: aggregateID, text: "second" }],
+        ])
+        .pipe(Effect.exit)
+
+      expect(String(exit)).toContain("projector failed")
+      expect(yield* db.all("SELECT value FROM event_batch_probe")).toEqual([])
+      expect(yield* db.select().from(EventTable).where(eq(EventTable.aggregate_id, aggregateID)).all()).toEqual([])
+      expect(
+        yield* db.select().from(EventSequenceTable).where(eq(EventSequenceTable.aggregate_id, aggregateID)).all(),
+      ).toEqual([])
+      expect(notifications).toEqual([])
+    }),
+  )
+
+  it.effect("does not interleave a concurrent publish with batch notifications", () =>
+    Effect.gen(function* () {
+      const bus = yield* Bus.Service
+      const aggregateID = Event.ID.create()
+      const firstObserved = yield* Deferred.make<void>()
+      const continueNotifications = yield* Deferred.make<void>()
+      const observed = new Array<string>()
+      yield* bus.listen((event) => {
+        if (event.type !== SyncMessage.type) return Effect.void
+        const text = (event.data as { readonly text: string }).text
+        return Effect.sync(() => observed.push(text)).pipe(
+          Effect.andThen(text === "first" ? Deferred.succeed(firstObserved, undefined) : Effect.void),
+          Effect.andThen(text === "first" ? Deferred.await(continueNotifications) : Effect.void),
+        )
+      })
+
+      const batch = yield* bus
+        .publishAll([
+          [SyncMessage, { id: aggregateID, text: "first" }],
+          [SyncMessage, { id: aggregateID, text: "second" }],
+        ])
+        .pipe(Effect.forkScoped)
+      yield* Deferred.await(firstObserved)
+      const single = yield* bus.publish(SyncMessage, { id: aggregateID, text: "third" }).pipe(Effect.forkScoped)
+      yield* Effect.yieldNow
+
+      expect(observed).toEqual(["first"])
+      yield* Deferred.succeed(continueNotifications, undefined)
+      yield* Fiber.join(batch)
+      yield* Fiber.join(single)
+      expect(observed).toEqual(["first", "second", "third"])
+    }),
+  )
+
   it.effect("replays durable aggregate events after a sequence and tails new events", () =>
     Effect.gen(function* () {
       const bus = yield* Bus.Service

packages/core/test/environment.test.ts

@@ -1,9 +1,10 @@
 import fs from "node:fs/promises"
 import { describe, expect } from "bun:test"
 import { Effect } from "effect"
-import { ChildProcessSpawner } from "effect/unstable/process"
+import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process"
 import { CrossSpawnSpawner } from "@opencode-ai/util/cross-spawn-spawner"
 import { LayerNode } from "@opencode-ai/util/effect/layer-node"
+import { EnvironmentUnavailable } from "../src/environment/unavailable"
 import {
   execDefaults,
   Failed,
@@ -35,6 +36,17 @@ describe("typeFollowing", () => {
   )
 })
 
+describe("no execution plane", () => {
+  it.effect("fails spawn with a typed location error", () =>
+    Effect.gen(function* () {
+      const error = yield* EnvironmentUnavailable.spawner.spawn(ChildProcess.make("echo", ["hello"])).pipe(Effect.flip)
+
+      expect(error._tag).toBe("PlatformError")
+      expect(error.message).toContain("location has no execution plane")
+    }),
+  )
+})
+
 environmentConformance("memory environment", () =>
   Effect.sync(() => {
     const driver = makeMemoryDriver()

packages/core/test/fixture/durable-object-storage.ts

@@ -0,0 +1,47 @@
+import { Database } from "bun:sqlite"
+import type { DurableObjectStorage } from "@opencode-ai/core/database/sqlite.workerd"
+
+// Emulates the Durable Object storage API over bun:sqlite so the workerd
+// adapter and the workerd server profile can be verified without workerd or
+// Cloudflare runtime dependencies. The real runtime is covered by the
+// workerd-spike package, which boots inside an actual isolate.
+export const makeDurableObjectStorage = (): DurableObjectStorage => {
+  const native = new Database(":memory:")
+  const toSqlStorageValue = (value: unknown) => {
+    if (!(value instanceof Uint8Array)) return value as ArrayBuffer | string | number | null
+    const buffer = new ArrayBuffer(value.byteLength)
+    new Uint8Array(buffer).set(value)
+    return buffer
+  }
+  return {
+    sql: {
+      exec(query: string, ...bindings: Array<unknown>) {
+        const statement = native.query(query)
+        const rows = (statement.values(...(bindings as never[])) ?? []).map((row) => row.map(toSqlStorageValue))
+        const columnNames = statement.columnNames
+        return {
+          columnNames,
+          raw: () => rows[Symbol.iterator](),
+          toArray: () => rows.map((row) => Object.fromEntries(columnNames.map((name, i) => [name, row[i]]))),
+        }
+      },
+    },
+    transaction<T>(closure: (txn: { rollback(): void }) => Promise<T>): Promise<T> {
+      native.run("BEGIN")
+      let rolledBack = false
+      return closure({ rollback: () => (rolledBack = true) }).then(
+        (result) => {
+          native.run(rolledBack ? "ROLLBACK" : "COMMIT")
+          return result
+        },
+        (error) => {
+          native.run("ROLLBACK")
+          throw error
+        },
+      )
+    },
+    transactionSync<T>(closure: () => T): T {
+      return native.transaction(closure)()
+    },
+  }
+}

packages/core/test/fixture/environment.ts

@@ -1,7 +1,42 @@
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { Environment } from "@opencode-ai/core/environment/index"
 import { Location } from "@opencode-ai/core/location"
+import { CrossSpawnSpawner } from "@opencode-ai/util/cross-spawn-spawner"
+import { LayerNode } from "@opencode-ai/util/effect/layer-node"
 import { Effect, Layer } from "effect"
+import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process"
+
+/**
+ * The host environment, without the workspace machinery: what a location with no `workspaceID`
+ * resolves to.
+ */
+export const hostEnvironmentLayer = Layer.effect(
+  Environment.Service,
+  Effect.gen(function* () {
+    const spawner = yield* ChildProcessSpawner.ChildProcessSpawner
+    const driver = Environment.makeLocalDriver(spawner)
+    return Environment.Service.of({ files: Environment.makeFiles(driver), spawner: driver.spawner })
+  }),
+).pipe(Layer.provide(LayerNode.compile(CrossSpawnSpawner.node)))
+
+/**
+ * The host environment with its spawner wrapped so a test can assert on every command that crosses
+ * the seam. Spawning still really happens, so the process under test behaves normally.
+ */
+export const recordingEnvironmentLayer = (spawns: Array<ChildProcess.Command>) =>
+  Layer.effect(
+    Environment.Service,
+    Effect.gen(function* () {
+      const environment = yield* Environment.Service
+      return Environment.Service.of({
+        ...environment,
+        spawner: ChildProcessSpawner.make((command) => {
+          spawns.push(command)
+          return environment.spawner.spawn(command)
+        }),
+      })
+    }),
+  ).pipe(Layer.provide(hostEnvironmentLayer))
 
 export type EnvironmentFilesTransform = (files: Environment.Files) => Partial<Environment.Files>
 

packages/core/test/mcp.test.ts

@@ -22,19 +22,25 @@ import { Bus } from "@opencode-ai/core/bus"
 import { ID, type Payload } from "@opencode-ai/schema/event"
 import { Form } from "@opencode-ai/core/form"
 import { Integration } from "@opencode-ai/core/integration"
+import { Environment } from "@opencode-ai/core/environment/index"
+import { EnvironmentUnavailable } from "@opencode-ai/core/environment/unavailable"
 import { Location } from "@opencode-ai/core/location"
 import { MCP } from "@opencode-ai/core/mcp/index"
 import { MCPClient } from "@opencode-ai/core/mcp/client"
+import { MCPStdio } from "@opencode-ai/core/mcp/stdio"
 import { Permission } from "@opencode-ai/core/permission"
 import { AbsolutePath } from "@opencode-ai/core/schema"
 import { Session } from "@opencode-ai/core/session"
 import { McpTool } from "@opencode-ai/core/tool/mcp"
 import { Tool } from "@opencode-ai/core/tool"
-import { DateTime, Deferred, Effect, Exit, Fiber, Layer, PubSub, Schedule, Schema, Stream } from "effect"
+import { DateTime, Deferred, Effect, Exit, Fiber, Layer, PubSub, Schedule, Schema, Sink, Stream } from "effect"
+import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process"
+import { ExitCode, makeHandle, ProcessId } from "effect/unstable/process/ChildProcessSpawner"
 import { Image } from "@opencode-ai/core/image"
 import { testEffect } from "./lib/effect"
 import { imagePassthrough } from "./lib/image"
 import { location } from "./fixture/location"
+import { hostEnvironmentLayer, recordingEnvironmentLayer } from "./fixture/environment"
 import { executeTool, toolDefinitions, toolIdentity, waitForCodeModeTool, waitForTool } from "./lib/tool"
 
 let assertion: Deferred.Deferred<Permission.AssertInput> | undefined
@@ -167,6 +173,7 @@ function resourceMcpLayer(
   overrides?: {
     entries?: Config.Interface["entries"]
     subscribe?: Bus.Interface["subscribe"]
+    environment?: Layer.Layer<Environment.Service>
   },
 ) {
   const directory = AbsolutePath.make(import.meta.dir)
@@ -229,11 +236,15 @@ function resourceMcpLayer(
           },
         }),
         Layer.mock(Credential.Service, {}),
+        overrides?.environment ?? hostEnvironmentLayer,
       ),
     ),
   )
 }
 
+const connect = (server: string, config: typeof ConfigMCP.Server.Type, directory: string) =>
+  MCPClient.connect(server, config, directory).pipe(Effect.provide(hostEnvironmentLayer))
+
 const mcp = Layer.mock(MCP.Service, {
   tools: () =>
     Effect.succeed([
@@ -407,7 +418,7 @@ test("retains output schemas across paginated MCP discovery", async () => {
   const tools = await Effect.runPromise(
     Effect.scoped(
       Effect.gen(function* () {
-        const connection = yield* MCPClient.connect(
+        const connection = yield* connect(
           "pagination",
           new ConfigMCP.Local({
             type: "local",
@@ -440,11 +451,160 @@ test("retains output schemas across paginated MCP discovery", async () => {
   ])
 })
 
+test("spawns local MCP servers through the location environment", async () => {
+  const spawns: Array<ChildProcess.Command> = []
+  const cwd = path.join(import.meta.dir, "fixture")
+  const config = new ConfigMCP.Local({
+    type: "local",
+    command: [process.execPath, path.join(import.meta.dir, "fixture/mcp-output-schema.ts")],
+    cwd: "fixture",
+    environment: { MCP_LOCATION_TEST: "configured" },
+  })
+
+  await Effect.runPromise(
+    Effect.scoped(
+      Effect.gen(function* () {
+        const connection = yield* MCPClient.connect("environment", config, import.meta.dir)
+        yield* connection.tools()
+      }),
+    ).pipe(Effect.provide(recordingEnvironmentLayer(spawns))),
+  )
+
+  expect(spawns).toHaveLength(1)
+  const command = spawns[0]
+  if (!command || !ChildProcess.isStandardCommand(command)) throw new Error("Expected a standard process command")
+  expect(command.command).toBe(process.execPath)
+  expect(command.options.cwd).toBe(cwd)
+  expect(command.options.extendEnv).toBe(true)
+  expect(command.options.env).toEqual({ MCP_LOCATION_TEST: "configured" })
+})
+
+test("reports a local MCP server as failed when the location has no execution plane", async () => {
+  const config = new ConfigMCP.Local({ type: "local", command: ["example-mcp"] })
+  const driver = Environment.makeMemoryDriver()
+  const environment = Layer.succeed(
+    Environment.Service,
+    Environment.Service.of({ files: Environment.makeFiles(driver), spawner: EnvironmentUnavailable.spawner }),
+  )
+
+  await Effect.runPromise(
+    Effect.gen(function* () {
+      const service = yield* MCP.Service
+      yield* service.tools()
+      const status = (yield* service.servers()).find((server) => server.name === "resources")?.status
+      expect(status).toEqual({
+        status: "failed",
+        error: expect.stringContaining("location has no execution plane"),
+      })
+    }).pipe(Effect.provide(resourceMcpLayer(config, undefined, undefined, { environment }))),
+  )
+})
+
+test("rejects sends before the stdio transport is started", async () => {
+  await Effect.runPromise(
+    Effect.scoped(
+      Effect.gen(function* () {
+        const transport = yield* MCPStdio.make({
+          server: "not-started",
+          command: process.execPath,
+          args: [path.join(import.meta.dir, "fixture/mcp-output-schema.ts")],
+          cwd: import.meta.dir,
+          environment: {},
+        })
+        yield* Effect.tryPromise({
+          try: () => transport.send({ jsonrpc: "2.0", method: "notifications/initialized" }),
+          catch: (cause) => (cause instanceof Error ? cause : new Error(String(cause))),
+        }).pipe(
+          Effect.flip,
+          Effect.tap((error) => Effect.sync(() => expect(error.message).toBe("Not connected"))),
+        )
+      }).pipe(Effect.provide(hostEnvironmentLayer)),
+    ),
+  )
+})
+
+test("joins concurrent stdio transport closes", async () => {
+  await Effect.runPromise(
+    Effect.scoped(
+      Effect.gen(function* () {
+        const transport = yield* MCPStdio.make({
+          server: "concurrent-close",
+          command: "unused",
+          args: [],
+          cwd: import.meta.dir,
+          environment: {},
+        })
+        const first = transport.close()
+        expect(transport.close()).toBe(first)
+        yield* Effect.promise(() => first)
+      }).pipe(Effect.provide(hostEnvironmentLayer)),
+    ),
+  )
+})
+
+test("closes a stdio process that finishes spawning after close", async () => {
+  const spawning = Deferred.makeUnsafe<void>()
+  const release = Deferred.makeUnsafe<void>()
+  const exited = Deferred.makeUnsafe<ExitCode>()
+  const signals: Array<string> = []
+  const driver = Environment.makeMemoryDriver()
+  const environment = Layer.succeed(
+    Environment.Service,
+    Environment.Service.of({
+      files: Environment.makeFiles(driver),
+      spawner: ChildProcessSpawner.make(() =>
+        Effect.gen(function* () {
+          yield* Deferred.succeed(spawning, undefined)
+          yield* Deferred.await(release)
+          return makeHandle({
+            pid: ProcessId(1),
+            exitCode: Deferred.await(exited),
+            isRunning: Deferred.isDone(exited).pipe(Effect.map((done) => !done)),
+            kill: (options) =>
+              Effect.gen(function* () {
+                signals.push(options?.killSignal ?? "SIGTERM")
+                yield* Deferred.succeed(exited, ExitCode(143))
+              }),
+            stdin: Sink.drain,
+            stdout: Stream.never,
+            stderr: Stream.empty,
+            all: Stream.never,
+            getInputFd: () => Sink.drain,
+            getOutputFd: () => Stream.empty,
+            unref: Effect.succeed(Effect.void),
+          })
+        }),
+      ),
+    }),
+  )
+
+  await Effect.runPromise(
+    Effect.scoped(
+      Effect.gen(function* () {
+        const transport = yield* MCPStdio.make({
+          server: "close-during-spawn",
+          command: "unused",
+          args: [],
+          cwd: import.meta.dir,
+          environment: {},
+        })
+        const start = transport.start()
+        yield* Deferred.await(spawning)
+        const close = transport.close()
+        yield* Deferred.succeed(release, undefined)
+        yield* Effect.promise(() => Promise.all([start, close]))
+      }).pipe(Effect.provide(environment)),
+    ),
+  )
+
+  expect(signals).toEqual(["SIGTERM"])
+})
+
 test("applies the configured MCP catalog timeout", async () => {
   const result = Effect.runPromise(
     Effect.scoped(
       Effect.gen(function* () {
-        const connection = yield* MCPClient.connect(
+        const connection = yield* connect(
           "catalog-timeout",
           new ConfigMCP.Local({
             type: "local",
@@ -466,7 +626,7 @@ test("applies the configured MCP execution timeout", async () => {
   const result = Effect.runPromise(
     Effect.scoped(
       Effect.gen(function* () {
-        const connection = yield* MCPClient.connect(
+        const connection = yield* connect(
           "execution-timeout",
           new ConfigMCP.Local({
             type: "local",
@@ -487,7 +647,7 @@ test("applies the configured MCP execution timeout to prompts", async () => {
   const result = Effect.runPromise(
     Effect.scoped(
       Effect.gen(function* () {
-        const connection = yield* MCPClient.connect(
+        const connection = yield* connect(
           "prompt-timeout",
           new ConfigMCP.Local({
             type: "local",
@@ -508,7 +668,7 @@ test("applies configured MCP timeouts to resource operations", async () => {
   const catalog = Effect.runPromise(
     Effect.scoped(
       Effect.gen(function* () {
-        const connection = yield* MCPClient.connect(
+        const connection = yield* connect(
           "resource-catalog-timeout",
           new ConfigMCP.Local({
             type: "local",
@@ -527,7 +687,7 @@ test("applies configured MCP timeouts to resource operations", async () => {
   const read = Effect.runPromise(
     Effect.scoped(
       Effect.gen(function* () {
-        const connection = yield* MCPClient.connect(
+        const connection = yield* connect(
           "resource-read-timeout",
           new ConfigMCP.Local({
             type: "local",
@@ -562,7 +722,7 @@ test("lists, reads, and reports MCP resource changes", async () => {
           },
           "templates-2": { items: [{ name: "Issue", uriTemplate: "issue://{id}", description: "Issue" }] },
         }
-        const connection = yield* MCPClient.connect(
+        const connection = yield* connect(
           "resources",
           new ConfigMCP.Remote({ type: "remote", url: server.url, oauth: false }),
           import.meta.dir,
@@ -633,7 +793,7 @@ test("skips MCP resource requests when the capability is absent", async () => {
     Effect.scoped(
       Effect.gen(function* () {
         const server = yield* resourceServer({ resources: false })
-        const connection = yield* MCPClient.connect(
+        const connection = yield* connect(
           "resources",
           new ConfigMCP.Remote({ type: "remote", url: server.url, oauth: false }),
           import.meta.dir,

packages/core/test/plugin/promise.test.ts

@@ -11,7 +11,7 @@ import { PluginPromise } from "@opencode-ai/core/plugin/promise"
 import { WebSearch } from "@opencode-ai/core/websearch"
 import { Session } from "@opencode-ai/core/session"
 import { SessionMessage } from "@opencode-ai/core/session/message"
-import { SessionPending } from "@opencode-ai/core/session/pending"
+import { SessionInbox } from "@opencode-ai/core/session/inbox"
 import { Tool } from "@opencode-ai/core/tool"
 import { Provider } from "@opencode-ai/core/provider"
 import { define } from "@opencode-ai/plugin/promise/plugin"
@@ -61,12 +61,12 @@ describe("fromPromise", () => {
           synthetic: (value) => {
             seen = value
             return Effect.succeed(
-              SessionPending.Synthetic.make({
+              SessionInbox.Synthetic.make({
                 id: SessionMessage.ID.make(input.id),
                 sessionID: Session.ID.make(input.sessionID),
                 timeCreated: DateTime.makeUnsafe(0),
                 type: "synthetic",
-                data: {
+                payload: {
                   text: input.text,
                   metadata: input.metadata,
                 },

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

@@ -195,6 +195,22 @@ describe("GithubCopilotPlugin", () => {
     }),
   )
 
+  it.effect("rewrites models.dev fallback models to the GitHub Copilot package", () =>
+    Effect.gen(function* () {
+      const catalog = yield* Catalog.Service
+      yield* catalog.transform((catalog) => {
+        catalog.provider.update(Provider.ID.githubCopilot, () => {})
+        catalog.model.update(Provider.ID.githubCopilot, Model.ID.make("gpt-5.6-sol"), (model) => {
+          model.package = "@ai-sdk/openai-compatible"
+        })
+      })
+      yield* addPlugin()
+      expect(required(yield* catalog.model.get(Provider.ID.githubCopilot, Model.ID.make("gpt-5.6-sol"))).package).toBe(
+        "@ai-sdk/github-copilot",
+      )
+    }),
+  )
+
   it.effect("selects languageModel when responses and chat are absent", () =>
     Effect.gen(function* () {
       const plugin = yield* Plugin.Service

packages/core/test/session-compact.test.ts

@@ -15,7 +15,6 @@ import { AbsolutePath } from "@opencode-ai/core/schema"
 import { Session } from "@opencode-ai/core/session"
 import { SessionCompaction } from "@opencode-ai/core/session/compaction"
 import { SessionEvent } from "@opencode-ai/core/session/event"
-import { SessionPending } from "@opencode-ai/core/session/pending"
 import { SessionMessage } from "@opencode-ai/core/session/message"
 import { SessionProjector } from "@opencode-ai/core/session/projector"
 import { SessionExecution } from "@opencode-ai/core/session/execution"
@@ -81,7 +80,7 @@ const it = testEffect(
 )
 
 describe("Session.compact", () => {
-  it.effect("durably admits and coalesces manual compaction", () =>
+  it.effect("durably stacks manual compaction", () =>
     Effect.gen(function* () {
       requests = []
       const session = yield* Session.Service
@@ -89,18 +88,18 @@ describe("Session.compact", () => {
       const created = yield* session.create({ location })
 
       const messageID = SessionMessage.ID.create()
-      yield* bus.publish(SessionEvent.InputAdmitted, {
+      yield* bus.publish(SessionEvent.InboxEnqueued, {
         sessionID: created.id,
-        inputID: messageID,
-        input: {
+        inboxID: messageID,
+        item: {
           type: "user",
-          data: { text: "Please compact this session history." },
+          payload: { text: "Please compact this session history." },
           delivery: "steer",
         },
       })
-      yield* bus.publish(SessionEvent.InputPromoted, {
+      yield* bus.publish(SessionEvent.InboxDelivered, {
         sessionID: created.id,
-        inputID: messageID,
+        inboxID: messageID,
       })
 
       expect(yield* session.compact({ id: messageID, sessionID: created.id }).pipe(Effect.flip)).toMatchObject({
@@ -110,12 +109,17 @@ describe("Session.compact", () => {
       const first = yield* session.compact({ sessionID: created.id })
       const second = yield* session.compact({ sessionID: created.id })
 
-      expect(second.id).toBe(first.id)
+      expect(second.id).not.toBe(first.id)
       expect(requests).toHaveLength(0)
-      expect(yield* SessionPending.compaction((yield* Database.Service).db, created.id)).toMatchObject({
-        id: first.id,
-      })
+      expect(yield* session.inbox(created.id)).toEqual([
+        expect.objectContaining({ id: first.id, type: "compaction", delivery: "queue" }),
+        expect.objectContaining({ id: second.id, type: "compaction", delivery: "queue" }),
+      ])
       expect((yield* session.context(created.id)).find((message) => message.id === first.id)).toBeUndefined()
+
+      const steered = yield* session.create({ location })
+      const steer = yield* session.compact({ sessionID: steered.id, delivery: "steer" })
+      expect(steer).toMatchObject({ type: "compaction", delivery: "steer" })
     }),
   )
 })

packages/core/test/session-create.test.ts

@@ -1,4 +1,6 @@
 import { describe, expect } from "bun:test"
+import { $ } from "bun"
+import fs from "fs/promises"
 import path from "path"
 import { DateTime, Effect, Layer, Stream } from "effect"
 import { Money } from "@opencode-ai/schema/money"
@@ -7,6 +9,7 @@ import { asc, eq } from "drizzle-orm"
 import { Database } from "@opencode-ai/core/database/database"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { LayerNode } from "@opencode-ai/util/effect/layer-node"
+import { Hash } from "@opencode-ai/util/hash"
 import { Bus } from "@opencode-ai/core/bus"
 import { EventTable } from "@opencode-ai/core/event/sql"
 import { Location } from "@opencode-ai/core/location"
@@ -19,7 +22,7 @@ import { Session } from "@opencode-ai/core/session"
 import { SessionMessage } from "@opencode-ai/core/session/message"
 import { SessionProjector } from "@opencode-ai/core/session/projector"
 import { SessionExecution } from "@opencode-ai/core/session/execution"
-import { SessionPending } from "@opencode-ai/core/session/pending"
+import { SessionInbox } from "@opencode-ai/core/session/inbox"
 import { SessionEvent } from "@opencode-ai/core/session/event"
 import { SessionTable } from "@opencode-ai/core/session/sql"
 import { SessionStore } from "@opencode-ai/core/session/store"
@@ -53,6 +56,15 @@ const it = testEffect(
     ],
   ),
 )
+const liveIt = testEffect(
+  AppNodeBuilder.build(
+    LayerNode.group([Database.node, Bus.node, Project.node, SessionProjector.node, SessionStore.node, Session.node]),
+    [
+      [Bus.node, Bus.configured({ persist: true })],
+      [SessionExecution.node, SessionExecution.noopLayer],
+    ],
+  ),
+)
 const location = Location.Ref.make({ directory: AbsolutePath.make("/project") })
 const id = Session.ID.create()
 
@@ -78,6 +90,65 @@ function withTmp<A, E, R>(f: (directory: string) => Effect.Effect<A, E, R>) {
 }
 
 describe("Session.create", () => {
+  liveIt.live("follows the directory's project identity established after creation", () =>
+    withTmp((directory) =>
+      Effect.gen(function* () {
+        const session = yield* Session.Service
+        const projects = yield* Project.Service
+        const { db } = yield* Database.Service
+        const ref = Location.Ref.make({ directory: AbsolutePath.make(directory) })
+        const nested = Location.Ref.make({ directory: AbsolutePath.make(path.join(directory, "packages", "app")) })
+        const created = yield* session.create({ location: ref, title: "Before git" })
+        const child = yield* session.create({ location: nested, title: "Nested before git" })
+        const originalUpdated = created.time.updated
+
+        yield* Effect.promise(async () => {
+          await $`git init -q`.cwd(directory)
+          await $`git config user.email test@example.com`.cwd(directory)
+          await $`git config user.name Test`.cwd(directory)
+          await fs.writeFile(path.join(directory, "README.md"), "test\n")
+          await $`git add README.md`.cwd(directory)
+          await $`git commit -qm initial`.cwd(directory)
+          await $`git remote add origin git@github.com:owner/adopted.git`.cwd(directory)
+        })
+
+        const project = yield* projects.resolve(ref.directory)
+        const repeat = yield* projects.resolve(ref.directory)
+        const adopted = yield* session.get(created.id)
+        const nestedAdopted = yield* session.get(child.id)
+        const page = yield* session.list({ project: project.id })
+        const log = Array.from(yield* Stream.runCollect(logEvents(session, created.id)))
+
+        expect(created.projectID).toBe(Project.ID.global)
+        expect(project.id).toBe(Project.ID.make(Hash.fast("git-remote:github.com/owner/adopted")))
+        expect(repeat.id).toBe(project.id)
+        expect(page.data.map((item) => item.id)).toEqual(expect.arrayContaining([created.id, child.id]))
+        expect(adopted).toMatchObject({
+          projectID: project.id,
+          location: ref,
+          subpath: undefined,
+          time: { updated: originalUpdated },
+        })
+        expect(nestedAdopted).toMatchObject({
+          projectID: project.id,
+          location: nested,
+          subpath: RelativePath.make("packages/app"),
+        })
+        // Adoption is a project-domain fact; the session log records nothing new.
+        expect(log.map((event) => event.type)).toEqual(["session.created"])
+        expect(yield* session.messages({ sessionID: created.id })).toEqual([])
+        // Repeated resolution announces the directory's identity exactly once.
+        const announced = yield* db
+          .select({ type: EventTable.type })
+          .from(EventTable)
+          .where(eq(EventTable.aggregate_id, project.id))
+          .all()
+          .pipe(Effect.orDie)
+        expect(announced.map((event) => event.type)).toEqual(["project.directory.resolved.1"])
+      }),
+    ),
+  )
+
   it.effect("persists a missing title until one is generated or supplied", () =>
     Effect.gen(function* () {
       const session = yield* Session.Service
@@ -267,9 +338,9 @@ describe("Session.create", () => {
         text: "First",
         resume: false,
       })
-      yield* SessionPending.promote(db, bus, parent.id, "steer")
+      yield* SessionInbox.promote(db, bus, parent.id, "steer")
       yield* session.synthetic({ sessionID: parent.id, text: "parent note", resume: false })
-      yield* SessionPending.promote(db, bus, parent.id, "steer")
+      yield* SessionInbox.promote(db, bus, parent.id, "steer")
 
       const forked = yield* session.fork({ sessionID: parent.id, boundary: { type: "through" } })
       const parentContext = yield* session.context(parent.id)
@@ -289,24 +360,24 @@ describe("Session.create", () => {
         durable: { seq: 0 },
         data: { sessionID: forked.id, parentID: parent.id },
       })
-      expect(yield* SessionPending.find(db, forkContext[0].id)).toBeUndefined()
-      expect(yield* SessionPending.find(db, forkContext[1].id)).toBeUndefined()
+      expect(yield* SessionInbox.find(db, forkContext[0].id)).toBeUndefined()
+      expect(yield* SessionInbox.find(db, forkContext[1].id)).toBeUndefined()
       expect(
         yield* session.prompt({ id: forkContext[0].id, sessionID: forked.id, text: "First", resume: false }),
-      ).toMatchObject({ id: forkContext[0].id, type: "user", data: { text: "First" } })
+      ).toMatchObject({ id: forkContext[0].id, type: "user", payload: { text: "First" } })
 
       yield* session.prompt({
         sessionID: parent.id,
         text: "Parent changed",
         resume: false,
       })
-      yield* SessionPending.promote(db, bus, parent.id, "steer")
+      yield* SessionInbox.promote(db, bus, parent.id, "steer")
       yield* session.prompt({
         sessionID: forked.id,
         text: "Child continues",
         resume: false,
       })
-      yield* SessionPending.promote(db, bus, forked.id, "steer")
+      yield* SessionInbox.promote(db, bus, forked.id, "steer")
 
       expect((yield* session.context(parent.id)).map((message) => message.type)).toEqual(["user", "synthetic", "user"])
       expect((yield* session.context(forked.id)).map((message) => message.type)).toEqual(["user", "synthetic", "user"])
@@ -316,7 +387,7 @@ describe("Session.create", () => {
           (event): number | undefined => event.durable?.seq,
         ),
       ).toEqual([0, 5, 6])
-      expect(yield* SessionPending.find(db, admitted.id)).toBeUndefined()
+      expect(yield* SessionInbox.find(db, admitted.id)).toBeUndefined()
     }),
   )
 
@@ -327,7 +398,7 @@ describe("Session.create", () => {
       const { db } = yield* Database.Service
       const parent = yield* session.create({ location })
       yield* session.prompt({ sessionID: parent.id, text: "First", resume: false })
-      yield* SessionPending.promote(db, bus, parent.id, "steer")
+      yield* SessionInbox.promote(db, bus, parent.id, "steer")
 
       const forked = yield* session.fork({ sessionID: parent.id, boundary: { type: "through" } })
       const row = yield* db.select().from(SessionTable).where(eq(SessionTable.id, forked.id)).get().pipe(Effect.orDie)
@@ -359,13 +430,13 @@ describe("Session.create", () => {
         text: "First",
         resume: false,
       })
-      yield* SessionPending.promote(db, bus, parent.id, "steer")
+      yield* SessionInbox.promote(db, bus, parent.id, "steer")
       const second = yield* session.prompt({
         sessionID: parent.id,
         text: "Second",
         resume: false,
       })
-      yield* SessionPending.promote(db, bus, parent.id, "steer")
+      yield* SessionInbox.promote(db, bus, parent.id, "steer")
       const assistantMessageID = SessionMessage.ID.create()
       const model = Model.Ref.make({ id: Model.ID.make("model"), providerID: Provider.ID.make("provider") })
       yield* bus.publish(SessionEvent.Step.Started, {
@@ -496,7 +567,7 @@ describe("Session.create", () => {
         text: "Hello",
         resume: false,
       })
-      yield* SessionPending.promote(db, bus, created.id, "steer")
+      yield* SessionInbox.promote(db, bus, created.id, "steer")
 
       expect(
         Array.from(yield* logEvents(session, created.id, true).pipe(Stream.take(3), Stream.runCollect)),
@@ -504,10 +575,13 @@ describe("Session.create", () => {
         { durable: { seq: 0 }, type: "session.created" },
         {
           durable: { seq: 1 },
-          type: "session.input.admitted",
-          data: { input: { type: "user", data: { text: "Hello" }, delivery: "steer" } },
+          type: "session.inbox.enqueued",
+          data: {
+            inboxID: expect.any(String),
+            item: { type: "user", payload: { text: "Hello" }, delivery: "steer" },
+          },
         },
-        { durable: { seq: 2 }, type: "session.input.promoted" },
+        { durable: { seq: 2 }, type: "session.inbox.delivered" },
       ])
     }),
   )
@@ -523,7 +597,7 @@ describe("Session.create", () => {
         text: "Replay lifecycle",
         resume: false,
       })
-      yield* SessionPending.promote(sourceDb, sourceEvents, created.id, "steer")
+      yield* SessionInbox.promote(sourceDb, sourceEvents, created.id, "steer")
       const serialized = (yield* sourceDb
         .select()
         .from(EventTable)
@@ -563,17 +637,17 @@ describe("Session.create", () => {
 
         expect(yield* store.get(created.id)).toBeUndefined()
         expect(yield* bus.replayAll(serialized.slice(0, 2))).toBe(created.id)
-        expect(yield* SessionPending.find(db, admitted.id)).toMatchObject({
+        expect(yield* SessionInbox.find(db, admitted.id)).toMatchObject({
           id: admitted.id,
           sessionID: created.id,
           type: "user",
-          data: { text: "Replay lifecycle" },
+          payload: { text: "Replay lifecycle" },
           delivery: "steer",
         })
         expect(yield* store.context(created.id)).toEqual([])
 
         expect(yield* bus.replayAll(serialized.slice(2))).toBe(created.id)
-        expect(yield* SessionPending.find(db, admitted.id)).toBeUndefined()
+        expect(yield* SessionInbox.find(db, admitted.id)).toBeUndefined()
         expect(yield* store.context(created.id)).toMatchObject([
           { id: admitted.id, type: "user", text: "Replay lifecycle" },
         ])
@@ -587,8 +661,8 @@ describe("Session.create", () => {
             .pipe(Effect.orDie)).map((event) => [event.seq, event.type]),
         ).toEqual([
           [0, Bus.versionedType(SessionEvent.Created.type, 1)],
-          [1, Bus.versionedType(SessionEvent.InputAdmitted.type, 1)],
-          [2, Bus.versionedType(SessionEvent.InputPromoted.type, 1)],
+          [1, Bus.versionedType(SessionEvent.InboxEnqueued.type, 1)],
+          [2, Bus.versionedType(SessionEvent.InboxDelivered.type, 1)],
         ])
       }).pipe(Effect.provide(Layer.fresh(targetLayer)))
     }),
@@ -808,7 +882,7 @@ describe("SessionTransfer", () => {
       ])
 
       yield* session.prompt({ sessionID, text: "Continue", resume: false })
-      yield* SessionPending.promote(db, bus, sessionID, "steer")
+      yield* SessionInbox.promote(db, bus, sessionID, "steer")
 
       expect((yield* session.messages({ sessionID, order: "asc" })).map((message) => message.type)).toEqual([
         "user",

packages/core/test/session-execution.test.ts

@@ -346,14 +346,17 @@ function attempts(database: Database.Service["Service"], sessionID: Session.ID)
 /** Builds the local execution layer plus the restart actions against the test harness services. */
 function buildExecution(
   scope: Scope.Closeable,
-  drain: SessionRunner.Interface["drain"],
+  drain: (input: Parameters<SessionRunner.Interface["drain"]>[0]) => Effect.Effect<void, SessionRunner.RunError>,
   options?: SessionRestart.Options,
 ) {
   return Effect.gen(function* () {
     const database = yield* Database.Service
     const bus = yield* Bus.Service
     const store = yield* SessionStore.Service
-    const runner = Layer.succeed(SessionRunner.Service, SessionRunner.Service.of({ drain }))
+    const runner = Layer.succeed(
+      SessionRunner.Service,
+      SessionRunner.Service.of({ drain: (input) => drain(input).pipe(Effect.as({ type: "complete" as const })) }),
+    )
     const locations = Layer.effect(
       LocationServiceMap.Service,
       LayerMap.make(

packages/core/test/session-generate.test.ts

@@ -38,7 +38,7 @@ import {
   InstructionBlobTable,
   InstructionStateTable,
   SessionMessageTable,
-  SessionPendingTable,
+  SessionInboxTable,
   SessionTable,
 } from "@opencode-ai/core/session/sql"
 import { SessionStore } from "@opencode-ai/core/session/store"
@@ -170,9 +170,9 @@ const durableState = (db: Database.Interface["db"], sessionID: SessionSchema.ID)
       .pipe(Effect.orDie),
     pending: db
       .select()
-      .from(SessionPendingTable)
-      .where(eq(SessionPendingTable.session_id, sessionID))
-      .orderBy(asc(SessionPendingTable.admitted_seq))
+      .from(SessionInboxTable)
+      .where(eq(SessionInboxTable.session_id, sessionID))
+      .orderBy(asc(SessionInboxTable.enqueued_seq))
       .all()
       .pipe(Effect.orDie),
     instructions: db
@@ -225,12 +225,15 @@ it.effect("generates from fresh settled Session context without durable mutation
     const { db, bus, instructions } = yield* setup
     yield* InstructionState.prepare(db, bus, instructions, sessionID)
     const existing = SessionMessage.ID.create()
-    yield* bus.publish(SessionEvent.InputAdmitted, {
+    yield* bus.publish(SessionEvent.InboxEnqueued, {
       sessionID,
-      inputID: existing,
-      input: { type: "user", data: { text: "Existing durable context" }, delivery: "steer" },
+      inboxID: existing,
+      item: { type: "user", payload: { text: "Existing durable context" }, delivery: "steer" },
+    })
+    yield* bus.publish(SessionEvent.InboxDelivered, {
+      sessionID,
+      inboxID: existing,
     })
-    yield* bus.publish(SessionEvent.InputPromoted, { sessionID, inputID: existing })
     const settledAssistant = SessionMessage.ID.create()
     yield* bus.publish(SessionEvent.Step.Started, {
       sessionID,
@@ -275,10 +278,10 @@ it.effect("generates from fresh settled Session context without durable mutation
       input: {},
       executed: false,
     })
-    yield* bus.publish(SessionEvent.InputAdmitted, {
+    yield* bus.publish(SessionEvent.InboxEnqueued, {
       sessionID,
-      inputID: SessionMessage.ID.create(),
-      input: { type: "user", data: { text: "Queued input must remain invisible" }, delivery: "queue" },
+      inboxID: SessionMessage.ID.create(),
+      item: { type: "user", payload: { text: "Queued input must remain invisible" }, delivery: "queue" },
     })
     instruction = "Changed context"
     const before = yield* durableState(db, sessionID)

packages/core/test/session-move.test.ts

@@ -1,6 +1,7 @@
 import { describe, expect } from "bun:test"
 import path from "path"
 import { Effect, Layer } from "effect"
+import { Event } from "@opencode-ai/schema/project-directories"
 import { Bus } from "@opencode-ai/core/bus"
 import { Database } from "@opencode-ai/core/database/database"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
@@ -8,6 +9,7 @@ import { Location } from "@opencode-ai/core/location"
 import { Project } from "@opencode-ai/core/project"
 import { AbsolutePath } from "@opencode-ai/core/schema"
 import { Session } from "@opencode-ai/core/session"
+import { SessionEvent } from "@opencode-ai/core/session/event"
 import { SessionExecution } from "@opencode-ai/core/session/execution"
 import { SessionProjector } from "@opencode-ai/core/session/projector"
 import { SessionStore } from "@opencode-ai/core/session/store"
@@ -34,7 +36,7 @@ const it = testEffect(
 )
 
 describe("Session.move", () => {
-  it.effect("moves a session whose source directory no longer exists", () =>
+  it.effect("enqueues one move when the source directory no longer exists", () =>
     Effect.acquireRelease(
       Effect.promise(() => tmpdir()),
       (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
@@ -49,24 +51,65 @@ describe("Session.move", () => {
 
           yield* session.move({ sessionID: created.id, directory: destination })
 
-          expect((yield* session.get(created.id)).location.directory).toBe(destination)
-          const messages = yield* session.messages({ sessionID: created.id, order: "asc" })
-          expect(messages).toEqual([
-            expect.objectContaining({
-              type: "location-switched",
-              location: { directory: destination },
-              projectID: Project.ID.global,
-              previous: {
-                location: { directory: path.join(tmp.path, "deleted") },
+          expect((yield* session.get(created.id)).location.directory).toBe(
+            AbsolutePath.make(path.join(tmp.path, "deleted")),
+          )
+          expect(yield* session.inbox(created.id)).toMatchObject([
+            {
+              type: "move",
+              delivery: "steer",
+              payload: {
+                location: { directory: destination },
                 projectID: Project.ID.global,
-                subpath: "",
               },
-              subpath: "",
-            }),
+            },
           ])
 
           yield* session.move({ sessionID: created.id, directory: destination })
-          expect(yield* session.messages({ sessionID: created.id, order: "asc" })).toEqual(messages)
+          expect(yield* session.inbox(created.id)).toHaveLength(2)
+
+          const steered = yield* session.create({
+            location: Location.Ref.make({ directory: AbsolutePath.make(path.join(tmp.path, "other")) }),
+          })
+          yield* session.move({ sessionID: steered.id, directory: destination, delivery: "queue" })
+          expect(yield* session.inbox(steered.id)).toMatchObject([{ type: "move", delivery: "queue" }])
+        }),
+      ),
+    ),
+  )
+
+  it.effect("keeps a moved session out of its former directory's new identity", () =>
+    Effect.acquireRelease(
+      Effect.promise(() => tmpdir()),
+      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
+    ).pipe(
+      Effect.flatMap((tmp) =>
+        Effect.gen(function* () {
+          const session = yield* Session.Service
+          const bus = yield* Bus.Service
+          const previous = AbsolutePath.make(path.join(tmp.path, "previous"))
+          const destination = AbsolutePath.make(tmp.path)
+          const created = yield* session.create({ location: Location.Ref.make({ directory: previous }) })
+
+          // Moves are admitted through the inbox and applied by the drain;
+          // publish the applied move directly since execution is a no-op here.
+          yield* bus.publish(SessionEvent.Moved, {
+            sessionID: created.id,
+            location: Location.Ref.make({ directory: destination }),
+            projectID: Project.ID.global,
+          })
+          // The former directory becomes a project after the session left it.
+          yield* bus.publish(Event.Resolved, {
+            projectID: Project.ID.make("adopting"),
+            directory: previous,
+            previous: Project.ID.global,
+          })
+
+          expect(yield* session.get(created.id)).toMatchObject({
+            projectID: Project.ID.global,
+            location: { directory: destination },
+            subpath: undefined,
+          })
         }),
       ),
     ),

packages/core/test/session-projector.test.ts

@@ -20,11 +20,11 @@ import { Money } from "@opencode-ai/schema/money"
 import { SessionProjector } from "@opencode-ai/core/session/projector"
 import { SessionExecution } from "@opencode-ai/core/session/execution"
 import { fromRow } from "@opencode-ai/core/session/info"
-import { SessionPending } from "@opencode-ai/core/session/pending"
+import { SessionInbox } from "@opencode-ai/core/session/inbox"
 import { Shell } from "@opencode-ai/schema/shell"
 import {
   InstructionStateTable,
-  SessionPendingTable,
+  SessionInboxTable,
   SessionMessageTable,
   SessionTable,
 } from "@opencode-ai/core/session/sql"
@@ -81,7 +81,7 @@ describe("SessionProjector", () => {
         .run()
       const bus = yield* Bus.Service
       const inputID = SessionMessage.ID.make("msg_manual_compaction")
-      yield* SessionPending.admitCompaction(db, bus, { id: inputID, sessionID })
+      yield* SessionInbox.admitCompaction(db, bus, { id: inputID, sessionID, delivery: "queue" })
 
       yield* bus.publish(SessionEvent.Compaction.Failed, {
         sessionID,
@@ -89,7 +89,7 @@ describe("SessionProjector", () => {
         error: { type: "compaction.failed", message: "Auto compaction failed" },
       })
 
-      expect(yield* SessionPending.compaction(db, sessionID)).toMatchObject({ id: inputID })
+      expect(yield* SessionInbox.find(db, inputID)).toMatchObject({ id: inputID })
     }),
   )
 
@@ -247,29 +247,29 @@ describe("SessionProjector", () => {
         .pipe(Effect.orDie)
       const bus = yield* Bus.Service
 
-      yield* bus.publish(SessionEvent.InputAdmitted, {
+      yield* bus.publish(SessionEvent.InboxEnqueued, {
         sessionID,
-        inputID: SessionMessage.ID.make("msg_first"),
-        input: { type: "user", data: { text: "first" }, delivery: "steer" },
+        inboxID: SessionMessage.ID.make("msg_first"),
+        item: { type: "user", payload: { text: "first" }, delivery: "steer" },
       })
       yield* bus.publish(
-        SessionEvent.InputPromoted,
+        SessionEvent.InboxDelivered,
         {
           sessionID,
-          inputID: SessionMessage.ID.make("msg_first"),
+          inboxID: SessionMessage.ID.make("msg_first"),
         },
         { id: Event.ID.make("evt_z") },
       )
-      yield* bus.publish(SessionEvent.InputAdmitted, {
+      yield* bus.publish(SessionEvent.InboxEnqueued, {
         sessionID,
-        inputID: SessionMessage.ID.make("msg_second"),
-        input: { type: "user", data: { text: "second" }, delivery: "steer" },
+        inboxID: SessionMessage.ID.make("msg_second"),
+        item: { type: "user", payload: { text: "second" }, delivery: "steer" },
       })
       yield* bus.publish(
-        SessionEvent.InputPromoted,
+        SessionEvent.InboxDelivered,
         {
           sessionID,
-          inputID: SessionMessage.ID.make("msg_second"),
+          inboxID: SessionMessage.ID.make("msg_second"),
         },
         { id: Event.ID.make("evt_a") },
       )
@@ -320,20 +320,20 @@ describe("SessionProjector", () => {
         .pipe(Effect.orDie)
       const bus = yield* Bus.Service
       const id = SessionMessage.ID.make("msg_admitted")
-      const admitted = yield* SessionPending.admit(db, bus, {
+      const admitted = yield* SessionInbox.admit(db, bus, {
         id,
         sessionID,
-        input: { type: "user", data: { text: "promote me" }, delivery: "steer" },
+        item: { type: "user", payload: { text: "promote me" }, delivery: "steer" },
       })
       if (!admitted) return yield* Effect.die("Prompt admission failed")
 
-      const event = yield* bus.publish(SessionEvent.InputPromoted, {
+      const event = yield* bus.publish(SessionEvent.InboxDelivered, {
         sessionID,
-        inputID: id,
+        inboxID: id,
       })
 
       expect(
-        yield* db.select().from(SessionPendingTable).where(eq(SessionPendingTable.id, id)).get().pipe(Effect.orDie),
+        yield* db.select().from(SessionInboxTable).where(eq(SessionInboxTable.id, id)).get().pipe(Effect.orDie),
       ).toBeUndefined()
       expect(
         yield* db.select().from(SessionMessageTable).where(eq(SessionMessageTable.id, id)).get().pipe(Effect.orDie),

packages/core/test/session-prompt.test.ts

@@ -21,8 +21,8 @@ import { Session } from "@opencode-ai/core/session"
 import { SessionMessage } from "@opencode-ai/core/session/message"
 import { SessionProjector } from "@opencode-ai/core/session/projector"
 import { SessionExecution } from "@opencode-ai/core/session/execution"
-import { SessionPending } from "@opencode-ai/core/session/pending"
-import { SessionPendingTable, SessionMessageTable, SessionTable } from "@opencode-ai/core/session/sql"
+import { SessionInbox } from "@opencode-ai/core/session/inbox"
+import { SessionInboxTable, SessionMessageTable, SessionTable } from "@opencode-ai/core/session/sql"
 import { SessionStore } from "@opencode-ai/core/session/store"
 import { LocationServiceMap } from "@opencode-ai/core/location-service-map"
 import type { LocationServices } from "@opencode-ai/core/location-services"
@@ -100,11 +100,11 @@ const setup = Effect.gen(function* () {
     .pipe(Effect.orDie)
 })
 
-const admitted = (id: SessionMessage.ID) => Database.Service.use(({ db }) => SessionPending.find(db, id))
+const admitted = (id: SessionMessage.ID) => Database.Service.use(({ db }) => SessionInbox.find(db, id))
 const admittedCount = Database.Service.use(({ db }) =>
   db
     .select()
-    .from(SessionPendingTable)
+    .from(SessionInboxTable)
     .all()
     .pipe(
       Effect.orDie,
@@ -227,13 +227,13 @@ describe("Session.prompt", () => {
         resume: false,
       })
 
-      expect(message.data.text).toBe("Fix the failing tests")
+      expect(message.payload.text).toBe("Fix the failing tests")
       expect(yield* session.messages({ sessionID })).toEqual([])
       expect(yield* admitted(message.id)).toMatchObject({
         id: message.id,
         sessionID,
         type: "user",
-        data: { text: "Fix the failing tests" },
+        payload: { text: "Fix the failing tests" },
         delivery: "steer",
       })
     }),
@@ -251,7 +251,7 @@ describe("Session.prompt", () => {
         text: "boundary",
         resume: false,
       })
-      yield* SessionPending.promote(db, bus, sessionID, "steer")
+      yield* SessionInbox.promote(db, bus, sessionID, "steer")
       const stale = SessionMessage.ID.make("msg_stale_assistant")
       yield* db.insert(SessionMessageTable).values(assistantRow(stale, 100)).run().pipe(Effect.orDie)
       yield* bus.publish(SessionEvent.RevertEvent.Staged, {
@@ -268,7 +268,7 @@ describe("Session.prompt", () => {
           (row) => row.id,
         ),
       ).not.toContainAnyValues([boundary.id, stale])
-      expect(yield* SessionPending.find(db, boundary.id)).toBeUndefined()
+      expect(yield* SessionInbox.find(db, boundary.id)).toBeUndefined()
     }),
   )
 
@@ -283,7 +283,7 @@ describe("Session.prompt", () => {
         text: "boundary",
         resume: false,
       })
-      yield* SessionPending.promote(db, bus, sessionID, "steer")
+      yield* SessionInbox.promote(db, bus, sessionID, "steer")
       yield* bus.publish(SessionEvent.RevertEvent.Staged, {
         sessionID,
         revert: { messageID: boundary.id, files: [] },
@@ -293,11 +293,11 @@ describe("Session.prompt", () => {
       const completion = yield* session.synthetic({ sessionID, text: "stale completion" })
 
       expect(wakeCalls).toEqual([])
-      expect(yield* SessionPending.find(db, completion.id)).toMatchObject({ type: "synthetic" })
+      expect(yield* SessionInbox.find(db, completion.id)).toMatchObject({ type: "synthetic" })
 
       yield* session.revert.commit(sessionID)
 
-      expect(yield* SessionPending.find(db, completion.id)).toBeUndefined()
+      expect(yield* SessionInbox.find(db, completion.id)).toBeUndefined()
     }),
   )
 
@@ -315,7 +315,7 @@ describe("Session.prompt", () => {
         resume: false,
       })
 
-      expect(message.data.files).toEqual([
+      expect(message.payload.files).toEqual([
         {
           data: uri.slice(uri.indexOf(",") + 1),
           mime: "image/png",
@@ -326,7 +326,7 @@ describe("Session.prompt", () => {
       ])
       const stored = yield* admitted(message.id)
       expect(stored?.type).toBe("user")
-      if (stored?.type === "user") expect(stored.data.files).toEqual(message.data.files)
+      if (stored?.type === "user") expect(stored.payload.files).toEqual(message.payload.files)
     }),
   )
 
@@ -347,14 +347,14 @@ describe("Session.prompt", () => {
         resume: false,
       })
 
-      expect(message.data.files).toHaveLength(1)
-      expect(message.data.files?.[0]).toMatchObject({
+      expect(message.payload.files).toHaveLength(1)
+      expect(message.payload.files?.[0]).toMatchObject({
         mime: "text/plain",
         source: { type: "uri", uri: sourceUri.href },
         name: "main.ts",
       })
       expect(
-        Buffer.from(message.data.files?.[0]?.data ?? "", "base64")
+        Buffer.from(message.payload.files?.[0]?.data ?? "", "base64")
           .toString("utf8")
           .replace(/\r$/, ""),
       ).toBe('import { describe, expect } from "bun:test"')
@@ -374,13 +374,13 @@ describe("Session.prompt", () => {
         resume: false,
       })
 
-      expect(message.data.files).toHaveLength(1)
-      expect(message.data.files?.[0]).toMatchObject({
+      expect(message.payload.files).toHaveLength(1)
+      expect(message.payload.files?.[0]).toMatchObject({
         mime: "application/x-directory",
         source: { type: "uri", uri },
         name: "source",
       })
-      expect(Buffer.from(message.data.files?.[0]?.data ?? "", "base64").toString("utf8")).toContain(
+      expect(Buffer.from(message.payload.files?.[0]?.data ?? "", "base64").toString("utf8")).toContain(
         "session-prompt.test.ts",
       )
     }),
@@ -408,7 +408,7 @@ describe("Session.prompt", () => {
         resume: false,
       })
 
-      expect(message.data.files).toEqual([
+      expect(message.payload.files).toEqual([
         {
           data: bytes.toString("base64"),
           mime: "image/png",
@@ -417,7 +417,7 @@ describe("Session.prompt", () => {
         },
       ])
       const stored = yield* admitted(message.id)
-      expect(stored?.type === "user" ? stored.data.files : undefined).toEqual(message.data.files)
+      expect(stored?.type === "user" ? stored.payload.files : undefined).toEqual(message.payload.files)
     }),
   )
 
@@ -440,7 +440,7 @@ describe("Session.prompt", () => {
         resume: false,
       })
 
-      expect(message.data.files).toEqual([
+      expect(message.payload.files).toEqual([
         {
           data: "AA==",
           mime: "image/png",
@@ -463,7 +463,7 @@ describe("Session.prompt", () => {
         resume: false,
       })
 
-      expect(message.data.files).toEqual([
+      expect(message.payload.files).toEqual([
         {
           data: Buffer.from("export const value = 1\n").toString("base64"),
           mime: "text/plain",
@@ -512,20 +512,20 @@ describe("Session.prompt", () => {
 
       yield* session.prompt({ sessionID, text: "First", resume: false })
       yield* session.prompt({ sessionID, text: "Second", resume: false })
-      yield* SessionPending.promote(db, bus, sessionID, "steer")
+      yield* SessionInbox.promote(db, bus, sessionID, "steer")
       const streamed = Array.from(yield* Fiber.join(fiber))
 
       expect(streamed.map((event): [number | undefined, string] => [event.durable?.seq, event.type])).toEqual([
-        [0, "session.input.admitted"],
-        [1, "session.input.admitted"],
-        [2, "session.input.promoted"],
-        [3, "session.input.promoted"],
+        [0, "session.inbox.enqueued"],
+        [1, "session.inbox.enqueued"],
+        [2, "session.inbox.delivered"],
+        [3, "session.inbox.delivered"],
       ])
       expect(
         Array.from(
           yield* publicEvents({ sessionID, after: streamed[0].durable?.seq }).pipe(Stream.take(1), Stream.runCollect),
         ).map((event): [number | undefined, string] => [event.durable?.seq, event.type]),
-      ).toEqual([[1, "session.input.admitted"]])
+      ).toEqual([[1, "session.inbox.enqueued"]])
     }),
   )
 
@@ -593,12 +593,12 @@ describe("Session.prompt", () => {
       const { db } = yield* Database.Service
       const input = { sessionID, id: messageID, text: "Fix the failing tests", resume: false }
       const first = yield* session.prompt(input)
-      yield* SessionPending.promote(db, bus, sessionID, "steer")
+      yield* SessionInbox.promote(db, bus, sessionID, "steer")
       yield* db.delete(EventTable).where(eq(EventTable.aggregate_id, sessionID)).run().pipe(Effect.orDie)
 
       const retried = yield* session.prompt(input)
 
-      expect(retried).toMatchObject({ id: first.id, type: "user", data: { text: first.data.text } })
+      expect(retried).toMatchObject({ id: first.id, type: "user", payload: { text: first.payload.text } })
       expect(yield* session.messages({ sessionID })).toMatchObject([
         { id: messageID, type: "user", text: "Fix the failing tests" },
       ])
@@ -613,11 +613,11 @@ describe("Session.prompt", () => {
       const { db } = yield* Database.Service
       const input = { sessionID, id: messageID, text: "Fix the failing tests", resume: false }
       yield* session.prompt(input)
-      yield* SessionPending.promote(db, bus, sessionID, "steer")
+      yield* SessionInbox.promote(db, bus, sessionID, "steer")
 
       const retried = yield* session.prompt({ ...input, delivery: "queue" })
 
-      expect(retried).toMatchObject({ id: messageID, type: "user", data: { text: input.text } })
+      expect(retried).toMatchObject({ id: messageID, type: "user", payload: { text: input.text } })
       expect(yield* admitted(messageID)).toBeUndefined()
     }),
   )
@@ -708,7 +708,7 @@ describe("Session.prompt", () => {
       expect(messages[1]).toEqual(messages[0])
       expect(yield* session.messages({ sessionID })).toEqual([])
       expect(yield* admittedCount).toBe(1)
-      expect(yield* eventCount(Bus.versionedType(SessionEvent.InputAdmitted.type, 1))).toBe(1)
+      expect(yield* eventCount(Bus.versionedType(SessionEvent.InboxEnqueued.type, 1))).toBe(1)
     }),
   )
 
@@ -726,11 +726,11 @@ describe("Session.prompt", () => {
       })
 
       yield* Effect.all(
-        [SessionPending.promote(db, bus, sessionID, "steer"), SessionPending.promote(db, bus, sessionID, "steer")],
+        [SessionInbox.promote(db, bus, sessionID, "steer"), SessionInbox.promote(db, bus, sessionID, "steer")],
         { concurrency: "unbounded" },
       )
 
-      expect(yield* eventCount(Bus.versionedType(SessionEvent.InputPromoted.type, 1))).toBe(1)
+      expect(yield* eventCount(Bus.versionedType(SessionEvent.InboxDelivered.type, 1))).toBe(1)
       expect(yield* admitted(messageID)).toBeUndefined()
       expect(yield* session.messages({ sessionID })).toMatchObject([
         { id: messageID, type: "user", text: "Promote once" },
@@ -761,11 +761,7 @@ describe("Session.prompt", () => {
         .pipe(Effect.orDie)
 
       yield* bus.remove(sessionID)
-      yield* db
-        .delete(SessionPendingTable)
-        .where(eq(SessionPendingTable.session_id, sessionID))
-        .run()
-        .pipe(Effect.orDie)
+      yield* db.delete(SessionInboxTable).where(eq(SessionInboxTable.session_id, sessionID)).run().pipe(Effect.orDie)
       yield* db
         .delete(SessionMessageTable)
         .where(eq(SessionMessageTable.session_id, sessionID))
@@ -785,12 +781,12 @@ describe("Session.prompt", () => {
       expect(yield* admitted(messageID)).toMatchObject({
         id: messageID,
         type: "user",
-        data: { text: "Replay pending" },
+        payload: { text: "Replay pending" },
       })
       expect(yield* admitted(syntheticID)).toMatchObject({
         id: syntheticID,
         type: "synthetic",
-        data: { text: "Replay synthetic" },
+        payload: { text: "Replay synthetic" },
       })
       expect(yield* session.messages({ sessionID })).toEqual([])
       expect(wakeCalls).toEqual([])
@@ -923,7 +919,7 @@ describe("Session.prompt", () => {
       const failure = yield* session.prompt({ ...input, metadata: { source: "plugin" } }).pipe(Effect.flip)
 
       expect(retried).toEqual(first)
-      expect(first.data.metadata).toEqual({ source: "api" })
+      expect(first.payload.metadata).toEqual({ source: "api" })
       expect(failure._tag).toBe("Session.PromptConflictError")
     }),
   )
@@ -949,14 +945,14 @@ describe("Session.prompt", () => {
         type: "synthetic",
         sessionID,
         delivery: "steer",
-        data: {
+        payload: {
           text: "Background work completed",
           description: "shell completion",
           metadata: { job: "shell" },
         },
       })
 
-      yield* SessionPending.promote(db, bus, sessionID, "steer")
+      yield* SessionInbox.promote(db, bus, sessionID, "steer")
 
       expect(yield* session.messages({ sessionID })).toMatchObject([
         {
@@ -981,15 +977,15 @@ describe("Session.prompt", () => {
       const entries = yield* Effect.all([session.synthetic(input), session.synthetic(input)], {
         concurrency: "unbounded",
       })
-      yield* SessionPending.promote(database.db, bus, sessionID, "steer")
+      yield* SessionInbox.promote(database.db, bus, sessionID, "steer")
       const promotedRetry = yield* session.synthetic(input)
       const failure = yield* session.synthetic({ ...input, text: "Different completion" }).pipe(Effect.flip)
 
       expect(entries[1]).toEqual(entries[0])
-      expect(promotedRetry).toMatchObject({ id: messageID, type: "synthetic", data: { text: "Completed" } })
+      expect(promotedRetry).toMatchObject({ id: messageID, type: "synthetic", payload: { text: "Completed" } })
       expect(failure).toMatchObject({ _tag: "Session.SyntheticConflictError", sessionID, inputID: messageID })
       expect(yield* admittedCount).toBe(0)
-      expect(yield* eventCount(Bus.versionedType(SessionEvent.InputAdmitted.type, 1))).toBe(1)
+      expect(yield* eventCount(Bus.versionedType(SessionEvent.InboxEnqueued.type, 1))).toBe(1)
     }),
   )
 
@@ -1008,11 +1004,11 @@ describe("Session.prompt", () => {
       })
 
       expect(input.delivery).toBe("queue")
-      expect(yield* SessionPending.has(db, sessionID, "input")).toBe(true)
-      expect(yield* SessionPending.promote(db, bus, sessionID, "steer")).toBe(0)
+      expect(yield* SessionInbox.has(db, sessionID, "input")).toBe(true)
+      expect(yield* SessionInbox.promote(db, bus, sessionID, "steer")).toBe(0)
       expect(yield* session.messages({ sessionID })).toEqual([])
-      expect(yield* SessionPending.promote(db, bus, sessionID, "input")).toBe(1)
-      expect(yield* SessionPending.has(db, sessionID, "input")).toBe(false)
+      expect(yield* SessionInbox.promote(db, bus, sessionID, "input")).toBe(1)
+      expect(yield* SessionInbox.has(db, sessionID, "input")).toBe(false)
       expect(yield* session.messages({ sessionID })).toMatchObject([
         { id: input.id, type: "synthetic", text: "Queued completion" },
       ])
@@ -1038,7 +1034,7 @@ describe("Session.prompt", () => {
         resume: false,
       })
 
-      yield* SessionPending.promote(db, bus, sessionID, "steer")
+      yield* SessionInbox.promote(db, bus, sessionID, "steer")
 
       expect(
         (yield* session.messages({ sessionID, order: "asc" })).map((message) =>
@@ -1049,11 +1045,11 @@ describe("Session.prompt", () => {
   )
 })
 
-describe("Session.pending", () => {
+describe("Session.inbox", () => {
   it.effect("fails for an unknown session", () =>
     Effect.gen(function* () {
       const session = yield* Session.Service
-      expect(yield* session.pending(Session.ID.make("ses_missing")).pipe(Effect.flip)).toMatchObject({
+      expect(yield* session.inbox(Session.ID.make("ses_missing")).pipe(Effect.flip)).toMatchObject({
         _tag: "Session.NotFoundError",
       })
     }),
@@ -1075,34 +1071,34 @@ describe("Session.pending", () => {
       })
       const second = yield* session.prompt({ sessionID, text: "Second steer", resume: false })
 
-      expect(yield* session.pending(sessionID)).toMatchObject([
+      expect(yield* session.inbox(sessionID)).toMatchObject([
         { id: first.id, type: "user", delivery: "steer" },
         { id: queued.id, type: "synthetic", delivery: "queue" },
         { id: second.id, type: "user", delivery: "steer" },
       ])
 
-      expect(yield* SessionPending.promote(db, bus, sessionID, "input")).toBe(2)
-      expect(yield* session.pending(sessionID)).toMatchObject([{ id: queued.id, type: "synthetic" }])
+      expect(yield* SessionInbox.promote(db, bus, sessionID, "input")).toBe(2)
+      expect(yield* session.inbox(sessionID)).toMatchObject([{ id: queued.id, type: "synthetic" }])
 
-      expect(yield* SessionPending.promote(db, bus, sessionID, "input")).toBe(1)
-      expect(yield* session.pending(sessionID)).toEqual([])
+      expect(yield* SessionInbox.promote(db, bus, sessionID, "input")).toBe(1)
+      expect(yield* session.inbox(sessionID)).toEqual([])
     }),
   )
 
-  it.effect("lists an unhandled compaction barrier until it settles", () =>
+  it.effect("lists an unhandled compaction until it is cancelled", () =>
     Effect.gen(function* () {
       yield* setup
       const session = yield* Session.Service
       const { db } = yield* Database.Service
 
       const barrier = yield* session.compact({ sessionID })
-      expect(yield* SessionPending.has(db, sessionID, "any")).toBe(true)
-      expect(yield* SessionPending.has(db, sessionID, "input")).toBe(false)
-      expect(yield* session.pending(sessionID)).toMatchObject([{ id: barrier.id, type: "compaction" }])
+      expect(yield* SessionInbox.has(db, sessionID, "any")).toBe(true)
+      expect(yield* SessionInbox.has(db, sessionID, "input")).toBe(true)
+      expect(yield* session.inbox(sessionID)).toMatchObject([{ id: barrier.id, type: "compaction" }])
 
-      yield* SessionPending.settleCompaction(db, { sessionID })
-      expect(yield* SessionPending.has(db, sessionID, "any")).toBe(false)
-      expect(yield* session.pending(sessionID)).toEqual([])
+      yield* session.cancelInbox({ sessionID, inboxID: barrier.id })
+      expect(yield* SessionInbox.has(db, sessionID, "any")).toBe(false)
+      expect(yield* session.inbox(sessionID)).toEqual([])
     }),
   )
 
@@ -1119,16 +1115,16 @@ describe("Session.pending", () => {
         resume: false,
       })
 
-      yield* session.cancelPending({ sessionID, inputID })
+      yield* session.cancelInbox({ sessionID, inboxID: inputID })
 
-      expect(yield* session.pending(sessionID)).toEqual([])
-      expect(yield* eventCount(Bus.versionedType(SessionEvent.InputCancelled.type, 1))).toBe(1)
-      expect(yield* session.cancelPending({ sessionID, inputID }).pipe(Effect.flip)).toMatchObject({
-        _tag: "Session.PendingInputConflictError",
+      expect(yield* session.inbox(sessionID)).toEqual([])
+      expect(yield* eventCount(Bus.versionedType(SessionEvent.InboxCancelled.type, 1))).toBe(1)
+      expect(yield* session.cancelInbox({ sessionID, inboxID: inputID }).pipe(Effect.flip)).toMatchObject({
+        _tag: "Session.InboxConflictError",
         sessionID,
-        inputID,
+        inboxID: inputID,
       })
-      expect(yield* eventCount(Bus.versionedType(SessionEvent.InputCancelled.type, 1))).toBe(1)
+      expect(yield* eventCount(Bus.versionedType(SessionEvent.InboxCancelled.type, 1))).toBe(1)
 
       const retried = yield* session.prompt({
         id: inputID,
@@ -1154,33 +1150,33 @@ describe("Session.pending", () => {
       const alreadySteered = yield* session.prompt({ sessionID, text: "Already steer", resume: false })
       wakeCalls.length = 0
 
-      yield* session.steerPending({ sessionID, inputID: queued.id })
+      yield* session.steerInbox({ sessionID, inboxID: queued.id })
 
-      expect(yield* session.pending(sessionID)).toMatchObject([
+      expect(yield* session.inbox(sessionID)).toMatchObject([
         { id: queued.id, delivery: "steer" },
         { id: alreadySteered.id, delivery: "steer" },
       ])
       expect(wakeCalls).toEqual([sessionID])
-      expect(yield* eventCount(Bus.versionedType(SessionEvent.InputSteered.type, 1))).toBe(1)
+      expect(yield* eventCount(Bus.versionedType(SessionEvent.InboxDeliveryChanged.type, 1))).toBe(1)
 
       wakeCalls.length = 0
-      yield* session.queuePending({ sessionID, inputID: queued.id })
-      expect(yield* session.pending(sessionID)).toMatchObject([
+      yield* session.queueInbox({ sessionID, inboxID: queued.id })
+      expect(yield* session.inbox(sessionID)).toMatchObject([
         { id: queued.id, delivery: "queue" },
         { id: alreadySteered.id, delivery: "steer" },
       ])
       expect(wakeCalls).toEqual([])
-      expect(yield* eventCount(Bus.versionedType(SessionEvent.InputQueued.type, 1))).toBe(1)
+      expect(yield* eventCount(Bus.versionedType(SessionEvent.InboxDeliveryChanged.type, 1))).toBe(2)
 
-      expect(yield* session.steerPending({ sessionID, inputID: alreadySteered.id }).pipe(Effect.flip)).toMatchObject({
-        _tag: "Session.PendingInputConflictError",
+      expect(yield* session.steerInbox({ sessionID, inboxID: alreadySteered.id }).pipe(Effect.flip)).toMatchObject({
+        _tag: "Session.InboxConflictError",
         sessionID,
-        inputID: alreadySteered.id,
+        inboxID: alreadySteered.id,
       })
-      yield* session.cancelPending({ sessionID, inputID: alreadySteered.id })
+      yield* session.cancelInbox({ sessionID, inboxID: alreadySteered.id })
       expect(wakeCalls).toEqual([])
-      expect(yield* eventCount(Bus.versionedType(SessionEvent.InputSteered.type, 1))).toBe(1)
-      expect(yield* eventCount(Bus.versionedType(SessionEvent.InputCancelled.type, 1))).toBe(1)
+      expect(yield* eventCount(Bus.versionedType(SessionEvent.InboxDeliveryChanged.type, 1))).toBe(2)
+      expect(yield* eventCount(Bus.versionedType(SessionEvent.InboxCancelled.type, 1))).toBe(1)
     }),
   )
 })

packages/core/test/session-runner-recorded.test.ts

@@ -129,7 +129,7 @@ const execution = (llmClient: Layer.Layer<typeof LLMClient.Service>) =>
     Effect.gen(function* () {
       const sessionRunner = yield* SessionRunner.Service
       const coordinator = yield* SessionRunCoordinator.make<Session.ID, SessionRunner.RunError>({
-        drain: (sessionID, force) => sessionRunner.drain({ sessionID, force }),
+        drain: (sessionID, force) => sessionRunner.drain({ sessionID, force }).pipe(Effect.asVoid),
       })
       return SessionExecution.Service.of({
         active: coordinator.active,
@@ -243,9 +243,9 @@ describe("SessionRunnerLLM recorded", () => {
           .orderBy(EventTable.seq)
           .all()).map((event) => event.type),
       ).toEqual([
-        "session.input.admitted.1",
+        "session.inbox.enqueued.1",
         "session.instructions.updated.2",
-        "session.input.promoted.1",
+        "session.inbox.delivered.1",
         "session.step.started.1",
         "session.text.started.1",
         "session.text.ended.1",

packages/core/test/session-runner-tool-registry.test.ts

@@ -110,6 +110,28 @@ describe("Tool", () => {
     }),
   )
 
+  it.effect("rejects invalid tool definitions before installing any tools", () =>
+    Effect.gen(function* () {
+      const service = yield* Tool.Service
+      const error = yield* service
+        .transform((draft) => {
+          draft.add({ ...make(), name: "healthy", options: { codemode: false } })
+          draft.add({
+            name: "phone_type",
+            input: Schema.Struct({}),
+            execute: () => Effect.succeed({ content: "ok" }),
+            options: { codemode: false },
+          } as unknown as Info)
+        })
+        .pipe(Effect.flip)
+
+      expect(error).toBeInstanceOf(Tool.RegistrationError)
+      expect(error.name).toBe("phone_type")
+      expect(error.message).toContain('Expected string, got undefined\n  at ["description"]')
+      expect((yield* service.snapshot()).definitions.map((tool) => tool.name)).toEqual(["execute"])
+    }),
+  )
+
   it.effect("canonicalizes effective definitions and keeps Code Mode last", () =>
     Effect.gen(function* () {
       const service = yield* Tool.Service

packages/core/test/session-runner.test.ts

@@ -32,7 +32,7 @@ import { AbsolutePath } from "@opencode-ai/core/schema"
 import { Session } from "@opencode-ai/core/session"
 import { Snapshot } from "@opencode-ai/core/snapshot"
 import { SessionEvent } from "@opencode-ai/core/session/event"
-import { SessionPending } from "@opencode-ai/core/session/pending"
+import { SessionInbox } from "@opencode-ai/core/session/inbox"
 import { SessionMessage } from "@opencode-ai/core/session/message"
 import { Money } from "@opencode-ai/schema/money"
 import { SessionProjector } from "@opencode-ai/core/session/projector"
@@ -55,7 +55,7 @@ import { Tool } from "@opencode-ai/core/tool"
 import type { Info as ToolInfo } from "@opencode-ai/schema/tool"
 import {
   InstructionStateTable,
-  SessionPendingTable,
+  SessionInboxTable,
   SessionMessageTable,
   SessionTable,
 } from "@opencode-ai/core/session/sql"
@@ -72,7 +72,7 @@ import { Location } from "@opencode-ai/core/location"
 import { Provider } from "@opencode-ai/core/provider"
 import { Cause, DateTime, Deferred, Effect, Exit, Fiber, Layer, Schema, Scope, Stream } from "effect"
 import { TestClock } from "effect/testing"
-import { asc, eq } from "drizzle-orm"
+import { asc, desc, eq } from "drizzle-orm"
 import { testEffect } from "./lib/effect"
 import { agentHost, catalogHost, host } from "./plugin/host"
 import PROMPT_DEFAULT from "../src/session/runner/prompt/base.txt"
@@ -387,8 +387,21 @@ const execution = Layer.effect(
   SessionExecution.Service,
   Effect.gen(function* () {
     const sessionRunner = yield* SessionRunner.Service
+    function drain(
+      sessionID: Session.ID,
+      force: boolean,
+      continuation?: SessionRunner.Continuation,
+    ): Effect.Effect<void, SessionRunner.RunError> {
+      return sessionRunner
+        .drain({ sessionID, force, continuation })
+        .pipe(
+          Effect.flatMap((result) =>
+            result.type === "complete" ? Effect.void : drain(sessionID, false, result.continuation),
+          ),
+        )
+    }
     const coordinator = yield* SessionRunCoordinator.make<Session.ID, SessionRunner.RunError>({
-      drain: (sessionID, force) => sessionRunner.drain({ sessionID, force }),
+      drain: (sessionID, force) => drain(sessionID, force),
     })
     return SessionExecution.Service.of({
       active: coordinator.active,
@@ -629,7 +642,7 @@ const replaySessionProjection = (id: Session.ID) =>
 
     yield* bus.remove(id)
     yield* db.delete(InstructionStateTable).where(eq(InstructionStateTable.session_id, id)).run().pipe(Effect.orDie)
-    yield* db.delete(SessionPendingTable).where(eq(SessionPendingTable.session_id, id)).run().pipe(Effect.orDie)
+    yield* db.delete(SessionInboxTable).where(eq(SessionInboxTable.session_id, id)).run().pipe(Effect.orDie)
     yield* db.delete(SessionMessageTable).where(eq(SessionMessageTable.session_id, id)).run().pipe(Effect.orDie)
     yield* bus.replayAll(
       recorded.map((event) => ({
@@ -816,7 +829,7 @@ const verifyPartialFlushOnInterruption = (kind: FragmentKind) =>
   })
 
 describe("SessionRunnerLLM", () => {
-  it.effect("retries title generation from the first prompt after execution and title failures", () =>
+  it.effect("generates the title while the first model step is still running", () =>
     Effect.gen(function* () {
       const session = yield* setup
       const agents = yield* Agent.Service
@@ -831,16 +844,48 @@ describe("SessionRunnerLLM", () => {
       )
 
       yield* admit(session, "First prompt")
-      yield* TestLLM.push(Stream.fail(invalidRequest()))
+      yield* TestLLM.push(TestLLM.text("Generated title", "text-title"), Stream.never)
+      const bus = yield* Bus.Service
+      const renamed = yield* bus.subscribe(SessionEvent.Renamed).pipe(
+        Stream.filter((event) => event.data.sessionID === sessionID),
+        Stream.take(1),
+        Stream.runDrain,
+        Effect.forkScoped({ startImmediately: true }),
+      )
+      const runner = yield* SessionRunner.Service
+      const fiber = yield* runner.drain({ sessionID, force: true }).pipe(Effect.forkChild)
+      yield* Fiber.join(renamed)
+
+      expect((yield* session.get(sessionID)).title).toBe("Generated title")
+      yield* Fiber.interrupt(fiber)
+    }),
+  )
+
+  it.effect("retries title generation from the first prompt after title and execution failures", () =>
+    Effect.gen(function* () {
+      const session = yield* setup
+      const agents = yield* Agent.Service
+      const { db } = yield* Database.Service
+      yield* db.update(SessionTable).set({ title: null }).where(eq(SessionTable.id, sessionID)).run().pipe(Effect.orDie)
+      yield* agents.transform((draft) =>
+        draft.update(Agent.ID.make("title"), (agent) => {
+          agent.mode = "primary"
+          agent.hidden = true
+          agent.system = "Generate a title."
+        }),
+      )
+
+      yield* admit(session, "First prompt")
+      yield* TestLLM.push(Stream.fail(invalidRequest()), Stream.fail(invalidRequest()))
       expect((yield* session.resume(sessionID).pipe(Effect.exit))._tag).toBe("Failure")
 
       yield* admit(session, "Second prompt")
       const titleFailed = yield* Deferred.make<void>()
       yield* TestLLM.push(
-        TestLLM.text("Recovered", "text-recovered"),
         Stream.make(LLMEvent.providerError({ message: "Title provider unavailable" })).pipe(
           Stream.ensuring(Deferred.succeed(titleFailed, undefined)),
         ),
+        TestLLM.text("Recovered", "text-recovered"),
       )
       yield* session.resume(sessionID)
       yield* Deferred.await(titleFailed)
@@ -856,13 +901,13 @@ describe("SessionRunnerLLM", () => {
       )
       yield* admit(session, "Third prompt")
       yield* TestLLM.push(
-        TestLLM.text("Recovered again", "text-recovered-again"),
         TestLLM.text("Generated title", "text-title"),
+        TestLLM.text("Recovered again", "text-recovered-again"),
       )
       yield* session.resume(sessionID)
       yield* Fiber.join(renamed)
 
-      expect(requests).toHaveLength(5)
+      expect(requests).toHaveLength(6)
       expect(requests[2]?.messages).toContainEqual(Message.user("First prompt"))
       expect(requests[4]?.messages).toContainEqual(Message.user("First prompt"))
       expect((yield* session.get(sessionID)).title).toBe("Generated title")
@@ -1154,7 +1199,7 @@ describe("SessionRunnerLLM", () => {
       expect(Exit.isFailure(exit)).toBe(true)
       if (Exit.isFailure(exit)) expect(Cause.squash(exit.cause)).toBeInstanceOf(Instructions.InitializationBlocked)
       expect(requests).toHaveLength(0)
-      expect(yield* SessionPending.has(db, sessionID, "steer")).toBe(true)
+      expect(yield* SessionInbox.has(db, sessionID, "steer")).toBe(true)
       expect(
         yield* db.select().from(InstructionStateTable).where(eq(InstructionStateTable.session_id, sessionID)).get(),
       ).toBeUndefined()
@@ -1178,6 +1223,7 @@ describe("SessionRunnerLLM", () => {
       yield* bus.publish(SessionEvent.Moved, {
         sessionID,
         location: Location.Ref.make({ directory: AbsolutePath.make("/moved") }),
+        projectID: Project.ID.global,
       })
       expect(
         yield* db.select().from(InstructionStateTable).where(eq(InstructionStateTable.session_id, sessionID)).get(),
@@ -1188,7 +1234,78 @@ describe("SessionRunnerLLM", () => {
 
       expect(Exit.isFailure(exit) && Cause.hasInterruptsOnly(exit.cause)).toBe(true)
       expect(requests).toHaveLength(1)
-      expect(yield* SessionPending.has(db, sessionID, "steer")).toBe(true)
+      expect(yield* SessionInbox.has(db, sessionID, "steer")).toBe(true)
+    }),
+  )
+
+  it.effect("delivers a queued move atomically at the idle boundary", () =>
+    Effect.gen(function* () {
+      const session = yield* setup
+      const bus = yield* Bus.Service
+      const { db } = yield* Database.Service
+      const inboxID = SessionMessage.ID.create()
+      yield* SessionInbox.admit(db, bus, {
+        id: inboxID,
+        sessionID,
+        item: {
+          type: "move",
+          payload: {
+            location: Location.Ref.make({ directory: AbsolutePath.make("/moved") }),
+            projectID: Project.ID.global,
+          },
+          delivery: "queue",
+        },
+      })
+
+      yield* session.resume(sessionID)
+
+      expect((yield* session.get(sessionID)).location.directory).toBe(AbsolutePath.make("/moved"))
+      expect(yield* session.inbox(sessionID)).toEqual([])
+      expect(requests).toEqual([])
+      expect(
+        (yield* db
+          .select({ type: EventTable.type })
+          .from(EventTable)
+          .where(eq(EventTable.aggregate_id, sessionID))
+          .orderBy(desc(EventTable.seq))
+          .limit(2)
+          .all()).map((event) => event.type),
+      ).toEqual([Bus.versionedType(SessionEvent.Moved.type, 1), Bus.versionedType(SessionEvent.InboxDelivered.type, 1)])
+    }),
+  )
+
+  it.effect("preserves a tool continuation across a steered move", () =>
+    Effect.gen(function* () {
+      const session = yield* setup
+      const bus = yield* Bus.Service
+      const { db } = yield* Database.Service
+      yield* admit(session, "Echo before moving")
+      yield* TestLLM.push(
+        TestLLM.tool("call-move", "echo", { text: "moving" }),
+        TestLLM.text("Done", "text-after-move"),
+      )
+      const tools = yield* blockTools()
+      const run = yield* session.resume(sessionID).pipe(Effect.forkChild)
+      yield* tools.started
+      yield* SessionInbox.admit(db, bus, {
+        id: SessionMessage.ID.create(),
+        sessionID,
+        item: {
+          type: "move",
+          payload: {
+            location: Location.Ref.make({ directory: AbsolutePath.make("/project") }),
+            projectID: Project.ID.global,
+          },
+          delivery: "steer",
+        },
+      })
+
+      yield* tools.release
+      yield* Fiber.join(run)
+
+      expect(requests).toHaveLength(2)
+      expect(requests.map(messageRoles).at(1)?.slice(0, 3)).toEqual(["user", "assistant", "tool"])
+      expect(yield* session.inbox(sessionID)).toEqual([])
     }),
   )
 
@@ -1793,15 +1910,15 @@ describe("SessionRunnerLLM", () => {
     }),
   )
 
-  it.effect("runs one durable compaction barrier after tool settlement and before later inputs", () =>
+  it.effect("runs steers before queued compaction and later queued input", () =>
     Effect.gen(function* () {
       const session = yield* setup
       currentModel = recoveryModel
       const stream = yield* TestLLM.gate
       yield* TestLLM.push(
         TestLLM.tool("call-active", "echo", { text: "active" }),
-        [LLMEvent.textDelta({ id: "summary", text: "durable summary" })],
         TestLLM.text("Steer complete", "text-steer"),
+        [LLMEvent.textDelta({ id: "summary", text: "durable summary" })],
         TestLLM.text("Queue complete", "text-queue"),
       )
       yield* admit(session, "Active work")
@@ -1809,9 +1926,7 @@ describe("SessionRunnerLLM", () => {
       yield* stream.started
 
       const first = yield* session.compact({ sessionID })
-      const second = yield* session.compact({ sessionID })
-      expect(second.id).toBe(first.id)
-      expect(yield* SessionPending.compaction((yield* Database.Service).db, sessionID)).toMatchObject({
+      expect(yield* SessionInbox.find((yield* Database.Service).db, first.id)).toMatchObject({
         id: first.id,
       })
       expect((yield* session.messages({ sessionID })).find((message) => message.id === first.id)).toBeUndefined()
@@ -1824,17 +1939,17 @@ describe("SessionRunnerLLM", () => {
         delivery: "queue",
         resume: false,
       })
-      expect(yield* SessionPending.has((yield* Database.Service).db, sessionID, "steer")).toBe(false)
+      expect(yield* SessionInbox.has((yield* Database.Service).db, sessionID, "steer")).toBe(true)
 
       yield* stream.release
       yield* Fiber.join(active)
 
       expect(requests).toHaveLength(4)
-      expect(userTexts(requests[1])[0]).toContain("Create a new anchored summary")
-      expect(userTexts(requests[2])).toContain("Steer after compaction")
-      expect(userTexts(requests[2])).toContain("Completion after compaction")
+      expect(userTexts(requests[1])).toContain("Steer after compaction")
+      expect(userTexts(requests[1])).toContain("Completion after compaction")
+      expect(userTexts(requests[2])[0]).toContain("Create a new anchored summary")
       expect(userTexts(requests[3])).toContain("Queue after compaction")
-      expect(yield* SessionPending.compaction((yield* Database.Service).db, sessionID)).toBeUndefined()
+      expect(yield* SessionInbox.find((yield* Database.Service).db, first.id)).toBeUndefined()
       expect((yield* session.messages({ sessionID })).find((message) => message.id === first.id)).toMatchObject({
         type: "compaction",
         status: "completed",
@@ -1869,7 +1984,7 @@ describe("SessionRunnerLLM", () => {
 
       expect(requests).toHaveLength(3)
       expect(userTexts(requests[2])).toContain("Continue after failure")
-      expect(yield* SessionPending.compaction((yield* Database.Service).db, sessionID)).toBeUndefined()
+      expect(yield* SessionInbox.find((yield* Database.Service).db, compaction.id)).toBeUndefined()
       expect((yield* session.messages({ sessionID })).find((message) => message.id === compaction.id)).toMatchObject({
         type: "compaction",
         status: "failed",
@@ -1891,7 +2006,7 @@ describe("SessionRunnerLLM", () => {
 
       yield* session.resume(sessionID)
 
-      expect(yield* SessionPending.compaction((yield* Database.Service).db, sessionID)).toBeUndefined()
+      expect(yield* SessionInbox.find((yield* Database.Service).db, compaction.id)).toBeUndefined()
       expect((yield* session.messages({ sessionID })).find((message) => message.id === compaction.id)).toMatchObject({
         type: "compaction",
         status: "failed",
@@ -1906,7 +2021,7 @@ describe("SessionRunnerLLM", () => {
     }),
   )
 
-  it.effect("manually compacts when the model has no context limit", () =>
+  it.effect("delivers steered manual compaction when the model has no context limit", () =>
     Effect.gen(function* () {
       const session = yield* setup
       yield* TestLLM.push(TestLLM.text("Earlier answer", "text-manual-unknown-history"))
@@ -1914,7 +2029,7 @@ describe("SessionRunnerLLM", () => {
 
       requests.length = 0
       yield* TestLLM.push(TestLLM.text("Manual summary", "text-manual-unknown-summary"))
-      const compaction = yield* session.compact({ sessionID })
+      const compaction = yield* session.compact({ sessionID, delivery: "steer" })
       yield* session.resume(sessionID)
 
       expect(requests).toHaveLength(1)
@@ -1983,7 +2098,7 @@ describe("SessionRunnerLLM", () => {
       yield* session.interrupt(sessionID)
 
       yield* Fiber.await(run)
-      expect(yield* SessionPending.compaction((yield* Database.Service).db, sessionID)).toBeUndefined()
+      expect(yield* SessionInbox.find((yield* Database.Service).db, compaction.id)).toBeUndefined()
       expect((yield* session.messages({ sessionID })).find((message) => message.id === compaction.id)).toMatchObject({
         type: "compaction",
         status: "failed",
@@ -2004,7 +2119,7 @@ describe("SessionRunnerLLM", () => {
 
       expect(yield* Effect.exit(session.resume(sessionID))).toMatchObject({ _tag: "Failure" })
 
-      expect(yield* SessionPending.compaction((yield* Database.Service).db, sessionID)).toBeUndefined()
+      expect(yield* SessionInbox.find((yield* Database.Service).db, compaction.id)).toBeUndefined()
       expect((yield* session.messages({ sessionID })).find((message) => message.id === compaction.id)).toMatchObject({
         type: "compaction",
         status: "failed",
@@ -2832,7 +2947,7 @@ describe("SessionRunnerLLM", () => {
       yield* session.interrupt(sessionID)
       expect(yield* Fiber.await(run)).toMatchObject({ _tag: "Failure" })
       expect(requests).toHaveLength(1)
-      expect(yield* SessionPending.has(db, sessionID, "queue")).toBe(true)
+      expect(yield* SessionInbox.has(db, sessionID, "queue")).toBe(true)
       const resumed = yield* session.resume(sessionID).pipe(Effect.forkChild)
       yield* stream.started
       yield* stream.release
@@ -2862,7 +2977,7 @@ describe("SessionRunnerLLM", () => {
       yield* session.interrupt(sessionID)
       expect(yield* Fiber.await(run)).toMatchObject({ _tag: "Failure" })
       expect(requests).toHaveLength(1)
-      expect(yield* SessionPending.has(db, sessionID, "steer")).toBe(true)
+      expect(yield* SessionInbox.has(db, sessionID, "steer")).toBe(true)
 
       const resumed = yield* session.resume(sessionID).pipe(Effect.forkChild)
       yield* stream.started
@@ -3015,7 +3130,7 @@ describe("SessionRunnerLLM", () => {
       const session = yield* setup
       const bus = yield* Bus.Service
       yield* admit(session, "Recover interrupted tool")
-      yield* SessionPending.promote((yield* Database.Service).db, bus, sessionID, "steer")
+      yield* SessionInbox.promote((yield* Database.Service).db, bus, sessionID, "steer")
       const assistantMessageID = SessionMessage.ID.create()
       yield* bus.publish(SessionEvent.Step.Started, {
         sessionID,
@@ -3072,7 +3187,7 @@ describe("SessionRunnerLLM", () => {
       const session = yield* setup
       const bus = yield* Bus.Service
       yield* admit(session, "Recover interrupted hosted tool")
-      yield* SessionPending.promote((yield* Database.Service).db, bus, sessionID, "steer")
+      yield* SessionInbox.promote((yield* Database.Service).db, bus, sessionID, "steer")
       const assistantMessageID = SessionMessage.ID.create()
       yield* bus.publish(SessionEvent.Step.Started, {
         sessionID,
@@ -3123,7 +3238,7 @@ describe("SessionRunnerLLM", () => {
       const session = yield* setup
       const bus = yield* Bus.Service
       yield* admit(session, "Recover interrupted tool input")
-      yield* SessionPending.promote((yield* Database.Service).db, bus, sessionID, "steer")
+      yield* SessionInbox.promote((yield* Database.Service).db, bus, sessionID, "steer")
       const assistantMessageID = SessionMessage.ID.create()
       yield* bus.publish(SessionEvent.Step.Started, {
         sessionID,
@@ -3176,7 +3291,7 @@ describe("SessionRunnerLLM", () => {
       const bus = yield* Bus.Service
       const defect = new Error("fail after prompt promotion")
       let fail = true
-      yield* bus.project(SessionEvent.InputPromoted, () => (fail ? Effect.die(defect) : Effect.void))
+      yield* bus.project(SessionEvent.InboxDelivered, () => (fail ? Effect.die(defect) : Effect.void))
       yield* admit(session, "Recover promoted input")
 
       expect(yield* session.resume(sessionID).pipe(Effect.catchDefect(Effect.succeed))).toBe(defect)
@@ -3198,7 +3313,7 @@ describe("SessionRunnerLLM", () => {
       const session = yield* setup
       const bus = yield* Bus.Service
       yield* bus.listen((event) =>
-        event.type === SessionEvent.InputPromoted.type
+        event.type === SessionEvent.InboxDelivered.type
           ? Effect.die("fail after prompt promotion commits")
           : Effect.void,
       )

packages/core/test/session-skill.test.ts

@@ -15,7 +15,7 @@ import { SessionExecution } from "@opencode-ai/core/session/execution"
 import { SessionMessage } from "@opencode-ai/core/session/message"
 import { SessionProjector } from "@opencode-ai/core/session/projector"
 import { SessionStore } from "@opencode-ai/core/session/store"
-import { SessionPending } from "@opencode-ai/core/session/pending"
+import { SessionInbox } from "@opencode-ai/core/session/inbox"
 import { Skill } from "@opencode-ai/core/skill"
 import { testEffect } from "./lib/effect"
 
@@ -71,7 +71,7 @@ describe("Session.skill", () => {
         skills: [{ id: Skill.ID.make("effect"), mention: { start: 20, end: 27, text: "/effect" } }],
         resume: false,
       })
-      yield* SessionPending.promote(database.db, bus, session.id, "steer")
+      yield* SessionInbox.promote(database.db, bus, session.id, "steer")
 
       expect(yield* sessions.messages({ sessionID: session.id })).toContainEqual(
         expect.objectContaining({

packages/core/test/session-title.test.ts

@@ -114,14 +114,14 @@ const prompt = (sessionID: Session.ID, text: string) =>
   Effect.gen(function* () {
     const bus = yield* Bus.Service
     const messageID = SessionMessage.ID.create()
-    yield* bus.publish(SessionEvent.InputAdmitted, {
+    yield* bus.publish(SessionEvent.InboxEnqueued, {
       sessionID,
-      inputID: messageID,
-      input: { type: "user", data: { text }, delivery: "steer" },
+      inboxID: messageID,
+      item: { type: "user", payload: { text }, delivery: "steer" },
     })
-    yield* bus.publish(SessionEvent.InputPromoted, {
+    yield* bus.publish(SessionEvent.InboxDelivered, {
       sessionID,
-      inputID: messageID,
+      inboxID: messageID,
     })
   })
 

packages/core/test/shared-schema.test.ts

@@ -9,7 +9,7 @@ import { Project } from "@opencode-ai/schema/project"
 import { ProjectDirectories } from "@opencode-ai/schema/project-directories"
 import { PermissionV1 } from "@opencode-ai/schema/permission-v1"
 import { Prompt } from "@opencode-ai/schema/prompt"
-import { SessionPending } from "@opencode-ai/schema/session-pending"
+import { SessionInbox } from "@opencode-ai/schema/session-inbox"
 import { SessionMessage } from "@opencode-ai/schema/session-message"
 import { Workspace } from "@opencode-ai/schema/workspace"
 import { Command } from "@opencode-ai/schema/command"
@@ -44,7 +44,7 @@ test("Core reuses the canonical shared schemas", async () => {
     coreProject,
     coreProvider,
     coreReference,
-    coreSessionPending,
+    coreSessionInbox,
     coreSessionMessage,
     coreSkill,
     coreSchema,
@@ -65,7 +65,7 @@ test("Core reuses the canonical shared schemas", async () => {
     import("@opencode-ai/core/project/schema"),
     import("@opencode-ai/core/provider"),
     import("@opencode-ai/core/reference"),
-    import("@opencode-ai/core/session/pending"),
+    import("@opencode-ai/core/session/inbox"),
     import("@opencode-ai/core/session/message"),
     import("@opencode-ai/core/skill"),
     import("@opencode-ai/core/schema"),
@@ -126,10 +126,10 @@ test("Core reuses the canonical shared schemas", async () => {
     [Session.ID, schemaSession.Session.ID],
     [Session.Info, schemaSession.Session.Info],
     [Session.ListAnchor, schemaSession.Session.ListAnchor],
-    [coreSessionPending.Delivery, SessionPending.Delivery],
-    [coreSessionPending.Message, SessionPending.Message],
-    [coreSessionPending.User, SessionPending.User],
-    [coreSessionPending.Synthetic, SessionPending.Synthetic],
+    [coreSessionInbox.Delivery, SessionInbox.Delivery],
+    [coreSessionInbox.Item, SessionInbox.Item],
+    [coreSessionInbox.User, SessionInbox.User],
+    [coreSessionInbox.Synthetic, SessionInbox.Synthetic],
     [coreSessionMessage.ID, SessionMessage.ID],
     [coreSessionMessage.AssistantRetry, SessionMessage.AssistantRetry],
     [coreSessionMessage.AgentSelected, SessionMessage.AgentSelected],

packages/core/test/snapshot.test.ts

@@ -143,44 +143,47 @@ describe("Snapshot", () => {
     ),
   )
 
-  testEffect(Layer.empty).live("isolates snapshot indexes by canonical Git worktree", () =>
-    Effect.acquireUseRelease(
-      Effect.promise(() => tmpdir()),
-      (tmp) =>
-        Effect.gen(function* () {
-          const project = path.join(tmp.path, "project")
-          const linked = path.join(tmp.path, "linked")
-          yield* Effect.promise(async () => {
-            await fs.mkdir(project)
-            await fs.writeFile(path.join(project, "tracked.txt"), "main\n")
-            await initGit(project, true)
-            await $`git -c core.fsmonitor=false worktree add --detach ${linked} HEAD`.cwd(project).quiet()
-          })
+  testEffect(Layer.empty).live(
+    "isolates snapshot indexes by canonical Git worktree",
+    () =>
+      Effect.acquireUseRelease(
+        Effect.promise(() => tmpdir()),
+        (tmp) =>
+          Effect.gen(function* () {
+            const project = path.join(tmp.path, "project")
+            const linked = path.join(tmp.path, "linked")
+            yield* Effect.promise(async () => {
+              await fs.mkdir(project)
+              await fs.writeFile(path.join(project, "tracked.txt"), "main\n")
+              await initGit(project, true)
+              await $`git -c core.fsmonitor=false worktree add --detach ${linked} HEAD`.cwd(project).quiet()
+            })
 
-          const capture = (directory: string) =>
-            Effect.gen(function* () {
-              const snapshot = yield* Snapshot.Service
-              return yield* snapshot.capture()
-            }).pipe(Effect.provide(snapshotLayer(tmp.path, directory)))
-          expect(yield* capture(project)).toBeDefined()
-          expect(yield* capture(linked)).toBeDefined()
+            const capture = (directory: string) =>
+              Effect.gen(function* () {
+                const snapshot = yield* Snapshot.Service
+                return yield* snapshot.capture()
+              }).pipe(Effect.provide(snapshotLayer(tmp.path, directory)))
+            expect(yield* capture(project)).toBeDefined()
+            expect(yield* capture(linked)).toBeDefined()
 
-          const projectID = yield* Effect.gen(function* () {
-            return (yield* Location.Service).project.id
-          }).pipe(
-            Effect.provide(
-              AppNodeBuilder.build(Location.boundNode(Location.Ref.make({ directory: AbsolutePath.make(project) }))),
-            ),
-          )
-          expect(
-            yield* Effect.promise(() => fs.stat(path.join(tmp.path, "snapshot", projectID, Hash.fast(project)))),
-          ).toBeDefined()
-          expect(
-            yield* Effect.promise(() => fs.stat(path.join(tmp.path, "snapshot", projectID, Hash.fast(linked)))),
-          ).toBeDefined()
-        }),
-      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
-    ),
+            const projectID = yield* Effect.gen(function* () {
+              return (yield* Location.Service).project.id
+            }).pipe(
+              Effect.provide(
+                AppNodeBuilder.build(Location.boundNode(Location.Ref.make({ directory: AbsolutePath.make(project) }))),
+              ),
+            )
+            expect(
+              yield* Effect.promise(() => fs.stat(path.join(tmp.path, "snapshot", projectID, Hash.fast(project)))),
+            ).toBeDefined()
+            expect(
+              yield* Effect.promise(() => fs.stat(path.join(tmp.path, "snapshot", projectID, Hash.fast(linked)))),
+            ).toBeDefined()
+          }),
+        (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
+      ),
+    { timeout: 15_000 },
   )
 })
 

packages/core/test/sqlite-workerd.test.ts

@@ -1,63 +1,19 @@
 import { describe, expect, test } from "bun:test"
-import { Database } from "bun:sqlite"
 import { Effect, Layer } from "effect"
 import { SqlClient } from "effect/unstable/sql"
 import { SqlError } from "effect/unstable/sql/SqlError"
 import { sqliteLayer } from "@opencode-ai/core/database/sqlite.workerd"
 import type { DurableObjectStorage } from "@opencode-ai/core/database/sqlite.workerd"
+import { makeDurableObjectStorage } from "./fixture/durable-object-storage"
 import { tempGlobalLayer } from "./fixture/global"
 
-// Emulates the Durable Object storage API over bun:sqlite so the adapter can
-// be verified without workerd or Cloudflare runtime dependencies.
-const makeFakeStorage = () => {
-  const native = new Database(":memory:")
-  const toSqlStorageValue = (value: unknown) => {
-    if (!(value instanceof Uint8Array)) return value as ArrayBuffer | string | number | null
-    const buffer = new ArrayBuffer(value.byteLength)
-    new Uint8Array(buffer).set(value)
-    return buffer
-  }
-  const storage: DurableObjectStorage = {
-    sql: {
-      exec(query: string, ...bindings: Array<unknown>) {
-        const statement = native.query(query)
-        const rows = (statement.values(...(bindings as never[])) ?? []).map((row) => row.map(toSqlStorageValue))
-        const columnNames = statement.columnNames
-        return {
-          columnNames,
-          raw: () => rows[Symbol.iterator](),
-          toArray: () => rows.map((row) => Object.fromEntries(columnNames.map((name, i) => [name, row[i]]))),
-        }
-      },
-    },
-    transaction<T>(closure: (txn: { rollback(): void }) => Promise<T>): Promise<T> {
-      native.run("BEGIN")
-      let rolledBack = false
-      return closure({ rollback: () => (rolledBack = true) }).then(
-        (result) => {
-          native.run(rolledBack ? "ROLLBACK" : "COMMIT")
-          return result
-        },
-        (error) => {
-          native.run("ROLLBACK")
-          throw error
-        },
-      )
-    },
-    transactionSync<T>(closure: () => T): T {
-      return native.transaction(closure)()
-    },
-  }
-  return storage
-}
-
 const run = <A, E>(storage: DurableObjectStorage, effect: Effect.Effect<A, E, SqlClient.SqlClient>) =>
   Effect.runPromise(effect.pipe(Effect.provide(sqliteLayer({ storage })), Effect.scoped))
 
 describe("sqlite.workerd", () => {
   test("executes statements with bindings and maps rows to records", async () => {
     const rows = await run(
-      makeFakeStorage(),
+      makeDurableObjectStorage(),
       Effect.gen(function* () {
         const sql = yield* SqlClient.SqlClient
         yield* sql`CREATE TABLE item (id INTEGER PRIMARY KEY, name TEXT NOT NULL)`
@@ -73,7 +29,7 @@ describe("sqlite.workerd", () => {
 
   test("normalizes ArrayBuffer blob values to Uint8Array", async () => {
     const rows = await run(
-      makeFakeStorage(),
+      makeDurableObjectStorage(),
       Effect.gen(function* () {
         const sql = yield* SqlClient.SqlClient
         yield* sql`CREATE TABLE blob (data BLOB NOT NULL)`
@@ -86,7 +42,7 @@ describe("sqlite.workerd", () => {
   })
 
   test("withTransaction commits on success and rolls back on failure", async () => {
-    const storage = makeFakeStorage()
+    const storage = makeDurableObjectStorage()
     const count = await run(
       storage,
       Effect.gen(function* () {
@@ -109,7 +65,7 @@ describe("sqlite.workerd", () => {
 
   test("nested withTransaction fails with SqlError", async () => {
     const error = await run(
-      makeFakeStorage(),
+      makeDurableObjectStorage(),
       Effect.gen(function* () {
         const sql = yield* SqlClient.SqlClient
         yield* sql`CREATE TABLE t (value TEXT NOT NULL)`
@@ -122,7 +78,7 @@ describe("sqlite.workerd", () => {
   })
 
   test("boots the full database layer with migrations over injected storage", async () => {
-    const storage = makeFakeStorage()
+    const storage = makeDurableObjectStorage()
     const core = await import("@opencode-ai/core/database/database")
     await Effect.runPromise(
       Effect.scoped(