release: v1.15.13

2026-08-04 01:06:16 -04:00 · 2026-05-30 23:40:45 +00:00
459 changed files with 17199 additions and 22244 deletions
@@ -2,9 +2,6 @@
  "$schema": "https://opencode.ai/config.json",
  "provider": {},
  "permission": {},
-  "reference": {
-    "effect": "github.com/Effect-TS/effect-smol",
-  },
  "mcp": {},
  "tools": {
    "github-triage": false,
@@ -47,12 +47,6 @@ obj.b
 const { a, b } = obj
 ```

-### Imports
-
- Never alias imports. Do not use `import { foo as bar } from "..."` or renamed imports like `resolve as pathResolve`.
- Never use star imports. Do not use `import * as Foo from "..."` or `import type * as Foo from "..."`.
- If a namespace-style value is needed, import the module's own exported namespace by name, for example `import { Project } from "@opencode-ai/core/project"`, then reference `Project.ID`.
-
 ### Variables

 Prefer `const` over `let`. Use ternaries or early returns instead of reassignment.
@@ -259,11 +259,8 @@
        "@aws-sdk/credential-providers": "3.993.0",
        "@effect/opentelemetry": "catalog:",
        "@effect/platform-node": "catalog:",
-        "@effect/sql-sqlite-bun": "catalog:",
        "@npmcli/arborist": "9.4.0",
        "@npmcli/config": "10.8.1",
-        "@opencode-ai/effect-drizzle-sqlite": "workspace:*",
-        "@opencode-ai/effect-sqlite-node": "workspace:*",
        "@openrouter/ai-sdk-provider": "2.8.1",
        "@opentelemetry/api": "1.9.0",
        "@opentelemetry/context-async-hooks": "2.6.1",
@@ -271,7 +268,6 @@
        "@opentelemetry/sdk-trace-base": "2.6.1",
        "ai-gateway-provider": "3.1.2",
        "cross-spawn": "catalog:",
-        "drizzle-orm": "catalog:",
        "effect": "catalog:",
        "gitlab-ai-provider": "6.8.0",
        "glob": "13.0.5",
@@ -293,7 +289,6 @@
        "@types/npm-package-arg": "6.1.4",
        "@types/npmcli__arborist": "6.3.3",
        "@types/semver": "catalog:",
-        "drizzle-kit": "catalog:",
      },
    },
    "packages/desktop": {
@@ -365,18 +360,6 @@
        "@typescript/native-preview": "catalog:",
      },
    },
-    "packages/effect-sqlite-node": {
-      "name": "@opencode-ai/effect-sqlite-node",
-      "version": "1.15.10",
-      "dependencies": {
-        "effect": "catalog:",
-      },
-      "devDependencies": {
-        "@tsconfig/bun": "catalog:",
-        "@types/node": "catalog:",
-        "@typescript/native-preview": "catalog:",
-      },
-    },
    "packages/enterprise": {
      "name": "@opencode-ai/enterprise",
      "version": "1.15.13",
@@ -586,6 +569,7 @@
        "@types/which": "3.0.4",
        "@types/yargs": "17.0.33",
        "@typescript/native-preview": "catalog:",
+        "drizzle-kit": "catalog:",
        "drizzle-orm": "catalog:",
        "prettier": "3.6.2",
        "typescript": "catalog:",
@@ -611,9 +595,9 @@
        "typescript": "catalog:",
      },
      "peerDependencies": {
-        "@opentui/core": ">=0.3.0",
-        "@opentui/keymap": ">=0.3.0",
-        "@opentui/solid": ">=0.3.0",
+        "@opentui/core": ">=0.2.16",
+        "@opentui/keymap": ">=0.2.16",
+        "@opentui/solid": ">=0.2.16",
      },
      "optionalPeers": [
        "@opentui/core",
@@ -862,9 +846,9 @@
    "@npmcli/arborist": "9.4.0",
    "@octokit/rest": "22.0.0",
    "@openauthjs/openauth": "0.0.0-20250322224806",
-    "@opentui/core": "0.3.0",
-    "@opentui/keymap": "0.3.0",
-    "@opentui/solid": "0.3.0",
+    "@opentui/core": "0.2.16",
+    "@opentui/keymap": "0.2.16",
+    "@opentui/solid": "0.2.16",
    "@pierre/diffs": "1.1.0-beta.18",
    "@playwright/test": "1.59.1",
    "@sentry/solid": "10.36.0",
@@ -1700,8 +1684,6 @@

    "@opencode-ai/effect-drizzle-sqlite": ["@opencode-ai/effect-drizzle-sqlite@workspace:packages/effect-drizzle-sqlite"],

-    "@opencode-ai/effect-sqlite-node": ["@opencode-ai/effect-sqlite-node@workspace:packages/effect-sqlite-node"],
-
    "@opencode-ai/enterprise": ["@opencode-ai/enterprise@workspace:packages/enterprise"],

    "@opencode-ai/function": ["@opencode-ai/function@workspace:packages/function"],
@@ -1758,23 +1740,23 @@

    "@opentelemetry/semantic-conventions": ["@opentelemetry/semantic-conventions@1.40.0", "", {}, "sha512-cifvXDhcqMwwTlTK04GBNeIe7yyo28Mfby85QXFe1Yk8nmi36Ab/5UQwptOx84SsoGNRg+EVSjwzfSZMy6pmlw=="],

-    "@opentui/core": ["@opentui/core@0.3.0", "", { "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.0", "@opentui/core-darwin-x64": "0.3.0", "@opentui/core-linux-arm64": "0.3.0", "@opentui/core-linux-x64": "0.3.0", "@opentui/core-win32-arm64": "0.3.0", "@opentui/core-win32-x64": "0.3.0" }, "peerDependencies": { "web-tree-sitter": "0.25.10" } }, "sha512-wvNESYGYGRLuvarZ3QY4CTB+BziZ/j6Snd9qRKD4fQ7SF6G4UpYElLTFrg7uzRo1v7WJTqbquymcTvWEHMnpYA=="],
+    "@opentui/core": ["@opentui/core@0.2.16", "", { "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.2.16", "@opentui/core-darwin-x64": "0.2.16", "@opentui/core-linux-arm64": "0.2.16", "@opentui/core-linux-x64": "0.2.16", "@opentui/core-win32-arm64": "0.2.16", "@opentui/core-win32-x64": "0.2.16" }, "peerDependencies": { "web-tree-sitter": "0.25.10" } }, "sha512-4vWN15Zc3nsXJlOiHhhpqkBXD+wrNFKxCPtiTiillZYDRre+XsZogVTOOGUDwaBIC23OSxq7imezLmmtShVBEA=="],

-    "@opentui/core-darwin-arm64": ["@opentui/core-darwin-arm64@0.3.0", "", { "os": "darwin", "cpu": "arm64" }, "sha512-/eDfAcutAHJqR9spwHMLuo6LMqngymev/m+i6uqlk98gX1EJiJe2pJ16sKbp3RctgH/Gz/8TYOhVHpPGYJl7yQ=="],
+    "@opentui/core-darwin-arm64": ["@opentui/core-darwin-arm64@0.2.16", "", { "os": "darwin", "cpu": "arm64" }, "sha512-aFb2Yp+oqDu3h6VCWi7xpQ9yjpKSQcROzGGfHgqC6Nd3U+uiLfPJBkmiI87iK0opCggCFj5TkKI004050DmGjg=="],

-    "@opentui/core-darwin-x64": ["@opentui/core-darwin-x64@0.3.0", "", { "os": "darwin", "cpu": "x64" }, "sha512-/j6EWAvdwhz1wU/mWfXepAf3+NuMYz2Ic5ozaid5LdwIpPomIkM9yCUDm76mQhRBbjsAl/7UeSeUA0qSCMSZBg=="],
+    "@opentui/core-darwin-x64": ["@opentui/core-darwin-x64@0.2.16", "", { "os": "darwin", "cpu": "x64" }, "sha512-KimiHE0j7EsTB5P8doW0lr1eH5iZKLPKWQO+tmy1VcdYr/TzqhdHSvGuJXrZvfTFi9/rV57Eq0d7964Ri9O0vQ=="],

-    "@opentui/core-linux-arm64": ["@opentui/core-linux-arm64@0.3.0", "", { "os": "linux", "cpu": "arm64" }, "sha512-uUFVT3V35KkM1m8gaLmRcTV9dsJzXnxwM+dv6+NjScx0W/Y0CJKbW9wDYwnLyPnBNgaFUi171zmJra5gTtFTsw=="],
+    "@opentui/core-linux-arm64": ["@opentui/core-linux-arm64@0.2.16", "", { "os": "linux", "cpu": "arm64" }, "sha512-4fCwRCfTtUgS/5QcSEkSuBjgQymSOUWXgrXG2ycrf3Swi0QhKDA/pVjwLrUJ6eF+/8mQyQSEV72T8MxMO3M2qg=="],

-    "@opentui/core-linux-x64": ["@opentui/core-linux-x64@0.3.0", "", { "os": "linux", "cpu": "x64" }, "sha512-73bNNNU2OaqZQLIlvzDOdAzQmzBAqf+cSilmJ+Y9JnybrBn1d6VShC66+V4xxIgonq1swk7BD+SUHYbwwGilQA=="],
+    "@opentui/core-linux-x64": ["@opentui/core-linux-x64@0.2.16", "", { "os": "linux", "cpu": "x64" }, "sha512-KgQBGjiucw4e7gM+R8qOzHWBFhjCY1IfCrGjW3Wzxv2hKUlL+mPhelaeJwnEqtNxMUdVTYjlwlu3IHxslXMJWQ=="],

-    "@opentui/core-win32-arm64": ["@opentui/core-win32-arm64@0.3.0", "", { "os": "win32", "cpu": "arm64" }, "sha512-jg5KrV/4mVQ0mdkcL9CtQVtBk0NAtQ+2rCKoZ/jNHB6GxGK0ot9vDV6P3X68hZVkvpb2pdXfg6GRsZJ+Np4hZA=="],
+    "@opentui/core-win32-arm64": ["@opentui/core-win32-arm64@0.2.16", "", { "os": "win32", "cpu": "arm64" }, "sha512-C6WqEI3VkXatXraMgSFXZjEXq0pzURGjRpFAJZYmuVDmpqE57o7E80Np2UkdZ6m5kpJDt4mRyu3krc/P825iNQ=="],

-    "@opentui/core-win32-x64": ["@opentui/core-win32-x64@0.3.0", "", { "os": "win32", "cpu": "x64" }, "sha512-kiM3C5bwQBTfrJKAOfb+L3U6MMkPSQlMhAERlLMjqSurc+llcyqygr/wbXSvfAqJtKlIpf3MKJRnVFTyfRIdng=="],
+    "@opentui/core-win32-x64": ["@opentui/core-win32-x64@0.2.16", "", { "os": "win32", "cpu": "x64" }, "sha512-kCX3CMTns6DMCFDNTDV4sjmBKyA/iEvzaVhl/jYi4JRIVT2zcy1lo+lhXT5mPgYHmJZu8Uye6j3Zi3c7Z2Me5A=="],

-    "@opentui/keymap": ["@opentui/keymap@0.3.0", "", { "dependencies": { "@opentui/core": "0.3.0" }, "peerDependencies": { "@opentui/react": "0.3.0", "@opentui/solid": "0.3.0", "react": ">=19.2.0", "solid-js": "1.9.12" }, "optionalPeers": ["@opentui/react", "@opentui/solid", "react", "solid-js"] }, "sha512-lJN57DanKujy3u0IhfSMCShvXIobRjhprdkrdM3brQoX6wxk7gTFE8fTCCz9z1nINkXNsKHQ6grZO1dsT/0mzA=="],
+    "@opentui/keymap": ["@opentui/keymap@0.2.16", "", { "dependencies": { "@opentui/core": "0.2.16" }, "peerDependencies": { "@opentui/react": "0.2.16", "@opentui/solid": "0.2.16", "react": ">=19.2.0", "solid-js": "1.9.12" }, "optionalPeers": ["@opentui/react", "@opentui/solid", "react", "solid-js"] }, "sha512-YBLQfNLbU2kx49bjEY9rrFoNlvIoi5qNJfRcOt6frvnR3C6MLl0/8hZY+vMQ2PEQWeEiNejFnl1lQw+z4Nk2FQ=="],

-    "@opentui/solid": ["@opentui/solid@0.3.0", "", { "dependencies": { "@babel/core": "7.28.0", "@babel/preset-typescript": "7.27.1", "@opentui/core": "0.3.0", "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-AUtNzvgkdW81Ftl0sahAy3tY1LIPSMzBw3APBC8jiDAzzPv4kYVdyWXryTxLbU2q+Pgtr57VwKwHgc5wsNrd2w=="],
+    "@opentui/solid": ["@opentui/solid@0.2.16", "", { "dependencies": { "@babel/core": "7.28.0", "@babel/preset-typescript": "7.27.1", "@opentui/core": "0.2.16", "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-2Q+v1PPpXXr+sALi9Aj6I5Jvo7xDfbmstYjRLL7lW3Hghh9i7ONQKpt/gyDDRbhSsYrhxKYTNenF9OxgoXkTHg=="],

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

@@ -1,8 +1,8 @@
 {
  "nodeModules": {
-    "x86_64-linux": "sha256-3OI8L9IT1XFN44CO3YEgHy/zKqVNhzkJjW1P2+9X4lU=",
-    "aarch64-linux": "sha256-YZSeZIUBQCII3+dLwKhvKv4RKHwAkLSnvGXXEHbmjeQ=",
-    "aarch64-darwin": "sha256-8CsowndXBpFDTd2RNSMh7xaULwLoz3Lu6kfqkacOk2s=",
-    "x86_64-darwin": "sha256-pWyjVHZVBjcGvVU9AoSR4nhuMNKIHKJK5faihD8UzhQ="
+    "x86_64-linux": "sha256-aTweGlyK8w+A9X7FpZnbVh+czXAVlttnn7Efhzm+8kY=",
+    "aarch64-linux": "sha256-Gl+fwiGv/BC9u8xV4h0NIYbEac+LJSODLSTipWwdWII=",
+    "aarch64-darwin": "sha256-Vt6eVf9gb+A5nULpMgtrg2YNIQy3L//wNVThVkVbgyc=",
+    "x86_64-darwin": "sha256-0uHk7YnGTeIOLxajdj+CcAokfAIdDLFeS0VwN0mXRrc="
  }
 }
@@ -38,9 +38,9 @@
      "@types/cross-spawn": "6.0.6",
      "@octokit/rest": "22.0.0",
      "@hono/zod-validator": "0.4.2",
-      "@opentui/core": "0.3.0",
-      "@opentui/keymap": "0.3.0",
-      "@opentui/solid": "0.3.0",
+      "@opentui/core": "0.2.16",
+      "@opentui/keymap": "0.2.16",
+      "@opentui/solid": "0.2.16",
      "ulid": "3.0.1",
      "@kobalte/core": "0.13.11",
      "@types/luxon": "3.7.1",
@@ -9,7 +9,6 @@
    "opencode": "./src/index.ts"
  },
  "scripts": {
-    "build": "bun run script/build.ts",
    "dev": "bun run src/index.ts",
    "typecheck": "tsgo --noEmit"
  },
@@ -3,17 +3,11 @@ import { AgentV2 } from "@opencode-ai/core/agent"
 import { PluginBoot } from "@opencode-ai/core/plugin/boot"
 import * as Effect from "effect/Effect"
 import * as Command from "effect/unstable/cli/Command"
-import { LocationServiceMap } from "@opencode-ai/core/location-layer"
-import { AbsolutePath } from "@opencode-ai/core/schema"

 export const AgentsCommand = Command.make("agents", {}, () =>
  Effect.gen(function* () {
-    const svc = {
-      plugin: yield* PluginBoot.Service,
-      agent: yield* AgentV2.Service,
-    }
-    yield* svc.plugin.wait()
-    const agents = yield* svc.agent.all()
+    yield* PluginBoot.Service.use((service) => service.wait())
+    const agents = yield* AgentV2.Service.use((service) => service.all())
    process.stdout.write(
      JSON.stringify(
        agents.sort((a, b) => a.id.localeCompare(b.id)),
@@ -21,11 +15,5 @@ export const AgentsCommand = Command.make("agents", {}, () =>
        2,
      ) + EOL,
    )
-  }).pipe(
-    Effect.provide(
-      LocationServiceMap.get({
-        directory: AbsolutePath.make(process.cwd()),
-      }),
-    ),
-  ),
+  }),
 ).pipe(Command.withDescription("List all agents"))
@@ -2,17 +2,48 @@

 import * as NodeRuntime from "@effect/platform-node/NodeRuntime"
 import * as NodeServices from "@effect/platform-node/NodeServices"
+import { AccountV2 } from "@opencode-ai/core/account"
+import { AgentV2 } from "@opencode-ai/core/agent"
+import { Catalog } from "@opencode-ai/core/catalog"
+import { Config } from "@opencode-ai/core/config"
+import { EventV2 } from "@opencode-ai/core/event"
+import { Location } from "@opencode-ai/core/location"
+import { Npm } from "@opencode-ai/core/npm"
+import { PluginV2 } from "@opencode-ai/core/plugin"
+import { PluginBoot } from "@opencode-ai/core/plugin/boot"
+import { Policy } from "@opencode-ai/core/policy"
+import { AbsolutePath } from "@opencode-ai/core/schema"
 import * as Effect from "effect/Effect"
 import * as Layer from "effect/Layer"
 import * as Command from "effect/unstable/cli/Command"
 import { DebugCommand } from "./debug"
-import { LocationServiceMap } from "@opencode-ai/core/location-layer"

 const cli = Command.make("opencode", {}, () => Effect.void).pipe(
  Command.withDescription("OpenCode command line interface"),
  Command.withSubcommands([DebugCommand]),
 )

-const layer = Layer.mergeAll(LocationServiceMap.layer, NodeServices.layer)
+const locationLayer = Location.defaultLayer({
+  directory: AbsolutePath.make(process.cwd()),
+})
+
+const policyLayer = Policy.defaultLayer.pipe(Layer.provideMerge(locationLayer))
+const pluginLayer = PluginV2.defaultLayer
+const eventLayer = EventV2.defaultLayer
+
+const layer = PluginBoot.layer.pipe(
+  Layer.provideMerge(
+    Layer.mergeAll(
+      NodeServices.layer,
+      Catalog.layer.pipe(Layer.provideMerge(Layer.mergeAll(eventLayer, pluginLayer, policyLayer))),
+      eventLayer,
+      pluginLayer,
+      AccountV2.defaultLayer,
+      AgentV2.defaultLayer,
+      Config.defaultLayer.pipe(Layer.provideMerge(policyLayer)),
+      Npm.defaultLayer,
+    ),
+  ),
+)

 Command.run(cli, { version: "local" }).pipe(Effect.provide(layer), Effect.scoped, NodeRuntime.runMain)
@@ -1 +0,0 @@
-ALTER TABLE `session` ADD `metadata` text;
@@ -6,8 +6,6 @@
  "license": "MIT",
  "private": true,
  "scripts": {
-    "db": "bun drizzle-kit",
-    "migration": "bun run script/migration.ts",
    "test": "bun test",
    "test:ci": "mkdir -p .artifacts/unit && bun test --timeout 30000 --reporter=junit --reporter-outfile=.artifacts/unit/junit.xml",
    "typecheck": "tsgo --noEmit"
@@ -18,21 +16,14 @@
  "exports": {
    "./*": "./src/*.ts"
  },
-  "imports": {
-    "#sqlite": {
-      "bun": "./src/database/sqlite.bun.ts",
-      "node": "./src/database/sqlite.node.ts",
-      "default": "./src/database/sqlite.bun.ts"
-    }
-  },
+  "imports": {},
  "devDependencies": {
    "@tsconfig/bun": "catalog:",
    "@types/bun": "catalog:",
    "@types/cross-spawn": "catalog:",
    "@types/npm-package-arg": "6.1.4",
    "@types/npmcli__arborist": "6.3.3",
-    "@types/semver": "catalog:",
-    "drizzle-kit": "catalog:"
+    "@types/semver": "catalog:"
  },
  "dependencies": {
    "@ai-sdk/alibaba": "1.0.17",
@@ -58,11 +49,8 @@
    "@aws-sdk/credential-providers": "3.993.0",
    "@effect/opentelemetry": "catalog:",
    "@effect/platform-node": "catalog:",
-    "@effect/sql-sqlite-bun": "catalog:",
    "@npmcli/arborist": "9.4.0",
    "@npmcli/config": "10.8.1",
-    "@opencode-ai/effect-drizzle-sqlite": "workspace:*",
-    "@opencode-ai/effect-sqlite-node": "workspace:*",
    "@opentelemetry/api": "1.9.0",
    "@opentelemetry/context-async-hooks": "2.6.1",
    "@opentelemetry/exporter-trace-otlp-http": "0.214.0",
@@ -70,7 +58,6 @@
    "@openrouter/ai-sdk-provider": "2.8.1",
    "ai-gateway-provider": "3.1.2",
    "cross-spawn": "catalog:",
-    "drizzle-orm": "catalog:",
    "effect": "catalog:",
    "gitlab-ai-provider": "6.8.0",
    "glob": "13.0.5",
@@ -1,122 +0,0 @@
-#!/usr/bin/env bun
-
-import { $ } from "bun"
-import fs from "fs/promises"
-import os from "os"
-import path from "path"
-import { pathToFileURL } from "url"
-
-const root = path.resolve(import.meta.dirname, "../../..")
-const sqlDir = path.join(root, "packages/core/migration")
-const tsDir = path.join(root, "packages/core/src/database/migration")
-const registry = path.join(root, "packages/core/src/database/migration.gen.ts")
-
-if (Bun.argv.includes("--check")) {
-  await check()
-  process.exit(0)
-}
-
-await $`bun drizzle-kit generate`.cwd(path.join(root, "packages/core"))
-
-const sqlMigrations = (await Array.fromAsync(new Bun.Glob("*/migration.sql").scan({ cwd: sqlDir })))
-  .map((file) => file.split("/")[0])
-  .filter((name) => name !== undefined)
-  .sort()
-
-for (const name of sqlMigrations) {
-  if (await Bun.file(path.join(tsDir, `${name}.ts`)).exists()) continue
-  await Bun.write(
-    path.join(tsDir, `${name}.ts`),
-    renderMigration(name, await Bun.file(path.join(sqlDir, name, "migration.sql")).text()),
-  )
-}
-
-await Bun.write(registry, renderRegistry(sqlMigrations))
-
-async function check() {
-  const temporary = await fs.mkdtemp(path.join(os.tmpdir(), "opencode-core-migration-check-"))
-  const output = path.join(temporary, "migration")
-  try {
-    await fs.cp(sqlDir, output, { recursive: true })
-    const config = path.join(temporary, "drizzle.config.ts")
-    await Bun.write(
-      config,
-      `import config from ${JSON.stringify(pathToFileURL(path.join(root, "packages/core/drizzle.config.ts")).href)}
-
-export default { ...config, out: ${JSON.stringify(output)} }
-`,
-    )
-    const before = await snapshot(output)
-    await $`bun drizzle-kit generate --config ${config}`.cwd(path.join(root, "packages/core"))
-    const after = await snapshot(output)
-    if (JSON.stringify(after) !== JSON.stringify(before)) {
-      throw new Error(
-        "Core schema has ungenerated database migrations. Run `bun script/migration.ts` from packages/core.",
-      )
-    }
-
-    const migrations = before
-      .map((entry) => entry.path.split("/")[0])
-      .filter((name, index, all) => name !== undefined && all.indexOf(name) === index)
-      .sort()
-    for (const name of migrations) {
-      if (await Bun.file(path.join(tsDir, `${name}.ts`)).exists()) continue
-      throw new Error(
-        `Database migration TypeScript wrapper is missing for ${name}. Run \`bun script/migration.ts\` from packages/core.`,
-      )
-    }
-    if ((await Bun.file(registry).text()) !== renderRegistry(migrations)) {
-      throw new Error("Database migration registry is stale. Run `bun script/migration.ts` from packages/core.")
-    }
-  } finally {
-    await fs.rm(temporary, { recursive: true, force: true })
-  }
-}
-
-async function snapshot(directory: string) {
-  const files = await Array.fromAsync(new Bun.Glob("**/*").scan({ cwd: directory, onlyFiles: true }))
-  return Promise.all(
-    files.sort().map(async (file) => ({ path: file, contents: await Bun.file(path.join(directory, file)).text() })),
-  )
-}
-
-function renderMigration(name: string, sql: string) {
-  return `import { Effect } from "effect"
-import type { DatabaseMigration } from "../migration"
-
-export default {
-  id: ${JSON.stringify(name)},
-  up(tx) {
-    return Effect.gen(function* () {
-${sql
-  .split("--> statement-breakpoint")
-  .map((statement) => statement.trim())
-  .filter((statement) => statement.length > 0)
-  .map(renderRun)
-  .join("\n")}
-    })
-  },
-} satisfies DatabaseMigration.Migration
-`
-}
-
-function renderRun(statement: string) {
-  const lines = statement.replaceAll("\t", "  ").split("\n")
-  if (lines.length === 1) return `      yield* tx.run(\`${escapeTemplate(lines[0])}\`)`
-  return `      yield* tx.run(\`\n${lines.map((line) => `        ${escapeTemplate(line)}`).join("\n")}\n      \`)`
-}
-
-function escapeTemplate(line: string) {
-  return line.replaceAll("\\", "\\\\").replaceAll("`", "\\`").replaceAll("${", "\\${")
-}
-
-function renderRegistry(names: string[]) {
-  return `import type { DatabaseMigration } from "./migration"
-
-export const migrations = (
-  await Promise.all([
-${names.map((name) => `    import("./migration/${name}"),`).join("\n")}
-  ])
-).map((module) => module.default) satisfies DatabaseMigration.Migration[]
-`
-}
@@ -1,101 +1,319 @@
-export * as AccountV2 from "./account"
+import path from "path"
+import { Effect, Layer, Option, Schema, Context, SynchronizedRef } from "effect"
+import { Identifier } from "./util/identifier"
+import { NonNegativeInt, withStatics } from "./schema"
+import { Global } from "./global"
+import { AppFileSystem } from "./filesystem"
+import { EventV2 } from "./event"

-import { Schema } from "effect"
-import type * as HttpClientError from "effect/unstable/http/HttpClientError"
+export const ID = Schema.String.pipe(
+  Schema.brand("AccountV2.ID"),
+  withStatics((schema) => ({ create: () => schema.make("acc_" + Identifier.ascending()) })),
+)
+export type ID = typeof ID.Type

-export const ID = Schema.String.pipe(Schema.brand("AccountID"))
-export type ID = Schema.Schema.Type<typeof ID>
+export const ServiceID = Schema.String.pipe(Schema.brand("ServiceID"))
+export type ServiceID = typeof ServiceID.Type

-export const OrgID = Schema.String.pipe(Schema.brand("OrgID"))
-export type OrgID = Schema.Schema.Type<typeof OrgID>
+export class OAuthCredential extends Schema.Class<OAuthCredential>("AccountV2.OAuthCredential")({
+  type: Schema.Literal("oauth"),
+  refresh: Schema.String,
+  access: Schema.String,
+  expires: NonNegativeInt,
+}) {}

-export const AccessToken = Schema.String.pipe(Schema.brand("AccessToken"))
-export type AccessToken = Schema.Schema.Type<typeof AccessToken>
+export class ApiKeyCredential extends Schema.Class<ApiKeyCredential>("AccountV2.ApiKeyCredential")({
+  type: Schema.Literal("api"),
+  key: Schema.String,
+  metadata: Schema.optional(Schema.Record(Schema.String, Schema.String)),
+}) {}

-export const RefreshToken = Schema.String.pipe(Schema.brand("RefreshToken"))
-export type RefreshToken = Schema.Schema.Type<typeof RefreshToken>
+export const Credential = Schema.Union([OAuthCredential, ApiKeyCredential])
+  .pipe(Schema.toTaggedUnion("type"))
+  .annotate({
+    identifier: "AccountV2.Credential",
+  })
+export type Credential = Schema.Schema.Type<typeof Credential>

-export const DeviceCode = Schema.String.pipe(Schema.brand("DeviceCode"))
-export type DeviceCode = Schema.Schema.Type<typeof DeviceCode>
-
-export const UserCode = Schema.String.pipe(Schema.brand("UserCode"))
-export type UserCode = Schema.Schema.Type<typeof UserCode>
-
-export class Info extends Schema.Class<Info>("Account")({
+export class Info extends Schema.Class<Info>("AccountV2.Info")({
  id: ID,
-  email: Schema.String,
-  url: Schema.String,
-  active_org_id: Schema.NullOr(OrgID),
+  serviceID: ServiceID,
+  description: Schema.String,
+  credential: Credential,
 }) {}

-export class Org extends Schema.Class<Org>("Org")({
-  id: OrgID,
-  name: Schema.String,
-}) {}
-
-export class AccountRepoError extends Schema.TaggedErrorClass<AccountRepoError>()("AccountRepoError", {
-  message: Schema.String,
-  cause: Schema.optional(Schema.Defect),
-}) {}
-
-export class AccountServiceError extends Schema.TaggedErrorClass<AccountServiceError>()("AccountServiceError", {
-  message: Schema.String,
-  cause: Schema.optional(Schema.Defect),
-}) {}
-
-export class AccountTransportError extends Schema.TaggedErrorClass<AccountTransportError>()("AccountTransportError", {
-  method: Schema.String,
-  url: Schema.String,
-  description: Schema.optional(Schema.String),
-  cause: Schema.optional(Schema.Defect),
-}) {
-  static fromHttpClientError(error: HttpClientError.TransportError): AccountTransportError {
-    return new AccountTransportError({
-      method: error.request.method,
-      url: error.request.url,
-      description: error.description,
-      cause: error.cause,
-    })
-  }
-
-  override get message(): string {
-    return [
-      `Could not reach ${this.method} ${this.url}.`,
-      `This failed before the server returned an HTTP response.`,
-      this.description,
-      `Check your network, proxy, or VPN configuration and try again.`,
-    ]
-      .filter(Boolean)
-      .join("\n")
-  }
-}
-
-export type AccountError = AccountRepoError | AccountServiceError | AccountTransportError
-
-export class Login extends Schema.Class<Login>("Login")({
-  code: DeviceCode,
-  user: UserCode,
-  url: Schema.String,
-  server: Schema.String,
-  expiry: Schema.Duration,
-  interval: Schema.Duration,
-}) {}
-
-export class PollSuccess extends Schema.TaggedClass<PollSuccess>()("PollSuccess", {
-  email: Schema.String,
-}) {}
-
-export class PollPending extends Schema.TaggedClass<PollPending>()("PollPending", {}) {}
-
-export class PollSlow extends Schema.TaggedClass<PollSlow>()("PollSlow", {}) {}
-
-export class PollExpired extends Schema.TaggedClass<PollExpired>()("PollExpired", {}) {}
-
-export class PollDenied extends Schema.TaggedClass<PollDenied>()("PollDenied", {}) {}
-
-export class PollError extends Schema.TaggedClass<PollError>()("PollError", {
+export class FileWriteError extends Schema.TaggedErrorClass<FileWriteError>()("AccountV2.FileWriteError", {
+  operation: Schema.Union([Schema.Literal("migrate"), Schema.Literal("write")]),
  cause: Schema.Defect,
 }) {}

-export const PollResult = Schema.Union([PollSuccess, PollPending, PollSlow, PollExpired, PollDenied, PollError])
-export type PollResult = Schema.Schema.Type<typeof PollResult>
+export type Error = FileWriteError
+
+export const Event = {
+  Added: EventV2.define({
+    type: "account.added",
+    schema: {
+      account: Info,
+    },
+  }),
+  Removed: EventV2.define({
+    type: "account.removed",
+    schema: {
+      account: Info,
+    },
+  }),
+  Switched: EventV2.define({
+    type: "account.switched",
+    schema: {
+      serviceID: ServiceID,
+      from: Schema.optional(ID),
+      to: Schema.optional(ID),
+    },
+  }),
+}
+
+interface Writable {
+  version: 2
+  accounts: Record<string, Info>
+  active: Record<string, ID>
+}
+
+const decodeV1 = Schema.decodeUnknownOption(Schema.Record(Schema.String, Credential))
+
+function migrate(old: Record<string, unknown>): Writable {
+  const accounts: Record<string, Info> = {}
+  const active: Record<string, ID> = {}
+  for (const [serviceID, value] of Object.entries(old)) {
+    const decoded = Option.getOrElse(decodeV1({ [serviceID]: value }), () => ({}))
+    const parsed = (decoded as Record<string, Credential>)[serviceID]
+    if (!parsed) continue
+    const id = Identifier.ascending()
+    const account = ID.make(id)
+    const brandedServiceID = ServiceID.make(serviceID)
+    accounts[id] = new Info({
+      id: account,
+      serviceID: brandedServiceID,
+      description: "default",
+      credential: parsed,
+    })
+    active[brandedServiceID] = account
+  }
+  return { version: 2, accounts, active }
+}
+
+export interface Interface {
+  readonly get: (id: ID) => Effect.Effect<Info | undefined, Error>
+  readonly all: () => Effect.Effect<Info[], Error>
+  readonly create: (input: {
+    serviceID: ServiceID
+    credential: Credential
+    description?: string
+  }) => Effect.Effect<Info | undefined, Error>
+  readonly update: (id: ID, updates: Partial<Pick<Info, "description" | "credential">>) => Effect.Effect<void, Error>
+  readonly remove: (id: ID) => Effect.Effect<void, Error>
+  readonly activate: (id: ID) => Effect.Effect<void, Error>
+  readonly active: (serviceID: ServiceID) => Effect.Effect<Info | undefined, Error>
+  readonly forService: (serviceID: ServiceID) => Effect.Effect<Info[], Error>
+}
+
+export class Service extends Context.Service<Service, Interface>()("@opencode/v2/Account") {}
+
+export const layer = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    const fsys = yield* AppFileSystem.Service
+    const global = yield* Global.Service
+    const events = yield* EventV2.Service
+    const file = path.join(global.data, "account.json")
+    const legacyFile = path.join(global.data, "auth.json")
+
+    const writeMigrated = Effect.fnUntraced(function* (raw: Record<string, unknown>) {
+      const migrated = migrate(raw)
+      yield* fsys
+        .writeJson(file, migrated, 0o600)
+        .pipe(Effect.mapError((cause) => new FileWriteError({ operation: "migrate", cause })))
+      return migrated
+    })
+
+    const parseAuthContent = () => {
+      try {
+        return JSON.parse(process.env.OPENCODE_AUTH_CONTENT ?? "")
+      } catch {}
+    }
+
+    const load: () => Effect.Effect<Writable, Error> = Effect.fnUntraced(function* () {
+      if (process.env.OPENCODE_AUTH_CONTENT) {
+        const raw = parseAuthContent()
+        if (raw && typeof raw === "object") {
+          if ("version" in raw && raw.version === 2) return raw as Writable
+          return yield* writeMigrated(raw as Record<string, unknown>)
+        }
+        return { version: 2, accounts: {}, active: {} }
+      }
+
+      const legacy = yield* fsys.readJson(legacyFile).pipe(Effect.orElseSucceed(() => null))
+      if (legacy && typeof legacy === "object") return yield* writeMigrated(legacy as Record<string, unknown>)
+
+      const raw = yield* fsys.readJson(file).pipe(Effect.orElseSucceed(() => null))
+
+      if (raw && typeof raw === "object") {
+        if ("version" in raw && raw.version === 2) return raw as Writable
+        return yield* writeMigrated(raw as Record<string, unknown>)
+      }
+
+      return { version: 2, accounts: {}, active: {} }
+    })
+
+    const write = (data: Writable) =>
+      fsys
+        .writeJson(file, data, 0o600)
+        .pipe(Effect.mapError((cause) => new FileWriteError({ operation: "write", cause })))
+
+    const state = SynchronizedRef.makeUnsafe(
+      yield* load().pipe(Effect.orElseSucceed((): Writable => ({ version: 2, accounts: {}, active: {} }))),
+    )
+
+    const activate = Effect.fn("AccountV2.activate")(function* (id: ID) {
+      const data = yield* SynchronizedRef.get(state)
+      const account = data.accounts[id]
+      if (!account) return
+      const activated = yield* SynchronizedRef.modifyEffect(
+        state,
+        Effect.fnUntraced(function* (data) {
+          const nextAccount = data.accounts[id]
+          if (!nextAccount) return [undefined, data] as const
+
+          const next = { ...data, active: { ...data.active, [nextAccount.serviceID]: id } }
+          yield* write(next)
+          return [{ serviceID: nextAccount.serviceID, from: data.active[nextAccount.serviceID], to: id }, next] as const
+        }),
+      )
+      if (activated) yield* events.publish(Event.Switched, activated)
+    })
+
+    const result: Interface = {
+      get: Effect.fn("AccountV2.get")(function* (id) {
+        return (yield* SynchronizedRef.get(state)).accounts[id]
+      }),
+
+      all: Effect.fn("AccountV2.all")(function* () {
+        return Object.values((yield* SynchronizedRef.get(state)).accounts)
+      }),
+
+      active: Effect.fn("AccountV2.active")(function* (serviceID) {
+        const data = yield* SynchronizedRef.get(state)
+        return (
+          data.accounts[data.active[serviceID]] ?? Object.values(data.accounts).find((a) => a.serviceID === serviceID)
+        )
+      }),
+
+      forService: Effect.fn("AccountV2.list")(function* (serviceID) {
+        return Object.values((yield* SynchronizedRef.get(state)).accounts).filter((a) => a.serviceID === serviceID)
+      }),
+
+      create: Effect.fn("AccountV2.add")(function* (input) {
+        const id = ID.make(Identifier.ascending())
+        const account = new Info({
+          id,
+          serviceID: input.serviceID,
+          description: input.description ?? "default",
+          credential: input.credential,
+        })
+        const added = yield* SynchronizedRef.modifyEffect(
+          state,
+          Effect.fnUntraced(function* (data) {
+            const next = {
+              ...data,
+              accounts: { ...data.accounts, [account.id]: account },
+              active: { ...data.active, [account.serviceID]: account.id },
+            }
+
+            yield* write(next)
+            return [
+              {
+                account,
+                switched: { serviceID: account.serviceID, from: data.active[account.serviceID], to: account.id },
+              },
+              next,
+            ] as const
+          }),
+        )
+        yield* events.publish(Event.Added, { account: added.account })
+        yield* events.publish(Event.Switched, added.switched)
+        return added.account
+      }),
+
+      update: Effect.fn("AccountV2.update")(function* (id, updates) {
+        const existing = (yield* SynchronizedRef.get(state)).accounts[id]
+        if (!existing) return
+        yield* SynchronizedRef.modifyEffect(
+          state,
+          Effect.fnUntraced(function* (data) {
+            if (!data.accounts[id]) return [undefined, data] as const
+
+            const next = {
+              ...data,
+              accounts: {
+                ...data.accounts,
+                [id]: new Info({
+                  id,
+                  serviceID: existing.serviceID,
+                  description: updates.description ?? existing.description,
+                  credential: updates.credential ?? existing.credential,
+                }),
+              },
+            }
+
+            yield* write(next)
+            return [undefined, next] as const
+          }),
+        )
+      }),
+
+      remove: Effect.fn("AccountV2.remove")(function* (id) {
+        const removed = yield* SynchronizedRef.modifyEffect(
+          state,
+          Effect.fnUntraced(function* (data) {
+            const accounts = { ...data.accounts }
+            const active = { ...data.active }
+            const removed = accounts[id]
+            if (!removed) return [undefined, data] as const
+            const wasActive = active[removed.serviceID] === id
+            delete accounts[id]
+            const replacement = Object.values(accounts).find((account) => account.serviceID === removed.serviceID)
+            if (wasActive) {
+              if (replacement) active[removed.serviceID] = replacement.id
+              else delete active[removed.serviceID]
+            }
+
+            const next = { ...data, accounts, active }
+            yield* write(next)
+            return [
+              {
+                account: removed,
+                switched: wasActive ? { serviceID: removed.serviceID, from: id, to: replacement?.id } : undefined,
+              },
+              next,
+            ] as const
+          }),
+        )
+        if (removed) {
+          yield* events.publish(Event.Removed, { account: removed.account })
+          if (removed.switched) yield* events.publish(Event.Switched, removed.switched)
+        }
+      }),
+
+      activate,
+    }
+
+    return Service.of(result)
+  }),
+)
+
+export const defaultLayer = layer.pipe(
+  Layer.provide(AppFileSystem.defaultLayer),
+  Layer.provide(Global.defaultLayer),
+  Layer.provide(EventV2.defaultLayer),
+)
+
+export * as AccountV2 from "./account"
@@ -104,4 +104,4 @@ export const layer = Layer.effect(
  }),
 )

