feat(core): discover AGENTS.md up to the home directory

2026-08-11 03:59:54 -04:00 · 2026-08-10 22:38:37 -04:00
41 changed files with 360 additions and 861 deletions
@@ -75,7 +75,7 @@ jobs:
  build-cli:
    needs: version
    runs-on: blacksmith-4vcpu-ubuntu-2404
-    if: github.repository == 'anomalyco/opencode' && github.ref_name != 'beta'
+    if: github.repository == 'anomalyco/opencode'
    steps:
      - uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 # v3.6.0
        with:
@@ -91,7 +91,7 @@ jobs:
          opencode-app-secret: ${{ secrets.OPENCODE_APP_SECRET }}

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

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

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

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

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

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

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

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

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

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

      - uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4.3.0
-        if: github.ref_name != 'beta'
        with:
          pattern: opencode-node-cli-*
          path: packages/cli/dist/node
@@ -439,7 +439,6 @@
        "@actions/artifact": "4.0.0",
        "@lydell/node-pty": "catalog:",
        "@opencode-ai/app": "workspace:*",
-        "@opencode-ai/client": "workspace:*",
        "@opencode-ai/ui": "workspace:*",
        "@sentry/solid": "catalog:",
        "@sentry/vite-plugin": "catalog:",
@@ -41,7 +41,6 @@ export type SessionMessageAgentSelected = {
  time: { created: number }
  type: "agent-switched"
  agent: string
-  previous?: string
 }

 export type PromptBase64 = string
