refactor(core): route plugin agent reads through one location helper

.github/actions/setup-bun/action.yml

@@ -9,10 +9,6 @@ inputs:
     description: "Additional flags to pass to 'bun install'"
     required: false
     default: ""
-  node-version:
-    description: "Node version to install"
-    required: false
-    default: "24"
 runs:
   using: "composite"
   steps:
@@ -21,7 +17,7 @@ runs:
     - name: Setup Node
       uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4.4.0
       with:
-        node-version: ${{ inputs.node-version }}
+        node-version: "24"
 
     - name: Get baseline download URL
       id: bun-url

.github/workflows/test.yml

@@ -73,6 +73,11 @@ jobs:
           token: ${{ secrets.GITHUB_TOKEN }}
           fetch-depth: 0
 
+      - name: Setup Node
+        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4.4.0
+        with:
+          node-version: "24"
+
       - name: Setup Bun
         uses: ./.github/actions/setup-bun
 
@@ -197,13 +202,17 @@ jobs:
         with:
           token: ${{ secrets.GITHUB_TOKEN }}
 
-      - name: Setup Bun
+      - name: Setup Node
         if: env.E2E_ENABLED == 'true'
-        uses: ./.github/actions/setup-bun
+        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4.4.0
         with:
           # Playwright 1.59 hangs while extracting Chromium with Node 24.16.
           node-version: "24.15"
 
+      - name: Setup Bun
+        if: env.E2E_ENABLED == 'true'
+        uses: ./.github/actions/setup-bun
+
       - name: Read Playwright version
         if: env.E2E_ENABLED == 'true'
         id: playwright-version

packages/cli/src/acp/agent.ts

@@ -8,28 +8,20 @@ import {
   type AgentRequestMethod,
   type Stream,
 } from "@agentclientprotocol/sdk"
