fix(core): retain raw copilot completion usage

fix(core): preserve raw copilot usage
test(core): use observed copilot usage fixtures
2026-08-12 12:45:07 -04:00 · 2026-08-11 00:37:09 -05:00 · 2026-08-11 00:34:05 -05:00 · 2026-08-11 00:20:54 -05:00 · 2026-08-11 00:14:08 -05:00
80 changed files with 670 additions and 1462 deletions
@@ -75,7 +75,7 @@ jobs:
  build-cli:
    needs: version
    runs-on: blacksmith-4vcpu-ubuntu-2404
-    if: github.repository == 'anomalyco/opencode' && github.ref_name != 'beta'
+    if: github.repository == 'anomalyco/opencode'
    steps:
      - uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 # v3.6.0
        with:
@@ -91,7 +91,7 @@ jobs:
          opencode-app-secret: ${{ secrets.OPENCODE_APP_SECRET }}

      - name: Build legacy CLI
-        if: github.ref_name != 'v2' && github.ref_name != 'beta'
+        if: github.ref_name != 'v2'
        run: ./packages/opencode/script/build.ts ${{ (github.ref_name == 'beta' && '--sourcemaps') || '' }}
        env:
          OPENCODE_VERSION: ${{ needs.version.outputs.version }}
@@ -109,7 +109,7 @@ jobs:
          GH_TOKEN: ${{ steps.committer.outputs.token }}

      - uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
-        if: github.ref_name != 'v2' && github.ref_name != 'beta'
+        if: github.ref_name != 'v2'
        with:
          name: opencode-cli
          path: |
@@ -117,7 +117,7 @@ jobs:
            packages/opencode/dist/opencode-linux*

      - uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
-        if: github.ref_name != 'v2' && github.ref_name != 'beta'
+        if: github.ref_name != 'v2'
        with:
          name: opencode-cli-windows
          path: packages/opencode/dist/opencode-windows*
@@ -132,7 +132,7 @@ jobs:

  build-node-cli:
    needs: version
-    if: github.repository == 'anomalyco/opencode' && github.ref_name != 'beta'
+    if: github.repository == 'anomalyco/opencode'
    strategy:
      fail-fast: false
      matrix:
@@ -184,7 +184,7 @@ jobs:
      - build-cli
      - version
    runs-on: blacksmith-4vcpu-windows-2025
-    if: github.repository == 'anomalyco/opencode' && github.ref_name != 'v2' && github.ref_name != 'beta'
+    if: github.repository == 'anomalyco/opencode' && github.ref_name != 'v2'
    env:
      AZURE_CLIENT_ID: ${{ secrets.AZURE_CLIENT_ID }}
      AZURE_TENANT_ID: ${{ secrets.AZURE_TENANT_ID }}
@@ -377,7 +377,7 @@ jobs:
        env:
          OPENCODE_VERSION: ${{ needs.version.outputs.version }}
          OPENCODE_CHANNEL: ${{ (github.ref_name == 'beta' && 'beta') || 'prod' }}
-          OPENCODE_CLI_TARGET: ${{ matrix.settings.target }}
+          RUST_TARGET: ${{ matrix.settings.target }}

      - name: Build
        run: bun run build
@@ -393,7 +393,6 @@ jobs:
          VITE_SENTRY_DSN: ${{ vars.WEB_SENTRY_DSN }}
          VITE_SENTRY_ENVIRONMENT: ${{ (github.ref_name == 'beta' && 'beta') || 'production' }}
          VITE_SENTRY_RELEASE: desktop@${{ needs.version.outputs.version }}
-          OPENCODE_CLI_TARGET: ${{ matrix.settings.target }}

      - name: Package
        if: needs.version.outputs.release
@@ -497,31 +496,29 @@ jobs:
          registry-url: "https://registry.npmjs.org"

      - uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4.3.0
-        if: github.ref_name != 'v2' && github.ref_name != 'beta'
+        if: github.ref_name != 'v2'
        with:
          name: opencode-cli
          path: packages/opencode/dist

      - uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4.3.0
-        if: github.ref_name != 'v2' && github.ref_name != 'beta'
+        if: github.ref_name != 'v2'
        with:
          name: opencode-cli-windows
          path: packages/opencode/dist

      - uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4.3.0
-        if: github.ref_name != 'v2' && github.ref_name != 'beta'
+        if: github.ref_name != 'v2'
        with:
          name: opencode-cli-signed-windows
          path: packages/opencode/dist

      - uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4.3.0
-        if: github.ref_name != 'beta'
        with:
          name: opencode-preview-cli
          path: packages/cli/dist

      - uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4.3.0
-        if: github.ref_name != 'beta'
        with:
          pattern: opencode-node-cli-*
          path: packages/cli/dist/node
@@ -439,7 +439,6 @@
        "@actions/artifact": "4.0.0",
        "@lydell/node-pty": "catalog:",
        "@opencode-ai/app": "workspace:*",
-        "@opencode-ai/client": "workspace:*",
        "@opencode-ai/ui": "workspace:*",
        "@sentry/solid": "catalog:",
        "@sentry/vite-plugin": "catalog:",
@@ -348,10 +348,7 @@ const lowerMessages = Effect.fn("BedrockConverse.lowerMessages")(function* (
          continue
        }
      }
-      const previous = messages.at(-1)
-      if (previous?.role === "user")
-        messages[messages.length - 1] = { role: "user", content: [...previous.content, ...content] }
-      else messages.push({ role: "user", content })
+      messages.push({ role: "user", content })
      continue
    }

@@ -395,10 +392,7 @@ const lowerMessages = Effect.fn("BedrockConverse.lowerMessages")(function* (
      const cachePoint = BedrockCache.block(breakpoints, part.cache)
      if (cachePoint) content.push(cachePoint)
    }
-    const previous = messages.at(-1)
-    if (previous?.role === "user")
-      messages[messages.length - 1] = { role: "user", content: [...previous.content, ...content] }
-    else messages.push({ role: "user", content })
+    messages.push({ role: "user", content })
  }

  return messages
@@ -1,36 +0,0 @@
-{
-  "version": 1,
-  "metadata": {
-    "tags": [
-      "prefix:bedrock-converse",
-      "provider:amazon-bedrock",
-      "protocol:bedrock-converse",
-      "tool",
-      "tool-loop",
-      "parallel"
-    ],
-    "name": "bedrock-converse/continues-after-parallel-tool-results",
-    "recordedAt": "2026-08-11T16:41:46.482Z"
-  },
-  "interactions": [
-    {
-      "transport": "http",
-      "request": {
-        "method": "POST",
-        "url": "https://bedrock-runtime.us-east-1.amazonaws.com/model/us.amazon.nova-micro-v1%3A0/converse-stream",
-        "headers": {
-          "content-type": "application/json"
-        },
-        "body": "{\"modelId\":\"us.amazon.nova-micro-v1:0\",\"messages\":[{\"role\":\"user\",\"content\":[{\"text\":\"Compare the weather in Paris and London.\"}]},{\"role\":\"assistant\",\"content\":[{\"toolUse\":{\"toolUseId\":\"weather_paris\",\"name\":\"get_weather\",\"input\":{\"city\":\"Paris\"}}},{\"toolUse\":{\"toolUseId\":\"weather_london\",\"name\":\"get_weather\",\"input\":{\"city\":\"London\"}}}]},{\"role\":\"user\",\"content\":[{\"toolResult\":{\"toolUseId\":\"weather_paris\",\"content\":[{\"json\":{\"temperature\":22,\"condition\":\"sunny\"}}],\"status\":\"success\"}},{\"toolResult\":{\"toolUseId\":\"weather_london\",\"content\":[{\"json\":{\"temperature\":14,\"condition\":\"rainy\"}}],\"status\":\"success\"}}]}],\"system\":[{\"text\":\"After receiving both tool results, reply exactly: Paris is sunny; London is rainy.\"}],\"inferenceConfig\":{\"maxTokens\":40,\"temperature\":0},\"toolConfig\":{\"tools\":[{\"toolSpec\":{\"name\":\"get_weather\",\"description\":\"Get current weather for a city.\",\"inputSchema\":{\"json\":{\"type\":\"object\",\"properties\":{\"city\":{\"type\":\"string\"}},\"required\":[\"city\"],\"additionalProperties\":false}}}}]}}"
-      },
-      "response": {
-        "status": 200,
-        "headers": {
-          "content-type": "application/vnd.amazon.eventstream"
-        },
-        "body": "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",
-        "bodyEncoding": "base64"
-      }
-    }
-  ]
-}
@@ -255,57 +255,6 @@ describe("Bedrock Converse route", () => {
    }),
  )

-  it.effect("merges parallel tool results into one user message", () =>
-    Effect.gen(function* () {
-      const prepared = yield* compileRequest(
-        LLM.request({
-          id: "req_parallel_history",
-          model,
-          messages: [
-            Message.user("Compare the weather."),
-            Message.assistant([
-              ToolCallPart.make({ id: "tool_paris", name: "lookup", input: { city: "Paris" } }),
-              ToolCallPart.make({ id: "tool_london", name: "lookup", input: { city: "London" } }),
-            ]),
-            Message.tool({ id: "tool_paris", name: "lookup", result: { forecast: "sunny" } }),
-            Message.tool({ id: "tool_london", name: "lookup", result: { forecast: "rainy" } }),
-          ],
-          cache: "none",
-        }),
-      )
-
-      expect(prepared.body.messages).toEqual([
-        { role: "user", content: [{ text: "Compare the weather." }] },
-        {
-          role: "assistant",
-          content: [
-            { toolUse: { toolUseId: "tool_paris", name: "lookup", input: { city: "Paris" } } },
-            { toolUse: { toolUseId: "tool_london", name: "lookup", input: { city: "London" } } },
-          ],
-        },
-        {
-          role: "user",
-          content: [
-            {
-              toolResult: {
-                toolUseId: "tool_paris",
-                content: [{ json: { forecast: "sunny" } }],
-                status: "success",
-              },
-            },
-            {
-              toolResult: {
-                toolUseId: "tool_london",
-                content: [{ json: { forecast: "rainy" } }],
-                status: "success",
-              },
-            },
-          ],
-        },
-      ])
-    }),
-  )
-
  it.effect("lowers image content in tool-result messages", () =>
    Effect.gen(function* () {
      const prepared = yield* compileRequest(
@@ -1216,39 +1165,4 @@ describe("Bedrock Converse recorded", () => {
      )
    }),
  )
-
-  recorded.effect.with("continues after parallel tool results", { tags: ["tool", "tool-loop", "parallel"] }, () =>
-    Effect.gen(function* () {
-      const response = yield* LLMClient.generate(
-        LLM.request({
-          id: "recorded_bedrock_parallel_tool_results",
-          model: recordedModel(),
-          system: "After receiving both tool results, reply exactly: Paris is sunny; London is rainy.",
-          messages: [
-            Message.user("Compare the weather in Paris and London."),
-            Message.assistant([
-              ToolCallPart.make({ id: "weather_paris", name: weatherToolName, input: { city: "Paris" } }),
-              ToolCallPart.make({ id: "weather_london", name: weatherToolName, input: { city: "London" } }),
-            ]),
-            Message.tool({
-              id: "weather_paris",
-              name: weatherToolName,
-              result: { temperature: 22, condition: "sunny" },
-            }),
-            Message.tool({
-              id: "weather_london",
-              name: weatherToolName,
-              result: { temperature: 14, condition: "rainy" },
-            }),
-          ],
-          tools: [weatherTool],
-          cache: "none",
-          generation: { maxTokens: 40, temperature: 0 },
-        }),
-      )
-
-      expect(response.text.trim()).toBe("Paris is sunny; London is rainy.")
-      expect(response.finishReason?.normalized).toBe("stop")
-    }),
-  )
 })
@@ -69,63 +69,6 @@ describe("v2 session reducer", () => {
    })
  })

-  test("prefers durable selection predecessors and derives them for older events", () => {
-    const source: SessionMessageInfo[] = [
-      { id: "msg_previous_agent", type: "agent-switched", agent: "build", time: { created: 1 } },
-      {
-        id: "msg_previous_model",
-        type: "model-switched",
-        model: { id: "old", providerID: "provider" },
-        time: { created: 1 },
-      },
-    ]
-    const reducer = createV2SessionReducer()
-
-    const agent = reducer.reduce(
-      source,
-      event({
-        ...base,
-        id: "evt_agent",
-        type: "session.agent.selected",
-        data: { sessionID: "ses_1", agent: "plan", previous: "review" },
-      }),
-    )
-    const model = reducer.reduce(
-      source,
-      event({
-        ...base,
-        id: "evt_model",
-        type: "session.model.selected",
-        data: {
-          sessionID: "ses_1",
-          model: { id: "new", providerID: "provider" },
-          previous: { id: "durable", providerID: "provider" },
-        },
-      }),
-    )
-    const legacyAgent = reducer.reduce(
-      source,
-      event({
-        ...base,
-        id: "evt_legacy_agent",
-        type: "session.agent.selected",
-        data: { sessionID: "ses_1", agent: "plan" },
-      }),
-    )
-
-    expect(agent?.messages.at(-1)).toMatchObject({ type: "agent-switched", agent: "plan", previous: "review" })
-    expect(model?.messages.at(-1)).toMatchObject({
-      type: "model-switched",
-      model: { id: "new" },
-      previous: { id: "durable" },
-    })
-    expect(legacyAgent?.messages.at(-1)).toMatchObject({
-      type: "agent-switched",
-      agent: "plan",
-      previous: "build",
-    })
-  })
-
  test("folds tool, retry, and completion events", () => {
    const reducer = createV2SessionReducer()
    let messages: SessionMessageInfo[] = []
@@ -61,12 +61,6 @@ export function createV2SessionReducer() {
          type: "agent-switched",
          metadata: event.metadata,
          agent: event.data.agent,
-          previous:
-            event.data.previous ??
-            source.findLast(
-              (item): item is Extract<SessionMessageInfo, { type: "agent-switched" | "assistant" }> =>
-                item.type === "agent-switched" || item.type === "assistant",
-            )?.agent,
          time: { created: event.created },
        })
      case "session.model.selected":
@@ -75,12 +69,10 @@ export function createV2SessionReducer() {
          type: "model-switched",
          metadata: event.metadata,
          model: event.data.model,
-          previous:
-            event.data.previous ??
-            source.findLast(
-              (item): item is Extract<SessionMessageInfo, { type: "model-switched" | "assistant" }> =>
-                item.type === "model-switched" || item.type === "assistant",
-            )?.model,
+          previous: source.findLast(
+            (item): item is Extract<SessionMessageInfo, { type: "model-switched" | "assistant" }> =>
+              item.type === "model-switched" || item.type === "assistant",
+          )?.model,
          time: { created: event.created },
        })
      case "session.synthetic":