@@ -2536,7 +2535,6 @@ export type SessionImportInput = {
          readonly time: { readonly created: number }
          readonly type: "agent-switched"
          readonly agent: string
-          readonly previous?: string
        }
      | {
          readonly id: string
@@ -2788,7 +2786,6 @@ export type SessionImportInput = {
          readonly time: { readonly created: number }
          readonly type: "agent-switched"
          readonly agent: string
-          readonly previous?: string
        }
      | {
          readonly id: string
@@ -3040,7 +3037,6 @@ export type SessionImportInput = {
          readonly time: { readonly created: number }
          readonly type: "agent-switched"
          readonly agent: string
-          readonly previous?: string
        }
      | {
          readonly id: string
@@ -508,23 +508,8 @@ function toolOutput(result: ToolResultValue) {
    case "text":
    case "error":
      return { type: "text" as const, value: messageValue(result.value) }
-    case "content":
-      return {
-        type: "content" as const,
-        value: result.value.map((item) => {
-          if (item.type === "text") return { type: "text" as const, text: item.text }
-          const data = /^data:[^;,]+(?:;[^,]*)*;base64,(.*)$/s.exec(item.uri)?.[1]
-          const image = item.mime.toLowerCase().startsWith("image/")
-          if (data !== undefined)
-            return image
-              ? { type: "image-data" as const, data, mediaType: item.mime }
-              : { type: "file-data" as const, data, mediaType: item.mime, filename: item.name }
-          return image ? { type: "image-url" as const, url: item.uri } : { type: "file-url" as const, url: item.uri }
-        }),
-      }
-    case "json":
-      return { type: "json" as const, value: jsonValue(result.value) }
  }
+  return { type: "json" as const, value: jsonValue(result.value) }
 }

 function tool(input: ToolDefinition): LanguageModelV3FunctionTool {
@@ -27,8 +27,10 @@ export const Plugin = define({
      const changes = yield* PubSub.sliding<string>(1)
      const lock = Semaphore.makeUnsafe(1)
      const start = yield* fs.resolve(location.directory)
-      const stop = yield* fs.resolve(location.project.directory)
-      const project = discovery.project && FSUtil.contains(stop, start)
+      const root = yield* fs.resolve(location.project.directory)
+      const home = yield* fs.resolve(global.home)
+      const project = discovery.project && FSUtil.contains(root, start)
+      const stop = FSUtil.contains(home, start) ? home : root
      const globalFile = yield* fs.resolve(join(global.config, "AGENTS.md"))
      const loaded: { current: Loaded } = { current: { type: "available", files: [] } }

@@ -1,8 +1,11 @@
-import { Context, Duration, Effect, Layer, Option, Schedule, Schema, Semaphore } from "effect"
+import path from "path"
+import { Context, Duration, Effect, Layer, Option, Schedule, Schema } from "effect"
 import { HttpClient, HttpClientRequest } from "effect/unstable/http"
 import { ModelsDev } from "@opencode-ai/schema/models-dev"
 import { Money } from "@opencode-ai/schema/money"
 import { App } from "./app"
+import { Global } from "@opencode-ai/util/global"
+import { Flock } from "@opencode-ai/util/flock"
 import { Hash } from "@opencode-ai/util/hash"
 import { FSUtil } from "@opencode-ai/util/fs-util"
 import { Bus } from "./bus"
@@ -10,7 +13,6 @@ import { makeGlobalNode } from "@opencode-ai/util/effect/app-node"
 import { httpClient } from "@opencode-ai/util/effect/app-node-platform"
 import { Model } from "./model"
 import { Provider } from "./provider"
-import { KV } from "./kv"

 export const CatalogModelStatus = Schema.Literals(["alpha", "beta", "deprecated"])
 export type CatalogModelStatus = typeof CatalogModelStatus.Type
@@ -535,18 +537,6 @@ export type Options = typeof Options.Type

 export class Service extends Context.Service<Service, Interface>()("@opencode/ModelsDev") {}

-const CatalogJson = Schema.fromJsonString(Schema.Record(Schema.String, Schema.Unknown))
-const Cache = Schema.Struct({
-  updatedAt: Schema.Number,
-  body: CatalogJson,
-})
-const defaultSource = "https://models.opencode.ai"
-
-function cacheKey(source: string) {
-  if (source === defaultSource) return "models-dev:catalog"
-  return `models-dev:catalog:${Hash.fast(source)}`
-}
-
 export const layer = (options?: Options) =>
  Layer.effect(
    Service,
@@ -554,7 +544,7 @@ export const layer = (options?: Options) =>
      const fs = yield* FSUtil.Service
      const bus = yield* Bus.Service
      const app = yield* App.Metadata
-      const kv = yield* KV.Service
+      const global = yield* Global.Service
      const http = HttpClient.filterStatusOk(
        (yield* HttpClient.HttpClient).pipe(
          HttpClient.retryTransient({
@@ -565,28 +555,21 @@ export const layer = (options?: Options) =>
        ),
      )

-      const source = options?.url || defaultSource
+      const source = options?.url || "https://models.opencode.ai"
      const fetch = options?.fetch ?? true
      const userAgent = App.useragent(app)
-      const key = cacheKey(source)
+      const filepath = path.join(
+        global.cache,
+        source === "https://models.opencode.ai" ? "models.json" : `models-${Hash.fast(source)}.json`,
+      )
      const ttl = Duration.minutes(5)
-      const lock = Semaphore.makeUnsafe(1)
-
-      const loadFromCache = Effect.fnUntraced(function* () {
-        const value = yield* kv.get(key)
-        const cached = Schema.decodeUnknownOption(Cache)(value)
-        if (Option.isSome(cached))
-          return {
-            catalog: cached.value.body as Record<string, SourceProvider>,
-            updatedAt: cached.value.updatedAt,
-          }
-        if (value !== undefined) yield* kv.remove(key)
-      })
+      const lockKey = `models-dev:${filepath}`

      const fresh = Effect.fnUntraced(function* () {
-        const cached = yield* loadFromCache()
-        if (!cached) return false
-        return Date.now() - cached.updatedAt < Duration.toMillis(ttl)
+        const stat = yield* fs.stat(filepath).pipe(Effect.catch(() => Effect.succeed(undefined)))
+        if (!stat) return false
+        const mtime = Option.getOrElse(stat.mtime, () => new Date(0)).getTime()
+        return Date.now() - mtime < Duration.toMillis(ttl)
      })

      const fetchApi = Effect.fn("ModelsDev.fetchApi")(function* () {
@@ -598,12 +581,15 @@ export const layer = (options?: Options) =>
        )
      })

-      const loadFromFile = options?.file
-        ? fs.readJson(options.file).pipe(
-            Effect.map((input) => input as Record<string, SourceProvider>),
-            Effect.catch(() => Effect.succeed(undefined)),
-          )
-        : Effect.succeed(undefined)
+      const loadFromDisk = fs.readJson(options?.file ?? filepath).pipe(
+        Effect.map((input) => input as Record<string, SourceProvider>),
+        Effect.catch((error) => {
+          if (options?.file === undefined && error._tag === "FileSystemError" && error.method === "readJson") {
+            return fs.remove(filepath, { force: true }).pipe(Effect.ignore, Effect.as(undefined))
+          }
+          return Effect.succeed(undefined)
+        }),
+      )

      const loadSnapshot = Effect.sync(() =>
        typeof OPENCODE_MODELS_DEV === "undefined" ? undefined : OPENCODE_MODELS_DEV,
@@ -611,27 +597,33 @@ export const layer = (options?: Options) =>

      const fetchAndWrite = Effect.fn("ModelsDev.fetchAndWrite")(function* () {
        const text = yield* fetchApi()
-        const catalog = (yield* Schema.decodeUnknownEffect(CatalogJson)(text)) as Record<string, SourceProvider>
-        yield* kv.set(key, { updatedAt: Date.now(), body: text })
-        return catalog
+        const tempfile = `${filepath}.${process.pid}.${Date.now()}.tmp`
+        yield* fs.writeWithDirs(tempfile, text).pipe(
+          Effect.andThen(fs.rename(tempfile, filepath)),
+          Effect.catch((error) =>
+            Effect.gen(function* () {
+              yield* fs.remove(tempfile, { force: true }).pipe(Effect.ignore)
+              return yield* Effect.fail(error)
+            }),
+          ),
+        )
+        return text
      })

      const populate = Effect.gen(function* () {
-        const fromFile = yield* loadFromFile
-        if (fromFile) return normalize(fromFile)
-        const cached = options?.file ? undefined : yield* loadFromCache()
-        if (cached) return normalize(cached.catalog)
+        const fromDisk = yield* loadFromDisk
+        if (fromDisk) return normalize(fromDisk)
        const bundled = yield* loadSnapshot
        if (bundled) return normalize(bundled)
        if (!fetch) return []
-        const catalog = yield* lock.withPermit(
+        // Flock is cross-process: concurrent opencode CLIs can race on this cache file.
+        const text = yield* Effect.scoped(
          Effect.gen(function* () {
-            const stored = options?.file ? undefined : yield* loadFromCache()
-            if (stored) return stored.catalog
+            yield* Flock.effect(lockKey)
            return yield* fetchAndWrite()
          }),
        )
-        return normalize(catalog)
+        return normalize(JSON.parse(text) as Record<string, SourceProvider>)
      }).pipe(Effect.withSpan("ModelsDev.populate"), Effect.orDie)

      const [cachedGet, invalidate] = yield* Effect.cachedInvalidateWithTTL(populate, Duration.infinity)
@@ -639,19 +631,21 @@ export const layer = (options?: Options) =>
      const get = (): Effect.Effect<readonly Snapshot[]> => cachedGet

      const refresh = Effect.fn("ModelsDev.refresh")(function* (force = false) {
-        yield* lock
-          .withPermit(
-            Effect.gen(function* () {
-              if (!force && (yield* fresh())) return
-              yield* fetchAndWrite()
-              yield* invalidate
-              yield* bus.publish(ModelsDev.Event.Refreshed, {})
-            }),
-          )
-          .pipe(
-            Effect.tapCause((cause) => Effect.logError("Failed to fetch models.dev", { cause: cause })),
-            Effect.ignore,
-          )
+        if (!force && (yield* fresh())) return
+        yield* Effect.scoped(
+          Effect.gen(function* () {
+            yield* Flock.effect(lockKey)
+            // Re-check under the lock: another process may have refreshed between
+            // our outer check and lock acquisition.
+            if (!force && (yield* fresh())) return
+            yield* fetchAndWrite()
+            yield* invalidate
+            yield* bus.publish(ModelsDev.Event.Refreshed, {})
+          }),
+        ).pipe(
+          Effect.tapCause((cause) => Effect.logError("Failed to fetch models.dev", { cause: cause })),
+          Effect.ignore,
+        )
      })

      if (fetch && !process.argv.includes("--get-yargs-completions")) {
@@ -667,7 +661,7 @@ export function configured(options?: Options) {
  return makeGlobalNode({
    service: Service,
    layer: layer(options),
-    deps: [FSUtil.node, Bus.node, App.node, KV.node, httpClient],
+    deps: [FSUtil.node, Bus.node, App.node, Global.node, httpClient],
  })
 }

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

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

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

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

    const trigger: Interface["trigger"] = Effect.fn("PluginHooks.trigger")(function* (domain, name, event) {
      for (const callback of callbacks.get(key(domain, name)) ?? []) {
-        const result: Effect.Effect<void, Failures[typeof domain][typeof name]> = Reflect.apply(callback, undefined, [
-          event,
-        ])
+        const result: Effect.Effect<void> = Reflect.apply(callback, undefined, [event])
        yield* result
      }
      return event
@@ -4,7 +4,6 @@ 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: (
@@ -60,19 +59,15 @@ export function update(adapter: Adapter, event: SessionEvent.DurableEvent) {
      "session.created": () => Effect.void,
      "session.usage.recorded": () => Effect.void,
      "session.agent.selected": (event) => {
-        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 },
-            }),
-          )
-        })
+        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 },
+          }),
+        )
      },
      "session.model.selected": (event) => {
        return Effect.gen(function* () {
@@ -5,7 +5,6 @@ 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"
@@ -231,17 +230,6 @@ 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 })
@@ -410,15 +398,12 @@ const layer = Layer.effectDiscard(
      db.delete(SessionTable).where(eq(SessionTable.id, event.data.sessionID)).run().pipe(Effect.orDie),
    )
    yield* bus.project(SessionEvent.AgentSelected, (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)
-      }),
+      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))),
    )
    yield* bus.project(SessionEvent.ModelSelected, (event) =>
      Effect.gen(function* () {
@@ -59,25 +59,6 @@ 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 = (
@@ -205,7 +186,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)]),
-        ...userAttachmentContent(message.files ?? []),
+        ...(message.files ?? []).flatMap(attachmentContent),
      ]
      if (content.length === 0) return []
      return [
@@ -275,73 +275,6 @@ it.effect("projects replay metadata onto AI SDK prompt parts", () =>
  }),
 )

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

 const instructionLayer = (input: {
  config?: string
+  home?: string
  locationServiceLayer: Layer.Layer<Location.Service>
  filesystemLayer?: Layer.Layer<FSUtil.Service>
  project?: boolean
@@ -34,7 +35,15 @@ const instructionLayer = (input: {
      LayerNode.group([InstructionDiscovery.node, Bus.node, FSUtil.node, Global.node, Location.node, Watcher.node]),
      [
        [InstructionDiscovery.node, InstructionDiscovery.configured({ project: input.project })],
-        [Global.node, input.config ? Global.layerWith({ config: input.config }) : tempGlobalLayer],
+        [
+          Global.node,
+          input.config || input.home
+            ? Global.layerWith({
+                ...(input.config ? { config: input.config } : {}),
+                ...(input.home ? { home: input.home } : {}),
+              })
+            : tempGlobalLayer,
+        ],
        [Location.node, input.locationServiceLayer],
        [Watcher.node, watcher],
        ...(input.filesystemLayer ? [[FSUtil.node, input.filesystemLayer] as const] : []),
@@ -112,10 +121,13 @@ describe("ConfigInstructionPlugin.Plugin", () => {
    ).pipe(
      Effect.flatMap((tmp) => {
        const global = path.join(tmp.path, "global")
-        const project = path.join(tmp.path, "project")
+        const home = path.join(tmp.path, "home")
+        const shared = path.join(home, "code")
+        const project = path.join(shared, "repo")
        const directory = path.join(project, "packages", "core")
        const outside = path.join(tmp.path, "AGENTS.md")
        const globalFile = path.join(global, "AGENTS.md")
+        const sharedFile = path.join(shared, "AGENTS.md")
        const projectFile = path.join(project, "AGENTS.md")
        const packageFile = path.join(directory, "AGENTS.md")
        return Effect.gen(function* () {
@@ -124,6 +136,7 @@ describe("ConfigInstructionPlugin.Plugin", () => {
            await fs.mkdir(directory, { recursive: true })
            await fs.writeFile(outside, "outside")
            await fs.writeFile(globalFile, "global")
+            await fs.writeFile(sharedFile, "shared")
            await fs.writeFile(projectFile, "project")
            await fs.writeFile(packageFile, "package")
          })
@@ -135,13 +148,20 @@ describe("ConfigInstructionPlugin.Plugin", () => {
            { path: packageFile, type: "file" },
            { path: path.join(project, "packages", "AGENTS.md"), type: "file" },
            { path: projectFile, type: "file" },
+            { path: sharedFile, type: "file" },
+            { path: path.join(home, "AGENTS.md"), type: "file" },
          ])
+          expect(yield* watcher.subscriptions()).not.toContainEqual({
+            path: path.join(tmp.path, "AGENTS.md"),
+            type: "file",
+          })
          const initialized = yield* readInitial(yield* discovery.load())
          expect(initialized.text).toBe(
            [
              `Instructions from: ${globalFile}\nglobal`,
              `Instructions from: ${packageFile}\npackage`,
              `Instructions from: ${projectFile}\nproject`,
+              `Instructions from: ${sharedFile}\nshared`,
            ].join("\n\n"),
          )
          expect(initialized.text).not.toContain("outside")
@@ -159,6 +179,7 @@ describe("ConfigInstructionPlugin.Plugin", () => {
              "These instructions replace all previously loaded ambient instructions.",
              `Instructions from: ${globalFile}\nglobal`,
              `Instructions from: ${projectFile}\nproject`,
+              `Instructions from: ${sharedFile}\nshared`,
            ].join("\n\n"),
          )

@@ -166,6 +187,8 @@ describe("ConfigInstructionPlugin.Plugin", () => {
          yield* emitAndWait({ type: "delete", path: globalFile })
          yield* Effect.promise(() => fs.rm(projectFile))
          yield* emitAndWait({ type: "delete", path: projectFile })
+          yield* Effect.promise(() => fs.rm(sharedFile))
+          yield* emitAndWait({ type: "delete", path: sharedFile })
          expect((yield* readUpdate(yield* discovery.load(), initialized)).text).toBe(
            "Previously loaded instructions no longer apply.",
          )
@@ -173,6 +196,7 @@ describe("ConfigInstructionPlugin.Plugin", () => {
          Effect.provide(
            instructionLayer({
              config: global,
+              home,
              locationServiceLayer: Layer.succeed(
                Location.Service,
                Location.Service.of(
@@ -215,15 +239,17 @@ describe("ConfigInstructionPlugin.Plugin", () => {
    ),
  )

-  it.live("discovers a newly created instruction file in an intermediate directory", () =>
+  it.live("discovers a newly created instruction file above the project root", () =>
    Effect.acquireRelease(
      Effect.promise(() => tmpdir()),
      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
    ).pipe(
      Effect.flatMap((tmp) => {
-        const project = path.join(tmp.path, "project")
-        const intermediate = path.join(project, "packages", "AGENTS.md")
-        const directory = path.join(project, "packages", "core")
+        const home = path.join(tmp.path, "home")
+        const shared = path.join(home, "code")
+        const project = path.join(shared, "repo")
+        const intermediate = path.join(shared, "AGENTS.md")
+        const directory = path.join(project, "core")
        const projectFile = path.join(project, "AGENTS.md")
        return Effect.gen(function* () {
          yield* Effect.promise(() => fs.mkdir(directory, { recursive: true }))
@@ -235,7 +261,7 @@ describe("ConfigInstructionPlugin.Plugin", () => {
          yield* emitAndWait({ type: "create", path: intermediate })

          expect((yield* readInitial(yield* discovery.load())).text).toBe(
-            [`Instructions from: ${intermediate}\nintermediate`, `Instructions from: ${projectFile}\nproject`].join(
+            [`Instructions from: ${projectFile}\nproject`, `Instructions from: ${intermediate}\nintermediate`].join(
              "\n\n",
            ),
          )
@@ -243,6 +269,48 @@ describe("ConfigInstructionPlugin.Plugin", () => {
          Effect.provide(
            instructionLayer({
              config: path.join(tmp.path, "global"),
+              home,
+              locationServiceLayer: Layer.succeed(
+                Location.Service,
+                Location.Service.of(
+                  location(
+                    { directory: AbsolutePath.make(directory) },
+                    { projectDirectory: AbsolutePath.make(project) },
+                  ),
+                ),
+              ),
+            }),
+          ),
+        )
+      }),
+    ),
+  )
+
+  it.live("stops instruction candidates at the project root outside home", () =>
+    Effect.acquireRelease(
+      Effect.promise(() => tmpdir()),
+      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
+    ).pipe(
+      Effect.flatMap((tmp) => {
+        const global = path.join(tmp.path, "global")
+        const home = path.join(tmp.path, "home")
+        const project = path.join(tmp.path, "scratch", "repo")
+        const directory = path.join(project, "packages", "core")
+        return Effect.gen(function* () {
+          yield* Effect.promise(() => fs.mkdir(directory, { recursive: true }))
+          yield* start()
+          const watcher = yield* Watcher.Test
+          expect(yield* watcher.subscriptions()).toEqual([
+            { path: path.join(global, "AGENTS.md"), type: "file" },
+            { path: path.join(directory, "AGENTS.md"), type: "file" },
+            { path: path.join(project, "packages", "AGENTS.md"), type: "file" },
+            { path: path.join(project, "AGENTS.md"), type: "file" },
+          ])
+        }).pipe(
+          Effect.provide(
+            instructionLayer({
+              config: global,
+              home,
              locationServiceLayer: Layer.succeed(
                Location.Service,
                Location.Service.of(
@@ -1,17 +1,19 @@
-import { describe, expect, test } from "bun:test"
+import { describe, expect, beforeEach, afterAll, test } from "bun:test"
 import { Money } from "@opencode-ai/schema/money"
 import { Effect, Layer, Ref } from "effect"
 import { HttpClient, HttpClientResponse } from "effect/unstable/http"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { LayerNodePlatform } from "@opencode-ai/util/effect/app-node-platform"
 import { LayerNode } from "@opencode-ai/util/effect/layer-node"
-import { KV } from "@opencode-ai/core/kv"
+import { Global } from "@opencode-ai/util/global"
 import { Model } from "@opencode-ai/core/model"
 import { ModelsDev } from "@opencode-ai/core/models-dev"
 import { Provider } from "@opencode-ai/core/provider"
 import { it } from "./lib/effect"
+import { readFile, rm, writeFile, utimes, mkdir } from "fs/promises"
+import path from "path"

-const cacheKey = "models-dev:catalog"
+const cacheFile = path.join(Global.Path.cache, "models.json")

 test("normalizes permissive interleaved values to compatibility", () => {
  expect(Model.compatibility("reasoning_text")).toEqual({ reasoningField: "reasoning_text" })
@@ -162,18 +164,7 @@ const makeMockClient = (state: Ref.Ref<MockState>) =>
    }),
  )

-interface MockCache {
-  readonly values: Map<string, KV.Value>
-}
-
-const makeMockKV = (cache: MockCache) =>
-  Layer.mock(KV.Service, {
-    get: (key) => Effect.sync(() => cache.values.get(key)),
-    set: (key, value) => Effect.sync(() => cache.values.set(key, value)).pipe(Effect.asVoid),
-    remove: (key) => Effect.sync(() => cache.values.delete(key)).pipe(Effect.asVoid),
-  })
-
-const buildLayer = (state: Ref.Ref<MockState>, cache: MockCache, options: ModelsDev.Options = { fetch: false }) =>
+const buildLayer = (state: Ref.Ref<MockState>, options: ModelsDev.Options = { fetch: false }) =>
  // Layer.fresh is required because the ModelsDev implementation is a module-level Layer constant,
  // and Effect.provide uses a process-global MemoMap by default — without fresh,
  // every test would reuse the cachedInvalidateWithTTL state from the first run.
@@ -181,20 +172,31 @@ const buildLayer = (state: Ref.Ref<MockState>, cache: MockCache, options: Models
    AppNodeBuilder.build(ModelsDev.node, [
      [ModelsDev.node, ModelsDev.configured(options)],
      [LayerNodePlatform.httpClient, Layer.succeed(HttpClient.HttpClient, makeMockClient(state))],
-      [KV.node, makeMockKV(cache)],
    ]),
  )

-const makeCache = (): MockCache => ({ values: new Map() })
+const writeCacheText = (text: string, mtimeMs?: number) =>
+  Effect.promise(async () => {
+    await mkdir(Global.Path.cache, { recursive: true })
+    await writeFile(cacheFile, text)
+    if (mtimeMs !== undefined) {
+      const t = mtimeMs / 1000
+      await utimes(cacheFile, t, t)
+    }
+  })

-const writeCacheText = (cache: MockCache, text: string, updatedAt = Date.now()) =>
-  cache.values.set(cacheKey, { updatedAt, body: text })
+const writeCache = (data: object, mtimeMs?: number) => writeCacheText(JSON.stringify(data), mtimeMs)

-const writeCache = (cache: MockCache, data: object, updatedAt?: number) =>
-  writeCacheText(cache, JSON.stringify(data), updatedAt)
+const provided = <A, E>(state: Ref.Ref<MockState>, eff: Effect.Effect<A, E, ModelsDev.Service>) =>
+  eff.pipe(Effect.provide(buildLayer(state)))

-const provided = <A, E>(state: Ref.Ref<MockState>, cache: MockCache, eff: Effect.Effect<A, E, ModelsDev.Service>) =>
-  eff.pipe(Effect.provide(buildLayer(state, cache)))
+beforeEach(async () => {
+  await rm(cacheFile, { force: true })
+})
+
+afterAll(async () => {
+  await rm(cacheFile, { force: true })
+})

 const initialState: MockState = {
  body: JSON.stringify(fixture),
@@ -203,14 +205,12 @@ const initialState: MockState = {
 }

 describe("ModelsDev Service", () => {
-  it.live("get() returns normalized snapshots from KV when a cache entry exists", () =>
+  it.live("get() returns normalized snapshots from disk when cache file exists", () =>
    Effect.gen(function* () {
-      const cache = makeCache()
-      writeCache(cache, fixture)
+      yield* writeCache(fixture)
      const state = yield* Ref.make(initialState)
      const result = yield* provided(
        state,
-        cache,
        ModelsDev.Service.use((s) => s.get()),
      )
      expect(result).toEqual(fixtureSnapshot)
@@ -219,13 +219,11 @@ describe("ModelsDev Service", () => {
    }),
  )

-  it.live("get() returns empty catalog when KV is empty, fetch disabled, and no bundled snapshot is injected", () =>
+  it.live("get() returns empty catalog when disk empty, fetch disabled, and no bundled snapshot is injected", () =>
    Effect.gen(function* () {
-      const cache = makeCache()
      const state = yield* Ref.make(initialState)
      const result = yield* provided(
        state,
-        cache,
        ModelsDev.Service.use((s) => s.get()),
      )
      expect(result).toEqual([])
@@ -234,15 +232,14 @@ describe("ModelsDev Service", () => {
    }),
  )

-  it.live("get() recovers from a corrupted KV entry by fetching a fresh catalog", () =>
+  it.live("get() recovers from a corrupted cache file by fetching a fresh catalog", () =>
    Effect.gen(function* () {
-      const cache = makeCache()
-      writeCacheText(cache, "{")
+      yield* writeCacheText("{")
      const state = yield* Ref.make({ ...initialState, body: JSON.stringify(fixture2) })
-      const context = yield* Layer.build(buildLayer(state, cache, { fetch: true }))
+      const context = yield* Layer.build(buildLayer(state, { fetch: true }))
      const result = yield* ModelsDev.Service.use((s) => s.get()).pipe(Effect.provide(context))
      expect(result).toEqual(fixture2Snapshot)
-      expect(cache.values.get(cacheKey)).toMatchObject({ body: JSON.stringify(fixture2) })
+      expect(yield* Effect.promise(() => readFile(cacheFile, "utf8"))).toBe(JSON.stringify(fixture2))
      const final = yield* Ref.get(state)
      expect(final.calls.length).toBe(1)
    }),
@@ -250,10 +247,9 @@ describe("ModelsDev Service", () => {

  it.live("uses the default models URL when the configured URL is empty", () =>
    Effect.gen(function* () {
-      const cache = makeCache()
      const state = yield* Ref.make(initialState)
      yield* ModelsDev.Service.use((service) => service.get()).pipe(
-        Effect.provide(buildLayer(state, cache, { url: "", fetch: true })),
+        Effect.provide(buildLayer(state, { url: "", fetch: true })),
      )
      expect((yield* Ref.get(state)).calls[0]?.url).toBe("https://models.opencode.ai/api.json")
    }),
@@ -261,31 +257,32 @@ describe("ModelsDev Service", () => {

  it.live("get() is single-flight under concurrent calls", () =>
    Effect.gen(function* () {
-      const cache = makeCache()
+      yield* writeCache(fixture)
      const state = yield* Ref.make(initialState)
-      const results = yield* Effect.gen(function* () {
-        const svc = yield* ModelsDev.Service
-        return yield* Effect.all([svc.get(), svc.get(), svc.get(), svc.get(), svc.get()], {
-          concurrency: "unbounded",
-        })
-      }).pipe(Effect.provide(buildLayer(state, cache, { fetch: true })))
+      const results = yield* provided(
+        state,
+        Effect.gen(function* () {
+          const svc = yield* ModelsDev.Service
+          return yield* Effect.all([svc.get(), svc.get(), svc.get(), svc.get(), svc.get()], {
+            concurrency: "unbounded",
+          })
+        }),
+      )
      for (const result of results) expect(result).toEqual(fixtureSnapshot)
-      expect((yield* Ref.get(state)).calls.length).toBe(1)
    }),
  )

-  it.live("get() caches across calls (later KV writes are ignored until invalidate)", () =>
+  it.live("get() caches across calls (later disk writes are ignored until invalidate)", () =>
    Effect.gen(function* () {
-      const cache = makeCache()
-      writeCache(cache, fixture)
+      yield* writeCache(fixture)
      const state = yield* Ref.make(initialState)
      const first = yield* provided(
        state,
-        cache,
        Effect.gen(function* () {
          const svc = yield* ModelsDev.Service
          const a = yield* svc.get()
-          writeCache(cache, fixture2)
+          // mutate disk between calls — cache should mask the change
+          yield* writeCache(fixture2)
          const b = yield* svc.get()
          return { a, b }
        }),
@@ -297,12 +294,10 @@ describe("ModelsDev Service", () => {

  it.live("refresh(true) fetches via HttpClient and updates the cache", () =>
    Effect.gen(function* () {
-      const cache = makeCache()
-      writeCache(cache, fixture)
+      yield* writeCache(fixture)
      const state = yield* Ref.make({ ...initialState, body: JSON.stringify(fixture2) })
      const result = yield* provided(
        state,
-        cache,
        Effect.gen(function* () {
          const svc = yield* ModelsDev.Service
          const before = yield* svc.get()
@@ -313,7 +308,6 @@ describe("ModelsDev Service", () => {
      )
      expect(result.before).toEqual(fixtureSnapshot)
      expect(result.after).toEqual(fixture2Snapshot)
-      expect(cache.values.get(cacheKey)).toMatchObject({ body: JSON.stringify(fixture2) })
      const final = yield* Ref.get(state)
      expect(final.calls.length).toBe(1)
      expect(final.calls[0].url).toContain("/api.json")
@@ -321,14 +315,13 @@ describe("ModelsDev Service", () => {
    }),
  )

-  it.live("refresh(false) skips fetch when the KV entry is fresh", () =>
+  it.live("refresh(false) skips fetch when on-disk file is fresh", () =>
    Effect.gen(function* () {
-      const cache = makeCache()
-      writeCache(cache, fixture, Date.now() - 1000)
+      // Fresh: mtime within the 5-minute TTL.
+      yield* writeCache(fixture, Date.now() - 1000)
      const state = yield* Ref.make({ ...initialState, body: JSON.stringify(fixture2) })
      yield* provided(
        state,
-        cache,
        ModelsDev.Service.use((s) => s.refresh(false)),
      )
      const final = yield* Ref.get(state)
@@ -336,14 +329,13 @@ describe("ModelsDev Service", () => {
    }),
  )

-  it.live("refresh(false) fetches when the KV entry is stale", () =>
+  it.live("refresh(false) fetches when on-disk file is stale", () =>
    Effect.gen(function* () {
-      const cache = makeCache()
-      writeCache(cache, fixture, Date.now() - 10 * 60 * 1000)
+      // Stale: mtime 10 minutes ago, beyond the 5-minute TTL.
+      yield* writeCache(fixture, Date.now() - 10 * 60 * 1000)
      const state = yield* Ref.make({ ...initialState, body: JSON.stringify(fixture2) })
      const after = yield* provided(
        state,
-        cache,
        Effect.gen(function* () {
          const svc = yield* ModelsDev.Service
          yield* svc.refresh(false)
@@ -358,12 +350,10 @@ describe("ModelsDev Service", () => {

  it.live("refresh swallows HTTP errors and leaves cache intact", () =>
    Effect.gen(function* () {
-      const cache = makeCache()
-      writeCache(cache, fixture)
+      yield* writeCache(fixture)
      const state = yield* Ref.make({ ...initialState, status: 500, body: "boom" })
      const result = yield* provided(
        state,
-        cache,
        Effect.gen(function* () {
          const svc = yield* ModelsDev.Service
          yield* svc.refresh(true)
@@ -1,5 +1,4 @@
 import { describe, expect } from "bun:test"
-import { ToolFailure } from "@opencode-ai/ai"
 import { Context, Effect, Exit, Fiber, Schema, Stream } from "effect"
 import { Plugin as EffectPlugin } from "@opencode-ai/plugin/effect"
 import { Config as ConfigSchema } from "@opencode-ai/schema/config"
@@ -396,51 +395,4 @@ describe("Plugin", () => {
      })
    }),
  )
-
-  it.effect("rejects tool execution when an execute.before hook fails", () =>
-    Effect.gen(function* () {
-      const plugins = yield* Plugin.Service
-      const registry = yield* Tool.Service
-      const executed: unknown[] = []
-
-      const plugin = EffectPlugin.define({
-        id: "tool-hook-reject",
-        effect: (ctx) =>
-          Effect.gen(function* () {
-            yield* ctx.tool
-              .transform((draft) =>
-                draft.add({
-                  name: "echo",
-                  options: { codemode: false },
-                  description: "Echo",
-                  input: Schema.Struct({ text: Schema.String }),
-                  output: Schema.Struct({ text: Schema.String }),
-                  execute: ({ text }) =>
-                    Effect.sync(() => executed.push({ text })).pipe(Effect.as({ output: { text } })),
-                }),
-              )
-              .pipe(Effect.orDie)
-
-            yield* ctx.tool
-              .hook("execute.before", () => new ToolFailure({ message: "write disabled" }))
-              .pipe(Effect.asVoid)
-          }),
-      })
-
-      yield* plugins.activate([versioned(plugin)])
-
-      const toolSet = yield* registry.snapshot()
-      const failure = yield* toolSet
-        .execute({
-          sessionID: Session.ID.make("ses_hook_reject"),
-          agent: Agent.ID.make("build"),
-          messageID: SessionMessage.ID.make("msg_hook_reject"),
-          call: { type: "tool-call", id: "call-hook-reject", name: "echo", input: { text: "original" } },
-        })
-        .pipe(Effect.flip)
-
-      expect(failure).toMatchObject({ _tag: "Tool.Error", message: "write disabled" })
-      expect(executed).toEqual([])
-    }),
-  )
 })
@@ -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, agent: Agent.ID.make("build") })
+      const created = yield* session.create({ location })

      yield* session.switchAgent({ sessionID: created.id, agent: Agent.ID.make("plan") })

@@ -655,9 +655,6 @@ 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" },
-      ])
    }),
  )

@@ -358,7 +358,6 @@ describe("SessionProjector", () => {
          directory: "/project",
          title: "test",
          version: "test",
-          agent: "plan",
          model: previousModel,
        })
        .run()
@@ -460,10 +459,6 @@ 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",
@@ -373,103 +373,6 @@ 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(
      [
@@ -57,35 +57,35 @@ test("keeps a hidden prod launcher for old Linux pins", async () => {
  expect(desktop).toContain("NoDisplay=true")
 })

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

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

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

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

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

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

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

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

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

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

  return binaryConfig
 }

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

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

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

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

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

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

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

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

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

 function endpoint(url: string | undefined) {
@@ -181,7 +181,7 @@ const main = Effect.gen(function* () {
    return
  }

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

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

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

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

 export async function checkHealth(url: string, password?: string | null): Promise<boolean> {
@@ -4,11 +4,9 @@ export interface Registration {
  readonly dispose: Effect.Effect<void>
 }

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

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

-// Only execute.before may fail: a Tool.Error rejects the call before the tool runs.
-export interface ToolFailures extends Record<keyof ToolHooks, unknown> {
-  readonly "execute.before": Tool.Error
-  readonly "execute.after": never
-}
-
 export interface ToolDomain {
  readonly transform: Transform<ToolDraft>
-  readonly hook: Hooks<ToolHooks, ToolFailures>
+  readonly hook: Hooks<ToolHooks>
 }
@@ -12733,9 +12733,6 @@
          },
          "agent": {
            "type": "string"
-          },
-          "previous": {
-            "type": "string"
          }
        },
        "required": ["id", "time", "type", "agent"],
@@ -42,7 +42,6 @@ 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> {}
@@ -60,11 +60,6 @@ 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 = {
@@ -336,7 +331,7 @@ export function Prompt(props: PromptProps) {
  }

  const imageAttachments = createMemo(() =>
-    (deduplicatePromptImages(store.prompt.files) ?? []).filter((file) => file.uri.startsWith("data:image/")),
+    (store.prompt.files ?? []).filter((file) => typeof file.uri === "string" && file.uri.startsWith("data:image/")),
  )
  const imagePreviewHeight = createMemo(() => Math.max(4, Math.min(8, Math.floor(dimensions().height / 4))))
  const imagePreviewWidth = createMemo(() => imagePreviewHeight() * 2)
@@ -741,7 +736,6 @@ 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"]> = []
@@ -755,8 +749,9 @@ 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)
-            fileExtmarks.set(extmark.id, part)
+            newMap.set(extmark.id, { type: "file", index })
            continue
          }
          if (ref.type === "agent") {
@@ -788,19 +783,8 @@ 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
-        if (
-          nextFiles.length !== draft.prompt.files?.length ||
-          nextFiles.some((file, index) => file !== draft.prompt.files?.[index])
-        )
-          draft.prompt.files = nextFiles
+        draft.prompt.files = files
        draft.prompt.agents = agents
        draft.prompt.skills = skills
        draft.prompt.pasted = pasted
@@ -1154,6 +1138,7 @@ 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({
@@ -1391,7 +1376,13 @@ export function Prompt(props: PromptProps) {
  function pasteAttachment(file: { filename?: string; uri: string }) {
    const currentOffset = input.cursorOffset
    const extmarkStart = currentOffset
-    const virtualText = promptAttachmentLabel(store.prompt.files, { uri: file.uri, name: file.filename })
+    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 extmarkEnd = extmarkStart + virtualText.length
    const textToInsert = virtualText + " "

@@ -386,8 +386,7 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
            },
          }))
          break
-        case "session.agent.selected": {
-          const previous = store.session.info[event.data.sessionID]?.agent
+        case "session.agent.selected":
          if (store.session.info[event.data.sessionID])
            setStore("session", "info", event.data.sessionID, "agent", event.data.agent)
          message.update(event.data.sessionID, (draft, index) => {
@@ -395,12 +394,10 @@ 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)
@@ -1,96 +0,0 @@
-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}]`
-}
@@ -70,7 +70,6 @@ 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"
@@ -650,18 +649,8 @@ export function Session() {
      slash: {
        name: "compact",
      },
-      run: async () => {
-        const selection = local.model.current()
-        if (selection)
-          await client.api.session.switchModel({
-            sessionID: route.sessionID,
-            model: {
-              providerID: selection.providerID,
-              id: selection.modelID,
-              variant: local.model.variant.current(),
-            },
-          })
-        await client.api.session.compact({ sessionID: route.sessionID })
+      run: () => {
+        void client.api.session.compact({ sessionID: route.sessionID })
        dialog.clear()
      },
    },
@@ -1662,12 +1651,7 @@ function SessionSwitchMessageV2(props: { message: SessionMessageInfo }) {
  const ctx = use()
  const theme = useTheme()
  const text = () => {
-    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 === "agent-switched") return `Switched agent to ${props.message.agent}`
    if (props.message.type === "model-switched")
      return switchLabel(props.message.model, ctx.models(), props.message.previous)
    return ""
@@ -1915,7 +1899,7 @@ function UserMessage(props: { message: SessionMessageUser }) {
  const ctx = use()
  const data = useData()
  const local = useLocal()
-  const files = createMemo(() => deduplicateVisibleImages(props.message.files ?? []))
+  const files = createMemo(() => props.message.files ?? [])
  const skills = createMemo(() => props.message.skills ?? [])
  const images = createMemo(() =>
    files().flatMap((file) =>
@@ -1,125 +0,0 @@
-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])
-  })
-})
@@ -41,21 +41,4 @@ 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])
-  })
 })
@@ -19,8 +19,9 @@ V2 loads:

 1. The global file at `$XDG_CONFIG_HOME/opencode/AGENTS.md`, normally
   `~/.config/opencode/AGENTS.md`.
-2. Every `AGENTS.md` from the current Location up to and including the project
-   root.
+2. Every `AGENTS.md` from the current Location up to and including the home
+   directory when the Location is inside it. For Locations outside home, the
+   scan stops at the project root.

 For example, when the Location is `packages/web`, OpenCode can load all three
 project files below:
@@ -35,9 +36,9 @@ my-project/
 ```

 The files are combined rather than selecting a single winner. They are rendered
-in this order: global, then project files from the Location toward the project
+in this order: global, then files from the Location toward home or the project
 root. OpenCode does not resolve conflicts between their contents, so keep broad
-guidance global and put scoped guidance in the relevant project directory.
+guidance global and put scoped guidance in the relevant directory.

 If the Location is outside the project root, only the global file is loaded.
 Setting `OPENCODE_DISABLE_PROJECT_CONFIG=1` also skips project `AGENTS.md`
@@ -504,8 +504,8 @@ require a V2 rewrite. See [Skills](/skills).

 ### Instruction files

-Existing `AGENTS.md` files stay in place. V2 discovers the global `~/.config/opencode/AGENTS.md` and project `AGENTS.md`
-files from the current directory up to the project root.
+Existing `AGENTS.md` files stay in place. V2 discovers the global `~/.config/opencode/AGENTS.md` and ambient `AGENTS.md`
+files from the current directory up to home. For projects outside home, discovery stops at the project root.

 If a V1 setup relied on a `CLAUDE.md` fallback, move that guidance into the applicable `AGENTS.md`. V2 currently only
 discovers `AGENTS.md`; because non-API V1 behavior is intended to remain compatible, also run `/report` with the affected
@@ -12733,9 +12733,6 @@
          },
          "agent": {
            "type": "string"
-          },
-          "previous": {
-            "type": "string"
          }
        },
        "required": ["id", "time", "type", "agent"],
@@ -12733,9 +12733,6 @@
          },
          "agent": {
            "type": "string"
-          },
-          "previous": {
-            "type": "string"
          }
        },
        "required": ["id", "time", "type", "agent"],
@@ -35,34 +35,32 @@ if (Script.release && !Script.preview) {

 await prepareReleaseFiles()

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

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

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

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

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

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

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

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

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

 if (Script.release) {
  await $`bun ./packages/desktop/scripts/finalize-latest-json.ts`