-import type { OpenCodeClient } from "@opencode/client/promise"
-import { Cause, Deferred, Effect, type Scope } from "effect"
-import { ACPCatalog } from "./catalog"
+import { ClientError, type OpenCodeClient } from "@opencode/client/promise"
+import { Cause, Effect } from "effect"
+import { ACPConnection } from "./connection"
 import { ACPError } from "./error"
 import { ACPService } from "./service"
 
 // Untraced so request spans parent to the caller's span instead of a setup span that has already ended.
 export const connect = Effect.fnUntraced(function* (client: OpenCodeClient, stream: Stream) {
-  const run = Effect.runPromiseWith(yield* Effect.context<Scope.Scope>())
-  const catalog = yield* ACPCatalog.make(client)
-  // Requests can dispatch once the stream's read loop yields, which may be before the service below is built.
-  const ready = yield* Deferred.make<ACPService.Interface>()
+  const run = Effect.runPromiseWith(yield* Effect.context<never>())
   const handle =
-    <Params, A>(
-      call: (service: ACPService.Interface, ctx: AgentHandlerContext<Params>) => Effect.Effect<A, ACPService.Failure>,
-    ) =>
+    <Params, A>(call: (ctx: AgentHandlerContext<Params>) => Effect.Effect<A, ACPError.Error | RequestError>) =>
     (name: string) => {
       const handler = Effect.fn(name)(
-        (ctx: AgentHandlerContext<Params>) =>
-          Deferred.await(ready).pipe(Effect.flatMap((service) => call(service, ctx))),
-        // Catalog failures arrive typed and are classified like promise rejections.
-        Effect.catch(ACPError.classify),
+        call,
         Effect.mapError((error) => (error instanceof RequestError ? error : ACPError.toRequestError(error))),
         Effect.tapCauseIf(Cause.hasDies, (cause) => Effect.logError("ACP request failed", cause)),
         Effect.catchDefect((defect) => Effect.fail(ACPError.toRequestError(ACPError.fromUnknown(defect)))),
@@ -48,63 +40,74 @@ export const connect = Effect.fnUntraced(function* (client: OpenCodeClient, stre
 
   request(
     "initialize",
-    handle((service, ctx) => service.initialize(ctx.params)),
+    handle((ctx) => promise(() => service.initialize(ctx.params))),
   )
   request(
     "authenticate",
-    handle((service, ctx) => service.authenticate(ctx.params)),
+    handle((ctx) => promise(() => service.authenticate(ctx.params))),
   )
   request(
     "session/new",
-    handle((service, ctx) => service.newSession(ctx.params)),
+    handle((ctx) => promise(() => service.newSession(ctx.params))),
   )
   request(
     "session/load",
-    handle((service, ctx) => service.loadSession(ctx.params)),
+    handle((ctx) => promise(() => service.loadSession(ctx.params))),
   )
   request(
     "session/list",
-    handle((service, ctx) => service.listSessions(ctx.params)),
+    handle((ctx) => promise(() => service.listSessions(ctx.params))),
   )
   request(
     "session/delete",
-    handle((service, ctx) => service.deleteSession(ctx.params)),
+    handle((ctx) => promise(() => service.deleteSession(ctx.params))),
   )
   request(
     "session/resume",
-    handle((service, ctx) => service.resumeSession(ctx.params)),
+    handle((ctx) => promise(() => service.resumeSession(ctx.params))),
   )
   request(
     "session/close",
-    handle((service, ctx) => ACPError.promise(() => service.closeSession(ctx.params))),
+    handle((ctx) => promise(() => service.closeSession(ctx.params))),
   )
   request(
     "session/fork",
-    handle((service, ctx) => service.forkSession(ctx.params)),
+    handle((ctx) => promise(() => service.forkSession(ctx.params))),
   )
   request(
     "session/set_config_option",
-    handle((service, ctx) => service.setSessionConfigOption(ctx.params)),
+    handle((ctx) => promise(() => service.setSessionConfigOption(ctx.params))),
   )
   request(
     "session/set_mode",
-    handle((service, ctx) => service.setSessionMode(ctx.params)),
+    handle((ctx) => promise(() => service.setSessionMode(ctx.params))),
   )
   // The SDK signal is passed through rather than interrupting the fiber: a cancelled turn still resolves with
   // `stopReason: "cancelled"`.
   request(
     "session/prompt",
-    handle((service, ctx) => ACPError.promise(() => service.prompt(ctx.params, ctx.signal))),
+    handle((ctx) => promise(() => service.prompt(ctx.params, ctx.signal))),
   )
   notification(
     "session/cancel",
-    handle((service, ctx) => ACPError.promise(() => service.cancel(ctx.params))),
+    handle((ctx) => promise(() => service.cancel(ctx.params))),
   )
   const connection = app.connect(stream)
-  yield* Deferred.succeed(ready, yield* ACPService.make({ client, connection, catalog, run }))
+  // Inbound dispatch starts after the stream's async read loop yields, so handlers never observe this before assignment.
+  const service = ACPService.make({ client, connection: ACPConnection.make(connection) })
   return connection
 })
 
 const spanName = (method: string) => `cli.acp.${method.replaceAll("/", ".")}`
 
+const promise = <A>(evaluate: () => Promise<A>) =>
+  Effect.tryPromise({ try: evaluate, catch: (cause) => cause }).pipe(
+    Effect.catch((cause) => {
+      if (cause instanceof RequestError || ACPError.is(cause)) return Effect.fail(cause)
+      if (cause instanceof ClientError && cause.reason === "Transport")
+        return Effect.fail(new ACPError.ServerUnavailableError())
+      return Effect.die(cause)
+    }),
+  )
+
 export * as ACP from "./agent"

packages/cli/src/acp/catalog.ts

@@ -1,6 +1,5 @@
 import type { CommandInfo, ModelInfo, ModelRef, OpenCodeClient, OpenCodeEvent } from "@opencode/client/promise"
 import { FSUtil } from "@opencode/util/fs-util"
-import { Context, Deferred, Effect, Exit, Schedule, Schema, Semaphore, Stream, SubscriptionRef } from "effect"
 import type { ConfigOptionProvider } from "./config-option"
 
 export type Catalog = {
@@ -12,173 +11,118 @@ export type Catalog = {
   readonly commands: CommandInfo[]
 }
 
-export class NotReadyError extends Schema.TaggedError<NotReadyError>()("ACPCatalogNotReadyError", {
-  reason: Schema.Literals(["models", "agents"]),
-}) {
-  override get message() {
-    return this.reason === "models" ? "No models are available" : "No primary agents are available"
-  }
-}
-
-export class LoadError extends Schema.TaggedError<LoadError>()("ACPCatalogLoadError", {
-  cause: Schema.Defect(),
-}) {}
-
-export type Error = NotReadyError | LoadError
-
-export interface Interface {
-  /** Loads a directory's catalog once. Concurrent callers share the load, and a failed load is not cached. */
-  readonly get: (cwd: string) => Effect.Effect<Catalog, Error>
-  /** Resolves after a reload that started after the call. A failed reload keeps the previous catalog. */
-  readonly reload: (cwd: string) => Effect.Effect<void, Error>
-  /** Emits the current catalog, then each reloaded one. */
-  readonly changes: (cwd: string) => Stream.Stream<Catalog, Error>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/cli/acp/Catalog") {}
-
-type Entry = {
+export type Live = {
   readonly cwd: string
-  readonly catalog: SubscriptionRef.SubscriptionRef<Catalog>
-  readonly lock: Semaphore.Semaphore
-  requested: number
-  loaded: number
+  current: Catalog
 }
 
 // Provider, integration, and credential changes reach the catalog through model.updated.
 const reloadOn = new Set<OpenCodeEvent["type"]>(["model.updated", "agent.updated", "command.updated"])
 
-export const make = Effect.fnUntraced(function* (client: OpenCodeClient) {
-  const scope = yield* Effect.scope
-  const entries = new Map<string, Deferred.Deferred<Entry, Error>>()
-  const connected = yield* Deferred.make<void>()
+export function make(input: {
+  readonly client: OpenCodeClient
+  readonly signal?: AbortSignal
+  readonly changed: (live: Live, previous: Catalog) => Promise<unknown>
+}) {
+  const entries = new Map<string, Promise<Live>>()
+  const running = new Map<Live, Promise<void>>()
+  const queued = new Set<Live>()
+  let subscribed: Promise<void> | undefined
 
-  // A reload covers every request made before it starts, so requests queued behind a running reload share
-  // one more load. Typed load failures keep the previous catalog and still settle the requests they covered.
-  const reload = (entry: Entry) =>
-    Effect.suspend(() => {
-      const target = ++entry.requested
-      return entry.lock.withPermit(
-        Effect.suspend(() => {
-          if (entry.loaded >= target) return Effect.void
-          const generation = entry.requested
-          return load(client, entry.cwd).pipe(
-            Effect.flatMap((next) => SubscriptionRef.set(entry.catalog, next)),
-            Effect.ignore,
-            Effect.andThen(
-              Effect.sync(() => {
-                entry.loaded = generation
-              }),
-            ),
-          )
-        }),
-      )
-    })
+  const get = (cwd: string) => {
+    const key = FSUtil.resolve(cwd)
+    const cached = entries.get(key)
+    if (cached) return cached
+    // Subscribe before the first read so an update between the read and the subscription is not lost.
+    const loaded = subscribe()
+      .then(() => load(input.client, cwd))
+      .then((current): Live => ({ cwd, current }))
+      .catch((error) => {
+        entries.delete(key)
+        throw error
+      })
+    entries.set(key, loaded)
+    return loaded
+  }
 
-  // Subscribe before the first read so an update between the read and the subscription is not lost.
-  yield* Stream.fromAsyncIterable(client.event.subscribe(), (cause) => cause).pipe(
-    Stream.runForEach((event) => {
-      if (event.type === "server.connected") return Deferred.succeed(connected, undefined)
-      if (!reloadOn.has(event.type)) return Effect.void
-      const directory = event.location?.directory
-      const targets = directory === undefined ? [...entries.values()] : [entries.get(FSUtil.resolve(directory))]
-      return Effect.forEach(
-        targets.filter((entry) => entry !== undefined),
-        (entry) => Deferred.await(entry).pipe(Effect.flatMap(reload), Effect.ignore, Effect.forkIn(scope)),
-        { discard: true },
-      )
-    }),
-    Effect.ignore,
-    Effect.ensuring(Deferred.succeed(connected, undefined)),
-    Effect.forkScoped,
-  )
+  const reload = (live: Live) => {
+    const current = running.get(live)
+    if (current) {
+      queued.add(live)
+      return current
+    }
+    const run = (async () => {
+      do {
+        queued.delete(live)
+        const next = await load(input.client, live.cwd).catch(() => undefined)
+        if (!next) break
+        const previous = live.current
+        live.current = next
+        await input.changed(live, previous).catch(() => {})
+      } while (queued.has(live))
+      running.delete(live)
+    })()
+    running.set(live, run)
+    return run
+  }
 
-  const create = Effect.fnUntraced(function* (cwd: string) {
-    yield* Deferred.await(connected)
-    return {
-      cwd,
-      catalog: yield* SubscriptionRef.make<Catalog>(yield* load(client, cwd)),
-      lock: Semaphore.makeUnsafe(1),
-      requested: 0,
-      loaded: 0,
-    } satisfies Entry
-  })
+  const subscribe = () =>
+    (subscribed ??= new Promise<void>((ready) => {
+      void (async () => {
+        for await (const event of input.client.event.subscribe({ signal: input.signal })) {
+          if (event.type === "server.connected") ready()
+          if (!reloadOn.has(event.type)) continue
+          const directory = event.location?.directory
+          const targets = directory === undefined ? [...entries.values()] : [entries.get(FSUtil.resolve(directory))]
+          targets.forEach((entry) => void entry?.then(reload, () => {}))
+        }
+      })()
+        .catch(() => {})
+        .finally(ready)
+    }))
 
-  const entry = (cwd: string) =>
-    Effect.suspend(() => {
-      const key = FSUtil.resolve(cwd)
-      const cached = entries.get(key)
-      if (cached) return Deferred.await(cached)
-      const loading = Deferred.makeUnsafe<Entry, Error>()
-      entries.set(key, loading)
-      return create(cwd).pipe(
-        Effect.onExit((exit) => {
-          if (Exit.isFailure(exit)) entries.delete(key)
-          return Deferred.done(loading, exit)
-        }),
-        Effect.forkIn(scope),
-        Effect.andThen(Deferred.await(loading)),
-      )
-    })
+  return { get, reload }
+}
 
-  return Service.of({
-    get: Effect.fn("cli.acp.catalog.get")(function* (cwd) {
-      const loaded = yield* entry(cwd)
-      return yield* SubscriptionRef.get(loaded.catalog)
-    }),
-    reload: Effect.fn("cli.acp.catalog.reload")(function* (cwd) {
-      yield* reload(yield* entry(cwd))
-    }),
-    changes: (cwd) => Stream.unwrap(entry(cwd).pipe(Effect.map((loaded) => SubscriptionRef.changes(loaded.catalog)))),
-  })
-})
-
-const load = (client: OpenCodeClient, cwd: string) =>
-  read(client, cwd).pipe(
-    // Some providers discover models in the background after plugin startup begins.
-    Effect.retry({
-      while: (error) => error._tag === "ACPCatalogNotReadyError",
-      schedule: Schedule.spaced("25 millis").pipe(Schedule.upTo({ duration: "5 seconds" })),
-    }),
-    Effect.withSpan("cli.acp.catalog.load"),
-  )
-
-const read = Effect.fnUntraced(function* (client: OpenCodeClient, cwd: string) {
+async function load(client: OpenCodeClient, cwd: string): Promise<Catalog> {
   const location = { directory: cwd }
-  const [modelResult, defaultResult, agentResult, commandResult] = yield* Effect.tryPromise({
-    try: (signal) =>
-      Promise.all([
-        client.model.list({ location }, { signal }),
-        client.model.default({ location }, { signal }),
-        client.agent.list({ location }, { signal }),
-        client.command.list({ location }, { signal }),
-      ]),
-    catch: (cause) => new LoadError({ cause }),
-  })
-  const models = modelResult.data.filter((model) => model.enabled)
-  const preferred = defaultResult.data
-  // Parallel reads can straddle initialization; select only from this model list.
-  const defaultModel = preferred
-    ? models.find((model) => model.providerID === preferred.providerID && model.id === preferred.id)
-    : models[0]
-  if (!defaultModel) return yield* new NotReadyError({ reason: "models" })
-  const agents = agentResult.data.filter((agent) => agent.mode !== "subagent" && !agent.hidden)
-  // Core lists its resolved default agent first, the same one a new session runs.
-  const defaultAgent = agents[0]
-  if (!defaultAgent) return yield* new NotReadyError({ reason: "agents" })
-  return {
-    providers: providers(models),
-    models,
-    defaultModel: {
-      providerID: defaultModel.providerID,
-      id: defaultModel.id,
-      variant: defaultModel.variants.find((variant) => variant.id === "default")?.id,
-    },
-    modes: agents.map((agent) => ({ id: agent.id, name: agent.name, description: agent.description })),
-    defaultModeID: defaultAgent.id,
-    commands: commandResult.data,
-  } satisfies Catalog
-})
+  // Some providers discover models in the background after plugin startup begins.
+  const deadline = Date.now() + 5_000
+  let missing = "No models are available"
+  while (Date.now() < deadline) {
+    const [modelResult, defaultResult, agentResult, commandResult] = await Promise.all([
+      client.model.list({ location }),
+      client.model.default({ location }),
+      client.agent.list({ location }),
+      client.command.list({ location }),
+    ])
+    const models = modelResult.data.filter((model) => model.enabled)
+    const preferred = defaultResult.data
+    // Parallel reads can straddle initialization; select only from this model list.
+    const defaultModel = preferred
+      ? models.find((model) => model.providerID === preferred.providerID && model.id === preferred.id)
+      : models[0]
+    const agents = agentResult.data.filter((agent) => agent.mode !== "subagent" && !agent.hidden)
+    const defaultAgent = agents.find((agent) => agent.mode === "primary") ?? agents[0]
+    if (defaultModel && defaultAgent) {
+      return {
+        providers: providers(models),
+        models,
+        defaultModel: {
+          providerID: defaultModel.providerID,
+          id: defaultModel.id,
+          variant: defaultModel.variants.find((variant) => variant.id === "default")?.id,
+        },
+        modes: agents.map((agent) => ({ id: agent.id, name: agent.name, description: agent.description })),
+        defaultModeID: defaultAgent.id,
+        commands: commandResult.data,
+      }
+    }
+    missing = defaultModel ? "No primary agents are available" : "No models are available"
+    await Bun.sleep(25)
+  }
+  throw new Error(missing)
+}
 
 function providers(models: readonly ModelInfo[]): ConfigOptionProvider[] {
   return Array.from(new Set(models.map((model) => model.providerID)))

packages/cli/src/acp/connection.ts

@@ -1,51 +1,29 @@
 import {
   methods,
   type AgentConnection,
-  type RequestError,
   type RequestPermissionRequest,
   type RequestPermissionResponse,
   type SendRequestOptions,
   type SessionNotification,
+  type WriteTextFileRequest,
+  type WriteTextFileResponse,
 } from "@agentclientprotocol/sdk"
-import { Context, type Effect } from "effect"
-import { ACPError } from "./error"
-
-type Failure = ACPError.Error | RequestError
-
-export interface Interface {
-  readonly sessionUpdate: (params: SessionNotification) => Effect.Effect<void, Failure>
-  /** Interrupting the request cancels it on the client. */
-  readonly requestPermission: (params: RequestPermissionRequest) => Effect.Effect<RequestPermissionResponse, Failure>
-  readonly extNotification: (method: string, params: Record<string, unknown>) => Effect.Effect<void, Failure>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/cli/acp/Connection") {}
-
-export function service(connection: AgentConnection) {
-  return Service.of({
-    sessionUpdate: (params) => ACPError.promise(() => connection.client.notify(methods.client.session.update, params)),
-    requestPermission: (params) =>
-      ACPError.promise((signal) =>
-        connection.client.request(methods.client.session.requestPermission, params, { cancellationSignal: signal }),
-      ),
-    extNotification: (method, params) => ACPError.promise(() => connection.client.notify(method, params)),
-  })
-}
 
 export type Connection = {
   readonly signal?: AbortSignal
   sessionUpdate(params: SessionNotification): Promise<void>
   requestPermission(params: RequestPermissionRequest, options?: SendRequestOptions): Promise<RequestPermissionResponse>
+  writeTextFile?(params: WriteTextFileRequest, options?: SendRequestOptions): Promise<WriteTextFileResponse>
   extNotification?(method: string, params: Record<string, unknown>): Promise<void>
 }
 
-/** Promise view for the turn and permission code until they run as effects. */
 export function make(connection: AgentConnection): Connection {
   return {
     signal: connection.signal,
     sessionUpdate: (params) => connection.client.notify(methods.client.session.update, params),
     requestPermission: (params, options) =>
       connection.client.request(methods.client.session.requestPermission, params, options),
+    writeTextFile: (params, options) => connection.client.request(methods.client.fs.writeTextFile, params, options),
     extNotification: (method, params) => connection.client.notify(method, params),
   }
 }

packages/cli/src/acp/error.ts

@@ -1,7 +1,5 @@
 import { RequestError } from "@agentclientprotocol/sdk"
-import { ClientError } from "@opencode/client/promise"
-import { Effect, Schema } from "effect"
-import { ACPCatalog } from "./catalog"
+import { Schema } from "effect"
 
 export class SessionNotFoundError extends Schema.TaggedError<SessionNotFoundError>()("ACPSessionNotFoundError", {
   sessionId: Schema.String,
@@ -103,18 +101,6 @@ export function toRequestError(error: Error): RequestError {
   return exhaustive
 }
 
-/** Runs a promise, keeping ACP failures typed. Any other rejection is a defect. */
-export const promise = <A>(evaluate: (signal: AbortSignal) => Promise<A>) =>
-  Effect.tryPromise({ try: evaluate, catch: (cause) => cause }).pipe(Effect.catch(classify))
-
-export function classify(cause: unknown): Effect.Effect<never, Error | RequestError> {
-  // A catalog load failure is classified by the client error that caused it.
-  if (cause instanceof ACPCatalog.LoadError) return classify(cause.cause)
-  if (cause instanceof RequestError || is(cause)) return Effect.fail(cause)
-  if (cause instanceof ClientError && cause.reason === "Transport") return Effect.fail(new ServerUnavailableError())
-  return Effect.die(cause)
-}
-
 export function fromUnknown(error: unknown, service?: string) {
   const errorName = error instanceof Error ? error.name : undefined
   return new ServiceFailureError({ safeMessage: "Internal service failure", service, errorName })

packages/cli/src/acp/event.ts

@@ -5,15 +5,11 @@ import type {
   SessionMessageAssistant,
   SessionMessageInfo,
   SessionStructuredError,
-  TokenUsageInfo,
 } from "@opencode/client/promise"
-import { Event } from "@opencode/schema/event"
-import { SessionMessage } from "@opencode/schema/session-message"
-import { TokenUsage } from "@opencode/schema/token-usage"
 import type { ACPConnection } from "./connection"
 import { partsToContentChunks, type ReplayPart } from "./content"
 import { ACPError } from "./error"
-import { replyPermission } from "./permission"
+import { replyPermission, syncEditedFiles } from "./permission"
 import {
   completedToolUpdate,
   errorToolUpdate,
@@ -23,7 +19,7 @@ import {
   type ToolInput,
 } from "./tool"
 
-type Connection = Pick<ACPConnection.Connection, "sessionUpdate" | "requestPermission">
+type Connection = Pick<ACPConnection.Connection, "sessionUpdate" | "requestPermission" | "writeTextFile">
 
 export type TurnControl = {
   cancelled: boolean
@@ -46,7 +42,6 @@ export type TurnStart =
 export const ChildSessionUpdatesCapability = "opencode/child-session-updates"
 export const ChildSessionUpdateMethod = "opencode/session/child_update"
 const RetryMeta = "opencode/retry"
-const CompactionMeta = "opencode/compaction"
 
 type RetryStatus = {
   readonly attempt: number
@@ -54,18 +49,6 @@ type RetryStatus = {
   readonly error: SessionStructuredError
 }
 
-type CompactionMarker = {
-  readonly status: "started" | "completed" | "failed"
-  readonly messageId: string
-  readonly reason: "auto" | "manual"
-  readonly error?: SessionStructuredError
-}
-
-type CompactionEvent = Extract<
-  EventSubscribeOutput,
-  { readonly type: "session.compaction.started" | "session.compaction.ended" | "session.compaction.failed" }
->
-
 type ChildSessionUpdateBase = {
   readonly rootSessionId: string
   readonly childSessionId: string
@@ -101,13 +84,14 @@ export async function streamTurn(input: {
   readonly sessionID: string
   readonly cwd: string
   readonly start: TurnStart
+  readonly writeTextFile: boolean
   readonly action?: boolean
   readonly submit: (signal: AbortSignal) => Promise<unknown>
   readonly control: TurnControl
   readonly childSessionUpdate?: (update: ChildSessionUpdate) => Promise<void>
   readonly connectionSignal?: AbortSignal
   readonly sessionSignal?: AbortSignal
-}): Promise<{ readonly response: PromptResponse; readonly contextTokens: number | undefined }> {
+}): Promise<PromptResponse> {
   const streamController = new AbortController()
   const connectionAbort = () => streamController.abort()
   input.connectionSignal?.addEventListener("abort", connectionAbort, { once: true })
@@ -117,32 +101,15 @@ export async function streamTurn(input: {
 
   const control = input.control
   let started = false
+  let assistantMessageID: string | undefined
   let finish: SessionMessageAssistant["finish"]
   let executionError: { readonly type: string; readonly message: string } | undefined
-  let stepError: SessionStructuredError | undefined
-  let usage: { readonly turn: TokenUsageInfo; readonly last: TokenUsageInfo } | undefined
   const tools = new Map<string, ToolState>()
   const retries = new Map<string, RetryStatus>()
-  const compactions = new Map<string, string>()
   const children = new Map<string, ChildSession>()
   const openChildren = new Set<string>()
   let handedOff = false
 
-  const recordStep = (tokens: TokenUsageInfo) => {
-    const turn = usage?.turn
-    usage = {
-      turn: turn
-        ? {
-            input: turn.input + tokens.input,
-            output: turn.output + tokens.output,
-            reasoning: turn.reasoning + tokens.reasoning,
-            cache: { read: turn.cache.read + tokens.cache.read, write: turn.cache.write + tokens.cache.write },
-          }
-        : tokens,
-      last: tokens,
-    }
-  }
-
   const notifyChild = async (child: ChildSession, value: ChildSessionEvent) => {
     if (!input.childSessionUpdate) return
     await input
@@ -229,7 +196,7 @@ export async function streamTurn(input: {
       }
 
       if (event.type === "session.step.started") {
-        if (!child) stepError = undefined
+        if (!child) assistantMessageID = event.data.assistantMessageID
         if (retries.delete(eventSessionID))
           await send({ sessionUpdate: "session_info_update", _meta: { [RetryMeta]: null } })
         continue
@@ -244,16 +211,8 @@ export async function streamTurn(input: {
         await send({ sessionUpdate: "session_info_update", _meta: { [RetryMeta]: retry } })
         continue
       }
-      if (
-        event.type === "session.compaction.started" ||
-        event.type === "session.compaction.ended" ||
-        event.type === "session.compaction.failed"
-      ) {
-        const marker = compactionMarker(event, compactions)
-        if (marker) await send(compactionUpdate(marker))
-        continue
-      }
       if (event.type === "session.text.delta") {
+        if (!child) assistantMessageID = event.data.assistantMessageID
         await send({
           sessionUpdate: "agent_message_chunk",
           messageId: event.data.assistantMessageID,
@@ -262,6 +221,7 @@ export async function streamTurn(input: {
         continue
       }
       if (event.type === "session.reasoning.delta") {
+        if (!child) assistantMessageID = event.data.assistantMessageID
         await send({
           sessionUpdate: "agent_thought_chunk",
           messageId: `${event.data.assistantMessageID}:reasoning:${event.data.ordinal}`,
@@ -270,6 +230,7 @@ export async function streamTurn(input: {
         continue
       }
       if (event.type === "session.tool.input.started") {
+        if (!child) assistantMessageID = event.data.assistantMessageID
         tools.set(toolKey(event.data.sessionID, event.data.id), {
           name: event.data.name,
           input: {},
@@ -288,6 +249,7 @@ export async function streamTurn(input: {
         continue
       }
       if (event.type === "session.tool.called") {
+        if (!child) assistantMessageID = event.data.assistantMessageID
         const key = toolKey(event.data.sessionID, event.data.id)
         const current = tools.get(key) ?? emptyToolState()
         current.input = event.data.input
@@ -322,6 +284,16 @@ export async function streamTurn(input: {
         const key = toolKey(event.data.sessionID, event.data.id)
         const current = tools.get(key) ?? emptyToolState()
         tools.delete(key)
+        await syncEditedFiles({
+          connection: input.connection,
+          writeTextFile: input.writeTextFile,
+          sessionID: input.sessionID,
+          cwd: input.cwd,
+          toolName: current.name,
+          toolInput: current.input,
+          metadata: event.data.metadata ?? {},
+          signal: control.admission.signal,
+        }).catch(() => {})
         await send({
           sessionUpdate: "tool_call_update",
           ...completedToolUpdate({
@@ -330,7 +302,6 @@ export async function streamTurn(input: {
             input: current.input,
             metadata: event.data.metadata,
             content: event.data.content,
-            cwd: input.cwd,
           }),
         })
         continue
@@ -355,15 +326,8 @@ export async function streamTurn(input: {
       }
       if (event.type === "session.step.ended") {
         if (!child) {
+          assistantMessageID = event.data.assistantMessageID
           finish = event.data.finish
-          recordStep(event.data.tokens)
-        }
-        continue
-      }
-      if (event.type === "session.step.failed") {
-        if (!child) {
-          stepError = event.data.error
-          if (event.data.tokens) recordStep(event.data.tokens)
         }
         continue
       }
@@ -409,17 +373,14 @@ export async function streamTurn(input: {
     if (input.action) {
       streamController.abort()
       await completed.catch(() => {})
-      return {
-        response: response(undefined, undefined, "succeeded", control.cancelled, undefined),
-        contextTokens: undefined,
-      }
+      return response(undefined, undefined, "succeeded", control.cancelled, undefined)
     }
     if (control.cancelled) {
       await input.client.session.interrupt({ sessionID: input.sessionID }).catch(() => {})
       if (!started) {
         streamController.abort()
         await completed.catch(() => {})
-        return { response: response(undefined, undefined, "interrupted", true, undefined), contextTokens: undefined }
+        return response(undefined, undefined, "interrupted", true, undefined)
       }
     }
     const terminal = await completed
@@ -430,17 +391,19 @@ export async function streamTurn(input: {
         .catch(() => {})
         .finally(closeStream)
     }
-    return {
-      response: response(
-        usage?.turn,
-        stepError ?? executionError,
-        terminal,
-        control.cancelled,
-        finish,
-        retries.get(input.sessionID),
-      ),
-      contextTokens: usage ? TokenUsage.total(usage.last) : undefined,
-    }
+    const assistant = assistantMessageID
+      ? await input.client.session
+          .message.get({ sessionID: input.sessionID, messageID: assistantMessageID })
+          .catch(() => undefined)
+      : undefined
+    return response(
+      assistant?.type === "assistant" ? assistant : undefined,
+      executionError,
+      terminal,
+      control.cancelled,
+      finish,
+      retries.get(input.sessionID),
+    )
   } catch (error) {
     streamController.abort()
     await completed.catch(() => {})
@@ -460,31 +423,6 @@ function toolKey(sessionID: string, id: string) {
   return `${sessionID}:${id}`
 }
 
-// Message IDs follow core's compaction message projection, so live markers match replayed ones.
-function compactionMarker(event: CompactionEvent, compactions: Map<string, string>): CompactionMarker | undefined {
-  const sessionID = event.data.sessionID
-  if (event.type === "session.compaction.started") {
-    const messageId = event.data.inputID ?? SessionMessage.ID.fromEvent(Event.ID.make(event.id))
-    compactions.set(sessionID, messageId)
-    return { status: "started", messageId, reason: event.data.reason }
-  }
-  const tracked = compactions.get(sessionID)
-  compactions.delete(sessionID)
-  if (event.type === "session.compaction.ended")
-    return tracked ? { status: "completed", messageId: tracked, reason: event.data.reason } : undefined
-  // Automatic compaction can fail before it starts, for example when there is nothing to compact yet.
-  return {
-    status: "failed",
-    messageId: tracked ?? event.data.inputID ?? SessionMessage.ID.fromEvent(Event.ID.make(event.id)),
-    reason: event.data.reason,
-    error: event.data.error,
-  }
-}
-
-function compactionUpdate(marker: CompactionMarker): SessionUpdate {
-  return { sessionUpdate: "session_info_update", _meta: { [CompactionMeta]: marker } }
-}
-
 function projectChildUpdate(update: SessionUpdate, child: ChildSession) {
   const projected = { ...update }
   projected._meta = {
@@ -541,19 +479,6 @@ async function replayMessage(
     }
     return
   }
-  // A running compaction has no live turn on this connection to settle it, so replay only settled ones.
-  if (message.type === "compaction" && message.status !== "running") {
-    await connection.sessionUpdate({
-      sessionId: sessionID,
-      update: compactionUpdate({
-        status: message.status,
-        messageId: message.id,
-        reason: message.reason,
-        ...(message.status === "failed" ? { error: message.error } : {}),
-      }),
-    })
-    return
-  }
   if (message.type !== "assistant") return
   // Live reasoning ordinals count only reasoning parts, not the mixed content array.
   let reasoningOrdinal = 0
@@ -604,7 +529,6 @@ async function replayMessage(
               input: part.state.input,
               metadata: part.state.metadata,
               content: part.state.content,
-              cwd,
             }),
           },
         })
@@ -653,13 +577,14 @@ function matchesStart(event: EventSubscribeOutput, start: TurnStart) {
 }
 
 function response(
-  tokens: TokenUsageInfo | undefined,
-  error: { readonly type: string; readonly message: string } | undefined,
+  assistant: SessionMessageAssistant | undefined,
+  executionError: { readonly type: string; readonly message: string } | undefined,
   terminal: "succeeded" | "failed" | "interrupted",
   cancelled: boolean,
   finish: SessionMessageAssistant["finish"],
   retry?: RetryStatus,
 ): PromptResponse {
+  const error = assistant?.error ?? executionError
   if (error?.type === "provider.auth") throw new ACPError.AuthRequiredError()
   if (error && error.type !== "aborted" && error.type !== "provider.content-filter") {
     throw new ACPError.ServiceFailureError({
@@ -668,11 +593,12 @@ function response(
       errorName: error.type,
     })
   }
+  const tokens = assistant?.tokens
   const usage = tokens
     ? {
         inputTokens: tokens.input,
         outputTokens: tokens.output,
-        totalTokens: TokenUsage.total(tokens),
+        totalTokens: tokens.input + tokens.output + tokens.reasoning + tokens.cache.read + tokens.cache.write,
         ...(tokens.reasoning > 0 ? { thoughtTokens: tokens.reasoning } : {}),
         ...(tokens.cache.read > 0 ? { cachedReadTokens: tokens.cache.read } : {}),
         ...(tokens.cache.write > 0 ? { cachedWriteTokens: tokens.cache.write } : {}),

packages/cli/src/acp/permission.ts

@@ -1,19 +1,13 @@
 import type { PermissionOption, ToolCallContent, ToolCallLocation } from "@agentclientprotocol/sdk"
 import type { EventSubscribeOutput, OpenCodeClient } from "@opencode/client/promise"
 import { Patch } from "@opencode/util/patch"
+import { Result } from "effect"
+import { isAbsolute, resolve } from "node:path"
 import type { ACPConnection } from "./connection"
-import {
-  absolutePath,
-  filePath,
-  patchHunks,
-  pendingToolCall,
-  stringValue,
-  toLocations,
-  type ToolInput,
-} from "./tool"
+import { pendingToolCall, stringValue, toLocations, toToolKind, type ToolInput } from "./tool"
 
 type PermissionEvent = Extract<EventSubscribeOutput, { type: "permission.asked" }>
-type Connection = Pick<ACPConnection.Connection, "requestPermission">
+type Connection = Pick<ACPConnection.Connection, "requestPermission" | "writeTextFile">
 type Tool = { readonly name: string; readonly input: ToolInput }
 
 const options: PermissionOption[] = [
@@ -51,7 +45,7 @@ export async function replyPermission(input: {
         },
         cwd: input.cwd,
       }),
-      locations: permissionLocations(toolName, toolInput, input.event.data.resources, input.cwd),
+      locations: permissionLocations(toolName, toolInput, input.event.data.resources, input.cwd, previews),
       ...(previews.length > 0 ? { content: previews } : {}),
     },
     options,
@@ -75,13 +69,45 @@ function prefixedTitle(prefix: string | undefined, title: string | undefined) {
   return `${prefix}: ${title}`
 }
 
+export async function syncEditedFiles(input: {
+  readonly connection: Pick<ACPConnection.Connection, "writeTextFile">
+  readonly writeTextFile: boolean
+  readonly sessionID: string
+  readonly cwd: string
+  readonly toolName: string
+  readonly toolInput: ToolInput
+  readonly metadata: Readonly<Record<string, unknown>>
+  readonly signal?: AbortSignal
+}) {
+  if (!input.writeTextFile || !input.connection.writeTextFile || toToolKind(input.toolName) !== "edit") return
+  const files = Array.isArray(input.metadata.files)
+    ? input.metadata.files.flatMap((file): string[] => {
+        if (!file || typeof file !== "object") return []
+        const path = "file" in file ? file.file : undefined
+        return typeof path === "string" ? [path] : []
+      })
+    : []
+  const path = filePath(input.toolInput)
+  const paths = [...new Set([...files, ...(path ? [path] : [])])]
+  await Promise.all(
+    paths.map(async (path) => {
+      const target = resolvePath(path, input.cwd)
+      const file = Bun.file(target)
+      if (!(await file.exists())) return
+      await input.connection.writeTextFile?.(
+        { sessionId: input.sessionID, path: target, content: await file.text() },
+        { cancellationSignal: input.signal },
+      )
+    }),
+  )
+}
+
 async function permissionPreviews(toolName: string, input: ToolInput, cwd: string): Promise<ToolCallContent[]> {
   const tool = toolName.toLocaleLowerCase()
   if (tool === "patch" || tool === "apply_patch") return patchPreviews(input, cwd)
-  const file = filePath(input)
-  if (!file) return []
-  const path = absolutePath(file, cwd)
-  const oldText = await readText(path)
+  const path = filePath(input)
+  if (!path) return []
+  const oldText = await readText(path, cwd)
   if (tool === "write") {
     const content = stringValue(input.content)
     return content === undefined ? [] : [{ type: "diff", path, oldText, newText: content }]
@@ -95,25 +121,31 @@ async function permissionPreviews(toolName: string, input: ToolInput, cwd: strin
   return [{ type: "diff", path, oldText, newText }]
 }
 
-function patchPreviews(input: ToolInput, cwd: string): Promise<ToolCallContent[]> {
-  // Patch.derive throws when a hunk does not match the current file.
-  return Promise.all(
-    patchHunks(input).map(async (hunk): Promise<ToolCallContent> => {
-      const path = absolutePath(hunk.path, cwd)
-      if (hunk.type === "add") {
-        const newText = hunk.contents.endsWith("\n") || hunk.contents === "" ? hunk.contents : `${hunk.contents}\n`
-        return { type: "diff", path, oldText: "", newText }
-      }
-      const oldText = await readText(path)
-      if (hunk.type === "delete") return { type: "diff", path, oldText, newText: "" }
-      return {
-        type: "diff",
-        path: hunk.movePath ? absolutePath(hunk.movePath, cwd) : path,
-        oldText,
-        newText: Patch.derive(hunk.path, hunk.chunks, oldText).content,
-      }
-    }),
-  ).catch(() => [])
+async function patchPreviews(input: ToolInput, cwd: string): Promise<ToolCallContent[]> {
+  const patchText = stringValue(input.patchText)
+  if (!patchText) return []
+  try {
+    const parsed = Patch.parse(patchText)
+    if (Result.isFailure(parsed)) return []
+    return await Promise.all(
+      parsed.success.map(async (hunk): Promise<ToolCallContent> => {
+        const oldText = hunk.type === "add" ? "" : await readText(hunk.path, cwd)
+        if (hunk.type === "add") {
+          const newText = hunk.contents.endsWith("\n") || hunk.contents === "" ? hunk.contents : `${hunk.contents}\n`
+          return { type: "diff", path: hunk.path, oldText, newText }
+        }
+        if (hunk.type === "delete") return { type: "diff", path: hunk.path, oldText, newText: "" }
+        return {
+          type: "diff",
+          path: hunk.movePath ?? hunk.path,
+          oldText,
+          newText: Patch.derive(hunk.path, hunk.chunks, oldText).content,
+        }
+      }),
+    )
+  } catch {
+    return []
+  }
 }
 
 function permissionTitle(toolName: string, input: ToolInput, previews: ReadonlyArray<ToolCallContent>) {
@@ -144,16 +176,27 @@ function permissionLocations(
   input: ToolInput,
   resources: ReadonlyArray<string>,
   cwd: string,
+  previews: ReadonlyArray<ToolCallContent>,
 ): ToolCallLocation[] {
+  const paths = previews.flatMap((preview) => (preview.type === "diff" ? [preview.path] : []))
+  if (paths.length > 0) return [...new Set(paths)].map((path) => ({ path }))
   const locations = toLocations(toolName, input, cwd)
   if (locations.length > 0) return locations
-  return resources.filter((resource) => resource !== "*").map((path) => ({ path: absolutePath(path, cwd) }))
+  return resources.filter((resource) => resource !== "*").map((path) => ({ path }))
 }
 
-function readText(path: string) {
-  return Bun.file(path)
+function readText(path: string, cwd: string) {
+  return Bun.file(resolvePath(path, cwd))
     .text()
     .catch(() => "")
 }
 
+function filePath(input: ToolInput) {
+  return stringValue(input.path) ?? stringValue(input.filePath) ?? stringValue(input.filepath)
+}
+
+function resolvePath(path: string, cwd: string) {
+  return isAbsolute(path) ? path : resolve(cwd, path)
+}
+
 export * as ACPPermission from "./permission"

packages/cli/src/acp/service.ts

@@ -1,9 +1,15 @@
-import { isSessionNotFoundError, type CommandInfo, type ModelRef, type OpenCodeClient } from "@opencode/client/promise"
+import { isDeepStrictEqual } from "node:util"
+import {
+  isSessionNotFoundError,
+  type CommandInfo,
+  type ModelRef,
+  type OpenCodeClient,
+  type SessionInfo,
+  type SessionMessageInfo,
+} from "@opencode/client/promise"
 import { FSUtil } from "@opencode/util/fs-util"
-import { Effect, Option, Ref, Stream, type Scope } from "effect"
 import { withTimestampedFallback } from "@opencode/util/session-title-fallback"
 import type {
-  AgentConnection,
   AuthenticateRequest,
   AuthenticateResponse,
   AuthMethod,
@@ -20,11 +26,11 @@ import type {
   ListSessionsResponse,
   LoadSessionRequest,
   LoadSessionResponse,
+  McpServer,
   NewSessionRequest,
   NewSessionResponse,
   PromptRequest,
   PromptResponse,
-  RequestError,
   ResumeSessionRequest,
   ResumeSessionResponse,
   SetSessionConfigOptionRequest,
@@ -34,9 +40,9 @@ import type {
 } from "@agentclientprotocol/sdk"
 import { OPENCODE_VERSION } from "../version"
 import { SessionMessage } from "@opencode/schema/session-message"
-import type { ACPCatalog, Catalog } from "./catalog"
-import { DEFAULT_VARIANT_VALUE, parseModelSelection } from "./config-option"
-import { ACPConnection } from "./connection"
+import { ACPCatalog, type Catalog } from "./catalog"
+import { buildConfigOptions, DEFAULT_VARIANT_VALUE, parseModelSelection } from "./config-option"
+import type { ACPConnection } from "./connection"
 import { promptContentToParts } from "./content"
 import {
   ChildSessionUpdateMethod,
@@ -48,10 +54,19 @@ import {
   type TurnStart,
 } from "./event"
 import { ACPError } from "./error"
-import { ACPSessions, builtinCommands, type Attached } from "./sessions"
 
 export const AuthMethodID = "opencode-login"
 
+// Model and mode are unset while the session follows the server defaults.
+type Attached = {
+  readonly id: string
+  readonly cwd: string
+  readonly abort: AbortController
+  readonly catalog: ACPCatalog.Live
+  model?: ModelRef
+  modeID?: string
+}
+
 type PreparedPrompt = {
   readonly start: TurnStart
   readonly text: string
@@ -61,114 +76,88 @@ type PreparedPrompt = {
   readonly command?: CommandInfo
 }
 
-export type Failure = ACPError.Error | RequestError | ACPCatalog.Error
-
 export interface Interface {
-  readonly initialize: (input: InitializeRequest) => Effect.Effect<InitializeResponse>
-  readonly authenticate: (input: AuthenticateRequest) => Effect.Effect<AuthenticateResponse, Failure>
-  readonly newSession: (input: NewSessionRequest) => Effect.Effect<NewSessionResponse, Failure>
-  readonly loadSession: (input: LoadSessionRequest) => Effect.Effect<LoadSessionResponse, Failure>
-  readonly listSessions: (input: ListSessionsRequest) => Effect.Effect<ListSessionsResponse, Failure>
-  readonly deleteSession: (input: DeleteSessionRequest) => Effect.Effect<DeleteSessionResponse, Failure>
-  readonly resumeSession: (input: ResumeSessionRequest) => Effect.Effect<ResumeSessionResponse, Failure>
-  readonly forkSession: (input: ForkSessionRequest) => Effect.Effect<ForkSessionResponse, Failure>
-  readonly setSessionConfigOption: (
-    input: SetSessionConfigOptionRequest,
-  ) => Effect.Effect<SetSessionConfigOptionResponse, Failure>
-  readonly setSessionMode: (input: SetSessionModeRequest) => Effect.Effect<SetSessionModeResponse, Failure>
+  initialize(input: InitializeRequest): Promise<InitializeResponse>
+  authenticate(input: AuthenticateRequest): Promise<AuthenticateResponse>
+  newSession(input: NewSessionRequest): Promise<NewSessionResponse>
+  loadSession(input: LoadSessionRequest): Promise<LoadSessionResponse>
+  listSessions(input: ListSessionsRequest): Promise<ListSessionsResponse>
+  deleteSession(input: DeleteSessionRequest): Promise<DeleteSessionResponse>
+  resumeSession(input: ResumeSessionRequest): Promise<ResumeSessionResponse>
   closeSession(input: CloseSessionRequest): Promise<CloseSessionResponse>
+  forkSession(input: ForkSessionRequest): Promise<ForkSessionResponse>
+  setSessionConfigOption(input: SetSessionConfigOptionRequest): Promise<SetSessionConfigOptionResponse>
+  setSessionMode(input: SetSessionModeRequest): Promise<SetSessionModeResponse>
   prompt(input: PromptRequest, signal?: AbortSignal): Promise<PromptResponse>
   cancel(input: CancelNotification): Promise<void>
 }
 
-export const make = Effect.fnUntraced(function* (input: {
+export function make(input: {
   readonly client: OpenCodeClient
-  readonly connection: AgentConnection
-  readonly catalog: ACPCatalog.Interface
-  readonly run: <A, E>(effect: Effect.Effect<A, E, Scope.Scope>) => Promise<A>
-}) {
-  const connection = ACPConnection.service(input.connection)
-  // The turn still runs on promises.
-  const turnConnection = ACPConnection.make(input.connection)
-  const sessions = yield* ACPSessions.make({ client: input.client, connection, catalog: input.catalog })
-  const capabilities = yield* Ref.make({ childSessionUpdates: false })
+  readonly connection: ACPConnection.Connection
+}): Interface {
+  const sessions = new Map<string, Attached>()
+  const registeredMcp = new Map<string, Set<string>>()
   const active = new Map<string, { readonly control: TurnControl; readonly turn: Promise<PromptResponse> }>()
+  const capabilities = { writeTextFile: false, childSessionUpdates: false }
 
-  const configOptions = Effect.fnUntraced(function* (attached: Attached) {
-    const catalog = yield* input.catalog.get(attached.cwd)
-    return ACPSessions.configOptions(catalog, yield* Ref.get(attached.selection))
-  })
-
-  // A selection the catalog has not seen may be new on the server, so reload once before rejecting it.
-  const withReload = <A>(attached: Attached, select: Effect.Effect<A, Failure>) => {
-    const retry = () => input.catalog.reload(attached.cwd).pipe(Effect.andThen(select))
-    return select.pipe(
-      Effect.catchTags({ ACPInvalidModelError: retry, ACPInvalidModeError: retry, ACPInvalidEffortError: retry }),
-    )
-  }
-
-  const selectOption = Effect.fnUntraced(function* (attached: Attached, configId: string, value: string) {
-    if (configId === "mode") return yield* selectMode(attached, value)
-    if (configId !== "model" && configId !== "effort") return yield* new ACPError.InvalidConfigOptionError({ configId })
-    const catalog = yield* input.catalog.get(attached.cwd)
-    const current = ACPSessions.currentModel(catalog, yield* Ref.get(attached.selection))
-    const model =
-      configId === "model"
-        ? yield* requireModel(catalog, value, current)
-        : yield* requireEffort(catalog, value, current)
-    yield* Ref.update(attached.selection, (selection) => ({ ...selection, model }))
-    yield* ACPError.promise(() => input.client.session.switchModel({ sessionID: attached.id, model }))
-  })
-
-  const selectMode = Effect.fnUntraced(function* (attached: Attached, modeID: string) {
-    const catalog = yield* input.catalog.get(attached.cwd)
-    if (!catalog.modes.some((mode) => mode.id === modeID)) return yield* new ACPError.InvalidModeError({ mode: modeID })
-    yield* Ref.update(attached.selection, (selection) => ({ ...selection, modeID }))
-    yield* ACPError.promise(() => input.client.session.switchAgent({ sessionID: attached.id, agent: modeID }))
-  })
-
-  const getSession = Effect.fnUntraced(function* (sessionID: string, cwd: string) {
-    const session = yield* ACPError.promise(() => input.client.session.get({ sessionID }).catch(notFound(sessionID)))
-    if (FSUtil.resolve(cwd) !== FSUtil.resolve(session.location.directory))
-      return yield* new ACPError.SessionDirectoryMismatchError({ sessionId: sessionID, cwd })
-    return session
-  })
-
-  const replay = (attached: Attached) =>
-    Stream.paginate(Option.none<string>(), (cursor) =>
-      ACPError.promise(() =>
-        Option.isSome(cursor)
-          ? input.client.message.list({ sessionID: attached.id, limit: 200, cursor: cursor.value })
-          : input.client.message.list({ sessionID: attached.id, limit: 200, order: "asc" }),
-      ).pipe(
-        Effect.map(
-          (page) => [page.data, Option.fromNullishOr(page.cursor.next).pipe(Option.map(Option.some))] as const,
-        ),
+  const catalogs = ACPCatalog.make({
+    client: input.client,
+    signal: input.connection.signal,
+    changed: (live, previous) =>
+      Promise.all(
+        Array.from(sessions.values())
+          .filter((state) => state.catalog === live)
+          .map(async (state) => {
+            const options = configOptions(state)
+            if (!isDeepStrictEqual(options, configOptions(state, previous))) {
+              await input.connection.sessionUpdate({
+                sessionId: state.id,
+                update: { sessionUpdate: "config_option_update", configOptions: options },
+              })
+            }
+            if (!isDeepStrictEqual(live.current.commands, previous.commands)) await sendCommands(state)
+          }),
       ),
-    ).pipe(
-      Stream.runCollect,
-      Effect.flatMap((messages) =>
-        ACPError.promise(() => replayMessages(turnConnection, attached.id, attached.cwd, messages)),
-      ),
-    )
+  })
 
-  const sendUsageUpdate = Effect.fnUntraced(function* (attached: Attached, used: number | undefined) {
-    if (!used) return
-    const catalog = yield* input.catalog.get(attached.cwd)
-    const current = ACPSessions.currentModel(catalog, yield* Ref.get(attached.selection))
-    const model = catalog.models.find((item) => item.providerID === current.providerID && item.id === current.id)
-    if (!model?.limit.context) return
-    const info = yield* ACPError.promise(() => input.client.session.get({ sessionID: attached.id }))
-    yield* connection.sessionUpdate({
-      sessionId: attached.id,
+  const sendCommands = (state: Attached) =>
+    input.connection.sessionUpdate({
+      sessionId: state.id,
       update: {
-        sessionUpdate: "usage_update",
-        used,
-        size: model.limit.context,
-        cost: { amount: info.cost, currency: "USD" },
+        sessionUpdate: "available_commands_update",
+        availableCommands: state.catalog.current.commands.map((command) => ({
+          name: command.name,
+          description: command.description ?? "",
+        })),
       },
     })
-  })
+
+  const withReload = <A>(state: Attached, select: () => Promise<A>) =>
+    select().catch(async (error: unknown) => {
+      if (
+        !(
+          error instanceof ACPError.InvalidModelError ||
+          error instanceof ACPError.InvalidModeError ||
+          error instanceof ACPError.InvalidEffortError
+        )
+      )
+        throw error
+      await catalogs.reload(state.catalog)
+      return select()
+    })
+
+  const requireSession = async (sessionID: string) => {
+    const current = sessions.get(sessionID)
+    if (current) return current
+    throw new ACPError.SessionNotFoundError({ sessionId: sessionID })
+  }
+
+  const detach = (sessionID: string) => {
+    sessions.get(sessionID)?.abort.abort()
+    sessions.delete(sessionID)
+    registeredMcp.delete(sessionID)
+  }
 
   const cancelTurn = (sessionID: string) => {
     const turn = active.get(sessionID)
@@ -179,11 +168,42 @@ export const make = Effect.fnUntraced(function* (input: {
     return input.client.session.interrupt({ sessionID })
   }
 
+  const attach = async (session: SessionInfo, cwd: string, mcpServers: readonly McpServer[]) => {
+    const catalog = await catalogs.get(cwd)
+    sessions.get(session.id)?.abort.abort()
+    const state: Attached = {
+      id: session.id,
+      cwd,
+      abort: new AbortController(),
+      catalog,
+      model: session.model,
+      modeID: session.agent,
+    }
+    sessions.set(session.id, state)
+    await registerMcpServers(input.client, registeredMcp, state, mcpServers)
+    await sendCommands(state)
+    return state
+  }
+
+  const replay = async (state: Attached) => {
+    await replayMessages(input.connection, state.id, state.cwd, await messages(input.client, state.id))
+  }
+
+  const configOptions = (state: Attached, catalog = state.catalog.current) => {
+    const model = currentModel(state, catalog)
+    return buildConfigOptions({
+      providers: catalog.providers,
+      currentModel: { providerID: model.providerID, modelID: model.id },
+      currentVariant: model.variant,
+      modes: catalog.modes,
+      currentModeId: state.modeID ?? catalog.defaultModeID,
+    })
+  }
+
   return {
-    initialize: Effect.fnUntraced(function* (params) {
-      yield* Ref.set(capabilities, {
-        childSessionUpdates: params.clientCapabilities?._meta?.[ChildSessionUpdatesCapability] === true,
-      })
+    initialize: async (params) => {
+      capabilities.writeTextFile = params.clientCapabilities?.fs?.writeTextFile === true
+      capabilities.childSessionUpdates = params.clientCapabilities?._meta?.[ChildSessionUpdatesCapability] === true
       const authMethod: AuthMethod = {
         description: "Run `opencode auth login` in the terminal",
         name: "Login with opencode",
@@ -206,37 +226,32 @@ export const make = Effect.fnUntraced(function* (input: {
         authMethods: [authMethod],
         agentInfo: { name: "OpenCode", version: OPENCODE_VERSION },
       }
-    }),
-    authenticate: Effect.fnUntraced(function* (params) {
-      if (params.methodId !== AuthMethodID)
-        return yield* new ACPError.UnknownAuthMethodError({ methodId: params.methodId })
+    },
+    authenticate: async (params) => {
+      if (params.methodId !== AuthMethodID) throw new ACPError.UnknownAuthMethodError({ methodId: params.methodId })
       return {}
-    }),
-    newSession: Effect.fnUntraced(function* (params) {
+    },
+    newSession: async (params) => {
       // Load before creating so a catalog failure leaves no session behind. Agent and model stay unset
       // so the server resolves its defaults after plugins activate.
-      yield* input.catalog.get(params.cwd)
-      const created = yield* ACPError.promise(() =>
-        input.client.session.create({ location: { directory: params.cwd } }),
-      )
-      const attached = yield* sessions.attach(created, params.cwd, params.mcpServers)
-      return { sessionId: attached.id, configOptions: yield* configOptions(attached) }
-    }),
-    loadSession: Effect.fnUntraced(function* (params) {
-      const session = yield* getSession(params.sessionId, params.cwd)
-      const attached = yield* sessions.attach(session, session.location.directory, params.mcpServers)
-      yield* replay(attached)
-      return { configOptions: yield* configOptions(attached) }
-    }),
-    listSessions: Effect.fnUntraced(function* (params) {
-      const page = yield* ACPError.promise(() =>
-        input.client.session.list({
-          ...(params.cwd ? { directory: params.cwd } : {}),
-          order: "desc",
-          limit: 100,
-          ...(params.cursor ? { cursor: params.cursor } : {}),
-        }),
-      )
+      await catalogs.get(params.cwd)
+      const created = await input.client.session.create({ location: { directory: params.cwd } })
+      const state = await attach(created, params.cwd, params.mcpServers)
+      return { sessionId: state.id, configOptions: configOptions(state) }
+    },
+    loadSession: async (params) => {
+      const session = await getSession(input.client, params.sessionId, params.cwd)
+      const state = await attach(session, session.location.directory, params.mcpServers)
+      await replay(state)
+      return { configOptions: configOptions(state) }
+    },
+    listSessions: async (params) => {
+      const page = await input.client.session.list({
+        ...(params.cwd ? { directory: params.cwd } : {}),
+        order: "desc",
+        limit: 100,
+        ...(params.cursor ? { cursor: params.cursor } : {}),
+      })
       return {
         sessions: page.data.map((session) => ({
           sessionId: session.id,
@@ -246,59 +261,74 @@ export const make = Effect.fnUntraced(function* (input: {
         })),
         ...(page.cursor.next ? { nextCursor: page.cursor.next } : {}),
       }
-    }),
-    deleteSession: Effect.fnUntraced(function* (params) {
-      yield* ACPError.promise(() =>
-        input.client.session.remove({ sessionID: params.sessionId }).catch(notFound(params.sessionId)),
-      ).pipe(Effect.catchTag("ACPSessionNotFoundError", () => Effect.void))
-      yield* sessions.detach(params.sessionId)
+    },
+    deleteSession: async (params) => {
+      await input.client.session.remove({ sessionID: params.sessionId }).catch((error) => {
+        if (!isSessionNotFoundError(error)) throw error
+      })
+      detach(params.sessionId)
       return {}
-    }),
-    resumeSession: Effect.fnUntraced(function* (params) {
-      const session = yield* getSession(params.sessionId, params.cwd)
-      const attached = yield* sessions.attach(session, session.location.directory, params.mcpServers ?? [])
-      return { configOptions: yield* configOptions(attached) }
-    }),
-    forkSession: Effect.fnUntraced(function* (params) {
-      const forked = yield* ACPError.promise(() => input.client.session.fork({ sessionID: params.sessionId }))
-      const attached = yield* sessions.attach(forked, forked.location.directory, params.mcpServers ?? [])
-      yield* replay(attached)
-      return { sessionId: attached.id, configOptions: yield* configOptions(attached) }
-    }),
-    setSessionConfigOption: Effect.fnUntraced(function* (params) {
-      const attached = yield* sessions.require(params.sessionId)
-      const value = params.value
-      if (typeof value !== "string") return yield* new ACPError.InvalidConfigOptionError({ configId: params.configId })
-      yield* withReload(attached, selectOption(attached, params.configId, value))
-      return { configOptions: yield* configOptions(attached) }
-    }),
-    setSessionMode: Effect.fnUntraced(function* (params) {
-      const attached = yield* sessions.require(params.sessionId)
-      yield* withReload(attached, selectMode(attached, params.modeId))
-      return {}
-    }),
+    },
+    resumeSession: async (params) => {
+      const session = await getSession(input.client, params.sessionId, params.cwd)
+      const state = await attach(session, session.location.directory, params.mcpServers ?? [])
+      return { configOptions: configOptions(state) }
+    },
     closeSession: async (params) => {
       const turn = active.get(params.sessionId)
       await cancelTurn(params.sessionId).catch((error) => {
         if (!isSessionNotFoundError(error)) throw error
       })
       await turn?.turn.catch(() => {})
-      await input.run(sessions.detach(params.sessionId))
+      detach(params.sessionId)
+      return {}
+    },
+    forkSession: async (params) => {
+      const forked = await input.client.session.fork({
+        sessionID: params.sessionId,
+      })
+      const state = await attach(forked, forked.location.directory, params.mcpServers ?? [])
+      await replay(state)
+      return { sessionId: state.id, configOptions: configOptions(state) }
+    },
+    setSessionConfigOption: async (params) => {
+      const state = await requireSession(params.sessionId)
+      const value = params.value
+      if (typeof value !== "string") throw new ACPError.InvalidConfigOptionError({ configId: params.configId })
+      await withReload(state, async () => {
+        switch (params.configId) {
+          case "model": {
+            const selected = requireModel(state.catalog.current, value, currentModel(state))
+            state.model = selected
+            await input.client.session.switchModel({ sessionID: state.id, model: selected })
+            return
+          }
+          case "effort": {
+            const current = currentModel(state)
+            const model = state.catalog.current.models.find(
+              (item) => item.providerID === current.providerID && item.id === current.id,
+            )
+            if (!model || (value !== DEFAULT_VARIANT_VALUE && !model.variants.some((variant) => variant.id === value)))
+              throw new ACPError.InvalidEffortError({ effort: value })
+            state.model = { ...current, variant: value }
+            await input.client.session.switchModel({ sessionID: state.id, model: state.model })
+            return
+          }
+          case "mode":
+            return selectMode(input.client, state, value)
+          default:
+            throw new ACPError.InvalidConfigOptionError({ configId: params.configId })
+        }
+      })
+      return { configOptions: configOptions(state) }
+    },
+    setSessionMode: async (params) => {
+      const state = await requireSession(params.sessionId)
+      await withReload(state, () => selectMode(input.client, state, params.modeId))
       return {}
     },
     prompt: async (params, signal) => {
-      // Read everything first so the active check and registration below stay synchronous.
-      const resolved = await input.run(
-        Effect.gen(function* () {
-          const attached = yield* sessions.require(params.sessionId)
-          return {
-            attached,
-            catalog: yield* input.catalog.get(attached.cwd),
-            childSessionUpdates: (yield* Ref.get(capabilities)).childSessionUpdates,
-          }
-        }),
-      )
-      const state = resolved.attached
+      const state = await requireSession(params.sessionId)
       if (active.has(state.id)) {
         throw new ACPError.ServiceFailureError({
           safeMessage: `Session already has an active ACP prompt: ${state.id}`,
@@ -306,31 +336,32 @@ export const make = Effect.fnUntraced(function* (input: {
         })
       }
       const messageID = SessionMessage.ID.create()
-      const prepared = preparePrompt(resolved.catalog, params.prompt, messageID)
+      const prepared = preparePrompt(state.catalog.current, params.prompt, messageID)
       const control: TurnControl = { cancelled: false, admission: new AbortController() }
-      const extNotification = turnConnection.extNotification
+      const extNotification = input.connection.extNotification
       const childSessionUpdate =
-        resolved.childSessionUpdates && extNotification
+        capabilities.childSessionUpdates && extNotification
           ? (update: ChildSessionUpdate) => extNotification(ChildSessionUpdateMethod, update).then(() => {})
           : undefined
       // A `$/cancel_request` for this prompt behaves like `session/cancel` for its turn.
       const cancel = () => void cancelTurn(state.id).catch(() => {})
       const turn = streamTurn({
         client: input.client,
-        connection: turnConnection,
+        connection: input.connection,
         sessionID: state.id,
         cwd: state.cwd,
         start: prepared.start,
+        writeTextFile: capabilities.writeTextFile,
         action: prepared.command !== undefined,
         control,
-        connectionSignal: turnConnection.signal,
-        sessionSignal: state.signal,
+        connectionSignal: input.connection.signal,
+        sessionSignal: state.abort.signal,
         submit: (signal) => submitPrompt(input.client, state, prepared, signal),
         ...(childSessionUpdate ? { childSessionUpdate } : {}),
       })
-        .then(async (result) => {
-          await input.run(sendUsageUpdate(state, result.contextTokens)).catch(() => {})
-          return result.response
+        .then(async (response) => {
+          await sendUsageUpdate(input.client, input.connection, state, response.usage?.totalTokens).catch(() => {})
+          return response
         })
         .finally(() => {
           signal?.removeEventListener("abort", cancel)
@@ -345,12 +376,6 @@ export const make = Effect.fnUntraced(function* (input: {
     cancel: async (params) => {
       await cancelTurn(params.sessionId).catch(() => {})
     },
-  } satisfies Interface
-})
-
-function notFound(sessionID: string) {
-  return (error: unknown): never => {
-    throw isSessionNotFoundError(error) ? new ACPError.SessionNotFoundError({ sessionId: sessionID }) : error
   }
 }
 
@@ -361,8 +386,7 @@ function preparePrompt(catalog: Catalog, prompt: PromptRequest["prompt"], messag
   const text = visible.flatMap((part) => (part.type === "text" ? [part.text] : [])).join("\n")
   const files = visible.flatMap((part) => (part.type === "file" ? [{ uri: part.url, name: part.filename }] : []))
   const slash = detectSlashCommand(text)
-  const command =
-    slash && !builtinCommands.has(slash.name) ? catalog.commands.find((item) => item.name === slash.name) : undefined
+  const command = slash ? catalog.commands.find((item) => item.name === slash.name) : undefined
   const start = turnStart(messageID, slash)
   return { start, text, files, synthetic, slash, command }
 }
@@ -397,18 +421,18 @@ async function submitPrompt(client: OpenCodeClient, session: Attached, prompt: P
 }
 
 function turnStart(messageID: string, slash: PreparedPrompt["slash"]): TurnStart {
-  if (slash && builtinCommands.get(slash.name)?.start === "compaction") return { type: "compaction", id: messageID }
+  if (slash?.name === "compact") return { type: "compaction", id: messageID }
   return { type: "input", id: messageID }
 }
 
-const requireModel = Effect.fnUntraced(function* (catalog: Catalog, modelID: string, current: ModelRef) {
+function requireModel(catalog: Catalog, modelID: string, current: ModelRef): ModelRef {
   const selected = parseModelSelection(modelID, catalog.providers)
   const model = catalog.models.find(
     (item) => item.providerID === selected.model.providerID && item.id === selected.model.modelID,
   )
-  if (!model) return yield* new ACPError.InvalidModelError({ providerId: selected.model.providerID, modelId: modelID })
+  if (!model) throw new ACPError.InvalidModelError({ providerId: selected.model.providerID, modelId: modelID })
   if (selected.variant && !model.variants.some((variant) => variant.id === selected.variant))
-    return yield* new ACPError.InvalidEffortError({ effort: selected.variant })
+    throw new ACPError.InvalidEffortError({ effort: selected.variant })
   const variant =
     selected.variant ??
     (current.providerID === model.providerID &&
@@ -416,15 +440,117 @@ const requireModel = Effect.fnUntraced(function* (catalog: Catalog, modelID: str
     (current.variant === DEFAULT_VARIANT_VALUE || model.variants.some((variant) => variant.id === current.variant))
       ? current.variant
       : undefined)
-  return { providerID: model.providerID, id: model.id, variant } satisfies ModelRef
-})
+  return { providerID: model.providerID, id: model.id, variant }
+}
 
-const requireEffort = Effect.fnUntraced(function* (catalog: Catalog, effort: string, current: ModelRef) {
-  const model = catalog.models.find((item) => item.providerID === current.providerID && item.id === current.id)
-  if (!model || (effort !== DEFAULT_VARIANT_VALUE && !model.variants.some((variant) => variant.id === effort)))
-    return yield* new ACPError.InvalidEffortError({ effort })
-  return { ...current, variant: effort } satisfies ModelRef
-})
+function currentModel(state: Attached, catalog = state.catalog.current) {
+  return state.model ?? catalog.defaultModel
+}
+
+async function selectMode(client: OpenCodeClient, state: Attached, modeID: string) {
+  if (!state.catalog.current.modes.some((mode) => mode.id === modeID))
+    throw new ACPError.InvalidModeError({ mode: modeID })
+  state.modeID = modeID
+  await client.session.switchAgent({ sessionID: state.id, agent: modeID })
+}
+
+async function getSession(client: OpenCodeClient, sessionID: string, cwd: string) {
+  const session = await client.session.get({ sessionID }).catch((error) => {
+    if (isSessionNotFoundError(error)) throw new ACPError.SessionNotFoundError({ sessionId: sessionID })
+    throw error
+  })
+  if (FSUtil.resolve(cwd) !== FSUtil.resolve(session.location.directory)) {
+    throw new ACPError.SessionDirectoryMismatchError({ sessionId: sessionID, cwd })
+  }
+  return session
+}
+
+async function messages(client: OpenCodeClient, sessionID: string) {
+  const result: SessionMessageInfo[] = []
+  let cursor: string | undefined
+  do {
+    const page = cursor
+      ? await client.message.list({ sessionID, limit: 200, cursor })
+      : await client.message.list({ sessionID, limit: 200, order: "asc" })
+    result.push(...page.data)
+    cursor = page.cursor.next ?? undefined
+  } while (cursor)
+  return result
+}
+
+async function registerMcpServers(
+  client: OpenCodeClient,
+  registered: Map<string, Set<string>>,
+  session: Attached,
+  servers: readonly McpServer[],
+) {
+  const current = registered.get(session.id) ?? new Set<string>()
+  registered.set(session.id, current)
+  await Promise.all(
+    servers.flatMap((server) => {
+      const config = mcpConfig(server)
+      const key = `${server.name}:${stableStringify(config)}`
+      if (current.has(key)) return []
+      current.add(key)
+      return [
+        client.mcp.add({ server: server.name, location: { directory: session.cwd }, config }).catch((error) => {
+          current.delete(key)
+          throw error
+        }),
+      ]
+    }),
+  )
+}
+
+function mcpConfig(server: McpServer) {
+  if ("type" in server) {
+    if (server.type === "acp") throw new Error("MCP-over-ACP is not supported")
+    return {
+      type: "remote" as const,
+      url: server.url,
+      headers: Object.fromEntries(server.headers.map((header) => [header.name, header.value])),
+      oauth: false as const,
+    }
+  }
+  return {
+    type: "local" as const,
+    command: [server.command, ...server.args],
+    environment: Object.fromEntries(server.env.map((entry) => [entry.name, entry.value])),
+  }
+}
+
+function stableStringify(value: unknown): string {
+  if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`
+  if (!value || typeof value !== "object") return JSON.stringify(value)
+  return `{${Object.entries(value)
+    .toSorted(([a], [b]) => a.localeCompare(b))
+    .map(([key, item]) => `${JSON.stringify(key)}:${stableStringify(item)}`)
+    .join(",")}}`
+}
+
+async function sendUsageUpdate(
+  client: OpenCodeClient,
+  connection: ACPConnection.Connection,
+  session: Attached,
+  used?: number,
+) {
+  if (!used) return
+  const current = currentModel(session)
+  const model = session.catalog.current.models.find(
+    (item) => item.providerID === current.providerID && item.id === current.id,
+  )
+  if (!model?.limit.context) return
+  const info = await client.session.get({ sessionID: session.id })
+  await connection.sessionUpdate({
+    sessionId: session.id,
+    update: {
+      sessionUpdate: "usage_update",
+      used,
+      size: model.limit.context,
+      cost: { amount: info.cost, currency: "USD" },
+    },
+  })
+}
 
 function detectSlashCommand(text: string): { readonly name: string; readonly args: string } | undefined {
   const value = text.trim()

packages/cli/src/acp/sessions.ts

@@ -1,196 +0,0 @@
-import { isDeepStrictEqual } from "node:util"
-import type { McpServer, RequestError } from "@agentclientprotocol/sdk"
-import type { ModelRef, OpenCodeClient, SessionInfo } from "@opencode/client/promise"
-import { Cause, Context, Effect, Exit, Ref, Scope, Stream } from "effect"
-import type { ACPCatalog, Catalog } from "./catalog"
-import { buildConfigOptions } from "./config-option"
-import type { ACPConnection } from "./connection"
-import { ACPError } from "./error"
-
-// ACP runs these itself; they take precedence over server commands with the same name.
-export const builtinCommands = new Map([
-  ["compact", { description: "Compact the session", start: "compaction" as const }],
-])
-
-/** Unset fields follow the server defaults. */
-export type Selection = {
-  readonly model?: ModelRef
-  readonly modeID?: string
-}
-
-export type Attached = {
-  readonly id: string
-  readonly cwd: string
-  readonly selection: Ref.Ref<Selection>
-  /** Aborted when the session detaches, for the promise-based turn. */
-  readonly signal: AbortSignal
-}
-
-export interface Interface {
-  /**
-   * Attaches a session in its own scope, closing any previous attachment of the same ID. The scope follows the
-   * cwd's catalog and pushes config option and command updates while it is open.
-   */
-  readonly attach: (
-    session: SessionInfo,
-    cwd: string,
-    mcpServers: readonly McpServer[],
-  ) => Effect.Effect<Attached, ACPError.Error | RequestError | ACPCatalog.Error>
-  /** Closes the session scope. No-op when the session is not attached. */
-  readonly detach: (sessionID: string) => Effect.Effect<void>
-  readonly require: (sessionID: string) => Effect.Effect<Attached, ACPError.SessionNotFoundError>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/cli/acp/Sessions") {}
-
-export const make = Effect.fnUntraced(function* (input: {
-  readonly client: OpenCodeClient
-  readonly connection: ACPConnection.Interface
-  readonly catalog: ACPCatalog.Interface
-}) {
-  const scope = yield* Effect.scope
-  const sessions = new Map<string, { readonly attached: Attached; readonly scope: Scope.Closeable }>()
-  // Kept across re-attachment so resuming with the same servers does not add them again.
-  const registeredMcp = new Map<string, Set<string>>()
-
-  const sendCommands = (sessionID: string, catalog: Catalog) =>
-    input.connection.sessionUpdate({
-      sessionId: sessionID,
-      update: {
-        sessionUpdate: "available_commands_update",
-        availableCommands: [
-          ...catalog.commands
-            .filter((command) => !builtinCommands.has(command.name))
-            .map((command) => ({ name: command.name, description: command.description ?? "" })),
-          ...Array.from(builtinCommands, ([name, command]) => ({ name, description: command.description })),
-        ],
-      },
-    })
-
-  const changed = Effect.fnUntraced(function* (attached: Attached, previous: Catalog, next: Catalog) {
-    const selection = yield* Ref.get(attached.selection)
-    const options = configOptions(next, selection)
-    if (!isDeepStrictEqual(options, configOptions(previous, selection))) {
-      yield* input.connection.sessionUpdate({
-        sessionId: attached.id,
-        update: { sessionUpdate: "config_option_update", configOptions: options },
-      })
-    }
-    if (!isDeepStrictEqual(next.commands, previous.commands)) yield* sendCommands(attached.id, next)
-  })
-
-  const registerMcp = (attached: Attached, servers: readonly McpServer[]) =>
-    Effect.suspend(() => {
-      const registered = registeredMcp.get(attached.id) ?? new Set<string>()
-      registeredMcp.set(attached.id, registered)
-      return Effect.forEach(
-        servers,
-        (server) =>
-          Effect.suspend(() => {
-            const config = mcpConfig(server)
-            const key = `${server.name}:${stableStringify(config)}`
-            if (registered.has(key)) return Effect.void
-            registered.add(key)
-            return ACPError.promise(() =>
-              input.client.mcp.add({ server: server.name, location: { directory: attached.cwd }, config }),
-            ).pipe(
-              // An interrupted add still completes on the server, so only a failed one is forgotten.
-              Effect.tapCause((cause) =>
-                Cause.hasInterruptsOnly(cause) ? Effect.void : Effect.sync(() => registered.delete(key)),
-              ),
-            )
-          }),
-        { concurrency: "unbounded", discard: true },
-      )
-    })
-
-  return Service.of({
-    attach: Effect.fn("cli.acp.sessions.attach")(function* (session, cwd, mcpServers) {
-      const current = yield* input.catalog.get(cwd)
-      const abort = new AbortController()
-      const attached: Attached = {
-        id: session.id,
-        cwd,
-        selection: yield* Ref.make<Selection>({ model: session.model, modeID: session.agent }),
-        signal: abort.signal,
-      }
-      // Swap synchronously so concurrent attaches of one ID cannot both keep a scope.
-      const sessionScope = Scope.forkUnsafe(scope)
-      const replaced = sessions.get(session.id)
-      sessions.set(session.id, { attached, scope: sessionScope })
-      if (replaced) yield* Scope.close(replaced.scope, Exit.void)
-      yield* Scope.addFinalizer(
-        sessionScope,
-        Effect.sync(() => abort.abort()),
-      )
-      yield* input.catalog.changes(cwd).pipe(
-        Stream.runFoldEffect(
-          () => current,
-          (previous, next) =>
-            next === previous
-              ? Effect.succeed(previous)
-              : changed(attached, previous, next).pipe(Effect.ignore, Effect.as(next)),
-        ),
-        Effect.ignore,
-        Effect.forkIn(sessionScope),
-      )
-      yield* registerMcp(attached, mcpServers)
-      yield* sendCommands(attached.id, yield* input.catalog.get(cwd))
-      return attached
-    }),
-    detach: Effect.fn("cli.acp.sessions.detach")(function* (sessionID) {
-      const entry = sessions.get(sessionID)
-      sessions.delete(sessionID)
-      registeredMcp.delete(sessionID)
-      if (entry) yield* Scope.close(entry.scope, Exit.void)
-    }),
-    require: Effect.fn("cli.acp.sessions.require")(function* (sessionID) {
-      const entry = sessions.get(sessionID)
-      if (!entry) return yield* new ACPError.SessionNotFoundError({ sessionId: sessionID })
-      return entry.attached
-    }),
-  })
-})
-
-export function currentModel(catalog: Catalog, selection: Selection) {
-  return selection.model ?? catalog.defaultModel
-}
-
-export function configOptions(catalog: Catalog, selection: Selection) {
-  const model = currentModel(catalog, selection)
-  return buildConfigOptions({
-    providers: catalog.providers,
-    currentModel: { providerID: model.providerID, modelID: model.id },
-    currentVariant: model.variant,
-    modes: catalog.modes,
-    currentModeId: selection.modeID ?? catalog.defaultModeID,
-  })
-}
-
-function mcpConfig(server: McpServer) {
-  if ("type" in server) {
-    if (server.type === "acp") throw new Error("MCP-over-ACP is not supported")
-    return {
-      type: "remote" as const,
-      url: server.url,
-      headers: Object.fromEntries(server.headers.map((header) => [header.name, header.value])),
-      oauth: false as const,
-    }
-  }
-  return {
-    type: "local" as const,
-    command: [server.command, ...server.args],
-    environment: Object.fromEntries(server.env.map((entry) => [entry.name, entry.value])),
-  }
-}
-
-function stableStringify(value: unknown): string {
-  if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`
-  if (!value || typeof value !== "object") return JSON.stringify(value)
-  return `{${Object.entries(value)
-    .toSorted(([a], [b]) => a.localeCompare(b))
-    .map(([key, item]) => `${JSON.stringify(key)}:${stableStringify(item)}`)
-    .join(",")}}`
-}
-
-export * as ACPSessions from "./sessions"

packages/cli/src/acp/tool.ts

@@ -1,8 +1,6 @@
 import { isAbsolute, resolve } from "node:path"
 import type { ToolCall, ToolCallContent, ToolCallLocation, ToolCallUpdate, ToolKind } from "@agentclientprotocol/sdk"
 import { readDisplayText } from "@opencode/tui/mini/tool"
-import { Patch } from "@opencode/util/patch"
-import { Result } from "effect"
 
 export type ToolInput = Record<string, unknown>
 export type ToolContent = ReadonlyArray<
@@ -38,29 +36,28 @@ export function toToolKind(toolName: string): ToolKind {
   }
 }
 
-export function toLocations(toolName: string, input: ToolInput, cwd: string): ToolCallLocation[] {
+export function toLocations(toolName: string, input: ToolInput, cwd?: string): ToolCallLocation[] {
   switch (toolName.toLocaleLowerCase()) {
     case "bash":
-    case "shell":
-      return locationFrom(cwd, stringValue(input.workdir) ?? stringValue(input.cwd) ?? cwd)
+    case "shell": {
+      const workdir = shellWorkdir(input, cwd)
+      return workdir ? [{ path: workdir }] : []
+    }
     case "read":
+      return locationFrom(input.path)
     case "edit":
     case "write":
-      return locationFrom(cwd, filePath(input))
     case "patch":
     case "apply_patch":
-      return locationFrom(
-        cwd,
-        ...patchHunks(input).flatMap((hunk) => [hunk.path, hunk.type === "update" ? hunk.movePath : undefined]),
-      )
+      return locationFrom(input.filePath ?? input.filepath)
     case "external_directory":
-      return locationFrom(cwd, input.filepath)
+      return locationFrom(input.filePath ?? input.filepath, input.parentDir, input.directories)
     case "grep":
     case "glob":
     case "context":
     case "context7_resolve_library_id":
     case "context7_get_library_docs":
-      return locationFrom(cwd, input.path)
+      return locationFrom(input.path)
     default:
       return []
   }
@@ -70,7 +67,7 @@ export function pendingToolCall(input: {
   readonly toolCallId: string
   readonly toolName: string
   readonly state: { readonly input: ToolInput; readonly title?: string }
-  readonly cwd: string
+  readonly cwd?: string
 }): ToolCall {
   return {
     toolCallId: input.toolCallId,
@@ -87,7 +84,7 @@ export function runningToolUpdate(input: {
   readonly toolName: string
   readonly state: { readonly input: ToolInput; readonly title?: string }
   readonly content?: ToolContent
-  readonly cwd: string
+  readonly cwd?: string
 }): ToolCallUpdate {
   return {
     toolCallId: input.toolCallId,
@@ -106,7 +103,6 @@ export function completedToolUpdate(input: {
   readonly input: ToolInput
   readonly content: ToolContent
   readonly metadata?: Readonly<Record<string, unknown>>
-  readonly cwd: string
 }): ToolCallUpdate {
   const normalized = toolContent(input.content)
   // Read's model content is a JSON page envelope; show the clean text instead.
@@ -119,15 +115,20 @@ export function completedToolUpdate(input: {
       : [{ type: "content" as const, content: { type: "text" as const, text: read } }]
   const oldText = stringValue(input.input.oldString)
   const newText = stringValue(input.input.newString)
-  const path = filePath(input.input)
   const diff: ToolCallContent[] =
-    oldText === undefined || newText === undefined || path === undefined
+    oldText === undefined || newText === undefined
       ? []
-      : [{ type: "diff", path: absolutePath(path, input.cwd), oldText, newText }]
+      : [
+          {
+            type: "diff",
+            path: stringValue(input.input.path) ?? stringValue(input.input.filePath) ?? "",
+            oldText,
+            newText,
+          },
+        ]
   return {
     toolCallId: input.toolCallId,
     status: "completed",
-    locations: toLocations(input.toolName, input.input, input.cwd),
     content: [...primary, ...diff, ...images],
     rawOutput: {
       ...(input.metadata === undefined ? {} : { metadata: input.metadata }),
@@ -142,7 +143,7 @@ export function errorToolUpdate(input: {
   readonly content?: ToolContent
   readonly metadata?: Readonly<Record<string, unknown>>
   readonly error: string
-  readonly cwd: string
+  readonly cwd?: string
 }): ToolCallUpdate {
   return {
     toolCallId: input.toolCallId,
@@ -173,9 +174,16 @@ function toolTitle(toolName: string, input: ToolInput, fallback: string | undefi
   return fallback || toolName
 }
 
-function rawInput(toolName: string, input: ToolInput, cwd: string): ToolInput {
+function rawInput(toolName: string, input: ToolInput, cwd?: string): ToolInput {
   if (!isShell(toolName) || input.cwd || input.workdir) return input
-  return { ...input, cwd }
+  const workdir = shellWorkdir(input, cwd)
+  return workdir ? { ...input, cwd: workdir } : input
+}
+
+function shellWorkdir(input: ToolInput, cwd?: string) {
+  const explicit = stringValue(input.workdir) ?? stringValue(input.cwd)
+  if (!explicit) return cwd
+  return isAbsolute(explicit) ? explicit : resolve(cwd ?? process.cwd(), explicit)
 }
 
 function isShell(toolName: string) {
@@ -183,29 +191,20 @@ function isShell(toolName: string) {
   return tool === "bash" || tool === "shell"
 }
 
-function locationFrom(cwd: string, ...values: unknown[]): ToolCallLocation[] {
+function locationFrom(...values: unknown[]): ToolCallLocation[] {
   return Array.from(
-    new Set(values.flatMap((value) => (typeof value === "string" && value ? [absolutePath(value, cwd)] : []))),
+    new Set(
+      values.flatMap((value): string[] => {
+        if (Array.isArray(value))
+          return value.filter((item): item is string => typeof item === "string" && item.length > 0)
+        const path = stringValue(value)
+        return path ? [path] : []
+      }),
+    ),
     (path) => ({ path }),
   )
 }
 
-// Sessions migrated from V1 keep their original `filePath` tool inputs.
-export function filePath(input: ToolInput) {
-  return stringValue(input.path) ?? stringValue(input.filePath)
-}
-
-export function patchHunks(input: ToolInput) {
-  const patchText = stringValue(input.patchText)
-  if (!patchText) return []
-  const parsed = Patch.parse(patchText)
-  return Result.isSuccess(parsed) ? parsed.success : []
-}
-
-export function absolutePath(path: string, cwd: string) {
-  return isAbsolute(path) ? path : resolve(cwd, path)
-}
-
 export function stringValue(value: unknown) {
   return typeof value === "string" ? value : undefined
 }

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

@@ -1,128 +0,0 @@
-import { describe, expect } from "bun:test"
-import { OpenCode } from "@opencode/client/promise"
-import { Clock, Duration, Effect, Fiber } from "effect"
-import { TestClock } from "effect/testing"
-import { it } from "../../../core/test/lib/effect"
-import { ACPCatalog } from "../../src/acp/catalog"
-import { buildAgent, planAgent, startWire, testModel, type Wire, type WireOptions } from "./wire-fixture"
-
-describe("acp catalog service", () => {
-  it.effect("coalesces reloads requested during a reload into one more load", () => {
-    const gate = { held: false, release: Promise.withResolvers<void>() }
-    return withCatalog(
-      {
-        fetch: (request) =>
-          request.path === "/api/agent" && gate.held ? gate.release.promise.then(() => undefined) : undefined,
-      },
-      (acp) =>
-        Effect.gen(function* () {
-          const catalog = yield* ACPCatalog.Service
-          yield* catalog.get("/workspace")
-          gate.held = true
-
-          const running = yield* catalog.reload("/workspace").pipe(Effect.forkChild({ startImmediately: true }))
-          yield* Effect.promise(() => acp.until(() => requests(acp, "/api/agent") === 2, "the held reload"))
-          const queued = yield* Effect.all(
-            [0, 1].map(() => catalog.reload("/workspace").pipe(Effect.forkChild({ startImmediately: true }))),
-          )
-          acp.server.catalog.agents = [planAgent, buildAgent]
-          gate.held = false
-          gate.release.resolve()
-          yield* Fiber.join(running)
-          yield* Fiber.joinAll(queued)
-
-          expect(reads(acp, "agent")).toBe(3)
-          expect((yield* catalog.get("/workspace")).defaultModeID).toBe("plan")
-        }),
-    )
-  })
-
-  it.effect("keeps the previous catalog when a reload fails", () => {
-    const failing = { model: false }
-    return withCatalog(
-      {
-        fetch: (request) =>
-          failing.model && request.path === "/api/model"
-            ? Response.json({ name: "ModelsNotReadyError", data: { message: "catalog is warming" } }, { status: 503 })
-            : undefined,
-      },
-      () =>
-        Effect.gen(function* () {
-          const catalog = yield* ACPCatalog.Service
-          const before = yield* catalog.get("/workspace")
-          failing.model = true
-
-          yield* catalog.reload("/workspace")
-
-          expect(yield* catalog.get("/workspace")).toBe(before)
-        }),
-    )
-  })
-
-  it.effect("waits 25ms between readiness reads", () =>
-    withCatalog({}, (acp) =>
-      Effect.gen(function* () {
-        const catalog = yield* ACPCatalog.Service
-        acp.server.catalog.models = []
-
-        const loading = yield* catalog.get("/workspace").pipe(Effect.forkChild)
-        yield* Effect.promise(() => acp.until(() => reads(acp, "model") === 1, "the first model read"))
-        acp.server.catalog.models = [testModel]
-        yield* advance("5 millis", () => reads(acp, "model") === 2)
-        const retriedAt = yield* Clock.currentTimeMillis
-        const loaded = yield* Fiber.join(loading)
-
-        expect(retriedAt).toBeGreaterThanOrEqual(25)
-        expect(loaded.defaultModel).toEqual({ providerID: "test", id: "test-model", variant: "default" })
-      }),
-    ),
-  )
-
-  it.effect("gives up with the last readiness failure after 5 seconds", () =>
-    withCatalog({}, (acp) =>
-      Effect.gen(function* () {
-        const catalog = yield* ACPCatalog.Service
-        acp.server.catalog.agents = []
-
-        const loading = yield* catalog.get("/workspace").pipe(Effect.flip, Effect.timed, Effect.forkChild)
-        yield* advance("25 millis", () => loading.pollUnsafe() !== undefined)
-        const [elapsed, error] = yield* Fiber.join(loading)
-
-        expect(error).toEqual(new ACPCatalog.NotReadyError({ reason: "agents" }))
-        expect(error.message).toBe("No primary agents are available")
-        // Reads in flight while the clock steps push the last attempt slightly past the deadline.
-        expect(Duration.toMillis(elapsed)).toBeGreaterThanOrEqual(5_000)
-        expect(Duration.toMillis(elapsed)).toBeLessThan(6_000)
-      }),
-    ),
-  )
-})
-
-function withCatalog<A, E>(options: WireOptions, body: (acp: Wire) => Effect.Effect<A, E, ACPCatalog.Service>) {
-  return Effect.acquireRelease(
-    Effect.promise(() => startWire(options)),
-    (acp) => Effect.promise(() => acp[Symbol.asyncDispose]()),
-  ).pipe(
-    Effect.flatMap((acp) =>
-      body(acp).pipe(
-        Effect.provideServiceEffect(ACPCatalog.Service, ACPCatalog.make(OpenCode.make({ baseUrl: acp.server.url }))),
-      ),
-    ),
-  )
-}
-
-// Catalog reads are real HTTP that settles between sleeps, so the clock moves in steps until the reads catch up.
-function advance(step: Duration.Input, done: () => boolean) {
-  return TestClock.adjust(step).pipe(
-    Effect.andThen(TestClock.withLive(Effect.sleep("1 millis"))),
-    Effect.repeat({ until: done }),
-  )
-}
-
-function reads(acp: Wire, kind: "model" | "agent") {
-  return acp.server.catalogReads.filter((read) => read.kind === kind).length
-}
-
-function requests(acp: Wire, path: string) {
-  return acp.server.requests.filter((request) => request.path === path).length
-}

packages/cli/test/acp/catalog.test.ts

@@ -37,7 +37,7 @@ describe("acp catalog and config options over the wire", () => {
       [other.sessionId]: "/other",
     })
     await acp.until(() => acp.updates.filter((item) => commandNames(item)).length === 3, "commands for each session")
-    expect(acp.updates.map(commandNames)).toEqual(Array.from({ length: 3 }, () => ["review", "compact"]))
+    expect(acp.updates.map(commandNames)).toEqual([["review"], ["review"], ["review"]])
   })
 
   test("follows server defaults and refreshes the catalog when location plugins finish activating", async () => {
@@ -57,28 +57,14 @@ describe("acp catalog and config options over the wire", () => {
       currentValue: "copilot-build",
       options: ["copilot-build", "build", "plan"],
     })
-    const commands = await acp.waitForUpdate((item) => commandNames(item)?.length === 3)
-    expect(commandNames(commands)).toEqual(["review", "ship", "compact"])
+    const commands = await acp.waitForUpdate((item) => commandNames(item)?.length === 2)
+    expect(commandNames(commands)).toEqual(["review", "ship"])
     expect(agentReads(acp)).toBe(reads + 1)
 
     const second = await acp.newSession()
     expect(currentValue(second, "mode")).toBe("copilot-build")
   })
 
-  test("defaults the mode to the first selectable agent the server lists", async () => {
-    const configured = { ...buildAgent, id: "review", name: "Review", mode: "all" as const }
-    await using acp = await startWire()
-    acp.server.catalog.agents = [configured, buildAgent, planAgent]
-    await acp.initialize()
-
-    const session = await acp.newSession()
-
-    expect(modeOption(session.configOptions ?? [])).toEqual({
-      currentValue: "review",
-      options: ["review", "build", "plan"],
-    })
-  })
-
   test("pushes config options on model.updated and commands on command.updated", async () => {
     await using acp = await startWire()
     acp.server.catalog.models = [testModel]
@@ -95,7 +81,7 @@ describe("acp catalog and config options over the wire", () => {
 
     acp.server.catalog.commands = [reviewCommand, { name: "ship", description: "Ship it" }]
     acp.server.send(ephemeralEvent("command.updated", {}, { directory: "/workspace" }))
-    const commands = await acp.waitForUpdate((item) => commandNames(item)?.length === 3)
+    const commands = await acp.waitForUpdate((item) => commandNames(item)?.length === 2)
     expect(commands).toEqual({
       sessionId: session.sessionId,
       update: {
@@ -103,7 +89,6 @@ describe("acp catalog and config options over the wire", () => {
         availableCommands: [
           { name: "review", description: "Review changes" },
           { name: "ship", description: "Ship it" },
-          { name: "compact", description: "Compact the session" },
         ],
       },
     })
@@ -136,86 +121,6 @@ describe("acp catalog and config options over the wire", () => {
     expect(agentReads(acp)).toBeGreaterThan(reads)
   })
 
-  test("reloads the catalog once for an unseen model and selects it", async () => {
-    await using acp = await startWire()
-    acp.server.catalog.models = [testModel]
-    await acp.initialize()
-    const session = await acp.newSession()
-    acp.server.catalog.models = [testModel, secondModel]
-    const set = (value: string) =>
-      acp.request("session/set_config_option", { sessionId: session.sessionId, configId: "model", value })
-    const reads = modelReads(acp)
-
-    const selected = await set("test/second-model")
-    expect(modelReads(acp)).toBe(reads + 1)
-    expect(await rpcError(set("test/missing-model"))).toMatchObject({ code: -32602 })
-
-    expect(currentValue(selected, "model")).toBe("test/second-model")
-    expect(modelReads(acp)).toBe(reads + 2)
-    expect(acp.server.selections).toEqual([
-      { sessionID: session.sessionId, model: { providerID: "test", id: secondModel.id } },
-    ])
-  })
-
-  test("stops catalog updates for a closed session while other sessions in the cwd keep them", async () => {
-    await using acp = await startWire()
-    acp.server.catalog.models = [testModel]
-    await acp.initialize()
-    const closed = await acp.newSession()
-    const open = await acp.newSession()
-    await acp.request("session/close", { sessionId: closed.sessionId })
-    const since = acp.updates.length
-
-    await change(acp, open.sessionId, "config_option_update", () => {
-      acp.server.catalog.models = [testModel, secondModel]
-      acp.server.send(ephemeralEvent("model.updated", {}))
-    })
-    await change(acp, open.sessionId, "available_commands_update", () => {
-      acp.server.catalog.commands = [reviewCommand, { name: "ship", description: "Ship it" }]
-      acp.server.send(ephemeralEvent("command.updated", {}, { directory: "/workspace" }))
-    })
-    await change(acp, open.sessionId, "config_option_update", () => {
-      acp.server.catalog.agents = [buildAgent]
-      acp.server.send(ephemeralEvent("agent.updated", {}, { directory: "/workspace" }))
-    })
-
-    expect(updateKinds(acp, since)).toEqual([
-      [open.sessionId, "config_option_update"],
-      [open.sessionId, "available_commands_update"],
-      [open.sessionId, "config_option_update"],
-    ])
-  })
-
-  test.each(["session/load", "session/resume"] as const)(
-    "pushes one update per catalog change after %s re-attaches a session",
-    async (method) => {
-      await using acp = await startSession()
-      const params = { cwd: "/workspace", sessionId: acp.sessionId, mcpServers: [] }
-      await acp.request(method, params)
-      await acp.request(method, params)
-      const since = acp.updates.length
-
-      await change(acp, acp.sessionId, "config_option_update", () => {
-        acp.server.catalog.models = [testModel]
-        acp.server.send(ephemeralEvent("model.updated", {}))
-      })
-      await change(acp, acp.sessionId, "available_commands_update", () => {
-        acp.server.catalog.commands = [reviewCommand, { name: "ship", description: "Ship it" }]
-        acp.server.send(ephemeralEvent("command.updated", {}, { directory: "/workspace" }))
-      })
-      await change(acp, acp.sessionId, "config_option_update", () => {
-        acp.server.catalog.agents = [buildAgent]
-        acp.server.send(ephemeralEvent("agent.updated", {}, { directory: "/workspace" }))
-      })
-
-      expect(updateKinds(acp, since)).toEqual([
-        [acp.sessionId, "config_option_update"],
-        [acp.sessionId, "available_commands_update"],
-        [acp.sessionId, "config_option_update"],
-      ])
-    },
-  )
-
   test.each(["empty", "missing the default"])(
     "retries when the model list is %s but the default is ready",
     async (initial) => {
@@ -288,43 +193,16 @@ describe("acp catalog and config options over the wire", () => {
     })
   })
 
-  test("advertises and runs the built-in compact over a server command (https://github.com/anomalyco/opencode/issues/37229)", async () => {
-    await using acp = await startSession()
-    const advertised = await acp.waitForUpdate((item) => commandNames(item) !== undefined)
+  test.todo(
+    "advertises the built-in compact command (https://github.com/anomalyco/opencode/issues/37229)",
+    async () => {
+      await using acp = await startSession()
 
-    acp.server.catalog.commands = [reviewCommand, { name: "compact", description: "Server compact" }]
-    acp.server.send(ephemeralEvent("command.updated", {}, { directory: "/workspace" }))
-    const replaced = await acp.waitForUpdate((item) => item !== advertised && commandNames(item) !== undefined)
-    const compacted = await acp.prompt(acp.sessionId, "/compact")
-
-    expect([advertised, replaced].map((item) => item.update)).toEqual(
-      Array.from({ length: 2 }, () => ({
-        sessionUpdate: "available_commands_update",
-        availableCommands: [
-          { name: "review", description: "Review changes" },
-          { name: "compact", description: "Compact the session" },
-        ],
-      })),
-    )
-    expect(compacted.stopReason).toBe("end_turn")
-    expect(acp.server.submissions.map((item) => item.kind)).toEqual(["compact"])
-  })
-})
-
-// Each change waits on a catalog reload over HTTP, so a stray update for an earlier change lands before the next one.
-async function change(acp: Wire, sessionId: string, kind: string, trigger: () => void) {
-  const seen = acp.updates.filter((item) => item.sessionId === sessionId && item.update.sessionUpdate === kind).length
-  trigger()
-  await acp.until(
-    () =>
-      acp.updates.filter((item) => item.sessionId === sessionId && item.update.sessionUpdate === kind).length > seen,
-    kind,
+      const commands = await acp.waitForUpdate((item) => commandNames(item) !== undefined)
+      expect(commandNames(commands)).toContain("compact")
+    },
   )
-}
-
-function updateKinds(acp: Wire, since: number) {
-  return acp.updates.slice(since).map((item) => [item.sessionId, item.update.sessionUpdate])
-}
+})
 
 function commandNames(item: SessionNotification) {
   if (item.update.sessionUpdate !== "available_commands_update") return undefined

packages/cli/test/acp/compaction.test.ts

@@ -1,271 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import type { SessionNotification } from "@agentclientprotocol/sdk"
-import { OpenCode, type OpenCodeEvent, type SessionMessageInfo } from "@opencode/client/promise"
-import { Event } from "@opencode/schema/event"
-import { SessionMessage } from "@opencode/schema/session-message"
-import { Schema } from "effect"
-import {
-  assistantMessage,
-  childCreated,
-  durableEvent,
-  ephemeralEvent,
-  makeSession,
-  startSession,
-  startWire,
-  stepEnded,
-  succeeded,
-  textDelta,
-  turn,
-} from "./wire-fixture"
-
-const summary = "Summary of the earlier conversation"
-const providerError = { type: "provider.error", message: "summary request failed", status: 500 }
-const decodeCompact = Schema.decodeUnknownSync(Schema.Struct({ id: Schema.String }))
-
-describe("acp compaction markers over the wire", () => {
-  test("marks a /compact turn without forwarding the summary text", async () => {
-    const compacted = await compactTurn((sessionID, id) => [
-      durableEvent("session.compaction.started", { sessionID, reason: "manual", recent: "", inputID: id }),
-      ephemeralEvent("session.compaction.delta", { sessionID, text: summary }),
-      durableEvent("session.compaction.ended", { sessionID, reason: "manual", text: summary, recent: "" }),
-    ])
-    await using acp = compacted.acp
-
-    expect(turnUpdates(acp.updates)).toEqual([
-      marker(acp.sessionId, { status: "started", messageId: compacted.id, reason: "manual" }),
-      marker(acp.sessionId, { status: "completed", messageId: compacted.id, reason: "manual" }),
-    ])
-    expect(compacted.response.stopReason).toBe("end_turn")
-  })
-
-  test("marks a failed /compact turn with the full compaction error", async () => {
-    const compacted = await compactTurn((sessionID, id) => [
-      durableEvent("session.compaction.started", { sessionID, reason: "manual", recent: "", inputID: id }),
-      durableEvent("session.compaction.failed", { sessionID, reason: "manual", inputID: id, error: providerError }),
-    ])
-    await using acp = compacted.acp
-
-    expect(turnUpdates(acp.updates)).toEqual([
-      marker(acp.sessionId, { status: "started", messageId: compacted.id, reason: "manual" }),
-      marker(acp.sessionId, { status: "failed", messageId: compacted.id, reason: "manual", error: providerError }),
-    ])
-    expect(compacted.response.stopReason).toBe("end_turn")
-  })
-
-  test("marks an automatic compaction between steps with the ID its replayed message gets", async () => {
-    await using acp = await startSession({
-      onPrompt: ({ sessionID, id }) =>
-        turn(
-          sessionID,
-          id,
-          textDelta(sessionID, "msg_before", "before"),
-          stepEnded(sessionID, "msg_before"),
-          durableEvent("session.compaction.started", { sessionID, reason: "auto", recent: "" }),
-          ephemeralEvent("session.compaction.delta", { sessionID, text: summary }),
-          durableEvent("session.compaction.ended", { sessionID, reason: "auto", text: summary, recent: "" }),
-          textDelta(sessionID, "msg_after", "after"),
-          stepEnded(sessionID, "msg_after"),
-        ),
-    })
-    using events = await watchEvents(acp.server.url)
-
-    const response = await acp.prompt(acp.sessionId, "hello")
-
-    const messageId = await events.messageID("session.compaction.started")
-    expect(turnUpdates(acp.updates)).toEqual([
-      chunk(acp.sessionId, "msg_before", "before"),
-      marker(acp.sessionId, { status: "started", messageId, reason: "auto" }),
-      marker(acp.sessionId, { status: "completed", messageId, reason: "auto" }),
-      chunk(acp.sessionId, "msg_after", "after"),
-    ])
-    expect(response.stopReason).toBe("end_turn")
-
-    const live = turnUpdates(acp.updates)
-    acp.server.messages.set(acp.sessionId, [
-      {
-        id: messageId,
-        type: "compaction",
-        status: "completed",
-        reason: "auto",
-        summary,
-        recent: "",
-        time: { created: 1 },
-      },
-    ])
-    await acp.request("session/load", { cwd: "/workspace", sessionId: acp.sessionId, mcpServers: [] })
-
-    expect(turnUpdates(acp.updates).slice(live.length)).toEqual([
-      marker(acp.sessionId, { status: "completed", messageId, reason: "auto" }),
-    ])
-  })
-
-  test("marks automatic compaction failures before and after the compaction starts", async () => {
-    await using acp = await startSession({
-      onPrompt: ({ sessionID, id }) =>
-        turn(
-          sessionID,
-          id,
-          durableEvent("session.compaction.failed", {
-            sessionID,
-            reason: "auto",
-            error: { type: "compaction.unavailable", message: "Nothing to compact yet" },
-          }),
-          durableEvent("session.compaction.started", { sessionID, reason: "auto", recent: "" }),
-          durableEvent("session.compaction.failed", { sessionID, reason: "auto", error: providerError }),
-        ),
-    })
-    using events = await watchEvents(acp.server.url)
-
-    await acp.prompt(acp.sessionId, "hello")
-
-    const unstarted = await events.messageID("session.compaction.failed")
-    const started = await events.messageID("session.compaction.started")
-    expect(turnUpdates(acp.updates)).toEqual([
-      marker(acp.sessionId, {
-        status: "failed",
-        messageId: unstarted,
-        reason: "auto",
-        error: { type: "compaction.unavailable", message: "Nothing to compact yet" },
-      }),
-      marker(acp.sessionId, { status: "started", messageId: started, reason: "auto" }),
-      marker(acp.sessionId, { status: "failed", messageId: started, reason: "auto", error: providerError }),
-    ])
-  })
-
-  test("projects child session compaction markers onto the parent turn", async () => {
-    await using acp = await startSession({
-      onPrompt: ({ sessionID, id }) =>
-        turn(
-          sessionID,
-          id,
-          childCreated("ses_child", sessionID, "Explore"),
-          durableEvent("session.compaction.started", { sessionID: "ses_child", reason: "auto", recent: "" }),
-          ephemeralEvent("session.compaction.delta", { sessionID: "ses_child", text: summary }),
-          durableEvent("session.compaction.ended", {
-            sessionID: "ses_child",
-            reason: "auto",
-            text: summary,
-            recent: "",
-          }),
-          succeeded("ses_child"),
-        ),
-    })
-    using events = await watchEvents(acp.server.url)
-
-    await acp.prompt(acp.sessionId, "hello")
-
-    const messageId = await events.messageID("session.compaction.started")
-    const child = { id: "ses_child", parentID: acp.sessionId, depth: 1, title: "Explore" }
-    expect(turnUpdates(acp.updates).map((item) => item.update._meta)).toEqual([
-      { "opencode/compaction": { status: "started", messageId, reason: "auto" }, "opencode/child-session": child },
-      { "opencode/compaction": { status: "completed", messageId, reason: "auto" }, "opencode/child-session": child },
-    ])
-  })
-
-  test("replays settled compactions at their position on session/load", async () => {
-    await using acp = await startWire()
-    acp.server.sessions.set("ses_compacted", makeSession("ses_compacted"))
-    acp.server.messages.set("ses_compacted", compactedHistory())
-    await acp.initialize()
-
-    await acp.request("session/load", { cwd: "/workspace", sessionId: "ses_compacted", mcpServers: [] })
-
-    expect(turnUpdates(acp.updates)).toEqual([
-      {
-        sessionId: "ses_compacted",
-        update: {
-          sessionUpdate: "user_message_chunk",
-          messageId: "msg_user",
-          content: { type: "text", text: "hello" },
-        },
-      },
-      marker("ses_compacted", {
-        status: "failed",
-        messageId: "msg_compaction_failed",
-        reason: "auto",
-        error: providerError,
-      }),
-      marker("ses_compacted", { status: "completed", messageId: "msg_compaction", reason: "manual" }),
-      chunk("ses_compacted", "msg_after", "after"),
-    ])
-  })
-})
-
-// Holds the compact response so the test can publish the turn's events while the request is in flight.
-async function compactTurn(events: (sessionID: string, id: string) => OpenCodeEvent[]) {
-  const held = Promise.withResolvers<Response>()
-  const acp = await startSession({ fetch: (request) => (request.path.endsWith("/compact") ? held.promise : undefined) })
-  const response = acp.prompt(acp.sessionId, "/compact")
-  const request = await acp.until(
-    () => acp.server.requests.find((item) => item.path.endsWith("/compact")),
-    "compact request",
-  )
-  const id = decodeCompact(request.body).id
-  acp.server.send(...turn(acp.sessionId, id, ...events(acp.sessionId, id)))
-  held.resolve(Response.json({ data: {} }))
-  return { acp, id, response: await response }
-}
-
-// Core derives an automatic compaction's message ID from the event ID the server stamps on publish.
-async function watchEvents(url: string) {
-  const controller = new AbortController()
-  const stream = OpenCode.make({ baseUrl: url }).event.subscribe({ signal: controller.signal })[Symbol.asyncIterator]()
-  await stream.next()
-  return {
-    async messageID(type: OpenCodeEvent["type"]) {
-      while (true) {
-        const next = await stream.next()
-        if (next.done) throw new Error(`event stream ended before ${type}`)
-        if (next.value.type === type) return SessionMessage.ID.fromEvent(Event.ID.make(next.value.id))
-      }
-    },
-    [Symbol.dispose]: () => controller.abort(),
-  }
-}
-
-function marker(sessionId: string, value: Record<string, unknown>): SessionNotification {
-  return { sessionId, update: { sessionUpdate: "session_info_update", _meta: { "opencode/compaction": value } } }
-}
-
-function chunk(sessionId: string, messageId: string, text: string): SessionNotification {
-  return { sessionId, update: { sessionUpdate: "agent_message_chunk", messageId, content: { type: "text", text } } }
-}
-
-function turnUpdates(updates: readonly SessionNotification[]) {
-  return updates.filter(
-    (item) => item.update.sessionUpdate !== "available_commands_update" && item.update.sessionUpdate !== "usage_update",
-  )
-}
-
-function compactedHistory(): SessionMessageInfo[] {
-  return [
-    { id: "msg_user", type: "user", text: "hello", time: { created: 1 } },
-    {
-      id: "msg_compaction_failed",
-      type: "compaction",
-      status: "failed",
-      reason: "auto",
-      error: providerError,
-      time: { created: 2 },
-    },
-    {
-      id: "msg_compaction",
-      type: "compaction",
-      status: "completed",
-      reason: "manual",
-      summary,
-      recent: "",
-      time: { created: 3 },
-    },
-    {
-      id: "msg_compaction_running",
-      type: "compaction",
-      status: "running",
-      reason: "auto",
-      summary: "",
-      recent: "",
-      time: { created: 4 },
-    },
-    assistantMessage("msg_after", { time: { created: 5, completed: 6 }, content: [{ type: "text", text: "after" }] }),
-  ]
-}

packages/cli/test/acp/permission.test.ts

@@ -89,7 +89,12 @@ describe("acp permissions over the wire", () => {
           id,
           permissionAsked(sessionID, "perm_external", {
             action: "external_directory",
-            metadata: { filepath: "/tmp/outside/a.ts", parentDir: "/tmp/outside" },
+            metadata: {
+              command: "mkdir -p /tmp/outside",
+              description: "Create external directory",
+              directories: ["/tmp/outside"],
+              patterns: ["/tmp/outside/*"],
+            },
           }),
         ),
       permission: allowOnce,
@@ -98,9 +103,14 @@ describe("acp permissions over the wire", () => {
     await acp.prompt(acp.sessionId, "hello")
 
     expect(acp.permissions[0]?.toolCall).toMatchObject({
-      title: "/tmp/outside",
-      locations: [{ path: "/tmp/outside/a.ts" }],
-      rawInput: { filepath: "/tmp/outside/a.ts", parentDir: "/tmp/outside" },
+      title: "Create external directory",
+      locations: [{ path: "/tmp/outside" }],
+      rawInput: {
+        command: "mkdir -p /tmp/outside",
+        description: "Create external directory",
+        directories: ["/tmp/outside"],
+        patterns: ["/tmp/outside/*"],
+      },
     })
   })
 
@@ -253,8 +263,8 @@ describe("acp permissions over the wire", () => {
   })
 })
 
-describe("acp edit previews over the wire", () => {
-  test("previews edits during approval", async () => {
+describe("acp edit previews and client file sync over the wire", () => {
+  test("previews edits during approval and syncs the completed file", async () => {
     await using dir = await tmpdir()
     const file = path.join(dir.path, "file.ts")
     await fs.writeFile(file, "before")
@@ -277,7 +287,7 @@ describe("acp edit previews over the wire", () => {
       },
       permission: allowOnce,
     })
-    await acp.initialize()
+    await acp.initialize({ writeTextFile: true })
     const session = await acp.newSession(dir.path)
 
     await acp.prompt(session.sessionId, "hello")
@@ -285,12 +295,13 @@ describe("acp edit previews over the wire", () => {
     expect(acp.permissions[0]?.toolCall).toMatchObject({
       title: "file.ts",
       kind: "edit",
-      locations: [{ path: file }],
-      content: [{ type: "diff", path: file, oldText: "before", newText: "after" }],
+      locations: [{ path: "file.ts" }],
+      content: [{ type: "diff", path: "file.ts", oldText: "before", newText: "after" }],
     })
+    expect(acp.writes).toEqual([{ sessionId: session.sessionId, path: file, content: "after" }])
   })
 
-  test("previews each file in a patch", async () => {
+  test("previews and syncs each file in a patch", async () => {
     await using dir = await tmpdir()
     await Promise.all([
       fs.writeFile(path.join(dir.path, "first.ts"), "one\n"),
@@ -330,7 +341,7 @@ describe("acp edit previews over the wire", () => {
       },
       permission: allowOnce,
     })
-    await acp.initialize()
+    await acp.initialize({ writeTextFile: true })
     const session = await acp.newSession(dir.path)
 
     await acp.prompt(session.sessionId, "hello")
@@ -338,96 +349,36 @@ describe("acp edit previews over the wire", () => {
     expect(acp.permissions[0]?.toolCall).toMatchObject({
       title: "2 files",
       kind: "edit",
-      locations: [{ path: path.join(dir.path, "first.ts") }, { path: path.join(dir.path, "second.ts") }],
+      locations: [{ path: "first.ts" }, { path: "second.ts" }],
       content: [
-        { type: "diff", path: path.join(dir.path, "first.ts"), oldText: "one\n", newText: "two\n" },
-        { type: "diff", path: path.join(dir.path, "second.ts"), oldText: "alpha\n", newText: "beta\n" },
+        { type: "diff", path: "first.ts", oldText: "one\n", newText: "two\n" },
+        { type: "diff", path: "second.ts", oldText: "alpha\n", newText: "beta\n" },
       ],
     })
-  })
-
-  test("reports the same absolute locations for a moved file in the permission and tool updates", async () => {
-    await using dir = await tmpdir()
-    await fs.writeFile(path.join(dir.path, "old.ts"), "one\n")
-    const patchText = [
-      "*** Begin Patch",
-      "*** Update File: old.ts",
-      "*** Move to: new.ts",
-      "@@",
-      "-one",
-      "+two",
-      "*** End Patch",
-    ].join("\n")
-    await using acp = await startWire({
-      onPrompt: ({ sessionID, id }) => [
-        delivered(sessionID, id),
-        toolStarted(sessionID, "call_move", "patch"),
-        toolCalled(sessionID, "call_move", { patchText }),
-        permissionAsked(sessionID, "perm_move", {
-          action: "edit",
-          source: { type: "tool", messageID: "msg_move", id: "call_move" },
-        }),
-      ],
-      onPermissionReply: ({ sessionID }) => [
-        toolSucceeded(sessionID, "call_move", {}, "patched"),
-        succeeded(sessionID),
-      ],
-      permission: allowOnce,
-    })
-    await acp.initialize()
-    const session = await acp.newSession(dir.path)
-
-    await acp.prompt(session.sessionId, "hello")
-
-    const locations = [{ path: path.join(dir.path, "old.ts") }, { path: path.join(dir.path, "new.ts") }]
-    expect(acp.permissions[0]?.toolCall).toMatchObject({
-      locations,
-      content: [{ type: "diff", path: path.join(dir.path, "new.ts"), oldText: "one\n", newText: "two\n" }],
-    })
-    expect(
-      acp.updates.flatMap((item) =>
-        item.update.sessionUpdate === "tool_call_update" && item.update.toolCallId === "call_move"
-          ? [[item.update.status, item.update.locations]]
-          : [],
-      ),
-    ).toEqual([
-      ["in_progress", locations],
-      ["completed", locations],
+    expect(acp.writes.toSorted((a, b) => a.path.localeCompare(b.path))).toEqual([
+      { sessionId: session.sessionId, path: path.join(dir.path, "first.ts"), content: "two\n" },
+      { sessionId: session.sessionId, path: path.join(dir.path, "second.ts"), content: "beta\n" },
     ])
   })
 
-  test("does not echo completed edits to a client that advertises writeTextFile", async () => {
+  test("does not sync edits when the client did not advertise writeTextFile", async () => {
     await using dir = await tmpdir()
-    const file = path.join(dir.path, "file.ts")
-    await fs.writeFile(file, "after")
+    await fs.writeFile(path.join(dir.path, "file.ts"), "after")
     await using acp = await startWire({
       onPrompt: ({ sessionID, id }) =>
         turn(
           sessionID,
           id,
           toolStarted(sessionID, "call_edit", "edit"),
-          toolCalled(sessionID, "call_edit", { filePath: file, oldString: "before", newString: "after" }),
-          toolSucceeded(sessionID, "call_edit", { files: [{ file }] }, "edited"),
+          toolCalled(sessionID, "call_edit", { filePath: path.join(dir.path, "file.ts") }),
+          toolSucceeded(sessionID, "call_edit", {}, "edited"),
         ),
     })
-    await acp.initialize({ writeTextFile: true })
+    await acp.initialize()
     const session = await acp.newSession(dir.path)
 
     expect(await acp.prompt(session.sessionId, "hello")).toMatchObject({ stopReason: "end_turn" })
     expect(acp.writes).toEqual([])
-    expect(
-      acp.updates.flatMap((item) =>
-        item.update.sessionUpdate === "tool_call_update" && item.update.status === "completed" ? [item.update] : [],
-      ),
-    ).toMatchObject([
-      {
-        toolCallId: "call_edit",
-        content: [
-          { type: "content", content: { type: "text", text: "edited" } },
-          { type: "diff", path: file, oldText: "before", newText: "after" },
-        ],
-      },
-    ])
   })
 })
 

packages/cli/test/acp/prompt.test.ts

@@ -2,7 +2,7 @@ import { describe, expect, test } from "bun:test"
 import type { StopReason } from "@agentclientprotocol/sdk"
 import type { OpenCodeEvent } from "@opencode/client/promise"
 import {
-  childCreated,
+  assistantMessage,
   delivered,
   durableEvent,
   failed,
@@ -32,6 +32,7 @@ describe("acp prompt turns over the wire", () => {
       onPrompt: ({ sessionID, id }) =>
         turn(sessionID, id, textDelta(sessionID, "msg_assistant", "hello"), stepEnded(sessionID, "msg_assistant")),
     })
+    acp.server.messages.set(acp.sessionId, [assistantMessage("msg_assistant")])
 
     const response = await acp.prompt(acp.sessionId, "hi")
 
@@ -113,6 +114,7 @@ describe("acp prompt turns over the wire", () => {
       value: "test/second-model",
     })
     acp.server.sessions.set(acp.sessionId, makeSession(acp.sessionId, { cost: 3.5 }))
+    acp.server.messages.set(acp.sessionId, [assistantMessage("msg_assistant", { tokens: assistantTokens })])
 
     const response = await acp.prompt(acp.sessionId, "hello")
 
@@ -143,6 +145,7 @@ describe("acp prompt turns over the wire", () => {
         return turn(sessionID, id, stepEnded(sessionID, "msg_assistant"))
       },
     })
+    acp.server.messages.set(acp.sessionId, [assistantMessage("msg_assistant")])
 
     expect((await acp.prompt(acp.sessionId, "hello")).stopReason).toBe("end_turn")
   })
@@ -188,20 +191,14 @@ describe("acp prompt turns over the wire", () => {
     expect(await rpcError(acp.prompt(acp.sessionId, "hello"))).toMatchObject({ code: -32000 })
   })
 
-  test("maps an assistant step auth error to auth required", async () => {
+  test("maps an assistant message auth error to auth required", async () => {
     await using acp = await startSession({
       onPrompt: ({ sessionID, id }) =>
-        turn(
-          sessionID,
-          id,
-          textDelta(sessionID, "msg_auth", "partial"),
-          durableEvent("session.step.failed", {
-            sessionID,
-            assistantMessageID: "msg_auth",
-            error: { type: "provider.auth", message: "expired" },
-          }),
-        ),
+        turn(sessionID, id, textDelta(sessionID, "msg_auth", "partial"), stepEnded(sessionID, "msg_auth")),
     })
+    acp.server.messages.set(acp.sessionId, [
+      assistantMessage("msg_auth", { error: { type: "provider.auth", message: "expired" } }),
+    ])
 
     expect(await rpcError(acp.prompt(acp.sessionId, "hello"))).toMatchObject({ code: -32000 })
   })
@@ -356,110 +353,27 @@ describe("acp prompt turns over the wire", () => {
     expect((await first).stopReason).toBe("cancelled")
   })
 
-  test("reports usage summed across every step of the turn", async () => {
-    await using acp = await startSession({
-      onPrompt: ({ sessionID, id }) =>
-        turn(
-          sessionID,
-          id,
-          stepEnded(sessionID, "msg_step_1", { finish: "tool-calls", tokens: { ...tokens(), input: 10, output: 5 } }),
-          stepEnded(sessionID, "msg_step_2", { tokens: { ...tokens(), input: 20, output: 7 } }),
-        ),
-    })
-
-    const response = await acp.prompt(acp.sessionId, "hello")
-
-    expect(response.usage).toEqual({ inputTokens: 30, outputTokens: 12, totalTokens: 42 })
-  })
-
-  test("publishes the last step's context usage rather than the turn sum", async () => {
-    await using acp = await startSession({
-      onPrompt: ({ sessionID, id }) =>
-        turn(
-          sessionID,
-          id,
-          stepEnded(sessionID, "msg_step_1", {
-            finish: "tool-calls",
-            tokens: { input: 100, output: 10, reasoning: 0, cache: { read: 0, write: 50 } },
-          }),
-          stepEnded(sessionID, "msg_step_2", {
-            tokens: { input: 20, output: 5, reasoning: 3, cache: { read: 150, write: 0 } },
-          }),
-        ),
-    })
-
-    const response = await acp.prompt(acp.sessionId, "hello")
-
-    expect(response.usage).toEqual({
-      inputTokens: 120,
-      outputTokens: 15,
-      thoughtTokens: 3,
-      cachedReadTokens: 150,
-      cachedWriteTokens: 50,
-      totalTokens: 338,
-    })
-    expect(await acp.waitForUpdate((item) => item.update.sessionUpdate === "usage_update")).toEqual({
-      sessionId: acp.sessionId,
-      update: { sessionUpdate: "usage_update", used: 178, size: 100_000, cost: { amount: 0, currency: "USD" } },
-    })
-  })
-
-  test("counts a failed step's tokens and clears its error when the next step starts", async () => {
-    await using acp = await startSession({
-      onPrompt: ({ sessionID, id }) =>
-        turn(
-          sessionID,
-          id,
-          durableEvent("session.step.failed", {
+  test.todo(
+    "reports usage summed across every step of the turn (https://github.com/anomalyco/opencode/issues/41660)",
+    async () => {
+      await using acp = await startSession({
+        onPrompt: ({ sessionID, id }) =>
+          turn(
             sessionID,
-            assistantMessageID: "msg_1",
-            error: { type: "provider.stream", message: "stream interrupted" },
-            cost: 0,
-            tokens: { ...tokens(), input: 40, output: 4 },
-          }),
-          durableEvent("session.step.started", {
-            sessionID,
-            assistantMessageID: "msg_2",
-            agent: "build",
-            model: { providerID: "test", id: "test-model" },
-            started: 0,
-          }),
-          stepEnded(sessionID, "msg_2", { tokens: { ...tokens(), input: 20, output: 7 } }),
-        ),
-    })
+            id,
+            stepEnded(sessionID, "msg_step_1", { finish: "tool-calls", tokens: { ...tokens(), input: 10, output: 5 } }),
+            stepEnded(sessionID, "msg_step_2", { tokens: { ...tokens(), input: 20, output: 7 } }),
+          ),
+      })
+      acp.server.messages.set(acp.sessionId, [
+        assistantMessage("msg_step_2", { tokens: { ...tokens(), input: 20, output: 7 } }),
+      ])
 
-    const response = await acp.prompt(acp.sessionId, "hello")
+      const response = await acp.prompt(acp.sessionId, "hello")
 
-    expect(response).toEqual({
-      stopReason: "end_turn",
-      usage: { inputTokens: 60, outputTokens: 11, totalTokens: 71 },
-      _meta: {},
-    })
-    expect(await acp.waitForUpdate((item) => item.update.sessionUpdate === "usage_update")).toMatchObject({
-      update: { used: 27 },
-    })
-  })
-
-  test("excludes child session steps from the turn usage", async () => {
-    await using acp = await startSession({
-      onPrompt: ({ sessionID, id }) =>
-        turn(
-          sessionID,
-          id,
-          childCreated("ses_child", sessionID, "Explore"),
-          stepEnded("ses_child", "msg_child", { tokens: { ...tokens(), input: 500, output: 50 } }),
-          succeeded("ses_child"),
-          stepEnded(sessionID, "msg_root", { tokens: { ...tokens(), input: 20, output: 7 } }),
-        ),
-    })
-
-    const response = await acp.prompt(acp.sessionId, "hello")
-
-    expect(response.usage).toEqual({ inputTokens: 20, outputTokens: 7, totalTokens: 27 })
-    expect(await acp.waitForUpdate((item) => item.update.sessionUpdate === "usage_update")).toMatchObject({
-      update: { used: 27 },
-    })
-  })
+      expect(response.usage).toEqual({ inputTokens: 30, outputTokens: 12, totalTokens: 42 })
+    },
+  )
 })
 
 // The server answered admission before streaming the chunk, and this request round-trips through the server after it,

packages/cli/test/acp/session.test.ts

@@ -54,13 +54,7 @@ describe("acp session lifecycle over the wire", () => {
     ])
     expect(await acp.waitForUpdate((item) => item.update.sessionUpdate === "available_commands_update")).toEqual({
       sessionId: result.sessionId,
-      update: {
-        sessionUpdate: "available_commands_update",
-        availableCommands: [
-          { name: "review", description: "" },
-          { name: "compact", description: "Compact the session" },
-        ],
-      },
+      update: { sessionUpdate: "available_commands_update", availableCommands: [{ name: "review", description: "" }] },
     })
   })
 

packages/cli/test/acp/tool.test.ts

@@ -28,105 +28,22 @@ describe("acp tools", () => {
   })
 
   test("extracts file locations from tool input", () => {
-    expect(toLocations("read", { path: "/tmp/a.ts" }, "/workspace")).toEqual([{ path: "/tmp/a.ts" }])
-    expect(toLocations("edit", { path: "/tmp/b.ts", oldString: "a", newString: "b" }, "/workspace")).toEqual([
-      { path: "/tmp/b.ts" },
+    expect(toLocations("read", { path: "/tmp/a.ts" })).toEqual([{ path: "/tmp/a.ts" }])
+    expect(toLocations("edit", { filePath: "/tmp/b.ts" })).toEqual([{ path: "/tmp/b.ts" }])
+    expect(toLocations("write", { filePath: "/tmp/c.ts" })).toEqual([{ path: "/tmp/c.ts" }])
+    expect(toLocations("grep", { path: "/repo/src" })).toEqual([{ path: "/repo/src" }])
+    expect(toLocations("glob", { path: "/repo/test" })).toEqual([{ path: "/repo/test" }])
+    expect(toLocations("context7_get_library_docs", { path: "/docs" })).toEqual([{ path: "/docs" }])
+    expect(toLocations("external_directory", { directories: ["/tmp/outside"], patterns: ["/tmp/outside/*"] })).toEqual([
+      { path: "/tmp/outside" },
     ])
-    expect(toLocations("write", { path: "/tmp/c.ts", content: "c" }, "/workspace")).toEqual([{ path: "/tmp/c.ts" }])
-    expect(toLocations("read", { filePath: "/tmp/v1.ts" }, "/workspace")).toEqual([{ path: "/tmp/v1.ts" }])
-    expect(toLocations("edit", { path: "src/b.ts" }, "/workspace")).toEqual([
-      { path: resolve("/workspace", "src/b.ts") },
-    ])
-    expect(toLocations("grep", { path: "/repo/src" }, "/workspace")).toEqual([{ path: "/repo/src" }])
-    expect(toLocations("glob", { path: "/repo/test" }, "/workspace")).toEqual([{ path: "/repo/test" }])
-    expect(toLocations("grep", { pattern: "x", path: "src" }, "/workspace")).toEqual([
-      { path: resolve("/workspace", "src") },
-    ])
-    expect(toLocations("glob", { pattern: "*.ts" }, "/workspace")).toEqual([])
-    expect(toLocations("context7_get_library_docs", { path: "/docs" }, "/workspace")).toEqual([{ path: "/docs" }])
-    expect(
-      toLocations("external_directory", { filepath: "/tmp/outside/a.ts", parentDir: "/tmp/outside" }, "/workspace"),
-    ).toEqual([{ path: "/tmp/outside/a.ts" }])
     expect(toLocations("bash", { cmd: "pwd" }, "/workspace")).toEqual([{ path: "/workspace" }])
     expect(toLocations("bash", { command: "pwd", workdir: "subdir" }, "/workspace")).toEqual([
       { path: resolve("/workspace", "subdir") },
     ])
     expect(toLocations("bash", { command: "pwd", workdir: "/abs/dir" }, "/workspace")).toEqual([{ path: "/abs/dir" }])
-    expect(toLocations("read", { path: "/tmp/missing-file-path.ts" }, "/workspace")).toEqual([
-      { path: "/tmp/missing-file-path.ts" },
-    ])
-  })
-
-  test("extracts patch locations from every hunk in the patch body", () => {
-    const patchText = [
-      "*** Begin Patch",
-      "*** Add File: src/new.ts",
-      "+created",
-      "*** Update File: /abs/old.ts",
-      "*** Move to: src/moved.ts",
-      "@@",
-      "-one",
-      "+two",
-      "*** Update File: src/same.ts",
-      "@@",
-      "-a",
-      "+b",
-      "*** Delete File: src/gone.ts",
-      "*** Update File: src/new.ts",
-      "@@",
-      "-created",
-      "+changed",
-      "*** End Patch",
-    ].join("\n")
-
-    expect(toLocations("patch", { patchText }, "/workspace")).toEqual([
-      { path: resolve("/workspace", "src/new.ts") },
-      { path: "/abs/old.ts" },
-      { path: resolve("/workspace", "src/moved.ts") },
-      { path: resolve("/workspace", "src/same.ts") },
-      { path: resolve("/workspace", "src/gone.ts") },
-    ])
-    expect(toLocations("apply_patch", { patchText }, "/workspace")).toHaveLength(5)
-  })
-
-  test("returns no patch locations when the patch body cannot be parsed", () => {
-    expect(toLocations("patch", { patchText: "*** Update File: src/a.ts\n-a\n+b" }, "/workspace")).toEqual([])
-    expect(toLocations("patch", { patchText: "*** Begin Patch\nnot a hunk\n*** End Patch" }, "/workspace")).toEqual([])
-    expect(toLocations("patch", {}, "/workspace")).toEqual([])
-  })
-
-  test("reports resolved locations on completed and failed updates", () => {
-    const patchText = ["*** Begin Patch", "*** Add File: src/a.ts", "+a", "*** End Patch"].join("\n")
-    expect(
-      completedToolUpdate({
-        toolCallId: "call",
-        toolName: "patch",
-        input: { patchText },
-        content: [{ type: "text", text: "patched" }],
-        cwd: "/workspace",
-      }).locations,
-    ).toEqual([{ path: resolve("/workspace", "src/a.ts") }])
-    expect(
-      completedToolUpdate({
-        toolCallId: "call",
-        toolName: "edit",
-        input: { path: "src/b.ts", oldString: "before", newString: "after" },
-        content: [],
-        cwd: "/workspace",
-      }),
-    ).toMatchObject({
-      locations: [{ path: resolve("/workspace", "src/b.ts") }],
-      content: [{ type: "diff", path: resolve("/workspace", "src/b.ts"), oldText: "before", newText: "after" }],
-    })
-    expect(
-      errorToolUpdate({
-        toolCallId: "call",
-        toolName: "write",
-        input: { path: "src/c.ts", content: "c" },
-        error: "denied",
-        cwd: "/workspace",
-      }).locations,
-    ).toEqual([{ path: resolve("/workspace", "src/c.ts") }])
+    expect(toLocations("bash", { command: "printf hello" })).toEqual([])
+    expect(toLocations("read", { path: "/tmp/missing-file-path.ts" })).toEqual([{ path: "/tmp/missing-file-path.ts" }])
   })
 
   test("builds completed content with text and image attachments", () => {
@@ -135,10 +52,9 @@ describe("acp tools", () => {
     expect(
       completedToolUpdate({
         toolCallId: "tool-1",
-        cwd: "/workspace",
         toolName: "edit",
         input: {
-          path: "/tmp/file.ts",
+          filePath: "/tmp/file.ts",
           oldString: "before",
           newString: "after",
         },
@@ -171,10 +87,9 @@ describe("acp tools", () => {
     expect(
       completedToolUpdate({
         toolCallId: "tool-1",
-        cwd: "/workspace",
         toolName: "write",
         input: {
-          path: "/tmp/file.ts",
+          filePath: "/tmp/file.ts",
           content: "created",
         },
         content: [{ type: "text", text: "wrote /tmp/file.ts" }],
@@ -192,7 +107,6 @@ describe("acp tools", () => {
     expect(
       completedToolUpdate({
         toolCallId: "tool-read",
-        cwd: "/workspace",
         toolName: "read",
         input: { path: "/tmp/file.ts" },
         content: [
@@ -211,7 +125,6 @@ describe("acp tools", () => {
     expect(
       completedToolUpdate({
         toolCallId: "tool-list",
-        cwd: "/workspace",
         toolName: "read",
         input: { path: "/tmp" },
         content: [
@@ -233,11 +146,10 @@ describe("acp tools", () => {
     expect(
       pendingToolCall({
         toolCallId: "tool-1",
-        cwd: "/workspace",
         toolName: "edit",
         state: {
           input: {
-            path: "/tmp/file.ts",
+            filePath: "/tmp/file.ts",
             oldString: "before",
             newString: "after",
           },
@@ -249,7 +161,7 @@ describe("acp tools", () => {
       kind: "edit",
       locations: [{ path: "/tmp/file.ts" }],
       rawInput: {
-        path: "/tmp/file.ts",
+        filePath: "/tmp/file.ts",
         oldString: "before",
         newString: "after",
       },
@@ -258,10 +170,9 @@ describe("acp tools", () => {
     expect(
       completedToolUpdate({
         toolCallId: "tool-1",
-        cwd: "/workspace",
         toolName: "edit",
         input: {
-          path: "/tmp/file.ts",
+          filePath: "/tmp/file.ts",
           oldString: "before",
           newString: "after",
         },
@@ -271,7 +182,6 @@ describe("acp tools", () => {
     ).toEqual({
       toolCallId: "tool-1",
       status: "completed",
-      locations: [{ path: "/tmp/file.ts" }],
       content: [
         {
           type: "content",
@@ -294,7 +204,6 @@ describe("acp tools", () => {
     expect(
       runningToolUpdate({
         toolCallId: "call",
-        cwd: "/workspace",
         toolName: "read",
         state: { input: { path: "/tmp/a" } },
         content: [{ type: "text", text: "done" }],
@@ -320,7 +229,6 @@ describe("acp tools", () => {
     expect(
       completedToolUpdate({
         toolCallId: "call",
-        cwd: "/workspace",
         toolName: "read",
         input: {},
         content: [],
@@ -333,7 +241,6 @@ describe("acp tools", () => {
     expect(
       completedToolUpdate({
         toolCallId: "call",
-        cwd: "/workspace",
         toolName: "read",
         input: {},
         content: [],
@@ -345,7 +252,6 @@ describe("acp tools", () => {
     expect(
       completedToolUpdate({
         toolCallId: "call",
-        cwd: "/workspace",
         toolName: "read",
         input: {},
         content: [
@@ -367,7 +273,6 @@ describe("acp tools", () => {
     expect(
       errorToolUpdate({
         toolCallId: "call",
-        cwd: "/workspace",
         toolName: "read",
         input: { path: "/tmp/a" },
         content: [{ type: "text", text: "partial output" }],

packages/cli/test/acp/turn.test.ts

@@ -317,50 +317,53 @@ describe("acp turn events over the wire", () => {
     expect(acp.server.cancelledForms).toEqual([{ sessionID: acp.sessionId, formID: "frm_question" }])
   })
 
-  test("reports locations for native edit, write, and patch tools (https://github.com/anomalyco/opencode/issues/49591)", async () => {
-    const patchText = [
-      "*** Begin Patch",
-      "*** Update File: /workspace/src/c.ts",
-      "@@",
-      "-one",
-      "+two",
-      "*** End Patch",
-    ].join("\n")
-    await using acp = await startSession({
-      onPrompt: ({ sessionID, id }) =>
-        turn(
-          sessionID,
-          id,
-          toolStarted(sessionID, "call_edit", "edit"),
-          toolCalled(sessionID, "call_edit", { path: "/workspace/src/a.ts", oldString: "a", newString: "b" }),
-          toolSucceeded(sessionID, "call_edit", {}, "edited"),
-          toolStarted(sessionID, "call_write", "write"),
-          toolCalled(sessionID, "call_write", { path: "/workspace/src/b.ts", content: "b" }),
-          toolSucceeded(sessionID, "call_write", {}, "written"),
-          toolStarted(sessionID, "call_patch", "patch"),
-          toolCalled(sessionID, "call_patch", { patchText }),
-          toolSucceeded(sessionID, "call_patch", {}, "patched"),
-        ),
-    })
+  test.todo(
+    "reports locations for native edit, write, and patch tools (https://github.com/anomalyco/opencode/issues/49591)",
+    async () => {
+      const patchText = [
+        "*** Begin Patch",
+        "*** Update File: /workspace/src/c.ts",
+        "@@",
+        "-one",
+        "+two",
+        "*** End Patch",
+      ].join("\n")
+      await using acp = await startSession({
+        onPrompt: ({ sessionID, id }) =>
+          turn(
+            sessionID,
+            id,
+            toolStarted(sessionID, "call_edit", "edit"),
+            toolCalled(sessionID, "call_edit", { path: "/workspace/src/a.ts", oldString: "a", newString: "b" }),
+            toolSucceeded(sessionID, "call_edit", {}, "edited"),
+            toolStarted(sessionID, "call_write", "write"),
+            toolCalled(sessionID, "call_write", { path: "/workspace/src/b.ts", content: "b" }),
+            toolSucceeded(sessionID, "call_write", {}, "written"),
+            toolStarted(sessionID, "call_patch", "patch"),
+            toolCalled(sessionID, "call_patch", { patchText }),
+            toolSucceeded(sessionID, "call_patch", {}, "patched"),
+          ),
+      })
 
-    await acp.prompt(acp.sessionId, "hello")
+      await acp.prompt(acp.sessionId, "hello")
 
-    const locations = turnUpdates(acp.updates)
-      .filter((item) => item.update.sessionUpdate === "tool_call_update")
-      .map((item) => [
-        toolCallID(item),
-        toolStatus(item),
-        "locations" in item.update ? item.update.locations : undefined,
+      const locations = turnUpdates(acp.updates)
+        .filter((item) => item.update.sessionUpdate === "tool_call_update")
+        .map((item) => [
+          toolCallID(item),
+          toolStatus(item),
+          "locations" in item.update ? item.update.locations : undefined,
+        ])
+      expect(locations).toEqual([
+        ["call_edit", "in_progress", [{ path: "/workspace/src/a.ts" }]],
+        ["call_edit", "completed", [{ path: "/workspace/src/a.ts" }]],
+        ["call_write", "in_progress", [{ path: "/workspace/src/b.ts" }]],
+        ["call_write", "completed", [{ path: "/workspace/src/b.ts" }]],
+        ["call_patch", "in_progress", [{ path: "/workspace/src/c.ts" }]],
+        ["call_patch", "completed", [{ path: "/workspace/src/c.ts" }]],
       ])
-    expect(locations).toEqual([
-      ["call_edit", "in_progress", [{ path: "/workspace/src/a.ts" }]],
-      ["call_edit", "completed", [{ path: "/workspace/src/a.ts" }]],
-      ["call_write", "in_progress", [{ path: "/workspace/src/b.ts" }]],
-      ["call_write", "completed", [{ path: "/workspace/src/b.ts" }]],
-      ["call_patch", "in_progress", [{ path: "/workspace/src/c.ts" }]],
-      ["call_patch", "completed", [{ path: "/workspace/src/c.ts" }]],
-    ])
-  })
+    },
+  )
 })
 
 function turnUpdates(updates: readonly SessionNotification[]) {

packages/cli/test/acp/wire-fixture.ts

@@ -28,7 +28,7 @@ import {
   type TokenUsageInfo,
 } from "@opencode/client/promise"
 import type { BunRequest } from "bun"
-import { Effect, Exit, Logger, Option, Schema, Scope } from "effect"
+import { Effect, Logger, Option, Schema } from "effect"
 import { ACP } from "../../src/acp/agent"
 
 type DurableEvent = Extract<OpenCodeEvent, { durable: unknown }>
@@ -378,15 +378,11 @@ export async function startWire(options: WireOptions = {}) {
   const clientToAgent = new TransformStream<Uint8Array, Uint8Array>()
   const agentToClient = new TransformStream<Uint8Array, Uint8Array>()
   const logs: Array<Pick<Logger.Options<unknown>, "message" | "cause">> = []
-  const agentScope = Scope.makeUnsafe()
   const agentConnection = await Effect.runPromise(
     ACP.connect(
       OpenCode.make({ baseUrl: server.url }),
       ndJsonStream(agentToClient.writable, clientToAgent.readable),
-    ).pipe(
-      Scope.provide(agentScope),
-      Effect.provide(Logger.layer([Logger.make((log) => logs.push({ message: log.message, cause: log.cause }))])),
-    ),
+    ).pipe(Effect.provide(Logger.layer([Logger.make((log) => logs.push({ message: log.message, cause: log.cause }))]))),
   )
   const clientStream = ndJsonStream(clientToAgent.writable, agentToClient.readable)
   const connection = client({ name: "test" })
@@ -486,7 +482,6 @@ export async function startWire(options: WireOptions = {}) {
     async [Symbol.asyncDispose]() {
       connection.close()
       agentConnection.close()
-      await Effect.runPromise(Scope.close(agentScope, Exit.void))
       await server.stop()
     },
   }

packages/client/src/effect/api/api.ts

@@ -76,6 +76,10 @@ export type AgentListInput = { readonly location?: { readonly directory?: string
 export type AgentListOutput = { readonly location: Location.PublicRef; readonly data: ReadonlyArray<Agent.Info> }
 export type AgentListOperation<E = never> = (input?: AgentListInput) => Effect.Effect<AgentListOutput, E>
 
+export type AgentDefaultInput = { readonly location?: { readonly directory?: string | undefined } | undefined }
+export type AgentDefaultOutput = { readonly location: Location.PublicRef; readonly data: Agent.Info | undefined }
+export type AgentDefaultOperation<E = never> = (input?: AgentDefaultInput) => Effect.Effect<AgentDefaultOutput, E>
+
 export type AgentGetInput = {
   readonly agentID: Agent.ID
   readonly location?: { readonly directory?: string | undefined } | undefined
@@ -85,6 +89,7 @@ export type AgentGetOperation<E = never> = (input: AgentGetInput) => Effect.Effe
 
 export interface AgentApi<E = never> {
   readonly list: AgentListOperation<E>
+  readonly default: AgentDefaultOperation<E>
   readonly get: AgentGetOperation<E>
 }
 

packages/client/src/effect/generated/client.ts

@@ -14,6 +14,8 @@ import type {
   LocationReloadOutput,
   AgentListInput,
   AgentListOutput,
+  AgentDefaultInput,
+  AgentDefaultOutput,
   AgentGetInput,
   AgentGetOutput,
   PluginListInput,
@@ -319,6 +321,11 @@ const EndpointAgentList = (raw: RawClient["server.agent"]) => (input?: AgentList
     raw["agent.list"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError)),
   )
 
+const EndpointAgentDefault = (raw: RawClient["server.agent"]) => (input?: AgentDefaultInput) =>
+  preserveEffect<AgentDefaultOutput>()(
+    raw["agent.default"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError)),
+  )
+
 const EndpointAgentGet = (raw: RawClient["server.agent"]) => (input: AgentGetInput) =>
   preserveEffect<AgentGetOutput>()(
     raw["agent.get"]({ params: { agentID: input["agentID"] }, query: { location: input["location"] } }).pipe(
@@ -328,6 +335,7 @@ const EndpointAgentGet = (raw: RawClient["server.agent"]) => (input: AgentGetInp
 
 const adaptGroupAgent = (raw: RawClient["server.agent"]) => ({
   list: EndpointAgentList(raw),
+  default: EndpointAgentDefault(raw),
   get: EndpointAgentGet(raw),
 })
 

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

@@ -8,6 +8,8 @@ import type {
   LocationReloadOutput,
   AgentListInput,
   AgentListOutput,
+  AgentDefaultInput,
+  AgentDefaultOutput,
   AgentGetInput,
   AgentGetOutput,
   PluginListInput,
@@ -477,6 +479,18 @@ export function make(options: ClientOptions) {
           },
           requestOptions,
         ),
+      default: (input?: AgentDefaultInput, requestOptions?: RequestOptions) =>
+        request<AgentDefaultOutput>(
+          {
+            method: "GET",
+            path: `/api/agent/default`,
+            query: { location: input?.["location"] },
+            successStatus: 200,
+            declaredStatuses: [400, 401],
+            empty: false,
+          },
+          requestOptions,
+        ),
       get: (input: AgentGetInput, requestOptions?: RequestOptions) =>
         request<AgentGetOutput>(
           {

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

@@ -2759,6 +2759,12 @@ export type AgentListInput = {
 
 export type AgentListOutput = { location: LocationPublicRef; data: Array<AgentInfo> }
 
+export type AgentDefaultInput = {
+  readonly location?: { readonly location?: { readonly directory?: string | undefined } | undefined }["location"]
+}
+
+export type AgentDefaultOutput = { location: LocationPublicRef; data: AgentInfo | null }
+
 export type AgentGetInput = {
   readonly agentID: { readonly agentID: string }["agentID"]
   readonly location?: { readonly location?: { readonly directory?: string | undefined } | undefined }["location"]

packages/core/src/agent.ts

@@ -46,6 +46,7 @@ export interface Interface extends State.Transformable<Editor> {
   readonly get: (id: ID) => Effect.Effect<Info | undefined>
   readonly resolve: (id?: ID | string) => Effect.Effect<Info | undefined>
   readonly select: (id?: ID | string) => Effect.Effect<Selection>
+  readonly default: () => Effect.Effect<Info | undefined>
   readonly list: () => Effect.Effect<Info[]>
 }
 
@@ -121,6 +122,9 @@ const layer = Layer.effect(
         const info = selectedDefault()
         return { id: info?.id ?? defaultID, info }
       }),
+      default: Effect.fn("Agent.default")(function* () {
+        return selectedDefault()
+      }),
       list: Effect.fn("Agent.list")(function* () {
         const agents = Array.fromIterable(state.get().agents.values())
         const selected = selectedDefault()

packages/core/src/models-dev/snapshot.txt

@@ -1 +1 @@
-{"deepinfra":{"id":"deepinfra","env":["DEEPINFRA_API_KEY"],"npm":"@ai-sdk/deepinfra","name":"Deep Infra","doc":"https://deepinfra.com/models","models":{"tencent/Hy3":{"id":"tencent/Hy3","name":"Hy3","description":"Tencent Hy reasoning model for coding, instruction following, and agent tasks","family":"Hy","attachment":false,"reasoning":true,"reasoning_options":[],"tool_call":true,"structured_output":true,"temperature":true,"release_date":"2026-07-06","last_updated":"2026-07-06","modalities":{"input":["text"],"output":["text"]},"open_weights":true,"limit":{"context":262144,"input":192000,"output":128000},"cost":{"input":0.13,"output":0.53,"cache_read":0.033},"canonical_model_id":"tencent/hy3"},"tencent/Hy4-preview":{"id":"tencent/Hy4-preview","name":"Hy4 preview","description":"A next-generation productivity model with significantly enhanced Agent and complex task execution capabilities.","family":"Hy","attachment":false,"reasoning":true,"reasoning_options":[{"type":"effort","values":["none","high"]}],"tool_call":true,"structured_output":true,"temperature":true,"release_date":"2026-08-28","last_updated":"2026-08-28","modalities":{"input":["text"],"output":["text"]},"open_weights":true,"limit":{"context":1048576,"output":64000},"cost":{"input":0.834,"output":2.501,"cache_read":0.042},"canonical_model_id":"tencent/hy4-preview"},"meta-llama/Llama-3.3-70B-Instruct-Turbo":{"id":"meta-llama/Llama-3.3-70B-Instruct-Turbo","name":"Llama 3.3 70B Turbo","description":"Compact Llama instruction model for fast chat and local deployment","family":"llama","attachment":false,"reasoning":false,"tool_call":true,"structured_output":true,"release_date":"2024-12-06","last_updated":"2024-12-06","modalities":{"input":["text"],"output":["text"]},"open_weights":true,"limit":{"context":131072,"output":16384},"cost":{"input":0.1,"output":0.32}},"meta-llama/Llama-4-Scout-17B-16E-Instruct":{"id":"meta-llama/Llama-4-Scout-17B-16E-Instruct","name":"Llama 4 Scout 17B","description":"Open multimodal Llama model for long-context analysis and efficient agents","family":"llama","attachment":true,"reasoning":false,"tool_call":true,"structured_output":true,"release_date":"2025-04-05","last_updated":"2025-04-05","modalities":{"input":["text","image"],"output":["text"]},"open_weights":true,"limit":{"context":327680,"output":16384},"cost":{"input":0.1,"output":0.3}},"meta-llama/Llama-4-Maverick-17B-128E-Instruct-FP8":{"id":"meta-llama/Llama-4-Maverick-17B-128E-Instruct-FP8","name":"Llama 4 Maverick 17B FP8","description":"Open multimodal Llama model for strong reasoning and fast responses","family":"llama","attachment":true,"reasoning":false,"tool_call":false,"structured_output":true,"release_date":"2025-04-05","last_updated":"2025-04-05","modalities":{"input":["text","image"],"output":["text"]},"open_weights":true,"limit":{"context":1048576,"output":16384},"cost":{"input":0.2,"output":0.8}},"XiaomiMiMo/MiMo-V2.6-Pro":{"id":"XiaomiMiMo/MiMo-V2.6-Pro","name":"MiMo-V2.6-Pro","description":"Stronger MiMo Pro tier for multimodal reasoning and coding-agent execution","family":"mimo","attachment":true,"reasoning":true,"reasoning_options":[{"type":"toggle"}],"tool_call":true,"structured_output":true,"temperature":true,"release_date":"2026-09-22","last_updated":"2026-09-22","modalities":{"input":["text","image","audio","video"],"output":["text"]},"open_weights":true,"limit":{"context":1048576,"output":131072},"cost":{"input":0.43,"output":0.87,"cache_read":0.0036},"canonical_model_id":"xiaomi/mimo-v2.6-pro"},"XiaomiMiMo/MiMo-V2.5-Pro":{"id":"XiaomiMiMo/MiMo-V2.5-Pro","name":"MiMo-V2.5-Pro","description":"Stronger MiMo Pro tier for multimodal reasoning and coding-agent execution","family":"mimo","attachment":true,"reasoning":true,"reasoning_options":[{"type":"toggle"}],"tool_call":true,"interleaved":{"field":"reasoning_content"},"structured_output":true,"temperature":true,"knowledge":"2024-12","release_date":"2026-04-22","last_updated":"2026-04-22","modalities":{"input":["text","audio"],"output":["text"]},"open_weights":true,"limit":{"context":1048576,"output":16384},"status":"deprecated","cost":{"input":1,"output":3,"cache_read":0.2},"canonical_model_id":"xiaomi/mimo-v2.5-pro"},"XiaomiMiMo/MiMo-V2.6-Flash":{"id":"XiaomiMiMo/MiMo-V2.6-Flash","name":"MiMo-V2.6-Flash","description":"MiMo Flash model for multimodal coding agents and long-context automation","family":"mimo","attachment":true,"reasoning":true,"reasoning_options":[{"type":"toggle"}],"tool_call":true,"structured_output":true,"temperature":true,"release_date":"2026-09-22","last_updated":"2026-09-22","modalities":{"input":["text","image","audio","video"],"output":["text"]},"open_weights":true,"limit":{"context":1048576,"output":131072},"cost":{"input":0.14,"output":0.28,"cache_read":0.0028},"canonical_model_id":"xiaomi/mimo-v2.6-flash"},"XiaomiMiMo/MiMo-V2.5":{"id":"XiaomiMiMo/MiMo-V2.5","name":"MiMo-V2.5","description":"Open MiMo model for multimodal coding agents and long-context automation","famLine truncated
+{"deepinfra":{"id":"deepinfra","env":["DEEPINFRA_API_KEY"],"npm":"@ai-sdk/deepinfra","name":"Deep Infra","doc":"https://deepinfra.com/models","models":{"tencent/Hy3":{"id":"tencent/Hy3","name":"Hy3","description":"Tencent Hy reasoning model for coding, instruction following, and agent tasks","family":"Hy","attachment":false,"reasoning":true,"reasoning_options":[],"tool_call":true,"structured_output":true,"temperature":true,"release_date":"2026-07-06","last_updated":"2026-07-06","modalities":{"input":["text"],"output":["text"]},"open_weights":true,"limit":{"context":262144,"input":192000,"output":128000},"cost":{"input":0.13,"output":0.53,"cache_read":0.033},"canonical_model_id":"tencent/hy3"},"tencent/Hy4-preview":{"id":"tencent/Hy4-preview","name":"Hy4 preview","description":"A next-generation productivity model with significantly enhanced Agent and complex task execution capabilities.","family":"Hy","attachment":false,"reasoning":true,"reasoning_options":[{"type":"effort","values":["none","high"]}],"tool_call":true,"structured_output":true,"temperature":true,"release_date":"2026-08-28","last_updated":"2026-08-28","modalities":{"input":["text"],"output":["text"]},"open_weights":true,"limit":{"context":1048576,"output":64000},"cost":{"input":0.834,"output":2.501,"cache_read":0.042},"canonical_model_id":"tencent/hy4-preview"},"meta-llama/Llama-3.3-70B-Instruct-Turbo":{"id":"meta-llama/Llama-3.3-70B-Instruct-Turbo","name":"Llama 3.3 70B Turbo","description":"Compact Llama instruction model for fast chat and local deployment","family":"llama","attachment":false,"reasoning":false,"tool_call":true,"structured_output":true,"release_date":"2024-12-06","last_updated":"2024-12-06","modalities":{"input":["text"],"output":["text"]},"open_weights":true,"limit":{"context":131072,"output":16384},"cost":{"input":0.1,"output":0.32}},"meta-llama/Llama-4-Scout-17B-16E-Instruct":{"id":"meta-llama/Llama-4-Scout-17B-16E-Instruct","name":"Llama 4 Scout 17B","description":"Open multimodal Llama model for long-context analysis and efficient agents","family":"llama","attachment":true,"reasoning":false,"tool_call":true,"structured_output":true,"release_date":"2025-04-05","last_updated":"2025-04-05","modalities":{"input":["text","image"],"output":["text"]},"open_weights":true,"limit":{"context":327680,"output":16384},"cost":{"input":0.1,"output":0.3}},"meta-llama/Llama-4-Maverick-17B-128E-Instruct-FP8":{"id":"meta-llama/Llama-4-Maverick-17B-128E-Instruct-FP8","name":"Llama 4 Maverick 17B FP8","description":"Open multimodal Llama model for strong reasoning and fast responses","family":"llama","attachment":true,"reasoning":false,"tool_call":false,"structured_output":true,"release_date":"2025-04-05","last_updated":"2025-04-05","modalities":{"input":["text","image"],"output":["text"]},"open_weights":true,"limit":{"context":1048576,"output":16384},"cost":{"input":0.2,"output":0.8}},"XiaomiMiMo/MiMo-V2.6-Pro":{"id":"XiaomiMiMo/MiMo-V2.6-Pro","name":"MiMo-V2.6-Pro","description":"Stronger MiMo Pro tier for multimodal reasoning and coding-agent execution","family":"mimo","attachment":true,"reasoning":true,"reasoning_options":[{"type":"toggle"}],"tool_call":true,"structured_output":true,"temperature":true,"release_date":"2026-09-22","last_updated":"2026-09-22","modalities":{"input":["text","image","audio","video"],"output":["text"]},"open_weights":true,"limit":{"context":1048576,"output":131072},"cost":{"input":0.43,"output":0.87,"cache_read":0.0036},"canonical_model_id":"xiaomi/mimo-v2.6-pro"},"XiaomiMiMo/MiMo-V2.5-Pro":{"id":"XiaomiMiMo/MiMo-V2.5-Pro","name":"MiMo-V2.5-Pro","description":"Stronger MiMo Pro tier for multimodal reasoning and coding-agent execution","family":"mimo","attachment":true,"reasoning":true,"reasoning_options":[{"type":"toggle"}],"tool_call":true,"interleaved":{"field":"reasoning_content"},"structured_output":true,"temperature":true,"knowledge":"2024-12","release_date":"2026-04-22","last_updated":"2026-04-22","modalities":{"input":["text","audio"],"output":["text"]},"open_weights":true,"limit":{"context":1048576,"output":16384},"status":"deprecated","cost":{"input":1,"output":3,"cache_read":0.2},"canonical_model_id":"xiaomi/mimo-v2.5-pro"},"XiaomiMiMo/MiMo-V2.6-Flash":{"id":"XiaomiMiMo/MiMo-V2.6-Flash","name":"MiMo-V2.6-Flash","description":"MiMo Flash model for multimodal coding agents and long-context automation","family":"mimo","attachment":true,"reasoning":true,"reasoning_options":[{"type":"toggle"}],"tool_call":true,"structured_output":true,"temperature":true,"release_date":"2026-09-22","last_updated":"2026-09-22","modalities":{"input":["text","image","audio","video"],"output":["text"]},"open_weights":true,"limit":{"context":1048576,"output":131072},"cost":{"input":0.14,"output":0.28,"cache_read":0.0028},"canonical_model_id":"xiaomi/mimo-v2.6-flash"},"XiaomiMiMo/MiMo-V2.5":{"id":"XiaomiMiMo/MiMo-V2.5","name":"MiMo-V2.5","description":"Open MiMo model for multimodal coding agents and long-context automation","famLine truncated

packages/core/src/plugin/host.ts

@@ -96,20 +96,25 @@ export const make = Effect.fn("PluginHost.make")(function* (
   const decodeWorktree = Schema.decodeUnknownEffect(Worktree.Info)
   const decodeWorktrees = Schema.decodeUnknownEffect(Schema.Array(Worktree.ListEntry))
 
-  const listAgents = Effect.fn("PluginHost.listAgents")((ref: Location.Ref) =>
-    Effect.gen(function* () {
+  const atAgentLocation = <A>(
+    input: Parameters<typeof locationRef>[0],
+    use: (agents: Agent.Interface) => Effect.Effect<A>,
+  ) => {
+    const ref = locationRef(input)
+    if (!ref || isCurrentLocation(ref)) return response(use(agents))
+    return Effect.gen(function* () {
       const location = yield* Location.Service
-      const agents = yield* Agent.Service
+      const remote = yield* Agent.Service
       return {
         location: new Location.Info({
           directory: location.directory,
           workspaceID: location.workspaceID,
           project: location.project,
         }),
-        data: yield* agents.list(),
+        data: yield* use(remote),
       }
-    }).pipe(Effect.provide(locations.get(ref)), Effect.orDie),
-  )
+    }).pipe(Effect.provide(locations.get(ref)), Effect.orDie, Effect.withSpan("PluginHost.atAgentLocation"))
+  }
 
   // Keep the instance graph's inferred types independent of Session handles.
   const context: Plugin.Context = {
@@ -118,30 +123,16 @@ export const make = Effect.fn("PluginHost.make")(function* (
     options: {},
     rpc: Object.assign(rpc.client, { register: rpc.register }),
     agent: {
-      get: (input) => {
-        const ref = locationRef(input)
-        const output =
-          ref && !isCurrentLocation(ref)
-            ? listAgents(ref).pipe(
-                Effect.map((result) => ({
-                  ...result,
-                  data: result.data.find((agent) => agent.id === input.agentID),
-                })),
-              )
-            : response(agents.get(input.agentID))
-        return output.pipe(
+      get: (input) =>
+        atAgentLocation(input, (agents) => agents.get(input.agentID)).pipe(
           Effect.flatMap((result) =>
             result.data
               ? Effect.succeed({ ...result, data: result.data })
               : Effect.fail(new Error(`Agent not found: ${input.agentID}`)),
           ),
-        )
-      },
-      list: (input) => {
-        const ref = locationRef(input)
-        if (ref && !isCurrentLocation(ref)) return listAgents(ref)
-        return response(agents.list())
-      },
+        ),
+      list: (input) => atAgentLocation(input, (agents) => agents.list()),
+      default: (input) => atAgentLocation(input, (agents) => agents.default()),
       reload: agents.reload,
       transform: (callback) =>
         agents.transform((editor) => {

packages/core/test/agent.test.ts

@@ -87,6 +87,73 @@ describe("Agent", () => {
     }),
   )
 
+  it.effect("resolves the default agent the same way sessions select one", () =>
+    Effect.gen(function* () {
+      const agent = yield* Agent.Service
+      yield* agent.transform((editor) => {
+        editor.update(Agent.ID.make("plan"), (info) => {
+          info.mode = "primary"
+        })
+        editor.update(Agent.ID.make("build"), (info) => {
+          info.mode = "primary"
+        })
+        editor.update(Agent.ID.make("reviewer"), (info) => {
+          info.mode = "primary"
+        })
+        editor.update(Agent.ID.make("secret"), (info) => {
+          info.hidden = true
+        })
+        editor.update(Agent.ID.make("explore"), (info) => {
+          info.mode = "subagent"
+        })
+      })
+      const resolved = Effect.gen(function* () {
+        const info = yield* agent.default()
+        expect((yield* agent.select()).info).toEqual(info)
+        return info?.id
+      })
+
+      expect(yield* resolved).toBe(Agent.ID.make("build"))
+      yield* Effect.forEach(
+        [
+          ["reviewer", "reviewer"],
+          ["missing", "build"],
+          ["secret", "build"],
+          ["explore", "build"],
+        ] as const,
+        ([id, expected]) =>
+          Effect.gen(function* () {
+            yield* agent.transform((editor) => editor.default(Agent.ID.make(id)))
+            expect(yield* resolved).toBe(Agent.ID.make(expected))
+          }),
+      )
+    }),
+  )
+
+  it.effect("falls back to the first selectable agent without build", () =>
+    Effect.gen(function* () {
+      const agent = yield* Agent.Service
+      yield* agent.transform((editor) => {
+        editor.update(Agent.ID.make("explore"), (info) => {
+          info.mode = "subagent"
+        })
+        editor.update(Agent.ID.make("plan"), (info) => {
+          info.mode = "primary"
+        })
+      })
+
+      expect((yield* agent.default())?.id).toBe(Agent.ID.make("plan"))
+
+      yield* agent.transform((editor) =>
+        editor.update(Agent.ID.make("plan"), (info) => {
+          info.mode = "subagent"
+        }),
+      )
+      expect(yield* agent.default()).toBeUndefined()
+      expect(yield* agent.select()).toEqual({ id: Agent.defaultID, info: undefined })
+    }),
+  )
+
   it.effect("rebuilds state when a transform is replaced", () =>
     Effect.gen(function* () {
       const agent = yield* Agent.Service

packages/core/test/plugin/host.ts

@@ -39,6 +39,7 @@ export function host(overrides: Overrides = {}): Plugin.Context {
     agent: overrides.agent ?? {
       get: () => Effect.die("unused agent.get"),
       list: () => Effect.die("unused agent.list"),
+      default: () => Effect.die("unused agent.default"),
       transform: () => Effect.die("unused agent.transform"),
       reload: () => Effect.die("unused agent.reload"),
     },
@@ -204,6 +205,7 @@ export function agentHost(agent: Agent.Interface): Plugin.Context["agent"] {
         ),
       ),
     list: () => Effect.die("unused agent.list"),
+    default: () => Effect.die("unused agent.default"),
     reload: agent.reload,
     transform: (callback) =>
       agent.transform((editor) =>

packages/core/test/plugin/plan.test.ts

@@ -56,6 +56,7 @@ const run = Effect.fnUntraced(function* (events: ReadonlyArray<SessionEvent.Agen
       agent: {
         get: () => Effect.die("unused agent.get"),
         list: () => Effect.die("unused agent.list"),
+        default: () => Effect.die("unused agent.default"),
         reload: () => Effect.die("unused agent.reload"),
         transform: (callback) => {
           callback({

packages/plugin/src/promise/adapter.ts

@@ -295,6 +295,7 @@ export function fromPromise(plugin: Plugin) {
           agent: {
             get: adaptApiMethod(AgentEndpoints["agent.get"], host.agent.get),
             list: adaptApiMethod(AgentEndpoints["agent.list"], host.agent.list),
+            default: adaptApiMethod(AgentEndpoints["agent.default"], host.agent.default),
             transform: transform(host.agent),
             reload: () => run(host.agent.reload()),
           },

packages/protocol/src/groups/agent.ts

@@ -20,6 +20,21 @@ export const AgentGroup = HttpApiGroup.make("server.agent")
         }),
       ),
   )
+  .add(
+    HttpApiEndpoint.get("agent.default", "/api/agent/default", {
+      query: LocationQuery,
+      success: Location.response(Schema.UndefinedOr(Agent.Info)),
+    })
+      .annotateMerge(locationQueryOpenApi)
+      .annotateMerge(
+        OpenApi.annotations({
+          identifier: "agent.default",
+          summary: "Get default agent",
+          description:
+            "Retrieve the agent used when a session has no explicit agent selection. The result may precede initial plugin and config settlement.",
+        }),
+      ),
+  )
   .add(
     HttpApiEndpoint.get("agent.get", "/api/agent/:agentID", {
       params: { agentID: Agent.ID },

packages/server/src/handlers/agent.ts

@@ -12,6 +12,13 @@ export const AgentHandler = HttpApiBuilder.group(Api, "server.agent", (handlers)
         return yield* response(Agent.Service.use((agent) => agent.list()))
       }),
     )
+    .handle(
+      "agent.default",
+      Effect.fn(function* () {
+        const agents = yield* Agent.Service
+        return yield* response(agents.default())
+      }),
+    )
     .handle(
       "agent.get",
       Effect.fn(function* (ctx) {

packages/server/test/agent.test.ts

@@ -0,0 +1,50 @@
+import fs from "node:fs/promises"
+import path from "node:path"
+import { expect } from "bun:test"
+import { Agent } from "@opencode/schema/agent"
+import { Effect, Schedule, Schema } from "effect"
+import { tmpdir } from "../../core/test/fixture/tmpdir"
+import { it } from "../../core/test/lib/effect"
+import { startServer } from "./fixture/server"
+
+const DefaultResponse = Schema.Struct({
+  location: Schema.Struct({ directory: Schema.String }),
+  data: Schema.NullOr(Agent.Info),
+})
+
+it.live("returns the default agent for each location", () =>
+  Effect.gen(function* () {
+    const global = yield* Effect.acquireDisposable(Effect.promise(() => tmpdir("opencode-agent-default-global-")))
+    const configured = yield* Effect.acquireDisposable(Effect.promise(() => tmpdir("opencode-agent-default-")))
+    const unconfigured = yield* Effect.acquireDisposable(Effect.promise(() => tmpdir("opencode-agent-default-")))
+    yield* Effect.promise(() =>
+      fs.writeFile(
+        path.join(configured.path, "opencode.json"),
+        JSON.stringify({ default_agent: "reviewer", agents: { reviewer: { mode: "primary" } } }),
+      ),
+    )
+    const server = yield* startServer(global.path)
+
+    yield* Effect.forEach(
+      [
+        { directory: configured.path, expected: "reviewer" },
+        { directory: unconfigured.path, expected: "build" },
+      ],
+      (project) =>
+        Effect.gen(function* () {
+          const url = new URL("/api/agent/default", server.base)
+          url.searchParams.set("location[directory]", project.directory)
+          const response = yield* Effect.promise(() => fetch(url, { headers: server.headers }))
+          expect(response.status).toBe(200)
+          const body = Schema.decodeUnknownSync(DefaultResponse)(yield* Effect.promise(() => response.json()))
+          expect(body.location.directory).toBe(project.directory)
+          return body.data?.id
+        }).pipe(
+          // Agents register during plugin activation, after the location is served.
+          Effect.filterOrFail((id) => id === project.expected),
+          Effect.retry(Schedule.spaced("10 millis")),
+          Effect.timeout("2 seconds"),
+        ),
+    )
+  }),
+)

services/www/src/docs/content/build/plugins/effect.mdx

@@ -890,7 +890,7 @@ effect: (ctx) =>
         id: Skill.ID.make("review"),
         name: Skill.Name.make("Review"),
         description: "Review the current changes",
-        path: "/workspace/.opencode/skills/review/SKILL.md",
+        location: "/workspace/.opencode/skills/review.md",
         content: "Review the current changes for correctness and missing tests.",
       }))
       const review = editor.get("review")

services/www/src/docs/content/build/plugins/index.mdx

@@ -829,7 +829,7 @@ await ctx.skill.transform((editor) => {
     id: "review",
     name: "Review",
     description: "Review the current changes",
-    path: "/workspace/.opencode/skills/review/SKILL.md",
+    location: "/workspace/.opencode/skills/review.md",
     content: "Review the current changes for correctness and missing tests.",
   })
   const review = editor.get("review")