@@ -351,8 +351,8 @@ export const { use: useTabs, provider: TabsProvider } = createSimpleContext({
        const key = tabKey(tab)
        const next = { title: session.title, directory: session.location.directory }
        const current = info[key]
-        if (current && current.title === next.title && current.directory === next.directory) return
-        console.debug("[tabs] update persisted session info", { key, sessionID: session.id, current, next })
+        console.log({ tab, session, current })
+        if (current?.title === next.title && current.directory === next.directory) return
        setInfo(key, next)
      },
      select: navigateTab,
@@ -422,7 +422,8 @@ async function loadCatalog(client: OpenCodeClient, cwd: string): Promise<Catalog
        defaultModel: {
          providerID: defaultModel.providerID,
          id: defaultModel.id,
-          variant: defaultModel.variants.find((variant) => variant.id === "default")?.id,
+          variant:
+            defaultModel.variants.find((variant) => variant.id === "default")?.id ?? defaultModel.variants[0]?.id,
        },
        modes: agents.map((agent) => ({ id: agent.id, name: agent.name, description: agent.description })),
        defaultModeID: defaultAgent.id,
@@ -3,38 +3,6 @@ import type { SessionConfigOption } from "@agentclientprotocol/sdk"
 import { makeACPFixture, makeSession, secondModel } from "./service-fixture"

 describe("acp service lifecycle", () => {
-  test("does not persist the first catalog variant when no explicit default exists", async () => {
-    const model = { ...secondModel, variants: [{ id: "none" }, { id: "high" }] }
-    await using fixture = makeACPFixture({
-      models: [model],
-      defaultModel: model,
-      fetch(request) {
-        if (request.method === "POST" && request.path === "/api/session") {
-          return Response.json({
-            data: makeSession("ses_default_variant", {
-              model: { providerID: model.providerID, id: model.id },
-            }),
-          })
-        }
-        return undefined
-      },
-    })
-
-    const created = await fixture.service.newSession({ cwd: "/workspace", mcpServers: [] })
-
-    expect(fixture.requests).toContainEqual({
-      method: "POST",
-      path: "/api/session",
-      query: {},
-      body: {
-        location: { directory: "/workspace" },
-        agent: "build",
-        model: { providerID: "test", id: "second-model" },
-      },
-    })
-    expect(currentValue(created, "effort")).toBe("none")
-  })
-
  test("loads and forks with paginated replay while resume does not replay", async () => {
    await using fixture = makeACPFixture({
      fetch(request) {
@@ -339,11 +339,7 @@ export type Endpoint5_31Output =
          readonly type: "session.agent.selected"
          readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
          readonly location?: Location.Ref | undefined
-          readonly data: {
-            readonly sessionID: Session.ID
-            readonly agent: Agent.ID
-            readonly previous?: Agent.ID | undefined
-          }
+          readonly data: { readonly sessionID: Session.ID; readonly agent: Agent.ID }
        }
      | {
          readonly id: Event.ID
@@ -352,11 +348,7 @@ export type Endpoint5_31Output =
          readonly type: "session.model.selected"
          readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
          readonly location?: Location.Ref | undefined
-          readonly data: {
-            readonly sessionID: Session.ID
-            readonly model: Model.Ref
-            readonly previous?: Model.Ref | undefined
-          }
+          readonly data: { readonly sessionID: Session.ID; readonly model: Model.Ref }
        }
      | {
          readonly id: Event.ID
@@ -436,7 +436,7 @@ export type SessionAgentSelected = {
  type: "session.agent.selected"
  durable: { aggregateID: string; seq: number; version: 1 }
  location?: LocationRef
-  data: { sessionID: string; agent: string; previous?: string }
+  data: { sessionID: string; agent: string }
 }

 export type SessionModelSelected = {
@@ -446,7 +446,7 @@ export type SessionModelSelected = {
  type: "session.model.selected"
  durable: { aggregateID: string; seq: number; version: 1 }
  location?: LocationRef
-  data: { sessionID: string; model: ModelRef; previous?: ModelRef }
+  data: { sessionID: string; model: ModelRef }
 }

 export type SessionMoved = {
@@ -194,10 +194,11 @@ async function formatTypescript(input: string) {

 function renderRegistry(names: string[]) {
  return `import type { DatabaseMigration } from "./migration"
-${names.map((name, index) => `import m${index.toString().padStart(2, "0")} from "./migration/${name}"`).join("\n")}

-export const migrations = [
-${names.map((_, index) => `  m${index.toString().padStart(2, "0")},`).join("\n")}
-] satisfies DatabaseMigration.Migration[]
+export const migrations: DatabaseMigration.Migration[] = (
+  await Promise.all([
+${names.map((name) => `    import("./migration/${name}"),`).join("\n")}
+  ])
+).map((module) => module.default)
 `
 }
@@ -508,23 +508,8 @@ function toolOutput(result: ToolResultValue) {
    case "text":
    case "error":
      return { type: "text" as const, value: messageValue(result.value) }
-    case "content":
-      return {
-        type: "content" as const,
-        value: result.value.map((item) => {
-          if (item.type === "text") return { type: "text" as const, text: item.text }
-          const data = /^data:[^;,]+(?:;[^,]*)*;base64,(.*)$/s.exec(item.uri)?.[1]
-          const image = item.mime.toLowerCase().startsWith("image/")
-          if (data !== undefined)
-            return image
-              ? { type: "image-data" as const, data, mediaType: item.mime }
-              : { type: "file-data" as const, data, mediaType: item.mime, filename: item.name }
-          return image ? { type: "image-url" as const, url: item.uri } : { type: "file-url" as const, url: item.uri }
-        }),
-      }
-    case "json":
-      return { type: "json" as const, value: jsonValue(result.value) }
  }
+  return { type: "json" as const, value: jsonValue(result.value) }
 }

 function tool(input: ToolDefinition): LanguageModelV3FunctionTool {
@@ -4,7 +4,7 @@ import { Directory, Document, type Entry } from "@opencode-ai/schema/config"
 import { ConfigPlugin } from "@opencode-ai/schema/config/plugin"
 import { FSUtil } from "@opencode-ai/util/fs-util"
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
-import { Context, Effect, Layer, Option, Predicate, PubSub, Schema, Scope, Stream } from "effect"
+import { Context, Effect, Layer, Option, PubSub, Scope, Stream } from "effect"
 import path from "path"
 import { fileURLToPath } from "url"
 import { Config } from "../../config"
@@ -153,70 +153,22 @@ const scan = Effect.fn("ConfigPluginSource.scan")(function* (
  })
 })

-const sourceDirectories = ["plugin", "plugins"] as const
-const Package = Schema.Struct({
-  exports: Schema.optional(Schema.Unknown),
-  module: Schema.optional(Schema.Unknown),
-  main: Schema.optional(Schema.Unknown),
-})
-const decodePackage = Schema.decodeUnknownOption(Package)
-
 function discoverDirectory(fs: FSUtil.Interface, directory: string) {
  return Effect.gen(function* () {
-    const children = (yield* Effect.forEach(sourceDirectories, (source) =>
-      fs.readDirectoryEntries(path.join(directory, source)).pipe(
-        Effect.orElseSucceed(() => []),
-        Effect.map((entries) =>
-          entries.map((entry) => ({ ...entry, target: path.join(directory, source, entry.name) })),
-        ),
-      ),
-    ))
-      .flat()
-      .sort((a, b) => (a.target < b.target ? -1 : a.target > b.target ? 1 : 0))
-    const targets = yield* Effect.forEach(children, (entry) => discoverChild(fs, entry))
-    return targets.flatMap(Option.toArray).map((target): Operation => ({ type: "add", target, options: {} }))
+    const files = yield* fs
+      .scan("{plugin,plugins}/*.{ts,js}", {
+        cwd: directory,
+        absolute: true,
+        include: "file",
+        dot: true,
+        symlink: true,
+      })
+      .pipe(Effect.orElseSucceed(() => []))
+    return files.sort().map((target): Operation => ({ type: "add", target, options: {} }))
  })
 }

-function discoverChild(fs: FSUtil.Interface, entry: FSUtil.DirEntry & { target: string }) {
-  return Effect.gen(function* () {
-    const source = entry.target.endsWith(".ts") || entry.target.endsWith(".js")
-    if (entry.type === "file" && source) return Option.some(entry.target)
-    if (entry.type === "directory") return yield* discoverPackage(fs, entry.target)
-    if (entry.type !== "symlink") return Option.none<string>()
-    if (source && (yield* fs.isFile(entry.target))) return Option.some(entry.target)
-    if (yield* fs.isDir(entry.target)) return yield* discoverPackage(fs, entry.target)
-    return Option.none<string>()
-  })
-}
-
-function discoverPackage(fs: FSUtil.Interface, directory: string) {
-  return Effect.gen(function* () {
-    const root = yield* fs.resolve(directory)
-    const manifest = yield* fs
-      .readJson(path.join(directory, "package.json"))
-      .pipe(Effect.map(decodePackage), Effect.orElseSucceed(Option.none))
-    const configured = Option.isSome(manifest)
-      ? [manifest.value.exports, manifest.value.module, manifest.value.main].filter(Predicate.isString)
-      : []
-    return yield* Effect.findFirst(
-      [...configured, "index.ts", "index.js"]
-        .filter((entry) => !path.isAbsolute(entry))
-        .map((entry) => path.resolve(directory, entry))
-        .filter((entry) => FSUtil.contains(directory, entry)),
-      (entry) =>
-        fs
-          .isFile(entry)
-          .pipe(
-            Effect.flatMap((exists) =>
-              exists
-                ? fs.resolve(entry).pipe(Effect.map((resolved) => FSUtil.contains(root, resolved)))
-                : Effect.succeed(false),
-            ),
-          ),
-    )
-  })
-}
+const sourceDirectories = ["plugin", "plugins"] as const

 function isPluginSource(entries: readonly Entry[], file: string) {
  return entries.some(
@@ -42,10 +42,10 @@ const databaseLayer = Layer.effect(
 export function layer(options: Options = { path: ":memory:" }) {
  return Layer.unwrap(
    Effect.gen(function* () {
+      const global = yield* Global.Service
      const provide = (filename: string) => databaseLayer.pipe(Layer.provide(sqliteLayer({ filename })))
      const filename = options.path ?? ":memory:"
      if (filename === ":memory:" || isAbsolute(filename)) return provide(filename)
-      const global = yield* Global.Service
      return provide(join(global.data, filename))
    }),
  )
@@ -1,86 +1,47 @@
 import type { DatabaseMigration } from "./migration"
-import m00 from "./migration/20260127222353_familiar_lady_ursula"
-import m01 from "./migration/20260211171708_add_project_commands"
-import m02 from "./migration/20260213144116_wakeful_the_professor"
-import m03 from "./migration/20260225215848_workspace"
-import m04 from "./migration/20260227213759_add_session_workspace_id"
-import m05 from "./migration/20260228203230_blue_harpoon"
-import m06 from "./migration/20260303231226_add_workspace_fields"
-import m07 from "./migration/20260309230000_move_org_to_state"
-import m08 from "./migration/20260312043431_session_message_cursor"
-import m09 from "./migration/20260323234822_events"
-import m10 from "./migration/20260410174513_workspace-name"
-import m11 from "./migration/20260413175956_chief_energizer"
-import m12 from "./migration/20260423070820_add_icon_url_override"
-import m13 from "./migration/20260427172553_slow_nightmare"
-import m14 from "./migration/20260428004200_add_session_path"
-import m15 from "./migration/20260501142318_next_venus"
-import m16 from "./migration/20260504145000_add_sync_owner"
-import m17 from "./migration/20260507164347_add_workspace_time"
-import m18 from "./migration/20260510033149_session_usage"
-import m19 from "./migration/20260511000411_data_migration_state"
-import m20 from "./migration/20260511173437_session-metadata"
-import m21 from "./migration/20260601010001_normalize_storage_paths"
-import m22 from "./migration/20260601202201_amazing_prowler"
-import m23 from "./migration/20260602002951_lowly_union_jack"
-import m24 from "./migration/20260602182828_add_project_directories"
-import m25 from "./migration/20260603001617_session_message_projection_indexes"
-import m26 from "./migration/20260603040000_session_message_projection_order"
-import m27 from "./migration/20260603141458_session_input_inbox"
-import m28 from "./migration/20260603160727_jittery_ezekiel_stane"
-import m29 from "./migration/20260604172448_event_sourced_session_input"
-import m30 from "./migration/20260605003541_add_session_context_snapshot"
-import m31 from "./migration/20260605042240_add_context_epoch_agent"
-import m32 from "./migration/20260611035744_credential"
-import m33 from "./migration/20260611192811_lush_chimera"
-import m34 from "./migration/20260612174303_project_dir_strategy"
-import m35 from "./migration/20260622142730_simplify_session_context_epoch"
-import m36 from "./migration/20260622170816_reset_v2_session_state"
-import m37 from "./migration/20260622202450_simplify_session_input"
-import m38 from "./migration/20260804233008_loose_psylocke"
-import m39 from "./migration/20260805200742_import_legacy_credentials"
-import m40 from "./migration/20260808023530_workspace_domain"

-export const migrations = [
-  m00,
-  m01,
-  m02,
-  m03,
-  m04,
-  m05,
-  m06,
-  m07,
-  m08,
-  m09,
-  m10,
-  m11,
-  m12,
-  m13,
-  m14,
-  m15,
-  m16,
-  m17,
-  m18,
-  m19,
-  m20,
-  m21,
-  m22,
-  m23,
-  m24,
-  m25,
-  m26,
-  m27,
-  m28,
-  m29,
-  m30,
-  m31,
-  m32,
-  m33,
-  m34,
-  m35,
-  m36,
-  m37,
-  m38,
-  m39,
-  m40,
-] satisfies DatabaseMigration.Migration[]
+export const migrations: DatabaseMigration.Migration[] = (
+  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/20260511173437_session-metadata"),
+    import("./migration/20260601010001_normalize_storage_paths"),
+    import("./migration/20260601202201_amazing_prowler"),
+    import("./migration/20260602002951_lowly_union_jack"),
+    import("./migration/20260602182828_add_project_directories"),
+    import("./migration/20260603001617_session_message_projection_indexes"),
+    import("./migration/20260603040000_session_message_projection_order"),
+    import("./migration/20260603141458_session_input_inbox"),
+    import("./migration/20260603160727_jittery_ezekiel_stane"),
+    import("./migration/20260604172448_event_sourced_session_input"),
+    import("./migration/20260605003541_add_session_context_snapshot"),
+    import("./migration/20260605042240_add_context_epoch_agent"),
+    import("./migration/20260611035744_credential"),
+    import("./migration/20260611192811_lush_chimera"),
+    import("./migration/20260612174303_project_dir_strategy"),
+    import("./migration/20260622142730_simplify_session_context_epoch"),
+    import("./migration/20260622170816_reset_v2_session_state"),
+    import("./migration/20260622202450_simplify_session_input"),
+    import("./migration/20260804233008_loose_psylocke"),
+    import("./migration/20260805200742_import_legacy_credentials"),
+    import("./migration/20260808023530_workspace_domain"),
+  ])
+).map((module) => module.default)
@@ -1,32 +1,58 @@
-import { Database, type SQLQueryBindings } from "bun:sqlite"
+import { Database } from "bun:sqlite"
 import { drizzle } from "drizzle-orm/bun-sqlite"
-import { Context, Effect, Layer } from "effect"
+import { Context, Effect, Fiber, Layer, Scope, Semaphore, Stream } from "effect"
+import { identity } from "effect/Function"
 import { Reactivity } from "effect/unstable/reactivity"
-import { SqlClient } from "effect/unstable/sql"
+import { SqlClient, Statement } from "effect/unstable/sql"
+import type { Connection } from "effect/unstable/sql/SqlConnection"
 import { classifySqliteError, SqlError } from "effect/unstable/sql/SqlError"
 import { Sqlite } from "./sqlite"

-const TypeId = "~@opencode-ai/core/database/SqliteBun" as const
+const ATTR_DB_SYSTEM_NAME = "db.system.name"

-interface Config extends Sqlite.ClientConfig {
+const TypeId = "~@opencode-ai/core/database/SqliteBun" as const
+type TypeId = typeof TypeId
+
+interface SqliteClient extends SqlClient.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<Record<string, unknown>, SQLQueryBindings[]>(query)
+        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, SqlClient.SafeIntegers))
        try {
-          return Effect.succeed(statement.all(...(params as SQLQueryBindings[])) ?? [])
+          return Effect.succeed((statement.all(...(params as any)) ?? []) as Array<Record<string, unknown>>)
        } catch (cause) {
          return Effect.fail(
            new SqlError({
@@ -38,11 +64,11 @@ const make = (options: Config) =>

    const runValues = (query: string, params: ReadonlyArray<unknown> = []) =>
      Effect.withFiber<Array<unknown[]>, SqlError>((fiber) => {
-        const statement = native.query<unknown, SQLQueryBindings[]>(query)
+        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, SqlClient.SafeIntegers))
        try {
-          return Effect.succeed(statement.values(...(params as SQLQueryBindings[])) ?? [])
+          return Effect.succeed((statement.values(...(params as any)) ?? []) as Array<unknown[]>)
        } catch (cause) {
          return Effect.fail(
            new SqlError({
@@ -52,7 +78,25 @@ const make = (options: Config) =>
        }
      })

-    const connection = Sqlite.makeConnection(run, runValues, {
+    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)
+      },
+      executeValuesUnprepared(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) =>
@@ -60,7 +104,7 @@ const make = (options: Config) =>
            reason: classifySqliteError(cause, { message: "Failed to export database", operation: "export" }),
          }),
      }),
-      loadExtension: (path: string) =>
+      loadExtension: (path) =>
        Effect.try({
          try: () => native.loadExtension(path),
          catch: (cause) =>
@@ -70,10 +114,37 @@ const make = (options: Config) =>
        }),
    })

-    return yield* Sqlite.makeClient(options, connection, TypeId, (acquirer) => ({
-      export: Effect.flatMap(acquirer, (_) => _.export),
-      loadExtension: (path: string) => Effect.flatMap(acquirer, (_) => _.loadExtension(path)),
-    }))
+    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* SqlClient.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) =>
@@ -1,14 +1,26 @@
 import { DatabaseSync, type SQLInputValue } from "node:sqlite"
 import { drizzle } from "drizzle-orm/node-sqlite"
-import { Context, Effect, Layer } from "effect"
+import { Context, Effect, Fiber, Layer, Scope, Semaphore, Stream } from "effect"
+import { identity } from "effect/Function"
 import { Reactivity } from "effect/unstable/reactivity"
-import { SqlClient } from "effect/unstable/sql"
+import { SqlClient, Statement } from "effect/unstable/sql"
+import type { Connection } from "effect/unstable/sql/SqlConnection"
 import { classifySqliteError, SqlError } from "effect/unstable/sql/SqlError"
 import { Sqlite } from "./sqlite"

-const TypeId = "~@opencode-ai/core/database/SqliteNode" as const
+const ATTR_DB_SYSTEM_NAME = "db.system.name"

-interface Config extends Sqlite.ClientConfig {
+const TypeId = "~@opencode-ai/core/database/SqliteNode" as const
+type TypeId = typeof TypeId
+
+interface SqliteClient extends SqlClient.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
@@ -16,12 +28,24 @@ interface Config extends Sqlite.ClientConfig {
  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)
@@ -55,8 +79,26 @@ const make = (options: Config) =>
        }
      })

-    const connection = Sqlite.makeConnection(run, runValues, {
-      loadExtension: (path: string) =>
+    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)
+      },
+      executeValuesUnprepared(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) =>
@@ -66,9 +108,36 @@ const make = (options: Config) =>
        }),
    })

-    return yield* Sqlite.makeClient(options, connection, TypeId, (acquirer) => ({
-      loadExtension: (path: string) => Effect.flatMap(acquirer, (_) => _.loadExtension(path)),
-    }))
+    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* SqlClient.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) =>
@@ -1,100 +1,8 @@
 export * as Sqlite from "./sqlite"

-import { Context, Effect, Fiber, Scope, Semaphore, Stream } from "effect"
-import { identity } from "effect/Function"
-import { SqlClient, Statement } from "effect/unstable/sql"
-import type { Connection } from "effect/unstable/sql/SqlConnection"
-import type { SqlError } from "effect/unstable/sql/SqlError"
+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") {}
-
-export interface ClientConfig {
-  readonly spanAttributes?: Record<string, unknown>
-  readonly transformResultNames?: (str: string) => string
-  readonly transformQueryNames?: (str: string) => string
-}
-
-type Run = (
-  query: string,
-  params?: ReadonlyArray<unknown>,
-) => Effect.Effect<ReadonlyArray<Record<string, unknown>>, SqlError>
-
-type RunValues = (
-  query: string,
-  params?: ReadonlyArray<unknown>,
-) => Effect.Effect<ReadonlyArray<ReadonlyArray<unknown>>, SqlError>
-
-export const makeConnection = <Extensions extends object>(run: Run, runValues: RunValues, extensions: Extensions) =>
-  identity<Connection & Extensions>({
-    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)
-    },
-    executeValuesUnprepared(query, params) {
-      return runValues(query, params)
-    },
-    executeUnprepared(query, params, transformRows) {
-      return this.execute(query, params, transformRows)
-    },
-    executeStream() {
-      return Stream.die("executeStream not implemented")
-    },
-    ...extensions,
-  })
-
-export const makeClient = <
-  Config extends ClientConfig,
-  SqliteConnection extends Connection,
-  const TypeId extends string,
-  Extensions extends object,
->(
-  options: Config,
-  connection: SqliteConnection,
-  typeId: TypeId,
-  extensions: (acquirer: Effect.Effect<SqliteConnection, SqlError, Scope.Scope>) => Extensions,
-) =>
-  Effect.gen(function* () {
-    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 transformRows = options.transformResultNames
-      ? Statement.defaultTransforms(options.transformResultNames).array
-      : undefined
-
-    return Object.assign(
-      yield* SqlClient.make({
-        acquirer,
-        compiler: Statement.makeCompilerSqlite(options.transformQueryNames),
-        transactionAcquirer,
-        spanAttributes: [
-          ...(options.spanAttributes ? Object.entries(options.spanAttributes) : []),
-          ["db.system.name", "sqlite"],
-        ],
-        transformRows,
-      }),
-      {
-        [typeId]: typeId,
-        config: options,
-        ...extensions(acquirer),
-      },
-    ) as SqlClient.SqlClient &
-      Record<TypeId, TypeId> & {
-        readonly config: Config
-        readonly updateValues: never
-      } & Extensions
-  })
@@ -7,7 +7,7 @@ import { SessionV1 } from "@opencode-ai/schema/session-v1"
 import { SessionMessage } from "../session/message"
 import { SessionSchema } from "../session/schema"
 import { KVTable } from "../kv/sql"
