fix(desktop): install matching V2 CLI in WSL

packages/cli/src/acp/service.ts

@@ -422,8 +422,7 @@ 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 ?? defaultModel.variants[0]?.id,
+          variant: defaultModel.variants.find((variant) => variant.id === "default")?.id,
         },
         modes: agents.map((agent) => ({ id: agent.id, name: agent.name, description: agent.description })),
         defaultModeID: defaultAgent.id,

packages/cli/src/server-process.ts

@@ -39,8 +39,6 @@ export const run = Effect.fnUntraced(function* (options: Options) {
 })
 
 const processEffect = Effect.fnUntraced(function* (options: Options) {
-  const serviceErrorFormat = process.env.OPENCODE_SERVICE_ERROR_FORMAT
-  delete process.env.OPENCODE_SERVICE_ERROR_FORMAT
   const global = yield* Global.Service
   if (options.mode === "service") yield* Effect.sync(() => process.chdir(global.home))
   return yield* Effect.scoped(
@@ -129,7 +127,15 @@ const processEffect = Effect.fnUntraced(function* (options: Options) {
           if (serviceOptions === undefined || port === undefined || !addressInUse(error)) return Effect.fail(error)
           return recognizeIncumbent(serviceOptions, hostname, port).pipe(
             Effect.flatMap((found) =>
-              found ? Effect.void : managedPortInUse(hostname, port, error, serviceErrorFormat),
+              found
+                ? Effect.void
+                : Effect.fail(
+                    new Error(
+                      `Managed service port ${port} on ${hostname} is already in use by another process. ` +
+                        "Configure another port with `opencode service set port <port>` and start the service again.",
+                      { cause: error },
+                    ),
+                  ),
             ),
           )
         }),
@@ -208,17 +214,6 @@ function serviceURL(hostname: string, port: number) {
   return `http://${hostname.includes(":") ? `[${hostname}]` : hostname}:${port}`
 }
 
-function managedPortInUse(hostname: string, port: number, cause: unknown, format?: string) {
-  const message =
-    `Managed service port ${port} on ${hostname} is already in use by another process. ` +
-    "Configure another port with `opencode service set port <port>` and start the service again."
-  const failure = new Error(message, { cause })
-  if (format !== "plain") return Effect.fail(failure)
-  return Effect.sync(() => process.stderr.write(`OPENCODE_SERVICE_ERROR:${message}\n`)).pipe(
-    Effect.andThen(Effect.fail(failure)),
-  )
-}
-
 function truthy(value?: string) {
   return value === "1" || value?.toLowerCase() === "true"
 }

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

@@ -3,6 +3,38 @@ 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) {

packages/client/src/effect/service.ts

@@ -1,9 +1,9 @@
 import { ServiceStatus } from "@opencode-ai/protocol/groups/health"
 import { Effect, FileSystem, Option, Schedule, Schema } from "effect"
+import { spawn, type ChildProcess } from "node:child_process"
 import { homedir } from "node:os"
 import { join } from "node:path"
 import type { DiscoverOptions, Endpoint, EnsureOptions, StopOptions } from "../service.js"
-import { ServiceProcess } from "../service-process.js"
 
 export * from "../service.js"
 /** Contents of the local service registration file. */
@@ -17,6 +17,11 @@ export type Info = import("../service.js").Info
 // is all a client needs to connect. The daemon's own configuration (port,
 // persisted password) is CLI-owned and never read here.
 
+type Contender = {
+  readonly child: ChildProcess
+  readonly error: () => Error | undefined
+}
+
 // Read-only lookup: registration file plus health check and version gate.
 // Never spawns; escalation to ensure() is the caller's policy.
 /** Discover a healthy, compatible local service without starting one. */
@@ -47,12 +52,11 @@ const discoverLocal = Effect.fnUntraced(function* (options: DiscoverOptions) {
 // becomes discoverable. A contender is never killed merely for slow startup.
 /** Ensure a healthy, compatible local service is running. */
 export const ensure = Effect.fn("service.ensure")(function* (options: EnsureOptions = {}) {
-  const contenders = new Set<ServiceProcess.Contender>()
+  const contenders = new Set<Contender>()
   let timeouts: { readonly info: Info; readonly count: number } | undefined
   let announced = false
   let lastSpawn = 0
   let spawnDelay = 5_000
-  let lastFailure: Error | undefined
   const announce = (reason: "missing" | "version-mismatch", previousVersion?: string) =>
     Effect.sync(() => {
       if (announced) return
@@ -63,7 +67,15 @@ export const ensure = Effect.fn("service.ensure")(function* (options: EnsureOpti
     const [command, ...args] = options.command ?? ["opencode", "serve", "--service"]
     if (command === undefined) return yield* Effect.fail(new Error("Missing service command"))
     return yield* Effect.try({
-      try: () => ServiceProcess.start(command, args),
+      try: () => {
+        const child = spawn(command, args, { detached: true, stdio: "ignore" })
+        let error: Error | undefined
+        child.once("error", (cause) => {
+          error = new Error("Failed to start server", { cause })
+        })
+        child.unref()
+        return { child, error: () => error }
+      },
       catch: (cause) => new Error("Failed to start server", { cause }),
     })
   })
@@ -96,9 +108,8 @@ export const ensure = Effect.fn("service.ensure")(function* (options: EnsureOpti
       return Option.none<LocalService>()
     } else if (lastSpawn === 0 && info !== undefined) lastSpawn = Date.now()
 
-    const finished = [...contenders].filter(ServiceProcess.finished)
-    const failure = finished.map(ServiceProcess.failure).find((error): error is Error => error !== undefined)
-    if (failure !== undefined) lastFailure = failure
+    const finished = [...contenders].filter(contenderFinished)
+    const failure = finished.map(contenderFailure).find((error): error is Error => error !== undefined)
     if (finished.some((item) => item.child.exitCode === 0)) {
       spawnDelay = Math.min(spawnDelay * 2, 30_000)
     }
@@ -118,10 +129,24 @@ export const ensure = Effect.fn("service.ensure")(function* (options: EnsureOpti
     }),
   )
   if (Option.isNone(found))
-    return yield* Effect.fail(lastFailure ?? new Error("Timed out waiting for the background service to start"))
+    return yield* Effect.fail(new Error("Timed out waiting for the background service to start"))
   return found.value.endpoint
 })
 
+function contenderFailure(contender: Contender) {
+  const error = contender.error()
+  if (error !== undefined) return error
+  if (contender.child.exitCode !== null && contender.child.exitCode !== 0)
+    return new Error(`Server process exited with code ${contender.child.exitCode}`)
+  if (contender.child.signalCode !== null)
+    return new Error(`Server process terminated by ${contender.child.signalCode}`)
+  return undefined
+}
+
+function contenderFinished(contender: Contender) {
+  return contender.error() !== undefined || contender.child.exitCode !== null || contender.child.signalCode !== null
+}
+
 /** Stop the registered local service. */
 export const stop = Effect.fn("service.stop")(function* (options: StopOptions = {}) {
   const existing = yield* find(options)

packages/client/src/promise/service.ts

@@ -1,8 +1,8 @@
 import { readFile } from "node:fs/promises"
+import { spawn, type ChildProcess } from "node:child_process"
 import { homedir } from "node:os"
 import { join } from "node:path"
 import type { DiscoverOptions, Endpoint, Info, EnsureOptions, StopOptions } from "../service.js"
-import { ServiceProcess } from "../service-process.js"
 import type { ServiceHealth, ServiceStopResponse } from "./generated/types.js"
 
 export * from "../service.js"
@@ -13,6 +13,11 @@ export * from "../service.js"
 // intentionally implemented with Node APIs so Promise clients do not need
 // Effect or @effect/platform-node at runtime.
 
+type Contender = {
+  readonly child: ChildProcess
+  readonly error: () => Error | undefined
+}
+
 /** Discover a healthy, compatible local service without starting one. */
 export async function discover(options: DiscoverOptions = {}) {
   return (await discoverLocal(options))?.endpoint
@@ -28,12 +33,11 @@ async function discoverLocal(options: DiscoverOptions) {
 /** Ensure a healthy, compatible local service is running. */
 export async function ensure(options: EnsureOptions = {}): Promise<Endpoint> {
   const deadline = Date.now() + 120_000
-  const contenders = new Set<ServiceProcess.Contender>()
+  const contenders = new Set<Contender>()
   let timeouts: { readonly info: Info; readonly count: number } | undefined
   let announced = false
   let lastSpawn = 0
   let spawnDelay = 5_000
-  let lastFailure: Error | undefined
 
   const announce = (reason: "missing" | "version-mismatch", previousVersion?: string) => {
     if (announced) return
@@ -43,11 +47,21 @@ export async function ensure(options: EnsureOptions = {}): Promise<Endpoint> {
   const spawnContender = () => {
     const [command, ...args] = options.command ?? ["opencode", "serve", "--service"]
     if (command === undefined) throw new Error("Missing service command")
-    return ServiceProcess.start(command, args)
+    try {
+      const child = spawn(command, args, { detached: true, stdio: "ignore" })
+      let error: Error | undefined
+      child.once("error", (cause) => {
+        error = new Error("Failed to start server", { cause })
+      })
+      child.unref()
+      return { child, error: () => error }
+    } catch (cause) {
+      throw new Error("Failed to start server", { cause })
+    }
   }
 
   while (true) {
-    if (Date.now() >= deadline) throw lastFailure ?? new Error("Timed out waiting for the background service to start")
+    if (Date.now() >= deadline) throw new Error("Timed out waiting for the background service to start")
     const registration = await registered(options.file, true)
     if (registration.timedOut && registration.info !== undefined) {
       timeouts = {
@@ -75,9 +89,8 @@ export async function ensure(options: EnsureOptions = {}): Promise<Endpoint> {
       }
     } else {
       if (lastSpawn === 0 && registration.info !== undefined) lastSpawn = Date.now()
-      const finished = [...contenders].filter(ServiceProcess.finished)
-      const failure = finished.map(ServiceProcess.failure).find((error) => error !== undefined)
-      if (failure !== undefined) lastFailure = failure
+      const finished = [...contenders].filter(contenderFinished)
+      const failure = finished.map(contenderFailure).find((error) => error !== undefined)
       if (finished.some((item) => item.child.exitCode === 0)) {
         spawnDelay = Math.min(spawnDelay * 2, 30_000)
       }
@@ -94,6 +107,20 @@ export async function ensure(options: EnsureOptions = {}): Promise<Endpoint> {
   }
 }
 
+function contenderFailure(contender: Contender) {
+  const error = contender.error()
+  if (error !== undefined) return error
+  if (contender.child.exitCode !== null && contender.child.exitCode !== 0)
+    return new Error(`Server process exited with code ${contender.child.exitCode}`)
+  if (contender.child.signalCode !== null)
+    return new Error(`Server process terminated by ${contender.child.signalCode}`)
+  return undefined
+}
+
+function contenderFinished(contender: Contender) {
+  return contender.error() !== undefined || contender.child.exitCode !== null || contender.child.signalCode !== null
+}
+
 /** Stop the registered local service. */
 export async function stop(options: StopOptions = {}) {
   const existing = await find(options)

packages/client/src/service-process.ts

@@ -1,57 +0,0 @@
-export * as ServiceProcess from "./service-process"
-
-import { spawn, type ChildProcess } from "node:child_process"
-
-const errorPrefix = "OPENCODE_SERVICE_ERROR:"
-
-export type Contender = {
-  readonly child: ChildProcess
-  readonly error: () => Error | undefined
-  readonly startupError: () => string
-}
-
-export function start(command: string, args: ReadonlyArray<string>) {
-  try {
-    const child = spawn(command, args, {
-      detached: true,
-      stdio: ["ignore", "ignore", "pipe"],
-      env: { ...process.env, OPENCODE_SERVICE_ERROR_FORMAT: "plain" },
-    })
-    let error: Error | undefined
-    let pending = ""
-    let startupError = ""
-    child.once("error", (cause) => {
-      error = new Error("Failed to start server", { cause })
-    })
-    child.stderr?.on("data", (chunk) => {
-      const lines = (pending + chunk.toString()).split(/\r?\n/)
-      pending = lines.pop()?.slice(-64 * 1024) ?? ""
-      const message = lines.findLast((line) => line.startsWith(errorPrefix))
-      if (message !== undefined) startupError = message.slice(errorPrefix.length)
-    })
-    unref(child.stderr)
-    child.unref()
-    return { child, error: () => error, startupError: () => startupError } satisfies Contender
-  } catch (cause) {
-    throw new Error("Failed to start server", { cause })
-  }
-}
-
-export function failure(contender: Contender) {
-  const error = contender.error()
-  if (error !== undefined) return error
-  if (contender.child.exitCode !== null && contender.child.exitCode !== 0)
-    return new Error(contender.startupError() || `Server process exited with code ${contender.child.exitCode}`)
-  if (contender.child.signalCode !== null)
-    return new Error(`Server process terminated by ${contender.child.signalCode}`)
-  return undefined
-}
-
-export function finished(contender: Contender) {
-  return contender.error() !== undefined || contender.child.exitCode !== null || contender.child.signalCode !== null
-}
-
-function unref(stream: ChildProcess["stderr"]) {
-  if (!stream || !("unref" in stream) || typeof stream.unref !== "function") return
-  stream.unref()
-}

packages/client/test/fixture/service.ts

@@ -3,11 +3,6 @@ import { appendFile, rename, writeFile } from "node:fs/promises"
 const [registration, mode, delay] = process.argv.slice(2)
 if (registration === undefined || mode === undefined) throw new Error("Missing service fixture arguments")
 if (mode === "failed") process.exit(1)
-if (mode === "failed-message") {
-  console.error("sensitive startup detail")
-  console.error("OPENCODE_SERVICE_ERROR:Managed service port is already in use")
-  process.exit(1)
-}
 if (mode === "record-start") {
   await writeFile(registration + ".started", "")
   process.exit(1)

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

@@ -70,19 +70,6 @@ test("reports a failed registered service", async () => {
   )
 })
 
-test("reports the native contender's startup error", async () => {
-  const directory = await temp()
-  const registration = join(directory, "service.json")
-
-  await expect(
-    Service.ensure({
-      file: registration,
-      version: "test",
-      command: [process.execPath, fixture, registration, "failed-message"],
-    }),
-  ).rejects.toThrow(/^Managed service port is already in use$/)
-}, 10_000)
-
 test("evicts an unresponsive registered service before starting its replacement", async () => {
   const directory = await temp()
   const registration = join(directory, "service.json")

packages/client/test/service.test.ts

@@ -197,20 +197,6 @@ test("reports a contender that fails to start", async () => {
   ).rejects.toThrow("Server process exited with code 1")
 }, 10_000)
 
-test("reports the contender's startup error", async () => {
-  const directory = await temp()
-  const registration = join(directory, "service.json")
-  await expect(
-    run(
-      Service.ensure({
-        file: registration,
-        version: "test",
-        command: [process.execPath, fixture, registration, "failed-message"],
-      }),
-    ),
-  ).rejects.toThrow(/^Managed service port is already in use$/)
-}, 10_000)
-
 test("reports a contender terminated by a signal", async () => {
   const directory = await temp()
   const registration = join(directory, "service.json")

packages/core/src/config/plugin/source.ts

@@ -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, PubSub, Scope, Stream } from "effect"
+import { Context, Effect, Layer, Option, Predicate, PubSub, Schema, Scope, Stream } from "effect"
 import path from "path"
 import { fileURLToPath } from "url"
 import { Config } from "../../config"
@@ -154,19 +154,67 @@ 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 files = yield* fs
-      .scan(`{${sourceDirectories.join(",")}}/*.{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: {} }))
+    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: {} }))
+  })
+}
+
+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),
+            ),
+          ),
+    )
   })
 }
 

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

@@ -1,58 +1,32 @@
-import { Database } from "bun:sqlite"
+import { Database, type SQLQueryBindings } from "bun:sqlite"
 import { drizzle } from "drizzle-orm/bun-sqlite"
-import { Context, Effect, Fiber, Layer, Scope, Semaphore, Stream } from "effect"
-import { identity } from "effect/Function"
+import { Context, Effect, Layer } from "effect"
 import { Reactivity } from "effect/unstable/reactivity"
-import { SqlClient, Statement } from "effect/unstable/sql"
-import type { Connection } from "effect/unstable/sql/SqlConnection"
+import { SqlClient } from "effect/unstable/sql"
 import { classifySqliteError, SqlError } from "effect/unstable/sql/SqlError"
 import { Sqlite } from "./sqlite"
 
-const ATTR_DB_SYSTEM_NAME = "db.system.name"
-
 const TypeId = "~@opencode-ai/core/database/SqliteBun" as const
-type TypeId = typeof TypeId
 
-interface SqliteClient extends 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 {
+interface Config extends Sqlite.ClientConfig {
   readonly filename: string
   readonly readonly?: boolean
   readonly create?: boolean
   readonly readwrite?: boolean
   readonly disableWAL?: boolean
-  readonly spanAttributes?: Record<string, unknown>
-  readonly transformResultNames?: (str: string) => string
-  readonly transformQueryNames?: (str: string) => string
-}
-
-interface SqliteConnection extends Connection {
-  readonly export: Effect.Effect<Uint8Array, SqlError>
-  readonly loadExtension: (path: string) => Effect.Effect<void, SqlError>
 }
 
 const make = (options: Config) =>
   Effect.gen(function* () {
     const native = (yield* Sqlite.Native) as Database
 
-    const compiler = Statement.makeCompilerSqlite(options.transformQueryNames)
-    const transformRows = options.transformResultNames
-      ? Statement.defaultTransforms(options.transformResultNames).array
-      : undefined
-
     const run = (query: string, params: ReadonlyArray<unknown> = []) =>
       Effect.withFiber<Array<Record<string, unknown>>, SqlError>((fiber) => {
-        const statement = native.query(query)
+        const statement = native.query<Record<string, unknown>, SQLQueryBindings[]>(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 any)) ?? []) as Array<Record<string, unknown>>)
+          return Effect.succeed(statement.all(...(params as SQLQueryBindings[])) ?? [])
         } catch (cause) {
           return Effect.fail(
             new SqlError({
@@ -64,11 +38,11 @@ const make = (options: Config) =>
 
     const runValues = (query: string, params: ReadonlyArray<unknown> = []) =>
       Effect.withFiber<Array<unknown[]>, SqlError>((fiber) => {
-        const statement = native.query(query)
+        const statement = native.query<unknown, SQLQueryBindings[]>(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 any)) ?? []) as Array<unknown[]>)
+          return Effect.succeed(statement.values(...(params as SQLQueryBindings[])) ?? [])
         } catch (cause) {
           return Effect.fail(
             new SqlError({
@@ -78,25 +52,7 @@ const make = (options: Config) =>
         }
       })
 
-    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")
-      },
+    const connection = Sqlite.makeConnection(run, runValues, {
       export: Effect.try({
         try: () => native.serialize(),
         catch: (cause) =>
@@ -104,7 +60,7 @@ const make = (options: Config) =>
             reason: classifySqliteError(cause, { message: "Failed to export database", operation: "export" }),
           }),
       }),
-      loadExtension: (path) =>
+      loadExtension: (path: string) =>
         Effect.try({
           try: () => native.loadExtension(path),
           catch: (cause) =>
@@ -114,37 +70,10 @@ const make = (options: Config) =>
         }),
     })
 
-    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
+    return yield* Sqlite.makeClient(options, connection, TypeId, (acquirer) => ({
+      export: Effect.flatMap(acquirer, (_) => _.export),
+      loadExtension: (path: string) => Effect.flatMap(acquirer, (_) => _.loadExtension(path)),
+    }))
   })
 
 const nativeLayer = (config: Config) =>

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

@@ -1,26 +1,14 @@
 import { DatabaseSync, type SQLInputValue } from "node:sqlite"
 import { drizzle } from "drizzle-orm/node-sqlite"
-import { Context, Effect, Fiber, Layer, Scope, Semaphore, Stream } from "effect"
-import { identity } from "effect/Function"
+import { Context, Effect, Layer } from "effect"
 import { Reactivity } from "effect/unstable/reactivity"
-import { SqlClient, Statement } from "effect/unstable/sql"
-import type { Connection } from "effect/unstable/sql/SqlConnection"
+import { SqlClient } from "effect/unstable/sql"
 import { classifySqliteError, SqlError } from "effect/unstable/sql/SqlError"
 import { Sqlite } from "./sqlite"
 
-const ATTR_DB_SYSTEM_NAME = "db.system.name"
-
 const TypeId = "~@opencode-ai/core/database/SqliteNode" as const
-type TypeId = typeof TypeId
 
-interface SqliteClient extends SqlClient.SqlClient {
-  readonly [TypeId]: TypeId
-  readonly config: Config
-  readonly loadExtension: (path: string) => Effect.Effect<void, SqlError>
-  readonly updateValues: never
-}
-
-interface Config {
+interface Config extends Sqlite.ClientConfig {
   readonly filename: string
   readonly readonly?: boolean
   readonly create?: boolean
@@ -28,24 +16,12 @@ interface Config {
   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)
@@ -79,26 +55,8 @@ const make = (options: Config) =>
         }
       })
 
-    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) =>
+    const connection = Sqlite.makeConnection(run, runValues, {
+      loadExtension: (path: string) =>
         Effect.try({
           try: () => native.loadExtension(path),
           catch: (cause) =>
@@ -108,36 +66,9 @@ const make = (options: Config) =>
         }),
     })
 
-    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
+    return yield* Sqlite.makeClient(options, connection, TypeId, (acquirer) => ({
+      loadExtension: (path: string) => Effect.flatMap(acquirer, (_) => _.loadExtension(path)),
+    }))
   })
 
 const nativeLayer = (config: Config) =>

packages/core/src/database/sqlite.ts

@@ -1,8 +1,100 @@
 export * as Sqlite from "./sqlite"
 
-import { Context } from "effect"
+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 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
+  })

packages/core/src/plugin/internal.ts

@@ -17,6 +17,7 @@ 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"
@@ -76,6 +77,7 @@ 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
@@ -112,6 +114,7 @@ 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),
@@ -155,6 +158,7 @@ export const requirements = LayerNode.group([
   Command.node,
   Config.node,
   Credential.node,
+  ConfigPluginSource.node,
   Bus.node,
   Environment.node,
   FileMutation.node,

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

@@ -1,16 +1,10 @@
-import { Effect } from "effect"
-import { define } from "@opencode-ai/plugin/effect/plugin"
+import { createProviderPlugin } from "./factory"
 
-export const AlibabaPlugin = define({
+export const AlibabaPlugin = createProviderPlugin({
   id: "opencode.provider.alibaba",
-  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)
-      }),
-    )
-  }),
+  package: "@ai-sdk/alibaba",
+  load: async (options) => {
+    const { createAlibaba } = await import("@ai-sdk/alibaba")
+    return createAlibaba(options)
+  },
 })

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

@@ -1,16 +1,10 @@
-import { Effect } from "effect"
-import { define } from "@opencode-ai/plugin/effect/plugin"
+import { createProviderPlugin } from "./factory"
 
-export const CoherePlugin = define({
+export const CoherePlugin = createProviderPlugin({
   id: "opencode.provider.cohere",
-  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)
-      }),
-    )
-  }),
+  package: "@ai-sdk/cohere",
+  load: async (options) => {
+    const { createCohere } = await import("@ai-sdk/cohere")
+    return createCohere(options)
+  },
 })

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

@@ -1,16 +1,10 @@
-import { Effect } from "effect"
-import { define } from "@opencode-ai/plugin/effect/plugin"
+import { createProviderPlugin } from "./factory"
 
-export const DeepInfraPlugin = define({
+export const DeepInfraPlugin = createProviderPlugin({
   id: "opencode.provider.deepinfra",
-  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)
-      }),
-    )
-  }),
+  package: "@ai-sdk/deepinfra",
+  load: async (options) => {
+    const { createDeepInfra } = await import("@ai-sdk/deepinfra")
+    return createDeepInfra(options)
+  },
 })

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

@@ -0,0 +1,22 @@
+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))
+        }),
+      )
+    }),
+  })
+}

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

@@ -1,16 +1,10 @@
-import { Effect } from "effect"
-import { define } from "@opencode-ai/plugin/effect/plugin"
+import { createProviderPlugin } from "./factory"
 
-export const GatewayPlugin = define({
+export const GatewayPlugin = createProviderPlugin({
   id: "opencode.provider.gateway",
-  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)
-      }),
-    )
-  }),
+  package: "@ai-sdk/gateway",
+  load: async (options) => {
+    const { createGateway } = await import("@ai-sdk/gateway")
+    return createGateway(options)
+  },
 })

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

@@ -1,16 +1,10 @@
-import { Effect } from "effect"
-import { define } from "@opencode-ai/plugin/effect/plugin"
+import { createProviderPlugin } from "./factory"
 
-export const GroqPlugin = define({
+export const GroqPlugin = createProviderPlugin({
   id: "opencode.provider.groq",
-  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)
-      }),
-    )
-  }),
+  package: "@ai-sdk/groq",
+  load: async (options) => {
+    const { createGroq } = await import("@ai-sdk/groq")
+    return createGroq(options)
+  },
 })

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

@@ -1,16 +1,10 @@
-import { Effect } from "effect"
-import { define } from "@opencode-ai/plugin/effect/plugin"
+import { createProviderPlugin } from "./factory"
 
-export const MistralPlugin = define({
+export const MistralPlugin = createProviderPlugin({
   id: "opencode.provider.mistral",
-  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)
-      }),
-    )
-  }),
+  package: "@ai-sdk/mistral",
+  load: async (options) => {
+    const { createMistral } = await import("@ai-sdk/mistral")
+    return createMistral(options)
+  },
 })

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

@@ -1,16 +1,10 @@
-import { Effect } from "effect"
-import { define } from "@opencode-ai/plugin/effect/plugin"
+import { createProviderPlugin } from "./factory"
 
-export const PerplexityPlugin = define({
+export const PerplexityPlugin = createProviderPlugin({
   id: "opencode.provider.perplexity",
-  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)
-      }),
-    )
-  }),
+  package: "@ai-sdk/perplexity",
+  load: async (options) => {
+    const { createPerplexity } = await import("@ai-sdk/perplexity")
+    return createPerplexity(options)
+  },
 })

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

@@ -1,16 +1,10 @@
-import { Effect } from "effect"
-import { define } from "@opencode-ai/plugin/effect/plugin"
+import { createProviderPlugin } from "./factory"
 
-export const TogetherAIPlugin = define({
+export const TogetherAIPlugin = createProviderPlugin({
   id: "opencode.provider.togetherai",
-  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)
-      }),
-    )
-  }),
+  package: "@ai-sdk/togetherai",
+  load: async (options) => {
+    const { createTogetherAI } = await import("@ai-sdk/togetherai")
+    return createTogetherAI(options)
+  },
 })

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

@@ -1,16 +1,10 @@
-import { Effect } from "effect"
-import { define } from "@opencode-ai/plugin/effect/plugin"
+import { createProviderPlugin } from "./factory"
 
-export const VenicePlugin = define({
+export const VenicePlugin = createProviderPlugin({
   id: "opencode.provider.venice",
-  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)
-      }),
-    )
-  }),
+  package: "venice-ai-sdk-provider",
+  load: async (options) => {
+    const { createVenice } = await import("venice-ai-sdk-provider")
+    return createVenice(options)
+  },
 })

packages/core/src/plugin/skill.ts

@@ -6,12 +6,8 @@ import { define, type Context } from "@opencode-ai/plugin/effect/plugin"
 import { Effect } from "effect"
 import { AbsolutePath } from "../schema"
 import { Skill } from "../skill"
-import { Config } from "../config"
-import { Location } from "../location"
-import { FSUtil } from "@opencode-ai/util/fs-util"
+import { ConfigPluginSource } from "../config/plugin/source"
 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" }
 
@@ -72,32 +68,10 @@ const reportContentWithDiagnostics = Effect.fn("SkillPlugin.reportContentWithDia
 })
 
 const configuredPlugins = Effect.fn("SkillPlugin.configuredPlugins")(function* () {
-  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()))
+  const sources = yield* ConfigPluginSource.Service
+  return (yield* sources.operations())
+    .map((operation) => (operation.type === "remove" ? `-${operation.target}` : operation.target))
+    .toSorted()
 })
 
 function terminal() {

packages/core/src/project.ts

@@ -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, isNotNull, isNull, ne, or } from "drizzle-orm"
+import { asc, desc } 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 } from "./project/sql"
+import { ProjectTable, upsertProject } from "./project/sql"
 
 export const ID = ProjectSchema.ID
 export type ID = ProjectSchema.ID
@@ -98,19 +98,7 @@ const layer = Layer.effect(
       yield* db
         .transaction((tx) =>
           Effect.gen(function* () {
-            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()
+            yield* upsertProject(tx, project)
             if (!project.vcs) return
             yield* projectDirectories.create({ projectID: project.id, directory: project.canonical }, tx)
             if (project.directory === project.canonical) return

packages/core/src/project/sql.ts

@@ -1,8 +1,14 @@
+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(),
@@ -33,3 +39,22 @@ 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()
+}

packages/core/src/session.ts

@@ -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, isNotNull, isNull, like, lt, ne, or, type SQL } from "drizzle-orm"
+import { and, asc, desc, eq, gt, isNull, like, lt, 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 { ProjectTable } from "./project/sql"
+import { upsertProject } from "./project/sql"
 import path from "path"
 import { fromRow } from "./session/info"
 import { SessionRunner } from "./session/runner/index"
@@ -309,22 +309,7 @@ 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) => {
-      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 persistProject = (project: Project.Resolved) => upsertProject(db, project).pipe(Effect.orDie)
     const decode = (row: typeof SessionMessageTable.$inferSelect) =>
       decodeMessage({ ...row.data, id: row.id, type: row.type }).pipe(
         Effect.mapError(

packages/core/src/session/transfer.ts

@@ -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, isNotNull, isNull, ne, or } from "drizzle-orm"
+import { eq } 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 { ProjectTable } from "../project/sql"
+import { upsertProject } from "../project/sql"
 import { AbsolutePath, RelativePath } from "../schema"
 import { Session } from "../session"
 import { Slug } from "../util/slug"
@@ -49,22 +49,7 @@ const layer = Layer.effect(
     const sessions = yield* Session.Service
     const encodeMessage = Schema.encodeSync(SessionMessage.Info)
 
-    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 persistProject = (project: Project.Resolved) => upsertProject(db, project).pipe(Effect.orDie)
 
     return Service.of({
       export: Effect.fn("SessionTransfer.export")(function* (input) {

packages/core/test/config/plugin.test.ts

@@ -168,6 +168,75 @@ 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
@@ -389,3 +458,21 @@ 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))),
+  ])
+}

packages/core/test/plugin/skill.test.ts

@@ -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 { FSUtil } from "@opencode-ai/util/fs-util"
-import { Location } from "@opencode-ai/core/location"
-import { Effect, Stream } from "effect"
+import { ConfigPluginSource } from "@opencode-ai/core/config/plugin/source"
+import { Effect, Layer, 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,15 +27,7 @@ describe("SkillPlugin.Plugin", () => {
             reload: skill.reload,
           },
         }),
-      ).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),
-      )
+      ).pipe(Effect.provide(sources()))
       const skills = yield* skill.list()
       const report = skills.find((item) => item.id === "report")
 
@@ -58,4 +50,30 @@ 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 } },
+        ]),
+      ),
+    ),
+  )
 })

packages/desktop/src/main/background-cli.ts

@@ -37,6 +37,7 @@ export async function startBackgroundCli(logger: Logger) {
     url: service.url,
     username: service.auth.username,
     password: service.auth.password,
+    version,
   }
 }
 

packages/desktop/src/main/index.ts

@@ -134,10 +134,10 @@ const main = Effect.gen(function* () {
   initCrashReporter()
 
   const wslServers = createWslServersController(
-    app.getVersion(),
-    async (distro) => {
+    CHANNEL === "beta" ? null : app.getVersion(),
+    async (distro, version, channel) => {
       logger.log("spawning wsl sidecar", { distro })
-      return spawnWslSidecar(distro, {
+      return spawnWslSidecar(distro, version, channel, {
         onLine: (line) => logger.log("wsl sidecar", { distro, stream: line.stream, text: line.text }),
       })
     },
@@ -146,6 +146,7 @@ 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()
@@ -311,6 +312,7 @@ const main = Effect.gen(function* () {
 
     logger.log("starting v2 background service")
     const sidecar = yield* Effect.promise(() => startBackgroundCli(logger))
+    if (CHANNEL === "beta") wslServers.setCliVersion(sidecar.version)
     yield* Deferred.succeed(serverReady, {
       url: sidecar.url,
       username: sidecar.username,

packages/desktop/src/main/wsl/runtime.ts

@@ -264,18 +264,22 @@ export async function installWslDistro(name: string, opts?: RunWslOptions) {
   )
 }
 
-export async function installWslOpencode(version: string, distro: string, opts?: RunWslOptions) {
+export async function installWslOpencode(version: string, channel: string, distro: string, opts?: RunWslOptions) {
   return runInteractiveCommand(
     resolveSystem32Command("wsl.exe"),
-    wslArgs(
-      ["bash", "-lc", `curl -fsSL https://opencode.ai/install | bash -s -- --version ${shellEscape(version)}`],
-      distro,
-    ),
+    wslArgs(["bash", "-lc", wslOpencodeInstallCommand(version, channel)], 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,
@@ -307,11 +311,22 @@ export async function probeWslDistro(name: string, opts?: RunWslOptions): Promis
   }
 }
 
-export async function resolveWslOpencode(distro: string, opts?: RunWslOptions) {
+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,
+    )
+  }
   return firstLine(
     (
       await runWslSh(
-        'if [ -x "$HOME/.opencode/bin/opencode" ]; then printf "%s\\n" "$HOME/.opencode/bin/opencode"; fi',
+        'PATH=$(awk -v RS=: -v ORS=: \'$0 !~ /^\\/mnt\\//\' <<<"$PATH" | sed "s/:$//"); export PATH; command -v opencode2 || true',
         distro,
         opts,
       )
@@ -321,7 +336,13 @@ export async function resolveWslOpencode(distro: string, opts?: RunWslOptions) {
 
 export async function readWslCommandVersion(command: string, distro: string, opts?: RunWslOptions) {
   const result = await runWslSh(`${shellEscape(command)} --version 2>/dev/null || true`, distro, opts)
-  return firstLine(result.stdout)
+  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)
 }
 
 export function openWslTerminal(distro?: string | null) {

packages/desktop/src/main/wsl/servers.test.ts

@@ -13,6 +13,10 @@ import {
   wslServerIdsToStartOnInitialize,
 } from "./startup"
 import { createWslServersController, type WslServerConfig } from "./servers"
+import {
+  parseWslOpencodeVersion,
+  wslOpencodeInstallCommand,
+} from "./runtime"
 
 let persistedServers: WslServerConfig[] = []
 let releaseOpencodeResolve: (() => void) | undefined
@@ -33,6 +37,51 @@ 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(
@@ -55,7 +104,7 @@ test("clears cached distro probes when removing a WSL server", () => {
       {
         Debian: {
           distro: "Debian",
-          resolvedPath: "/home/luke/.opencode/bin/opencode",
+          resolvedPath: "/home/luke/.local/share/opencode/desktop/beta/1.16.2/opencode2",
           version: "1.16.2",
           expectedVersion: "1.16.2",
           matchesDesktop: true,
@@ -164,7 +213,7 @@ test("probes addable distros in parallel before checking OpenCode", async () =>
     },
     resolveOpencode: async (distro) => {
       opencode.push(distro)
-      return "/home/me/.opencode/bin/opencode"
+      return "/home/me/.local/share/opencode/desktop/dev/1.16.2/opencode2"
     },
   })
 
@@ -195,7 +244,7 @@ test("does not check OpenCode in addable distros that cannot execute commands",
     }),
     resolveOpencode: async (distro) => {
       opencode.push(distro)
-      return "/home/me/.opencode/bin/opencode"
+      return "/home/me/.local/share/opencode/desktop/dev/1.16.2/opencode2"
     },
   })
 
@@ -225,7 +274,7 @@ function testControllerOptions() {
       await new Promise<void>((resolve) => {
         releaseOpencodeResolve = resolve
       })
-      return "/home/me/.opencode/bin/opencode"
+      return "/home/me/.local/share/opencode/desktop/dev/1.16.2/opencode2"
     },
   }
 }

packages/desktop/src/main/wsl/servers.ts

@@ -37,7 +37,7 @@ type RunningSidecar = {
   password: string
 }
 
-type SpawnSidecar = (distro: string) => Promise<RunningSidecar>
+type SpawnSidecar = (distro: string, version: string, channel: string) => Promise<RunningSidecar>
 
 type ControllerLogger = {
   log: (message: string, meta?: unknown) => void
@@ -51,6 +51,8 @@ type WslServersControllerOptions = {
   probeDistro?: typeof probeWslDistro
   resolveOpencode?: typeof resolveWslOpencode
   readCommandVersion?: typeof readWslCommandVersion
+  installOpencode?: typeof installWslOpencode
+  channel?: string
 }
 
 export type WslServersController = ReturnType<typeof createWslServersController>
@@ -60,7 +62,7 @@ export function wslServerIdForDistro(distro: string) {
 }
 
 export function createWslServersController(
-  appVersion: string,
+  initialCliVersion: string | null,
   spawnSidecar: SpawnSidecar,
   options?: WslServersControllerOptions,
 ) {
@@ -69,10 +71,17 @@ 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 })
@@ -132,11 +141,12 @@ export function createWslServersController(
   }
 
   const checkOpencode = async (distro: string, opts?: { signal?: AbortSignal }) => {
-    const resolved = await (options?.resolveOpencode ?? resolveWslOpencode)(distro, opts)
-    const version = resolved
+    const version = expectedVersion()
+    const resolved = await (options?.resolveOpencode ?? resolveWslOpencode)(distro, channel, opts)
+    const installed = resolved
       ? await (options?.readCommandVersion ?? readWslCommandVersion)(resolved, distro, opts)
       : null
-    return opencodeCheck(distro, resolved, version, appVersion)
+    return opencodeCheck(distro, resolved, installed, version)
   }
 
   const refreshOpencodeCheck = async (distro: string, opts?: { signal?: AbortSignal }) => {
@@ -229,7 +239,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)
+      const sidecar = await spawnSidecar(item.config.distro, expectedVersion(), channel)
       if (!isCurrentStartAttempt(id, attempt)) {
         try {
           sidecar.listener.stop()
@@ -294,6 +304,10 @@ export function createWslServersController(
   }
 
   return {
+    setCliVersion(version: string) {
+      cliVersion = version
+    },
+
     getState() {
       return state
     },
@@ -362,12 +376,15 @@ export function createWslServersController(
 
     async installOpencode(name: string) {
       await runJob({ kind: "install-opencode", distro: name, startedAt: Date.now() }, async (abort) => {
-        const result = await installWslOpencode(appVersion, name, { signal: abort.signal })
+        const version = expectedVersion()
+        const result = await (options?.installOpencode ?? installWslOpencode)(version, channel, 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, appVersion, name)
+        expectOpencodeVersion(state.opencodeChecks[name]?.version ?? null, version, name)
         const id = wslServerIdToRestart(state.servers, name)
         if (id) await startServer(id)
       })

packages/desktop/src/main/wsl/sidecar.ts

@@ -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, resolveWslOpencode, shellEscape, wslArgs } from "./runtime"
+import { type WslCommandLine, readWslCommandVersion, resolveWslOpencode, shellEscape, wslArgs } from "./runtime"
 import { pollWslHealth } from "./startup"
 import { nativeT } from "../native-translations"
 
@@ -16,10 +16,22 @@ 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)
+  const opencode = await resolveWslOpencode(distro, channel)
   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()