deps: update OpenTUI to 0.4.2

2026-08-03 16:56:33 -04:00 · 2026-06-26 01:54:11 +00:00
56 changed files with 758 additions and 1131 deletions
@@ -174,7 +174,6 @@ _Avoid_: Response envelope
 - `sessions.messages(...)` returns a **Page** and uses the same cursor discipline as `sessions.list(...)`: the initial request supplies `sessionID`, ordering, and page size; continuation supplies `sessionID` plus only an opaque branded message cursor carrying ordering, page size, direction, and message anchor. Using a cursor with another Session is invalid.
 - `sessions.message({ sessionID, messageID })` is a required resource lookup. An unknown Session fails with `SessionNotFoundError`; a known Session with an absent or differently owned message fails with `MessageNotFoundError` without disclosing cross-Session ownership. Absence is not represented as `undefined` across the public HTTP boundary.
 - `sessions.interrupt({ sessionID })` first verifies that the durable Session exists, failing with `SessionNotFoundError` otherwise. For a known Session, interruption is idempotent: idle, already-settled, or locally unowned execution is a no-op.
- `sessions.active()` snapshots the current process's foreground Session drain registry as a record of Session IDs to `{ type: "running" }`. Missing IDs are inactive; background subagents and tasks do not make their parent Session active, and process restart clears the registry.
 - `sessions.context({ sessionID })` preserves the existing message-only operation. It returns projected conversational messages selected as Session context; it does not include or represent the complete provider request context, whose baseline system context and other contributions remain separate.
 - **Open question**: Should a future, separately named operation expose the complete provider request context, including baseline system context, selected source contributions, and context-epoch metadata?
 - `sessions.prompt(...)` exposes `resume?: boolean`. Omitting it preserves durable admission followed by an advisory execution wake; `resume: false` requests durable admit-only behavior.
@@ -682,9 +682,9 @@
        "typescript": "catalog:",
      },
      "peerDependencies": {
-        "@opentui/core": ">=0.3.4",
-        "@opentui/keymap": ">=0.3.4",
-        "@opentui/solid": ">=0.3.4",
+        "@opentui/core": ">=0.4.2",
+        "@opentui/keymap": ">=0.4.2",
+        "@opentui/solid": ">=0.4.2",
      },
      "optionalPeers": [
        "@opentui/core",
@@ -1072,9 +1072,9 @@
    "@npmcli/arborist": "9.4.0",
    "@octokit/rest": "22.0.0",
    "@openauthjs/openauth": "0.0.0-20250322224806",
-    "@opentui/core": "0.3.4",
-    "@opentui/keymap": "0.3.4",
-    "@opentui/solid": "0.3.4",
+    "@opentui/core": "0.4.2",
+    "@opentui/keymap": "0.4.2",
+    "@opentui/solid": "0.4.2",
    "@pierre/diffs": "1.2.10",
    "@playwright/test": "1.59.1",
    "@sentry/solid": "10.36.0",
@@ -1991,27 +1991,27 @@

    "@opentelemetry/semantic-conventions": ["@opentelemetry/semantic-conventions@1.41.1", "", {}, "sha512-/UhIkaZgPutTFmQ7RnIJGgDXZmtEJ7Dvi86xNTFWcnRxVRNk/aotsqDJYeEvDP+FSMB2SdW+pQzNMcWP0rwuNA=="],

-    "@opentui/core": ["@opentui/core@0.3.4", "", { "dependencies": { "bun-ffi-structs": "0.2.2", "diff": "9.0.0", "marked": "17.0.1", "string-width": "7.2.0", "strip-ansi": "7.1.2", "yoga-layout": "3.2.1" }, "optionalDependencies": { "@opentui/core-darwin-arm64": "0.3.4", "@opentui/core-darwin-x64": "0.3.4", "@opentui/core-linux-arm64": "0.3.4", "@opentui/core-linux-arm64-musl": "0.3.4", "@opentui/core-linux-x64": "0.3.4", "@opentui/core-linux-x64-musl": "0.3.4", "@opentui/core-win32-arm64": "0.3.4", "@opentui/core-win32-x64": "0.3.4" }, "peerDependencies": { "web-tree-sitter": "0.25.10" } }, "sha512-y0DlrChP9lcJ4jC5z/1wMS34+ygfSTW7gD5OJHwJaAScfmlFvuJOZbwmCGrJURZ+5wFBxuOi9LatZsmeAUIKAA=="],
+    "@opentui/core": ["@opentui/core@0.4.2", "", { "dependencies": { "bun-ffi-structs": "0.2.3", "diff": "9.0.0", "marked": "17.0.1", "string-width": "7.2.0", "strip-ansi": "7.1.2" }, "optionalDependencies": { "@opentui/core-darwin-arm64": "0.4.2", "@opentui/core-darwin-x64": "0.4.2", "@opentui/core-linux-arm64": "0.4.2", "@opentui/core-linux-arm64-musl": "0.4.2", "@opentui/core-linux-x64": "0.4.2", "@opentui/core-linux-x64-musl": "0.4.2", "@opentui/core-win32-arm64": "0.4.2", "@opentui/core-win32-x64": "0.4.2" }, "peerDependencies": { "web-tree-sitter": "0.25.10" } }, "sha512-ulx6RMqftf2fm7Itf9e81GcCDMNY6NAhmnKYhllDOMYD+PxYXR+vomy2bxQNV5ow31RE7s8WQFnb7hWTRUbx2g=="],

-    "@opentui/core-darwin-arm64": ["@opentui/core-darwin-arm64@0.3.4", "", { "os": "darwin", "cpu": "arm64" }, "sha512-4A7JYXUsZqhu9PPCe07E30ourSJYkitkwMujUyNKjM5e/dHNDVnz+5r5cO3M5snofLafc1DN7+9jEPn4UQzchQ=="],
+    "@opentui/core-darwin-arm64": ["@opentui/core-darwin-arm64@0.4.2", "", { "os": "darwin", "cpu": "arm64" }, "sha512-is+O+sS/l3E9cZXyM9pRF1WhqnE+hYSPYoZkbseR9CthJcaWPGi3R3jUJa1cLj325252jWgxVupnDqFUtKg36w=="],

-    "@opentui/core-darwin-x64": ["@opentui/core-darwin-x64@0.3.4", "", { "os": "darwin", "cpu": "x64" }, "sha512-Jvm9E8n2sPhKEyKSXn9GlmJcj8WoJXJTooXb3djwjVaiimjihIj0XxHzCWhdqbDtQp+VxDFyCKoQagOOz20qhA=="],
+    "@opentui/core-darwin-x64": ["@opentui/core-darwin-x64@0.4.2", "", { "os": "darwin", "cpu": "x64" }, "sha512-ACi42h81DurSeybUAD1XyKT6xmXZcKeTxS54lZFi0CVZh46w0g99vNj8PlQzIFXvvFLT0e0IlRS//eWSWS2zGQ=="],

-    "@opentui/core-linux-arm64": ["@opentui/core-linux-arm64@0.3.4", "", { "os": "linux", "cpu": "arm64" }, "sha512-0uPuHCeZxm/O7+L+iNQl8zRAfehiwYstKkT9J0uTZO64/byBCLvy5lvn1DiE/72s/nTJ5nwpLN+pQs2/WYVKLQ=="],
+    "@opentui/core-linux-arm64": ["@opentui/core-linux-arm64@0.4.2", "", { "os": "linux", "cpu": "arm64" }, "sha512-RjOx2HcjLRtGSy9WrAGSdr5M9SpJuPifPORpImx6Mciovw0ltnE0uoYjIyor82uf6/LExWC7YA2AcAl+YBxayA=="],

-    "@opentui/core-linux-arm64-musl": ["@opentui/core-linux-arm64-musl@0.3.4", "", { "os": "linux", "cpu": "arm64" }, "sha512-sJYUzYcSOb5PCXRlhwsse/fdsMiVomNvIwq/2TDhAANef+YPO3Br+OH9kQRbuj0bjVDmUS36SGYWSTFu2lUO+A=="],
+    "@opentui/core-linux-arm64-musl": ["@opentui/core-linux-arm64-musl@0.4.2", "", { "os": "linux", "cpu": "arm64" }, "sha512-heNciL2ngPU+kq1h01PHLsxn6Fr8iqTFtbxSdVbhaY3XihuIjkuXyEhFeuoa1lsXY7Bb2gpWnX5EQVWnZsAuDQ=="],

-    "@opentui/core-linux-x64": ["@opentui/core-linux-x64@0.3.4", "", { "os": "linux", "cpu": "x64" }, "sha512-btYIQeNdPbN4JCrCjVB/RwMGrnRY7qWB2piNEfALSByuULKNjPKQ33PYIj38Yd01zCvCV7FotIeXEGSHx3tgCA=="],
+    "@opentui/core-linux-x64": ["@opentui/core-linux-x64@0.4.2", "", { "os": "linux", "cpu": "x64" }, "sha512-9s0s/ooK+AhWP306By3gu+XhzcVEThC2sqKMPK1nQmGDujQhd+xOrtbtfCVcJSx62UzAovC2VNqypvP8vHByOg=="],

-    "@opentui/core-linux-x64-musl": ["@opentui/core-linux-x64-musl@0.3.4", "", { "os": "linux", "cpu": "x64" }, "sha512-fhmUey4oJJ2+N62xlIgAPxAl36Fa7wYffqDOT4QLpm0jfyD5xzo+wL/hr2zUqaEI439R8Iq6jHNxf/Nsx1WuuQ=="],
+    "@opentui/core-linux-x64-musl": ["@opentui/core-linux-x64-musl@0.4.2", "", { "os": "linux", "cpu": "x64" }, "sha512-Cjv6Bv7l3p/KLNJr5RyqCS0FmRlAGJnkA2IK3S+HkHhCOv/O02S1G+DBUY6POnyjp1eNy95vauustApobhdbig=="],

-    "@opentui/core-win32-arm64": ["@opentui/core-win32-arm64@0.3.4", "", { "os": "win32", "cpu": "arm64" }, "sha512-sh432vPU+eLp8eA4I0KWKKn7D0VHbk01YTg6mA9/ihCNYHntc6LZ8/sLvsPv8CvKscMotfIkh3M5YhdS36BuXw=="],
+    "@opentui/core-win32-arm64": ["@opentui/core-win32-arm64@0.4.2", "", { "os": "win32", "cpu": "arm64" }, "sha512-mfJZrJ0TNPFRZUzXNsxAPe1YdiWsy/vbTl93+yeXGHPI1B8Qnk9V5hpzSxxEyBGhlTHSfGNtgiO+VrrdRC3kZA=="],

-    "@opentui/core-win32-x64": ["@opentui/core-win32-x64@0.3.4", "", { "os": "win32", "cpu": "x64" }, "sha512-dw8FcjUZaLAjw25P3/7BarobCh/QOHn3srYaWYQdysoqyvSlPkQumpI8kV/KgpJtdITU1GW02MQC4EeLIFFalA=="],
+    "@opentui/core-win32-x64": ["@opentui/core-win32-x64@0.4.2", "", { "os": "win32", "cpu": "x64" }, "sha512-P2oguG3ng3OMjAdasFSA3GhHaQXtzDUsIRDGbzWFOimpZ/zMemidp+JQ0V8V6XwK6Utk5G0aQ03oBaRCoLyYDw=="],

-    "@opentui/keymap": ["@opentui/keymap@0.3.4", "", { "dependencies": { "@opentui/core": "0.3.4" }, "peerDependencies": { "@opentui/react": "0.3.4", "@opentui/solid": "0.3.4", "react": ">=19.2.0", "solid-js": "1.9.12" }, "optionalPeers": ["@opentui/react", "@opentui/solid", "react", "solid-js"] }, "sha512-8fo6BZWQgCjANfbKkzPo0ghAzS1E7TlHjDDS+SUhrX01qEUO1clFTRssKluHbXd2UJY1Ehle01TV5bFmY78f8w=="],
+    "@opentui/keymap": ["@opentui/keymap@0.4.2", "", { "dependencies": { "@opentui/core": "0.4.2" }, "peerDependencies": { "@opentui/react": "0.4.2", "@opentui/solid": "0.4.2", "react": ">=19.2.0", "solid-js": "1.9.12" }, "optionalPeers": ["@opentui/react", "@opentui/solid", "react", "solid-js"] }, "sha512-wxBEFfWgm3feqCRLckWg1JH4tbMJinpyK3yobkLTsWJ7PDsM+fPoFMyQ8ieKVdUL2eP6ELTmHvM1bHKShZ7SUQ=="],

-    "@opentui/solid": ["@opentui/solid@0.3.4", "", { "dependencies": { "@babel/core": "7.28.0", "@babel/preset-typescript": "7.27.1", "@opentui/core": "0.3.4", "babel-plugin-module-resolver": "5.0.2", "babel-preset-solid": "1.9.12", "entities": "7.0.1", "s-js": "^0.4.9" }, "peerDependencies": { "solid-js": "1.9.12" } }, "sha512-gin1VnsVBahX0nrU3mpgh5U1qvyJBIZu4NE5mc0YnObWOEf9HVNxKY4/BpUvQPh91kT6zeOzTBvAvYK4R7g9MQ=="],
+    "@opentui/solid": ["@opentui/solid@0.4.2", "", { "dependencies": { "@babel/core": "7.28.0", "@babel/preset-typescript": "7.27.1", "@opentui/core": "0.4.2", "babel-plugin-module-resolver": "5.0.2", "babel-preset-solid": "1.9.12", "entities": "7.0.1", "s-js": "^0.4.9" }, "peerDependencies": { "solid-js": "1.9.12" } }, "sha512-zuYXsnrlsMtnXrS7QCYBdPzMtUSonG2LqnJikBR2NjEE2O4zEKvJd48n3eB1igcxjv96tiotTXRNCylYS0SNdQ=="],

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

@@ -3189,7 +3189,7 @@

    "builder-util-runtime": ["builder-util-runtime@9.7.0", "", { "dependencies": { "debug": "^4.3.4", "sax": "^1.2.4" } }, "sha512-g/kR520giAFYkSXTzcmF3kqQq7wi8F6N6SzeDgZrqTBN+VHdmgWOyTdD1yD7AATDId/yXLvuP34CxW46/BwCdw=="],

-    "bun-ffi-structs": ["bun-ffi-structs@0.2.2", "", { "peerDependencies": { "typescript": "^5" } }, "sha512-N/ZWtyN0piZlrXQT7TO0V+q952orYqkfhXRXM1Hcbb+R3QSiBH4vLnib187Mrs1H7pWIYECAmPeapGYDOMCl+w=="],
+    "bun-ffi-structs": ["bun-ffi-structs@0.2.3", "", { "peerDependencies": { "typescript": "^5" } }, "sha512-pgJiXP+hEgFo9qG51J6ItfY4ocs3vniwNzJ9WhoakB3QB2GdzQxX2EXssentPYlB2hOfJrTjO6iIQkWYzUodpg=="],

    "bun-pty": ["bun-pty@0.4.8", "", {}, "sha512-rO70Mrbr13+jxHHHu2YBkk2pNqrJE5cJn29WE++PUr+GFA0hq/VgtQPZANJ8dJo6d7XImvBk37Innt8GM7O28w=="],

@@ -5547,8 +5547,6 @@

    "yoctocolors": ["yoctocolors@2.1.2", "", {}, "sha512-CzhO+pFNo8ajLM2d2IW/R93ipy99LWjtwblvC1RsoSUMZgyLbYFr221TnSNT7GjGdYui6P459mw9JH/g/zW2ug=="],

-    "yoga-layout": ["yoga-layout@3.2.1", "", {}, "sha512-0LPOt3AxKqMdFBZA3HBAt/t/8vIKq7VaQYbuA8WxCgung+p9TVyKRYdpvCb80HcdTN2NkbIKbhNwKUfm3tQywQ=="],
-
    "youch": ["youch@4.1.0-beta.10", "", { "dependencies": { "@poppinss/colors": "^4.1.5", "@poppinss/dumper": "^0.6.4", "@speed-highlight/core": "^1.2.7", "cookie": "^1.0.2", "youch-core": "^0.3.3" } }, "sha512-rLfVLB4FgQneDr0dv1oddCVZmKjcJ6yX6mS4pU82Mq/Dt9a3cLZQ62pDBL4AUO+uVrCvtWz3ZFUL2HFAFJ/BXQ=="],

    "youch-core": ["youch-core@0.3.3", "", { "dependencies": { "@poppinss/exception": "^1.2.2", "error-stack-parser-es": "^1.0.5" } }, "sha512-ho7XuGjLaJ2hWHoK8yFnsUGy2Y5uDpqSTq1FkHLK4/oqKtyUU1AFbOOxY4IpC9f0fTLjwYbslUz0Po5BpD1wrA=="],
@@ -39,9 +39,9 @@
      "@octokit/rest": "22.0.0",
      "@hono/standard-validator": "0.2.0",
      "@hono/zod-validator": "0.4.2",
-      "@opentui/core": "0.3.4",
-      "@opentui/keymap": "0.3.4",
-      "@opentui/solid": "0.3.4",
+      "@opentui/core": "0.4.2",
+      "@opentui/keymap": "0.4.2",
+      "@opentui/solid": "0.4.2",
      "@tanstack/solid-virtual": "3.13.28",
      "@shikijs/stream": "4.2.0",
      "ulid": "3.0.1",
@@ -1,79 +0,0 @@
-import { expect, test } from "@playwright/test"
-import { mockOpenCodeServer } from "../utils/mock-server"
-import { expectSessionTitle } from "../utils/waits"
-
-const directory = "C:/OpenCode/HiddenTerminalRegression"
-const projectID = "proj_hidden_terminal_regression"
-const sessionID = "ses_hidden_terminal_regression"
-const title = "Hidden terminal regression"
-
-test("unmounts the terminal renderer while the pane is hidden", async ({ page }) => {
-  await page.setViewportSize({ width: 1400, height: 900 })
-  await mockOpenCodeServer(page, {
-    directory,
-    project: {
-      id: projectID,
-      worktree: directory,
-      vcs: "git",
-      name: "hidden-terminal-regression",
-      time: { created: 1700000000000, updated: 1700000000000 },
-      sandboxes: [],
-    },
-    provider: {
-      all: [
-        {
-          id: "opencode",
-          name: "OpenCode",
-          models: { test: { id: "test", name: "Test", limit: { context: 200_000 } } },
-        },
-      ],
-      connected: ["opencode"],
-      default: { providerID: "opencode", modelID: "test" },
-    },
-    sessions: [
-      {
-        id: sessionID,
-        slug: "hidden-terminal-regression",
-        projectID,
-        directory,
-        title,
-        version: "dev",
-        time: { created: 1700000000000, updated: 1700000000000 },
-      },
-    ],
-    pageMessages: () => ({ items: [] }),
-  })
-  await page.route("**/pty", (route) =>
-    route.fulfill({
-      status: 200,
-      contentType: "application/json",
-      body: JSON.stringify({ id: "pty_hidden_terminal", title: "Terminal 1" }),
-    }),
-  )
-  await page.route("**/pty/pty_hidden_terminal", (route) =>
-    route.fulfill({ status: 200, contentType: "application/json", body: "{}" }),
-  )
-  await page.routeWebSocket("**/pty/pty_hidden_terminal/connect", () => undefined)
-
-  await page.goto(`/${base64Encode(directory)}/session/${sessionID}`)
-  await expectSessionTitle(page, title)
-
-  await page.keyboard.press("Control+Backquote")
-  const panel = page.locator("#terminal-panel")
-  await expect(panel).toHaveAttribute("aria-hidden", "false")
-  await expect(page.locator('[data-component="terminal"]')).toBeVisible()
-
-  await page.keyboard.press("Control+Backquote")
-  await expect(panel).toHaveAttribute("aria-hidden", "true")
-  await expect(page.locator('[data-component="terminal"]')).toHaveCount(0)
-
-  await page.setViewportSize({ width: 1200, height: 700 })
-  await expect(page.locator('[data-component="terminal"]')).toHaveCount(0)
-
-  await page.keyboard.press("Control+Backquote")
-  await expect(page.locator('[data-component="terminal"]')).toBeVisible()
-})
-
-function base64Encode(value: string) {
-  return Buffer.from(value, "utf8").toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "")
-}
@@ -1,43 +0,0 @@
-import { useParams } from "@solidjs/router"
-import { onCleanup } from "solid-js"
-import { useCommand } from "@/context/command"
-import { useLanguage } from "@/context/language"
-import { useDialog } from "@opencode-ai/ui/context/dialog"
-
-export function useSettingsDialog() {
-  const dialog = useDialog()
-  const params = useParams<{ id?: string }>()
-  let run = 0
-  let dead = false
-
-  onCleanup(() => {
-    dead = true
-  })
-
-  return () => {
-    const current = ++run
-    const sessionID = params.id
-    void import("@/components/settings-v2").then((module) => {
-      if (dead || run !== current) return
-      void dialog.show(() => <module.DialogSettings sessionID={sessionID} />)
-    })
-  }
-}
-
-export function useSettingsCommand() {
-  const command = useCommand()
-  const language = useLanguage()
-  const show = useSettingsDialog()
-
-  command.register("settings", () => [
-    {
-      id: "settings.open",
-      title: language.t("command.settings.open"),
-      category: language.t("command.category.settings"),
-      keybind: "mod+comma",
-      onSelect: show,
-    },
-  ])
-
-  return show
-}
@@ -11,9 +11,7 @@ import { SettingsModelsV2 } from "./models"
 import "./settings-v2.css"
 import { SettingsServersV2 } from "./servers"