-import { EventSequenceTable } from "../event/sql"
+import { EventSequenceTable, EventTable } from "../event/sql"
 import { eq, sql } from "drizzle-orm"
 import { Global } from "@opencode-ai/util/global"
 import { existsSync } from "node:fs"
@@ -161,7 +161,6 @@ type NextMessage = {

 const lock = Semaphore.makeUnsafe(1)
 const MIGRATION_STATE_KEY = "migration.v1-v2"
-const EVENT_DELETE_BATCH_SIZE = 1_000
 const decodeJson = Schema.decodeUnknownOption(Schema.UnknownFromJsonString)
 const decodeMessage = Schema.decodeUnknownOption(SessionV1.Info)
 const decodePart = Schema.decodeUnknownOption(SessionV1.Part)
@@ -486,15 +485,7 @@ export function run(options: Options = {}): Effect.Effect<RunResult, never, Data
          yield* db
            .transaction((tx) =>
              Effect.gen(function* () {
-                while (true) {
-                  yield* tx.run(sql`
-                    DELETE FROM event
-                    WHERE rowid IN (SELECT rowid FROM event LIMIT ${EVENT_DELETE_BATCH_SIZE})
-                  `)
-                  const deleted = (yield* tx.get<{ value: number }>(sql`SELECT changes() AS value`))?.value ?? 0
-                  if (deleted < EVENT_DELETE_BATCH_SIZE) break
-                  yield* Effect.yieldNow
-                }
+                yield* tx.delete(EventTable).run()
                yield* tx
                  .insert(KVTable)
                  .values({ key: MIGRATION_STATE_KEY, value: { phase: "sessions" } })
@@ -285,9 +285,8 @@ export class OpenAICompatibleChatLanguageModel implements LanguageModelV3 {
          cacheWrite: undefined,
        },
        outputTokens: {
-          total: responseBody.usage?.completion_tokens ?? undefined,
+          ...outputUsage(responseBody.usage),
          text: undefined,
-          reasoning: responseBody.usage?.completion_tokens_details?.reasoning_tokens ?? undefined,
        },
        raw: responseBody.usage ?? undefined,
      },
@@ -357,6 +356,7 @@ export class OpenAICompatibleChatLanguageModel implements LanguageModelV3 {
        cachedTokens: number | undefined
      }
      totalTokens: number | undefined
+      rawCompletionTokens: number | undefined
    } = {
      completionTokens: undefined,
      completionTokensDetails: {
@@ -369,6 +369,7 @@ export class OpenAICompatibleChatLanguageModel implements LanguageModelV3 {
        cachedTokens: undefined,
      },
      totalTokens: undefined,
+      rawCompletionTokens: undefined,
    }
    let isFirstChunk = true
    const providerOptionsName = this.providerOptionsName
@@ -432,11 +433,11 @@ export class OpenAICompatibleChatLanguageModel implements LanguageModelV3 {
              } = value.usage

              usage.promptTokens = prompt_tokens ?? undefined
-              usage.completionTokens = completion_tokens ?? undefined
+              usage.rawCompletionTokens = completion_tokens ?? undefined
+              const output = outputUsage(value.usage)
+              usage.completionTokens = output.total
+              usage.completionTokensDetails.reasoningTokens = output.reasoning
              usage.totalTokens = total_tokens ?? undefined
-              if (completion_tokens_details?.reasoning_tokens != null) {
-                usage.completionTokensDetails.reasoningTokens = completion_tokens_details?.reasoning_tokens
-              }
              if (completion_tokens_details?.accepted_prediction_tokens != null) {
                usage.completionTokensDetails.acceptedPredictionTokens =
                  completion_tokens_details?.accepted_prediction_tokens
@@ -708,7 +709,7 @@ export class OpenAICompatibleChatLanguageModel implements LanguageModelV3 {
                },
                raw: {
                  prompt_tokens: usage.promptTokens ?? null,
-                  completion_tokens: usage.completionTokens ?? null,
+                  completion_tokens: usage.rawCompletionTokens ?? null,
                  total_tokens: usage.totalTokens ?? null,
                },
              },
@@ -727,6 +728,7 @@ const openaiCompatibleTokenUsageSchema = z
  .object({
    prompt_tokens: z.number().nullish(),
    completion_tokens: z.number().nullish(),
+    reasoning_tokens: z.number().nullish(),
    total_tokens: z.number().nullish(),
    prompt_tokens_details: z
      .object({
@@ -743,6 +745,17 @@ const openaiCompatibleTokenUsageSchema = z
  })
  .nullish()

+function outputUsage(usage: z.infer<typeof openaiCompatibleTokenUsageSchema>) {
+  const nested = usage?.completion_tokens_details?.reasoning_tokens
+  return {
+    total:
+      usage?.completion_tokens == null
+        ? undefined
+        : usage.completion_tokens + (nested == null ? (usage.reasoning_tokens ?? 0) : 0),
+    reasoning: nested ?? usage?.reasoning_tokens ?? undefined,
+  }
+}
+
 // limited version of the schema, focussed on what is needed for the implementation
 // this approach limits breakages when the API changes and increases efficiency
 const OpenAICompatibleChatResponseSchema = z.object({
@@ -1,4 +1,4 @@
-import { Cause, Context, Duration, Effect, Layer, Option, Schedule, Schema, Semaphore } from "effect"
+import { Context, Duration, Effect, Layer, Option, Schedule, Schema, Semaphore } from "effect"
 import { HttpClient, HttpClientRequest } from "effect/unstable/http"
 import { ModelsDev } from "@opencode-ai/schema/models-dev"
 import { Money } from "@opencode-ai/schema/money"
@@ -612,16 +612,7 @@ export const layer = (options?: Options) =>
      const fetchAndWrite = Effect.fn("ModelsDev.fetchAndWrite")(function* () {
        const text = yield* fetchApi()
        const catalog = (yield* Schema.decodeUnknownEffect(CatalogJson)(text)) as Record<string, SourceProvider>
-        // Best-effort: a cache-write failure must never kill catalog
-        // population. The payload has outgrown some KV backends' per-value
-        // limits (Durable Object SQLite caps values at 2 MB and api.json
-        // passed it in Aug 2026); a boot without a cache hit just refetches.
-        yield* kv.set(key, { updatedAt: Date.now(), body: text }).pipe(
-          Effect.catchCauseIf(
-            (cause) => !Cause.hasInterruptsOnly(cause),
-            (cause) => Effect.logWarning("Failed to cache models.dev catalog", { cause }),
-          ),
-        )
+        yield* kv.set(key, { updatedAt: Date.now(), body: text })
        return catalog
      })

@@ -3,7 +3,7 @@ export * as PluginHooks from "./hooks"
 import type { AISDKHooks } from "@opencode-ai/plugin/effect/aisdk"
 import type { SessionHooks } from "@opencode-ai/plugin/effect/session"
 import type { ShellHooks } from "@opencode-ai/plugin/effect/shell"
-import type { ToolFailures, ToolHooks } from "@opencode-ai/plugin/effect/tool"
+import type { ToolHooks } from "@opencode-ai/plugin/effect/tool"
 import { Context, Effect, Layer, Scope } from "effect"
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
 import { State } from "../state"
@@ -15,29 +15,19 @@ export interface Domains {
  readonly tool: ToolHooks
 }

-type NoFailures<Spec> = { readonly [Name in keyof Spec]: never }
-
-// Failure channel for each hook event. Only tool execute.before may fail: a Tool.Error rejects the call before it runs.
-interface Failures extends Record<keyof Domains, unknown> {
-  readonly aisdk: NoFailures<AISDKHooks>
-  readonly session: NoFailures<SessionHooks>
-  readonly shell: NoFailures<ShellHooks>
-  readonly tool: ToolFailures
-}
-
-type Callback<Event, Error> = (event: Event) => Effect.Effect<void, Error>
+type Callback<Event> = (event: Event) => Effect.Effect<void>

 export interface Interface {
-  readonly register: <Domain extends keyof Domains, Name extends keyof Domains[Domain] & keyof Failures[Domain]>(
+  readonly register: <Domain extends keyof Domains, Name extends keyof Domains[Domain]>(
    domain: Domain,
    name: Name,
-    callback: Callback<Domains[Domain][Name], Failures[Domain][Name]>,
+    callback: Callback<Domains[Domain][Name]>,
  ) => Effect.Effect<State.Registration, never, Scope.Scope>
-  readonly trigger: <Domain extends keyof Domains, Name extends keyof Domains[Domain] & keyof Failures[Domain]>(
+  readonly trigger: <Domain extends keyof Domains, Name extends keyof Domains[Domain]>(
    domain: Domain,
    name: Name,
    event: Domains[Domain][Name],
-  ) => Effect.Effect<Domains[Domain][Name], Failures[Domain][Name]>
+  ) => Effect.Effect<Domains[Domain][Name]>
 }

 export class Service extends Context.Service<Service, Interface>()("@opencode/PluginHooks") {}
@@ -66,9 +56,7 @@ const layer = Layer.effect(

    const trigger: Interface["trigger"] = Effect.fn("PluginHooks.trigger")(function* (domain, name, event) {
      for (const callback of callbacks.get(key(domain, name)) ?? []) {
-        const result: Effect.Effect<void, Failures[typeof domain][typeof name]> = Reflect.apply(callback, undefined, [
-          event,
-        ])
+        const result: Effect.Effect<void> = Reflect.apply(callback, undefined, [event])
        yield* result
      }
      return event
@@ -17,7 +17,6 @@ import { ConfigProviderPlugin } from "../config/plugin/provider"
 import { ConfigPolicyPlugin } from "../config/plugin/policy"
 import { ConfigReferencePlugin } from "../config/plugin/reference"
 import { ConfigSkillPlugin } from "../config/plugin/skill"
-import { ConfigPluginSource } from "../config/plugin/source"
 import { ConfigWebSearchPlugin } from "../config/plugin/websearch"
 import { Bus } from "../bus"
 import { Environment } from "../environment"
@@ -77,7 +76,6 @@ const services = Effect.fn("PluginInternal.services")(function* () {
  const command = yield* Command.Service
  const config = yield* Config.Service
  const credential = yield* Credential.Service
-  const pluginSources = yield* ConfigPluginSource.Service
  const bus = yield* Bus.Service
  const environment = yield* Environment.Service
  const mutation = yield* FileMutation.Service
@@ -114,7 +112,6 @@ const services = Effect.fn("PluginInternal.services")(function* () {
    Context.make(Command.Service, command),
    Context.make(Config.Service, config),
    Context.make(Credential.Service, credential),
-    Context.make(ConfigPluginSource.Service, pluginSources),
    Context.make(Bus.Service, bus),
    Context.make(Environment.Service, environment),
    Context.make(FileMutation.Service, mutation),
@@ -158,7 +155,6 @@ export const requirements = LayerNode.group([
  Command.node,
  Config.node,
  Credential.node,
-  ConfigPluginSource.node,
  Bus.node,
  Environment.node,
  FileMutation.node,
@@ -36,7 +36,6 @@ export const ModelsDevPlugin = define({
          draft.integrationID = Integration.ID.make(provider.info.id)
        })
        for (const model of provider.models) {
-          if (model.status === "deprecated") continue
          catalog.model.update(provider.info.id, model.id, (draft) => Object.assign(draft, model))
        }
      }
@@ -1,10 +1,16 @@
-import { createProviderPlugin } from "./factory"
+import { Effect } from "effect"
+import { define } from "@opencode-ai/plugin/effect/plugin"

-export const AlibabaPlugin = createProviderPlugin({
+export const AlibabaPlugin = define({
  id: "opencode.provider.alibaba",
-  package: "@ai-sdk/alibaba",
-  load: async (options) => {
-    const { createAlibaba } = await import("@ai-sdk/alibaba")
-    return createAlibaba(options)
-  },
+  effect: Effect.fn(function* (ctx) {
+    yield* ctx.aisdk.hook(
+      "sdk",
+      Effect.fn(function* (evt) {
+        if (evt.package !== "@ai-sdk/alibaba") return
+        const mod = yield* Effect.promise(() => import("@ai-sdk/alibaba"))
+        evt.sdk = mod.createAlibaba(evt.options)
+      }),
+    )
+  }),
 })
@@ -1,10 +1,16 @@
-import { createProviderPlugin } from "./factory"
+import { Effect } from "effect"
+import { define } from "@opencode-ai/plugin/effect/plugin"

-export const CoherePlugin = createProviderPlugin({
+export const CoherePlugin = define({
  id: "opencode.provider.cohere",
-  package: "@ai-sdk/cohere",
-  load: async (options) => {
-    const { createCohere } = await import("@ai-sdk/cohere")
-    return createCohere(options)
-  },
+  effect: Effect.fn(function* (ctx) {
+    yield* ctx.aisdk.hook(
+      "sdk",
+      Effect.fn(function* (evt) {
+        if (evt.package !== "@ai-sdk/cohere") return
+        const mod = yield* Effect.promise(() => import("@ai-sdk/cohere"))
+        evt.sdk = mod.createCohere(evt.options)
+      }),
+    )
+  }),
 })
@@ -1,10 +1,16 @@
-import { createProviderPlugin } from "./factory"
+import { Effect } from "effect"
+import { define } from "@opencode-ai/plugin/effect/plugin"

-export const DeepInfraPlugin = createProviderPlugin({
+export const DeepInfraPlugin = define({
  id: "opencode.provider.deepinfra",
-  package: "@ai-sdk/deepinfra",
-  load: async (options) => {
-    const { createDeepInfra } = await import("@ai-sdk/deepinfra")
-    return createDeepInfra(options)
-  },
+  effect: Effect.fn(function* (ctx) {
+    yield* ctx.aisdk.hook(
+      "sdk",
+      Effect.fn(function* (evt) {
+        if (evt.package !== "@ai-sdk/deepinfra") return
+        const mod = yield* Effect.promise(() => import("@ai-sdk/deepinfra"))
+        evt.sdk = mod.createDeepInfra(evt.options)
+      }),
+    )
+  }),
 })
@@ -1,22 +0,0 @@
-import { define } from "@opencode-ai/plugin/effect/plugin"
-import type { AISDKHooks } from "@opencode-ai/plugin/effect/aisdk"
-import { Effect } from "effect"
-
-export function createProviderPlugin(input: {
-  readonly id: string
-  readonly package: string
-  readonly load: (options: AISDKHooks["sdk"]["options"]) => Promise<unknown>
-}) {
-  return define({
-    id: input.id,
-    effect: Effect.fn(function* (ctx) {
-      yield* ctx.aisdk.hook(
-        "sdk",
-        Effect.fn(function* (evt) {
-          if (evt.package !== input.package) return
-          evt.sdk = yield* Effect.promise(() => input.load(evt.options))
-        }),
-      )
-    }),
-  })
-}
@@ -1,10 +1,16 @@
-import { createProviderPlugin } from "./factory"
+import { Effect } from "effect"
+import { define } from "@opencode-ai/plugin/effect/plugin"

-export const GatewayPlugin = createProviderPlugin({
+export const GatewayPlugin = define({
  id: "opencode.provider.gateway",
-  package: "@ai-sdk/gateway",
-  load: async (options) => {
-    const { createGateway } = await import("@ai-sdk/gateway")
-    return createGateway(options)
-  },
+  effect: Effect.fn(function* (ctx) {
+    yield* ctx.aisdk.hook(
+      "sdk",
+      Effect.fn(function* (evt) {
+        if (evt.package !== "@ai-sdk/gateway") return
+        const mod = yield* Effect.promise(() => import("@ai-sdk/gateway"))
+        evt.sdk = mod.createGateway(evt.options)
+      }),
+    )
+  }),
 })
@@ -1,10 +1,16 @@
-import { createProviderPlugin } from "./factory"
+import { Effect } from "effect"
+import { define } from "@opencode-ai/plugin/effect/plugin"

-export const GroqPlugin = createProviderPlugin({
+export const GroqPlugin = define({
  id: "opencode.provider.groq",
-  package: "@ai-sdk/groq",
-  load: async (options) => {
-    const { createGroq } = await import("@ai-sdk/groq")
-    return createGroq(options)
-  },
+  effect: Effect.fn(function* (ctx) {
+    yield* ctx.aisdk.hook(
+      "sdk",
+      Effect.fn(function* (evt) {
+        if (evt.package !== "@ai-sdk/groq") return
+        const mod = yield* Effect.promise(() => import("@ai-sdk/groq"))
+        evt.sdk = mod.createGroq(evt.options)
+      }),
+    )
+  }),
 })
@@ -1,10 +1,16 @@
-import { createProviderPlugin } from "./factory"
+import { Effect } from "effect"
+import { define } from "@opencode-ai/plugin/effect/plugin"

-export const MistralPlugin = createProviderPlugin({
+export const MistralPlugin = define({
  id: "opencode.provider.mistral",
-  package: "@ai-sdk/mistral",
-  load: async (options) => {
-    const { createMistral } = await import("@ai-sdk/mistral")
-    return createMistral(options)
-  },
+  effect: Effect.fn(function* (ctx) {
+    yield* ctx.aisdk.hook(
+      "sdk",
+      Effect.fn(function* (evt) {
+        if (evt.package !== "@ai-sdk/mistral") return
+        const mod = yield* Effect.promise(() => import("@ai-sdk/mistral"))
+        evt.sdk = mod.createMistral(evt.options)
+      }),
+    )
+  }),
 })
@@ -1,10 +1,16 @@
-import { createProviderPlugin } from "./factory"
+import { Effect } from "effect"
+import { define } from "@opencode-ai/plugin/effect/plugin"

-export const PerplexityPlugin = createProviderPlugin({
+export const PerplexityPlugin = define({
  id: "opencode.provider.perplexity",
-  package: "@ai-sdk/perplexity",
-  load: async (options) => {
-    const { createPerplexity } = await import("@ai-sdk/perplexity")
-    return createPerplexity(options)
-  },
+  effect: Effect.fn(function* (ctx) {
+    yield* ctx.aisdk.hook(
+      "sdk",
+      Effect.fn(function* (evt) {
+        if (evt.package !== "@ai-sdk/perplexity") return
+        const mod = yield* Effect.promise(() => import("@ai-sdk/perplexity"))
+        evt.sdk = mod.createPerplexity(evt.options)
+      }),
+    )
+  }),
 })
@@ -1,10 +1,16 @@
-import { createProviderPlugin } from "./factory"
+import { Effect } from "effect"
+import { define } from "@opencode-ai/plugin/effect/plugin"

-export const TogetherAIPlugin = createProviderPlugin({
+export const TogetherAIPlugin = define({
  id: "opencode.provider.togetherai",
-  package: "@ai-sdk/togetherai",
-  load: async (options) => {
-    const { createTogetherAI } = await import("@ai-sdk/togetherai")
-    return createTogetherAI(options)
-  },
+  effect: Effect.fn(function* (ctx) {
+    yield* ctx.aisdk.hook(
+      "sdk",
+      Effect.fn(function* (evt) {
+        if (evt.package !== "@ai-sdk/togetherai") return
+        const mod = yield* Effect.promise(() => import("@ai-sdk/togetherai"))
+        evt.sdk = mod.createTogetherAI(evt.options)
+      }),
+    )
+  }),
 })
@@ -1,10 +1,16 @@
-import { createProviderPlugin } from "./factory"
+import { Effect } from "effect"
+import { define } from "@opencode-ai/plugin/effect/plugin"

-export const VenicePlugin = createProviderPlugin({
+export const VenicePlugin = define({
  id: "opencode.provider.venice",
-  package: "venice-ai-sdk-provider",
-  load: async (options) => {
-    const { createVenice } = await import("venice-ai-sdk-provider")
-    return createVenice(options)
-  },
+  effect: Effect.fn(function* (ctx) {
+    yield* ctx.aisdk.hook(
+      "sdk",
+      Effect.fn(function* (evt) {
+        if (evt.package !== "venice-ai-sdk-provider") return
+        const mod = yield* Effect.promise(() => import("venice-ai-sdk-provider"))
+        evt.sdk = mod.createVenice(evt.options)
+      }),
+    )
+  }),
 })
@@ -6,8 +6,12 @@ import { define, type Context } from "@opencode-ai/plugin/effect/plugin"
 import { Effect } from "effect"
 import { AbsolutePath } from "../schema"
 import { Skill } from "../skill"
-import { ConfigPluginSource } from "../config/plugin/source"
+import { Config } from "../config"
+import { Location } from "../location"
+import { FSUtil } from "@opencode-ai/util/fs-util"
 import os from "os"
+import path from "path"
+import { fileURLToPath } from "url"
 import opencodeContent from "./skill/opencode.md" with { type: "text" }
 import reportContent from "./skill/report.md" with { type: "text" }

@@ -68,10 +72,32 @@ const reportContentWithDiagnostics = Effect.fn("SkillPlugin.reportContentWithDia
 })

 const configuredPlugins = Effect.fn("SkillPlugin.configuredPlugins")(function* () {
-  const sources = yield* ConfigPluginSource.Service
-  return (yield* sources.operations())
-    .map((operation) => (operation.type === "remove" ? `-${operation.target}` : operation.target))
-    .toSorted()
+  const config = yield* Config.Service
+  const fs = yield* FSUtil.Service
+  const location = yield* Location.Service
+  return yield* Effect.forEach(yield* config.entries(), (entry) => {
+    if (entry.type === "document") {
+      const directory = entry.path ? path.dirname(entry.path) : location.directory
+      return Effect.succeed(
+        (entry.info.plugins ?? []).map((item) => {
+          const ref = typeof item === "string" ? { package: item } : item
+          if (ref.package.startsWith("file://")) return fileURLToPath(ref.package)
+          if (ref.package.startsWith("./") || ref.package.startsWith("../")) return path.resolve(directory, ref.package)
+          return ref.package
+        }),
+      )
+    }
+    if (entry.type !== "directory") return Effect.succeed([])
+    return fs
+      .scan("{plugin,plugins}/*.{ts,js}", {
+        cwd: entry.path,
+        absolute: true,
+        include: "file",
+        dot: true,
+        symlink: true,
+      })
+      .pipe(Effect.orElseSucceed(() => []))
+  }).pipe(Effect.map((items) => items.flat().toSorted()))
 })

 function terminal() {
@@ -2,7 +2,7 @@ export * as Project from "./project"

 import { Context, Effect, Layer, Schema } from "effect"
 import { ChildProcess } from "effect/unstable/process"
-import { asc, desc } from "drizzle-orm"
+import { asc, desc, isNotNull, isNull, ne, or } from "drizzle-orm"
 import path from "path"
 import { AbsolutePath } from "./schema"
 import { Database } from "./database/database"
@@ -13,7 +13,7 @@ import { makeGlobalNode } from "@opencode-ai/util/effect/app-node"
 import { Hash } from "@opencode-ai/util/hash"
 import { ProjectDirectories } from "./project/directories"
 import { ProjectSchema } from "./project/schema"
-import { ProjectTable, upsertProject } from "./project/sql"
+import { ProjectTable } from "./project/sql"

 export const ID = ProjectSchema.ID
 export type ID = ProjectSchema.ID
@@ -98,7 +98,19 @@ const layer = Layer.effect(
      yield* db
        .transaction((tx) =>
          Effect.gen(function* () {
-            yield* upsertProject(tx, project)
+            const vcs = project.vcs?.type
+            yield* tx
+              .insert(ProjectTable)
+              .values({ id: project.id, worktree: project.canonical, vcs, sandboxes: [] })
+              .onConflictDoUpdate({
+                target: ProjectTable.id,
+                set: { worktree: project.canonical, vcs: vcs ?? null },
+                setWhere: or(
+                  ne(ProjectTable.worktree, project.canonical),
+                  vcs ? or(isNull(ProjectTable.vcs), ne(ProjectTable.vcs, vcs)) : isNotNull(ProjectTable.vcs),
+                ),
+              })
+              .run()
            if (!project.vcs) return
            yield* projectDirectories.create({ projectID: project.id, directory: project.canonical }, tx)
            if (project.directory === project.canonical) return
@@ -1,14 +1,8 @@
-import type { EffectDrizzleSqlite } from "@opencode-ai/effect-drizzle-sqlite"
-import { isNotNull, isNull, ne, or } from "drizzle-orm"
 import { sqliteTable, text, integer, primaryKey } from "drizzle-orm/sqlite-core"
 import { absoluteArrayColumn, absoluteColumn } from "../database/path"
 import { Timestamps } from "../database/schema.sql"
-import type { AbsolutePath } from "../schema"
 import { ProjectSchema } from "./schema"

-type DatabaseClient = EffectDrizzleSqlite.EffectSQLiteDatabase
-type Transaction = Parameters<Parameters<DatabaseClient["transaction"]>[0]>[0]
-
 export const ProjectTable = sqliteTable("project", {
  id: text().$type<ProjectSchema.ID>().primaryKey(),
  worktree: absoluteColumn().notNull(),
@@ -39,22 +33,3 @@ export const ProjectDirectoryTable = sqliteTable(
  },
  (table) => [primaryKey({ columns: [table.project_id, table.directory] })],
 )
-
-export function upsertProject(
-  db: DatabaseClient | Transaction,
-  project: { readonly id: ProjectSchema.ID; readonly canonical: AbsolutePath; readonly vcs?: ProjectSchema.Vcs },
-) {
-  const vcs = project.vcs?.type
-  return db
-    .insert(ProjectTable)
-    .values({ id: project.id, worktree: project.canonical, vcs, sandboxes: [] })
-    .onConflictDoUpdate({
-      target: ProjectTable.id,
-      set: { worktree: project.canonical, vcs: vcs ?? null },
-      setWhere: or(
-        ne(ProjectTable.worktree, project.canonical),
-        vcs ? or(isNull(ProjectTable.vcs), ne(ProjectTable.vcs, vcs)) : isNotNull(ProjectTable.vcs),
-      ),
-    })
-    .run()
-}
@@ -3,7 +3,7 @@ export * from "./session/schema"

 import { Effect, Layer, Schema, Context, Stream, Scope } from "effect"
 import { ListAnchor } from "@opencode-ai/schema/session"
-import { and, asc, desc, eq, gt, isNull, like, lt, or, type SQL } from "drizzle-orm"
+import { and, asc, desc, eq, gt, isNotNull, isNull, like, lt, ne, or, type SQL } from "drizzle-orm"
 import { Project } from "./project"
 import { Workspace } from "./workspace"
 import { Model } from "./model"
@@ -21,7 +21,7 @@ import { Agent } from "./agent"
 import { Money } from "@opencode-ai/schema/money"
 import { App } from "./app"
 import { Slug } from "./util/slug"
-import { upsertProject } from "./project/sql"
+import { ProjectTable } from "./project/sql"
 import path from "path"
 import { fromRow } from "./session/info"
 import { SessionRunner } from "./session/runner/index"
@@ -309,7 +309,22 @@ const layer = Layer.effect(
    const shellLocks = KeyedMutex.makeUnsafe<SessionSchema.ID>()
    const decodeMessage = Schema.decodeUnknownEffect(SessionMessage.Info)
    const isDurableSessionEvent = Schema.is(SessionEvent.Durable)
-    const persistProject = (project: Project.Resolved) => upsertProject(db, project).pipe(Effect.orDie)
+    const persistProject = (project: Project.Resolved) => {
+      const vcs = project.vcs?.type
+      return db
+        .insert(ProjectTable)
+        .values({ id: project.id, worktree: project.canonical, vcs, sandboxes: [] })
+        .onConflictDoUpdate({
+          target: ProjectTable.id,
+          set: { worktree: project.canonical, vcs: vcs ?? null },
+          setWhere: or(
+            ne(ProjectTable.worktree, project.canonical),
+            vcs ? or(isNull(ProjectTable.vcs), ne(ProjectTable.vcs, vcs)) : isNotNull(ProjectTable.vcs),
+          ),
+        })
+        .run()
+        .pipe(Effect.orDie)
+    }
    const decode = (row: typeof SessionMessageTable.$inferSelect) =>
      decodeMessage({ ...row.data, id: row.id, type: row.type }).pipe(
        Effect.mapError(
@@ -701,11 +716,10 @@ const layer = Layer.effect(
            .pipe(Effect.ignore, Effect.forkIn(scope, { startImmediately: true }), Effect.asVoid)
      }),
      switchAgent: Effect.fn("Session.switchAgent")(function* (input) {
-        const session = yield* result.get(input.sessionID)
+        yield* result.get(input.sessionID)
        yield* bus.publish(SessionEvent.AgentSelected, {
          sessionID: input.sessionID,
          agent: input.agent,
-          previous: session.agent,
        })
      }),
      switchModel: Effect.fn("Session.switchModel")(function* (input) {
@@ -719,7 +733,6 @@ const layer = Layer.effect(
        yield* bus.publish(SessionEvent.ModelSelected, {
          sessionID: input.sessionID,
          model: input.model,
-          previous: session.model,
        })
      }),
      rename: Effect.fn("Session.rename")(function* (input) {
@@ -61,7 +61,7 @@ export function update(adapter: Adapter, event: SessionEvent.DurableEvent) {
      "session.usage.recorded": () => Effect.void,
      "session.agent.selected": (event) => {
        return Effect.gen(function* () {
-          const previous = event.data.previous ?? (yield* adapter.getAgent())
+          const previous = yield* adapter.getAgent()
          yield* adapter.appendMessage(
            SessionMessage.AgentSelected.make({
              id: SessionMessage.ID.fromEvent(event.id),
@@ -76,7 +76,7 @@ export function update(adapter: Adapter, event: SessionEvent.DurableEvent) {
      },
      "session.model.selected": (event) => {
        return Effect.gen(function* () {
-          const previous = event.data.previous ?? (yield* adapter.getModel())
+          const previous = yield* adapter.getModel()
          yield* adapter.appendMessage(
            SessionMessage.ModelSelected.make({
              id: SessionMessage.ID.fromEvent(event.id),
@@ -65,15 +65,15 @@ const userAttachmentContent = (files: readonly FileAttachment[]) => {
  )
  if (eligible.length < 2) return files.flatMap(attachmentContent)

-  const seen = new Map<string, Set<string>>()
+  const seen = new Map<string, string[]>()
  return files.flatMap((file) => {
    if (!imageMimes.has(file.mime) || file.source.type !== "inline" || !file.mention?.text)
      return attachmentContent(file)
    const metadata = JSON.stringify([file.mime, file.name ?? null, file.description ?? null, file.mention.text])
-    const payloads = seen.get(metadata) ?? new Set<string>()
-    if (payloads.has(file.data)) return []
-    payloads.add(file.data)
-    seen.set(metadata, payloads)
+    const matches = seen.get(metadata)
+    if (matches?.includes(file.data)) return []
+    if (matches) matches.push(file.data)
+    if (!matches) seen.set(metadata, [file.data])
    return attachmentContent(file)
  })
 }
@@ -3,7 +3,7 @@ export * as SessionTransfer from "./transfer"
 import { SessionTransfer } from "@opencode-ai/schema/session-transfer"
 import { Tool } from "@opencode-ai/schema/tool"
 import { Skill } from "@opencode-ai/schema/skill"
-import { eq } from "drizzle-orm"
+import { eq, isNotNull, isNull, ne, or } from "drizzle-orm"
 import { Context, DateTime, Effect, Layer, Schema } from "effect"
 import path from "path"
 import { makeGlobalNode } from "@opencode-ai/util/effect/app-node"
@@ -12,7 +12,7 @@ import { Bus } from "../bus"
 import { Database } from "../database/database"
 import { Location } from "../location"
 import { Project } from "../project"
-import { upsertProject } from "../project/sql"
+import { ProjectTable } from "../project/sql"
 import { AbsolutePath, RelativePath } from "../schema"
 import { Session } from "../session"
 import { Slug } from "../util/slug"
@@ -49,7 +49,22 @@ const layer = Layer.effect(
    const sessions = yield* Session.Service
    const encodeMessage = Schema.encodeSync(SessionMessage.Info)

-    const persistProject = (project: Project.Resolved) => upsertProject(db, project).pipe(Effect.orDie)
+    const persistProject = (project: Project.Resolved) => {
+      const vcs = project.vcs?.type
+      return db
+        .insert(ProjectTable)
+        .values({ id: project.id, worktree: project.canonical, vcs, sandboxes: [] })
+        .onConflictDoUpdate({
+          target: ProjectTable.id,
+          set: { worktree: project.canonical, vcs: vcs ?? null },
+          setWhere: or(
+            ne(ProjectTable.worktree, project.canonical),
+            vcs ? or(isNull(ProjectTable.vcs), ne(ProjectTable.vcs, vcs)) : isNotNull(ProjectTable.vcs),
+          ),
+        })
+        .run()
+        .pipe(Effect.orDie)
+    }

    return Service.of({
      export: Effect.fn("SessionTransfer.export")(function* (input) {
@@ -21,7 +21,7 @@ Usage notes:
 - If you recommend a specific option, make that the first option in the list and add "(Recommended)" at the end of the label`

 export const Input = Schema.Struct({
-  questions: Schema.Array(Question.Prompt).check(Schema.isNonEmpty()).annotate({ description: "Questions to ask" }),
+  questions: Schema.NonEmptyArray(Question.Prompt).annotate({ description: "Questions to ask" }),
 })

 export const Output = Schema.Struct({
@@ -275,73 +275,6 @@ it.effect("projects replay metadata onto AI SDK prompt parts", () =>
  }),
 )

-it.effect("preserves tool result content in AI SDK prompts", () =>
-  Effect.gen(function* () {
-    const aisdk = yield* AISDK.Service
-    yield* aisdk.hook.sdk((event) => {
-      event.sdk = { languageModel: () => ({ provider: event.model.providerID }) }
-    })
-
-    const resolved = yield* aisdk.model(model("test-ai-sdk"))
-    const prepared = yield* compileRequest(
-      LLM.request({
-        model: resolved,
-        messages: [
-          Message.tool({
-            id: "call_1",
-            name: "read",
-            result: {
-              type: "content",
-              value: [
-                { type: "text", text: "attachments" },
-                { type: "file", uri: "data:image/png;base64,AAAA", mime: "image/png", name: "pixel.png" },
-                {
-                  type: "file",
-                  uri: "data:application/pdf;charset=utf-8;base64,JVBERg==",
-                  mime: "application/pdf",
-                  name: "document.pdf",
-                },
-                { type: "file", uri: "data:audio/mpeg;base64,SUQz", mime: "audio/mpeg", name: "clip.mp3" },
-                { type: "file", uri: "https://example.com/pixel.png", mime: "image/png" },
-                { type: "file", uri: "https://example.com/document.pdf", mime: "application/pdf" },
-              ],
-            },
-          }),
-        ],
-      }),
-    )
-
-    expect(prepared.body.prompt).toEqual([
-      {
-        role: "tool",
-        content: [
-          {
-            type: "tool-result",
-            toolCallId: "call_1",
-            toolName: "read",
-            output: {
-              type: "content",
-              value: [
-                { type: "text", text: "attachments" },
-                { type: "image-data", data: "AAAA", mediaType: "image/png" },
-                {
-                  type: "file-data",
-                  data: "JVBERg==",
-                  mediaType: "application/pdf",
-                  filename: "document.pdf",
-                },
-                { type: "file-data", data: "SUQz", mediaType: "audio/mpeg", filename: "clip.mp3" },
-                { type: "image-url", url: "https://example.com/pixel.png" },
-                { type: "file-url", url: "https://example.com/document.pdf" },
-              ],
-            },
-          },
-        ],
-      },
-    ])
-  }),
-)
-
 it.effect("emits malformed AI SDK tool input without executing it", () =>
  Effect.gen(function* () {
    const aisdk = yield* AISDK.Service
@@ -168,75 +168,6 @@ describe("PluginSupervisor config", () => {
    ),
  )

-  it.live("loads auto-discovered plugin package entrypoints in order", () =>
-    withLocation(
-      undefined,
-      Effect.gen(function* () {
-        yield* ready()
-        const plugins = yield* Plugin.Service
-        const ids = (yield* plugins.list()).map((plugin) => String(plugin.id))
-        expect(ids).toContain("package-exports")
-        expect(ids).toContain("package-module")
-        expect(ids).toContain("package-main")
-        expect(ids).toContain("package-index")
-      }),
-      false,
-      async (directory) => {
-        await Promise.all([
-          writeDiscoveredPackage(directory, "exports", { exports: "./entry.ts" }, { "entry.ts": "package-exports" }),
-          writeDiscoveredPackage(
-            directory,
-            "module",
-            { exports: "./missing.js", module: "./entry.js" },
-            { "entry.js": "package-module" },
-          ),
-          writeDiscoveredPackage(
-            directory,
-            "main",
-            { exports: { import: "./missing.js" }, module: "./missing.js", main: "./entry.js" },
-            { "entry.js": "package-main" },
-          ),
-          writeDiscoveredPackage(directory, "index", undefined, { "index.js": "package-index" }),
-        ])
-      },
-    ),
-  )
-
-  it.live("keeps auto-discovered package entrypoints inside the package directory", () =>
-    withLocation(
-      undefined,
-      Effect.gen(function* () {
-        yield* ready()
-        const plugins = yield* Plugin.Service
-        const ids = (yield* plugins.list()).map((plugin) => String(plugin.id))
-        expect(ids).toContain("contained-fallback")
-        expect(ids).toContain("symlink-fallback")
-        expect(ids).not.toContain("escaped-entrypoint")
-      }),
-      false,
-      async (directory) => {
-        await fs.mkdir(path.join(directory, ".opencode"), { recursive: true })
-        await fs.writeFile(path.join(directory, ".opencode", "escape.js"), discoveredPlugin("escaped-entrypoint"))
-        await writeDiscoveredPackage(
-          directory,
-          "contained",
-          { exports: "../../escape.js" },
-          { "index.js": "contained-fallback" },
-        )
-        await writeDiscoveredPackage(
-          directory,
-          "symlink",
-          { exports: "./entry.js" },
-          { "index.js": "symlink-fallback" },
-        )
-        await fs.symlink(
-          path.join(directory, ".opencode", "escape.js"),
-          path.join(directory, ".opencode", "plugins", "symlink", "entry.js"),
-        )
-      },
-    ),
-  )
-
  staticIt.live("uses only internal and SDK plugins when the static source is wired", () =>
    Effect.gen(function* () {
      const sdk = yield* SdkPlugins.Service
@@ -458,21 +389,3 @@ export default Plugin.define({
 })
 `
 }
-
-function discoveredPlugin(id: string) {
-  return `export default { id: ${JSON.stringify(id)}, setup() {} }`
-}
-
-async function writeDiscoveredPackage(
-  directory: string,
-  name: string,
-  manifest: Record<string, unknown> | undefined,
-  files: Record<string, string>,
-) {
-  const plugin = path.join(directory, ".opencode", "plugins", name)
-  await fs.mkdir(plugin, { recursive: true })
-  await Promise.all([
-    ...(manifest ? [fs.writeFile(path.join(plugin, "package.json"), JSON.stringify(manifest))] : []),
-    ...Object.entries(files).map(([file, id]) => fs.writeFile(path.join(plugin, file), discoveredPlugin(id))),
-  ])
-}
@@ -204,7 +204,7 @@ describe("doStream", () => {
      finishReason: { unified: "tool-calls" },
      usage: {
        inputTokens: { total: 19581 },
-        outputTokens: { total: 53 },
+        outputTokens: { total: 187, reasoning: 134 },
      },
    })
  })
@@ -259,7 +259,7 @@ describe("doStream", () => {
      finishReason: { unified: "stop" },
      usage: {
        inputTokens: { total: 5778 },
-        outputTokens: { total: 59 },
+        outputTokens: { total: 154, reasoning: 95 },
      },
      providerMetadata: {
        copilot: {
@@ -391,7 +391,7 @@ describe("doStream", () => {
      finishReason: { unified: "tool-calls" },
      usage: {
        inputTokens: { total: 3767 },
-        outputTokens: { total: 19 },
+        outputTokens: { total: 30, reasoning: 11 },
      },
    })
  })
@@ -185,15 +185,6 @@ const buildLayer = (state: Ref.Ref<MockState>, cache: MockCache, options: Models
    ]),
  )

-// Mirrors production KV backends whose writes die as defects (e.g. Durable
-// Object SQLite rejecting values over its 2 MB cap with EffectDrizzleQueryError).
-const makeFailingWriteKV = (cache: MockCache) =>
-  Layer.mock(KV.Service, {
-    get: (key) => Effect.sync(() => cache.values.get(key)),
-    set: () => Effect.die(new Error('Failed query: insert into "kv"')),
-    remove: (key) => Effect.sync(() => cache.values.delete(key)).pipe(Effect.asVoid),
-  })
-
 const makeCache = (): MockCache => ({ values: new Map() })

 const writeCacheText = (cache: MockCache, text: string, updatedAt = Date.now()) =>
@@ -257,25 +248,6 @@ describe("ModelsDev Service", () => {
    }),
  )

-  it.live("get() still populates the catalog when the KV cache write fails", () =>
-    Effect.gen(function* () {
-      const cache = makeCache()
-      const state = yield* Ref.make({ ...initialState, body: JSON.stringify(fixture2) })
-      const layer = Layer.fresh(
-        AppNodeBuilder.build(ModelsDev.node, [
-          [ModelsDev.node, ModelsDev.configured({ fetch: true })],
-          [LayerNodePlatform.httpClient, Layer.succeed(HttpClient.HttpClient, makeMockClient(state))],
-          [KV.node, makeFailingWriteKV(cache)],
-        ]),
-      )
-      const result = yield* ModelsDev.Service.use((s) => s.get()).pipe(Effect.provide(layer))
-      expect(result).toEqual(fixture2Snapshot)
-      expect(cache.values.has(cacheKey)).toBe(false)
-      const final = yield* Ref.get(state)
-      expect(final.calls.length).toBe(1)
-    }),
-  )
-
  it.live("uses the default models URL when the configured URL is empty", () =>
    Effect.gen(function* () {
      const cache = makeCache()
@@ -1,5 +1,4 @@
 import { describe, expect } from "bun:test"
-import { ToolFailure } from "@opencode-ai/ai"
 import { Context, Effect, Exit, Fiber, Schema, Stream } from "effect"
 import { Plugin as EffectPlugin } from "@opencode-ai/plugin/effect"
 import { Config as ConfigSchema } from "@opencode-ai/schema/config"
@@ -396,51 +395,4 @@ describe("Plugin", () => {
      })
    }),
  )
-
-  it.effect("rejects tool execution when an execute.before hook fails", () =>
-    Effect.gen(function* () {
-      const plugins = yield* Plugin.Service
-      const registry = yield* Tool.Service
-      const executed: unknown[] = []
-
-      const plugin = EffectPlugin.define({
-        id: "tool-hook-reject",
-        effect: (ctx) =>
-          Effect.gen(function* () {
-            yield* ctx.tool
-              .transform((draft) =>
-                draft.add({
-                  name: "echo",
-                  options: { codemode: false },
-                  description: "Echo",
-                  input: Schema.Struct({ text: Schema.String }),
-                  output: Schema.Struct({ text: Schema.String }),
-                  execute: ({ text }) =>
-                    Effect.sync(() => executed.push({ text })).pipe(Effect.as({ output: { text } })),
-                }),
-              )
-              .pipe(Effect.orDie)
-
-            yield* ctx.tool
-              .hook("execute.before", () => new ToolFailure({ message: "write disabled" }))
-              .pipe(Effect.asVoid)
-          }),
-      })
-
-      yield* plugins.activate([versioned(plugin)])
-
-      const toolSet = yield* registry.snapshot()
-      const failure = yield* toolSet
-        .execute({
-          sessionID: Session.ID.make("ses_hook_reject"),
-          agent: Agent.ID.make("build"),
-          messageID: SessionMessage.ID.make("msg_hook_reject"),
-          call: { type: "tool-call", id: "call-hook-reject", name: "echo", input: { text: "original" } },
-        })
-        .pipe(Effect.flip)
-
-      expect(failure).toMatchObject({ _tag: "Tool.Error", message: "write disabled" })
-      expect(executed).toEqual([])
-    }),
-  )
 })
@@ -215,66 +215,6 @@ describe("ModelsDevPlugin", () => {
    }),
  )

-  it.effect("omits deprecated models from the catalog", () =>
-    Effect.gen(function* () {
-      const integrations = yield* Integration.Service
-      const catalog = yield* Catalog.Service
-      const providerID = Provider.ID.make("acme")
-      const activeID = Model.ID.make("current")
-      const deprecatedID = Model.ID.make("legacy")
-      const model = {
-        modelID: activeID,
-        providerID,
-        name: "Current",
-        capabilities: { tools: true, input: [], output: [] },
-        variants: [],
-        time: { released: Date.parse("2026-01-01") },
-        cost: [],
-        status: "active",
-        enabled: true,
-        limit: { context: 128_000, output: 32_000 },
-      } satisfies Omit<Model.Info, "id">
-      const snapshots = [
-        {
-          info: {
-            id: providerID,
-            name: "Acme",
-            package: Provider.aisdk("@ai-sdk/openai-compatible"),
-          },
-          environment: [],
-          models: [
-            { id: activeID, ...model },
-            {
-              id: deprecatedID,
-              ...model,
-              modelID: deprecatedID,
-              name: "Legacy",
-              status: "deprecated" as const,
-            },
-          ],
-        },
-      ] satisfies readonly ModelsDev.Snapshot[]
-
-      yield* ModelsDevPlugin.effect(
-        host({
-          catalog: catalogHost(catalog),
-          integration: integrationHost(integrations),
-        }),
-      ).pipe(
-        Effect.provideService(
-          ModelsDev.Service,
-          ModelsDev.Service.of({
-            get: () => Effect.succeed(snapshots),
-            refresh: () => Effect.void,
-          }),
-        ),
-      )
-
-      expect(yield* catalog.model.get(providerID, activeID)).toBeDefined()
-      expect(yield* catalog.model.get(providerID, deprecatedID)).toBeUndefined()
-    }),
-  )
-
  it.effect("registers key methods for providers with environment variables", () =>
    Effect.gen(function* () {
      const integrations = yield* Integration.Service
@@ -1,18 +1,18 @@
 import { describe, expect } from "bun:test"
+import { NodeFileSystem } from "@effect/platform-node"
+import { Config } from "@opencode-ai/core/config"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
-import { ConfigPluginSource } from "@opencode-ai/core/config/plugin/source"
-import { Effect, Layer, Stream } from "effect"
+import { FSUtil } from "@opencode-ai/util/fs-util"
+import { Location } from "@opencode-ai/core/location"
+import { Effect, Stream } from "effect"
 import { SkillPlugin } from "@opencode-ai/core/plugin/skill"
+import { AbsolutePath } from "@opencode-ai/core/schema"
 import { Skill } from "@opencode-ai/core/skill"
+import { location } from "../fixture/location"
 import { testEffect } from "../lib/effect"
 import { host } from "./host"

 const it = testEffect(AppNodeBuilder.build(Skill.node))
-const sources = (operations: readonly ConfigPluginSource.Operation[] = []) =>
-  Layer.succeed(
-    ConfigPluginSource.Service,
-    ConfigPluginSource.Service.of({ operations: () => Effect.succeed(operations), changes: () => Stream.never }),
-  )

 describe("SkillPlugin.Plugin", () => {
  it.effect("registers built-in skills", () =>
@@ -27,7 +27,15 @@ describe("SkillPlugin.Plugin", () => {
            reload: skill.reload,
          },
        }),
-      ).pipe(Effect.provide(sources()))
+      ).pipe(
+        Effect.provide(Config.testLayer()),
+        Effect.provideService(
+          Location.Service,
+          Location.Service.of(location({ directory: AbsolutePath.make(import.meta.dir) })),
+        ),
+        Effect.provide(AppNodeBuilder.build(FSUtil.node)),
+        Effect.provide(NodeFileSystem.layer),
+      )
      const skills = yield* skill.list()
      const report = skills.find((item) => item.id === "report")

@@ -50,30 +58,4 @@ describe("SkillPlugin.Plugin", () => {
      expect(report?.content).toContain("- install/channel: beta")
    }),
  )
-
-  it.effect("reports canonical configured plugin sources with existing labels and ordering", () =>
-    Effect.gen(function* () {
-      const skill = yield* Skill.Service
-      yield* SkillPlugin.Plugin.effect(
-        host({
-          skill: {
-            list: () => Effect.die("unused skill.list"),
-            transform: skill.transform,
-            reload: skill.reload,
-          },
-        }),
-      )
-      const report = (yield* skill.list()).find((item) => item.id === "report")
-      expect(report?.content).toContain("- Active plugins: -disabled, local.ts, package-plugin, package-plugin")
-    }).pipe(
-      Effect.provide(
-        sources([
-          { type: "add", target: "package-plugin", options: {} },
-          { type: "remove", target: "disabled" },
-          { type: "add", target: "local.ts", options: {}, mtime: 1 },
-          { type: "add", target: "package-plugin", options: { enabled: true } },
-        ]),
-      ),
-    ),
-  )
 })
@@ -654,7 +654,7 @@ describe("Session.create", () => {
      expect(yield* session.get(created.id)).toMatchObject({ agent: "plan" })
      expect(
        Array.from(yield* logEvents(session, created.id, true).pipe(Stream.drop(1), Stream.take(1), Stream.runCollect)),
-      ).toMatchObject([{ type: "session.agent.selected", data: { agent: "plan", previous: "build" } }])
+      ).toMatchObject([{ type: "session.agent.selected", data: { agent: "plan" } }])
      expect(yield* session.messages({ sessionID: created.id, order: "asc" })).toMatchObject([
        { type: "agent-switched", agent: "plan", previous: "build" },
      ])
@@ -678,12 +678,7 @@ describe("Session.create", () => {
  it.effect("switches the selected model through the durable Session event", () =>
    Effect.gen(function* () {
      const session = yield* Session.Service
-      const previous = Model.Ref.make({
-        id: Model.ID.make("haiku"),
-        providerID: Provider.ID.anthropic,
-        variant: Model.VariantID.make("default"),
-      })
-      const created = yield* session.create({ location, model: previous })
+      const created = yield* session.create({ location })
      const model = Model.Ref.make({
        id: Model.ID.make("sonnet"),
        providerID: Provider.ID.anthropic,
@@ -697,10 +692,7 @@ describe("Session.create", () => {
        yield* logEvents(session, created.id, true).pipe(Stream.drop(1), Stream.take(1), Stream.runCollect),
      )
      expect(bus).toMatchObject([{ type: "session.model.selected" }])
-      expect(bus[0]?.data).toEqual({ sessionID: created.id, model, previous })
-      expect(yield* session.messages({ sessionID: created.id, order: "asc" })).toMatchObject([
-        { type: "model-switched", model, previous },
-      ])
+      expect(bus[0]?.data).toEqual({ sessionID: created.id, model })
    }),
  )

@@ -89,30 +89,6 @@ const it = testEffect(
 )

 describe("QuestionTool", () => {
-  it.effect("emits one item schema for the nonempty questions array", () =>
-    Effect.gen(function* () {
-      captured = undefined
-      const registry = yield* Tool.Service
-      const definition = (yield* toolDefinitions(registry)).find((tool) => tool.name === QuestionTool.name)
-
-      expect(definition?.inputSchema).toHaveProperty("properties.questions.type", "array")
-      expect(definition?.inputSchema).toHaveProperty("properties.questions.minItems", 1)
-      expect(definition?.inputSchema).toHaveProperty("properties.questions.items")
-      expect(definition?.inputSchema).not.toHaveProperty("properties.questions.prefixItems")
-      expect(
-        yield* executeTool(registry, {
-          sessionID,
-          ...toolIdentity,
-          call: { type: "tool-call", id: "call-question-empty", name: QuestionTool.name, input: { questions: [] } },
-        }),
-      ).toMatchObject({
-        status: "error",
-        error: { type: "tool.execution", message: expect.stringContaining("Invalid tool input") },
-      })
-      expect(capturedInput()).toBeUndefined()
-    }),
-  )
-
  it.effect("omits a catalog-denied question and enforces its leaf permission", () =>
    Effect.gen(function* () {
      captured = undefined
@@ -11,7 +11,7 @@ import { Project } from "@opencode-ai/core/project"
 import { ProjectTable } from "@opencode-ai/core/project/sql"
 import { AbsolutePath } from "@opencode-ai/core/schema"
 import { Global } from "@opencode-ai/util/global"
-import { Effect, Fiber, Layer, Logger, Schedule, Schema, Scope } from "effect"
+import { Effect, Layer, Logger, Schedule, Schema, Scope } from "effect"
 import { eq, sql } from "drizzle-orm"
 import type { SqlClient } from "effect/unstable/sql/SqlClient"
 import { tmpdir } from "./fixture/tmpdir"
@@ -798,35 +798,6 @@ describe("V1Migration database workflow", () => {
    )
  })

-  test("yields while clearing stale events in batches", async () => {
-    await database(
-      Effect.gen(function* () {
-        const { db } = yield* Database.Service
-        yield* db.run(sql`INSERT INTO event_sequence (aggregate_id, seq) VALUES ('stale', 2500)`)
-        yield* db.run(sql`
-          WITH RECURSIVE rows(value) AS (
-            VALUES(1)
-            UNION ALL
-            SELECT value + 1 FROM rows WHERE value < 2500
-          )
-          INSERT INTO event (id, aggregate_id, seq, created, type, data)
-          SELECT printf('event_%04d', value), 'stale', value, 1, 'session.renamed.1', '{}'
-          FROM rows
-        `)
-        let yielded = false
-        const heartbeat = yield* Effect.yieldNow.pipe(
-          Effect.andThen(Effect.sync(() => (yielded = true))),
-          Effect.forkChild({ startImmediately: true }),
-        )
-
-        expect(yield* V1Migration.run()).toEqual({ status: "completed" })
-        expect(yielded).toBe(true)
-        yield* Fiber.join(heartbeat)
-        expect(yield* db.get<{ value: number }>(sql`SELECT COUNT(*) AS value FROM event`)).toEqual({ value: 0 })
-      }),
-    )
-  })
-
  test("imports previous V2 sessions and messages as part of the migration", async () => {
    await using tmp = await tmpdir()
    const filename = path.join(tmp.path, "opencode-next.db")
@@ -57,35 +57,35 @@ test("keeps a hidden prod launcher for old Linux pins", async () => {
  expect(desktop).toContain("NoDisplay=true")
 })

-for (const channel of ["dev", "beta"] as const) {
-  test(`bundles the CLI outside the ${channel} app archive`, async () => {
+test("bundles the CLI outside the dev app archive", async () => {
+  const previous = process.env.OPENCODE_CHANNEL
+  process.env.OPENCODE_CHANNEL = "dev"
+  const module = await import("./electron-builder.config.ts?cli-resource")
+  const config = module.default as Configuration
+  if (previous === undefined) delete process.env.OPENCODE_CHANNEL
+  else process.env.OPENCODE_CHANNEL = previous
+
+  expect(config.files).toContain("!resources/opencode-cli*")
+  expect(config.extraResources).toContainEqual({
+    from: "resources/",
+    to: "",
+    filter: ["opencode-cli*"],
+  })
+})
+
+for (const channel of ["beta", "prod"] as const) {
+  test(`does not bundle the CLI in ${channel} builds`, async () => {
    const previous = process.env.OPENCODE_CHANNEL
    process.env.OPENCODE_CHANNEL = channel
-    const module = await import(`./electron-builder.config.ts?cli-resource=${channel}`)
+    const module = await import(`./electron-builder.config.ts?no-cli-resource=${channel}`)
    const config = module.default as Configuration
    if (previous === undefined) delete process.env.OPENCODE_CHANNEL
    else process.env.OPENCODE_CHANNEL = previous

-    expect(config.files).toContain("!resources/opencode-cli*")
-    expect(config.extraResources).toContainEqual({
+    expect(config.extraResources).not.toContainEqual({
      from: "resources/",
      to: "",
      filter: ["opencode-cli*"],
    })
  })
 }
-
-test("does not bundle the CLI in prod builds", async () => {
-  const previous = process.env.OPENCODE_CHANNEL
-  process.env.OPENCODE_CHANNEL = "prod"
-  const module = await import("./electron-builder.config.ts?no-cli-resource=prod")
-  const config = module.default as Configuration
-  if (previous === undefined) delete process.env.OPENCODE_CHANNEL
-  else process.env.OPENCODE_CHANNEL = previous
-
-  expect(config.extraResources).not.toContainEqual({
-    from: "resources/",
-    to: "",
-    filter: ["opencode-cli*"],
-  })
-})
@@ -57,7 +57,7 @@ const getBase = (appId: string): Configuration => ({
  },
  files: ["out/**/*", "resources/**/*", "!resources/opencode-cli*"],
  extraResources: [
-    ...(channel !== "prod"
+    ...(channel === "dev"
      ? [
          {
            from: "resources/",
@@ -37,7 +37,6 @@
    "@actions/artifact": "4.0.0",
    "@lydell/node-pty": "catalog:",
    "@opencode-ai/app": "workspace:*",
-    "@opencode-ai/client": "workspace:*",
    "@opencode-ai/ui": "workspace:*",
    "@sentry/solid": "catalog:",
    "@sentry/vite-plugin": "catalog:",
@@ -1,9 +1,9 @@
 import { $ } from "bun"
 import * as path from "node:path"

-import { CLI_TARGET } from "./utils"
+import { RUST_TARGET } from "./utils"

-if (!CLI_TARGET) throw new Error("OPENCODE_CLI_TARGET not defined")
+if (!RUST_TARGET) throw new Error("RUST_TARGET not defined")

 const BUNDLE_DIR = "dist"
 const BUNDLES_OUT_DIR = path.join(process.cwd(), "dist/bundles")
@@ -8,4 +8,3 @@ await $`bun ./scripts/copy-icons.ts ${channel}`
 await $`bun ./scripts/copy-metainfo.ts ${channel}`

 if (channel === "dev") await downloadCliToResources()
-if (channel === "beta") await downloadCliToResources("next")
@@ -13,46 +13,46 @@ export function resolveChannel(): Channel {
  return "dev"
 }

-export const CLI_BINARIES: Array<{ target: string; package: string; os: string; cpu: string }> = [
+export const CLI_BINARIES: Array<{ rustTarget: string; package: string; os: string; cpu: string }> = [
  {
-    target: "aarch64-apple-darwin",
+    rustTarget: "aarch64-apple-darwin",
    package: "@opencode-ai/cli-darwin-arm64",
    os: "darwin",
    cpu: "arm64",
  },
  {
-    target: "x86_64-apple-darwin",
+    rustTarget: "x86_64-apple-darwin",
    package: "@opencode-ai/cli-darwin-x64-baseline",
    os: "darwin",
    cpu: "x64",
  },
  {
-    target: "aarch64-pc-windows-msvc",
+    rustTarget: "aarch64-pc-windows-msvc",
    package: "@opencode-ai/cli-windows-arm64",
    os: "win32",
    cpu: "arm64",
  },
  {
-    target: "x86_64-pc-windows-msvc",
+    rustTarget: "x86_64-pc-windows-msvc",
    package: "@opencode-ai/cli-windows-x64-baseline",
    os: "win32",
    cpu: "x64",
  },
  {
-    target: "x86_64-unknown-linux-gnu",
+    rustTarget: "x86_64-unknown-linux-gnu",
    package: "@opencode-ai/cli-linux-x64-baseline",
    os: "linux",
    cpu: "x64",
  },
  {
-    target: "aarch64-unknown-linux-gnu",
+    rustTarget: "aarch64-unknown-linux-gnu",
    package: "@opencode-ai/cli-linux-arm64",
    os: "linux",
    cpu: "arm64",
  },
 ]

-export const CLI_TARGET = Bun.env.OPENCODE_CLI_TARGET
+export const RUST_TARGET = Bun.env.RUST_TARGET

 function nativeTarget() {
  const { platform, arch } = process
@@ -62,19 +62,19 @@ function nativeTarget() {
  throw new Error(`Unsupported platform: ${platform}/${arch}`)
 }

-export function getCurrentCli(target = CLI_TARGET ?? nativeTarget()) {
-  const binaryConfig = CLI_BINARIES.find((item) => item.target === target)
+export function getCurrentCli(target = RUST_TARGET ?? nativeTarget()) {
+  const binaryConfig = CLI_BINARIES.find((item) => item.rustTarget === target)
  if (!binaryConfig) throw new Error(`CLI configuration not available for target '${target}'`)

  return binaryConfig
 }

-export async function downloadCliToResources(version = CLI_VERSION) {
+export async function downloadCliToResources() {
  const cli = getCurrentCli()
  const directory = await mkdtemp(join(tmpdir(), "opencode-cli-"))
  const dest = windowsify("resources/opencode-cli")
  try {
-    await $`bun install --no-save --cwd ${directory} ${`${cli.package}@${version}`} ${`--os=${cli.os}`} ${`--cpu=${cli.cpu}`}`
+    await $`bun install --no-save --cwd ${directory} ${`${cli.package}@${CLI_VERSION}`} ${`--os=${cli.os}`} ${`--cpu=${cli.cpu}`}`
    await copyFile(
      join(directory, "node_modules", cli.package, "bin", cli.os === "win32" ? "opencode2.exe" : "opencode2"),
      dest,
@@ -88,7 +88,7 @@ export async function downloadCliToResources(version = CLI_VERSION) {
  }
  if (process.platform === "darwin") await $`codesign --force --sign - ${dest}`

-  console.log(`Copied ${cli.package}@${version} to ${dest}`)
+  console.log(`Copied ${cli.package} to ${dest}`)
 }

 export function windowsify(path: string) {
@@ -1,4 +1,3 @@
-import { Service } from "@opencode-ai/client/service"
 import { execFile } from "node:child_process"
 import { existsSync } from "node:fs"
 import { chmod, copyFile, mkdir, rename, rm } from "node:fs/promises"
@@ -9,35 +8,52 @@ import { app } from "electron"

 const execFileAsync = promisify(execFile)
 const root = dirname(fileURLToPath(import.meta.url))
+const stateHome = process.env.XDG_STATE_HOME
+const desktopStateNames = ["ai.opencode.desktop.dev", "ai.opencode.desktop.beta", "ai.opencode.desktop"]

 type Logger = {
  log(message: string, meta?: Record<string, unknown>): void
  error(message: string, meta?: Record<string, unknown>): void
 }

-export async function startBackgroundCli(logger: Logger) {
+export async function startBackgroundCli(logger: Logger, shellStateHome?: string) {
  const bundled = app.isPackaged
    ? join(process.resourcesPath, executableName())
    : join(root, "../../resources", executableName())
  logger.log("v2 CLI executable resolved", { bundled, packaged: app.isPackaged })
-  const version = parseVersion(await run(bundled, ["--version"], logger))
+  const version = await run(bundled, ["--version"], logger)
  const binary = app.isPackaged ? await installCli(bundled, version, logger) : bundled
-  const service = await Service.ensure({
-    version,
-    command: [binary, "serve", "--service"],
-    onStart: (reason, previousVersion) => logger.log("v2 CLI background service starting", { reason, previousVersion }),
+
+  const candidates = [
+    ...new Set([stateHome, shellStateHome, ...desktopStateNames.map((name) => join(app.getPath("appData"), name))]),
+  ].filter((candidate) => candidate === undefined || existsSync(candidate))
+  const discovered = await Promise.all(
+    candidates.map(async (candidate) => ({
+      stateHome: candidate,
+      url: serviceUrl(await run(binary, ["service", "status"], logger, { stateHome: candidate })),
+    })),
+  )
+  const found = discovered.find((candidate) => candidate.url !== undefined)
+  logger.log("v2 CLI background instance checked", {
+    detected: Boolean(found),
+    ...endpoint(found?.url),
+  })
+
+  const daemonStateHome = found?.stateHome ?? stateHome
+  const url = await run(binary, ["service", "start"], logger, { stateHome: daemonStateHome })
+  const password = await run(binary, ["service", "get", "password"], logger, {
+    redact: true,
+    stateHome: daemonStateHome,
  })
-  if (service.auth?.type !== "basic") throw new Error("V2 CLI background service did not provide authentication")
  logger.log("v2 CLI background service ready", {
-    username: service.auth.username,
-    version,
-    ...endpoint(service.url),
+    existing: Boolean(found),
+    username: "opencode",
+    ...endpoint(url),
  })
  return {
-    url: service.url,
-    username: service.auth.username,
-    password: service.auth.password,
-    version,
+    url,
+    username: "opencode",
+    password,
  }
 }

@@ -61,13 +77,21 @@ async function installCli(source: string, version: string, logger: Logger) {
  return destination
 }

-async function run(binary: string, args: string[], logger: Logger) {
+async function run(
+  binary: string,
+  args: string[],
+  logger: Logger,
+  options: { redact?: boolean; stateHome?: string } = {},
+) {
  logger.log("v2 CLI command started", { binary, args })
-  return execFileAsync(binary, args, { windowsHide: true }).then(
+  const env = { ...process.env }
+  if (options.stateHome === undefined) delete env.XDG_STATE_HOME
+  else env.XDG_STATE_HOME = options.stateHome
+  return execFileAsync(binary, args, { env, windowsHide: true }).then(
    (result) => {
      const stdout = result.stdout.trim()
      const stderr = result.stderr.trim()
-      logger.log("v2 CLI command completed", { args, stdout, stderr })
+      logger.log("v2 CLI command completed", { args, stdout: options.redact ? "[redacted]" : stdout, stderr })
      return stdout
    },
    (error: unknown) => {
@@ -75,7 +99,7 @@ async function run(binary: string, args: string[], logger: Logger) {
      logger.error("v2 CLI command failed", {
        args,
        error: error instanceof Error ? error.message : String(error),
-        stdout: output.stdout?.trim() ?? "",
+        stdout: options.redact && output.stdout ? "[redacted]" : (output.stdout?.trim() ?? ""),
        stderr: output.stderr?.trim() ?? "",
      })
      throw error
@@ -83,11 +107,11 @@ async function run(binary: string, args: string[], logger: Logger) {
  )
 }

-function parseVersion(output: string) {
-  const marker = output.lastIndexOf(" v")
-  const version = marker === -1 ? output : output.slice(marker + 2)
-  if (!version) throw new Error("V2 CLI did not provide a version")
-  return version
+function serviceUrl(status: string) {
+  if (URL.canParse(status)) return status
+  if (!status.startsWith("running ")) return
+  const url = status.slice("running ".length).trim()
+  return URL.canParse(url) ? url : undefined
 }

 function endpoint(url: string | undefined) {
@@ -134,10 +134,10 @@ const main = Effect.gen(function* () {
  initCrashReporter()

  const wslServers = createWslServersController(
-    CHANNEL === "beta" ? null : app.getVersion(),
-    async (distro, version, channel) => {
+    app.getVersion(),
+    async (distro) => {
      logger.log("spawning wsl sidecar", { distro })
-      return spawnWslSidecar(distro, version, channel, {
+      return spawnWslSidecar(distro, {
        onLine: (line) => logger.log("wsl sidecar", { distro, stream: line.stream, text: line.text }),
      })
    },
@@ -146,7 +146,6 @@ const main = Effect.gen(function* () {
        log: (message, meta) => logger.log(message, meta),
        error: (message, meta) => logger.error(message, meta),
      },
-      channel: CHANNEL,
    },
  )
  const stopSidecars = async () => wslServers.stopAll()
@@ -182,7 +181,7 @@ const main = Effect.gen(function* () {
    return
  }

-  preferAppEnv()
+  const shellEnv = preferAppEnv(app.getPath("userData"))

  app.on("second-instance", (_event: Event, argv: string[]) => {
    const urls = argv.filter((arg: string) => arg.startsWith("opencode://"))
@@ -311,8 +310,7 @@ const main = Effect.gen(function* () {
    useEnvProxy()

    logger.log("starting v2 background service")
-    const sidecar = yield* Effect.promise(() => startBackgroundCli(logger))
-    if (CHANNEL === "beta") wslServers.setCliVersion(sidecar.version)
+    const sidecar = yield* Effect.promise(() => startBackgroundCli(logger, shellEnv?.XDG_STATE_HOME))
    yield* Deferred.succeed(serverReady, {
      url: sidecar.url,
      username: sidecar.username,
@@ -17,16 +17,17 @@ export function setDefaultServerUrl(url: string | null) {
  getStore().delete(DEFAULT_SERVER_URL_KEY)
 }

-export function preferAppEnv() {
+export function preferAppEnv(userDataPath: string) {
  const shell = process.platform === "win32" ? null : getUserShell()
  const shellEnv = shell ? loadShellEnv(shell, getLogger()) : null
-  if (!shellEnv?.XDG_STATE_HOME) delete process.env.XDG_STATE_HOME
  Object.assign(process.env, {
    ...shellEnv,
    OPENCODE_EXPERIMENTAL_ICON_DISCOVERY: "true",
    OPENCODE_EXPERIMENTAL_FILEWATCHER: "true",
    OPENCODE_CLIENT: "desktop",
+    XDG_STATE_HOME: process.env.XDG_STATE_HOME ?? userDataPath,
  })
+  return shellEnv
 }

 export async function checkHealth(url: string, password?: string | null): Promise<boolean> {
@@ -264,22 +264,18 @@ export async function installWslDistro(name: string, opts?: RunWslOptions) {
  )
 }

-export async function installWslOpencode(version: string, channel: string, distro: string, opts?: RunWslOptions) {
+export async function installWslOpencode(version: string, distro: string, opts?: RunWslOptions) {
  return runInteractiveCommand(
    resolveSystem32Command("wsl.exe"),
-    wslArgs(["bash", "-lc", wslOpencodeInstallCommand(version, channel)], distro),
+    wslArgs(
+      ["bash", "-lc", `curl -fsSL https://opencode.ai/install | bash -s -- --version ${shellEscape(version)}`],
+      distro,
+    ),
    withTimeout(opts, DEFAULT_WSL_INSTALL_TIMEOUT_MS),
    DEFAULT_WSL_INSTALL_TIMEOUT_MS,
  )
 }

-export function wslOpencodeInstallCommand(version: string, channel: string) {
-  if (channel === "beta") {
-    return `npm install --global --no-audit --no-fund ${shellEscape(`@opencode-ai/cli@${version}`)}`
-  }
-  return `curl -fsSL https://opencode.ai/install | bash -s -- --version ${shellEscape(version)}`
-}
-
 export async function probeWslDistro(name: string, opts?: RunWslOptions): Promise<WslDistroProbe> {
  const executable = await runWslInDistro(["/bin/true"], name, opts).catch((error) => ({
    code: 1,
@@ -311,22 +307,11 @@ export async function probeWslDistro(name: string, opts?: RunWslOptions): Promis
  }
 }

-export async function resolveWslOpencode(distro: string, channel: string, opts?: RunWslOptions) {
-  if (channel !== "beta") {
-    return firstLine(
-      (
-        await runWslSh(
-          'if [ -x "$HOME/.opencode/bin/opencode" ]; then printf "%s\\n" "$HOME/.opencode/bin/opencode"; fi',
-          distro,
-          opts,
-        )
-      ).stdout,
-    )
-  }
+export async function resolveWslOpencode(distro: string, opts?: RunWslOptions) {
  return firstLine(
    (
      await runWslSh(
-        'PATH=$(awk -v RS=: -v ORS=: \'$0 !~ /^\\/mnt\\//\' <<<"$PATH" | sed "s/:$//"); export PATH; command -v opencode2 || true',
+        'if [ -x "$HOME/.opencode/bin/opencode" ]; then printf "%s\\n" "$HOME/.opencode/bin/opencode"; fi',
        distro,
        opts,
      )
@@ -336,13 +321,7 @@ export async function resolveWslOpencode(distro: string, channel: string, opts?:

 export async function readWslCommandVersion(command: string, distro: string, opts?: RunWslOptions) {
  const result = await runWslSh(`${shellEscape(command)} --version 2>/dev/null || true`, distro, opts)
-  return parseWslOpencodeVersion(firstLine(result.stdout))
-}
-
-export function parseWslOpencodeVersion(output: string | null) {
-  if (!output) return null
-  const marker = output.lastIndexOf(" v")
-  return marker === -1 ? output : output.slice(marker + 2)
+  return firstLine(result.stdout)
 }

 export function openWslTerminal(distro?: string | null) {
@@ -13,10 +13,6 @@ import {
  wslServerIdsToStartOnInitialize,
 } from "./startup"
 import { createWslServersController, type WslServerConfig } from "./servers"
-import {
-  parseWslOpencodeVersion,
-  wslOpencodeInstallCommand,
-} from "./runtime"

 let persistedServers: WslServerConfig[] = []
 let releaseOpencodeResolve: (() => void) | undefined
@@ -37,51 +33,6 @@ test("rejects an update that did not install the desktop version", () => {
  )
 })

-test("installs the exact V2 CLI package through npm", () => {
-  const version = "0.0.0-next-17181"
-  const command = wslOpencodeInstallCommand(version, "beta")
-
-  expect(command).toBe("npm install --global --no-audit --no-fund '@opencode-ai/cli@0.0.0-next-17181'")
-  expect(command).not.toContain("@next")
-  expect(command).not.toContain("https://opencode.ai/install")
-})
-
-test("keeps the curl installer outside the beta channel", () => {
-  expect(wslOpencodeInstallCommand("1.18.16", "prod")).toBe(
-    "curl -fsSL https://opencode.ai/install | bash -s -- --version '1.18.16'",
-  )
-  expect(wslOpencodeInstallCommand("1.18.16", "dev")).toBe(
-    "curl -fsSL https://opencode.ai/install | bash -s -- --version '1.18.16'",
-  )
-})
-
-test("reads the version reported by the V2 binary", () => {
-  expect(parseWslOpencodeVersion("opencode2 v0.0.0-next-17181")).toBe("0.0.0-next-17181")
-  expect(parseWslOpencodeVersion("1.18.16")).toBe("1.18.16")
-})
-
-test("installs the bundled CLI version instead of the Desktop release version", async () => {
-  persistedServers = []
-  let requested: { version: string; channel: string; distro: string } | undefined
-  const controller = createWslServersController(null, async () => new Promise<never>(() => undefined), {
-    channel: "beta",
-    readServers: () => persistedServers,
-    writeServers: () => undefined,
-    resolveOpencode: async () => "/home/me/.npm/bin/opencode2",
-    readCommandVersion: async () => "0.0.0-next-17181",
-    installOpencode: async (version, channel, distro) => {
-      requested = { version, channel, distro }
-      return { code: 0, signal: null, stdout: "", stderr: "" }
-    },
-  })
-  controller.setCliVersion("0.0.0-next-17181")
-
-  await controller.installOpencode("Debian")
-
-  expect(requested).toEqual({ version: "0.0.0-next-17181", channel: "beta", distro: "Debian" })
-  expect(controller.getState().opencodeChecks.Debian?.matchesDesktop).toBe(true)
-})
-
 test("restarts an existing distro server after updating OpenCode", () => {
  expect(
    wslServerIdToRestart(
@@ -104,7 +55,7 @@ test("clears cached distro probes when removing a WSL server", () => {
      {
        Debian: {
          distro: "Debian",
-          resolvedPath: "/home/luke/.local/share/opencode/desktop/beta/1.16.2/opencode2",
+          resolvedPath: "/home/luke/.opencode/bin/opencode",
          version: "1.16.2",
          expectedVersion: "1.16.2",
          matchesDesktop: true,
@@ -213,7 +164,7 @@ test("probes addable distros in parallel before checking OpenCode", async () =>
    },
    resolveOpencode: async (distro) => {
      opencode.push(distro)
-      return "/home/me/.local/share/opencode/desktop/dev/1.16.2/opencode2"
+      return "/home/me/.opencode/bin/opencode"
    },
  })

@@ -244,7 +195,7 @@ test("does not check OpenCode in addable distros that cannot execute commands",
    }),
    resolveOpencode: async (distro) => {
      opencode.push(distro)
-      return "/home/me/.local/share/opencode/desktop/dev/1.16.2/opencode2"
+      return "/home/me/.opencode/bin/opencode"
    },
  })

@@ -274,7 +225,7 @@ function testControllerOptions() {
      await new Promise<void>((resolve) => {
        releaseOpencodeResolve = resolve
      })
-      return "/home/me/.local/share/opencode/desktop/dev/1.16.2/opencode2"
+      return "/home/me/.opencode/bin/opencode"
    },
  }
 }
@@ -37,7 +37,7 @@ type RunningSidecar = {
  password: string
 }

-type SpawnSidecar = (distro: string, version: string, channel: string) => Promise<RunningSidecar>
+type SpawnSidecar = (distro: string) => Promise<RunningSidecar>

 type ControllerLogger = {
  log: (message: string, meta?: unknown) => void
@@ -51,8 +51,6 @@ type WslServersControllerOptions = {
  probeDistro?: typeof probeWslDistro
  resolveOpencode?: typeof resolveWslOpencode
  readCommandVersion?: typeof readWslCommandVersion
-  installOpencode?: typeof installWslOpencode
-  channel?: string
 }

 export type WslServersController = ReturnType<typeof createWslServersController>
@@ -62,7 +60,7 @@ export function wslServerIdForDistro(distro: string) {
 }

 export function createWslServersController(
-  initialCliVersion: string | null,
+  appVersion: string,
  spawnSidecar: SpawnSidecar,
  options?: WslServersControllerOptions,
 ) {
@@ -71,17 +69,10 @@ export function createWslServersController(
  const sidecars = new Map<string, RunningSidecar>()
  const startAttempts = new Map<string, number>()
  let jobAbort: AbortController | undefined
-  let cliVersion = initialCliVersion
  const logger = options?.logger
  const readServers = options?.readServers ?? readPersistedServers
  const writeServers = options?.writeServers ?? writePersistedServers
  const probeDistro = options?.probeDistro ?? probeWslDistro
-  const channel = options?.channel ?? "dev"
-
-  const expectedVersion = () => {
-    if (cliVersion) return cliVersion
-    throw new Error(nativeT("desktop.wsl.error.opencodeCannotRun"))
-  }

  const emit = () => {
    for (const listener of listeners) listener({ type: "state", state })
@@ -141,12 +132,11 @@ export function createWslServersController(
  }

  const checkOpencode = async (distro: string, opts?: { signal?: AbortSignal }) => {
-    const version = expectedVersion()
-    const resolved = await (options?.resolveOpencode ?? resolveWslOpencode)(distro, channel, opts)
-    const installed = resolved
+    const resolved = await (options?.resolveOpencode ?? resolveWslOpencode)(distro, opts)
+    const version = resolved
      ? await (options?.readCommandVersion ?? readWslCommandVersion)(resolved, distro, opts)
      : null
-    return opencodeCheck(distro, resolved, installed, version)
+    return opencodeCheck(distro, resolved, version, appVersion)
  }

  const refreshOpencodeCheck = async (distro: string, opts?: { signal?: AbortSignal }) => {
@@ -239,7 +229,7 @@ export function createWslServersController(
    setRuntime(id, { kind: "starting" })
    logger?.log("wsl sidecar starting", { id, distro: item.config.distro })
    try {
-      const sidecar = await spawnSidecar(item.config.distro, expectedVersion(), channel)
+      const sidecar = await spawnSidecar(item.config.distro)
      if (!isCurrentStartAttempt(id, attempt)) {
        try {
          sidecar.listener.stop()
@@ -304,10 +294,6 @@ export function createWslServersController(
  }

  return {
-    setCliVersion(version: string) {
-      cliVersion = version
-    },
-
    getState() {
      return state
    },
@@ -376,15 +362,12 @@ export function createWslServersController(

    async installOpencode(name: string) {
      await runJob({ kind: "install-opencode", distro: name, startedAt: Date.now() }, async (abort) => {
-        const version = expectedVersion()
-        const result = await (options?.installOpencode ?? installWslOpencode)(version, channel, name, {
-          signal: abort.signal,
-        })
+        const result = await installWslOpencode(appVersion, name, { signal: abort.signal })
        if (result.code !== 0) {
          throw new Error(summarize(result.stderr || result.stdout) || nativeT("desktop.wsl.error.installOpencode"))
        }
        await refreshOpencodeCheck(name, { signal: abort.signal })
-        expectOpencodeVersion(state.opencodeChecks[name]?.version ?? null, version, name)
+        expectOpencodeVersion(state.opencodeChecks[name]?.version ?? null, appVersion, name)
        const id = wslServerIdToRestart(state.servers, name)
        if (id) await startServer(id)
      })
@@ -3,7 +3,7 @@ import { randomUUID } from "node:crypto"
 import { createServer } from "node:net"
 import { app } from "electron"
 import { checkHealth } from "../server"
-import { type WslCommandLine, readWslCommandVersion, resolveWslOpencode, shellEscape, wslArgs } from "./runtime"
+import { type WslCommandLine, resolveWslOpencode, shellEscape, wslArgs } from "./runtime"
 import { pollWslHealth } from "./startup"
 import { nativeT } from "../native-translations"

@@ -16,22 +16,10 @@ export type WslSidecar = {

 export async function spawnWslSidecar(
  distro: string,
-  version: string,
-  channel: string,
  opts: { onLine?: (line: WslCommandLine) => void; healthTimeoutMs?: number } = {},
 ): Promise<WslSidecar> {
-  const opencode = await resolveWslOpencode(distro, channel)
+  const opencode = await resolveWslOpencode(distro)
  if (!opencode) throw new Error(nativeT("desktop.wsl.error.opencodeNotInstalled", { distro }))
-  const installed = await readWslCommandVersion(opencode, distro)
-  if (installed !== version) {
-    throw new Error(
-      nativeT("desktop.wsl.error.updateVersion", {
-        distro,
-        installed: installed ?? nativeT("desktop.wsl.error.noVersion"),
-        expected: version,
-      }),
-    )
-  }

  const port = await allocatePort()
  const password = randomUUID()
@@ -77,21 +77,20 @@ export function spatialPathSpans(points: readonly DiagramPoint[]): SpatialSpan[]
    .sort(([left], [right]) => left - right)
    .flatMap(([y, xs]) => {
      const sorted = [...xs].sort((left, right) => left - right)
-      const [first, ...rest] = sorted
-      if (first === undefined) return []
      const spans: SpatialSpan[] = []
-      let start = first
-      let end = first
-      for (const x of rest) {
-        if (x === end + 1) {
+      let start = sorted[0]
+      let end = start
+      if (start === undefined) return spans
+      for (const x of sorted.slice(1)) {
+        if (x === end! + 1) {
          end = x
          continue
        }
-        spans.push(normalizedSpan(y, start, end))
+        spans.push(normalizedSpan(y, start, end!))
        start = x
        end = x
      }
-      spans.push(normalizedSpan(y, start, end))
+      spans.push(normalizedSpan(y, start, end!))
      return spans
    })
 }
@@ -4,11 +4,9 @@ export interface Registration {
  readonly dispose: Effect.Effect<void>
 }

-export type Hooks<Spec, Failures extends Record<keyof Spec, unknown> = Record<keyof Spec, never>> = <
-  Name extends keyof Spec,
->(
+export type Hooks<Spec> = <Name extends keyof Spec>(
  name: Name,
-  callback: (input: Spec[Name]) => Effect.Effect<void, Failures[Name]>,
+  callback: (input: Spec[Name]) => Effect.Effect<void>,
 ) => Effect.Effect<Registration, never, Scope.Scope>

 export type Transform<Input> = (callback: (input: Input) => void) => Effect.Effect<Registration, never, Scope.Scope>
@@ -38,13 +38,7 @@ export interface ToolHooks {
  )
 }

-// Only execute.before may fail: a Tool.Error rejects the call before the tool runs.
-export interface ToolFailures extends Record<keyof ToolHooks, unknown> {
-  readonly "execute.before": Tool.Error
-  readonly "execute.after": never
-}
-
 export interface ToolDomain {
  readonly transform: Transform<ToolDraft>
-  readonly hook: Hooks<ToolHooks, ToolFailures>
+  readonly hook: Hooks<ToolHooks>
 }
@@ -14373,9 +14373,6 @@
              },
              "agent": {
                "type": "string"
-              },
-              "previous": {
-                "type": "string"
              }
            },
            "required": ["sessionID", "agent"],
@@ -14444,9 +14441,6 @@
              },
              "model": {
                "$ref": "#/components/schemas/Model.Ref"
-              },
-              "previous": {
-                "$ref": "#/components/schemas/Model.Ref"
              }
            },
            "required": ["sessionID", "model"],
@@ -69,7 +69,6 @@ export const AgentSelected = Event.durable({
  schema: {
    ...Base,
    agent: Agent.ID,
-    previous: Agent.ID.pipe(optional),
  },
 })
 export type AgentSelected = typeof AgentSelected.Type
@@ -80,7 +79,6 @@ export const ModelSelected = Event.durable({
  schema: {
    ...Base,
    model: Model.Ref,
-    previous: Model.Ref.pipe(optional),
  },
 })
 export type ModelSelected = typeof ModelSelected.Type
@@ -12,19 +12,6 @@ export const ModelHandler = HttpApiBuilder.group(Api, "server.model", (handlers)
      .handle(
        "model.list",
        Effect.fn(function* () {
-          const plugins = yield* PluginSupervisor.Service
-          yield* plugins.flush.pipe(
-            Effect.timeoutOrElse({
-              duration: "5 seconds",
-              orElse: () =>
-                Effect.fail(
-                  new ServiceUnavailableError({
-                    message: "Model catalog initialization timed out",
-                    service: "model.catalog",
-                  }),
-                ),
-            }),
-          )
          const catalog = yield* Catalog.Service
          return yield* response(catalog.model.available())
        }),
@@ -1,57 +0,0 @@
-import fs from "node:fs/promises"
-import path from "node:path"
-import { expect } from "bun:test"
-import { Effect } from "effect"
-import { HttpServer } from "effect/unstable/http"
-import { tmpdir } from "../../core/test/fixture/tmpdir"
-import { it } from "../../core/test/lib/effect"
-import { ServerProcess } from "../src/process"
-
-it.live("waits for plugin initialization before listing models", () =>
-  Effect.acquireUseRelease(
-    Effect.promise(() => tmpdir("opencode-model-endpoint-")),
-    (tmp) =>
-      Effect.gen(function* () {
-        yield* Effect.promise(() =>
-          fs.writeFile(
-            path.join(tmp.path, "opencode.json"),
-            JSON.stringify({
-              providers: {
-                custom: {
-                  package: "aisdk:@ai-sdk/openai-compatible",
-                  settings: { apiKey: "secret" },
-                  models: { chat: {} },
-                },
-              },
-            }),
-          ),
-        )
-        const server = yield* ServerProcess.start<never, never>({
-          hostname: "127.0.0.1",
-          port: 0,
-          password: "secret",
-          app: { version: "test-version" },
-          database: { path: ":memory:" },
-          config: { directory: tmp.path },
-          fs: { filewatcher: false },
-        })
-        const url = new URL("/api/model", HttpServer.formatAddress(server.address))
-        url.searchParams.set("location[directory]", tmp.path)
-        const response = yield* Effect.promise(() =>
-          fetch(url, { headers: { authorization: `Basic ${btoa("opencode:secret")}` } }),
-        )
-
-        expect(response.status).toBe(200)
-        const body: unknown = yield* Effect.promise(() => response.json())
-        if (!isRecord(body) || !Array.isArray(body["data"])) throw new Error("Expected a model list response")
-        expect(
-          body["data"].some((model) => isRecord(model) && model["providerID"] === "custom" && model["id"] === "chat"),
-        ).toBeTrue()
-      }),
-    (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
-  ),
-)
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value)
-}
@@ -62,9 +62,13 @@ function createMarquee(hovered: () => string | undefined, animations: () => bool
  const leading = createAnimatable({ opacity: 0 }, { enabled: animations, transition: tween({ duration: 0.25 }) })

  createEffect(() => {
+    if (!hovered()) {
+      setOffset(0)
+      leading.jump({ opacity: 0 })
+      return
+    }
    setOffset(0)
    leading.jump({ opacity: 0 })
-    if (!hovered()) return
    let interval: ReturnType<typeof setInterval> | undefined
    const delay = setTimeout(() => {
      setOffset(1)
@@ -25,14 +25,14 @@ function deduplicateByIdentity<T>(
  items: readonly T[],
  identity: (item: T) => { metadata: string; payload: string } | undefined,
 ) {
-  const seen = new Map<string, Set<string>>()
+  const seen = new Map<string, string[]>()
  return items.filter((item) => {
    const key = identity(item)
    if (!key) return true
-    const payloads = seen.get(key.metadata) ?? new Set<string>()
-    if (payloads.has(key.payload)) return false
-    payloads.add(key.payload)
-    seen.set(key.metadata, payloads)
+    const matches = seen.get(key.metadata)
+    if (matches?.includes(key.payload)) return false
+    if (matches) matches.push(key.payload)
+    if (!matches) seen.set(key.metadata, [key.payload])
    return true
  })
 }
@@ -42,7 +42,7 @@ export function deduplicatePromptImages(files: readonly PromptFile[] | undefined
  return deduplicateByIdentity(files, (file) =>
    file.uri.startsWith("data:image/") && file.mention?.text
      ? {
-          metadata: JSON.stringify([file.name ?? null, file.description ?? null, file.mention.text]),
+          metadata: JSON.stringify([attachmentMetadata(file), file.mention.text]),
          payload: file.uri,
        }
      : undefined,
@@ -650,18 +650,8 @@ export function Session() {
      slash: {
        name: "compact",
      },
-      run: async () => {
-        const selection = local.model.current()
-        if (selection)
-          await client.api.session.switchModel({
-            sessionID: route.sessionID,
-            model: {
-              providerID: selection.providerID,
-              id: selection.modelID,
-              variant: local.model.variant.current(),
-            },
-          })
-        await client.api.session.compact({ sessionID: route.sessionID })
+      run: () => {
+        void client.api.session.compact({ sessionID: route.sessionID })
        dialog.clear()
      },
    },
@@ -14373,9 +14373,6 @@
              },
              "agent": {
                "type": "string"
-              },
-              "previous": {
-                "type": "string"
              }
            },
            "required": ["sessionID", "agent"],
@@ -14444,9 +14441,6 @@
              },
              "model": {
                "$ref": "#/components/schemas/Model.Ref"
-              },
-              "previous": {
-                "$ref": "#/components/schemas/Model.Ref"
              }
            },
            "required": ["sessionID", "model"],
@@ -14373,9 +14373,6 @@
              },
              "agent": {
                "type": "string"
-              },
-              "previous": {
-                "type": "string"
              }
            },
            "required": ["sessionID", "agent"],
@@ -14444,9 +14441,6 @@
              },
              "model": {
                "$ref": "#/components/schemas/Model.Ref"
-              },
-              "previous": {
-                "$ref": "#/components/schemas/Model.Ref"
              }
            },
            "required": ["sessionID", "model"],
@@ -35,34 +35,32 @@ if (Script.release && !Script.preview) {

 await prepareReleaseFiles()

-if (Script.channel !== "beta") {
-  console.log("\n=== schema ===\n")
-  await $`bun ./packages/schema/script/publish.ts`
+console.log("\n=== schema ===\n")
+await $`bun ./packages/schema/script/publish.ts`

-  console.log("\n=== theme ===\n")
-  await $`bun ./packages/theme/script/publish.ts`
+console.log("\n=== theme ===\n")
+await $`bun ./packages/theme/script/publish.ts`

-  console.log("\n=== ai ===\n")
-  await $`bun ./packages/ai/script/publish.ts`
+console.log("\n=== ai ===\n")
+await $`bun ./packages/ai/script/publish.ts`

-  console.log("\n=== util ===\n")
-  await $`bun ./packages/util/script/publish.ts`
+console.log("\n=== util ===\n")
+await $`bun ./packages/util/script/publish.ts`

-  console.log("\n=== protocol ===\n")
-  await $`bun ./packages/protocol/script/publish.ts`
+console.log("\n=== protocol ===\n")
+await $`bun ./packages/protocol/script/publish.ts`

-  console.log("\n=== client ===\n")
-  await $`bun ./packages/client/script/publish.ts`
+console.log("\n=== client ===\n")
+await $`bun ./packages/client/script/publish.ts`

-  console.log("\n=== cli ===\n")
-  await $`bun ./packages/cli/script/publish.ts`
+console.log("\n=== cli ===\n")
+await $`bun ./packages/cli/script/publish.ts`

-  console.log("\n=== plugin ===\n")
-  await $`bun ./packages/plugin/script/publish.ts`
+console.log("\n=== plugin ===\n")
+await $`bun ./packages/plugin/script/publish.ts`

-  console.log("\n=== ui ===\n")
-  await $`bun ./packages/ui/script/publish.ts`
-}
+console.log("\n=== ui ===\n")
+await $`bun ./packages/ui/script/publish.ts`

 if (Script.release) {
  await $`bun ./packages/desktop/scripts/finalize-latest-json.ts`
Author	SHA1	Message	Date
Aiden Cline	5076497e11	fix(core): retain raw copilot completion usage	2026-08-11 00:37:09 -05:00
Aiden Cline	f31582b907	fix(core): preserve raw copilot usage	2026-08-11 00:34:05 -05:00
Aiden Cline	c1abcce820	test(core): use observed copilot usage fixtures	2026-08-11 00:20:54 -05:00
Aiden Cline	24d8e41aab	fix(core): normalize copilot reasoning usage	2026-08-11 00:14:08 -05:00