-export const locationLayer = layer
+export const defaultLayer = layer
@@ -3,7 +3,6 @@ export * as AISDK from "./aisdk"
 import type { LanguageModelV3 } from "@ai-sdk/provider"
 import { Cause, Context, Effect, Layer, Schema } from "effect"
 import { ModelV2 } from "./model"
-import { EventV2 } from "./event"
 import { PluginV2 } from "./plugin"
 import { ProviderV2 } from "./provider"

@@ -170,4 +169,4 @@ export const layer = Layer.effect(
  }),
 )

-export const defaultLayer = layer.pipe(Layer.provide(PluginV2.locationLayer.pipe(Layer.provide(EventV2.defaultLayer))))
+export const defaultLayer = layer.pipe(Layer.provide(PluginV2.defaultLayer))
@@ -1,340 +0,0 @@
-export * as Auth from "./auth"
-
-import path from "path"
-import { Effect, Layer, Option, Schema, Context, SynchronizedRef } from "effect"
-import { Identifier } from "./util/identifier"
-import { NonNegativeInt, withStatics } from "./schema"
-import { Global } from "./global"
-import { AppFileSystem } from "./filesystem"
-import { EventV2 } from "./event"
-
-export const ID = Schema.String.pipe(
-  Schema.brand("Auth.ID"),
-  withStatics((schema) => ({ create: () => schema.make("acc_" + Identifier.ascending()) })),
-)
-export type ID = typeof ID.Type
-
-export const ServiceID = Schema.String.pipe(Schema.brand("ServiceID"))
-export type ServiceID = typeof ServiceID.Type
-
-export const OrgID = Schema.String.pipe(Schema.brand("OrgID"))
-export type OrgID = typeof OrgID.Type
-export const AccessToken = Schema.String.pipe(Schema.brand("AccessToken"))
-export type AccessToken = typeof AccessToken.Type
-export const RefreshToken = Schema.String.pipe(Schema.brand("RefreshToken"))
-export type RefreshToken = typeof RefreshToken.Type
-
-export class OAuthCredential extends Schema.Class<OAuthCredential>("Auth.OAuthCredential")({
-  type: Schema.Literal("oauth"),
-  refresh: Schema.String,
-  access: Schema.String,
-  expires: NonNegativeInt,
-}) {}
-
-export class ApiKeyCredential extends Schema.Class<ApiKeyCredential>("Auth.ApiKeyCredential")({
-  type: Schema.Literal("api"),
-  key: Schema.String,
-  metadata: Schema.optional(Schema.Record(Schema.String, Schema.String)),
-}) {}
-
-export const Credential = Schema.Union([OAuthCredential, ApiKeyCredential])
-  .pipe(Schema.toTaggedUnion("type"))
-  .annotate({
-    identifier: "Auth.Credential",
-  })
-export type Credential = Schema.Schema.Type<typeof Credential>
-
-export class Info extends Schema.Class<Info>("Auth.Info")({
-  id: ID,
-  serviceID: ServiceID,
-  description: Schema.String,
-  credential: Credential,
-}) {}
-
-export class FileWriteError extends Schema.TaggedErrorClass<FileWriteError>()("Auth.FileWriteError", {
-  operation: Schema.Union([Schema.Literal("migrate"), Schema.Literal("write")]),
-  cause: Schema.Defect,
-}) {}
-
-export type Error = FileWriteError
-
-export const Event = {
-  Added: EventV2.define({
-    type: "account.added",
-    schema: {
-      account: Info,
-    },
-  }),
-  Removed: EventV2.define({
-    type: "account.removed",
-    schema: {
-      account: Info,
-    },
-  }),
-  Switched: EventV2.define({
-    type: "account.switched",
-    schema: {
-      serviceID: ServiceID,
-      from: Schema.optional(ID),
-      to: Schema.optional(ID),
-    },
-  }),
-}
-
-interface Writable {
-  version: 2
-  accounts: Record<string, Info>
-  active: Record<string, ID>
-}
-
-const decodeV1 = Schema.decodeUnknownOption(Schema.Record(Schema.String, Credential))
-
-function migrate(old: Record<string, unknown>): Writable {
-  const accounts: Record<string, Info> = {}
-  const active: Record<string, ID> = {}
-  for (const [serviceID, value] of Object.entries(old)) {
-    const decoded = Option.getOrElse(decodeV1({ [serviceID]: value }), () => ({}))
-    const parsed = (decoded as Record<string, Credential>)[serviceID]
-    if (!parsed) continue
-    const id = Identifier.ascending()
-    const account = ID.make(id)
-    const brandedServiceID = ServiceID.make(serviceID)
-    accounts[id] = new Info({
-      id: account,
-      serviceID: brandedServiceID,
-      description: "default",
-      credential: parsed,
-    })
-    active[brandedServiceID] = account
-  }
-  return { version: 2, accounts, active }
-}
-
-export interface Interface {
-  readonly get: (id: ID) => Effect.Effect<Info | undefined, Error>
-  readonly all: () => Effect.Effect<Info[], Error>
-  readonly create: (input: {
-    serviceID: ServiceID
-    credential: Credential
-    description?: string
-  }) => Effect.Effect<Info | undefined, Error>
-  readonly update: (id: ID, updates: Partial<Pick<Info, "description" | "credential">>) => Effect.Effect<void, Error>
-  readonly remove: (id: ID) => Effect.Effect<void, Error>
-  readonly activate: (id: ID) => Effect.Effect<void, Error>
-  readonly active: (serviceID: ServiceID) => Effect.Effect<Info | undefined, Error>
-  readonly activeAll: () => Effect.Effect<Map<ServiceID, Info>, Error>
-  readonly forService: (serviceID: ServiceID) => Effect.Effect<Info[], Error>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/v2/Account") {}
-
-export const layer = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const fsys = yield* AppFileSystem.Service
-    const global = yield* Global.Service
-    const events = yield* EventV2.Service
-    const file = path.join(global.data, "account.json")
-    const legacyFile = path.join(global.data, "auth.json")
-
-    const writeMigrated = Effect.fnUntraced(function* (raw: Record<string, unknown>) {
-      const migrated = migrate(raw)
-      yield* fsys
-        .writeJson(file, migrated, 0o600)
-        .pipe(Effect.mapError((cause) => new FileWriteError({ operation: "migrate", cause })))
-      return migrated
-    })
-
-    const parseAuthContent = () => {
-      try {
-        return JSON.parse(process.env.OPENCODE_AUTH_CONTENT ?? "")
-      } catch {}
-    }
-
-    const load: () => Effect.Effect<Writable, Error> = Effect.fnUntraced(function* () {
-      if (process.env.OPENCODE_AUTH_CONTENT) {
-        const raw = parseAuthContent()
-        if (raw && typeof raw === "object") {
-          if ("version" in raw && raw.version === 2) return raw as Writable
-          return yield* writeMigrated(raw as Record<string, unknown>)
-        }
-        return { version: 2, accounts: {}, active: {} }
-      }
-
-      const legacy = yield* fsys.readJson(legacyFile).pipe(Effect.orElseSucceed(() => null))
-      if (legacy && typeof legacy === "object") return yield* writeMigrated(legacy as Record<string, unknown>)
-
-      const raw = yield* fsys.readJson(file).pipe(Effect.orElseSucceed(() => null))
-
-      if (raw && typeof raw === "object") {
-        if ("version" in raw && raw.version === 2) return raw as Writable
-        return yield* writeMigrated(raw as Record<string, unknown>)
-      }
-
-      return { version: 2, accounts: {}, active: {} }
-    })
-
-    const write = (data: Writable) =>
-      fsys
-        .writeJson(file, data, 0o600)
-        .pipe(Effect.mapError((cause) => new FileWriteError({ operation: "write", cause })))
-
-    const state = SynchronizedRef.makeUnsafe(
-      yield* load().pipe(Effect.orElseSucceed((): Writable => ({ version: 2, accounts: {}, active: {} }))),
-    )
-
-    const activate = Effect.fn("Auth.activate")(function* (id: ID) {
-      const data = yield* SynchronizedRef.get(state)
-      const account = data.accounts[id]
-      if (!account) return
-      const activated = yield* SynchronizedRef.modifyEffect(
-        state,
-        Effect.fnUntraced(function* (data) {
-          const nextAccount = data.accounts[id]
-          if (!nextAccount) return [undefined, data] as const
-
-          const next = { ...data, active: { ...data.active, [nextAccount.serviceID]: id } }
-          yield* write(next)
-          return [{ serviceID: nextAccount.serviceID, from: data.active[nextAccount.serviceID], to: id }, next] as const
-        }),
-      )
-      if (activated) yield* events.publish(Event.Switched, activated)
-    })
-
-    const result: Interface = {
-      get: Effect.fn("Auth.get")(function* (id) {
-        return (yield* SynchronizedRef.get(state)).accounts[id]
-      }),
-
-      all: Effect.fn("Auth.all")(function* () {
-        return Object.values((yield* SynchronizedRef.get(state)).accounts)
-      }),
-
-      active: Effect.fn("Auth.active")(function* (serviceID) {
-        const data = yield* SynchronizedRef.get(state)
-        return (
-          data.accounts[data.active[serviceID]] ?? Object.values(data.accounts).find((a) => a.serviceID === serviceID)
-        )
-      }),
-
-      activeAll: Effect.fn("Auth.activeAll")(function* () {
-        const data = yield* SynchronizedRef.get(state)
-        const result = new Map<ServiceID, Info>()
-        for (const account of Object.values(data.accounts)) {
-          if (!result.has(account.serviceID)) result.set(account.serviceID, account)
-        }
-        for (const [serviceID, id] of Object.entries(data.active)) {
-          const account = data.accounts[id]
-          if (account) result.set(ServiceID.make(serviceID), account)
-        }
-        return result
-      }),
-
-      forService: Effect.fn("Auth.list")(function* (serviceID) {
-        return Object.values((yield* SynchronizedRef.get(state)).accounts).filter((a) => a.serviceID === serviceID)
-      }),
-
-      create: Effect.fn("Auth.add")(function* (input) {
-        const id = ID.make(Identifier.ascending())
-        const account = new Info({
-          id,
-          serviceID: input.serviceID,
-          description: input.description ?? "default",
-          credential: input.credential,
-        })
-        const added = yield* SynchronizedRef.modifyEffect(
-          state,
-          Effect.fnUntraced(function* (data) {
-            const next = {
-              ...data,
-              accounts: { ...data.accounts, [account.id]: account },
-              active: { ...data.active, [account.serviceID]: account.id },
-            }
-
-            yield* write(next)
-            return [
-              {
-                account,
-                switched: { serviceID: account.serviceID, from: data.active[account.serviceID], to: account.id },
-              },
-              next,
-            ] as const
-          }),
-        )
-        yield* events.publish(Event.Added, { account: added.account })
-        yield* events.publish(Event.Switched, added.switched)
-        return added.account
-      }),
-
-      update: Effect.fn("Auth.update")(function* (id, updates) {
-        const existing = (yield* SynchronizedRef.get(state)).accounts[id]
-        if (!existing) return
-        yield* SynchronizedRef.modifyEffect(
-          state,
-          Effect.fnUntraced(function* (data) {
-            if (!data.accounts[id]) return [undefined, data] as const
-
-            const next = {
-              ...data,
-              accounts: {
-                ...data.accounts,
-                [id]: new Info({
-                  id,
-                  serviceID: existing.serviceID,
-                  description: updates.description ?? existing.description,
-                  credential: updates.credential ?? existing.credential,
-                }),
-              },
-            }
-
-            yield* write(next)
-            return [undefined, next] as const
-          }),
-        )
-      }),
-
-      remove: Effect.fn("Auth.remove")(function* (id) {
-        const removed = yield* SynchronizedRef.modifyEffect(
-          state,
-          Effect.fnUntraced(function* (data) {
-            const accounts = { ...data.accounts }
-            const active = { ...data.active }
-            const removed = accounts[id]
-            if (!removed) return [undefined, data] as const
-            const wasActive = active[removed.serviceID] === id
-            delete accounts[id]
-            const replacement = Object.values(accounts).find((account) => account.serviceID === removed.serviceID)
-            if (wasActive) {
-              if (replacement) active[removed.serviceID] = replacement.id
-              else delete active[removed.serviceID]
-            }
-
-            const next = { ...data, accounts, active }
-            yield* write(next)
-            return [
-              {
-                account: removed,
-                switched: wasActive ? { serviceID: removed.serviceID, from: id, to: replacement?.id } : undefined,
-              },
-              next,
-            ] as const
-          }),
-        )
-        if (removed) {
-          yield* events.publish(Event.Removed, { account: removed.account })
-          if (removed.switched) yield* events.publish(Event.Switched, removed.switched)
-        }
-      }),
-
-      activate,
-    }
-
-    return Service.of(result)
-  }),
-)
-
-export const defaultLayer = layer.pipe(
-  Layer.provide(AppFileSystem.defaultLayer),
-  Layer.provide(Global.defaultLayer),
-  Layer.provide(EventV2.defaultLayer),
-)
@@ -89,7 +89,7 @@ enableMapSet()
 export const layer = Layer.effect(
  Service,
  Effect.gen(function* () {
-    const location = yield* Location.Service
+    yield* Location.Service
    const plugin = yield* PluginV2.Service
    const events = yield* EventV2.Service
    const policy = yield* Policy.Service
@@ -166,14 +166,8 @@ export const layer = Layer.effect(
          model: {
            get: (providerID, modelID) => draft.providers.get(providerID)?.models.get(modelID),
            update: (providerID, modelID, fn) => {
-              let record = draft.providers.get(providerID)
-              if (!record) {
-                record = castDraft({
-                  provider: ProviderV2.Info.empty(providerID),
-                  models: new Map<ModelV2.ID, ModelV2.Info>(),
-                })
-                draft.providers.set(providerID, record)
-              }
+              result.provider.update(providerID, () => {})
+              const record = draft.providers.get(providerID)!
              const model = record.models.get(modelID) ?? castDraft(ModelV2.Info.empty(providerID, modelID))
              if (!record.models.has(modelID)) record.models.set(modelID, model)
              fn(model)
@@ -196,7 +190,6 @@ export const layer = Layer.effect(
      },
      finalize: Effect.fn("CatalogV2.finalize")(function* (catalog, reason) {
        if (reason !== "plugin.added") yield* plugin.trigger("catalog.transform", catalog, {}).pipe(Effect.asVoid)
-        if (!policy.hasStatements()) return
        for (const record of [...catalog.provider.list()]) {
          if ((yield* policy.evaluate("provider.use", record.provider.id, "allow")) === "deny") {
            catalog.provider.remove(record.provider.id)
@@ -206,11 +199,6 @@ export const layer = Layer.effect(
    })

    yield* events.subscribe(PluginV2.Event.Added).pipe(
-      // Plugin registries are location scoped even though the event bus is process scoped.
-      Stream.filter(
-        (event) =>
-          event.location?.directory === location.directory && event.location.workspaceID === location.workspaceID,
-      ),
      Stream.runForEach((event) =>
        state.update((catalog) => plugin.triggerFor(event.data.id, "catalog.transform", catalog, {}), "plugin.added"),
      ),
@@ -329,7 +317,4 @@ export const layer = Layer.effect(

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

-export const locationLayer = layer.pipe(
-  Layer.provideMerge(PluginV2.locationLayer),
-  Layer.provideMerge(Policy.locationLayer),
-)
+export const defaultLayer = layer.pipe(Layer.provide(EventV2.defaultLayer), Layer.provide(PluginV2.defaultLayer))
@@ -200,4 +200,4 @@ export const layer = Layer.effect(
  }),
 )

-export const locationLayer = layer.pipe(Layer.provideMerge(Policy.locationLayer))
+export const defaultLayer = layer.pipe(Layer.provide(AppFileSystem.defaultLayer), Layer.provide(Global.defaultLayer))
@@ -1,60 +0,0 @@
-export * as Database from "./database"
-
-import { EffectDrizzleSqlite } from "@opencode-ai/effect-drizzle-sqlite"
-import { layer as sqliteLayer } from "#sqlite"
-import { Context, Effect, Layer } from "effect"
-import { Global } from "../global"
-import { Flag } from "../flag/flag"
-import { isAbsolute, join } from "path"
-import { DatabaseMigration } from "./migration"
-import { InstallationChannel } from "../installation/version"
-
-const makeDatabase = EffectDrizzleSqlite.makeWithDefaults()
-type DatabaseShape = Effect.Success<typeof makeDatabase>
-
-export interface Interface {
-  db: DatabaseShape
-}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/v2/storage/Database") {}
-
-export const layer = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const db = yield* makeDatabase
-
-    yield* db.run("PRAGMA journal_mode = WAL")
-    yield* db.run("PRAGMA synchronous = NORMAL")
-    yield* db.run("PRAGMA busy_timeout = 5000")
-    yield* db.run("PRAGMA cache_size = -64000")
-    yield* db.run("PRAGMA foreign_keys = ON")
-    yield* db.run("PRAGMA wal_checkpoint(PASSIVE)")
-    yield* DatabaseMigration.apply(db)
-
-    return { db }
-  }).pipe(Effect.orDie),
-)
-
-export function layerFromPath(filename: string) {
-  return layer.pipe(Layer.provide(sqliteLayer({ filename })))
-}
-
-export function path() {
-  if (Flag.OPENCODE_DB) {
-    if (Flag.OPENCODE_DB === ":memory:" || isAbsolute(Flag.OPENCODE_DB)) return Flag.OPENCODE_DB
-    return join(Global.Path.data, Flag.OPENCODE_DB)
-  }
-  if (
-    ["latest", "beta", "prod"].includes(InstallationChannel) ||
-    process.env.OPENCODE_DISABLE_CHANNEL_DB === "1" ||
-    process.env.OPENCODE_DISABLE_CHANNEL_DB === "true"
-  )
-    return join(Global.Path.data, "opencode.db")
-  return join(Global.Path.data, `opencode-${InstallationChannel.replace(/[^a-zA-Z0-9._-]/g, "-")}.db`)
-}
-
-export const defaultLayer = Layer.unwrap(
-  Effect.gen(function* () {
-    return layerFromPath(path())
-  }),
-).pipe(Layer.provide(Global.defaultLayer))
@@ -1,27 +0,0 @@
-import type { DatabaseMigration } from "./migration"
-
-export const migrations = (
-  await Promise.all([
-    import("./migration/20260127222353_familiar_lady_ursula"),
-    import("./migration/20260211171708_add_project_commands"),
-    import("./migration/20260213144116_wakeful_the_professor"),
-    import("./migration/20260225215848_workspace"),
-    import("./migration/20260227213759_add_session_workspace_id"),
-    import("./migration/20260228203230_blue_harpoon"),
-    import("./migration/20260303231226_add_workspace_fields"),
-    import("./migration/20260309230000_move_org_to_state"),
-    import("./migration/20260312043431_session_message_cursor"),
-    import("./migration/20260323234822_events"),
-    import("./migration/20260410174513_workspace-name"),
-    import("./migration/20260413175956_chief_energizer"),
-    import("./migration/20260423070820_add_icon_url_override"),
-    import("./migration/20260427172553_slow_nightmare"),
-    import("./migration/20260428004200_add_session_path"),
-    import("./migration/20260501142318_next_venus"),
-    import("./migration/20260504145000_add_sync_owner"),
-    import("./migration/20260507164347_add_workspace_time"),
-    import("./migration/20260510033149_session_usage"),
-    import("./migration/20260511000411_data_migration_state"),
-    import("./migration/20260530232709_lovely_romulus"),
-  ])
-).map((module) => module.default) satisfies DatabaseMigration.Migration[]
@@ -1,58 +0,0 @@
-export * as DatabaseMigration from "./migration"
-
-import { sql } from "drizzle-orm"
-import { Effect } from "effect"
-import type { EffectDrizzleSqlite } from "@opencode-ai/effect-drizzle-sqlite"
-import { migrations } from "./migration.gen"
-
-type Database = EffectDrizzleSqlite.EffectSQLiteDatabase
-type Transaction = Parameters<Parameters<Database["transaction"]>[0]>[0]
-
-export type Migration = {
-  id: string
-  up: (tx: Transaction) => Effect.Effect<void, unknown>
-}
-
-export function apply(db: Database) {
-  return applyOnly(db, migrations)
-}
-
-export function applyOnly(db: Database, input: Migration[]) {
-  return Effect.gen(function* () {
-    yield* db.run(
-      sql`CREATE TABLE IF NOT EXISTS ${sql.identifier("migration")} (id TEXT PRIMARY KEY, time_completed INTEGER NOT NULL)`,
-    )
-    let completed = new Set(
-      (yield* db.all<{ id: string }>(sql`SELECT id FROM ${sql.identifier("migration")}`)).map((row) => row.id),
-    )
-    if (completed.size === 0) {
-      // Existing installs used Drizzle's migration journal. Seed the new
-      // journal once so TypeScript migrations don't replay old SQL.
-      if (
-        yield* db.get(sql`SELECT name FROM sqlite_master WHERE type = 'table' AND name = ${"__drizzle_migrations"}`)
-      ) {
-        yield* db.run(sql`
-          INSERT OR IGNORE INTO ${sql.identifier("migration")} (id, time_completed)
-          SELECT name, ${Date.now()}
-          FROM ${sql.identifier("__drizzle_migrations")}
-          WHERE name IS NOT NULL
-        `)
-        completed = new Set(
-          (yield* db.all<{ id: string }>(sql`SELECT id FROM ${sql.identifier("migration")}`)).map((row) => row.id),
-        )
-      }
-    }
-
-    for (const migration of input) {
-      if (completed.has(migration.id)) continue
-      yield* db.transaction((tx) =>
-        Effect.gen(function* () {
-          if (!process.env.OPENCODE_SKIP_MIGRATIONS) yield* migration.up(tx)
-          yield* tx.run(
-            sql`INSERT INTO ${sql.identifier("migration")} (id, time_completed) VALUES (${migration.id}, ${Date.now()})`,
-          )
-        }),
-      )
-    }
-  })
-}
@@ -1,107 +0,0 @@
-import { Effect } from "effect"
-import type { DatabaseMigration } from "../migration"
-
-export default {
-  id: "20260127222353_familiar_lady_ursula",
-  up(tx) {
-    return Effect.gen(function* () {
-      yield* tx.run(`
-        CREATE TABLE \`project\` (
-          \`id\` text PRIMARY KEY,
-          \`worktree\` text NOT NULL,
-          \`vcs\` text,
-          \`name\` text,
-          \`icon_url\` text,
-          \`icon_color\` text,
-          \`time_created\` integer NOT NULL,
-          \`time_updated\` integer NOT NULL,
-          \`time_initialized\` integer,
-          \`sandboxes\` text NOT NULL
-        );
-      `)
-      yield* tx.run(`
-        CREATE TABLE \`message\` (
-          \`id\` text PRIMARY KEY,
-          \`session_id\` text NOT NULL,
-          \`time_created\` integer NOT NULL,
-          \`time_updated\` integer NOT NULL,
-          \`data\` text NOT NULL,
-          CONSTRAINT \`fk_message_session_id_session_id_fk\` FOREIGN KEY (\`session_id\`) REFERENCES \`session\`(\`id\`) ON DELETE CASCADE
-        );
-      `)
-      yield* tx.run(`
-        CREATE TABLE \`part\` (
-          \`id\` text PRIMARY KEY,
-          \`message_id\` text NOT NULL,
-          \`session_id\` text NOT NULL,
-          \`time_created\` integer NOT NULL,
-          \`time_updated\` integer NOT NULL,
-          \`data\` text NOT NULL,
-          CONSTRAINT \`fk_part_message_id_message_id_fk\` FOREIGN KEY (\`message_id\`) REFERENCES \`message\`(\`id\`) ON DELETE CASCADE
-        );
-      `)
-      yield* tx.run(`
-        CREATE TABLE \`permission\` (
-          \`project_id\` text PRIMARY KEY,
-          \`time_created\` integer NOT NULL,
-          \`time_updated\` integer NOT NULL,
-          \`data\` text NOT NULL,
-          CONSTRAINT \`fk_permission_project_id_project_id_fk\` FOREIGN KEY (\`project_id\`) REFERENCES \`project\`(\`id\`) ON DELETE CASCADE
-        );
-      `)
-      yield* tx.run(`
-        CREATE TABLE \`session\` (
-          \`id\` text PRIMARY KEY,
-          \`project_id\` text NOT NULL,
-          \`parent_id\` text,
-          \`slug\` text NOT NULL,
-          \`directory\` text NOT NULL,
-          \`title\` text NOT NULL,
-          \`version\` text NOT NULL,
-          \`share_url\` text,
-          \`summary_additions\` integer,
-          \`summary_deletions\` integer,
-          \`summary_files\` integer,
-          \`summary_diffs\` text,
-          \`revert\` text,
-          \`permission\` text,
-          \`time_created\` integer NOT NULL,
-          \`time_updated\` integer NOT NULL,
-          \`time_compacting\` integer,
-          \`time_archived\` integer,
-          CONSTRAINT \`fk_session_project_id_project_id_fk\` FOREIGN KEY (\`project_id\`) REFERENCES \`project\`(\`id\`) ON DELETE CASCADE
-        );
-      `)
-      yield* tx.run(`
-        CREATE TABLE \`todo\` (
-          \`session_id\` text NOT NULL,
-          \`content\` text NOT NULL,
-          \`status\` text NOT NULL,
-          \`priority\` text NOT NULL,
-          \`position\` integer NOT NULL,
-          \`time_created\` integer NOT NULL,
-          \`time_updated\` integer NOT NULL,
-          CONSTRAINT \`todo_pk\` PRIMARY KEY(\`session_id\`, \`position\`),
-          CONSTRAINT \`fk_todo_session_id_session_id_fk\` FOREIGN KEY (\`session_id\`) REFERENCES \`session\`(\`id\`) ON DELETE CASCADE
-        );
-      `)
-      yield* tx.run(`
-        CREATE TABLE \`session_share\` (
-          \`session_id\` text PRIMARY KEY,
-          \`id\` text NOT NULL,
-          \`secret\` text NOT NULL,
-          \`url\` text NOT NULL,
-          \`time_created\` integer NOT NULL,
-          \`time_updated\` integer NOT NULL,
-          CONSTRAINT \`fk_session_share_session_id_session_id_fk\` FOREIGN KEY (\`session_id\`) REFERENCES \`session\`(\`id\`) ON DELETE CASCADE
-        );
-      `)
-      yield* tx.run(`CREATE INDEX \`message_session_idx\` ON \`message\` (\`session_id\`);`)
-      yield* tx.run(`CREATE INDEX \`part_message_idx\` ON \`part\` (\`message_id\`);`)
-      yield* tx.run(`CREATE INDEX \`part_session_idx\` ON \`part\` (\`session_id\`);`)
-      yield* tx.run(`CREATE INDEX \`session_project_idx\` ON \`session\` (\`project_id\`);`)
-      yield* tx.run(`CREATE INDEX \`session_parent_idx\` ON \`session\` (\`parent_id\`);`)
-      yield* tx.run(`CREATE INDEX \`todo_session_idx\` ON \`todo\` (\`session_id\`);`)
-    })
-  },
-} satisfies DatabaseMigration.Migration
@@ -1,11 +0,0 @@
-import { Effect } from "effect"
-import type { DatabaseMigration } from "../migration"
-
-export default {
-  id: "20260211171708_add_project_commands",
-  up(tx) {
-    return Effect.gen(function* () {
-      yield* tx.run(`ALTER TABLE \`project\` ADD \`commands\` text;`)
-    })
-  },
-} satisfies DatabaseMigration.Migration
@@ -1,23 +0,0 @@
-import { Effect } from "effect"
-import type { DatabaseMigration } from "../migration"
-
-export default {
-  id: "20260213144116_wakeful_the_professor",
-  up(tx) {
-    return Effect.gen(function* () {
-      yield* tx.run(`
-        CREATE TABLE \`control_account\` (
-          \`email\` text NOT NULL,
-          \`url\` text NOT NULL,
-          \`access_token\` text NOT NULL,
-          \`refresh_token\` text NOT NULL,
-          \`token_expiry\` integer,
-          \`active\` integer NOT NULL,
-          \`time_created\` integer NOT NULL,
-          \`time_updated\` integer NOT NULL,
-          CONSTRAINT \`control_account_pk\` PRIMARY KEY(\`email\`, \`url\`)
-        );
-      `)
-    })
-  },
-} satisfies DatabaseMigration.Migration
@@ -1,19 +0,0 @@
-import { Effect } from "effect"
-import type { DatabaseMigration } from "../migration"
-
-export default {
-  id: "20260225215848_workspace",
-  up(tx) {
-    return Effect.gen(function* () {
-      yield* tx.run(`
-        CREATE TABLE \`workspace\` (
-          \`id\` text PRIMARY KEY,
-          \`branch\` text,
-          \`project_id\` text NOT NULL,
-          \`config\` text NOT NULL,
-          CONSTRAINT \`fk_workspace_project_id_project_id_fk\` FOREIGN KEY (\`project_id\`) REFERENCES \`project\`(\`id\`) ON DELETE CASCADE
-        );
-      `)
-    })
-  },
-} satisfies DatabaseMigration.Migration
@@ -1,12 +0,0 @@
-import { Effect } from "effect"
-import type { DatabaseMigration } from "../migration"
-
-export default {
-  id: "20260227213759_add_session_workspace_id",
-  up(tx) {
-    return Effect.gen(function* () {
-      yield* tx.run(`ALTER TABLE \`session\` ADD \`workspace_id\` text;`)
-      yield* tx.run(`CREATE INDEX \`session_workspace_idx\` ON \`session\` (\`workspace_id\`);`)
-    })
-  },
-} satisfies DatabaseMigration.Migration
@@ -1,30 +0,0 @@
-import { Effect } from "effect"
-import type { DatabaseMigration } from "../migration"
-
-export default {
-  id: "20260228203230_blue_harpoon",
-  up(tx) {
-    return Effect.gen(function* () {
-      yield* tx.run(`
-        CREATE TABLE \`account\` (
-          \`id\` text PRIMARY KEY,
-          \`email\` text NOT NULL,
-          \`url\` text NOT NULL,
-          \`access_token\` text NOT NULL,
-          \`refresh_token\` text NOT NULL,
-          \`token_expiry\` integer,
-          \`selected_org_id\` text,
-          \`time_created\` integer NOT NULL,
-          \`time_updated\` integer NOT NULL
-        );
-      `)
-      yield* tx.run(`
-        CREATE TABLE \`account_state\` (
-          \`id\` integer PRIMARY KEY NOT NULL,
-          \`active_account_id\` text,
-          FOREIGN KEY (\`active_account_id\`) REFERENCES \`account\`(\`id\`) ON UPDATE no action ON DELETE set null
-        );
-      `)
-    })
-  },
-} satisfies DatabaseMigration.Migration
@@ -1,15 +0,0 @@
-import { Effect } from "effect"
-import type { DatabaseMigration } from "../migration"
-
-export default {
-  id: "20260303231226_add_workspace_fields",
-  up(tx) {
-    return Effect.gen(function* () {
-      yield* tx.run(`ALTER TABLE \`workspace\` ADD \`type\` text NOT NULL;`)
-      yield* tx.run(`ALTER TABLE \`workspace\` ADD \`name\` text;`)
-      yield* tx.run(`ALTER TABLE \`workspace\` ADD \`directory\` text;`)
-      yield* tx.run(`ALTER TABLE \`workspace\` ADD \`extra\` text;`)
-      yield* tx.run(`ALTER TABLE \`workspace\` DROP COLUMN \`config\`;`)
-    })
-  },
-} satisfies DatabaseMigration.Migration
@@ -1,15 +0,0 @@
-import { Effect } from "effect"
-import type { DatabaseMigration } from "../migration"
-
-export default {
-  id: "20260309230000_move_org_to_state",
-  up(tx) {
-    return Effect.gen(function* () {
-      yield* tx.run(`ALTER TABLE \`account_state\` ADD \`active_org_id\` text;`)
-      yield* tx.run(
-        `UPDATE \`account_state\` SET \`active_org_id\` = (SELECT \`selected_org_id\` FROM \`account\` WHERE \`account\`.\`id\` = \`account_state\`.\`active_account_id\`);`,
-      )
-      yield* tx.run(`ALTER TABLE \`account\` DROP COLUMN \`selected_org_id\`;`)
-    })
-  },
-} satisfies DatabaseMigration.Migration
@@ -1,16 +0,0 @@
-import { Effect } from "effect"
-import type { DatabaseMigration } from "../migration"
-
-export default {
-  id: "20260312043431_session_message_cursor",
-  up(tx) {
-    return Effect.gen(function* () {
-      yield* tx.run(`DROP INDEX IF EXISTS \`message_session_idx\`;`)
-      yield* tx.run(`DROP INDEX IF EXISTS \`part_message_idx\`;`)
-      yield* tx.run(
-        `CREATE INDEX \`message_session_time_created_id_idx\` ON \`message\` (\`session_id\`,\`time_created\`,\`id\`);`,
-      )
-      yield* tx.run(`CREATE INDEX \`part_message_id_id_idx\` ON \`part\` (\`message_id\`,\`id\`);`)
-    })
-  },
-} satisfies DatabaseMigration.Migration
@@ -1,26 +0,0 @@
-import { Effect } from "effect"
-import type { DatabaseMigration } from "../migration"
-
-export default {
-  id: "20260323234822_events",
-  up(tx) {
-    return Effect.gen(function* () {
-      yield* tx.run(`
-        CREATE TABLE \`event_sequence\` (
-          \`aggregate_id\` text PRIMARY KEY,
-          \`seq\` integer NOT NULL
-        );
-      `)
-      yield* tx.run(`
-        CREATE TABLE \`event\` (
-          \`id\` text PRIMARY KEY,
-          \`aggregate_id\` text NOT NULL,
-          \`seq\` integer NOT NULL,
-          \`type\` text NOT NULL,
-          \`data\` text NOT NULL,
-          CONSTRAINT \`fk_event_aggregate_id_event_sequence_aggregate_id_fk\` FOREIGN KEY (\`aggregate_id\`) REFERENCES \`event_sequence\`(\`aggregate_id\`) ON DELETE CASCADE
-        );
-      `)
-    })
-  },
-} satisfies DatabaseMigration.Migration
@@ -1,29 +0,0 @@
-import { Effect } from "effect"
-import type { DatabaseMigration } from "../migration"
-
-export default {
-  id: "20260410174513_workspace-name",
-  up(tx) {
-    return Effect.gen(function* () {
-      yield* tx.run(`PRAGMA foreign_keys=OFF;`)
-      yield* tx.run(`
-        CREATE TABLE \`__new_workspace\` (
-          \`id\` text PRIMARY KEY,
-          \`type\` text NOT NULL,
-          \`name\` text DEFAULT '' NOT NULL,
-          \`branch\` text,
-          \`directory\` text,
-          \`extra\` text,
-          \`project_id\` text NOT NULL,
-          CONSTRAINT \`fk_workspace_project_id_project_id_fk\` FOREIGN KEY (\`project_id\`) REFERENCES \`project\`(\`id\`) ON DELETE CASCADE
-        );
-      `)
-      yield* tx.run(
-        `INSERT INTO \`__new_workspace\`(\`id\`, \`type\`, \`branch\`, \`name\`, \`directory\`, \`extra\`, \`project_id\`) SELECT \`id\`, \`type\`, \`branch\`, \`name\`, \`directory\`, \`extra\`, \`project_id\` FROM \`workspace\`;`,
-      )
-      yield* tx.run(`DROP TABLE \`workspace\`;`)
-      yield* tx.run(`ALTER TABLE \`__new_workspace\` RENAME TO \`workspace\`;`)
-      yield* tx.run(`PRAGMA foreign_keys=ON;`)
-    })
-  },
-} satisfies DatabaseMigration.Migration
@@ -1,24 +0,0 @@
-import { Effect } from "effect"
-import type { DatabaseMigration } from "../migration"
-
-export default {
-  id: "20260413175956_chief_energizer",
-  up(tx) {
-    return Effect.gen(function* () {
-      yield* tx.run(`
-        CREATE TABLE \`session_entry\` (
-          \`id\` text PRIMARY KEY,
-          \`session_id\` text NOT NULL,
-          \`type\` text NOT NULL,
-          \`time_created\` integer NOT NULL,
-          \`time_updated\` integer NOT NULL,
-          \`data\` text NOT NULL,
-          CONSTRAINT \`fk_session_entry_session_id_session_id_fk\` FOREIGN KEY (\`session_id\`) REFERENCES \`session\`(\`id\`) ON DELETE CASCADE
-        );
-      `)
-      yield* tx.run(`CREATE INDEX \`session_entry_session_idx\` ON \`session_entry\` (\`session_id\`);`)
-      yield* tx.run(`CREATE INDEX \`session_entry_session_type_idx\` ON \`session_entry\` (\`session_id\`,\`type\`);`)
-      yield* tx.run(`CREATE INDEX \`session_entry_time_created_idx\` ON \`session_entry\` (\`time_created\`);`)
-    })
-  },
-} satisfies DatabaseMigration.Migration
@@ -1,14 +0,0 @@
-import { Effect } from "effect"
-import type { DatabaseMigration } from "../migration"
-
-export default {
-  id: "20260423070820_add_icon_url_override",
-  up(tx) {
-    return Effect.gen(function* () {
-      yield* tx.run(`
-        ALTER TABLE \`project\` ADD \`icon_url_override\` text;
-        UPDATE \`project\` SET \`icon_url_override\` = \`icon_url\` WHERE \`icon_url\` IS NOT NULL;
-      `)
-    })
-  },
-} satisfies DatabaseMigration.Migration
@@ -1,30 +0,0 @@
-import { Effect } from "effect"
-import type { DatabaseMigration } from "../migration"
-
-export default {
-  id: "20260427172553_slow_nightmare",
-  up(tx) {
-    return Effect.gen(function* () {
-      yield* tx.run(`
-        CREATE TABLE \`session_message\` (
-          \`id\` text PRIMARY KEY,
-          \`session_id\` text NOT NULL,
-          \`type\` text NOT NULL,
-          \`time_created\` integer NOT NULL,
-          \`time_updated\` integer NOT NULL,
-          \`data\` text NOT NULL,
-          CONSTRAINT \`fk_session_message_session_id_session_id_fk\` FOREIGN KEY (\`session_id\`) REFERENCES \`session\`(\`id\`) ON DELETE CASCADE
-        );
-      `)
-      yield* tx.run(`DROP INDEX IF EXISTS \`session_entry_session_idx\`;`)
-      yield* tx.run(`DROP INDEX IF EXISTS \`session_entry_session_type_idx\`;`)
-      yield* tx.run(`DROP INDEX IF EXISTS \`session_entry_time_created_idx\`;`)
-      yield* tx.run(`CREATE INDEX \`session_message_session_idx\` ON \`session_message\` (\`session_id\`);`)
-      yield* tx.run(
-        `CREATE INDEX \`session_message_session_type_idx\` ON \`session_message\` (\`session_id\`,\`type\`);`,
-      )
-      yield* tx.run(`CREATE INDEX \`session_message_time_created_idx\` ON \`session_message\` (\`time_created\`);`)
-      yield* tx.run(`DROP TABLE \`session_entry\`;`)
-    })
-  },
-} satisfies DatabaseMigration.Migration
@@ -1,11 +0,0 @@
-import { Effect } from "effect"
-import type { DatabaseMigration } from "../migration"
-
-export default {
-  id: "20260428004200_add_session_path",
-  up(tx) {
-    return Effect.gen(function* () {
-      yield* tx.run(`ALTER TABLE \`session\` ADD \`path\` text;`)
-    })
-  },
-} satisfies DatabaseMigration.Migration
@@ -1,12 +0,0 @@
-import { Effect } from "effect"
-import type { DatabaseMigration } from "../migration"
-
-export default {
-  id: "20260501142318_next_venus",
-  up(tx) {
-    return Effect.gen(function* () {
-      yield* tx.run(`ALTER TABLE \`session\` ADD \`agent\` text;`)
-      yield* tx.run(`ALTER TABLE \`session\` ADD \`model\` text;`)
-    })
-  },
-} satisfies DatabaseMigration.Migration
@@ -1,11 +0,0 @@
-import { Effect } from "effect"
-import type { DatabaseMigration } from "../migration"
-
-export default {
-  id: "20260504145000_add_sync_owner",
-  up(tx) {
-    return Effect.gen(function* () {
-      yield* tx.run(`ALTER TABLE \`event_sequence\` ADD \`owner_id\` text;`)
-    })
-  },
-} satisfies DatabaseMigration.Migration
@@ -1,11 +0,0 @@
-import { Effect } from "effect"
-import type { DatabaseMigration } from "../migration"
-
-export default {
-  id: "20260507164347_add_workspace_time",
-  up(tx) {
-    return Effect.gen(function* () {
-      yield* tx.run(`ALTER TABLE \`workspace\` ADD \`time_used\` integer NOT NULL DEFAULT 0;`)
-    })
-  },
-} satisfies DatabaseMigration.Migration
@@ -1,56 +0,0 @@
-import { Effect } from "effect"
-import type { DatabaseMigration } from "../migration"
-
-export default {
-  id: "20260510033149_session_usage",
-  up(tx) {
-    return Effect.gen(function* () {
-      yield* tx.run(`ALTER TABLE \`session\` ADD \`cost\` real DEFAULT 0 NOT NULL;`)
-      yield* tx.run(`ALTER TABLE \`session\` ADD \`tokens_input\` integer DEFAULT 0 NOT NULL;`)
-      yield* tx.run(`ALTER TABLE \`session\` ADD \`tokens_output\` integer DEFAULT 0 NOT NULL;`)
-      yield* tx.run(`ALTER TABLE \`session\` ADD \`tokens_reasoning\` integer DEFAULT 0 NOT NULL;`)
-      yield* tx.run(`ALTER TABLE \`session\` ADD \`tokens_cache_read\` integer DEFAULT 0 NOT NULL;`)
-      yield* tx.run(`ALTER TABLE \`session\` ADD \`tokens_cache_write\` integer DEFAULT 0 NOT NULL;`)
-      yield* tx.run(`
-        UPDATE session
-        SET
-          cost = coalesce((
-            SELECT sum(coalesce(json_extract(message.data, '$.cost'), 0))
-            FROM message
-            WHERE message.session_id = session.id
-              AND json_extract(message.data, '$.role') = 'assistant'
-          ), 0),
-          tokens_input = coalesce((
-            SELECT sum(coalesce(json_extract(message.data, '$.tokens.input'), 0))
-            FROM message
-            WHERE message.session_id = session.id
-              AND json_extract(message.data, '$.role') = 'assistant'
-          ), 0),
-          tokens_output = coalesce((
-            SELECT sum(coalesce(json_extract(message.data, '$.tokens.output'), 0))
-            FROM message
-            WHERE message.session_id = session.id
-              AND json_extract(message.data, '$.role') = 'assistant'
-          ), 0),
-          tokens_reasoning = coalesce((
-            SELECT sum(coalesce(json_extract(message.data, '$.tokens.reasoning'), 0))
-            FROM message
-            WHERE message.session_id = session.id
-              AND json_extract(message.data, '$.role') = 'assistant'
-          ), 0),
-          tokens_cache_read = coalesce((
-            SELECT sum(coalesce(json_extract(message.data, '$.tokens.cache.read'), 0))
-            FROM message
-            WHERE message.session_id = session.id
-              AND json_extract(message.data, '$.role') = 'assistant'
-          ), 0),
-          tokens_cache_write = coalesce((
-            SELECT sum(coalesce(json_extract(message.data, '$.tokens.cache.write'), 0))
-            FROM message
-            WHERE message.session_id = session.id
-              AND json_extract(message.data, '$.role') = 'assistant'
-          ), 0)
-      `)
-    })
-  },
-} satisfies DatabaseMigration.Migration
@@ -1,16 +0,0 @@
-import { Effect } from "effect"
-import type { DatabaseMigration } from "../migration"
-
-export default {
-  id: "20260511000411_data_migration_state",
-  up(tx) {
-    return Effect.gen(function* () {
-      yield* tx.run(`
-        CREATE TABLE \`data_migration\` (
-          \`name\` text PRIMARY KEY,
-          \`time_completed\` integer NOT NULL
-        );
-      `)
-    })
-  },
-} satisfies DatabaseMigration.Migration
@@ -1,11 +0,0 @@
-import { Effect } from "effect"
-import type { DatabaseMigration } from "../migration"
-
-export default {
-  id: "20260530232709_lovely_romulus",
-  up(tx) {
-    return Effect.gen(function* () {
-      yield* tx.run(`ALTER TABLE \`session\` ADD \`metadata\` text;`)
-    })
-  },
-} satisfies DatabaseMigration.Migration
@@ -1,182 +0,0 @@
-import { Database } from "bun:sqlite"
-import { drizzle } from "drizzle-orm/bun-sqlite"
-import * as Context from "effect/Context"
-import * as Effect from "effect/Effect"
-import * as Fiber from "effect/Fiber"
-import { identity } from "effect/Function"
-import * as Layer from "effect/Layer"
-import * as Scope from "effect/Scope"
-import * as Semaphore from "effect/Semaphore"
-import * as Stream from "effect/Stream"
-import * as Reactivity from "effect/unstable/reactivity/Reactivity"
-import * as Client from "effect/unstable/sql/SqlClient"
-import type { Connection } from "effect/unstable/sql/SqlConnection"
-import { classifySqliteError, SqlError } from "effect/unstable/sql/SqlError"
-import * as Statement from "effect/unstable/sql/Statement"
-import { Sqlite } from "./sqlite"
-
-const ATTR_DB_SYSTEM_NAME = "db.system.name"
-
-const TypeId = "~@opencode-ai/core/database/SqliteBun" as const
-type TypeId = typeof TypeId
-
-interface SqliteClient extends Client.SqlClient {
-  readonly [TypeId]: TypeId
-  readonly config: Config
-  readonly export: Effect.Effect<Uint8Array, SqlError>
-  readonly loadExtension: (path: string) => Effect.Effect<void, SqlError>
-  readonly updateValues: never
-}
-
-interface Config {
-  readonly filename: string
-  readonly readonly?: boolean
-  readonly create?: boolean
-  readonly readwrite?: boolean
-  readonly disableWAL?: boolean
-  readonly spanAttributes?: Record<string, unknown>
-  readonly transformResultNames?: (str: string) => string
-  readonly transformQueryNames?: (str: string) => string
-}
-
-interface SqliteConnection extends Connection {
-  readonly export: Effect.Effect<Uint8Array, SqlError>
-  readonly loadExtension: (path: string) => Effect.Effect<void, SqlError>
-}
-
-const make = (options: Config) =>
-  Effect.gen(function* () {
-    const native = (yield* Sqlite.Native) as Database
-
-    const compiler = Statement.makeCompilerSqlite(options.transformQueryNames)
-    const transformRows = options.transformResultNames
-      ? Statement.defaultTransforms(options.transformResultNames).array
-      : undefined
-
-    const run = (query: string, params: ReadonlyArray<unknown> = []) =>
-      Effect.withFiber<Array<Record<string, unknown>>, SqlError>((fiber) => {
-        const statement = native.query(query)
-        // @ts-ignore bun-types missing safeIntegers method, fixed in https://github.com/oven-sh/bun/pull/26627
-        statement.safeIntegers(Context.get(fiber.context, Client.SafeIntegers))
-        try {
-          return Effect.succeed((statement.all(...(params as any)) ?? []) as Array<Record<string, unknown>>)
-        } catch (cause) {
-          return Effect.fail(
-            new SqlError({
-              reason: classifySqliteError(cause, { message: "Failed to execute statement", operation: "execute" }),
-            }),
-          )
-        }
-      })
-
-    const runValues = (query: string, params: ReadonlyArray<unknown> = []) =>
-      Effect.withFiber<Array<unknown[]>, SqlError>((fiber) => {
-        const statement = native.query(query)
-        // @ts-ignore bun-types missing safeIntegers method, fixed in https://github.com/oven-sh/bun/pull/26627
-        statement.safeIntegers(Context.get(fiber.context, Client.SafeIntegers))
-        try {
-          return Effect.succeed((statement.values(...(params as any)) ?? []) as Array<unknown[]>)
-        } catch (cause) {
-          return Effect.fail(
-            new SqlError({
-              reason: classifySqliteError(cause, { message: "Failed to execute statement", operation: "execute" }),
-            }),
-          )
-        }
-      })
-
-    const connection = identity<SqliteConnection>({
-      execute(query, params, transformRows) {
-        return transformRows ? Effect.map(run(query, params), transformRows) : run(query, params)
-      },
-      executeRaw(query, params) {
-        return run(query, params)
-      },
-      executeValues(query, params) {
-        return runValues(query, params)
-      },
-      executeUnprepared(query, params, transformRows) {
-        return this.execute(query, params, transformRows)
-      },
-      executeStream() {
-        return Stream.die("executeStream not implemented")
-      },
-      export: Effect.try({
-        try: () => native.serialize(),
-        catch: (cause) =>
-          new SqlError({
-            reason: classifySqliteError(cause, { message: "Failed to export database", operation: "export" }),
-          }),
-      }),
-      loadExtension: (path) =>
-        Effect.try({
-          try: () => native.loadExtension(path),
-          catch: (cause) =>
-            new SqlError({
-              reason: classifySqliteError(cause, { message: "Failed to load extension", operation: "loadExtension" }),
-            }),
-        }),
-    })
-
-    const semaphore = yield* Semaphore.make(1)
-    const acquirer = semaphore.withPermits(1)(Effect.succeed(connection))
-    const transactionAcquirer = Effect.uninterruptibleMask((restore) => {
-      const fiber = Fiber.getCurrent()!
-      const scope = Context.getUnsafe(fiber.context, Scope.Scope)
-      return Effect.as(
-        Effect.tap(restore(semaphore.take(1)), () => Scope.addFinalizer(scope, semaphore.release(1))),
-        connection,
-      )
-    })
-
-    const client = Object.assign(
-      (yield* Client.make({
-        acquirer,
-        compiler,
-        transactionAcquirer,
-        spanAttributes: [
-          ...(options.spanAttributes ? Object.entries(options.spanAttributes) : []),
-          [ATTR_DB_SYSTEM_NAME, "sqlite"],
-        ],
-        transformRows,
-      })) as SqliteClient,
-      {
-        [TypeId]: TypeId,
-        config: options,
-        export: Effect.flatMap(acquirer, (_) => _.export),
-        loadExtension: (path: string) => Effect.flatMap(acquirer, (_) => _.loadExtension(path)),
-      },
-    )
-
-    return client
-  })
-
-const nativeLayer = (config: Config) =>
-  Layer.effect(
-    Sqlite.Native,
-    Effect.gen(function* () {
-      const native = new Database(config.filename, {
-        readonly: config.readonly,
-        readwrite: config.readwrite ?? true,
-        create: config.create ?? true,
-      })
-      yield* Effect.addFinalizer(() => Effect.sync(() => native.close()))
-      if (config.disableWAL !== true) native.run("PRAGMA journal_mode = WAL;")
-      return native
-    }),
-  )
-
-const sqliteLayer = (config: Config) => Layer.effect(Client.SqlClient, make(config))
-
-const drizzleLayer = Layer.effect(
-  Sqlite.Drizzle,
-  Effect.gen(function* () {
-    return drizzle({ client: (yield* Sqlite.Native) as Database })
-  }),
-)
-
-export const layer = (config: Config) =>
-  Layer.merge(
-    nativeLayer(config),
-    Layer.merge(sqliteLayer(config), drizzleLayer).pipe(Layer.provide(nativeLayer(config))),
-  ).pipe(Layer.provide(Reactivity.layer))
@@ -1,177 +0,0 @@
-import { DatabaseSync, type SQLInputValue } from "node:sqlite"
-import { drizzle } from "drizzle-orm/node-sqlite"
-import * as Context from "effect/Context"
-import * as Effect from "effect/Effect"
-import * as Fiber from "effect/Fiber"
-import { identity } from "effect/Function"
-import * as Layer from "effect/Layer"
-import * as Scope from "effect/Scope"
-import * as Semaphore from "effect/Semaphore"
-import * as Stream from "effect/Stream"
-import * as Reactivity from "effect/unstable/reactivity/Reactivity"
-import * as Client from "effect/unstable/sql/SqlClient"
-import type { Connection } from "effect/unstable/sql/SqlConnection"
-import { classifySqliteError, SqlError } from "effect/unstable/sql/SqlError"
-import * as Statement from "effect/unstable/sql/Statement"
-import { Sqlite } from "./sqlite"
-
-const ATTR_DB_SYSTEM_NAME = "db.system.name"
-
-const TypeId = "~@opencode-ai/core/database/SqliteNode" as const
-type TypeId = typeof TypeId
-
-interface SqliteClient extends Client.SqlClient {
-  readonly [TypeId]: TypeId
-  readonly config: Config
-  readonly loadExtension: (path: string) => Effect.Effect<void, SqlError>
-  readonly updateValues: never
-}
-
-interface Config {
-  readonly filename: string
-  readonly readonly?: boolean
-  readonly create?: boolean
-  readonly readwrite?: boolean
-  readonly disableWAL?: boolean
-  readonly timeout?: number
-  readonly allowExtension?: boolean
-  readonly spanAttributes?: Record<string, unknown>
-  readonly transformResultNames?: (str: string) => string
-  readonly transformQueryNames?: (str: string) => string
-}
-
-interface SqliteConnection extends Connection {
-  readonly loadExtension: (path: string) => Effect.Effect<void, SqlError>
-}
-
-const make = (options: Config) =>
-  Effect.gen(function* () {
-    const native = (yield* Sqlite.Native) as DatabaseSync
-
-    const compiler = Statement.makeCompilerSqlite(options.transformQueryNames)
-    const transformRows = options.transformResultNames
-      ? Statement.defaultTransforms(options.transformResultNames).array
-      : undefined
-
-    const run = (query: string, params: ReadonlyArray<unknown> = []) =>
-      Effect.withFiber<Array<Record<string, unknown>>, SqlError>((fiber) => {
-        const statement = native.prepare(query)
-        statement.setReadBigInts(Context.get(fiber.context, Client.SafeIntegers))
-        try {
-          return Effect.succeed(statement.all(...(params as SQLInputValue[])) as Array<Record<string, unknown>>)
-        } catch (cause) {
-          return Effect.fail(
-            new SqlError({
-              reason: classifySqliteError(cause, { message: "Failed to execute statement", operation: "execute" }),
-            }),
-          )
-        }
-      })
-
-    const runValues = (query: string, params: ReadonlyArray<unknown> = []) =>
-      Effect.withFiber<ReadonlyArray<ReadonlyArray<unknown>>, SqlError>((fiber) => {
-        const statement = native.prepare(query)
-        statement.setReadBigInts(Context.get(fiber.context, Client.SafeIntegers))
-        statement.setReturnArrays(true)
-        try {
-          return Effect.succeed(
-            statement.all(...(params as SQLInputValue[])) as unknown as ReadonlyArray<ReadonlyArray<unknown>>,
-          )
-        } catch (cause) {
-          return Effect.fail(
-            new SqlError({
-              reason: classifySqliteError(cause, { message: "Failed to execute statement", operation: "execute" }),
-            }),
-          )
-        }
-      })
-
-    const connection = identity<SqliteConnection>({
-      execute(query, params, transformRows) {
-        return transformRows ? Effect.map(run(query, params), transformRows) : run(query, params)
-      },
-      executeRaw(query, params) {
-        return run(query, params)
-      },
-      executeValues(query, params) {
-        return runValues(query, params)
-      },
-      executeUnprepared(query, params, transformRows) {
-        return this.execute(query, params, transformRows)
-      },
-      executeStream() {
-        return Stream.die("executeStream not implemented")
-      },
-      loadExtension: (path) =>
-        Effect.try({
-          try: () => native.loadExtension(path),
-          catch: (cause) =>
-            new SqlError({
-              reason: classifySqliteError(cause, { message: "Failed to load extension", operation: "loadExtension" }),
-            }),
-        }),
-    })
-
-    const semaphore = yield* Semaphore.make(1)
-    const acquirer = semaphore.withPermits(1)(Effect.succeed(connection))
-    const transactionAcquirer = Effect.uninterruptibleMask((restore) => {
-      const fiber = Fiber.getCurrent()!
-      const scope = Context.getUnsafe(fiber.context, Scope.Scope)
-      return Effect.as(
-        Effect.tap(restore(semaphore.take(1)), () => Scope.addFinalizer(scope, semaphore.release(1))),
-        connection,
-      )
-    })
-
-    const client = Object.assign(
-      (yield* Client.make({
-        acquirer,
-        compiler,
-        transactionAcquirer,
-        spanAttributes: [
-          ...(options.spanAttributes ? Object.entries(options.spanAttributes) : []),
-          [ATTR_DB_SYSTEM_NAME, "sqlite"],
-        ],
-        transformRows,
-      })) as SqliteClient,
-      {
-        [TypeId]: TypeId,
-        config: options,
-        loadExtension: (path: string) => Effect.flatMap(acquirer, (_) => _.loadExtension(path)),
-      },
-    )
-
-    return client
-  })
-
-const nativeLayer = (config: Config) =>
-  Layer.effect(
-    Sqlite.Native,
-    Effect.gen(function* () {
-      const native = new DatabaseSync(config.filename, {
-        readOnly: config.readonly,
-        timeout: config.timeout,
-        allowExtension: config.allowExtension,
-        enableForeignKeyConstraints: true,
-        open: true,
-      })
-      yield* Effect.addFinalizer(() => Effect.sync(() => native.close()))
-      if (config.disableWAL !== true && config.readonly !== true) native.exec("PRAGMA journal_mode = WAL;")
-      return native
-    }),
-  )
-
-const sqliteLayer = (config: Config) => Layer.effect(Client.SqlClient, make(config))
-
-const drizzleLayer = Layer.effect(
-  Sqlite.Drizzle,
-  Effect.gen(function* () {
-    return drizzle({ client: (yield* Sqlite.Native) as DatabaseSync }) as unknown as Sqlite.DrizzleClient
-  }),
-)
-
-export const layer = (config: Config) =>
-  Layer.merge(
-    nativeLayer(config),
-    Layer.merge(sqliteLayer(config), drizzleLayer).pipe(Layer.provide(nativeLayer(config))),
-  ).pipe(Layer.provide(Reactivity.layer))
@@ -1,8 +0,0 @@
-export * as Sqlite from "./sqlite"
-
-import { Context } from "effect"
-import type { drizzle } from "drizzle-orm/bun-sqlite"
-
-export type DrizzleClient = ReturnType<typeof drizzle>
-export class Native extends Context.Service<Native, unknown>()("@opencode-ai/core/database/SqliteNative") {}
-export class Drizzle extends Context.Service<Drizzle, DrizzleClient>()("@opencode-ai/core/database/SqliteDrizzle") {}
@@ -1,9 +1,6 @@
 export * as EventV2 from "./event"

 import { Context, Effect, Layer, Option, PubSub, Schema, Stream } from "effect"
-import { eq } from "drizzle-orm"
-import { Database } from "./database/database"
-import { EventSequenceTable, EventTable } from "./event/sql"
 import { Location } from "./location"
 import { withStatics } from "./schema"
 import { Identifier } from "./util/identifier"
@@ -16,10 +13,8 @@ export type ID = typeof ID.Type

 export type Definition<Type extends string = string, DataSchema extends Schema.Top = Schema.Top> = {
  readonly type: Type
-  readonly sync?: {
-    readonly version: number
-    readonly aggregate: string
-  }
+  readonly version?: number
+  readonly aggregate?: string
  readonly data: DataSchema
 }

@@ -34,41 +29,14 @@ export type Payload<D extends Definition = Definition> = {
  readonly metadata?: Record<string, unknown>
 }

-export type Projector<D extends Definition = Definition> = (event: Payload<D>) => Effect.Effect<void>
-type AnyProjector = (event: Payload) => Effect.Effect<void>
-export type Listener = (event: Payload) => Effect.Effect<void>
 export type Sync = (event: Payload) => Effect.Effect<void>
-export type Unsubscribe = Effect.Effect<void>
-
-export type SerializedEvent = {
-  readonly id: ID
-  readonly type: string
-  readonly seq: number
-  readonly aggregateID: string
-  readonly data: Record<string, unknown>
-}
-
-export class InvalidSyncEventError extends Schema.TaggedErrorClass<InvalidSyncEventError>()(
-  "EventV2.InvalidSyncEvent",
-  {
-    type: Schema.String,
-    message: Schema.String,
-  },
-) {}
-
-export function versionedType(type: string, version: number) {
-  return `${type}.${version}`
-}

 export const registry = new Map<string, Definition>()
-const syncRegistry = new Map<string, Definition & { readonly sync: NonNullable<Definition["sync"]> }>()

 export function define<const Type extends string, Fields extends Schema.Struct.Fields>(input: {
  readonly type: Type
-  readonly sync?: {
-    readonly version: number
-    readonly aggregate: string
-  }
+  readonly version?: number
+  readonly aggregate?: string
  readonly schema: Fields
 }): Schema.Schema<Payload<Definition<Type, Schema.Struct<Fields>>>> & Definition<Type, Schema.Struct<Fields>> {
  const Data = Schema.Struct(input.schema)
@@ -83,18 +51,11 @@ export function define<const Type extends string, Fields extends Schema.Struct.F

  const definition = Object.assign(Payload, {
    type: input.type,
-    ...(input.sync === undefined ? {} : { sync: input.sync }),
+    ...(input.version === undefined ? {} : { version: input.version }),
+    ...(input.aggregate === undefined ? {} : { aggregate: input.aggregate }),
    data: Data,
  })
-  const existing = registry.get(input.type)
-  if (input.sync === undefined || existing?.sync === undefined || input.sync.version >= existing.sync.version) {
-    registry.set(input.type, definition)
-  }
-  if (input.sync)
-    syncRegistry.set(
-      versionedType(input.type, input.sync.version),
-      definition as Definition & { readonly sync: NonNullable<Definition["sync"]> },
-    )
+  registry.set(input.type, definition)
  return definition as Schema.Schema<Payload<Definition<Type, Schema.Struct<Fields>>>> &
    Definition<Type, Schema.Struct<Fields>>
 }
@@ -106,30 +67,20 @@ export function definitions() {
 export interface PublishOptions {
  readonly id?: ID
  readonly metadata?: Record<string, unknown>
-  readonly location?: Location.Ref
 }

+export type Unsubscribe = Effect.Effect<void>
+
 export interface Interface {
  readonly publish: <D extends Definition>(
    definition: D,
    data: Data<D>,
    options?: PublishOptions,
  ) => Effect.Effect<Payload<D>>
+  readonly publishEvent: <D extends Definition>(event: Payload<D>) => Effect.Effect<Payload<D>>
  readonly subscribe: <D extends Definition>(definition: D) => Stream.Stream<Payload<D>>
  readonly all: () => Stream.Stream<Payload>
  readonly sync: (handler: Sync) => Effect.Effect<Unsubscribe>
-  readonly listen: (listener: Listener) => Effect.Effect<Unsubscribe>
-  readonly project: <D extends Definition>(definition: D, projector: Projector<D>) => Effect.Effect<void>
-  readonly replay: (
-    event: SerializedEvent,
-    options?: { readonly publish?: boolean; readonly ownerID?: string },
-  ) => Effect.Effect<void>
-  readonly replayAll: (
-    events: SerializedEvent[],
-    options?: { readonly publish?: boolean; readonly ownerID?: string },
-  ) => Effect.Effect<string | undefined>
-  readonly remove: (aggregateID: string) => Effect.Effect<void>
-  readonly claim: (aggregateID: string, ownerID: string) => Effect.Effect<void>
 }

 export class Service extends Context.Service<Service, Interface>()("@opencode/Event") {}
@@ -139,10 +90,7 @@ export const layer = Layer.effect(
  Effect.gen(function* () {
    const all = yield* PubSub.unbounded<Payload>()
    const typed = new Map<string, PubSub.PubSub<Payload>>()
-    const projectors = new Map<string, AnyProjector[]>()
-    const listeners = new Array<Listener>()
    const syncHandlers = new Array<Sync>()
-    const { db } = yield* Database.Service

    const getOrCreate = (definition: Definition) =>
      Effect.gen(function* () {
@@ -160,97 +108,11 @@ export const layer = Layer.effect(
      }),
    )

-    function commitSyncEvent(
-      event: Payload,
-      input?: { readonly seq: number; readonly aggregateID: string; readonly ownerID?: string },
-    ) {
-      return Effect.gen(function* () {
-        const definition = registry.get(event.type)
-        const sync = definition?.sync
-        if (sync) {
-          if (event.version !== sync.version) {
-            yield* Effect.die(
-              new InvalidSyncEventError({
-                type: event.type,
-                message: `Expected event version ${sync.version}, got ${event.version}`,
-              }),
-            )
-          }
-          const aggregateID = (event.data as Record<string, unknown>)[sync.aggregate]
-          if (typeof aggregateID !== "string") {
-            yield* Effect.die(
-              new InvalidSyncEventError({
-                type: event.type,
-                message: `Expected string aggregate field ${sync.aggregate}`,
-              }),
-            )
-          } else {
-            const list = projectors.get(event.type) ?? []
-            yield* db
-              .transaction(
-                () =>
-                  Effect.gen(function* () {
-                    const row = yield* db
-                      .select({ seq: EventSequenceTable.seq, ownerID: EventSequenceTable.owner_id })
-                      .from(EventSequenceTable)
-                      .where(eq(EventSequenceTable.aggregate_id, aggregateID))
-                      .get()
-                      .pipe(Effect.orDie)
-                    const latest = row?.seq ?? -1
-                    if (input && input.seq <= latest) return
-                    if (input && row?.ownerID && row.ownerID !== input.ownerID) return
-                    const seq = input?.seq ?? latest + 1
-                    if (input && seq !== latest + 1) {
-                      yield* Effect.die(
-                        new InvalidSyncEventError({
-                          type: event.type,
-                          message: `Sequence mismatch for aggregate ${aggregateID}: expected ${latest + 1}, got ${seq}`,
-                        }),
-                      )
-                    }
-                    for (const projector of list) {
-                      yield* projector(event as Payload)
-                    }
-                    yield* db
-                      .insert(EventSequenceTable)
-                      .values([{ aggregate_id: aggregateID, seq, owner_id: input?.ownerID }])
-                      .onConflictDoUpdate({
-                        target: EventSequenceTable.aggregate_id,
-                        set: { seq },
-                      })
-                      .run()
-                      .pipe(Effect.orDie)
-                    yield* db
-                      .insert(EventTable)
-                      .values([
-                        {
-                          id: event.id,
-                          aggregate_id: aggregateID,
-                          seq,
-                          type: versionedType(definition.type, sync.version),
-                          data: event.data as Record<string, unknown>,
-                        },
-                      ])
-                      .run()
-                      .pipe(Effect.orDie)
-                  }),
-                { behavior: "immediate" },
-              )
-              .pipe(Effect.orDie)
-          }
-        }
-      })
-    }
-
    function publishEvent<D extends Definition>(event: Payload<D>) {
      return Effect.gen(function* () {
        for (const sync of syncHandlers) {
          yield* sync(event as Payload)
        }
-        yield* commitSyncEvent(event as Payload)
-        for (const listener of listeners) {
-          yield* listener(event as Payload)
-        }
        const pubsub = typed.get(event.type)
        if (pubsub) yield* PubSub.publish(pubsub, event as Payload)
        yield* PubSub.publish(all, event as Payload)
@@ -260,117 +122,25 @@ export const layer = Layer.effect(

    function publish<D extends Definition>(definition: D, data: Data<D>, options?: PublishOptions) {
      return Effect.gen(function* () {
-        const serviceLocation = Option.getOrUndefined(yield* Effect.serviceOption(Location.Service))
-        const location =
-          options?.location ??
-          (serviceLocation
-            ? { directory: serviceLocation.directory, workspaceID: serviceLocation.workspaceID }
-            : undefined)
-        return yield* publishEvent({
+        const location = Option.getOrUndefined(yield* Effect.serviceOption(Location.Service))
+        const event = {
          id: options?.id ?? ID.create(),
          ...(options?.metadata ? { metadata: options.metadata } : {}),
          type: definition.type,
-          ...(definition.sync === undefined ? {} : { version: definition.sync.version }),
-          ...(location ? { location } : {}),
+          ...(definition.version === undefined ? {} : { version: definition.version }),
+          ...(location ? { location: { directory: location.directory, workspaceID: location.workspaceID } } : {}),
          data,
-        } as Payload<D>)
+        } as Payload<D>
+        return yield* publishEvent(event)
      })
    }

-    function replay(event: SerializedEvent, options?: { readonly publish?: boolean; readonly ownerID?: string }) {
-      return Effect.gen(function* () {
-        const definition = syncRegistry.get(event.type)
-        if (!definition) {
-          yield* Effect.die(
-            new InvalidSyncEventError({ type: event.type, message: `Unknown sync event type ${event.type}` }),
-          )
-        } else {
-          const payload = {
-            id: event.id,
-            type: definition.type,
-            version: definition.sync.version,
-            data: event.data,
-          } as Payload
-          yield* commitSyncEvent(payload, { seq: event.seq, aggregateID: event.aggregateID, ownerID: options?.ownerID })
-          if (options?.publish) {
-            for (const listener of listeners) {
-              yield* listener(payload)
-            }
-            const pubsub = typed.get(payload.type)
-            if (pubsub) yield* PubSub.publish(pubsub, payload)
-            yield* PubSub.publish(all, payload)
-          }
-        }
-      })
-    }
-
-    function replayAll(events: SerializedEvent[], options?: { readonly publish?: boolean; readonly ownerID?: string }) {
-      return Effect.gen(function* () {
-        const source = events[0]?.aggregateID
-        if (!source) return undefined
-        if (events.some((event) => event.aggregateID !== source)) {
-          yield* Effect.die(
-            new InvalidSyncEventError({
-              type: events[0]?.type ?? "unknown",
-              message: "Replay events must belong to the same aggregate",
-            }),
-          )
-        }
-        const start = events[0]?.seq ?? 0
-        for (const [index, event] of events.entries()) {
-          const seq = start + index
-          if (event.seq !== seq) {
-            yield* Effect.die(
-              new InvalidSyncEventError({
-                type: event.type,
-                message: `Replay sequence mismatch at index ${index}: expected ${seq}, got ${event.seq}`,
-              }),
-            )
-          }
-        }
-        for (const event of events) {
-          yield* replay(event, options)
-        }
-        return source
-      })
-    }
-
-    function remove(aggregateID: string) {
-      return db
-        .transaction(() =>
-          Effect.gen(function* () {
-            yield* db.delete(EventSequenceTable).where(eq(EventSequenceTable.aggregate_id, aggregateID)).run()
-            yield* db.delete(EventTable).where(eq(EventTable.aggregate_id, aggregateID)).run()
-          }),
-        )
-        .pipe(Effect.orDie)
-    }
-
-    function claim(aggregateID: string, ownerID: string) {
-      return db
-        .update(EventSequenceTable)
-        .set({ owner_id: ownerID })
-        .where(eq(EventSequenceTable.aggregate_id, aggregateID))
-        .run()
-        .pipe(Effect.orDie)
-    }
-
    const subscribe = <D extends Definition>(definition: D): Stream.Stream<Payload<D>> =>
      Stream.unwrap(getOrCreate(definition).pipe(Effect.map((pubsub) => Stream.fromPubSub(pubsub)))).pipe(
        Stream.map((event) => event as Payload<D>),
      )

    const streamAll = (): Stream.Stream<Payload> => Stream.fromPubSub(all)
-
-    const listen = (listener: Listener): Effect.Effect<Unsubscribe> =>
-      Effect.sync(() => {
-        listeners.push(listener)
-        return Effect.sync(() => {
-          const index = listeners.indexOf(listener)
-          if (index >= 0) listeners.splice(index, 1)
-        })
-      })
-
    const sync = (handler: Sync): Effect.Effect<Unsubscribe> =>
      Effect.sync(() => {
        syncHandlers.push(handler)
@@ -380,15 +150,8 @@ export const layer = Layer.effect(
        })
      })

-    const project = <D extends Definition>(definition: D, projector: Projector<D>): Effect.Effect<void> =>
-      Effect.sync(() => {
-        const list = projectors.get(definition.type) ?? []
-        list.push((event) => projector(event as Payload<D>))
-        projectors.set(definition.type, list)
-      })
-
-    return Service.of({ publish, subscribe, all: streamAll, sync, listen, project, replay, replayAll, remove, claim })
+    return Service.of({ publish, publishEvent, subscribe, all: streamAll, sync })
  }),
 )

-export const defaultLayer = layer.pipe(Layer.provide(Database.defaultLayer))
+export const defaultLayer = layer
@@ -1,80 +0,0 @@
-import { randomBytes } from "crypto"
-
-const prefixes = {
-  job: "job",
-  event: "evt",
-  session: "ses",
-  message: "msg",
-  permission: "per",
-  question: "que",
-  part: "prt",
-  pty: "pty",
-  tool: "tool",
-  workspace: "wrk",
-} as const
-
-const LENGTH = 26
-
-// State for monotonic ID generation
-let lastTimestamp = 0
-let counter = 0
-
-export function ascending(prefix: keyof typeof prefixes, given?: string) {
-  return generateID(prefix, "ascending", given)
-}
-
-export function descending(prefix: keyof typeof prefixes, given?: string) {
-  return generateID(prefix, "descending", given)
-}
-
-function generateID(prefix: keyof typeof prefixes, direction: "descending" | "ascending", given?: string): string {
-  if (!given) {
-    return create(prefixes[prefix], direction)
-  }
-
-  if (!given.startsWith(prefixes[prefix])) {
-    throw new Error(`ID ${given} does not start with ${prefixes[prefix]}`)
-  }
-  return given
-}
-
-function randomBase62(length: number): string {
-  const chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
-  let result = ""
-  const bytes = randomBytes(length)
-  for (let i = 0; i < length; i++) {
-    result += chars[bytes[i] % 62]
-  }
-  return result
-}
-
-export function create(prefix: string, direction: "descending" | "ascending", timestamp?: number): string {
-  const currentTimestamp = timestamp ?? Date.now()
-
-  if (currentTimestamp !== lastTimestamp) {
-    lastTimestamp = currentTimestamp
-    counter = 0
-  }
-  counter++
-
-  let now = BigInt(currentTimestamp) * BigInt(0x1000) + BigInt(counter)
-
-  now = direction === "descending" ? ~now : now
-
-  const timeBytes = Buffer.alloc(6)
-  for (let i = 0; i < 6; i++) {
-    timeBytes[i] = Number((now >> BigInt(40 - 8 * i)) & BigInt(0xff))
-  }
-
-  return prefix + "_" + timeBytes.toString("hex") + randomBase62(LENGTH - 12)
-}
-
-/** Extract timestamp from an ascending ID. Does not work with descending IDs. */
-export function timestamp(id: string): number {
-  const prefix = id.split("_")[0]
-  const hex = id.slice(prefix.length + 1, prefix.length + 13)
-  const encoded = BigInt("0x" + hex)
-  return Number(encoded / BigInt(0x1000))
-}
-
-export * as Identifier from "./id"
@@ -1,40 +1,18 @@
 import { Layer, LayerMap } from "effect"
 import { Location } from "./location"
+import { Catalog } from "./catalog"
+import { PluginBoot } from "./plugin/boot"
 import { Policy } from "./policy"
 import { Config } from "./config"
-import { PluginV2 } from "./plugin"
-import { Catalog } from "./catalog"
-import { AgentV2 } from "./agent"
-import { PluginBoot } from "./plugin/boot"
-import { Project } from "./project"
-import { EventV2 } from "./event"
-import { Auth } from "./auth"
-import { Npm } from "./npm"
-import { ModelsDev } from "./models-dev"
-import { AppFileSystem } from "./filesystem"
-import { Global } from "./global"

 export class LocationServiceMap extends LayerMap.Service<LocationServiceMap>()("@opencode/example/LocationServiceMap", {
  lookup: (ref: Location.Ref) => {
-    const location = Location.layer(ref)
-    return Layer.mergeAll(
-      location,
-      Policy.locationLayer,
-      Config.locationLayer,
-      PluginV2.locationLayer,
-      Catalog.locationLayer,
-      AgentV2.locationLayer,
-      PluginBoot.locationLayer,
-    ).pipe(Layer.provideMerge(location), Layer.fresh)
+    const result = Layer.mergeAll(Catalog.defaultLayer, PluginBoot.defaultLayer, Config.defaultLayer).pipe(
+      Layer.provideMerge(Policy.defaultLayer),
+      Layer.provideMerge(Location.defaultLayer(ref)),
+    )
+    return result
  },
  idleTimeToLive: "60 minutes",
-  dependencies: [
-    Project.defaultLayer,
-    EventV2.defaultLayer,
-    Auth.defaultLayer,
-    Npm.defaultLayer,
-    ModelsDev.defaultLayer,
-    AppFileSystem.defaultLayer,
-    Global.defaultLayer,
-  ],
+  dependencies: [],
 }) {}
@@ -36,3 +36,5 @@ export const layer = (ref: Ref) =>
      })
    }),
  )
+
+export const defaultLayer = (ref: Ref) => layer(ref).pipe(Layer.provide(Project.defaultLayer))
@@ -68,8 +68,8 @@ export class Info extends Schema.Class<Info>("ModelV2.Info")({
    output: Schema.Int,
  }),
 }) {
-  static empty(providerID: ProviderV2.ID, modelID: ID): Info {
-    return {
+  static empty(providerID: ProviderV2.ID, modelID: ID) {
+    return new Info({
      id: modelID,
      apiID: modelID,
      providerID,
@@ -101,7 +101,7 @@ export class Info extends Schema.Class<Info>("ModelV2.Info")({
        context: 0,
        output: 0,
      },
-    }
+    })
  }
 }

@@ -2,29 +2,18 @@ export * as PermissionV2 from "./permission"

 import { Schema } from "effect"
 import { Wildcard } from "./util/wildcard"
-import { Identifier } from "./id/id"
-import { Newtype } from "./schema"

-export class PermissionID extends Newtype<PermissionID>()(
-  "PermissionID",
-  Schema.String.check(Schema.isStartsWith("per")),
-) {
-  static ascending(id?: string): PermissionID {
-    return this.make(Identifier.ascending("permission", id))
-  }
-}
-
-export const Action = Schema.Literals(["allow", "deny", "ask"]).annotate({ identifier: "Permission.Action" })
+export const Action = Schema.Literals(["allow", "deny", "ask"]).annotate({ identifier: "PermissionV2.Action" })
 export type Action = typeof Action.Type

 export const Rule = Schema.Struct({
  permission: Schema.String,
  pattern: Schema.String,
  action: Action,
-}).annotate({ identifier: "Permission.Rule" })
+}).annotate({ identifier: "PermissionV2.Rule" })
 export type Rule = typeof Rule.Type

-export const Ruleset = Schema.Array(Rule).annotate({ identifier: "Permission.Ruleset" })
+export const Ruleset = Schema.Array(Rule).annotate({ identifier: "PermissionV2.Ruleset" })
 export type Ruleset = typeof Ruleset.Type

 const EDIT_TOOLS = ["edit", "write", "apply_patch"]
@@ -26,9 +26,9 @@ type HookSpec = {
  }
  "account.switched": {
    input: {
-      serviceID: import("./auth").Auth.ServiceID
-      from?: import("./auth").Auth.ID
-      to?: import("./auth").Auth.ID
+      serviceID: import("./account").AccountV2.ServiceID
+      from?: import("./account").AccountV2.ID
+      to?: import("./account").AccountV2.ID
    }
    output: {}
  }
@@ -111,14 +111,7 @@ export const layer = Layer.effect(
        const existing = hooks.find((item) => item.id === input.id)
        if (existing) yield* Scope.close(existing.scope, Exit.void).pipe(Effect.ignore)
        const scope = yield* Scope.make()
-        const result = yield* input.effect.pipe(
-          Scope.provide(scope),
-          Effect.withSpan("Plugin.load", {
-            attributes: {
-              "plugin.id": input.id,
-            },
-          }),
-        )
+        const result = yield* input.effect.pipe(Scope.provide(scope))
        hooks = [
          ...hooks.filter((item) => item.id !== input.id),
          {
@@ -176,7 +169,7 @@ export const layer = Layer.effect(
  }),
 )

-export const locationLayer = layer
+export const defaultLayer = layer.pipe(Layer.provide(EventV2.defaultLayer))

 // opencode
 // sdcok
@@ -1,18 +1,16 @@
 import { Effect, Scope, Stream } from "effect"
+import { AccountV2 } from "../account"
 import { EventV2 } from "../event"
 import { PluginV2 } from "../plugin"
-import { Auth } from "../auth"

-// Depending on what account is active, enable matching providers for that
-// service
 export const AccountPlugin = PluginV2.define({
  id: PluginV2.ID.make("account"),
  effect: Effect.gen(function* () {
-    const accounts = yield* Auth.Service
+    const accounts = yield* AccountV2.Service
    const events = yield* EventV2.Service
    const scope = yield* Scope.Scope

-    yield* events.subscribe(Auth.Event.Switched).pipe(
+    yield* events.subscribe(AccountV2.Event.Switched).pipe(
      Stream.runForEach((event) =>
        PluginV2.Service.use((plugin) => plugin.trigger("account.switched", event.data, {})).pipe(Effect.asVoid),
      ),
@@ -21,10 +19,8 @@ export const AccountPlugin = PluginV2.define({

    return {
      "catalog.transform": Effect.fn(function* (evt) {
-        const active = yield* accounts.activeAll().pipe(Effect.orDie)
-        if (active.size === 0) return
        for (const item of evt.provider.list()) {
-          const account = active.get(Auth.ServiceID.make(item.provider.id))
+          const account = yield* accounts.active(AccountV2.ServiceID.make(item.provider.id)).pipe(Effect.orDie)
          if (!account) continue
          evt.provider.update(item.provider.id, (provider) => {
            provider.enabled = {
@@ -1,14 +1,13 @@
 export * as PluginBoot from "./boot"

 import { Context, Deferred, Effect, Layer } from "effect"
-import { Auth } from "../auth"
+import { AccountV2 } from "../account"
 import { AgentV2 } from "../agent"
 import { Catalog } from "../catalog"
 import { Config } from "../config"
 import { ConfigAgentPlugin } from "../config/plugin/agent"
 import { EventV2 } from "../event"
 import { Location } from "../location"
-import { ModelsDev } from "../models-dev"
 import { Npm } from "../npm"
 import { PluginV2 } from "../plugin"
 import { AccountPlugin } from "./account"
@@ -22,14 +21,13 @@ type Plugin = {
  id: PluginV2.ID
  effect: PluginV2.Effect<
    | Catalog.Service
-    | Auth.Service
+    | AccountV2.Service
    | AgentV2.Service
    | Npm.Service
    | EventV2.Service
    | Location.Service
    | PluginV2.Service
    | Config.Service
-    | ModelsDev.Service
  >
 }

@@ -44,11 +42,10 @@ export const layer = Layer.effect(
  Effect.gen(function* () {
    const catalog = yield* Catalog.Service
    const plugin = yield* PluginV2.Service
-    const accounts = yield* Auth.Service
+    const accounts = yield* AccountV2.Service
    const agents = yield* AgentV2.Service
    const config = yield* Config.Service
    const location = yield* Location.Service
-    const modelsDev = yield* ModelsDev.Service
    const npm = yield* Npm.Service
    const events = yield* EventV2.Service
    const done = yield* Deferred.make<void>()
@@ -58,11 +55,10 @@ export const layer = Layer.effect(
        id: input.id,
        effect: input.effect.pipe(
          Effect.provideService(Catalog.Service, catalog),
-          Effect.provideService(Auth.Service, accounts),
+          Effect.provideService(AccountV2.Service, accounts),
          Effect.provideService(AgentV2.Service, agents),
          Effect.provideService(Config.Service, config),
          Effect.provideService(Location.Service, location),
-          Effect.provideService(ModelsDev.Service, modelsDev),
          Effect.provideService(Npm.Service, npm),
          Effect.provideService(EventV2.Service, events),
          Effect.provideService(PluginV2.Service, plugin),
@@ -94,8 +90,12 @@ export const layer = Layer.effect(
  }),
 )

-export const locationLayer = layer.pipe(
-  Layer.provideMerge(Catalog.locationLayer),
-  Layer.provideMerge(Config.locationLayer),
-  Layer.provideMerge(AgentV2.locationLayer),
+export const defaultLayer = layer.pipe(
+  Layer.provide(Catalog.defaultLayer),
+  Layer.provide(EventV2.defaultLayer),
+  Layer.provide(PluginV2.defaultLayer),
+  Layer.provide(AccountV2.defaultLayer),
+  Layer.provide(AgentV2.defaultLayer),
+  Layer.provide(Config.defaultLayer),
+  Layer.provide(Npm.defaultLayer),
 )
@@ -114,7 +114,7 @@ export const ModelsDevPlugin = PluginV2.define({
    yield* refresh()
    yield* events.subscribe(ModelsDev.Event.Refreshed).pipe(
      Stream.runForEach(() => refresh()),
-      Effect.forkScoped({ startImmediately: true }),
+      Effect.forkIn(scope, { startImmediately: true }),
    )
-  }),
+  }).pipe(Effect.provide(ModelsDev.defaultLayer)),
 })
@@ -1,67 +1 @@
-import { AlibabaPlugin } from "./provider/alibaba"
-import { AmazonBedrockPlugin } from "./provider/amazon-bedrock"
-import { AnthropicPlugin } from "./provider/anthropic"
-import { AzureCognitiveServicesPlugin, AzurePlugin } from "./provider/azure"
-import { CerebrasPlugin } from "./provider/cerebras"
-import { CloudflareAIGatewayPlugin } from "./provider/cloudflare-ai-gateway"
-import { CloudflareWorkersAIPlugin } from "./provider/cloudflare-workers-ai"
-import { CoherePlugin } from "./provider/cohere"
-import { DeepInfraPlugin } from "./provider/deepinfra"
-import { DynamicProviderPlugin } from "./provider/dynamic"
-import { GatewayPlugin } from "./provider/gateway"
-import { GithubCopilotPlugin } from "./provider/github-copilot"
-import { GitLabPlugin } from "./provider/gitlab"
-import { GooglePlugin } from "./provider/google"
-import { GoogleVertexAnthropicPlugin, GoogleVertexPlugin } from "./provider/google-vertex"
-import { GroqPlugin } from "./provider/groq"
-import { KiloPlugin } from "./provider/kilo"
-import { LLMGatewayPlugin } from "./provider/llmgateway"
-import { MistralPlugin } from "./provider/mistral"
-import { NvidiaPlugin } from "./provider/nvidia"
-import { OpenAIPlugin } from "./provider/openai"
-import { OpenAICompatiblePlugin } from "./provider/openai-compatible"
-import { OpencodePlugin } from "./provider/opencode"
-import { OpenRouterPlugin } from "./provider/openrouter"
-import { PerplexityPlugin } from "./provider/perplexity"
-import { SapAICorePlugin } from "./provider/sap-ai-core"
-import { TogetherAIPlugin } from "./provider/togetherai"
-import { VercelPlugin } from "./provider/vercel"
-import { VenicePlugin } from "./provider/venice"
-import { XAIPlugin } from "./provider/xai"
-import { ZenmuxPlugin } from "./provider/zenmux"
-
-export const ProviderPlugins = [
-  AlibabaPlugin,
-  AmazonBedrockPlugin,
-  AnthropicPlugin,
-  AzureCognitiveServicesPlugin,
-  AzurePlugin,
-  CerebrasPlugin,
-  CloudflareAIGatewayPlugin,
-  CloudflareWorkersAIPlugin,
-  CoherePlugin,
-  DeepInfraPlugin,
-  GatewayPlugin,
-  GithubCopilotPlugin,
-  GitLabPlugin,
-  GooglePlugin,
-  GoogleVertexAnthropicPlugin,
-  GoogleVertexPlugin,
-  GroqPlugin,
-  KiloPlugin,
-  LLMGatewayPlugin,
-  MistralPlugin,
-  NvidiaPlugin,
-  OpencodePlugin,
-  OpenAICompatiblePlugin,
-  OpenAIPlugin,
-  OpenRouterPlugin,
-  PerplexityPlugin,
-  SapAICorePlugin,
-  TogetherAIPlugin,
-  VercelPlugin,
-  VenicePlugin,
-  XAIPlugin,
-  ZenmuxPlugin,
-  DynamicProviderPlugin,
-]
+export { ProviderPlugins } from "./provider/index"
@@ -0,0 +1,67 @@
+import { AlibabaPlugin } from "./alibaba"
+import { AmazonBedrockPlugin } from "./amazon-bedrock"
+import { AnthropicPlugin } from "./anthropic"
+import { AzureCognitiveServicesPlugin, AzurePlugin } from "./azure"
+import { CerebrasPlugin } from "./cerebras"
+import { CloudflareAIGatewayPlugin } from "./cloudflare-ai-gateway"
+import { CloudflareWorkersAIPlugin } from "./cloudflare-workers-ai"
+import { CoherePlugin } from "./cohere"
+import { DeepInfraPlugin } from "./deepinfra"
+import { DynamicProviderPlugin } from "./dynamic"
+import { GatewayPlugin } from "./gateway"
+import { GithubCopilotPlugin } from "./github-copilot"
+import { GitLabPlugin } from "./gitlab"
+import { GooglePlugin } from "./google"
+import { GoogleVertexAnthropicPlugin, GoogleVertexPlugin } from "./google-vertex"
+import { GroqPlugin } from "./groq"
+import { KiloPlugin } from "./kilo"
+import { LLMGatewayPlugin } from "./llmgateway"
+import { MistralPlugin } from "./mistral"
+import { NvidiaPlugin } from "./nvidia"
+import { OpenAIPlugin } from "./openai"
+import { OpenAICompatiblePlugin } from "./openai-compatible"
+import { OpencodePlugin } from "./opencode"
+import { OpenRouterPlugin } from "./openrouter"
+import { PerplexityPlugin } from "./perplexity"
+import { SapAICorePlugin } from "./sap-ai-core"
+import { TogetherAIPlugin } from "./togetherai"
+import { VercelPlugin } from "./vercel"
+import { VenicePlugin } from "./venice"
+import { XAIPlugin } from "./xai"
+import { ZenmuxPlugin } from "./zenmux"
+
+export const ProviderPlugins = [
+  AlibabaPlugin,
+  AmazonBedrockPlugin,
+  AnthropicPlugin,
+  AzureCognitiveServicesPlugin,
+  AzurePlugin,
+  CerebrasPlugin,
+  CloudflareAIGatewayPlugin,
+  CloudflareWorkersAIPlugin,
+  CoherePlugin,
+  DeepInfraPlugin,
+  GatewayPlugin,
+  GithubCopilotPlugin,
+  GitLabPlugin,
+  GooglePlugin,
+  GoogleVertexAnthropicPlugin,
+  GoogleVertexPlugin,
+  GroqPlugin,
+  KiloPlugin,
+  LLMGatewayPlugin,
+  MistralPlugin,
+  NvidiaPlugin,
+  OpencodePlugin,
+  OpenAICompatiblePlugin,
+  OpenAIPlugin,
+  OpenRouterPlugin,
+  PerplexityPlugin,
+  SapAICorePlugin,
+  TogetherAIPlugin,
+  VercelPlugin,
+  VenicePlugin,
+  XAIPlugin,
+  ZenmuxPlugin,
+  DynamicProviderPlugin,
+]
@@ -16,7 +16,6 @@ export class Info extends Schema.Class<Info>("Policy.Info")({
 export interface Interface {
  readonly load: (statements: Info[]) => EffectRuntime.Effect<void>
  readonly evaluate: (action: string, resource: string, fallback: Effect) => EffectRuntime.Effect<Effect>
-  readonly hasStatements: () => boolean
 }

 export class Service extends Context.Service<Service, Interface>()("@opencode/v2/Policy") {}
@@ -31,7 +30,6 @@ export const layer = Layer.effect(
      load: EffectRuntime.fn("Policy.load")(function* (input) {
        statements = input
      }),
-      hasStatements: () => statements.length > 0,
      evaluate: EffectRuntime.fn("Policy.evaluate")(function* (action, resource, fallback) {
        return (
          statements.findLast(
@@ -43,4 +41,4 @@ export const layer = Layer.effect(
  }),
 )

-export const locationLayer = layer
+export const defaultLayer = layer
@@ -1,4 +1,3 @@
-export * as ProjectV2 from "./project"
 export * as Project from "./project"

 import { Context, Effect, Layer, Schema } from "effect"
@@ -22,9 +22,6 @@ export const ID = Schema.String.pipe(
 )
 export type ID = typeof ID.Type

-export const ModelID = Schema.String.pipe(Schema.brand("ModelID"))
-export type ModelID = typeof ModelID.Type
-
 const OpenAIResponses = Schema.Struct({
  type: Schema.Literal("openai/responses"),
  url: Schema.String,
@@ -101,8 +98,8 @@ export class Info extends Schema.Class<Info>("ProviderV2.Info")({
  endpoint: Endpoint,
  options: Options,
 }) {
-  static empty(providerID: ID): Info {
-    return {
+  static empty(providerID: ID) {
+    return new Info({
      id: providerID,
      name: providerID,
      enabled: false,
@@ -118,6 +115,6 @@ export class Info extends Schema.Class<Info>("ProviderV2.Info")({
          request: {},
        },
      },
-    }
+    })
  }
 }
@@ -1,5 +1,11 @@
 import { Option, Schema, SchemaGetter } from "effect"

+export const AbsolutePath = Schema.String.pipe(Schema.brand("AbsolutePath"))
+export type AbsolutePath = typeof AbsolutePath.Type
+
+export const RelativePath = Schema.String.pipe(Schema.brand("RelativePath"))
+export type RelativePath = typeof RelativePath.Type
+
 /**
 * Integer greater than zero.
 */
@@ -10,18 +16,6 @@ export const PositiveInt = Schema.Int.check(Schema.isGreaterThan(0))
 */
 export const NonNegativeInt = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0))

-/**
- * Relative file path (e.g., `src/components/Button.tsx`).
- */
-export const RelativePath = Schema.String.pipe(Schema.brand("RelativePath"))
-export type RelativePath = Schema.Schema.Type<typeof RelativePath>
-
-/**
- * Absolute file path (e.g., `/home/user/projects/myapp/src/main.ts`).
- */
-export const AbsolutePath = Schema.String.pipe(Schema.brand("AbsolutePath"))
-export type AbsolutePath = Schema.Schema.Type<typeof AbsolutePath>
-
 /**
 * Optional public JSON field that can hold explicit `undefined` on the type
 * side but encodes it as an omitted key, matching legacy `JSON.stringify`.
@@ -1,11 +1,11 @@
 import { Schema } from "effect"
-import { EventV2 } from "../event"
-import { ModelV2 } from "../model"
-import { NonNegativeInt } from "../schema"
-import { ToolOutput } from "../tool-output"
-import { V2Schema } from "../v2-schema"
-import { FileAttachment, Prompt } from "./prompt"
-import { SessionSchema } from "./schema"
+import { EventV2 } from "./event"
+import { ModelV2 } from "./model"
+import { NonNegativeInt } from "./schema"
+import { Session } from "./session"
+import { FileAttachment, Prompt } from "./session-prompt"
+import { ToolOutput } from "./tool-output"
+import { V2Schema } from "./v2-schema"

 export { FileAttachment }

@@ -20,14 +20,12 @@ export type Source = typeof Source.Type

 const Base = {
  timestamp: V2Schema.DateTimeUtcFromMillis,
-  sessionID: SessionSchema.ID,
+  sessionID: Session.ID,
 }

 const options = {
-  sync: {
-    aggregate: "sessionID",
-    version: 1,
-  },
+  aggregate: "sessionID",
+  version: 1,
 } as const

 export const UnknownError = Schema.Struct({
@@ -397,7 +395,8 @@ export const All = Schema.Union(
    mode: "oneOf",
  },
 ).pipe(Schema.toTaggedUnion("type"))
+
 export type Event = typeof All.Type
 export type Type = Event["type"]

-export * as SessionEvent from "./event"
+export * as SessionEvent from "./session-event"
@@ -0,0 +1,417 @@
+import { produce, type WritableDraft } from "immer"
+import { SessionEvent } from "./session-event"
+import { SessionMessage } from "./session-message"
+
+export type MemoryState = {
+  messages: SessionMessage.Message[]
+}
+
+export interface Adapter<Result> {
+  readonly getCurrentAssistant: () => SessionMessage.Assistant | undefined
+  readonly getCurrentCompaction: () => SessionMessage.Compaction | undefined
+  readonly getCurrentShell: (callID: string) => SessionMessage.Shell | undefined
+  readonly updateAssistant: (assistant: SessionMessage.Assistant) => void
+  readonly updateCompaction: (compaction: SessionMessage.Compaction) => void
+  readonly updateShell: (shell: SessionMessage.Shell) => void
+  readonly appendMessage: (message: SessionMessage.Message) => void
+  readonly finish: () => Result
+}
+
+export function memory(state: MemoryState): Adapter<MemoryState> {
+  const activeAssistantIndex = () =>
+    state.messages.findLastIndex((message) => message.type === "assistant" && !message.time.completed)
+  const activeCompactionIndex = () => state.messages.findLastIndex((message) => message.type === "compaction")
+  const activeShellIndex = (callID: string) =>
+    state.messages.findLastIndex((message) => message.type === "shell" && message.callID === callID)
+
+  return {
+    getCurrentAssistant() {
+      const index = activeAssistantIndex()
+      if (index < 0) return
+      const assistant = state.messages[index]
+      return assistant?.type === "assistant" ? assistant : undefined
+    },
+    getCurrentCompaction() {
+      const index = activeCompactionIndex()
+      if (index < 0) return
+      const compaction = state.messages[index]
+      return compaction?.type === "compaction" ? compaction : undefined
+    },
+    getCurrentShell(callID) {
+      const index = activeShellIndex(callID)
+      if (index < 0) return
+      const shell = state.messages[index]
+      return shell?.type === "shell" ? shell : undefined
+    },
+    updateAssistant(assistant) {
+      const index = activeAssistantIndex()
+      if (index < 0) return
+      const current = state.messages[index]
+      if (current?.type !== "assistant") return
+      state.messages[index] = assistant
+    },
+    updateCompaction(compaction) {
+      const index = activeCompactionIndex()
+      if (index < 0) return
+      const current = state.messages[index]
+      if (current?.type !== "compaction") return
+      state.messages[index] = compaction
+    },
+    updateShell(shell) {
+      const index = activeShellIndex(shell.callID)
+      if (index < 0) return
+      const current = state.messages[index]
+      if (current?.type !== "shell") return
+      state.messages[index] = shell
+    },
+    appendMessage(message) {
+      state.messages.push(message)
+    },
+    finish() {
+      return state
+    },
+  }
+}
+
+export function update<Result>(adapter: Adapter<Result>, event: SessionEvent.Event): Result {
+  const currentAssistant = adapter.getCurrentAssistant()
+  type DraftAssistant = WritableDraft<SessionMessage.Assistant>
+  type DraftTool = WritableDraft<SessionMessage.AssistantTool>
+  type DraftText = WritableDraft<SessionMessage.AssistantText>
+  type DraftReasoning = WritableDraft<SessionMessage.AssistantReasoning>
+
+  const latestTool = (assistant: DraftAssistant | undefined, callID?: string) =>
+    assistant?.content.findLast(
+      (item): item is DraftTool => item.type === "tool" && (callID === undefined || item.id === callID),
+    )
+
+  const latestText = (assistant: DraftAssistant | undefined) =>
+    assistant?.content.findLast((item): item is DraftText => item.type === "text")
+
+  const latestReasoning = (assistant: DraftAssistant | undefined, reasoningID: string) =>
+    assistant?.content.findLast((item): item is DraftReasoning => item.type === "reasoning" && item.id === reasoningID)
+
+  SessionEvent.All.match(event, {
+    "session.next.agent.switched": (event) => {
+      adapter.appendMessage(
+        new SessionMessage.AgentSwitched({
+          id: event.id,
+          type: "agent-switched",
+          metadata: event.metadata,
+          agent: event.data.agent,
+          time: { created: event.data.timestamp },
+        }),
+      )
+    },
+    "session.next.model.switched": (event) => {
+      adapter.appendMessage(
+        new SessionMessage.ModelSwitched({
+          id: event.id,
+          type: "model-switched",
+          metadata: event.metadata,
+          model: event.data.model,
+          time: { created: event.data.timestamp },
+        }),
+      )
+    },
+    "session.next.prompted": (event) => {
+      adapter.appendMessage(
+        new SessionMessage.User({
+          id: event.id,
+          type: "user",
+          metadata: event.metadata,
+          text: event.data.prompt.text,
+          files: event.data.prompt.files,
+          agents: event.data.prompt.agents,
+          references: event.data.prompt.references,
+          time: { created: event.data.timestamp },
+        }),
+      )
+    },
+    "session.next.synthetic": (event) => {
+      adapter.appendMessage(
+        new SessionMessage.Synthetic({
+          sessionID: event.data.sessionID,
+          text: event.data.text,
+          id: event.id,
+          type: "synthetic",
+          time: { created: event.data.timestamp },
+        }),
+      )
+    },
+    "session.next.shell.started": (event) => {
+      adapter.appendMessage(
+        new SessionMessage.Shell({
+          id: event.id,
+          type: "shell",
+          metadata: event.metadata,
+          callID: event.data.callID,
+          command: event.data.command,
+          output: "",
+          time: { created: event.data.timestamp },
+        }),
+      )
+    },
+    "session.next.shell.ended": (event) => {
+      const currentShell = adapter.getCurrentShell(event.data.callID)
+      if (currentShell) {
+        adapter.updateShell(
+          produce(currentShell, (draft) => {
+            draft.output = event.data.output
+            draft.time.completed = event.data.timestamp
+          }),
+        )
+      }
+    },
+    "session.next.step.started": (event) => {
+      if (currentAssistant) {
+        adapter.updateAssistant(
+          produce(currentAssistant, (draft) => {
+            draft.time.completed = event.data.timestamp
+          }),
+        )
+      }
+      adapter.appendMessage(
+        new SessionMessage.Assistant({
+          id: event.id,
+          type: "assistant",
+          agent: event.data.agent,
+          model: event.data.model,
+          time: { created: event.data.timestamp },
+          content: [],
+          snapshot: event.data.snapshot ? { start: event.data.snapshot } : undefined,
+        }),
+      )
+    },
+    "session.next.step.ended": (event) => {
+      if (currentAssistant) {
+        adapter.updateAssistant(
+          produce(currentAssistant, (draft) => {
+            draft.time.completed = event.data.timestamp
+            draft.finish = event.data.finish
+            draft.cost = event.data.cost
+            draft.tokens = event.data.tokens
+            if (event.data.snapshot) draft.snapshot = { ...draft.snapshot, end: event.data.snapshot }
+          }),
+        )
+      }
+    },
+    "session.next.step.failed": (event) => {
+      if (currentAssistant) {
+        adapter.updateAssistant(
+          produce(currentAssistant, (draft) => {
+            draft.time.completed = event.data.timestamp
+            draft.finish = "error"
+            draft.error = event.data.error
+          }),
+        )
+      }
+    },
+    "session.next.text.started": () => {
+      if (currentAssistant) {
+        adapter.updateAssistant(
+          produce(currentAssistant, (draft) => {
+            draft.content.push({
+              type: "text",
+              text: "",
+            })
+          }),
+        )
+      }
+    },
+    "session.next.text.delta": (event) => {
+      if (currentAssistant) {
+        adapter.updateAssistant(
+          produce(currentAssistant, (draft) => {
+            const match = latestText(draft)
+            if (match) match.text += event.data.delta
+          }),
+        )
+      }
+    },
+    "session.next.text.ended": (event) => {
+      if (currentAssistant) {
+        adapter.updateAssistant(
+          produce(currentAssistant, (draft) => {
+            const match = latestText(draft)
+            if (match) match.text = event.data.text
+          }),
+        )
+      }
+    },
+    "session.next.tool.input.started": (event) => {
+      if (currentAssistant) {
+        adapter.updateAssistant(
+          produce(currentAssistant, (draft) => {
+            draft.content.push({
+              type: "tool",
+              id: event.data.callID,
+              name: event.data.name,
+              time: {
+                created: event.data.timestamp,
+              },
+              state: {
+                status: "pending",
+                input: "",
+              },
+            })
+          }),
+        )
+      }
+    },
+    "session.next.tool.input.delta": (event) => {
+      if (currentAssistant) {
+        adapter.updateAssistant(
+          produce(currentAssistant, (draft) => {
+            const match = latestTool(draft, event.data.callID)
+            // oxlint-disable-next-line no-base-to-string -- event.delta is a Schema.String (runtime string)
+            if (match && match.state.status === "pending") match.state.input += event.data.delta
+          }),
+        )
+      }
+    },
+    "session.next.tool.input.ended": () => {},
+    "session.next.tool.called": (event) => {
+      if (currentAssistant) {
+        adapter.updateAssistant(
+          produce(currentAssistant, (draft) => {
+            const match = latestTool(draft, event.data.callID)
+            if (match) {
+              match.provider = event.data.provider
+              match.time.ran = event.data.timestamp
+              match.state = {
+                status: "running",
+                input: event.data.input,
+                structured: {},
+                content: [],
+              }
+            }
+          }),
+        )
+      }
+    },
+    "session.next.tool.progress": (event) => {
+      if (currentAssistant) {
+        adapter.updateAssistant(
+          produce(currentAssistant, (draft) => {
+            const match = latestTool(draft, event.data.callID)
+            if (match && match.state.status === "running") {
+              match.state.structured = event.data.structured
+              match.state.content = [...event.data.content]
+            }
+          }),
+        )
+      }
+    },
+    "session.next.tool.success": (event) => {
+      if (currentAssistant) {
+        adapter.updateAssistant(
+          produce(currentAssistant, (draft) => {
+            const match = latestTool(draft, event.data.callID)
+            if (match && match.state.status === "running") {
+              match.provider = event.data.provider
+              match.time.completed = event.data.timestamp
+              match.state = {
+                status: "completed",
+                input: match.state.input,
+                structured: event.data.structured,
+                content: [...event.data.content],
+              }
+            }
+          }),
+        )
+      }
+    },
+    "session.next.tool.failed": (event) => {
+      if (currentAssistant) {
+        adapter.updateAssistant(
+          produce(currentAssistant, (draft) => {
+            const match = latestTool(draft, event.data.callID)
+            if (match && match.state.status === "running") {
+              match.provider = event.data.provider
+              match.time.completed = event.data.timestamp
+              match.state = {
+                status: "error",
+                error: event.data.error,
+                input: match.state.input,
+                structured: match.state.structured,
+                content: match.state.content,
+              }
+            }
+          }),
+        )
+      }
+    },
+    "session.next.reasoning.started": (event) => {
+      if (currentAssistant) {
+        adapter.updateAssistant(
+          produce(currentAssistant, (draft) => {
+            draft.content.push({
+              type: "reasoning",
+              id: event.data.reasoningID,
+              text: "",
+            })
+          }),
+        )
+      }
+    },
+    "session.next.reasoning.delta": (event) => {
+      if (currentAssistant) {
+        adapter.updateAssistant(
+          produce(currentAssistant, (draft) => {
+            const match = latestReasoning(draft, event.data.reasoningID)
+            if (match) match.text += event.data.delta
+          }),
+        )
+      }
+    },
+    "session.next.reasoning.ended": (event) => {
+      if (currentAssistant) {
+        adapter.updateAssistant(
+          produce(currentAssistant, (draft) => {
+            const match = latestReasoning(draft, event.data.reasoningID)
+            if (match) match.text = event.data.text
+          }),
+        )
+      }
+    },
+    "session.next.retried": () => {},
+    "session.next.compaction.started": (event) => {
+      adapter.appendMessage(
+        new SessionMessage.Compaction({
+          id: event.id,
+          type: "compaction",
+          metadata: event.metadata,
+          reason: event.data.reason,
+          summary: "",
+          time: { created: event.data.timestamp },
+        }),
+      )
+    },
+    "session.next.compaction.delta": (event) => {
+      const currentCompaction = adapter.getCurrentCompaction()
+      if (currentCompaction) {
+        adapter.updateCompaction(
+          produce(currentCompaction, (draft) => {
+            draft.summary += event.data.text
+          }),
+        )
+      }
+    },
+    "session.next.compaction.ended": (event) => {
+      const currentCompaction = adapter.getCurrentCompaction()
+      if (currentCompaction) {
+        adapter.updateCompaction(
+          produce(currentCompaction, (draft) => {
+            draft.summary = event.data.text
+            draft.include = event.data.include
+          }),
+        )
+      }
+    },
+  })
+
+  return adapter.finish()
+}
+
+export * as SessionMessageUpdater from "./session-message-updater"
@@ -1,12 +1,10 @@
-export * as SessionMessage from "./message"
-
 import { Schema } from "effect"
-import { EventV2 } from "../event"
-import { ModelV2 } from "../model"
-import { ToolOutput } from "../tool-output"
-import { V2Schema } from "../v2-schema"
-import { SessionEvent } from "./event"
-import { Prompt } from "./prompt"
+import { Prompt } from "./session-prompt"
+import { SessionEvent } from "./session-event"
+import { EventV2 } from "./event"
+import { ToolOutput } from "./tool-output"
+import { V2Schema } from "./v2-schema"
+import { ModelV2 } from "./model"

 export const ID = EventV2.ID
 export type ID = Schema.Schema.Type<typeof ID>
@@ -171,3 +169,5 @@ export const Message = Schema.Union([AgentSwitched, ModelSwitched, User, Synthet
 export type Message = Schema.Schema.Type<typeof Message>

 export type Type = Message["type"]
+
+export * as SessionMessage from "./session-message"
@@ -1,337 +1,13 @@
-export * as SessionV2 from "./session"
-export * from "./session/schema"
+export * as Session from "./session"

-import { DateTime, Effect, Layer, Schema, Context } from "effect"
-import { and, asc, desc, eq, gt, gte, like, lt, or, type SQL } from "drizzle-orm"
-import { ProjectV2 } from "./project"
-import { WorkspaceV2 } from "./workspace"
-import { ModelV2 } from "./model"
-import { Location } from "./location"
-import { SessionMessage } from "./session/message"
-import type { Prompt } from "./session/prompt"
-import { EventV2 } from "./event"
-import { ProviderV2 } from "./provider"
-import { Database } from "./database/database"
-import { SessionProjector } from "./session/projector"
-import { SessionMessageTable, SessionTable } from "./session/sql"
-import { SessionSchema } from "./session/schema"
-import { AbsolutePath, RelativePath } from "./schema"
+import { Schema } from "effect"
+import { withStatics } from "./schema"
+import { Identifier } from "./util/identifier"

-// get project -> project.locations
-//
-// get all sessions
-//
-
-// - by project
-//   - by subpath
-// - by workspace (home is special)
-
-export const ListCursor = Schema.Struct({
-  id: SessionSchema.ID,
-  time: Schema.Finite,
-  direction: Schema.Literals(["previous", "next"]),
-})
-export type ListCursor = typeof ListCursor.Type
-
-const ListInputBase = {
-  workspaceID: WorkspaceV2.ID.pipe(Schema.optional),
-  search: Schema.String.pipe(Schema.optional),
-  limit: Schema.Int.pipe(Schema.optional),
-  order: Schema.Literals(["asc", "desc"]).pipe(Schema.optional),
-  cursor: ListCursor.pipe(Schema.optional),
-}
-
-export const ListInput = Schema.Union([
-  Schema.Struct({
-    ...ListInputBase,
-  }),
-  Schema.Struct({
-    ...ListInputBase,
-    directory: AbsolutePath,
-  }),
-  Schema.Struct({
-    ...ListInputBase,
-    project: ProjectV2.ID,
-    subpath: RelativePath.pipe(Schema.optional),
-  }),
-])
-export type ListInput = typeof ListInput.Type
-
-type CreateInput = {
-  id?: SessionSchema.ID
-  agent?: string
-  model?: ModelV2.Ref
-  location: Location.Ref
-}
-
-type MoveInput = {
-  sessionID: SessionSchema.ID
-  location: Location.Ref
-}
-
-type CompactInput = {
-  sessionID: SessionSchema.ID
-  prompt?: Prompt
-}
-
-export class NotFoundError extends Schema.TaggedErrorClass<NotFoundError>()("Session.NotFoundError", {
-  sessionID: SessionSchema.ID,
-}) {}
-
-export class OperationUnavailableError extends Schema.TaggedErrorClass<OperationUnavailableError>()(
-  "Session.OperationUnavailableError",
-  {
-    operation: Schema.Literals(["prompt", "compact", "wait"]),
-  },
-) {}
-
-export class MessageDecodeError extends Schema.TaggedErrorClass<MessageDecodeError>()("Session.MessageDecodeError", {
-  sessionID: SessionSchema.ID,
-  messageID: SessionMessage.ID,
-}) {}
-
-export type Error = NotFoundError | MessageDecodeError | OperationUnavailableError
-
-export interface Interface {
-  readonly list: (input?: ListInput) => Effect.Effect<SessionSchema.Info[]>
-  readonly create: (input?: CreateInput) => Effect.Effect<SessionSchema.Info>
-  readonly move: (input: MoveInput) => Effect.Effect<void, NotFoundError>
-  readonly get: (sessionID: SessionSchema.ID) => Effect.Effect<SessionSchema.Info, NotFoundError>
-  readonly messages: (input: {
-    sessionID: SessionSchema.ID
-    limit?: number
-    order?: "asc" | "desc"
-    cursor?: {
-      id: SessionMessage.ID
-      time: number
-      direction: "previous" | "next"
-    }
-  }) => Effect.Effect<SessionMessage.Message[], NotFoundError | MessageDecodeError>
-  readonly context: (
-    sessionID: SessionSchema.ID,
-  ) => Effect.Effect<SessionMessage.Message[], NotFoundError | MessageDecodeError>
-  readonly switchAgent: (input: { sessionID: SessionSchema.ID; agent: string }) => Effect.Effect<void, never>
-  readonly switchModel: (input: { sessionID: SessionSchema.ID; model: ModelV2.Ref }) => Effect.Effect<void, never>
-  readonly prompt: (input: {
-    id?: EventV2.ID
-    sessionID: SessionSchema.ID
-    prompt: Prompt
-    delivery?: SessionSchema.Delivery
-    resume?: boolean
-  }) => Effect.Effect<SessionMessage.User, NotFoundError | OperationUnavailableError>
-  readonly shell: (input: {
-    id?: EventV2.ID
-    sessionID: SessionSchema.ID
-    command: string
-    delivery?: SessionSchema.Delivery
-    resume?: boolean
-  }) => Effect.Effect<void, never>
-  readonly skill: (input: {
-    id?: EventV2.ID
-    sessionID: SessionSchema.ID
-    skill: string
-    delivery?: SessionSchema.Delivery
-    resume?: boolean
-  }) => Effect.Effect<void, never>
-  readonly compact: (input: CompactInput) => Effect.Effect<void, NotFoundError | OperationUnavailableError>
-  readonly wait: (id: SessionSchema.ID) => Effect.Effect<void, NotFoundError | OperationUnavailableError>
-  readonly resume: (sessionID: SessionSchema.ID) => Effect.Effect<void>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/v2/Session") {}
-
-function fromRow(row: typeof SessionTable.$inferSelect): SessionSchema.Info {
-  return new SessionSchema.Info({
-    id: SessionSchema.ID.make(row.id),
-    projectID: ProjectV2.ID.make(row.project_id),
-    workspaceID: row.workspace_id ? WorkspaceV2.ID.make(row.workspace_id) : undefined,
-    title: row.title,
-    parentID: row.parent_id ? SessionSchema.ID.make(row.parent_id) : undefined,
-    path: row.path ?? "",
-    agent: row.agent ?? undefined,
-    model: row.model
-      ? {
-          id: ModelV2.ID.make(row.model.id),
-          providerID: ProviderV2.ID.make(row.model.providerID),
-          variant: ModelV2.VariantID.make(row.model.variant ?? "default"),
-        }
-      : undefined,
-    cost: row.cost,
-    tokens: {
-      input: row.tokens_input,
-      output: row.tokens_output,
-      reasoning: row.tokens_reasoning,
-      cache: {
-        read: row.tokens_cache_read,
-        write: row.tokens_cache_write,
-      },
-    },
-    time: {
-      created: DateTime.makeUnsafe(row.time_created),
-      updated: DateTime.makeUnsafe(row.time_updated),
-      archived: row.time_archived ? DateTime.makeUnsafe(row.time_archived) : undefined,
-    },
-  })
-}
-
-export const layer = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const db = (yield* Database.Service).db
-    const decodeMessage = Schema.decodeUnknownEffect(SessionMessage.Message)
-
-    const decode = (row: typeof SessionMessageTable.$inferSelect) =>
-      decodeMessage({ ...row.data, id: row.id, type: row.type }).pipe(
-        Effect.mapError(
-          () =>
-            new MessageDecodeError({
-              sessionID: SessionSchema.ID.make(row.session_id),
-              messageID: SessionMessage.ID.make(row.id),
-            }),
-        ),
-      )
-
-    const result = Service.of({
-      create: Effect.fn("V2Session.create")(function* () {
-        return {} as SessionSchema.Info
-      }),
-      get: Effect.fn("V2Session.get")(function* (sessionID) {
-        const row = yield* db.select().from(SessionTable).where(eq(SessionTable.id, sessionID)).get().pipe(Effect.orDie)
-        if (!row) return yield* new NotFoundError({ sessionID })
-        return fromRow(row)
-      }),
-      list: Effect.fn("V2Session.list")(function* (input = {}) {
-        const direction = input.cursor?.direction ?? "next"
-        const requestedOrder = input.order ?? "desc"
-        const order = direction === "previous" ? (requestedOrder === "asc" ? "desc" : "asc") : requestedOrder
-        const sortColumn = SessionTable.time_updated
-        const conditions: SQL[] = []
-        if ("directory" in input) conditions.push(eq(SessionTable.directory, input.directory))
-        if (input.workspaceID) conditions.push(eq(SessionTable.workspace_id, input.workspaceID))
-        if ("project" in input) conditions.push(eq(SessionTable.project_id, input.project))
-        if (input.search) conditions.push(like(SessionTable.title, `%${input.search}%`))
-        if (input.cursor) {
-          conditions.push(
-            order === "asc"
-              ? or(
-                  gt(sortColumn, input.cursor.time),
-                  and(eq(sortColumn, input.cursor.time), gt(SessionTable.id, input.cursor.id)),
-                )!
-              : or(
-                  lt(sortColumn, input.cursor.time),
-                  and(eq(sortColumn, input.cursor.time), lt(SessionTable.id, input.cursor.id)),
-                )!,
-          )
-        }
-        const query = db
-          .select()
-          .from(SessionTable)
-          .where(conditions.length > 0 ? and(...conditions) : undefined)
-          .orderBy(
-            order === "asc" ? asc(sortColumn) : desc(sortColumn),
-            order === "asc" ? asc(SessionTable.id) : desc(SessionTable.id),
-          )
-        const rows = yield* (input.limit === undefined ? query.all() : query.limit(input.limit).all()).pipe(
-          Effect.orDie,
-        )
-        return (direction === "previous" ? rows.toReversed() : rows).map((row) => fromRow(row))
-      }),
-      messages: Effect.fn("V2Session.messages")(function* (input) {
-        yield* result.get(input.sessionID)
-        const direction = input.cursor?.direction ?? "next"
-        const requestedOrder = input.order ?? "desc"
-        const order = direction === "previous" ? (requestedOrder === "asc" ? "desc" : "asc") : requestedOrder
-        const boundary = input.cursor
-          ? order === "asc"
-            ? or(
-                gt(SessionMessageTable.time_created, input.cursor.time),
-                and(
-                  eq(SessionMessageTable.time_created, input.cursor.time),
-                  gt(SessionMessageTable.id, input.cursor.id),
-                ),
-              )
-            : or(
-                lt(SessionMessageTable.time_created, input.cursor.time),
-                and(
-                  eq(SessionMessageTable.time_created, input.cursor.time),
-                  lt(SessionMessageTable.id, input.cursor.id),
-                ),
-              )
-          : undefined
-        const where = boundary
-          ? and(eq(SessionMessageTable.session_id, input.sessionID), boundary)
-          : eq(SessionMessageTable.session_id, input.sessionID)
-        const query = db
-          .select()
-          .from(SessionMessageTable)
-          .where(where)
-          .orderBy(
-            order === "asc" ? asc(SessionMessageTable.time_created) : desc(SessionMessageTable.time_created),
-            order === "asc" ? asc(SessionMessageTable.id) : desc(SessionMessageTable.id),
-          )
-        const rows = yield* (input.limit === undefined ? query.all() : query.limit(input.limit).all()).pipe(
-          Effect.orDie,
-        )
-        return yield* Effect.forEach(direction === "previous" ? rows.toReversed() : rows, decode)
-      }),
-      context: Effect.fn("V2Session.context")(function* (sessionID) {
-        yield* result.get(sessionID)
-        const compaction = yield* db
-          .select()
-          .from(SessionMessageTable)
-          .where(and(eq(SessionMessageTable.session_id, sessionID), eq(SessionMessageTable.type, "compaction")))
-          .orderBy(desc(SessionMessageTable.time_created), desc(SessionMessageTable.id))
-          .limit(1)
-          .get()
-          .pipe(Effect.orDie)
-        const rows = yield* db
-          .select()
-          .from(SessionMessageTable)
-          .where(
-            and(
-              eq(SessionMessageTable.session_id, sessionID),
-              compaction
-                ? or(
-                    gt(SessionMessageTable.time_created, compaction.time_created),
-                    and(
-                      eq(SessionMessageTable.time_created, compaction.time_created),
-                      gte(SessionMessageTable.id, compaction.id),
-                    ),
-                  )
-                : undefined,
-            ),
-          )
-          .orderBy(asc(SessionMessageTable.time_created), asc(SessionMessageTable.id))
-          .all()
-          .pipe(Effect.orDie)
-        return yield* Effect.forEach(rows, decode)
-      }),
-      prompt: Effect.fn("V2Session.prompt")(function* (input) {
-        yield* result.get(input.sessionID)
-        return yield* Effect.fail(new OperationUnavailableError({ operation: "prompt" }))
-      }),
-      shell: Effect.fn("V2Session.shell")(function* () {}),
-      skill: Effect.fn("V2Session.skill")(function* () {}),
-      switchAgent: Effect.fn("V2Session.switchAgent")(function* () {}),
-      switchModel: Effect.fn("V2Session.switchModel")(function* () {}),
-      compact: Effect.fn("V2Session.compact")(function* (input) {
-        yield* result.get(input.sessionID)
-        return yield* new OperationUnavailableError({ operation: "compact" })
-      }),
-      wait: Effect.fn("V2Session.wait")(function* (sessionID) {
-        yield* result.get(sessionID)
-        return yield* new OperationUnavailableError({ operation: "wait" })
-      }),
-      resume: Effect.fn("V2Session.resume")(function* () {}),
-      move: Effect.fn("V2Session.move")(function* () {}),
-    })
-
-    return result
-  }),
-)
-
-export const defaultLayer = layer.pipe(
-  Layer.provide(SessionProjector.defaultLayer),
-  Layer.provide(Database.defaultLayer),
-  Layer.orDie,
+export const ID = Schema.String.check(Schema.isStartsWith("ses")).pipe(
+  Schema.brand("SessionID"),
+  withStatics((schema) => ({
+    descending: (id?: string) => schema.make(id ?? "ses_" + Identifier.descending()),
+  })),
 )
+export type ID = typeof ID.Type
@@ -1,625 +0,0 @@
-export * as SessionLegacy from "./legacy"
-
-import { Effect, Schema, Types } from "effect"
-import { EventV2 } from "../event"
-import { PermissionV2 } from "../permission"
-import { ProjectV2 } from "../project"
-import { ProviderV2 } from "../provider"
-import { optionalOmitUndefined, withStatics } from "../schema"
-import { Identifier } from "../util/identifier"
-import { NonNegativeInt } from "../schema"
-import { NamedError } from "../util/error"
-import { SessionSchema } from "./schema"
-import { WorkspaceV2 } from "../workspace"
-
-export const MessageID = Schema.String.check(Schema.isStartsWith("msg")).pipe(
-  Schema.brand("MessageID"),
-  withStatics((schema) => ({ ascending: (id?: string) => schema.make(id ?? "msg_" + Identifier.ascending()) })),
-)
-export type MessageID = typeof MessageID.Type
-
-export const PartID = Schema.String.check(Schema.isStartsWith("prt")).pipe(
-  Schema.brand("PartID"),
-  withStatics((schema) => ({ ascending: (id?: string) => schema.make(id ?? "prt_" + Identifier.ascending()) })),
-)
-export type PartID = typeof PartID.Type
-
-export const OutputLengthError = NamedError.create("MessageOutputLengthError", {})
-
-export const AuthError = NamedError.create("ProviderAuthError", {
-  providerID: Schema.String,
-  message: Schema.String,
-})
-
-export const AbortedError = NamedError.create("MessageAbortedError", { message: Schema.String })
-export const StructuredOutputError = NamedError.create("StructuredOutputError", {
-  message: Schema.String,
-  retries: NonNegativeInt,
-})
-export const APIError = NamedError.create("APIError", {
-  message: Schema.String,
-  statusCode: Schema.optional(NonNegativeInt),
-  isRetryable: Schema.Boolean,
-  responseHeaders: Schema.optional(Schema.Record(Schema.String, Schema.String)),
-  responseBody: Schema.optional(Schema.String),
-  metadata: Schema.optional(Schema.Record(Schema.String, Schema.String)),
-})
-export type APIError = Schema.Schema.Type<typeof APIError.Schema>
-export const ContextOverflowError = NamedError.create("ContextOverflowError", {
-  message: Schema.String,
-  responseBody: Schema.optional(Schema.String),
-})
-
-export class OutputFormatText extends Schema.Class<OutputFormatText>("OutputFormatText")({
-  type: Schema.Literal("text"),
-}) {}
-
-export class OutputFormatJsonSchema extends Schema.Class<OutputFormatJsonSchema>("OutputFormatJsonSchema")({
-  type: Schema.Literal("json_schema"),
-  schema: Schema.Record(Schema.String, Schema.Any).annotate({ identifier: "JSONSchema" }),
-  retryCount: NonNegativeInt.pipe(Schema.optional, Schema.withDecodingDefault(Effect.succeed(2))),
-}) {}
-
-export const Format = Schema.Union([OutputFormatText, OutputFormatJsonSchema]).annotate({
-  discriminator: "type",
-  identifier: "OutputFormat",
-})
-export type OutputFormat = Schema.Schema.Type<typeof Format>
-
-const partBase = {
-  id: PartID,
-  sessionID: SessionSchema.ID,
-  messageID: MessageID,
-}
-
-export const SnapshotPart = Schema.Struct({
-  ...partBase,
-  type: Schema.Literal("snapshot"),
-  snapshot: Schema.String,
-}).annotate({ identifier: "SnapshotPart" })
-export type SnapshotPart = Types.DeepMutable<Schema.Schema.Type<typeof SnapshotPart>>
-
-export const PatchPart = Schema.Struct({
-  ...partBase,
-  type: Schema.Literal("patch"),
-  hash: Schema.String,
-  files: Schema.Array(Schema.String),
-}).annotate({ identifier: "PatchPart" })
-export type PatchPart = Types.DeepMutable<Schema.Schema.Type<typeof PatchPart>>
-
-export const TextPart = Schema.Struct({
-  ...partBase,
-  type: Schema.Literal("text"),
-  text: Schema.String,
-  synthetic: Schema.optional(Schema.Boolean),
-  ignored: Schema.optional(Schema.Boolean),
-  time: Schema.optional(
-    Schema.Struct({
-      start: NonNegativeInt,
-      end: Schema.optional(NonNegativeInt),
-    }),
-  ),
-  metadata: Schema.optional(Schema.Record(Schema.String, Schema.Any)),
-}).annotate({ identifier: "TextPart" })
-export type TextPart = Types.DeepMutable<Schema.Schema.Type<typeof TextPart>>
-
-export const ReasoningPart = Schema.Struct({
-  ...partBase,
-  type: Schema.Literal("reasoning"),
-  text: Schema.String,
-  metadata: Schema.optional(Schema.Record(Schema.String, Schema.Any)),
-  time: Schema.Struct({
-    start: NonNegativeInt,
-    end: Schema.optional(NonNegativeInt),
-  }),
-}).annotate({ identifier: "ReasoningPart" })
-export type ReasoningPart = Types.DeepMutable<Schema.Schema.Type<typeof ReasoningPart>>
-
-const filePartSourceBase = {
-  text: Schema.Struct({
-    value: Schema.String,
-    start: Schema.Finite,
-    end: Schema.Finite,
-  }).annotate({ identifier: "FilePartSourceText" }),
-}
-
-export const Range = Schema.Struct({
-  start: Schema.Struct({ line: NonNegativeInt, character: NonNegativeInt }),
-  end: Schema.Struct({ line: NonNegativeInt, character: NonNegativeInt }),
-}).annotate({ identifier: "Range" })
-export type Range = typeof Range.Type
-
-export const FileSource = Schema.Struct({
-  ...filePartSourceBase,
-  type: Schema.Literal("file"),
-  path: Schema.String,
-}).annotate({ identifier: "FileSource" })
-
-export const SymbolSource = Schema.Struct({
-  ...filePartSourceBase,
-  type: Schema.Literal("symbol"),
-  path: Schema.String,
-  range: Range,
-  name: Schema.String,
-  kind: NonNegativeInt,
-}).annotate({ identifier: "SymbolSource" })
-
-export const ResourceSource = Schema.Struct({
-  ...filePartSourceBase,
-  type: Schema.Literal("resource"),
-  clientName: Schema.String,
-  uri: Schema.String,
-}).annotate({ identifier: "ResourceSource" })
-
-export const FilePartSource = Schema.Union([FileSource, SymbolSource, ResourceSource]).annotate({
-  discriminator: "type",
-  identifier: "FilePartSource",
-})
-
-export const FilePart = Schema.Struct({
-  ...partBase,
-  type: Schema.Literal("file"),
-  mime: Schema.String,
-  filename: Schema.optional(Schema.String),
-  url: Schema.String,
-  source: Schema.optional(FilePartSource),
-}).annotate({ identifier: "FilePart" })
-export type FilePart = Types.DeepMutable<Schema.Schema.Type<typeof FilePart>>
-
-export const AgentPart = Schema.Struct({
-  ...partBase,
-  type: Schema.Literal("agent"),
-  name: Schema.String,
-  source: Schema.optional(
-    Schema.Struct({
-      value: Schema.String,
-      start: NonNegativeInt,
-      end: NonNegativeInt,
-    }),
-  ),
-}).annotate({ identifier: "AgentPart" })
-export type AgentPart = Types.DeepMutable<Schema.Schema.Type<typeof AgentPart>>
-
-export const CompactionPart = Schema.Struct({
-  ...partBase,
-  type: Schema.Literal("compaction"),
-  auto: Schema.Boolean,
-  overflow: Schema.optional(Schema.Boolean),
-  tail_start_id: Schema.optional(MessageID),
-}).annotate({ identifier: "CompactionPart" })
-export type CompactionPart = Types.DeepMutable<Schema.Schema.Type<typeof CompactionPart>>
-
-export const SubtaskPart = Schema.Struct({
-  ...partBase,
-  type: Schema.Literal("subtask"),
-  prompt: Schema.String,
-  description: Schema.String,
-  agent: Schema.String,
-  model: Schema.optional(
-    Schema.Struct({
-      providerID: ProviderV2.ID,
-      modelID: ProviderV2.ModelID,
-    }),
-  ),
-  command: Schema.optional(Schema.String),
-}).annotate({ identifier: "SubtaskPart" })
-export type SubtaskPart = Types.DeepMutable<Schema.Schema.Type<typeof SubtaskPart>>
-
-export const RetryPart = Schema.Struct({
-  ...partBase,
-  type: Schema.Literal("retry"),
-  attempt: NonNegativeInt,
-  error: APIError.EffectSchema,
-  time: Schema.Struct({
-    created: NonNegativeInt,
-  }),
-}).annotate({ identifier: "RetryPart" })
-export type RetryPart = Omit<Types.DeepMutable<Schema.Schema.Type<typeof RetryPart>>, "error"> & {
-  error: APIError
-}
-
-export const StepStartPart = Schema.Struct({
-  ...partBase,
-  type: Schema.Literal("step-start"),
-  snapshot: Schema.optional(Schema.String),
-}).annotate({ identifier: "StepStartPart" })
-export type StepStartPart = Types.DeepMutable<Schema.Schema.Type<typeof StepStartPart>>
-
-export const StepFinishPart = Schema.Struct({
-  ...partBase,
-  type: Schema.Literal("step-finish"),
-  reason: Schema.String,
-  snapshot: Schema.optional(Schema.String),
-  cost: Schema.Finite,
-  tokens: Schema.Struct({
-    total: Schema.optional(Schema.Finite),
-    input: Schema.Finite,
-    output: Schema.Finite,
-    reasoning: Schema.Finite,
-    cache: Schema.Struct({
-      read: Schema.Finite,
-      write: Schema.Finite,
-    }),
-  }),
-}).annotate({ identifier: "StepFinishPart" })
-export type StepFinishPart = Types.DeepMutable<Schema.Schema.Type<typeof StepFinishPart>>
-
-export const ToolStatePending = Schema.Struct({
-  status: Schema.Literal("pending"),
-  input: Schema.Record(Schema.String, Schema.Any),
-  raw: Schema.String,
-}).annotate({ identifier: "ToolStatePending" })
-export type ToolStatePending = Types.DeepMutable<Schema.Schema.Type<typeof ToolStatePending>>
-
-export const ToolStateRunning = Schema.Struct({
-  status: Schema.Literal("running"),
-  input: Schema.Record(Schema.String, Schema.Any),
-  title: Schema.optional(Schema.String),
-  metadata: Schema.optional(Schema.Record(Schema.String, Schema.Any)),
-  time: Schema.Struct({
-    start: NonNegativeInt,
-  }),
-}).annotate({ identifier: "ToolStateRunning" })
-export type ToolStateRunning = Types.DeepMutable<Schema.Schema.Type<typeof ToolStateRunning>>
-
-export const ToolStateCompleted = Schema.Struct({
-  status: Schema.Literal("completed"),
-  input: Schema.Record(Schema.String, Schema.Any),
-  output: Schema.String,
-  title: Schema.String,
-  metadata: Schema.Record(Schema.String, Schema.Any),
-  time: Schema.Struct({
-    start: NonNegativeInt,
-    end: NonNegativeInt,
-    compacted: Schema.optional(NonNegativeInt),
-  }),
-  attachments: Schema.optional(Schema.Array(FilePart)),
-}).annotate({ identifier: "ToolStateCompleted" })
-export type ToolStateCompleted = Types.DeepMutable<Schema.Schema.Type<typeof ToolStateCompleted>>
-
-export const ToolStateError = Schema.Struct({
-  status: Schema.Literal("error"),
-  input: Schema.Record(Schema.String, Schema.Any),
-  error: Schema.String,
-  metadata: Schema.optional(Schema.Record(Schema.String, Schema.Any)),
-  time: Schema.Struct({
-    start: NonNegativeInt,
-    end: NonNegativeInt,
-  }),
-}).annotate({ identifier: "ToolStateError" })
-export type ToolStateError = Types.DeepMutable<Schema.Schema.Type<typeof ToolStateError>>
-
-export const ToolState = Schema.Union([
-  ToolStatePending,
-  ToolStateRunning,
-  ToolStateCompleted,
-  ToolStateError,
-]).annotate({
-  discriminator: "status",
-  identifier: "ToolState",
-})
-export type ToolState = ToolStatePending | ToolStateRunning | ToolStateCompleted | ToolStateError
-
-export const ToolPart = Schema.Struct({
-  ...partBase,
-  type: Schema.Literal("tool"),
-  callID: Schema.String,
-  tool: Schema.String,
-  state: ToolState,
-  metadata: Schema.optional(Schema.Record(Schema.String, Schema.Any)),
-}).annotate({ identifier: "ToolPart" })
-export type ToolPart = Omit<Types.DeepMutable<Schema.Schema.Type<typeof ToolPart>>, "state"> & {
-  state: ToolState
-}
-
-const messageBase = {
-  id: MessageID,
-  sessionID: partBase.sessionID,
-}
-
-const FileDiff = Schema.Struct({
-  file: Schema.optional(Schema.String),
-  patch: Schema.optional(Schema.String),
-  additions: Schema.Finite,
-  deletions: Schema.Finite,
-  status: Schema.optional(Schema.Literals(["added", "deleted", "modified"])),
-}).annotate({ identifier: "SnapshotFileDiff" })
-
-export const User = Schema.Struct({
-  ...messageBase,
-  role: Schema.Literal("user"),
-  time: Schema.Struct({
-    created: NonNegativeInt,
-  }),
-  format: Schema.optional(Format),
-  summary: Schema.optional(
-    Schema.Struct({
-      title: Schema.optional(Schema.String),
-      body: Schema.optional(Schema.String),
-      diffs: Schema.Array(FileDiff),
-    }),
-  ),
-  agent: Schema.String,
-  model: Schema.Struct({
-    providerID: ProviderV2.ID,
-    modelID: ProviderV2.ModelID,
-    variant: Schema.optional(Schema.String),
-  }),
-  system: Schema.optional(Schema.String),
-  tools: Schema.optional(Schema.Record(Schema.String, Schema.Boolean)),
-}).annotate({ identifier: "UserMessage" })
-export type User = Types.DeepMutable<Schema.Schema.Type<typeof User>>
-
-export const Part = Schema.Union([
-  TextPart,
-  SubtaskPart,
-  ReasoningPart,
-  FilePart,
-  ToolPart,
-  StepStartPart,
-  StepFinishPart,
-  SnapshotPart,
-  PatchPart,
-  AgentPart,
-  RetryPart,
-  CompactionPart,
-]).annotate({ discriminator: "type", identifier: "Part" })
-export type Part =
-  | TextPart
-  | SubtaskPart
-  | ReasoningPart
-  | FilePart
-  | ToolPart
-  | StepStartPart
-  | StepFinishPart
-  | SnapshotPart
-  | PatchPart
-  | AgentPart
-  | RetryPart
-  | CompactionPart
-
-const AssistantErrorSchema = Schema.Union([
-  AuthError.EffectSchema,
-  NamedError.Unknown.EffectSchema,
-  OutputLengthError.EffectSchema,
-  AbortedError.EffectSchema,
-  StructuredOutputError.EffectSchema,
-  ContextOverflowError.EffectSchema,
-  APIError.EffectSchema,
-]).annotate({ discriminator: "name" })
-type AssistantError = Schema.Schema.Type<typeof AssistantErrorSchema>
-
-export const TextPartInput = Schema.Struct({
-  id: Schema.optional(PartID),
-  type: Schema.Literal("text"),
-  text: Schema.String,
-  synthetic: Schema.optional(Schema.Boolean),
-  ignored: Schema.optional(Schema.Boolean),
-  time: Schema.optional(
-    Schema.Struct({
-      start: NonNegativeInt,
-      end: Schema.optional(NonNegativeInt),
-    }),
-  ),
-  metadata: Schema.optional(Schema.Record(Schema.String, Schema.Any)),
-}).annotate({ identifier: "TextPartInput" })
-export type TextPartInput = Types.DeepMutable<Schema.Schema.Type<typeof TextPartInput>>
-
-export const FilePartInput = Schema.Struct({
-  id: Schema.optional(PartID),
-  type: Schema.Literal("file"),
-  mime: Schema.String,
-  filename: Schema.optional(Schema.String),
-  url: Schema.String,
-  source: Schema.optional(FilePartSource),
-}).annotate({ identifier: "FilePartInput" })
-export type FilePartInput = Types.DeepMutable<Schema.Schema.Type<typeof FilePartInput>>
-
-export const AgentPartInput = Schema.Struct({
-  id: Schema.optional(PartID),
-  type: Schema.Literal("agent"),
-  name: Schema.String,
-  source: Schema.optional(
-    Schema.Struct({
-      value: Schema.String,
-      start: NonNegativeInt,
-      end: NonNegativeInt,
-    }),
-  ),
-}).annotate({ identifier: "AgentPartInput" })
-export type AgentPartInput = Types.DeepMutable<Schema.Schema.Type<typeof AgentPartInput>>
-
-export const SubtaskPartInput = Schema.Struct({
-  id: Schema.optional(PartID),
-  type: Schema.Literal("subtask"),
-  prompt: Schema.String,
-  description: Schema.String,
-  agent: Schema.String,
-  model: Schema.optional(
-    Schema.Struct({
-      providerID: ProviderV2.ID,
-      modelID: ProviderV2.ModelID,
-    }),
-  ),
-  command: Schema.optional(Schema.String),
-}).annotate({ identifier: "SubtaskPartInput" })
-export type SubtaskPartInput = Types.DeepMutable<Schema.Schema.Type<typeof SubtaskPartInput>>
-
-export const Assistant = Schema.Struct({
-  ...messageBase,
-  role: Schema.Literal("assistant"),
-  time: Schema.Struct({
-    created: NonNegativeInt,
-    completed: Schema.optional(NonNegativeInt),
-  }),
-  error: Schema.optional(AssistantErrorSchema),
-  parentID: MessageID,
-  modelID: ProviderV2.ModelID,
-  providerID: ProviderV2.ID,
-  mode: Schema.String,
-  agent: Schema.String,
-  path: Schema.Struct({
-    cwd: Schema.String,
-    root: Schema.String,
-  }),
-  summary: Schema.optional(Schema.Boolean),
-  cost: Schema.Finite,
-  tokens: Schema.Struct({
-    total: Schema.optional(Schema.Finite),
-    input: Schema.Finite,
-    output: Schema.Finite,
-    reasoning: Schema.Finite,
-    cache: Schema.Struct({
-      read: Schema.Finite,
-      write: Schema.Finite,
-    }),
-  }),
-  structured: Schema.optional(Schema.Any),
-  variant: Schema.optional(Schema.String),
-  finish: Schema.optional(Schema.String),
-}).annotate({ identifier: "AssistantMessage" })
-export type Assistant = Omit<Types.DeepMutable<Schema.Schema.Type<typeof Assistant>>, "error"> & {
-  error?: AssistantError
-}
-
-export const Info = Schema.Union([User, Assistant]).annotate({ discriminator: "role", identifier: "Message" })
-export type Info = User | Assistant
-
-export const WithParts = Schema.Struct({
-  info: Info,
-  parts: Schema.Array(Part),
-})
-export type WithParts = {
-  info: Info
-  parts: Part[]
-}
-
-const options = {
-  sync: {
-    aggregate: "sessionID",
-    version: 1,
-  },
-} as const
-
-const SessionSummary = Schema.Struct({
-  additions: Schema.Finite,
-  deletions: Schema.Finite,
-  files: Schema.Finite,
-  diffs: optionalOmitUndefined(Schema.Array(FileDiff)),
-})
-
-const SessionTokens = Schema.Struct({
-  input: Schema.Finite,
-  output: Schema.Finite,
-  reasoning: Schema.Finite,
-  cache: Schema.Struct({
-    read: Schema.Finite,
-    write: Schema.Finite,
-  }),
-})
-
-const SessionShare = Schema.Struct({
-  url: Schema.String,
-})
-
-const SessionRevert = Schema.Struct({
-  messageID: MessageID,
-  partID: optionalOmitUndefined(PartID),
-  snapshot: optionalOmitUndefined(Schema.String),
-  diff: optionalOmitUndefined(Schema.String),
-})
-
-const SessionModel = Schema.Struct({
-  id: ProviderV2.ModelID,
-  providerID: ProviderV2.ID,
-  variant: optionalOmitUndefined(Schema.String),
-})
-
-export const SessionInfo = Schema.Struct({
-  id: SessionSchema.ID,
-  slug: Schema.String,
-  projectID: ProjectV2.ID,
-  workspaceID: optionalOmitUndefined(WorkspaceV2.ID),
-  directory: Schema.String,
-  path: optionalOmitUndefined(Schema.String),
-  parentID: optionalOmitUndefined(SessionSchema.ID),
-  summary: optionalOmitUndefined(SessionSummary),
-  cost: optionalOmitUndefined(Schema.Finite),
-  tokens: optionalOmitUndefined(SessionTokens),
-  share: optionalOmitUndefined(SessionShare),
-  title: Schema.String,
-  agent: optionalOmitUndefined(Schema.String),
-  model: optionalOmitUndefined(SessionModel),
-  version: Schema.String,
-  metadata: optionalOmitUndefined(Schema.Record(Schema.String, Schema.Any)),
-  time: Schema.Struct({
-    created: NonNegativeInt,
-    updated: NonNegativeInt,
-    compacting: optionalOmitUndefined(NonNegativeInt),
-    archived: optionalOmitUndefined(Schema.Finite),
-  }),
-  permission: optionalOmitUndefined(PermissionV2.Ruleset),
-  revert: optionalOmitUndefined(SessionRevert),
-}).annotate({ identifier: "Session" })
-export type SessionInfo = typeof SessionInfo.Type
-
-export const Event = {
-  Created: EventV2.define({
-    type: "session.created",
-    ...options,
-    schema: {
-      sessionID: SessionSchema.ID,
-      info: SessionInfo,
-    },
-  }),
-  Updated: EventV2.define({
-    type: "session.updated",
-    ...options,
-    schema: {
-      sessionID: SessionSchema.ID,
-      info: SessionInfo,
-    },
-  }),
-  Deleted: EventV2.define({
-    type: "session.deleted",
-    ...options,
-    schema: {
-      sessionID: SessionSchema.ID,
-      info: SessionInfo,
-    },
-  }),
-  MessageUpdated: EventV2.define({
-    type: "message.updated",
-    ...options,
-    schema: {
-      sessionID: SessionSchema.ID,
-      info: Info,
-    },
-  }),
-  MessageRemoved: EventV2.define({
-    type: "message.removed",
-    ...options,
-    schema: {
-      sessionID: SessionSchema.ID,
-      messageID: MessageID,
-    },
-  }),
-  PartUpdated: EventV2.define({
-    type: "message.part.updated",
-    ...options,
-    schema: {
-      sessionID: SessionSchema.ID,
-      part: Part,
-      time: Schema.Finite,
-    },
-  }),
-  PartRemoved: EventV2.define({
-    type: "message.part.removed",
-    ...options,
-    schema: {
-      sessionID: SessionSchema.ID,
-      messageID: MessageID,
-      partID: PartID,
-    },
-  }),
-}
@@ -1,474 +0,0 @@
-import { produce, type WritableDraft } from "immer"
-import { Effect } from "effect"
-import { SessionEvent } from "./event"
-import { SessionMessage } from "./message"
-
-export type MemoryState = {
-  messages: SessionMessage.Message[]
-}
-
-export interface Adapter {
-  readonly getCurrentAssistant: () => Effect.Effect<SessionMessage.Assistant | undefined>
-  readonly getCurrentCompaction: () => Effect.Effect<SessionMessage.Compaction | undefined>
-  readonly getCurrentShell: (callID: string) => Effect.Effect<SessionMessage.Shell | undefined>
-  readonly updateAssistant: (assistant: SessionMessage.Assistant) => Effect.Effect<void>
-  readonly updateCompaction: (compaction: SessionMessage.Compaction) => Effect.Effect<void>
-  readonly updateShell: (shell: SessionMessage.Shell) => Effect.Effect<void>
-  readonly appendMessage: (message: SessionMessage.Message) => Effect.Effect<void>
-}
-
-export function memory(state: MemoryState): Adapter {
-  const activeAssistantIndex = () =>
-    state.messages.findLastIndex((message) => message.type === "assistant" && !message.time.completed)
-  const activeCompactionIndex = () => state.messages.findLastIndex((message) => message.type === "compaction")
-  const activeShellIndex = (callID: string) =>
-    state.messages.findLastIndex((message) => message.type === "shell" && message.callID === callID)
-
-  return {
-    getCurrentAssistant() {
-      return Effect.sync(() => {
-        const index = activeAssistantIndex()
-        if (index < 0) return
-        const assistant = state.messages[index]
-        return assistant?.type === "assistant" ? assistant : undefined
-      })
-    },
-    getCurrentCompaction() {
-      return Effect.sync(() => {
-        const index = activeCompactionIndex()
-        if (index < 0) return
-        const compaction = state.messages[index]
-        return compaction?.type === "compaction" ? compaction : undefined
-      })
-    },
-    getCurrentShell(callID) {
-      return Effect.sync(() => {
-        const index = activeShellIndex(callID)
-        if (index < 0) return
-        const shell = state.messages[index]
-        return shell?.type === "shell" ? shell : undefined
-      })
-    },
-    updateAssistant(assistant) {
-      return Effect.sync(() => {
-        const index = activeAssistantIndex()
-        if (index < 0) return
-        const current = state.messages[index]
-        if (current?.type !== "assistant") return
-        state.messages[index] = assistant
-      })
-    },
-    updateCompaction(compaction) {
-      return Effect.sync(() => {
-        const index = activeCompactionIndex()
-        if (index < 0) return
-        const current = state.messages[index]
-        if (current?.type !== "compaction") return
-        state.messages[index] = compaction
-      })
-    },
-    updateShell(shell) {
-      return Effect.sync(() => {
-        const index = activeShellIndex(shell.callID)
-        if (index < 0) return
-        const current = state.messages[index]
-        if (current?.type !== "shell") return
-        state.messages[index] = shell
-      })
-    },
-    appendMessage(message) {
-      return Effect.sync(() => {
-        state.messages.push(message)
-      })
-    },
-  }
-}
-
-export function update(adapter: Adapter, event: SessionEvent.Event) {
-  type DraftAssistant = WritableDraft<SessionMessage.Assistant>
-  type DraftTool = WritableDraft<SessionMessage.AssistantTool>
-  type DraftText = WritableDraft<SessionMessage.AssistantText>
-  type DraftReasoning = WritableDraft<SessionMessage.AssistantReasoning>
-
-  const latestTool = (assistant: DraftAssistant | undefined, callID?: string) =>
-    assistant?.content.findLast(
-      (item): item is DraftTool => item.type === "tool" && (callID === undefined || item.id === callID),
-    )
-
-  const latestText = (assistant: DraftAssistant | undefined) =>
-    assistant?.content.findLast((item): item is DraftText => item.type === "text")
-
-  const latestReasoning = (assistant: DraftAssistant | undefined, reasoningID: string) =>
-    assistant?.content.findLast((item): item is DraftReasoning => item.type === "reasoning" && item.id === reasoningID)
-
-  return Effect.gen(function* () {
-    yield* SessionEvent.All.match(event, {
-      "session.next.agent.switched": (event) => {
-        return adapter.appendMessage(
-          new SessionMessage.AgentSwitched({
-            id: event.id,
-            type: "agent-switched",
-            metadata: event.metadata,
-            agent: event.data.agent,
-            time: { created: event.data.timestamp },
-          }),
-        )
-      },
-      "session.next.model.switched": (event) => {
-        return adapter.appendMessage(
-          new SessionMessage.ModelSwitched({
-            id: event.id,
-            type: "model-switched",
-            metadata: event.metadata,
-            model: event.data.model,
-            time: { created: event.data.timestamp },
-          }),
-        )
-      },
-      "session.next.prompted": (event) => {
-        return adapter.appendMessage(
-          new SessionMessage.User({
-            id: event.id,
-            type: "user",
-            metadata: event.metadata,
-            text: event.data.prompt.text,
-            files: event.data.prompt.files,
-            agents: event.data.prompt.agents,
-            references: event.data.prompt.references,
-            time: { created: event.data.timestamp },
-          }),
-        )
-      },
-      "session.next.synthetic": (event) => {
-        return adapter.appendMessage(
-          new SessionMessage.Synthetic({
-            sessionID: event.data.sessionID,
-            text: event.data.text,
-            id: event.id,
-            type: "synthetic",
-            time: { created: event.data.timestamp },
-          }),
-        )
-      },
-      "session.next.shell.started": (event) => {
-        return adapter.appendMessage(
-          new SessionMessage.Shell({
-            id: event.id,
-            type: "shell",
-            metadata: event.metadata,
-            callID: event.data.callID,
-            command: event.data.command,
-            output: "",
-            time: { created: event.data.timestamp },
-          }),
-        )
-      },
-      "session.next.shell.ended": (event) => {
-        return Effect.gen(function* () {
-          const currentShell = yield* adapter.getCurrentShell(event.data.callID)
-          if (currentShell) {
-            yield* adapter.updateShell(
-              produce(currentShell, (draft) => {
-                draft.output = event.data.output
-                draft.time.completed = event.data.timestamp
-              }),
-            )
-          }
-        })
-      },
-      "session.next.step.started": (event) => {
-        return Effect.gen(function* () {
-          const currentAssistant = yield* adapter.getCurrentAssistant()
-          if (currentAssistant) {
-            yield* adapter.updateAssistant(
-              produce(currentAssistant, (draft) => {
-                draft.time.completed = event.data.timestamp
-              }),
-            )
-          }
-          yield* adapter.appendMessage(
-            new SessionMessage.Assistant({
-              id: event.id,
-              type: "assistant",
-              agent: event.data.agent,
-              model: event.data.model,
-              time: { created: event.data.timestamp },
-              content: [],
-              snapshot: event.data.snapshot ? { start: event.data.snapshot } : undefined,
-            }),
-          )
-        })
-      },
-      "session.next.step.ended": (event) => {
-        return Effect.gen(function* () {
-          const currentAssistant = yield* adapter.getCurrentAssistant()
-          if (currentAssistant) {
-            yield* adapter.updateAssistant(
-              produce(currentAssistant, (draft) => {
-                draft.time.completed = event.data.timestamp
-                draft.finish = event.data.finish
-                draft.cost = event.data.cost
-                draft.tokens = event.data.tokens
-                if (event.data.snapshot) draft.snapshot = { ...draft.snapshot, end: event.data.snapshot }
-              }),
-            )
-          }
-        })
-      },
-      "session.next.step.failed": (event) => {
-        return Effect.gen(function* () {
-          const currentAssistant = yield* adapter.getCurrentAssistant()
-          if (currentAssistant) {
-            yield* adapter.updateAssistant(
-              produce(currentAssistant, (draft) => {
-                draft.time.completed = event.data.timestamp
-                draft.finish = "error"
-                draft.error = event.data.error
-              }),
-            )
-          }
-        })
-      },
-      "session.next.text.started": () => {
-        return Effect.gen(function* () {
-          const currentAssistant = yield* adapter.getCurrentAssistant()
-          if (currentAssistant) {
-            yield* adapter.updateAssistant(
-              produce(currentAssistant, (draft) => {
-                draft.content.push(new SessionMessage.AssistantText({ type: "text", text: "" }) as DraftText)
-              }),
-            )
-          }
-        })
-      },
-      "session.next.text.delta": (event) => {
-        return Effect.gen(function* () {
-          const currentAssistant = yield* adapter.getCurrentAssistant()
-          if (currentAssistant) {
-            yield* adapter.updateAssistant(
-              produce(currentAssistant, (draft) => {
-                const match = latestText(draft)
-                if (match) match.text += event.data.delta
-              }),
-            )
-          }
-        })
-      },
-      "session.next.text.ended": (event) => {
-        return Effect.gen(function* () {
-          const currentAssistant = yield* adapter.getCurrentAssistant()
-          if (currentAssistant) {
-            yield* adapter.updateAssistant(
-              produce(currentAssistant, (draft) => {
-                const match = latestText(draft)
-                if (match) match.text = event.data.text
-              }),
-            )
-          }
-        })
-      },
-      "session.next.tool.input.started": (event) => {
-        return Effect.gen(function* () {
-          const currentAssistant = yield* adapter.getCurrentAssistant()
-          if (currentAssistant) {
-            yield* adapter.updateAssistant(
-              produce(currentAssistant, (draft) => {
-                draft.content.push(
-                  new SessionMessage.AssistantTool({
-                    type: "tool",
-                    id: event.data.callID,
-                    name: event.data.name,
-                    time: { created: event.data.timestamp },
-                    state: new SessionMessage.ToolStatePending({ status: "pending", input: "" }),
-                  }) as DraftTool,
-                )
-              }),
-            )
-          }
-        })
-      },
-      "session.next.tool.input.delta": (event) => {
-        return Effect.gen(function* () {
-          const currentAssistant = yield* adapter.getCurrentAssistant()
-          if (currentAssistant) {
-            yield* adapter.updateAssistant(
-              produce(currentAssistant, (draft) => {
-                const match = latestTool(draft, event.data.callID)
-                // oxlint-disable-next-line no-base-to-string -- event.delta is a Schema.String (runtime string)
-                if (match && match.state.status === "pending") match.state.input += event.data.delta
-              }),
-            )
-          }
-        })
-      },
-      "session.next.tool.input.ended": () => Effect.void,
-      "session.next.tool.called": (event) => {
-        return Effect.gen(function* () {
-          const currentAssistant = yield* adapter.getCurrentAssistant()
-          if (currentAssistant) {
-            yield* adapter.updateAssistant(
-              produce(currentAssistant, (draft) => {
-                const match = latestTool(draft, event.data.callID)
-                if (match) {
-                  match.provider = event.data.provider
-                  match.time.ran = event.data.timestamp
-                  match.state = {
-                    status: "running",
-                    input: event.data.input,
-                    structured: {},
-                    content: [],
-                  }
-                }
-              }),
-            )
-          }
-        })
-      },
-      "session.next.tool.progress": (event) => {
-        return Effect.gen(function* () {
-          const currentAssistant = yield* adapter.getCurrentAssistant()
-          if (currentAssistant) {
-            yield* adapter.updateAssistant(
-              produce(currentAssistant, (draft) => {
-                const match = latestTool(draft, event.data.callID)
-                if (match && match.state.status === "running") {
-                  match.state.structured = event.data.structured
-                  match.state.content = [...event.data.content]
-                }
-              }),
-            )
-          }
-        })
-      },
-      "session.next.tool.success": (event) => {
-        return Effect.gen(function* () {
-          const currentAssistant = yield* adapter.getCurrentAssistant()
-          if (currentAssistant) {
-            yield* adapter.updateAssistant(
-              produce(currentAssistant, (draft) => {
-                const match = latestTool(draft, event.data.callID)
-                if (match && match.state.status === "running") {
-                  match.provider = event.data.provider
-                  match.time.completed = event.data.timestamp
-                  match.state = {
-                    status: "completed",
-                    input: match.state.input,
-                    structured: event.data.structured,
-                    content: [...event.data.content],
-                  }
-                }
-              }),
-            )
-          }
-        })
-      },
-      "session.next.tool.failed": (event) => {
-        return Effect.gen(function* () {
-          const currentAssistant = yield* adapter.getCurrentAssistant()
-          if (currentAssistant) {
-            yield* adapter.updateAssistant(
-              produce(currentAssistant, (draft) => {
-                const match = latestTool(draft, event.data.callID)
-                if (match && match.state.status === "running") {
-                  match.provider = event.data.provider
-                  match.time.completed = event.data.timestamp
-                  match.state = {
-                    status: "error",
-                    error: event.data.error,
-                    input: match.state.input,
-                    structured: match.state.structured,
-                    content: match.state.content,
-                  }
-                }
-              }),
-            )
-          }
-        })
-      },
-      "session.next.reasoning.started": (event) => {
-        return Effect.gen(function* () {
-          const currentAssistant = yield* adapter.getCurrentAssistant()
-          if (currentAssistant) {
-            yield* adapter.updateAssistant(
-              produce(currentAssistant, (draft) => {
-                draft.content.push(
-                  new SessionMessage.AssistantReasoning({
-                    type: "reasoning",
-                    id: event.data.reasoningID,
-                    text: "",
-                  }) as DraftReasoning,
-                )
-              }),
-            )
-          }
-        })
-      },
-      "session.next.reasoning.delta": (event) => {
-        return Effect.gen(function* () {
-          const currentAssistant = yield* adapter.getCurrentAssistant()
-          if (currentAssistant) {
-            yield* adapter.updateAssistant(
-              produce(currentAssistant, (draft) => {
-                const match = latestReasoning(draft, event.data.reasoningID)
-                if (match) match.text += event.data.delta
-              }),
-            )
-          }
-        })
-      },
-      "session.next.reasoning.ended": (event) => {
-        return Effect.gen(function* () {
-          const currentAssistant = yield* adapter.getCurrentAssistant()
-          if (currentAssistant) {
-            yield* adapter.updateAssistant(
-              produce(currentAssistant, (draft) => {
-                const match = latestReasoning(draft, event.data.reasoningID)
-                if (match) match.text = event.data.text
-              }),
-            )
-          }
-        })
-      },
-      "session.next.retried": () => Effect.void,
-      "session.next.compaction.started": (event) => {
-        return adapter.appendMessage(
-          new SessionMessage.Compaction({
-            id: event.id,
-            type: "compaction",
-            metadata: event.metadata,
-            reason: event.data.reason,
-            summary: "",
-            time: { created: event.data.timestamp },
-          }),
-        )
-      },
-      "session.next.compaction.delta": (event) => {
-        return Effect.gen(function* () {
-          const currentCompaction = yield* adapter.getCurrentCompaction()
-          if (currentCompaction) {
-            yield* adapter.updateCompaction(
-              produce(currentCompaction, (draft) => {
-                draft.summary += event.data.text
-              }),
-            )
-          }
-        })
-      },
-      "session.next.compaction.ended": (event) => {
-        return Effect.gen(function* () {
-          const currentCompaction = yield* adapter.getCurrentCompaction()
-          if (currentCompaction) {
-            yield* adapter.updateCompaction(
-              produce(currentCompaction, (draft) => {
-                draft.summary = event.data.text
-                draft.include = event.data.include
-              }),
-            )
-          }
-        })
-      },
-    })
-  })
-}
-
-export * as SessionMessageUpdater from "./message-updater"
@@ -1,456 +0,0 @@
-export * as SessionProjector from "./projector"
-
-import { and, eq, sql } from "drizzle-orm"
-import { DateTime, Effect, Layer, Schema } from "effect"
-import { Database } from "../database/database"
-import { EventV2 } from "../event"
-import { SessionEvent } from "./event"
-import { SessionLegacy } from "./legacy"
-import { WorkspaceTable } from "../control-plane/workspace.sql"
-import { SessionMessage } from "./message"
-import { SessionMessageUpdater } from "./message-updater"
-import { MessageTable, PartTable, SessionMessageTable, SessionTable } from "./sql"
-import type { DeepMutable } from "../schema"
-
-type DatabaseService = Database.Interface["db"]
-
-const decodeMessage = Schema.decodeUnknownSync(SessionMessage.Message)
-const encodeMessage = Schema.encodeSync(SessionMessage.Message)
-
-type Usage = {
-  cost: number
-  tokens: {
-    input: number
-    output: number
-    reasoning: number
-    cache: { read: number; write: number }
-  }
-}
-
-function usage(part: (typeof SessionLegacy.Event.PartUpdated.Type)["data"]["part"] | unknown): Usage | undefined {
-  if (typeof part !== "object" || part === null) return undefined
-  const value = part as Record<string, unknown>
-  if (value.type !== "step-finish") return undefined
-  if (!("cost" in value) || !("tokens" in value)) return undefined
-  return { cost: value.cost as Usage["cost"], tokens: value.tokens as Usage["tokens"] }
-}
-
-function sessionRow(info: SessionLegacy.SessionInfo): typeof SessionTable.$inferInsert {
-  return {
-    id: info.id,
-    project_id: info.projectID,
-    workspace_id: info.workspaceID ?? null,
-    parent_id: info.parentID,
-    slug: info.slug,
-    directory: info.directory,
-    path: info.path,
-    title: info.title,
-    agent: info.agent,
-    model: info.model,
-    version: info.version,
-    share_url: info.share?.url,
-    summary_additions: info.summary?.additions,
-    summary_deletions: info.summary?.deletions,
-    summary_files: info.summary?.files,
-    summary_diffs: info.summary?.diffs ? [...info.summary.diffs] : undefined,
-    metadata: info.metadata,
-    cost: info.cost ?? 0,
-    tokens_input: (info.tokens ?? { input: 0 }).input,
-    tokens_output: (info.tokens ?? { output: 0 }).output,
-    tokens_reasoning: (info.tokens ?? { reasoning: 0 }).reasoning,
-    tokens_cache_read: (info.tokens ?? { cache: { read: 0 } }).cache.read,
-    tokens_cache_write: (info.tokens ?? { cache: { write: 0 } }).cache.write,
-    revert: info.revert ?? null,
-    permission: info.permission ? [...info.permission] : undefined,
-    time_created: info.time.created,
-    time_updated: info.time.updated,
-    time_compacting: info.time.compacting,
-    time_archived: info.time.archived,
-  }
-}
-
-function messageData(
-  info: (typeof SessionLegacy.Event.MessageUpdated.Type)["data"]["info"],
-): typeof MessageTable.$inferInsert.data {
-  const { id: _, sessionID: __, ...rest } = info
-  return rest as DeepMutable<typeof rest>
-}
-
-function partData(
-  part: (typeof SessionLegacy.Event.PartUpdated.Type)["data"]["part"],
-): typeof PartTable.$inferInsert.data {
-  const { id: _, messageID: __, sessionID: ___, ...rest } = part
-  return rest as DeepMutable<typeof rest>
-}
-
-function applyUsage(
-  db: DatabaseService,
-  sessionID: (typeof SessionLegacy.Event.MessageUpdated.Type)["data"]["sessionID"],
-  value: Usage,
-  sign = 1,
-) {
-  return db
-    .update(SessionTable)
-    .set({
-      cost: sql`${SessionTable.cost} + ${value.cost * sign}`,
-      tokens_input: sql`${SessionTable.tokens_input} + ${value.tokens.input * sign}`,
-      tokens_output: sql`${SessionTable.tokens_output} + ${value.tokens.output * sign}`,
-      tokens_reasoning: sql`${SessionTable.tokens_reasoning} + ${value.tokens.reasoning * sign}`,
-      tokens_cache_read: sql`${SessionTable.tokens_cache_read} + ${value.tokens.cache.read * sign}`,
-      tokens_cache_write: sql`${SessionTable.tokens_cache_write} + ${value.tokens.cache.write * sign}`,
-      time_updated: sql`${SessionTable.time_updated}`,
-    })
-    .where(eq(SessionTable.id, sessionID))
-    .run()
-    .pipe(Effect.orDie)
-}
-
-function run(db: DatabaseService, event: SessionEvent.Event) {
-  return Effect.gen(function* () {
-    const adapter: SessionMessageUpdater.Adapter = {
-      getCurrentAssistant() {
-        return Effect.gen(function* () {
-          const rows = yield* db
-            .select()
-            .from(SessionMessageTable)
-            .where(
-              and(eq(SessionMessageTable.session_id, event.data.sessionID), eq(SessionMessageTable.type, "assistant")),
-            )
-            .all()
-            .pipe(Effect.orDie)
-          return rows
-            .map((row) => decodeMessage({ ...row.data, id: row.id, type: row.type }))
-            .find(
-              (message): message is SessionMessage.Assistant => message.type === "assistant" && !message.time.completed,
-            )
-        })
-      },
-      getCurrentCompaction() {
-        return Effect.gen(function* () {
-          const rows = yield* db
-            .select()
-            .from(SessionMessageTable)
-            .where(
-              and(eq(SessionMessageTable.session_id, event.data.sessionID), eq(SessionMessageTable.type, "compaction")),
-            )
-            .all()
-            .pipe(Effect.orDie)
-          return rows
-            .map((row) => decodeMessage({ ...row.data, id: row.id, type: row.type }))
-            .find((message): message is SessionMessage.Compaction => message.type === "compaction")
-        })
-      },
-      getCurrentShell(callID) {
-        return Effect.gen(function* () {
-          const rows = yield* db
-            .select()
-            .from(SessionMessageTable)
-            .where(and(eq(SessionMessageTable.session_id, event.data.sessionID), eq(SessionMessageTable.type, "shell")))
-            .all()
-            .pipe(Effect.orDie)
-          return rows
-            .map((row) => decodeMessage({ ...row.data, id: row.id, type: row.type }))
-            .find((message): message is SessionMessage.Shell => message.type === "shell" && message.callID === callID)
-        })
-      },
-      updateAssistant(message) {
-        return Effect.gen(function* () {
-          const encoded = encodeMessage(message)
-          const { id, type, ...data } = encoded
-          yield* db
-            .insert(SessionMessageTable)
-            .values([
-              {
-                id: SessionMessage.ID.make(id),
-                session_id: event.data.sessionID,
-                type,
-                time_created: DateTime.toEpochMillis(message.time.created),
-                data,
-              },
-            ])
-            .onConflictDoUpdate({
-              target: SessionMessageTable.id,
-              set: {
-                type,
-                time_created: DateTime.toEpochMillis(message.time.created),
-                data,
-              },
-            })
-            .run()
-            .pipe(Effect.orDie)
-        })
-      },
-      updateCompaction(message) {
-        return Effect.gen(function* () {
-          const encoded = encodeMessage(message)
-          const { id, type, ...data } = encoded
-          yield* db
-            .insert(SessionMessageTable)
-            .values([
-              {
-                id: SessionMessage.ID.make(id),
-                session_id: event.data.sessionID,
-                type,
-                time_created: DateTime.toEpochMillis(message.time.created),
-                data,
-              },
-            ])
-            .onConflictDoUpdate({
-              target: SessionMessageTable.id,
-              set: {
-                type,
-                time_created: DateTime.toEpochMillis(message.time.created),
-                data,
-              },
-            })
-            .run()
-            .pipe(Effect.orDie)
-        })
-      },
-      updateShell(message) {
-        return Effect.gen(function* () {
-          const encoded = encodeMessage(message)
-          const { id, type, ...data } = encoded
-          yield* db
-            .insert(SessionMessageTable)
-            .values([
-              {
-                id: SessionMessage.ID.make(id),
-                session_id: event.data.sessionID,
-                type,
-                time_created: DateTime.toEpochMillis(message.time.created),
-                data,
-              },
-            ])
-            .onConflictDoUpdate({
-              target: SessionMessageTable.id,
-              set: {
-                type,
-                time_created: DateTime.toEpochMillis(message.time.created),
-                data,
-              },
-            })
-            .run()
-            .pipe(Effect.orDie)
-        })
-      },
-      appendMessage(message) {
-        return Effect.gen(function* () {
-          const encoded = encodeMessage(message)
-          const { id, type, ...data } = encoded
-          yield* db
-            .insert(SessionMessageTable)
-            .values([
-              {
-                id: SessionMessage.ID.make(id),
-                session_id: event.data.sessionID,
-                type,
-                time_created: DateTime.toEpochMillis(message.time.created),
-                data,
-              },
-            ])
-            .onConflictDoUpdate({
-              target: SessionMessageTable.id,
-              set: {
-                type,
-                time_created: DateTime.toEpochMillis(message.time.created),
-                data,
-              },
-            })
-            .run()
-            .pipe(Effect.orDie)
-        })
-      },
-    }
-    yield* SessionMessageUpdater.update(adapter, event)
-  })
-}
-
-export const layer = Layer.effectDiscard(
-  Effect.gen(function* () {
-    const events = yield* EventV2.Service
-    const { db } = yield* Database.Service
-    yield* events.project(SessionLegacy.Event.Created, (event) =>
-      Effect.gen(function* () {
-        yield* db.insert(SessionTable).values(sessionRow(event.data.info)).run().pipe(Effect.orDie)
-        if (event.data.info.workspaceID) {
-          yield* db
-            .update(WorkspaceTable)
-            .set({ time_used: Date.now() })
-            .where(eq(WorkspaceTable.id, event.data.info.workspaceID))
-            .run()
-            .pipe(Effect.orDie)
-        }
-      }),
-    )
-    yield* events.project(SessionLegacy.Event.Updated, (event) =>
-      db
-        .update(SessionTable)
-        .set(sessionRow(event.data.info))
-        .where(eq(SessionTable.id, event.data.sessionID))
-        .run()
-        .pipe(Effect.orDie),
-    )
-    yield* events.project(SessionLegacy.Event.Deleted, (event) =>
-      db.delete(SessionTable).where(eq(SessionTable.id, event.data.sessionID)).run().pipe(Effect.orDie),
-    )
-    yield* events.project(SessionLegacy.Event.MessageUpdated, (event) =>
-      Effect.gen(function* () {
-        const time_created = event.data.info.time.created
-        const id = event.data.info.id
-        const sessionID = event.data.info.sessionID
-        const data = messageData(event.data.info)
-        yield* db
-          .insert(MessageTable)
-          .values({ id, session_id: sessionID, time_created, data })
-          .onConflictDoUpdate({ target: MessageTable.id, set: { data } })
-          .run()
-          .pipe(Effect.orDie)
-      }),
-    )
-    yield* events.project(SessionLegacy.Event.MessageRemoved, (event) =>
-      Effect.gen(function* () {
-        const rows = yield* db
-          .select()
-          .from(PartTable)
-          .where(and(eq(PartTable.message_id, event.data.messageID), eq(PartTable.session_id, event.data.sessionID)))
-          .all()
-          .pipe(Effect.orDie)
-        for (const row of rows) {
-          const previous = usage(row.data)
-          if (previous) yield* applyUsage(db, event.data.sessionID, previous, -1)
-        }
-        yield* db
-          .delete(MessageTable)
-          .where(and(eq(MessageTable.id, event.data.messageID), eq(MessageTable.session_id, event.data.sessionID)))
-          .run()
-          .pipe(Effect.orDie)
-      }),
-    )
-    yield* events.project(SessionLegacy.Event.PartRemoved, (event) =>
-      Effect.gen(function* () {
-        const row = yield* db
-          .select()
-          .from(PartTable)
-          .where(and(eq(PartTable.id, event.data.partID), eq(PartTable.session_id, event.data.sessionID)))
-          .get()
-          .pipe(Effect.orDie)
-        const previous = row && usage(row.data)
-        if (previous) yield* applyUsage(db, event.data.sessionID, previous, -1)
-        yield* db
-          .delete(PartTable)
-          .where(and(eq(PartTable.id, event.data.partID), eq(PartTable.session_id, event.data.sessionID)))
-          .run()
-          .pipe(Effect.orDie)
-      }),
-    )
-    yield* events.project(SessionLegacy.Event.PartUpdated, (event) =>
-      Effect.gen(function* () {
-        const id = event.data.part.id
-        const messageID = event.data.part.messageID
-        const sessionID = event.data.part.sessionID
-        const data = partData(event.data.part)
-        const row = yield* db.select().from(PartTable).where(eq(PartTable.id, id)).get().pipe(Effect.orDie)
-        yield* db
-          .insert(PartTable)
-          .values({ id, message_id: messageID, session_id: sessionID, time_created: event.data.time, data })
-          .onConflictDoUpdate({ target: PartTable.id, set: { data } })
-          .run()
-          .pipe(Effect.orDie)
-        const previous = row && usage(row.data)
-        const next = usage(event.data.part)
-        if (previous) yield* applyUsage(db, row.session_id, previous, -1)
-        if (next) yield* applyUsage(db, sessionID, next)
-      }),
-    )
-    // session.next.* projectors are disabled while the v2 message projection is stabilized.
-    // The events still publish through EventV2 and fan out through the opencode bridge.
-    // yield* events.project(SessionEvent.AgentSwitched, (event) =>
-    //   Effect.gen(function* () {
-    //     const message = Schema.encodeSync(SessionMessage.AgentSwitched)(
-    //       new SessionMessage.AgentSwitched({
-    //         id: event.id,
-    //         type: "agent-switched",
-    //         metadata: event.metadata,
-    //         agent: event.data.agent,
-    //         time: { created: event.data.timestamp },
-    //       }),
-    //     )
-    //     const data = { metadata: message.metadata, agent: message.agent, time: message.time }
-    //     yield* db
-    //       .update(SessionTable)
-    //       .set({ agent: event.data.agent, time_updated: DateTime.toEpochMillis(event.data.timestamp) })
-    //       .where(eq(SessionTable.id, event.data.sessionID))
-    //       .run()
-    //       .pipe(Effect.orDie)
-    //     yield* db
-    //       .insert(SessionMessageTable)
-    //       .values([
-    //         {
-    //           id: SessionMessage.ID.make(event.id),
-    //           session_id: event.data.sessionID,
-    //           type: "agent-switched",
-    //           time_created: DateTime.toEpochMillis(event.data.timestamp),
-    //           data,
-    //         },
-    //       ])
-    //       .run()
-    //       .pipe(Effect.orDie)
-    //   }),
-    // )
-    // yield* events.project(SessionEvent.ModelSwitched, (event) =>
-    //   Effect.gen(function* () {
-    //     const message = Schema.encodeSync(SessionMessage.ModelSwitched)(
-    //       new SessionMessage.ModelSwitched({
-    //         id: event.id,
-    //         type: "model-switched",
-    //         metadata: event.metadata,
-    //         model: event.data.model,
-    //         time: { created: event.data.timestamp },
-    //       }),
-    //     )
-    //     const data = { metadata: message.metadata, model: message.model, time: message.time }
-    //     yield* db
-    //       .update(SessionTable)
-    //       .set({ model: event.data.model, time_updated: DateTime.toEpochMillis(event.data.timestamp) })
-    //       .where(eq(SessionTable.id, event.data.sessionID))
-    //       .run()
-    //       .pipe(Effect.orDie)
-    //     yield* db
-    //       .insert(SessionMessageTable)
-    //       .values([
-    //         {
-    //           id: SessionMessage.ID.make(event.id),
-    //           session_id: event.data.sessionID,
-    //           type: "model-switched",
-    //           time_created: DateTime.toEpochMillis(event.data.timestamp),
-    //           data,
-    //         },
-    //       ])
-    //       .run()
-    //       .pipe(Effect.orDie)
-    //   }),
-    // )
-    // yield* events.project(SessionEvent.Prompted, (event) => run(db, event))
-    // yield* events.project(SessionEvent.Synthetic, (event) => run(db, event))
-    // yield* events.project(SessionEvent.Shell.Started, (event) => run(db, event))
-    // yield* events.project(SessionEvent.Shell.Ended, (event) => run(db, event))
-    // yield* events.project(SessionEvent.Step.Started, (event) => run(db, event))
-    // yield* events.project(SessionEvent.Step.Ended, (event) => run(db, event))
-    // yield* events.project(SessionEvent.Step.Failed, (event) => run(db, event))
-    // yield* events.project(SessionEvent.Text.Started, (event) => run(db, event))
-    // yield* events.project(SessionEvent.Text.Ended, (event) => run(db, event))
-    // yield* events.project(SessionEvent.Tool.Input.Started, (event) => run(db, event))
-    // yield* events.project(SessionEvent.Tool.Input.Ended, (event) => run(db, event))
-    // yield* events.project(SessionEvent.Tool.Called, (event) => run(db, event))
-    // yield* events.project(SessionEvent.Tool.Success, (event) => run(db, event))
-    // yield* events.project(SessionEvent.Tool.Failed, (event) => run(db, event))
-    // yield* events.project(SessionEvent.Reasoning.Started, (event) => run(db, event))
-    // yield* events.project(SessionEvent.Reasoning.Ended, (event) => run(db, event))
-    // yield* events.project(SessionEvent.Retried, (event) => run(db, event))
-    // yield* events.project(SessionEvent.Compaction.Started, (event) => run(db, event))
-    // yield* events.project(SessionEvent.Compaction.Ended, (event) => run(db, event))
-  }),
-)
-
-export const defaultLayer = layer.pipe(Layer.provide(EventV2.defaultLayer), Layer.provide(Database.defaultLayer))
@@ -1,59 +0,0 @@
-export * as SessionSchema from "./schema"
-
-import { Schema } from "effect"
-import { Location } from "../location"
-import { ModelV2 } from "../model"
-import { ProjectV2 } from "../project"
-import { RelativePath, optionalOmitUndefined, withStatics } from "../schema"
-import { WorkspaceV2 } from "../workspace"
-import { Identifier } from "../util/identifier"
-import { V2Schema } from "../v2-schema"
-
-export const Delivery = Schema.Literals(["immediate", "deferred"]).annotate({
-  identifier: "Session.Delivery",
-})
-export type Delivery = Schema.Schema.Type<typeof Delivery>
-
-export const DefaultDelivery = "immediate" satisfies Delivery
-
-export const ID = Schema.String.check(Schema.isStartsWith("ses")).pipe(
-  Schema.brand("SessionID"),
-  withStatics((schema) => ({
-    descending: (id?: string) => schema.make(id ?? "ses_" + Identifier.descending()),
-  })),
-)
-export type ID = typeof ID.Type
-
-export const LegacyInfo = Schema.Struct({
-  id: ID,
-  location: Location.Ref,
-  subpath: RelativePath, // derived from location
-  project: ProjectV2.ID, // derived from location
-})
-export type LegacyInfo = typeof LegacyInfo.Type
-
-export class Info extends Schema.Class<Info>("Session.Info")({
-  id: ID,
-  parentID: optionalOmitUndefined(ID),
-  projectID: ProjectV2.ID,
-  workspaceID: optionalOmitUndefined(WorkspaceV2.ID),
-  path: optionalOmitUndefined(Schema.String),
-  agent: optionalOmitUndefined(Schema.String),
-  model: ModelV2.Ref.pipe(optionalOmitUndefined),
-  cost: Schema.Finite,
-  tokens: Schema.Struct({
-    input: Schema.Finite,
-    output: Schema.Finite,
-    reasoning: Schema.Finite,
-    cache: Schema.Struct({
-      read: Schema.Finite,
-      write: Schema.Finite,
-    }),
-  }),
-  time: Schema.Struct({
-    created: V2Schema.DateTimeUtcFromMillis,
-    updated: V2Schema.DateTimeUtcFromMillis,
-    archived: optionalOmitUndefined(V2Schema.DateTimeUtcFromMillis),
-  }),
-  title: Schema.String,
-}) {}
@@ -1,9 +0,0 @@
-export namespace Snapshot {
-  export type FileDiff = {
-    file?: string
-    patch?: string
-    additions: number
-    deletions: number
-    status?: "added" | "deleted" | "modified"
-  }
-}
@@ -1,7 +1,7 @@
 export * as State from "./state"

 import { Effect, Scope, Semaphore } from "effect"
-import type { Draft, Objectish } from "immer"
+import { createDraft, finishDraft, type Draft, type Objectish } from "immer"

 export type Transform<Editor> = (editor: Editor) => void
 export type MakeEditor<State extends Objectish, Editor> = (draft: Draft<State>) => Editor
@@ -24,18 +24,17 @@ export function create<State extends Objectish, Editor>(options: Options<State,
  let transforms: { update: Transform<Editor> }[] = []
  const semaphore = Semaphore.makeUnsafe(1)

-  const commit = Effect.fn("State.commit")(function* (next: State, reason?: string) {
-    const api = options.editor(next as Draft<State>)
+  const commit = Effect.fn("State.commit")(function* (draft: Draft<State>, reason?: string) {
+    const api = options.editor(draft)
    if (options.finalize) yield* options.finalize(api, reason)
-    state = next
+    state = finishDraft(draft) as State
  })

  const rebuild = Effect.fn("State.rebuild")(function* () {
-    const next = options.initial()
-    const api = options.editor(next as Draft<State>)
-    for (const transform of transforms)
-      yield* Effect.sync(() => transform.update(api)).pipe(Effect.withSpan("State.rebuild.update", {}))
-    yield* commit(next)
+    const draft = createDraft(options.initial())
+    const api = options.editor(draft)
+    for (const transform of transforms) transform.update(api)
+    yield* commit(draft)
  }, semaphore.withPermit)

  return {
@@ -56,9 +55,9 @@ export function create<State extends Objectish, Editor>(options: Options<State,
      })
    }),
    update: Effect.fn("State.update")(function* (update, reason) {
-      const api = options.editor(state as Draft<State>)
-      yield* update(api)
-      if (options.finalize) yield* options.finalize(api, reason)
+      const draft = createDraft(state)
+      yield* update(options.editor(draft))
+      yield* commit(draft, reason)
    }, semaphore.withPermit),
  }
 }
@@ -1,18 +0,0 @@
-export * as WorkspaceV2 from "./workspace"
-
-import { Schema } from "effect"
-import { withStatics } from "./schema"
-import { Identifier } from "./util/identifier"
-
-export const ID = Schema.String.check(Schema.isStartsWith("wrk")).pipe(
-  Schema.brand("WorkspaceV2.ID"),
-  withStatics((schema) => ({
-    ascending: (id?: string) => {
-      if (!id) return schema.make("wrk_" + Identifier.ascending())
-      if (!id.startsWith("wrk")) throw new Error(`ID ${id} does not start with wrk`)
-      return schema.make(id)
-    },
-    create: () => schema.make("wrk_" + Identifier.ascending()),
-  })),
-)
-export type ID = typeof ID.Type
@@ -2,7 +2,7 @@ import path from "path"
 import { describe, expect } from "bun:test"
 import { produce } from "immer"
 import { Effect, Fiber, Layer, Option, Stream } from "effect"
-import { Auth } from "@opencode-ai/core/auth"
+import { AccountV2 } from "@opencode-ai/core/account"
 import { Catalog } from "@opencode-ai/core/catalog"
 import { EventV2 } from "@opencode-ai/core/event"
 import { AppFileSystem } from "@opencode-ai/core/filesystem"
@@ -14,7 +14,7 @@ import { ProviderV2 } from "@opencode-ai/core/provider"
 import { tmpdir } from "./fixture/tmpdir"
 import { testEffect } from "./lib/effect"

-const it = testEffect(PluginV2.locationLayer.pipe(Layer.provide(EventV2.defaultLayer)))
+const it = testEffect(PluginV2.defaultLayer)

 function context(
  records: { provider: ProviderV2.Info; models: Map<ModelV2.ID, ModelV2.Info> }[],
@@ -56,7 +56,7 @@ function context(
 }

 function testLayer(dir: string) {
-  return Auth.layer.pipe(
+  return AccountV2.layer.pipe(
    Layer.provide(AppFileSystem.defaultLayer),
    Layer.provideMerge(EventV2.defaultLayer),
    Layer.provide(
@@ -74,7 +74,7 @@ function testLayer(dir: string) {
  )
 }

-describe("Auth", () => {
+describe("AccountV2", () => {
  it.live("emits account lifecycle events", () =>
    Effect.acquireRelease(
      Effect.promise(() => tmpdir()),
@@ -82,23 +82,23 @@ describe("Auth", () => {
    ).pipe(
      Effect.flatMap((tmp) =>
        Effect.gen(function* () {
-          const accounts = yield* Auth.Service
+          const accounts = yield* AccountV2.Service
          const eventSvc = yield* EventV2.Service
          const addedFiber = yield* eventSvc
-            .subscribe(Auth.Event.Added)
+            .subscribe(AccountV2.Event.Added)
            .pipe(Stream.take(2), Stream.runCollect, Effect.forkScoped)
          const switchedFiber = yield* eventSvc
-            .subscribe(Auth.Event.Switched)
+            .subscribe(AccountV2.Event.Switched)
            .pipe(Stream.take(3), Stream.runCollect, Effect.forkScoped)
          const removedFiber = yield* eventSvc
-            .subscribe(Auth.Event.Removed)
+            .subscribe(AccountV2.Event.Removed)
            .pipe(Stream.take(1), Stream.runCollect, Effect.forkScoped)

          yield* Effect.yieldNow

          const first = yield* accounts.create({
-            serviceID: Auth.ServiceID.make("provider"),
-            credential: new Auth.ApiKeyCredential({ type: "api", key: "raw-key" }),
+            serviceID: AccountV2.ServiceID.make("provider"),
+            credential: new AccountV2.ApiKeyCredential({ type: "api", key: "raw-key" }),
          })
          expect(first).toBeDefined()
          if (!first) return
@@ -113,8 +113,8 @@ describe("Auth", () => {
          if (updated?.credential.type === "api") expect(updated.credential.key).toBe("raw-key")

          const second = yield* accounts.create({
-            serviceID: Auth.ServiceID.make("provider"),
-            credential: new Auth.ApiKeyCredential({ type: "api", key: "second-key" }),
+            serviceID: AccountV2.ServiceID.make("provider"),
+            credential: new AccountV2.ApiKeyCredential({ type: "api", key: "second-key" }),
          })
          expect(second).toBeDefined()
          if (!second) return
@@ -125,9 +125,9 @@ describe("Auth", () => {
          const removed = Array.from(yield* Fiber.join(removedFiber))
          expect(added.map((event) => event.data.account.id)).toEqual([first.id, second.id])
          expect(switched.map((event) => event.data)).toEqual([
-            { serviceID: Auth.ServiceID.make("provider"), from: undefined, to: first.id },
-            { serviceID: Auth.ServiceID.make("provider"), from: first.id, to: second.id },
-            { serviceID: Auth.ServiceID.make("provider"), from: second.id, to: first.id },
+            { serviceID: AccountV2.ServiceID.make("provider"), from: undefined, to: first.id },
+            { serviceID: AccountV2.ServiceID.make("provider"), from: first.id, to: second.id },
+            { serviceID: AccountV2.ServiceID.make("provider"), from: second.id, to: first.id },
          ])
          expect(removed[0]?.data.account.id).toBe(second.id)
        }).pipe(Effect.provide(testLayer(tmp.path))),
@@ -142,25 +142,25 @@ describe("Auth", () => {
    ).pipe(
      Effect.flatMap((tmp) =>
        Effect.gen(function* () {
-          const accounts = yield* Auth.Service
+          const accounts = yield* AccountV2.Service
          const eventSvc = yield* EventV2.Service
          const switchedFiber = yield* eventSvc
-            .subscribe(Auth.Event.Switched)
+            .subscribe(AccountV2.Event.Switched)
            .pipe(Stream.take(3), Stream.runCollect, Effect.forkScoped)

          yield* Effect.yieldNow

          const first = yield* accounts.create({
-            serviceID: Auth.ServiceID.make("provider"),
-            credential: new Auth.ApiKeyCredential({ type: "api", key: "first-key" }),
+            serviceID: AccountV2.ServiceID.make("provider"),
+            credential: new AccountV2.ApiKeyCredential({ type: "api", key: "first-key" }),
          })
          const second = yield* accounts.create({
-            serviceID: Auth.ServiceID.make("provider"),
-            credential: new Auth.ApiKeyCredential({ type: "api", key: "second-key" }),
+            serviceID: AccountV2.ServiceID.make("provider"),
+            credential: new AccountV2.ApiKeyCredential({ type: "api", key: "second-key" }),
          })
          const third = yield* accounts.create({
-            serviceID: Auth.ServiceID.make("provider"),
-            credential: new Auth.ApiKeyCredential({ type: "api", key: "third-key" }),
+            serviceID: AccountV2.ServiceID.make("provider"),
+            credential: new AccountV2.ApiKeyCredential({ type: "api", key: "third-key" }),
          })

          expect(first).toBeDefined()
@@ -168,11 +168,11 @@ describe("Auth", () => {
          expect(third).toBeDefined()
          if (!first || !second || !third) return

-          expect((yield* accounts.active(Auth.ServiceID.make("provider")))?.id).toBe(third.id)
+          expect((yield* accounts.active(AccountV2.ServiceID.make("provider")))?.id).toBe(third.id)
          expect(Array.from(yield* Fiber.join(switchedFiber)).map((event) => event.data)).toEqual([
-            { serviceID: Auth.ServiceID.make("provider"), from: undefined, to: first.id },
-            { serviceID: Auth.ServiceID.make("provider"), from: first.id, to: second.id },
-            { serviceID: Auth.ServiceID.make("provider"), from: second.id, to: third.id },
+            { serviceID: AccountV2.ServiceID.make("provider"), from: undefined, to: first.id },
+            { serviceID: AccountV2.ServiceID.make("provider"), from: first.id, to: second.id },
+            { serviceID: AccountV2.ServiceID.make("provider"), from: second.id, to: third.id },
          ])
        }).pipe(Effect.provide(testLayer(tmp.path))),
      ),
@@ -186,7 +186,7 @@ describe("Auth", () => {
    ).pipe(
      Effect.flatMap((tmp) =>
        Effect.gen(function* () {
-          const accounts = yield* Auth.Service
+          const accounts = yield* AccountV2.Service
          const plugin = yield* PluginV2.Service
          const records = [
            {
@@ -215,7 +215,7 @@ describe("Auth", () => {
          yield* plugin.add({
            ...AccountPlugin,
            effect: AccountPlugin.effect.pipe(
-              Effect.provideService(Auth.Service, accounts),
+              Effect.provideService(AccountV2.Service, accounts),
              Effect.provideService(Catalog.Service, catalog),
              Effect.provideService(EventV2.Service, eventSvc),
              Effect.provideService(PluginV2.Service, plugin),
@@ -224,8 +224,8 @@ describe("Auth", () => {
          yield* Effect.yieldNow

          const first = yield* accounts.create({
-            serviceID: Auth.ServiceID.make("provider"),
-            credential: new Auth.ApiKeyCredential({ type: "api", key: "first-key" }),
+            serviceID: AccountV2.ServiceID.make("provider"),
+            credential: new AccountV2.ApiKeyCredential({ type: "api", key: "first-key" }),
          })
          expect(first).toBeDefined()
          if (!first) return
@@ -233,15 +233,15 @@ describe("Auth", () => {
          expect(updates).toEqual([
            {
              id: ProviderV2.ID.make("provider"),
-              enabled: { via: "account", service: Auth.ServiceID.make("provider") },
+              enabled: { via: "account", service: AccountV2.ServiceID.make("provider") },
              apiKey: "first-key",
            },
          ])

          updates.length = 0
          const second = yield* accounts.create({
-            serviceID: Auth.ServiceID.make("provider"),
-            credential: new Auth.ApiKeyCredential({ type: "api", key: "second-key" }),
+            serviceID: AccountV2.ServiceID.make("provider"),
+            credential: new AccountV2.ApiKeyCredential({ type: "api", key: "second-key" }),
          })
          expect(second).toBeDefined()
          if (!second) return
@@ -249,7 +249,7 @@ describe("Auth", () => {
          expect(updates).toEqual([
            {
              id: ProviderV2.ID.make("provider"),
-              enabled: { via: "account", service: Auth.ServiceID.make("provider") },
+              enabled: { via: "account", service: AccountV2.ServiceID.make("provider") },
              apiKey: "second-key",
            },
          ])
@@ -260,7 +260,7 @@ describe("Auth", () => {
          expect(updates).toEqual([
            {
              id: ProviderV2.ID.make("provider"),
-              enabled: { via: "account", service: Auth.ServiceID.make("provider") },
+              enabled: { via: "account", service: AccountV2.ServiceID.make("provider") },
              apiKey: "first-key",
            },
          ])
@@ -271,7 +271,7 @@ describe("Auth", () => {
          expect(updates).toEqual([
            {
              id: ProviderV2.ID.make("provider"),
-              enabled: { via: "account", service: Auth.ServiceID.make("provider") },
+              enabled: { via: "account", service: AccountV2.ServiceID.make("provider") },
              apiKey: "second-key",
            },
          ])
@@ -3,7 +3,7 @@ import { Effect, Exit, Scope } from "effect"
 import { AgentV2 } from "@opencode-ai/core/agent"
 import { testEffect } from "./lib/effect"

-const it = testEffect(AgentV2.locationLayer)
+const it = testEffect(AgentV2.defaultLayer)

 describe("AgentV2", () => {
  it.effect("starts without agents", () =>
@@ -16,7 +16,12 @@ const locationLayer = Layer.succeed(
  Location.Service.of(location({ directory: AbsolutePath.make("test") })),
 )
 const it = testEffect(
-  Catalog.locationLayer.pipe(Layer.provideMerge(EventV2.defaultLayer), Layer.provideMerge(locationLayer)),
+  Catalog.layer.pipe(
+    Layer.provideMerge(EventV2.defaultLayer),
+    Layer.provideMerge(PluginV2.defaultLayer),
+    Layer.provideMerge(Policy.defaultLayer),
+    Layer.provideMerge(locationLayer),
+  ),
 )

 describe("CatalogV2", () => {
@@ -161,32 +166,6 @@ describe("CatalogV2", () => {
    }),
  )

-  it.effect("ignores plugin additions from another location", () =>
-    Effect.gen(function* () {
-      const events = yield* EventV2.Service
-      const plugin = yield* PluginV2.Service
-      let invoked = 0
-
-      yield* plugin.add({
-        id: PluginV2.ID.make("test-transform"),
-        effect: Effect.succeed({
-          "catalog.transform": () => Effect.sync(() => invoked++),
-        }),
-      })
-      yield* Effect.yieldNow
-      expect(invoked).toBe(1)
-
-      yield* events.publish(
-        PluginV2.Event.Added,
-        { id: PluginV2.ID.make("test-transform") },
-        { location: { directory: AbsolutePath.make("other") } },
-      )
-      yield* Effect.yieldNow
-
-      expect(invoked).toBe(1)
-    }),
-  )
-
  it.effect("resolves provider and model option merges", () =>
    Effect.gen(function* () {
      const catalog = yield* Catalog.Service
@@ -6,7 +6,7 @@ import { ConfigAgentPlugin } from "@opencode-ai/core/config/plugin/agent"
 import { PermissionV2 } from "@opencode-ai/core/permission"
 import { testEffect } from "../lib/effect"

-const it = testEffect(AgentV2.locationLayer)
+const it = testEffect(AgentV2.defaultLayer)
 const decode = Schema.decodeUnknownSync(Config.Info)

 describe("ConfigAgentPlugin.Plugin", () => {
@@ -22,9 +22,10 @@ function testLayer(
  projectDirectory = directory,
  vcs?: Project.Vcs,
 ) {
-  return Config.locationLayer.pipe(
+  return Config.layer.pipe(
    Layer.provide(AppFileSystem.defaultLayer),
    Layer.provide(Global.layerWith({ config: globalDirectory })),
+    Layer.provideMerge(Policy.defaultLayer),
    Layer.provide(
      Layer.succeed(
        Location.Service,
@@ -1,112 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { $ } from "bun"
-import { fileURLToPath } from "url"
-import { SqliteClient } from "@effect/sql-sqlite-bun"
-import { EffectDrizzleSqlite } from "@opencode-ai/effect-drizzle-sqlite"
-import { Effect } from "effect"
-import { sql } from "drizzle-orm"
-import { DatabaseMigration } from "@opencode-ai/core/database/migration"
-import sessionUsageMigration from "@opencode-ai/core/database/migration/20260510033149_session_usage"
-import type { SqlClient as SqlClientService } from "effect/unstable/sql/SqlClient"
-
-const run = <A, E>(effect: Effect.Effect<A, E, SqlClientService>) =>
-  Effect.runPromise(
-    effect.pipe(Effect.provide(SqliteClient.layer({ filename: ":memory:", disableWAL: true })), Effect.scoped),
-  )
-
-const makeDb = EffectDrizzleSqlite.makeWithDefaults()
-
-describe("DatabaseMigration", () => {
-  if (process.platform === "linux") {
-    test("declared schema has no ungenerated migrations", async () => {
-      const result = await $`bun ${fileURLToPath(new URL("../script/migration.ts", import.meta.url))} --check`
-        .quiet()
-        .nothrow()
-      expect(result.exitCode, result.stderr.toString()).toBe(0)
-      expect(result.stdout.toString()).toContain("No schema changes, nothing to migrate")
-    }, 30_000)
-  }
-
-  test("applies tracked migrations to an empty database", async () => {
-    await run(
-      Effect.gen(function* () {
-        const db = yield* makeDb
-        yield* DatabaseMigration.apply(db)
-
-        expect(yield* db.get(sql`SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'session'`)).toEqual({
-          name: "session",
-        })
-        expect(yield* db.get(sql`SELECT count(*) as count FROM migration`)).toEqual({ count: 21 })
-      }),
-    )
-  })
-
-  test("runs session usage backfill in order with schema changes", async () => {
-    await run(
-      Effect.gen(function* () {
-        const db = yield* makeDb
-        yield* db.run(sql`CREATE TABLE session (id text PRIMARY KEY, time_updated integer NOT NULL)`)
-        yield* db.run(sql`CREATE TABLE message (id text PRIMARY KEY, session_id text NOT NULL, data text NOT NULL)`)
-        yield* db.run(sql`INSERT INTO session (id, time_updated) VALUES ('session_1', 1)`)
-        yield* db.run(
-          sql`INSERT INTO message (id, session_id, data) VALUES ('message_1', 'session_1', '{"role":"assistant","cost":1.25,"tokens":{"input":2,"output":3,"reasoning":4,"cache":{"read":5,"write":6}}}')`,
-        )
-
-        yield* DatabaseMigration.applyOnly(db, [sessionUsageMigration])
-
-        expect(
-          yield* db.get(
-            sql`SELECT cost, tokens_input, tokens_output, tokens_reasoning, tokens_cache_read, tokens_cache_write FROM session WHERE id = 'session_1'`,
-          ),
-        ).toEqual({
-          cost: 1.25,
-          tokens_input: 2,
-          tokens_output: 3,
-          tokens_reasoning: 4,
-          tokens_cache_read: 5,
-          tokens_cache_write: 6,
-        })
-      }),
-    )
-  })
-
-  test("imports existing drizzle migration state", async () => {
-    await run(
-      Effect.gen(function* () {
-        const db = yield* makeDb
-        yield* db.run(
-          sql`CREATE TABLE __drizzle_migrations (id INTEGER PRIMARY KEY, hash text NOT NULL, created_at numeric, name text, applied_at TEXT)`,
-        )
-        yield* db.run(sql`
-          INSERT INTO __drizzle_migrations (hash, created_at, name, applied_at)
-          VALUES ('hash', 1, '20260127222353_familiar_lady_ursula', ${new Date().toISOString()})
-        `)
-
-        yield* DatabaseMigration.applyOnly(db, [])
-
-        expect(yield* db.get(sql`SELECT id FROM migration`)).toEqual({ id: "20260127222353_familiar_lady_ursula" })
-      }),
-    )
-  })
-
-  test("skips drizzle import when migration table already has state", async () => {
-    await run(
-      Effect.gen(function* () {
-        const db = yield* makeDb
-        yield* db.run(sql`CREATE TABLE migration (id TEXT PRIMARY KEY, time_completed INTEGER NOT NULL)`)
-        yield* db.run(sql`INSERT INTO migration (id, time_completed) VALUES ('existing', 1)`)
-        yield* db.run(
-          sql`CREATE TABLE __drizzle_migrations (id INTEGER PRIMARY KEY, hash text NOT NULL, created_at numeric, name text, applied_at TEXT)`,
-        )
-        yield* db.run(sql`
-          INSERT INTO __drizzle_migrations (hash, created_at, name, applied_at)
-          VALUES ('hash', 1, '20260127222353_familiar_lady_ursula', ${new Date().toISOString()})
-        `)
-
-        yield* DatabaseMigration.applyOnly(db, [])
-
-        expect(yield* db.all(sql`SELECT id FROM migration ORDER BY id`)).toEqual([{ id: "existing" }])
-      }),
-    )
-  })
-})
@@ -1,11 +1,8 @@
 import { describe, expect } from "bun:test"
 import { Effect, Fiber, Layer, Schema, Stream } from "effect"
 import { EventV2 } from "@opencode-ai/core/event"
-import { Database } from "@opencode-ai/core/database/database"
-import { EventSequenceTable, EventTable } from "@opencode-ai/core/event/sql"
 import { Location } from "@opencode-ai/core/location"
 import { AbsolutePath } from "@opencode-ai/core/schema"
-import { eq } from "drizzle-orm"
 import { location } from "./fixture/location"
 import { testEffect } from "./lib/effect"

@@ -13,9 +10,8 @@ const locationLayer = Layer.succeed(
  Location.Service,
  Location.Service.of(location({ directory: AbsolutePath.make("project"), workspaceID: "workspace" })),
 )
-const eventLayer = Layer.mergeAll(EventV2.defaultLayer, Database.defaultLayer)
-const it = testEffect(eventLayer.pipe(Layer.provideMerge(locationLayer)))
-const itWithoutLocation = testEffect(eventLayer)
+const it = testEffect(EventV2.layer.pipe(Layer.provideMerge(locationLayer)))
+const itWithoutLocation = testEffect(EventV2.layer)

 const Message = EventV2.define({
  type: "test.message",
@@ -24,30 +20,6 @@ const Message = EventV2.define({
  },
 })

-const SyncMessage = EventV2.define({
-  type: "test.sync",
-  sync: {
-    version: 1,
-    aggregate: "id",
-  },
-  schema: {
-    id: Schema.String,
-    text: Schema.String,
-  },
-})
-
-const SyncSent = EventV2.define({
-  type: "test.sent",
-  sync: {
-    version: 1,
-    aggregate: "messageID",
-  },
-  schema: {
-    messageID: Schema.String,
-    text: Schema.String,
-  },
-})
-
 const GlobalMessage = EventV2.define({
  type: "test.global",
  schema: {
@@ -57,12 +29,8 @@ const GlobalMessage = EventV2.define({

 const VersionedMessage = EventV2.define({
  type: "test.versioned",
-  sync: {
-    version: 2,
-    aggregate: "id",
-  },
+  version: 2,
  schema: {
-    id: Schema.String,
    text: Schema.String,
  },
 })
@@ -97,7 +65,7 @@ describe("EventV2", () => {
  it.effect("publishes definition version", () =>
    Effect.gen(function* () {
      const events = yield* EventV2.Service
-      const event = yield* events.publish(VersionedMessage, { id: "one", text: "hello" })
+      const event = yield* events.publish(VersionedMessage, { text: "hello" })

      expect(event.type).toBe("test.versioned")
      expect(event.version).toBe(2)
@@ -110,23 +78,6 @@ describe("EventV2", () => {
    }),
  )

-  it.effect("keeps the latest sync definition in the registry", () =>
-    Effect.sync(() => {
-      const latest = EventV2.define({
-        type: "test.out-of-order",
-        sync: { version: 2, aggregate: "id" },
-        schema: { id: Schema.String },
-      })
-      EventV2.define({
-        type: "test.out-of-order",
-        sync: { version: 1, aggregate: "id" },
-        schema: { id: Schema.String },
-      })
-
-      expect(EventV2.registry.get("test.out-of-order")).toBe(latest)
-    }),
-  )
-
  it.effect("publishes to typed and wildcard subscriptions", () =>
    Effect.gen(function* () {
      const events = yield* EventV2.Service
@@ -140,25 +91,25 @@ describe("EventV2", () => {
    }),
  )

-  it.effect("runs projectors inline", () =>
+  it.effect("runs sync handlers inline", () =>
    Effect.gen(function* () {
      const events = yield* EventV2.Service
      const received = new Array<EventV2.Payload>()
-      yield* events.project(SyncMessage, (event) =>
+      const unsubscribe = yield* events.sync((event) =>
        Effect.sync(() => {
          received.push(event)
        }),
      )

-      const event = yield* events.publish(SyncMessage, { id: "one", text: "hello" })
-      yield* events.publish(SyncMessage, { id: "one", text: "after unsubscribe" })
+      const event = yield* events.publish(Message, { text: "hello" })
+      yield* unsubscribe
+      yield* events.publish(Message, { text: "after unsubscribe" })

-      expect(received[0]).toEqual(event)
-      expect(received[1]?.data).toEqual({ id: "one", text: "after unsubscribe" })
+      expect(received).toEqual([event])
    }),
  )

-  it.effect("runs projectors before publishing to streams", () =>
+  it.effect("runs sync handlers before publishing to streams", () =>
    Effect.gen(function* () {
      const events = yield* EventV2.Service
      const received = new Array<string>()
@@ -167,410 +118,17 @@ describe("EventV2", () => {
        Stream.runForEach(() => Effect.sync(() => received.push("stream"))),
        Effect.forkScoped,
      )
-      yield* events.project(SyncMessage, (event) =>
+      yield* events.sync((event) =>
        Effect.sync(() => {
          received.push(event.type)
        }),
      )

      yield* Effect.yieldNow
-      yield* events.publish(SyncMessage, { id: "one", text: "hello" })
+      yield* events.publish(Message, { text: "hello" })
      yield* Fiber.join(fiber)

-      expect(received).toEqual([SyncMessage.type, "stream"])
-    }),
-  )
-
-  it.effect("runs listeners inline after projectors", () =>
-    Effect.gen(function* () {
-      const events = yield* EventV2.Service
-      const received = new Array<string>()
-      yield* events.project(SyncMessage, () =>
-        Effect.sync(() => {
-          received.push("projector")
-        }),
-      )
-      const unsubscribe = yield* events.listen(() =>
-        Effect.sync(() => {
-          received.push("listener")
-        }),
-      )
-
-      yield* events.publish(SyncMessage, { id: "one", text: "hello" })
-      yield* unsubscribe
-      yield* events.publish(SyncMessage, { id: "one", text: "after unsubscribe" })
-
-      expect(received).toEqual(["projector", "listener", "projector"])
-    }),
-  )
-
-  it.effect("inserts sync event rows on publish", () =>
-    Effect.gen(function* () {
-      const events = yield* EventV2.Service
-      const { db } = yield* Database.Service
-      const aggregateID = EventV2.ID.create()
-
-      yield* events.publish(SyncMessage, { id: aggregateID, text: "first" })
-      const rows = yield* db
-        .select()
-        .from(EventTable)
-        .where(eq(EventTable.aggregate_id, aggregateID))
-        .all()
-        .pipe(Effect.orDie)
-
-      expect(rows).toHaveLength(1)
-      expect(rows[0]?.type).toBe(EventV2.versionedType(SyncMessage.type, 1))
-      expect(rows[0]?.aggregate_id).toBe(aggregateID)
-    }),
-  )
-
-  it.effect("increments sync event seq per aggregate", () =>
-    Effect.gen(function* () {
-      const events = yield* EventV2.Service
-      const { db } = yield* Database.Service
-      const aggregateID = EventV2.ID.create()
-
-      yield* events.publish(SyncMessage, { id: aggregateID, text: "first" })
-      yield* events.publish(SyncMessage, { id: aggregateID, text: "second" })
-      const rows = yield* db
-        .select()
-        .from(EventTable)
-        .where(eq(EventTable.aggregate_id, aggregateID))
-        .all()
-        .pipe(Effect.orDie)
-
-      expect(rows.map((row) => row.seq)).toEqual([0, 1])
-    }),
-  )
-
-  it.effect("uses custom sync aggregate field", () =>
-    Effect.gen(function* () {
-      const events = yield* EventV2.Service
-      const { db } = yield* Database.Service
-      const aggregateID = EventV2.ID.create()
-
-      yield* events.publish(SyncSent, { messageID: aggregateID, text: "sent" })
-      const rows = yield* db
-        .select()
-        .from(EventTable)
-        .where(eq(EventTable.aggregate_id, aggregateID))
-        .all()
-        .pipe(Effect.orDie)
-
-      expect(rows).toHaveLength(1)
-      expect(rows[0]?.aggregate_id).toBe(aggregateID)
-    }),
-  )
-
-  it.effect("replays sync events through projectors", () =>
-    Effect.gen(function* () {
-      const events = yield* EventV2.Service
-      const received = new Array<EventV2.Payload>()
-      yield* events.project(SyncMessage, (event) =>
-        Effect.sync(() => {
-          received.push(event)
-        }),
-      )
-      const aggregateID = EventV2.ID.create()
-
-      yield* events.replay({
-        id: EventV2.ID.create(),
-        type: EventV2.versionedType(SyncMessage.type, 1),
-        seq: 0,
-        aggregateID,
-        data: { id: aggregateID, text: "hello" },
-      })
-
-      expect(received[0]?.type).toBe(SyncMessage.type)
-      expect(received[0]?.data).toEqual({ id: aggregateID, text: "hello" })
-    }),
-  )
-
-  it.effect("replay inserts external event rows", () =>
-    Effect.gen(function* () {
-      const events = yield* EventV2.Service
-      const { db } = yield* Database.Service
-      const aggregateID = EventV2.ID.create()
-
-      yield* events.replay({
-        id: EventV2.ID.create(),
-        type: EventV2.versionedType(SyncMessage.type, 1),
-        seq: 0,
-        aggregateID,
-        data: { id: aggregateID, text: "replayed" },
-      })
-      const rows = yield* db
-        .select()
-        .from(EventTable)
-        .where(eq(EventTable.aggregate_id, aggregateID))
-        .all()
-        .pipe(Effect.orDie)
-
-      expect(rows).toHaveLength(1)
-      expect(rows[0]?.aggregate_id).toBe(aggregateID)
-    }),
-  )
-
-  it.effect("replay defects on sequence mismatch", () =>
-    Effect.gen(function* () {
-      const events = yield* EventV2.Service
-      const aggregateID = EventV2.ID.create()
-
-      yield* events.replay({
-        id: EventV2.ID.create(),
-        type: EventV2.versionedType(SyncMessage.type, 1),
-        seq: 0,
-        aggregateID,
-        data: { id: aggregateID, text: "first" },
-      })
-      const exit = yield* events
-        .replay({
-          id: EventV2.ID.create(),
-          type: EventV2.versionedType(SyncMessage.type, 1),
-          seq: 5,
-          aggregateID,
-          data: { id: aggregateID, text: "bad" },
-        })
-        .pipe(Effect.exit)
-
-      expect(String(exit)).toContain("Sequence mismatch")
-    }),
-  )
-
-  it.effect("replay defects on unknown event type", () =>
-    Effect.gen(function* () {
-      const events = yield* EventV2.Service
-      const exit = yield* events
-        .replay({
-          id: EventV2.ID.create(),
-          type: "unknown.event.1",
-          seq: 0,
-          aggregateID: EventV2.ID.create(),
-          data: {},
-        })
-        .pipe(Effect.exit)
-
-      expect(String(exit)).toContain("Unknown sync event type")
-    }),
-  )
-
-  it.effect("replayAll validates contiguous aggregate events", () =>
-    Effect.gen(function* () {
-      const events = yield* EventV2.Service
-      const aggregateID = EventV2.ID.create()
-      const source = yield* events.replayAll([
-        {
-          id: EventV2.ID.create(),
-          type: EventV2.versionedType(SyncMessage.type, 1),
-          seq: 0,
-          aggregateID,
-          data: { id: aggregateID, text: "one" },
-        },
-        {
-          id: EventV2.ID.create(),
-          type: EventV2.versionedType(SyncMessage.type, 1),
-          seq: 1,
-          aggregateID,
-          data: { id: aggregateID, text: "two" },
-        },
-      ])
-
-      expect(source).toBe(aggregateID)
-    }),
-  )
-
-  it.effect("replayAll accepts later chunks after the first batch", () =>
-    Effect.gen(function* () {
-      const events = yield* EventV2.Service
-      const { db } = yield* Database.Service
-      const aggregateID = EventV2.ID.create()
-
-      const one = yield* events.replayAll([
-        {
-          id: EventV2.ID.create(),
-          type: EventV2.versionedType(SyncMessage.type, 1),
-          seq: 0,
-          aggregateID,
-          data: { id: aggregateID, text: "one" },
-        },
-        {
-          id: EventV2.ID.create(),
-          type: EventV2.versionedType(SyncMessage.type, 1),
-          seq: 1,
-          aggregateID,
-          data: { id: aggregateID, text: "two" },
-        },
-      ])
-      const two = yield* events.replayAll([
-        {
-          id: EventV2.ID.create(),
-          type: EventV2.versionedType(SyncMessage.type, 1),
-          seq: 2,
-          aggregateID,
-          data: { id: aggregateID, text: "three" },
-        },
-        {
-          id: EventV2.ID.create(),
-          type: EventV2.versionedType(SyncMessage.type, 1),
-          seq: 3,
-          aggregateID,
-          data: { id: aggregateID, text: "four" },
-        },
-      ])
-      const rows = yield* db
-        .select()
-        .from(EventTable)
-        .where(eq(EventTable.aggregate_id, aggregateID))
-        .all()
-        .pipe(Effect.orDie)
-
-      expect(one).toBe(aggregateID)
-      expect(two).toBe(aggregateID)
-      expect(rows.map((row) => row.seq)).toEqual([0, 1, 2, 3])
-    }),
-  )
-
-  it.effect("claim fences replay owners", () =>
-    Effect.gen(function* () {
-      const events = yield* EventV2.Service
-      const received = new Array<EventV2.Payload>()
-      const aggregateID = EventV2.ID.create()
-      yield* events.publish(SyncMessage, { id: aggregateID, text: "seed" })
-      yield* events.claim(aggregateID, "owner-a")
-      yield* events.project(SyncMessage, (event) =>
-        Effect.sync(() => {
-          received.push(event)
-        }),
-      )
-
-      yield* events.replay(
-        {
-          id: EventV2.ID.create(),
-          type: EventV2.versionedType(SyncMessage.type, 1),
-          seq: 1,
-          aggregateID,
-          data: { id: aggregateID, text: "ignored" },
-        },
-        { ownerID: "owner-b" },
-      )
-
-      expect(received).toHaveLength(0)
-    }),
-  )
-
-  it.effect("replay with owner claims an unowned sequence", () =>
-    Effect.gen(function* () {
-      const events = yield* EventV2.Service
-      const { db } = yield* Database.Service
-      const aggregateID = EventV2.ID.create()
-
-      yield* events.replay(
-        {
-          id: EventV2.ID.create(),
-          type: EventV2.versionedType(SyncMessage.type, 1),
-          seq: 0,
-          aggregateID,
-          data: { id: aggregateID, text: "owned" },
-        },
-        { ownerID: "owner-1" },
-      )
-      const row = yield* db
-        .select({ seq: EventSequenceTable.seq, ownerID: EventSequenceTable.owner_id })
-        .from(EventSequenceTable)
-        .where(eq(EventSequenceTable.aggregate_id, aggregateID))
-        .get()
-        .pipe(Effect.orDie)
-
-      expect(row).toEqual({ seq: 0, ownerID: "owner-1" })
-    }),
-  )
-
-  it.effect("replay from a different owner leaves claimed sequence unchanged", () =>
-    Effect.gen(function* () {
-      const events = yield* EventV2.Service
-      const { db } = yield* Database.Service
-      const aggregateID = EventV2.ID.create()
-
-      yield* events.replay(
-        {
-          id: EventV2.ID.create(),
-          type: EventV2.versionedType(SyncMessage.type, 1),
-          seq: 0,
-          aggregateID,
-          data: { id: aggregateID, text: "first" },
-        },
-        { ownerID: "owner-1" },
-      )
-      yield* events.replay(
-        {
-          id: EventV2.ID.create(),
-          type: EventV2.versionedType(SyncMessage.type, 1),
-          seq: 1,
-          aggregateID,
-          data: { id: aggregateID, text: "ignored" },
-        },
-        { ownerID: "owner-2" },
-      )
-      const rows = yield* db
-        .select()
-        .from(EventTable)
-        .where(eq(EventTable.aggregate_id, aggregateID))
-        .all()
-        .pipe(Effect.orDie)
-      const sequence = yield* db
-        .select({ seq: EventSequenceTable.seq, ownerID: EventSequenceTable.owner_id })
-        .from(EventSequenceTable)
-        .where(eq(EventSequenceTable.aggregate_id, aggregateID))
-        .get()
-        .pipe(Effect.orDie)
-
-      expect(rows).toHaveLength(1)
-      expect(sequence).toEqual({ seq: 0, ownerID: "owner-1" })
-    }),
-  )
-
-  it.effect("claim updates the event sequence owner", () =>
-    Effect.gen(function* () {
-      const events = yield* EventV2.Service
-      const { db } = yield* Database.Service
-      const aggregateID = EventV2.ID.create()
-
-      yield* events.publish(SyncMessage, { id: aggregateID, text: "claimed" })
-      yield* events.claim(aggregateID, "owner-1")
-      yield* events.claim(aggregateID, "owner-2")
-      const row = yield* db
-        .select({ seq: EventSequenceTable.seq, ownerID: EventSequenceTable.owner_id })
-        .from(EventSequenceTable)
-        .where(eq(EventSequenceTable.aggregate_id, aggregateID))
-        .get()
-        .pipe(Effect.orDie)
-
-      expect(row).toEqual({ seq: 0, ownerID: "owner-2" })
-    }),
-  )
-
-  it.effect("remove clears sync event sequence", () =>
-    Effect.gen(function* () {
-      const events = yield* EventV2.Service
-      const received = new Array<EventV2.Payload>()
-      const aggregateID = EventV2.ID.create()
-      yield* events.publish(SyncMessage, { id: aggregateID, text: "seed" })
-      yield* events.remove(aggregateID)
-      yield* events.project(SyncMessage, (event) =>
-        Effect.sync(() => {
-          received.push(event)
-        }),
-      )
-
-      yield* events.replay({
-        id: EventV2.ID.create(),
-        type: EventV2.versionedType(SyncMessage.type, 1),
-        seq: 0,
-        aggregateID,
-        data: { id: aggregateID, text: "replayed" },
-      })
-
-      expect(received[0]?.data).toEqual({ id: aggregateID, text: "replayed" })
+      expect(received).toEqual([Message.type, "stream"])
    }),
  )
 })
@@ -1,72 +0,0 @@
-import fs from "fs/promises"
-import path from "path"
-import { describe, expect } from "bun:test"
-import { Effect, Layer } from "effect"
-import { Catalog } from "@opencode-ai/core/catalog"
-import { LocationServiceMap } from "@opencode-ai/core/location-layer"
-import { PluginBoot } from "@opencode-ai/core/plugin/boot"
-import { ProviderV2 } from "@opencode-ai/core/provider"
-import { AbsolutePath } from "@opencode-ai/core/schema"
-import { tmpdir } from "./fixture/tmpdir"
-import { testEffect } from "./lib/effect"
-import { AppFileSystem } from "../src/filesystem"
-import { Auth } from "../src/auth"
-import { EventV2 } from "../src/event"
-import { Global } from "../src/global"
-import { ModelsDev } from "../src/models-dev"
-import { Npm } from "../src/npm"
-import { Project } from "../src/project"
-
-const it = testEffect(
-  LocationServiceMap.layer.pipe(
-    Layer.provide(
-      Layer.mergeAll(
-        Project.defaultLayer,
-        EventV2.defaultLayer,
-        Auth.defaultLayer,
-        Npm.defaultLayer,
-        ModelsDev.defaultLayer,
-        AppFileSystem.defaultLayer,
-        Global.defaultLayer,
-      ),
-    ),
-  ),
-)
-
-describe("LocationServiceMap", () => {
-  it.live("isolates location state while sharing location policy with catalog", () =>
-    Effect.acquireRelease(
-      Effect.promise(() => Promise.all([tmpdir(), tmpdir()])),
-      (dirs) => Effect.promise(() => Promise.all(dirs.map((dir) => dir[Symbol.asyncDispose]())).then(() => undefined)),
-    ).pipe(
-      Effect.flatMap(([blocked, allowed]) =>
-        Effect.gen(function* () {
-          yield* Effect.promise(() =>
-            fs.writeFile(
-              path.join(blocked.path, "opencode.json"),
-              JSON.stringify({
-                experimental: { policies: [{ effect: "deny", action: "provider.use", resource: "test" }] },
-              }),
-            ),
-          )
-
-          const update = (directory: string) =>
-            Effect.gen(function* () {
-              yield* PluginBoot.Service.use((boot) => boot.wait())
-              const catalog = yield* Catalog.Service
-              const transform = yield* catalog.transform()
-              yield* transform((editor) => editor.provider.update(ProviderV2.ID.make("test"), () => {}))
-              return yield* catalog.provider.all()
-            }).pipe(Effect.scoped, Effect.provide(LocationServiceMap.get({ directory: AbsolutePath.make(directory) })))
-
-          expect((yield* update(blocked.path)).some((provider) => provider.id === ProviderV2.ID.make("test"))).toBe(
-            false,
-          )
-          expect((yield* update(allowed.path)).some((provider) => provider.id === ProviderV2.ID.make("test"))).toBe(
-            true,
-          )
-        }),
-      ),
-    ),
-  )
-})
@@ -1,10 +1,11 @@
 import { describe, expect } from "bun:test"
 import { Effect, Layer } from "effect"
-import { Auth } from "@opencode-ai/core/auth"
+import { AccountV2 } from "@opencode-ai/core/account"
 import { Catalog } from "@opencode-ai/core/catalog"
 import { EventV2 } from "@opencode-ai/core/event"
 import { Location } from "@opencode-ai/core/location"
 import { PluginV2 } from "@opencode-ai/core/plugin"
+import { Policy } from "@opencode-ai/core/policy"
 import { AccountPlugin } from "@opencode-ai/core/plugin/account"
 import { AzurePlugin } from "@opencode-ai/core/plugin/provider/azure"
 import { ProviderV2 } from "@opencode-ai/core/provider"
@@ -14,9 +15,11 @@ import { testEffect } from "../lib/effect"
 import { fakeSelectorSdk, it, model, npmLayer, provider, withEnv } from "./provider-helper"

 const itWithAccount = testEffect(
-  Catalog.locationLayer.pipe(
-    Layer.provideMerge(Auth.defaultLayer),
+  Catalog.layer.pipe(
+    Layer.provideMerge(PluginV2.defaultLayer),
+    Layer.provideMerge(AccountV2.defaultLayer),
    Layer.provideMerge(EventV2.defaultLayer),
+    Layer.provide(Policy.defaultLayer),
    Layer.provideMerge(
      Layer.succeed(Location.Service, Location.Service.of(location({ directory: AbsolutePath.make("test") }))),
    ),
@@ -76,12 +79,12 @@ describe("AzurePlugin", () => {
      () =>
        Effect.gen(function* () {
          const plugin = yield* PluginV2.Service
-          const accounts = yield* Auth.Service
+          const accounts = yield* AccountV2.Service
          const catalog = yield* Catalog.Service
          const events = yield* EventV2.Service
          yield* accounts.create({
-            serviceID: Auth.ServiceID.make("azure"),
-            credential: new Auth.ApiKeyCredential({
+            serviceID: AccountV2.ServiceID.make("azure"),
+            credential: new AccountV2.ApiKeyCredential({
              type: "api",
              key: "key",
              metadata: { resourceName: "from-account" },
@@ -90,7 +93,7 @@ describe("AzurePlugin", () => {
          yield* plugin.add({
            ...AccountPlugin,
            effect: AccountPlugin.effect.pipe(
-              Effect.provideService(Auth.Service, accounts),
+              Effect.provideService(AccountV2.Service, accounts),
              Effect.provideService(Catalog.Service, catalog),
              Effect.provideService(EventV2.Service, events),
              Effect.provideService(PluginV2.Service, plugin),
@@ -1,11 +1,12 @@
 import { describe, expect } from "bun:test"
 import { Effect, Layer } from "effect"
-import { Auth } from "@opencode-ai/core/auth"
+import { AccountV2 } from "@opencode-ai/core/account"
 import { Catalog } from "@opencode-ai/core/catalog"
 import { Location } from "@opencode-ai/core/location"
 import { EventV2 } from "@opencode-ai/core/event"
 import { ModelV2 } from "@opencode-ai/core/model"
 import { PluginV2 } from "@opencode-ai/core/plugin"
+import { Policy } from "@opencode-ai/core/policy"
 import { AccountPlugin } from "@opencode-ai/core/plugin/account"
 import { CloudflareWorkersAIPlugin } from "@opencode-ai/core/plugin/provider/cloudflare-workers-ai"
 import { ProviderV2 } from "@opencode-ai/core/provider"
@@ -15,9 +16,11 @@ import { testEffect } from "../lib/effect"
 import { fakeSelectorSdk, it, model, npmLayer, withEnv } from "./provider-helper"

 const itWithAccount = testEffect(
-  Catalog.locationLayer.pipe(
-    Layer.provideMerge(Auth.defaultLayer),
+  Catalog.layer.pipe(
+    Layer.provideMerge(PluginV2.defaultLayer),
+    Layer.provideMerge(AccountV2.defaultLayer),
    Layer.provideMerge(EventV2.defaultLayer),
+    Layer.provide(Policy.defaultLayer),
    Layer.provideMerge(
      Layer.succeed(Location.Service, Location.Service.of(location({ directory: AbsolutePath.make("test") }))),
    ),
@@ -128,12 +131,12 @@ describe("CloudflareWorkersAIPlugin", () => {
      () =>
        Effect.gen(function* () {
          const plugin = yield* PluginV2.Service
-          const accounts = yield* Auth.Service
+          const accounts = yield* AccountV2.Service
          const catalog = yield* Catalog.Service
          const events = yield* EventV2.Service
          yield* accounts.create({
-            serviceID: Auth.ServiceID.make("cloudflare-workers-ai"),
-            credential: new Auth.ApiKeyCredential({
+            serviceID: AccountV2.ServiceID.make("cloudflare-workers-ai"),
+            credential: new AccountV2.ApiKeyCredential({
              type: "api",
              key: "account-key",
              metadata: { accountId: "account-acct" },
@@ -142,7 +145,7 @@ describe("CloudflareWorkersAIPlugin", () => {
          yield* plugin.add({
            ...AccountPlugin,
            effect: AccountPlugin.effect.pipe(
-              Effect.provideService(Auth.Service, accounts),
+              Effect.provideService(AccountV2.Service, accounts),
              Effect.provideService(Catalog.Service, catalog),
              Effect.provideService(EventV2.Service, events),
              Effect.provideService(PluginV2.Service, plugin),
@@ -1,15 +1,12 @@
 import { describe, expect, mock } from "bun:test"
 import { Effect, Layer } from "effect"
 import { AISDK } from "@opencode-ai/core/aisdk"
-import { EventV2 } from "@opencode-ai/core/event"
 import { PluginV2 } from "@opencode-ai/core/plugin"
 import { DeepInfraPlugin } from "@opencode-ai/core/plugin/provider/deepinfra"
 import { testEffect } from "../lib/effect"
 import { it, model } from "./provider-helper"

-const itAISDK = testEffect(
-  Layer.provideMerge(AISDK.layer, PluginV2.locationLayer.pipe(Layer.provide(EventV2.defaultLayer))),
-)
+const itAISDK = testEffect(Layer.provideMerge(AISDK.layer, PluginV2.defaultLayer))
 const deepinfraOptions: Record<string, any>[] = []
 const deepinfraLanguageModels: string[] = []

@@ -6,7 +6,6 @@ import os from "os"
 import path from "path"
 import { fileURLToPath } from "url"
 import { AISDK } from "@opencode-ai/core/aisdk"
-import { EventV2 } from "@opencode-ai/core/event"
 import { ModelV2 } from "@opencode-ai/core/model"
 import { PluginV2 } from "@opencode-ai/core/plugin"
 import { DynamicProviderPlugin } from "@opencode-ai/core/plugin/provider/dynamic"
@@ -14,9 +13,7 @@ import { testEffect } from "../lib/effect"
 import { fixtureProvider, it, model, npmLayer } from "./provider-helper"

 const fixtureProviderPath = fileURLToPath(fixtureProvider)
-const itWithAISDK = testEffect(
-  AISDK.layer.pipe(Layer.provideMerge(PluginV2.locationLayer.pipe(Layer.provide(EventV2.defaultLayer)))),
-)
+const itWithAISDK = testEffect(AISDK.layer.pipe(Layer.provideMerge(PluginV2.defaultLayer)))

 function npmEntrypointLayer(entrypoint: Option.Option<string>) {
  return Layer.succeed(
@@ -1,15 +1,15 @@
 import { describe, expect, mock } from "bun:test"
 import { Effect, Layer } from "effect"
-import { Auth } from "@opencode-ai/core/auth"
+import { AccountV2 } from "@opencode-ai/core/account"
 import { Catalog } from "@opencode-ai/core/catalog"
 import { EventV2 } from "@opencode-ai/core/event"
 import { Location } from "@opencode-ai/core/location"
 import { PluginV2 } from "@opencode-ai/core/plugin"
+import { Policy } from "@opencode-ai/core/policy"
 import { AccountPlugin } from "@opencode-ai/core/plugin/account"
 import { GitLabPlugin } from "@opencode-ai/core/plugin/provider/gitlab"
 import { ProviderV2 } from "@opencode-ai/core/provider"
 import { AbsolutePath } from "@opencode-ai/core/schema"
-import { location } from "../fixture/location"
 import { testEffect } from "../lib/effect"
 import { it, model, npmLayer, withEnv } from "./provider-helper"

@@ -29,13 +29,15 @@ void mock.module("gitlab-ai-provider", () => ({
 }))

 const itWithAccount = testEffect(
-  Catalog.locationLayer.pipe(
-    Layer.provideMerge(Auth.defaultLayer),
-    Layer.provideMerge(EventV2.defaultLayer),
-    Layer.provideMerge(
-      Layer.succeed(Location.Service, Location.Service.of(location({ directory: AbsolutePath.make("/") }))),
-    ),
-    Layer.provideMerge(npmLayer),
+  Layer.mergeAll(
+    Catalog.defaultLayer,
+    PluginV2.defaultLayer,
+    AccountV2.defaultLayer,
+    EventV2.defaultLayer,
+    npmLayer,
+  ).pipe(
+    Layer.provide(Policy.defaultLayer),
+    Layer.provide(Location.defaultLayer({ directory: AbsolutePath.make("/") })),
  ),
 )

@@ -165,17 +167,17 @@ describe("GitLabPlugin", () => {
        Effect.gen(function* () {
          gitlabSDKOptions.length = 0
          const plugin = yield* PluginV2.Service
-          const accounts = yield* Auth.Service
+          const accounts = yield* AccountV2.Service
          const catalog = yield* Catalog.Service
          const events = yield* EventV2.Service
          yield* accounts.create({
-            serviceID: Auth.ServiceID.make("gitlab"),
-            credential: new Auth.ApiKeyCredential({ type: "api", key: "account-token" }),
+            serviceID: AccountV2.ServiceID.make("gitlab"),
+            credential: new AccountV2.ApiKeyCredential({ type: "api", key: "account-token" }),
          })
          yield* plugin.add({
            ...AccountPlugin,
            effect: AccountPlugin.effect.pipe(
-              Effect.provideService(Auth.Service, accounts),
+              Effect.provideService(AccountV2.Service, accounts),
              Effect.provideService(Catalog.Service, catalog),
              Effect.provideService(EventV2.Service, events),
              Effect.provideService(PluginV2.Service, plugin),
@@ -208,12 +210,12 @@ describe("GitLabPlugin", () => {
        Effect.gen(function* () {
          gitlabSDKOptions.length = 0
          const plugin = yield* PluginV2.Service
-          const accounts = yield* Auth.Service
+          const accounts = yield* AccountV2.Service
          const catalog = yield* Catalog.Service
          const events = yield* EventV2.Service
          yield* accounts.create({
-            serviceID: Auth.ServiceID.make("gitlab"),
-            credential: new Auth.OAuthCredential({
+            serviceID: AccountV2.ServiceID.make("gitlab"),
+            credential: new AccountV2.OAuthCredential({
              type: "oauth",
              refresh: "refresh-token",
              access: "account-oauth-token",
@@ -223,7 +225,7 @@ describe("GitLabPlugin", () => {
          yield* plugin.add({
            ...AccountPlugin,
            effect: AccountPlugin.effect.pipe(
-              Effect.provideService(Auth.Service, accounts),
+              Effect.provideService(AccountV2.Service, accounts),
              Effect.provideService(Catalog.Service, catalog),
              Effect.provideService(EventV2.Service, events),
              Effect.provideService(PluginV2.Service, plugin),
@@ -1,16 +1,13 @@
 import { describe, expect } from "bun:test"
 import { Effect, Layer } from "effect"
 import { AISDK } from "@opencode-ai/core/aisdk"
-import { EventV2 } from "@opencode-ai/core/event"
 import { ModelV2 } from "@opencode-ai/core/model"
 import { PluginV2 } from "@opencode-ai/core/plugin"
 import { GooglePlugin } from "@opencode-ai/core/plugin/provider/google"
 import { testEffect } from "../lib/effect"
 import { it, model } from "./provider-helper"

-const itWithAISDK = testEffect(
-  AISDK.layer.pipe(Layer.provideMerge(PluginV2.locationLayer.pipe(Layer.provide(EventV2.defaultLayer)))),
-)
+const itWithAISDK = testEffect(AISDK.layer.pipe(Layer.provideMerge(PluginV2.defaultLayer)))

 describe("GooglePlugin", () => {
  it.effect("creates a Google Generative AI SDK for @ai-sdk/google using the provider ID as SDK name", () =>
@@ -2,16 +2,13 @@ import { describe, expect } from "bun:test"
 import { createGroq } from "@ai-sdk/groq"
 import { Effect, Layer } from "effect"
 import { AISDK } from "@opencode-ai/core/aisdk"
-import { EventV2 } from "@opencode-ai/core/event"
 import { ModelV2 } from "@opencode-ai/core/model"
 import { PluginV2 } from "@opencode-ai/core/plugin"
 import { GroqPlugin } from "@opencode-ai/core/plugin/provider/groq"
 import { it, model } from "./provider-helper"
 import { testEffect } from "../lib/effect"

-const aisdkIt = testEffect(
-  AISDK.layer.pipe(Layer.provideMerge(PluginV2.locationLayer.pipe(Layer.provide(EventV2.defaultLayer)))),
-)
+const aisdkIt = testEffect(AISDK.layer.pipe(Layer.provideMerge(PluginV2.defaultLayer)))

 describe("GroqPlugin", () => {
  it.effect("creates a Groq SDK for @ai-sdk/groq", () =>
@@ -7,6 +7,7 @@ import { EventV2 } from "@opencode-ai/core/event"
 import { Location } from "@opencode-ai/core/location"
 import { ModelV2 } from "@opencode-ai/core/model"
 import { PluginV2 } from "@opencode-ai/core/plugin"
+import { Policy } from "@opencode-ai/core/policy"
 import { ProviderV2 } from "@opencode-ai/core/provider"
 import { AbsolutePath } from "@opencode-ai/core/schema"
 import { location } from "../fixture/location"
@@ -47,8 +48,10 @@ export const catalogLayer = Layer.succeed(
 )

 export const it = testEffect(
-  Catalog.locationLayer.pipe(
+  Catalog.layer.pipe(
+    Layer.provideMerge(PluginV2.defaultLayer),
    Layer.provideMerge(EventV2.defaultLayer),
+    Layer.provide(Policy.defaultLayer),
    Layer.provideMerge(locationLayer),
    Layer.provideMerge(npmLayer),
  ),
@@ -1,11 +1,11 @@
 import { describe, expect } from "bun:test"
 import { DateTime, Effect, Layer, Option } from "effect"
 import { Catalog } from "@opencode-ai/core/catalog"
-import { EventV2 } from "@opencode-ai/core/event"
 import { Location } from "@opencode-ai/core/location"
 import { ModelV2 } from "@opencode-ai/core/model"
 import { PluginV2 } from "@opencode-ai/core/plugin"
 import { OpencodePlugin } from "@opencode-ai/core/plugin/provider/opencode"
+import { Policy } from "@opencode-ai/core/policy"
 import { ProviderV2 } from "@opencode-ai/core/provider"
 import { AbsolutePath } from "@opencode-ai/core/schema"
 import { location } from "../fixture/location"
@@ -227,7 +227,7 @@ describe("OpencodePlugin", () => {

      expect(Option.getOrUndefined(selected)?.id).toBe(ModelV2.ID.make("gpt-5-nano"))
    }).pipe(
-      Effect.provide(Catalog.locationLayer.pipe(Layer.provide(EventV2.defaultLayer), Layer.provide(locationLayer))),
+      Effect.provide(Catalog.defaultLayer.pipe(Layer.provide(Policy.defaultLayer), Layer.provide(locationLayer))),
    ),
  )
 })
@@ -1,6 +1,5 @@
 import { describe, expect } from "bun:test"
-import { Effect, Layer } from "effect"
-import { EventV2 } from "@opencode-ai/core/event"
+import { Effect } from "effect"
 import { ModelV2 } from "@opencode-ai/core/model"
 import { PluginV2 } from "@opencode-ai/core/plugin"
 import { XAIPlugin } from "@opencode-ai/core/plugin/provider/xai"
@@ -8,7 +7,7 @@ import { ProviderV2 } from "@opencode-ai/core/provider"
 import { testEffect } from "../lib/effect"
 import { fakeSelectorSdk } from "./provider-helper"

-const it = testEffect(PluginV2.locationLayer.pipe(Layer.provide(EventV2.defaultLayer)))
+const it = testEffect(PluginV2.defaultLayer)

 const model = new ModelV2.Info({
  ...ModelV2.Info.empty(ProviderV2.ID.make("xai"), ModelV2.ID.make("grok-4")),
@@ -7,7 +7,7 @@ import { location } from "./fixture/location"
 import { testEffect } from "./lib/effect"

 const it = testEffect(
-  Policy.locationLayer.pipe(
+  Policy.defaultLayer.pipe(
    Layer.provide(
      Layer.succeed(Location.Service, Location.Service.of(location({ directory: AbsolutePath.make("test") }))),
    ),
@@ -3,16 +3,16 @@ import { $ } from "bun"
 import fs from "fs/promises"
 import path from "path"
 import { Effect } from "effect"
-import { ProjectV2 } from "@opencode-ai/core/project"
+import { Project } from "@opencode-ai/core/project"
 import { AbsolutePath } from "@opencode-ai/core/schema"
 import { Hash } from "@opencode-ai/core/util/hash"
 import { tmpdir } from "./fixture/tmpdir"
 import { testEffect } from "./lib/effect"

-const it = testEffect(ProjectV2.defaultLayer)
+const it = testEffect(Project.defaultLayer)

 function remoteID(remote: string) {
-  return ProjectV2.ID.make(Hash.fast(`git-remote:${remote}`))
+  return Project.ID.make(Hash.fast(`git-remote:${remote}`))
 }

 function abs(value: string) {
@@ -44,11 +44,11 @@ describe("ProjectV2.resolve", () => {
        Effect.promise(() => tmpdir()),
        (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
      )
-      const project = yield* ProjectV2.Service
+      const project = yield* Project.Service

      const result = yield* project.resolve(abs(tmp.path))

-      expect(result.id).toBe(ProjectV2.ID.make("global"))
+      expect(result.id).toBe(Project.ID.make("global"))
      expect(path.resolve(result.directory)).toBe(path.parse(tmp.path).root)
      expect(result.previous).toBeUndefined()
      expect(result.vcs).toBeUndefined()
@@ -62,11 +62,11 @@ describe("ProjectV2.resolve", () => {
        (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
      )
      yield* Effect.promise(() => initRepo(tmp.path))
-      const project = yield* ProjectV2.Service
+      const project = yield* Project.Service

      const result = yield* project.resolve(abs(tmp.path))

-      expect(result.id).toBe(ProjectV2.ID.make("global"))
+      expect(result.id).toBe(Project.ID.make("global"))
      expect(result.directory).toBe(yield* real(tmp.path))
      expect(result.previous).toBeUndefined()
      expect(result.vcs?.type).toBe("git")
@@ -80,11 +80,11 @@ describe("ProjectV2.resolve", () => {
        (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
      )
      yield* Effect.promise(() => initRepo(tmp.path, { commit: true }))
-      const project = yield* ProjectV2.Service
+      const project = yield* Project.Service

      const result = yield* project.resolve(abs(tmp.path))

-      expect(result.id).toBe(ProjectV2.ID.make(yield* Effect.promise(() => rootCommit(tmp.path))))
+      expect(result.id).toBe(Project.ID.make(yield* Effect.promise(() => rootCommit(tmp.path))))
      expect(result.directory).toBe(yield* real(tmp.path))
      expect(result.previous).toBeUndefined()
      expect(result.vcs?.type).toBe("git")
@@ -98,12 +98,12 @@ describe("ProjectV2.resolve", () => {
        (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
      )
      yield* Effect.promise(() => initRepo(tmp.path, { commit: true, remote: "git@github.com:Acme/App.git" }))
-      const project = yield* ProjectV2.Service
+      const project = yield* Project.Service

      const result = yield* project.resolve(abs(tmp.path))

      expect(result.id).toBe(remoteID("github.com/Acme/App"))
-      expect(result.id).not.toBe(ProjectV2.ID.make(yield* Effect.promise(() => rootCommit(tmp.path))))
+      expect(result.id).not.toBe(Project.ID.make(yield* Effect.promise(() => rootCommit(tmp.path))))
      expect(result.directory).toBe(yield* real(tmp.path))
      expect(result.vcs?.type).toBe("git")
    }),
@@ -121,7 +121,7 @@ describe("ProjectV2.resolve", () => {
      )
      yield* Effect.promise(() => initRepo(ssh.path, { commit: true, remote: "git@github.com:owner/repo.git" }))
      yield* Effect.promise(() => initRepo(https.path, { commit: true, remote: "https://github.com/owner/repo.git" }))
-      const project = yield* ProjectV2.Service
+      const project = yield* Project.Service

      const a = yield* project.resolve(abs(ssh.path))
      const b = yield* project.resolve(abs(https.path))
@@ -138,11 +138,11 @@ describe("ProjectV2.resolve", () => {
        (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
      )
      yield* Effect.promise(() => initRepo(tmp.path, { commit: true, remote: `file://${tmp.path}` }))
-      const project = yield* ProjectV2.Service
+      const project = yield* Project.Service

      const result = yield* project.resolve(abs(tmp.path))

-      expect(result.id).toBe(ProjectV2.ID.make(yield* Effect.promise(() => rootCommit(tmp.path))))
+      expect(result.id).toBe(Project.ID.make(yield* Effect.promise(() => rootCommit(tmp.path))))
    }),
  )

@@ -154,11 +154,11 @@ describe("ProjectV2.resolve", () => {
      )
      yield* Effect.promise(() => initRepo(tmp.path, { commit: true, remote: "git@github.com:owner/repo.git" }))
      yield* Effect.promise(() => Bun.write(path.join(tmp.path, ".git", "opencode"), "old-id"))
-      const project = yield* ProjectV2.Service
+      const project = yield* Project.Service

      const result = yield* project.resolve(abs(tmp.path))

-      expect(result.previous).toBe(ProjectV2.ID.make("old-id"))
+      expect(result.previous).toBe(Project.ID.make("old-id"))
      expect(result.id).toBe(remoteID("github.com/owner/repo"))
    }),
  )
@@ -170,7 +170,7 @@ describe("ProjectV2.resolve", () => {
        (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
      )
      yield* Effect.promise(() => initRepo(tmp.path, { commit: true, remote: "git@github.com:owner/repo.git" }))
-      const project = yield* ProjectV2.Service
+      const project = yield* Project.Service

      yield* project.resolve(abs(tmp.path))

@@ -186,7 +186,7 @@ describe("ProjectV2.resolve", () => {
      )
      yield* Effect.promise(() => initRepo(tmp.path, { commit: true }))
      yield* Effect.promise(() => fs.mkdir(path.join(tmp.path, "a", "b"), { recursive: true }))
-      const project = yield* ProjectV2.Service
+      const project = yield* Project.Service

      const result = yield* project.resolve(abs(path.join(tmp.path, "a", "b")))

@@ -207,12 +207,12 @@ describe("ProjectV2.resolve", () => {
      yield* Effect.promise(() => initRepo(tmp.path, { commit: true, remote: "git@github.com:owner/repo.git" }))
      yield* Effect.promise(() => Bun.write(path.join(tmp.path, ".git", "opencode"), "old-id"))
      yield* Effect.promise(() => $`git worktree add ${worktree} -b test-${Date.now()}`.cwd(tmp.path).quiet())
-      const project = yield* ProjectV2.Service
+      const project = yield* Project.Service

      const result = yield* project.resolve(abs(worktree))

      expect(result.directory).toBe(yield* real(worktree))
-      expect(result.previous).toBe(ProjectV2.ID.make("old-id"))
+      expect(result.previous).toBe(Project.ID.make("old-id"))
      expect(result.id).toBe(remoteID("github.com/owner/repo"))
      expect(result.vcs?.type).toBe("git")
    }),
@@ -1,22 +0,0 @@
-{
-  "$schema": "https://json.schemastore.org/package.json",
-  "version": "1.15.10",
-  "name": "@opencode-ai/effect-sqlite-node",
-  "type": "module",
-  "license": "MIT",
-  "private": true,
-  "scripts": {
-    "typecheck": "tsgo --noEmit"
-  },
-  "exports": {
-    ".": "./src/index.ts"
-  },
-  "devDependencies": {
-    "@tsconfig/bun": "catalog:",
-    "@types/node": "catalog:",
-    "@typescript/native-preview": "catalog:"
-  },
-  "dependencies": {
-    "effect": "catalog:"
-  }
-}
@@ -1,168 +0,0 @@
-export * as NodeSqliteClient from "./index"
-
-import { DatabaseSync, type SQLInputValue } from "node:sqlite"
-import { identity } from "effect/Function"
-import * as Context from "effect/Context"
-import * as Effect from "effect/Effect"
-import * as Fiber from "effect/Fiber"
-import * as Layer from "effect/Layer"
-import * as Scope from "effect/Scope"
-import * as Semaphore from "effect/Semaphore"
-import * as Stream from "effect/Stream"
-import * as Reactivity from "effect/unstable/reactivity/Reactivity"
-import * as Client from "effect/unstable/sql/SqlClient"
-import type { Connection } from "effect/unstable/sql/SqlConnection"
-import { classifySqliteError, SqlError } from "effect/unstable/sql/SqlError"
-import * as Statement from "effect/unstable/sql/Statement"
-
-const ATTR_DB_SYSTEM_NAME = "db.system.name"
-
-export const TypeId: TypeId = "~@opencode-ai/effect-sqlite-node/NodeSqliteClient"
-export type TypeId = "~@opencode-ai/effect-sqlite-node/NodeSqliteClient"
-
-export interface SqliteClient extends Client.SqlClient {
-  readonly [TypeId]: TypeId
-  readonly config: SqliteClientConfig
-  readonly loadExtension: (path: string) => Effect.Effect<void, SqlError>
-  readonly updateValues: never
-}
-
-export const SqliteClient = Context.Service<SqliteClient>("@opencode-ai/effect-sqlite-node/NodeSqliteClient")
-
-export interface SqliteClientConfig {
-  readonly filename: string
-  readonly readonly?: boolean | undefined
-  readonly create?: boolean | undefined
-  readonly readwrite?: boolean | undefined
-  readonly disableWAL?: boolean | undefined
-  readonly timeout?: number | undefined
-  readonly allowExtension?: boolean | undefined
-  readonly spanAttributes?: Record<string, unknown> | undefined
-  readonly transformResultNames?: ((str: string) => string) | undefined
-  readonly transformQueryNames?: ((str: string) => string) | undefined
-}
-
-interface SqliteConnection extends Connection {
-  readonly loadExtension: (path: string) => Effect.Effect<void, SqlError>
-}
-
-export const make = (
-  options: SqliteClientConfig,
-): Effect.Effect<SqliteClient, never, Scope.Scope | Reactivity.Reactivity> =>
-  Effect.gen(function* () {
-    const compiler = Statement.makeCompilerSqlite(options.transformQueryNames)
-    const transformRows = options.transformResultNames
-      ? Statement.defaultTransforms(options.transformResultNames).array
-      : undefined
-
-    const makeConnection = Effect.gen(function* () {
-      const db = new DatabaseSync(options.filename, {
-        readOnly: options.readonly,
-        timeout: options.timeout,
-        allowExtension: options.allowExtension,
-        enableForeignKeyConstraints: true,
-        open: true,
-      })
-      yield* Effect.addFinalizer(() => Effect.sync(() => db.close()))
-
-      if (options.disableWAL !== true && options.readonly !== true) {
-        db.exec("PRAGMA journal_mode = WAL;")
-      }
-
-      const run = (sql: string, params: ReadonlyArray<unknown> = []) =>
-        Effect.withFiber<Array<Record<string, unknown>>, SqlError>((fiber) => {
-          const statement = db.prepare(sql)
-          statement.setReadBigInts(Context.get(fiber.context, Client.SafeIntegers))
-          try {
-            return Effect.succeed(statement.all(...(params as SQLInputValue[])) as Array<Record<string, unknown>>)
-          } catch (cause) {
-            return Effect.fail(
-              new SqlError({
-                reason: classifySqliteError(cause, { message: "Failed to execute statement", operation: "execute" }),
-              }),
-            )
-          }
-        })
-
-      const runValues = (sql: string, params: ReadonlyArray<unknown> = []) =>
-        Effect.withFiber<ReadonlyArray<ReadonlyArray<unknown>>, SqlError>((fiber) => {
-          const statement = db.prepare(sql)
-          statement.setReadBigInts(Context.get(fiber.context, Client.SafeIntegers))
-          statement.setReturnArrays(true)
-          try {
-            return Effect.succeed(
-              statement.all(...(params as SQLInputValue[])) as unknown as ReadonlyArray<ReadonlyArray<unknown>>,
-            )
-          } catch (cause) {
-            return Effect.fail(
-              new SqlError({
-                reason: classifySqliteError(cause, { message: "Failed to execute statement", operation: "execute" }),
-              }),
-            )
-          }
-        })
-
-      return identity<SqliteConnection>({
-        execute(sql, params, transformRows) {
-          return transformRows ? Effect.map(run(sql, params), transformRows) : run(sql, params)
-        },
-        executeRaw(sql, params) {
-          return run(sql, params)
-        },
-        executeValues(sql, params) {
-          return runValues(sql, params)
-        },
-        executeUnprepared(sql, params, transformRows) {
-          return this.execute(sql, params, transformRows)
-        },
-        executeStream() {
-          return Stream.die("executeStream not implemented")
-        },
-        loadExtension: (path) =>
-          Effect.try({
-            try: () => db.loadExtension(path),
-            catch: (cause) =>
-              new SqlError({
-                reason: classifySqliteError(cause, { message: "Failed to load extension", operation: "loadExtension" }),
-              }),
-          }),
-      })
-    })
-
-    const semaphore = yield* Semaphore.make(1)
-    const connection = yield* makeConnection
-    const acquirer = semaphore.withPermits(1)(Effect.succeed(connection))
-    const transactionAcquirer = Effect.uninterruptibleMask((restore) => {
-      const fiber = Fiber.getCurrent()!
-      const scope = Context.getUnsafe(fiber.context, Scope.Scope)
-      return Effect.as(
-        Effect.tap(restore(semaphore.take(1)), () => Scope.addFinalizer(scope, semaphore.release(1))),
-        connection,
-      )
-    })
-
-    return Object.assign(
-      (yield* Client.make({
-        acquirer,
-        compiler,
-        transactionAcquirer,
-        spanAttributes: [
-          ...(options.spanAttributes ? Object.entries(options.spanAttributes) : []),
-          [ATTR_DB_SYSTEM_NAME, "sqlite"],
-        ],
-        transformRows,
-      })) as SqliteClient,
-      {
-        [TypeId]: TypeId as TypeId,
-        config: options,
-        loadExtension: (path: string) => Effect.flatMap(acquirer, (_) => _.loadExtension(path)),
-      },
-    )
-  })
-
-export const layer = (config: SqliteClientConfig): Layer.Layer<SqliteClient | Client.SqlClient> =>
-  Layer.effectContext(
-    Effect.map(make(config), (client) =>
-      Context.make(SqliteClient, client).pipe(Context.add(Client.SqlClient, client)),
-    ),
-  ).pipe(Layer.provide(Reactivity.layer))
@@ -1,15 +0,0 @@
-{
-  "$schema": "https://json.schemastore.org/tsconfig",
-  "extends": "@tsconfig/bun/tsconfig.json",
-  "compilerOptions": {
-    "lib": ["ESNext", "DOM", "DOM.Iterable"],
-    "noUncheckedIndexedAccess": false,
-    "plugins": [
-      {
-        "name": "@effect/language-service",
-        "transform": "@effect/language-service/transform",
-        "namespaceImportPackages": ["effect", "@effect/*"]
-      }
-    ]
-  }
-}
@@ -320,9 +320,7 @@ const lowerToolResultOutput = Effect.fn("OpenAIResponses.lowerToolResultOutput")
  // Text/json/error results are encoded as a plain string for backward
  // compatibility with existing cassettes and provider expectations.
  if (part.result.type !== "content") return ProviderShared.toolResultText(part)
-  // Preserve the narrowed array element type when compiled through a consumer package.
-  const content: ReadonlyArray<ToolResultContentPart> = part.result.value
-  return yield* Effect.forEach(content, lowerToolResultContentItem)
+  return yield* Effect.forEach(part.result.value, lowerToolResultContentItem)
 })

 const lowerMessages = Effect.fn("OpenAIResponses.lowerMessages")(function* (request: LLMRequest) {
@@ -429,7 +427,6 @@ const lowerOptions = Effect.fn("OpenAIResponses.lowerOptions")(function* (reques

 const fromRequest = Effect.fn("OpenAIResponses.fromRequest")(function* (request: LLMRequest) {
  const generation = request.generation
-  const options = yield* lowerOptions(request)
  return {
    model: request.model.id,
    input: yield* lowerMessages(request),
@@ -439,7 +436,7 @@ const fromRequest = Effect.fn("OpenAIResponses.fromRequest")(function* (request:
    max_output_tokens: generation?.maxTokens,
    temperature: generation?.temperature,
    top_p: generation?.topP,
-    ...options,
+    ...(yield* lowerOptions(request)),
  }
 })

@@ -2,8 +2,12 @@

 ## Database

- **Schema**: Drizzle schema lives in `packages/core/src/**/*.sql.ts`.
- **Migrations**: database migrations live in `packages/core` and are applied by core.
+- **Schema**: Drizzle schema lives in `src/**/*.sql.ts`.
+- **Naming**: tables and columns use snake*case; join columns are `<entity>_id`; indexes are `<table>*<column>\_idx`.
+- **Migrations**: generated by Drizzle Kit using `drizzle.config.ts` (schema: `./src/**/*.sql.ts`, output: `./migration`).
+- **Command**: `bun run db generate --name <slug>`.
+- **Output**: creates `migration/<timestamp>_<slug>/migration.sql` and `snapshot.json`.
+- **Tests**: migration tests should read the per-folder layout (no `_journal.json`).

 ## Development server

@@ -2,7 +2,7 @@ import { defineConfig } from "drizzle-kit"

 export default defineConfig({
  dialect: "sqlite",
-  schema: ["./src/**/*.sql.ts", "./src/**/sql.ts"],
+  schema: "./src/**/*.sql.ts",
  out: "./migration",
  dbCredentials: {
    url: "/home/thdxr/.local/share/opencode/opencode.db",
--- a/Show More
+++ b/Show More