feat(plugin): allow tool hooks to fail with tool errors (#41668)

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

.github/workflows/publish.yml

@@ -75,7 +75,7 @@ jobs:
   build-cli:
     needs: version
     runs-on: blacksmith-4vcpu-ubuntu-2404
-    if: github.repository == 'anomalyco/opencode'
+    if: github.repository == 'anomalyco/opencode' && github.ref_name != 'beta'
     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'
+        if: github.ref_name != 'v2' && github.ref_name != 'beta'
         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'
+        if: github.ref_name != 'v2' && github.ref_name != 'beta'
         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'
+        if: github.ref_name != 'v2' && github.ref_name != 'beta'
         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'
+    if: github.repository == 'anomalyco/opencode' && github.ref_name != 'beta'
     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'
+    if: github.repository == 'anomalyco/opencode' && github.ref_name != 'v2' && github.ref_name != 'beta'
     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' }}
-          RUST_TARGET: ${{ matrix.settings.target }}
+          OPENCODE_CLI_TARGET: ${{ matrix.settings.target }}
 
       - name: Build
         run: bun run build
@@ -393,6 +393,7 @@ 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
@@ -496,29 +497,31 @@ jobs:
           registry-url: "https://registry.npmjs.org"
 
       - uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4.3.0
-        if: github.ref_name != 'v2'
+        if: github.ref_name != 'v2' && github.ref_name != 'beta'
         with:
           name: opencode-cli
           path: packages/opencode/dist
 
       - uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4.3.0
-        if: github.ref_name != 'v2'
+        if: github.ref_name != 'v2' && github.ref_name != 'beta'
         with:
           name: opencode-cli-windows
           path: packages/opencode/dist
 
       - uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4.3.0
-        if: github.ref_name != 'v2'
+        if: github.ref_name != 'v2' && github.ref_name != 'beta'
         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

bun.lock

@@ -439,6 +439,7 @@
         "@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:",

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

@@ -41,6 +41,7 @@ export type SessionMessageAgentSelected = {
   time: { created: number }
   type: "agent-switched"
   agent: string
+  previous?: string
 }
 
 export type PromptBase64 = string
@@ -2535,6 +2536,7 @@ export type SessionImportInput = {
           readonly time: { readonly created: number }
           readonly type: "agent-switched"
           readonly agent: string
+          readonly previous?: string
         }
       | {
           readonly id: string
@@ -2786,6 +2788,7 @@ export type SessionImportInput = {
           readonly time: { readonly created: number }
           readonly type: "agent-switched"
           readonly agent: string
+          readonly previous?: string
         }
       | {
           readonly id: string
@@ -3037,6 +3040,7 @@ export type SessionImportInput = {
           readonly time: { readonly created: number }
           readonly type: "agent-switched"
           readonly agent: string
+          readonly previous?: string
         }
       | {
           readonly id: string

packages/core/package.json

@@ -25,7 +25,6 @@
   },
   "imports": {
     "#sqlite": {
-      "workerd": "./src/database/sqlite.workerd.ts",
       "bun": "./src/database/sqlite.bun.ts",
       "node": "./src/database/sqlite.node.ts",
       "default": "./src/database/sqlite.bun.ts"

packages/core/src/aisdk.ts

@@ -508,8 +508,23 @@ 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 {

packages/core/src/database/database.ts

@@ -1,9 +1,8 @@
 export * as Database from "./database"
 
 import { EffectDrizzleSqlite } from "@opencode-ai/effect-drizzle-sqlite"
-import { sqliteLayer, supportsForeignKeyToggle, supportsTuningPragmas } from "#sqlite"
+import { sqliteLayer } from "#sqlite"
 import { Context, Effect, Layer, Schema } from "effect"
-import type { SqlClient } from "effect/unstable/sql"
 import { Global } from "@opencode-ai/util/global"
 import { isAbsolute, join } from "path"
 import { DatabaseMigration } from "./migration"
@@ -28,15 +27,12 @@ const databaseLayer = Layer.effect(
   Effect.gen(function* () {
     const db = yield* makeDatabase
 
-    if (supportsTuningPragmas) {
-      yield* db.run("PRAGMA journal_mode = WAL")
-      yield* db.run("PRAGMA synchronous = NORMAL")
-      yield* db.run("PRAGMA busy_timeout = 5000")
-      yield* db.run("PRAGMA cache_size = -64000")
-      yield* db.run("PRAGMA wal_checkpoint(PASSIVE)")
-    }
-    // Durable Object SQLite always enforces foreign keys and rejects the pragma.
-    if (supportsForeignKeyToggle) yield* db.run("PRAGMA foreign_keys = ON")
+    yield* db.run("PRAGMA journal_mode = WAL")
+    yield* db.run("PRAGMA synchronous = NORMAL")
+    yield* db.run("PRAGMA busy_timeout = 5000")
+    yield* db.run("PRAGMA cache_size = -64000")
+    yield* db.run("PRAGMA foreign_keys = ON")
+    yield* db.run("PRAGMA wal_checkpoint(PASSIVE)")
     yield* DatabaseMigration.apply(db)
 
     return { db }
@@ -47,19 +43,14 @@ 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 layerWith(sqliteLayer({ filename }))
-      return layerWith(sqliteLayer({ filename: join(global.data, filename) }))
+      if (filename === ":memory:" || isAbsolute(filename)) return provide(filename)
+      return provide(join(global.data, filename))
     }),
   )
 }
 
-// Builds the database service over an already-configured SqlClient layer for
-// runtimes that receive database storage instead of opening a filesystem path.
-export function layerWith(sqlite: Layer.Layer<SqlClient.SqlClient>) {
-  return databaseLayer.pipe(Layer.provide(sqlite))
-}
-
 export function configured(options?: Options) {
   return makeGlobalNode({ service: Service, layer: layer(options), deps: [Global.node] })
 }

packages/core/src/database/migration.ts

@@ -2,7 +2,6 @@ export * as DatabaseMigration from "./migration"
 
 import { sql } from "drizzle-orm"
 import { Effect, Semaphore } from "effect"
-import { supportsForeignKeyToggle } from "#sqlite"
 import type { EffectDrizzleSqlite } from "@opencode-ai/effect-drizzle-sqlite"
 import { migrations } from "./migration.gen"
 import schema from "./schema.gen"
@@ -21,10 +20,8 @@ export type Migration = {
 export function apply(db: Database) {
   return lock.withPermit(
     Effect.gen(function* () {
-      // OpenCode owns the unprefixed table namespace. Embedders sharing this
-      // database may own underscore-prefixed tables, which bootstrap ignores.
       const tables = yield* db.all<{ name: string }>(
-        sql`SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%' AND substr(name, 1, 1) <> '_'`,
+        sql`SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%'`,
       )
       if (tables.some((table) => table.name === "session" || table.name === "session_v2"))
         return yield* applyOnly(db, migrations)
@@ -106,15 +103,9 @@ export function applyOnly(db: Database, input: Migration[]) {
         })
         continue
       }
-      // Durable Object SQLite rejects the foreign_keys toggle; the closest
-      // allowlisted relaxation is deferring enforcement to transaction commit.
-      const relaxForeignKeys = supportsForeignKeyToggle
-        ? db.run(sql`PRAGMA foreign_keys = OFF`)
-        : db.run(sql`PRAGMA defer_foreign_keys = ON`)
-      const restoreForeignKeys = supportsForeignKeyToggle ? db.run(sql`PRAGMA foreign_keys = ON`) : Effect.void
-      yield* relaxForeignKeys
+      yield* db.run(sql`PRAGMA foreign_keys = OFF`)
       yield* apply.pipe(
-        Effect.ensuring(restoreForeignKeys.pipe(Effect.orDie)),
+        Effect.ensuring(db.run(sql`PRAGMA foreign_keys = ON`).pipe(Effect.orDie)),
         Effect.tapError((error) =>
           Effect.logError("database migration failed", {
             migration: migration.id,

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

@@ -13,11 +13,6 @@ const ATTR_DB_SYSTEM_NAME = "db.system.name"
 const TypeId = "~@opencode-ai/core/database/SqliteBun" as const
 type TypeId = typeof TypeId
 
-export const supportsTuningPragmas = true
-
-// Foreign keys default OFF and can be toggled per connection.
-export const supportsForeignKeyToggle = true
-
 interface SqliteClient extends SqlClient.SqlClient {
   readonly [TypeId]: TypeId
   readonly config: Config

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

@@ -13,11 +13,6 @@ const ATTR_DB_SYSTEM_NAME = "db.system.name"
 const TypeId = "~@opencode-ai/core/database/SqliteNode" as const
 type TypeId = typeof TypeId
 
-export const supportsTuningPragmas = true
-
-// Foreign keys default OFF and can be toggled per connection.
-export const supportsForeignKeyToggle = true
-
 interface SqliteClient extends SqlClient.SqlClient {
   readonly [TypeId]: TypeId
   readonly config: Config

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

@@ -1,254 +0,0 @@
-import { drizzle } from "drizzle-orm/durable-sqlite"
-import { Context, Effect, Exit, Fiber, Layer, Scope, Semaphore, Stream } from "effect"
-import { identity } from "effect/Function"
-import { Reactivity } from "effect/unstable/reactivity"
-import { SqlClient, Statement } from "effect/unstable/sql"
-import type { Connection } from "effect/unstable/sql/SqlConnection"
-import { classifySqliteError, SqlError, UnknownError } from "effect/unstable/sql/SqlError"
-import { Sqlite } from "./sqlite"
-
-const ATTR_DB_SYSTEM_NAME = "db.system.name"
-
-const TypeId = "~@opencode-ai/core/database/SqliteWorkerd" as const
-type TypeId = typeof TypeId
-
-// Durable Object SQLite only allowlists introspection pragmas; journal_mode,
-// synchronous, busy_timeout, cache_size, and wal_checkpoint all throw, and
-// foreign keys are already enforced by default (SQLITE_DEFAULT_FOREIGN_KEYS=1).
-export const supportsTuningPragmas = false
-
-// Durable Object SQLite rejects `PRAGMA foreign_keys`: enforcement is always
-// on (SQLITE_DEFAULT_FOREIGN_KEYS=1) and only `defer_foreign_keys` is
-// allowlisted for migrations that must relax checking inside a transaction.
-export const supportsForeignKeyToggle = false
-
-// Minimal structural types for the Durable Object storage API so this adapter
-// does not depend on @cloudflare/workers-types (whose ambient globals conflict
-// with @types/bun). Shapes match the SqlStorage and DurableObjectStorage docs.
-type SqlStorageValue = ArrayBuffer | string | number | null
-
-interface SqlStorageCursor {
-  readonly columnNames: Array<string>
-  raw(): IterableIterator<Array<SqlStorageValue>>
-  toArray(): Array<Record<string, SqlStorageValue>>
-}
-
-export interface SqlStorage {
-  exec(query: string, ...bindings: Array<unknown>): SqlStorageCursor
-}
-
-export interface DurableObjectStorage {
-  readonly sql: SqlStorage
-  transaction<T>(closure: (txn: { rollback(): void }) => Promise<T>): Promise<T>
-  transactionSync<T>(closure: () => T): T
-}
-
-interface SqliteClient extends SqlClient.SqlClient {
-  readonly [TypeId]: TypeId
-  readonly config: Config
-  readonly updateValues: never
-}
-
-interface Config {
-  readonly storage: DurableObjectStorage
-  readonly spanAttributes?: Record<string, unknown>
-  readonly transformResultNames?: (str: string) => string
-  readonly transformQueryNames?: (str: string) => string
-}
-
-// sql.exec() rejects BEGIN/COMMIT/SAVEPOINT, so SqlClient.make's default
-// transaction SQL can never run. withTransaction is replaced below with a
-// DurableObjectStorage.transaction-backed implementation; this service only
-// tracks the active transaction connection for statements and nesting checks.
-const WorkerdTransaction = Context.Service<SqlClient.TransactionConnection, SqlClient.TransactionConnection.Service>(
-  "@opencode-ai/core/database/SqliteWorkerdTransaction",
-)
-
-const transactionError = (message: string) =>
-  new SqlError({
-    reason: new UnknownError({ cause: new Error(message), message, operation: "transaction" }),
-  })
-
-const makeWithTransaction =
-  (
-    storage: DurableObjectStorage,
-    connection: Connection,
-    semaphore: Semaphore.Semaphore,
-  ): SqlClient.SqlClient["withTransaction"] =>
-  <A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E | SqlError, R> =>
-    Effect.withFiber((fiber) => {
-      const services = fiber.context
-      if (Context.getOption(services, WorkerdTransaction)._tag === "Some")
-        return Effect.fail(
-          transactionError("Nested transactions are not supported by Cloudflare Durable Object SQLite storage"),
-        )
-      const effectWithTxn = Effect.provideContext(
-        effect,
-        Context.add(services, WorkerdTransaction, [connection, 0] as const),
-      )
-      return semaphore.withPermits(1)(
-        Effect.callback((resume) => {
-          let interrupted = false
-          const promise = storage
-            .transaction(
-              (txn) =>
-                new Promise<void>((resolve) => {
-                  if (interrupted) return resolve()
-                  resume(
-                    Effect.onExit(effectWithTxn, (exit) => {
-                      if (Exit.isFailure(exit)) txn.rollback()
-                      resolve()
-                      // wait for the transaction to complete
-                      return Effect.promise(() => promise)
-                    }),
-                  )
-                }),
-            )
-            .catch((cause) =>
-              resume(
-                Effect.fail(
-                  new SqlError({
-                    reason: classifySqliteError(cause, { message: "Failed transaction", operation: "transaction" }),
-                  }),
-                ),
-              ),
-            )
-          return Effect.suspend(() => {
-            interrupted = true
-            return Effect.promise(() => promise)
-          })
-        }),
-      )
-    })
-
-const make = (options: Config) =>
-  Effect.gen(function* () {
-    const native = (yield* Sqlite.Native) as DurableObjectStorage
-
-    const compiler = Statement.makeCompilerSqlite(options.transformQueryNames)
-    const transformRows = options.transformResultNames
-      ? Statement.defaultTransforms(options.transformResultNames).array
-      : undefined
-
-    // SqlClient.SafeIntegers is ignored: Durable Object SQLite has no bigint
-    // mode and always returns integers as numbers. Blobs come back as
-    // ArrayBuffer and are normalized to Uint8Array to match the other adapters.
-    function* runIterator(query: string, params: ReadonlyArray<unknown> = []) {
-      const cursor = native.sql.exec(query, ...params)
-      const columns = cursor.columnNames
-      for (const row of cursor.raw()) {
-        const record: Record<string, unknown> = {}
-        for (let i = 0; i < columns.length; i++) {
-          const value = row[i]
-          record[columns[i]] = value instanceof ArrayBuffer ? new Uint8Array(value) : value
-        }
-        yield record
-      }
-    }
-
-    const run = (query: string, params: ReadonlyArray<unknown> = []) =>
-      Effect.try({
-        try: () => Array.from(runIterator(query, params)),
-        catch: (cause) =>
-          new SqlError({
-            reason: classifySqliteError(cause, { message: "Failed to execute statement", operation: "execute" }),
-          }),
-      })
-
-    const runValues = (query: string, params: ReadonlyArray<unknown> = []) =>
-      Effect.try({
-        try: () =>
-          Array.from(native.sql.exec(query, ...params).raw(), (row) =>
-            row.map((value) => (value instanceof ArrayBuffer ? new Uint8Array(value) : value)),
-          ),
-        catch: (cause) =>
-          new SqlError({
-            reason: classifySqliteError(cause, { message: "Failed to execute statement", operation: "execute" }),
-          }),
-      })
-
-    const connection = identity<Connection>({
-      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 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,
-        transactionService: WorkerdTransaction,
-        spanAttributes: [
-          ...(options.spanAttributes ? Object.entries(options.spanAttributes) : []),
-          [ATTR_DB_SYSTEM_NAME, "sqlite"],
-        ],
-        transformRows,
-      })) as SqliteClient,
-      {
-        [TypeId]: TypeId,
-        config: options,
-        withTransaction: makeWithTransaction(native, connection, semaphore),
-        // Durable Object SQLite rejects BEGIN/COMMIT/SAVEPOINT; consumers such
-        // as the drizzle session must route through withTransaction instead.
-        transactionStatements: false,
-      },
-    )
-
-    return client
-  })
-
-// Defends against the shared path-based Database.layer, which passes a
-// filename instead of storage when resolved under the workerd condition.
-const nativeLayer = (config: Config) =>
-  config.storage
-    ? Layer.succeed(Sqlite.Native, config.storage)
-    : Layer.effect(
-        Sqlite.Native,
-        Effect.die(
-          "workerd sqlite cannot open a database from a path; use Database.layerWith(sqliteLayer({ storage }))",
-        ),
-      )
-
-const clientLayer = (config: Config) => Layer.effect(SqlClient.SqlClient, make(config))
-
-const drizzleLayer = Layer.effect(
-  Sqlite.Drizzle,
-  Effect.gen(function* () {
-    const native = (yield* Sqlite.Native) as DurableObjectStorage
-    return drizzle(native) as unknown as Sqlite.DrizzleClient
-  }),
-)
-
-export const sqliteLayer = (config: Config) => {
-  const native = nativeLayer(config)
-  return Layer.merge(native, Layer.merge(clientLayer(config), drizzleLayer).pipe(Layer.provide(native))).pipe(
-    Layer.provide(Reactivity.layer),
-  )
-}

packages/core/src/plugin/hooks.ts

@@ -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 { ToolHooks } from "@opencode-ai/plugin/effect/tool"
+import type { ToolFailures, 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,19 +15,29 @@ export interface Domains {
   readonly tool: ToolHooks
 }
 
-type Callback<Event> = (event: Event) => Effect.Effect<void>
+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>
 
 export interface Interface {
-  readonly register: <Domain extends keyof Domains, Name extends keyof Domains[Domain]>(
+  readonly register: <Domain extends keyof Domains, Name extends keyof Domains[Domain] & keyof Failures[Domain]>(
     domain: Domain,
     name: Name,
-    callback: Callback<Domains[Domain][Name]>,
+    callback: Callback<Domains[Domain][Name], Failures[Domain][Name]>,
   ) => Effect.Effect<State.Registration, never, Scope.Scope>
-  readonly trigger: <Domain extends keyof Domains, Name extends keyof Domains[Domain]>(
+  readonly trigger: <Domain extends keyof Domains, Name extends keyof Domains[Domain] & keyof Failures[Domain]>(
     domain: Domain,
     name: Name,
     event: Domains[Domain][Name],
-  ) => Effect.Effect<Domains[Domain][Name]>
+  ) => Effect.Effect<Domains[Domain][Name], Failures[Domain][Name]>
 }
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/PluginHooks") {}
@@ -56,7 +66,9 @@ 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> = Reflect.apply(callback, undefined, [event])
+        const result: Effect.Effect<void, Failures[typeof domain][typeof name]> = Reflect.apply(callback, undefined, [
+          event,
+        ])
         yield* result
       }
       return event

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

@@ -4,6 +4,7 @@ import { SessionEvent } from "./event"
 import { SessionMessage } from "./message"
 
 export interface Adapter {
+  readonly getAgent: () => Effect.Effect<SessionMessage.AgentSelected["agent"] | undefined, never, never>
   readonly getModel: () => Effect.Effect<SessionMessage.ModelSelected["model"] | undefined, never, never>
   readonly getCurrentAssistant: () => Effect.Effect<SessionMessage.Assistant | undefined, never, never>
   readonly getAssistant: (
@@ -59,15 +60,19 @@ export function update(adapter: Adapter, event: SessionEvent.DurableEvent) {
       "session.created": () => Effect.void,
       "session.usage.recorded": () => Effect.void,
       "session.agent.selected": (event) => {
-        return adapter.appendMessage(
-          SessionMessage.AgentSelected.make({
-            id: SessionMessage.ID.fromEvent(event.id),
-            type: "agent-switched",
-            metadata: event.metadata,
-            agent: event.data.agent,
-            time: { created: event.created },
-          }),
-        )
+        return Effect.gen(function* () {
+          const previous = yield* adapter.getAgent()
+          yield* adapter.appendMessage(
+            SessionMessage.AgentSelected.make({
+              id: SessionMessage.ID.fromEvent(event.id),
+              type: "agent-switched",
+              metadata: event.metadata,
+              agent: event.data.agent,
+              previous,
+              time: { created: event.created },
+            }),
+          )
+        })
       },
       "session.model.selected": (event) => {
         return Effect.gen(function* () {

packages/core/src/session/projector.ts

@@ -5,6 +5,7 @@ import { DateTime, Effect, Layer, Schema, Stream } from "effect"
 import { Database } from "../database/database"
 import { Bus } from "../bus"
 import { makeGlobalNode } from "@opencode-ai/util/effect/app-node"
+import { Agent } from "../agent"
 import { Model } from "../model"
 import { SessionEvent } from "./event"
 import { SessionMessage } from "./message"
@@ -230,6 +231,17 @@ function run(db: DatabaseService, event: MessageEvent) {
     }
     const appendMessage = (message: SessionMessage.Info) => insertMessage(db, event, message)
     const adapter: SessionMessageUpdater.Adapter = {
+      getAgent() {
+        return db
+          .select({ agent: SessionTable.agent })
+          .from(SessionTable)
+          .where(eq(SessionTable.id, event.data.sessionID))
+          .get()
+          .pipe(
+            Effect.orDie,
+            Effect.map((row) => (row?.agent ? Agent.ID.make(row.agent) : undefined)),
+          )
+      },
       getModel() {
         return db
           .select({ model: SessionTable.model })
@@ -398,12 +410,15 @@ const layer = Layer.effectDiscard(
       db.delete(SessionTable).where(eq(SessionTable.id, event.data.sessionID)).run().pipe(Effect.orDie),
     )
     yield* bus.project(SessionEvent.AgentSelected, (event) =>
-      db
-        .update(SessionTable)
-        .set({ agent: event.data.agent, time_updated: DateTime.toEpochMillis(event.created) })
-        .where(eq(SessionTable.id, event.data.sessionID))
-        .run()
-        .pipe(Effect.orDie, Effect.andThen(run(db, event))),
+      Effect.gen(function* () {
+        yield* run(db, event)
+        yield* db
+          .update(SessionTable)
+          .set({ agent: event.data.agent, time_updated: DateTime.toEpochMillis(event.created) })
+          .where(eq(SessionTable.id, event.data.sessionID))
+          .run()
+          .pipe(Effect.orDie)
+      }),
     )
     yield* bus.project(SessionEvent.ModelSelected, (event) =>
       Effect.gen(function* () {

packages/core/src/session/runner/to-llm-message.ts

@@ -59,6 +59,25 @@ const attachmentContent = (file: FileAttachment): ContentPart[] => {
   return []
 }
 
+const userAttachmentContent = (files: readonly FileAttachment[]) => {
+  const eligible = files.filter(
+    (file) => imageMimes.has(file.mime) && file.source.type === "inline" && file.mention?.text,
+  )
+  if (eligible.length < 2) return files.flatMap(attachmentContent)
+
+  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 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)
+  })
+}
+
 const decodeToolInput = Schema.decodeUnknownOption(Schema.UnknownFromJsonString)
 
 const providerMetadata = (
@@ -186,7 +205,7 @@ function toLLMMessage(message: SessionMessage.Info, model: Model.Ref, providerMe
       const content = [
         ...(message.skills ?? []).map((skill) => Message.text(skill.text)),
         ...(message.text === "" ? [] : [Message.text(message.text)]),
-        ...(message.files ?? []).flatMap(attachmentContent),
+        ...userAttachmentContent(message.files ?? []),
       ]
       if (content.length === 0) return []
       return [

packages/core/test/aisdk.test.ts

@@ -275,6 +275,73 @@ 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

packages/core/test/database-migration.test.ts

@@ -84,19 +84,6 @@ describe("DatabaseMigration", () => {
     ).rejects.toThrow("Database is not empty and has no session table")
   })
 
-  test("bootstraps alongside underscore-prefixed embedder tables", async () => {
-    await run(
-      Effect.gen(function* () {
-        const db = yield* makeDb
-        yield* db.run(sql`CREATE TABLE _embedder_state (id text PRIMARY KEY)`)
-        yield* DatabaseMigration.apply(db)
-        expect(yield* db.get(sql`SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'session_v2'`)).toEqual(
-          { name: "session_v2" },
-        )
-      }),
-    )
-  })
-
   test("applies generic migrations once and records their order", async () => {
     await run(
       Effect.gen(function* () {

packages/core/test/plugin.test.ts

@@ -1,4 +1,5 @@
 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"
@@ -395,4 +396,51 @@ 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([])
+    }),
+  )
 })

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

@@ -647,7 +647,7 @@ describe("Session.create", () => {
   it.effect("switches the selected agent through the durable Session event", () =>
     Effect.gen(function* () {
       const session = yield* Session.Service
-      const created = yield* session.create({ location })
+      const created = yield* session.create({ location, agent: Agent.ID.make("build") })
 
       yield* session.switchAgent({ sessionID: created.id, agent: Agent.ID.make("plan") })
 
@@ -655,6 +655,9 @@ describe("Session.create", () => {
       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" } }])
+      expect(yield* session.messages({ sessionID: created.id, order: "asc" })).toMatchObject([
+        { type: "agent-switched", agent: "plan", previous: "build" },
+      ])
     }),
   )
 

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

@@ -358,6 +358,7 @@ describe("SessionProjector", () => {
           directory: "/project",
           title: "test",
           version: "test",
+          agent: "plan",
           model: previousModel,
         })
         .run()
@@ -459,6 +460,10 @@ describe("SessionProjector", () => {
         text: "synthetic context",
         metadata: { source: "projector-test" },
       })
+      expect(messages.find((message) => message.type === "agent-switched")).toMatchObject({
+        agent: build,
+        previous: "plan",
+      })
       expect(messages.find((message) => message.type === "model-switched")).toMatchObject({ previous: previousModel })
       expect(messages.find((message) => message.type === "shell")).toMatchObject({
         command: "pwd",

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

@@ -373,6 +373,103 @@ Recent work
     ])
   })
 
+  test("deduplicates provider media while preserving durable attachment references", () => {
+    const data = Base64.make("AAECAw==")
+    const messages = toLLMMessages(
+      [
+        SessionMessage.User.make({
+          id: id("user-duplicate-image"),
+          type: "user",
+          text: "[Image 1] [Image 1] [Image 2]",
+          files: [
+            FileAttachment.make({
+              data,
+              mime: "image/png",
+              source: { type: "inline" },
+              name: "image.png",
+              mention: { start: 0, end: 9, text: "[Image 1]" },
+            }),
+            FileAttachment.make({
+              data,
+              mime: "image/png",
+              source: { type: "inline" },
+              name: "image.png",
+              mention: { start: 10, end: 19, text: "[Image 1]" },
+            }),
+            FileAttachment.make({
+              data,
+              mime: "image/png",
+              source: { type: "inline" },
+              name: "image.png",
+              description: "alternate use",
+              mention: { start: 20, end: 29, text: "[Image 2]" },
+            }),
+          ],
+          time: { created },
+        }),
+      ],
+      model,
+    )
+
+    expect(messages[0]?.content).toEqual([
+      { type: "text", text: "[Image 1] [Image 1] [Image 2]" },
+      { type: "media", mediaType: "image/png", data, filename: "image.png" },
+      {
+        type: "media",
+        mediaType: "image/png",
+        data,
+        filename: "image.png",
+        metadata: { description: "alternate use" },
+      },
+    ])
+  })
+
+  test("preserves provider media with distinct labels or URI sources", () => {
+    const data = Base64.make("AAECAw==")
+    const messages = toLLMMessages(
+      [
+        SessionMessage.User.make({
+          id: id("user-distinct-images"),
+          type: "user",
+          text: "[Image 1] [Image 2]",
+          files: [
+            FileAttachment.make({
+              data,
+              mime: "image/png",
+              source: { type: "inline" },
+              name: "image.png",
+              mention: { start: 0, end: 9, text: "[Image 1]" },
+            }),
+            FileAttachment.make({
+              data,
+              mime: "image/png",
+              source: { type: "inline" },
+              name: "image.png",
+              mention: { start: 10, end: 19, text: "[Image 2]" },
+            }),
+            FileAttachment.make({
+              data,
+              mime: "image/png",
+              source: { type: "uri", uri: "file:///project/image.png" },
+              name: "image.png",
+              mention: { start: 0, end: 9, text: "[Image 1]" },
+            }),
+            FileAttachment.make({
+              data,
+              mime: "image/png",
+              source: { type: "inline" },
+              name: "image.png",
+            }),
+          ],
+          time: { created },
+        }),
+      ],
+      model,
+    )
+
+    expect(messages[0]?.content.filter((part) => part.type === "media")).toHaveLength(4)
+  })
+
   test("replays durable tool media into canonical tool messages without structured base64", () => {
     const messages = toLLMMessages(
       [

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

@@ -1,137 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { Database } from "bun:sqlite"
-import { Effect, Layer } from "effect"
-import { SqlClient } from "effect/unstable/sql"
-import { SqlError } from "effect/unstable/sql/SqlError"
-import { sqliteLayer } from "@opencode-ai/core/database/sqlite.workerd"
-import type { DurableObjectStorage } from "@opencode-ai/core/database/sqlite.workerd"
-import { tempGlobalLayer } from "./fixture/global"
-
-// Emulates the Durable Object storage API over bun:sqlite so the adapter can
-// be verified without workerd or Cloudflare runtime dependencies.
-const makeFakeStorage = () => {
-  const native = new Database(":memory:")
-  const toSqlStorageValue = (value: unknown) => {
-    if (!(value instanceof Uint8Array)) return value as ArrayBuffer | string | number | null
-    const buffer = new ArrayBuffer(value.byteLength)
-    new Uint8Array(buffer).set(value)
-    return buffer
-  }
-  const storage: DurableObjectStorage = {
-    sql: {
-      exec(query: string, ...bindings: Array<unknown>) {
-        const statement = native.query(query)
-        const rows = (statement.values(...(bindings as never[])) ?? []).map((row) => row.map(toSqlStorageValue))
-        const columnNames = statement.columnNames
-        return {
-          columnNames,
-          raw: () => rows[Symbol.iterator](),
-          toArray: () => rows.map((row) => Object.fromEntries(columnNames.map((name, i) => [name, row[i]]))),
-        }
-      },
-    },
-    transaction<T>(closure: (txn: { rollback(): void }) => Promise<T>): Promise<T> {
-      native.run("BEGIN")
-      let rolledBack = false
-      return closure({ rollback: () => (rolledBack = true) }).then(
-        (result) => {
-          native.run(rolledBack ? "ROLLBACK" : "COMMIT")
-          return result
-        },
-        (error) => {
-          native.run("ROLLBACK")
-          throw error
-        },
-      )
-    },
-    transactionSync<T>(closure: () => T): T {
-      return native.transaction(closure)()
-    },
-  }
-  return storage
-}
-
-const run = <A, E>(storage: DurableObjectStorage, effect: Effect.Effect<A, E, SqlClient.SqlClient>) =>
-  Effect.runPromise(effect.pipe(Effect.provide(sqliteLayer({ storage })), Effect.scoped))
-
-describe("sqlite.workerd", () => {
-  test("executes statements with bindings and maps rows to records", async () => {
-    const rows = await run(
-      makeFakeStorage(),
-      Effect.gen(function* () {
-        const sql = yield* SqlClient.SqlClient
-        yield* sql`CREATE TABLE item (id INTEGER PRIMARY KEY, name TEXT NOT NULL)`
-        yield* sql`INSERT INTO item (id, name) VALUES (${1}, ${"one"}), (${2}, ${"two"})`
-        return yield* sql<{ id: number; name: string }>`SELECT id, name FROM item ORDER BY id`
-      }),
-    )
-    expect(rows).toEqual([
-      { id: 1, name: "one" },
-      { id: 2, name: "two" },
-    ])
-  })
-
-  test("normalizes ArrayBuffer blob values to Uint8Array", async () => {
-    const rows = await run(
-      makeFakeStorage(),
-      Effect.gen(function* () {
-        const sql = yield* SqlClient.SqlClient
-        yield* sql`CREATE TABLE blob (data BLOB NOT NULL)`
-        yield* sql`INSERT INTO blob (data) VALUES (${new Uint8Array([1, 2, 3])})`
-        return yield* sql<{ data: Uint8Array }>`SELECT data FROM blob`
-      }),
-    )
-    expect(rows[0].data).toBeInstanceOf(Uint8Array)
-    expect(Array.from(rows[0].data)).toEqual([1, 2, 3])
-  })
-
-  test("withTransaction commits on success and rolls back on failure", async () => {
-    const storage = makeFakeStorage()
-    const count = await run(
-      storage,
-      Effect.gen(function* () {
-        const sql = yield* SqlClient.SqlClient
-        yield* sql`CREATE TABLE t (value TEXT NOT NULL)`
-        yield* sql.withTransaction(sql`INSERT INTO t (value) VALUES (${"kept"})`)
-        yield* sql
-          .withTransaction(
-            Effect.gen(function* () {
-              yield* sql`INSERT INTO t (value) VALUES (${"discarded"})`
-              return yield* Effect.fail("rollback")
-            }),
-          )
-          .pipe(Effect.ignore)
-        return yield* sql<{ count: number }>`SELECT count(*) AS count FROM t`
-      }),
-    )
-    expect(count[0].count).toBe(1)
-  })
-
-  test("nested withTransaction fails with SqlError", async () => {
-    const error = await run(
-      makeFakeStorage(),
-      Effect.gen(function* () {
-        const sql = yield* SqlClient.SqlClient
-        yield* sql`CREATE TABLE t (value TEXT NOT NULL)`
-        return yield* sql
-          .withTransaction(sql.withTransaction(sql`INSERT INTO t (value) VALUES (${"nested"})`))
-          .pipe(Effect.flip)
-      }),
-    )
-    expect(error).toBeInstanceOf(SqlError)
-  })
-
-  test("boots the full database layer with migrations over injected storage", async () => {
-    const storage = makeFakeStorage()
-    const core = await import("@opencode-ai/core/database/database")
-    await Effect.runPromise(
-      Effect.scoped(Layer.build(core.Database.layerWith(sqliteLayer({ storage })).pipe(Layer.provide(tempGlobalLayer)))),
-    )
-    const names = storage.sql
-      .exec("SELECT name FROM sqlite_master WHERE type = 'table' ORDER BY name")
-      .toArray()
-      .map((row) => row.name)
-    expect(names).toContain("migration")
-    expect(names).toContain("session_v2")
-  })
-})

packages/desktop/electron-builder.config.test.ts

@@ -57,35 +57,35 @@ test("keeps a hidden prod launcher for old Linux pins", async () => {
   expect(desktop).toContain("NoDisplay=true")
 })
 
-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 () => {
+for (const channel of ["dev", "beta"] as const) {
+  test(`bundles the CLI outside the ${channel} app archive`, async () => {
     const previous = process.env.OPENCODE_CHANNEL
     process.env.OPENCODE_CHANNEL = channel
-    const module = await import(`./electron-builder.config.ts?no-cli-resource=${channel}`)
+    const module = await import(`./electron-builder.config.ts?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.extraResources).not.toContainEqual({
+    expect(config.files).toContain("!resources/opencode-cli*")
+    expect(config.extraResources).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*"],
+  })
+})

packages/desktop/electron-builder.config.ts

@@ -57,7 +57,7 @@ const getBase = (appId: string): Configuration => ({
   },
   files: ["out/**/*", "resources/**/*", "!resources/opencode-cli*"],
   extraResources: [
-    ...(channel === "dev"
+    ...(channel !== "prod"
       ? [
           {
             from: "resources/",

packages/desktop/package.json

@@ -37,6 +37,7 @@
     "@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:",

packages/desktop/scripts/copy-bundles.ts

@@ -1,9 +1,9 @@
 import { $ } from "bun"
 import * as path from "node:path"
 
-import { RUST_TARGET } from "./utils"
+import { CLI_TARGET } from "./utils"
 
-if (!RUST_TARGET) throw new Error("RUST_TARGET not defined")
+if (!CLI_TARGET) throw new Error("OPENCODE_CLI_TARGET not defined")
 
 const BUNDLE_DIR = "dist"
 const BUNDLES_OUT_DIR = path.join(process.cwd(), "dist/bundles")

packages/desktop/scripts/prebuild.ts

@@ -8,3 +8,4 @@ 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")

packages/desktop/scripts/utils.ts

@@ -13,46 +13,46 @@ export function resolveChannel(): Channel {
   return "dev"
 }
 
-export const CLI_BINARIES: Array<{ rustTarget: string; package: string; os: string; cpu: string }> = [
+export const CLI_BINARIES: Array<{ target: string; package: string; os: string; cpu: string }> = [
   {
-    rustTarget: "aarch64-apple-darwin",
+    target: "aarch64-apple-darwin",
     package: "@opencode-ai/cli-darwin-arm64",
     os: "darwin",
     cpu: "arm64",
   },
   {
-    rustTarget: "x86_64-apple-darwin",
+    target: "x86_64-apple-darwin",
     package: "@opencode-ai/cli-darwin-x64-baseline",
     os: "darwin",
     cpu: "x64",
   },
   {
-    rustTarget: "aarch64-pc-windows-msvc",
+    target: "aarch64-pc-windows-msvc",
     package: "@opencode-ai/cli-windows-arm64",
     os: "win32",
     cpu: "arm64",
   },
   {
-    rustTarget: "x86_64-pc-windows-msvc",
+    target: "x86_64-pc-windows-msvc",
     package: "@opencode-ai/cli-windows-x64-baseline",
     os: "win32",
     cpu: "x64",
   },
   {
-    rustTarget: "x86_64-unknown-linux-gnu",
+    target: "x86_64-unknown-linux-gnu",
     package: "@opencode-ai/cli-linux-x64-baseline",
     os: "linux",
     cpu: "x64",
   },
   {
-    rustTarget: "aarch64-unknown-linux-gnu",
+    target: "aarch64-unknown-linux-gnu",
     package: "@opencode-ai/cli-linux-arm64",
     os: "linux",
     cpu: "arm64",
   },
 ]
 
-export const RUST_TARGET = Bun.env.RUST_TARGET
+export const CLI_TARGET = Bun.env.OPENCODE_CLI_TARGET
 
 function nativeTarget() {
   const { platform, arch } = process
@@ -62,19 +62,19 @@ function nativeTarget() {
   throw new Error(`Unsupported platform: ${platform}/${arch}`)
 }
 
-export function getCurrentCli(target = RUST_TARGET ?? nativeTarget()) {
-  const binaryConfig = CLI_BINARIES.find((item) => item.rustTarget === target)
+export function getCurrentCli(target = CLI_TARGET ?? nativeTarget()) {
+  const binaryConfig = CLI_BINARIES.find((item) => item.target === target)
   if (!binaryConfig) throw new Error(`CLI configuration not available for target '${target}'`)
 
   return binaryConfig
 }
 
-export async function downloadCliToResources() {
+export async function downloadCliToResources(version = CLI_VERSION) {
   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}@${CLI_VERSION}`} ${`--os=${cli.os}`} ${`--cpu=${cli.cpu}`}`
+    await $`bun install --no-save --cwd ${directory} ${`${cli.package}@${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() {
   }
   if (process.platform === "darwin") await $`codesign --force --sign - ${dest}`
 
-  console.log(`Copied ${cli.package} to ${dest}`)
+  console.log(`Copied ${cli.package}@${version} to ${dest}`)
 }
 
 export function windowsify(path: string) {

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

@@ -1,3 +1,4 @@
+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"
@@ -8,52 +9,34 @@ 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, shellStateHome?: string) {
+export async function startBackgroundCli(logger: Logger) {
   const bundled = app.isPackaged
     ? join(process.resourcesPath, executableName())
     : join(root, "../../resources", executableName())
   logger.log("v2 CLI executable resolved", { bundled, packaged: app.isPackaged })
-  const version = await run(bundled, ["--version"], logger)
+  const version = parseVersion(await run(bundled, ["--version"], logger))
   const binary = app.isPackaged ? await installCli(bundled, version, logger) : bundled
-
-  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,
+  const service = await Service.ensure({
+    version,
+    command: [binary, "serve", "--service"],
+    onStart: (reason, previousVersion) => logger.log("v2 CLI background service starting", { reason, previousVersion }),
   })
+  if (service.auth?.type !== "basic") throw new Error("V2 CLI background service did not provide authentication")
   logger.log("v2 CLI background service ready", {
-    existing: Boolean(found),
-    username: "opencode",
-    ...endpoint(url),
+    username: service.auth.username,
+    version,
+    ...endpoint(service.url),
   })
   return {
-    url,
-    username: "opencode",
-    password,
+    url: service.url,
+    username: service.auth.username,
+    password: service.auth.password,
   }
 }
 
@@ -77,21 +60,13 @@ async function installCli(source: string, version: string, logger: Logger) {
   return destination
 }
 
-async function run(
-  binary: string,
-  args: string[],
-  logger: Logger,
-  options: { redact?: boolean; stateHome?: string } = {},
-) {
+async function run(binary: string, args: string[], logger: Logger) {
   logger.log("v2 CLI command started", { binary, args })
-  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(
+  return execFileAsync(binary, args, { windowsHide: true }).then(
     (result) => {
       const stdout = result.stdout.trim()
       const stderr = result.stderr.trim()
-      logger.log("v2 CLI command completed", { args, stdout: options.redact ? "[redacted]" : stdout, stderr })
+      logger.log("v2 CLI command completed", { args, stdout, stderr })
       return stdout
     },
     (error: unknown) => {
@@ -99,7 +74,7 @@ async function run(
       logger.error("v2 CLI command failed", {
         args,
         error: error instanceof Error ? error.message : String(error),
-        stdout: options.redact && output.stdout ? "[redacted]" : (output.stdout?.trim() ?? ""),
+        stdout: output.stdout?.trim() ?? "",
         stderr: output.stderr?.trim() ?? "",
       })
       throw error
@@ -107,11 +82,11 @@ async function run(
   )
 }
 
-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 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 endpoint(url: string | undefined) {

packages/desktop/src/main/index.ts

@@ -181,7 +181,7 @@ const main = Effect.gen(function* () {
     return
   }
 
-  const shellEnv = preferAppEnv(app.getPath("userData"))
+  preferAppEnv()
 
   app.on("second-instance", (_event: Event, argv: string[]) => {
     const urls = argv.filter((arg: string) => arg.startsWith("opencode://"))
@@ -310,7 +310,7 @@ const main = Effect.gen(function* () {
     useEnvProxy()
 
     logger.log("starting v2 background service")
-    const sidecar = yield* Effect.promise(() => startBackgroundCli(logger, shellEnv?.XDG_STATE_HOME))
+    const sidecar = yield* Effect.promise(() => startBackgroundCli(logger))
     yield* Deferred.succeed(serverReady, {
       url: sidecar.url,
       username: sidecar.username,

packages/desktop/src/main/server.ts

@@ -17,17 +17,16 @@ export function setDefaultServerUrl(url: string | null) {
   getStore().delete(DEFAULT_SERVER_URL_KEY)
 }
 
-export function preferAppEnv(userDataPath: string) {
+export function preferAppEnv() {
   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> {

packages/plugin/src/effect/registration.ts

@@ -4,9 +4,11 @@ export interface Registration {
   readonly dispose: Effect.Effect<void>
 }
 
-export type Hooks<Spec> = <Name extends keyof Spec>(
+export type Hooks<Spec, Failures extends Record<keyof Spec, unknown> = Record<keyof Spec, never>> = <
+  Name extends keyof Spec,
+>(
   name: Name,
-  callback: (input: Spec[Name]) => Effect.Effect<void>,
+  callback: (input: Spec[Name]) => Effect.Effect<void, Failures[Name]>,
 ) => Effect.Effect<Registration, never, Scope.Scope>
 
 export type Transform<Input> = (callback: (input: Input) => void) => Effect.Effect<Registration, never, Scope.Scope>

packages/plugin/src/effect/tool.ts

@@ -38,7 +38,13 @@ 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>
+  readonly hook: Hooks<ToolHooks, ToolFailures>
 }

packages/protocol/openapi.json

@@ -12733,6 +12733,9 @@
           },
           "agent": {
             "type": "string"
+          },
+          "previous": {
+            "type": "string"
           }
         },
         "required": ["id", "time", "type", "agent"],

packages/schema/src/session-message.ts

@@ -42,6 +42,7 @@ export const AgentSelected = Schema.Struct({
   ...Base,
   type: Schema.tag("agent-switched"),
   agent: Agent.ID,
+  previous: Agent.ID.pipe(optional),
 }).annotate({ identifier: "Session.Message.AgentSelected" })
 
 export interface ModelSelected extends Schema.Schema.Type<typeof ModelSelected> {}

packages/tui/src/component/prompt/index.tsx

@@ -60,6 +60,11 @@ import { Keymap, type KeymapCommand } from "../../context/keymap"
 import { abbreviateHome } from "../../runtime"
 import { PluginSlot } from "../../plugin/render"
 import type { SessionPending } from "@opencode-ai/schema/session-pending"
+import {
+  deduplicatePromptImages,
+  preserveMentionlessPromptAttachments,
+  promptAttachmentLabel,
+} from "../../prompt/attachment"
 import { DialogImagePreview } from "../dialog-image-preview"
 
 export type PromptProps = {
@@ -331,7 +336,7 @@ export function Prompt(props: PromptProps) {
   }
 
   const imageAttachments = createMemo(() =>
-    (store.prompt.files ?? []).filter((file) => typeof file.uri === "string" && file.uri.startsWith("data:image/")),
+    (deduplicatePromptImages(store.prompt.files) ?? []).filter((file) => file.uri.startsWith("data:image/")),
   )
   const imagePreviewHeight = createMemo(() => Math.max(4, Math.min(8, Math.floor(dimensions().height / 4))))
   const imagePreviewWidth = createMemo(() => imagePreviewHeight() * 2)
@@ -736,6 +741,7 @@ export function Prompt(props: PromptProps) {
     setStore(
       produce((draft) => {
         const newMap = new Map<number, PromptPartRef>()
+        const fileExtmarks = new Map<number, NonNullable<PromptInfo["files"]>[number]>()
         const files: NonNullable<PromptInfo["files"]> = []
         const agents: NonNullable<PromptInfo["agents"]> = []
         const skills: NonNullable<PromptInfo["skills"]> = []
@@ -749,9 +755,8 @@ export function Prompt(props: PromptProps) {
             if (!part?.mention) continue
             part.mention.start = extmark.start
             part.mention.end = extmark.end
-            const index = files.length
             files.push(part)
-            newMap.set(extmark.id, { type: "file", index })
+            fileExtmarks.set(extmark.id, part)
             continue
           }
           if (ref.type === "agent") {
@@ -783,8 +788,19 @@ export function Prompt(props: PromptProps) {
           newMap.set(extmark.id, { type: "pasted", index })
         }
 
+        const nextFiles = preserveMentionlessPromptAttachments(draft.prompt.files, files)
+        const fileIndices = new Map(nextFiles.map((file, index) => [file, index]))
+        for (const [extmark, file] of fileExtmarks) {
+          const index = fileIndices.get(file)
+          if (index !== undefined) newMap.set(extmark, { type: "file", index })
+        }
+
         draft.extmarkToPart = newMap
-        draft.prompt.files = files
+        if (
+          nextFiles.length !== draft.prompt.files?.length ||
+          nextFiles.some((file, index) => file !== draft.prompt.files?.[index])
+        )
+          draft.prompt.files = nextFiles
         draft.prompt.agents = agents
         draft.prompt.skills = skills
         draft.prompt.pasted = pasted
@@ -1138,7 +1154,6 @@ export function Prompt(props: PromptProps) {
 
     // Capture mode before it gets reset
     const currentMode = store.mode
-
     if (store.mode === "shell") {
       move.startSubmit()
       void client.api.session.shell({
@@ -1376,13 +1391,7 @@ export function Prompt(props: PromptProps) {
   function pasteAttachment(file: { filename?: string; uri: string }) {
     const currentOffset = input.cursorOffset
     const extmarkStart = currentOffset
-    const pdf = file.uri.startsWith("data:application/pdf;")
-    const count = pdf
-      ? (store.prompt.files?.filter(
-          (attachment) => typeof attachment.uri === "string" && attachment.uri.startsWith("data:application/pdf;"),
-        ).length ?? 0)
-      : imageAttachments().length
-    const virtualText = pdf ? `[PDF ${count + 1}]` : `[Image ${count + 1}]`
+    const virtualText = promptAttachmentLabel(store.prompt.files, { uri: file.uri, name: file.filename })
     const extmarkEnd = extmarkStart + virtualText.length
     const textToInsert = virtualText + " "
 

packages/tui/src/context/data.tsx

@@ -386,7 +386,8 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
             },
           }))
           break
-        case "session.agent.selected":
+        case "session.agent.selected": {
+          const previous = store.session.info[event.data.sessionID]?.agent
           if (store.session.info[event.data.sessionID])
             setStore("session", "info", event.data.sessionID, "agent", event.data.agent)
           message.update(event.data.sessionID, (draft, index) => {
@@ -394,10 +395,12 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
               id: messageIDFromEvent(event.id),
               type: "agent-switched",
               agent: event.data.agent,
+              previous,
               time: { created: event.created },
             })
           })
           break
+        }
         case "session.model.selected":
           if (store.session.info[event.data.sessionID])
             setStore("session", "info", event.data.sessionID, "model", event.data.model)

packages/tui/src/prompt/attachment.ts

@@ -0,0 +1,96 @@
+import type { PromptInput } from "@opencode-ai/schema"
+
+type PromptFile = PromptInput.FileAttachment
+type PromptFileIdentity = Pick<PromptFile, "uri" | "name" | "description">
+type ProjectedFile = Readonly<{
+  data: string
+  mime: string
+  source: { type: string }
+  name?: string
+  description?: string
+  mention?: { text: string }
+}>
+
+function attachmentKind(uri: string) {
+  if (uri.startsWith("data:image/")) return "Image"
+  if (uri.startsWith("data:application/pdf;")) return "PDF"
+  return undefined
+}
+
+function attachmentMetadata(file: PromptFileIdentity) {
+  return JSON.stringify([file.name ?? null, file.description ?? null])
+}
+
+function deduplicateByIdentity<T>(
+  items: readonly T[],
+  identity: (item: T) => { metadata: string; payload: string } | undefined,
+) {
+  const seen = new Map<string, string[]>()
+  return items.filter((item) => {
+    const key = identity(item)
+    if (!key) return true
+    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
+  })
+}
+
+export function deduplicatePromptImages(files: readonly PromptFile[] | undefined) {
+  if (!files || files.length < 2) return files
+  return deduplicateByIdentity(files, (file) =>
+    file.uri.startsWith("data:image/") && file.mention?.text
+      ? {
+          metadata: JSON.stringify([attachmentMetadata(file), file.mention.text]),
+          payload: file.uri,
+        }
+      : undefined,
+  )
+}
+
+export function preserveMentionlessPromptAttachments(
+  files: readonly PromptFile[] | undefined,
+  mentioned: PromptFile[],
+) {
+  if (!files) return mentioned
+  const tracked = mentioned.values()
+  return files.flatMap((file) => {
+    if (!file.mention?.text) return [file]
+    const next = tracked.next()
+    return next.done ? [] : [next.value]
+  })
+}
+
+export function deduplicateVisibleImages<T extends ProjectedFile>(files: readonly T[]) {
+  return deduplicateByIdentity(files, (file) =>
+    file.mime.startsWith("image/") && file.source.type === "inline" && file.mention?.text
+      ? {
+          metadata: JSON.stringify([file.mime, file.name ?? null, file.description ?? null, file.mention.text]),
+          payload: file.data,
+        }
+      : undefined,
+  )
+}
+
+export function promptAttachmentLabel(files: readonly PromptFile[] | undefined, file: PromptFileIdentity) {
+  const kind = attachmentKind(file.uri)
+  if (!kind) throw new Error(`Unsupported inline attachment: ${file.uri}`)
+  const metadata = attachmentMetadata(file)
+  const existing =
+    kind === "Image"
+      ? files?.find(
+          (candidate) =>
+            candidate.uri === file.uri && attachmentMetadata(candidate) === metadata && candidate.mention?.text,
+        )?.mention?.text
+      : undefined
+  if (existing) return existing
+
+  const pattern = new RegExp(`^\\[${kind} (\\d+)\\]$`)
+  const count =
+    files?.reduce((highest, candidate) => {
+      const match = candidate.mention?.text.match(pattern)
+      return match ? Math.max(highest, Number(match[1])) : highest
+    }, 0) ?? 0
+  return `[${kind} ${count + 1}]`
+}

packages/tui/src/routes/session/index.tsx

@@ -70,6 +70,7 @@ import stripAnsi from "strip-ansi"
 import { usePromptRef } from "../../context/prompt"
 import { sessionTabsFitVertically, SESSION_SIDEBAR_WIDTH } from "../../ui/layout"
 import { projectedPromptInput } from "../../prompt/codec"
+import { deduplicateVisibleImages } from "../../prompt/attachment"
 import { useEpilogue } from "../../context/epilogue"
 import { normalizePath } from "../../util/path"
 import { PermissionPrompt } from "./permission"
@@ -649,8 +650,18 @@ export function Session() {
       slash: {
         name: "compact",
       },
-      run: () => {
-        void client.api.session.compact({ sessionID: route.sessionID })
+      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 })
         dialog.clear()
       },
     },
@@ -1651,7 +1662,12 @@ function SessionSwitchMessageV2(props: { message: SessionMessageInfo }) {
   const ctx = use()
   const theme = useTheme()
   const text = () => {
-    if (props.message.type === "agent-switched") return `Switched agent to ${props.message.agent}`
+    if (props.message.type === "agent-switched") {
+      const agent = Locale.titlecase(props.message.agent)
+      if (props.message.previous && props.message.previous !== props.message.agent)
+        return `Switched agent from ${Locale.titlecase(props.message.previous)} to ${agent}`
+      return `Switched agent to ${agent}`
+    }
     if (props.message.type === "model-switched")
       return switchLabel(props.message.model, ctx.models(), props.message.previous)
     return ""
@@ -1899,7 +1915,7 @@ function UserMessage(props: { message: SessionMessageUser }) {
   const ctx = use()
   const data = useData()
   const local = useLocal()
-  const files = createMemo(() => props.message.files ?? [])
+  const files = createMemo(() => deduplicateVisibleImages(props.message.files ?? []))
   const skills = createMemo(() => props.message.skills ?? [])
   const images = createMemo(() =>
     files().flatMap((file) =>

packages/tui/test/prompt/attachment.test.ts

@@ -0,0 +1,125 @@
+import { describe, expect, test } from "bun:test"
+import {
+  deduplicatePromptImages,
+  deduplicateVisibleImages,
+  preserveMentionlessPromptAttachments,
+  promptAttachmentLabel,
+} from "../../src/prompt/attachment"
+
+describe("prompt attachments", () => {
+  test("deduplicates identical inline images while preserving other attachments", () => {
+    const files = [
+      {
+        uri: "data:image/png;base64,AAA",
+        name: "first.png",
+        mention: { start: 0, end: 9, text: "[Image 1]" },
+      },
+      { uri: "file:///same", name: "first.txt" },
+      { uri: "data:application/pdf;base64,CCC", name: "first.pdf" },
+      {
+        uri: "data:image/png;base64,BBB",
+        name: "second.png",
+        mention: { start: 10, end: 19, text: "[Image 2]" },
+      },
+      {
+        uri: "data:image/png;base64,AAA",
+        name: "first.png",
+        mention: { start: 20, end: 29, text: "[Image 1]" },
+      },
+      {
+        uri: "data:image/png;base64,AAA",
+        name: "first.png",
+        description: "alternate use",
+        mention: { start: 30, end: 39, text: "[Image 1]" },
+      },
+      { uri: "file:///same", name: "second.txt" },
+      { uri: "data:application/pdf;base64,CCC", name: "first.pdf" },
+    ]
+
+    expect(deduplicatePromptImages(files)).toEqual([
+      files[0],
+      files[1],
+      files[2],
+      files[3],
+      files[5],
+      files[6],
+      files[7],
+    ])
+    expect(files).toHaveLength(8)
+  })
+
+  test("reuses labels for identical image data", () => {
+    const first = "data:image/png;base64,AAA"
+    const second = "data:image/png;base64,BBB"
+    const files = [{ uri: first, mention: { start: 0, end: 9, text: "[Image 1]" } }]
+
+    expect(promptAttachmentLabel(files, { uri: first })).toBe("[Image 1]")
+    expect(promptAttachmentLabel([...files, { ...files[0], mention: undefined }], { uri: second })).toBe("[Image 2]")
+    expect(promptAttachmentLabel([{ uri: first }], { uri: first })).toBe("[Image 1]")
+  })
+
+  test("numbers PDFs independently from images", () => {
+    const files = [{ uri: "data:image/png;base64,AAA" }]
+
+    expect(promptAttachmentLabel(files, { uri: "data:application/pdf;base64,BBB" })).toBe("[PDF 1]")
+  })
+
+  test("does not reuse a label when attachment metadata differs", () => {
+    const uri = "data:image/png;base64,AAA"
+    const files = [{ uri, name: "one.png", mention: { start: 0, end: 9, text: "[Image 1]" } }]
+
+    expect(promptAttachmentLabel(files, { uri, name: "two.png" })).toBe("[Image 2]")
+  })
+
+  test("does not reuse numbers after an earlier attachment is removed", () => {
+    const files = [{ uri: "data:image/png;base64,BBB", mention: { start: 0, end: 9, text: "[Image 2]" } }]
+
+    expect(promptAttachmentLabel(files, { uri: "data:image/png;base64,CCC" })).toBe("[Image 3]")
+  })
+
+  test("preserves mentionless attachments when tracked mentions are synchronized", () => {
+    const mentionless = { uri: "data:image/png;base64,AAA" }
+    const emptyMention = {
+      uri: "data:image/png;base64,CCC",
+      mention: { start: 0, end: 0, text: "" },
+    }
+    const mentioned = {
+      uri: "data:image/png;base64,BBB",
+      mention: { start: 0, end: 9, text: "[Image 1]" },
+    }
+
+    const restored = preserveMentionlessPromptAttachments([mentionless, emptyMention, mentioned], [mentioned])
+    expect(restored).toEqual([mentionless, emptyMention, mentioned])
+    expect(restored.indexOf(mentioned)).toBe(2)
+
+    const another = {
+      uri: "data:image/png;base64,DDD",
+      mention: { start: 10, end: 19, text: "[Image 2]" },
+    }
+    expect(preserveMentionlessPromptAttachments([mentioned, mentionless, another], [another, mentioned])).toEqual([
+      another,
+      mentionless,
+      mentioned,
+    ])
+  })
+
+  test("deduplicates visible inline image cards without dropping durable references", () => {
+    const file = {
+      data: "AAA",
+      mime: "image/png",
+      source: { type: "inline" },
+      name: "clipboard",
+      mention: { text: "[Image 1]" },
+    }
+    const files = [file, { ...file, mention: { text: "[Image 1]" } }]
+
+    expect(deduplicateVisibleImages(files)).toEqual([file])
+    expect(files).toHaveLength(2)
+
+    const distinct = [
+      { ...file, mention: { text: "[Image 2]" } },
+      { ...file, mention: undefined },
+    ]
+    expect(deduplicateVisibleImages([file, ...distinct])).toEqual([file, ...distinct])
+  })
+})

packages/tui/test/prompt/history.test.ts

@@ -41,4 +41,21 @@ describe("prompt history", () => {
     const b = entry("describe this", [{ name: "b.png", uri: "data:image/png;base64,BBB" }])
     expect(isDuplicateEntry(a, b)).toBe(false)
   })
+
+  test("preserves duplicate attachment mentions for prompt restoration", () => {
+    const value = entry("[Image 1] [Image 1]", [
+      {
+        name: "clipboard",
+        uri: "data:image/png;base64,AAA",
+        mention: { start: 0, end: 9, text: "[Image 1]" },
+      },
+      {
+        name: "clipboard",
+        uri: "data:image/png;base64,AAA",
+        mention: { start: 10, end: 19, text: "[Image 1]" },
+      },
+    ])
+
+    expect(parsePromptHistory(JSON.stringify(value))).toEqual([value])
+  })
 })

packages/www/openapi.json

@@ -12733,6 +12733,9 @@
           },
           "agent": {
             "type": "string"
+          },
+          "previous": {
+            "type": "string"
           }
         },
         "required": ["id", "time", "type", "agent"],

packages/www/public/openapi.json

@@ -12733,6 +12733,9 @@
           },
           "agent": {
             "type": "string"
+          },
+          "previous": {
+            "type": "string"
           }
         },
         "required": ["id", "time", "type", "agent"],

script/publish.ts

@@ -35,32 +35,34 @@ if (Script.release && !Script.preview) {
 
 await prepareReleaseFiles()
 
-console.log("\n=== schema ===\n")
-await $`bun ./packages/schema/script/publish.ts`
+if (Script.channel !== "beta") {
+  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`