-export const DialogSettings: Component<{
-  sessionID?: string
-}> = (props) => {
+export const DialogSettings: Component = () => {
  const language = useLanguage()
  const platform = usePlatform()

@@ -64,7 +62,7 @@ export const DialogSettings: Component<{
          </div>
        </TabsV2.List>
        <TabsV2.Content value="general" class="settings-v2-panel">
-          <SettingsGeneralV2 sessionID={props.sessionID} />
+          <SettingsGeneralV2 />
        </TabsV2.Content>
        <TabsV2.Content value="shortcuts" class="settings-v2-panel">
          <SettingsKeybinds v2 />
@@ -6,6 +6,7 @@ import { Switch } from "@opencode-ai/ui/v2/switch-v2"
 import { TextInputV2 } from "@opencode-ai/ui/v2/text-input-v2"
 import { useTheme, type ColorScheme } from "@opencode-ai/ui/theme/context"
 import { useDialog } from "@opencode-ai/ui/context/dialog"
+import { useParams } from "@solidjs/router"
 import { useLanguage } from "@/context/language"
 import { usePermission } from "@/context/permission"
 import { usePlatform } from "@/context/platform"
@@ -24,6 +25,7 @@ import {
  terminalInput,
  useSettings,
 } from "@/context/settings"
+import { decode64 } from "@/utils/base64"
 import { playSoundById, SOUND_OPTIONS } from "@/utils/sound"
 import { Link } from "../link"
 import { SettingsListV2 } from "./parts/list"
@@ -80,46 +82,50 @@ const playDemoSound = (id: string | undefined) => {
  }, 100)
 }

-export const SettingsGeneralV2: Component<{
-  sessionID?: string
-}> = (props) => {
+export const SettingsGeneralV2: Component = () => {
  const theme = useTheme()
  const language = useLanguage()
  const permission = usePermission()
  const platform = usePlatform()
  const dialog = useDialog()
+  const params = useParams()
  const settings = useSettings()
-  const serverSync = useServerSync()
-  const serverSdk = useServerSDK()
  const mobile = createMediaQuery("(max-width: 767px)")

  const updater = useUpdaterAction()

-  const dir = createMemo(() => {
-    if (!props.sessionID) return undefined
-    return serverSync().session.lineage.peek(props.sessionID)?.session.directory
-  })
+  const dir = createMemo(() => decode64(params.dir))
  const accepting = createMemo(() => {
    const value = dir()
-    if (!value || !props.sessionID) return false
-    return permission.isAutoAccepting(props.sessionID, value)
+    if (!value) return false
+    if (!params.id) return permission.isAutoAcceptingDirectory(value)
+    return permission.isAutoAccepting(params.id, value)
  })

  const toggleAccept = (checked: boolean) => {
    const value = dir()
-    if (!value || !props.sessionID) return
+    if (!value) return

-    if (checked) {
-      permission.enableAutoAccept(props.sessionID, value)
+    if (!params.id) {
+      if (permission.isAutoAcceptingDirectory(value) === checked) return
+      permission.toggleAutoAcceptDirectory(value)
      return
    }

-    permission.disableAutoAccept(props.sessionID, value)
+    if (checked) {
+      permission.enableAutoAccept(params.id, value)
+      return
+    }
+
+    permission.disableAutoAccept(params.id, value)
  }
  const desktop = createMemo(() => platform.platform === "desktop")

  const themeOptions = createMemo<ThemeOption[]>(() => theme.ids().map((id) => ({ id, name: theme.name(id) })))

+  const serverSync = useServerSync()
+  const serverSdk = useServerSDK()
+
  const [shells] = createResource(
    () =>
      serverSdk()
@@ -33,7 +33,6 @@ import { usePlatform } from "@/context/platform"
 import { DateTime } from "luxon"
 import { useDialog } from "@opencode-ai/ui/context/dialog"
 import { useDirectoryPicker } from "@/components/directory-picker"
-import { useSettingsCommand } from "@/components/settings-dialog"
 import { DialogSelectServer, useServerManagementController } from "@/components/dialog-select-server"
 import { DialogServerV2 } from "@/components/settings-v2/dialog-server-v2"
 import { ServerConnection, serverName, useServer } from "@/context/server"
@@ -145,7 +144,6 @@ export function NewHome() {
  const command = useCommand()
  const notification = useNotification()
  const marked = useMarked()
-  const openSettings = useSettingsCommand()
  let focusSessionSearch: (() => void) | undefined
  const [state, setState] = createStore({
    search: "",
@@ -404,6 +402,12 @@ export function NewHome() {
    })
  }

+  function openSettings() {
+    void import("@/components/settings-v2").then((x) => {
+      dialog.show(() => <x.DialogSettings />)
+    })
+  }
+
  return (
    <div class="rounded-[10px] shadow-[var(--v2-elevation-raised)] m-2 min-h-0 lg:overflow-hidden bg-v2-background-bg-base self-stretch flex-1">
      <div class="mx-auto grid h-full w-full max-w-[1080px] grid-rows-[auto_minmax(0,1fr)_auto] gap-4 px-3 pb-3 lg:grid-cols-[280px_minmax(0,720px)] lg:grid-rows-1 lg:gap-8 lg:px-6 lg:pb-16">
@@ -3,12 +3,18 @@ import { useNavigate, useParams } from "@solidjs/router"
 import { DebugBar } from "@/components/debug-bar"
 import { HelpButton } from "@/components/help-button"
 import { Titlebar, type TitlebarUpdate } from "@/components/titlebar"
+import { useCommand } from "@/context/command"
+import { useDialog } from "@opencode-ai/ui/context/dialog"
+import { useLanguage } from "@/context/language"
 import { useNotification } from "@/context/notification"
 import { usePlatform } from "@/context/platform"
 import { setNavigate } from "@/utils/notification-click"
 import { setV2Toast, ToastRegion } from "@/utils/toast"

 export default function NewLayout(props: ParentProps) {
+  const command = useCommand()
+  const dialog = useDialog()
+  const language = useLanguage()
  const platform = usePlatform()
  const notification = useNotification()
  const navigate = useNavigate()
@@ -22,6 +28,20 @@ export default function NewLayout(props: ParentProps) {
    notification.session.markViewed(params.id)
  })

+  command.register("layout", () => [
+    {
+      id: "settings.open",
+      title: language.t("command.settings.open"),
+      category: language.t("command.category.settings"),
+      keybind: "mod+comma",
+      onSelect: () => {
+        void import("@/components/settings-v2").then((x) => {
+          dialog.show(() => <x.DialogSettings />)
+        })
+      },
+    },
+  ])
+
  const update: TitlebarUpdate = {
    version: () => {
      const state = platform.updater?.state()
@@ -3,7 +3,6 @@ import { createStore } from "solid-js/store"
 import { useSearchParams } from "@solidjs/router"
 import { NewSessionDesignView } from "@/components/session"
 import { PromptInput } from "@/components/prompt-input"
-import { useSettingsCommand } from "@/components/settings-dialog"
 import {
  PromptProjectAddButton,
  PromptProjectSelector,
@@ -36,7 +35,6 @@ export default function NewSessionPage() {
  const [searchParams, setSearchParams] = useSearchParams<{ draftId?: string; prompt?: string }>()

  useComposerCommands()
-  useSettingsCommand()

  let inputRef: HTMLDivElement | undefined

@@ -43,7 +43,6 @@ import { useSettings } from "@/context/settings"
 import { useSync } from "@/context/sync"
 import { useTerminal } from "@/context/terminal"
 import { PromptInput } from "@/components/prompt-input"
-import { useSettingsCommand } from "@/components/settings-dialog"
 import { type FollowupDraft, sendFollowupDraft } from "@/components/prompt-input/submit"
 import {
  createPromptInputController,
@@ -788,7 +787,6 @@ export default function Page() {
  }

  useComposerCommands()
-  useSettingsCommand()
  useSessionCommands({
    navigateMessageByOffset,
    setActiveMessage,
@@ -293,7 +293,7 @@ export function TerminalPanel() {
                </Tabs.List>
              </Tabs>
              <div class="flex-1 min-h-0 relative">
-                <Show when={opened() && terminal.active()} keyed>
+                <Show when={terminal.active()} keyed>
                  {(id) => {
                    const ops = terminal.bind()
                    return (
@@ -55,49 +55,43 @@ const Endpoint0_1 = (raw: RawClient["server.session"]) => (input?: Endpoint0_1In
    Effect.map((value) => value.data),
  )

-const Endpoint0_2 = (raw: RawClient["server.session"]) => () =>
-  raw["session.active"]({}).pipe(
-    Effect.mapError(mapClientError),
-    Effect.map((value) => value.data),
-  )
-
-type Endpoint0_3Request = Parameters<RawClient["server.session"]["session.get"]>[0]
-type Endpoint0_3Input = { readonly sessionID: Endpoint0_3Request["params"]["sessionID"] }
-const Endpoint0_3 = (raw: RawClient["server.session"]) => (input: Endpoint0_3Input) =>
+type Endpoint0_2Request = Parameters<RawClient["server.session"]["session.get"]>[0]
+type Endpoint0_2Input = { readonly sessionID: Endpoint0_2Request["params"]["sessionID"] }
+const Endpoint0_2 = (raw: RawClient["server.session"]) => (input: Endpoint0_2Input) =>
  raw["session.get"]({ params: { sessionID: input.sessionID } }).pipe(
    Effect.mapError(mapClientError),
    Effect.map((value) => value.data),
  )

-type Endpoint0_4Request = Parameters<RawClient["server.session"]["session.switchAgent"]>[0]
-type Endpoint0_4Input = {
-  readonly sessionID: Endpoint0_4Request["params"]["sessionID"]
-  readonly agent: Endpoint0_4Request["payload"]["agent"]
+type Endpoint0_3Request = Parameters<RawClient["server.session"]["session.switchAgent"]>[0]
+type Endpoint0_3Input = {
+  readonly sessionID: Endpoint0_3Request["params"]["sessionID"]
+  readonly agent: Endpoint0_3Request["payload"]["agent"]
 }
-const Endpoint0_4 = (raw: RawClient["server.session"]) => (input: Endpoint0_4Input) =>
+const Endpoint0_3 = (raw: RawClient["server.session"]) => (input: Endpoint0_3Input) =>
  raw["session.switchAgent"]({ params: { sessionID: input.sessionID }, payload: { agent: input.agent } }).pipe(
    Effect.mapError(mapClientError),
  )

-type Endpoint0_5Request = Parameters<RawClient["server.session"]["session.switchModel"]>[0]
-type Endpoint0_5Input = {
-  readonly sessionID: Endpoint0_5Request["params"]["sessionID"]
-  readonly model: Endpoint0_5Request["payload"]["model"]
+type Endpoint0_4Request = Parameters<RawClient["server.session"]["session.switchModel"]>[0]
+type Endpoint0_4Input = {
+  readonly sessionID: Endpoint0_4Request["params"]["sessionID"]
+  readonly model: Endpoint0_4Request["payload"]["model"]
 }
-const Endpoint0_5 = (raw: RawClient["server.session"]) => (input: Endpoint0_5Input) =>
+const Endpoint0_4 = (raw: RawClient["server.session"]) => (input: Endpoint0_4Input) =>
  raw["session.switchModel"]({ params: { sessionID: input.sessionID }, payload: { model: input.model } }).pipe(
    Effect.mapError(mapClientError),
  )

-type Endpoint0_6Request = Parameters<RawClient["server.session"]["session.prompt"]>[0]
-type Endpoint0_6Input = {
-  readonly sessionID: Endpoint0_6Request["params"]["sessionID"]
-  readonly id?: Endpoint0_6Request["payload"]["id"]
-  readonly prompt: Endpoint0_6Request["payload"]["prompt"]
-  readonly delivery?: Endpoint0_6Request["payload"]["delivery"]
-  readonly resume?: Endpoint0_6Request["payload"]["resume"]
+type Endpoint0_5Request = Parameters<RawClient["server.session"]["session.prompt"]>[0]
+type Endpoint0_5Input = {
+  readonly sessionID: Endpoint0_5Request["params"]["sessionID"]
+  readonly id?: Endpoint0_5Request["payload"]["id"]
+  readonly prompt: Endpoint0_5Request["payload"]["prompt"]
+  readonly delivery?: Endpoint0_5Request["payload"]["delivery"]
+  readonly resume?: Endpoint0_5Request["payload"]["resume"]
 }
-const Endpoint0_6 = (raw: RawClient["server.session"]) => (input: Endpoint0_6Input) =>
+const Endpoint0_5 = (raw: RawClient["server.session"]) => (input: Endpoint0_5Input) =>
  raw["session.prompt"]({
    params: { sessionID: input.sessionID },
    payload: { id: input.id, prompt: input.prompt, delivery: input.delivery, resume: input.resume },
@@ -106,23 +100,23 @@ const Endpoint0_6 = (raw: RawClient["server.session"]) => (input: Endpoint0_6Inp
    Effect.map((value) => value.data),
  )

-type Endpoint0_7Request = Parameters<RawClient["server.session"]["session.compact"]>[0]
-type Endpoint0_7Input = { readonly sessionID: Endpoint0_7Request["params"]["sessionID"] }
-const Endpoint0_7 = (raw: RawClient["server.session"]) => (input: Endpoint0_7Input) =>
+type Endpoint0_6Request = Parameters<RawClient["server.session"]["session.compact"]>[0]
+type Endpoint0_6Input = { readonly sessionID: Endpoint0_6Request["params"]["sessionID"] }
+const Endpoint0_6 = (raw: RawClient["server.session"]) => (input: Endpoint0_6Input) =>
  raw["session.compact"]({ params: { sessionID: input.sessionID } }).pipe(Effect.mapError(mapClientError))

-type Endpoint0_8Request = Parameters<RawClient["server.session"]["session.wait"]>[0]
-type Endpoint0_8Input = { readonly sessionID: Endpoint0_8Request["params"]["sessionID"] }
-const Endpoint0_8 = (raw: RawClient["server.session"]) => (input: Endpoint0_8Input) =>
+type Endpoint0_7Request = Parameters<RawClient["server.session"]["session.wait"]>[0]
+type Endpoint0_7Input = { readonly sessionID: Endpoint0_7Request["params"]["sessionID"] }
+const Endpoint0_7 = (raw: RawClient["server.session"]) => (input: Endpoint0_7Input) =>
  raw["session.wait"]({ params: { sessionID: input.sessionID } }).pipe(Effect.mapError(mapClientError))

-type Endpoint0_9Request = Parameters<RawClient["server.session"]["session.revert.stage"]>[0]
-type Endpoint0_9Input = {
-  readonly sessionID: Endpoint0_9Request["params"]["sessionID"]
-  readonly messageID: Endpoint0_9Request["payload"]["messageID"]
-  readonly files?: Endpoint0_9Request["payload"]["files"]
+type Endpoint0_8Request = Parameters<RawClient["server.session"]["session.revert.stage"]>[0]
+type Endpoint0_8Input = {
+  readonly sessionID: Endpoint0_8Request["params"]["sessionID"]
+  readonly messageID: Endpoint0_8Request["payload"]["messageID"]
+  readonly files?: Endpoint0_8Request["payload"]["files"]
 }
-const Endpoint0_9 = (raw: RawClient["server.session"]) => (input: Endpoint0_9Input) =>
+const Endpoint0_8 = (raw: RawClient["server.session"]) => (input: Endpoint0_8Input) =>
  raw["session.revert.stage"]({
    params: { sessionID: input.sessionID },
    payload: { messageID: input.messageID, files: input.files },
@@ -131,30 +125,30 @@ const Endpoint0_9 = (raw: RawClient["server.session"]) => (input: Endpoint0_9Inp
    Effect.map((value) => value.data),
  )

-type Endpoint0_10Request = Parameters<RawClient["server.session"]["session.revert.clear"]>[0]
-type Endpoint0_10Input = { readonly sessionID: Endpoint0_10Request["params"]["sessionID"] }
-const Endpoint0_10 = (raw: RawClient["server.session"]) => (input: Endpoint0_10Input) =>
+type Endpoint0_9Request = Parameters<RawClient["server.session"]["session.revert.clear"]>[0]
+type Endpoint0_9Input = { readonly sessionID: Endpoint0_9Request["params"]["sessionID"] }
+const Endpoint0_9 = (raw: RawClient["server.session"]) => (input: Endpoint0_9Input) =>
  raw["session.revert.clear"]({ params: { sessionID: input.sessionID } }).pipe(Effect.mapError(mapClientError))

-type Endpoint0_11Request = Parameters<RawClient["server.session"]["session.revert.commit"]>[0]
-type Endpoint0_11Input = { readonly sessionID: Endpoint0_11Request["params"]["sessionID"] }
-const Endpoint0_11 = (raw: RawClient["server.session"]) => (input: Endpoint0_11Input) =>
+type Endpoint0_10Request = Parameters<RawClient["server.session"]["session.revert.commit"]>[0]
+type Endpoint0_10Input = { readonly sessionID: Endpoint0_10Request["params"]["sessionID"] }
+const Endpoint0_10 = (raw: RawClient["server.session"]) => (input: Endpoint0_10Input) =>
  raw["session.revert.commit"]({ params: { sessionID: input.sessionID } }).pipe(Effect.mapError(mapClientError))

-type Endpoint0_12Request = Parameters<RawClient["server.session"]["session.context"]>[0]
-type Endpoint0_12Input = { readonly sessionID: Endpoint0_12Request["params"]["sessionID"] }
-const Endpoint0_12 = (raw: RawClient["server.session"]) => (input: Endpoint0_12Input) =>
+type Endpoint0_11Request = Parameters<RawClient["server.session"]["session.context"]>[0]
+type Endpoint0_11Input = { readonly sessionID: Endpoint0_11Request["params"]["sessionID"] }
+const Endpoint0_11 = (raw: RawClient["server.session"]) => (input: Endpoint0_11Input) =>
  raw["session.context"]({ params: { sessionID: input.sessionID } }).pipe(
    Effect.mapError(mapClientError),
    Effect.map((value) => value.data),
  )

-type Endpoint0_13Request = Parameters<RawClient["server.session"]["session.events"]>[0]
-type Endpoint0_13Input = {
-  readonly sessionID: Endpoint0_13Request["params"]["sessionID"]
-  readonly after?: Endpoint0_13Request["query"]["after"]
+type Endpoint0_12Request = Parameters<RawClient["server.session"]["session.events"]>[0]
+type Endpoint0_12Input = {
+  readonly sessionID: Endpoint0_12Request["params"]["sessionID"]
+  readonly after?: Endpoint0_12Request["query"]["after"]
 }
-const Endpoint0_13 = (raw: RawClient["server.session"]) => (input: Endpoint0_13Input) =>
+const Endpoint0_12 = (raw: RawClient["server.session"]) => (input: Endpoint0_12Input) =>
  Stream.unwrap(
    raw["session.events"]({ params: { sessionID: input.sessionID }, query: { after: input.after } }).pipe(
      Effect.mapError(mapClientError),
@@ -162,17 +156,17 @@ const Endpoint0_13 = (raw: RawClient["server.session"]) => (input: Endpoint0_13I
    ),
  )

-type Endpoint0_14Request = Parameters<RawClient["server.session"]["session.interrupt"]>[0]
-type Endpoint0_14Input = { readonly sessionID: Endpoint0_14Request["params"]["sessionID"] }
-const Endpoint0_14 = (raw: RawClient["server.session"]) => (input: Endpoint0_14Input) =>
+type Endpoint0_13Request = Parameters<RawClient["server.session"]["session.interrupt"]>[0]
+type Endpoint0_13Input = { readonly sessionID: Endpoint0_13Request["params"]["sessionID"] }
+const Endpoint0_13 = (raw: RawClient["server.session"]) => (input: Endpoint0_13Input) =>
  raw["session.interrupt"]({ params: { sessionID: input.sessionID } }).pipe(Effect.mapError(mapClientError))

-type Endpoint0_15Request = Parameters<RawClient["server.session"]["session.message"]>[0]
-type Endpoint0_15Input = {
-  readonly sessionID: Endpoint0_15Request["params"]["sessionID"]
-  readonly messageID: Endpoint0_15Request["params"]["messageID"]
+type Endpoint0_14Request = Parameters<RawClient["server.session"]["session.message"]>[0]
+type Endpoint0_14Input = {
+  readonly sessionID: Endpoint0_14Request["params"]["sessionID"]
+  readonly messageID: Endpoint0_14Request["params"]["messageID"]
 }
-const Endpoint0_15 = (raw: RawClient["server.session"]) => (input: Endpoint0_15Input) =>
+const Endpoint0_14 = (raw: RawClient["server.session"]) => (input: Endpoint0_14Input) =>
  raw["session.message"]({ params: { sessionID: input.sessionID, messageID: input.messageID } }).pipe(
    Effect.mapError(mapClientError),
    Effect.map((value) => value.data),
@@ -181,20 +175,19 @@ const Endpoint0_15 = (raw: RawClient["server.session"]) => (input: Endpoint0_15I
 const adaptGroup0 = (raw: RawClient["server.session"]) => ({
  list: Endpoint0_0(raw),
  create: Endpoint0_1(raw),
-  active: Endpoint0_2(raw),
-  get: Endpoint0_3(raw),
-  switchAgent: Endpoint0_4(raw),
-  switchModel: Endpoint0_5(raw),
-  prompt: Endpoint0_6(raw),
-  compact: Endpoint0_7(raw),
-  wait: Endpoint0_8(raw),
-  stage: Endpoint0_9(raw),
-  clear: Endpoint0_10(raw),
-  commit: Endpoint0_11(raw),
-  context: Endpoint0_12(raw),
-  events: Endpoint0_13(raw),
-  interrupt: Endpoint0_14(raw),
-  message: Endpoint0_15(raw),
+  get: Endpoint0_2(raw),
+  switchAgent: Endpoint0_3(raw),
+  switchModel: Endpoint0_4(raw),
+  prompt: Endpoint0_5(raw),
+  compact: Endpoint0_6(raw),
+  wait: Endpoint0_7(raw),
+  stage: Endpoint0_8(raw),
+  clear: Endpoint0_9(raw),
+  commit: Endpoint0_10(raw),
+  context: Endpoint0_11(raw),
+  events: Endpoint0_12(raw),
+  interrupt: Endpoint0_13(raw),
+  message: Endpoint0_14(raw),
 })

 const adaptClient = (raw: RawClient) => ({ sessions: adaptGroup0(raw["server.session"]) })
@@ -3,7 +3,6 @@ import type {
  SessionsListOutput,
  SessionsCreateInput,
  SessionsCreateOutput,
-  SessionsActiveOutput,
  SessionsGetInput,
  SessionsGetOutput,
  SessionsSwitchAgentInput,
@@ -199,17 +198,6 @@ export function make(options: ClientOptions) {
          },
          requestOptions,
        ).then((value) => value.data),
-      active: (requestOptions?: RequestOptions) =>
-        request<{ readonly data: SessionsActiveOutput }>(
-          {
-            method: "GET",
-            path: `/api/session/active`,
-            successStatus: 200,
-            declaredStatuses: [401, 400],
-            empty: false,
-          },
-          requestOptions,
-        ).then((value) => value.data),
      get: (input: SessionsGetInput, requestOptions?: RequestOptions) =>
        request<{ readonly data: SessionsGetOutput }>(
          {
@@ -243,8 +243,6 @@ export type SessionsCreateOutput = {
  }
 }["data"]

-export type SessionsActiveOutput = { readonly data: { readonly [x: string]: { readonly type: "running" } } }["data"]
-
 export type SessionsGetInput = { readonly sessionID: { readonly sessionID: string }["sessionID"] }

 export type SessionsGetOutput = {
@@ -581,26 +579,7 @@ export type SessionsContextOutput = {
          readonly reasoning: number
          readonly cache: { readonly read: number; readonly write: number }
        }
-        readonly error?:
-          | { readonly type: "unknown"; readonly message: string }
-          | {
-              readonly type: "provider"
-              readonly category:
-                | "invalid-request"
-                | "no-route"
-                | "authentication"
-                | "rate-limit"
-                | "quota-exceeded"
-                | "content-policy"
-                | "provider-internal"
-                | "transport"
-                | "invalid-provider-output"
-                | "unknown"
-              readonly message: string
-              readonly status?: number | null
-              readonly retryable: boolean
-              readonly retryAfterMs?: number | null
-            }
+        readonly error?: { readonly type: "unknown"; readonly message: string }
      }
    | {
        readonly type: "compaction"
@@ -813,26 +792,7 @@ export type SessionsEventsOutput =
        readonly timestamp: number
        readonly sessionID: string
        readonly assistantMessageID: string
-        readonly error:
-          | { readonly type: "unknown"; readonly message: string }
-          | {
-              readonly type: "provider"
-              readonly category:
-                | "invalid-request"
-                | "no-route"
-                | "authentication"
-                | "rate-limit"
-                | "quota-exceeded"
-                | "content-policy"
-                | "provider-internal"
-                | "transport"
-                | "invalid-provider-output"
-                | "unknown"
-              readonly message: string
-              readonly status?: number | undefined
-              readonly retryable: boolean
-              readonly retryAfterMs?: number | undefined
-            }
+        readonly error: { readonly type: "unknown"; readonly message: string }
      }
    }
  | {
@@ -1236,26 +1196,7 @@ export type SessionsMessageOutput = {
          readonly reasoning: number
          readonly cache: { readonly read: number; readonly write: number }
        }
-        readonly error?:
-          | { readonly type: "unknown"; readonly message: string }
-          | {
-              readonly type: "provider"
-              readonly category:
-                | "invalid-request"
-                | "no-route"
-                | "authentication"
-                | "rate-limit"
-                | "quota-exceeded"
-                | "content-policy"
-                | "provider-internal"
-                | "transport"
-                | "invalid-provider-output"
-                | "unknown"
-              readonly message: string
-              readonly status?: number | null
-              readonly retryable: boolean
-              readonly retryAfterMs?: number | null
-            }
+        readonly error?: { readonly type: "unknown"; readonly message: string }
      }
    | {
        readonly type: "compaction"
@@ -37,11 +37,6 @@ test("session methods retain decoded Effect inputs and outputs", async () => {
    if (url.includes("/message/")) {
      return Effect.succeed(HttpClientResponse.fromWeb(request, Response.json({ data: modelSwitchedMessage })))
    }
-    if (url.endsWith("/api/session/active")) {
-      return Effect.succeed(
-        HttpClientResponse.fromWeb(request, Response.json({ data: { ses_test: { type: "running" } } })),
-      )
-    }
    if (request.method === "POST" && url.endsWith("/api/session")) {
      return Effect.succeed(HttpClientResponse.fromWeb(request, Response.json(session)))
    }
@@ -55,7 +50,6 @@ test("session methods retain decoded Effect inputs and outputs", async () => {
  const result = await Effect.gen(function* () {
    const client = yield* OpenCode.make({ baseUrl: "http://localhost:3000" })
    const page = yield* client.sessions.list({ limit: 10 })
-    const active = yield* client.sessions.active()
    const created = yield* client.sessions.create({
      location: Location.Ref.make({ directory: AbsolutePath.make("/tmp/project") }),
    })
@@ -80,11 +74,10 @@ test("session methods retain decoded Effect inputs and outputs", async () => {
      sessionID: Session.ID.make("ses_test"),
      messageID: SessionMessage.ID.make("msg_model"),
    })
-    return { page, active, created, admitted, context, events, message }
+    return { page, created, admitted, context, events, message }
  }).pipe(Effect.provideService(HttpClient.HttpClient, httpClient), Effect.runPromise)

  expect(DateTime.toEpochMillis(result.page.data[0].time.created)).toBe(1_717_171_717_000)
-  expect(result.active).toEqual({ ses_test: { type: "running" } })
  expect(Object.getPrototypeOf(result.page.data[0])).toBe(Object.prototype)
  expect(Object.getPrototypeOf(result.created)).toBe(Object.prototype)
  expect(result.created.id).toBe("ses_test")
@@ -32,7 +32,6 @@ test("session methods use the public HTTP contract", async () => {
      if (url.includes("/prompt")) return Response.json(admission)
      if (url.includes("/context")) return Response.json({ data: [] })
      if (url.includes("/message/")) return Response.json({ data: modelSwitchedMessage })
-      if (url.endsWith("/api/session/active")) return Response.json({ data: { ses_test: { type: "running" } } })
      if (init?.method === "POST" && url.endsWith("/api/session")) return Response.json(session)
      if (init?.method === "POST") return new Response(null, { status: 204 })
      return Response.json({ data: [session.data], cursor: { next: "next" } })
@@ -40,7 +39,6 @@ test("session methods use the public HTTP contract", async () => {
  })

  const page = await client.sessions.list({ limit: "10", order: "desc" })
-  const active = await client.sessions.active()
  const created = await client.sessions.create({ location: { directory: "/tmp/project" } })
  await client.sessions.switchAgent({ sessionID: "ses_test", agent: "build" })
  await client.sessions.switchModel({
@@ -61,7 +59,6 @@ test("session methods use the public HTTP contract", async () => {
  const message = await client.sessions.message({ sessionID: "ses_test", messageID: "msg_model" })

  expect(page.cursor.next).toBe("next")
-  expect(active).toEqual({ ses_test: { type: "running" } })
  expect(created.id).toBe("ses_test")
  expect(admitted.id).toBe("msg_test")
  expect(context).toEqual([])
@@ -69,7 +66,6 @@ test("session methods use the public HTTP contract", async () => {
  expect(message).toEqual(modelSwitchedMessage)
  expect(requests.map((request) => [request.init?.method, request.url])).toEqual([
    ["GET", "http://localhost:3000/api/session?limit=10&order=desc"],
-    ["GET", "http://localhost:3000/api/session/active"],
    ["POST", "http://localhost:3000/api/session"],
    ["POST", "http://localhost:3000/api/session/ses_test/agent"],
    ["POST", "http://localhost:3000/api/session/ses_test/model"],
@@ -81,7 +77,7 @@ test("session methods use the public HTTP contract", async () => {
    ["POST", "http://localhost:3000/api/session/ses_test/interrupt"],
    ["GET", "http://localhost:3000/api/session/ses_test/message/msg_model"],
  ])
-  const body = requests.find((request) => request.url.endsWith("/api/session/ses_test/prompt"))?.init?.body
+  const body = requests[4]?.init?.body
  if (typeof body !== "string") throw new Error("Expected JSON request body")
  expect(JSON.parse(body)).toEqual({
    prompt: { text: "Hello" },
@@ -6,9 +6,9 @@ import { Git } from "../git"
 import { Location } from "../location"
 import { ProjectV2 } from "../project"
 import { SessionV2 } from "../session"
+import { SessionExecution } from "../session/execution"
 import { SessionEvent } from "../session/event"
 import { SessionSchema } from "../session/schema"
-import { SessionStore } from "../session/store"
 import { AbsolutePath, RelativePath } from "../schema"
 import path from "path"

@@ -71,11 +71,10 @@ export const layer = Layer.effect(
    const git = yield* Git.Service
    const events = yield* EventV2.Service
    const project = yield* ProjectV2.Service
-    const sessions = yield* SessionStore.Service
+    const session = yield* SessionV2.Service

    const moveSession = Effect.fn("MoveSession.moveSession")(function* (input: Input) {
-      const current = yield* sessions.get(input.sessionID)
-      if (!current) return yield* new SessionV2.NotFoundError({ sessionID: input.sessionID })
+      const current = yield* session.get(input.sessionID)
      const directory = AbsolutePath.make(input.destination.directory)
      if (current.location.directory === directory) return

@@ -144,5 +143,6 @@ export const defaultLayer = layer.pipe(
  Layer.provide(Git.defaultLayer),
  Layer.provide(EventV2.defaultLayer),
  Layer.provide(ProjectV2.defaultLayer),
-  Layer.provide(SessionStore.defaultLayer),
+  Layer.provide(SessionExecution.noopLayer),
+  Layer.provide(SessionV2.defaultLayer),
 )
@@ -155,7 +155,6 @@ export interface Interface {
  }) => Effect.Effect<void, OperationUnavailableError>
  readonly compact: (input: CompactInput) => Effect.Effect<void, NotFoundError | OperationUnavailableError>
  readonly wait: (id: SessionSchema.ID) => Effect.Effect<void, NotFoundError | OperationUnavailableError>
-  readonly active: Effect.Effect<ReadonlySet<SessionSchema.ID>>
  readonly resume: (sessionID: SessionSchema.ID) => Effect.Effect<void, NotFoundError | SessionRunner.RunError>
  readonly interrupt: (sessionID: SessionSchema.ID) => Effect.Effect<void>
  readonly revert: {
@@ -403,7 +402,6 @@ export const layer = Layer.unwrap(
              yield* result.get(sessionID)
              return yield* new OperationUnavailableError({ operation: "wait" })
            }),
-            active: execution.active,
            resume: Effect.fn("V2Session.resume")(function* (sessionID) {
              yield* result.get(sessionID)
              yield* execution.resume(sessionID)
@@ -445,6 +443,7 @@ export const defaultLayer = layer.pipe(
  Layer.provide(
    Layer.unwrap(Effect.promise(() => import("./location-layer")).pipe(Effect.map((m) => m.LocationServiceMap.layer))),
  ),
+  Layer.provide(SessionExecution.noopLayer),
  Layer.provide(SessionStore.defaultLayer),
  Layer.provide(SessionProjector.defaultLayer),
  Layer.provide(EventV2.defaultLayer),
@@ -5,8 +5,6 @@ import { SessionRunner } from "./runner/index"
 import { SessionSchema } from "./schema"

 export interface Interface {
-  /** Snapshots active execution owned by this process. */
-  readonly active: Effect.Effect<ReadonlySet<SessionSchema.ID>>
  /** Starts execution while idle or joins the active execution. */
  readonly resume: (sessionID: SessionSchema.ID) => Effect.Effect<void, SessionRunner.RunError>
  /** Registers newly recorded work. Repeated wakeups may coalesce. */
@@ -21,10 +19,5 @@ export class Service extends Context.Service<Service, Interface>()("@opencode/v2
 /** Low-level compatibility layer for callers that only need durable Session recording. */
 export const noopLayer = Layer.succeed(
  Service,
-  Service.of({
-    active: Effect.succeed(new Set()),
-    resume: () => Effect.void,
-    wake: () => Effect.void,
-    interrupt: () => Effect.void,
-  }),
+  Service.of({ resume: () => Effect.void, wake: () => Effect.void, interrupt: () => Effect.void }),
 )
@@ -28,7 +28,6 @@ export const layer = Layer.effect(
    })

    return SessionExecution.Service.of({
-      active: coordinator.active,
      interrupt: coordinator.interrupt,
      resume: coordinator.run,
      wake: coordinator.wake,
@@ -4,8 +4,6 @@ import { Deferred, Effect, Exit, Fiber, FiberSet, Scope } from "effect"

 /** Serializes execution for each key while allowing different keys to run concurrently. */
 export interface Coordinator<Key, E> {
-  /** Snapshots keys with an execution owned by this coordinator. */
-  readonly active: Effect.Effect<ReadonlySet<Key>>
  /** Starts execution while idle or joins the active execution. */
  readonly run: (key: Key) => Effect.Effect<void, E>
  /** Registers one coalesced follow-up after newly recorded work. */
@@ -100,5 +98,5 @@ export const make = <Key, E>(options: {
        return Fiber.interrupt(entry.owner)
      })

-    return { active: Effect.sync(() => new Set(active.keys())), run, wake, interrupt }
+    return { run, wake, interrupt }
  })
@@ -6,7 +6,6 @@ import {
  Message,
  SystemPart,
  isContextOverflowFailure,
-  type LLMErrorReason,
  type ProviderErrorEvent,
 } from "@opencode-ai/llm"
 import { Cause, DateTime, Effect, FiberSet, Layer, Option, Semaphore, Stream } from "effect"
@@ -33,7 +32,7 @@ import { SessionSchema } from "../schema"
 import { SessionStore } from "../store"
 import { type RunError, Service } from "./index"
 import { SessionRunnerModel } from "./model"
-import { createLLMEventPublisher, providerError } from "./publish-llm-event"
+import { createLLMEventPublisher } from "./publish-llm-event"
 import { toLLMMessages } from "./to-llm-message"
 import { MAX_STEPS_PROMPT } from "./max-steps"
 import { Snapshot } from "../../snapshot"
@@ -88,29 +87,6 @@ import { Snapshot } from "../../snapshot"
 * explicit loop starts the next provider turn after local settlement. Configured agent step limits bound the loop.
 */

-const providerCategories = {
-  InvalidRequest: "invalid-request",
-  NoRoute: "no-route",
-  Authentication: "authentication",
-  RateLimit: "rate-limit",
-  QuotaExceeded: "quota-exceeded",
-  ContentPolicy: "content-policy",
-  ProviderInternal: "provider-internal",
-  Transport: "transport",
-  InvalidProviderOutput: "invalid-provider-output",
-  UnknownProvider: "unknown",
-} as const satisfies Record<LLMErrorReason["_tag"], Parameters<typeof providerError>[0]["category"]>
-
-const toSessionProviderError = (reason: LLMErrorReason) =>
-  providerError({
-    category: providerCategories[reason._tag],
-    status:
-      ("http" in reason ? reason.http?.response?.status : undefined) ??
-      ("status" in reason ? reason.status : undefined),
-    retryable: reason.retryable,
-    retryAfterMs: "retryAfterMs" in reason ? reason.retryAfterMs : undefined,
-  })
-
 export const layer = Layer.effect(
  Service,
  Effect.gen(function* () {
@@ -307,7 +283,7 @@ export const layer = Layer.effect(
          const llmFailure = failure instanceof LLMError ? failure : undefined
          if (llmFailure && !publisher.hasProviderError()) {
            yield* withPublication(publisher.failUnsettledTools("Provider did not return a tool result", true))
-            yield* withPublication(publisher.failAssistant(toSessionProviderError(llmFailure.reason)))
+            yield* withPublication(publisher.failAssistant(llmFailure.reason.message))
          }
          if (stream._tag === "Failure" && Cause.hasInterrupts(stream.cause)) yield* FiberSet.clear(toolFibers)
          const settled = yield* restore(awaitToolFibers(toolFibers)).pipe(Effect.exit)
@@ -323,7 +299,7 @@ export const layer = Layer.effect(
            yield* FiberSet.clear(toolFibers)
            yield* withPublication(publisher.failUnsettledTools("Tool execution interrupted"))
            if (publisher.hasActiveAssistant())
-              yield* withPublication(publisher.failAssistant({ type: "unknown", message: "Provider turn interrupted" }))
+              yield* withPublication(publisher.failAssistant("Provider turn interrupted"))
          }
          if (settled._tag === "Failure" && !Cause.hasInterrupts(settled.cause)) {
            const failure = Cause.squash(settled.cause)
@@ -50,33 +50,6 @@ const settledOutput = (value: ToolOutput | undefined, result: ToolResultValue):
  return { structured: record(settled.structured), content: settled.content }
 }

-const providerMessages: Record<SessionMessage.ProviderErrorCategory, string> = {
-  "invalid-request": "Provider rejected the request",
-  "no-route": "Provider unavailable: no provider route",
-  authentication: "Provider authentication failed",
-  "rate-limit": "Provider rate limit exceeded",
-  "quota-exceeded": "Provider quota exceeded",
-  "content-policy": "Provider rejected the invalid request due to content policy",
-  "provider-internal": "Provider service unavailable",
-  transport: "Provider connection failed",
-  "invalid-provider-output": "Provider returned an invalid response",
-  unknown: "Provider request failed",
-}
-
-export const providerError = (input: {
-  readonly category: SessionMessage.ProviderErrorCategory
-  readonly status?: number
-  readonly retryable?: boolean
-  readonly retryAfterMs?: number
-}): SessionMessage.ProviderError => ({
-  type: "provider",
-  category: input.category,
-  message: providerMessages[input.category],
-  status: input.status,
-  retryable: input.retryable ?? (input.category === "rate-limit" || input.category === "provider-internal"),
-  retryAfterMs: input.retryAfterMs,
-})
-
 /** Persist one provider turn without executing tools or starting a continuation turn. */
 export const createLLMEventPublisher = (events: EventV2.Interface, input: Input) => {
  const tools = new Map<
@@ -94,6 +67,7 @@ export const createLLMEventPublisher = (events: EventV2.Interface, input: Input)
  const timestamp = DateTime.now
  let assistantMessageID: SessionMessage.ID | undefined
  let assistantActive = false
+  let assistantFailed = false
  let providerFailed = false
  let stepSettlement: { readonly finish: string; readonly tokens: ReturnType<typeof tokens> } | undefined

@@ -222,17 +196,17 @@ export const createLLMEventPublisher = (events: EventV2.Interface, input: Input)
    yield* flushFragments()
  })

-  const failAssistant = Effect.fnUntraced(function* (error: SessionMessage.Error) {
-    if (providerFailed) return
-    providerFailed = true
+  const failAssistant = Effect.fnUntraced(function* (message: string) {
+    if (assistantFailed) return
    yield* flush()
    const assistantMessageID = yield* startAssistant()
    assistantActive = false
+    assistantFailed = true
    yield* events.publish(SessionEvent.Step.Failed, {
      sessionID: input.sessionID,
      timestamp: yield* timestamp,
      assistantMessageID,
-      error,
+      error: { type: "unknown", message },
    })
  })

@@ -428,13 +402,8 @@ export const createLLMEventPublisher = (events: EventV2.Interface, input: Input)
      case "finish":
        return
      case "provider-error":
-        yield* failAssistant(
-          providerError({
-            category: event.category ?? (event.classification === "context-overflow" ? "invalid-request" : "unknown"),
-            status: event.status,
-            retryable: event.retryable,
-          }),
-        )
+        providerFailed = true
+        yield* failAssistant(event.message)
        return
    }
  })
@@ -42,7 +42,7 @@ const layer = MoveSession.layer.pipe(
  Layer.provide(Git.defaultLayer),
  Layer.provide(EventV2.defaultLayer),
  Layer.provide(project),
-  Layer.provide(SessionStore.defaultLayer),
+  Layer.provide(sessions),
 )
 const it = testEffect(
  Layer.mergeAll(
@@ -53,6 +53,7 @@ const it = testEffect(
    project,
    SessionProjector.defaultLayer,
    SessionStore.defaultLayer,
+    SessionExecution.noopLayer,
    sessions,
  ),
 )
@@ -22,11 +22,9 @@ import { testEffect } from "./lib/effect"
 const executionCalls: SessionV2.ID[] = []
 const interruptCalls: SessionV2.ID[] = []
 const wakeCalls: SessionV2.ID[] = []
-const activeSessions = new Set<SessionV2.ID>()
 const execution = Layer.succeed(
  SessionExecution.Service,
  SessionExecution.Service.of({
-    active: Effect.sync(() => new Set(activeSessions)),
    resume: (sessionID) =>
      Effect.sync(() => {
        executionCalls.push(sessionID)
@@ -110,13 +108,6 @@ const eventCount = (type: string) =>
  )

 describe("SessionV2.prompt", () => {
-  it.effect("exposes the execution registry", () =>
-    Effect.gen(function* () {
-      activeSessions.add(sessionID)
-      expect(Array.from(yield* (yield* SessionV2.Service).active)).toEqual([sessionID])
-    }).pipe(Effect.ensuring(Effect.sync(() => activeSessions.clear()))),
-  )
-
  it.effect("delegates execution continuation through SessionExecution", () =>
    Effect.gen(function* () {
      yield* setup
@@ -66,78 +66,6 @@ describe("SessionRunCoordinator", () => {
    ),
  )

-  it.effect("snapshots only active executions", () =>
-    Effect.scoped(
-      Effect.gen(function* () {
-        const firstStarted = yield* Deferred.make<void>()
-        const secondStarted = yield* Deferred.make<void>()
-        const firstGate = yield* Deferred.make<void>()
-        const secondGate = yield* Deferred.make<void>()
-        const coordinator = yield* SessionRunCoordinator.make({
-          drain: (key: string) =>
-            Deferred.succeed(key === "first" ? firstStarted : secondStarted, undefined).pipe(
-              Effect.andThen(Deferred.await(key === "first" ? firstGate : secondGate)),
-            ),
-        })
-
-        expect(Array.from(yield* coordinator.active)).toEqual([])
-        const first = yield* coordinator.run("first").pipe(Effect.forkChild)
-        yield* Deferred.await(firstStarted)
-        expect(Array.from(yield* coordinator.active)).toEqual(["first"])
-
-        const second = yield* coordinator.run("second").pipe(Effect.forkChild)
-        yield* Deferred.await(secondStarted)
-        expect(Array.from(yield* coordinator.active)).toEqual(["first", "second"])
-
-        yield* Deferred.succeed(firstGate, undefined)
-        yield* Fiber.join(first)
-        expect(Array.from(yield* coordinator.active)).toEqual(["second"])
-        yield* Deferred.succeed(secondGate, undefined)
-        yield* Fiber.join(second)
-        expect(Array.from(yield* coordinator.active)).toEqual([])
-      }),
-    ),
-  )
-
-  it.effect("cleans active executions after failure and defect", () =>
-    Effect.scoped(
-      Effect.gen(function* () {
-        const failure = new Error("failed")
-        const defect = new Error("defect")
-        const coordinator = yield* SessionRunCoordinator.make({
-          drain: (key: string) => (key === "failure" ? Effect.fail(failure) : Effect.die(defect)),
-        })
-
-        const failed = yield* coordinator.run("failure").pipe(Effect.exit)
-        expect(Exit.isFailure(failed) && Cause.hasFails(failed.cause)).toBeTrue()
-        expect(Array.from(yield* coordinator.active)).toEqual([])
-
-        const died = yield* coordinator.run("defect").pipe(Effect.exit)
-        expect(Exit.isFailure(died) && Cause.hasDies(died.cause)).toBeTrue()
-        expect(Array.from(yield* coordinator.active)).toEqual([])
-      }),
-    ),
-  )
-
-  it.effect("cleans active executions when its scope closes", () =>
-    Effect.gen(function* () {
-      const started = yield* Deferred.make<void>()
-      const coordinator = yield* Effect.scoped(
-        Effect.gen(function* () {
-          const coordinator = yield* SessionRunCoordinator.make({
-            drain: () => Deferred.succeed(started, undefined).pipe(Effect.andThen(Effect.never)),
-          })
-          yield* coordinator.wake("session")
-          yield* Deferred.await(started)
-          expect(Array.from(yield* coordinator.active)).toEqual(["session"])
-          return coordinator
-        }),
-      )
-
-      expect(Array.from(yield* coordinator.active)).toEqual([])
-    }),
-  )
-
  it.effect("coalesces wakes received during active execution", () =>
    Effect.scoped(
      Effect.gen(function* () {
@@ -238,7 +166,6 @@ describe("SessionRunCoordinator", () => {

        const exit = yield* Fiber.await(resumed)
        expect(Exit.isFailure(exit) && Cause.hasInterruptsOnly(exit.cause)).toBeTrue()
-        expect(Array.from(yield* coordinator.active)).toEqual([])
        expect(runs).toBe(1)
      }),
    ),
@@ -95,7 +95,6 @@ const execution = Layer.effect(
      drain: (sessionID, force) => sessionRunner.run({ sessionID, force }),
    })
    return SessionExecution.Service.of({
-      active: coordinator.active,
      resume: coordinator.run,
      wake: coordinator.wake,
      interrupt: coordinator.interrupt,
@@ -4,11 +4,6 @@ import {
  LLMError,
  LLMEvent,
  Model,
-  HttpContext,
-  HttpRateLimitDetails,
-  HttpRequestDetails,
-  HttpResponseDetails,
-  RateLimitReason,
  TransportReason,
  InvalidRequestReason,
  type LLMClientShape,
@@ -259,7 +254,6 @@ const execution = Layer.effect(
      drain: (sessionID, force) => sessionRunner.run({ sessionID, force }),
    })
    return SessionExecution.Service.of({
-      active: coordinator.active,
      resume: coordinator.run,
      wake: coordinator.wake,
      interrupt: coordinator.interrupt,
@@ -520,21 +514,13 @@ const verifyPartialFlushOnFailure = (kind: FragmentKind) =>
    responseStream = Stream.concat(Stream.fromIterable(fixture.partialEvents), Stream.fail(failure))

    expect(yield* session.resume(sessionID).pipe(Effect.flip)).toBe(failure)
-    const expectedContent =
-      kind === "tool input"
-        ? {
-            type: "tool",
-            id: fragmentID(kind, "partial"),
-            state: { status: "error", error: { message: "Tool execution interrupted" } },
-          }
-        : fixture.expectedContent
    expect(yield* session.context(sessionID)).toMatchObject([
      { type: "user", text: prompt },
      {
        type: "assistant",
        finish: "error",
-        error: { type: "provider", category: "transport", message: "Provider connection failed", retryable: false },
-        content: [expectedContent],
+        error: { type: "unknown", message: "Provider unavailable" },
+        content: [fixture.expectedContent],
      },
    ])
  })
@@ -1209,16 +1195,7 @@ describe("SessionRunnerLLM", () => {
      expect(requests).toHaveLength(3)
      expect(yield* session.context(sessionID)).toMatchObject([
        { type: "compaction" },
-        {
-          type: "assistant",
-          finish: "error",
-          error: {
-            type: "provider",
-            category: "invalid-request",
-            message: "Provider rejected the request",
-            retryable: false,
-          },
-        },
+        { type: "assistant", finish: "error", error: { message: "prompt too long" } },
      ])
    }),
  )
@@ -1266,16 +1243,7 @@ describe("SessionRunnerLLM", () => {
      expect(context.some((message) => message.type === "compaction")).toBe(false)
      expect(context.slice(-2)).toMatchObject([
        { type: "user", text: "Continue" },
-        {
-          type: "assistant",
-          finish: "error",
-          error: {
-            type: "provider",
-            category: "invalid-request",
-            message: "Provider rejected the request",
-            retryable: false,
-          },
-        },
+        { type: "assistant", finish: "error", error: { message: "prompt too long" } },
      ])
    }),
  )
@@ -2951,16 +2919,7 @@ describe("SessionRunnerLLM", () => {
      expect(requests).toHaveLength(1)
      expect(yield* session.context(sessionID)).toMatchObject([
        { type: "user", text: "Fail durably" },
-        {
-          type: "assistant",
-          finish: "error",
-          error: {
-            type: "provider",
-            category: "unknown",
-            message: "Provider request failed",
-            retryable: false,
-          },
-        },
+        { type: "assistant", finish: "error", error: { type: "unknown", message: "Provider unavailable" } },
      ])
    }),
  )
@@ -2979,16 +2938,7 @@ describe("SessionRunnerLLM", () => {
      expect(requests).toHaveLength(1)
      expect(yield* session.context(sessionID)).toMatchObject([
        { type: "user", text: "Fail before step" },
-        {
-          type: "assistant",
-          finish: "error",
-          error: {
-            type: "provider",
-            category: "unknown",
-            message: "Provider request failed",
-            retryable: false,
-          },
-        },
+        { type: "assistant", finish: "error", error: { type: "unknown", message: "Provider unavailable" } },
      ])
    }),
  )
@@ -3015,12 +2965,7 @@ describe("SessionRunnerLLM", () => {
        {
          type: "assistant",
          finish: "error",
-          error: {
-            type: "provider",
-            category: "invalid-request",
-            message: "Provider rejected the request",
-            retryable: false,
-          },
+          error: { message: "prompt too long" },
          content: [{ type: "text", text: "Partial" }],
        },
      ])
@@ -3039,138 +2984,11 @@ describe("SessionRunnerLLM", () => {
      yield* replaySessionProjection(sessionID)
      expect(yield* session.context(sessionID)).toMatchObject([
        { type: "user", text: "Fail raw stream durably" },
-        {
-          type: "assistant",
-          finish: "error",
-          error: { type: "provider", category: "transport", message: "Provider connection failed", retryable: false },
-        },
+        { type: "assistant", finish: "error", error: { type: "unknown", message: "Provider unavailable" } },
      ])
    }),
  )

-  it.effect("does not publish step ended when the provider throws after step finish", () =>
-    Effect.gen(function* () {
-      yield* setup
-      const session = yield* SessionV2.Service
-      const db = yield* Database.Service
-      yield* session.prompt({ sessionID, prompt: Prompt.make({ text: "Fail after finish" }), resume: false })
-      const failure = providerUnavailable()
-      responseStream = Stream.concat(
-        Stream.fromIterable([LLMEvent.stepFinish({ index: 0, reason: "stop" })]),
-        Stream.fail(failure),
-      )
-
-      expect(yield* session.resume(sessionID).pipe(Effect.flip)).toBe(failure)
-
-      const types = yield* db.db.select({ type: EventTable.type }).from(EventTable).all().pipe(Effect.orDie)
-      expect(types).toContainEqual({
-        type: EventV2.versionedType(SessionEvent.Step.Failed.type, 2),
-      })
-      expect(types).not.toContainEqual({
-        type: EventV2.versionedType(SessionEvent.Step.Ended.type, 2),
-      })
-      expect(yield* session.context(sessionID)).toMatchObject([
-        { type: "user", text: "Fail after finish" },
-        {
-          type: "assistant",
-          finish: "error",
-          error: { type: "provider", category: "transport", message: "Provider connection failed" },
-        },
-      ])
-    }),
-  )
-
-  it.effect("preserves sanitized HTTP rate-limit details in the durable event and projection", () =>
-    Effect.gen(function* () {
-      yield* setup
-      const session = yield* SessionV2.Service
-      const db = yield* Database.Service
-      yield* session.prompt({ sessionID, prompt: Prompt.make({ text: "Fail with rate limit" }), resume: false })
-      const failure = new LLMError({
-        module: "RequestExecutor",
-        method: "execute",
-        reason: new RateLimitReason({
-          message: "secret provider response message",
-          retryAfterMs: 12_000,
-          rateLimit: new HttpRateLimitDetails({ retryAfterMs: 12_000, limit: { requests: "secret-limit" } }),
-          http: new HttpContext({
-            request: new HttpRequestDetails({
-              method: "POST",
-              url: "https://secret.example/v1/responses?api_key=credential",
-              headers: { authorization: "Bearer credential" },
-            }),
-            response: new HttpResponseDetails({ status: 429, headers: { "x-secret": "secret-header" } }),
-            body: '{"secret":"provider body"}',
-            requestId: "secret-request-id",
-          }),
-        }),
-      })
-      responseStream = Stream.fail(failure)
-
-      expect(yield* session.resume(sessionID).pipe(Effect.flip)).toBe(failure)
-
-      const event = yield* db.db
-        .select({ data: EventTable.data })
-        .from(EventTable)
-        .where(eq(EventTable.type, EventV2.versionedType(SessionEvent.Step.Failed.type, 2)))
-        .get()
-        .pipe(Effect.orDie)
-      const expected = {
-        type: "provider",
-        category: "rate-limit",
-        message: "Provider rate limit exceeded",
-        status: 429,
-        retryable: true,
-        retryAfterMs: 12_000,
-      }
-      expect(event?.data.error).toEqual(expected)
-      expect(yield* session.context(sessionID)).toMatchObject([
-        { type: "user", text: "Fail with rate limit" },
-        { type: "assistant", finish: "error", error: expected },
-      ])
-      expect(JSON.stringify(event)).not.toMatch(
-        /secret provider|secret\.example|credential|secret-header|provider body|secret-request-id|secret-limit/,
-      )
-      expect(JSON.stringify(yield* session.context(sessionID))).not.toMatch(
-        /secret provider|secret\.example|credential|secret-header|provider body|secret-request-id|secret-limit/,
-      )
-    }),
-  )
-
-  it.effect("projects categorized in-band failures without fabricating an HTTP status", () =>
-    Effect.gen(function* () {
-      yield* setup
-      const session = yield* SessionV2.Service
-      yield* session.prompt({ sessionID, prompt: Prompt.make({ text: "Fail in band" }), resume: false })
-      response = [
-        LLMEvent.providerError({
-          message: "rate_limit_exceeded: secret provider message",
-          category: "rate-limit",
-          retryable: false,
-        }),
-      ]
-
-      yield* session.resume(sessionID)
-
-      expect(yield* session.context(sessionID)).toMatchObject([
-        { type: "user", text: "Fail in band" },
-        {
-          type: "assistant",
-          finish: "error",
-          error: {
-            type: "provider",
-            category: "rate-limit",
-            message: "Provider rate limit exceeded",
-            retryable: false,
-          },
-        },
-      ])
-      const assistant = (yield* session.context(sessionID))[1]
-      expect(assistant?.type === "assistant" ? assistant.error : undefined).not.toHaveProperty("status")
-      expect(JSON.stringify(assistant)).not.toContain("secret provider message")
-    }),
-  )
-
  it.effect("does not continue automatically after a provider error follows a local tool call", () =>
    Effect.gen(function* () {
      yield* setup
@@ -3186,25 +3004,13 @@ describe("SessionRunnerLLM", () => {
      response = [
        LLMEvent.stepStart({ index: 0 }),
        LLMEvent.toolCall({ id: "call-before-provider-error", name: "echo", input: { text: "settled" } }),
-        LLMEvent.providerError({ message: "secret provider failure" }),
+        LLMEvent.providerError({ message: "Provider unavailable" }),
      ]

      yield* session.resume(sessionID)

      expect(requests).toHaveLength(1)
      expect(executions.slice(executionCount)).toEqual(["settled"])
-      const assistant = (yield* session.context(sessionID))[1]
-      expect(assistant).toMatchObject({
-        type: "assistant",
-        finish: "error",
-        error: {
-          type: "provider",
-          category: "unknown",
-          message: "Provider request failed",
-          retryable: false,
-        },
-      })
-      expect(JSON.stringify(assistant)).not.toContain("secret provider failure")
    }),
  )

@@ -3294,12 +3100,7 @@ describe("SessionRunnerLLM", () => {
        {
          type: "assistant",
          finish: "error",
-          error: {
-            type: "provider",
-            category: "transport",
-            message: "Provider connection failed",
-            retryable: false,
-          },
+          error: { type: "unknown", message: "Provider unavailable" },
          content: [{ type: "tool", id: "call-hosted-raw-failure", state: { status: "error" } }],
        },
      ])
@@ -144,8 +144,6 @@ test("Core reuses the canonical shared schemas", async () => {
    [coreSessionInput.Admitted, SessionInput.Admitted],
    [coreSessionMessage.ID, SessionMessage.ID],
    [coreSessionMessage.UnknownError, SessionMessage.UnknownError],
-    [coreSessionMessage.ProviderError, SessionMessage.ProviderError],
-    [coreSessionMessage.Error, SessionMessage.Error],
    [coreSessionMessage.AgentSwitched, SessionMessage.AgentSwitched],
    [coreSessionMessage.ModelSwitched, SessionMessage.ModelSwitched],
    [coreSessionMessage.User, SessionMessage.User],
@@ -206,17 +204,3 @@ test("shared record schemas construct and decode plain objects", () => {
  expect(Prompt.fromUserMessage({ text: "hello" })).toEqual(made)
  expect(Workspace.ID.ascending("")).toStartWith("wrk_")
 })
-
-test("assistant errors retain legacy unknown decode compatibility", () => {
-  const assistant = Schema.decodeUnknownSync(SessionMessage.Assistant)({
-    id: "msg_legacy_error",
-    type: "assistant",
-    agent: "build",
-    model: { id: "model", providerID: "provider" },
-    content: [],
-    error: { type: "unknown", message: "Legacy failure" },
-    time: { created: 0 },
-  })
-
-  expect(assistant.error).toEqual({ type: "unknown", message: "Legacy failure" })
-})
@@ -4,20 +4,6 @@ import { ModelID, ProviderID, ProviderMetadata, RouteID } from "./ids"
 export const ProviderFailureClassification = Schema.Literal("context-overflow")
 export type ProviderFailureClassification = typeof ProviderFailureClassification.Type

-export const ProviderFailureCategory = Schema.Literals([
-  "invalid-request",
-  "no-route",
-  "authentication",
-  "rate-limit",
-  "quota-exceeded",
-  "content-policy",
-  "provider-internal",
-  "transport",
-  "invalid-provider-output",
-  "unknown",
-])
-export type ProviderFailureCategory = typeof ProviderFailureCategory.Type
-
 export class HttpRequestDetails extends Schema.Class<HttpRequestDetails>("LLM.HttpRequestDetails")({
  method: Schema.String,
  url: Schema.String,
@@ -2,7 +2,7 @@ import { Schema } from "effect"
 import { ContentBlockID, FinishReason, ProtocolID, ProviderMetadata, RouteID, ToolCallID } from "./ids"
 import { ModelSchema } from "./options"
 import { ToolOutput, ToolResultValue } from "./messages"
-import { ProviderFailureCategory, ProviderFailureClassification } from "./errors"
+import { ProviderFailureClassification } from "./errors"

 /**
 * Token usage reported by an LLM provider.
@@ -201,8 +201,6 @@ export const ProviderErrorEvent = Schema.Struct({
  type: Schema.tag("provider-error"),
  message: Schema.String,
  classification: Schema.optional(ProviderFailureClassification),
-  category: Schema.optional(ProviderFailureCategory),
-  status: Schema.optional(Schema.Number),
  retryable: Schema.optional(Schema.Boolean),
  providerMetadata: Schema.optional(ProviderMetadata),
 }).annotate({ identifier: "LLM.Event.ProviderError" })
@@ -13,11 +13,14 @@ import { Config } from "@/config/config"
 import { NotFoundError } from "@/storage/storage"

 import { Effect, Layer, Context } from "effect"
+import * as DateTime from "effect/DateTime"
 import { InstanceState } from "@/effect/instance-state"
 import { isOverflow as overflow, usable } from "./overflow"
 import { serviceUse } from "@opencode-ai/core/effect/service-use"
 import { RuntimeFlags } from "@/effect/runtime-flags"
 import { EventV2Bridge } from "@/event-v2-bridge"
+import { SessionEvent } from "@opencode-ai/core/session/event"
+import { SessionMessage } from "@opencode-ai/core/session/message"
 import { ProviderV2 } from "@opencode-ai/core/provider"
 import { ModelV2 } from "@opencode-ai/core/model"
 import { buildPrompt } from "@opencode-ai/core/session/compaction"
@@ -352,6 +355,18 @@ export const layer = Layer.effect(
        stripMedia: true,
        toolOutputMaxChars: TOOL_OUTPUT_MAX_CHARS,
      })
+      const tailIndex = selected.tail_start_id
+        ? history.findIndex((message) => message.info.id === selected.tail_start_id)
+        : -1
+      const recent =
+        tailIndex < 0
+          ? ""
+          : JSON.stringify(
+              yield* MessageV2.toModelMessagesEffect(history.slice(tailIndex), model, {
+                stripMedia: true,
+                toolOutputMaxChars: TOOL_OUTPUT_MAX_CHARS,
+              }),
+            )
      const ctx = yield* InstanceState.context
      const msg: SessionV1.Assistant = {
        id: MessageID.ascending(),
@@ -505,6 +520,25 @@ export const layer = Layer.effect(

      if (processor.message.error) return "stop"
      if (result === "continue") {
+        const summary = summaryText(
+          (yield* session.messages({ sessionID: input.sessionID }).pipe(Effect.orDie)).find(
+            (item) => item.info.id === msg.id,
+          ) ?? {
+            info: msg,
+            parts: [],
+          },
+        )
+        if (flags.experimentalEventSystem) {
+          if (summary)
+            yield* events.publish(SessionEvent.Compaction.Ended, {
+              sessionID: input.sessionID,
+              messageID: SessionMessage.ID.make(input.parentID),
+              timestamp: DateTime.makeUnsafe(Date.now()),
+              reason: input.auto ? "auto" : "manual",
+              text: summary ?? "",
+              recent,
+            })
+        }
        yield* events.publish(Event.Compacted, { sessionID: input.sessionID })
      }
      return result
@@ -533,6 +567,14 @@ export const layer = Layer.effect(
        auto: input.auto,
        overflow: input.overflow,
      })
+      if (flags.experimentalEventSystem) {
+        yield* events.publish(SessionEvent.Compaction.Started, {
+          sessionID: input.sessionID,
+          messageID: SessionMessage.ID.make(msg.id),
+          timestamp: DateTime.makeUnsafe(Date.now()),
+          reason: input.auto ? "auto" : "manual",
+        })
+      }
    })

    return Service.of({
@@ -24,7 +24,13 @@ import { errorMessage } from "@/util/error"
 import { isRecord } from "@/util/record"
 import { EventV2Bridge } from "@/event-v2-bridge"
 import { Database } from "@opencode-ai/core/database/database"
-import { Usage, type LLMEvent } from "@opencode-ai/llm"
+import { SessionEvent } from "@opencode-ai/core/session/event"
+import { SessionMessage } from "@opencode-ai/core/session/message"
+import { ModelV2 } from "@opencode-ai/core/model"
+import { ProviderV2 } from "@opencode-ai/core/provider"
+import * as DateTime from "effect/DateTime"
+import { RuntimeFlags } from "@/effect/runtime-flags"
+import { ToolOutput, Usage, type LLMEvent } from "@opencode-ai/llm"

 const DOOM_LOOP_THRESHOLD = 3
 export type Result = "compact" | "stop" | "continue"
@@ -58,10 +64,13 @@ export interface Interface {
 }

 type ToolCall = {
+  assistantMessageID?: SessionMessage.ID
  partID: SessionV1.ToolPart["id"]
  messageID: SessionV1.ToolPart["messageID"]
  sessionID: SessionV1.ToolPart["sessionID"]
  done: Deferred.Deferred<void>
+  inputEnded: boolean
+  raw: string
 }

 interface ProcessorContext extends Input {
@@ -71,7 +80,9 @@ interface ProcessorContext extends Input {
  blocked: boolean
  needsCompaction: boolean
  currentText: SessionV1.TextPart | undefined
+  currentTextID: string | undefined
  reasoningMap: Record<string, SessionV1.ReasoningPart>
+  v2AssistantMessageID: SessionMessage.ID | undefined
 }

 type StreamEvent = LLMEvent
@@ -93,6 +104,7 @@ export const layer = Layer.effect(
    const status = yield* SessionStatus.Service
    const image = yield* Image.Service
    const events = yield* EventV2Bridge.Service
+    const flags = yield* RuntimeFlags.Service
    const database = yield* Database.Service

    const create = Effect.fn("SessionProcessor.create")(function* (input: Input) {
@@ -110,8 +122,11 @@ export const layer = Layer.effect(
        blocked: false,
        needsCompaction: false,
        currentText: undefined,
+        currentTextID: undefined,
        reasoningMap: {},
+        v2AssistantMessageID: undefined,
      }
+      const mirrorAssistant = flags.experimentalEventSystem && !input.assistantMessage.summary
      let aborted = false

      const parse = (e: unknown) =>
@@ -126,6 +141,34 @@ export const layer = Layer.effect(
        if (done) yield* Deferred.succeed(done, undefined).pipe(Effect.ignore)
      })

+      const ensureV2AssistantMessage = Effect.fn("SessionProcessor.ensureV2AssistantMessage")(function* () {
+        if (ctx.v2AssistantMessageID) return ctx.v2AssistantMessageID
+        ctx.v2AssistantMessageID = SessionMessage.ID.create()
+        yield* events.publish(SessionEvent.Step.Started, {
+          sessionID: ctx.sessionID,
+          assistantMessageID: ctx.v2AssistantMessageID,
+          agent: input.assistantMessage.agent,
+          model: {
+            id: ModelV2.ID.make(ctx.model.id),
+            providerID: ProviderV2.ID.make(ctx.model.providerID),
+            variant: ModelV2.VariantID.make(input.assistantMessage.variant ?? "default"),
+          },
+          snapshot: ctx.snapshot,
+          timestamp: DateTime.makeUnsafe(Date.now()),
+        })
+        return ctx.v2AssistantMessageID
+      })
+
+      const requireV2AssistantMessage = (toolCall?: ToolCall) =>
+        toolCall?.assistantMessageID === undefined
+          ? Effect.die("V2 tool settlement has no owning assistant message")
+          : Effect.succeed(toolCall.assistantMessageID)
+
+      const currentV2AssistantMessage = () =>
+        ctx.v2AssistantMessageID === undefined
+          ? Effect.die("V2 step settlement has no owning assistant message")
+          : Effect.succeed(ctx.v2AssistantMessageID)
+
      const readToolCall = Effect.fn("SessionProcessor.readToolCall")(function* (toolCallID: string) {
        const call = ctx.toolcalls[toolCallID]
        if (!call) return undefined
@@ -204,6 +247,17 @@ export const layer = Layer.effect(

      const finishReasoning = Effect.fn("SessionProcessor.finishReasoning")(function* (reasoningID: string) {
        if (!(reasoningID in ctx.reasoningMap)) return
+        // TODO(v2): Temporary dual-write while migrating session messages to v2 events.
+        if (mirrorAssistant) {
+          yield* events.publish(SessionEvent.Reasoning.Ended, {
+            sessionID: ctx.sessionID,
+            assistantMessageID: yield* currentV2AssistantMessage(),
+            reasoningID,
+            text: ctx.reasoningMap[reasoningID].text,
+            providerMetadata: ctx.reasoningMap[reasoningID].metadata,
+            timestamp: DateTime.makeUnsafe(Date.now()),
+          })
+        }
        // oxlint-disable-next-line no-self-assign -- reactivity trigger
        ctx.reasoningMap[reasoningID].text = ctx.reasoningMap[reasoningID].text
        ctx.reasoningMap[reasoningID].time = { ...ctx.reasoningMap[reasoningID].time, end: Date.now() }
@@ -211,6 +265,33 @@ export const layer = Layer.effect(
        delete ctx.reasoningMap[reasoningID]
      })

+      const flushV2Fragments = Effect.fn("SessionProcessor.flushV2Fragments")(function* () {
+        if (!mirrorAssistant) return
+        if (!ctx.assistantMessage.summary && ctx.currentText && ctx.currentTextID) {
+          yield* events.publish(SessionEvent.Text.Ended, {
+            sessionID: ctx.sessionID,
+            assistantMessageID: yield* currentV2AssistantMessage(),
+            textID: ctx.currentTextID,
+            text: ctx.currentText.text,
+            timestamp: DateTime.makeUnsafe(Date.now()),
+          })
+        }
+        yield* Effect.forEach(Object.entries(ctx.reasoningMap), ([reasoningID, part]) =>
+          currentV2AssistantMessage().pipe(
+            Effect.flatMap((assistantMessageID) =>
+              events.publish(SessionEvent.Reasoning.Ended, {
+                sessionID: ctx.sessionID,
+                assistantMessageID,
+                reasoningID,
+                text: part.text,
+                providerMetadata: part.metadata,
+                timestamp: DateTime.makeUnsafe(Date.now()),
+              }),
+            ),
+          ),
+        )
+      })
+
      const ensureToolCall = Effect.fn("SessionProcessor.ensureToolCall")(function* (input: {
        id: string
        name: string
@@ -231,6 +312,17 @@ export const layer = Layer.effect(
          }
          return { call: ctx.toolcalls[input.id], part }
        }
+        // TODO(v2): Temporary dual-write while migrating session messages to v2 events.
+        const assistantMessageID = mirrorAssistant ? yield* ensureV2AssistantMessage() : undefined
+        if (assistantMessageID) {
+          yield* events.publish(SessionEvent.Tool.Input.Started, {
+            sessionID: ctx.sessionID,
+            assistantMessageID,
+            callID: input.id,
+            name: input.name,
+            timestamp: DateTime.makeUnsafe(Date.now()),
+          })
+        }
        const part = yield* session.updatePart({
          id: PartID.ascending(),
          messageID: ctx.assistantMessage.id,
@@ -242,10 +334,13 @@ export const layer = Layer.effect(
          metadata: input.providerExecuted ? { providerExecuted: true } : undefined,
        } satisfies SessionV1.ToolPart)
        ctx.toolcalls[input.id] = {
+          assistantMessageID,
          done: yield* Deferred.make<void>(),
          partID: part.id,
          messageID: part.messageID,
          sessionID: part.sessionID,
+          inputEnded: false,
+          raw: "",
        }
        return { call: ctx.toolcalls[input.id], part }
      })
@@ -277,6 +372,16 @@ export const layer = Layer.effect(
        switch (value.type) {
          case "reasoning-start":
            if (value.id in ctx.reasoningMap) return
+            // TODO(v2): Temporary dual-write while migrating session messages to v2 events.
+            if (mirrorAssistant) {
+              yield* events.publish(SessionEvent.Reasoning.Started, {
+                sessionID: ctx.sessionID,
+                assistantMessageID: yield* ensureV2AssistantMessage(),
+                reasoningID: value.id,
+                providerMetadata: value.providerMetadata,
+                timestamp: DateTime.makeUnsafe(Date.now()),
+              })
+            }
            ctx.reasoningMap[value.id] = {
              id: PartID.ascending(),
              messageID: ctx.assistantMessage.id,
@@ -294,6 +399,15 @@ export const layer = Layer.effect(
            if (!(value.id in ctx.reasoningMap)) return
            ctx.reasoningMap[value.id].text += value.text
            if (value.providerMetadata) ctx.reasoningMap[value.id].metadata = value.providerMetadata
+            if (mirrorAssistant) {
+              yield* events.publish(SessionEvent.Reasoning.Delta, {
+                sessionID: ctx.sessionID,
+                assistantMessageID: yield* currentV2AssistantMessage(),
+                reasoningID: value.id,
+                delta: value.text,
+                timestamp: DateTime.makeUnsafe(Date.now()),
+              })
+            }
            yield* session.updatePartDelta({
              sessionID: ctx.reasoningMap[value.id].sessionID,
              messageID: ctx.reasoningMap[value.id].messageID,
@@ -318,11 +432,36 @@ export const layer = Layer.effect(
            return

          case "tool-input-delta":
-            yield* ensureToolCall(value)
+            {
+              const toolCall = yield* ensureToolCall(value)
+              const assistantMessageID = mirrorAssistant ? yield* requireV2AssistantMessage(toolCall.call) : undefined
+              if (assistantMessageID) {
+                yield* events.publish(SessionEvent.Tool.Input.Delta, {
+                  sessionID: ctx.sessionID,
+                  assistantMessageID,
+                  callID: value.id,
+                  delta: value.text,
+                  timestamp: DateTime.makeUnsafe(Date.now()),
+                })
+              }
+              ctx.toolcalls[value.id] = { ...toolCall.call, raw: toolCall.call.raw + value.text }
+            }
            return

          case "tool-input-end": {
-            yield* ensureToolCall(value)
+            const toolCall = yield* ensureToolCall(value)
+            // TODO(v2): Temporary dual-write while migrating session messages to v2 events.
+            if (mirrorAssistant) {
+              const assistantMessageID = yield* requireV2AssistantMessage(toolCall.call)
+              yield* events.publish(SessionEvent.Tool.Input.Ended, {
+                sessionID: ctx.sessionID,
+                assistantMessageID,
+                callID: value.id,
+                text: toolCall.call.raw,
+                timestamp: DateTime.makeUnsafe(Date.now()),
+              })
+            }
+            ctx.toolcalls[value.id] = { ...toolCall.call, inputEnded: true }
            return
          }

@@ -330,8 +469,37 @@ export const layer = Layer.effect(
            if (ctx.assistantMessage.summary) {
              throw new Error(`Tool call not allowed while generating summary: ${value.name}`)
            }
-            yield* ensureToolCall(value)
+            const toolCall = yield* ensureToolCall(value)
            const input = isRecord(value.input) ? value.input : { value: value.input }
+            if (!toolCall.call.inputEnded) {
+              // TODO(v2): Temporary dual-write while migrating session messages to v2 events.
+              if (mirrorAssistant) {
+                const assistantMessageID = yield* requireV2AssistantMessage(toolCall.call)
+                yield* events.publish(SessionEvent.Tool.Input.Ended, {
+                  sessionID: ctx.sessionID,
+                  assistantMessageID,
+                  callID: value.id,
+                  text: toolCall.call.raw,
+                  timestamp: DateTime.makeUnsafe(Date.now()),
+                })
+              }
+            }
+            // TODO(v2): Temporary dual-write while migrating session messages to v2 events.
+            if (mirrorAssistant) {
+              const assistantMessageID = yield* requireV2AssistantMessage(toolCall.call)
+              yield* events.publish(SessionEvent.Tool.Called, {
+                sessionID: ctx.sessionID,
+                assistantMessageID,
+                callID: value.id,
+                tool: value.name,
+                input,
+                provider: {
+                  executed: toolCall.part.metadata?.providerExecuted === true,
+                  ...(value.providerMetadata ? { metadata: value.providerMetadata } : {}),
+                },
+                timestamp: DateTime.makeUnsafe(Date.now()),
+              })
+            }
            yield* updateToolCall(value.id, (match) => ({
              ...match,
              tool: value.name,
@@ -382,6 +550,22 @@ export const layer = Layer.effect(
            const toolCall = yield* readToolCall(value.id)
            if (!toolCall && value.result.type === "error") return
            if (value.result.type === "error") {
+              // TODO(v2): Temporary dual-write while migrating session messages to v2 events.
+              if (mirrorAssistant) {
+                const assistantMessageID = yield* requireV2AssistantMessage(toolCall?.call)
+                yield* events.publish(SessionEvent.Tool.Failed, {
+                  sessionID: ctx.sessionID,
+                  assistantMessageID,
+                  callID: value.id,
+                  error: { type: "unknown", message: errorMessage(value.result.value) },
+                  result: value.result,
+                  provider: {
+                    executed: value.providerExecuted === true || toolCall?.part.metadata?.providerExecuted === true,
+                    ...(value.providerMetadata ? { metadata: value.providerMetadata } : {}),
+                  },
+                  timestamp: DateTime.makeUnsafe(Date.now()),
+                })
+              }
              yield* failToolCall(value.id, value.result.value)
              return
            }
@@ -407,11 +591,81 @@ export const layer = Layer.effect(
                  : `${rawOutput.output}\n\n[${omitted} image${omitted === 1 ? "" : "s"} omitted: could not be resized below the image size limit.]`,
              attachments: attachments.length ? attachments : undefined,
            }
+            // TODO(v2): Temporary dual-write while migrating session messages to v2 events.
+            if (mirrorAssistant) {
+              const assistantMessageID = yield* requireV2AssistantMessage(toolCall?.call)
+              const content = [
+                { type: "text" as const, text: output.output },
+                ...(output.attachments?.map(
+                  (item: SessionV1.FilePart) =>
+                    ({
+                      type: "file",
+                      uri: item.url,
+                      mime: item.mime,
+                      name: item.filename,
+                    }) as const,
+                ) ?? []),
+              ]
+              const unsupported = content.find((item) => item.type === "file" && !item.uri.startsWith("data:"))
+              if (unsupported?.type === "file") {
+                const error = new Error(
+                  `Tool attachment URI "${unsupported.uri}" must be materialized before durable V2 settlement`,
+                )
+                yield* events.publish(SessionEvent.Tool.Failed, {
+                  sessionID: ctx.sessionID,
+                  assistantMessageID,
+                  callID: value.id,
+                  error: {
+                    type: "unknown",
+                    message: error.message,
+                  },
+                  provider: {
+                    executed: value.providerExecuted === true || toolCall?.part.metadata?.providerExecuted === true,
+                    ...(value.providerMetadata ? { metadata: value.providerMetadata } : {}),
+                  },
+                  timestamp: DateTime.makeUnsafe(Date.now()),
+                })
+                yield* failToolCall(value.id, error)
+                return
+              } else
+                yield* events.publish(SessionEvent.Tool.Success, {
+                  sessionID: ctx.sessionID,
+                  assistantMessageID,
+                  callID: value.id,
+                  structured: output.metadata,
+                  content,
+                  result: value.result,
+                  provider: {
+                    executed: value.providerExecuted === true || toolCall?.part.metadata?.providerExecuted === true,
+                    ...(value.providerMetadata ? { metadata: value.providerMetadata } : {}),
+                  },
+                  timestamp: DateTime.makeUnsafe(Date.now()),
+                })
+            }
            yield* completeToolCall(value.id, output)
            return
          }

          case "tool-error": {
+            const toolCall = yield* readToolCall(value.id)
+            // TODO(v2): Temporary dual-write while migrating session messages to v2 events.
+            if (mirrorAssistant) {
+              const assistantMessageID = yield* requireV2AssistantMessage(toolCall?.call)
+              yield* events.publish(SessionEvent.Tool.Failed, {
+                sessionID: ctx.sessionID,
+                assistantMessageID,
+                callID: value.id,
+                error: {
+                  type: "unknown",
+                  message: value.message,
+                },
+                provider: {
+                  executed: toolCall?.part.metadata?.providerExecuted === true,
+                  ...(value.providerMetadata ? { metadata: value.providerMetadata } : {}),
+                },
+                timestamp: DateTime.makeUnsafe(Date.now()),
+              })
+            }
            yield* failToolCall(value.id, value.error ?? new Error(value.message))
            return
          }
@@ -421,6 +675,12 @@ export const layer = Layer.effect(

          case "step-start":
            if (!ctx.snapshot) ctx.snapshot = yield* snapshot.track()
+            if (!ctx.assistantMessage.summary) {
+              // TODO(v2): Temporary dual-write while migrating session messages to v2 events.
+              if (mirrorAssistant) {
+                yield* ensureV2AssistantMessage()
+              }
+            }
            yield* session.updatePart({
              id: PartID.ascending(),
              messageID: ctx.assistantMessage.id,
@@ -438,6 +698,21 @@ export const layer = Layer.effect(
              usage: value.usage ?? new Usage({}),
              metadata: value.providerMetadata,
            })
+            if (!ctx.assistantMessage.summary) {
+              // TODO(v2): Temporary dual-write while migrating session messages to v2 events.
+              if (mirrorAssistant) {
+                yield* events.publish(SessionEvent.Step.Ended, {
+                  sessionID: ctx.sessionID,
+                  assistantMessageID: yield* currentV2AssistantMessage(),
+                  finish: value.reason,
+                  cost: usage.cost,
+                  tokens: usage.tokens,
+                  snapshot: completedSnapshot,
+                  timestamp: DateTime.makeUnsafe(Date.now()),
+                })
+                ctx.v2AssistantMessageID = undefined
+              }
+            }
            ctx.assistantMessage.finish = value.reason
            ctx.assistantMessage.cost += usage.cost
            ctx.assistantMessage.tokens = usage.tokens
@@ -482,6 +757,17 @@ export const layer = Layer.effect(
          }

          case "text-start":
+            if (!ctx.assistantMessage.summary) {
+              // TODO(v2): Temporary dual-write while migrating session messages to v2 events.
+              if (mirrorAssistant) {
+                yield* events.publish(SessionEvent.Text.Started, {
+                  sessionID: ctx.sessionID,
+                  assistantMessageID: yield* ensureV2AssistantMessage(),
+                  timestamp: DateTime.makeUnsafe(Date.now()),
+                  textID: value.id,
+                })
+              }
+            }
            ctx.currentText = {
              id: PartID.ascending(),
              messageID: ctx.assistantMessage.id,
@@ -491,6 +777,7 @@ export const layer = Layer.effect(
              time: { start: Date.now() },
              metadata: value.providerMetadata,
            }
+            ctx.currentTextID = value.id
            yield* session.updatePart(ctx.currentText)
            return

@@ -498,6 +785,15 @@ export const layer = Layer.effect(
            if (!ctx.currentText) return
            ctx.currentText.text += value.text
            if (value.providerMetadata) ctx.currentText.metadata = value.providerMetadata
+            if (mirrorAssistant) {
+              yield* events.publish(SessionEvent.Text.Delta, {
+                sessionID: ctx.sessionID,
+                assistantMessageID: yield* currentV2AssistantMessage(),
+                textID: value.id,
+                delta: value.text,
+                timestamp: DateTime.makeUnsafe(Date.now()),
+              })
+            }
            yield* session.updatePartDelta({
              sessionID: ctx.currentText.sessionID,
              messageID: ctx.currentText.messageID,
@@ -520,6 +816,18 @@ export const layer = Layer.effect(
              },
              { text: ctx.currentText.text },
            )).text
+            if (!ctx.assistantMessage.summary) {
+              // TODO(v2): Temporary dual-write while migrating session messages to v2 events.
+              if (mirrorAssistant) {
+                yield* events.publish(SessionEvent.Text.Ended, {
+                  sessionID: ctx.sessionID,
+                  assistantMessageID: yield* currentV2AssistantMessage(),
+                  text: ctx.currentText.text,
+                  timestamp: DateTime.makeUnsafe(Date.now()),
+                  textID: value.id,
+                })
+              }
+            }
            {
              const end = Date.now()
              ctx.currentText.time = { start: ctx.currentText.time?.start ?? end, end }
@@ -527,6 +835,7 @@ export const layer = Layer.effect(
            if (value.providerMetadata) ctx.currentText.metadata = value.providerMetadata
            yield* session.updatePart(ctx.currentText)
            ctx.currentText = undefined
+            ctx.currentTextID = undefined
            return

          case "finish":
@@ -555,6 +864,7 @@ export const layer = Layer.effect(
          ctx.currentText.time = { start: ctx.currentText.time?.start ?? end, end }
          yield* session.updatePart(ctx.currentText)
          ctx.currentText = undefined
+          ctx.currentTextID = undefined
        }

        for (const part of Object.values(ctx.reasoningMap)) {
@@ -576,6 +886,16 @@ export const layer = Layer.effect(
          const match = yield* readToolCall(toolCallID)
          if (!match) continue
          const part = match.part
+          if (mirrorAssistant && match.call.assistantMessageID) {
+            yield* events.publish(SessionEvent.Tool.Failed, {
+              sessionID: ctx.sessionID,
+              assistantMessageID: match.call.assistantMessageID,
+              callID: toolCallID,
+              error: { type: "unknown", message: "Tool execution aborted" },
+              provider: { executed: part.metadata?.providerExecuted === true },
+              timestamp: DateTime.makeUnsafe(Date.now()),
+            })
+          }
          const end = Date.now()
          const metadata = "metadata" in part.state && isRecord(part.state.metadata) ? part.state.metadata : {}
          yield* session.updatePart({
@@ -602,6 +922,7 @@ export const layer = Layer.effect(
          stack: e instanceof Error ? e.stack : undefined,
        })
        const error = parse(e)
+        yield* flushV2Fragments()
        if (SessionV1.ContextOverflowError.isInstance(error)) {
          if ((yield* config.get()).compaction?.auto === false && !ctx.assistantMessage.summary) {
            ctx.assistantMessage.error = error
@@ -614,6 +935,20 @@ export const layer = Layer.effect(
          yield* events.publish(Session.Event.Error, { sessionID: ctx.sessionID, error })
          return
        }
+        if (!ctx.assistantMessage.summary) {
+          // TODO(v2): Temporary dual-write while migrating session messages to v2 events.
+          if (mirrorAssistant) {
+            yield* events.publish(SessionEvent.Step.Failed, {
+              sessionID: ctx.sessionID,
+              assistantMessageID: yield* ensureV2AssistantMessage(),
+              error: {
+                type: "unknown",
+                message: errorMessage(e),
+              },
+              timestamp: DateTime.makeUnsafe(Date.now()),
+            })
+          }
+        }
        ctx.assistantMessage.error = error
        yield* events.publish(Session.Event.Error, {
          sessionID: ctx.assistantMessage.sessionID,
@@ -633,6 +968,7 @@ export const layer = Layer.effect(
        return yield* Effect.gen(function* () {
          yield* Effect.gen(function* () {
            ctx.currentText = undefined
+            ctx.currentTextID = undefined
            ctx.reasoningMap = {}
            yield* status.set(ctx.sessionID, { type: "busy" })
            const stream = llm.stream(streamInput)
@@ -660,13 +996,30 @@ export const layer = Layer.effect(
                provider: input.model.providerID,
                parse,
                set: (info) => {
-                  return status.set(ctx.sessionID, {
-                    type: "retry",
-                    attempt: info.attempt,
-                    message: info.message,
-                    action: info.action,
-                    next: info.next,
-                  })
+                  // TODO(v2): Temporary dual-write while migrating session messages to v2 events.
+                  const event = mirrorAssistant
+                    ? events.publish(SessionEvent.Retried, {
+                        sessionID: ctx.sessionID,
+                        attempt: info.attempt,
+                        error: {
+                          message: info.message,
+                          isRetryable: true,
+                        },
+                        timestamp: DateTime.makeUnsafe(Date.now()),
+                      })
+                    : Effect.void
+                  return flushV2Fragments().pipe(
+                    Effect.andThen(event),
+                    Effect.andThen(
+                      status.set(ctx.sessionID, {
+                        type: "retry",
+                        attempt: info.attempt,
+                        message: info.message,
+                        action: info.action,
+                        next: info.next,
+                      }),
+                    ),
+                  )
                },
              }),
            ),
@@ -706,6 +1059,7 @@ export const defaultLayer = Layer.suspend(() =>
    Layer.provide(SessionStatus.defaultLayer),
    Layer.provide(Image.defaultLayer),
    Layer.provide(Config.defaultLayer),
+    Layer.provide(RuntimeFlags.defaultLayer),
    Layer.provide(Database.defaultLayer),
    Layer.provide(EventV2Bridge.defaultLayer),
  ),
@@ -726,6 +1080,7 @@ export const node = LayerNode.make({
    SessionStatus.node,
    Image.node,
    EventV2Bridge.node,
+    RuntimeFlags.node,
    Database.node,
  ],
 })
@@ -49,8 +49,12 @@ import { SessionRunState } from "./run-state"
 import { RuntimeFlags } from "@/effect/runtime-flags"
 import { EventV2Bridge } from "@/event-v2-bridge"
 import { Database } from "@opencode-ai/core/database/database"
+import { SessionEvent } from "@opencode-ai/core/session/event"
+import { SessionMessage } from "@opencode-ai/core/session/message"
 import { ModelV2 } from "@opencode-ai/core/model"
 import { ProviderV2 } from "@opencode-ai/core/provider"
+import { AgentAttachment, FileAttachment, Prompt, Source } from "@opencode-ai/core/session/prompt"
+import * as DateTime from "effect/DateTime"
 import { eq } from "drizzle-orm"
 import { SessionTable } from "@opencode-ai/core/session/sql"
 import { SessionReminders } from "./reminders"
@@ -516,6 +520,15 @@ export const layer = Layer.effect(
              },
            }
            yield* sessions.updatePart(part)
+            if (flags.experimentalEventSystem) {
+              yield* events.publish(SessionEvent.Shell.Started, {
+                sessionID: input.sessionID,
+                messageID: SessionMessage.ID.create(),
+                timestamp: DateTime.makeUnsafe(started),
+                callID: part.callID,
+                command: input.command,
+              })
+            }
            return { msg, part, cwd: ctx.directory }
          }).pipe(Effect.ensuring(markReady))

@@ -531,6 +544,14 @@ export const layer = Layer.effect(
                output += "\n\n" + ["<metadata>", "User aborted the command", "</metadata>"].join("\n")
              }
              const completed = Date.now()
+              if (flags.experimentalEventSystem) {
+                yield* events.publish(SessionEvent.Shell.Ended, {
+                  sessionID: input.sessionID,
+                  timestamp: DateTime.makeUnsafe(completed),
+                  callID: part.callID,
+                  output,
+                })
+              }
              if (!msg.time.completed) {
                msg.time.completed = completed
                yield* sessions.updateMessage(msg)
@@ -643,6 +664,12 @@ export const layer = Layer.effect(
        throw error
      }

+      const current = yield* db
+        .select({ agent: SessionTable.agent, model: SessionTable.model })
+        .from(SessionTable)
+        .where(eq(SessionTable.id, input.sessionID))
+        .get()
+        .pipe(Effect.orDie)
      const model = input.model ?? ag.model ?? (yield* currentModel(input.sessionID))
      const same = ag.model && model.providerID === ag.model.providerID && model.modelID === ag.model.modelID
      const full =
@@ -669,22 +696,28 @@ export const layer = Layer.effect(
        format: input.format,
      }

-      const current = yield* sessions.get(input.sessionID).pipe(Effect.orDie)
-      if (
-        current.agent !== info.agent ||
-        current.model?.providerID !== info.model.providerID ||
-        current.model?.id !== info.model.modelID ||
-        (current.model?.variant === "default" ? undefined : current.model?.variant) !== info.model.variant
-      ) {
-        yield* sessions.setAgentModel({
+      if (current?.agent !== info.agent) {
+        yield* events.publish(SessionEvent.AgentSwitched, {
          sessionID: input.sessionID,
+          messageID: SessionMessage.ID.create(),
+          timestamp: DateTime.makeUnsafe(info.time.created),
          agent: info.agent,
+        })
+      }
+      if (
+        current?.model?.providerID !== info.model.providerID ||
+        current.model.id !== info.model.modelID ||
+        (current.model.variant === "default" ? undefined : current.model.variant) !== info.model.variant
+      ) {
+        yield* events.publish(SessionEvent.ModelSwitched, {
+          sessionID: input.sessionID,
+          messageID: SessionMessage.ID.create(),
+          timestamp: DateTime.makeUnsafe(info.time.created),
          model: {
-            id: info.model.modelID,
-            providerID: info.model.providerID,
-            variant: info.model.variant ?? "default",
+            id: ModelV2.ID.make(info.model.modelID),
+            providerID: ProviderV2.ID.make(info.model.providerID),
+            variant: ModelV2.VariantID.make(info.model.variant ?? "default"),
          },
-          time: info.time.created,
        })
      }

@@ -1045,6 +1078,76 @@ export const layer = Layer.effect(

      yield* sessions.updateMessage(info)
      for (const part of parts) yield* sessions.updatePart(part)
+      const nextPrompt = parts.reduce(
+        (result, part) => {
+          if (part.type === "text") {
+            if (part.synthetic) result.synthetic.push(part.text)
+            else result.text.push(part.text)
+          }
+          if (part.type === "file") {
+            result.files.push(
+              FileAttachment.make({
+                uri: part.url,
+                mime: part.mime,
+                name: part.filename,
+                source: part.source
+                  ? Source.make({
+                      start: part.source.text.start,
+                      end: part.source.text.end,
+                      text: part.source.text.value,
+                    })
+                  : undefined,
+              }),
+            )
+          }
+          if (part.type === "agent") {
+            result.agents.push(
+              AgentAttachment.make({
+                name: part.name,
+                source: part.source
+                  ? Source.make({
+                      start: part.source.start,
+                      end: part.source.end,
+                      text: part.source.value,
+                    })
+                  : undefined,
+              }),
+            )
+          }
+          return result
+        },
+        {
+          text: [] as string[],
+          files: [] as FileAttachment[],
+          agents: [] as AgentAttachment[],
+          synthetic: [] as string[],
+        },
+      )
+      // TODO(v2): Temporary dual-write while migrating session messages to v2 events.
+      if (flags.experimentalEventSystem) {
+        yield* events.publish(SessionEvent.Prompted, {
+          sessionID: input.sessionID,
+          messageID: SessionMessage.ID.create(),
+          timestamp: DateTime.makeUnsafe(info.time.created),
+          delivery: "steer",
+          prompt: Prompt.make({
+            text: nextPrompt.text.join("\n"),
+            files: nextPrompt.files,
+            agents: nextPrompt.agents,
+          }),
+        })
+      }
+      for (const text of nextPrompt.synthetic) {
+        // TODO(v2): Temporary dual-write while migrating session messages to v2 events.
+        if (flags.experimentalEventSystem) {
+          yield* events.publish(SessionEvent.Synthetic, {
+            sessionID: input.sessionID,
+            messageID: SessionMessage.ID.create(),
+            timestamp: DateTime.makeUnsafe(info.time.created),
+            text,
+          })
+        }
+      }

      return { info, parts }
    }, Effect.scoped)
@@ -12,8 +12,7 @@ import { Database } from "@opencode-ai/core/database/database"
 import { makeRuntime } from "@opencode-ai/core/effect/runtime"
 import { EventV2Bridge } from "@/event-v2-bridge"
 import { SessionV2 } from "@opencode-ai/core/session"
-import * as SessionExecutionLocal from "@opencode-ai/core/session/execution/local"
-import { LocationServiceMap } from "@opencode-ai/core/location-layer"
+import { SessionExecution } from "@opencode-ai/core/session/execution"

 import { NotFoundError } from "@/storage/storage"
 import { eq } from "drizzle-orm"
@@ -433,12 +432,6 @@ export interface Interface {
  readonly setTitle: (input: { sessionID: SessionID; title: string }) => Effect.Effect<void>
  readonly setArchived: (input: { sessionID: SessionID; time?: number }) => Effect.Effect<void>
  readonly setMetadata: (input: typeof SetMetadataInput.Type) => Effect.Effect<void>
-  readonly setAgentModel: (input: {
-    sessionID: SessionID
-    agent: string
-    model: NonNullable<Info["model"]>
-    time: number
-  }) => Effect.Effect<void>
  readonly setPermission: (input: { sessionID: SessionID; permission: PermissionV1.Ruleset }) => Effect.Effect<void>
  readonly setRevert: (input: {
    sessionID: SessionID
@@ -767,19 +760,6 @@ export const layer: Layer.Layer<
      yield* patch(input.sessionID, { metadata: input.metadata, time: { updated: Date.now() } }).pipe(Effect.orDie)
    })

-    const setAgentModel = Effect.fn("Session.setAgentModel")(function* (input: {
-      sessionID: SessionID
-      agent: string
-      model: NonNullable<Info["model"]>
-      time: number
-    }) {
-      yield* patch(input.sessionID, {
-        agent: input.agent,
-        model: input.model,
-        time: { updated: input.time },
-      }).pipe(Effect.orDie)
-    })
-
    const setPermission = Effect.fn("Session.setPermission")(function* (input: {
      sessionID: SessionID
      permission: PermissionV1.Ruleset
@@ -918,7 +898,6 @@ export const layer: Layer.Layer<
      setTitle,
      setArchived,
      setMetadata,
-      setAgentModel,
      setPermission,
      setRevert,
      clearRevert,
@@ -944,12 +923,8 @@ export const defaultLayer = layer.pipe(
  Layer.provide(BackgroundJob.defaultLayer),
  Layer.provide(Database.defaultLayer),
  Layer.provide(EventV2Bridge.defaultLayer),
-  Layer.provide(
-    SessionV2.defaultLayer.pipe(
-      Layer.provide(SessionExecutionLocal.defaultLayer),
-      Layer.provide(LocationServiceMap.layer),
-    ),
-  ),
+  Layer.provide(SessionExecution.noopLayer),
+  Layer.provide(SessionV2.defaultLayer),
  Layer.provide(RuntimeFlags.defaultLayer),
 )

@@ -964,7 +964,6 @@ const scenarios: Scenario[] = [
      headers: ctx.headers(),
    }))
    .status(400, undefined, "none"),
-  http.protected.get("/api/session/active", "v2.session.active").json(200, data(object), "none"),
  http.protected
    .post("/api/session", "v2.session.create")
    .at((ctx) => ({
@@ -34,7 +34,7 @@ import { resetDatabase } from "../fixture/db"
 import { disposeAllInstances, provideInstanceEffect, TestInstance, tmpdirScoped } from "../fixture/fixture"
 import { TestLLMServer } from "../lib/llm-server"
 import { testProviderConfig } from "../lib/test-provider"
-import { pollWithTimeout, testEffect } from "../lib/effect"
+import { testEffect } from "../lib/effect"

 const originalWorkspaces = Flag.OPENCODE_EXPERIMENTAL_WORKSPACES
 const workspaceLayer = Workspace.defaultLayer.pipe(
@@ -581,7 +581,7 @@ describe("session HttpApi", () => {
          request(`/api/session/${session.id}/prompt`, {
            method: "POST",
            headers: { ...headers, "content-type": "application/json" },
-            body: JSON.stringify({ id: "msg_http_prompt", prompt: { text: "hello" }, resume: false }),
+            body: JSON.stringify({ id: "msg_http_prompt", prompt: { text: "hello" } }),
          })
        const first = yield* recordPrompt()
        const retried = yield* recordPrompt()
@@ -624,22 +624,6 @@ describe("session HttpApi", () => {
          message: "Prompt message ID conflicts with an existing durable record: msg_http_prompt",
          resource: "msg_http_prompt",
        })
-
-        const wakeID = SessionMessage.ID.make("msg_http_wake")
-        const wake = yield* request(`/api/session/${session.id}/prompt`, {
-          method: "POST",
-          headers: { ...headers, "content-type": "application/json" },
-          body: JSON.stringify({ id: wakeID, prompt: { text: "hello again" } }),
-        })
-        expect(wake.status).toBe(200)
-        const message = yield* pollWithTimeout(
-          requestJson<{ data: SessionMessage.Message[] }>(`/api/session/${session.id}/message`, { headers }).pipe(
-            Effect.map(({ data }) => data.find((message) => message.id === wakeID)),
-          ),
-          "V2 prompt was not promoted after wake",
-          "10 seconds",
-        )
-        expect(message).toMatchObject({ id: wakeID, type: "user" })
      }),
    { git: true, config: { formatter: false, lsp: false } },
  )
@@ -613,7 +613,8 @@ describe("session.compaction.create", () => {
        })

        const v2 = yield* SessionV2.Service.use((svc) => svc.messages({ sessionID: info.id })).pipe(
-          Effect.provide(SessionV2.defaultLayer.pipe(Layer.provide(SessionExecution.noopLayer))),
+          Effect.provide(SessionExecution.noopLayer),
+          Effect.provide(SessionV2.defaultLayer),
        )
        expect(v2.at(-1)).toMatchObject({
          type: "compaction",
@@ -853,12 +854,12 @@ describe("session.compaction.process", () => {
      const msg = yield* createUserMessage(session.id, "hello")
      const msgs = yield* ssn.messages({ sessionID: session.id })
      const done = yield* Deferred.make<void, Error>()
-      const seen: string[] = []
+      let seen = false
      const unsub = yield* events.listen((evt) => {
-        seen.push(evt.type)
        if (evt.type !== SessionCompaction.Event.Compacted.type) return Effect.void
        if ((evt.data as typeof SessionCompaction.Event.Compacted.data.Type).sessionID !== session.id)
          return Effect.void
+        seen = true
        Deferred.doneUnsafe(done, Effect.void)
        return Effect.void
      })
@@ -873,8 +874,7 @@ describe("session.compaction.process", () => {

      yield* Deferred.await(done).pipe(Effect.timeout("500 millis"))
      expect(result).toBe("continue")
-      expect(seen).toContain(SessionCompaction.Event.Compacted.type)
-      expect(seen.filter((type) => type.startsWith("session.next."))).toEqual([])
+      expect(seen).toBe(true)
    }),
  )

@@ -24,6 +24,7 @@ import { raw, reply, TestLLMServer } from "../lib/llm-server"
 import { RuntimeFlags } from "@/effect/runtime-flags"
 import { ProviderV2 } from "@opencode-ai/core/provider"
 import { ModelV2 } from "@opencode-ai/core/model"
+import { SessionEvent } from "@opencode-ai/core/session/event"
 import { SessionProjector } from "@opencode-ai/core/session/projector"
 import { LLMEvent } from "@opencode-ai/llm"

@@ -980,9 +981,10 @@ itProviderError.live("session.processor effect tests fail provider-executed erro
        const parent = yield* user(chat.id, "provider tool error")
        const msg = yield* assistant(chat.id, parent.id, path.resolve(dir))
        const mdl = yield* provider.getModel(ref.providerID, ref.modelID)
-        const seen: string[] = []
+        const settlements: Array<typeof SessionEvent.Tool.Failed.Type> = []
        const off = yield* events.listen((event) => {
-          seen.push(event.type)
+          if (event.type === SessionEvent.Tool.Failed.type)
+            settlements.push(event as typeof SessionEvent.Tool.Failed.Type)
          return Effect.void
        })
        const handle = yield* processors.create({ assistantMessage: msg, sessionID: chat.id, model: mdl })
@@ -1009,15 +1011,19 @@ itProviderError.live("session.processor effect tests fail provider-executed erro
        const call = parts.find((part): part is SessionV1.ToolPart => part.type === "tool")
        expect(call?.state.status).toBe("error")
        if (call?.state.status === "error") expect(call.state.error).toBe("provider boom")
-        expect(seen).toContain(MessageV2.Event.PartUpdated.type)
-        expect(seen).toContain(MessageV2.Event.Updated.type)
-        expect(seen.filter((type) => type.startsWith("session.next."))).toEqual([])
+        expect(settlements).toHaveLength(1)
+        expect(settlements[0]?.data).toMatchObject({
+          callID: "call-1",
+          error: { type: "unknown", message: "provider boom" },
+          result: { type: "error", value: "provider boom" },
+          provider: { executed: true },
+        })
      }),
    { config: cfg },
  ),
 )

-itFragmentFailure.live("session.processor effect tests retain partial legacy parts without v2 events", () =>
+itFragmentFailure.live("session.processor effect tests flush partial v2 fragments before step failure", () =>
  provideTmpdirInstance(
    (dir) =>
      Effect.gen(function* () {
@@ -1029,8 +1035,14 @@ itFragmentFailure.live("session.processor effect tests retain partial legacy par
        const msg = yield* assistant(chat.id, parent.id, path.resolve(dir))
        const mdl = yield* provider.getModel(ref.providerID, ref.modelID)
        const seen: string[] = []
+        let text: string | undefined
+        let reasoning: string | undefined
        const off = yield* events.listen((event) => {
          seen.push(event.type)
+          if (event.type === SessionEvent.Text.Ended.type)
+            text = (event.data as typeof SessionEvent.Text.Ended.data.Type).text
+          if (event.type === SessionEvent.Reasoning.Ended.type)
+            reasoning = (event.data as typeof SessionEvent.Reasoning.Ended.data.Type).text
          return Effect.void
        })
        const handle = yield* processors.create({ assistantMessage: msg, sessionID: chat.id, model: mdl })
@@ -1055,16 +1067,12 @@ itFragmentFailure.live("session.processor effect tests retain partial legacy par
        ).toBe("stop")
        yield* off

-        const parts = yield* MessageV2.parts(msg.id)
-        expect(parts).toEqual(
-          expect.arrayContaining([
-            expect.objectContaining({ type: "text", text: "partial" }),
-            expect.objectContaining({ type: "reasoning", text: "thinking" }),
-          ]),
-        )
-        expect(seen).toContain(MessageV2.Event.PartUpdated.type)
-        expect(seen).toContain(Session.Event.Error.type)
-        expect(seen.filter((type) => type.startsWith("session.next."))).toEqual([])
+        const failed = seen.indexOf(SessionEvent.Step.Failed.type)
+        expect(failed).toBeGreaterThan(-1)
+        expect(seen.indexOf(SessionEvent.Text.Ended.type)).toBeLessThan(failed)
+        expect(seen.indexOf(SessionEvent.Reasoning.Ended.type)).toBeLessThan(failed)
+        expect(text).toBe("partial")
+        expect(reasoning).toBe("thinking")
      }),
    { config: cfg },
  ),
@@ -8,7 +8,7 @@ import { FetchHttpClient } from "effect/unstable/http"
 import { expect } from "bun:test"
 import { Cause, Deferred, Duration, Effect, Exit, Fiber, Layer } from "effect"
 import path from "path"
-import { fileURLToPath } from "url"
+import { fileURLToPath, pathToFileURL } from "url"
 import { NamedError } from "@opencode-ai/core/util/error"
 import { Agent as AgentSvc } from "../../src/agent/agent"
 import { BackgroundJob } from "@/background/job"
@@ -317,6 +317,11 @@ const writeText = Effect.fn("test.writeText")(function* (file: string, text: str
  yield* fs.writeWithDirs(file, text)
 })

+const ensureDir = Effect.fn("test.ensureDir")(function* (dir: string) {
+  const fs = yield* FSUtil.Service
+  yield* fs.ensureDir(dir)
+})
+
 const writeConfig = Effect.fn("test.writeConfig")(function* (dir: string, config: Partial<ConfigV1.Info>) {
  yield* writeText(
    path.join(dir, "opencode.json"),
@@ -549,54 +554,6 @@ withMcpInstructions.instance(
  15_000,
 )

-it.instance("legacy prompt emits message events without session.next events", () =>
-  Effect.gen(function* () {
-    const events = yield* EventV2Bridge.Service
-    const prompt = yield* SessionPrompt.Service
-    const sessions = yield* Session.Service
-    const chat = yield* sessions.create({
-      title: "Pinned",
-      agent: "plan",
-      model: { providerID: ProviderV2.ID.make("old"), id: ModelV2.ID.make("old-model") },
-    })
-    const seen: string[] = []
-    const off = yield* events.listen((event) => {
-      seen.push(event.type)
-      return Effect.void
-    })
-
-    const first = yield* prompt.prompt({
-      sessionID: chat.id,
-      agent: "build",
-      model: ref,
-      noReply: true,
-      parts: [{ type: "text", text: "hello" }],
-    })
-    const second = yield* prompt.prompt({
-      sessionID: chat.id,
-      agent: "build",
-      noReply: true,
-      parts: [{ type: "text", text: "again" }],
-    })
-    yield* off
-
-    expect(first.info.role).toBe("user")
-    expect(second.info.role).toBe("user")
-    if (first.info.role === "user" && second.info.role === "user") {
-      expect(first.info.model).toEqual(ref)
-      expect(second.info.model).toEqual(ref)
-    }
-    expect(yield* sessions.get(chat.id)).toMatchObject({
-      agent: "build",
-      model: { providerID: ref.providerID, id: ref.modelID },
-    })
-    expect(seen).toContain(Session.Event.Updated.type)
-    expect(seen).toContain(MessageV2.Event.Updated.type)
-    expect(seen).toContain(MessageV2.Event.PartUpdated.type)
-    expect(seen.filter((type) => type.startsWith("session.next."))).toEqual([])
-  }),
-)
-
 it.instance("loop surfaces content-filter finishes as session errors", () =>
  Effect.gen(function* () {
    const { llm } = yield* useServerConfig(providerCfg)
@@ -697,7 +654,8 @@ noLLMServer.instance.skip(
      })

      const messages = yield* SessionV2.Service.use((session) => session.messages({ sessionID: chat.id })).pipe(
-        Effect.provide(SessionV2.defaultLayer.pipe(Layer.provide(SessionExecution.noopLayer))),
+        Effect.provide(SessionExecution.noopLayer),
+        Effect.provide(SessionV2.defaultLayer),
      )
      const { db } = yield* Database.Service
      const row = yield* db
@@ -27,9 +27,9 @@
    "zod": "catalog:"
  },
  "peerDependencies": {
-    "@opentui/core": ">=0.3.4",
-    "@opentui/keymap": ">=0.3.4",
-    "@opentui/solid": ">=0.3.4"
+    "@opentui/core": ">=0.4.2",
+    "@opentui/keymap": ">=0.4.2",
+    "@opentui/solid": ">=0.4.2"
  },
  "peerDependenciesMeta": {
    "@opentui/core": {
@@ -73,10 +73,6 @@ export const SessionsCursor = Schema.String.pipe(
 )
 export type SessionsCursor = typeof SessionsCursor.Type

-const SessionActive = Schema.Struct({
-  type: Schema.Literal("running"),
-}).annotate({ identifier: "SessionActive" })
-
 const SessionsQueryCursor = SessionsCursor.annotate({
  description: "Opaque pagination cursor returned as cursor.previous or cursor.next in the previous response.",
 })
@@ -128,18 +124,6 @@ export const makeSessionGroup = <I extends HttpApiMiddleware.AnyId, S>(sessionLo
        }),
      ),
    )
-    .add(
-      HttpApiEndpoint.get("session.active", "/api/session/active", {
-        success: Schema.Struct({ data: Schema.Record(Session.ID, SessionActive) }),
-      }).annotateMerge(
-        OpenApi.annotations({
-          identifier: "v2.session.active",
-          summary: "List active sessions",
-          description:
-            "Retrieve foreground Session drains currently owned by this OpenCode process. Sessions absent from the result are inactive.",
-        }),
-      ),
-    )
    .add(
      HttpApiEndpoint.get("session.get", "/api/session/:sessionID", {
        params: { sessionID: Session.ID },
@@ -50,10 +50,6 @@ const stepSettlementOptions = {

 export const UnknownError = SessionMessage.UnknownError
 export type UnknownError = SessionMessage.UnknownError
-export const ProviderError = SessionMessage.ProviderError
-export type ProviderError = SessionMessage.ProviderError
-export const Error = SessionMessage.Error
-export type Error = SessionMessage.Error

 export const AgentSwitched = Event.define({
  type: "session.next.agent.switched",
@@ -192,7 +188,7 @@ export namespace Step {
    schema: {
      ...Base,
      assistantMessageID: SessionMessage.ID,
-      error: Error,
+      error: UnknownError,
    },
  })
  export type Failed = typeof Failed.Type
@@ -21,33 +21,6 @@ export const UnknownError = Schema.Struct({
  message: Schema.String,
 }).annotate({ identifier: "Session.Error.Unknown" })

-export const ProviderErrorCategory = Schema.Literals([
-  "invalid-request",
-  "no-route",
-  "authentication",
-  "rate-limit",
-  "quota-exceeded",
-  "content-policy",
-  "provider-internal",
-  "transport",
-  "invalid-provider-output",
-  "unknown",
-])
-export type ProviderErrorCategory = typeof ProviderErrorCategory.Type
-
-export interface ProviderError extends Schema.Schema.Type<typeof ProviderError> {}
-export const ProviderError = Schema.Struct({
-  type: Schema.Literal("provider"),
-  category: ProviderErrorCategory,
-  message: Schema.String,
-  status: Schema.Finite.pipe(Schema.optional),
-  retryable: Schema.Boolean,
-  retryAfterMs: Schema.Finite.pipe(Schema.optional),
-}).annotate({ identifier: "Session.Error.Provider" })
-
-export const Error = Schema.Union([UnknownError, ProviderError]).pipe(Schema.toTaggedUnion("type"))
-export type Error = UnknownError | ProviderError
-
 const Base = {
  id: ID,
  metadata: Schema.Record(Schema.String, Schema.Unknown).pipe(optional),
@@ -204,7 +177,7 @@ export const Assistant = Schema.Struct({
    reasoning: Schema.Finite,
    cache: Schema.Struct({ read: Schema.Finite, write: Schema.Finite }),
  }).pipe(optional),
-  error: Error.pipe(optional),
+  error: UnknownError.pipe(optional),
  time: Schema.Struct({
    created: DateTimeUtcFromMillis,
    completed: DateTimeUtcFromMillis.pipe(optional),
@@ -33,24 +33,12 @@ test("embedded client uses the real router and handlers", async () => {
      yield* opencode.sessions.switchModel({ sessionID, model })
      const selected = yield* opencode.sessions.get({ sessionID })
      const page = yield* opencode.sessions.list({ directory: AbsolutePath.make(directory) })
-      const active = yield* opencode.sessions.active()
      const admitted = yield* opencode.sessions.prompt({
        sessionID,
        prompt: Prompt.make({ text: "Do not run" }),
        resume: false,
      })
      const context = yield* opencode.sessions.context({ sessionID })
-      const wake = yield* opencode.sessions.prompt({
-        sessionID,
-        prompt: Prompt.make({ text: "Promote this input" }),
-      })
-      const prompted = yield* opencode.sessions.events({ sessionID }).pipe(
-        Stream.filter((event) => event.type === "session.next.prompted" && event.data.messageID === wake.id),
-        Stream.runHead,
-        Effect.timeout("10 seconds"),
-        Effect.map(Option.getOrThrow),
-      )
-      const wakeContext = yield* opencode.sessions.context({ sessionID })
      const event = yield* opencode.sessions
        .events({ sessionID })
        .pipe(Stream.take(1), Stream.runHead, Effect.map(Option.getOrUndefined))
@@ -82,10 +70,7 @@ test("embedded client uses the real router and handlers", async () => {
      expect(selected.model?.id).toBe(model.id)
      expect(selected.model?.providerID).toBe(model.providerID)
      expect(page.data.some((session) => session.id === sessionID)).toBe(true)
-      expect(active).toEqual({})
      expect(admitted.sessionID).toBe(sessionID)
-      expect(prompted.type).toBe("session.next.prompted")
-      expect(wakeContext).toContainEqual(expect.objectContaining({ id: wake.id, type: "user" }))
      expect(context.some((message) => message.type === "model-switched")).toBe(true)
      expect(event).toMatchObject({ type: "session.next.model.switched", durable: { seq: 1 } })
      expect(message).toEqual(modelMessage)
@@ -333,8 +333,6 @@ import type {
  V2QuestionRequestListResponses,
  V2ReferenceListErrors,
  V2ReferenceListResponses,
-  V2SessionActiveErrors,
-  V2SessionActiveResponses,
  V2SessionCompactErrors,
  V2SessionCompactResponses,
  V2SessionContextErrors,
@@ -5503,18 +5501,6 @@ export class Session3 extends HeyApiClient {
    })
  }

-  /**
-   * List active sessions
-   *
-   * Retrieve foreground Session drains currently owned by this OpenCode process. Sessions absent from the result are inactive.
-   */
-  public active<ThrowOnError extends boolean = false>(options?: Options<never, ThrowOnError>) {
-    return (options?.client ?? this.client).get<V2SessionActiveResponses, V2SessionActiveErrors, ThrowOnError>({
-      url: "/api/session/active",
-      ...options,
-    })
-  }
-
  /**
   * Get session
   *
@@ -952,7 +952,7 @@ export type GlobalEvent = {
          timestamp: number
          sessionID: string
          assistantMessageID: string
-          error: SessionErrorUnknown | SessionErrorProvider
+          error: SessionErrorUnknown
        }
      }
    | {
@@ -2690,10 +2690,6 @@ export type InvalidCursorError = {
  message: string
 }

-export type SessionActive = {
-  type: "running"
-}
-
 export type SessionNotFoundError = {
  _tag: "SessionNotFoundError"
  sessionID: string
@@ -2955,25 +2951,6 @@ export type SessionErrorUnknown = {
  message: string
 }

-export type SessionErrorProvider = {
-  type: "provider"
-  category:
-    | "invalid-request"
-    | "no-route"
-    | "authentication"
-    | "rate-limit"
-    | "quota-exceeded"
-    | "content-policy"
-    | "provider-internal"
-    | "transport"
-    | "invalid-provider-output"
-    | "unknown"
-  message: string
-  status?: number
-  retryable: boolean
-  retryAfterMs?: number
-}
-
 export type LlmProviderMetadata = {
  [key: string]: {
    [key: string]: unknown
@@ -3418,7 +3395,7 @@ export type SyncEventSessionNextStepFailed = {
      timestamp: number
      sessionID: string
      assistantMessageID: string
-      error: SessionErrorUnknown | SessionErrorProvider
+      error: SessionErrorUnknown
    }
  }
 }
@@ -4028,7 +4005,7 @@ export type SessionMessageAssistant = {
      write: number
    }
  }
-  error?: SessionErrorUnknown | SessionErrorProvider
+  error?: SessionErrorUnknown
 }

 export type SessionMessageCompaction = {
@@ -4308,7 +4285,7 @@ export type SessionNextStepFailed = {
    timestamp: number
    sessionID: string
    assistantMessageID: string
-    error: SessionErrorUnknown | SessionErrorProvider
+    error: SessionErrorUnknown
  }
 }

@@ -5363,7 +5340,7 @@ export type V2EventSessionNextStepFailed = {
    timestamp: number
    sessionID: string
    assistantMessageID: string
-    error: SessionErrorUnknown | SessionErrorProvider
+    error: SessionErrorUnknown
  }
 }

@@ -6950,7 +6927,7 @@ export type EventSessionNextStepFailed = {
    timestamp: number
    sessionID: string
    assistantMessageID: string
-    error: SessionErrorUnknown | SessionErrorProvider
+    error: SessionErrorUnknown
  }
 }

@@ -11963,39 +11940,6 @@ export type V2SessionCreateResponses = {

 export type V2SessionCreateResponse = V2SessionCreateResponses[keyof V2SessionCreateResponses]

-export type V2SessionActiveData = {
-  body?: never
-  path?: never
-  query?: never
-  url: "/api/session/active"
-}
-
-export type V2SessionActiveErrors = {
-  /**
-   * InvalidRequestError
-   */
-  400: InvalidRequestError
-  /**
-   * UnauthorizedError
-   */
-  401: UnauthorizedError
-}
-
-export type V2SessionActiveError = V2SessionActiveErrors[keyof V2SessionActiveErrors]
-
-export type V2SessionActiveResponses = {
-  /**
-   * Success
-   */
-  200: {
-    data: {
-      [key: string]: unknown | SessionActive
-    }
-  }
-}
-
-export type V2SessionActiveResponse = V2SessionActiveResponses[keyof V2SessionActiveResponses]
-
 export type V2SessionGetData = {
  body?: never
  path: {
@@ -10187,66 +10187,6 @@
        ]
      }
    },
-    "/api/session/active": {
-      "get": {
-        "tags": ["sessions"],
-        "operationId": "v2.session.active",
-        "parameters": [],
-        "security": [],
-        "responses": {
-          "200": {
-            "description": "Success",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "type": "object",
-                  "properties": {
-                    "data": {
-                      "type": "object",
-                      "patternProperties": {
-                        "^ses": {
-                          "$ref": "#/components/schemas/SessionActive"
-                        }
-                      }
-                    }
-                  },
-                  "required": ["data"],
-                  "additionalProperties": false
-                }
-              }
-            }
-          },
-          "400": {
-            "description": "InvalidRequestError",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/InvalidRequestError"
-                }
-              }
-            }
-          },
-          "401": {
-            "description": "UnauthorizedError",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/UnauthorizedError"
-                }
-              }
-            }
-          }
-        },
-        "description": "Retrieve foreground Session drains currently owned by this OpenCode process. Sessions absent from the result are inactive.",
-        "summary": "List active sessions",
-        "x-codeSamples": [
-          {
-            "lang": "js",
-            "source": "import { createOpencodeClient } from \"@opencode-ai/sdk\n\nconst client = createOpencodeClient()\nawait client.v2.session.active({\n  ...\n})"
-          }
-        ]
-      }
-    },
    "/api/session/{sessionID}": {
      "get": {
        "tags": ["sessions"],
@@ -23505,17 +23445,6 @@
        "required": ["_tag", "message"],
        "additionalProperties": false
      },
-      "SessionActive": {
-        "type": "object",
-        "properties": {
-          "type": {
-            "type": "string",
-            "enum": ["running"]
-          }
-        },
-        "required": ["type"],
-        "additionalProperties": false
-      },
      "SessionNotFoundError": {
        "type": "object",
        "properties": {
@@ -26,11 +26,6 @@ import { CredentialHandler } from "./handlers/credential"
 import { Credential } from "@opencode-ai/core/credential"
 import { ProjectCopyHandler } from "./handlers/project-copy"

-const sessionLayer = SessionV2.defaultLayer.pipe(
-  Layer.provide(SessionExecutionLocal.defaultLayer),
-  Layer.provide(LocationServiceMap.layer),
-)
-
 export const handlers = Layer.mergeAll(
  HealthHandler,
  LocationHandler,
@@ -53,7 +48,8 @@ export const handlers = Layer.mergeAll(
 ).pipe(
  Layer.provide(sessionLocationLayer),
  Layer.provide(locationLayer),
-  Layer.provide(sessionLayer),
+  Layer.provide(SessionV2.defaultLayer),
+  Layer.provide(SessionExecutionLocal.defaultLayer),
  Layer.provide(PermissionSaved.defaultLayer),
  Layer.provide(PtyTicket.defaultLayer),
  Layer.provide(LocationServiceMap.layer),
@@ -76,16 +76,6 @@ export const SessionHandler = HttpApiBuilder.group(Api, "server.session", (handl
          }
        }),
      )
-      .handle(
-        "session.active",
-        Effect.fn(function* () {
-          return {
-            data: Object.fromEntries(
-              Array.from(yield* session.active, (sessionID) => [sessionID, { type: "running" as const }]),
-            ),
-          }
-        }),
-      )
      .handle(
        "session.get",
        Effect.fn(function* (ctx) {
@@ -366,8 +366,8 @@ function ApiMethod(props: ApiMethodProps) {
    <DialogPrompt
      title={props.title}
      placeholder="API key"
-      description={
-        {
+      description={() =>
+        ({
          opencode: (
            <box gap={1}>
              <text fg={theme.textMuted}>
@@ -390,7 +390,7 @@ function ApiMethod(props: ApiMethodProps) {
              </text>
            </box>
          ),
-        }[props.providerID] ?? undefined
+        })[props.providerID] ?? undefined
      }
      onConfirm={async (value) => {
        if (!value) return
@@ -1528,7 +1528,7 @@ function AssistantMessage(props: { message: AssistantMessage; parts: Part[]; las
          customBorderChars={SplitBorder.customBorderChars}
          borderColor={theme.error}
        >
-          <text fg={theme.textMuted}>{props.message.error?.data.message}</text>
+          <text fg={theme.textMuted}>{errorMessage(props.message.error)}</text>
        </box>
      </Show>
      <Switch>
@@ -83,7 +83,7 @@ export function DialogPrompt(props: DialogPromptProps) {
        </text>
      </box>
      <box gap={1}>
-        {props.description}
+        {props.description?.()}
        <textarea
          height={3}
          ref={(val: TextareaRenderable) => {
@@ -1,7 +1,3 @@
-[data-component="tooltip-v2-trigger"] {
-  display: flex;
-}
-
 [data-component="tooltip-v2"] {
  box-sizing: border-box;
  display: inline-flex;
@@ -25,11 +25,6 @@ sessions.interrupt(sessionID)
  -> clears a coalesced follow-up wake already registered with this coordinator
  -> preserves durable inbox rows for a later wake or resume
  -> idle or missing Session is a no-op
-
-sessions.active()
-  -> snapshots foreground Session drains owned by this process
-  -> returns only active Session IDs with { type: "running" }
-  -> absence means inactive; activity is not durable across process restarts
 ```

 `session_input` is the durable admission inbox. `PromptAdmitted` records and projects accepted input so pending queue state can be replayed, replicated, and observed by clients. Admitted inputs remain outside model-visible Session history until the serialized runner publishes `Prompted`. Its projector atomically writes the visible user message and marks the inbox row promoted in the same event transaction. The V1-to-V2 shadow bridge publishes the same `Prompted` event for already-visible V1 prompts.
@@ -166,8 +161,6 @@ Post-crash continuation recovery is intentionally deferred. A wake does not infe

 A process-global `SessionRunCoordinator` serializes execution for each local Session while allowing different Sessions to run concurrently. Resumes join active execution, overlapping wakes coalesce into one follow-up, and interruption stops current process-local execution without deleting durable inbox work. The runner enters the Session's current Location when execution starts and fences each new provider turn against that Location.

-The coordinator's active registry is also the source for `sessions.active()`. It represents only foreground Session drains owned by the current process; background subagents and tasks do not add parent Sessions to this registry. The snapshot is runtime state and is empty after a process restart.
-
 Inbox promotion coalesces pending steers in durable admission order. Once continuation would otherwise end, it promotes one queued input at a time in FIFO order. Add explicit inbox backlog and steering-batch limits before exposing broad multi-caller admission or untrusted queue growth.

 Eager local-tool execution is intentionally unbounded in the current local slice. This minimizes tool latency but does not increase SQLite settlement throughput: Session-event publication remains serialized per provider turn. Before broadening exposure, revisit per-turn call limits, output truncation, and operational backpressure using observed workloads. The `session.next.*` event schemas remain experimental and unshipped; databases created by earlier experimental builds are disposable rather than compatibility targets.