test(app): rename removed layout regression

bun.lock

@@ -395,7 +395,6 @@
         "ignore": "7.0.5",
         "immer": "11.1.4",
         "jsonc-parser": "3.3.1",
-        "mime-types": "3.0.2",
         "tree-sitter-bash": "0.25.0",
         "tree-sitter-powershell": "0.25.10",
         "turndown": "7.2.0",

packages/ai/src/providers/openai-compatible.ts

@@ -1,7 +1,6 @@
-import { HttpOptions, ProviderID, mergeHttpOptions, type ModelID } from "../schema"
+import { ProviderID, type ModelID } from "../schema"
 import * as OpenAICompatibleChat from "../protocols/openai-compatible-chat"
 import type { RouteDefaultsInput } from "../route/client"
-import { Auth } from "../route/auth"
 import { AuthOptions, type ProviderAuthOption } from "../route/auth-options"
 import type { ProviderPackage } from "../provider-package"
 import { profiles, type OpenAICompatibleProfile } from "./openai-compatible-profile"
@@ -20,8 +19,6 @@ export interface Settings extends ProviderPackage.Settings {
   readonly apiKey?: string
   readonly baseURL: string
   readonly provider?: string
-  readonly http?: RouteDefaultsInput["http"]
-  readonly providerOptions?: OpenAIProviderOptionsInput
 }
 
 export type FamilyModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
@@ -34,24 +31,16 @@ export const routes = [OpenAICompatibleChat.route]
 
 export const configure = (input: GenericModelOptions) => {
   const provider = input.provider ?? "openai-compatible"
-  const {
-    provider: _,
-    baseURL,
-    apiKey: _apiKey,
-    auth: _auth,
-    headers,
-    ...rest
-  } = input
+  const { provider: _, baseURL, apiKey: _apiKey, auth: _auth, ...rest } = input
   const route = OpenAICompatibleChat.route.with({
     ...rest,
     provider,
     endpoint: { baseURL },
-    auth: AuthOptions.bearer(input, []).andThen(Auth.headers(headers ?? {})),
+    auth: AuthOptions.bearer(input, []),
   })
   return {
     id: ProviderID.make(provider),
     model: (modelID: string | ModelID) =>
-      // oxlint-disable-next-line typescript-eslint/no-unnecessary-type-arguments -- preserves provider-option validation at call sites
       route.model<OpenAIProviderOptionsInput>({ id: modelID, provider: ProviderID.make(provider) }),
     configure,
   }
@@ -78,18 +67,14 @@ export const provider = {
   configure,
 }
 
-export const model: ProviderPackage.Definition<Settings>["model"] = (modelID, settings) =>
+export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (modelID, settings) =>
   configure({
     apiKey: settings.apiKey,
     baseURL: settings.baseURL,
     headers: settings.headers === undefined ? undefined : { ...settings.headers },
-    http: mergeHttpOptions(
-      settings.http === undefined ? undefined : HttpOptions.make(settings.http),
-      settings.body === undefined ? undefined : new HttpOptions({ body: { ...settings.body } }),
-    ),
+    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
     limits: settings.limits,
     provider: settings.provider,
-    providerOptions: settings.providerOptions,
   }).model(modelID)
 
 export const baseten = define(profiles.baseten)

packages/ai/test/provider-package.test.ts

@@ -111,22 +111,6 @@ describe("provider package entrypoints", () => {
     })
   })
 
-  test("maps OpenAI-compatible Chat settings onto the executable model", async () => {
-    const OpenAICompatible = await import("@opencode-ai/ai/providers/openai-compatible")
-    const selected = OpenAICompatible.model("custom-model", {
-      apiKey: "fixture",
-      baseURL: "https://chat.example.test/v1",
-      provider: "example",
-      http: { query: { tenant: "one" } },
-      providerOptions: { openai: { reasoningEffort: "high" } },
-    })
-
-    expect(String(selected.provider)).toBe("example")
-    expect(selected.route.id).toBe("openai-compatible-chat")
-    expect(selected.route.defaults.http?.query).toEqual({ tenant: "one" })
-    expect(selected.route.defaults.providerOptions).toEqual({ openai: { reasoningEffort: "high" } })
-  })
-
   test("maps Anthropic-compatible settings onto the executable model", async () => {
     const AnthropicCompatible = await import("@opencode-ai/ai/providers/anthropic-compatible")
     const selected = AnthropicCompatible.model("compatible-model", {

packages/ai/test/provider/openai-compatible-chat.test.ts

@@ -4,7 +4,6 @@ import { HttpClientRequest } from "effect/unstable/http"
 import { LLM, LLMRequest, Message, ToolCallPart, ToolChoice, ToolDefinition } from "../../src"
 import { Auth, LLMClient } from "../../src/route"
 import { compileRequest } from "../../src/route/client"
-import { jsonRequestParts } from "../../src/route/transport/http"
 import * as OpenAICompatible from "../../src/providers/openai-compatible"
 import * as OpenAICompatibleChat from "../../src/protocols/openai-compatible-chat"
 import { it } from "../lib/effect"
@@ -145,48 +144,6 @@ describe("OpenAI-compatible Chat route", () => {
     }),
   )
 
-  it.effect("preserves compatible provider URL, usage, options, and body extensions", () =>
-    Effect.gen(function* () {
-      const selected = OpenAICompatible.model("custom-model", {
-        apiKey: "generated-key",
-        baseURL: "https://compatible.example/v1",
-        provider: "custom",
-        headers: { Authorization: "Bearer configured-key" },
-        http: {
-          query: { tenant: "one" },
-          body: {
-            user: "user-1",
-            verbosity: "low",
-            vendor_extension: { enabled: true },
-            custom_boolean: false,
-          },
-        },
-        providerOptions: { openai: { reasoningEffort: "high" } },
-      })
-      const request = LLM.request({ model: selected, prompt: "Hello" })
-      const prepared = yield* compileRequest(request)
-      const parts = yield* jsonRequestParts({
-        endpoint: selected.route.endpoint,
-        auth: selected.route.auth,
-        headers: selected.route.headers,
-        request: LLMRequest.update(request, { http: selected.route.defaults.http }),
-        body: prepared.body,
-        encodeBody: (body) => JSON.stringify(body),
-      })
-
-      expect(parts.url).toBe("https://compatible.example/v1/chat/completions?tenant=one")
-      expect(parts.headers.authorization).toBe("Bearer configured-key")
-      expect(parts.jsonBody).toMatchObject({
-        user: "user-1",
-        reasoning_effort: "high",
-        verbosity: "low",
-        vendor_extension: { enabled: true },
-        custom_boolean: false,
-      })
-      expect(parts.jsonBody).toMatchObject({ stream_options: { include_usage: true } })
-    }),
-  )
-
   it.effect("configures the max tokens request field", () =>
     Effect.gen(function* () {
       const compatible = OpenAICompatibleChat.route

packages/app/e2e/regression/removed-layout-preference.spec.ts

@@ -23,6 +23,7 @@ test("ignores persisted old layout preferences when opening drafts", async ({ pa
   await page.addInitScript(
     ({ directory, draftID, server }) => {
       localStorage.setItem("settings.v3", JSON.stringify({ general: { newLayoutDesigns: false } }))
+      localStorage.setItem("app-version.v1", JSON.stringify({ version: "1.17.20" }))
       localStorage.setItem(
         "opencode.window.browser.dat:tabs",
         JSON.stringify([{ type: "draft", draftID, server, directory }]),

packages/app/src/context/server-session-v2-reducer.test.ts

@@ -153,88 +153,4 @@ describe("v2 session reducer", () => {
 
     expect(result).toMatchObject({ sessionID: "ses_1", missing: "msg_user", touched: [] })
   })
-
-  test("removes cancelled input from the pending promotion fold", () => {
-    const reducer = createV2SessionReducer()
-    reducer.reduce(
-      [],
-      event({
-        ...base,
-        id: "evt_admitted",
-        type: "session.input.admitted",
-        data: {
-          sessionID: "ses_1",
-          inputID: "msg_user",
-          input: { type: "user", delivery: "queue", data: { text: "cancel me" } },
-        },
-      }),
-    )
-    reducer.reduce(
-      [],
-      event({
-        ...base,
-        id: "evt_cancelled",
-        type: "session.input.cancelled",
-        data: { sessionID: "ses_1", inputID: "msg_user" },
-      }),
-    )
-    const result = reducer.reduce(
-      [],
-      event({
-        ...base,
-        id: "evt_promoted",
-        type: "session.input.promoted",
-        data: { sessionID: "ses_1", inputID: "msg_user" },
-      }),
-    )
-
-    expect(result).toMatchObject({ missing: "msg_user" })
-  })
-
-  test("keeps steered input available to the promotion fold", () => {
-    const reducer = createV2SessionReducer()
-    reducer.reduce(
-      [],
-      event({
-        ...base,
-        id: "evt_admitted",
-        type: "session.input.admitted",
-        data: {
-          sessionID: "ses_1",
-          inputID: "msg_user",
-          input: { type: "user", delivery: "queue", data: { text: "steer me" } },
-        },
-      }),
-    )
-    reducer.reduce(
-      [],
-      event({
-        ...base,
-        id: "evt_steered",
-        type: "session.input.steered",
-        data: { sessionID: "ses_1", inputID: "msg_user" },
-      }),
-    )
-    reducer.reduce(
-      [],
-      event({
-        ...base,
-        id: "evt_queued",
-        type: "session.input.queued",
-        data: { sessionID: "ses_1", inputID: "msg_user" },
-      }),
-    )
-
-    const result = reducer.reduce(
-      [],
-      event({
-        ...base,
-        id: "evt_promoted",
-        type: "session.input.promoted",
-        data: { sessionID: "ses_1", inputID: "msg_user" },
-      }),
-    )
-
-    expect(result?.messages).toMatchObject([{ id: "msg_user", type: "user", text: "steer me" }])
-  })
 })

packages/app/src/context/server-session-v2-reducer.ts

@@ -29,9 +29,6 @@ export function createV2SessionReducer() {
       case "session.input.admitted":
         pending.set(key(sessionID, event.data.inputID), event.data.input)
         return result([...source])
-      case "session.input.cancelled":
-        pending.delete(key(sessionID, event.data.inputID))
-        return
       case "session.input.promoted": {
         const input = pending.get(key(sessionID, event.data.inputID))
         pending.delete(key(sessionID, event.data.inputID))

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

@@ -263,52 +263,38 @@ export type Endpoint5_23Input = { readonly sessionID: Session.ID }
 export type Endpoint5_23Output = ReadonlyArray<SessionPending.Info>
 export type SessionPendingListOperation<E = never> = (input: Endpoint5_23Input) => Effect.Effect<Endpoint5_23Output, E>
 
-export type Endpoint5_24Input = { readonly sessionID: Session.ID; readonly inputID: SessionMessage.ID }
-export type Endpoint5_24Output = void
-export type SessionPendingCancelOperation<E = never> = (
+export type Endpoint5_24Input = { readonly sessionID: Session.ID }
+export type Endpoint5_24Output = ReadonlyArray<InstructionEntry.Info>
+export type SessionInstructionsEntryListOperation<E = never> = (
   input: Endpoint5_24Input,
 ) => Effect.Effect<Endpoint5_24Output, E>
 
-export type Endpoint5_25Input = { readonly sessionID: Session.ID; readonly inputID: SessionMessage.ID }
-export type Endpoint5_25Output = void
-export type SessionPendingSteerOperation<E = never> = (input: Endpoint5_25Input) => Effect.Effect<Endpoint5_25Output, E>
-
-export type Endpoint5_26Input = { readonly sessionID: Session.ID; readonly inputID: SessionMessage.ID }
-export type Endpoint5_26Output = void
-export type SessionPendingQueueOperation<E = never> = (input: Endpoint5_26Input) => Effect.Effect<Endpoint5_26Output, E>
-
-export type Endpoint5_27Input = { readonly sessionID: Session.ID }
-export type Endpoint5_27Output = ReadonlyArray<InstructionEntry.Info>
-export type SessionInstructionsEntryListOperation<E = never> = (
-  input: Endpoint5_27Input,
-) => Effect.Effect<Endpoint5_27Output, E>
-
-export type Endpoint5_28Input = {
+export type Endpoint5_25Input = {
   readonly sessionID: Session.ID
   readonly key: InstructionEntry.Key
   readonly value: Schema.Json
 }
-export type Endpoint5_28Output = void
+export type Endpoint5_25Output = void
 export type SessionInstructionsEntryPutOperation<E = never> = (
-  input: Endpoint5_28Input,
-) => Effect.Effect<Endpoint5_28Output, E>
+  input: Endpoint5_25Input,
+) => Effect.Effect<Endpoint5_25Output, E>
 
-export type Endpoint5_29Input = { readonly sessionID: Session.ID; readonly key: InstructionEntry.Key }
-export type Endpoint5_29Output = void
+export type Endpoint5_26Input = { readonly sessionID: Session.ID; readonly key: InstructionEntry.Key }
+export type Endpoint5_26Output = void
 export type SessionInstructionsEntryRemoveOperation<E = never> = (
-  input: Endpoint5_29Input,
-) => Effect.Effect<Endpoint5_29Output, E>
+  input: Endpoint5_26Input,
+) => Effect.Effect<Endpoint5_26Output, E>
 
-export type Endpoint5_30Input = { readonly sessionID: Session.ID; readonly prompt: string }
-export type Endpoint5_30Output = { readonly text: string }
-export type SessionGenerateOperation<E = never> = (input: Endpoint5_30Input) => Effect.Effect<Endpoint5_30Output, E>
+export type Endpoint5_27Input = { readonly sessionID: Session.ID; readonly prompt: string }
+export type Endpoint5_27Output = { readonly text: string }
+export type SessionGenerateOperation<E = never> = (input: Endpoint5_27Input) => Effect.Effect<Endpoint5_27Output, E>
 
-export type Endpoint5_31Input = {
+export type Endpoint5_28Input = {
   readonly sessionID: Session.ID
   readonly after?: Event.Seq | undefined
   readonly follow?: boolean | undefined
 }
-export type Endpoint5_31Output =
+export type Endpoint5_28Output =
   | (
       | {
           readonly id: Event.ID
@@ -418,33 +404,6 @@ export type Endpoint5_31Output =
             readonly input: SessionPending.Message
           }
         }
-      | {
-          readonly id: Event.ID
-          readonly created: DateTime.Utc
-          readonly metadata?: { readonly [x: string]: unknown } | undefined
-          readonly type: "session.input.cancelled"
-          readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
-          readonly location?: Location.Ref | undefined
-          readonly data: { readonly sessionID: Session.ID; readonly inputID: SessionMessage.ID }
-        }
-      | {
-          readonly id: Event.ID
-          readonly created: DateTime.Utc
-          readonly metadata?: { readonly [x: string]: unknown } | undefined
-          readonly type: "session.input.steered"
-          readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
-          readonly location?: Location.Ref | undefined
-          readonly data: { readonly sessionID: Session.ID; readonly inputID: SessionMessage.ID }
-        }
-      | {
-          readonly id: Event.ID
-          readonly created: DateTime.Utc
-          readonly metadata?: { readonly [x: string]: unknown } | undefined
-          readonly type: "session.input.queued"
-          readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
-          readonly location?: Location.Ref | undefined
-          readonly data: { readonly sessionID: Session.ID; readonly inputID: SessionMessage.ID }
-        }
       | {
           readonly id: Event.ID
           readonly created: DateTime.Utc
@@ -903,19 +862,19 @@ export type Endpoint5_31Output =
         }
     )
   | EventLog.Synced
-export type SessionLogOperation<E = never> = (input: Endpoint5_31Input) => Stream.Stream<Endpoint5_31Output, E>
+export type SessionLogOperation<E = never> = (input: Endpoint5_28Input) => Stream.Stream<Endpoint5_28Output, E>
 
-export type Endpoint5_32Input = { readonly sessionID: Session.ID }
-export type Endpoint5_32Output = void
-export type SessionInterruptOperation<E = never> = (input: Endpoint5_32Input) => Effect.Effect<Endpoint5_32Output, E>
+export type Endpoint5_29Input = { readonly sessionID: Session.ID }
+export type Endpoint5_29Output = void
+export type SessionInterruptOperation<E = never> = (input: Endpoint5_29Input) => Effect.Effect<Endpoint5_29Output, E>
 
-export type Endpoint5_33Input = { readonly sessionID: Session.ID }
-export type Endpoint5_33Output = void
-export type SessionBackgroundOperation<E = never> = (input: Endpoint5_33Input) => Effect.Effect<Endpoint5_33Output, E>
+export type Endpoint5_30Input = { readonly sessionID: Session.ID }
+export type Endpoint5_30Output = void
+export type SessionBackgroundOperation<E = never> = (input: Endpoint5_30Input) => Effect.Effect<Endpoint5_30Output, E>
 
-export type Endpoint5_34Input = { readonly sessionID: Session.ID; readonly messageID: SessionMessage.ID }
-export type Endpoint5_34Output = SessionMessage.Info
-export type SessionMessageOperation<E = never> = (input: Endpoint5_34Input) => Effect.Effect<Endpoint5_34Output, E>
+export type Endpoint5_31Input = { readonly sessionID: Session.ID; readonly messageID: SessionMessage.ID }
+export type Endpoint5_31Output = SessionMessage.Info
+export type SessionMessageOperation<E = never> = (input: Endpoint5_31Input) => Effect.Effect<Endpoint5_31Output, E>
 
 export interface SessionApi<E = never> {
   readonly list: SessionListOperation<E>
@@ -943,12 +902,7 @@ export interface SessionApi<E = never> {
     readonly commit: SessionRevertCommitOperation<E>
   }
   readonly context: SessionContextOperation<E>
-  readonly pending: {
-    readonly list: SessionPendingListOperation<E>
-    readonly cancel: SessionPendingCancelOperation<E>
-    readonly steer: SessionPendingSteerOperation<E>
-    readonly queue: SessionPendingQueueOperation<E>
-  }
+  readonly pending: { readonly list: SessionPendingListOperation<E> }
   readonly instructions: {
     readonly entry: {
       readonly list: SessionInstructionsEntryListOperation<E>

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

@@ -80,12 +80,6 @@ import type {
   Endpoint5_30Output,
   Endpoint5_31Input,
   Endpoint5_31Output,
-  Endpoint5_32Input,
-  Endpoint5_32Output,
-  Endpoint5_33Input,
-  Endpoint5_33Output,
-  Endpoint5_34Input,
-  Endpoint5_34Output,
   Endpoint6_0Input,
   Endpoint6_0Output,
   Endpoint7_0Input,
@@ -529,58 +523,37 @@ const Endpoint5_23 = (raw: RawClient["server.session"]) => (input: Endpoint5_23I
 
 const Endpoint5_24 = (raw: RawClient["server.session"]) => (input: Endpoint5_24Input) =>
   preserveEffect<Endpoint5_24Output>()(
-    raw["session.pending.cancel"]({ params: { sessionID: input["sessionID"], inputID: input["inputID"] } }).pipe(
-      Effect.mapError(mapClientError),
-    ),
-  )
-
-const Endpoint5_25 = (raw: RawClient["server.session"]) => (input: Endpoint5_25Input) =>
-  preserveEffect<Endpoint5_25Output>()(
-    raw["session.pending.steer"]({ params: { sessionID: input["sessionID"], inputID: input["inputID"] } }).pipe(
-      Effect.mapError(mapClientError),
-    ),
-  )
-
-const Endpoint5_26 = (raw: RawClient["server.session"]) => (input: Endpoint5_26Input) =>
-  preserveEffect<Endpoint5_26Output>()(
-    raw["session.pending.queue"]({ params: { sessionID: input["sessionID"], inputID: input["inputID"] } }).pipe(
-      Effect.mapError(mapClientError),
-    ),
-  )
-
-const Endpoint5_27 = (raw: RawClient["server.session"]) => (input: Endpoint5_27Input) =>
-  preserveEffect<Endpoint5_27Output>()(
     raw["session.instructions.entry.list"]({ params: { sessionID: input["sessionID"] } }).pipe(
       Effect.mapError(mapClientError),
       Effect.map((value) => value.data),
     ),
   )
 
-const Endpoint5_28 = (raw: RawClient["server.session"]) => (input: Endpoint5_28Input) =>
-  preserveEffect<Endpoint5_28Output>()(
+const Endpoint5_25 = (raw: RawClient["server.session"]) => (input: Endpoint5_25Input) =>
+  preserveEffect<Endpoint5_25Output>()(
     raw["session.instructions.entry.put"]({
       params: { sessionID: input["sessionID"], key: input["key"] },
       payload: { value: input["value"] },
     }).pipe(Effect.mapError(mapClientError)),
   )
 
-const Endpoint5_29 = (raw: RawClient["server.session"]) => (input: Endpoint5_29Input) =>
-  preserveEffect<Endpoint5_29Output>()(
+const Endpoint5_26 = (raw: RawClient["server.session"]) => (input: Endpoint5_26Input) =>
+  preserveEffect<Endpoint5_26Output>()(
     raw["session.instructions.entry.remove"]({ params: { sessionID: input["sessionID"], key: input["key"] } }).pipe(
       Effect.mapError(mapClientError),
     ),
   )
 
-const Endpoint5_30 = (raw: RawClient["server.session"]) => (input: Endpoint5_30Input) =>
-  preserveEffect<Endpoint5_30Output>()(
+const Endpoint5_27 = (raw: RawClient["server.session"]) => (input: Endpoint5_27Input) =>
+  preserveEffect<Endpoint5_27Output>()(
     raw["session.generate"]({ params: { sessionID: input["sessionID"] }, payload: { prompt: input["prompt"] } }).pipe(
       Effect.mapError(mapClientError),
       Effect.map((value) => value.data),
     ),
   )
 
-const Endpoint5_31 = (raw: RawClient["server.session"]) => (input: Endpoint5_31Input) =>
-  preserveStream<Endpoint5_31Output>()(
+const Endpoint5_28 = (raw: RawClient["server.session"]) => (input: Endpoint5_28Input) =>
+  preserveStream<Endpoint5_28Output>()(
     Stream.unwrap(
       raw["session.log"]({
         params: { sessionID: input["sessionID"] },
@@ -592,18 +565,18 @@ const Endpoint5_31 = (raw: RawClient["server.session"]) => (input: Endpoint5_31I
     ),
   )
 
-const Endpoint5_32 = (raw: RawClient["server.session"]) => (input: Endpoint5_32Input) =>
-  preserveEffect<Endpoint5_32Output>()(
+const Endpoint5_29 = (raw: RawClient["server.session"]) => (input: Endpoint5_29Input) =>
+  preserveEffect<Endpoint5_29Output>()(
     raw["session.interrupt"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError)),
   )
 
-const Endpoint5_33 = (raw: RawClient["server.session"]) => (input: Endpoint5_33Input) =>
-  preserveEffect<Endpoint5_33Output>()(
+const Endpoint5_30 = (raw: RawClient["server.session"]) => (input: Endpoint5_30Input) =>
+  preserveEffect<Endpoint5_30Output>()(
     raw["session.background"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError)),
   )
 
-const Endpoint5_34 = (raw: RawClient["server.session"]) => (input: Endpoint5_34Input) =>
-  preserveEffect<Endpoint5_34Output>()(
+const Endpoint5_31 = (raw: RawClient["server.session"]) => (input: Endpoint5_31Input) =>
+  preserveEffect<Endpoint5_31Output>()(
     raw["session.message"]({ params: { sessionID: input["sessionID"], messageID: input["messageID"] } }).pipe(
       Effect.mapError(mapClientError),
       Effect.map((value) => value.data),
@@ -632,13 +605,13 @@ const adaptGroup5 = (raw: RawClient["server.session"]) => ({
   wait: Endpoint5_18(raw),
   revert: { stage: Endpoint5_19(raw), clear: Endpoint5_20(raw), commit: Endpoint5_21(raw) },
   context: Endpoint5_22(raw),
-  pending: { list: Endpoint5_23(raw), cancel: Endpoint5_24(raw), steer: Endpoint5_25(raw), queue: Endpoint5_26(raw) },
-  instructions: { entry: { list: Endpoint5_27(raw), put: Endpoint5_28(raw), remove: Endpoint5_29(raw) } },
-  generate: Endpoint5_30(raw),
-  log: Endpoint5_31(raw),
-  interrupt: Endpoint5_32(raw),
-  background: Endpoint5_33(raw),
-  message: Endpoint5_34(raw),
+  pending: { list: Endpoint5_23(raw) },
+  instructions: { entry: { list: Endpoint5_24(raw), put: Endpoint5_25(raw), remove: Endpoint5_26(raw) } },
+  generate: Endpoint5_27(raw),
+  log: Endpoint5_28(raw),
+  interrupt: Endpoint5_29(raw),
+  background: Endpoint5_30(raw),
+  message: Endpoint5_31(raw),
 })
 
 const Endpoint6_0 = (raw: RawClient["server.message"]) => (input: Endpoint6_0Input) =>

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

@@ -58,12 +58,6 @@ import type {
   SessionContextOutput,
   SessionPendingListInput,
   SessionPendingListOutput,
-  SessionPendingCancelInput,
-  SessionPendingCancelOutput,
-  SessionPendingSteerInput,
-  SessionPendingSteerOutput,
-  SessionPendingQueueInput,
-  SessionPendingQueueOutput,
   SessionInstructionsEntryListInput,
   SessionInstructionsEntryListOutput,
   SessionInstructionsEntryPutInput,
@@ -772,39 +766,6 @@ export function make(options: ClientOptions) {
             },
             requestOptions,
           ).then((value) => value.data),
-        cancel: (input: SessionPendingCancelInput, requestOptions?: RequestOptions) =>
-          request<SessionPendingCancelOutput>(
-            {
-              method: "DELETE",
-              path: `/api/session/${encodeURIComponent(input.sessionID)}/pending/${encodeURIComponent(input.inputID)}`,
-              successStatus: 204,
-              declaredStatuses: [409, 404, 401, 400],
-              empty: true,
-            },
-            requestOptions,
-          ),
-        steer: (input: SessionPendingSteerInput, requestOptions?: RequestOptions) =>
-          request<SessionPendingSteerOutput>(
-            {
-              method: "POST",
-              path: `/api/session/${encodeURIComponent(input.sessionID)}/pending/${encodeURIComponent(input.inputID)}/steer`,
-              successStatus: 204,
-              declaredStatuses: [409, 404, 401, 400],
-              empty: true,
-            },
-            requestOptions,
-          ),
-        queue: (input: SessionPendingQueueInput, requestOptions?: RequestOptions) =>
-          request<SessionPendingQueueOutput>(
-            {
-              method: "POST",
-              path: `/api/session/${encodeURIComponent(input.sessionID)}/pending/${encodeURIComponent(input.inputID)}/queue`,
-              successStatus: 204,
-              declaredStatuses: [409, 404, 401, 400],
-              empty: true,
-            },
-            requestOptions,
-          ),
       },
       instructions: {
         entry: {

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

@@ -502,36 +502,6 @@ export type SessionInputPromoted = {
   data: { sessionID: string; inputID: string }
 }
 
-export type SessionInputCancelled = {
-  id: string
-  created: number
-  metadata?: { [x: string]: any }
-  type: "session.input.cancelled"
-  durable: { aggregateID: string; seq: number; version: 1 }
-  location?: LocationRef
-  data: { sessionID: string; inputID: string }
-}
-
-export type SessionInputSteered = {
-  id: string
-  created: number
-  metadata?: { [x: string]: any }
-  type: "session.input.steered"
-  durable: { aggregateID: string; seq: number; version: 1 }
-  location?: LocationRef
-  data: { sessionID: string; inputID: string }
-}
-
-export type SessionInputQueued = {
-  id: string
-  created: number
-  metadata?: { [x: string]: any }
-  type: "session.input.queued"
-  durable: { aggregateID: string; seq: number; version: 1 }
-  location?: LocationRef
-  data: { sessionID: string; inputID: string }
-}
-
 export type SessionExecutionStarted = {
   id: string
   created: number
@@ -2000,9 +1970,6 @@ export type SessionEventDurable =
   | SessionForked
   | SessionInputPromoted
   | SessionInputAdmitted
-  | SessionInputCancelled
-  | SessionInputSteered
-  | SessionInputQueued
   | SessionExecutionStarted
   | SessionExecutionSucceeded
   | SessionExecutionFailed
@@ -2057,9 +2024,6 @@ export type V2Event =
   | SessionForked
   | SessionInputPromoted
   | SessionInputAdmitted
-  | SessionInputCancelled
-  | SessionInputSteered
-  | SessionInputQueued
   | SessionExecutionStarted
   | SessionExecutionSucceeded
   | SessionExecutionFailed
@@ -3725,27 +3689,6 @@ export type SessionPendingListInput = { readonly sessionID: { readonly sessionID
 
 export type SessionPendingListOutput = { data: Array<SessionPendingInfo> }["data"]
 
-export type SessionPendingCancelInput = {
-  readonly sessionID: { readonly sessionID: string; readonly inputID: string }["sessionID"]
-  readonly inputID: { readonly sessionID: string; readonly inputID: string }["inputID"]
-}
-
-export type SessionPendingCancelOutput = void
-
-export type SessionPendingSteerInput = {
-  readonly sessionID: { readonly sessionID: string; readonly inputID: string }["sessionID"]
-  readonly inputID: { readonly sessionID: string; readonly inputID: string }["inputID"]
-}
-
-export type SessionPendingSteerOutput = void
-
-export type SessionPendingQueueInput = {
-  readonly sessionID: { readonly sessionID: string; readonly inputID: string }["sessionID"]
-  readonly inputID: { readonly sessionID: string; readonly inputID: string }["inputID"]
-}
-
-export type SessionPendingQueueOutput = void
-
 export type SessionInstructionsEntryListInput = { readonly sessionID: { readonly sessionID: string }["sessionID"] }
 
 export type SessionInstructionsEntryListOutput = { data: Array<InstructionEntryInfo> }["data"]

packages/client/test/contract-identity.test.ts

@@ -19,7 +19,7 @@ test("effect entrypoint exposes canonical Schema contracts", () => {
 test("generated Effect API names canonical and composed outputs", async () => {
   const source = await Bun.file(new URL("../src/effect/api/api.ts", import.meta.url)).text()
 
-  expect(source).toContain("export type Endpoint5_5Output = Session.Info")
+  expect(source).toContain("export type Endpoint5_3Output = Session.Info")
   expect(source).toContain("export type Endpoint19_0Output = OpenCodeEvent")
   expect(source).not.toContain("HttpApiClient.ForApi")
 })

packages/client/test/promise.test.ts

@@ -32,7 +32,6 @@ test("exposes every standard HTTP API group", () => {
     "projectCopy",
     "vcs",
     "debug",
-    "migration",
     "websearch",
     "config",
   ])
@@ -357,28 +356,6 @@ test("session.pending.list uses the public HTTP contract", async () => {
   expect(requests).toEqual([{ method: "GET", url: "http://localhost:3000/api/session/ses_test/pending" }])
 })
 
-test("session.pending mutations use the public HTTP contract", async () => {
-  const requests: Array<{ method: string; url: string }> = []
-  const client = OpenCode.make({
-    baseUrl: "http://localhost:3000",
-    fetch: async (input, init) => {
-      const request = input instanceof Request ? input : new Request(input, init)
-      requests.push({ method: request.method, url: request.url })
-      return new Response(null, { status: 204 })
-    },
-  })
-
-  await client.session.pending.cancel({ sessionID: "ses_test", inputID: "msg_cancel" })
-  await client.session.pending.steer({ sessionID: "ses_test", inputID: "msg_steer" })
-  await client.session.pending.queue({ sessionID: "ses_test", inputID: "msg_queue" })
-
-  expect(requests).toEqual([
-    { method: "DELETE", url: "http://localhost:3000/api/session/ses_test/pending/msg_cancel" },
-    { method: "POST", url: "http://localhost:3000/api/session/ses_test/pending/msg_steer/steer" },
-    { method: "POST", url: "http://localhost:3000/api/session/ses_test/pending/msg_queue/queue" },
-  ])
-})
-
 test("event.subscribe exposes the Promise event stream wire projection", async () => {
   const client = OpenCode.make({
     baseUrl: "http://localhost:3000",

packages/core/package.json

@@ -17,7 +17,6 @@
     "opencode": "./bin/opencode"
   },
   "exports": {
-    "./environment": "./src/environment/index.ts",
     "./session/runner": "./src/session/runner/index.ts",
     "./instructions": "./src/instructions/index.ts",
     "./*": "./src/*.ts"
@@ -118,7 +117,6 @@
     "immer": "11.1.4",
     "ignore": "7.0.5",
     "jsonc-parser": "3.3.1",
-    "mime-types": "3.0.2",
     "turndown": "7.2.0",
     "tree-sitter-bash": "0.25.0",
     "tree-sitter-powershell": "0.25.10",

packages/core/src/aisdk-native.ts

@@ -51,8 +51,6 @@ export function map(input: MapInput): Mapping | undefined {
           ...mapGoogleOptions(input.settings),
         },
       }
-    case "@ai-sdk/openai-compatible":
-      return mapOpenAICompatible(input.settings)
     case "@openrouter/ai-sdk-provider":
       return mapOpenRouter(input.settings, baseSettings)
     case "@ai-sdk/xai":
@@ -65,34 +63,6 @@ export function map(input: MapInput): Mapping | undefined {
         },
       }
   }
-  return undefined
-}
-
-function mapOpenAICompatible(settings: Readonly<Record<string, unknown>>): Mapping | undefined {
-  if (typeof settings.baseURL !== "string") return undefined
-  if (
-    settings.timeout !== undefined ||
-    settings.headerTimeout !== undefined ||
-    settings.chunkTimeout !== undefined ||
-    settings.fetch !== undefined ||
-    settings.transformRequestBody !== undefined ||
-    settings.metadataExtractor !== undefined ||
-    settings.supportsStructuredOutputs === true ||
-    settings.strictJsonSchema !== undefined
-  )
-    return undefined
-  const options = typeof settings.reasoningEffort === "string" ? { reasoningEffort: settings.reasoningEffort } : undefined
-  return {
-    package: "@opencode-ai/ai/providers/openai-compatible",
-    settings: {
-      baseURL: settings.baseURL,
-      ...(typeof settings.name === "string" ? { provider: settings.name } : {}),
-      ...mapAPIKey(settings),
-      ...(isStringRecord(settings.queryParams) ? { http: { query: settings.queryParams } } : {}),
-      ...(options === undefined ? {} : { providerOptions: { openai: options } }),
-    },
-    ...(isStringRecord(settings.headers) ? { headers: settings.headers } : {}),
-  }
 }
 
 function mapBedrockMantle(input: MapInput, baseSettings: Readonly<Record<string, unknown>>): Mapping | undefined {
@@ -222,7 +192,9 @@ function mapOpenAIOptions(settings: Readonly<Record<string, unknown>>) {
 }
 
 function mapBaseSettings(settings: Readonly<Record<string, unknown>>) {
-  return typeof settings.baseURL === "string" ? { baseURL: settings.baseURL } : {}
+  return {
+    ...(typeof settings.baseURL === "string" ? { baseURL: settings.baseURL } : {}),
+  }
 }
 
 function mapAPIKey(settings: Readonly<Record<string, unknown>>) {

packages/core/src/config/normalize.ts

@@ -41,7 +41,7 @@ export type Result =
   | { readonly type: "rejected"; readonly diagnostics: readonly Diagnostic[] }
 
 const options = { errors: "all", onExcessProperty: "ignore", propertyOrder: "original" } as const
-const unsupportedTopLevel = ["logLevel", "server", "subagent_depth", "layout"] as const
+const unsupportedTopLevel = ["logLevel", "server", "small_model", "subagent_depth", "layout"] as const
 const unsupportedExperimental = [
   "disable_paste_summary",
   "batch_tool",
@@ -113,23 +113,6 @@ export function normalize(input: unknown): Result {
   const legacyAgents = mapValues(decodeMap(input.agent, ConfigAgentV1.Info, ["agent"], diagnostics), (value) =>
     canonical(ConfigAgent.Info, ConfigMigrateV1.migrateAgent(value)),
   )
-  const legacySmallModel = own(input, "small_model")
-    ? decodeValue(Schema.String, input.small_model, ["small_model"], diagnostics)
-    : undefined
-  const migratedSmallModel = legacySmallModel
-    ? ConfigMigrateV1.migrate({ small_model: legacySmallModel }).agents?.title?.model
-    : undefined
-  if (legacySmallModel && !migratedSmallModel)
-    diagnostics.push({
-      kind: "unsupported",
-      path: ["small_model"],
-      message: "omitted unsupported legacy model reference",
-    })
-  if (migratedSmallModel)
-    legacyAgents.title = {
-      model: migratedSmallModel,
-      ...legacyAgents.title,
-    }
   const modeAgents = mapValues(decodeMap(input.mode, ConfigAgentV1.Info, ["mode"], diagnostics), (value) =>
     canonical(ConfigAgent.Info, ConfigMigrateV1.migrateAgent({ ...value, mode: "primary" })),
   )

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

@@ -161,14 +161,11 @@ function isPathAction(action: string): action is PathAction {
 }
 
 function expandHome(resource: string, home: string) {
+  if (resource.startsWith("~/")) return home + resource.slice(1)
   if (resource === "~") return home
   if (resource === "$HOME") return home
-  const relative = resource.startsWith("~/")
-    ? resource.slice(2)
-    : resource.startsWith("$HOME/") || resource.startsWith("$HOME\\")
-      ? resource.slice(6)
-      : undefined
-  if (relative !== undefined) return (path.posix.isAbsolute(home) ? path.posix : path.win32).join(home, relative)
+  if (resource.startsWith("$HOME/")) return home + resource.slice(5)
+  if (resource.startsWith("$HOME\\")) return home + resource.slice(5)
   return resource
 }
 

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

@@ -13,14 +13,12 @@ export const Plugin = define({
     const config = yield* Config.Service
     const loaded = { entries: yield* config.entries() }
     yield* ctx.integration.transform((integrations) => {
+      const configuredIntegrations = new Set(
+        configuredProviders(loaded.entries).flatMap(([id, provider]) => (provider.env === undefined ? [] : [id])),
+      )
       for (const [id, provider] of configuredProviders(loaded.entries)) {
         const integrationID = id
-        if (!integrations.get(integrationID)) {
-          integrations.method.update({
-            integrationID,
-            method: { type: "key", label: "Manually enter API Key" },
-          })
-        }
+        if (!configuredIntegrations.has(id) && !integrations.get(integrationID)) continue
         integrations.update(integrationID, (integration) => {
           integration.name = provider.name ?? integration.name
         })

packages/core/src/environment/driver.ts

@@ -1,9 +0,0 @@
-import type { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner"
-import type { FilesImpl } from "./files"
-
-export interface Driver {
-  readonly spawner: ChildProcessSpawner["Service"]
-  readonly overrides?: Partial<FilesImpl>
-}
-
-export * as EnvironmentDriver from "./driver"

packages/core/src/environment/environment.ts

@@ -1,26 +0,0 @@
-import { CrossSpawnSpawner } from "@opencode-ai/util/cross-spawn-spawner"
-import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
-import { Context, Effect, Layer } from "effect"
-import { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner"
-import type { Files } from "./files"
-import { makeFiles } from "./index"
-import { makeLocalDriver } from "./local"
-
-export interface Interface {
-  readonly files: Files
-  readonly spawner: ChildProcessSpawner["Service"]
-}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/Environment") {}
-
-const layer = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const spawner = yield* ChildProcessSpawner
-    return Service.of({ files: makeFiles(makeLocalDriver(spawner)), spawner })
-  }),
-)
-
-export const node = makeLocationNode({ service: Service, layer, deps: [CrossSpawnSpawner.node] })
-
-export * as EnvironmentService from "./environment"

packages/core/src/environment/exec-defaults.ts

@@ -1,192 +0,0 @@
-import { Effect, Stream } from "effect"
-import { ChildProcess } from "effect/unstable/process"
-import type { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner"
-import { collectStream } from "@opencode-ai/util/process"
-import { Failed, NotFound, WrongKind, type FileInfo, type FileType, type FilesImpl } from "./files"
-
-/**
- * Files derived from spawning processes: one process per intent, "$1" is
- * always the target path. Scripts report classification through an exit-code
- * protocol (44/45/46) so failures never require parsing localized error text;
- * LC_ALL=C pins the one stderr match that remains. Requires GNU coreutils and
- * findutils in the target image — BSD and busybox userlands will not work.
- * Malformed output from these scripts is our own bug and dies as a defect.
- */
-
-const MAX_DATA_BYTES = 64 * 1024 * 1024
-const MAX_ERROR_BYTES = 64 * 1024
-const NOT_FOUND = 44
-const WRONG_KIND = 45
-const FAILED = 46
-const TAB = "\t"
-
-const loadMetadata = (flags = "") => `
-metadata=$(stat ${flags} -c '%F${TAB}%s${TAB}%Y' -- "$1" 2>&1) || {
-  case "$metadata" in
-    *'No such file or directory'*|*'Not a directory'*) exit ${NOT_FOUND} ;;
-    *) printf '%s' "$metadata" >&2; exit ${FAILED} ;;
-  esac
-}
-`
-
-const statScript = `
-${loadMetadata()}
-printf '%s\n' "$metadata"
-`
-
-const readScript = `
-${loadMetadata("-L")}
-kind=\${metadata%%${TAB}*}
-if [ "$kind" != 'regular file' ] && [ "$kind" != 'regular empty file' ]; then
-  printf '%s' "$kind" >&2
-  exit ${WRONG_KIND}
-fi
-printf '%s\n' "$metadata"
-if [ "$2" = range ]; then
-  dd if="$1" iflag=skip_bytes,count_bytes skip="$3" count="$4" status=none
-else
-  cat -- "$1"
-fi
-`
-
-const listScript = `
-${loadMetadata("-L")}
-kind=\${metadata%%${TAB}*}
-if [ "$kind" != directory ]; then
-  printf '%s' "$kind" >&2
-  exit ${WRONG_KIND}
-fi
-find -H "$1" -mindepth 1 -maxdepth 1 -printf '%y\\0%f\\0'
-`
-
-const moveScript = `
-${loadMetadata()}
-mv -- "$1" "$2"
-`
-
-interface Result {
-  readonly exitCode: number
-  readonly stdout: Uint8Array
-  readonly stderr: Uint8Array
-}
-
-export const execDefaults = (spawner: ChildProcessSpawner["Service"]): FilesImpl => {
-  const run = (
-    path: string,
-    script: string,
-    args: ReadonlyArray<string> = [],
-    stdin?: Uint8Array,
-  ): Effect.Effect<Result, Failed> =>
-    Effect.scoped(
-      Effect.gen(function* () {
-        const command = ChildProcess.make("sh", ["-c", script, "sh", path, ...args], {
-          env: { LC_ALL: "C" },
-          extendEnv: true,
-          stdin: stdin === undefined ? undefined : Stream.make(stdin),
-        })
-        const handle = yield* spawner.spawn(command).pipe(Effect.mapError((cause) => new Failed({ path, cause })))
-        const [stdout, stderr, exitCode] = yield* Effect.all(
-          [
-            collectStream(handle.stdout, MAX_DATA_BYTES),
-            collectStream(handle.stderr, MAX_ERROR_BYTES),
-            handle.exitCode,
-          ],
-          { concurrency: "unbounded" },
-        ).pipe(Effect.mapError((cause) => new Failed({ path, cause })))
-        if (stdout.truncated || stderr.truncated) {
-          return yield* new Failed({ path, cause: new Error("Process output exceeded its collection limit") })
-        }
-        return { exitCode, stdout: stdout.buffer, stderr: stderr.buffer }
-      }),
-    )
-
-  const classify = <A>(
-    path: string,
-    result: Result,
-    success: (stdout: Uint8Array) => A,
-  ): Effect.Effect<A, NotFound | WrongKind | Failed> => {
-    if (result.exitCode === 0) return Effect.sync(() => success(result.stdout))
-    if (result.exitCode === NOT_FOUND) return Effect.fail(new NotFound({ path }))
-    if (result.exitCode === WRONG_KIND) {
-      return Effect.fail(new WrongKind({ path, actual: parseType(new TextDecoder().decode(result.stderr)) }))
-    }
-    return Effect.fail(processFailure(path, result))
-  }
-
-  const complete = (path: string, result: Result) =>
-    result.exitCode === 0 ? Effect.void : Effect.fail(processFailure(path, result))
-
-  return {
-    stat: (path) => run(path, statScript).pipe(Effect.flatMap((result) => classifyPlain(path, result, parseInfo))),
-    read: (path, range) =>
-      run(
-        path,
-        readScript,
-        range === undefined ? ["whole"] : ["range", String(range.offset), String(range.length)],
-      ).pipe(
-        Effect.flatMap((result) =>
-          classify(path, result, (stdout) => {
-            const newline = stdout.indexOf(10)
-            if (newline < 0) throw new Error("Missing read metadata header")
-            return {
-              info: parseInfo(stdout.slice(0, newline)),
-              bytes: stdout.slice(newline + 1),
-            }
-          }),
-        ),
-      ),
-    write: (path, bytes) =>
-      run(path, `mkdir -p "$(dirname "$1")" && cat > "$1"`, [], bytes).pipe(
-        Effect.flatMap((result) => complete(path, result)),
-      ),
-    list: (path) => run(path, listScript).pipe(Effect.flatMap((result) => classify(path, result, parseList))),
-    remove: (path) => run(path, `rm -rf -- "$1"`).pipe(Effect.flatMap((result) => complete(path, result))),
-    move: (from, to) =>
-      run(from, moveScript, [to]).pipe(Effect.flatMap((result) => classifyPlain(from, result, () => undefined))),
-    mkdir: (path) => run(path, `mkdir -p -- "$1"`).pipe(Effect.flatMap((result) => complete(path, result))),
-  }
-}
-
-/** `classify` for scripts whose protocol never reports WrongKind. */
-const classifyPlain = <A>(
-  path: string,
-  result: Result,
-  success: (stdout: Uint8Array) => A,
-): Effect.Effect<A, NotFound | Failed> => {
-  if (result.exitCode === 0) return Effect.sync(() => success(result.stdout))
-  if (result.exitCode === NOT_FOUND) return Effect.fail(new NotFound({ path }))
-  return Effect.fail(processFailure(path, result))
-}
-
-const processFailure = (path: string, result: Result) =>
-  new Failed({
-    path,
-    cause: new Error(new TextDecoder().decode(result.stderr).trim() || `Process exited with code ${result.exitCode}`),
-  })
-
-const parseInfo = (bytes: Uint8Array): FileInfo => {
-  const [rawType, rawSize, rawMtime] = new TextDecoder().decode(bytes).trim().split(TAB)
-  const size = Number(rawSize)
-  const mtimeMs = Number(rawMtime) * 1_000
-  if (!rawType || !Number.isFinite(size) || !Number.isFinite(mtimeMs)) throw new Error("Invalid stat output")
-  return { type: parseType(rawType), size, mtimeMs }
-}
-
-const parseType = (value: string): FileType => {
-  if (value === "regular file" || value === "regular empty file" || value === "f") return "file"
-  if (value === "directory" || value === "d") return "directory"
-  if (value === "symbolic link" || value === "l") return "symlink"
-  return "other"
-}
-
-const parseList = (bytes: Uint8Array) => {
-  const fields = new TextDecoder().decode(bytes).split("\0")
-  fields.pop()
-  if (fields.length % 2 !== 0) throw new Error("Invalid find output")
-  return Array.from({ length: fields.length / 2 }, (_, index) => ({
-    name: fields[index * 2 + 1],
-    type: parseType(fields[index * 2]),
-  }))
-}
-
-export * as EnvironmentExecDefaults from "./exec-defaults"

packages/core/src/environment/files.ts

@@ -1,70 +0,0 @@
-import { Effect, Schema } from "effect"
-
-export const FileType = Schema.Literals(["file", "directory", "symlink", "other"])
-export type FileType = typeof FileType.Type
-
-export interface FileInfo {
-  readonly type: FileType
-  readonly size: number
-  readonly mtimeMs: number
-}
-
-export interface DirEntry {
-  readonly name: string
-  readonly type: FileType
-}
-
-export class NotFound extends Schema.TaggedErrorClass<NotFound>()("Environment.NotFound", {
-  path: Schema.String,
-}) {}
-
-export class WrongKind extends Schema.TaggedErrorClass<WrongKind>()("Environment.WrongKind", {
-  path: Schema.String,
-  actual: FileType,
-}) {}
-
-export class Failed extends Schema.TaggedErrorClass<Failed>()("Environment.Failed", {
-  path: Schema.String,
-  cause: Schema.Defect(),
-}) {}
-
-export interface FilesImpl {
-  /**
-   * Content operations (`read`, `list`) follow final symlinks; metadata operations (`stat` and entry
-   * tags returned by `list`) do not. `info` describes the target file whose bytes are returned.
-   * The process-backed default caps collected output at 64 MiB; larger whole-file reads fail with
-   * `Failed`, so callers must use ranges for larger files.
-   */
-  readonly read: (
-    path: string,
-    range?: { readonly offset: number; readonly length: number },
-  ) => Effect.Effect<{ readonly info: FileInfo; readonly bytes: Uint8Array }, NotFound | WrongKind | Failed>
-  readonly write: (path: string, bytes: Uint8Array) => Effect.Effect<void, Failed>
-  /** Describes the path entry itself, so a final symlink is reported as `symlink` rather than followed. */
-  readonly stat: (path: string) => Effect.Effect<FileInfo, NotFound | Failed>
-  /** Follows a final symlink to the listed directory while preserving each returned entry's own type. */
-  readonly list: (path: string) => Effect.Effect<ReadonlyArray<DirEntry>, NotFound | WrongKind | Failed>
-  readonly remove: (path: string) => Effect.Effect<void, Failed>
-  readonly move: (from: string, to: string) => Effect.Effect<void, NotFound | Failed>
-  readonly mkdir: (path: string) => Effect.Effect<void, Failed>
-}
-
-export interface Files extends FilesImpl {}
-
-/**
- * Derives a follow-stat kind from the lstat-like Files contract. A dangling
- * symlink fails with `NotFound`.
- */
-export const typeFollowing = (files: Files, path: string) =>
-  files.stat(path).pipe(
-    Effect.flatMap((info) =>
-      info.type === "symlink"
-        ? files.read(path, { offset: 0, length: 0 }).pipe(
-            Effect.map((result) => result.info.type),
-            Effect.catchTag("Environment.WrongKind", (error) => Effect.succeed(error.actual)),
-          )
-        : Effect.succeed(info.type),
-    ),
-  )
-
-export * as EnvironmentFiles from "./files"

packages/core/src/environment/index.ts

@@ -1,27 +0,0 @@
-export * as Environment from "./index"
-
-export { type Driver } from "./driver"
-export {
-  type DirEntry,
-  Failed,
-  type FileInfo,
-  type Files,
-  type FilesImpl,
-  type FileType,
-  NotFound,
-  typeFollowing,
-  WrongKind,
-} from "./files"
-export { execDefaults } from "./exec-defaults"
-export { makeLocalDriver } from "./local"
-export { makeMemoryDriver, type MemoryDriver } from "./memory"
-export { type Interface, node, Service } from "./environment"
-
-import type { Driver } from "./driver"
-import { execDefaults } from "./exec-defaults"
-import type { Files } from "./files"
-
-export const makeFiles = (driver: Driver): Files => ({
-  ...execDefaults(driver.spawner),
-  ...driver.overrides,
-})

packages/core/src/environment/local.ts

@@ -1,103 +0,0 @@
-import fs from "node:fs/promises"
-import path from "node:path"
-import { Effect } from "effect"
-import type { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner"
-import type { Driver } from "./driver"
-import { Failed, NotFound, WrongKind, type FileInfo, type FilesImpl, type FileType } from "./files"
-
-/**
- * The host filesystem binding. Deliberately raw node:fs rather than effect's
- * FileSystem service or FSUtil: the contract needs lstat semantics (stat
- * reports "symlink") and typed directory entries, and effect's node
- * FileSystem provides neither — its stat always follows symlinks and
- * readDirectory returns names only. FSUtil hits the same gap and its
- * readDirectoryEntries already bypasses to raw node readdir internally.
- * Nothing above the environment seam touches node:fs.
- */
-export const makeLocalDriver = (spawner: ChildProcessSpawner["Service"]): Driver => {
-  const overrides: FilesImpl = {
-    read: (value, range) =>
-      Effect.gen(function* () {
-        const info = yield* stat(value, true)
-        if (info.type !== "file") return yield* new WrongKind({ path: value, actual: info.type })
-        if (range === undefined) {
-          const bytes = yield* attempt(value, () => fs.readFile(value), true)
-          return { info, bytes }
-        }
-        const bytes = yield* attempt(
-          value,
-          async () => {
-            const handle = await fs.open(value, "r")
-            try {
-              const buffer = new Uint8Array(range.length)
-              const result = await handle.read(buffer, 0, range.length, range.offset)
-              return buffer.subarray(0, result.bytesRead)
-            } finally {
-              await handle.close()
-            }
-          },
-          true,
-        )
-        return { info, bytes }
-      }),
-    stat: (value) => stat(value, false),
-    list: (value) =>
-      Effect.gen(function* () {
-        const info = yield* stat(value, true)
-        if (info.type !== "directory") return yield* new WrongKind({ path: value, actual: info.type })
-        const entries = yield* attempt(value, () => fs.readdir(value, { withFileTypes: true }), true)
-        return entries.map((entry) => ({ name: entry.name, type: fileType(entry) }))
-      }),
-    write: (value, bytes) =>
-      attempt(value, async () => {
-        await fs.mkdir(path.dirname(value), { recursive: true })
-        await fs.writeFile(value, bytes)
-      }),
-    remove: (value) => attempt(value, () => fs.rm(value, { recursive: true, force: true })),
-    move: (from, to) =>
-      Effect.gen(function* () {
-        yield* stat(from, false)
-        const destination = yield* stat(to, false).pipe(
-          Effect.map((info) => (info.type === "directory" ? path.join(to, path.basename(from)) : to)),
-          Effect.catchIf(
-            (error) => error instanceof NotFound,
-            () => Effect.succeed(to),
-          ),
-        )
-        yield* attempt(from, () => fs.rename(from, destination))
-      }),
-    mkdir: (value) => attempt(value, () => fs.mkdir(value, { recursive: true }).then(() => undefined)),
-  }
-
-  return { spawner, overrides }
-}
-
-const stat = (value: string, follow: boolean) =>
-  attempt(value, () => (follow ? fs.stat(value) : fs.lstat(value)), true).pipe(
-    Effect.map((stats): FileInfo => ({ type: fileType(stats), size: stats.size, mtimeMs: stats.mtimeMs })),
-  )
-
-const fileType = (entry: { isFile(): boolean; isDirectory(): boolean; isSymbolicLink(): boolean }): FileType => {
-  if (entry.isFile()) return "file"
-  if (entry.isDirectory()) return "directory"
-  if (entry.isSymbolicLink()) return "symlink"
-  return "other"
-}
-
-function attempt<A>(value: string, run: () => Promise<A>): Effect.Effect<A, Failed>
-function attempt<A>(value: string, run: () => Promise<A>, missing: true): Effect.Effect<A, NotFound | Failed>
-function attempt<A>(value: string, run: () => Promise<A>, missing = false) {
-  return Effect.tryPromise({
-    try: run,
-    catch: (cause) =>
-      missing && isMissing(cause) ? new NotFound({ path: value }) : new Failed({ path: value, cause }),
-  })
-}
-
-const isMissing = (cause: unknown) =>
-  cause !== null &&
-  typeof cause === "object" &&
-  "code" in cause &&
-  (cause.code === "ENOENT" || cause.code === "ENOTDIR")
-
-export * as EnvironmentLocal from "./local"

packages/core/src/environment/memory.ts

@@ -1,168 +0,0 @@
-import path from "node:path"
-import { Effect, PlatformError } from "effect"
-import { make } from "effect/unstable/process/ChildProcessSpawner"
-import type { Driver } from "./driver"
-import { Failed, NotFound, WrongKind, type FileInfo, type FilesImpl, type FileType } from "./files"
-
-type Node =
-  | { readonly type: "file"; readonly bytes: Uint8Array; readonly mtimeMs: number }
-  | { readonly type: "directory"; readonly mtimeMs: number }
-  | { readonly type: "symlink"; readonly target: string; readonly mtimeMs: number }
-
-export interface MemoryDriver extends Driver {
-  readonly symlink: (target: string, path: string) => Effect.Effect<void, Failed>
-}
-
-export const makeMemoryDriver = (): MemoryDriver => {
-  const nodes = new Map<string, Node>([["/", { type: "directory", mtimeMs: Date.now() }]])
-  const key = (value: string) => path.posix.resolve("/", value)
-  const info = (node: Node): FileInfo => ({
-    type: node.type,
-    size:
-      node.type === "file"
-        ? node.bytes.length
-        : node.type === "symlink"
-          ? new TextEncoder().encode(node.target).length
-          : 0,
-    mtimeMs: node.mtimeMs,
-  })
-  const resolveKey = (value: string, followFinal: boolean, seen = new Set<string>()): string | undefined => {
-    const normalized = key(value)
-    const parts = normalized.split("/").filter(Boolean)
-    const base = "/"
-    const walk = (current: string, index: number): string | undefined => {
-      if (index === parts.length) return current
-      const part = parts[index]
-      const candidate = path.posix.join(current, part)
-      const node = nodes.get(candidate)
-      if (node?.type !== "symlink" || (!followFinal && index === parts.length - 1)) return walk(candidate, index + 1)
-      if (seen.has(candidate)) return undefined
-      seen.add(candidate)
-      const target = path.posix.resolve(path.posix.dirname(candidate), node.target)
-      return resolveKey(path.posix.join(target, ...parts.slice(index + 1)), followFinal, seen)
-    }
-    return walk(base, 0)
-  }
-  const lookup = (value: string) => nodes.get(resolveKey(value, false) ?? key(value))
-  const requireParent = (value: string) => {
-    const parentPath = path.posix.dirname(key(value))
-    const parent = nodes.get(resolveKey(parentPath, true) ?? parentPath)
-    if (!parent) throw new Error(`Parent directory does not exist: ${path.posix.dirname(value)}`)
-    if (parent.type !== "directory") throw new Error(`Parent is not a directory: ${path.posix.dirname(value)}`)
-  }
-  const mkdirSync = (value: string) => {
-    const target = resolveKey(value, false) ?? key(value)
-    const existing = nodes.get(target)
-    if (existing?.type === "directory") return
-    if (existing) throw new Error(`Path is not a directory: ${value}`)
-    const parent = path.posix.dirname(target)
-    if (parent !== target) mkdirSync(parent)
-    nodes.set(target, { type: "directory", mtimeMs: Date.now() })
-  }
-  const failed = (value: string, cause: unknown) => new Failed({ path: value, cause })
-  const overrides: FilesImpl = {
-    stat: (value) => {
-      const node = lookup(value)
-      return node ? Effect.succeed(info(node)) : Effect.fail(new NotFound({ path: value }))
-    },
-    read: (value, range) => {
-      const original = lookup(value)
-      if (!original) return Effect.fail(new NotFound({ path: value }))
-      if (original.type === "directory") return Effect.fail(new WrongKind({ path: value, actual: "directory" }))
-      const resolved = resolveKey(value, true)
-      const node = resolved === undefined ? undefined : nodes.get(resolved)
-      if (!node) return Effect.fail(new NotFound({ path: value }))
-      if (node.type !== "file") return Effect.fail(new WrongKind({ path: value, actual: node.type }))
-      const bytes = range === undefined ? node.bytes : node.bytes.subarray(range.offset, range.offset + range.length)
-      return Effect.succeed({ info: info(node), bytes: bytes.slice() })
-    },
-    write: (value, bytes) =>
-      Effect.try({
-        try: () => {
-          mkdirSync(path.posix.dirname(key(value)))
-          const existing = lookup(value)
-          if (existing?.type === "directory") throw new Error(`Path is a directory: ${value}`)
-          const target = existing?.type === "symlink" ? resolveKey(value, true) : resolveKey(value, false)
-          if (!target) throw new Error(`Cannot resolve symlink: ${value}`)
-          requireParent(target)
-          nodes.set(target, { type: "file", bytes: bytes.slice(), mtimeMs: Date.now() })
-        },
-        catch: (cause) => failed(value, cause),
-      }),
-    list: (value) => {
-      const target = resolveKey(value, true) ?? key(value)
-      const node = nodes.get(target)
-      if (!node) return Effect.fail(new NotFound({ path: value }))
-      if (node.type !== "directory") return Effect.fail(new WrongKind({ path: value, actual: node.type }))
-      const entries = [...nodes.entries()]
-        .filter(([entry]) => entry !== target && path.posix.dirname(entry) === target)
-        .map(([entry, child]) => ({ name: path.posix.basename(entry), type: child.type satisfies FileType }))
-        .sort((a, b) => a.name.localeCompare(b.name))
-      return Effect.succeed(entries)
-    },
-    remove: (value) =>
-      Effect.sync(() => {
-        const target = resolveKey(value, false) ?? key(value)
-        for (const entry of nodes.keys()) {
-          if (entry === target || entry.startsWith(`${target}/`)) nodes.delete(entry)
-        }
-      }),
-    move: (from, to) => {
-      const source = resolveKey(from, false) ?? key(from)
-      const node = nodes.get(source)
-      if (!node) return Effect.fail(new NotFound({ path: from }))
-      return Effect.try({
-        try: () => {
-          const requested = resolveKey(to, false) ?? key(to)
-          const destination =
-            nodes.get(requested)?.type === "directory"
-              ? path.posix.join(requested, path.posix.basename(source))
-              : requested
-          if (node.type === "directory" && destination.startsWith(`${source}/`)) {
-            throw new Error(`Cannot move a directory into itself: ${from}`)
-          }
-          const existing = nodes.get(destination)
-          if (node.type === "directory" && existing && existing.type !== "directory") {
-            throw new Error(`Cannot overwrite a non-directory with a directory: ${to}`)
-          }
-          requireParent(destination)
-          const moved = [...nodes.entries()].filter(([entry]) => entry === source || entry.startsWith(`${source}/`))
-          for (const [entry] of moved) nodes.delete(entry)
-          for (const [entry, child] of moved) nodes.set(`${destination}${entry.slice(source.length)}`, child)
-        },
-        catch: (cause) => failed(from, cause),
-      })
-    },
-    mkdir: (value) => Effect.try({ try: () => mkdirSync(value), catch: (cause) => failed(value, cause) }),
-  }
-
-  const spawner = make((command) =>
-    Effect.suspend(() => {
-      const description = command._tag === "StandardCommand" ? command.command : "pipeline"
-      return Effect.fail(
-        PlatformError.systemError({
-          _tag: "Unknown",
-          module: "EnvironmentMemory",
-          method: "spawn",
-          pathOrDescriptor: description,
-          cause: failed(description, new Error("The memory driver cannot spawn processes")),
-        }),
-      )
-    }),
-  )
-
-  return {
-    spawner,
-    overrides,
-    symlink: (target, value) =>
-      Effect.try({
-        try: () => {
-          requireParent(value)
-          nodes.set(resolveKey(value, false) ?? key(value), { type: "symlink", target, mtimeMs: Date.now() })
-        },
-        catch: (cause) => failed(value, cause),
-      }),
-  }
-}
-
-export * as EnvironmentMemory from "./memory"

packages/core/src/file-mutation.ts

@@ -5,11 +5,9 @@ import { Context, Effect, Layer } from "effect"
 import { KeyedMutex } from "./effect/keyed-mutex"
 import { FSUtil } from "@opencode-ai/util/fs-util"
 import { Bom } from "@opencode-ai/util/bom"
-import { Environment } from "./environment"
-import type { Files } from "./environment"
 
 export interface Target {
-  readonly absolute: string
+  readonly canonical: string
   readonly resource: string
 }
 
@@ -31,58 +29,31 @@ export interface WriteResult {
 }
 
 export interface Interface {
-  /** Serialize a complete read/prepare/write mutation transaction by resolved path. */
-  readonly withLock: (
-    targets: ReadonlyArray<string>,
-  ) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
-  readonly write: (input: WriteInput) => Effect.Effect<WriteResult, Environment.Failed>
+  readonly write: (input: WriteInput) => Effect.Effect<WriteResult, FSUtil.Error>
   /** Write text while retaining an existing UTF-8 BOM and emitting at most one BOM. */
-  readonly writeTextPreservingBom: (
-    input: TextWriteInput,
-  ) => Effect.Effect<WriteResult, Environment.WrongKind | Environment.Failed>
+  readonly writeTextPreservingBom: (input: TextWriteInput) => Effect.Effect<WriteResult, FSUtil.Error>
 }
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/FileMutation") {}
 
-export const readText = Effect.fn("FileMutation.readText")(function* (files: Files, target: string) {
-  return Bom.decodeBytes((yield* files.read(target)).bytes)
-})
-
-export const syncTextBom = Effect.fn("FileMutation.syncTextBom")(function* (
-  files: Files,
-  target: string,
-  bom: boolean,
-) {
-  const synced = Bom.syncBytes((yield* files.read(target)).bytes, bom)
-  if (synced.bytes) yield* files.write(target, synced.bytes)
-  return synced.text
-})
-
-/** Share transaction locks across Location graphs that address the same file. */
-const transactionLocks = KeyedMutex.makeUnsafe<string>()
-
 /**
- * Serialize file changes by absolute target. Conditional writes compare and
+ * Serialize file changes by canonical target. Conditional writes compare and
  * write under the same process-local lock so cooperating OpenCode mutations do
  * not overwrite changes made from the same stale content.
  */
 const layer = Layer.effect(
   Service,
   Effect.gen(function* () {
-    const environment = yield* Environment.Service
+    const fs = yield* FSUtil.Service
     const locks = KeyedMutex.makeUnsafe<string>()
-    const withLock: Interface["withLock"] = (targets) => (effect) =>
-      [...new Set(targets.map(FSUtil.resolve))]
-        .sort()
-        .reduceRight((result, target) => transactionLocks.withLock(target)(result), effect)
     const withTargetLock =
       (target: Target) =>
       <A, E, R>(effect: Effect.Effect<A, E, R>) =>
-        locks.withLock(target.absolute)(Effect.uninterruptible(effect))
+        locks.withLock(target.canonical)(Effect.uninterruptible(effect))
 
     const writeResult = (target: Target, existed: boolean): WriteResult => ({
       operation: "write",
-      target: target.absolute,
+      target: target.canonical,
       resource: target.resource,
       existed,
     })
@@ -90,14 +61,8 @@ const layer = Layer.effect(
     const write = Effect.fn("FileMutation.write")((input: WriteInput) =>
       withTargetLock(input.target)(
         Effect.gen(function* () {
-          const existed = yield* environment.files.stat(input.target.absolute).pipe(
-            Effect.as(true),
-            Effect.catchTag("Environment.NotFound", () => Effect.succeed(false)),
-          )
-          yield* environment.files.write(
-            input.target.absolute,
-            typeof input.content === "string" ? new TextEncoder().encode(input.content) : input.content,
-          )
+          const existed = yield* fs.exists(input.target.canonical)
+          yield* fs.writeWithDirs(input.target.canonical, input.content)
           return writeResult(input.target, existed)
         }),
       ),
@@ -107,24 +72,23 @@ const layer = Layer.effect(
       withTargetLock(input.target)(
         Effect.gen(function* () {
           const next = Bom.split(input.content)
-          const current = yield* environment.files.read(input.target.absolute, { offset: 0, length: 3 }).pipe(
-            Effect.map((result) => result.bytes),
-            Effect.catchTag("Environment.NotFound", () => Effect.succeed(undefined)),
-          )
-          yield* environment.files.write(
-            input.target.absolute,
-            new TextEncoder().encode(Bom.join(next.text, Boolean(current && Bom.has(current)) || next.bom)),
+          const current = yield* fs
+            .readFile(input.target.canonical)
+            .pipe(Effect.catchReason("PlatformError", "NotFound", () => Effect.succeed(undefined)))
+          yield* fs.writeWithDirs(
+            input.target.canonical,
+            Bom.join(next.text, Boolean(current && Bom.has(current)) || next.bom),
           )
           return writeResult(input.target, current !== undefined)
         }),
       ),
     )
 
-    return Service.of({ withLock, write, writeTextPreservingBom })
+    return Service.of({ write, writeTextPreservingBom })
   }),
 )
 
-export const node = makeLocationNode({ service: Service, layer, deps: [Environment.node] })
+export const node = makeLocationNode({ service: Service, layer, deps: [FSUtil.node] })
 
 /**
  * Deferred until the corresponding integrations exist.

packages/core/src/location-mutation.ts

@@ -23,9 +23,14 @@ export const ResolveInput = Schema.Struct({
 })
 export type ResolveInput = typeof ResolveInput.Type
 
+export class PathError extends Schema.TaggedErrorClass<PathError>()("LocationMutation.PathError", {
+  path: Schema.String,
+  reason: Schema.Literal("non_directory_ancestor"),
+}) {}
+
 export interface ExternalDirectoryAuthorization {
   readonly action: "external_directory"
-  /** Lexical directory used as the external approval boundary. */
+  /** Canonical existing directory used as the external approval boundary. */
   readonly directory: string
   /** `external_directory` permission resource. */
   readonly resource: string
@@ -39,9 +44,9 @@ export const externalDirectoryPermission = (input: ExternalDirectoryAuthorizatio
 })
 
 export interface Target {
-  /** Absolute lexical path. */
-  readonly absolute: string
-  /** Permission resource: Location-relative for internal paths, absolute for external paths. */
+  /** Canonical existing path, or missing path below a canonical directory. */
+  readonly canonical: string
+  /** Permission resource: Location-relative for internal paths, canonical for external paths. */
   readonly resource: string
   readonly externalDirectory?: ExternalDirectoryAuthorization
 }
@@ -52,11 +57,25 @@ export interface Interface {
    * from the Location. Paths outside it require separate `external_directory`
    * approval. This does not approve the mutation.
    */
-  readonly resolve: (input: ResolveInput) => Effect.Effect<Target, FSUtil.Error>
+  readonly resolve: (input: ResolveInput) => Effect.Effect<Target, PathError | FSUtil.Error>
 }
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/LocationMutation") {}
 
+interface ResolvedPath {
+  readonly canonical: string
+  readonly type?:
+    | "File"
+    | "Directory"
+    | "SymbolicLink"
+    | "BlockDevice"
+    | "CharacterDevice"
+    | "FIFO"
+    | "Socket"
+    | "Unknown"
+  readonly directory: string
+}
+
 const slash = (value: string) => value.replaceAll("\\", "/")
 
 const layer = Layer.effect(
@@ -65,33 +84,65 @@ const layer = Layer.effect(
     const fs = yield* FSUtil.Service
     const location = yield* Location.Service
 
+    function notFound<A>(effect: Effect.Effect<A, FSUtil.Error>) {
+      return effect.pipe(Effect.catchReason("PlatformError", "NotFound", () => Effect.succeed(undefined)))
+    }
+
+    const resolvePath = Effect.fnUntraced(function* (absolute: string) {
+      const existing = yield* notFound(fs.realPath(absolute))
+      if (existing !== undefined) {
+        const info = yield* fs.stat(existing)
+        return {
+          canonical: existing,
+          type: info.type,
+          directory: info.type === "Directory" ? existing : path.dirname(existing),
+        } satisfies ResolvedPath
+      }
+
+      let anchor = path.dirname(absolute)
+      while (true) {
+        const canonical = yield* notFound(fs.realPath(anchor))
+        if (canonical !== undefined) {
+          const info = yield* fs.stat(canonical)
+          if (info.type !== "Directory") {
+            return yield* new PathError({ path: absolute, reason: "non_directory_ancestor" })
+          }
+          return {
+            canonical: path.resolve(canonical, path.relative(anchor, absolute)),
+            directory: canonical,
+          } satisfies ResolvedPath
+        }
+        const parent = path.dirname(anchor)
+        if (parent === anchor) return yield* new PathError({ path: absolute, reason: "non_directory_ancestor" })
+        anchor = parent
+      }
+    })
+
     const resolve = Effect.fn("LocationMutation.resolve")(function* (input: ResolveInput) {
       const absolute = path.resolve(location.directory, input.path)
-      if (FSUtil.contains(location.directory, absolute)) {
-        return {
-          absolute,
-          resource: slash(path.relative(location.directory, absolute) || "."),
-        } satisfies Target
-      }
-      const type =
-        input.kind === "directory"
-          ? "Directory"
-          : (yield* fs
-              .stat(absolute)
-              .pipe(Effect.catchReason("PlatformError", "NotFound", () => Effect.succeed(undefined))))?.type
-      const externalDirectory = type === "Directory" ? absolute : path.dirname(absolute)
+      // External access follows the requested path boundary. Symlinks reached through an
+      // internal path intentionally retain internal permission semantics after canonicalization.
+      const lexicallyInternal = FSUtil.contains(location.directory, absolute)
+
+      const resolved = yield* resolvePath(absolute)
+      const external = !lexicallyInternal
+      const resource = external ? slash(resolved.canonical) : slash(path.relative(location.directory, absolute) || ".")
+      const externalDirectory =
+        input.kind === "directory" && resolved.type === "Directory" ? resolved.canonical : resolved.directory
       const externalResource = slash(path.join(externalDirectory, "*"))
       return {
-        absolute,
-        resource: slash(absolute),
-        externalDirectory: {
-          action: "external_directory",
-          directory: externalDirectory,
-          resource: externalResource,
-          save: slash(
-            path.join((yield* Project.root(fs, AbsolutePath.make(externalDirectory))) ?? externalDirectory, "*"),
-          ),
-        },
+        canonical: resolved.canonical,
+        resource,
+        externalDirectory: external
+          ? {
+              action: "external_directory",
+              directory: externalDirectory,
+              resource: externalResource,
+              save: slash(
+                path.join((yield* Project.root(fs, AbsolutePath.make(externalDirectory))) ?? externalDirectory, "*"),
+              ),
+            }
+          : undefined,
       } satisfies Target
     })
 

packages/core/src/location-services.ts

@@ -8,7 +8,6 @@ import { LayerNode } from "@opencode-ai/util/effect/layer-node"
 import { Node } from "@opencode-ai/util/effect/app-node"
 import { Bus } from "./bus"
 import { FileMutation } from "./file-mutation"
-import { Environment } from "./environment"
 import { Formatter } from "./formatter"
 import { FileSystem } from "./filesystem"
 import { FileSystemSearch } from "./filesystem/search"
@@ -47,14 +46,12 @@ import { SessionGenerateNode } from "./session/generate-node"
 import { McpTool } from "./tool/mcp"
 import { ReadToolFileSystem } from "./tool/read-filesystem"
 import { Tool } from "./tool"
-import { ToolOutput } from "./tool-output"
 import { Vcs } from "./vcs"
 
 export { LocationServiceMap } from "./location-service-map"
 
 const locationServiceNodes = [
   Location.node,
-  Environment.node,
   Config.node,
   Agent.node,
   Command.node,
@@ -81,7 +78,6 @@ const locationServiceNodes = [
   MCP.node,
   Permission.node,
   Tool.node,
-  ToolOutput.node,
   Image.node,
   SkillInstructions.node,
   ReferenceInstructions.node,

packages/core/src/model-resolver.ts

@@ -5,6 +5,8 @@ import { LanguageModel } from "@opencode-ai/ai"
 // ast-grep-ignore: no-star-import
 import * as AnthropicMessages from "@opencode-ai/ai/protocols/anthropic-messages"
 // ast-grep-ignore: no-star-import
+import * as OpenAICompatibleChat from "@opencode-ai/ai/protocols/openai-compatible-chat"
+// ast-grep-ignore: no-star-import
 import * as OpenAIResponses from "@opencode-ai/ai/protocols/openai-responses"
 import { Auth, type AnyRoute } from "@opencode-ai/ai/route"
 import { Context, Effect, Layer, Schema } from "effect"
@@ -162,6 +164,17 @@ export const fromCatalogModel = (
         .model({ id: resolved.modelID ?? resolved.id, compatibility: resolved.compatibility }),
     )
   }
+  if (
+    Provider.isAISDK(resolved.package) &&
+    packageName === "@ai-sdk/openai-compatible" &&
+    typeof resolved.settings?.baseURL === "string"
+  ) {
+    return Effect.succeed(
+      withDefaults(resolved, OpenAICompatibleChat.route)
+        .with({ auth: key === undefined ? Auth.none : Auth.bearer(key) })
+        .model({ id: resolved.modelID ?? resolved.id, compatibility: resolved.compatibility }),
+    )
+  }
   const configured = { ...resolved.settings, ...credential?.metadata }
   const mapping = Provider.isAISDK(resolved.package)
     ? AISDKNative.map({

packages/core/src/plugin/internal.ts

@@ -16,7 +16,6 @@ import { ConfigReferencePlugin } from "../config/plugin/reference"
 import { ConfigSkillPlugin } from "../config/plugin/skill"
 import { ConfigWebSearchPlugin } from "../config/plugin/websearch"
 import { Bus } from "../bus"
-import { Environment } from "../environment"
 import { FileMutation } from "../file-mutation"
 import { Formatter } from "../formatter"
 import { Form } from "../form"
@@ -71,7 +70,6 @@ const services = Effect.fn("PluginInternal.services")(function* () {
   const config = yield* Config.Service
   const credential = yield* Credential.Service
   const bus = yield* Bus.Service
-  const environment = yield* Environment.Service
   const mutation = yield* FileMutation.Service
   const formatter = yield* Formatter.Service
   const filesystem = yield* FileSystem.Service
@@ -104,7 +102,6 @@ const services = Effect.fn("PluginInternal.services")(function* () {
     Context.make(Config.Service, config),
     Context.make(Credential.Service, credential),
     Context.make(Bus.Service, bus),
-    Context.make(Environment.Service, environment),
     Context.make(FileMutation.Service, mutation),
     Context.make(Formatter.Service, formatter),
     Context.make(FileSystem.Service, filesystem),

packages/core/src/plugin/supervisor.ts

@@ -14,7 +14,6 @@ import { Credential } from "../credential"
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
 import { httpClient } from "@opencode-ai/util/effect/app-node-platform"
 import { Bus } from "../bus"
-import { Environment } from "../environment"
 import { FileMutation } from "../file-mutation"
 import { Formatter } from "../formatter"
 import { FileSystem } from "../filesystem"
@@ -283,9 +282,7 @@ const layer = Layer.effect(
     })
     const updates = Stream.merge(
       config.changes().pipe(
-        Stream.filterEffect((update) =>
-          Effect.map(config.entries(), (entries) => isPluginSource(entries, update.path)),
-        ),
+        Stream.filterEffect((update) => Effect.map(config.entries(), (entries) => isPluginSource(entries, update.path))),
         Stream.merge(Stream.fromPubSub(configuredChanges)),
       ),
       bus.subscribe([Event.Updated, SdkPlugins.Updated]),
@@ -323,7 +320,6 @@ export const node = makeLocationNode({
     Config.node,
     Credential.node,
     Bus.node,
-    Environment.node,
     FileMutation.node,
     Formatter.node,
     FileSystem.node,

packages/core/src/plugin/websearch/firecrawl.ts

@@ -1,84 +0,0 @@
-export * as WebSearchFirecrawl from "./firecrawl"
-
-import { define } from "@opencode-ai/plugin/effect/plugin"
-import { Effect, Option, Schema, Scope } from "effect"
-import { HttpClient } from "effect/unstable/http"
-import { App } from "../../app"
-import { WebSearchMcp } from "./mcp"
-
-export const endpoint = "https://mcp.firecrawl.dev/v2/mcp"
-
-const McpInput = Schema.Struct({
-  query: Schema.String,
-  limit: Schema.Number.pipe(Schema.optional),
-})
-
-const McpOutput = Schema.Struct({
-  content: Schema.Array(Schema.Struct({ type: Schema.Literal("text"), text: Schema.String })),
-})
-
-const SearchResponse = Schema.fromJsonString(
-  Schema.Struct({
-    success: Schema.Boolean,
-    data: Schema.Struct({
-      web: Schema.Array(
-        Schema.Struct({
-          url: Schema.String,
-          title: Schema.NullOr(Schema.String).pipe(Schema.optional),
-          description: Schema.NullOr(Schema.String).pipe(Schema.optional),
-        }),
-      ),
-    }),
-  }),
-)
-const decodeSearchResponse = Schema.decodeUnknownOption(SearchResponse)
-
-export const Plugin = define<HttpClient.HttpClient | Scope.Scope>({
-  id: "opencode.websearch.firecrawl",
-  effect: Effect.fn("WebSearchFirecrawl.Plugin")(function* (ctx) {
-    const http = yield* HttpClient.HttpClient
-    yield* ctx.integration.transform((draft) => {
-      draft.update("firecrawl", (integration) => (integration.name = "Firecrawl"))
-      draft.method.update({
-        integrationID: "firecrawl",
-        method: { type: "key", label: "API key (optional)" },
-      })
-      draft.method.update({
-        integrationID: "firecrawl",
-        method: { type: "env", names: ["FIRECRAWL_API_KEY"] },
-      })
-    })
-    yield* ctx.websearch.transform((draft) => {
-      draft.add({
-        id: "firecrawl",
-        name: "Firecrawl",
-        execute: (input) =>
-          Effect.gen(function* () {
-            const connection = yield* ctx.integration.connection.active("firecrawl")
-            const credential = connection ? yield* ctx.integration.connection.resolve(connection) : undefined
-            const result = yield* WebSearchMcp.call(
-              http,
-              endpoint,
-              "firecrawl_search",
-              { input: McpInput, output: McpOutput },
-              { query: input.query, limit: 8 },
-              {
-                "User-Agent": App.useragent(ctx.app),
-                ...(credential?.type === "key" ? { Authorization: `Bearer ${credential.key}` } : {}),
-              },
-            )
-            const content = result?.content.find((item) => item.text)
-            const response = content ? Option.getOrUndefined(decodeSearchResponse(content.text)) : undefined
-            return (
-              response?.data.web.map((item) => ({
-                url: item.url,
-                ...(item.title ? { title: item.title } : {}),
-                ...(item.description ? { content: item.description } : {}),
-                time: {},
-              })) ?? []
-            )
-          }),
-      })
-    })
-  }),
-})

packages/core/src/plugin/websearch/index.ts

@@ -1,5 +1,4 @@
 import { WebSearchExa } from "./exa"
-import { WebSearchFirecrawl } from "./firecrawl"
 import { WebSearchParallel } from "./parallel"
 
-export const WebSearchPlugins = [WebSearchExa.Plugin, WebSearchFirecrawl.Plugin, WebSearchParallel.Plugin] as const
+export const WebSearchPlugins = [WebSearchExa.Plugin, WebSearchParallel.Plugin] as const

packages/core/src/ripgrep.ts

@@ -3,9 +3,8 @@ export * as Ripgrep from "./ripgrep"
 import { Context, Effect, Fiber, Layer, Schema, Stream } from "effect"
 import { ChildProcess } from "effect/unstable/process"
 import { Entry, Match } from "@opencode-ai/schema/filesystem"
-import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
-import { collectStream, waitForAbort } from "@opencode-ai/util/process"
-import { Environment } from "./environment"
+import { makeGlobalNode } from "@opencode-ai/util/effect/app-node"
+import { AppProcess, collectStream, waitForAbort } from "@opencode-ai/util/process"
 import { NonNegativeInt, PositiveInt, RelativePath } from "./schema"
 import { RipgrepBinary } from "./ripgrep/binary"
 
@@ -94,7 +93,7 @@ const isInvalidPattern = (stderr: string) =>
 const layer = Layer.effect(
   Service,
   Effect.gen(function* () {
-    const environment = yield* Environment.Service
+    const process = yield* AppProcess.Service
     const binary = yield* RipgrepBinary.Service
 
     const run = <A>(input: {
@@ -108,8 +107,7 @@ const layer = Layer.effect(
     }) => {
       const program = Effect.scoped(
         Effect.gen(function* () {
-          // Hosted environments will resolve rg through their driver image; the spawner is the execution seam.
-          const handle = yield* environment.spawner.spawn(
+          const handle = yield* process.spawn(
             ChildProcess.make(yield* binary.filepath, input.args, { cwd: input.cwd, extendEnv: true, stdin: "ignore" }),
           )
           const stderrFiber = yield* collectStream(handle.stderr, ERROR_BYTES).pipe(
@@ -277,4 +275,4 @@ const layer = Layer.effect(
   }),
 )
 
-export const node = makeLocationNode({ service: Service, layer, deps: [Environment.node, RipgrepBinary.node] })
+export const node = makeGlobalNode({ service: Service, layer: layer, deps: [RipgrepBinary.node, AppProcess.node] })

packages/core/src/session.ts

@@ -133,14 +133,6 @@ export class CompactionConflictError extends Schema.TaggedErrorClass<CompactionC
 export class BusyError extends Schema.TaggedErrorClass<BusyError>()("Session.BusyError", {
   sessionID: SessionSchema.ID,
 }) {}
-export class PendingInputConflictError extends Schema.TaggedErrorClass<PendingInputConflictError>()(
-  "Session.PendingInputConflictError",
-  {
-    sessionID: SessionSchema.ID,
-    inputID: SessionMessage.ID,
-  },
-) {}
-type PendingInputRef = { readonly sessionID: SessionSchema.ID; readonly inputID: SessionMessage.ID }
 export class SkillNotFoundError extends Schema.TaggedErrorClass<SkillNotFoundError>()("Session.SkillNotFoundError", {
   skill: Skill.ID,
 }) {}
@@ -189,9 +181,6 @@ export interface Interface {
    * unhandled compaction barriers.
    */
   readonly pending: (sessionID: SessionSchema.ID) => Effect.Effect<SessionPending.Info[], NotFoundError>
-  readonly cancelPending: (input: PendingInputRef) => Effect.Effect<void, NotFoundError | PendingInputConflictError>
-  readonly steerPending: (input: PendingInputRef) => Effect.Effect<void, NotFoundError | PendingInputConflictError>
-  readonly queuePending: (input: PendingInputRef) => Effect.Effect<void, NotFoundError | PendingInputConflictError>
   /**
    * Durable, ordered session log read. Replays durable session bus after
    * the exclusive `after` cursor, emits a `Synced` marker at the captured
@@ -329,31 +318,6 @@ const layer = Layer.effect(
         ),
       )
 
-    const pendingConflict = Effect.fn("Session.pendingConflict")(function* (input: PendingInputRef) {
-      yield* result.get(input.sessionID)
-      return yield* new PendingInputConflictError(input)
-    })
-    const mutatePending = (
-      input: PendingInputRef,
-      mutation: (
-        bus: Bus.Interface,
-        input: { readonly id: SessionMessage.ID; readonly sessionID: SessionSchema.ID },
-      ) => Effect.Effect<unknown>,
-      wake = false,
-    ) =>
-      Effect.uninterruptible(
-        Effect.gen(function* () {
-          yield* mutation(bus, { sessionID: input.sessionID, id: input.inputID }).pipe(
-            Effect.catchDefect((defect) =>
-              defect instanceof SessionPending.LifecycleConflict
-                ? pendingConflict(input)
-                : Effect.die(defect),
-            ),
-          )
-          if (wake) yield* execution.wake(input.sessionID)
-        }),
-      )
-
     const result = Service.of({
       create: Effect.fn("Session.create")(function* (input) {
         const sessionID = input.id ?? SessionSchema.ID.create()
@@ -543,9 +507,6 @@ const layer = Layer.effect(
         yield* result.get(sessionID)
         return yield* SessionPending.list(db, sessionID)
       }),
-      cancelPending: Effect.fn("Session.cancelPending")((input) => mutatePending(input, SessionPending.cancel)),
-      steerPending: Effect.fn("Session.steerPending")((input) => mutatePending(input, SessionPending.steer, true)),
-      queuePending: Effect.fn("Session.queuePending")((input) => mutatePending(input, SessionPending.queue)),
       log: (input) =>
         Stream.unwrap(
           result

packages/core/src/session/execution/restart.ts

@@ -2,14 +2,9 @@ export * as SessionRestart from "./restart"
 
 import { Context, Effect, Layer } from "effect"
 import { makeGlobalNode } from "@opencode-ai/util/effect/app-node"
-import { Bus } from "../../bus"
-import { SessionEvent } from "../event"
 import { SessionExecution } from "../execution"
 import { SessionStore } from "../store"
 
-const CONTINUE_AFTER_SERVER_RESTART =
-  "The server restarted while you were working. Continue from where you left off without repeating completed work."
-
 export interface Interface {
   /**
    * Marks every execution active in this process for resumption by the next server start.
@@ -31,7 +26,6 @@ export const layer = Layer.effect(
   Effect.gen(function* () {
     const store = yield* SessionStore.Service
     const execution = yield* SessionExecution.Service
-    const bus = yield* Bus.Service
     return Service.of({
       suspendActiveSessions: Effect.gen(function* () {
         yield* store.suspend(yield* execution.active)
@@ -43,11 +37,6 @@ export const layer = Layer.effect(
           (sessionID) =>
             Effect.gen(function* () {
               if (!(yield* store.consumeSuspended(sessionID))) return
-              yield* bus.publish(SessionEvent.Synthetic, {
-                sessionID,
-                text: CONTINUE_AFTER_SERVER_RESTART,
-                description: "Continuing after restart",
-              })
               // Drain failures are already logged and durably recorded by the execution layer.
               yield* Effect.ignore(execution.resume(sessionID))
             }),
@@ -58,8 +47,4 @@ export const layer = Layer.effect(
   }),
 )
 
-export const node = makeGlobalNode({
-  service: Service,
-  layer,
-  deps: [SessionStore.node, SessionExecution.node, Bus.node],
-})
+export const node = makeGlobalNode({ service: Service, layer, deps: [SessionStore.node, SessionExecution.node] })

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

@@ -90,9 +90,6 @@ export function update(adapter: Adapter, event: SessionEvent.DurableEvent) {
       "session.forked": () => Effect.void,
       "session.input.promoted": () => Effect.void,
       "session.input.admitted": () => Effect.void,
-      "session.input.cancelled": () => Effect.void,
-      "session.input.steered": () => Effect.void,
-      "session.input.queued": () => Effect.void,
       "session.execution.started": () => Effect.void,
       "session.execution.succeeded": () => clearCurrentRetry,
       "session.execution.failed": () => clearCurrentRetry,

packages/core/src/session/pending.ts

@@ -37,7 +37,6 @@ const decodeSynthetic = Schema.decodeUnknownSync(SyntheticData)
 const encodeSynthetic = Schema.encodeSync(SyntheticData)
 const decodeMessage = Schema.decodeUnknownSync(SessionMessage.Info)
 const inboxLocks = KeyedMutex.makeUnsafe<SessionSchema.ID>()
-type PendingRef = { readonly id: SessionMessage.ID; readonly sessionID: SessionSchema.ID }
 
 export class LifecycleConflict extends Schema.TaggedErrorClass<LifecycleConflict>()(
   "SessionPending.LifecycleConflict",
@@ -295,7 +294,10 @@ export const projectCompactionAdmitted = Effect.fn("SessionPending.projectCompac
  */
 export const projectPromoted = Effect.fn("SessionPending.projectPromoted")(function* (
   db: DatabaseService,
-  input: PendingRef,
+  input: {
+    readonly id: SessionMessage.ID
+    readonly sessionID: SessionSchema.ID
+  },
 ) {
   if (yield* compaction(db, input.sessionID)) return yield* Effect.die(new LifecycleConflict({ id: input.id }))
   const deleted = yield* db
@@ -310,55 +312,6 @@ export const projectPromoted = Effect.fn("SessionPending.projectPromoted")(funct
   return stored
 })
 
-export const projectCancelled = Effect.fn("SessionPending.projectCancelled")(function* (
-  db: DatabaseService,
-  input: PendingRef,
-) {
-  const deleted = yield* db
-    .delete(SessionPendingTable)
-    .where(
-      and(
-        eq(SessionPendingTable.id, input.id),
-        eq(SessionPendingTable.session_id, input.sessionID),
-        or(eq(SessionPendingTable.delivery, "queue"), eq(SessionPendingTable.delivery, "steer")),
-      ),
-    )
-    .returning({ id: SessionPendingTable.id })
-    .get()
-    .pipe(Effect.orDie)
-  if (!deleted) return yield* Effect.die(new LifecycleConflict({ id: input.id }))
-})
-
-const projectDelivery = Effect.fn("SessionPending.projectDelivery")(function* (
-  db: DatabaseService,
-  input: PendingRef & { readonly from: Delivery; readonly to: Delivery },
-) {
-  const updated = yield* db
-    .update(SessionPendingTable)
-    .set({ delivery: input.to })
-    .where(
-      and(
-        eq(SessionPendingTable.id, input.id),
-        eq(SessionPendingTable.session_id, input.sessionID),
-        eq(SessionPendingTable.delivery, input.from),
-      ),
-    )
-    .returning({ id: SessionPendingTable.id })
-    .get()
-    .pipe(Effect.orDie)
-  if (!updated) return yield* Effect.die(new LifecycleConflict({ id: input.id }))
-})
-
-export const projectSteered = Effect.fn("SessionPending.projectSteered")(
-  (db: DatabaseService, input: PendingRef) =>
-    projectDelivery(db, { ...input, from: "queue", to: "steer" }),
-)
-
-export const projectQueued = Effect.fn("SessionPending.projectQueued")(
-  (db: DatabaseService, input: PendingRef) =>
-    projectDelivery(db, { ...input, from: "steer", to: "queue" }),
-)
-
 export const settleCompaction = Effect.fn("SessionPending.settleCompaction")(function* (
   db: DatabaseService,
   input: { readonly sessionID: SessionSchema.ID },
@@ -436,39 +389,6 @@ export const equivalent = (
   return false
 }
 
-const publishMutation = <A, E, R>(input: PendingRef, effect: Effect.Effect<A, E, R>) =>
-  inboxLocks.withLock(input.sessionID)(effect).pipe(Effect.asVoid)
-
-export const cancel = Effect.fn("SessionPending.cancel")((bus: Bus.Interface, input: PendingRef) =>
-  publishMutation(
-    input,
-    bus.publish(SessionEvent.InputCancelled, {
-      sessionID: input.sessionID,
-      inputID: input.id,
-    }),
-  ),
-)
-
-export const steer = Effect.fn("SessionPending.steer")((bus: Bus.Interface, input: PendingRef) =>
-  publishMutation(
-    input,
-    bus.publish(SessionEvent.InputSteered, {
-      sessionID: input.sessionID,
-      inputID: input.id,
-    }),
-  ),
-)
-
-export const queue = Effect.fn("SessionPending.queue")((bus: Bus.Interface, input: PendingRef) =>
-  publishMutation(
-    input,
-    bus.publish(SessionEvent.InputQueued, {
-      sessionID: input.sessionID,
-      inputID: input.id,
-    }),
-  ),
-)
-
 const publish = Effect.fn("SessionPending.publish")(function* (
   db: DatabaseService,
   bus: Bus.Interface,

packages/core/src/session/projector.ts

@@ -485,24 +485,6 @@ const layer = Layer.effectDiscard(
           .pipe(Effect.orDie)
       }),
     )
-    yield* bus.project(SessionEvent.InputCancelled, (event) =>
-      SessionPending.projectCancelled(db, {
-        id: event.data.inputID,
-        sessionID: event.data.sessionID,
-      }),
-    )
-    yield* bus.project(SessionEvent.InputSteered, (event) =>
-      SessionPending.projectSteered(db, {
-        id: event.data.inputID,
-        sessionID: event.data.sessionID,
-      }),
-    )
-    yield* bus.project(SessionEvent.InputQueued, (event) =>
-      SessionPending.projectQueued(db, {
-        id: event.data.inputID,
-        sessionID: event.data.sessionID,
-      }),
-    )
     yield* bus.project(SessionEvent.Compaction.Admitted, (event) =>
       Effect.gen(function* () {
         if (event.durable === undefined)

packages/core/src/session/runner/llm.ts

@@ -32,7 +32,6 @@ import { StepFailedError } from "../error"
 import { toSessionError } from "../to-session-error"
 import { SessionRunnerRetry } from "./retry"
 import { SessionUsage } from "../usage"
-import { ToolOutput } from "../../tool-output"
 
 /** How one model call ended: settled, awaiting a scheduled retry, or restarted by compaction. */
 type CallOutcome = Data.TaggedEnum<{
@@ -108,7 +107,6 @@ const layer = Layer.effect(
     const db = (yield* Database.Service).db
     const compaction = yield* SessionCompaction.Service
     const title = yield* SessionTitle.Service
-    const toolOutput = yield* ToolOutput.Service
     // Title generation is a side effect of a successful step; it must not delay continuation.
     // The in-flight set coalesces overlapping steps while title presence records success durably.
     const titlesRunning = new Set<SessionSchema.ID>()
@@ -336,7 +334,6 @@ const layer = Layer.effect(
                 ).pipe(
                   // The fiber owns its call: it publishes its own completion, masked so a
                   // finished execution always reaches its durable settlement.
-                  Effect.flatMap(toolOutput.truncate),
                   Effect.flatMap((outcome) => publisher.toolExecution(event.id, event.name, outcome)),
                   Effect.catchTag("Tool.Error", (error) =>
                     publisher.failTool(event.id, toSessionError(error)).pipe(Effect.asVoid),
@@ -565,7 +562,6 @@ export const node = makeLocationNode({
     SessionCompaction.node,
     SessionTitle.node,
     Snapshot.node,
-    ToolOutput.node,
     Database.node,
   ],
 })

packages/core/src/shell.ts

@@ -6,9 +6,9 @@ import { ChildProcess } from "effect/unstable/process"
 import { produce } from "immer"
 import { Shell } from "@opencode-ai/schema/shell"
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
+import { AppProcess } from "@opencode-ai/util/process"
 import { Config } from "./config"
 import { Bus } from "./bus"
-import { Environment } from "./environment"
 import { Location } from "./location"
 import { Global } from "@opencode-ai/util/global"
 import { ShellSelect } from "./shell/select"
@@ -65,284 +65,285 @@ export interface Interface {
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/Shell") {}
 
-export const layer = (options?: ShellSelect.Options) =>
-  Layer.effect(
-    Service,
-    Effect.gen(function* () {
-      const bus = yield* Bus.Service
-      const location = yield* Location.Service
-      const config = yield* Config.Service
-      const global = yield* Global.Service
-      const environment = yield* Environment.Service
-      const hooks = yield* PluginHooks.Service
-      const context = yield* Effect.context()
-      const runFork = Effect.runForkWith(context)
-      const sessions = new Map<string, Active>()
-      const exitOrder: string[] = []
+export const layer = (options?: ShellSelect.Options) => Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    const bus = yield* Bus.Service
+    const location = yield* Location.Service
+    const config = yield* Config.Service
+    const global = yield* Global.Service
+    const appProcess = yield* AppProcess.Service
+    const hooks = yield* PluginHooks.Service
+    const context = yield* Effect.context()
+    const runFork = Effect.runForkWith(context)
+    const sessions = new Map<string, Active>()
+    const exitOrder: string[] = []
 
-      const outputDir = path.join(global.data, "shell", location.project.id)
-      const { mkdir, unlink } = yield* Effect.promise(() => import("fs/promises"))
-      const { createWriteStream, createReadStream } = yield* Effect.promise(() => import("fs"))
-      yield* Effect.promise(() => mkdir(outputDir, { recursive: true }))
+    const outputDir = path.join(global.data, "shell", location.project.id)
+    const { mkdir, unlink } = yield* Effect.promise(() => import("fs/promises"))
+    const { createWriteStream, createReadStream } = yield* Effect.promise(() => import("fs"))
+    yield* Effect.promise(() => mkdir(outputDir, { recursive: true }))
 
-      yield* Effect.addFinalizer(() =>
-        Effect.gen(function* () {
-          for (const session of sessions.values()) {
-            if (session.timeoutFiber) yield* Fiber.interrupt(session.timeoutFiber)
-            // Unblock waiters still pending at teardown; succeed is a no-op once already resolved.
-            yield* Deferred.fail(session.done, new NotFoundError({ id: Shell.ID.make(session.info.id) }))
-          }
-          sessions.clear()
-          exitOrder.length = 0
-        }),
+    yield* Effect.addFinalizer(() =>
+      Effect.gen(function* () {
+        for (const session of sessions.values()) {
+          if (session.timeoutFiber) yield* Fiber.interrupt(session.timeoutFiber)
+          // Unblock waiters still pending at teardown; succeed is a no-op once already resolved.
+          yield* Deferred.fail(session.done, new NotFoundError({ id: Shell.ID.make(session.info.id) }))
+        }
+        sessions.clear()
+        exitOrder.length = 0
+      }),
+    )
+
+    const require = Effect.fn("Shell.require")(function* (id: Shell.ID) {
+      const session = sessions.get(id)
+      if (!session) return yield* new NotFoundError({ id })
+      return session
+    })
+
+    const removeSession = Effect.fnUntraced(function* (id: Shell.ID) {
+      const session = sessions.get(id)
+      if (!session) return
+      sessions.delete(id)
+      const index = exitOrder.indexOf(id)
+      if (index !== -1) exitOrder.splice(index, 1)
+      if (session.timeoutFiber) yield* Fiber.interrupt(session.timeoutFiber)
+      // Unblock any wait still pending when the command is removed before it terminated.
+      yield* Deferred.fail(session.done, new NotFoundError({ id }))
+      yield* Effect.promise(() => unlink(session.file).catch(() => {}))
+      yield* bus.publish(Shell.Event.Deleted, { id })
+    })
+
+    const remove = Effect.fn("Shell.remove")(function* (id: Shell.ID) {
+      yield* require(id)
+      yield* removeSession(id)
+    })
+
+    const list = Effect.fn("Shell.list")(function* () {
+      return Array.from(sessions.values())
+        .filter((session) => session.info.status === "running")
+        .map((session) => session.info)
+    })
+
+    const get = Effect.fn("Shell.get")(function* (id: Shell.ID) {
+      return (yield* require(id)).info
+    })
+
+    const wait = Effect.fn("Shell.wait")(function* (id: Shell.ID) {
+      return yield* Deferred.await((yield* require(id)).done)
+    })
+
+    const timeout = Effect.fn("Shell.timeout")(function* (id: Shell.ID, duration: number) {
+      const session = yield* require(id)
+      if (session.info.status !== "running" || !session.timeout) return session.info
+      yield* session.timeout(duration)
+      return session.info
+    })
+
+    const resolve = () =>
+      config
+        .entries()
+        .pipe(Effect.map((entries) => ShellSelect.preferred(Config.latest(entries, "shell"), options)))
+
+    const name = () => resolve().pipe(Effect.map(ShellSelect.name))
+
+    const output = Effect.fn("Shell.output")(function* (id: Shell.ID, input?: Shell.OutputInput) {
+      const session = yield* require(id)
+      const cursor = input?.cursor ?? 0
+      const limit = input?.limit ?? 65536
+      if (cursor >= session.size) return { output: "", cursor: session.size, size: session.size, truncated: false }
+      const start = Math.max(0, cursor)
+      const length = Math.min(limit, session.size - start)
+      const buffer = Buffer.alloc(length)
+      const bytesRead = yield* Effect.promise(
+        () =>
+          new Promise<number>((resolve) => {
+            const stream = createReadStream(session.file, { start, end: start + length - 1 })
+            let offset = 0
+            stream.on("data", (chunk: string | Buffer) => {
+              const bytes = Buffer.from(chunk)
+              bytes.copy(buffer, offset)
+              offset += bytes.length
+            })
+            stream.on("end", () => resolve(offset))
+            stream.on("error", () => resolve(0))
+          }),
+      )
+      return {
+        output: buffer.subarray(0, bytesRead).toString("utf8"),
+        cursor: start + bytesRead,
+        size: session.size,
+        truncated: false,
+      }
+    })
+
+    const create = Effect.fn("Shell.create")(function* <E = never, R = never>(
+      input: Shell.CreateInput,
+      before?: (input: ShellCreateBefore) => Effect.Effect<void, E, R>,
+    ) {
+      const invocation: ShellCreateBefore = {
+        command: input.command,
+        cwd: input.cwd ?? location.directory,
+        timeout: input.timeout,
+        shell: yield* resolve(),
+        env: {
+          ...process.env,
+          TERM: "xterm-256color",
+          OPENCODE_TERMINAL: "1",
+        },
+      }
+      yield* hooks.trigger("shell", "create.before", invocation)
+      if (before) yield* before(invocation)
+
+      const id = Shell.ID.ascending()
+      const args = ShellSelect.args(invocation.shell, invocation.command)
+      const file = path.join(outputDir, `${id}.out`)
+
+      const info: Info = {
+        id,
+        status: "running",
+        command: invocation.command,
+        cwd: invocation.cwd,
+        shell: invocation.shell,
+        file,
+        metadata: input.metadata ?? {},
+        time: { started: Date.now() },
+      }
+
+      // Spawn via AppProcess and stream combined output to the file. The handle is scope-bound, so
+      // the managing fiber keeps its scope open until the command terminates (it awaits `done` at the
+      // end). `create` returns once `ready` resolves with the registered session.
+      const ready = Deferred.makeUnsafe<Active>()
+      runFork(
+        Effect.scoped(
+          Effect.gen(function* () {
+            const handle = yield* appProcess.spawn(
+              ChildProcess.make(invocation.shell, args, {
+                cwd: invocation.cwd,
+                env: invocation.env,
+                stdin: "ignore",
+                detached: process.platform !== "win32",
+                forceKillAfter: Duration.seconds(3),
+              }),
+            )
+            const session: Active = {
+              info: produce(info, (draft) => {
+                draft.pid = handle.pid
+              }),
+              file,
+              size: 0,
+              done: Deferred.makeUnsafe<Info, NotFoundError>(),
+            }
+            sessions.set(id, session)
+
+            const stream = createWriteStream(file)
+            const outputDone = Deferred.makeUnsafe<void>()
+            const pump = handle.all.pipe(
+              Stream.runForEach((chunk: Uint8Array) =>
+                Effect.sync(() => {
+                  stream.write(chunk)
+                  session.size += chunk.length
+                }),
+              ),
+            )
+            runFork(
+              Effect.gen(function* () {
+                yield* pump.pipe(Effect.catch(() => Effect.void))
+                yield* Effect.promise(
+                  () =>
+                    new Promise<void>((resolve) => {
+                      stream.end(() => resolve())
+                    }),
+                )
+                yield* Deferred.succeed(outputDone, undefined)
+              }).pipe(Effect.catch(() => Deferred.succeed(outputDone, undefined))),
+            )
+            yield* Effect.promise(
+              () =>
+                new Promise<void>((resolve) => {
+                  stream.once("open", () => resolve())
+                  stream.once("error", () => resolve())
+                }),
+            )
+
+            const finish = (status: Info["status"], exit?: number, beforeWait = Effect.void) =>
+              Effect.gen(function* () {
+                if (session.info.status !== "running") return
+                session.info = produce(session.info, (draft) => {
+                  draft.status = status
+                  if (exit !== undefined) draft.exit = exit
+                  draft.time.completed = Date.now()
+                })
+                yield* beforeWait
+                yield* Deferred.await(outputDone)
+                // Resolve waiters with the terminal Info before any retention eviction, so an evicted
+                // session still reports success rather than the removal NotFoundError. This runs before
+                // the timeout-fiber interrupt below, which on the timeout path would otherwise cancel
+                // this very fiber (finish is invoked by the timeout fiber) before waiters are resolved.
+                yield* Deferred.succeed(session.done, session.info)
+                yield* bus.publish(Shell.Event.Exited, {
+                  id,
+                  ...(exit !== undefined ? { exit } : {}),
+                  status,
+                })
+                exitOrder.push(id)
+                while (exitOrder.length > EXITED_LIMIT) {
+                  const oldest = exitOrder[0]
+                  if (!oldest) break
+                  yield* removeSession(Shell.ID.make(oldest))
+                }
+                // Cancel a pending timeout once the command exits on its own. Interrupting last avoids
+                // aborting finish when finish itself runs on the timeout fiber.
+                if (session.timeoutFiber) yield* Fiber.interrupt(session.timeoutFiber)
+              })
+
+            session.timeout = (duration) =>
+              Effect.gen(function* () {
+                if (session.timeoutFiber) yield* Fiber.interrupt(session.timeoutFiber)
+                session.timeoutFiber = undefined
+                if (duration === 0 || session.info.status !== "running") return
+                session.timeoutFiber = runFork(
+                  Effect.sleep(Duration.millis(duration)).pipe(
+                    Effect.flatMap(() =>
+                      finish("timeout", undefined, handle.kill().pipe(Effect.catch(() => Effect.void))),
+                    ),
+                    Effect.catch(() => Effect.void),
+                  ),
+                )
+              })
+
+            yield* session.timeout(invocation.timeout)
+
+            runFork(
+              handle.exitCode.pipe(
+                Effect.flatMap((code) => finish("exited", code)),
+                Effect.catch(() => Effect.void),
+              ),
+            )
+
+            yield* bus.publish(Shell.Event.Created, { info })
+            yield* Deferred.succeed(ready, session)
+            // Hold the handle's scope open until the command terminates; closing it earlier would
+            // release (kill) the process before its exit is observed.
+            yield* Deferred.await(session.done).pipe(Effect.catch(() => Effect.void))
+          }),
+        ).pipe(Effect.catch(() => Effect.void)),
       )
 
-      const require = Effect.fn("Shell.require")(function* (id: Shell.ID) {
-        const session = sessions.get(id)
-        if (!session) return yield* new NotFoundError({ id })
-        return session
-      })
+      const session = yield* Deferred.await(ready)
+      return session.info
+    })
 
-      const removeSession = Effect.fnUntraced(function* (id: Shell.ID) {
-        const session = sessions.get(id)
-        if (!session) return
-        sessions.delete(id)
-        const index = exitOrder.indexOf(id)
-        if (index !== -1) exitOrder.splice(index, 1)
-        if (session.timeoutFiber) yield* Fiber.interrupt(session.timeoutFiber)
-        // Unblock any wait still pending when the command is removed before it terminated.
-        yield* Deferred.fail(session.done, new NotFoundError({ id }))
-        yield* Effect.promise(() => unlink(session.file).catch(() => {}))
-        yield* bus.publish(Shell.Event.Deleted, { id })
-      })
-
-      const remove = Effect.fn("Shell.remove")(function* (id: Shell.ID) {
-        yield* require(id)
-        yield* removeSession(id)
-      })
-
-      const list = Effect.fn("Shell.list")(function* () {
-        return Array.from(sessions.values())
-          .filter((session) => session.info.status === "running")
-          .map((session) => session.info)
-      })
-
-      const get = Effect.fn("Shell.get")(function* (id: Shell.ID) {
-        return (yield* require(id)).info
-      })
-
-      const wait = Effect.fn("Shell.wait")(function* (id: Shell.ID) {
-        return yield* Deferred.await((yield* require(id)).done)
-      })
-
-      const timeout = Effect.fn("Shell.timeout")(function* (id: Shell.ID, duration: number) {
-        const session = yield* require(id)
-        if (session.info.status !== "running" || !session.timeout) return session.info
-        yield* session.timeout(duration)
-        return session.info
-      })
-
-      const resolve = () =>
-        config.entries().pipe(Effect.map((entries) => ShellSelect.preferred(Config.latest(entries, "shell"), options)))
-
-      const name = () => resolve().pipe(Effect.map(ShellSelect.name))
-
-      const output = Effect.fn("Shell.output")(function* (id: Shell.ID, input?: Shell.OutputInput) {
-        const session = yield* require(id)
-        const cursor = input?.cursor ?? 0
-        const limit = input?.limit ?? 65536
-        if (cursor >= session.size) return { output: "", cursor: session.size, size: session.size, truncated: false }
-        const start = Math.max(0, cursor)
-        const length = Math.min(limit, session.size - start)
-        const buffer = Buffer.alloc(length)
-        const bytesRead = yield* Effect.promise(
-          () =>
-            new Promise<number>((resolve) => {
-              const stream = createReadStream(session.file, { start, end: start + length - 1 })
-              let offset = 0
-              stream.on("data", (chunk: string | Buffer) => {
-                const bytes = Buffer.from(chunk)
-                bytes.copy(buffer, offset)
-                offset += bytes.length
-              })
-              stream.on("end", () => resolve(offset))
-              stream.on("error", () => resolve(0))
-            }),
-        )
-        return {
-          output: buffer.subarray(0, bytesRead).toString("utf8"),
-          cursor: start + bytesRead,
-          size: session.size,
-          truncated: false,
-        }
-      })
-
-      const create = Effect.fn("Shell.create")(function* <E = never, R = never>(
-        input: Shell.CreateInput,
-        before?: (input: ShellCreateBefore) => Effect.Effect<void, E, R>,
-      ) {
-        const invocation: ShellCreateBefore = {
-          command: input.command,
-          cwd: input.cwd ?? location.directory,
-          timeout: input.timeout,
-          shell: yield* resolve(),
-          env: {
-            ...process.env,
-            TERM: "xterm-256color",
-            OPENCODE_TERMINAL: "1",
-          },
-        }
-        yield* hooks.trigger("shell", "create.before", invocation)
-        if (before) yield* before(invocation)
-
-        const id = Shell.ID.ascending()
-        const args = ShellSelect.args(invocation.shell, invocation.command)
-        const file = path.join(outputDir, `${id}.out`)
-
-        const info: Info = {
-          id,
-          status: "running",
-          command: invocation.command,
-          cwd: invocation.cwd,
-          shell: invocation.shell,
-          file,
-          metadata: input.metadata ?? {},
-          time: { started: Date.now() },
-        }
-
-        // Spawn through the Environment and stream combined output to the file. The handle is scope-bound, so
-        // the managing fiber keeps its scope open until the command terminates (it awaits `done` at the
-        // end). `create` returns once `ready` resolves with the registered session.
-        const ready = Deferred.makeUnsafe<Active>()
-        runFork(
-          Effect.scoped(
-            Effect.gen(function* () {
-              const handle = yield* environment.spawner.spawn(
-                ChildProcess.make(invocation.shell, args, {
-                  cwd: invocation.cwd,
-                  env: invocation.env,
-                  stdin: "ignore",
-                  detached: process.platform !== "win32",
-                  forceKillAfter: Duration.seconds(3),
-                }),
-              )
-              const session: Active = {
-                info: produce(info, (draft) => {
-                  draft.pid = handle.pid
-                }),
-                file,
-                size: 0,
-                done: Deferred.makeUnsafe<Info, NotFoundError>(),
-              }
-              sessions.set(id, session)
-
-              const stream = createWriteStream(file)
-              const outputDone = Deferred.makeUnsafe<void>()
-              const pump = handle.all.pipe(
-                Stream.runForEach((chunk: Uint8Array) =>
-                  Effect.sync(() => {
-                    stream.write(chunk)
-                    session.size += chunk.length
-                  }),
-                ),
-              )
-              runFork(
-                Effect.gen(function* () {
-                  yield* pump.pipe(Effect.catch(() => Effect.void))
-                  yield* Effect.promise(
-                    () =>
-                      new Promise<void>((resolve) => {
-                        stream.end(() => resolve())
-                      }),
-                  )
-                  yield* Deferred.succeed(outputDone, undefined)
-                }).pipe(Effect.catch(() => Deferred.succeed(outputDone, undefined))),
-              )
-              yield* Effect.promise(
-                () =>
-                  new Promise<void>((resolve) => {
-                    stream.once("open", () => resolve())
-                    stream.once("error", () => resolve())
-                  }),
-              )
-
-              const finish = (status: Info["status"], exit?: number, beforeWait = Effect.void) =>
-                Effect.gen(function* () {
-                  if (session.info.status !== "running") return
-                  session.info = produce(session.info, (draft) => {
-                    draft.status = status
-                    if (exit !== undefined) draft.exit = exit
-                    draft.time.completed = Date.now()
-                  })
-                  yield* beforeWait
-                  yield* Deferred.await(outputDone)
-                  // Resolve waiters with the terminal Info before any retention eviction, so an evicted
-                  // session still reports success rather than the removal NotFoundError. This runs before
-                  // the timeout-fiber interrupt below, which on the timeout path would otherwise cancel
-                  // this very fiber (finish is invoked by the timeout fiber) before waiters are resolved.
-                  yield* Deferred.succeed(session.done, session.info)
-                  yield* bus.publish(Shell.Event.Exited, {
-                    id,
-                    ...(exit !== undefined ? { exit } : {}),
-                    status,
-                  })
-                  exitOrder.push(id)
-                  while (exitOrder.length > EXITED_LIMIT) {
-                    const oldest = exitOrder[0]
-                    if (!oldest) break
-                    yield* removeSession(Shell.ID.make(oldest))
-                  }
-                  // Cancel a pending timeout once the command exits on its own. Interrupting last avoids
-                  // aborting finish when finish itself runs on the timeout fiber.
-                  if (session.timeoutFiber) yield* Fiber.interrupt(session.timeoutFiber)
-                })
-
-              session.timeout = (duration) =>
-                Effect.gen(function* () {
-                  if (session.timeoutFiber) yield* Fiber.interrupt(session.timeoutFiber)
-                  session.timeoutFiber = undefined
-                  if (duration === 0 || session.info.status !== "running") return
-                  session.timeoutFiber = runFork(
-                    Effect.sleep(Duration.millis(duration)).pipe(
-                      Effect.flatMap(() =>
-                        finish("timeout", undefined, handle.kill().pipe(Effect.catch(() => Effect.void))),
-                      ),
-                      Effect.catch(() => Effect.void),
-                    ),
-                  )
-                })
-
-              yield* session.timeout(invocation.timeout)
-
-              runFork(
-                handle.exitCode.pipe(
-                  Effect.flatMap((code) => finish("exited", code)),
-                  Effect.catch(() => Effect.void),
-                ),
-              )
-
-              yield* bus.publish(Shell.Event.Created, { info })
-              yield* Deferred.succeed(ready, session)
-              // Hold the handle's scope open until the command terminates; closing it earlier would
-              // release (kill) the process before its exit is observed.
-              yield* Deferred.await(session.done).pipe(Effect.catch(() => Effect.void))
-            }),
-          ).pipe(Effect.catch(() => Effect.void)),
-        )
-
-        const session = yield* Deferred.await(ready)
-        return session.info
-      })
-
-      return Service.of({ name, create, list, get, wait, timeout, output, remove })
-    }),
-  )
+    return Service.of({ name, create, list, get, wait, timeout, output, remove })
+  }),
+)
 
 export function configured(options?: ShellSelect.Options) {
   return makeLocationNode({
     service: Service,
     layer: layer(options),
-    deps: [Bus.node, Location.node, Config.node, Global.node, Environment.node, PluginHooks.node],
+    deps: [Bus.node, Location.node, Config.node, Global.node, AppProcess.node, PluginHooks.node],
   })
 }
 

packages/core/src/skill.ts

@@ -2,7 +2,7 @@ export * as Skill from "./skill"
 
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
 import path from "path"
-import { Context, Effect, Layer, Schema, Scope, Stream, Types } from "effect"
+import { Context, Effect, Layer, Schema, Stream, Types } from "effect"
 import { FileSystem } from "@opencode-ai/schema/filesystem"
 import { Skill } from "@opencode-ai/schema/skill"
 import { Agent } from "./agent"
@@ -13,7 +13,6 @@ import { Permission } from "./permission"
 import { AbsolutePath } from "./schema"
 import { SkillDiscovery } from "./skill/discovery"
 import { State } from "./state"
-import { Watcher } from "./filesystem/watcher"
 
 export const DirectorySource = Skill.DirectorySource
 export type DirectorySource = Skill.DirectorySource
@@ -82,51 +81,6 @@ const layer = Layer.effect(
     const discovery = yield* SkillDiscovery.Service
     const fs = yield* FSUtil.Service
     const bus = yield* Bus.Service
-    const watcher = yield* Watcher.Service
-    const scope = yield* Scope.Scope
-    const cache = new Map<string, { skills: Info[]; paths: readonly string[] }>()
-    const watched = new Set<string>()
-
-    const invalidate = Effect.fn("Skill.invalidateFromWatcher")(function* (file: string) {
-      const invalidated = Array.from(cache.entries()).filter(([, loaded]) =>
-        loaded.paths.some((item) => FSUtil.overlaps(item, file)),
-      )
-      if (invalidated.length === 0) return
-      for (const [key] of invalidated) cache.delete(key)
-      yield* Effect.logInfo("skill cache invalidated", {
-        file,
-        sources: invalidated.map(([key]) => key),
-        skills: invalidated.flatMap(([, loaded]) => loaded.skills.map((skill) => skill.id)),
-      })
-      yield* bus.publish(Skill.Event.Updated, {}).pipe(Effect.asVoid)
-    })
-
-    const watch = Effect.fn("Skill.watch")(function* (directory: string) {
-      const target = path.resolve(directory)
-      if (watched.has(target)) return
-      watched.add(target)
-      const updates = yield* watcher.subscribe({ path: target, type: "directory" })
-      yield* updates.pipe(
-        Stream.runForEach((update) => invalidate(update.path)),
-        Effect.forkIn(scope, { startImmediately: true }),
-      )
-    })
-
-    const watchDirectory = Effect.fn("Skill.watchDirectory")(function* (directory: string) {
-      const target = path.resolve(directory)
-      const resolved = yield* fs.realPath(directory).pipe(Effect.catch(() => Effect.succeed(undefined)))
-      if (resolved) {
-        yield* watch(resolved)
-        if (resolved !== target) {
-          yield* watch(path.dirname(target))
-        }
-        return resolved === target ? [target] : [target, resolved]
-      }
-      if (yield* fs.isDir(path.dirname(target))) {
-        yield* watch(path.dirname(target))
-      }
-      return [target]
-    })
 
     const state = State.create<Data, Draft>({
       name: "skill",
@@ -138,8 +92,7 @@ const layer = Layer.effect(
         },
         list: () => draft.sources as Source[],
       }),
-      finalize: () =>
-        Effect.sync(() => cache.clear()).pipe(Effect.andThen(bus.publish(Skill.Event.Updated, {})), Effect.asVoid),
+      finalize: () => bus.publish(Skill.Event.Updated, {}).pipe(Effect.asVoid),
     })
 
     const load = Effect.fn("Skill.load")(function* (source: Source) {
@@ -151,22 +104,14 @@ const layer = Layer.effect(
           directories: [],
           skills: [source.skill.id],
         })
-        return { skills: [source.skill], paths: [] }
+        return { skills: [source.skill], directories: [] }
       }
       const directories = source.type === "directory" ? [source.path] : yield* discovery.pull(source.url)
-      const roots = (yield* Effect.forEach(directories, watchDirectory)).flat()
-      const paths = [...roots]
       for (const directory of directories) {
         const files = yield* fs
           .scan("{*.md,**/SKILL.md}", { cwd: directory, absolute: true, include: "file", symlink: true, dot: true })
           .pipe(Effect.catch(() => Effect.succeed([] as string[])))
         for (const filepath of files.toSorted()) {
-          const resolved = yield* fs.realPath(filepath).pipe(Effect.catch(() => Effect.succeed(filepath)))
-          if (!roots.some((root) => FSUtil.contains(root, resolved))) {
-            const external = path.dirname(resolved)
-            paths.push(external)
-            yield* watch(external)
-          }
           const content = yield* fs.readFileStringSafe(filepath).pipe(Effect.catch(() => Effect.succeed(undefined)))
           if (!content) continue
           const markdown = ConfigMarkdown.parseOption(content)
@@ -194,7 +139,22 @@ const layer = Layer.effect(
         directories,
         skills: skills.map((skill) => skill.id),
       })
-      return { skills, paths }
+      return { skills, directories }
+    })
+
+    const cache = new Map<string, { skills: Info[]; directories: readonly string[] }>()
+    const invalidate = Effect.fn("Skill.invalidateFromWatcher")(function* (file: string) {
+      const invalidated = Array.from(cache.entries()).filter(([, loaded]) =>
+        loaded.directories.some((directory) => FSUtil.contains(directory, file)),
+      )
+      if (invalidated.length === 0) return
+      for (const [key] of invalidated) cache.delete(key)
+      yield* Effect.logInfo("skill cache invalidated", {
+        file,
+        sources: invalidated.map(([key]) => key),
+        skills: invalidated.flatMap(([, loaded]) => loaded.skills.map((skill) => skill.id)),
+      })
+      yield* bus.publish(Skill.Event.Updated, {}).pipe(Effect.asVoid)
     })
 
     yield* bus.subscribe(FileSystem.Event.Changed).pipe(
@@ -227,5 +187,5 @@ const layer = Layer.effect(
 export const node = makeLocationNode({
   service: Service,
   layer,
-  deps: [SkillDiscovery.node, FSUtil.node, Bus.node, Watcher.node],
+  deps: [SkillDiscovery.node, FSUtil.node, Bus.node],
 })

packages/core/src/tool-output.ts

@@ -1,131 +0,0 @@
-export * as ToolOutput from "./tool-output"
-
-import path from "path"
-import type { Tool } from "@opencode-ai/schema/tool"
-import { Context, Duration, Effect, Layer, Schedule } from "effect"
-import { makeGlobalNode, makeLocationNode } from "@opencode-ai/util/effect/app-node"
-import { FSUtil } from "@opencode-ai/util/fs-util"
-import { Global } from "@opencode-ai/util/global"
-import { Config } from "./config"
-import { Identifier } from "./id/id"
-
-export const MAX_LINES = 2_000
-export const MAX_BYTES = 50 * 1024 // 50 KiB
-export const RETENTION = Duration.days(7)
-export const DIRECTORY = "tool-output"
-
-type Result = Tool.Result
-
-export interface Interface {
-  readonly truncate: (result: Result) => Effect.Effect<Result>
-  readonly cleanup: () => Effect.Effect<void>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/ToolOutput") {}
-
-const cleanup = Effect.fn("ToolOutput.cleanup")(function* (fs: FSUtil.Interface, directory: string) {
-  const cutoff = Identifier.timestamp(
-    Identifier.create("tool", "ascending", Date.now() - Duration.toMillis(RETENTION)),
-  )
-  const entries = yield* fs.readDirectory(directory).pipe(
-    Effect.map((entries) => entries.filter((entry) => /^tool_[0-9a-f]{12}/.test(entry))),
-    Effect.catch(() => Effect.succeed([])),
-  )
-  for (const entry of entries) {
-    if (Identifier.timestamp(entry) >= cutoff) continue
-    yield* fs.remove(path.join(directory, entry)).pipe(Effect.catch(() => Effect.void))
-  }
-})
-
-const layer = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const config = yield* Config.Service
-    const fs = yield* FSUtil.Service
-    const global = yield* Global.Service
-    const directory = path.join(global.data, DIRECTORY)
-
-    const truncate = Effect.fn("ToolOutput.truncate")(function* (result: Result) {
-      if (result.metadata?.truncated !== undefined) return result
-      const content =
-        typeof result.content === "string" ? [{ type: "text" as const, text: result.content }] : (result.content ?? [])
-      const text = content.flatMap((item) => (item.type === "text" ? [item.text] : [])).join("\n")
-      const configured = Config.latest(yield* config.entries(), "tool_output")
-      const maxLines = configured?.max_lines ?? MAX_LINES
-      const maxBytes = configured?.max_bytes ?? MAX_BYTES
-      const lines = text.split("\n")
-      if (text.endsWith("\n")) lines.pop()
-      const totalBytes = Buffer.byteLength(text, "utf-8")
-      if (lines.length <= maxLines && totalBytes <= maxBytes)
-        return { ...result, metadata: { ...result.metadata, truncated: false } }
-
-      const kept: string[] = []
-      let bytes = 0
-      let hitBytes = false
-      for (const line of lines.slice(0, maxLines)) {
-        const size = Buffer.byteLength(line, "utf-8") + (kept.length > 0 ? 1 : 0)
-        if (bytes + size > maxBytes) {
-          hitBytes = true
-          break
-        }
-        kept.push(line)
-        bytes += size
-      }
-      if (!hitBytes && kept.length === lines.length && totalBytes > bytes) hitBytes = true
-      const removed = hitBytes ? totalBytes - bytes : lines.length - kept.length
-      const unit = hitBytes ? (removed === 1 ? "byte" : "bytes") : removed === 1 ? "line" : "lines"
-      const file = path.join(directory, Identifier.ascending("tool"))
-      yield* fs.ensureDir(directory).pipe(Effect.orDie)
-      yield* fs.writeFileString(file, text).pipe(Effect.orDie)
-      const marker = `... ${removed} ${unit} truncated; full content saved to ${file} ...`
-      const bounded: Tool.Content[] = []
-      let remaining = kept.join("\n").length
-      let seenText = false
-      let marked = false
-      for (const item of content) {
-        if (item.type === "file") {
-          bounded.push(item)
-          continue
-        }
-        if (seenText && remaining > 0) remaining--
-        seenText = true
-        if (remaining >= item.text.length) {
-          bounded.push(item)
-          remaining -= item.text.length
-          continue
-        }
-        if (remaining > 0) bounded.push({ ...item, text: item.text.slice(0, remaining) })
-        if (!marked) bounded.push({ type: "text", text: marker })
-        remaining = 0
-        marked = true
-      }
-      if (!marked) bounded.push({ type: "text", text: marker })
-      return {
-        ...result,
-        content: bounded,
-        metadata: { ...result.metadata, truncated: true, outputPath: file },
-      }
-    })
-
-    return Service.of({ truncate, cleanup: () => cleanup(fs, directory) })
-  }),
-)
-
-const cleanupLayer = Layer.effectDiscard(
-  Effect.gen(function* () {
-    const fs = yield* FSUtil.Service
-    const global = yield* Global.Service
-    yield* cleanup(fs, path.join(global.data, DIRECTORY)).pipe(
-      Effect.repeat(Schedule.spaced(Duration.hours(1))),
-      Effect.forkScoped,
-    )
-  }),
-)
-
-const cleanupNode = makeGlobalNode({ name: "tool-output-cleanup", layer: cleanupLayer, deps: [FSUtil.node, Global.node] })
-
-export const node = makeLocationNode({
-  service: Service,
-  layer,
-  deps: [Config.node, FSUtil.node, Global.node, cleanupNode],
-})

packages/core/src/tool/plugin/edit.ts

@@ -11,11 +11,9 @@ import { ToolFailure } from "@opencode-ai/ai"
 import { FileDiff } from "@opencode-ai/schema/file-diff"
 import { Bom } from "@opencode-ai/util/bom"
 import { Effect, Schema } from "effect"
-import path from "path"
-import { Environment } from "../../environment"
 import { FileMutation } from "../../file-mutation"
 import { Formatter } from "../../formatter"
-import { Location } from "../../location"
+import { FSUtil } from "@opencode-ai/util/fs-util"
 import { LocationMutation } from "../../location-mutation"
 import { Permission } from "../../permission"
 import { fileDiff } from "./file-diff"
@@ -111,128 +109,131 @@ export const Plugin = {
   id: "opencode.tool.edit",
   effect: Effect.fn("EditTool.Plugin")(function* (ctx: PluginContext) {
     const mutation = yield* LocationMutation.Service
-    const fileMutation = yield* FileMutation.Service
-    const environment = yield* Environment.Service
+    const files = yield* FileMutation.Service
     const formatter = yield* Formatter.Service
-    const location = yield* Location.Service
+    const fs = yield* FSUtil.Service
     const permission = yield* Permission.Service
 
     yield* ctx.tool
       .transform((draft) =>
-        draft.add({
-          name,
-          options: { codemode: false, permission: "edit" },
-          description:
-            "Edit the contents of a file by finding and replacing exact text. When editing text from Read output, preserve the exact indentation (tabs or spaces) and omit the line-number prefix, such as `1: `. Never include the prefix in oldString or newString. The edit fails if oldString is not found. By default, oldString must identify a UNIQUE location. Multiple matches FAIL unless replaceAll is true. Add more surrounding context to disambiguate, or set replaceAll to true to replace every occurrence. Use replaceAll when the change should apply to every occurrence, such as renaming a variable.",
-          input: Input,
-          output: Output,
-          execute: (input, context) => {
-            return Effect.gen(function* () {
-              const permissionSource = {
-                type: "tool" as const,
-                messageID: context.messageID,
-                id: context.id,
-              }
-              if (input.oldString === input.newString) {
-                return yield* new ToolFailure({
-                  message: "No changes to apply: oldString and newString are identical.",
-                })
-              }
-              if (input.oldString === "") {
-                return yield* new ToolFailure({
-                  message: "oldString must not be empty. Use write to create or overwrite a file.",
-                })
-              }
+        draft.add(
+          ({
+              name,
+              options: { codemode: false, permission: "edit" },
+              description:
+                "Edit the contents of a file by finding and replacing exact text. When editing text from Read output, preserve the exact indentation (tabs or spaces) and omit the line-number prefix, such as `1: `. Never include the prefix in oldString or newString. The edit fails if oldString is not found. By default, oldString must identify a UNIQUE location. Multiple matches FAIL unless replaceAll is true. Add more surrounding context to disambiguate, or set replaceAll to true to replace every occurrence. Use replaceAll when the change should apply to every occurrence, such as renaming a variable.",
+              input: Input,
+              output: Output,
+              execute: (input, context) => {
+                return Effect.gen(function* () {
+                  const permissionSource = {
+                    type: "tool" as const,
+                    messageID: context.messageID,
+                    id: context.id,
+                  }
+                  if (input.oldString === input.newString) {
+                    return yield* new ToolFailure({
+                      message: "No changes to apply: oldString and newString are identical.",
+                    })
+                  }
+                  if (input.oldString === "") {
+                    return yield* new ToolFailure({
+                      message: "oldString must not be empty. Use write to create or overwrite a file.",
+                    })
+                  }
 
-              const target = yield* mutation.resolve({ path: input.path, kind: "file" })
-              const external = target.externalDirectory
-              if (external) {
-                yield* permission.assert({
-                  ...LocationMutation.externalDirectoryPermission(external),
-                  sessionID: context.sessionID,
-                  agent: context.agent,
-                  source: permissionSource,
-                })
-              }
+                  const target = yield* mutation.resolve({ path: input.path, kind: "file" })
+                  const external = target.externalDirectory
+                  if (external) {
+                    yield* permission.assert({
+                      ...LocationMutation.externalDirectoryPermission(external),
+                      sessionID: context.sessionID,
+                      agent: context.agent,
+                      source: permissionSource,
+                    })
+                  }
 
-              const original = yield* FileMutation.readText(environment.files, target.absolute).pipe(
-                Effect.catchTag("Environment.NotFound", () =>
-                  Effect.fail(new ToolFailure({ message: `File not found: ${input.path}` })),
-                ),
-                Effect.catchTag("Environment.WrongKind", (error) =>
-                  error.actual === "directory"
-                    ? Effect.fail(new ToolFailure({ message: `Path is a directory, not a file: ${input.path}` }))
-                    : Effect.fail(new ToolFailure({ message: `Unable to edit ${input.path}`, error })),
-                ),
-              )
-              const source = original.text
-              const ending = source.includes(crlf) ? crlf : "\n"
-              const oldString = input.oldString.replaceAll(crlf, "\n").replaceAll("\n", ending)
-              const newString = input.newString.replaceAll(crlf, "\n").replaceAll("\n", ending)
-              const exact = findOccurrences(source, oldString)
-              // These one-to-one mappings preserve offsets into the original source.
-              const unicode =
-                exact.length > 0 ? [] : findOccurrences(normalizeForMatch(source), normalizeForMatch(oldString))
-              const trailing = exact.length > 0 || unicode.length > 0 ? [] : findLineOccurrences(source, oldString)
-              const matches = exact.length > 0 ? exact : unicode.length > 0 ? unicode : trailing
-              const replacements = matches.length
-              const replaced = (input.replaceAll === true ? matches : matches.slice(0, 1))
-                .toReversed()
-                .reduce(
-                  (content, match) => `${content.slice(0, match.start)}${newString}${content.slice(match.end)}`,
-                  source,
+                  const info = yield* fs.stat(target.canonical).pipe(
+                    Effect.catchReason("PlatformError", "NotFound", () =>
+                      Effect.fail(new ToolFailure({ message: `File not found: ${input.path}` })),
+                    ),
+                  )
+                  if (info.type === "Directory") {
+                    return yield* new ToolFailure({ message: `Path is a directory, not a file: ${input.path}` })
+                  }
+                  const original = yield* Bom.readFile(fs, target.canonical)
+                  const source = original.text
+                  const ending = source.includes(crlf) ? crlf : "\n"
+                  const oldString = input.oldString.replaceAll(crlf, "\n").replaceAll("\n", ending)
+                  const newString = input.newString.replaceAll(crlf, "\n").replaceAll("\n", ending)
+                  const exact = findOccurrences(source, oldString)
+                  // These one-to-one mappings preserve offsets into the original source.
+                  const unicode =
+                    exact.length > 0 ? [] : findOccurrences(normalizeForMatch(source), normalizeForMatch(oldString))
+                  const trailing =
+                    exact.length > 0 || unicode.length > 0
+                      ? []
+                      : findLineOccurrences(source, oldString)
+                  const matches = exact.length > 0 ? exact : unicode.length > 0 ? unicode : trailing
+                  const replacements = matches.length
+                  const replaced = (input.replaceAll === true ? matches : matches.slice(0, 1))
+                    .toReversed()
+                    .reduce(
+                      (content, match) =>
+                        `${content.slice(0, match.start)}${newString}${content.slice(match.end)}`,
+                      source,
+                    )
+                  const preview =
+                    replacements > 0 && (replacements === 1 || input.replaceAll === true)
+                      ? fileDiff(target.resource, source, replaced)
+                      : undefined
+                  yield* permission.assert({
+                    action: "edit",
+                    resources: [target.resource],
+                    save: ["*"],
+                    metadata: preview ? { files: [preview] } : undefined,
+                    sessionID: context.sessionID,
+                    agent: context.agent,
+                    source: permissionSource,
+                  })
+                  if (replacements === 0) {
+                    return yield* new ToolFailure({
+                      message: `Could not find oldString in ${input.path}. It must match exactly, including whitespace and indentation.`,
+                    })
+                  }
+                  if (replacements > 1 && input.replaceAll !== true) {
+                    return yield* new ToolFailure({
+                      message: `Found ${replacements} matches for oldString, but expected exactly one. Add more surrounding context to make oldString unique, or set replaceAll to true to replace every occurrence.`,
+                    })
+                  }
+                  const replacementBom = replaced.startsWith("\uFEFF")
+                  const result = yield* files.write({
+                    target,
+                    content: Bom.join(replaced, original.bom || replacementBom),
+                  })
+                  const bom = original.bom || replacementBom
+                  const formatted = (yield* formatter.file(target.canonical))
+                    ? yield* Bom.syncFile(fs, target.canonical, bom)
+                    : (yield* Bom.readFile(fs, target.canonical)).text
+                  return {
+                    files: [fileDiff(result.resource, source, formatted)],
+                    replacements,
+                  } satisfies Output
+                }).pipe(
+                  Effect.map((output) => ({
+                    output,
+                    content: `Edited ${output.files[0]?.file} (${output.replacements} replacement${output.replacements === 1 ? "" : "s"})`,
+                    metadata: { files: output.files },
+                  })),
+                  Effect.mapError((error) =>
+                    error instanceof ToolFailure
+                      ? error
+                      : new ToolFailure({ message: `Unable to edit ${input.path}`, error }),
+                  ),
                 )
-              const preview =
-                replacements > 0 && (replacements === 1 || input.replaceAll === true)
-                  ? fileDiff(target.resource, source, replaced)
-                  : undefined
-              yield* permission.assert({
-                action: "edit",
-                resources: [target.resource],
-                save: ["*"],
-                metadata: preview ? { files: [preview] } : undefined,
-                sessionID: context.sessionID,
-                agent: context.agent,
-                source: permissionSource,
-              })
-              if (replacements === 0) {
-                return yield* new ToolFailure({
-                  message: `Could not find oldString in ${input.path}. It must match exactly, including whitespace and indentation.`,
-                })
-              }
-              if (replacements > 1 && input.replaceAll !== true) {
-                return yield* new ToolFailure({
-                  message: `Found ${replacements} matches for oldString, but expected exactly one. Add more surrounding context to make oldString unique, or set replaceAll to true to replace every occurrence.`,
-                })
-              }
-              const replacementBom = replaced.startsWith("\uFEFF")
-              const result = yield* fileMutation.write({
-                target,
-                content: Bom.join(replaced, original.bom || replacementBom),
-              })
-              const bom = original.bom || replacementBom
-              const formatted = (yield* formatter.file(target.absolute))
-                ? yield* FileMutation.syncTextBom(environment.files, target.absolute, bom)
-                : (yield* FileMutation.readText(environment.files, target.absolute)).text
-              return {
-                files: [fileDiff(result.resource, source, formatted)],
-                replacements,
-              } satisfies Output
-            }).pipe(
-              fileMutation.withLock([path.resolve(location.directory, input.path)]),
-              Effect.map((output) => ({
-                output,
-                content: `Edited ${output.files[0]?.file} (${output.replacements} replacement${output.replacements === 1 ? "" : "s"})`,
-                metadata: { files: output.files },
-              })),
-              Effect.mapError((error) =>
-                error instanceof ToolFailure
-                  ? error
-                  : new ToolFailure({ message: `Unable to edit ${input.path}`, error }),
-              ),
-            )
-          },
-        }),
+              },
+            }),
+        ),
       )
       .pipe(Effect.orDie)
   }),

packages/core/src/tool/plugin/glob.ts

@@ -4,8 +4,8 @@ import { ToolFailure } from "@opencode-ai/ai"
 import type { Context as PluginContext } from "@opencode-ai/plugin/effect/plugin"
 import { Effect, Schema } from "effect"
 import path from "path"
-import { Environment } from "../../environment"
 import { FileSystem } from "../../filesystem"
+import { FSUtil } from "@opencode-ai/util/fs-util"
 import { Location } from "../../location"
 import { LocationMutation } from "../../location-mutation"
 import { Ripgrep } from "../../ripgrep"
@@ -42,7 +42,7 @@ export const toModelContent = (entries: EncodedOutput, truncated = false) => {
 export const Plugin = {
   id: "opencode.tool.glob",
   effect: Effect.fn("GlobTool.Plugin")(function* (ctx: PluginContext) {
-    const environment = yield* Environment.Service
+    const fs = yield* FSUtil.Service
     const ripgrep = yield* Ripgrep.Service
     const location = yield* Location.Service
     const mutation = yield* LocationMutation.Service
@@ -50,91 +50,96 @@ export const Plugin = {
 
     yield* ctx.tool
       .transform((draft) =>
-        draft.add({
-          name,
-          options: { codemode: false },
-          description: 'Search file paths using a glob pattern (examples: "**/*.ts", "src/**/*.tsx").',
-          input: Input,
-          output: Output,
-          execute: (input, context) =>
-            Effect.gen(function* () {
-              const searchPath = input.path === "undefined" || input.path === "null" ? undefined : input.path
-              const source = { type: "tool" as const, messageID: context.messageID, id: context.id }
-              const target = yield* mutation.resolve({ path: searchPath ?? ".", kind: "directory" })
-              const external = target.externalDirectory
-              if (external)
+        draft.add(
+          ({
+            name,
+            options: { codemode: false },
+            description:
+              'Search file paths using a glob pattern (examples: "**/*.ts", "src/**/*.tsx").',
+            input: Input,
+            output: Output,
+            execute: (input, context) =>
+              Effect.gen(function* () {
+                const searchPath = input.path === "undefined" || input.path === "null" ? undefined : input.path
+                const source = { type: "tool" as const, messageID: context.messageID, id: context.id }
+                const target = yield* mutation.resolve({ path: searchPath ?? ".", kind: "directory" })
+                const external = target.externalDirectory
+                if (external)
+                  yield* permission.assert({
+                    ...LocationMutation.externalDirectoryPermission(external),
+                    sessionID: context.sessionID,
+                    agent: context.agent,
+                    source,
+                  })
                 yield* permission.assert({
-                  ...LocationMutation.externalDirectoryPermission(external),
+                  action: name,
+                  resources: [input.pattern],
+                  save: ["*"],
+                  metadata: {
+                    root: searchPath ?? ".",
+                    path: searchPath,
+                    limit: input.limit,
+                  },
                   sessionID: context.sessionID,
                   agent: context.agent,
                   source,
                 })
-              yield* permission.assert({
-                action: name,
-                resources: [input.pattern],
-                save: ["*"],
-                metadata: {
-                  root: searchPath ?? ".",
-                  path: searchPath,
-                  limit: input.limit,
-                },
-                sessionID: context.sessionID,
-                agent: context.agent,
-                source,
-              })
-              const type = yield* Environment.typeFollowing(environment.files, target.absolute).pipe(
-                Effect.catchTag("Environment.NotFound", () =>
-                  Effect.fail(new ToolFailure({ message: `Search path does not exist: ${searchPath ?? "."}` })),
-                ),
-              )
-              if (type !== "directory")
-                return yield* Effect.fail(
-                  new ToolFailure({ message: `Search path is not a directory: ${searchPath ?? "."}` }),
-                )
-              const root = target.absolute
-              const limit = input.limit ?? FileSystem.DEFAULT_SEARCH_LIMIT
-              const entries = yield* ripgrep
-                .glob({
-                  cwd: root,
-                  pattern: input.pattern,
-                  limit: limit + 1,
-                })
-                .pipe(
-                  Effect.timeoutOrElse({
-                    duration: FileSystem.DEFAULT_SEARCH_TIMEOUT_MS,
-                    orElse: () =>
-                      Effect.fail(
-                        new ToolFailure({
-                          message: `Search timed out after ${FileSystem.DEFAULT_SEARCH_TIMEOUT_MS / 1_000} seconds. Consider using a more specific path or pattern.`,
+                const info = yield* fs
+                  .stat(target.canonical)
+                  .pipe(
+                    Effect.catchReason("PlatformError", "NotFound", () =>
+                      Effect.fail(new ToolFailure({ message: `Search path does not exist: ${searchPath ?? "."}` })),
+                    ),
+                  )
+                if (info.type !== "Directory")
+                  return yield* Effect.fail(
+                    new ToolFailure({ message: `Search path is not a directory: ${searchPath ?? "."}` }),
+                  )
+                const root = path.resolve(location.directory, searchPath ?? ".")
+                const limit = input.limit ?? FileSystem.DEFAULT_SEARCH_LIMIT
+                const entries = yield* ripgrep
+                  .glob({
+                    cwd: target.canonical,
+                    pattern: input.pattern,
+                    limit: limit + 1,
+                  })
+                  .pipe(
+                    Effect.timeoutOrElse({
+                      duration: FileSystem.DEFAULT_SEARCH_TIMEOUT_MS,
+                      orElse: () =>
+                        Effect.fail(
+                          new ToolFailure({
+                            message: `Search timed out after ${FileSystem.DEFAULT_SEARCH_TIMEOUT_MS / 1_000} seconds. Consider using a more specific path or pattern.`,
+                          }),
+                        ),
+                    }),
+                    Effect.map((result) =>
+                      result.map((entry) =>
+                        FileSystem.Entry.make({
+                          ...entry,
+                          path: RelativePath.make(path.relative(location.directory, path.resolve(root, entry.path))),
                         }),
                       ),
-                  }),
-                  Effect.map((result) =>
-                    result.map((entry) =>
-                      FileSystem.Entry.make({
-                        ...entry,
-                        path: RelativePath.make(path.relative(location.directory, path.resolve(root, entry.path))),
-                      }),
                     ),
+                  )
+                return { entries: entries.slice(0, limit), truncated: entries.length > limit }
+              }).pipe(
+                Effect.map((result) => ({
+                  output: result.entries,
+                  content: toModelContent(
+                    result.entries.map((entry) => ({ ...entry, path: path.resolve(location.directory, entry.path) })),
+                    result.truncated,
                   ),
-                )
-              return { entries: entries.slice(0, limit), truncated: entries.length > limit }
-            }).pipe(
-              Effect.map((result) => ({
-                output: result.entries,
-                content: toModelContent(
-                  result.entries.map((entry) => ({ ...entry, path: path.resolve(location.directory, entry.path) })),
-                  result.truncated,
+                  metadata: { count: result.entries.length, truncated: result.truncated },
+                })),
+                Effect.mapError((error) =>
+                  error instanceof ToolFailure
+                    ? error
+                    : new ToolFailure({ message: `Unable to find files matching ${input.pattern}`, error }),
                 ),
-                metadata: { count: result.entries.length, truncated: result.truncated },
-              })),
-              Effect.mapError((error) =>
-                error instanceof ToolFailure
-                  ? error
-                  : new ToolFailure({ message: `Unable to find files matching ${input.pattern}`, error }),
               ),
-            ),
-        }),
+          }),
+        ),
       )
       .pipe(Effect.orDie)
   }),

packages/core/src/tool/plugin/grep.ts

@@ -4,8 +4,8 @@ import type { Context as PluginContext } from "@opencode-ai/plugin/effect/plugin
 import { ToolFailure } from "@opencode-ai/ai"
 import { Effect, Schema } from "effect"
 import path from "path"
-import { Environment } from "../../environment"
 import { FileSystem } from "../../filesystem"
+import { FSUtil } from "@opencode-ai/util/fs-util"
 import { Location } from "../../location"
 import { LocationMutation } from "../../location-mutation"
 import { Permission } from "../../permission"
@@ -15,11 +15,11 @@ import { RelativePath } from "../../schema"
 export const name = "grep"
 
 export const Input = Schema.Struct({
-  pattern: FileSystem.GrepInput.fields.pattern
-    .check(Schema.isMinLength(1, { message: "Pattern must not be empty" }))
-    .annotate({
-      description: "Regular expression to search for in file contents (ripgrep syntax)",
-    }),
+  pattern: FileSystem.GrepInput.fields.pattern.check(
+    Schema.isMinLength(1, { message: "Pattern must not be empty" }),
+  ).annotate({
+    description: "Regular expression to search for in file contents (ripgrep syntax)",
+  }),
   path: Schema.optionalKey(RelativePath).annotate({
     description: "File or directory to search. Defaults to the current working directory.",
   }),
@@ -58,7 +58,7 @@ export const toModelContent = (matches: EncodedOutput, truncated = false) => {
 export const Plugin = {
   id: "opencode.tool.grep",
   effect: Effect.fn("GrepTool.Plugin")(function* (ctx: PluginContext) {
-    const environment = yield* Environment.Service
+    const fs = yield* FSUtil.Service
     const ripgrep = yield* Ripgrep.Service
     const location = yield* Location.Service
     const mutation = yield* LocationMutation.Service
@@ -66,100 +66,104 @@ export const Plugin = {
 
     yield* ctx.tool
       .transform((draft) =>
-        draft.add({
-          name,
-          options: { codemode: false },
-          description:
-            "Search file contents using regular expressions. Use it to locate specific code, symbols, or text patterns, and narrow searches with `path` or `include`. Returns matching file paths, line numbers, and line previews.",
-          input: Input,
-          output: Output,
-          execute: (input, context) =>
-            Effect.gen(function* () {
-              const source = { type: "tool" as const, messageID: context.messageID, id: context.id }
-              const target = yield* mutation.resolve({ path: input.path ?? "." })
-              if (target.externalDirectory)
+        draft.add(
+          ({
+            name,
+            options: { codemode: false },
+            description:
+              "Search file contents using regular expressions. Use it to locate specific code, symbols, or text patterns, and narrow searches with `path` or `include`. Returns matching file paths, line numbers, and line previews.",
+            input: Input,
+            output: Output,
+            execute: (input, context) =>
+              Effect.gen(function* () {
+                const source = { type: "tool" as const, messageID: context.messageID, id: context.id }
+                const target = yield* mutation.resolve({ path: input.path ?? "." })
+                if (target.externalDirectory)
+                  yield* permission.assert({
+                    ...LocationMutation.externalDirectoryPermission(target.externalDirectory),
+                    sessionID: context.sessionID,
+                    agent: context.agent,
+                    source,
+                  })
                 yield* permission.assert({
-                  ...LocationMutation.externalDirectoryPermission(target.externalDirectory),
+                  action: name,
+                  resources: [input.pattern],
+                  save: ["*"],
+                  metadata: {
+                    root: ".",
+                    path: input.path,
+                    include: input.include,
+                    limit: input.limit,
+                  },
                   sessionID: context.sessionID,
                   agent: context.agent,
                   source,
                 })
-              yield* permission.assert({
-                action: name,
-                resources: [input.pattern],
-                save: ["*"],
-                metadata: {
-                  root: ".",
-                  path: input.path,
-                  include: input.include,
-                  limit: input.limit,
-                },
-                sessionID: context.sessionID,
-                agent: context.agent,
-                source,
-              })
-              const root = target.absolute
-              const type = yield* Environment.typeFollowing(environment.files, root).pipe(
-                Effect.catchTag("Environment.NotFound", () =>
-                  Effect.fail(new ToolFailure({ message: `Search path does not exist: ${input.path ?? "."}` })),
-                ),
-              )
-              const cwd = type === "directory" ? root : path.dirname(root)
-              const limit = input.limit ?? FileSystem.DEFAULT_SEARCH_LIMIT
-              const matches = yield* ripgrep
-                .grep({
-                  cwd,
-                  pattern: input.pattern,
-                  file: type === "file" ? path.basename(root) : undefined,
-                  include: input.include,
-                  limit: limit + 1,
-                })
-                .pipe(
-                  Effect.timeoutOrElse({
-                    duration: FileSystem.DEFAULT_SEARCH_TIMEOUT_MS,
-                    orElse: () =>
-                      Effect.fail(
-                        new ToolFailure({
-                          message: `Search timed out after ${FileSystem.DEFAULT_SEARCH_TIMEOUT_MS / 1_000} seconds. Consider using a more specific path or pattern.`,
+                const root = path.resolve(location.directory, input.path ?? ".")
+                const info = yield* fs
+                  .stat(root)
+                  .pipe(
+                    Effect.catchReason("PlatformError", "NotFound", () =>
+                      Effect.fail(new ToolFailure({ message: `Search path does not exist: ${input.path ?? "."}` })),
+                    ),
+                  )
+                const cwd = info?.type === "Directory" ? root : path.dirname(root)
+                const limit = input.limit ?? FileSystem.DEFAULT_SEARCH_LIMIT
+                const matches = yield* ripgrep
+                  .grep({
+                    cwd,
+                    pattern: input.pattern,
+                    file: info?.type === "File" ? path.basename(root) : undefined,
+                    include: input.include,
+                    limit: limit + 1,
+                  })
+                  .pipe(
+                    Effect.timeoutOrElse({
+                      duration: FileSystem.DEFAULT_SEARCH_TIMEOUT_MS,
+                      orElse: () =>
+                        Effect.fail(
+                          new ToolFailure({
+                            message: `Search timed out after ${FileSystem.DEFAULT_SEARCH_TIMEOUT_MS / 1_000} seconds. Consider using a more specific path or pattern.`,
+                          }),
+                        ),
+                    }),
+                    Effect.map((result) =>
+                      result.map((match) =>
+                        FileSystem.Match.make({
+                          ...match,
+                          entry: FileSystem.Entry.make({
+                            ...match.entry,
+                            path: RelativePath.make(
+                              path.relative(location.directory, path.resolve(cwd, match.entry.path)),
+                            ),
+                          }),
                         }),
                       ),
-                  }),
-                  Effect.map((result) =>
-                    result.map((match) =>
-                      FileSystem.Match.make({
-                        ...match,
-                        entry: FileSystem.Entry.make({
-                          ...match.entry,
-                          path: RelativePath.make(
-                            path.relative(location.directory, path.resolve(cwd, match.entry.path)),
-                          ),
-                        }),
-                      }),
                     ),
+                  )
+                return { matches: matches.slice(0, limit), truncated: matches.length > limit }
+              }).pipe(
+                Effect.map((result) => ({
+                  output: result.matches,
+                  content: toModelContent(
+                    result.matches.map((match) => ({
+                      ...match,
+                      entry: { ...match.entry, path: path.resolve(location.directory, match.entry.path) },
+                    })),
+                    result.truncated,
                   ),
-                )
-              return { matches: matches.slice(0, limit), truncated: matches.length > limit }
-            }).pipe(
-              Effect.map((result) => ({
-                output: result.matches,
-                content: toModelContent(
-                  result.matches.map((match) => ({
-                    ...match,
-                    entry: { ...match.entry, path: path.resolve(location.directory, match.entry.path) },
-                  })),
-                  result.truncated,
-                ),
-                metadata: { matches: result.matches.length, truncated: result.truncated },
-              })),
-              Effect.mapError((error) =>
-                error instanceof ToolFailure
-                  ? error
-                  : error instanceof Ripgrep.InvalidPatternError
-                    ? new ToolFailure({ message: `Invalid regex pattern: ${error.message}` })
+                  metadata: { matches: result.matches.length, truncated: result.truncated },
+                })),
+                Effect.mapError((error) =>
+                  error instanceof ToolFailure
+                    ? error
+                    : error instanceof Ripgrep.InvalidPatternError
+                      ? new ToolFailure({ message: `Invalid regex pattern: ${error.message}` })
                     : new ToolFailure({ message: `Unable to grep for ${input.pattern}`, error }),
+                ),
               ),
-            ),
-        }),
+          }),
+        ),
       )
       .pipe(Effect.orDie)
   }),

packages/core/src/tool/plugin/patch.ts

@@ -4,13 +4,12 @@ import type { Context as PluginContext } from "@opencode-ai/plugin/effect/plugin
 import { ToolFailure } from "@opencode-ai/ai"
 import { FileDiff } from "@opencode-ai/schema/file-diff"
 import { createTwoFilesPatch, diffLines } from "diff"
-import { Effect, Result, Schema } from "effect"
+import { Effect, Schema } from "effect"
+import { PlatformError } from "effect/PlatformError"
 import path from "path"
 import { Bom } from "@opencode-ai/util/bom"
 import { FSUtil } from "@opencode-ai/util/fs-util"
-import { Environment } from "../../environment"
 import { Formatter } from "../../formatter"
-import { FileMutation } from "../../file-mutation"
 import { Location } from "../../location"
 import { Patch } from "@opencode-ai/util/patch"
 import { Permission } from "../../permission"
@@ -45,13 +44,7 @@ export const toModelOutput = (output: Output) =>
   ].join("\n")
 
 type Prepared =
-  | (Extract<Patch.Hunk, { readonly type: "add" }> & {
-      readonly target: Target
-      readonly content: string
-      readonly before: string
-      readonly after: string
-    })
-  | (Extract<Patch.Hunk, { readonly type: "delete" }> & {
+  | (Extract<Patch.Hunk, { readonly type: "add" | "delete" }> & {
       readonly target: Target
       readonly before: string
       readonly after: string
@@ -65,7 +58,7 @@ type Prepared =
     })
 
 interface Target {
-  readonly absolute: string
+  readonly canonical: string
   readonly resource: string
   readonly externalDirectory?: {
     readonly directory: string
@@ -76,255 +69,274 @@ interface Target {
 export const Plugin = {
   id: "opencode.tool.patch",
   effect: Effect.fn("PatchTool.Plugin")(function* (ctx: PluginContext) {
-    const environment = yield* Environment.Service
-    const mutation = yield* FileMutation.Service
+    const fs = yield* FSUtil.Service
     const formatter = yield* Formatter.Service
     const location = yield* Location.Service
     const permission = yield* Permission.Service
 
     yield* ctx.tool
       .transform((draft) =>
-        draft.add({
-          name,
-          options: { codemode: false, permission: "edit" },
-          description: DESCRIPTION,
-          input: Input,
-          output: Output,
-          execute: (input, context) => {
-            const applied: Array<typeof Applied.Type> = []
-            const parsed = Patch.parse(input.patchText)
-            const lockTargets = Result.isSuccess(parsed)
-              ? parsed.success.flatMap((hunk) => [
-                  path.resolve(location.directory, hunk.path),
-                  ...(hunk.type === "update" && hunk.movePath ? [path.resolve(location.directory, hunk.movePath)] : []),
-                ])
-              : []
-            const fail = (operation: string, error: unknown) => {
-              const completed = applied.map((item) => item.resource).join(", ")
-              return new ToolFailure({
-                message: `${operation}: ${errorMessage(error)}${completed ? `. Completed before failure: ${completed}` : ""}`,
-              })
-            }
-            return Effect.gen(function* () {
-              const source = {
-                type: "tool" as const,
-                messageID: context.messageID,
-                id: context.id,
-              }
-              if (!input.patchText) return yield* new ToolFailure({ message: "patchText is required" })
-              const hunks = yield* Effect.fromResult(parsed).pipe(
-                Effect.mapError((error) => new ToolFailure({ message: `patch verification failed: ${error.message}` })),
-              )
-              if (hunks.length === 0) {
-                return yield* new ToolFailure({ message: "patch rejected: empty patch" })
-              }
-              const prepared: Prepared[] = []
-              const targets: Target[] = []
-              const updates = new Map<string, string>()
-              for (const hunk of hunks) {
-                yield* Effect.gen(function* () {
-                  const target = resolveTarget(location, hunk.path)
-                  targets.push(target)
-                  if (target.externalDirectory) {
-                    yield* permission.assert({
-                      action: "external_directory",
-                      resources: [target.externalDirectory.resource],
-                      save: [target.externalDirectory.resource],
-                      metadata: {
-                        filepath: target.absolute,
-                        parentDir: target.externalDirectory.directory,
-                      },
-                      sessionID: context.sessionID,
-                      agent: context.agent,
-                      source,
-                    })
+        draft.add(
+          ({
+              name,
+              options: { codemode: false, permission: "edit" },
+              description: DESCRIPTION,
+              input: Input,
+              output: Output,
+              execute: (input, context) => {
+                const applied: Array<typeof Applied.Type> = []
+                const fail = (operation: string, error: unknown) => {
+                  const completed = applied.map((item) => item.resource).join(", ")
+                  return new ToolFailure({
+                    message: `${operation}: ${errorMessage(error)}${completed ? `. Completed before failure: ${completed}` : ""}`,
+                  })
+                }
+                return Effect.gen(function* () {
+                  const source = {
+                    type: "tool" as const,
+                    messageID: context.messageID,
+                    id: context.id,
                   }
-                  if (hunk.type === "add") {
-                    const content =
-                      hunk.contents.endsWith("\n") || hunk.contents === "" ? hunk.contents : `${hunk.contents}\n`
-                    prepared.push({
-                      ...hunk,
-                      target,
-                      content,
-                      before: "",
-                      after: Bom.split(content).text,
-                    })
-                    return
+                  if (!input.patchText) return yield* new ToolFailure({ message: "patchText is required" })
+                  const hunks = yield* Effect.fromResult(Patch.parse(input.patchText)).pipe(
+                    Effect.mapError(
+                      (error) => new ToolFailure({ message: `patch verification failed: ${error.message}` }),
+                    ),
+                  )
+                  if (hunks.length === 0) {
+                    return yield* new ToolFailure({ message: "patch rejected: empty patch" })
                   }
-                  if (hunk.type === "delete") {
-                    const content = yield* FileMutation.readText(environment.files, target.absolute).pipe(
-                      Effect.mapError(
-                        (error) =>
-                          new ToolFailure({
-                            message: `patch verification failed: Failed to delete ${target.resource}: ${errorMessage(error)}`,
-                          }),
+                  const prepared: Prepared[] = []
+                  const targets: Target[] = []
+                  const updates = new Map<string, string>()
+                  for (const hunk of hunks) {
+                    yield* Effect.gen(function* () {
+                      const target = resolveTarget(location, hunk.path)
+                      targets.push(target)
+                      if (target.externalDirectory) {
+                        yield* permission.assert({
+                          action: "external_directory",
+                          resources: [target.externalDirectory.resource],
+                          save: [target.externalDirectory.resource],
+                          metadata: {
+                            filepath: target.canonical,
+                            parentDir: target.externalDirectory.directory,
+                          },
+                          sessionID: context.sessionID,
+                          agent: context.agent,
+                          source,
+                        })
+                      }
+                      if (hunk.type === "add") {
+                        prepared.push({
+                          ...hunk,
+                          target,
+                          before: "",
+                          after: Bom.split(
+                            hunk.contents.endsWith("\n") || hunk.contents === ""
+                              ? hunk.contents
+                              : `${hunk.contents}\n`,
+                          ).text,
+                        })
+                        return
+                      }
+                      if (hunk.type === "delete") {
+                        const content = yield* Bom.readFile(fs, target.canonical).pipe(
+                          Effect.mapError(
+                            (error) =>
+                              new ToolFailure({
+                                message: `patch verification failed: Failed to delete ${target.resource}: ${errorMessage(error)}`,
+                              }),
+                          ),
+                        )
+                        prepared.push({ ...hunk, target, before: content.text, after: "" })
+                        return
+                      }
+                      const previous = updates.get(target.canonical)
+                      const original =
+                        previous ??
+                        (yield* Effect.gen(function* () {
+                          const stats = yield* fs.stat(target.canonical).pipe(
+                            Effect.mapError(
+                              (error) =>
+                                new ToolFailure({
+                                  message: `patch verification failed: Failed to read file to update ${target.canonical}: ${errorMessage(error)}`,
+                                }),
+                            ),
+                          )
+                          if (stats.type === "Directory") {
+                            return yield* new ToolFailure({
+                              message: `patch verification failed: Failed to read file to update ${target.canonical}: path is a directory`,
+                            })
+                          }
+                          const content = yield* Bom.readFile(fs, target.canonical).pipe(
+                            Effect.mapError(
+                              (error) =>
+                                new ToolFailure({
+                                  message: `patch verification failed: Failed to read file to update ${target.canonical}: ${errorMessage(error)}`,
+                                }),
+                            ),
+                          )
+                          return Bom.join(content.text, content.bom)
+                        }))
+                      const before = Bom.split(original).text
+                      const update = yield* Effect.try({
+                        try: () => Patch.derive(hunk.path, hunk.chunks, original),
+                        catch: (error) =>
+                          new ToolFailure({ message: `patch verification failed: ${errorMessage(error)}` }),
+                      })
+                      const moveTarget = hunk.movePath ? resolveTarget(location, hunk.movePath) : undefined
+                      if (moveTarget) targets.push(moveTarget)
+                      if (moveTarget?.externalDirectory) {
+                        yield* permission.assert({
+                          action: "external_directory",
+                          resources: [moveTarget.externalDirectory.resource],
+                          save: [moveTarget.externalDirectory.resource],
+                          metadata: {
+                            filepath: moveTarget.canonical,
+                            parentDir: moveTarget.externalDirectory.directory,
+                          },
+                          sessionID: context.sessionID,
+                          agent: context.agent,
+                          source,
+                        })
+                      }
+                      prepared.push({
+                        ...hunk,
+                        target,
+                        content: Patch.joinBom(update.content, update.bom),
+                        before,
+                        after: update.content,
+                        moveTarget,
+                      })
+                      if (!moveTarget) updates.set(target.canonical, Patch.joinBom(update.content, update.bom))
+                    }).pipe(
+                      Effect.mapError((error) =>
+                        error instanceof ToolFailure
+                          ? error
+                          : new ToolFailure({ message: `Unable to prepare patch at ${hunk.path}`, error }),
                       ),
                     )
-                    prepared.push({ ...hunk, target, before: content.text, after: "" })
-                    return
                   }
-                  const previous = updates.get(target.absolute)
-                  const original =
-                    previous ??
-                    (yield* Effect.gen(function* () {
-                      const content = yield* FileMutation.readText(environment.files, target.absolute).pipe(
-                        Effect.mapError(
-                          (error) =>
-                            new ToolFailure({
-                              message: `patch verification failed: Failed to read file to update ${target.absolute}: ${errorMessage(error)}`,
-                            }),
-                        ),
-                      )
-                      return Bom.join(content.text, content.bom)
-                    }))
-                  const before = Bom.split(original).text
-                  const update = yield* Effect.try({
-                    try: () => Patch.derive(hunk.path, hunk.chunks, original),
-                    catch: (error) => new ToolFailure({ message: `patch verification failed: ${errorMessage(error)}` }),
+
+                  const patchFiles = prepared.map((change) => patchFile(change))
+                  yield* permission.assert({
+                    action: "edit",
+                    resources: [...new Set(targets.map((target) => target.resource))],
+                    save: ["*"],
+                    metadata: {
+                      filepath: targets.map((target) => target.resource).join(", "),
+                      diff: patchFiles.map((file) => `${file.patch}\n`).join(""),
+                      files: patchFiles,
+                    },
+                    sessionID: context.sessionID,
+                    agent: context.agent,
+                    source,
                   })
-                  const moveTarget = hunk.movePath ? resolveTarget(location, hunk.movePath) : undefined
-                  if (moveTarget) targets.push(moveTarget)
-                  if (moveTarget?.externalDirectory) {
-                    yield* permission.assert({
-                      action: "external_directory",
-                      resources: [moveTarget.externalDirectory.resource],
-                      save: [moveTarget.externalDirectory.resource],
-                      metadata: {
-                        filepath: moveTarget.absolute,
-                        parentDir: moveTarget.externalDirectory.directory,
-                      },
-                      sessionID: context.sessionID,
-                      agent: context.agent,
-                      source,
-                    })
-                  }
-                  prepared.push({
-                    ...hunk,
-                    target,
-                    content: Patch.joinBom(update.content, update.bom),
-                    before,
-                    after: update.content,
-                    moveTarget,
+
+                  yield* Effect.forEach(
+                    prepared,
+                    (change) =>
+                      Effect.gen(function* () {
+                        if (change.type === "add") {
+                          yield* fs
+                            .writeWithDirs(
+                              change.target.canonical,
+                              change.contents.endsWith("\n") || change.contents === ""
+                                ? change.contents
+                                : `${change.contents}\n`,
+                            )
+                            .pipe(
+                              Effect.mapError((error) => fail(`Failed to write ${change.target.resource}`, error)),
+                            )
+                          applied.push({
+                            type: change.type,
+                            resource: change.target.resource,
+                            target: change.target.canonical,
+                          })
+                          return
+                        }
+                        if (change.type === "delete") {
+                          yield* fs
+                            .remove(change.target.canonical)
+                            .pipe(
+                              Effect.mapError((error) => fail(`Failed to delete ${change.target.resource}`, error)),
+                            )
+                          applied.push({
+                            type: change.type,
+                            resource: change.target.resource,
+                            target: change.target.canonical,
+                          })
+                          return
+                        }
+                        if (change.moveTarget) {
+                          const moveTarget = change.moveTarget
+                          yield* fs
+                            .writeWithDirs(moveTarget.canonical, change.content)
+                            .pipe(Effect.mapError((error) => fail(`Failed to write ${moveTarget.resource}`, error)))
+                          yield* fs.remove(change.target.canonical).pipe(
+                            Effect.mapError((error) =>
+                              fail(`Wrote ${moveTarget.resource} but failed to remove ${change.target.resource}`, error),
+                            ),
+                          )
+                          applied.push({
+                            type: change.type,
+                            resource: change.moveTarget.resource,
+                            target: change.moveTarget.canonical,
+                          })
+                          return
+                        }
+                        yield* fs
+                          .writeWithDirs(change.target.canonical, change.content)
+                          .pipe(Effect.mapError((error) => fail(`Failed to write ${change.target.resource}`, error)))
+                        applied.push({
+                          type: change.type,
+                          resource: change.target.resource,
+                          target: change.target.canonical,
+                        })
+                      }),
+                    { discard: true },
+                  )
+                  const formatted = new Map<string, string>()
+                  yield* Effect.forEach(
+                    [...new Set(applied.filter((item) => item.type !== "delete").map((item) => item.target))],
+                    (target) =>
+                      Effect.gen(function* () {
+                        const current = yield* Bom.readFile(fs, target).pipe(
+                          Effect.mapError((error) => fail(`Failed to read ${target}`, error)),
+                        )
+                        formatted.set(
+                          target,
+                          (yield* formatter.file(target))
+                            ? yield* Bom.syncFile(fs, target, current.bom).pipe(
+                                Effect.mapError((error) => fail(`Failed to sync ${target}`, error)),
+                              )
+                            : current.text,
+                        )
+                      }),
+                    { discard: true },
+                  )
+                  const files = yield* Effect.forEach(prepared, (change) => {
+                    if (change.type === "delete") return Effect.succeed(patchFile(change))
+                    const target = change.type === "update" && change.moveTarget ? change.moveTarget : change.target
+                    return Effect.succeed(patchFile(change, formatted.get(target.canonical)))
                   })
-                  if (!moveTarget) updates.set(target.absolute, Patch.joinBom(update.content, update.bom))
+                  return { applied, files }
                 }).pipe(
+                  Effect.map((output) => ({
+                    output,
+                    content: toModelOutput(output),
+                    metadata: { files: output.files },
+                  })),
                   Effect.mapError((error) =>
                     error instanceof ToolFailure
                       ? error
-                      : new ToolFailure({ message: `Unable to prepare patch at ${hunk.path}`, error }),
+                      : new ToolFailure({ message: "Unable to apply patch", error }),
                   ),
                 )
-              }
-
-              const patchFiles = prepared.map((change) => patchFile(change))
-              yield* permission.assert({
-                action: "edit",
-                resources: [...new Set(targets.map((target) => target.resource))],
-                save: ["*"],
-                metadata: {
-                  filepath: targets.map((target) => target.resource).join(", "),
-                  diff: patchFiles.map((file) => `${file.patch}\n`).join(""),
-                  files: patchFiles,
-                },
-                sessionID: context.sessionID,
-                agent: context.agent,
-                source,
-              })
-
-              yield* Effect.forEach(
-                prepared,
-                (change) =>
-                  Effect.gen(function* () {
-                    if (change.type === "add") {
-                      yield* environment.files
-                        .write(change.target.absolute, new TextEncoder().encode(change.content))
-                        .pipe(Effect.mapError((error) => fail(`Failed to write ${change.target.resource}`, error)))
-                      applied.push({
-                        type: change.type,
-                        resource: change.target.resource,
-                        target: change.target.absolute,
-                      })
-                      return
-                    }
-                    if (change.type === "delete") {
-                      yield* environment.files
-                        .remove(change.target.absolute)
-                        .pipe(Effect.mapError((error) => fail(`Failed to delete ${change.target.resource}`, error)))
-                      applied.push({
-                        type: change.type,
-                        resource: change.target.resource,
-                        target: change.target.absolute,
-                      })
-                      return
-                    }
-                    if (change.moveTarget) {
-                      const moveTarget = change.moveTarget
-                      yield* environment.files
-                        .write(moveTarget.absolute, new TextEncoder().encode(change.content))
-                        .pipe(Effect.mapError((error) => fail(`Failed to write ${moveTarget.resource}`, error)))
-                      yield* environment.files
-                        .remove(change.target.absolute)
-                        .pipe(
-                          Effect.mapError((error) =>
-                            fail(`Wrote ${moveTarget.resource} but failed to remove ${change.target.resource}`, error),
-                          ),
-                        )
-                      applied.push({
-                        type: change.type,
-                        resource: change.moveTarget.resource,
-                        target: change.moveTarget.absolute,
-                      })
-                      return
-                    }
-                    yield* environment.files
-                      .write(change.target.absolute, new TextEncoder().encode(change.content))
-                      .pipe(Effect.mapError((error) => fail(`Failed to write ${change.target.resource}`, error)))
-                    applied.push({
-                      type: change.type,
-                      resource: change.target.resource,
-                      target: change.target.absolute,
-                    })
-                  }),
-                { discard: true },
-              )
-              const formatted = new Map<string, string>()
-              yield* Effect.forEach(
-                [...new Set(applied.filter((item) => item.type !== "delete").map((item) => item.target))],
-                (target) =>
-                  Effect.gen(function* () {
-                    const current = yield* FileMutation.readText(environment.files, target).pipe(
-                      Effect.mapError((error) => fail(`Failed to read ${target}`, error)),
-                    )
-                    formatted.set(
-                      target,
-                      (yield* formatter.file(target))
-                        ? yield* FileMutation.syncTextBom(environment.files, target, current.bom).pipe(
-                            Effect.mapError((error) => fail(`Failed to sync ${target}`, error)),
-                          )
-                        : current.text,
-                    )
-                  }),
-                { discard: true },
-              )
-              const files = yield* Effect.forEach(prepared, (change) => {
-                if (change.type === "delete") return Effect.succeed(patchFile(change))
-                const target = change.type === "update" && change.moveTarget ? change.moveTarget : change.target
-                return Effect.succeed(patchFile(change, formatted.get(target.absolute)))
-              })
-              return { applied, files }
-            }).pipe(
-              mutation.withLock(lockTargets),
-              Effect.map((output) => ({
-                output,
-                content: toModelOutput(output),
-                metadata: { files: output.files },
-              })),
-              Effect.mapError((error) =>
-                error instanceof ToolFailure ? error : new ToolFailure({ message: "Unable to apply patch", error }),
-              ),
-            )
-          },
-        }),
+              },
+            }),
+        ),
       )
       .pipe(Effect.orDie)
 
@@ -344,16 +356,18 @@ export const Plugin = {
 }
 
 function errorMessage(error: unknown) {
-  if (error instanceof Environment.NotFound) return "file does not exist"
-  if (error instanceof Environment.WrongKind)
-    return error.actual === "directory" ? "path is a directory" : `path is ${error.actual}`
-  if (error instanceof Environment.Failed) return errorMessage(error.cause)
+  if (error instanceof PlatformError) {
+    if (error.reason._tag === "NotFound") return "file does not exist"
+    return error.reason.description ?? error.reason.message
+  }
   return error instanceof Error ? error.message : String(error)
 }
 
 function patchFile(change: Prepared, after = change.after): typeof FileDiff.Info.Type {
   const target = (change.type === "update" ? change.moveTarget : undefined)?.resource ?? change.target.resource
-  const patch = trimDiff(createTwoFilesPatch(change.target.absolute, change.target.absolute, change.before, after))
+  const patch = trimDiff(
+    createTwoFilesPatch(change.target.canonical, change.target.canonical, change.before, after),
+  )
   const counts =
     change.type === "delete"
       ? { additions: 0, deletions: change.before.split("\n").length }
@@ -402,22 +416,22 @@ function trimDiff(diff: string) {
 }
 
 function resolveTarget(location: Location.Interface, value: string): Target {
-  const absolute =
+  const canonical =
     process.platform === "win32"
       ? FSUtil.normalizePath(path.resolve(location.directory, value))
       : path.resolve(location.directory, value)
   const projectRoot = path.parse(location.project.directory).root
   const external =
-    !FSUtil.contains(location.directory, absolute) &&
-    (location.project.directory === projectRoot || !FSUtil.contains(location.project.directory, absolute))
-  const directory = path.dirname(absolute)
+    !FSUtil.contains(location.directory, canonical) &&
+    (location.project.directory === projectRoot || !FSUtil.contains(location.project.directory, canonical))
+  const directory = path.dirname(canonical)
   const resource =
     process.platform === "win32"
       ? FSUtil.normalizePathPattern(path.join(directory, "*"))
       : path.join(directory, "*").replaceAll("\\", "/")
   return {
-    absolute,
-    resource: path.relative(location.project.directory, absolute).replaceAll("\\", "/") || ".",
+    canonical,
+    resource: path.relative(location.project.directory, canonical).replaceAll("\\", "/") || ".",
     externalDirectory: external ? { directory, resource } : undefined,
   }
 }

packages/core/src/tool/plugin/read.ts

@@ -11,7 +11,6 @@ import { Permission } from "../../permission"
 import { SessionInstructions } from "../../session/instructions"
 import { AbsolutePath } from "../../schema"
 import { ReadToolFileSystem } from "../read-filesystem"
-import { Environment } from "../../environment"
 
 export const name = "read"
 const FILENAME = "AGENTS.md"
@@ -26,7 +25,11 @@ const LocationInput = Schema.Struct({
   }),
 })
 export const Input = LocationInput
-const Output = Schema.Union([ReadToolFileSystem.FileContent, ReadToolFileSystem.TextPage, ReadToolFileSystem.ListPage])
+const Output = Schema.Union([
+  ReadToolFileSystem.FileContent,
+  ReadToolFileSystem.TextPage,
+  ReadToolFileSystem.ListPage,
+])
 
 export const Plugin = {
   id: "opencode.tool.read",
@@ -40,99 +43,105 @@ export const Plugin = {
 
     yield* ctx.tool
       .transform((draft) =>
-        draft.add({
-          name,
-          options: { codemode: false },
-          description:
-            "Read the contents of a file or directory. Supports text files, images, and PDFs. Images and PDFs are presented directly to the model. Each text line is prefixed by its 1-based line number as <line>: <content>. The prefix is for reference and is not part of the file content. Directory entries are returned one per line. Use offset and limit to read large files or directories in sections. Prefer one larger read over many small slices, and use grep to find specific content in large files.",
-          input: Input,
-          output: Output,
-          execute: (input, context) => {
-            return Effect.gen(function* () {
-              const source = {
-                type: "tool" as const,
-                messageID: context.messageID,
-                id: context.id,
-              }
-              const target = yield* mutation.resolve({ path: input.path })
-              const external = target.externalDirectory
-              if (external)
+        draft.add(
+          ({
+            name,
+            options: { codemode: false },
+            description:
+              "Read the contents of a file or directory. Supports text files, images, and PDFs. Images and PDFs are presented directly to the model. Each text line is prefixed by its 1-based line number as <line>: <content>. The prefix is for reference and is not part of the file content. Directory entries are returned one per line. Use offset and limit to read large files or directories in sections. Prefer one larger read over many small slices, and use grep to find specific content in large files.",
+            input: Input,
+            output: Output,
+            execute: (input, context) => {
+              return Effect.gen(function* () {
+                const source = {
+                  type: "tool" as const,
+                  messageID: context.messageID,
+                  id: context.id,
+                }
+                const target = yield* mutation.resolve({ path: input.path, kind: "directory" })
+                const external = target.externalDirectory
+                if (external)
+                  yield* permission.assert({
+                    ...LocationMutation.externalDirectoryPermission(external),
+                    sessionID: context.sessionID,
+                    agent: context.agent,
+                    source,
+                  })
+                const resource = target.resource
+                const absolute = AbsolutePath.make(target.canonical)
                 yield* permission.assert({
-                  ...LocationMutation.externalDirectoryPermission(external),
+                  action: name,
+                  resources: [resource],
+                  save: ["*"],
                   sessionID: context.sessionID,
                   agent: context.agent,
                   source,
                 })
-              const resource = target.resource
-              const absolute = AbsolutePath.make(target.absolute)
-              yield* permission.assert({
-                action: name,
-                resources: [resource],
-                save: ["*"],
-                sessionID: context.sessionID,
-                agent: context.agent,
-                source,
-              })
-              const content = yield* reader.read(absolute, resource, { offset: input.offset, limit: input.limit }).pipe(
-                Effect.catchIf(
-                  (error) => error instanceof Environment.NotFound,
-                  () => missing(input.path, target.absolute),
-                ),
-              )
-              // After a successful read, discover nearby AGENTS.md walking up to the Location
-              // root exclusive and inject them as durable synthetic instructions. For a
-              // directory listing the walk starts at the directory itself (so its own AGENTS.md
-              // is discovered); for a file it starts at the file's dirname. External reads are
-              // skipped, and discovery failures never fail the read.
-              yield* Effect.gen(function* () {
-                if (target.externalDirectory !== undefined) return
-                const resolved = yield* fs.resolve(target.absolute)
-                const root = yield* fs.resolve(location.directory)
-                // up() searches its stop directory, so the Location-root AGENTS.md (already
-                // supplied by core initial instructions) is dropped by the dirname filter.
-                const discovered = yield* fs.up({
-                  targets: [FILENAME],
-                  start: content.type === "list-page" ? resolved : dirname(resolved),
-                  stop: root,
-                })
-                const candidates = (yield* Effect.forEach(discovered, fs.resolve)).filter(
-                  (file) => dirname(file) !== root,
+                const type = yield* reader.inspect(absolute).pipe(
+                  Effect.catchReason("PlatformError", "NotFound", () => missing(input.path, target.canonical)),
                 )
-                if (candidates.length === 0) return
-                yield* sessionInstructions.load({ sessionID: context.sessionID, paths: candidates })
+                const content =
+                  type === "directory"
+                    ? yield* reader.list(absolute, { offset: input.offset, limit: input.limit })
+                    : yield* reader.read(absolute, resource, {
+                        offset: input.offset,
+                        limit: input.limit,
+                      })
+                // After a successful read, discover nearby AGENTS.md walking up to the Location
+                // root exclusive and inject them as durable synthetic instructions. For a
+                // directory listing the walk starts at the directory itself (so its own AGENTS.md
+                // is discovered); for a file it starts at the file's dirname. External reads are
+                // skipped, and discovery failures never fail the read.
+                yield* Effect.gen(function* () {
+                  if (target.externalDirectory !== undefined) return
+                  const resolved = yield* fs.resolve(target.canonical)
+                  const root = yield* fs.resolve(location.directory)
+                  // up() searches its stop directory, so the Location-root AGENTS.md (already
+                  // supplied by core initial instructions) is dropped by the dirname filter.
+                  const discovered = yield* fs.up({
+                    targets: [FILENAME],
+                    start: type === "directory" ? resolved : dirname(resolved),
+                    stop: root,
+                  })
+                  const candidates = (yield* Effect.forEach(discovered, fs.resolve)).filter(
+                    (file) => dirname(file) !== root,
+                  )
+                  if (candidates.length === 0) return
+                  yield* sessionInstructions.load({ sessionID: context.sessionID, paths: candidates })
+                }).pipe(
+                  Effect.catch(() => Effect.void),
+                  Effect.catchDefect(() => Effect.void),
+                )
+                if (content.type === "file" && content.encoding === "base64" && !SUPPORTED_MEDIA_MIMES.has(content.mime))
+                  return yield* Effect.fail(new ReadToolFileSystem.BinaryFileError({ resource }))
+                return content
               }).pipe(
-                Effect.catch(() => Effect.void),
-                Effect.catchDefect(() => Effect.void),
+                Effect.map((output) => ({
+                  output,
+                  content: toModelContent(input.path, input.offset, output),
+                })),
+                Effect.mapError((error) => {
+                  if (error instanceof ToolFailure) return error
+                  const message =
+                    error instanceof ReadToolFileSystem.BinaryFileError ||
+                    error instanceof ReadToolFileSystem.MediaIngestLimitError ||
+                    error instanceof ReadToolFileSystem.MalformedUtf8Error ||
+                    error instanceof ReadToolFileSystem.OffsetOutOfRangeError ||
+                    error instanceof ReadToolFileSystem.PathKindError
+                      ? error.message
+                      : `Unable to read ${input.path}`
+                  return new ToolFailure({ message, error })
+                }),
               )
-              if (content.type === "file" && content.encoding === "base64" && !SUPPORTED_MEDIA_MIMES.has(content.mime))
-                return yield* Effect.fail(new ReadToolFileSystem.BinaryFileError({ resource }))
-              return content
-            }).pipe(
-              Effect.map((output) => ({
-                output,
-                content: toModelContent(input.path, input.offset, output),
-                metadata: { truncated: output.type === "file" ? false : output.truncated },
-              })),
-              Effect.mapError((error) => {
-                if (error instanceof ToolFailure) return error
-                const message =
-                  error instanceof ReadToolFileSystem.BinaryFileError ||
-                  error instanceof ReadToolFileSystem.MediaIngestLimitError ||
-                  error instanceof ReadToolFileSystem.OffsetOutOfRangeError ||
-                  error instanceof ReadToolFileSystem.PathKindError
-                    ? error.message
-                    : `Unable to read ${input.path}`
-                return new ToolFailure({ message, error })
-              }),
-            )
-          },
-        }),
+            },
+          }),
+        ),
       )
       .pipe(Effect.orDie)
 
-    const missing = Effect.fn("ReadTool.missing")(function* (input: string, absolute: string) {
+    const missing = Effect.fn("ReadTool.missing")(function* (input: string, canonical: string) {
       const base = basename(input).toLowerCase()
-      const suggestions = yield* fs.readDirectory(dirname(absolute)).pipe(
+      const suggestions = yield* fs.readDirectory(dirname(canonical)).pipe(
         Effect.map((entries) =>
           entries
             .filter((entry) => {

packages/core/src/tool/plugin/shell.ts

@@ -5,8 +5,7 @@ import { ToolFailure } from "@opencode-ai/ai"
 import type { Content } from "@opencode-ai/schema/tool"
 import type { Context as PluginContext } from "@opencode-ai/plugin/effect/plugin"
 import { Deferred, Effect, Schema, Scope } from "effect"
-import { Config } from "../../config"
-import { Environment } from "../../environment"
+import { FSUtil } from "@opencode-ai/util/fs-util"
 import { LocationMutation } from "../../location-mutation"
 import { Permission } from "../../permission"
 import { PluginRuntime } from "../../plugin/runtime"
@@ -14,10 +13,10 @@ import { NonNegativeInt } from "../../schema"
 import { SessionSchema } from "../../session/schema"
 import { Shell } from "../../shell"
 import { ShellParse } from "../../shell/parse"
-import { ToolOutput } from "../../tool-output"
 
 export const name = "shell"
 export const DEFAULT_TIMEOUT_MS = 2 * 60 * 1_000
+export const MAX_CAPTURE_BYTES = 1024 * 1024
 
 const BACKGROUND_STARTED = "The command was moved to the background."
 const BACKGROUND_INSTRUCTION =
@@ -83,11 +82,10 @@ export const Plugin = {
   effect: Effect.fn("ShellTool.Plugin")(function* (ctx: PluginContext) {
     const runtime = yield* PluginRuntime.Service
     const scope = yield* Scope.Scope
-    const environment = yield* Environment.Service
+    const fsUtil = yield* FSUtil.Service
     const mutation = yield* LocationMutation.Service
     const shell = yield* Shell.Service
     const permission = yield* Permission.Service
-    const config = yield* Config.Service
 
     const notifyWhenDone = Effect.fn("ShellTool.notifyWhenDone")(function* (
       sessionID: SessionSchema.ID,
@@ -124,180 +122,174 @@ export const Plugin = {
 
     yield* ctx.tool
       .transform((draft) =>
-        draft.add({
-          name,
-          options: { codemode: false },
-          description: description(),
-          input: Input,
-          output: Output,
-          execute: (input, context) =>
-            Effect.gen(function* () {
-              const source = {
-                type: "tool" as const,
-                messageID: context.messageID,
-                id: context.id,
-              }
-              const timeout = input.background === true ? (input.timeout ?? 0) : (input.timeout ?? DEFAULT_TIMEOUT_MS)
-              let finalTimeout = timeout
-              const info = yield* shell.create(
-                {
-                  command: input.command,
-                  cwd: input.workdir,
-                  timeout,
-                  metadata: { sessionID: context.sessionID },
-                },
-                (invocation) =>
-                  Effect.gen(function* () {
-                    const target = yield* mutation.resolve({ path: invocation.cwd, kind: "directory" })
-                    const parsed = yield* ShellParse.scan(invocation.command, invocation.shell, target.absolute)
-                    const directories = yield* Effect.forEach(parsed.directories, (directory) =>
-                      mutation.resolve({ path: path.resolve(target.absolute, directory), kind: "directory" }),
-                    )
-                    invocation.cwd = target.absolute
-                    finalTimeout = invocation.timeout
-                    const external = [target, ...directories]
-                      .map((item) => item.externalDirectory)
-                      .filter((item) => item !== undefined)
-                      .filter(
-                        (item, index, items) => items.findIndex((other) => other.resource === item.resource) === index,
-                      )
-                    if (external.length > 0)
-                      yield* permission.assert({
-                        action: "external_directory",
-                        resources: external.map((item) => item.resource),
-                        save: external.map((item) => item.save),
-                        sessionID: context.sessionID,
-                        agent: context.agent,
-                        source,
-                      })
-                    if (parsed.commands.length > 0)
-                      yield* permission.assert({
-                        action: name,
-                        resources: parsed.commands.map((command) => command.resource),
-                        save: parsed.commands.map((command) => command.save),
-                        sessionID: context.sessionID,
-                        agent: context.agent,
-                        source,
-                      })
-                    const workdir = yield* Environment.typeFollowing(environment.files, target.absolute).pipe(
-                      Effect.catchTag("Environment.NotFound", () =>
-                        Effect.fail(new Error(`Working directory does not exist: ${target.absolute}`)),
-                      ),
-                    )
-                    if (workdir !== "directory")
-                      return yield* Effect.fail(new Error(`Working directory is not a directory: ${target.absolute}`))
-                  }),
-              )
-              yield* context.progress({ shellID: info.id })
-
-              const captureShell = Effect.fn("ShellTool.captureShell")(function* () {
-                const configured = Config.latest(yield* config.entries(), "tool_output")
-                const maxLines = configured?.max_lines ?? ToolOutput.MAX_LINES
-                const maxBytes = configured?.max_bytes ?? ToolOutput.MAX_BYTES
-                const latest = yield* shell.output(info.id, { cursor: Number.MAX_SAFE_INTEGER })
-                const page = yield* shell.output(info.id, {
-                  cursor: Math.max(0, latest.size - maxBytes),
-                  limit: maxBytes,
-                })
-                const lines = page.output.split("\n")
-                if (page.output.endsWith("\n")) lines.pop()
-                const truncated = latest.size > maxBytes || lines.length > maxLines
-                const output = lines.length > maxLines ? lines.slice(-maxLines).join("\n") : page.output
-                const notice = truncated ? `\n\n[output truncated; full output saved to: ${info.file}]` : ""
-                return {
-                  output: `${output || "(no output)"}${notice}`,
-                  truncated,
+        draft.add(
+          ({
+            name,
+            options: { codemode: false },
+            description: description(),
+            input: Input,
+            output: Output,
+            execute: (input, context) =>
+              Effect.gen(function* () {
+                const source = {
+                  type: "tool" as const,
+                  messageID: context.messageID,
+                  id: context.id,
                 }
-              })
+                const timeout = input.background === true ? (input.timeout ?? 0) : (input.timeout ?? DEFAULT_TIMEOUT_MS)
+                let finalTimeout = timeout
+                const info = yield* shell.create(
+                  {
+                    command: input.command,
+                    cwd: input.workdir,
+                    timeout,
+                    metadata: { sessionID: context.sessionID },
+                  },
+                  (invocation) =>
+                    Effect.gen(function* () {
+                      const target = yield* mutation.resolve({ path: invocation.cwd, kind: "directory" })
+                      const parsed = yield* ShellParse.scan(invocation.command, invocation.shell, target.canonical)
+                      const directories = yield* Effect.forEach(parsed.directories, (directory) =>
+                        mutation.resolve({ path: path.resolve(target.canonical, directory), kind: "directory" }),
+                      )
+                      invocation.cwd = target.canonical
+                      finalTimeout = invocation.timeout
+                      const external = [target, ...directories]
+                        .map((item) => item.externalDirectory)
+                        .filter((item) => item !== undefined)
+                        .filter((item, index, items) => items.findIndex((other) => other.resource === item.resource) === index)
+                      if (external.length > 0)
+                        yield* permission.assert({
+                          action: "external_directory",
+                          resources: external.map((item) => item.resource),
+                          save: external.map((item) => item.save),
+                          sessionID: context.sessionID,
+                          agent: context.agent,
+                          source,
+                        })
+                      if (parsed.commands.length > 0)
+                        yield* permission.assert({
+                          action: name,
+                          resources: parsed.commands.map((command) => command.resource),
+                          save: parsed.commands.map((command) => command.save),
+                          sessionID: context.sessionID,
+                          agent: context.agent,
+                          source,
+                        })
+                      const workdir = yield* fsUtil.stat(target.canonical).pipe(
+                        Effect.catchReason("PlatformError", "NotFound", () =>
+                          Effect.fail(new Error(`Working directory does not exist: ${target.canonical}`)),
+                        ),
+                      )
+                      if (workdir.type !== "Directory")
+                        return yield* Effect.fail(new Error(`Working directory is not a directory: ${target.canonical}`))
+                    }),
+                )
+                yield* context.progress({ shellID: info.id })
 
-              const settleShell = Effect.fn("ShellTool.settleShell")(function* () {
-                const final = yield* shell.wait(info.id)
-                const capture = yield* captureShell()
+                const captureShell = Effect.fn("ShellTool.captureShell")(function* () {
+                  const latest = yield* shell.output(info.id, { cursor: Number.MAX_SAFE_INTEGER })
+                  const truncated = latest.size > MAX_CAPTURE_BYTES
+                  const page = yield* shell.output(info.id, {
+                    cursor: Math.max(0, latest.size - MAX_CAPTURE_BYTES),
+                    limit: MAX_CAPTURE_BYTES,
+                  })
+                  const notice = truncated ? `\n\n[output truncated; full output saved to: ${info.file}]` : ""
+                  return {
+                    output: `${page.output || "(no output)"}${notice}`,
+                    truncated,
+                  }
+                })
+
+                const settleShell = Effect.fn("ShellTool.settleShell")(function* () {
+                  const final = yield* shell.wait(info.id)
+                  const capture = yield* captureShell()
+
+                  // `exit` is optionalKey in the Output schema; a present-but-undefined key
+                  // fails output encoding, so omit it when the process has no exit code.
+                  if (final.status === "timeout") {
+                    return {
+                      ...(final.exit !== undefined ? { exit: final.exit } : {}),
+                      output: `${capture.output}\n\nCommand exceeded timeout of ${finalTimeout} ms. Retry with a larger timeout if the command is expected to take longer.`,
+                      truncated: capture.truncated,
+                      timeout: true,
+                      status: "completed" as const,
+                    }
+                  }
 
-                // `exit` is optionalKey in the Output schema; a present-but-undefined key
-                // fails output encoding, so omit it when the process has no exit code.
-                if (final.status === "timeout") {
                   return {
                     ...(final.exit !== undefined ? { exit: final.exit } : {}),
-                    output: `${capture.output}\n\nCommand exceeded timeout of ${finalTimeout} ms. Retry with a larger timeout if the command is expected to take longer.`,
+                    output: capture.output,
                     truncated: capture.truncated,
-                    timeout: true,
                     status: "completed" as const,
                   }
+                })
+
+                const settled = yield* Deferred.make<Output>()
+                const run = settleShell().pipe(
+                  Effect.tap((output) => Deferred.succeed(settled, output)),
+                  Effect.map((output) => output.output),
+                  Effect.onInterrupt(() => shell.remove(info.id).pipe(Effect.ignore)),
+                )
+                const job = yield* runtime.job.start({
+                  id: context.id,
+                  type: name,
+                  title: info.command,
+                  metadata: { sessionID: context.sessionID, shellID: info.id },
+                  run,
+                })
+
+                if (input.background === true) {
+                  yield* runtime.job.background(job.id)
+                  yield* notifyWhenDone(context.sessionID, context.id, info.command)
+                  return {
+                    output: BACKGROUND_STARTED,
+                    shellID: info.id,
+                    truncated: false,
+                    status: "running" as const,
+                  }
                 }
 
-                return {
-                  ...(final.exit !== undefined ? { exit: final.exit } : {}),
-                  output: capture.output,
-                  truncated: capture.truncated,
-                  status: "completed" as const,
+                const result = yield* runtime.job.block({ id: job.id, sessionID: context.sessionID }).pipe(
+                  Effect.onInterrupt(() => runtime.job.cancel(job.id).pipe(Effect.ignore)),
+                )
+                if (result?.type === "backgrounded") {
+                  yield* shell.timeout(info.id, 0)
+                  yield* notifyWhenDone(context.sessionID, context.id, info.command)
+                  return {
+                    output: BACKGROUND_STARTED,
+                    shellID: info.id,
+                    truncated: false,
+                    status: "running" as const,
+                  }
                 }
-              })
+                if (result?.info.status === "error")
+                  return yield* Effect.fail(new Error(result.info.error ?? "Command failed"))
+                if (result?.info.status === "cancelled") return yield* Effect.fail(new Error("Command cancelled"))
 
-              const settled = yield* Deferred.make<Output>()
-              const run = settleShell().pipe(
-                Effect.tap((output) => Deferred.succeed(settled, output)),
-                Effect.map((output) => output.output),
-                Effect.onInterrupt(() => shell.remove(info.id).pipe(Effect.ignore)),
-              )
-              const job = yield* runtime.job.start({
-                id: context.id,
-                type: name,
-                title: info.command,
-                metadata: { sessionID: context.sessionID, shellID: info.id },
-                run,
-              })
-
-              if (input.background === true) {
-                yield* runtime.job.background(job.id)
-                yield* notifyWhenDone(context.sessionID, context.id, info.command)
-                return {
-                  output: BACKGROUND_STARTED,
-                  shellID: info.id,
-                  truncated: false,
-                  status: "running" as const,
-                }
-              }
-
-              const result = yield* runtime.job
-                .block({ id: job.id, sessionID: context.sessionID })
-                .pipe(Effect.onInterrupt(() => runtime.job.cancel(job.id).pipe(Effect.ignore)))
-              if (result?.type === "backgrounded") {
-                yield* shell.timeout(info.id, 0)
-                yield* notifyWhenDone(context.sessionID, context.id, info.command)
-                return {
-                  output: BACKGROUND_STARTED,
-                  shellID: info.id,
-                  truncated: false,
-                  status: "running" as const,
-                }
-              }
-              if (result?.info.status === "error")
-                return yield* Effect.fail(new Error(result.info.error ?? "Command failed"))
-              if (result?.info.status === "cancelled") return yield* Effect.fail(new Error("Command cancelled"))
-
-              return yield* Deferred.await(settled)
-            }).pipe(
-              Effect.map((output) => {
-                const content: Array<Content> = [{ type: "text", text: output.output }]
-                const model = modelOutput(output)
-                if (model) content.push({ type: "text", text: model })
-                return {
-                  output,
-                  content,
-                  metadata: {
-                    truncated: output.truncated,
-                    ...("exit" in output && output.exit !== undefined ? { exit: output.exit } : {}),
-                    ...("shellID" in output && output.shellID !== undefined ? { shellID: output.shellID } : {}),
-                    ...("timeout" in output && output.timeout !== undefined ? { timeout: output.timeout } : {}),
-                  },
-                }
-              }),
-              Effect.mapError(
-                (error) => new ToolFailure({ message: `Unable to execute command: ${input.command}`, error }),
+                return yield* Deferred.await(settled)
+              }).pipe(
+                Effect.map((output) => {
+                  const content: Array<Content> = [{ type: "text", text: output.output }]
+                  const model = modelOutput(output)
+                  if (model) content.push({ type: "text", text: model })
+                  return {
+                    output,
+                    content,
+                    metadata: {
+                      truncated: output.truncated,
+                      ...("exit" in output && output.exit !== undefined ? { exit: output.exit } : {}),
+                      ...("shellID" in output && output.shellID !== undefined ? { shellID: output.shellID } : {}),
+                      ...("timeout" in output && output.timeout !== undefined ? { timeout: output.timeout } : {}),
+                    },
+                  }
+                }),
+                Effect.mapError(
+                  (error) => new ToolFailure({ message: `Unable to execute command: ${input.command}`, error }),
+                ),
               ),
-            ),
-        }),
+          }),
+        ),
       )
       .pipe(Effect.orDie)
 

packages/core/src/tool/plugin/write.ts

@@ -10,7 +10,7 @@ import type { Context as PluginContext } from "@opencode-ai/plugin/effect/plugin
 import { ToolFailure } from "@opencode-ai/ai"
 import { Effect, Schema } from "effect"
 import { Bom } from "@opencode-ai/util/bom"
-import { Environment } from "../../environment"
+import { FSUtil } from "@opencode-ai/util/fs-util"
 import { FileMutation } from "../../file-mutation"
 import { Formatter } from "../../formatter"
 import { LocationMutation } from "../../location-mutation"
@@ -47,61 +47,66 @@ export const Plugin = {
   id: "opencode.tool.write",
   effect: Effect.fn("WriteTool.Plugin")(function* (ctx: PluginContext) {
     const mutation = yield* LocationMutation.Service
-    const fileMutation = yield* FileMutation.Service
-    const environment = yield* Environment.Service
+    const files = yield* FileMutation.Service
     const formatter = yield* Formatter.Service
+    const fs = yield* FSUtil.Service
     const permission = yield* Permission.Service
 
     yield* ctx.tool
       .transform((draft) =>
-        draft.add({
-          name,
-          options: { codemode: false, permission: "edit" },
-          description:
-            "Writes a file to the local filesystem, overwriting if one exists.\n\nMissing parent directories are created automatically.\n\nUse this tool to create new files or overwrite existing files. For partial changes, use the edit tool instead.",
-          input: Input,
-          output: Output,
-          execute: (input, context) =>
-            Effect.gen(function* () {
-              const source = {
-                type: "tool" as const,
-                messageID: context.messageID,
-                id: context.id,
-              }
-              const target = yield* mutation.resolve({ path: input.path, kind: "file" })
-              const external = target.externalDirectory
-              if (external)
-                yield* permission.assert({
-                  ...LocationMutation.externalDirectoryPermission(external),
-                  sessionID: context.sessionID,
-                  agent: context.agent,
-                  source,
-                })
-              const current = yield* FileMutation.readText(environment.files, target.absolute).pipe(
-                Effect.catchTag("Environment.NotFound", () => Effect.succeed(undefined)),
-              )
-              const next = Bom.split(input.content)
-              const preview = fileDiff(target.resource, current?.text ?? "", next.text, current ? "modified" : "added")
-              yield* permission.assert({
-                action: "edit",
-                resources: [target.resource],
-                save: ["*"],
-                metadata: { files: [preview] },
-                sessionID: context.sessionID,
-                agent: context.agent,
-                source,
-              })
-              const result = yield* fileMutation.writeTextPreservingBom({ target, content: input.content })
-              const bom = (yield* FileMutation.readText(environment.files, target.absolute)).bom
-              if (yield* formatter.file(target.absolute)) {
-                yield* FileMutation.syncTextBom(environment.files, target.absolute, bom)
-              }
-              return result
-            }).pipe(
-              Effect.map((output) => ({ output, content: toModelOutput(output) })),
-              Effect.mapError((error) => new ToolFailure({ message: `Unable to write ${input.path}`, error })),
-            ),
-        }),
+        draft.add(
+          ({
+              name,
+              options: { codemode: false, permission: "edit" },
+              description:
+                "Writes a file to the local filesystem, overwriting if one exists.\n\nMissing parent directories are created automatically.\n\nUse this tool to create new files or overwrite existing files. For partial changes, use the edit tool instead.",
+              input: Input,
+              output: Output,
+              execute: (input, context) =>
+                Effect.gen(function* () {
+                  const source = {
+                    type: "tool" as const,
+                    messageID: context.messageID,
+                    id: context.id,
+                  }
+                  const target = yield* mutation.resolve({ path: input.path, kind: "file" })
+                  const external = target.externalDirectory
+                  if (external)
+                    yield* permission.assert({
+                      ...LocationMutation.externalDirectoryPermission(external),
+                      sessionID: context.sessionID,
+                      agent: context.agent,
+                      source,
+                    })
+                  const current = yield* Bom.readFile(fs, target.canonical).pipe(
+                    Effect.catchReason("PlatformError", "NotFound", () => Effect.succeed(undefined)),
+                  )
+                  const next = Bom.split(input.content)
+                  const preview = fileDiff(
+                    target.resource,
+                    current?.text ?? "",
+                    next.text,
+                    current ? "modified" : "added",
+                  )
+                  yield* permission.assert({
+                    action: "edit",
+                    resources: [target.resource],
+                    save: ["*"],
+                    metadata: { files: [preview] },
+                    sessionID: context.sessionID,
+                    agent: context.agent,
+                    source,
+                  })
+                  const result = yield* files.writeTextPreservingBom({ target, content: input.content })
+                  const bom = (yield* Bom.readFile(fs, target.canonical)).bom
+                  if (yield* formatter.file(target.canonical)) yield* Bom.syncFile(fs, target.canonical, bom)
+                  return result
+                }).pipe(
+                  Effect.map((output) => ({ output, content: toModelOutput(output) })),
+                  Effect.mapError((error) => new ToolFailure({ message: `Unable to write ${input.path}`, error })),
+                ),
+            }),
+        ),
       )
       .pipe(Effect.orDie)
   }),

packages/core/src/tool/read-filesystem.ts

@@ -2,22 +2,17 @@ export * as ReadToolFileSystem from "./read-filesystem"
 
 import path from "path"
 import { pathToFileURL } from "url"
-import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
-import { Context, Effect, Layer, Schema } from "effect"
-import { lookup } from "mime-types"
-import { Environment } from "../environment"
-import type { Files } from "../environment"
+import { Context, Effect, Layer, Option, Schema } from "effect"
 import { FileSystem } from "../filesystem"
-import { Mime } from "../mime"
+import { FSUtil } from "@opencode-ai/util/fs-util"
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
 import { AbsolutePath, NonNegativeInt, PositiveInt, RelativePath } from "../schema"
 
 export const MAX_READ_LINES = 2_000
 export const MAX_READ_BYTES = 50 * 1024
 export const MAX_MEDIA_INGEST_BYTES = 20 * 1024 * 1024
-const FIRST_CHUNK = 256 * 1024
 const MAX_LINE_LENGTH = 2_000
 const MAX_LINE_SUFFIX = `... (line truncated to ${MAX_LINE_LENGTH} chars)`
-const MEDIA_MIMES = new Set(["image/png", "image/jpeg", "image/gif", "image/webp", "application/pdf"])
 
 export class BinaryFileError extends Schema.TaggedErrorClass<BinaryFileError>()("ReadTool.BinaryFileError", {
   resource: Schema.String,
@@ -39,6 +34,14 @@ export class MediaIngestLimitError extends Schema.TaggedErrorClass<MediaIngestLi
   }
 }
 
+export class MalformedUtf8Error extends Schema.TaggedErrorClass<MalformedUtf8Error>()("ReadTool.MalformedUtf8Error", {
+  resource: Schema.String,
+}) {
+  override get message() {
+    return `File is not valid UTF-8: ${this.resource}`
+  }
+}
+
 export class OffsetOutOfRangeError extends Schema.TaggedErrorClass<OffsetOutOfRangeError>()(
   "ReadTool.OffsetOutOfRangeError",
   { offset: Schema.Number },
@@ -57,11 +60,12 @@ export class PathKindError extends Schema.TaggedErrorClass<PathKindError>()("Rea
   }
 }
 
+export type InspectError = FSUtil.Error | PathKindError
 export type ReadError =
-  | Environment.NotFound
-  | Environment.Failed
+  | FSUtil.Error
   | BinaryFileError
   | MediaIngestLimitError
+  | MalformedUtf8Error
   | OffsetOutOfRangeError
   | PathKindError
 
@@ -86,149 +90,272 @@ export class TextPage extends Schema.Class<TextPage>("ReadTool.TextPage")({
   next: Schema.optionalKey(PositiveInt),
 }) {}
 
-export interface ListEntry extends Schema.Schema.Type<typeof ListEntry> {}
-export const ListEntry = Schema.Struct({
-  path: RelativePath,
-  type: Schema.Literals(["file", "directory", "symlink"]),
-}).annotate({ identifier: "ReadTool.ListEntry" })
-
 export class ListPage extends Schema.Class<ListPage>("ReadTool.ListPage")({
   type: Schema.Literal("list-page"),
-  entries: Schema.Array(ListEntry),
+  entries: Schema.Array(FileSystem.Entry),
   truncated: Schema.Boolean,
   next: Schema.optionalKey(PositiveInt),
 }) {}
 
 export interface Interface {
+  readonly inspect: (path: AbsolutePath) => Effect.Effect<"file" | "directory", InspectError>
   readonly read: (
     path: AbsolutePath,
     resource: string,
     page?: PageInput,
-  ) => Effect.Effect<FileContent | TextPage | ListPage, ReadError>
+  ) => Effect.Effect<FileContent | TextPage, ReadError>
+  readonly list: (path: AbsolutePath, page?: PageInput) => Effect.Effect<ListPage, FSUtil.Error>
 }
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/ReadToolFileSystem") {}
 
-const mimeType = (value: string) => lookup(value) || "application/octet-stream"
+const extensions = new Set([
+  ".zip",
+  ".tar",
+  ".gz",
+  ".exe",
+  ".dll",
+  ".so",
+  ".class",
+  ".jar",
+  ".war",
+  ".7z",
+  ".doc",
+  ".docx",
+  ".xls",
+  ".xlsx",
+  ".ppt",
+  ".pptx",
+  ".odt",
+  ".ods",
+  ".odp",
+  ".bin",
+  ".dat",
+  ".obj",
+  ".o",
+  ".a",
+  ".lib",
+  ".wasm",
+  ".pyc",
+  ".pyo",
+])
+const startsWith = (bytes: Uint8Array, prefix: number[]) => prefix.every((value, index) => bytes[index] === value)
+const mediaMime = (bytes: Uint8Array) => {
+  if (startsWith(bytes, [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a])) return "image/png"
+  if (startsWith(bytes, [0xff, 0xd8, 0xff])) return "image/jpeg"
+  if (startsWith(bytes, [0x47, 0x49, 0x46, 0x38])) return "image/gif"
+  if (startsWith(bytes, [0x52, 0x49, 0x46, 0x46]) && startsWith(bytes.subarray(8), [0x57, 0x45, 0x42, 0x50]))
+    return "image/webp"
+  if (startsWith(bytes, [0x25, 0x50, 0x44, 0x46, 0x2d])) return "application/pdf"
+}
+const binary = (resource: string, bytes: Uint8Array) => {
+  if (extensions.has(path.extname(resource).toLowerCase())) return true
+  if (bytes.length === 0) return false
+  let nonPrintable = 0
+  for (const byte of bytes) {
+    if (byte === 0) return true
+    if (byte < 9 || (byte > 13 && byte < 32)) nonPrintable++
+  }
+  return nonPrintable / bytes.length > 0.3
+}
+const decodeUtf8 = (resource: string, decoder: TextDecoder, bytes?: Uint8Array) =>
+  Effect.try({
+    try: () => decoder.decode(bytes, { stream: bytes !== undefined }),
+    catch: (error) => {
+      if (error instanceof TypeError) return new MalformedUtf8Error({ resource })
+      throw error
+    },
+  })
+const decodeChunk = (resource: string, decoder: TextDecoder, bytes: Uint8Array) =>
+  bytes.includes(0) ? Effect.fail(new BinaryFileError({ resource })) : decodeUtf8(resource, decoder, bytes)
+
+export const inspect = Effect.fn("ReadTool.inspect")(function* (fs: FSUtil.Interface, input: string) {
+  const info = yield* fs.stat(input)
+  const type = info.type === "File" ? "file" : info.type === "Directory" ? "directory" : undefined
+  if (!type) return yield* Effect.fail(new PathKindError({ resource: input, expected: "a file or directory" }))
+  return type
+})
 
 export const read = Effect.fn("ReadTool.read")(function* (
-  files: Files,
-  input: AbsolutePath,
+  fs: FSUtil.Interface,
+  input: string,
   resource: string,
   page: PageInput = {},
 ) {
-  const first = yield* files.read(input, { offset: 0, length: FIRST_CHUNK }).pipe(
-    Effect.catchTag("Environment.WrongKind", (error) => {
-      if (error.actual !== "directory")
-        return Effect.fail(new PathKindError({ resource, expected: "a file or directory" }))
-      return files.list(input).pipe(
-        Effect.map((entries) => list(entries, page)),
-        Effect.catchTag("Environment.WrongKind", () =>
-          Effect.fail(new PathKindError({ resource, expected: "a file or directory" })),
-        ),
+  const real = yield* fs.realPath(input)
+  return yield* Effect.scoped(
+    Effect.gen(function* () {
+      const file = yield* fs.open(real, { flag: "r" })
+      const info = yield* file.stat
+      if (info.type !== "File") return yield* Effect.fail(new PathKindError({ resource, expected: "a file" }))
+      const first = Option.getOrElse(
+        yield* file.readAlloc(Math.min(64 * 1024, Number(info.size) || 4 * 1024)),
+        () => new Uint8Array(),
       )
+      const mime = mediaMime(first)
+      if (mime) {
+        if (info.size > MAX_MEDIA_INGEST_BYTES)
+          return yield* Effect.fail(new MediaIngestLimitError({ resource, maximumBytes: MAX_MEDIA_INGEST_BYTES }))
+        const chunks = [first]
+        let total = first.length
+        while (total <= MAX_MEDIA_INGEST_BYTES) {
+          const chunk = yield* file.readAlloc(Math.min(64 * 1024, MAX_MEDIA_INGEST_BYTES + 1 - total))
+          if (Option.isNone(chunk)) break
+          chunks.push(chunk.value)
+          total += chunk.value.length
+        }
+        if (total > MAX_MEDIA_INGEST_BYTES)
+          return yield* Effect.fail(new MediaIngestLimitError({ resource, maximumBytes: MAX_MEDIA_INGEST_BYTES }))
+        return {
+          type: "file" as const,
+          uri: pathToFileURL(real).href,
+          name: path.basename(real),
+          content: Buffer.concat(
+            chunks.map((chunk) => Buffer.from(chunk)),
+            total,
+          ).toString("base64"),
+          encoding: "base64" as const,
+          mime,
+        }
+      }
+      if (extensions.has(path.extname(resource).toLowerCase()))
+        return yield* Effect.fail(new BinaryFileError({ resource }))
+      const paged = info.size > MAX_READ_BYTES || page.offset !== undefined || page.limit !== undefined
+      if (!paged) {
+        if (binary(resource, first)) return yield* Effect.fail(new BinaryFileError({ resource }))
+        const decoder = new TextDecoder("utf-8", { fatal: true })
+        const text = [yield* decodeUtf8(resource, decoder, first)]
+        while (true) {
+          const chunk = yield* file.readAlloc(64 * 1024)
+          if (Option.isNone(chunk)) break
+          text.push(yield* decodeChunk(resource, decoder, chunk.value))
+        }
+        text.push(yield* decodeUtf8(resource, decoder))
+        return {
+          type: "file" as const,
+          uri: pathToFileURL(real).href,
+          name: path.basename(real),
+          content: text.join(""),
+          encoding: "utf8" as const,
+          mime: FSUtil.mimeType(real),
+        }
+      }
+      const offset = page.offset || 1
+      const limit = Math.min(page.limit || MAX_READ_LINES, MAX_READ_LINES)
+      const lines: string[] = []
+      const decoder = new TextDecoder("utf-8", { fatal: true })
+      let pending = ""
+      let discard = false
+      let line = 1
+      let bytes = 0
+      let next: number | undefined
+      const append = (input: string) => {
+        if (line < offset) {
+          line++
+          return true
+        }
+        if (lines.length >= limit || bytes >= MAX_READ_BYTES) {
+          next = line
+          return false
+        }
+        const text = input.length > MAX_LINE_LENGTH ? input.slice(0, MAX_LINE_LENGTH) + MAX_LINE_SUFFIX : input
+        const size = Buffer.byteLength(text, "utf-8") + (lines.length > 0 ? 1 : 0)
+        if (bytes + size > MAX_READ_BYTES) {
+          next = line
+          return false
+        }
+        lines.push(text)
+        bytes += size
+        line++
+        return true
+      }
+      const consume = (input: string) => {
+        let text = input
+        while (true) {
+          const index = text.indexOf("\n")
+          if (index === -1) {
+            if (!discard) {
+              pending += text
+              if (pending.length > MAX_LINE_LENGTH) {
+                pending = pending.slice(0, MAX_LINE_LENGTH + 1)
+                discard = true
+              }
+            }
+            break
+          }
+          const current = pending + (discard ? "" : text.slice(0, index))
+          pending = ""
+          discard = false
+          text = text.slice(index + 1)
+          if (!append(current.endsWith("\r") ? current.slice(0, -1) : current)) return false
+        }
+        return true
+      }
+      const consumeChunk = Effect.fnUntraced(function* (chunk: Uint8Array) {
+        let start = 0
+        while (start < chunk.length) {
+          if (lines.length >= limit || bytes >= MAX_READ_BYTES) {
+            next = line
+            return false
+          }
+          const newline = chunk.indexOf(10, start)
+          const end = newline === -1 ? chunk.length : newline + 1
+          const segment = chunk.subarray(start, end)
+          if (binary(resource, segment)) return yield* Effect.fail(new BinaryFileError({ resource }))
+          if (!consume(yield* decodeUtf8(resource, decoder, segment))) return false
+          start = end
+        }
+        return true
+      })
+      let done = !(yield* consumeChunk(first))
+      while (!done) {
+        const chunk = yield* file.readAlloc(64 * 1024)
+        if (Option.isNone(chunk)) break
+        done = !(yield* consumeChunk(chunk.value))
+      }
+      if (!done) {
+        const tail = yield* decodeUtf8(resource, decoder)
+        if (!discard) pending += tail
+        if (pending) append(pending.endsWith("\r") ? pending.slice(0, -1) : pending)
+      }
+      if (lines.length === 0 && offset !== 1) return yield* Effect.fail(new OffsetOutOfRangeError({ offset }))
+      return new TextPage({
+        type: "text-page",
+        content: lines.join("\n"),
+        mime: FSUtil.mimeType(real),
+        offset,
+        truncated: next !== undefined,
+        ...(next === undefined ? {} : { next }),
+      })
     }),
   )
-  if (first instanceof ListPage) return first
-
-  const media = Mime.detect(first.bytes)
-  if (MEDIA_MIMES.has(media)) {
-    if (first.info.size > MAX_MEDIA_INGEST_BYTES)
-      return yield* new MediaIngestLimitError({ resource, maximumBytes: MAX_MEDIA_INGEST_BYTES })
-    const whole = yield* readFile(files, input, resource)
-    return {
-      type: "file" as const,
-      uri: pathToFileURL(input).href,
-      name: path.basename(input),
-      content: Buffer.from(whole.bytes).toString("base64"),
-      encoding: "base64" as const,
-      mime: media,
-    }
-  }
-
-  const paged = first.info.size > MAX_READ_BYTES || page.offset !== undefined || page.limit !== undefined
-  if (!paged) {
-    if (first.bytes.includes(0)) return yield* new BinaryFileError({ resource })
-    return {
-      type: "file" as const,
-      uri: pathToFileURL(input).href,
-      name: path.basename(input),
-      content: new TextDecoder().decode(first.bytes),
-      encoding: "utf8" as const,
-      mime: mimeType(input),
-    }
-  }
-
-  const chunks = [first.bytes]
-  while (true) {
-    const bytes = Buffer.concat(chunks)
-    const eof = bytes.length >= first.info.size
-    const result = textPage(bytes, eof, page)
-    if (result !== undefined) return yield* makeTextPage(bytes, input, resource, result)
-    const next = yield* readFile(files, input, resource, { offset: bytes.length, length: FIRST_CHUNK })
-    if (next.bytes.length === 0) {
-      const result = textPage(bytes, true, page)
-      if (result === undefined) return yield* Effect.die("Read page did not settle at EOF")
-      return yield* makeTextPage(bytes, input, resource, result)
-    }
-    chunks.push(next.bytes)
-  }
 })
 
-const readFile = (
-  files: Files,
-  input: AbsolutePath,
-  resource: string,
-  range?: { readonly offset: number; readonly length: number },
-) =>
-  files
-    .read(input, range)
-    .pipe(
-      Effect.catchTag("Environment.WrongKind", () => Effect.fail(new PathKindError({ resource, expected: "a file" }))),
-    )
-
-const makeTextPage = Effect.fnUntraced(function* (
-  bytes: Uint8Array,
-  input: AbsolutePath,
-  resource: string,
-  result: NonNullable<ReturnType<typeof textPage>>,
-) {
-  if (bytes.subarray(0, result.consumed).includes(0)) return yield* new BinaryFileError({ resource })
-  if (result.entries.length === 0 && result.offset !== 1)
-    return yield* new OffsetOutOfRangeError({ offset: result.offset })
-  return new TextPage({
-    type: "text-page",
-    content: result.entries.join("\n"),
-    mime: mimeType(input),
-    offset: result.offset,
-    truncated: result.next !== undefined,
-    ...(result.next === undefined ? {} : { next: result.next }),
-  })
-})
-
-const list = (items: ReadonlyArray<Environment.DirEntry>, page: PageInput) => {
+export const list = Effect.fn("ReadTool.list")(function* (fs: FSUtil.Interface, input: string, page: PageInput = {}) {
+  const real = yield* fs.realPath(input)
+  const items = yield* fs.readDirectoryEntries(real)
   const offset = page.offset || 1
   const limit = Math.min(page.limit || MAX_READ_LINES, MAX_READ_LINES)
-  const visible = items
-    .flatMap((item) =>
-      item.type === "other"
-        ? []
-        : [
-            ListEntry.make({
-              path: RelativePath.make(item.name + (item.type === "directory" ? path.sep : "")),
-              type: item.type,
-            }),
-          ],
-    )
-    .sort((a, b) =>
-      a.type === "directory"
-        ? b.type === "directory"
-          ? a.path.localeCompare(b.path)
-          : -1
-        : b.type === "directory"
-          ? 1
-          : a.path.localeCompare(b.path),
-    )
+  const entries = yield* Effect.forEach(
+    items,
+    (item) =>
+      Effect.gen(function* () {
+        const absolute = path.join(real, item.name)
+        const target = yield* fs.realPath(absolute).pipe(Effect.catch(() => Effect.void))
+        if (!target || !FSUtil.contains(real, target)) return
+        const info = yield* fs.stat(target).pipe(Effect.catch(() => Effect.void))
+        const type = info?.type === "Directory" ? "directory" : info?.type === "File" ? "file" : undefined
+        if (!type) return
+        return FileSystem.Entry.make({
+          path: RelativePath.make(item.name + (type === "directory" ? path.sep : "")),
+          type,
+        })
+      }),
+    { concurrency: 16 },
+  )
+  const visible = entries
+    .filter((item): item is FileSystem.Entry => item !== undefined)
+    .sort((a, b) => (a.type === b.type ? a.path.localeCompare(b.path) : a.type === "directory" ? -1 : 1))
   const selected = visible.slice(offset - 1, offset - 1 + limit)
   const truncated = offset - 1 + selected.length < visible.length
   return new ListPage({
@@ -237,58 +364,18 @@ const list = (items: ReadonlyArray<Environment.DirEntry>, page: PageInput) => {
     truncated,
     ...(truncated ? { next: offset + selected.length } : {}),
   })
-}
-
-const textPage = (bytes: Uint8Array, eof: boolean, page: PageInput) => {
-  const offset = page.offset || 1
-  const limit = Math.min(page.limit || MAX_READ_LINES, MAX_READ_LINES)
-  const decoded = new TextDecoder().decode(bytes)
-  const split = decoded.split("\n")
-  const complete = eof ? (split.at(-1) === "" ? split.slice(0, -1) : split) : split.slice(0, -1)
-  const available = complete.map((line) => (line.endsWith("\r") ? line.slice(0, -1) : line))
-
-  const entries: string[] = []
-  let size = 0
-  let next: number | undefined
-  for (const [index, value] of available.slice(offset - 1).entries()) {
-    const line = offset + index
-    if (entries.length >= limit || size >= MAX_READ_BYTES) {
-      next = line
-      break
-    }
-    const text = value.length > MAX_LINE_LENGTH ? value.slice(0, MAX_LINE_LENGTH) + MAX_LINE_SUFFIX : value
-    const lineSize = Buffer.byteLength(text, "utf-8") + (entries.length > 0 ? 1 : 0)
-    if (size + lineSize > MAX_READ_BYTES) {
-      next = line
-      break
-    }
-    entries.push(text)
-    size += lineSize
-  }
-  if (next === undefined && entries.length >= limit && (!eof || offset - 1 + entries.length < available.length))
-    next = offset + entries.length
-  if (!eof && next === undefined) return
-
-  const consumedLines = next === undefined ? available.length : next - 1
-  const consumed = consumedLines === 0 ? 0 : (nthNewline(bytes, consumedLines) ?? bytes.length)
-  return { entries, offset, next, consumed }
-}
-
-const nthNewline = (bytes: Uint8Array, count: number) => {
-  let found = 0
-  for (const [index, byte] of bytes.entries()) {
-    if (byte !== 10) continue
-    found++
-    if (found === count) return index + 1
-  }
-}
+})
 
 const layer = Layer.effect(
   Service,
   Effect.gen(function* () {
-    const environment = yield* Environment.Service
-    return Service.of({ read: (path, resource, page) => read(environment.files, path, resource, page) })
+    const fs = yield* FSUtil.Service
+    return Service.of({
+      inspect: (path) => inspect(fs, path),
+      read: (path, resource, page) => read(fs, path, resource, page),
+      list: (path, page) => list(fs, path, page),
+    })
   }),
 )
 
-export const node = makeLocationNode({ service: Service, layer, deps: [Environment.node] })
+export const node = makeLocationNode({ service: Service, layer, deps: [FSUtil.node] })

packages/core/src/v1/config/migrate.ts

@@ -119,16 +119,8 @@ function agents(info: typeof ConfigV1.Info.Type) {
     ...Object.entries(info.agent ?? {}),
     ...Object.entries(info.mode ?? {}).map(([name, agent]) => [name, { ...agent, mode: "primary" as const }] as const),
   ]
-  const result = Object.fromEntries(entries.flatMap(([name, agent]) => (agent ? [[name, migrateAgent(agent)]] : [])))
-  const small = modelSelection(info.small_model)
-  if (!small) return entries.length ? result : undefined
-  return {
-    ...result,
-    title: {
-      model: small,
-      ...result.title,
-    },
-  }
+  if (!entries.length) return undefined
+  return Object.fromEntries(entries.flatMap(([name, agent]) => (agent ? [[name, migrateAgent(agent)]] : [])))
 }
 
 export function migrateAgent(info: ConfigAgentV1.Info) {
@@ -248,7 +240,7 @@ function migrateStandardProvider(info: ConfigProviderV1.Info) {
     body: info.options && options.body,
     models:
       info.models &&
-      Object.fromEntries(Object.entries(info.models).map(([name, model]) => [name, migrateModel(model, info.npm)])),
+      Object.fromEntries(Object.entries(info.models).map(([name, model]) => [name, migrateModel(model)])),
   }
 }
 
@@ -294,9 +286,8 @@ export function providerID(input: string) {
   return input
 }
 
-function migrateModel(info: typeof ConfigProviderV1.Model.Type, inheritedPackage?: string) {
-  const packageName = info.provider?.npm ?? inheritedPackage
-  const overlays = info.options && ConfigProviderOptionsV1.modelOverlays(info.options, packageName)
+function migrateModel(info: typeof ConfigProviderV1.Model.Type) {
+  const settings = info.options && ConfigProviderOptionsV1.model(info.options)
   const costs = info.cost && [
     {
       input: info.cost.input,
@@ -324,15 +315,14 @@ function migrateModel(info: typeof ConfigProviderV1.Model.Type, inheritedPackage
     name: info.name,
     compatibility: Model.compatibility(info.interleaved),
     package: info.provider?.npm ? Provider.aisdk(info.provider.npm) : undefined,
-    settings: info.provider?.api ? { ...overlays?.settings, baseURL: info.provider.api } : overlays?.settings,
-    body: overlays?.body,
+    settings: info.provider?.api ? { ...settings, baseURL: info.provider.api } : settings,
     capabilities,
     headers: info.headers,
     variants:
       info.variants &&
       Object.entries(info.variants).map(([id, options]) => ({
         id,
-        ...ConfigProviderOptionsV1.modelOverlays(options, packageName),
+        settings: ConfigProviderOptionsV1.model(options),
       })),
     cost: costs,
     disabled: info.status === "deprecated" ? true : undefined,

packages/core/src/v1/config/provider-options.ts

@@ -29,18 +29,3 @@ export function provider(options: Options): ProviderResult {
 export function model(options: Options) {
   return { ...options }
 }
-
-export function modelOverlays(options: Options, packageName: string | undefined) {
-  if (packageName !== "@ai-sdk/openai-compatible") return { settings: model(options) }
-  const known = new Set(["reasoningEffort", "strictJsonSchema"])
-  const settings = Object.fromEntries(Object.entries(options).filter(([key]) => known.has(key)))
-  const body = Object.fromEntries(
-    Object.entries(options)
-      .filter(([key]) => !known.has(key))
-      .map(([key, value]) => [key === "textVerbosity" ? "verbosity" : key, value]),
-  )
-  return {
-    settings: Object.keys(settings).length === 0 ? undefined : settings,
-    body: Object.keys(body).length === 0 ? undefined : body,
-  }
-}

packages/core/test/agent.test.ts

@@ -126,7 +126,6 @@ describe("Agent", () => {
 
       yield* agent.transform((editor) => editor.update(id, () => {}))
       const info = yield* agent.get(id)
-      expect(info?.mode).toBe("primary")
       expect(info?.permissions.slice(0, Agent.Info.default(id).permissions.length)).toEqual(
         Agent.Info.default(id).permissions,
       )

packages/core/test/aisdk-native.test.ts

@@ -5,49 +5,6 @@ const map = (packageName: string, settings: Readonly<Record<string, unknown>>, m
   AISDKNative.map({ packageName, settings, modelID })
 
 describe("AISDKNative", () => {
-  test("maps the generic OpenAI-compatible package to the native provider package", () => {
-    expect(
-      map("@ai-sdk/openai-compatible", {
-        apiKey: "secret",
-        baseURL: "https://compatible.example/v1",
-        name: "example",
-        headers: { "x-test": "value" },
-        queryParams: { tenant: "one" },
-        reasoningEffort: "high",
-      }),
-    ).toEqual({
-      package: "@opencode-ai/ai/providers/openai-compatible",
-      settings: {
-        apiKey: "secret",
-        baseURL: "https://compatible.example/v1",
-        provider: "example",
-        http: { query: { tenant: "one" } },
-        providerOptions: {
-          openai: {
-            reasoningEffort: "high",
-          },
-        },
-      },
-      headers: { "x-test": "value" },
-    })
-    expect(map("@ai-sdk/openai-compatible", {})).toBeUndefined()
-    expect(
-      map("@ai-sdk/openai-compatible", { baseURL: "https://compatible.example/v1", timeout: 30_000 }),
-    ).toBeUndefined()
-    expect(
-      map("@ai-sdk/openai-compatible", {
-        baseURL: "https://compatible.example/v1",
-        supportsStructuredOutputs: true,
-      }),
-    ).toBeUndefined()
-    expect(
-      map("@ai-sdk/openai-compatible", {
-        baseURL: "https://compatible.example/v1",
-        strictJsonSchema: false,
-      }),
-    ).toBeUndefined()
-  })
-
   test("maps both models.dev Bedrock packages to native providers", () => {
     expect(map("@ai-sdk/amazon-bedrock", { region: "us-east-1" })).toEqual({
       package: "@opencode-ai/ai/providers/amazon-bedrock",

packages/core/test/config/agent.test.ts

@@ -51,11 +51,6 @@ describe("ConfigAgentPlugin.Plugin", () => {
   it.effect("matches Windows paths against home-relative permissions", () =>
     Effect.gen(function* () {
       const permissions = yield* loadHomePermissions("C:\\Users\\test")
-      expect(permissions).toContainEqual({
-        action: "external_directory",
-        resource: "C:\\Users\\test\\p\\**",
-        effect: "allow",
-      })
       expect(
         Permission.evaluate("external_directory", "C:\\Users\\test\\p\\opencode\\src\\*", permissions).effect,
       ).toBe("allow")

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

@@ -512,20 +512,6 @@ describe("Config", () => {
     }),
   )
 
-  it.effect("migrates the v1 small model to the title agent", () =>
-    Effect.sync(() => {
-      expect(
-        ConfigMigrateV1.migrate({
-          small_model: "anthropic/claude-haiku-4-5",
-          agent: { title: { prompt: "Custom title prompt" } },
-        }).agents?.title,
-      ).toEqual({
-        model: { providerID: "anthropic", model: "claude-haiku-4-5" },
-        system: "Custom title prompt",
-      })
-    }),
-  )
-
   it.effect("migrates v1 provider lists to policies", () =>
     Effect.sync(() => {
       expect(
@@ -570,72 +556,6 @@ describe("Config", () => {
     }),
   )
 
-  it.effect("preserves serializable OpenAI-compatible options across v1 migration", () =>
-    Effect.sync(() => {
-      const migrated = ConfigMigrateV1.migrate({
-        provider: {
-          acme: {
-            npm: "@ai-sdk/openai-compatible",
-            api: "https://api.example/v1",
-            options: {
-              apiKey: "secret",
-              name: "acme",
-              headers: { "x-provider": "yes" },
-              body: { provider_body_extension: true },
-              queryParams: { tenant: "one" },
-              includeUsage: false,
-              supportsStructuredOutputs: true,
-            },
-            models: {
-              chat: {
-                options: {
-                  user: "user-1",
-                  reasoningEffort: "high",
-                  textVerbosity: "low",
-                  strictJsonSchema: false,
-                  vendor_extension: { enabled: true },
-                },
-                variants: {
-                  strict: { strictJsonSchema: true, variant_extension: "value" },
-                },
-              },
-            },
-          },
-        },
-      })
-
-      expect(migrated.providers?.acme).toMatchObject({
-        package: Provider.aisdk("@ai-sdk/openai-compatible"),
-        settings: {
-          apiKey: "secret",
-          name: "acme",
-          queryParams: { tenant: "one" },
-          includeUsage: false,
-          supportsStructuredOutputs: true,
-          baseURL: "https://api.example/v1",
-        },
-        headers: { "x-provider": "yes" },
-        body: { provider_body_extension: true },
-        models: {
-          chat: {
-            settings: {
-              reasoningEffort: "high",
-              strictJsonSchema: false,
-            },
-            body: { user: "user-1", verbosity: "low", vendor_extension: { enabled: true } },
-            variants: [
-              {
-                id: "strict",
-                settings: { strictJsonSchema: true },
-                body: { variant_extension: "value" },
-              },
-            ],
-          },
-        },
-      })
-    }),
-  )
-
   it.effect("renames old provider IDs while migrating v1 configuration", () =>
     Effect.sync(() => {
       const migrated = ConfigMigrateV1.migrate({

packages/core/test/config/normalization.test.ts

@@ -149,28 +149,6 @@ describe("ConfigNormalize", () => {
     expect(() => Schema.decodeUnknownSync(Info)(result.encoded)).not.toThrow()
   })
 
-  test("migrates the legacy small model to the title agent", () => {
-    const result = normalized({
-      small_model: "anthropic/claude-haiku-4-5",
-      agent: { title: { prompt: "Custom title prompt" } },
-    })
-    expect(result.encoded.agents).toEqual({
-      title: {
-        model: { providerID: "anthropic", model: "claude-haiku-4-5" },
-        system: "Custom title prompt",
-      },
-    })
-    expect(result.diagnostics).toEqual([])
-  })
-
-  test("omits an invalid legacy small model without exposing its value", () => {
-    const secret = "do-not-log-this-value"
-    const result = normalized({ small_model: secret })
-    expect(result.encoded.agents).toBeUndefined()
-    expect(result.diagnostics.map((item) => [item.kind, item.path])).toEqual([["unsupported", ["small_model"]]])
-    expect(JSON.stringify(result.diagnostics)).not.toContain(secret)
-  })
-
   test("recovers malformed named entries and retains a valid legacy collision", () => {
     const result = normalized({
       command: { fallback: { template: "legacy" } },
@@ -412,6 +390,7 @@ describe("ConfigNormalize", () => {
     const secret = "do-not-log-this-value"
     const result = normalized({
       logLevel: "DEBUG",
+      small_model: secret,
       agent: { reviewer: { name: secret, prompt: "review" } },
       provider: {
         custom: {
@@ -430,6 +409,7 @@ describe("ConfigNormalize", () => {
     })
     expect(result.diagnostics.filter((item) => item.kind === "unsupported").map((item) => item.path)).toEqual([
       ["logLevel"],
+      ["small_model"],
       ["agent", "reviewer", "name"],
       ["provider", "custom", "id"],
       ["provider", "custom", "whitelist"],

packages/core/test/config/provider-options.test.ts

@@ -38,28 +38,6 @@ describe("ConfigProviderOptionsV1", () => {
     })
   })
 
-  test("splits OpenAI-compatible model options into native settings and body extensions", () => {
-    expect(
-      ConfigProviderOptionsV1.modelOverlays(
-        {
-          user: "user-1",
-          reasoningEffort: "high",
-          textVerbosity: "low",
-          strictJsonSchema: false,
-          vendor_extension: { enabled: true },
-          store: false,
-        },
-        "@ai-sdk/openai-compatible",
-      ),
-    ).toEqual({
-      settings: {
-        reasoningEffort: "high",
-        strictJsonSchema: false,
-      },
-      body: { user: "user-1", verbosity: "low", vendor_extension: { enabled: true }, store: false },
-    })
-  })
-
   test("uses mechanical lowering for custom provider options", () => {
     expect(ConfigProviderOptionsV1.provider({ enabled: true })).toEqual({
       settings: { enabled: true },

packages/core/test/config/provider.test.ts

@@ -50,33 +50,6 @@ function withEnv<A, E, R>(vars: Record<string, string | undefined>, effect: () =
 const decode = Schema.decodeUnknownSync(Info)
 
 describe("ConfigProviderPlugin.Plugin", () => {
-  it.effect("adds key auth for custom providers without env credentials", () =>
-    Effect.gen(function* () {
-      const integrations = yield* Integration.Service
-      const entries = [
-        new Document({
-          type: "document",
-          info: decode({
-            providers: {
-              litellm: {
-                package: "aisdk:@ai-sdk/openai-compatible",
-                models: { chat: {} },
-              },
-            },
-          }),
-        }),
-      ]
-
-      yield* addPlugin(entries)
-
-      expect(yield* integrations.get(Integration.ID.make("litellm"))).toMatchObject({
-        id: "litellm",
-        name: "litellm",
-        methods: [{ type: "key", label: "Manually enter API Key" }],
-      })
-    }),
-  )
-
   it.effect("defaults custom models to agent capabilities", () =>
     Effect.gen(function* () {
       const catalog = yield* Catalog.Service

packages/core/test/environment.test.ts

@@ -1,88 +0,0 @@
-import fs from "node:fs/promises"
-import { describe, expect } from "bun:test"
-import { Effect } from "effect"
-import { ChildProcessSpawner } from "effect/unstable/process"
-import { CrossSpawnSpawner } from "@opencode-ai/util/cross-spawn-spawner"
-import { LayerNode } from "@opencode-ai/util/effect/layer-node"
-import {
-  execDefaults,
-  Failed,
-  makeFiles,
-  makeLocalDriver,
-  makeMemoryDriver,
-  NotFound,
-  typeFollowing,
-} from "../src/environment/index"
-import { tmpdir } from "./fixture/tmpdir"
-import { environmentConformance } from "./lib/environment-conformance"
-import { it } from "./lib/effect"
-
-describe("typeFollowing", () => {
-  it.effect("follows symlinks without changing stat semantics", () =>
-    Effect.gen(function* () {
-      const driver = makeMemoryDriver()
-      const files = makeFiles(driver)
-      yield* files.mkdir("/directory")
-      yield* files.write("/file", new Uint8Array())
-      yield* driver.symlink("/directory", "/directory-link")
-      yield* driver.symlink("/file", "/file-link")
-      yield* driver.symlink("/missing", "/dangling-link")
-
-      expect(yield* typeFollowing(files, "/directory-link")).toBe("directory")
-      expect(yield* typeFollowing(files, "/file-link")).toBe("file")
-      expect(yield* typeFollowing(files, "/dangling-link").pipe(Effect.flip)).toBeInstanceOf(NotFound)
-    }),
-  )
-})
-
-environmentConformance("memory environment", () =>
-  Effect.sync(() => {
-    const driver = makeMemoryDriver()
-    return {
-      files: makeFiles(driver),
-      root: `/workspace-${crypto.randomUUID()}`,
-      symlink: driver.symlink,
-    }
-  }),
-)
-
-environmentConformance("local environment", () =>
-  Effect.gen(function* () {
-    const spawner = yield* ChildProcessSpawner.ChildProcessSpawner
-    const tmp = yield* Effect.promise(() => tmpdir("opencode-local-environment-"))
-    return {
-      files: makeFiles(makeLocalDriver(spawner)),
-      root: tmp.path,
-      ...(process.platform === "win32"
-        ? {}
-        : {
-            symlink: (target: string, link: string) =>
-              Effect.tryPromise({
-                try: () => fs.symlink(target, link),
-                catch: (cause) => new Failed({ path: link, cause }),
-              }),
-          }),
-      dispose: Effect.promise(() => tmp[Symbol.asyncDispose]()),
-    }
-  }).pipe(Effect.provide(LayerNode.compile(CrossSpawnSpawner.node))),
-)
-
-environmentConformance(
-  "GNU exec environment",
-  () =>
-    Effect.gen(function* () {
-      const spawner = yield* ChildProcessSpawner.ChildProcessSpawner
-      const tmp = yield* Effect.promise(() => tmpdir("opencode-environment-"))
-      return {
-        files: execDefaults(spawner),
-        root: tmp.path,
-        symlink: (target: string, link: string) =>
-          Effect.tryPromise({
-            try: () => fs.symlink(target, link),
-            catch: (cause) => new Failed({ path: link, cause }),
-          }),
-        dispose: Effect.promise(() => tmp[Symbol.asyncDispose]()),
-      }
-    }).pipe(Effect.provide(LayerNode.compile(CrossSpawnSpawner.node))),
-  process.platform !== "linux",
-)

packages/core/test/file-mutation.test.ts

@@ -5,7 +5,7 @@ import { Deferred, Effect, Fiber, Layer } from "effect"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { LayerNode } from "@opencode-ai/util/effect/layer-node"
 import { FileMutation } from "@opencode-ai/core/file-mutation"
-import { Environment } from "@opencode-ai/core/environment"
+import { FSUtil } from "@opencode-ai/util/fs-util"
 import { Location } from "@opencode-ai/core/location"
 import { LocationMutation } from "@opencode-ai/core/location-mutation"
 import { AbsolutePath } from "@opencode-ai/core/schema"
@@ -13,7 +13,7 @@ import { location } from "./fixture/location"
 import { tmpdir } from "./fixture/tmpdir"
 import { it } from "./lib/effect"
 
-function provide(directory: string, environmentLayer = LayerNode.compile(Environment.node)) {
+function provide(directory: string, filesystemLayer = LayerNode.compile(FSUtil.node)) {
   const activeLocation = Layer.succeed(
     Location.Service,
     Location.Service.of(location({ directory: AbsolutePath.make(directory) })),
@@ -21,7 +21,7 @@ function provide(directory: string, environmentLayer = LayerNode.compile(Environ
   return Effect.provide(
     AppNodeBuilder.build(LayerNode.group([LocationMutation.node, FileMutation.node]), [
       [Location.node, activeLocation],
-      [Environment.node, environmentLayer],
+      [FSUtil.node, filesystemLayer],
     ]),
   )
 }
@@ -43,7 +43,7 @@ describe("FileMutation", () => {
 
         expect(yield* (yield* FileMutation.Service).write({ target, content: "after" })).toEqual({
           operation: "write",
-          target: target.absolute,
+          target: target.canonical,
           resource: "hello.txt",
           existed: true,
         })
@@ -62,11 +62,11 @@ describe("FileMutation", () => {
 
         expect(result).toEqual({
           operation: "write",
-          target: target.absolute,
+          target: target.canonical,
           resource: "src/nested/hello.txt",
           existed: false,
         })
-        expect(yield* Effect.promise(() => fs.readFile(target.absolute, "utf8"))).toBe("hello")
+        expect(yield* Effect.promise(() => fs.readFile(result.target, "utf8"))).toBe("hello")
       }).pipe(provide(directory)),
     ),
   )
@@ -84,7 +84,7 @@ describe("FileMutation", () => {
         yield* files.writeTextPreservingBom({ target: created, content: "\uFEFF\uFEFF\uFEFFcreated" })
 
         expect(yield* Effect.promise(() => fs.readFile(preservedPath, "utf8"))).toBe("\uFEFFafter")
-        expect(yield* Effect.promise(() => fs.readFile(created.absolute, "utf8"))).toBe("\uFEFFcreated")
+        expect(yield* Effect.promise(() => fs.readFile(created.canonical, "utf8"))).toBe("\uFEFFcreated")
       }).pipe(provide(directory)),
     ),
   )
@@ -99,7 +99,7 @@ describe("FileMutation", () => {
 
           expect(result).toEqual({
             operation: "write",
-            target: target.absolute,
+            target: target.canonical,
             resource: target.resource,
             existed: false,
           })
@@ -109,7 +109,7 @@ describe("FileMutation", () => {
     ),
   )
 
-  it.live("serializes concurrent writes to the same absolute target", () =>
+  it.live("serializes concurrent writes to the same canonical target", () =>
     withTmp((directory) =>
       Effect.gen(function* () {
         const targetPath = path.join(directory, "shared.txt")
@@ -152,58 +152,7 @@ describe("FileMutation", () => {
     ),
   )
 
-  it.live("shares transaction locks across Location service instances", () =>
-    withTmp((directory) =>
-      Effect.gen(function* () {
-        const firstStarted = yield* Deferred.make<void>()
-        const releaseFirst = yield* Deferred.make<void>()
-        const secondStarted = yield* Deferred.make<void>()
-        const target = path.join(directory, "shared.txt")
-        const first = yield* Effect.gen(function* () {
-          const files = yield* FileMutation.Service
-          yield* files.withLock([target])(
-            Deferred.succeed(firstStarted, undefined).pipe(Effect.andThen(Deferred.await(releaseFirst))),
-          )
-        }).pipe(provide(directory), Effect.forkChild)
-        yield* Deferred.await(firstStarted)
-        const second = yield* Effect.gen(function* () {
-          const files = yield* FileMutation.Service
-          yield* files.withLock([target])(Deferred.succeed(secondStarted, undefined))
-        }).pipe(provide(directory), Effect.forkChild)
-        yield* Effect.yieldNow
-        expect(yield* Deferred.isDone(secondStarted)).toBe(false)
-
-        yield* Deferred.succeed(releaseFirst, undefined)
-        yield* Deferred.await(secondStarted)
-        yield* Fiber.join(first)
-        yield* Fiber.join(second)
-      }),
-    ),
-  )
-
-  it.live("allows transaction locks for distinct resolved paths to proceed independently", () =>
-    withTmp((directory) =>
-      Effect.gen(function* () {
-        const firstStarted = yield* Deferred.make<void>()
-        const releaseFirst = yield* Deferred.make<void>()
-        const secondFinished = yield* Deferred.make<void>()
-        const files = yield* FileMutation.Service
-        const first = yield* files
-          .withLock([path.join(directory, "first.txt")])(
-            Deferred.succeed(firstStarted, undefined).pipe(Effect.andThen(Deferred.await(releaseFirst))),
-          )
-          .pipe(Effect.forkChild)
-        yield* Deferred.await(firstStarted)
-        yield* files.withLock([path.join(directory, "second.txt")])(Deferred.succeed(secondFinished, undefined))
-        expect(yield* Deferred.isDone(secondFinished)).toBe(true)
-
-        yield* Deferred.succeed(releaseFirst, undefined)
-        yield* Fiber.join(first)
-      }).pipe(provide(directory)),
-    ),
-  )
-
-  it.live("allows distinct absolute targets to proceed independently", () =>
+  it.live("allows distinct canonical targets to proceed independently", () =>
     withTmp((directory) =>
       Effect.gen(function* () {
         const firstStarted = yield* Deferred.make<void>()
@@ -242,16 +191,16 @@ describe("FileMutation", () => {
 
 function instrumentWrites(run: <E>(write: Effect.Effect<void, E>, target: string) => Effect.Effect<void, E>) {
   return Layer.effect(
-    Environment.Service,
+    FSUtil.Service,
     Effect.gen(function* () {
-      const environment = yield* Environment.Service
-      return Environment.Service.of({
-        ...environment,
-        files: {
-          ...environment.files,
-          write: (target, content) => run(environment.files.write(target, content), target),
-        },
+      const filesystem = yield* FSUtil.Service
+      return FSUtil.Service.of({
+        ...filesystem,
+        writeWithDirs: (target, content, mode) => run(filesystem.writeWithDirs(target, content, mode), target),
+        writeFile: (target, content, options) => run(filesystem.writeFile(target, content, options), target),
+        writeFileString: (target, content, options) =>
+          run(filesystem.writeFileString(target, content, options), target),
       })
     }),
-  ).pipe(Layer.provide(LayerNode.compile(Environment.node)))
+  ).pipe(Layer.provide(LayerNode.compile(FSUtil.node)))
 }

packages/core/test/lib/environment-conformance.ts

@@ -1,169 +0,0 @@
-import { describe, expect } from "bun:test"
-import { Effect } from "effect"
-import { Failed, NotFound, WrongKind, type Files } from "../../src/environment/index"
-import { it } from "./effect"
-
-export interface EnvironmentHarness {
-  readonly files: Files
-  readonly root: string
-  readonly symlink?: (target: string, path: string) => Effect.Effect<void, Failed>
-  readonly dispose?: Effect.Effect<void>
-}
-
-export const environmentConformance = <E>(
-  name: string,
-  makeHarness: () => Effect.Effect<EnvironmentHarness, E>,
-  skip = false,
-) => {
-  const check = <A, E2>(title: string, body: (harness: EnvironmentHarness) => Effect.Effect<A, E2>) =>
-    it.live(title, () =>
-      Effect.gen(function* () {
-        const harness = yield* Effect.acquireRelease(makeHarness(), (harness) =>
-          Effect.gen(function* () {
-            yield* Effect.ignore(harness.files.remove(harness.root))
-            if (harness.dispose) yield* harness.dispose
-          }),
-        )
-        yield* harness.files.mkdir(harness.root)
-        return yield* body(harness)
-      }),
-    )
-
-  const bytes = (value: string) => new TextEncoder().encode(value)
-  const text = (value: Uint8Array) => new TextDecoder().decode(value)
-  const suite = skip ? describe.skip : describe
-
-  suite(name, () => {
-    check("writes, stats, and reads a file with its info", (harness) =>
-      Effect.gen(function* () {
-        const target = `${harness.root}/hello.txt`
-        yield* harness.files.write(target, bytes("hello"))
-        const result = yield* harness.files.read(target)
-        expect(text(result.bytes)).toBe("hello")
-        expect(result.info.type).toBe("file")
-        expect(result.info.size).toBe(5)
-        expect(yield* harness.files.stat(target)).toEqual(result.info)
-      }),
-    )
-
-    check("reports missing paths", (harness) =>
-      Effect.gen(function* () {
-        const target = `${harness.root}/missing`
-        expect(yield* Effect.flip(harness.files.read(target))).toBeInstanceOf(NotFound)
-        expect(yield* Effect.flip(harness.files.stat(target))).toBeInstanceOf(NotFound)
-        expect(yield* Effect.flip(harness.files.list(target))).toBeInstanceOf(NotFound)
-        expect(yield* Effect.flip(harness.files.move(target, `${harness.root}/other`))).toBeInstanceOf(NotFound)
-      }),
-    )
-
-    check("reports the actual kind", (harness) =>
-      Effect.gen(function* () {
-        const directory = `${harness.root}/directory`
-        const file = `${harness.root}/file`
-        yield* harness.files.mkdir(directory)
-        yield* harness.files.write(file, bytes("data"))
-        const readError = yield* Effect.flip(harness.files.read(directory))
-        const listError = yield* Effect.flip(harness.files.list(file))
-        expect(readError).toBeInstanceOf(WrongKind)
-        expect((readError as WrongKind).actual).toBe("directory")
-        expect(listError).toBeInstanceOf(WrongKind)
-        expect((listError as WrongKind).actual).toBe("file")
-      }),
-    )
-
-    check("write creates parent directories", (harness) =>
-      Effect.gen(function* () {
-        const target = `${harness.root}/one/two/file`
-        yield* harness.files.write(target, bytes("nested"))
-        yield* harness.files.write(`${harness.root}/empty`, new Uint8Array())
-        expect((yield* harness.files.stat(`${harness.root}/one/two`)).type).toBe("directory")
-        expect(yield* harness.files.stat(`${harness.root}/empty`)).toMatchObject({ type: "file", size: 0 })
-        expect(text((yield* harness.files.read(target)).bytes)).toBe("nested")
-      }),
-    )
-
-    check("reads byte ranges", (harness) =>
-      Effect.gen(function* () {
-        const target = `${harness.root}/range`
-        yield* harness.files.write(target, bytes("0123456789"))
-        expect(text((yield* harness.files.read(target, { offset: 2, length: 4 })).bytes)).toBe("2345")
-        expect(text((yield* harness.files.read(target, { offset: 8, length: 8 })).bytes)).toBe("89")
-        expect(text((yield* harness.files.read(target, { offset: 20, length: 4 })).bytes)).toBe("")
-      }),
-    )
-
-    check("lists immediate entries with their kinds", (harness) =>
-      Effect.gen(function* () {
-        yield* harness.files.write(`${harness.root}/file name`, bytes("data"))
-        yield* harness.files.mkdir(`${harness.root}/directory`)
-        yield* harness.files.write(`${harness.root}/directory/nested`, bytes("nested"))
-        const entries = yield* harness.files.list(harness.root)
-        expect(entries.toSorted((a, b) => a.name.localeCompare(b.name))).toEqual([
-          { name: "directory", type: "directory" },
-          { name: "file name", type: "file" },
-        ])
-      }),
-    )
-
-    check("preserves symlink metadata while following symlinks for content", (harness) =>
-      Effect.gen(function* () {
-        if (!harness.symlink) return
-        yield* harness.files.write(`${harness.root}/target`, bytes("target"))
-        yield* harness.files.write(`${harness.root}/target-dir/file`, bytes("through link"))
-        yield* harness.symlink("../target", `${harness.root}/target-dir/entry-link`)
-        yield* harness.symlink("target", `${harness.root}/link`)
-        yield* harness.symlink("target-dir", `${harness.root}/link-dir`)
-        yield* harness.symlink("missing", `${harness.root}/dangling-link`)
-        expect((yield* harness.files.stat(`${harness.root}/link`)).type).toBe("symlink")
-        expect(yield* harness.files.list(harness.root)).toContainEqual({ name: "link", type: "symlink" })
-        expect(text((yield* harness.files.read(`${harness.root}/link-dir/file`)).bytes)).toBe("through link")
-        expect(
-          (yield* harness.files.list(`${harness.root}/link-dir`)).toSorted((a, b) => a.name.localeCompare(b.name)),
-        ).toEqual([
-          { name: "entry-link", type: "symlink" },
-          { name: "file", type: "file" },
-        ])
-
-        const fileError = yield* Effect.flip(harness.files.list(`${harness.root}/link`))
-        expect(fileError).toBeInstanceOf(WrongKind)
-        expect((fileError as WrongKind).actual).toBe("file")
-        expect(yield* Effect.flip(harness.files.list(`${harness.root}/dangling-link`))).toBeInstanceOf(NotFound)
-      }),
-    )
-
-    check("follows symlinks when reading", (harness) =>
-      Effect.gen(function* () {
-        if (!harness.symlink) return
-        yield* harness.files.write(`${harness.root}/target`, bytes("target content"))
-        yield* harness.files.mkdir(`${harness.root}/directory`)
-        yield* harness.symlink("target", `${harness.root}/file-link`)
-        yield* harness.symlink("directory", `${harness.root}/directory-link`)
-        yield* harness.symlink("missing", `${harness.root}/dangling-link`)
-
-        const result = yield* harness.files.read(`${harness.root}/file-link`)
-        expect(text(result.bytes)).toBe("target content")
-        expect(result.info.type).toBe("file")
-        expect(result.info.size).toBe(bytes("target content").length)
-
-        const directoryError = yield* Effect.flip(harness.files.read(`${harness.root}/directory-link`))
-        expect(directoryError).toBeInstanceOf(WrongKind)
-        expect((directoryError as WrongKind).actual).toBe("directory")
-        expect(yield* Effect.flip(harness.files.read(`${harness.root}/dangling-link`))).toBeInstanceOf(NotFound)
-      }),
-    )
-
-    check("moves files and removes trees idempotently", (harness) =>
-      Effect.gen(function* () {
-        const source = `${harness.root}/source/file`
-        const destination = `${harness.root}/destination`
-        yield* harness.files.write(source, bytes("moved"))
-        yield* harness.files.move(source, destination)
-        expect(text((yield* harness.files.read(destination)).bytes)).toBe("moved")
-        expect(yield* Effect.flip(harness.files.stat(source))).toBeInstanceOf(NotFound)
-        yield* harness.files.remove(`${harness.root}/source`)
-        yield* harness.files.remove(`${harness.root}/source`)
-        expect(yield* Effect.flip(harness.files.stat(`${harness.root}/source`))).toBeInstanceOf(NotFound)
-      }),
-    )
-  })
-}

packages/core/test/location-mutation.test.ts

@@ -37,7 +37,7 @@ describe("LocationMutation", () => {
         const target = yield* (yield* LocationMutation.Service).resolve({ path: "hello.txt" })
 
         expect(target).toMatchObject({
-          absolute: targetPath,
+          canonical: yield* Effect.promise(() => fs.realpath(targetPath)),
           resource: "hello.txt",
         })
         expect(target.externalDirectory).toBeUndefined()
@@ -50,8 +50,10 @@ describe("LocationMutation", () => {
       Effect.gen(function* () {
         yield* Effect.promise(() => fs.mkdir(path.join(directory, "src")))
         const target = yield* (yield* LocationMutation.Service).resolve({ path: path.join("src", "new.txt") })
+        const root = yield* Effect.promise(() => fs.realpath(directory))
+
         expect(target).toMatchObject({
-          absolute: path.join(directory, "src", "new.txt"),
+          canonical: path.join(root, "src", "new.txt"),
           resource: "src/new.txt",
         })
       }).pipe(provide(directory)),
@@ -62,9 +64,9 @@ describe("LocationMutation", () => {
     withTmp((directory) =>
       Effect.gen(function* () {
         const target = yield* (yield* LocationMutation.Service).resolve({ path: "../outside.txt" })
-        const root = path.dirname(directory)
+        const root = yield* Effect.promise(() => fs.realpath(path.dirname(directory)))
         expect(target).toMatchObject({
-          absolute: path.join(root, "outside.txt"),
+          canonical: path.join(root, "outside.txt"),
           resource: path.join(root, "outside.txt").replaceAll("\\", "/"),
         })
         expect(target.externalDirectory).toMatchObject({
@@ -75,7 +77,7 @@ describe("LocationMutation", () => {
     ),
   )
 
-  it.live("resolves a prospective target below an external symlink lexically", () =>
+  it.live("authorizes a prospective target below an external symlink by its in-location path", () =>
     withTmp((directory) => {
       const outside = `${directory}-outside`
       return Effect.gen(function* () {
@@ -86,7 +88,7 @@ describe("LocationMutation", () => {
         })
         const target = yield* (yield* LocationMutation.Service).resolve({ path: path.join("escape", "new.txt") })
         expect(target).toMatchObject({
-          absolute: path.join(directory, "escape", "new.txt"),
+          canonical: path.join(yield* Effect.promise(() => fs.realpath(outside)), "new.txt"),
           resource: "escape/new.txt",
         })
         expect(target.externalDirectory).toBeUndefined()
@@ -105,7 +107,7 @@ describe("LocationMutation", () => {
         })
 
         expect(yield* (yield* LocationMutation.Service).resolve({ path: "linked/new.txt" })).toMatchObject({
-          absolute: path.join(directory, "linked", "new.txt"),
+          canonical: path.join(yield* Effect.promise(() => fs.realpath(directory)), "actual", "new.txt"),
           resource: "linked/new.txt",
         })
       }).pipe(provide(directory)),
@@ -118,7 +120,7 @@ describe("LocationMutation", () => {
         const targetPath = path.join(directory, "new.txt")
         const target = yield* (yield* LocationMutation.Service).resolve({ path: targetPath })
         expect(target).toMatchObject({
-          absolute: targetPath,
+          canonical: path.join(yield* Effect.promise(() => fs.realpath(directory)), "new.txt"),
           resource: "new.txt",
         })
         expect(target.externalDirectory).toBeUndefined()
@@ -132,9 +134,9 @@ describe("LocationMutation", () => {
         Effect.gen(function* () {
           const targetPath = path.join(outside, "new.txt")
           const target = yield* (yield* LocationMutation.Service).resolve({ path: targetPath })
-          const root = outside
+          const root = yield* Effect.promise(() => fs.realpath(outside))
           expect(target).toMatchObject({
-            absolute: path.join(root, "new.txt"),
+            canonical: path.join(root, "new.txt"),
             resource: path.join(root, "new.txt").replaceAll("\\", "/"),
           })
           expect(target.externalDirectory).toMatchObject({
@@ -153,23 +155,24 @@ describe("LocationMutation", () => {
           const targetPath = path.join(outside, "existing.txt")
           yield* Effect.promise(() => fs.writeFile(targetPath, "existing"))
           const target = yield* (yield* LocationMutation.Service).resolve({ path: targetPath })
-          expect(target).toMatchObject({ absolute: targetPath })
-          expect(target.externalDirectory?.directory).toBe(outside)
+          const root = yield* Effect.promise(() => fs.realpath(outside))
+          expect(target).toMatchObject({ canonical: path.join(root, "existing.txt") })
+          expect(target.externalDirectory?.directory).toBe(root)
         }).pipe(provide(directory)),
       ),
     ),
   )
 
-  it.live("authorizes prospective external descendants at their lexical parent", () =>
+  it.live("anchors prospective external descendants at their stable existing directory", () =>
     withTmp((directory) =>
       withTmp((outside) =>
         Effect.gen(function* () {
           const targetPath = path.join(outside, "new", "nested", "file.txt")
           const target = yield* (yield* LocationMutation.Service).resolve({ path: targetPath })
-          const parent = path.dirname(targetPath)
+          const root = yield* Effect.promise(() => fs.realpath(outside))
           expect(target.externalDirectory).toMatchObject({
-            directory: parent,
-            resource: path.join(parent, "*").replaceAll("\\", "/"),
+            directory: root,
+            resource: path.join(root, "*").replaceAll("\\", "/"),
           })
         }).pipe(provide(directory)),
       ),

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

@@ -13,7 +13,6 @@ import { Session } from "@opencode-ai/core/session"
 import { SessionExecution } from "@opencode-ai/core/session/execution"
 import { SessionRestart } from "@opencode-ai/core/session/execution/restart"
 import { UserInterruptedError } from "@opencode-ai/core/session/error"
-import { SessionEvent } from "@opencode-ai/core/session/event"
 import { SessionRunner } from "@opencode-ai/core/session/runner"
 import { SessionTable } from "@opencode-ai/core/session/sql"
 import { SessionStore } from "@opencode-ai/core/session/store"
@@ -128,34 +127,23 @@ describe("SessionExecution lifecycle", () => {
   it.effect("resumes each suspended Session at most once", () =>
     Effect.gen(function* () {
       const database = yield* Database.Service
-      const bus = yield* Bus.Service
       const first = Session.ID.make("ses_resume_first")
       const second = Session.ID.make("ses_resume_second")
       yield* seedSessions(database, [first, second], { time_suspended: Date.now() })
 
       const drained: string[] = []
-      const continued: SessionEvent.Synthetic[] = []
       const scope = yield* Scope.make()
       const context = yield* buildExecution(scope, ({ sessionID }) => Effect.sync(() => void drained.push(sessionID)))
       const execution = Context.get(context, SessionExecution.Service)
       const restart = Context.get(context, SessionRestart.Service)
-      yield* bus.project(SessionEvent.Synthetic, (event) => Effect.sync(() => void continued.push(event)))
 
       yield* restart.resumeSuspendedSessions
       yield* Effect.forEach([first, second], execution.awaitIdle, { discard: true })
       expect(drained.toSorted()).toEqual([first, second])
-      expect(continued.map((event) => event.data).toSorted((a, b) => a.sessionID.localeCompare(b.sessionID))).toEqual(
-        [first, second].map((sessionID) => ({
-          sessionID,
-          text: "The server restarted while you were working. Continue from where you left off without repeating completed work.",
-          description: "Continuing after restart",
-        })),
-      )
       expect(yield* suspensions(database)).toEqual({ [first]: false, [second]: false })
 
       yield* restart.resumeSuspendedSessions
       expect(drained.length).toBe(2)
-      expect(continued.length).toBe(2)
       yield* Scope.close(scope, Exit.void)
     }),
   )

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

@@ -1086,78 +1086,4 @@ describe("Session.pending", () => {
       expect(yield* session.pending(sessionID)).toEqual([])
     }),
   )
-
-  it.effect("cancels pending input and allows its ID to be admitted again", () =>
-    Effect.gen(function* () {
-      yield* setup
-      const session = yield* Session.Service
-      const inputID = SessionMessage.ID.make("msg_cancelled_queue")
-      yield* session.prompt({
-        id: inputID,
-        sessionID,
-        text: "Queue this",
-        delivery: "queue",
-        resume: false,
-      })
-
-      yield* session.cancelPending({ sessionID, inputID })
-
-      expect(yield* session.pending(sessionID)).toEqual([])
-      expect(yield* eventCount(Bus.versionedType(SessionEvent.InputCancelled.type, 1))).toBe(1)
-      expect(
-        yield* session.cancelPending({ sessionID, inputID }).pipe(Effect.flip),
-      ).toMatchObject({ _tag: "Session.PendingInputConflictError", sessionID, inputID })
-      expect(yield* eventCount(Bus.versionedType(SessionEvent.InputCancelled.type, 1))).toBe(1)
-
-      const retried = yield* session.prompt({
-        id: inputID,
-        sessionID,
-        text: "Queue this",
-        delivery: "queue",
-        resume: false,
-      })
-      expect(retried).toMatchObject({ id: inputID, delivery: "queue" })
-    }),
-  )
-
-  it.effect("moves pending input between steer and queue delivery", () =>
-    Effect.gen(function* () {
-      yield* setup
-      const session = yield* Session.Service
-      const queued = yield* session.synthetic({
-        sessionID,
-        text: "Steer this",
-        delivery: "queue",
-        resume: false,
-      })
-      const alreadySteered = yield* session.prompt({ sessionID, text: "Already steer", resume: false })
-      wakeCalls.length = 0
-
-      yield* session.steerPending({ sessionID, inputID: queued.id })
-
-      expect(yield* session.pending(sessionID)).toMatchObject([
-        { id: queued.id, delivery: "steer" },
-        { id: alreadySteered.id, delivery: "steer" },
-      ])
-      expect(wakeCalls).toEqual([sessionID])
-      expect(yield* eventCount(Bus.versionedType(SessionEvent.InputSteered.type, 1))).toBe(1)
-
-      wakeCalls.length = 0
-      yield* session.queuePending({ sessionID, inputID: queued.id })
-      expect(yield* session.pending(sessionID)).toMatchObject([
-        { id: queued.id, delivery: "queue" },
-        { id: alreadySteered.id, delivery: "steer" },
-      ])
-      expect(wakeCalls).toEqual([])
-      expect(yield* eventCount(Bus.versionedType(SessionEvent.InputQueued.type, 1))).toBe(1)
-
-      expect(
-        yield* session.steerPending({ sessionID, inputID: alreadySteered.id }).pipe(Effect.flip),
-      ).toMatchObject({ _tag: "Session.PendingInputConflictError", sessionID, inputID: alreadySteered.id })
-      yield* session.cancelPending({ sessionID, inputID: alreadySteered.id })
-      expect(wakeCalls).toEqual([])
-      expect(yield* eventCount(Bus.versionedType(SessionEvent.InputSteered.type, 1))).toBe(1)
-      expect(yield* eventCount(Bus.versionedType(SessionEvent.InputCancelled.type, 1))).toBe(1)
-    }),
-  )
 })

packages/core/test/skill.test.ts

@@ -6,11 +6,11 @@ import { Agent } from "@opencode-ai/core/agent"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { LayerNode } from "@opencode-ai/util/effect/layer-node"
 import { Bus } from "@opencode-ai/core/bus"
+import { FSUtil } from "@opencode-ai/util/fs-util"
 import { AbsolutePath } from "@opencode-ai/core/schema"
 import { Skill } from "@opencode-ai/core/skill"
 import { SkillDiscovery } from "@opencode-ai/core/skill/discovery"
 import { FileSystem } from "@opencode-ai/schema/filesystem"
-import { Watcher } from "@opencode-ai/core/filesystem/watcher"
 import { tmpdir } from "./fixture/tmpdir"
 import { testEffect } from "./lib/effect"
 
@@ -25,15 +25,8 @@ const discovery = Layer.succeed(
     },
   }),
 )
-const watcherLayer = Watcher.testLayer
 const it = testEffect(
-  Layer.mergeAll(
-    AppNodeBuilder.build(LayerNode.group([Skill.node, Agent.node, Bus.node]), [
-      [SkillDiscovery.node, discovery],
-      [Watcher.node, watcherLayer],
-    ]),
-    watcherLayer,
-  ),
+  AppNodeBuilder.build(LayerNode.group([Skill.node, Agent.node, Bus.node]), [[SkillDiscovery.node, discovery]]),
 )
 
 function write(directory: string, name: string, description: string) {
@@ -60,24 +53,6 @@ function waitForSkillUpdate() {
   })
 }
 
-function expectSubscription(check: (input: Watcher.WatchInput) => boolean) {
-  return Effect.gen(function* () {
-    const watcher = yield* Watcher.Test
-    expect((yield* watcher.subscriptions()).some(check)).toBe(true)
-  })
-}
-
-function emitAndWait(update: Watcher.Update) {
-  return Effect.gen(function* () {
-    const watcher = yield* Watcher.Test
-    yield* Effect.acquireUseRelease(
-      waitForSkillUpdate(),
-      ({ deferred }) => watcher.emit(update).pipe(Effect.andThen(Deferred.await(deferred)), Effect.timeout("1 second")),
-      ({ fiber }) => Fiber.interrupt(fiber),
-    )
-  })
-}
-
 describe("Skill", () => {
   it.live("publishes updates when skill sources change", () =>
     Effect.gen(function* () {
@@ -223,7 +198,7 @@ metadata:
     ),
   )
 
-  it.live("clears cached skills when sources reload", () =>
+  it.live("invalidates cached skills and publishes updates for watcher changes", () =>
     Effect.acquireRelease(
       Effect.promise(() => tmpdir()),
       (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
@@ -235,155 +210,26 @@ metadata:
             await write(tmp.path, "deploy", "Initial deploy")
           })
 
+          const bus = yield* Bus.Service
           const skill = yield* Skill.Service
           yield* skill.transform((editor) => editor.source({ type: "directory", path: AbsolutePath.make(tmp.path) }))
-          expect((yield* skill.list()).find((item) => item.id === "deploy")?.description).toBe("Initial deploy")
 
+          expect((yield* skill.list()).find((item) => item.name === "deploy")?.description).toBe("Initial deploy")
+
+          const file = path.join(tmp.path, "deploy", "SKILL.md")
           yield* Effect.promise(() => write(tmp.path, "deploy", "Updated deploy"))
-          yield* skill.reload()
+          expect((yield* skill.list()).find((item) => item.name === "deploy")?.description).toBe("Initial deploy")
 
-          expect((yield* skill.list()).find((item) => item.id === "deploy")?.description).toBe("Updated deploy")
-        }),
-      ),
-    ),
-  )
-
-  it.live("reloads project sources created after their missing parent", () =>
-    Effect.acquireRelease(
-      Effect.promise(() => tmpdir()),
-      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
-    ).pipe(
-      Effect.flatMap((tmp) =>
-        Effect.gen(function* () {
-          const source = path.join(tmp.path, "generated", "skills")
-          const file = path.join(source, "deploy", "SKILL.md")
-          const skill = yield* Skill.Service
-          const bus = yield* Bus.Service
-          yield* skill.transform((editor) => editor.source({ type: "directory", path: AbsolutePath.make(source) }))
-          expect(yield* skill.list()).toEqual([])
-
-          yield* Effect.promise(async () => {
-            await fs.mkdir(path.dirname(file), { recursive: true })
-            await write(source, "deploy", "Deploy production")
-          })
           yield* Effect.acquireUseRelease(
             waitForSkillUpdate(),
             ({ deferred }) =>
               bus
-                .publish(FileSystem.Event.Changed, { file, event: "add" })
+                .publish(FileSystem.Event.Changed, { file, event: "change" })
                 .pipe(Effect.andThen(Deferred.await(deferred)), Effect.timeout("1 second")),
             ({ fiber }) => Fiber.interrupt(fiber),
           )
 
-          expect((yield* skill.list()).map((item) => item.id)).toEqual([Skill.ID.make("deploy")])
-        }),
-      ),
-    ),
-  )
-
-  it.live("watches directory sources for added and changed skills", () =>
-    Effect.acquireRelease(
-      Effect.promise(() => tmpdir()),
-      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
-    ).pipe(
-      Effect.flatMap((tmp) =>
-        Effect.gen(function* () {
-          yield* Effect.promise(async () => {
-            await fs.mkdir(path.join(tmp.path, "deploy"), { recursive: true })
-            await write(tmp.path, "deploy", "Initial deploy")
-          })
-
-          const skill = yield* Skill.Service
-          yield* skill.transform((editor) => editor.source({ type: "directory", path: AbsolutePath.make(tmp.path) }))
-          expect((yield* skill.list()).map((item) => item.id)).toEqual([Skill.ID.make("deploy")])
-          yield* expectSubscription((input) => input.type === "directory" && input.path === tmp.path)
-
-          const deploy = path.join(tmp.path, "deploy", "SKILL.md")
-          yield* Effect.promise(() => write(tmp.path, "deploy", "Updated deploy"))
-          yield* emitAndWait({ type: "update", path: deploy })
-          expect((yield* skill.list()).find((item) => item.id === "deploy")?.description).toBe("Updated deploy")
-
-          yield* Effect.promise(async () => {
-            await fs.mkdir(path.join(tmp.path, "review"), { recursive: true })
-            await write(tmp.path, "review", "Review changes")
-          })
-          const review = path.join(tmp.path, "review", "SKILL.md")
-          yield* emitAndWait({ type: "create", path: review })
-          expect((yield* skill.list()).map((item) => item.id)).toEqual([
-            Skill.ID.make("deploy"),
-            Skill.ID.make("review"),
-          ])
-
-          yield* Effect.promise(() => fs.rm(path.join(tmp.path, "review"), { recursive: true }))
-          yield* emitAndWait({ type: "delete", path: review })
-          expect((yield* skill.list()).map((item) => item.id)).toEqual([Skill.ID.make("deploy")])
-        }),
-      ),
-    ),
-  )
-
-  it.live("watches canonical directories behind symlinked skills", () =>
-    Effect.acquireRelease(
-      Effect.promise(() => tmpdir()),
-      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
-    ).pipe(
-      Effect.flatMap((tmp) =>
-        Effect.gen(function* () {
-          const source = path.join(tmp.path, "source")
-          const target = path.join(tmp.path, "target", "bro")
-          const file = path.join(target, "SKILL.md")
-          yield* Effect.promise(async () => {
-            await fs.mkdir(source, { recursive: true })
-            await fs.mkdir(target, { recursive: true })
-            await fs.writeFile(file, "---\nname: bro\ndescription: Initial\n---\n# bro")
-            await fs.symlink(target, path.join(source, "bro"))
-          })
-
-          const skill = yield* Skill.Service
-          yield* skill.transform((editor) => editor.source({ type: "directory", path: AbsolutePath.make(source) }))
-          expect((yield* skill.list()).find((item) => item.id === "bro")?.description).toBe("Initial")
-          yield* expectSubscription((input) => input.type === "directory" && input.path === target)
-
-          yield* Effect.promise(() => fs.writeFile(file, "---\nname: bro\ndescription: Updated\n---\n# bro"))
-          yield* emitAndWait({ type: "update", path: file })
-          expect((yield* skill.list()).find((item) => item.id === "bro")?.description).toBe("Updated")
-        }),
-      ),
-    ),
-  )
-
-  it.live("invalidates symlinked sources when their target changes", () =>
-    Effect.acquireRelease(
-      Effect.promise(() => tmpdir()),
-      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
-    ).pipe(
-      Effect.flatMap((tmp) =>
-        Effect.gen(function* () {
-          const source = path.join(tmp.path, "source")
-          const first = path.join(tmp.path, "first")
-          const second = path.join(tmp.path, "second")
-          yield* Effect.promise(async () => {
-            await fs.mkdir(path.join(first, "bro"), { recursive: true })
-            await fs.mkdir(path.join(second, "bro"), { recursive: true })
-            await write(first, "bro", "First")
-            await write(second, "bro", "Second")
-            await fs.symlink(first, source)
-          })
-
-          const skill = yield* Skill.Service
-          yield* skill.transform((editor) => editor.source({ type: "directory", path: AbsolutePath.make(source) }))
-          expect((yield* skill.list()).find((item) => item.id === "bro")?.description).toBe("First")
-          yield* expectSubscription((input) => input.type === "directory" && input.path === first)
-          yield* expectSubscription((input) => input.type === "directory" && input.path === tmp.path)
-
-          yield* Effect.promise(async () => {
-            await fs.unlink(source)
-            await fs.symlink(second, source)
-          })
-          yield* emitAndWait({ type: "update", path: source })
-
-          expect((yield* skill.list()).find((item) => item.id === "bro")?.description).toBe("Second")
-          yield* expectSubscription((input) => input.type === "directory" && input.path === second)
+          expect((yield* skill.list()).find((item) => item.name === "deploy")?.description).toBe("Updated deploy")
         }),
       ),
     ),

packages/core/test/tool-edit.test.ts

@@ -4,9 +4,9 @@ import { describe, expect } from "bun:test"
 import { Effect, Layer } from "effect"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { LayerNode } from "@opencode-ai/util/effect/layer-node"
-import { Environment } from "@opencode-ai/core/environment"
 import { FileMutation } from "@opencode-ai/core/file-mutation"
 import { Formatter } from "@opencode-ai/core/formatter"
+import { FSUtil } from "@opencode-ai/util/fs-util"
 import { Location } from "@opencode-ai/core/location"
 import { LocationMutation } from "@opencode-ai/core/location-mutation"
 import { Permission } from "@opencode-ai/core/permission"
@@ -23,15 +23,7 @@ import { toolIdentity, executeTool, registerToolPlugin, toolDefinitions } from "
 const editToolNode = makeLocationNode({
   name: "test/edit-tool-plugin",
   layer: Layer.effectDiscard(registerToolPlugin(EditTool.Plugin)),
-  deps: [
-    Tool.node,
-    LocationMutation.node,
-    FileMutation.node,
-    Environment.node,
-    Formatter.node,
-    Location.node,
-    Permission.node,
-  ],
+  deps: [Tool.node, LocationMutation.node, FileMutation.node, Formatter.node, FSUtil.node, Permission.node],
 })
 
 const sessionID = Session.ID.make("ses_edit_tool_test")
@@ -80,28 +72,29 @@ const reset = () => {
   formatFile = () => Effect.succeed(false)
 }
 
-const environment = Layer.effect(
-  Environment.Service,
+const filesystem = Layer.effect(
+  FSUtil.Service,
   Effect.gen(function* () {
-    const current = yield* Environment.Service
-    return Environment.Service.of({
-      ...current,
-      files: {
-        ...current.files,
-        read: (target, range) =>
-          current.files
-            .read(target, range)
-            .pipe(
-              Effect.tap((result) =>
-                Effect.sync(() => reads++).pipe(Effect.andThen(Effect.suspend(() => afterRead(target, result.bytes)))),
-              ),
+    const fs = yield* FSUtil.Service
+    return FSUtil.Service.of({
+      ...fs,
+      readFile: (target) =>
+        fs
+          .readFile(target)
+          .pipe(
+            Effect.tap((content) =>
+              Effect.sync(() => reads++).pipe(Effect.andThen(Effect.suspend(() => afterRead(target, content)))),
             ),
-        write: (target, content) =>
-          Effect.sync(() => writes.push(target)).pipe(Effect.andThen(current.files.write(target, content))),
-      },
+          ),
+      writeWithDirs: (target, content, mode) =>
+        Effect.sync(() => writes.push(target)).pipe(Effect.andThen(fs.writeWithDirs(target, content, mode))),
+      writeFile: (target, content, options) =>
+        Effect.sync(() => writes.push(target)).pipe(Effect.andThen(fs.writeFile(target, content, options))),
+      writeFileString: (target, content, options) =>
+        Effect.sync(() => writes.push(target)).pipe(Effect.andThen(fs.writeFileString(target, content, options))),
     })
   }),
-).pipe(Layer.provide(LayerNode.compile(Environment.node)))
+).pipe(Layer.provide(LayerNode.compile(FSUtil.node)))
 
 const withTool = <A, E, R>(directory: string, body: (registry: Tool.Interface) => Effect.Effect<A, E, R>) => {
   const activeLocation = Layer.succeed(
@@ -113,9 +106,15 @@ const withTool = <A, E, R>(directory: string, body: (registry: Tool.Interface) =
   }).pipe(
     Effect.provide(
       AppNodeBuilder.build(
-        LayerNode.group([Tool.node, Tool.node, LocationMutation.node, FileMutation.node, editToolNode]),
+        LayerNode.group([
+          Tool.node,
+          Tool.node,
+          LocationMutation.node,
+          FileMutation.node,
+          editToolNode,
+        ]),
         [
-          [Environment.node, environment],
+          [FSUtil.node, filesystem],
           [Location.node, activeLocation],
           [Formatter.node, formatter],
           [Permission.node, permission],
@@ -472,7 +471,10 @@ describe("EditTool", () => {
             withTool(tmp.path, (registry) =>
               Effect.gen(function* () {
                 expect(
-                  yield* executeTool(registry, call({ path: "missing.ts", oldString: "before", newString: "after" })),
+                  yield* executeTool(
+                    registry,
+                    call({ path: "missing.ts", oldString: "before", newString: "after" }),
+                  ),
                 ).toEqual({
                   status: "error",
                   error: { type: "tool.execution", message: "File not found: missing.ts" },
@@ -643,43 +645,6 @@ describe("EditTool", () => {
     ),
   )
 
-  it.live("serializes concurrent edit transactions", () =>
-    Effect.acquireUseRelease(
-      Effect.promise(() => tmpdir()),
-      (tmp) => {
-        reset()
-        const target = path.join(tmp.path, "concurrent.txt")
-        afterRead = () => (reads === 1 ? Effect.sleep("50 millis") : Effect.void)
-        return Effect.promise(() => fs.writeFile(target, "one\ntwo\n")).pipe(
-          Effect.andThen(
-            withTool(tmp.path, (registry) =>
-              Effect.all(
-                [
-                  executeTool(
-                    registry,
-                    call({ path: "concurrent.txt", oldString: "one", newString: "ONE" }, "call-edit-one"),
-                  ),
-                  executeTool(
-                    registry,
-                    call({ path: "concurrent.txt", oldString: "two", newString: "TWO" }, "call-edit-two"),
-                  ),
-                ],
-                { concurrency: "unbounded" },
-              ),
-            ),
-          ),
-          Effect.andThen((results) =>
-            Effect.gen(function* () {
-              expect(results.map((result) => result.status)).toEqual(["completed", "completed"])
-              expect(yield* Effect.promise(() => fs.readFile(target, "utf8"))).toBe("ONE\nTWO\n")
-            }),
-          ),
-        )
-      },
-      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
-    ),
-  )
-
   it.live("applies the edit when content changes after matching", () =>
     Effect.acquireUseRelease(
       Effect.promise(() => tmpdir()),

packages/core/test/tool-output.test.ts

@@ -1,164 +0,0 @@
-import { describe, expect } from "bun:test"
-import path from "path"
-import { Effect, Layer, Stream } from "effect"
-import { Config } from "@opencode-ai/core/config"
-import { Document, Info } from "@opencode-ai/schema/config"
-import { ConfigToolOutput } from "@opencode-ai/schema/config/tool-output"
-import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
-import { LayerNode } from "@opencode-ai/util/effect/layer-node"
-import { ToolOutput } from "@opencode-ai/core/tool-output"
-import { FSUtil } from "@opencode-ai/util/fs-util"
-import { Global } from "@opencode-ai/util/global"
-import { Identifier } from "@opencode-ai/core/id/id"
-import { tmpdir } from "./fixture/tmpdir"
-import { it } from "./lib/effect"
-
-const withStore = <A, E, R>(
-  body: (output: ToolOutput.Interface, fs: FSUtil.Interface, root: string) => Effect.Effect<A, E, R>,
-  info = new Info(),
-) =>
-  Effect.acquireUseRelease(
-    Effect.promise(() => tmpdir()),
-    (tmp) => {
-      const config = Layer.succeed(
-        Config.Service,
-        Config.Service.of({
-          entries: () => Effect.succeed([new Document({ type: "document", info })]),
-          changes: () => Stream.empty,
-        }),
-      )
-      const layer = AppNodeBuilder.build(LayerNode.group([ToolOutput.node, FSUtil.node]), [
-        [Config.node, config],
-        [Global.node, Global.layerWith({ data: tmp.path })],
-      ])
-      return Effect.gen(function* () {
-        return yield* body(yield* ToolOutput.Service, yield* FSUtil.Service, tmp.path)
-      }).pipe(Effect.provide(layer))
-    },
-    (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
-  )
-
-describe("ToolOutput", () => {
-  it.live("writes oversized text and returns a bounded preview", () =>
-    withStore(
-      (service, fs) =>
-        Effect.gen(function* () {
-          const output = { items: [1, 2, 3] }
-          const result = yield* service.truncate({ output, content: "one\ntwo\nthree" })
-          expect(result.output).toBe(output)
-          expect(result.metadata).toMatchObject({ truncated: true })
-          const outputPath = result.metadata?.outputPath
-          expect(typeof outputPath).toBe("string")
-          if (typeof outputPath !== "string") return
-          expect(yield* fs.readFileString(outputPath)).toBe("one\ntwo\nthree")
-          expect(result.content).toEqual([
-            { type: "text", text: "one\ntwo" },
-            { type: "text", text: `... 1 line truncated; full content saved to ${outputPath} ...` },
-          ])
-        }),
-      new Info({ tool_output: new ConfigToolOutput.Info({ max_lines: 2, max_bytes: 1_000 }) }),
-    ),
-  )
-
-  it.live("reports bytes omitted by the byte limit", () =>
-    withStore(
-      (output) =>
-        Effect.gen(function* () {
-          const result = yield* output.truncate({ content: "one\ntwo" })
-          expect(result.content).toEqual([
-            { type: "text", text: "one" },
-            {
-              type: "text",
-              text: expect.stringMatching(/^\.\.\. 4 bytes truncated; full content saved to .+ \.\.\.$/),
-            },
-          ])
-        }),
-      new Info({ tool_output: new ConfigToolOutput.Info({ max_lines: 100, max_bytes: 5 }) }),
-    ),
-  )
-
-  it.live("preserves mixed content ordering", () =>
-    withStore(
-      (output) =>
-        Effect.gen(function* () {
-          const file = { type: "file" as const, uri: "file:///image.png", mime: "image/png" }
-          const result = yield* output.truncate({
-            content: [{ type: "text", text: "before" }, file, { type: "text", text: "after\nomitted" }],
-          })
-          expect(result.content).toEqual([
-            { type: "text", text: "before" },
-            file,
-            { type: "text", text: "after" },
-            { type: "text", text: expect.stringMatching(/^\.\.\. 1 line truncated; full content saved to /) },
-          ])
-        }),
-      new Info({ tool_output: new ConfigToolOutput.Info({ max_lines: 2, max_bytes: 1_000 }) }),
-    ),
-  )
-
-  it.live("skips results that report a truncation state", () =>
-    withStore((output) =>
-      Effect.gen(function* () {
-        const truncated = { content: "one\ntwo", metadata: { truncated: true, source: "tool" } }
-        const retained = { content: "one\ntwo", metadata: { truncated: false, source: "tool" } }
-        expect(yield* output.truncate(truncated)).toBe(truncated)
-        expect(yield* output.truncate(retained)).toBe(retained)
-      }),
-    ),
-  )
-
-  it.live("marks results that fit without changing their content", () =>
-    withStore((output) =>
-      Effect.gen(function* () {
-        const content = [{ type: "text" as const, text: "small" }]
-        expect(yield* output.truncate({ content })).toEqual({ content, metadata: { truncated: false } })
-      }),
-    ),
-  )
-
-  it.live("does not count a trailing newline as another line", () =>
-    withStore(
-      (output) =>
-        Effect.gen(function* () {
-          expect(yield* output.truncate({ content: "one\ntwo\n" })).toEqual({
-            content: "one\ntwo\n",
-            metadata: { truncated: false },
-          })
-        }),
-      new Info({ tool_output: new ConfigToolOutput.Info({ max_lines: 2, max_bytes: 1_000 }) }),
-    ),
-  )
-
-  it.live("reports a trailing newline omitted by the byte limit", () =>
-    withStore(
-      (output) =>
-        Effect.gen(function* () {
-          const result = yield* output.truncate({ content: "one\n" })
-          expect(result.content).toEqual([
-            { type: "text", text: "one" },
-            { type: "text", text: expect.stringMatching(/^\.\.\. 1 byte truncated; full content saved to /) },
-          ])
-        }),
-      new Info({ tool_output: new ConfigToolOutput.Info({ max_lines: 2, max_bytes: 3 }) }),
-    ),
-  )
-
-  it.live("removes expired managed files", () =>
-    withStore((output, fs, root) =>
-      Effect.gen(function* () {
-        const directory = path.join(root, ToolOutput.DIRECTORY)
-        const old = path.join(
-          directory,
-          Identifier.create("tool", "ascending", Date.now() - 8 * 24 * 60 * 60 * 1_000),
-        )
-        const recent = path.join(directory, Identifier.ascending("tool"))
-        yield* fs.ensureDir(directory)
-        yield* fs.writeFileString(old, "old")
-        yield* fs.writeFileString(recent, "recent")
-        yield* output.cleanup()
-        expect(yield* fs.exists(old)).toBe(false)
-        expect(yield* fs.exists(recent)).toBe(true)
-      }),
-    ),
-  )
-})

packages/core/test/tool-patch.test.ts

@@ -2,12 +2,11 @@ import fs from "fs/promises"
 import path from "path"
 import { describe, expect } from "bun:test"
 import { Effect, Exit, Layer, Schema } from "effect"
+import { systemError } from "effect/PlatformError"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { LayerNode } from "@opencode-ai/util/effect/layer-node"
-import { Environment } from "@opencode-ai/core/environment"
 import { FSUtil } from "@opencode-ai/util/fs-util"
 import { Formatter } from "@opencode-ai/core/formatter"
-import { FileMutation } from "@opencode-ai/core/file-mutation"
 import { Location } from "@opencode-ai/core/location"
 import { Permission } from "@opencode-ai/core/permission"
 import { AbsolutePath } from "@opencode-ai/core/schema"
@@ -23,7 +22,7 @@ import { toolIdentity, executeTool, registerToolPlugin, toolDefinitions } from "
 const patchToolNode = makeLocationNode({
   name: "test/patch-tool-plugin",
   layer: Layer.effectDiscard(registerToolPlugin(PatchTool.Plugin)),
-  deps: [Tool.node, FileMutation.node, Environment.node, Formatter.node, Location.node, Permission.node],
+  deps: [Tool.node, Formatter.node, FSUtil.node, Location.node, Permission.node],
 })
 
 const sessionID = Session.ID.make("ses_patch_tool_test")
@@ -82,33 +81,48 @@ const reset = () => {
   formatFile = () => Effect.succeed(false)
 }
 
-const environment = Layer.effect(
-  Environment.Service,
+const filesystem = Layer.effect(
+  FSUtil.Service,
   Effect.gen(function* () {
-    const current = yield* Environment.Service
-    return Environment.Service.of({
-      ...current,
-      files: {
-        ...current.files,
-        read: (target, range) =>
-          Effect.sync(() => {
-            if (!editApproved) readsBeforeEditApproval++
-          }).pipe(Effect.andThen(current.files.read(target, range))),
-        remove: (target) => {
-          if (failRemoveTarget && path.basename(target) === failRemoveTarget) return Effect.die("forced remove failure")
-          if (failRemoveErrorTarget && path.basename(target) === failRemoveErrorTarget)
-            return Effect.fail(new Environment.Failed({ path: target, cause: new Error("forced remove failure") }))
-          return current.files.remove(target)
-        },
-        write: (target, content) => {
-          if (failWriteTarget && path.basename(target) === failWriteTarget)
-            return Effect.fail(new Environment.Failed({ path: target, cause: new Error("forced write failure") }))
-          return current.files.write(target, content)
-        },
+    const fs = yield* FSUtil.Service
+    return FSUtil.Service.of({
+      ...fs,
+      readFile: (target) =>
+        Effect.sync(() => {
+          if (!editApproved) readsBeforeEditApproval++
+        }).pipe(Effect.andThen(fs.readFile(target))),
+      remove: (target, options) => {
+        if (failRemoveTarget && path.basename(target) === failRemoveTarget) return Effect.die("forced remove failure")
+        if (failRemoveErrorTarget && path.basename(target) === failRemoveErrorTarget) {
+          return Effect.fail(
+            systemError({
+              _tag: "Unknown",
+              module: "FileSystem",
+              method: "remove",
+              description: "forced remove failure",
+              pathOrDescriptor: target,
+            }),
+          )
+        }
+        return fs.remove(target, options)
+      },
+      writeWithDirs: (target, content, mode) => {
+        if (failWriteTarget && path.basename(target) === failWriteTarget) {
+          return Effect.fail(
+            systemError({
+              _tag: "Unknown",
+              module: "FileSystem",
+              method: "writeWithDirs",
+              description: "forced write failure",
+              pathOrDescriptor: target,
+            }),
+          )
+        }
+        return fs.writeWithDirs(target, content, mode)
       },
     })
   }),
-).pipe(Layer.provide(LayerNode.compile(Environment.node)))
+).pipe(Layer.provide(LayerNode.compile(FSUtil.node)))
 
 const withTool = <A, E, R>(
   directory: string,
@@ -125,8 +139,8 @@ const withTool = <A, E, R>(
     return yield* body(yield* Tool.Service)
   }).pipe(
     Effect.provide(
-      AppNodeBuilder.build(LayerNode.group([Tool.node, FileMutation.node, patchToolNode]), [
-        [Environment.node, environment],
+      AppNodeBuilder.build(LayerNode.group([Tool.node, patchToolNode]), [
+        [FSUtil.node, filesystem],
         [Location.node, activeLocation],
         [Formatter.node, formatter],
         [Permission.node, permission],
@@ -248,43 +262,6 @@ describe("PatchTool", () => {
     ),
   )
 
-  it.live("serializes concurrent patch transactions", () =>
-    withTempTool((directory, registry) => {
-      const target = path.join(directory, "concurrent.txt")
-      afterEditApproval = () =>
-        assertions.filter((input) => input.action === "edit").length === 1 ? Effect.sleep("50 millis") : Effect.void
-      return Effect.promise(() => fs.writeFile(target, "one\ntwo\n")).pipe(
-        Effect.andThen(
-          Effect.all(
-            [
-              executeTool(
-                registry,
-                call(
-                  "*** Begin Patch\n*** Update File: concurrent.txt\n@@\n-one\n+ONE\n*** End Patch",
-                  "call-patch-one",
-                ),
-              ),
-              executeTool(
-                registry,
-                call(
-                  "*** Begin Patch\n*** Update File: concurrent.txt\n@@\n-two\n+TWO\n*** End Patch",
-                  "call-patch-two",
-                ),
-              ),
-            ],
-            { concurrency: "unbounded" },
-          ),
-        ),
-        Effect.andThen((results) =>
-          Effect.gen(function* () {
-            expect(results.map((result) => result.status)).toEqual(["completed", "completed"])
-            expect(yield* Effect.promise(() => fs.readFile(target, "utf8"))).toBe("ONE\nTWO\n")
-          }),
-        ),
-      )
-    }),
-  )
-
   it.live("returns file diffs for final formatted content", () =>
     withTempTool((directory, registry) => {
       const target = path.join(directory, "formatted.txt")

packages/core/test/tool-read-filesystem.test.ts

@@ -1,255 +1,113 @@
 import { describe, expect } from "bun:test"
-import fs from "fs/promises"
 import path from "path"
-import { Environment } from "@opencode-ai/core/environment"
-import { AbsolutePath } from "@opencode-ai/core/schema"
-import { ReadToolFileSystem } from "@opencode-ai/core/tool/read-filesystem"
-import { CrossSpawnSpawner } from "@opencode-ai/util/cross-spawn-spawner"
+import { Effect, FileSystem } from "effect"
 import { LayerNodePlatform } from "@opencode-ai/util/effect/app-node-platform"
 import { LayerNode } from "@opencode-ai/util/effect/layer-node"
-import { Effect, FileSystem } from "effect"
-import { ChildProcessSpawner } from "effect/unstable/process"
+import { FSUtil } from "@opencode-ai/util/fs-util"
+import { ReadToolFileSystem } from "@opencode-ai/core/tool/read-filesystem"
 import { testEffect } from "./lib/effect"
 
-const it = testEffect(LayerNode.compile(LayerNode.group([CrossSpawnSpawner.node, LayerNodePlatform.filesystem])))
+const it = testEffect(LayerNode.compile(LayerNode.group([FSUtil.node, LayerNodePlatform.filesystem])))
 const fixture = Effect.gen(function* () {
+  const fs = yield* FSUtil.Service
   const files = yield* FileSystem.FileSystem
-  const spawner = yield* ChildProcessSpawner.ChildProcessSpawner
   const directory = yield* files.makeTempDirectoryScoped()
-  return { environment: Environment.makeFiles(Environment.makeLocalDriver(spawner)), files, directory }
+  return { fs, files, directory }
 })
-const absolute = (value: string) => AbsolutePath.make(value)
 
 describe("ReadToolFileSystem", () => {
-  it.effect("preserves the environment not-found error", () =>
+  it.effect("fails with a typed filesystem error when a resolved file disappears", () =>
     Effect.gen(function* () {
-      const { environment, directory } = yield* fixture
+      const { fs, directory } = yield* fixture
       const file = path.join(directory, "missing.txt")
 
-      const error = yield* ReadToolFileSystem.read(environment, absolute(file), "missing.txt").pipe(Effect.flip)
+      const error = yield* ReadToolFileSystem.read(fs, file, "missing.txt").pipe(Effect.flip)
 
-      expect(error).toBeInstanceOf(Environment.NotFound)
+      expect(error).toMatchObject({ _tag: "PlatformError" })
     }),
   )
 
-  it.effect("returns a listing when read reports a directory", () =>
+  it.effect("fails when a file becomes the wrong path kind", () =>
     Effect.gen(function* () {
-      const { environment, files, directory } = yield* fixture
-      yield* files.makeDirectory(path.join(directory, "folder"))
-      yield* files.writeFileString(path.join(directory, "file.txt"), "hello")
+      const { fs, directory } = yield* fixture
 
-      const result = yield* ReadToolFileSystem.read(environment, absolute(directory), "folder")
+      const error = yield* ReadToolFileSystem.read(fs, directory, "folder").pipe(Effect.flip)
 
-      expect(result).toMatchObject({
-        type: "list-page",
-        entries: [
-          { path: `folder${path.sep}`, type: "directory" },
-          { path: "file.txt", type: "file" },
-        ],
-      })
+      expect(error).toBeInstanceOf(ReadToolFileSystem.PathKindError)
     }),
   )
 
-  it.effect("reads malformed UTF-8 lossily and still rejects null-byte binary content", () =>
+  it.effect("fails with a typed filesystem error when directory listing fails", () =>
     Effect.gen(function* () {
-      const { environment, files, directory } = yield* fixture
+      const { fs, files, directory } = yield* fixture
+      const file = path.join(directory, "file.txt")
+      yield* files.writeFileString(file, "hello")
+
+      const error = yield* ReadToolFileSystem.list(fs, file).pipe(Effect.flip)
+
+      expect(error).toBeInstanceOf(FSUtil.FileSystemError)
+      if (error instanceof FSUtil.FileSystemError) expect(error.method).toBe("readDirectoryEntries")
+    }),
+  )
+
+  it.effect("reports binary and malformed UTF-8 content as typed errors", () =>
+    Effect.gen(function* () {
+      const { fs, files, directory } = yield* fixture
       const binary = path.join(directory, "archive.dat")
       const malformed = path.join(directory, "malformed.txt")
       yield* files.writeFile(binary, Uint8Array.of(0, 1, 2, 3))
-      yield* files.writeFile(malformed, Uint8Array.of(0x68, 0x69, 0x80))
+      const malformedContent = new Uint8Array(64 * 1024 + 1).fill(97)
+      malformedContent[64 * 1024] = 0x80
+      yield* files.writeFile(malformed, malformedContent)
 
-      const binaryError = yield* ReadToolFileSystem.read(environment, absolute(binary), "archive.dat").pipe(Effect.flip)
-      const malformedResult = yield* ReadToolFileSystem.read(environment, absolute(malformed), "malformed.txt")
+      const binaryError = yield* ReadToolFileSystem.read(fs, binary, "archive.dat").pipe(Effect.flip)
+      const malformedError = yield* ReadToolFileSystem.read(fs, malformed, "malformed.txt").pipe(Effect.flip)
 
       expect(binaryError).toBeInstanceOf(ReadToolFileSystem.BinaryFileError)
       expect(binaryError.message).toBe("Cannot read binary file: archive.dat")
-      expect(malformedResult).toMatchObject({ type: "file", content: "hi\uFFFD", encoding: "utf8" })
-    }),
-  )
-
-  it.effect("reads text despite a binary-associated extension", () =>
-    Effect.gen(function* () {
-      const { environment, files, directory } = yield* fixture
-      const file = path.join(directory, "notes.docx")
-      yield* files.writeFileString(file, "plain text")
-
-      const result = yield* ReadToolFileSystem.read(environment, absolute(file), "notes.docx")
-
-      expect(result).toMatchObject({ type: "file", content: "plain text", encoding: "utf8" })
-    }),
-  )
-
-  it.effect("lists unresolved symlinks, including broken and escaping links", () =>
-    Effect.gen(function* () {
-      if (process.platform === "win32") return
-      const { environment, files, directory } = yield* fixture
-      const outside = yield* files.makeTempDirectoryScoped()
-      yield* files.makeDirectory(path.join(directory, "folder"))
-      yield* files.writeFileString(path.join(directory, "file.txt"), "hello")
-      yield* Effect.promise(() => fs.symlink(path.join(outside, "target.txt"), path.join(directory, "escape")))
-      yield* Effect.promise(() => fs.symlink(path.join(directory, "missing.txt"), path.join(directory, "broken")))
-
-      const result = yield* ReadToolFileSystem.read(environment, absolute(directory), "folder")
-
-      expect(result.type).toBe("list-page")
-      if (result.type !== "list-page") return
-      expect(result.entries.map((entry) => ({ ...entry, path: String(entry.path) }))).toEqual([
-        { path: `folder${path.sep}`, type: "directory" },
-        { path: "broken", type: "symlink" },
-        { path: "escape", type: "symlink" },
-        { path: "file.txt", type: "file" },
-      ])
-    }),
-  )
-
-  it.effect("reads a symlinked directory as a listing", () =>
-    Effect.gen(function* () {
-      if (process.platform === "win32") return
-      const { environment, files, directory } = yield* fixture
-      const target = path.join(directory, "target")
-      const link = path.join(directory, "link")
-      yield* files.makeDirectory(target)
-      yield* files.writeFileString(path.join(target, "file.txt"), "hello")
-      yield* Effect.promise(() => fs.symlink(target, link))
-
-      const result = yield* ReadToolFileSystem.read(environment, absolute(link), "link")
-
-      expect(result).toMatchObject({
-        type: "list-page",
-        entries: [{ path: "file.txt", type: "file" }],
-      })
+      expect(malformedError).toBeInstanceOf(ReadToolFileSystem.MalformedUtf8Error)
     }),
   )
 
   it.effect("reports out-of-range pagination as a typed error", () =>
     Effect.gen(function* () {
-      const { environment, files, directory } = yield* fixture
+      const { fs, files, directory } = yield* fixture
       const file = path.join(directory, "short.txt")
       yield* files.writeFileString(file, "one\n")
 
-      const error = yield* ReadToolFileSystem.read(environment, absolute(file), "short.txt", { offset: 2 }).pipe(
-        Effect.flip,
-      )
+      const error = yield* ReadToolFileSystem.read(fs, file, "short.txt", { offset: 2 }).pipe(Effect.flip)
 
       expect(error).toBeInstanceOf(ReadToolFileSystem.OffsetOutOfRangeError)
       expect(error.message).toBe("Offset 2 is out of range")
     }),
   )
 
-  it.effect("pages text with one-based offsets", () =>
+  it.effect("stops reading after the requested page is complete", () =>
     Effect.gen(function* () {
-      const { environment, files, directory } = yield* fixture
-      const file = path.join(directory, "lines.txt")
-      yield* files.writeFileString(file, "one\r\ntwo\nthree")
+      const { fs, files, directory } = yield* fixture
+      const prefix = new TextEncoder().encode("one\n")
+      for (const [name, trailing] of [
+        ["malformed.txt", 0x80],
+        ["nul.txt", 0],
+      ] as const) {
+        const file = path.join(directory, name)
+        yield* files.writeFile(file, Uint8Array.from([...prefix, trailing]))
 
-      const result = yield* ReadToolFileSystem.read(environment, absolute(file), "lines.txt", {
-        offset: 2,
-        limit: 1,
-      })
+        const result = yield* ReadToolFileSystem.read(fs, file, name, { limit: 1 })
 
-      expect(result).toMatchObject({ type: "text-page", content: "two", offset: 2, truncated: true, next: 3 })
-    }),
-  )
-
-  it.effect("truncates long lines", () =>
-    Effect.gen(function* () {
-      const { environment, files, directory } = yield* fixture
-      const file = path.join(directory, "long.txt")
-      yield* files.writeFileString(file, "a".repeat(2_001))
-
-      const result = yield* ReadToolFileSystem.read(environment, absolute(file), "long.txt", { limit: 1 })
-
-      expect(result).toMatchObject({
-        type: "text-page",
-        content: `${"a".repeat(2_000)}... (line truncated to 2000 chars)`,
-        truncated: false,
-      })
-    }),
-  )
-
-  it.effect("enforces line and byte budgets with continuation offsets", () =>
-    Effect.gen(function* () {
-      const { environment, files, directory } = yield* fixture
-      const linesFile = path.join(directory, "many-lines.txt")
-      const bytesFile = path.join(directory, "many-bytes.txt")
-      yield* files.writeFileString(linesFile, Array.from({ length: 2_001 }, (_, index) => String(index)).join("\n"))
-      yield* files.writeFileString(bytesFile, Array.from({ length: 200 }, () => "a".repeat(2_000)).join("\n"))
-      const ranges: Array<{ readonly offset: number; readonly length: number } | undefined> = []
-      const tracked = {
-        ...environment,
-        read: (path: string, range?: { readonly offset: number; readonly length: number }) =>
-          Effect.sync(() => ranges.push(range)).pipe(Effect.andThen(environment.read(path, range))),
+        expect(result).toMatchObject({ type: "text-page", content: "one", truncated: true, next: 2 })
       }
-
-      const lines = yield* ReadToolFileSystem.read(environment, absolute(linesFile), "many-lines.txt", { limit: 2_000 })
-      const bytes = yield* ReadToolFileSystem.read(tracked, absolute(bytesFile), "many-bytes.txt", {})
-
-      expect(lines).toMatchObject({ type: "text-page", truncated: true, next: 2_001 })
-      expect(lines.type === "text-page" ? lines.content.split("\n") : []).toHaveLength(2_000)
-      expect(bytes).toMatchObject({ type: "text-page", truncated: true, next: 26 })
-      expect(bytes.type === "text-page" ? Buffer.byteLength(bytes.content) : Infinity).toBeLessThanOrEqual(
-        ReadToolFileSystem.MAX_READ_BYTES,
-      )
-      expect(ranges).toEqual([{ offset: 0, length: 256 * 1024 }])
-    }),
-  )
-
-  it.effect("sorts and pages directory entries", () =>
-    Effect.gen(function* () {
-      const { environment, files, directory } = yield* fixture
-      yield* files.makeDirectory(path.join(directory, "z"))
-      yield* files.makeDirectory(path.join(directory, "a"))
-      yield* files.writeFileString(path.join(directory, "b.txt"), "")
-
-      const result = yield* ReadToolFileSystem.read(environment, absolute(directory), "folder", {
-        offset: 2,
-        limit: 1,
-      })
-
-      expect(result).toMatchObject({
-        type: "list-page",
-        entries: [{ path: `z${path.sep}`, type: "directory" }],
-        truncated: true,
-        next: 3,
-      })
-    }),
-  )
-
-  it.effect("stops checking for null bytes after the requested page", () =>
-    Effect.gen(function* () {
-      const { environment, files, directory } = yield* fixture
-      const file = path.join(directory, "nul.txt")
-      yield* files.writeFile(file, Uint8Array.from([...new TextEncoder().encode("one\n"), 0]))
-
-      const result = yield* ReadToolFileSystem.read(environment, absolute(file), "nul.txt", { limit: 1 })
-
-      expect(result).toMatchObject({ type: "text-page", content: "one", truncated: true, next: 2 })
-    }),
-  )
-
-  it.effect("reads page two after fetching more than the first 256KB range", () =>
-    Effect.gen(function* () {
-      const { environment, files, directory } = yield* fixture
-      const file = path.join(directory, "large.txt")
-      yield* files.writeFileString(file, `${"a".repeat(300 * 1024)}\nsecond\n`)
-
-      const result = yield* ReadToolFileSystem.read(environment, absolute(file), "large.txt", {
-        offset: 2,
-        limit: 1,
-      })
-
-      expect(result).toMatchObject({ type: "text-page", content: "second", offset: 2, truncated: false })
     }),
   )
 
   it.effect("preserves the media ingestion limit message", () =>
     Effect.gen(function* () {
-      const { environment, files, directory } = yield* fixture
+      const { fs, files, directory } = yield* fixture
       const file = path.join(directory, "oversized.png")
       yield* files.writeFile(file, Uint8Array.of(0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a))
       yield* files.truncate(file, ReadToolFileSystem.MAX_MEDIA_INGEST_BYTES + 1)
 
-      const error = yield* ReadToolFileSystem.read(environment, absolute(file), "oversized.png").pipe(Effect.flip)
+      const error = yield* ReadToolFileSystem.read(fs, file, "oversized.png").pipe(Effect.flip)
 
       expect(error).toBeInstanceOf(ReadToolFileSystem.MediaIngestLimitError)
       expect(error.message).toBe(
@@ -260,11 +118,11 @@ describe("ReadToolFileSystem", () => {
 
   it.effect("reads PDFs as bounded media", () =>
     Effect.gen(function* () {
-      const { environment, files, directory } = yield* fixture
+      const { fs, files, directory } = yield* fixture
       const file = path.join(directory, "document.pdf")
       yield* files.writeFileString(file, "%PDF-1.7\ncontent")
 
-      const result = yield* ReadToolFileSystem.read(environment, absolute(file), "document.pdf")
+      const result = yield* ReadToolFileSystem.read(fs, file, "document.pdf")
 
       expect(result).toMatchObject({
         type: "file",

packages/core/test/tool-read.test.ts

@@ -1,6 +1,6 @@
 import { beforeEach, describe, expect } from "bun:test"
 import path from "path"
-import { Effect, Exit, Layer, Stream } from "effect"
+import { Effect, Exit, Layer, PlatformError, Stream } from "effect"
 import { Config } from "@opencode-ai/core/config"
 import { Document, Info } from "@opencode-ai/schema/config"
 import { ConfigMedia } from "@opencode-ai/schema/config/media"
@@ -21,7 +21,6 @@ import { ReadTool } from "@opencode-ai/core/tool/plugin/read"
 import { ReadToolFileSystem } from "@opencode-ai/core/tool/read-filesystem"
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
 import { SessionInstructions } from "@opencode-ai/core/session/instructions"
-import { Environment } from "@opencode-ai/core/environment"
 import { testEffect } from "./lib/effect"
 import { toolIdentity, executeTool, registerToolPlugin, toolDefinitions } from "./lib/tool"
 
@@ -43,13 +42,24 @@ const readToolNode = makeLocationNode({
 const assertions: Permission.AssertInput[] = []
 const missingPath = "__missing_read_target__.txt"
 const missingAbsolutePath = path.join(process.cwd(), missingPath)
+const notFound = (target: string) =>
+  PlatformError.systemError({
+    _tag: "NotFound",
+    module: "FileSystem",
+    method: "stat",
+    pathOrDescriptor: target,
+  })
 const readCalls: {
   input: AbsolutePath
   page: ReadToolFileSystem.PageInput
 }[] = []
+const listCalls: ReadToolFileSystem.PageInput[] = []
+let listResult = new ReadToolFileSystem.ListPage({ type: "list-page", entries: [], truncated: false })
+let resolvedType: "file" | "directory" = "file"
 let resolveFailure: unknown
+let inspectFailure: ReadToolFileSystem.InspectError | undefined
 let directoryEntries: string[] = []
-let readResult: ReadToolFileSystem.FileContent | ReadToolFileSystem.TextPage | ReadToolFileSystem.ListPage = {
+let readResult: ReadToolFileSystem.FileContent | ReadToolFileSystem.TextPage = {
   type: "file",
   uri: "file:///README.md",
   name: "README.md",
@@ -61,12 +71,22 @@ let readFailure: ReadToolFileSystem.ReadError | undefined
 const reader = Layer.succeed(
   ReadToolFileSystem.Service,
   ReadToolFileSystem.Service.of({
+    inspect: () =>
+      resolveFailure !== undefined
+        ? Effect.die(resolveFailure)
+        : inspectFailure !== undefined
+          ? Effect.fail(inspectFailure)
+          : Effect.succeed(resolvedType),
     read: (input, _resource, page = {}) => {
       readCalls.push({ input, page })
-      if (resolveFailure !== undefined) return Effect.die(resolveFailure)
       if (readFailure !== undefined) return Effect.fail(readFailure)
       return Effect.succeed(readResult)
     },
+    list: (_path, input = {}) =>
+      Effect.sync(() => {
+        listCalls.push(input)
+        return listResult
+      }),
   }),
 )
 let allow = true
@@ -105,6 +125,17 @@ const testFileSystem = Layer.effect(
       FSUtil.Service.of({
         ...fs,
         readDirectory: () => Effect.succeed(directoryEntries),
+        realPath: (path) =>
+          path === missingAbsolutePath
+            ? Effect.fail(
+                PlatformError.systemError({
+                  _tag: "NotFound",
+                  module: "FileSystem",
+                  method: "realPath",
+                  pathOrDescriptor: path,
+                }),
+              )
+            : Effect.succeed(path),
       }),
     ),
   ),
@@ -117,13 +148,13 @@ const mutation = Layer.succeed(
   LocationMutation.Service,
   LocationMutation.Service.of({
     resolve: (input) => {
-      const absolute = path.resolve(process.cwd(), input.path)
-      const external = path.isAbsolute(input.path) && !FSUtil.contains(process.cwd(), absolute)
-      const resource = external ? absolute.replaceAll("\\", "/") : path.relative(process.cwd(), absolute) || "."
-      const directory = path.dirname(absolute)
+      const canonical = path.resolve(process.cwd(), input.path)
+      const external = path.isAbsolute(input.path) && !FSUtil.contains(process.cwd(), canonical)
+      const resource = external ? canonical.replaceAll("\\", "/") : path.relative(process.cwd(), canonical) || "."
+      const directory = path.dirname(canonical)
       const externalResource = path.join(directory, "*").replaceAll("\\", "/")
       return Effect.succeed({
-        absolute,
+        canonical,
         resource,
         externalDirectory: external
           ? {
@@ -164,8 +195,11 @@ describe("ReadTool", () => {
   beforeEach(() => {
     assertions.length = 0
     readCalls.length = 0
+    listCalls.length = 0
     allow = true
+    resolvedType = "file"
     resolveFailure = undefined
+    inspectFailure = undefined
     directoryEntries = []
     readResult = {
       type: "file",
@@ -176,6 +210,7 @@ describe("ReadTool", () => {
       mime: "text/plain",
     }
     readFailure = undefined
+    listResult = new ReadToolFileSystem.ListPage({ type: "list-page", entries: [], truncated: false })
   })
 
   it.effect("registers, authorizes, and reads through the location filesystem", () =>
@@ -276,7 +311,9 @@ describe("ReadTool", () => {
       })
       expect(settled.status).toBe("completed")
       if (settled.status !== "completed") return
-      expect(settled.metadata).toEqual({ truncated: false })
+      // Image base64 is carried by the content file item only; read produces no
+      // metadata, so the original bytes are never persisted twice.
+      expect(settled.metadata).toBeUndefined()
       expect(settled.content).toMatchObject([
         { type: "text", text: "Image read successfully" },
         { type: "file", mime: "image/png", uri: `data:image/png;base64,${png}` },
@@ -584,6 +621,10 @@ describe("ReadTool", () => {
     Effect.gen(function* () {
       const registry = yield* Tool.Service
       for (const [error, message] of [
+        [
+          new ReadToolFileSystem.MalformedUtf8Error({ resource: "invalid.txt" }),
+          "File is not valid UTF-8: invalid.txt",
+        ],
         [new ReadToolFileSystem.OffsetOutOfRangeError({ offset: 10 }), "Offset 10 is out of range"],
         [
           new ReadToolFileSystem.PathKindError({ resource: "socket", expected: "a file" }),
@@ -637,7 +678,7 @@ describe("ReadTool", () => {
 
   it.effect("returns missing paths as model-visible tool failures", () =>
     Effect.gen(function* () {
-      readFailure = new Environment.NotFound({ path: missingAbsolutePath })
+      inspectFailure = notFound(missingAbsolutePath)
       directoryEntries = [
         "__missing_read_target__.txt.bak",
         "copy___missing_read_target__.txt",
@@ -661,18 +702,14 @@ describe("ReadTool", () => {
         },
       })
       expect(assertions).toMatchObject([{ sessionID, action: "read", resources: [missingPath], save: ["*"] }])
-      expect(readCalls).toEqual([
-        {
-          input: AbsolutePath.make(missingAbsolutePath),
-          page: { offset: undefined, limit: undefined },
-        },
-      ])
+      expect(readCalls).toEqual([])
     }),
   )
 
   it.effect("lists a bounded directory page through read", () =>
     Effect.gen(function* () {
-      readResult = new ReadToolFileSystem.ListPage({
+      resolvedType = "directory"
+      listResult = new ReadToolFileSystem.ListPage({
         type: "list-page",
         entries: [
           FileSystem.Entry.make({ path: RelativePath.make("components/"), type: "directory" }),
@@ -684,21 +721,17 @@ describe("ReadTool", () => {
       const registry = yield* Tool.Service
 
       const result = yield* executeTool(registry, {
-        sessionID,
-        ...toolIdentity,
-        call: {
-          type: "tool-call",
-          id: "call-read-directory",
-          name: "read",
-          input: { path: "src", offset: 2, limit: 10 },
-        },
-      })
-      expect(result).toMatchObject({
-        status: "completed",
-        output: { entries: readResult.entries, truncated: true, next: 4 },
-      })
+          sessionID,
+          ...toolIdentity,
+          call: {
+            type: "tool-call",
+            id: "call-read-directory",
+            name: "read",
+            input: { path: "src", offset: 2, limit: 10 },
+          },
+        })
+      expect(result).toMatchObject({ status: "completed", output: { entries: listResult.entries, truncated: true, next: 4 } })
       if (result.status !== "completed") return
-      expect(result.metadata).toEqual({ truncated: true })
       expect(result.content).toEqual([
         {
           type: "text",
@@ -706,15 +739,14 @@ describe("ReadTool", () => {
         },
       ])
       expect(assertions).toMatchObject([{ sessionID, action: "read", resources: ["src"], save: ["*"] }])
-      expect(readCalls).toEqual([
-        { input: AbsolutePath.make(path.join(process.cwd(), "src")), page: { offset: 2, limit: 10 } },
-      ])
+      expect(listCalls).toEqual([{ offset: 2, limit: 10 }])
     }),
   )
 
   it.effect("does not list a directory when permission is denied", () =>
     Effect.gen(function* () {
       allow = false
+      resolvedType = "directory"
       const registry = yield* Tool.Service
 
       expect(
@@ -724,7 +756,7 @@ describe("ReadTool", () => {
           call: { type: "tool-call", id: "call-read-directory-denied", name: "read", input: { path: "src" } },
         }),
       ).toEqual({ status: "error", error: { type: "permission.rejected", message: "Permission denied: read" } })
-      expect(readCalls).toEqual([])
+      expect(listCalls).toEqual([])
     }),
   )
 
@@ -743,12 +775,7 @@ describe("ReadTool", () => {
         ),
       ).toBe(true)
 
-      expect(readCalls).toEqual([
-        {
-          input: AbsolutePath.make(path.join(process.cwd(), "missing.txt")),
-          page: { offset: undefined, limit: undefined },
-        },
-      ])
+      expect(readCalls).toEqual([])
     }),
   )
 
@@ -779,7 +806,6 @@ describe("ReadTool", () => {
         output: { type: "text-page", content: "hello", mime: "text/plain", offset: 2, truncated: true, next: 3 },
       })
       if (result.status !== "completed") return
-      expect(result.metadata).toEqual({ truncated: true })
       expect(result.content).toEqual([
         {
           type: "text",

packages/core/test/tool-search.test.ts

@@ -5,8 +5,8 @@ import { Effect, Layer } from "effect"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
 import { LayerNode } from "@opencode-ai/util/effect/layer-node"
-import { Environment } from "@opencode-ai/core/environment"
 import { FileSystem } from "@opencode-ai/core/filesystem"
+import { FSUtil } from "@opencode-ai/util/fs-util"
 import { Location } from "@opencode-ai/core/location"
 import { LocationMutation } from "@opencode-ai/core/location-mutation"
 import { Permission } from "@opencode-ai/core/permission"
@@ -24,12 +24,19 @@ import { executeTool, registerToolPlugin, toolIdentity } from "./lib/tool"
 const globToolNode = makeLocationNode({
   name: "test/glob-tool-plugin",
   layer: Layer.effectDiscard(registerToolPlugin(GlobTool.Plugin)),
-  deps: [Tool.node, Environment.node, Ripgrep.node, Location.node, LocationMutation.node, Permission.node],
+  deps: [
+    Tool.node,
+    FSUtil.node,
+    Ripgrep.node,
+    Location.node,
+    LocationMutation.node,
+    Permission.node,
+  ],
 })
 const grepToolNode = makeLocationNode({
   name: "test/grep-tool-plugin",
   layer: Layer.effectDiscard(registerToolPlugin(GrepTool.Plugin)),
-  deps: [Tool.node, Environment.node, Ripgrep.node, Location.node, LocationMutation.node, Permission.node],
+  deps: [Tool.node, FSUtil.node, Ripgrep.node, Location.node, LocationMutation.node, Permission.node],
 })
 const sessionID = Session.ID.make("ses_search_tool_test")
 
@@ -179,7 +186,9 @@ describe("search tools", () => {
       Effect.promise(() => tmpdir()),
       (tmp) =>
         Effect.promise(() => fs.writeFile(path.join(tmp.path, "file.txt"), "haystack\n")).pipe(
-          Effect.andThen(withTools(tmp.path, (registry) => executeTool(registry, call("grep", { pattern: "needle" })))),
+          Effect.andThen(
+            withTools(tmp.path, (registry) => executeTool(registry, call("grep", { pattern: "needle" }))),
+          ),
           Effect.tap((result) =>
             Effect.sync(() => {
               expect(result).toMatchObject({
@@ -288,7 +297,9 @@ describe("search tools", () => {
       (tmp) =>
         Effect.promise(() => fs.writeFile(path.join(tmp.path, "file.txt"), "content\n")).pipe(
           Effect.andThen(
-            withTools(tmp.path, (registry) => executeTool(registry, call("glob", { path: "file.txt", pattern: "*" }))),
+            withTools(tmp.path, (registry) =>
+              executeTool(registry, call("glob", { path: "file.txt", pattern: "*" })),
+            ),
           ),
           Effect.tap((result) =>
             Effect.sync(() => {
@@ -320,7 +331,9 @@ describe("search tools", () => {
             Effect.sync(() => {
               expect(result.status).toBe("completed")
               expect(assertions.map((input) => input.action)).toEqual(["external_directory", "glob"])
-              expect(assertions[0]?.resources).toEqual([path.join(outside.path, "*").replaceAll("\\", "/")])
+              expect(assertions[0]?.resources).toEqual([
+                path.join(outside.path, "*").replaceAll("\\", "/"),
+              ])
             }),
           ),
         )

packages/core/test/tool-shell.test.ts

@@ -30,7 +30,6 @@ import { PluginRuntime } from "@opencode-ai/core/plugin/runtime"
 import { Shell } from "@opencode-ai/core/shell"
 import { Shell as ShellSchema } from "@opencode-ai/schema/shell"
 import { ShellTool } from "@opencode-ai/core/tool/plugin/shell"
-import { ToolOutput } from "@opencode-ai/core/tool-output"
 import { Tool } from "@opencode-ai/core/tool"
 import { tmpdir } from "./fixture/tmpdir"
 import { testEffect } from "./lib/effect"
@@ -172,9 +171,6 @@ const overflowCommand = (bytes: number) =>
   isWindows
     ? `[Console]::Out.Write('output-start' + ('x' * ${bytes}) + 'output-end'); Start-Sleep -Milliseconds 100`
     : `printf output-start; head -c ${bytes} /dev/zero | tr '\\0' 'x'; printf output-end`
-const lineOverflowCommand = isWindows
-  ? "[Console]::Out.Write('one' + [Environment]::NewLine + 'two' + [Environment]::NewLine + 'three')"
-  : "printf 'one\\ntwo\\nthree'"
 const progressOverflowCommand = (bytes: number, release: string) =>
   isWindows
     ? `[Console]::Out.Write(('x' * ${bytes})); while (!(Test-Path -LiteralPath '${release}')) { Start-Sleep -Milliseconds 50 }`
@@ -481,7 +477,7 @@ describe("ShellTool", () => {
       Effect.promise(() => tmpdir()),
       (tmp) => {
         reset()
-        const bytes = ToolOutput.MAX_BYTES + 1024
+        const bytes = ShellTool.MAX_CAPTURE_BYTES + 1024
         return withSession(tmp.path, (registry) =>
           executeTool(registry, call({ command: overflowCommand(bytes) }, "call-overflow")),
         ).pipe(
@@ -505,34 +501,6 @@ describe("ShellTool", () => {
     { timeout: 15_000 },
   )
 
-  it.live("uses configured line limits", () =>
-    Effect.acquireUseRelease(
-      Effect.promise(() => tmpdir()),
-      (tmp) => {
-        reset()
-        return Effect.gen(function* () {
-          yield* Effect.promise(() =>
-            Bun.write(
-              path.join(tmp.path, "opencode.json"),
-              JSON.stringify({ tool_output: { max_lines: 2, max_bytes: 1_000 } }),
-            ),
-          )
-          const settled = yield* withSession(tmp.path, (registry) =>
-            executeTool(registry, call({ command: lineOverflowCommand }, "call-line-overflow")),
-          )
-          expect(settled.metadata).toMatchObject({ exit: 0, truncated: true })
-          const content = settled.content?.[0]
-          if (!content || content.type !== "text") throw new Error("Expected text content")
-          expect(content.text).not.toContain("one")
-          // Windows shells emit CRLF; the assertion targets line limits, not line endings.
-          expect(content.text.replaceAll("\r\n", "\n")).toStartWith("two\nthree")
-          expect(content.text).toContain("output truncated; full output saved to:")
-        })
-      },
-      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]().then(() => undefined)),
-    ),
-  )
-
   it.live(
     "reports the shell ID for a running command",
     () =>
@@ -547,7 +515,7 @@ describe("ShellTool", () => {
               const observed = yield* Deferred.make<string>()
               yield* executeTool(registry, {
                 ...call(
-                  { command: progressOverflowCommand(ToolOutput.MAX_BYTES + 1024, release) },
+                  { command: progressOverflowCommand(ShellTool.MAX_CAPTURE_BYTES + 1024, release) },
                   "call-progress",
                 ),
                 progress: (update) =>

packages/core/test/tool-write.test.ts

@@ -6,7 +6,7 @@ import { FileMutation } from "@opencode-ai/core/file-mutation"
 import { Formatter } from "@opencode-ai/core/formatter"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { LayerNode } from "@opencode-ai/util/effect/layer-node"
-import { Environment } from "@opencode-ai/core/environment"
+import { FSUtil } from "@opencode-ai/util/fs-util"
 import { Location } from "@opencode-ai/core/location"
 import { LocationMutation } from "@opencode-ai/core/location-mutation"
 import { Permission } from "@opencode-ai/core/permission"
@@ -23,7 +23,7 @@ import { toolIdentity, executeTool, registerToolPlugin, toolDefinitions } from "
 const writeToolNode = makeLocationNode({
   name: "test/write-tool-plugin",
   layer: Layer.effectDiscard(registerToolPlugin(WriteTool.Plugin)),
-  deps: [Tool.node, LocationMutation.node, FileMutation.node, Environment.node, Formatter.node, Permission.node],
+  deps: [Tool.node, LocationMutation.node, FileMutation.node, Formatter.node, FSUtil.node, Permission.node],
 })
 
 const sessionID = Session.ID.make("ses_write_tool_test")
@@ -68,20 +68,17 @@ const reset = () => {
   denyAction = undefined
 }
 
-const environment = Layer.effect(
-  Environment.Service,
+const filesystem = Layer.effect(
+  FSUtil.Service,
   Effect.gen(function* () {
-    const current = yield* Environment.Service
-    return Environment.Service.of({
-      ...current,
-      files: {
-        ...current.files,
-        write: (target, content) =>
-          Effect.sync(() => writes.push(target)).pipe(Effect.andThen(current.files.write(target, content))),
-      },
+    const fs = yield* FSUtil.Service
+    return FSUtil.Service.of({
+      ...fs,
+      writeWithDirs: (target, content, mode) =>
+        Effect.sync(() => writes.push(target)).pipe(Effect.andThen(fs.writeWithDirs(target, content, mode))),
     })
   }),
-).pipe(Layer.provide(LayerNode.compile(Environment.node)))
+).pipe(Layer.provide(LayerNode.compile(FSUtil.node)))
 
 const withTool = <A, E, R>(directory: string, body: (registry: Tool.Interface) => Effect.Effect<A, E, R>) => {
   const activeLocation = Layer.succeed(
@@ -93,9 +90,15 @@ const withTool = <A, E, R>(directory: string, body: (registry: Tool.Interface) =
   }).pipe(
     Effect.provide(
       AppNodeBuilder.build(
-        LayerNode.group([Tool.node, Tool.node, LocationMutation.node, FileMutation.node, writeToolNode]),
+        LayerNode.group([
+          Tool.node,
+          Tool.node,
+          LocationMutation.node,
+          FileMutation.node,
+          writeToolNode,
+        ]),
         [
-          [Environment.node, environment],
+          [FSUtil.node, filesystem],
           [Location.node, activeLocation],
           [Formatter.node, formatter],
           [Permission.node, permission],
@@ -227,10 +230,7 @@ describe("WriteTool", () => {
         const deduplicated = path.join(tmp.path, "deduplicated.txt")
         formatFile = (target) =>
           Effect.promise(async () => {
-            await fs.writeFile(
-              target,
-              `\uFEFF\uFEFF\uFEFF${(await fs.readFile(target, "utf8")).replace(/^\uFEFF+/, "")}`,
-            )
+            await fs.writeFile(target, `\uFEFF\uFEFF\uFEFF${(await fs.readFile(target, "utf8")).replace(/^\uFEFF+/, "")}`)
             return true
           })
         return Effect.promise(() =>
@@ -323,22 +323,24 @@ describe("WriteTool", () => {
         ).pipe(
           Effect.andThen((settled) =>
             Effect.gen(function* () {
-              const absoluteTarget = target
+              const canonicalTarget = path.join(yield* Effect.promise(() => fs.realpath(outside.path)), "external.txt")
               expect(assertions.map((input) => input.action)).toEqual(["external_directory", "edit"])
               expect(assertions[0]).toMatchObject({
-                resources: [path.join(outside.path, "*").replaceAll("\\", "/")],
+                resources: [
+                  path.join(yield* Effect.promise(() => fs.realpath(outside.path)), "*").replaceAll("\\", "/"),
+                ],
               })
-              expect(assertions[1]).toMatchObject({ resources: [absoluteTarget.replaceAll("\\", "/")], save: ["*"] })
+              expect(assertions[1]).toMatchObject({ resources: [canonicalTarget.replaceAll("\\", "/")], save: ["*"] })
               expect(settled).toMatchObject({
                 status: "completed",
                 output: {
-                  target: absoluteTarget,
-                  resource: absoluteTarget.replaceAll("\\", "/"),
+                  target: canonicalTarget,
+                  resource: canonicalTarget.replaceAll("\\", "/"),
                   existed: false,
                 },
               })
               expect(yield* Effect.promise(() => fs.readFile(target, "utf8"))).toBe("external")
-              expect(writes).toEqual([absoluteTarget])
+              expect(writes).toEqual([canonicalTarget])
             }),
           ),
         )
@@ -366,10 +368,12 @@ describe("WriteTool", () => {
           ),
           Effect.andThen(
             Effect.gen(function* () {
+              const canonicalRepo = yield* Effect.promise(() => fs.realpath(repo))
+              const canonicalNested = yield* Effect.promise(() => fs.realpath(nested))
               expect(assertions[0]).toMatchObject({
                 action: "external_directory",
-                resources: [path.join(nested, "*").replaceAll("\\", "/")],
-                save: [path.join(repo, "*").replaceAll("\\", "/")],
+                resources: [path.join(canonicalNested, "*").replaceAll("\\", "/")],
+                save: [path.join(canonicalRepo, "*").replaceAll("\\", "/")],
               })
             }),
           ),

packages/protocol/src/groups/session.ts

@@ -522,45 +522,6 @@ export const makeSessionGroup = <I extends HttpApiMiddleware.AnyId, S>(sessionLo
           }),
         ),
     )
-    .add(
-      HttpApiEndpoint.delete("session.pending.cancel", "/api/session/:sessionID/pending/:inputID", {
-        params: { sessionID: Session.ID, inputID: SessionMessage.ID },
-        success: HttpApiSchema.NoContent,
-        error: [ConflictError, SessionNotFoundError],
-      }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "v2.session.pending.cancel",
-            summary: "Cancel pending input",
-            description: "Cancel an input that has not yet been promoted into session history.",
-          }),
-        ),
-    )
-    .add(
-      HttpApiEndpoint.post("session.pending.steer", "/api/session/:sessionID/pending/:inputID/steer", {
-        params: { sessionID: Session.ID, inputID: SessionMessage.ID },
-        success: HttpApiSchema.NoContent,
-        error: [ConflictError, SessionNotFoundError],
-      }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "v2.session.pending.steer",
-            summary: "Steer queued input",
-            description: "Change a queued input to steer delivery and wake session execution.",
-          }),
-        ),
-    )
-    .add(
-      HttpApiEndpoint.post("session.pending.queue", "/api/session/:sessionID/pending/:inputID/queue", {
-        params: { sessionID: Session.ID, inputID: SessionMessage.ID },
-        success: HttpApiSchema.NoContent,
-        error: [ConflictError, SessionNotFoundError],
-      }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "v2.session.pending.queue",
-            summary: "Queue pending steer",
-            description: "Change a pending steer to queued delivery.",
-          }),
-        ),
-    )
     .add(
       HttpApiEndpoint.get("session.instructions.entry.list", "/api/session/:sessionID/instructions/entries", {
         params: { sessionID: Session.ID },

packages/schema/src/agent.ts

@@ -41,7 +41,7 @@ export const Info = Schema.Struct({
           id,
           name: Name.make(id),
           request: { settings: {}, headers: {}, body: {} },
-          mode: "primary",
+          mode: "all",
           hidden: false,
           permissions: [
             { action: "*", resource: "*", effect: "allow" },

packages/schema/src/session-event.ts

@@ -152,15 +152,13 @@ export const Forked = Event.durable({
 })
 export type Forked = typeof Forked.Type
 
-const InputRef = {
-  ...Base,
-  inputID: SessionMessage.ID,
-}
-
 export const InputPromoted = Event.durable({
   type: "session.input.promoted",
   ...options,
-  schema: InputRef,
+  schema: {
+    sessionID: SessionID,
+    inputID: SessionMessage.ID,
+  },
 })
 export type InputPromoted = typeof InputPromoted.Type
 
@@ -168,33 +166,13 @@ export const InputAdmitted = Event.durable({
   type: "session.input.admitted",
   ...options,
   schema: {
-    ...InputRef,
+    ...Base,
+    inputID: SessionMessage.ID,
     input: SessionPending.Message,
   },
 })
 export type InputAdmitted = typeof InputAdmitted.Type
 
-export const InputCancelled = Event.durable({
-  type: "session.input.cancelled",
-  ...options,
-  schema: InputRef,
-})
-export type InputCancelled = typeof InputCancelled.Type
-
-export const InputSteered = Event.durable({
-  type: "session.input.steered",
-  ...options,
-  schema: InputRef,
-})
-export type InputSteered = typeof InputSteered.Type
-
-export const InputQueued = Event.durable({
-  type: "session.input.queued",
-  ...options,
-  schema: InputRef,
-})
-export type InputQueued = typeof InputQueued.Type
-
 export namespace Execution {
   export const Started = Event.durable({ type: "session.execution.started", ...options, schema: Base })
   export type Started = typeof Started.Type
@@ -602,9 +580,6 @@ export const Definitions = Event.inventory(
   Forked,
   InputPromoted,
   InputAdmitted,
-  InputCancelled,
-  InputSteered,
-  InputQueued,
   Execution.Started,
   Execution.Succeeded,
   Execution.Failed,
@@ -646,16 +621,13 @@ export const DurableDefinitions = Event.inventory(
   ...Definitions.filter((definition) => definition.durability === "durable"),
   UsageRecorded,
 )
-export const EphemeralDefinitions = Event.inventory(
-  ...Definitions.filter((definition) => definition.durability === "ephemeral"),
-)
 
 export const Durable = Schema.Union(DurableDefinitions, { mode: "oneOf" })
   .pipe(Schema.toTaggedUnion("type"))
   .annotate({ identifier: "Session.Event.Durable" })
 export type DurableEvent = typeof Durable.Type
 
-export const All = Schema.Union([Durable, ...EphemeralDefinitions], { mode: "oneOf" }).pipe(
+export const All = Schema.Union(Event.inventory(...Definitions, UsageRecorded), { mode: "oneOf" }).pipe(
   Schema.toTaggedUnion("type"),
 )
 export type Event = typeof All.Type

packages/schema/test/event-manifest.test.ts

@@ -84,9 +84,6 @@ describe("public event manifest", () => {
         "session.forked.2",
         "session.input.promoted.1",
         "session.input.admitted.1",
-        "session.input.cancelled.1",
-        "session.input.steered.1",
-        "session.input.queued.1",
         "session.execution.started.1",
         "session.execution.succeeded.1",
         "session.execution.failed.1",

packages/server/src/handlers/session.ts

@@ -26,22 +26,6 @@ export const SessionHandler = HttpApiBuilder.group(Api, "server.session", (handl
   Effect.gen(function* () {
     const session = yield* Session.Service
     const transfer = yield* SessionTransfer.Service
-    const pendingMutation = (effect: ReturnType<typeof session.cancelPending>, conflict: string) =>
-      effect.pipe(
-        Effect.catchTag(
-          "Session.NotFoundError",
-          (error) =>
-            new SessionNotFoundError({
-              sessionID: error.sessionID,
-              message: `Session not found: ${error.sessionID}`,
-            }),
-        ),
-        Effect.catchTag(
-          "Session.PendingInputConflictError",
-          (error) => new ConflictError({ resource: error.inputID, message: `${conflict}: ${error.inputID}` }),
-        ),
-        Effect.as(HttpApiSchema.NoContent.make()),
-      )
 
     return handlers
       .handle(
@@ -677,33 +661,6 @@ export const SessionHandler = HttpApiBuilder.group(Api, "server.session", (handl
           }
         }),
       )
-      .handle(
-        "session.pending.cancel",
-        Effect.fn(function* (ctx) {
-          return yield* pendingMutation(
-            session.cancelPending({ sessionID: ctx.params.sessionID, inputID: ctx.params.inputID }),
-            "Pending input can no longer be cancelled",
-          )
-        }),
-      )
-      .handle(
-        "session.pending.steer",
-        Effect.fn(function* (ctx) {
-          return yield* pendingMutation(
-            session.steerPending({ sessionID: ctx.params.sessionID, inputID: ctx.params.inputID }),
-            "Pending input is no longer queued",
-          )
-        }),
-      )
-      .handle(
-        "session.pending.queue",
-        Effect.fn(function* (ctx) {
-          return yield* pendingMutation(
-            session.queuePending({ sessionID: ctx.params.sessionID, inputID: ctx.params.inputID }),
-            "Pending input is no longer a steer",
-          )
-        }),
-      )
       .handle(
         "session.instructions.entry.list",
         Effect.fn(function* (ctx) {

packages/session-ui/src/components/message-part.tsx

@@ -462,7 +462,6 @@ function newLayout() {
 function webSearchProviderLabel(provider: unknown) {
   if (provider === "parallel") return "Parallel Web Search"
   if (provider === "exa") return "Exa Web Search"
-  if (provider === "firecrawl") return "Firecrawl Web Search"
   return "Web Search"
 }
 

packages/tui/src/app.tsx

@@ -512,7 +512,7 @@ function App(props: { pair?: DialogPairCredentials }) {
   const terminalTitleEnabled = () => config.data.terminal?.title ?? true
   const copyOnSelectEnabled = () => config.data.terminal?.copy_on_select ?? process.platform !== "win32"
   const pasteSummaryEnabled = () => config.data.prompt?.paste !== "full"
-  const tabsVertical = () => config.data.tabs.layout === "vertical" && sessionTabsFitVertically(dimensions().width)
+  const tabsVertical = () => (config.data.tabs?.vertical ?? false) && sessionTabsFitVertically(dimensions().width)
   const tabsVisible = () =>
     sessionTabs.enabled() && (sessionTabs.tabs().length > 0 || sessionTabs.newTab()) && route.data.type !== "plugin"
 

packages/tui/src/component/dialog-config.tsx

@@ -101,11 +101,12 @@ export const settings: Setting[] = [
     labels: ["current directory", "global"],
   },
   {
-    title: "Layout",
+    title: "Vertical",
     category: "Tabs",
-    path: ["tabs", "layout"],
-    default: "horizontal",
-    values: ["horizontal", "vertical"],
+    path: ["tabs", "vertical"],
+    default: false,
+    values: [false, true],
+    labels: ["off", "on"],
     keywords: ["sidebar", "orientation", "left"],
   },
   {

packages/tui/src/component/dialog-model.tsx

@@ -8,21 +8,17 @@ import * as fuzzysort from "fuzzysort"
 import { useConnected } from "./use-connected"
 import { useData } from "../context/data"
 import { modelPreferenceKey } from "../model-preference"
-import { useLocation } from "../context/location"
 
 export function DialogModel(props: { providerID?: string }) {
   const local = useLocal()
   const data = useData()
   const dialog = useDialog()
-  const location = useLocation()
   const [query, setQuery] = createSignal("")
   const favoritePriority = new Set(local.model.favorite().map(modelPreferenceKey))
 
   const connected = useConnected()
-  const providers = createMemo(
-    () => new Map((data.location.provider.list(location.ref) ?? []).map((item) => [item.id, item])),
-  )
-  const models = createMemo(() => data.location.model.list(location.ref) ?? [])
+  const providers = createMemo(() => new Map((data.location.provider.list() ?? []).map((item) => [item.id, item])))
+  const models = createMemo(() => data.location.model.list() ?? [])
 
   const showExtra = createMemo(() => connected() && !props.providerID)
 

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

@@ -53,14 +53,12 @@ import { useLocation } from "../../context/location"
 import { Keymap, type KeymapCommand } from "../../context/keymap"
 import { abbreviateHome } from "../../runtime"
 import { PluginSlot } from "../../plugin/render"
-import type { SessionPending } from "@opencode-ai/schema/session-pending"
 
 export type PromptProps = {
   sessionID?: string
   visible?: boolean
   disabled?: boolean
   onSubmit?: () => void
-  onEmptySubmit?: () => boolean | Promise<boolean>
   ref?: (ref: PromptRef | undefined) => void
   hint?: JSX.Element
   right?: JSX.Element
@@ -329,6 +327,10 @@ export function Prompt(props: PromptProps) {
     if (!session) return
     const agent = session.agent && local.agent.list().find((agent) => agent.id === session.agent)
     if (agent && !args.agent) local.agent.set(agent.id)
+    if (session.model) {
+      local.model.set({ providerID: session.model.providerID, modelID: session.model.id })
+      local.model.variant.set(session.model.variant)
+    }
     syncedSessionID = sessionID
   })
 
@@ -359,20 +361,6 @@ export function Prompt(props: PromptProps) {
           dialog.clear()
         },
       },
-      {
-        title: "Queue prompt",
-        name: "prompt.queue",
-        category: "Prompt",
-        palette: undefined,
-        run: async (_input: string | undefined, event?: KeyEvent) => {
-          event?.preventDefault()
-          event?.stopPropagation()
-          if (!input.focused) return
-          const handled = await submit("queue")
-          if (!handled) return
-          dialog.clear()
-        },
-      },
       {
         title: "Remove editor context",
         name: "prompt.editor_context.clear",
@@ -531,11 +519,6 @@ export function Prompt(props: PromptProps) {
     commands: promptCommands(),
   }))
 
-  Keymap.createLayer(() => ({
-    priority: 1,
-    bindings: ["prompt.queue"],
-  }))
-
   Keymap.createLayer(() => ({
     bindings: [
       "prompt.submit",
@@ -921,7 +904,7 @@ export function Prompt(props: PromptProps) {
   })
 
   let submitting = false
-  async function submit(delivery: SessionPending.Delivery = "steer") {
+  async function submit() {
     // Prevent overlapping invocations (e.g. a double-pressed Enter, or the
     // input's native onSubmit racing another dispatch). Without this guard,
     // a second call slips past the empty-input check before the first call
@@ -931,13 +914,13 @@ export function Prompt(props: PromptProps) {
     if (submitting) return false
     submitting = true
     try {
-      return await submitInner(delivery)
+      return await submitInner()
     } finally {
       submitting = false
     }
   }
 
-  async function submitInner(delivery: SessionPending.Delivery) {
+  async function submitInner() {
     // IME: double-defer may fire before onContentChange flushes the last
     // composed character (e.g. Korean hangul) to the store, so read
     // plainText directly and sync before any downstream reads.
@@ -948,76 +931,27 @@ export function Prompt(props: PromptProps) {
     if (props.disabled) return false
     if (move.creating()) return false
     if (auto()?.visible) return false
+    if (!store.prompt.text) return false
     const trimmed = store.prompt.text.trim()
-    if (!trimmed) return delivery === "steer" ? (await props.onEmptySubmit?.()) === true : false
-    if (
-      delivery === "queue" &&
-      (store.mode === "shell" || trimmed === "exit" || trimmed === "quit" || trimmed === ":q")
-    ) {
-      toast.show({ message: "This prompt cannot be queued", variant: "warning" })
-      return false
-    }
     if (trimmed === "exit" || trimmed === "quit" || trimmed === ":q") {
       void exit()
       return true
     }
     const slash = argumentSlash(store.prompt.text, keymapCommands())
     if (slash) {
-      if (delivery === "queue") {
-        toast.show({ message: "This prompt cannot be queued", variant: "warning" })
-        return false
-      }
       clearPrompt()
       await slash.command.run(slash.input)
       return true
     }
-    const inputText = expandTrackedPastedText(
-      store.prompt.text,
-      input.extmarks.getAllForTypeId(promptPartTypeId).flatMap((extmark) => {
-        const ref = store.extmarkToPart.get(extmark.id)
-        if (ref?.type !== "pasted") return []
-        const part = store.prompt.pasted[ref.index]
-        if (!part) return []
-        return [{ start: extmark.start, end: extmark.end, text: part.text }]
-      }),
-    )
-    const slashHead = parseSlashHead(inputText, /\s/)
-    const isSkill =
-      slashHead !== undefined &&
-      (data.location.skill.list(currentLocation.ref) ?? []).some(
-        (skill) => skill.slash === true && skill.id === slashHead.name,
-      )
-    const isCommand =
-      slashHead !== undefined &&
-      (data.location.command.list(currentLocation.ref) ?? []).some((command) => command.name === slashHead.name)
-    if (delivery === "queue" && isSkill) {
-      toast.show({ message: "Skills cannot be queued", variant: "warning" })
-      return false
-    }
-    const editorSelection = editorContext()
-    const pendingEditorSelection = editorSelection && editor.labelState() === "pending" ? editorSelection : undefined
-    if (delivery === "queue" && pendingEditorSelection) {
-      toast.show({ message: "Editor context cannot be queued", variant: "warning" })
-      return false
-    }
     const agent = local.agent.current()
     if (!agent) return false
-    const selection = local.model.selection()
-    if (!selection) {
+    const selectedModel = local.model.current()
+    if (!selectedModel) {
       void promptModelWarning()
       return false
     }
-    const usesModel = !props.sessionID || (store.mode !== "shell" && !isSkill)
-    if (usesModel && !local.model.available(selection)) {
-      toast.show({
-        title: "Model unavailable",
-        message: `${selection.providerID}/${selection.modelID} is not available in this session's location`,
-        variant: "warning",
-      })
-      return false
-    }
 
-    const variant = selection.variant
+    const variant = local.model.variant.current()
     let sessionID = props.sessionID
     let session = sessionID ? data.session.get(sessionID) : undefined
     let finishMoveProgress = false
@@ -1035,8 +969,8 @@ export function Prompt(props: PromptProps) {
           location: directory ? { directory } : location,
           agent: agent.id,
           model: {
-            providerID: selection.providerID,
-            id: selection.modelID,
+            providerID: selectedModel.providerID,
+            id: selectedModel.modelID,
             variant,
           },
         })
@@ -1056,8 +990,21 @@ export function Prompt(props: PromptProps) {
       session = created
     }
 
+    const inputText = expandTrackedPastedText(
+      store.prompt.text,
+      input.extmarks.getAllForTypeId(promptPartTypeId).flatMap((extmark) => {
+        const ref = store.extmarkToPart.get(extmark.id)
+        if (ref?.type !== "pasted") return []
+        const part = store.prompt.pasted[ref.index]
+        if (!part) return []
+        return [{ start: extmark.start, end: extmark.end, text: part.text }]
+      }),
+    )
+
     // Capture mode before it gets reset
     const currentMode = store.mode
+    const editorSelection = editorContext()
+    const pendingEditorSelection = editorSelection && editor.labelState() === "pending" ? editorSelection : undefined
 
     if (store.mode === "shell") {
       move.startSubmit()
@@ -1066,31 +1013,43 @@ export function Prompt(props: PromptProps) {
         command: inputText,
       })
       setStore("mode", "normal")
-    } else if (slashHead && isCommand) {
+    } else if (
+      inputText.startsWith("/") &&
+      (data.location.command.list(currentLocation.current) ?? []).some(
+        (command) => command.name === inputText.split("\n")[0].split(" ")[0].slice(1),
+      )
+    ) {
       move.startSubmit()
-      const model = { providerID: selection.providerID, id: selection.modelID, variant }
-      const cancelCommit = local.model.trackSessionCommit(sessionID, model)
+      // Parse command from first line, preserve multi-line content in arguments
+      const firstLineEnd = inputText.indexOf("\n")
+      const firstLine = firstLineEnd === -1 ? inputText : inputText.slice(0, firstLineEnd)
+      const [command, ...firstLineArgs] = firstLine.split(" ")
+      const restOfInput = firstLineEnd === -1 ? "" : inputText.slice(firstLineEnd + 1)
+      const args = firstLineArgs.join(" ") + (restOfInput ? "\n" + restOfInput : "")
 
       void client.api.session
         .command({
           sessionID,
-          command: slashHead.name,
-          arguments: slashHead.arguments,
+          command: command.slice(1),
+          arguments: args,
           agent: agent.id,
-          model,
+          model: { providerID: selectedModel.providerID, id: selectedModel.modelID, variant },
           files: store.prompt.files,
           agents: store.prompt.agents,
-          delivery,
         })
         .catch((error) => {
-          cancelCommit()
           toast.show({ title: "Failed to run command", message: errorMessage(error), variant: "error" })
         })
-    } else if (isSkill) {
+    } else if (
+      inputText.startsWith("/") &&
+      (data.location.skill.list(currentLocation.current) ?? []).some(
+        (skill) => skill.slash === true && skill.id === inputText.split("\n")[0].split(" ")[0].slice(1),
+      )
+    ) {
       move.startSubmit()
       void client.api.session.skill({
         sessionID,
-        skill: slashHead.name,
+        skill: inputText.split("\n")[0].split(" ")[0].slice(1),
       })
     } else {
       move.startSubmit()
@@ -1102,15 +1061,13 @@ export function Prompt(props: PromptProps) {
         await client.api.session.switchAgent({ sessionID, agent: agent.id })
       }
       if (
-        session?.model?.providerID !== selection.providerID ||
-        session.model.id !== selection.modelID ||
+        session?.model?.providerID !== selectedModel.providerID ||
+        session.model.id !== selectedModel.modelID ||
         (session.model.variant ?? "default") !== (variant ?? "default")
       ) {
-        const model = { providerID: selection.providerID, id: selection.modelID, variant }
-        const cancelCommit = local.model.trackSessionCommit(sessionID, model)
-        await client.api.session.switchModel({ sessionID, model }).catch((error) => {
-          cancelCommit()
-          throw error
+        await client.api.session.switchModel({
+          sessionID,
+          model: { providerID: selectedModel.providerID, id: selectedModel.modelID, variant },
         })
       }
       if (session?.revert) {
@@ -1146,7 +1103,6 @@ export function Prompt(props: PromptProps) {
           text: inputText,
           files: store.prompt.files,
           agents: store.prompt.agents,
-          delivery,
         })
         .then(
           () => undefined,
@@ -1364,7 +1320,10 @@ export function Prompt(props: PromptProps) {
       return `Ask anything... "${list()[store.placeholder % list().length]}"`
     })()
     if (!value) return undefined
-    const width = dimensions().width < 44 ? dimensions().width - 5 : Math.min(75, dimensions().width - 4) - 5
+    const width =
+      dimensions().width < 44
+        ? dimensions().width - 5
+        : Math.min(75, dimensions().width - 4) - 5
     return Locale.takeWidth(value, Math.max(1, width)).trimEnd()
   })
   const locationLabel = createMemo(() => {

packages/tui/src/config/index.tsx

@@ -132,8 +132,8 @@ export const Info = Schema.Struct({
       scope: Schema.optional(Schema.Literals(["global", "cwd"])).annotate({
         description: "Share tabs globally or keep a separate set for each working directory",
       }),
-      layout: Schema.optional(Schema.Literals(["horizontal", "vertical"])).annotate({
-        description: "Show tabs in a horizontal strip or vertical sidebar",
+      vertical: Schema.optional(Schema.Boolean).annotate({
+        description: "Show tabs in a left sidebar instead of a horizontal strip",
       }),
     }),
   ).annotate({ description: "Tab strip settings" }),
@@ -194,7 +194,7 @@ export type Resolved = Omit<Info, "attention" | "keybinds" | "leader" | "mouse"
   tabs: {
     enabled: boolean
     scope: "global" | "cwd"
-    layout: "horizontal" | "vertical"
+    vertical?: boolean
   }
 }
 
@@ -230,7 +230,6 @@ export function resolve(input: Info, options: { terminalSuspend: boolean }): Res
       ...input.tabs,
       enabled: input.tabs?.enabled ?? true,
       scope: input.tabs?.scope ?? "cwd",
-      layout: input.tabs?.layout ?? "horizontal",
     },
   }
 }

packages/tui/src/config/v1/keybind.ts

@@ -103,8 +103,7 @@ export const Definitions = {
   session_interrupt: keybind("escape", "Interrupt current session"),
   session_background: keybind("ctrl+b", "Background blocking session tools"),
   session_compact: keybind("<leader>c", "Compact the session"),
-  session_queued_prompts: keybind("<leader>q", "View queued prompts"),
-  queued_prompt_delete: keybind("ctrl+d", "Delete queued prompt"),
+  session_queued_prompts: keybind("<leader>q", "View pending work"),
   session_child_first: keybind("down", "Toggle subagent picker"),
   session_parent: keybind("up", "Go to parent session"),
   session_pin_toggle: keybind("ctrl+f", "Pin or unpin session in the session list"),
@@ -162,7 +161,6 @@ export const Definitions = {
   display_thinking: keybind("none", "Toggle thinking blocks visibility"),
 
   prompt_submit: keybind("none", "Submit prompt"),
-  prompt_queue: keybind("alt+return", "Queue prompt"),
   prompt_editor_context_clear: keybind("none", "Clear editor context"),
   prompt_skills: keybind("none", "Open skill selector"),
   prompt_stash: keybind("none", "Stash prompt"),
@@ -172,7 +170,7 @@ export const Definitions = {
   input_clear: keybind("ctrl+c", "Clear input field"),
   input_paste: keybind({ key: "ctrl+v", preventDefault: false }, "Paste from clipboard"),
   input_submit: keybind("return", "Submit input"),
-  input_newline: keybind("shift+return,ctrl+return,ctrl+j", "Insert newline in input"),
+  input_newline: keybind("shift+return,ctrl+return,alt+return,ctrl+j", "Insert newline in input"),
   input_move_left: keybind("left,ctrl+b", "Move cursor left in input"),
   input_move_right: keybind("right,ctrl+f", "Move cursor right in input"),
   input_move_up: keybind("up", "Move cursor up in input"),
@@ -307,7 +305,6 @@ export const CommandMap = {
   session_background: "session.background",
   session_compact: "session.compact",
   session_queued_prompts: "session.queued_prompts",
-  queued_prompt_delete: "queued_prompt.delete",
   session_child_first: "session.child.first",
   session_parent: "session.parent",
   session_pin_toggle: "session.pin.toggle",
@@ -362,7 +359,6 @@ export const CommandMap = {
   messages_redo: "session.redo",
   display_thinking: "session.toggle.thinking",
   prompt_submit: "prompt.submit",
-  prompt_queue: "prompt.queue",
   prompt_editor_context_clear: "prompt.editor_context.clear",
   prompt_skills: "prompt.skills",
   prompt_stash: "prompt.stash",

packages/tui/src/context/data.tsx

@@ -15,7 +15,6 @@ import type {
   ModelInfo,
   PermissionSavedInfo,
   PermissionRequest,
-  PermissionReplyInput,
   Project,
   ProviderInfo,
   ReferenceInfo,
@@ -32,13 +31,11 @@ import type {
   OpenCodeEvent,
   WebSearchProvider,
 } from "@opencode-ai/client"
-import { isPermissionNotFoundError } from "@opencode-ai/client"
 import type { Plugin } from "@opencode-ai/plugin/tui"
 import { createStore, produce, reconcile } from "solid-js/store"
 import { createSimpleContext } from "./helper"
 import { useClient } from "./client"
 import { nonEmptyToolContent } from "../util/tool-display"
-import type { SessionPending } from "@opencode-ai/schema/session-pending"
 import { createEffect, createSignal, onCleanup } from "solid-js"
 
 export type DataSessionStatus = "idle" | "running"
@@ -171,40 +168,14 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
 
     function removePending(sessionID: string, inputID?: string) {
       if (!inputID) return
-      if (store.session.pending[sessionID]?.some((item) => item.id === inputID))
-        setStore(
-          "session",
-          "pending",
-          sessionID,
-          (store.session.pending[sessionID] ?? []).filter((item) => item.id !== inputID),
-        )
-      if (store.session.input[sessionID]?.includes(inputID))
-        setStore(
-          "session",
-          "input",
-          sessionID,
-          (store.session.input[sessionID] ?? []).filter((id) => id !== inputID),
-        )
-    }
-
-    function removePermission(sessionID: string, requestID: string) {
-      const requests = store.session.permission[sessionID]
-      if (!requests?.some((request) => request.id === requestID)) return
       setStore(
         "session",
-        "permission",
+        "pending",
         sessionID,
-        requests.filter((request) => request.id !== requestID),
+        (store.session.pending[sessionID] ?? []).filter((item) => item.id !== inputID),
       )
     }
 
-    function updatePending(sessionID: string, inputID: string, delivery: SessionPending.Delivery) {
-      const index = store.session.pending[sessionID]?.findIndex((item) => item.id === inputID) ?? -1
-      const item = store.session.pending[sessionID]?.[index]
-      if (index < 0 || !item || item.type === "compaction" || item.delivery === delivery) return
-      setStore("session", "pending", sessionID, index, { ...item, delivery })
-    }
-
     const message = {
       update(sessionID: string, fn: (messages: SessionMessageInfo[], index: Map<string, number>) => void) {
         setStore(
@@ -251,12 +222,6 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
           (item): item is SessionMessageAssistantReasoning => item.type === "reasoning" && !item.time?.completed,
         )
       },
-      reindex(messages: SessionMessageInfo[], index: Map<string, number>, start: number) {
-        for (let position = start; position < messages.length; position++) {
-          const item = messages[position]
-          if (item) index.set(item.id, position)
-        }
-      },
     }
 
     function index(sessionID: string) {
@@ -438,36 +403,24 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
           }
           break
         case "session.input.promoted": {
-          const admitted = store.session.input[event.data.sessionID]?.includes(event.data.inputID) ?? false
           removePending(event.data.sessionID, event.data.inputID)
           message.update(event.data.sessionID, (draft, index) => {
             const position = index.get(event.data.inputID)
             if (position === undefined) return
             const existing = draft[position]
-            if (!existing || !admitted) return
+            if (!existing || !store.session.input[event.data.sessionID]?.includes(event.data.inputID)) return
             existing.time.created = event.created
             draft.splice(position, 1)
             draft.push(existing)
-            message.reindex(draft, index, position)
+            index.clear()
+            draft.forEach((message, indexValue) => index.set(message.id, indexValue))
           })
-          break
-        }
-        case "session.input.steered":
-          updatePending(event.data.sessionID, event.data.inputID, "steer")
-          break
-        case "session.input.queued":
-          updatePending(event.data.sessionID, event.data.inputID, "queue")
-          break
-        case "session.input.cancelled": {
-          removePending(event.data.sessionID, event.data.inputID)
-          if (messageIndex.get(event.data.sessionID)?.has(event.data.inputID))
-            message.update(event.data.sessionID, (draft, index) => {
-              const position = index.get(event.data.inputID)
-              if (position === undefined) return
-              draft.splice(position, 1)
-              index.delete(event.data.inputID)
-              message.reindex(draft, index, position)
-            })
+          setStore(
+            "session",
+            "input",
+            event.data.sessionID,
+            (store.session.input[event.data.sessionID] ?? []).filter((id) => id !== event.data.inputID),
+          )
           break
         }
         case "session.input.admitted":
@@ -887,7 +840,14 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
           ])
           break
         case "permission.replied":
-          removePermission(event.data.sessionID, event.data.requestID)
+          setStore(
+            "session",
+            "permission",
+            event.data.sessionID,
+            (store.session.permission[event.data.sessionID] ?? []).filter(
+              (request) => request.id !== event.data.requestID,
+            ),
+          )
           break
         case "form.created":
           if (store.session.form[event.data.form.sessionID]?.some((form) => form.id === event.data.form.id)) break
@@ -1076,12 +1036,6 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
           invalidate(sessionID: string) {
             sync.invalidate(`session.permission:${sessionID}`)
           },
-          async reply(input: PermissionReplyInput) {
-            await client.api.permission.reply(input).catch((error: unknown) => {
-              if (!isPermissionNotFoundError(error)) throw error
-            })
-            removePermission(input.sessionID, input.requestID)
-          },
         },
         form: {
           list(sessionID: string, ref?: LocationRef) {

packages/tui/src/context/local.tsx

@@ -1,7 +1,7 @@
 import { createStore } from "solid-js/store"
 import { dedupeWith } from "effect/Array"
 import { createSimpleContext } from "./helper"
-import { batch, createMemo, onCleanup } from "solid-js"
+import { batch, createMemo } from "solid-js"
 import { useEvent } from "./event"
 import path from "path"
 import { useTuiPaths } from "./runtime"
@@ -22,7 +22,6 @@ import { useToast } from "../ui/toast"
 import { useRoute } from "./route"
 import { useData } from "./data"
 import { usePermission } from "./permission"
-import { useLocation } from "./location"
 
 export function parseModel(model: string) {
   const [providerID, ...rest] = model.split("/")
@@ -58,29 +57,26 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
     const args = useArgs()
     const event = useEvent()
     const permission = usePermission()
-    const location = useLocation()
-
-    const models = () => data.location.model.list(location.ref)
-    const providers = () => data.location.provider.list(location.ref)
 
     function isModelValid(model: ModelPreferenceModel) {
-      return !!models()?.some((item) => item.providerID === model.providerID && item.id === model.modelID)
+      return !!data.location.model
+        .list()
+        ?.some((item) => item.providerID === model.providerID && item.id === model.modelID)
     }
 
     function getFirstValidModel(...modelFns: (() => ModelPreferenceModel | undefined)[]) {
       for (const modelFn of modelFns) {
         const model = modelFn()
-        if (model && isModelValid(model)) return model
+        if (!model) continue
+        if (isModelValid(model)) return model
       }
     }
 
     function createAgent() {
       const agents = createMemo(() =>
-        (data.location.agent.list(location.ref) ?? []).filter((agent) => agent.mode !== "subagent" && !agent.hidden),
-      )
-      const visibleAgents = createMemo(() =>
-        (data.location.agent.list(location.ref) ?? []).filter((agent) => !agent.hidden),
+        (data.location.agent.list() ?? []).filter((agent) => agent.mode !== "subagent" && !agent.hidden),
       )
+      const visibleAgents = createMemo(() => (data.location.agent.list() ?? []).filter((agent) => !agent.hidden))
       const [agentStore, setAgentStore] = createStore({
         current: undefined as string | undefined,
       })
@@ -132,40 +128,35 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
     const agent = createAgent()
 
     function createModel() {
-      type ModelSelection = ModelPreferenceModel & { variant?: string }
-      const [preferences, setPreferences] = createStore<ModelPreference & { ready: boolean }>({
+      const [modelStore, setModelStore] = createStore<
+        ModelPreference & {
+          ready: boolean
+          model: Record<string, ModelPreferenceModel>
+        }
+      >({
         ready: false,
+        model: {},
         recent: [],
         favorite: [],
         variant: {},
       })
-      const [selectionState, setSelectionState] = createStore<{
-        newSessionModelByLocationAgent: Record<string, ModelPreferenceModel | undefined>
-        draftBySession: Record<string, ModelSelection | undefined>
-      }>({
-        newSessionModelByLocationAgent: {},
-        draftBySession: {},
-      })
 
       const repository = createModelPreferenceRepository(path.join(paths.state, "model.json"))
-      const pendingSelectionCommits = new Map<string, string>()
-      const selectionKey = (value: ModelSelection) =>
-        `${modelPreferenceKey(value)}:${normalizeModelVariant(value.variant) ?? "default"}`
-      const saveState = {
+      const state = {
         pending: false,
       }
 
-      function savePreferences() {
-        if (!preferences.ready) {
-          saveState.pending = true
+      function save() {
+        if (!modelStore.ready) {
+          state.pending = true
           return
         }
-        saveState.pending = false
+        state.pending = false
         void repository
           .patch({
-            recent: preferences.recent,
-            favorite: preferences.favorite,
-            variant: preferences.variant,
+            recent: modelStore.recent,
+            favorite: modelStore.favorite,
+            variant: modelStore.variant,
           })
           .catch(() => undefined)
       }
@@ -173,14 +164,14 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
       repository
         .load()
         .then((value) => {
-          setPreferences("recent", value.recent)
-          setPreferences("favorite", value.favorite)
-          setPreferences("variant", value.variant)
+          setModelStore("recent", value.recent)
+          setModelStore("favorite", value.favorite)
+          setModelStore("variant", value.variant)
         })
         .catch(() => {})
         .finally(() => {
-          setPreferences("ready", true)
-          if (saveState.pending) savePreferences()
+          setModelStore("ready", true)
+          if (state.pending) save()
         })
 
       const fallbackModel = createMemo(() => {
@@ -194,13 +185,13 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
           }
         }
 
-        for (const item of preferences.recent) {
+        for (const item of modelStore.recent) {
           if (isModelValid(item)) {
             return item
           }
         }
 
-        const model = models()?.[0]
+        const model = data.location.model.list()?.[0]
         if (!model) return undefined
         return {
           providerID: model.providerID,
@@ -208,134 +199,30 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
         }
       })
 
-      const newSessionModel = createMemo(() => {
-        const a = agent.current()
-        return getFirstValidModel(
-          () => a && selectionState.newSessionModelByLocationAgent[locationAgentKey(a.id)],
-          () => a?.model && { providerID: a.model.providerID, modelID: a.model.id },
-          fallbackModel,
-        )
-      })
-
-      const currentSelection = createMemo<ModelSelection | undefined>(() => {
-        if (route.data.type === "session") return sessionSelection(route.data.sessionID)
-        const model = newSessionModel()
-        if (!model) return
-        return { ...model, variant: normalizeModelVariant(preferences.variant[modelPreferenceKey(model)]) }
-      })
-
       const currentModel = createMemo(() => {
-        const selection = currentSelection()
-        if (!selection) return
-        return { providerID: selection.providerID, modelID: selection.modelID }
-      })
-
-      function locationAgentKey(agentID: string) {
-        const ref = location.ref ?? data.location.default()
-        return `${JSON.stringify([ref.directory, ref.workspaceID])}:${agentID}`
-      }
-
-      function durableSelection(sessionID: string): ModelSelection | undefined {
-        const model = data.session.get(sessionID)?.model
-        if (!model) return
-        return {
-          providerID: model.providerID,
-          modelID: model.id,
-          variant: normalizeModelVariant(model.variant),
-        }
-      }
-
-      function sessionSelection(sessionID: string) {
-        return selectionState.draftBySession[sessionID] ?? durableSelection(sessionID)
-      }
-
-      function setSessionDraft(sessionID: string, selection: ModelSelection) {
-        const durable = durableSelection(sessionID)
-        setSelectionState(
-          "draftBySession",
-          sessionID,
-          durable && selectionKey(durable) === selectionKey(selection) ? undefined : selection,
+        const a = agent.current()
+        return (
+          getFirstValidModel(
+            () => a && modelStore.model[a.id],
+            () => a?.model && { providerID: a.model.providerID, modelID: a.model.id },
+            fallbackModel,
+          ) ?? undefined
         )
-      }
-
-      function selectModel(model: ModelPreferenceModel) {
-        if (route.data.type === "session") {
-          const sessionID = route.data.sessionID
-          const current = sessionSelection(sessionID)
-          const preferred = normalizeModelVariant(
-            current?.providerID === model.providerID && current.modelID === model.modelID
-              ? current.variant
-              : preferences.variant[modelPreferenceKey(model)],
-          )
-          const info = models()?.find((item) => item.providerID === model.providerID && item.id === model.modelID)
-          const variant = preferred && info?.variants?.some((item) => item.id === preferred) ? preferred : undefined
-          setSessionDraft(sessionID, { ...model, variant })
-          return true
-        }
-        const current = agent.current()
-        if (!current) return false
-        setSelectionState("newSessionModelByLocationAgent", locationAgentKey(current.id), model)
-        return true
-      }
-
-      onCleanup(
-        event.on("session.model.selected", (evt) => {
-          const expected = pendingSelectionCommits.get(evt.data.sessionID)
-          if (!expected) return
-          const committed = selectionKey({
-            providerID: evt.data.model.providerID,
-            modelID: evt.data.model.id,
-            variant: evt.data.model.variant,
-          })
-          if (committed !== expected) return
-          pendingSelectionCommits.delete(evt.data.sessionID)
-          const draft = selectionState.draftBySession[evt.data.sessionID]
-          if (draft && selectionKey(draft) === committed)
-            setSelectionState("draftBySession", evt.data.sessionID, undefined)
-        }),
-      )
-
-      onCleanup(
-        event.on("session.deleted", (evt) => {
-          pendingSelectionCommits.delete(evt.data.sessionID)
-          setSelectionState("draftBySession", evt.data.sessionID, undefined)
-        }),
-      )
+      })
 
       return {
         current: currentModel,
-        selection: currentSelection,
-        available(model = currentModel()) {
-          return model ? isModelValid(model) : false
-        },
-        trackSessionCommit(
-          sessionID: string,
-          value: {
-            providerID: string
-            id: string
-            variant?: string
-          },
-        ) {
-          const committed = selectionKey({ providerID: value.providerID, modelID: value.id, variant: value.variant })
-          pendingSelectionCommits.set(sessionID, committed)
-          return () => {
-            if (pendingSelectionCommits.get(sessionID) === committed) pendingSelectionCommits.delete(sessionID)
-          }
-        },
         get ready() {
-          return preferences.ready
-        },
-        get catalogReady() {
-          return models() !== undefined
+          return modelStore.ready
         },
         recent() {
-          return preferences.recent
+          return modelStore.recent
         },
         favorite() {
-          return preferences.favorite
+          return modelStore.favorite
         },
         parsed: createMemo(() => {
-          const value = currentSelection()
+          const value = currentModel()
           if (!value) {
             return {
               provider: "Connect a provider",
@@ -343,28 +230,33 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
               reasoning: false,
             }
           }
-          const provider = providers()?.find((item) => item.id === value.providerID)
-          const info = models()?.find((item) => item.providerID === value.providerID && item.id === value.modelID)
+          const provider = data.location.provider.list()?.find((item) => item.id === value.providerID)
+          const info = data.location.model
+            .list()
+            ?.find((item) => item.providerID === value.providerID && item.id === value.modelID)
           return {
             provider: provider?.name ?? value.providerID,
-            model: info?.name ?? `${value.modelID} (unavailable)`,
+            model: info?.name ?? value.modelID,
             reasoning: (info?.variants?.length ?? 0) !== 0,
           }
         }),
         cycle(direction: 1 | -1) {
-          const current = currentSelection()
+          const current = currentModel()
           if (!current) return
-          const recent = recentModels(current, preferences.recent).filter(isModelValid)
+          const recent = modelStore.recent
           const index = recent.findIndex((x) => x.providerID === current.providerID && x.modelID === current.modelID)
-          let next = index === -1 ? (direction === 1 ? 0 : recent.length - 1) : index + direction
+          if (index === -1) return
+          let next = index + direction
           if (next < 0) next = recent.length - 1
           if (next >= recent.length) next = 0
           const val = recent[next]
           if (!val) return
-          selectModel({ ...val })
+          const a = agent.current()
+          if (!a) return
+          setModelStore("model", a.id, { ...val })
         },
         cycleFavorite(direction: 1 | -1) {
-          const favorites = preferences.favorite.filter((item) => isModelValid(item))
+          const favorites = modelStore.favorite.filter((item) => isModelValid(item))
           if (!favorites.length) {
             toast.show({
               variant: "info",
@@ -373,7 +265,7 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
             })
             return
           }
-          const current = currentSelection()
+          const current = currentModel()
           let index = -1
           if (current) {
             index = favorites.findIndex((x) => x.providerID === current.providerID && x.modelID === current.modelID)
@@ -387,39 +279,45 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
           }
           const next = favorites[index]
           if (!next) return
-          if (!selectModel({ ...next })) return
-          setPreferences("recent", recentModels(next, preferences.recent))
-          savePreferences()
+          const a = agent.current()
+          if (!a) return
+          setModelStore("model", a.id, { ...next })
+          setModelStore("recent", recentModels(next, modelStore.recent))
+          save()
         },
         set(model: { providerID: string; modelID: string }, options?: { recent?: boolean }) {
           batch(() => {
             if (!isModelValid(model)) return
-            if (!selectModel(model)) return
+            const a = agent.current()
+            if (!a) return
+            setModelStore("model", a.id, model)
             if (options?.recent) {
-              setPreferences("recent", recentModels(model, preferences.recent))
-              savePreferences()
+              setModelStore("recent", recentModels(model, modelStore.recent))
+              save()
             }
           })
         },
         toggleFavorite(model: { providerID: string; modelID: string }) {
           batch(() => {
             if (!isModelValid(model)) return
-            const exists = preferences.favorite.some(
+            const exists = modelStore.favorite.some(
               (x) => x.providerID === model.providerID && x.modelID === model.modelID,
             )
             const next = exists
-              ? preferences.favorite.filter((x) => x.providerID !== model.providerID || x.modelID !== model.modelID)
-              : [model, ...preferences.favorite]
-            setPreferences(
+              ? modelStore.favorite.filter((x) => x.providerID !== model.providerID || x.modelID !== model.modelID)
+              : [model, ...modelStore.favorite]
+            setModelStore(
               "favorite",
               next.map((x) => ({ providerID: x.providerID, modelID: x.modelID })),
             )
-            savePreferences()
+            save()
           })
         },
         variant: {
           selected() {
-            return currentSelection()?.variant
+            const m = currentModel()
+            if (!m) return undefined
+            return normalizeModelVariant(modelStore.variant[modelPreferenceKey(m)])
           },
           current() {
             const v = this.selected()
@@ -427,20 +325,18 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
             return undefined
           },
           list() {
-            const m = currentSelection()
+            const m = currentModel()
             if (!m) return []
-            const info = models()?.find((item) => item.providerID === m.providerID && item.id === m.modelID)
+            const info = data.location.model
+              .list()
+              ?.find((item) => item.providerID === m.providerID && item.id === m.modelID)
             return info?.variants?.map((variant) => variant.id) ?? []
           },
           set(value: string | undefined) {
-            const m = currentSelection()
+            const m = currentModel()
             if (!m) return
-            if (route.data.type === "session") {
-              setSessionDraft(route.data.sessionID, { ...m, variant: normalizeModelVariant(value) })
-              return
-            }
-            setPreferences("variant", modelPreferenceKey(m), normalizeModelVariant(value))
-            savePreferences()
+            setModelStore("variant", modelPreferenceKey(m), normalizeModelVariant(value))
+            save()
           },
           cycle() {
             const variants = this.list()

packages/tui/src/context/storage.tsx

@@ -27,7 +27,6 @@ export interface Storage {
    * JSON-serializable.
    */
   memory<Value extends object>(key: string, options: { readonly initial: Value }): MemoryEntry<Value>
-  flush(): Promise<void>
 }
 
 function clone<Value extends object>(value: Value) {
@@ -47,7 +46,6 @@ function segment(value: string) {
 function createStorage(root: string, channel: string) {
   const entries = new Map<string, { readonly value: Entry<object>; readonly reload: () => void }>()
   const memories = new Map<string, MemoryEntry<object>>()
-  const pending = new Set<Promise<void>>()
   const directory = path.join(root, segment(channel), "tui")
   const locks = path.join(root, segment(channel), "locks")
   mkdirSync(directory, { recursive: true })
@@ -68,8 +66,8 @@ function createStorage(root: string, channel: string) {
       const [store, setStore] = createStore(load())
       const merge = (next: Value) => reconcile(next, { key: options.key })
       const reload = () => batch(() => setStore(merge(load())))
-      const update = (mutation: (draft: Value) => void) => {
-        const operation = Flock.withLock(
+      const update = (mutation: (draft: Value) => void) =>
+        Flock.withLock(
           file,
           async () => {
             const draft = load()
@@ -80,13 +78,6 @@ function createStorage(root: string, channel: string) {
           },
           { dir: locks },
         )
-        pending.add(operation)
-        operation.then(
-          () => pending.delete(operation),
-          () => pending.delete(operation),
-        )
-        return operation
-      }
       const entry = [store, update] as const
       entries.set(file, { value: entry as Entry<object>, reload })
       return entry
@@ -99,15 +90,6 @@ function createStorage(root: string, channel: string) {
       memories.set(key, entry as MemoryEntry<object>)
       return entry
     },
-    async flush() {
-      const failures: unknown[] = []
-      while (pending.size > 0) {
-        const results = await Promise.allSettled(pending)
-        failures.push(...results.filter((result) => result.status === "rejected").map((result) => result.reason))
-      }
-      if (failures.length === 1) throw failures[0]
-      if (failures.length > 1) throw new AggregateError(failures, "Storage writes failed")
-    },
   }
 
   const watcher = watch(directory, () => entries.forEach((entry) => entry.reload()))

packages/tui/src/mini/footer.command.tsx

@@ -3,9 +3,7 @@ import { TextAttributes, type InputRenderable, type KeyEvent } from "@opentui/co
 import { useKeyboard, type JSX } from "@opentui/solid"
 import fuzzysort from "fuzzysort"
 import { createEffect, createMemo, createSignal, type Accessor } from "solid-js"
-import { Keymap } from "../context/keymap"
 import { RunFooterMenu, createFooterMenuState, type RunFooterMenuItem } from "./footer.menu"
-import { monoShortcut } from "./mono"
 import type { RunFooterTheme } from "./theme"
 import type {
   FooterQueuedPrompt,
@@ -58,10 +56,6 @@ type SkillEntry = PanelEntry & {
   name: string
 }
 
-type QueuedPromptEntry = PanelEntry & {
-  prompt: FooterQueuedPrompt
-}
-
 type SubagentEntry = PanelEntry & {
   sessionID: string
   current: boolean
@@ -448,7 +442,7 @@ export function RunCommandMenuBody(props: {
           {
             action: "queued" as const,
             category: "Agent",
-            display: "View queued prompts",
+            display: "View pending work",
             footer: `${props.queued().length} pending`,
             keywords: props
               .queued()
@@ -843,48 +837,28 @@ export function RunQueuedPromptSelectBody(props: {
   theme: Accessor<RunFooterTheme>
   prompts: Accessor<FooterQueuedPrompt[]>
   onClose: () => void
-  onSteer: (prompt: FooterQueuedPrompt) => void
-  onDelete: (prompt: FooterQueuedPrompt) => void
   onRows?: (rows: number) => void
   mono?: boolean
 }) {
-  const entries = createMemo<QueuedPromptEntry[]>(() =>
+  const entries = createMemo(() =>
     props.prompts().map((prompt) => ({
       category: "",
       display: prompt.prompt.text.replaceAll("\n", " "),
-      footer: "queued",
+      footer: prompt.delivery,
       keywords: prompt.prompt.text,
-      prompt,
     })),
   )
   const controller = createSearchablePanelController({
     entries,
     limit: SUBAGENT_LIST_ROWS,
     onClose: props.onClose,
-    onSelect: (item) => props.onSteer(item.prompt),
+    onSelect: props.onClose,
     onRows: props.onRows,
   })
-  const shortcuts = Keymap.useShortcuts()
-  const deleteShortcut = () => monoShortcut(shortcuts.get("queued_prompt.delete") ?? "", props.mono ?? false)
-  Keymap.createLayer(() => ({
-    priority: 1,
-    commands: [
-      {
-        id: "queued_prompt.delete",
-        title: "Delete queued prompt",
-        group: "Prompt",
-        run() {
-          const item = controller.items()[controller.menu.selected()]
-          if (!item) return false
-          props.onDelete(item.prompt)
-        },
-      },
-    ],
-  }))
 
   return (
     <PanelShell
-      title="Queued prompts"
+      title="Pending work"
       query={controller.query()}
       count={controller.items().length}
       total={entries().length}
@@ -892,7 +866,6 @@ export function RunQueuedPromptSelectBody(props: {
       theme={props.theme}
       inputRef={controller.inputRef}
       onQuery={controller.setQuery}
-      hint={["enter steer", deleteShortcut() ? `${deleteShortcut()} delete` : undefined].filter(Boolean).join(" · ")}
       mono={props.mono}
     >
       <RunFooterMenu
@@ -902,7 +875,7 @@ export function RunQueuedPromptSelectBody(props: {
         offset={controller.menu.offset}
         rows={controller.menu.rows}
         limit={SUBAGENT_LIST_ROWS}
-        empty="No queued prompts"
+        empty="No pending work"
         border={false}
         paddingLeft={panelPad(props.mono)}
         paddingRight={panelPad(props.mono)}

packages/tui/src/mini/footer.prompt.tsx

@@ -19,7 +19,6 @@ import {
   displayCharAt,
   displaySlice,
   isExitCommand,
-  isCompactCommand,
   mentionTriggerIndex,
   isNewCommand,
   movePromptHistory,
@@ -32,16 +31,7 @@ import { realignEditorPromptParts, resolveEditorSlashValue } from "./prompt.edit
 import { monoTruncateMiddle } from "./mono"
 import { FOOTER_MENU_ROWS, createFooterMenuState, type RunFooterMenuItem } from "./footer.menu"
 import type { RunFooterTheme } from "./theme"
-import type {
-  FooterQueuedPrompt,
-  FooterState,
-  RunAgent,
-  RunCommand,
-  RunDelivery,
-  RunPrompt,
-  RunPromptPart,
-  RunReference,
-} from "./types"
+import type { FooterState, RunAgent, RunCommand, RunPrompt, RunPromptPart, RunReference } from "./types"
 
 const AUTOCOMPLETE_ROWS = FOOTER_MENU_ROWS
 const AUTOCOMPLETE_BOTTOM_ROWS = 1
@@ -82,8 +72,6 @@ type PromptInput = {
   theme: Accessor<RunFooterTheme>
   mono: Accessor<boolean>
   history?: Accessor<RunPrompt[]>
-  queuedPrompts: Accessor<FooterQueuedPrompt[]>
-  onQueuedPromptSteer: (inputID: string) => Promise<boolean>
   onSubmit: (input: RunPrompt) => boolean | Promise<boolean>
   onCycle: () => void
   onInterrupt: () => boolean
@@ -992,18 +980,8 @@ export function createPromptState(input: PromptInput): PromptState {
   }))
 
   Keymap.createLayer(() => ({
-    priority: 1,
     enabled: input.prompt() && !visible(),
     commands: [
-      {
-        id: "prompt.queue",
-        title: "Queue prompt",
-        group: "Prompt",
-        run() {
-          syncDraft()
-          submitPrompt(promptCopy(draft), "queue")
-        },
-      },
       {
         id: "prompt.editor",
         title: "Open editor",
@@ -1138,8 +1116,7 @@ export function createPromptState(input: PromptInput): PromptState {
     }
   }
 
-  let submitting = false
-  const submitPrompt = (next: RunPrompt, delivery: RunDelivery = "steer") => {
+  const submitPrompt = (next: RunPrompt) => {
     if (!area || area.isDestroyed) {
       draft = promptCopy(next)
     }
@@ -1153,34 +1130,12 @@ export function createPromptState(input: PromptInput): PromptState {
       hide()
     }
 
-    if (submitting) return
-
     if (!next.text.trim()) {
-      const queued = delivery === "steer" ? input.queuedPrompts()[0] : undefined
-      if (queued) {
-        submitting = true
-        void input.onQueuedPromptSteer(queued.messageID).finally(() => {
-          submitting = false
-        })
-        return
-      }
       input.onStatus(input.state().phase === "running" ? "waiting for current response" : "empty prompt ignored")
       return
     }
 
     const command = next.mode === "shell" ? undefined : selectedCommand(next.text, next.command)
-    if (
-      delivery === "queue" &&
-      (next.mode === "shell" ||
-        command?.source === "skill" ||
-        isNewCommand(next.text) ||
-        isCompactCommand(next.text) ||
-        isExitCommand(next.text) ||
-        next.text.trim().toLowerCase() === "/settings")
-    ) {
-      input.onStatus("this prompt cannot be queued")
-      return
-    }
     if (!command && next.mode !== "shell" && isExitCommand(next.text)) {
       input.onExit()
       return
@@ -1202,28 +1157,24 @@ export function createPromptState(input: PromptInput): PromptState {
     }
 
     const submit = command
-      ? { ...next, command, delivery }
+      ? { ...next, command }
       : parsed?.type === "command"
-        ? { ...next, command: parsed.command, delivery }
-        : { ...next, delivery }
+        ? { ...next, command: parsed.command }
+        : next
     const shellMode = next.mode === "shell"
 
-    submitting = true
     resetDraft()
     queueMicrotask(async () => {
-      try {
-        if (await input.onSubmit(submit)) {
-          push(next)
-          if (shellMode) {
-            setShellMode(false)
-            draft = emptyPrompt(false)
-          }
-          return
+      if (await input.onSubmit(submit)) {
+        push(next)
+        if (shellMode) {
+          setShellMode(false)
+          draft = emptyPrompt(false)
         }
-        restore(next)
-      } finally {
-        submitting = false
+        return
       }
+
+      restore(next)
     })
   }
 

packages/tui/src/mini/footer.ts

@@ -51,7 +51,6 @@ import type {
   MiniSettingChange,
   MiniSettings,
   PermissionReply,
-  QueuedPromptAction,
   RunAgent,
   RunCommand,
   RunInput,
@@ -97,7 +96,6 @@ type RunFooterOptions = {
   onVariantSelect?: (variant: string | undefined) => CycleResult | void | Promise<CycleResult | void>
   onInterrupt?: () => void
   onBackground?: () => void
-  onQueuedPromptAction?: (action: QueuedPromptAction, inputID: string) => Promise<void>
   onEditorOpen: (input: { value: string }) => Promise<string | undefined>
   onSubagentSelect?: (sessionID: string | undefined) => void
   onSubagentInterrupt?: (sessionID: string) => void
@@ -345,7 +343,6 @@ export class RunFooter implements FooterApi {
               onCycle: footer.handleCycle,
               onInterrupt: footer.handleInterrupt,
               onBackground: options.onBackground,
-              onQueuedPromptAction: options.onQueuedPromptAction,
               onEditorOpen: options.onEditorOpen,
               onInputClear: footer.handleInputClear,
               onExitRequest: footer.handleExit,

packages/tui/src/mini/footer.view.tsx

@@ -34,8 +34,6 @@ import { Keymap } from "../context/keymap"
 import { modelInfo } from "./variant.shared"
 import { monoShortcut } from "./mono"
 import { stringWidth } from "../util/string-width"
-import { errorMessage } from "../util/error"
-import { createSingleFlight } from "../util/single-flight"
 
 import type {
   FooterPromptRoute,
@@ -48,7 +46,6 @@ import type {
   MiniSettingChange,
   MiniSettings,
   PermissionReply,
-  QueuedPromptAction,
   RunAgent,
   RunCommand,
   RunInput,
@@ -95,14 +92,13 @@ type RunFooterViewProps = {
   mono: boolean
   miniSettings: () => MiniSettings
   history?: () => RunPrompt[]
-  onSubmit: (input: RunPrompt) => boolean | Promise<boolean>
+  onSubmit: (input: RunPrompt) => boolean
   onPermissionReply: (input: PermissionReply) => void | Promise<void>
   onFormReply: (input: FormReply) => void | Promise<void>
   onFormCancel: (input: FormCancel) => void | Promise<void>
   onCycle: () => void
   onInterrupt: () => boolean
   onBackground?: () => void
-  onQueuedPromptAction?: (action: QueuedPromptAction, inputID: string) => Promise<void>
   onEditorOpen: (input: { value: string }) => Promise<string | undefined>
   onInputClear: () => void
   onExitRequest?: () => boolean
@@ -136,7 +132,6 @@ export function RunFooterView(props: RunFooterViewProps) {
   const [route, setRoute] = createSignal<FooterPromptRoute>({ type: "composer" })
   const [subagentMenuRows, setSubagentMenuRows] = createSignal(RUN_SUBAGENT_PANEL_ROWS)
   const queuedPrompts = createMemo(() => props.queuedPrompts?.() ?? [])
-  const queue = createMemo(() => queuedPrompts().filter((item) => item.delivery === "queue"))
   const skills = createMemo(() => (props.commands() ?? []).filter((item) => item.source === "skill"))
   const prompt = createMemo(() => active().type === "prompt" && route().type === "composer")
   const selectingSubagent = createMemo(() => active().type === "prompt" && route().type === "subagent-menu")
@@ -234,7 +229,7 @@ export function RunFooterView(props: RunFooterViewProps) {
     const details = [busy() ? "running" : "idle", `agent ${props.currentAgent()}`]
     if (current) details.push(variant ? `${current} ${variant}` : current)
     if (usage()) details.push(props.mono ? usage().replaceAll(" · ", " - ") : usage())
-    if (queue().length > 0) details.push(`${queue().length} queued`)
+    if (queuedPrompts().length > 0) details.push(`${queuedPrompts().length} pending`)
     if (activeTabs().length > 0) details.push(`${activeTabs().length} subagent${activeTabs().length === 1 ? "" : "s"}`)
     return details.join(props.mono ? " - " : " · ")
   })
@@ -314,7 +309,7 @@ export function RunFooterView(props: RunFooterViewProps) {
   }
 
   const openQueuedMenu = () => {
-    if (queue().length === 0) return
+    if (queuedPrompts().length === 0) return
     setRoute({ type: "queued-menu" })
     props.onSubagentSelect?.(undefined)
   }
@@ -323,22 +318,6 @@ export function RunFooterView(props: RunFooterViewProps) {
     setRoute({ type: "composer" })
   }
 
-  const runQueuedAction = createSingleFlight<string>()
-  const queuedPromptAction = async (action: QueuedPromptAction, inputID: string) => {
-    const run = props.onQueuedPromptAction
-    if (!run) return false
-    const result = await runQueuedAction(inputID, async () => {
-      const error = await run(action, inputID).then(
-        () => undefined,
-        (error) => error,
-      )
-      if (!error) return true
-      props.onStatus(`failed to ${action === "cancel" ? "delete" : action} queued prompt: ${errorMessage(error)}`)
-      return false
-    })
-    return result ?? false
-  }
-
   const openTab = (sessionID: string) => {
     setRoute({ type: "subagent", sessionID })
     props.onSubagentSelect?.(sessionID)
@@ -378,8 +357,6 @@ export function RunFooterView(props: RunFooterViewProps) {
     theme,
     mono: () => props.mono,
     history: props.history,
-    queuedPrompts: queue,
-    onQueuedPromptSteer: (inputID) => queuedPromptAction("steer", inputID),
     onSubmit: props.onSubmit,
     onCycle: props.onCycle,
     onInterrupt: props.onInterrupt,
@@ -474,12 +451,13 @@ export function RunFooterView(props: RunFooterViewProps) {
     if (foregroundSubagents() && backgroundShortcut()) {
       items.push({ key: backgroundShortcut(), label: "background" })
     }
-    if (queue().length > 0 && queuedShortcut()) {
-      items.push({ key: queuedShortcut(), label: `${queue().length} queued` })
+    if (queuedPrompts().length > 0 && queuedShortcut()) {
+      items.push({ key: queuedShortcut(), label: `${queuedPrompts().length} pending` })
     }
     if (activeTabs().length > 0 && subagentShortcut()) {
       items.push({ key: subagentShortcut(), label: "subagents" })
     }
+
     return items
   })
   const commandHint = createMemo(() => {
@@ -590,11 +568,11 @@ export function RunFooterView(props: RunFooterViewProps) {
   }))
 
   Keymap.createLayer(() => ({
-    enabled: active().type === "prompt" && route().type === "composer" && queue().length > 0,
+    enabled: active().type === "prompt" && route().type === "composer" && queuedPrompts().length > 0,
     commands: [
       {
         id: "session.queued_prompts",
-        title: "View queued prompts",
+        title: "View pending work",
         group: "Session",
         run: openQueuedMenu,
       },
@@ -652,7 +630,7 @@ export function RunFooterView(props: RunFooterViewProps) {
   })
 
   createEffect(() => {
-    if (route().type !== "queued-menu" || queue().length > 0) return
+    if (route().type !== "queued-menu" || queuedPrompts().length > 0) return
     closePanel()
   })
 
@@ -756,16 +734,8 @@ export function RunFooterView(props: RunFooterViewProps) {
                         <Match when={selectingQueued()}>
                           <RunQueuedPromptSelectBody
                             theme={theme}
-                            prompts={queue}
+                            prompts={queuedPrompts}
                             onClose={closePanel}
-                            onSteer={(item) => {
-                              void queuedPromptAction("steer", item.messageID).then((steered) => {
-                                if (steered) closePanel()
-                              })
-                            }}
-                            onDelete={(item) => {
-                              void queuedPromptAction("cancel", item.messageID)
-                            }}
                             onRows={setSubagentMenuRows}
                             mono={props.mono}
                           />
@@ -775,7 +745,7 @@ export function RunFooterView(props: RunFooterViewProps) {
                             theme={theme}
                             commands={props.commands}
                             subagents={tabs}
-                            queued={queue}
+                            queued={queuedPrompts}
                             variants={props.variants}
                             variantCycle={variantCycle()}
                             onClose={closePanel}

packages/tui/src/mini/runtime.lifecycle.ts

@@ -22,7 +22,6 @@ import type {
   MiniSettings,
   MiniHost,
   PermissionReply,
-  QueuedPromptAction,
   RunAgent,
   RunInput,
   RunPrompt,
@@ -71,7 +70,6 @@ export type LifecycleInput = {
   onVariantSelect?: (variant: string | undefined) => CycleResult | void | Promise<CycleResult | void>
   onInterrupt?: () => void
   onBackground?: () => void
-  onQueuedPromptAction?: (action: QueuedPromptAction, inputID: string) => Promise<void>
   onSubagentSelect?: (sessionID: string | undefined) => void
   onSubagentInterrupt?: (sessionID: string) => void
 }
@@ -245,7 +243,6 @@ export async function createRuntimeLifecycle(input: LifecycleInput): Promise<Lif
     onVariantSelect: input.onVariantSelect,
     onInterrupt: input.onInterrupt,
     onBackground: input.onBackground,
-    onQueuedPromptAction: input.onQueuedPromptAction,
     onEditorOpen: async ({ value }) => {
       if (closed || renderer.isDestroyed) {
         return

packages/tui/src/mini/runtime.queue.ts

@@ -11,7 +11,7 @@
 import { SessionMessage } from "@opencode-ai/schema/session-message"
 import { Locale } from "../util/locale"
 import { isCompactCommand, isExitCommand, isNewCommand } from "./prompt.shared"
-import type { FooterApi, FooterEvent, RunDelivery, RunPrompt } from "./types"
+import type { FooterApi, FooterEvent, RunPrompt } from "./types"
 
 type Trace = {
   write(type: string, data?: unknown): void
@@ -21,11 +21,11 @@ export type QueueInput = {
   footer: FooterApi
   initialInput?: string
   trace?: Trace
-  onSend?: (prompt: RunPrompt, delivery: RunDelivery) => void
+  onSend?: (prompt: RunPrompt, delivery: "steer" | "queue") => void
   onAdmissionError?: (prompt: RunPrompt, error: unknown) => void | Promise<void>
   onNewSession?: () => void | Promise<void>
   onCompact?: () => void | Promise<void>
-  admit: (prompt: RunPrompt, delivery: RunDelivery, signal: AbortSignal) => Promise<void>
+  admit: (prompt: RunPrompt, signal: AbortSignal) => Promise<void>
   settle: () => Promise<void>
   run: (prompt: RunPrompt, signal: AbortSignal, admitted: () => void) => Promise<void>
 }
@@ -183,7 +183,7 @@ export async function runPromptQueue(input: QueueInput): Promise<void> {
               input.trace?.write("ui.commit", commit)
               input.footer.append(commit)
             }
-            input.onSend?.(sent, sent.delivery ?? "steer")
+            input.onSend?.(sent, "steer")
 
             if (state.closed) {
               break
@@ -276,11 +276,10 @@ export async function runPromptQueue(input: QueueInput): Promise<void> {
       const sent = { ...prompt, messageID: SessionMessage.ID.create() }
       const admission = state.admission
       admissionVersion += 1
-      const delivery = prompt.delivery ?? "queue"
-      input.onSend?.(sent, delivery)
+      input.onSend?.(sent, "queue")
       admissions = admissions
         .then(() => admission)
-        .then(() => input.admit(sent, delivery, admissionController.signal))
+        .then(() => input.admit(sent, admissionController.signal))
         .catch((error) => (state.closed ? undefined : input.onAdmissionError?.(sent, error)))
       return
     }

packages/tui/src/mini/runtime.ts

@@ -390,15 +390,6 @@ async function runInteractiveRuntime(input: RunRuntimeInput, deps: RunRuntimeDep
       log?.write("send.background", { sessionID: state.sessionID })
       void state.sdk.session.background({ sessionID: state.sessionID }).catch(() => {})
     },
-    onQueuedPromptAction: async (action, inputID) => {
-      if (!state.sessionID) return
-      log?.write(`send.pending.${action}`, { sessionID: state.sessionID, inputID })
-      if (action === "steer") {
-        await state.sdk.session.pending.steer({ sessionID: state.sessionID, inputID })
-        return
-      }
-      await state.sdk.session.pending.cancel({ sessionID: state.sessionID, inputID })
-    },
     onSubagentInterrupt: (sessionID) => {
       log?.write("send.subagent.interrupt", { sessionID })
       void state.sdk.session.interrupt({ sessionID }).catch(() => {})
@@ -901,7 +892,7 @@ async function runInteractiveRuntime(input: RunRuntimeInput, deps: RunRuntimeDep
       trace: log,
       onSend: (prompt, delivery) => {
         state.shown = true
-        state.history.push({ ...prompt, delivery: undefined })
+        state.history.push(prompt)
         if (prompt.mode !== "shell" && delivery === "steer") {
           rememberLocal({
             kind: "user",
@@ -912,21 +903,18 @@ async function runInteractiveRuntime(input: RunRuntimeInput, deps: RunRuntimeDep
           })
         }
       },
-      admit: async (prompt, delivery, signal) => {
+      admit: async (prompt, signal) => {
         await state.switching?.catch(() => {})
         const next = await ensureStream()
-        await next.handle.admitPromptTurn(
-          {
-            agent: state.agent,
-            model: state.model,
-            variant: state.activeVariant,
-            prompt,
-            files: input.files,
-            includeFiles: false,
-            signal,
-          },
-          delivery,
-        )
+        await next.handle.queuePromptTurn({
+          agent: state.agent,
+          model: state.model,
+          variant: state.activeVariant,
+          prompt,
+          files: input.files,
+          includeFiles: false,
+          signal,
+        })
       },
       onAdmissionError: renderPromptError,
       onCompact: async () => {

packages/tui/src/mini/stream-v2.subagent.ts

@@ -653,10 +653,6 @@ export function createSubagentTracker(input: SubagentTrackerInput): SubagentTrac
       }
       return
     }
-    if (event.type === "session.input.cancelled") {
-      child.prompts.delete(event.data.inputID)
-      return
-    }
     if (event.type === "session.step.started") {
       touch(child, event.created)
       if (child.label === FALLBACK_LABEL && event.data.agent) child.label = Locale.titlecase(event.data.agent)

packages/tui/src/mini/stream-v2.transport.ts

@@ -26,7 +26,6 @@ import type {
   FooterQueuedPrompt,
   RunFilePart,
   RunInput,
-  RunDelivery,
   RunPrompt,
   RunPromptPart,
   StreamCommit,
@@ -72,7 +71,7 @@ export type SessionResizeReplayInput = {
 
 export type SessionTransport = {
   runPromptTurn(input: SessionTurnInput, admitted?: () => void): Promise<void>
-  admitPromptTurn(input: SessionTurnInput, delivery: RunDelivery): Promise<void>
+  queuePromptTurn(input: SessionTurnInput): Promise<void>
   waitForIdle(): Promise<void>
   interruptActiveTurn(): Promise<void>
   selectSubagent(sessionID: string | undefined): void
@@ -516,12 +515,8 @@ export async function createSessionTransport(input: StreamInput): Promise<Sessio
     )
   }
 
-  let syncedPending: string[] | undefined
   const syncPending = () => {
-    const prompts = [...state.pending.values()].filter((item) => item.delivery === "queue")
-    const ids = prompts.map((item) => item.messageID)
-    if (syncedPending?.length === ids.length && syncedPending.every((id, index) => id === ids[index])) return
-    syncedPending = ids
+    const prompts = [...state.pending.values()]
     input.trace?.write("ui.patch", { pending: prompts.length })
     input.footer.event({ type: "queued.prompts", prompts })
   }
@@ -939,36 +934,6 @@ export async function createSessionTransport(input: StreamInput): Promise<Sessio
       write([], { phase: "running", status: "waiting for assistant" })
       return
     }
-    if (event.type === "session.input.steered") {
-      const pending = state.pending.get(event.data.inputID)
-      if (!pending) return
-      state.pending.set(event.data.inputID, { ...pending, delivery: "steer" })
-      syncPending()
-      if (state.messageIDs.has(event.data.inputID)) return
-      state.messageIDs.add(event.data.inputID)
-      write([
-        {
-          kind: "user",
-          source: "system",
-          text: pending.prompt.text,
-          phase: "start",
-          messageID: event.data.inputID,
-        },
-      ])
-      return
-    }
-    if (event.type === "session.input.queued") {
-      const pending = state.pending.get(event.data.inputID)
-      if (!pending) return
-      state.pending.set(event.data.inputID, { ...pending, delivery: "queue" })
-      syncPending()
-      return
-    }
-    if (event.type === "session.input.cancelled") {
-      state.admitted.delete(event.data.inputID)
-      if (state.pending.delete(event.data.inputID)) syncPending()
-      return
-    }
     if (event.type === "session.step.started") {
       state.stepModel = { providerID: event.data.model.providerID, modelID: event.data.model.id }
       write([], { phase: "running", status: "assistant responding" })
@@ -1612,7 +1577,7 @@ export async function createSessionTransport(input: StreamInput): Promise<Sessio
   let queuedResizeReplay: SessionResizeReplayInput | undefined
   let closing: Promise<void> | undefined
 
-  const admitPrompt = async (next: SessionTurnInput, client: OpenCodeClient, delivery: RunDelivery) => {
+  const admitPrompt = async (next: SessionTurnInput, client: OpenCodeClient, delivery: "steer" | "queue") => {
     const messageID = next.prompt.messageID
     if (!messageID) throw new Error("Prompt message ID is required")
     const command = next.prompt.command
@@ -1678,20 +1643,14 @@ export async function createSessionTransport(input: StreamInput): Promise<Sessio
   }
 
   return {
-    async admitPromptTurn(next, delivery) {
+    async queuePromptTurn(next) {
       if (next.prompt.mode === "shell" || next.prompt.command?.source === "skill")
         throw new Error("This prompt cannot be queued")
       if (!state.connected) throw new Error("Event stream is reconnecting")
       const client = sdk
       if (next.agent)
         await client.session.switchAgent({ sessionID: input.sessionID, agent: next.agent }, { signal: next.signal })
-      if (!next.prompt.command) {
-        const selected = await resolveSelectedModel(input, client, next)
-        if (next.variant && !selected) throw new Error("Cannot select a variant before selecting a model")
-        if (selected)
-          await client.session.switchModel({ sessionID: input.sessionID, model: selected }, { signal: next.signal })
-      }
-      mergePending(await admitPrompt(next, client, delivery))
+      mergePending(await admitPrompt(next, client, "queue"))
       settlementClient = client
     },
     async waitForIdle() {
@@ -1729,7 +1688,7 @@ export async function createSessionTransport(input: StreamInput): Promise<Sessio
         return
       }
       if (command) {
-        await runTurnWait(next, messageID, client, () => admitPrompt(next, client, next.prompt.delivery ?? "steer"), admitted)
+        await runTurnWait(next, messageID, client, () => admitPrompt(next, client, "steer"), admitted)
         return
       }
 
@@ -1741,7 +1700,7 @@ export async function createSessionTransport(input: StreamInput): Promise<Sessio
       if (selected)
         await client.session.switchModel({ sessionID: input.sessionID, model: selected }, { signal: next.signal })
 
-      await runTurnWait(next, messageID, client, () => admitPrompt(next, client, next.prompt.delivery ?? "steer"), admitted)
+      await runTurnWait(next, messageID, client, () => admitPrompt(next, client, "steer"), admitted)
     },
     async interruptActiveTurn() {
       // A running shell holds no drain, so session.interrupt cannot reach it;