fix(tui): keep closed tabs closed

packages/ai/AGENTS.md

@@ -10,7 +10,7 @@
 
 ## Conventions
 
-Per-type constructors live on the type, not as top-level re-exports. Use `Message.system(...)`, `Message.user(...)`, `Message.assistant(...)`, `Message.tool(...)`, `LanguageModel.make(...)`, `ToolDefinition.make(...)`, `ToolCallPart.make(...)`, `ToolResultPart.make(...)`, `ToolChoice.make(...)`, `ToolChoice.named(...)`, `SystemPart.make(...)`, and `GenerationOptions.make(...)` directly. The top-level `LLM` namespace is reserved for request-shaped call APIs: `LLM.request`, `LLM.generate`, `LLM.stream`, and `LLM.generateObject`. Use `LLMRequest.update(...)` when deriving canonical request data; do not add a duplicate `LLM.updateRequest(...)` path. Two ways to construct the same thing is one too many.
+Per-type constructors live on the type, not as top-level re-exports. Use `Message.system(...)`, `Message.user(...)`, `Message.assistant(...)`, `Message.tool(...)`, `LanguageModel.make(...)`, `ToolDefinition.make(...)`, `ToolCallPart.make(...)`, `ToolResultPart.make(...)`, `ToolChoice.make(...)`, `ToolChoice.named(...)`, `SystemPart.make(...)`, and `GenerationOptions.make(...)` directly. The top-level `LLM` namespace is reserved for request-shaped call APIs: `LLM.request`, `LLM.generate`, `LLM.stream`, `LLM.updateRequest`, and `LLM.generateObject`. Two ways to construct the same thing is one too many.
 
 - Keep provider-defined string enums forward-compatible. Expose known values for autocomplete while accepting future values with `Known | (string & {})`; use `Schema.String` at runtime unless rejecting unknown values is required for correctness.
 

packages/ai/README.md

@@ -3,9 +3,8 @@
 Schema-first AI primitives for opencode. Provider quirks live in adapters, not in calling code.
 
 ```ts
-import { Effect, Layer } from "effect"
+import { Effect } from "effect"
 import { LLM, LLMClient } from "@opencode-ai/ai"
-import { RequestExecutor } from "@opencode-ai/ai/route"
 import { OpenAI } from "@opencode-ai/ai/providers"
 
 const model = OpenAI.configure({ apiKey: process.env.OPENAI_API_KEY }).responses("gpt-4o-mini")
@@ -21,10 +20,6 @@ const program = Effect.gen(function* () {
   const response = yield* LLMClient.generate(request)
   console.log(response.text)
 })
-
-const llmLayer = LLMClient.layer.pipe(Layer.provide(RequestExecutor.fetchLayer))
-
-await Effect.runPromise(program.pipe(Effect.provide(llmLayer)))
 ```
 
 Run `LLMClient.stream(request)` instead of `generate` when you want incremental `LLMEvent`s. The event stream is provider-neutral — same shape across OpenAI Chat, OpenAI Responses, Anthropic Messages, Gemini, Bedrock Converse, and any OpenAI-compatible deployment.
@@ -205,32 +200,6 @@ The hosted result is represented as a provider-executed tool call and tool resul
 - **`Image.generate({...})`** — generate images through a provider-neutral image request and response model.
 - **`ImageClient`** — Effect service and layer for image execution, parallel to `LLMClient`.
 
-## Testing
-
-Use the deterministic test client from `@opencode-ai/ai/testing` to script provider-neutral responses and inspect
-the requests sent by code under test:
-
-```ts
-import { Effect } from "effect"
-import { TestLLM } from "@opencode-ai/ai/testing"
-
-const testLLM = TestLLM.layer({
-  fallback: TestLLM.text("Hello from the test model", "text-1"),
-})
-
-// TestLLM.clientLayer provides LLMClient.Service and consumes TestLLM.Service.
-const programWithTestClient = Effect.gen(function* () {
-  const result = yield* program
-  const test = yield* TestLLM.Service
-  console.log(test.requests)
-  return result
-}).pipe(Effect.provide(TestLLM.clientLayer), Effect.provide(testLLM))
-```
-
-`TestLLM.push(...)` scripts one-shot responses, `TestLLM.always(...)` changes the fallback, and
-`TestLLM.wait(...)` lets concurrent tests wait until a request has arrived. Every received canonical request is
-available on the yielded `TestLLM.Service`.
-
 ## Caching
 
 Prompt caching is **on by default**. Every `LLMRequest` resolves to `cache: "auto"` unless the caller opts out with `cache: "none"`. Each protocol translates `CacheHint`s to its wire format (`cache_control` on Anthropic, `cachePoint` on Bedrock; OpenAI and Gemini do implicit caching server-side and don't need inline markers — auto is a no-op there).

packages/ai/src/image-client.ts

@@ -15,11 +15,11 @@ export class Service extends Context.Service<Service, Interface>()("@opencode/Im
 
 export const generate = <Options extends ImageOptions>(
   request: ImageRequestFor<Options>,
-): Effect.Effect<ImageResponse, AIError, Service> =>
+): Effect.Effect<ImageResponse, AIError> =>
   Effect.gen(function* () {
     const client = yield* Service
     return yield* client.generate(request)
-  })
+  }) as Effect.Effect<ImageResponse, AIError>
 
 export const layer: Layer.Layer<Service, never, RequestExecutor.Service> = Layer.effect(
   Service,

packages/ai/src/llm.ts

@@ -1,5 +1,5 @@
 import { Effect, JsonSchema, Schema } from "effect"
-import { LLMClient, Service } from "./route/client"
+import { LLMClient } from "./route/client"
 import {
   GenerationOptions,
   HttpOptions,
@@ -151,10 +151,10 @@ const runGenerateObject = Effect.fn("LLM.generateObject")(function* (
  */
 export function generateObject<const SelectedLanguageModel extends LanguageModel, S extends ToolSchema<any>>(
   options: GenerateObjectOptions<S, SelectedLanguageModel>,
-): Effect.Effect<GenerateObjectResponse<Schema.Schema.Type<S>>, AIError, Service>
+): Effect.Effect<GenerateObjectResponse<Schema.Schema.Type<S>>, AIError>
 export function generateObject<const SelectedLanguageModel extends LanguageModel>(
   options: GenerateObjectDynamicOptions<SelectedLanguageModel>,
-): Effect.Effect<GenerateObjectResponse<unknown>, AIError, Service>
+): Effect.Effect<GenerateObjectResponse<unknown>, AIError>
 export function generateObject(options: GenerateObjectOptions<ToolSchema<any>> | GenerateObjectDynamicOptions) {
   if ("schema" in options) {
     const { schema, ...rest } = options

packages/ai/src/route/client.ts

@@ -5,7 +5,7 @@ import { Endpoint, type EndpointPatch } from "./endpoint"
 import { RequestExecutor } from "./executor"
 import { Framing } from "./framing"
 import { HttpTransport } from "./transport"
-import type { HttpMiddleware, Transport, TransportRuntime } from "./transport"
+import type { HttpRequestTransform, Transport, TransportRuntime } from "./transport"
 import { WebSocketExecutor } from "./transport"
 import type { Protocol } from "./protocol"
 import { applyCachePolicy } from "../cache-policy"
@@ -155,7 +155,7 @@ export interface Interface {
 }
 
 export interface StreamOptions {
-  readonly http?: HttpMiddleware
+  readonly transform?: HttpRequestTransform
 }
 
 export interface StreamMethod {
@@ -307,7 +307,7 @@ function makeFromTransport<Body, Prepared, Frame, Event, State>(
           auth: routeInput.auth ?? Auth.none,
           encodeBody,
           headers: routeInput.headers,
-          middleware: options?.http,
+          transform: options?.transform,
         }),
       streamPrepared: (prepared: Prepared, request: LLMRequest, runtime: TransportRuntime) => {
         const route = `${request.model.provider}/${request.model.route.id}`
@@ -422,18 +422,18 @@ const generateWith = (stream: Interface["stream"]) =>
     )
   })
 
-export function stream(request: LLMRequest, options?: StreamOptions): Stream.Stream<LLMEvent, AIError, Service> {
+export function stream(request: LLMRequest, options?: StreamOptions): Stream.Stream<LLMEvent, AIError> {
   return Stream.unwrap(
     Effect.gen(function* () {
       return (yield* Service).stream(request, options)
     }),
-  )
+  ) as Stream.Stream<LLMEvent, AIError>
 }
 
-export function generate(request: LLMRequest, options?: StreamOptions): Effect.Effect<LLMResponse, AIError, Service> {
+export function generate(request: LLMRequest, options?: StreamOptions): Effect.Effect<LLMResponse, AIError> {
   return Effect.gen(function* () {
     return yield* (yield* Service).generate(request, options)
-  })
+  }) as Effect.Effect<LLMResponse, AIError>
 }
 
 export const streamRequest = (request: LLMRequest, options?: StreamOptions) =>

packages/ai/src/route/executor.ts

@@ -20,18 +20,9 @@ import { classifyProviderFailure } from "../provider-error"
 export interface Interface {
   readonly execute: (
     request: HttpClientRequest.HttpClientRequest,
-    middleware?: HttpMiddleware,
   ) => Effect.Effect<HttpClientResponse.HttpClientResponse, AIError>
 }
 
-export type HttpHandler = (
-  request: HttpClientRequest.HttpClientRequest,
-) => Effect.Effect<HttpClientResponse.HttpClientResponse, Error>
-export type HttpMiddleware = (
-  request: HttpClientRequest.HttpClientRequest,
-  handler: HttpHandler,
-) => Effect.Effect<HttpClientResponse.HttpClientResponse, Error>
-
 export class Service extends Context.Service<Service, Interface>()("@opencode/AI/RequestExecutor") {}
 
 const BODY_LIMIT = 16_384
@@ -270,7 +261,7 @@ const toHttpError = (redactedNames: ReadonlyArray<string | RegExp>) => (error: u
     return transportError({ message: error.message, kind: "Timeout" })
   }
   if (!HttpClientError.isHttpClientError(error)) {
-    return transportError({ message: error instanceof Error ? error.message : "HTTP transport failed" })
+    return transportError({ message: "HTTP transport failed" })
   }
   const request = "request" in error ? error.request : undefined
   if (error.reason._tag === "TransportError") {
@@ -291,20 +282,12 @@ export const layer: Layer.Layer<Service, never, HttpClient.HttpClient> = Layer.e
   Service,
   Effect.gen(function* () {
     const http = yield* HttpClient.HttpClient
-    const executeOnce = (request: HttpClientRequest.HttpClientRequest, middleware?: HttpMiddleware) =>
+    const executeOnce = (request: HttpClientRequest.HttpClientRequest) =>
       Effect.gen(function* () {
         const redactedNames = yield* Headers.CurrentRedactedNames
-        if (!middleware)
-          return yield* http
-            .execute(request)
-            .pipe(Effect.mapError(toHttpError(redactedNames)), Effect.flatMap(statusError(request, redactedNames)))
-
-        const response = yield* middleware(request, (input) =>
-          http
-            .execute(input)
-            .pipe(Effect.mapError((cause) => (cause instanceof Error ? cause : new Error(String(cause))))),
-        ).pipe(Effect.mapError(toHttpError(redactedNames)))
-        return yield* statusError(response.request, redactedNames)(response)
+        return yield* http
+          .execute(request)
+          .pipe(Effect.mapError(toHttpError(redactedNames)), Effect.flatMap(statusError(request, redactedNames)))
       })
     return Service.of({
       execute: executeOnce,

packages/ai/src/route/index.ts

@@ -23,4 +23,4 @@ export type { ApiKeyMode, AuthOverride, ProviderAuthOption } from "./auth-option
 export type { Definition as EndpointFn, EndpointInput } from "./endpoint"
 export type { Definition as FramingDef } from "./framing"
 export type { Protocol as ProtocolDef } from "./protocol"
-export type { HttpHandler, HttpMiddleware, Transport as TransportDef, TransportRuntime } from "./transport"
+export type { HttpRequest, HttpRequestTransform, Transport as TransportDef, TransportRuntime } from "./transport"

packages/ai/src/route/transport/http.ts

@@ -3,7 +3,7 @@ import { Headers, HttpClientRequest } from "effect/unstable/http"
 import { Auth } from "../auth"
 import { render as renderEndpoint } from "../endpoint"
 import { Framing } from "../framing"
-import type { HttpMiddleware, Transport, TransportPrepareInput } from "./index"
+import type { Transport, TransportPrepareInput } from "./index"
 import * as ProviderShared from "../../protocols/shared"
 import { mergeJsonRecords, type LLMRequest } from "../../schema"
 
@@ -19,7 +19,6 @@ export interface JsonRequestParts<Body = unknown> {
 export interface HttpPrepared<Frame> {
   readonly request: HttpClientRequest.HttpClientRequest
   readonly framing: Framing.Definition<Frame>
-  readonly middleware?: HttpMiddleware
 }
 
 const applyQuery = (url: string, query: Record<string, string> | undefined) => {
@@ -75,21 +74,21 @@ export const httpJson = <Body, Frame>(input: HttpJsonInput<Body, Frame>): HttpJs
   prepare: (prepareInput) =>
     Effect.gen(function* () {
       const parts = yield* jsonRequestParts({ ...prepareInput })
-      const request = ProviderShared.jsonPost({
-        url: parts.url,
-        body: parts.bodyText,
-        headers: parts.headers,
-      })
+      const request = { url: parts.url, method: "POST", headers: { ...parts.headers }, body: parts.bodyText }
+      yield* (prepareInput.transform?.(request) ?? Effect.void)
       return {
-        request,
+        request: ProviderShared.jsonPost({
+          url: request.url,
+          body: request.body ?? "",
+          headers: Headers.fromInput(request.headers),
+        }),
         framing: input.framing,
-        middleware: prepareInput.middleware,
       }
     }),
   frames: (prepared, request, runtime) =>
     Stream.unwrap(
       runtime.http
-        .execute(prepared.request, prepared.middleware)
+        .execute(prepared.request)
         .pipe(
           Effect.map((response) =>
             prepared.framing.frame(

packages/ai/src/route/transport/index.ts

@@ -1,7 +1,7 @@
 import type { Effect, Stream } from "effect"
 import { Endpoint } from "../endpoint"
 import { Auth } from "../auth"
-import type { HttpMiddleware, Interface as RequestExecutorInterface } from "../executor"
+import type { Interface as RequestExecutorInterface } from "../executor"
 import type { Interface as WebSocketExecutorInterface } from "./websocket"
 import type { AIError, LLMRequest } from "../../schema"
 
@@ -10,6 +10,15 @@ export interface TransportRuntime {
   readonly webSocket?: WebSocketExecutorInterface
 }
 
+export interface HttpRequest {
+  url: string
+  readonly method: string
+  headers: Record<string, string>
+  body: string | undefined
+}
+
+export type HttpRequestTransform = (request: HttpRequest) => Effect.Effect<void>
+
 export interface Transport<Body, Prepared, Frame> {
   readonly id: string
   readonly prepare: (input: TransportPrepareInput<Body>) => Effect.Effect<Prepared, AIError>
@@ -23,9 +32,8 @@ export interface TransportPrepareInput<Body> {
   readonly auth: Auth.Definition
   readonly encodeBody: (body: Body) => string
   readonly headers?: (input: { readonly request: LLMRequest }) => Record<string, string>
-  readonly middleware?: HttpMiddleware
+  readonly transform?: HttpRequestTransform
 }
 
 export * as HttpTransport from "./http"
-export type { HttpHandler, HttpMiddleware } from "../executor"
 export { WebSocketExecutor, WebSocketTransport } from "./websocket"

packages/ai/test/compile.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test } from "bun:test"
-import { Effect, Ref, Schema } from "effect"
-import { HttpClientRequest, HttpClientResponse } from "effect/unstable/http"
+import { Effect, Schema } from "effect"
+import { HttpClientRequest } from "effect/unstable/http"
 import { LLM, mergeProviderOptions } from "../src"
 import { AnthropicMessages, OpenAIChat } from "../src/protocols"
 import { Auth, LLMClient } from "../src/route"
@@ -146,16 +146,12 @@ describe("request option precedence", () => {
         prompt: "Say hello.",
       }),
       {
-        http: (request, handler) =>
-          Effect.gen(function* () {
-            return yield* handler(
-              request.pipe(
-                HttpClientRequest.setUrl("https://proxy.test/v1/chat/completions"),
-                HttpClientRequest.setMethod("PUT"),
-                HttpClientRequest.setHeader("x-plugin", "transformed"),
-                HttpClientRequest.bodyText(JSON.stringify({ transformed: true }), "application/custom+json"),
-              ),
-            )
+        transform: (request) =>
+          Effect.sync(() => {
+            expect(request.headers.authorization).toBe("Bearer fresh-key")
+            request.url = "https://proxy.test/v1/chat/completions"
+            request.headers["x-plugin"] = "transformed"
+            request.body = JSON.stringify({ transformed: true })
           }),
       },
     ).pipe(
@@ -164,9 +160,7 @@ describe("request option precedence", () => {
           Effect.gen(function* () {
             const web = yield* HttpClientRequest.toWeb(input.request).pipe(Effect.orDie)
             expect(web.url).toBe("https://proxy.test/v1/chat/completions")
-            expect(web.method).toBe("PUT")
             expect(web.headers.get("x-plugin")).toBe("transformed")
-            expect(web.headers.get("content-type")).toBe("application/custom+json")
             expect(decodeJson(input.text)).toEqual({ transformed: true })
             return input.respond(sseEvents(deltaChunk({}, "stop")), {
               headers: { "content-type": "text/event-stream" },
@@ -177,82 +171,6 @@ describe("request option precedence", () => {
     ),
   )
 
-  it.effect("transforms the HTTP response before protocol decoding", () =>
-    Effect.gen(function* () {
-      const response = yield* LLMClient.generate(
-        LLM.request({
-          model: OpenAIChat.route
-            .with({ endpoint: { baseURL: "https://api.openai.test/v1/" }, auth: Auth.bearer("test") })
-            .model({ id: "gpt-4o-mini" }),
-          prompt: "Say hello.",
-        }),
-        {
-          http: (request, handler) =>
-            Effect.gen(function* () {
-              const response = yield* handler(request)
-              return HttpClientResponse.fromWeb(
-                response.request,
-                new Response((yield* response.text).replace("network", "hooked"), {
-                  status: response.status,
-                  headers: response.headers,
-                }),
-              )
-            }),
-        },
-      ).pipe(
-        Effect.provide(
-          dynamicResponse((input) =>
-            Effect.succeed(
-              input.respond(sseEvents(deltaChunk({ content: "network" }, "stop")), {
-                headers: { "content-type": "text/event-stream" },
-              }),
-            ),
-          ),
-        ),
-      )
-
-      expect(response.text).toBe("hooked")
-    }),
-  )
-
-  it.effect("can inspect an error response and retry the native request", () =>
-    Effect.gen(function* () {
-      const attempts = yield* Ref.make(0)
-      const response = yield* LLMClient.generate(
-        LLM.request({
-          model: OpenAIChat.route
-            .with({ endpoint: { baseURL: "https://api.openai.test/v1/" }, auth: Auth.bearer("stale") })
-            .model({ id: "gpt-4o-mini" }),
-          prompt: "Say hello.",
-        }),
-        {
-          http: (request, handler) =>
-            Effect.gen(function* () {
-              const response = yield* handler(request)
-              expect(response.status).toBe(401)
-              return yield* handler(HttpClientRequest.setHeader(request, "authorization", "Bearer refreshed"))
-            }),
-        },
-      ).pipe(
-        Effect.provide(
-          dynamicResponse((input) =>
-            Effect.gen(function* () {
-              yield* Ref.update(attempts, (value) => value + 1)
-              if (input.request.headers.authorization !== "Bearer refreshed")
-                return input.respond("unauthorized", { status: 401 })
-              return input.respond(sseEvents(deltaChunk({ content: "retried" }, "stop")), {
-                headers: { "content-type": "text/event-stream" },
-              })
-            }),
-          ),
-        ),
-      )
-
-      expect(response.text).toBe("retried")
-      expect(yield* Ref.get(attempts)).toBe(2)
-    }),
-  )
-
   it.effect("applies raw body overlays after protocol lowering", () =>
     LLMClient.generate(
       LLM.request({

packages/ai/test/executor.test.ts

@@ -67,18 +67,6 @@ const expectAIError = (error: unknown) => {
 const errorHttp = (error: AIError) => ("http" in error.reason ? error.reason.http : undefined)
 
 describe("RequestExecutor", () => {
-  it.effect("preserves middleware error messages", () =>
-    Effect.gen(function* () {
-      const executor = yield* RequestExecutor.Service
-      const error = yield* executor
-        .execute(request, () => Effect.fail(new Error("plugin rejected request")))
-        .pipe(Effect.flip)
-
-      expectAIError(error)
-      expect(error.reason.message).toBe("plugin rejected request")
-    }).pipe(Effect.provide(responsesLayer([]))),
-  )
-
   it.effect("classifies context overflow responses", () =>
     Effect.gen(function* () {
       const executor = yield* RequestExecutor.Service

packages/ai/test/image.types.ts

@@ -1,7 +1,5 @@
-import { Effect } from "effect"
 import {
   Image,
-  ImageClient,
   ImageInput,
   ImageModel,
   type ImageModelOptions,
@@ -9,13 +7,8 @@ import {
   type ImageRequestFor,
   type ImageRoute,
 } from "../src"
-import type { Service } from "../src/image-client"
 import { Google, OpenAI, XAI, ZAI } from "../src/providers"
 
-type Requirements<T> = T extends Effect.Effect<infer _A, infer _E, infer R> ? R : never
-type Equal<A, B> = [A, B] extends [B, A] ? true : false
-type Assert<T extends true> = T
-
 type GoogleLikeOptions = {
   readonly aspectRatio?: "1:1" | "16:9"
   readonly imageSize?: "1K" | "2K"
@@ -153,9 +146,6 @@ const request = Image.request({
 })
 const typedRequest: ImageRequestFor<GoogleLikeOptions> = request
 void typedRequest
-const generated = ImageClient.generate(request)
-type GenerateRequirements = Assert<Equal<Requirements<typeof generated>, Service>>
-void (true satisfies GenerateRequirements)
 
 // @ts-expect-error Image requests no longer expose a common count option.
 Image.generate({ model: openai, prompt: "A lighthouse", count: 2 })

packages/ai/test/llm-option-types.types.ts

@@ -1,11 +1,5 @@
-import { Effect, Schema, Stream } from "effect"
-import {
-  LLM,
-  type LLMClientService,
-  type LanguageModel,
-  type LanguageModelProviderOptions,
-  type ProviderOptions,
-} from "../src"
+import { Schema } from "effect"
+import { LLM, type LanguageModel, type LanguageModelProviderOptions, type ProviderOptions } from "../src"
 import { OpenAIChat } from "../src/protocols"
 
 interface ExampleOptions {
@@ -21,19 +15,9 @@ const model = OpenAIChat.route
   .with({ endpoint: { baseURL: "https://example.com/v1" } })
   .model<ExampleProviderOptions>({ id: "example" })
 
-type Requirements<T> = T extends Effect.Effect<infer _A, infer _E, infer R> ? R : never
-type StreamRequirements<T> = T extends Stream.Stream<infer _A, infer _E, infer R> ? R : never
-type Equal<A, B> = [A, B] extends [B, A] ? true : false
-type Assert<T extends true> = T
-
 LLM.request({ model, prompt: "Hello", providerOptions: { example: { mode: "fast" } } })
 LLM.request({ model, prompt: "Hello", providerOptions: { future: { option: true } } })
 
-const generated = LLM.generate(LLM.request({ model, prompt: "Hello" }))
-type GenerateRequirements = Assert<Equal<Requirements<typeof generated>, LLMClientService>>
-const streamed = LLM.stream(LLM.request({ model, prompt: "Hello" }))
-type StreamClientRequirements = Assert<Equal<StreamRequirements<typeof streamed>, LLMClientService>>
-
 LLM.request({
   model,
   prompt: "Hello",
@@ -41,20 +25,12 @@ LLM.request({
   providerOptions: { example: { mode: "slow" } },
 })
 
-const generatedObject = LLM.generateObject({
+LLM.generateObject({
   model,
   prompt: "Hello",
   schema: Schema.Struct({ answer: Schema.String }),
   providerOptions: { example: { mode: "thorough" } },
 })
-type GenerateObjectRequirements = Assert<Equal<Requirements<typeof generatedObject>, LLMClientService>>
-
-const generatedDynamicObject = LLM.generateObject({
-  model,
-  prompt: "Hello",
-  jsonSchema: { type: "object" },
-})
-type GenerateDynamicObjectRequirements = Assert<Equal<Requirements<typeof generatedDynamicObject>, LLMClientService>>
 
 LLM.generateObject({
   model,
@@ -68,8 +44,4 @@ declare const generic: LanguageModel
 LLM.request({ model: generic, prompt: "Hello", providerOptions: { arbitrary: { option: true } } })
 
 const options: LanguageModelProviderOptions<typeof model> = { example: { mode: "fast" } }
-void (options satisfies LanguageModelProviderOptions<typeof model>)
-void (true satisfies GenerateRequirements)
-void (true satisfies StreamClientRequirements)
-void (true satisfies GenerateObjectRequirements)
-void (true satisfies GenerateDynamicObjectRequirements)
+void options

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

@@ -1502,25 +1502,18 @@ export interface ProjectCopyApi<E = never> {
 export type Endpoint25_0Input = {
   readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
 }
-export type Endpoint25_0Output = { readonly location: Location.Info; readonly data: Vcs.Info }
-export type VcsGetOperation<E = never> = (input?: Endpoint25_0Input) => Effect.Effect<Endpoint25_0Output, E>
+export type Endpoint25_0Output = { readonly location: Location.Info; readonly data: ReadonlyArray<Vcs.FileStatus> }
+export type VcsStatusOperation<E = never> = (input?: Endpoint25_0Input) => Effect.Effect<Endpoint25_0Output, E>
 
 export type Endpoint25_1Input = {
   readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
-}
-export type Endpoint25_1Output = { readonly location: Location.Info; readonly data: ReadonlyArray<Vcs.FileStatus> }
-export type VcsStatusOperation<E = never> = (input?: Endpoint25_1Input) => Effect.Effect<Endpoint25_1Output, E>
-
-export type Endpoint25_2Input = {
-  readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
   readonly mode: Vcs.Mode
   readonly context?: number | undefined
 }
-export type Endpoint25_2Output = { readonly location: Location.Info; readonly data: ReadonlyArray<FileDiff.Info> }
-export type VcsDiffOperation<E = never> = (input: Endpoint25_2Input) => Effect.Effect<Endpoint25_2Output, E>
+export type Endpoint25_1Output = { readonly location: Location.Info; readonly data: ReadonlyArray<FileDiff.Info> }
+export type VcsDiffOperation<E = never> = (input: Endpoint25_1Input) => Effect.Effect<Endpoint25_1Output, E>
 
 export interface VcsApi<E = never> {
-  readonly get: VcsGetOperation<E>
   readonly status: VcsStatusOperation<E>
   readonly diff: VcsDiffOperation<E>
 }

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

@@ -210,8 +210,6 @@ import type {
   Endpoint25_0Output,
   Endpoint25_1Input,
   Endpoint25_1Output,
-  Endpoint25_2Input,
-  Endpoint25_2Output,
   Endpoint26_0Output,
   Endpoint26_1Input,
   Endpoint26_1Output,
@@ -1184,26 +1182,17 @@ const adaptGroup24 = (raw: RawClient["server.projectCopy"]) => ({
 
 const Endpoint25_0 = (raw: RawClient["server.vcs"]) => (input?: Endpoint25_0Input) =>
   preserveEffect<Endpoint25_0Output>()(
-    raw["vcs.get"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError)),
-  )
-
-const Endpoint25_1 = (raw: RawClient["server.vcs"]) => (input?: Endpoint25_1Input) =>
-  preserveEffect<Endpoint25_1Output>()(
     raw["vcs.status"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError)),
   )
 
-const Endpoint25_2 = (raw: RawClient["server.vcs"]) => (input: Endpoint25_2Input) =>
-  preserveEffect<Endpoint25_2Output>()(
+const Endpoint25_1 = (raw: RawClient["server.vcs"]) => (input: Endpoint25_1Input) =>
+  preserveEffect<Endpoint25_1Output>()(
     raw["vcs.diff"]({ query: { location: input["location"], mode: input["mode"], context: input["context"] } }).pipe(
       Effect.mapError(mapClientError),
     ),
   )
 
-const adaptGroup25 = (raw: RawClient["server.vcs"]) => ({
-  get: Endpoint25_0(raw),
-  status: Endpoint25_1(raw),
-  diff: Endpoint25_2(raw),
-})
+const adaptGroup25 = (raw: RawClient["server.vcs"]) => ({ status: Endpoint25_0(raw), diff: Endpoint25_1(raw) })
 
 const Endpoint26_0 = (raw: RawClient["server.debug"]) => () =>
   preserveEffect<Endpoint26_0Output>()(raw["debug.location"]({}).pipe(Effect.mapError(mapClientError)))

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

@@ -202,8 +202,6 @@ import type {
   ProjectCopyRemoveOutput,
   ProjectCopyRefreshInput,
   ProjectCopyRefreshOutput,
-  VcsGetInput,
-  VcsGetOutput,
   VcsStatusInput,
   VcsStatusOutput,
   VcsDiffInput,
@@ -1704,18 +1702,6 @@ export function make(options: ClientOptions) {
         ),
     },
     vcs: {
-      get: (input?: VcsGetInput, requestOptions?: RequestOptions) =>
-        request<VcsGetOutput>(
-          {
-            method: "GET",
-            path: `/api/vcs`,
-            query: { location: input?.["location"] },
-            successStatus: 200,
-            declaredStatuses: [401, 400],
-            empty: false,
-          },
-          requestOptions,
-        ),
       status: (input?: VcsStatusInput, requestOptions?: RequestOptions) =>
         request<VcsStatusOutput>(
           {

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

@@ -530,8 +530,6 @@ export type ReferenceGitSource = {
 
 export type ProjectCopyCopy = { directory: string }
 
-export type VcsBranch = { current?: string; default?: string }
-
 export type VcsFileStatus = {
   file: string
   additions: number
@@ -1747,8 +1745,6 @@ export type SessionStatus2 = {
 
 export type ReferenceSource = ReferenceLocalSource | ReferenceGitSource
 
-export type VcsInfo = { branch: VcsBranch }
-
 export type PermissionRuleset = Array<PermissionRule>
 
 export type SessionInfo = {
@@ -4906,17 +4902,6 @@ export type ProjectCopyRefreshInput = {
 
 export type ProjectCopyRefreshOutput = void
 
-export type VcsGetInput = {
-  readonly location?: {
-    readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
-  }["location"]
-}
-
-export type VcsGetOutput = {
-  location: { directory: string; workspaceID?: string; project: { id: string; directory: string; canonical: string } }
-  data: VcsInfo
-}
-
 export type VcsStatusInput = {
   readonly location?: {
     readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined

packages/client/test/promise.test.ts

@@ -44,7 +44,7 @@ test("exposes every standard HTTP API group", () => {
   expect(Object.keys(client.integration.command)).toEqual(["connect", "status", "cancel"])
   expect(Object.keys(client.websearch)).toEqual(["providers", "query"])
   expect(Object.keys(client.file)).toEqual(["read", "list", "find"])
-  expect(Object.keys(client.vcs)).toEqual(["get", "status", "diff"])
+  expect(Object.keys(client.vcs)).toEqual(["status", "diff"])
   expect(Object.keys(client.pty)).toEqual(["list", "create", "get", "update", "remove"])
   expect(Object.keys(client.shell)).toEqual(["list", "create", "get", "timeout", "output", "remove"])
   expect(Object.keys(client.project)).toEqual(["list", "current", "directories"])

packages/core/src/agent.ts

@@ -1,16 +1,11 @@
 export * as Agent from "./agent"
 
-import path from "path"
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
 import { Array, Context, Effect, Layer, Types } from "effect"
 import { Agent } from "@opencode-ai/schema/agent"
-import { Global } from "@opencode-ai/util/global"
 import { Bus } from "./bus"
 import { State } from "./state"
 
-const SHELL_OUTPUT_GLOB = (data: string) => path.join(data, "shell", "*", "*")
-const TOOL_OUTPUT_GLOB = (data: string) => path.join(data, "tool-output", "*")
-
 export const ID = Agent.ID
 export type ID = typeof ID.Type
 export const Name = Agent.Name
@@ -56,13 +51,6 @@ const layer = Layer.effect(
   Service,
   Effect.gen(function* () {
     const bus = yield* Bus.Service
-    const global = yield* Global.Service
-    const permissions: Info["permissions"] = [
-      { action: "external_directory", resource: SHELL_OUTPUT_GLOB(global.data), effect: "allow" },
-      { action: "external_directory", resource: TOOL_OUTPUT_GLOB(global.data), effect: "allow" },
-      { action: "external_directory", resource: path.join(global.tmp, "*"), effect: "allow" },
-      { action: "external_directory", resource: path.join(global.config, "*"), effect: "allow" },
-    ]
     const state = State.create<Data, Draft>({
       name: "agent",
       initial: () => ({ agents: new Map() }),
@@ -73,13 +61,7 @@ const layer = Layer.effect(
           draft.default = id
         },
         update: (id, fn) => {
-          const defaults = Info.default(id)
-          const current =
-            draft.agents.get(id) ??
-            ({
-              ...defaults,
-              permissions: [...defaults.permissions, ...permissions],
-            } as Types.DeepMutable<Info>)
+          const current = draft.agents.get(id) ?? (Info.empty(id) as Types.DeepMutable<Info>)
           if (!draft.agents.has(id)) draft.agents.set(id, current)
           fn(current)
           current.id = id
@@ -132,4 +114,4 @@ const layer = Layer.effect(
   }),
 )
 
-export const node = makeLocationNode({ service: Service, layer, deps: [Bus.node, Global.node] })
+export const node = makeLocationNode({ service: Service, layer, deps: [Bus.node] })

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

@@ -58,7 +58,7 @@ export const Plugin = define({
           const files = yield* discover(fs, entry.path)
           return yield* Effect.forEach(files, (file) =>
             fs.readFileStringSafe(file.filepath).pipe(
-              Effect.map((content) => (content ? decode(file, content) : undefined)),
+              Effect.map((content) => content && decode(file, content)),
               Effect.catch(() => Effect.succeed(undefined)),
             ),
           ).pipe(

packages/core/src/instructions/builtins.ts

@@ -2,7 +2,6 @@ export * as InstructionBuiltIns from "./builtins"
 
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
 import { Context, DateTime, Effect, Layer, Schema } from "effect"
-import { Global } from "@opencode-ai/util/global"
 import { Location } from "../location"
 import { SessionSchema } from "../session/schema"
 import { Instructions } from "./index"
@@ -16,7 +15,6 @@ export class Service extends Context.Service<Service, Interface>()("@opencode/In
 const layer = Layer.effect(
   Service,
   Effect.gen(function* () {
-    const global = yield* Global.Service
     const location = yield* Location.Service
     return Service.of({
       load: (sessionID) =>
@@ -33,7 +31,6 @@ const layer = Layer.effect(
                   `  Workspace root folder: ${location.project.directory}`,
                   `  Is directory a git repo: ${location.vcs?.type === "git" ? "yes" : "no"}`,
                   `  Platform: ${process.platform}`,
-                  `  Use ${global.tmp} for temporary work outside the workspace; it already exists and is pre-approved for external directory access.`,
                   "</env>",
                 ].join("\n"),
               ),
@@ -61,4 +58,4 @@ const layer = Layer.effect(
   }),
 )
 
-export const node = makeLocationNode({ service: Service, layer, deps: [Global.node, Location.node] })
+export const node = makeLocationNode({ service: Service, layer, deps: [Location.node] })

packages/core/src/model-resolver.ts

@@ -209,12 +209,9 @@ export const fromCatalogModel = (
       body: Provider.mergeOverlay(mapping?.body, resolved.body),
       limits: { context: resolved.limit.context, input: resolved.limit.input, output: resolved.limit.output },
     }
-    const finalized = specifier.startsWith("@opencode-ai/ai/providers/amazon-bedrock")
-      ? yield* withBedrockCredentials(settings, configured)
-      : settings
     return yield* Effect.try({
       try: () => {
-        const runtime = module.model(resolved.modelID ?? resolved.id, finalized)
+        const runtime = module.model(resolved.modelID ?? resolved.id, settings)
         return LanguageModel.update(runtime, {
           provider: resolved.providerID,
           compatibility: resolved.compatibility
@@ -248,53 +245,6 @@ const withoutNativeAuthSettings = (settings: Record<string, unknown>) => {
   return rest
 }
 
-// Chain providers cache and refresh resolved credentials internally, so reuse one per
-// AWS profile instead of re-walking SSO, shared config, and instance metadata each turn.
-const bedrockChains = new Map<
-  string,
-  () => Promise<{ accessKeyId: string; secretAccessKey: string; sessionToken?: string }>
->()
-
-// Bedrock signs requests with static credentials captured at model build time; the route
-// never refreshes them. Model resolution runs before every provider turn, so falling back
-// to the AWS default chain (env, shared config, SSO, process, instance roles) here keeps
-// credentials fresh without persisting them.
-const withBedrockCredentials = Effect.fnUntraced(function* (
-  settings: Readonly<Record<string, unknown>>,
-  configured: Readonly<Record<string, unknown>>,
-) {
-  const base =
-    typeof settings.region !== "string" && process.env.AWS_REGION
-      ? { ...settings, region: process.env.AWS_REGION }
-      : settings
-  if (typeof base.apiKey === "string" || base.credentials !== undefined) return base
-  if (process.env.AWS_BEARER_TOKEN_BEDROCK) return { ...base, apiKey: process.env.AWS_BEARER_TOKEN_BEDROCK }
-  const profile = typeof configured.profile === "string" ? configured.profile : process.env.AWS_PROFILE
-  const identity = yield* Effect.tryPromise(() => {
-    const chain = bedrockChains.get(profile ?? "")
-    if (chain) return chain()
-    return import("@aws-sdk/credential-providers").then((mod) => {
-      const created = mod.fromNodeProviderChain(profile === undefined ? {} : { profile })
-      bedrockChains.set(profile ?? "", created)
-      return created()
-    })
-  }).pipe(
-    Effect.catch((cause) =>
-      Effect.logWarning("AWS credential chain resolution failed for Bedrock", { cause }).pipe(Effect.as(undefined)),
-    ),
-  )
-  if (!identity) return base
-  return {
-    ...base,
-    credentials: {
-      region: typeof base.region === "string" ? base.region : "us-east-1",
-      accessKeyId: identity.accessKeyId,
-      secretAccessKey: identity.secretAccessKey,
-      ...(identity.sessionToken === undefined ? {} : { sessionToken: identity.sessionToken }),
-    },
-  }
-})
-
 const unsupported = (model: Info) =>
   new UnsupportedPackageError({
     providerID: model.providerID,

packages/core/src/plugin/agent.ts

@@ -1,10 +1,17 @@
 export * as AgentPlugin from "./agent"
 
+import path from "path"
 import { define } from "@opencode-ai/plugin/effect/plugin"
 import { Effect } from "effect"
 import { Agent } from "../agent"
+import { Global } from "@opencode-ai/util/global"
+import { Location } from "../location"
 import { Permission } from "../permission"
 
+// Combined output files written by the Shell service, e.g. `<data>/shell/<projectID>/<shellID>.out`.
+// Whitelisted so agents can read a command's full captured output without an external-directory prompt.
+const SHELL_OUTPUT_GLOB = path.join(Global.Path.data, "shell", "*", "*")
+
 const PROMPT_EXPLORE = `You are a file search specialist. You excel at thoroughly navigating and exploring codebases.
 
 Your strengths:
@@ -93,12 +100,38 @@ Rules:
 export const Plugin = define({
   id: "opencode.agent",
   effect: Effect.fn(function* (ctx) {
+    const location = yield* Location.Service
+    const worktree = location.directory
+    const whitelistedDirs = [SHELL_OUTPUT_GLOB, path.join(Global.Path.tmp, "*")]
+    const readonlyExternalDirectory: Permission.Ruleset = [
+      { action: "external_directory", resource: "*", effect: "ask" },
+      ...whitelistedDirs.map(
+        (resource): Permission.Rule => ({ action: "external_directory", resource, effect: "allow" }),
+      ),
+    ]
+    const defaults: Permission.Ruleset = [
+      { action: "*", resource: "*", effect: "allow" },
+      ...readonlyExternalDirectory,
+      { action: "question", resource: "*", effect: "deny" },
+      { action: "plan_enter", resource: "*", effect: "deny" },
+      { action: "plan_exit", resource: "*", effect: "deny" },
+      { action: "read", resource: "*", effect: "allow" },
+      { action: "read", resource: "*.env", effect: "ask" },
+      { action: "read", resource: "*.env.*", effect: "ask" },
+      { action: "read", resource: "*.env.example", effect: "allow" },
+    ]
+
     yield* ctx.agent.transform((draft) => {
       draft.update(Agent.defaultID, (item) => {
         item.name = Agent.Name.make("Build")
         item.description = "The default agent. Executes tools based on configured permissions."
         item.mode = "primary"
-        item.permissions.push({ action: "question", resource: "*", effect: "allow" })
+        item.permissions.push(
+          ...Permission.merge(defaults, [
+            { action: "question", resource: "*", effect: "allow" },
+            { action: "plan_enter", resource: "*", effect: "allow" },
+          ]),
+        )
       })
 
       draft.update(Agent.ID.make("plan"), (item) => {
@@ -106,8 +139,18 @@ export const Plugin = define({
         item.description = "Plan mode. Disallows all edit tools."
         item.mode = "primary"
         item.permissions.push(
-          { action: "question", resource: "*", effect: "allow" },
-          { action: "edit", resource: "*", effect: "deny" },
+          ...Permission.merge(defaults, [
+            { action: "question", resource: "*", effect: "allow" },
+            { action: "plan_exit", resource: "*", effect: "allow" },
+            { action: "external_directory", resource: path.join(Global.Path.data, "plans", "*"), effect: "allow" },
+            { action: "edit", resource: "*", effect: "deny" },
+            { action: "edit", resource: path.join(".opencode", "plans", "*.md"), effect: "allow" },
+            {
+              action: "edit",
+              resource: path.relative(worktree, path.join(Global.Path.data, "plans", "*.md")),
+              effect: "allow",
+            },
+          ]),
         )
       })
 
@@ -116,16 +159,10 @@ export const Plugin = define({
         item.description =
           "General-purpose agent for researching complex questions and executing multi-step tasks. Use this agent to execute multiple units of work in parallel."
         item.mode = "subagent"
-        item.permissions.push(
-          { action: "question", resource: "*", effect: "deny" },
-          { action: "subagent", resource: "*", effect: "deny" },
-        )
+        item.permissions.push(...Permission.merge(defaults, [{ action: "subagent", resource: "*", effect: "deny" }]))
       })
 
       draft.update(Agent.ID.make("explore"), (item) => {
-        const externalDirectories = item.permissions.filter(
-          (rule) => rule.action === "external_directory" && rule.effect === "allow",
-        )
         item.name = Agent.Name.make("Explore")
         item.description =
           'Fast agent specialized for exploring codebases. Use this when you need to quickly find files by patterns (eg. "src/components/**/*.tsx"), search code for keywords (eg. "API endpoints"), or answer questions about the codebase (eg. "how do API endpoints work?"). When calling this agent, specify the desired thoroughness level: "quick" for basic searches, "medium" for moderate exploration, or "very thorough" for comprehensive analysis across multiple locations and naming conventions.'
@@ -133,6 +170,7 @@ export const Plugin = define({
         item.mode = "subagent"
         item.permissions.push(
           ...Permission.merge(
+            defaults,
             [
               { action: "*", resource: "*", effect: "deny" },
               { action: "grep", resource: "*", effect: "allow" },
@@ -140,12 +178,9 @@ export const Plugin = define({
               { action: "webfetch", resource: "*", effect: "allow" },
               { action: "websearch", resource: "*", effect: "allow" },
               { action: "read", resource: "*", effect: "allow" },
-              { action: "read", resource: "*.env", effect: "ask" },
-              { action: "read", resource: "*.env.*", effect: "ask" },
-              { action: "read", resource: "*.env.example", effect: "allow" },
               { action: "subagent", resource: "*", effect: "deny" },
             ],
-            [{ action: "external_directory", resource: "*", effect: "ask" }, ...externalDirectories],
+            readonlyExternalDirectory,
           ),
         )
       })
@@ -155,7 +190,7 @@ export const Plugin = define({
         item.mode = "primary"
         item.hidden = true
         item.system = PROMPT_COMPACTION
-        item.permissions.push({ action: "*", resource: "*", effect: "deny" })
+        item.permissions.push(...Permission.merge(defaults, [{ action: "*", resource: "*", effect: "deny" }]))
       })
 
       draft.update(Agent.ID.make("title"), (item) => {
@@ -163,7 +198,7 @@ export const Plugin = define({
         item.mode = "primary"
         item.hidden = true
         item.system = PROMPT_TITLE
-        item.permissions.push({ action: "*", resource: "*", effect: "deny" })
+        item.permissions.push(...Permission.merge(defaults, [{ action: "*", resource: "*", effect: "deny" }]))
       })
 
       draft.update(Agent.ID.make("summary"), (item) => {
@@ -171,7 +206,7 @@ export const Plugin = define({
         item.mode = "primary"
         item.hidden = true
         item.system = PROMPT_SUMMARY
-        item.permissions.push({ action: "*", resource: "*", effect: "deny" })
+        item.permissions.push(...Permission.merge(defaults, [{ action: "*", resource: "*", effect: "deny" }]))
       })
     })
   }),

packages/core/src/plugin/promise.ts

@@ -2,7 +2,6 @@ export * as PluginPromise from "./promise"
 
 import { define } from "@opencode-ai/plugin/effect/plugin"
 import type { Context, Plugin } from "@opencode-ai/plugin/promise/plugin"
-import type { SessionHooks, SessionHttp, SessionHttpMiddleware } from "@opencode-ai/plugin/promise/session"
 import type { Info } from "@opencode-ai/plugin/promise/tool"
 import { Agent } from "@opencode-ai/schema/agent"
 import { Integration } from "@opencode-ai/schema/integration"
@@ -58,62 +57,6 @@ export function fromPromise(plugin: Plugin) {
               }),
             )
 
-        function sessionHook<Name extends keyof SessionHooks>(
-          name: Name,
-          callback: (event: SessionHooks[Name]) => Promise<void> | void,
-        ): Promise<Registration>
-        function sessionHook(
-          ...registration: {
-            [Name in keyof SessionHooks]: [
-              name: Name,
-              callback: (event: SessionHooks[Name]) => Promise<void> | void,
-            ]
-          }[keyof SessionHooks]
-        ) {
-          if (registration[0] !== "http")
-            return register(
-              host.session.hook(registration[0], (event) =>
-                Effect.promise(() => Promise.resolve(registration[1](event))),
-              ),
-            )
-          return register(
-            host.session.hook("http", (event) => {
-              const middlewares: SessionHttpMiddleware[] = []
-              const output: SessionHttp = {
-                ...event,
-                use: (item) => {
-                  middlewares.push(item)
-                },
-              }
-              return Effect.promise(() => Promise.resolve(registration[1](output))).pipe(
-                Effect.flatMap(() =>
-                  Effect.forEach(
-                    middlewares,
-                    (item) =>
-                      event.use((input, next) =>
-                        Effect.tryPromise({
-                          try: (signal) => {
-                            const inputSignal = AbortSignal.any([signal, input.signal])
-                            return Promise.resolve(
-                              item(new Request(input, { signal: inputSignal }), (request) => {
-                                const requestSignal = AbortSignal.any([signal, request.signal])
-                                return Effect.runPromiseWith(
-                                  context,
-                                )(next(new Request(request, { signal: requestSignal })), { signal: requestSignal })
-                              }),
-                            )
-                          },
-                          catch: (cause) => (cause instanceof Error ? cause : new Error(String(cause))),
-                        }),
-                      ),
-                    { discard: true },
-                  ),
-                ),
-              )
-            }),
-          )
-        }
-
         const context2: Context = {
           app: host.app,
           options: host.options,
@@ -251,9 +194,7 @@ export function fromPromise(plugin: Plugin) {
                               ),
                             ),
                           refresh:
-                            refresh === undefined
-                              ? undefined
-                              : (credential) => Effect.promise(() => refresh(credential)),
+                            refresh === undefined ? undefined : (credential) => Effect.promise(() => refresh(credential)),
                         })
                       },
                       remove: draft.method.remove,
@@ -322,7 +263,8 @@ export function fromPromise(plugin: Plugin) {
               ),
           },
           session: {
-            hook: sessionHook,
+            hook: (name, callback) =>
+              register(host.session.hook(name, (event) => Effect.promise(() => Promise.resolve(callback(event))))),
             create: (input) =>
               run(
                 host.session.create(

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

@@ -225,14 +225,15 @@ export const OpenAIPlugin = define({
         })
       }
     })
-    yield* ctx.session.hook("http", (evt) =>
-      evt.use((request, next) => {
-        if (!chatgpt || evt.model.providerID !== Provider.ID.openai) return next(request)
-        const url = new URL(request.url)
-        request.headers.set("originator", "opencode")
-        request.headers.set("session-id", evt.sessionID)
-        if (url.origin !== "https://api.openai.com") return next(request)
-        return next(new Request(`${codexBaseURL}${url.pathname.replace(/^\/v1/, "")}${url.search}`, request))
+    yield* ctx.session.hook("request", (evt) =>
+      Effect.sync(() => {
+        if (!chatgpt || evt.model.providerID !== Provider.ID.openai) return
+        const url = new URL(evt.url)
+        if (url.origin === "https://api.openai.com") {
+          evt.url = `${codexBaseURL}${url.pathname.replace(/^\/v1/, "")}${url.search}`
+        }
+        evt.headers.originator = "opencode"
+        evt.headers["session-id"] = evt.sessionID
       }),
     )
 

packages/core/src/session/model-request.ts

@@ -2,11 +2,9 @@ export * as SessionModelRequest from "./model-request"
 
 import { LLM, Message, SystemPart, type LLMRequest } from "@opencode-ai/ai"
 import type { StreamOptions } from "@opencode-ai/ai/route"
-import type { SessionHttpHandler, SessionHttpMiddleware } from "@opencode-ai/plugin/effect/session"
 import type { Content } from "@opencode-ai/schema/tool"
 import { SessionError } from "@opencode-ai/schema/session-error"
-import { Cause, Config, Context, Effect, Layer, Result, Stream } from "effect"
-import { HttpClientRequest, HttpClientResponse } from "effect/unstable/http"
+import { Cause, Config, Context, Effect, Layer, Result } from "effect"
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
 import { App } from "../app"
 import { Model } from "../model"
@@ -50,7 +48,9 @@ interface Prepared {
    * One request-scoped execution operation. Unknown, hook-removed, and
    * step-limit-violating calls fail individually through the same seam.
    */
-  readonly executeTool: (input: Parameters<Tool.Snapshot["execute"]>[0]) => Effect.Effect<Tool.Result, ExecuteError>
+  readonly executeTool: (
+    input: Parameters<Tool.Snapshot["execute"]>[0],
+  ) => Effect.Effect<Tool.Result, ExecuteError>
   /** True when this request is the final Step; violating calls are rejected and no continuation follows. */
   readonly stepLimitReached: boolean
 }
@@ -137,7 +137,8 @@ export const boundImages = (messages: LLMRequest["messages"]) => {
           result: {
             ...part.result,
             value: part.result.value.map((item: Content) => {
-              if (item.type !== "file" || !isImage(item.mime) || imageBytes - removed <= IMAGE_BYTES_TARGET) return item
+              if (item.type !== "file" || !isImage(item.mime) || imageBytes - removed <= IMAGE_BYTES_TARGET)
+                return item
               removed += Buffer.byteLength(item.uri)
               return { type: "text" as const, text: IMAGE_REMOVED }
             }),
@@ -188,87 +189,55 @@ export const layer = Layer.effect(
         .map(SystemPart.make)
       const history = toLLMMessages(input.context.messages, resolved.ref, providerMetadataKey)
       const messages = stepLimitReached ? [...history, Message.assistant(MAX_STEPS_PROMPT)] : history
-      const registry = new Map(tools.definitions.map((tool) => [tool.name, tool]))
-      // The definition objects we hand to hooks, mapped back to their tools. Hooks rename a
-      // tool by moving its definition to a new key; recognizing the object recovers the tool.
-      const given = new Map(
-        tools.definitions.map(
-          (tool) => [{ description: tool.description, input: { ...tool.inputSchema } }, tool] as const,
-        ),
-      )
-      // Hooks mutate this record in place: edit descriptions and schemas, rename, or remove.
-      const context = yield* hooks.trigger("session", "context", {
+      const toolDefinitions = tools.definitions
+      const toolsByName = new Map(toolDefinitions.map((tool) => [tool.name, tool]))
+      // Hooks may reshape available definitions but cannot advertise tools omitted by permissions or the Step limit.
+      const contextEvent = yield* hooks.trigger("session", "context", {
         sessionID: session.id,
         agent: agent.id,
         model: resolved.ref,
         system,
         messages,
-        tools: Object.fromEntries(Array.from(given, ([definition, tool]) => [tool.name, definition])),
+        tools: Object.fromEntries(
+          toolDefinitions.map((tool) => [tool.name, { description: tool.description, input: { ...tool.inputSchema } }]),
+        ),
+      })
+      const hookedTools = Object.entries(contextEvent.tools).flatMap(([name, tool]) => {
+        const registered = toolsByName.get(name)
+        return registered
+          ? [{ ...registered, description: tool.description, inputSchema: tool.input }]
+          : []
       })
-      // Match each surviving entry back to its tool, by recognizing a moved definition or
-      // by key. Identity wins so a definition moved onto another tool's name still executes
-      // the tool it describes. Entries matching neither were invented by a hook and dropped.
-      // `tool.name` stays canonical so execution can translate renamed calls back.
-      const hooked = new Map(
-        Object.entries(context.tools).flatMap(([name, definition]) => {
-          const tool = given.get(definition) ?? registry.get(name)
-          if (!tool) return []
-          return [[name, { ...tool, description: definition.description, inputSchema: definition.input }] as const]
-        }),
-      )
       const request = LLM.request({
         model,
         http: {
           headers: SessionModelHeaders.make(session, app),
         },
         providerOptions: { [providerMetadataKey]: { promptCacheKey } },
-        system: context.system,
-        messages: boundImages(unsupportedParts(context.messages, resolved.capabilities)),
-        tools: Array.from(hooked, ([name, tool]) => ({ ...tool, name })),
+        system: contextEvent.system,
+        messages: boundImages(unsupportedParts(contextEvent.messages, resolved.capabilities)),
+        tools: hookedTools,
         toolChoice: stepLimitReached ? "none" : undefined,
       })
       const options: StreamOptions = {
-        http: (request, handler) =>
-          Effect.gen(function* () {
-            let latest = request
-            const origins = new WeakMap<Response, HttpClientRequest.HttpClientRequest>()
-            const middlewares: SessionHttpMiddleware[] = []
-            const web = yield* HttpClientRequest.toWeb(request)
-            yield* hooks.trigger("session", "http", {
+        transform: (request) =>
+          hooks
+            .trigger("session", "request", {
               sessionID: session.id,
               agent: agent.id,
               model: resolved.ref,
-              use: (item) =>
-                Effect.sync(() => {
-                  middlewares.push(item)
-                }),
+              ...request,
             })
-            const send = (input: Request) =>
-              Effect.gen(function* () {
-                let sent = HttpClientRequest.fromWeb(input)
-                if (input.body)
-                  sent = HttpClientRequest.bodyUint8Array(
-                    sent,
-                    new Uint8Array(yield* Effect.promise(() => input.clone().arrayBuffer())),
-                    input.headers.get("content-type") ?? undefined,
-                  )
-                latest = sent
-                const response = yield* handler(sent)
-                const body = [204, 205, 304].includes(response.status)
-                  ? null
-                  : yield* Stream.toReadableStreamEffect(response.stream)
-                const output = new Response(body, { status: response.status, headers: response.headers })
-                origins.set(output, sent)
-                return output
-              })
-            const dispatch = middlewares.reduce<SessionHttpHandler>(
-              (next, item) => (input: Request) => item(input, next),
-              send,
-            )
-            const response = yield* dispatch(web)
-            const origin = origins.get(response) ?? latest
-            return HttpClientResponse.fromWeb(origin, response)
-          }).pipe(Effect.mapError((cause) => (cause instanceof Error ? cause : new Error(String(cause))))),
+            .pipe(
+              Effect.tap((event) =>
+                Effect.sync(() => {
+                  request.url = event.url
+                  request.headers = event.headers
+                  request.body = event.body
+                }),
+              ),
+              Effect.asVoid,
+            ),
       }
       if (promptCacheSnapshots) {
         const current = PromptCacheDiagnostics.snapshot(request)
@@ -287,15 +256,13 @@ export const layer = Layer.effect(
           }),
         )
       }
-      const executeTool: Prepared["executeTool"] = (input) => {
+      const executeTool: Prepared["executeTool"] = (executeInput) => {
         if (stepLimitReached)
           return new Tool.Error({ message: "Tools are disabled after the maximum agent steps" })
-        const tool = hooked.get(input.call.name)
-        // A registered tool absent from the hooked set was removed or renamed by a hook.
-        if (!tool && registry.has(input.call.name))
-          return new Tool.Error({ message: `Tool is not available for this request: ${input.call.name}` })
+        if (toolsByName.has(executeInput.call.name) && !Object.hasOwn(contextEvent.tools, executeInput.call.name))
+          return new Tool.Error({ message: `Tool is not available for this request: ${executeInput.call.name}` })
         return tools
-          .execute(tool ? { ...input, call: { ...input.call, name: tool.name } } : input)
+          .execute(executeInput)
           .pipe(Effect.catchCauseFilter(declineDefect, (decline) => Effect.fail(decline)))
       }
       return {

packages/core/src/vcs.ts

@@ -2,7 +2,7 @@ export * as Vcs from "./vcs"
 
 import { Context, Effect, Layer } from "effect"
 import { FileDiff } from "@opencode-ai/schema/file-diff"
-import { FileStatus, Info, Mode } from "@opencode-ai/schema/vcs"
+import { FileStatus, Mode } from "@opencode-ai/schema/vcs"
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
 import { FSUtil } from "@opencode-ai/util/fs-util"
 import { Location } from "./location"
@@ -10,14 +10,13 @@ import { AppProcess } from "@opencode-ai/util/process"
 import { VcsGit } from "./vcs/git"
 import { VcsHg } from "./vcs/hg"
 
-export { FileStatus, Info, Mode }
+export { FileStatus, Mode }
 
 export interface DiffOptions {
   readonly context?: number
 }
 
 export interface Interface {
-  readonly info: () => Effect.Effect<Info>
   readonly status: () => Effect.Effect<FileStatus[]>
   readonly diff: (mode: Mode, options?: DiffOptions) => Effect.Effect<FileDiff.Info[]>
 }
@@ -41,10 +40,6 @@ const layer = Layer.effect(
     const location = yield* Location.Service
     const impl = adapter(proc, fs, location)
     return Service.of({
-      info: Effect.fn("Vcs.info")(function* () {
-        if (!impl) return { branch: {} }
-        return yield* impl.info()
-      }),
       status: Effect.fn("Vcs.status")(function* () {
         if (!impl) return []
         return yield* impl.status()

packages/core/src/vcs/git.ts

@@ -3,7 +3,7 @@ export * as VcsGit from "./git"
 import { Effect } from "effect"
 import { ChildProcess } from "effect/unstable/process"
 import { FileDiff } from "@opencode-ai/schema/file-diff"
-import { FileStatus, Info, Mode } from "@opencode-ai/schema/vcs"
+import { FileStatus, Mode } from "@opencode-ai/schema/vcs"
 import { AppProcess } from "@opencode-ai/util/process"
 import type { DiffOptions, Interface } from "../vcs"
 import { chunksByFile, emptyPatch, MAX_PATCH_BYTES, MAX_TOTAL_PATCH_BYTES, PATCH_CONTEXT_LINES } from "./patch"
@@ -20,12 +20,6 @@ export function make(proc: AppProcess.Interface, input: { directory: string; wor
   const ctx: Ctx = { git: makeGit(proc), directory: input.directory, worktree: input.worktree }
 
   return {
-    info: Effect.fn("VcsGit.info")(function* () {
-      const [current, root] = yield* Effect.all([ctx.git.branch(ctx.directory), ctx.git.defaultBranch(ctx.directory)], {
-        concurrency: 2,
-      })
-      return { branch: { current, default: root?.name } } satisfies Info
-    }),
     status: Effect.fn("VcsGit.status")(function* () {
       const git = ctx.git
       const ref = (yield* git.hasHead(ctx.directory)) ? "HEAD" : undefined

packages/core/src/vcs/hg.ts

@@ -4,7 +4,7 @@ import path from "path"
 import { Effect } from "effect"
 import { ChildProcess } from "effect/unstable/process"
 import { FileDiff } from "@opencode-ai/schema/file-diff"
-import { FileStatus, Info, Mode } from "@opencode-ai/schema/vcs"
+import { FileStatus, Mode } from "@opencode-ai/schema/vcs"
 import { FSUtil } from "@opencode-ai/util/fs-util"
 import { AppProcess } from "@opencode-ai/util/process"
 import type { DiffOptions, Interface } from "../vcs"
@@ -73,9 +73,6 @@ export function make(
   })
 
   return {
-    info: Effect.fn("VcsHg.info")(function* () {
-      return { branch: { current: yield* hg.branch(), default: "default" } } satisfies Info
-    }),
     status: Effect.fn("VcsHg.status")(function* () {
       const [items, batch] = yield* Effect.all(
         // Zero-context patches are enough to count changed lines.

packages/core/test/agent.test.ts

@@ -1,4 +1,3 @@
-import path from "path"
 import { describe, expect } from "bun:test"
 import { Effect, Exit, Fiber, Layer, Scope, Stream } from "effect"
 import { TestClock } from "effect/testing"
@@ -10,19 +9,15 @@ import { Location } from "@opencode-ai/core/location"
 import { Permission } from "@opencode-ai/core/permission"
 import { AgentPlugin } from "@opencode-ai/core/plugin/agent"
 import { AbsolutePath } from "@opencode-ai/core/schema"
-import { Global } from "@opencode-ai/util/global"
 import { location } from "./fixture/location"
 import { testEffect } from "./lib/effect"
 import { agentHost, host } from "./plugin/host"
 
 const testLocation = location({ directory: AbsolutePath.make("/project") })
 const locationLayer = Layer.succeed(Location.Service, Location.Service.of(testLocation))
-const global = Global.make({ data: "/data", config: "/config", tmp: "/tmp/opencode" })
-const globalLayer = Layer.succeed(Global.Service, Global.Service.of(global))
 
 const it = testEffect(
   AppNodeBuilder.build(LayerNode.group([Agent.node, Bus.node, Location.node]), [
-    [Global.node, globalLayer],
     [Location.node, locationLayer],
   ]) as unknown as Layer.Layer<unknown, never>,
 )
@@ -125,35 +120,25 @@ describe("Agent", () => {
       const id = Agent.ID.make("custom")
 
       yield* agent.transform((editor) => editor.update(id, () => {}))
-      const info = yield* agent.get(id)
-      expect(info?.permissions.slice(0, Agent.Info.default(id).permissions.length)).toEqual(
-        Agent.Info.default(id).permissions,
-      )
-      expect(Permission.evaluate("external_directory", path.join(global.data, "shell", "*", "*"), info?.permissions ?? []).effect).toBe(
-        "allow",
-      )
-      expect(Permission.evaluate("external_directory", path.join(global.data, "tool-output", "*"), info?.permissions ?? []).effect).toBe(
-        "allow",
-      )
-      expect(Permission.evaluate("external_directory", path.join(global.config, "*"), info?.permissions ?? []).effect).toBe(
-        "allow",
-      )
-      expect(Permission.evaluate("external_directory", path.join(global.tmp, "*"), info?.permissions ?? []).effect).toBe(
-        "allow",
-      )
+      expect(yield* agent.get(id)).toEqual(Agent.Info.empty(id))
 
       yield* agent.transform((editor) => editor.remove(id))
       expect(yield* agent.get(id)).toBeUndefined()
     }),
   )
 
-  it.effect("applies managed external directories without opting built-in agents into bash", () =>
+  it.effect("does not ambiently opt built-in agents into bash", () =>
     Effect.gen(function* () {
       const agent = yield* Agent.Service
       yield* AgentPlugin.Plugin.effect(
         host({
           agent: agentHost(agent),
         }),
+      ).pipe(
+        Effect.provideService(
+          Location.Service,
+          Location.Service.of(location({ directory: AbsolutePath.make("/project") })),
+        ),
       )
 
       const agents = yield* agent.list()
@@ -167,20 +152,6 @@ describe("Agent", () => {
         "title",
       ])
       expect((yield* agent.get(Agent.defaultID))?.system).toBeUndefined()
-      const permissions = (yield* agent.get(Agent.defaultID))?.permissions ?? []
-      expect(
-        Permission.evaluate("external_directory", path.join(global.data, "shell", "*", "*"), permissions).effect,
-      ).toBe("allow")
-      expect(
-        Permission.evaluate("external_directory", path.join(global.data, "tool-output", "*"), permissions).effect,
-      ).toBe("allow")
-      expect(Permission.evaluate("external_directory", path.join(global.config, "*"), permissions).effect).toBe("allow")
-      expect(Permission.evaluate("external_directory", path.join(global.tmp, "*"), permissions).effect).toBe("allow")
-      const explore = yield* agent.get(Agent.ID.make("explore"))
-      expect(Permission.evaluate("read", ".env", explore?.permissions ?? []).effect).toBe("ask")
-      expect(Permission.evaluate("read", ".env.local", explore?.permissions ?? []).effect).toBe("ask")
-      expect(Permission.evaluate("read", ".env.example", explore?.permissions ?? []).effect).toBe("allow")
-      expect(Permission.evaluate("read", "src/index.ts", explore?.permissions ?? []).effect).toBe("allow")
       for (const item of agents) {
         expect(item.permissions.some((rule) => rule.action === "bash" && rule.effect !== "deny")).toBe(false)
       }
@@ -194,6 +165,11 @@ describe("Agent", () => {
         host({
           agent: agentHost(agent),
         }),
+      ).pipe(
+        Effect.provideService(
+          Location.Service,
+          Location.Service.of(location({ directory: AbsolutePath.make("/project") })),
+        ),
       )
 
       yield* Effect.forEach(["general", "explore"], (id) =>

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

@@ -20,13 +20,10 @@ import { agentHost, host } from "../plugin/host"
 
 const it = testEffect(AppNodeBuilder.build(LayerNode.group([Agent.node, Bus.node, FSUtil.node, Global.node])))
 const decode = Schema.decodeUnknownSync(Config.Info)
-const defaultPermissions = (global: Global.Interface): Permission.Ruleset => [
-  ...Agent.Info.default(Agent.ID.make("test")).permissions,
-  { action: "external_directory", resource: path.join(global.data, "shell", "*", "*"), effect: "allow" },
-  { action: "external_directory", resource: path.join(global.data, "tool-output", "*"), effect: "allow" },
-  { action: "external_directory", resource: path.join(global.tmp, "*"), effect: "allow" },
-  { action: "external_directory", resource: path.join(global.config, "*"), effect: "allow" },
-]
+const defaultPermissions = [
+  { action: "*", resource: "*", effect: "allow" },
+  { action: "external_directory", resource: "*", effect: "ask" },
+] satisfies Permission.Ruleset
 
 test("rejects named agent color tokens", () => {
   expect(() => decode({ agents: { reviewer: { color: "warning" } } })).toThrow()
@@ -61,7 +58,6 @@ describe("ConfigAgentPlugin.Plugin", () => {
   it.effect("applies all global permissions before agent-specific permissions", () =>
     Effect.gen(function* () {
       const agents = yield* Agent.Service
-      const global = yield* Global.Service
       const build = Agent.ID.make("build")
       yield* agents.transform((editor) =>
         editor.update(build, (agent) => {
@@ -114,7 +110,7 @@ describe("ConfigAgentPlugin.Plugin", () => {
       const buildAgent = yield* agents.get(build)
       if (!buildAgent) throw new Error("expected configured build agent")
       expect(buildAgent.permissions).toEqual([
-        ...defaultPermissions(global),
+        ...defaultPermissions,
         { action: "bash", resource: "*", effect: "allow" },
         { action: "bash", resource: "*", effect: "ask" },
         { action: "read", resource: "*", effect: "allow" },
@@ -132,7 +128,7 @@ describe("ConfigAgentPlugin.Plugin", () => {
         model: { providerID: "openrouter", id: "openai/gpt-5", variant: "high" },
       })
       expect(reviewer.permissions).toEqual([
-        ...defaultPermissions(global),
+        ...defaultPermissions,
         { action: "bash", resource: "*", effect: "ask" },
         { action: "read", resource: "*", effect: "allow" },
         { action: "edit", resource: "*", effect: "deny" },
@@ -140,7 +136,7 @@ describe("ConfigAgentPlugin.Plugin", () => {
       ])
       expect(Permission.evaluate("read", "README.md", reviewer.permissions).effect).toBe("deny")
       expect((yield* agents.get(Agent.ID.make("late")))?.permissions).toEqual([
-        ...defaultPermissions(global),
+        ...defaultPermissions,
         { action: "bash", resource: "*", effect: "ask" },
         { action: "read", resource: "*", effect: "allow" },
         { action: "edit", resource: "*", effect: "allow" },
@@ -270,11 +266,9 @@ permissions:
 Use native v2 fields.`,
             )
             await fs.writeFile(path.join(tmp.path, "agents", "disabled.md"), "---\ndisabled: true\n---\nDisabled")
-            await fs.writeFile(path.join(tmp.path, "agents", "empty.md"), "")
             await fs.writeFile(path.join(tmp.path, "modes", "plan.md"), "Make a plan.")
           })
           const agents = yield* Agent.Service
-          const global = yield* Global.Service
           const entries = [
             new Config.Document({
               type: "document",
@@ -292,16 +286,15 @@ Use native v2 fields.`,
             system: "Review carefully.",
             description: "Markdown description",
             request: { body: { temperature: 0.5 } },
-            permissions: [...defaultPermissions(global), { action: "edit", resource: "*", effect: "deny" }],
+            permissions: [...defaultPermissions, { action: "edit", resource: "*", effect: "deny" }],
           })
           expect(yield* agents.get(Agent.ID.make("team/helper"))).toMatchObject({ system: "Help the team." })
           expect(yield* agents.get(Agent.ID.make("native"))).toMatchObject({
             system: "Use native v2 fields.",
             request: { headers: { "x-agent": "native" }, body: { effort: "high" } },
-            permissions: [...defaultPermissions(global), { action: "edit", resource: "*", effect: "deny" }],
+            permissions: [...defaultPermissions, { action: "edit", resource: "*", effect: "deny" }],
           })
           expect(yield* agents.get(Agent.ID.make("disabled"))).toBeUndefined()
-          expect(yield* agents.get(Agent.ID.make("empty"))).toBeUndefined()
           expect(yield* agents.get(Agent.ID.make("plan"))).toMatchObject({ system: "Make a plan.", mode: "primary" })
         }),
       ),

packages/core/test/global.test.ts

@@ -5,8 +5,8 @@ import path from "path"
 import { Global } from "@opencode-ai/util/global"
 
 describe("global paths", () => {
-  test("tmp path is the canonical system temp directory", async () => {
-    expect(Global.Path.tmp).toBe(await fs.realpath(path.join(os.tmpdir(), "opencode")))
+  test("tmp path is under the system temp directory", () => {
+    expect(Global.Path.tmp).toBe(path.join(os.tmpdir(), "opencode"))
     expect(Global.make().tmp).toBe(Global.Path.tmp)
   })
 

packages/core/test/instructions/builtins.test.ts

@@ -29,7 +29,7 @@ const locationLayer = Layer.succeed(
 const it = testEffect(
   AppNodeBuilder.build(InstructionBuiltIns.node, [
     [Location.node, locationLayer],
-    [Global.node, Global.layerWith({ config: "/global", tmp: "/temporary" })],
+    [Global.node, Global.layerWith({ config: "/global" })],
   ]),
 )
 
@@ -49,7 +49,6 @@ describe("InstructionBuiltIns", () => {
           `  Workspace root folder: ${projectDirectory}`,
           "  Is directory a git repo: yes",
           `  Platform: ${process.platform}`,
-          "  Use /temporary for temporary work outside the workspace; it already exists and is pre-approved for external directory access.",
           "</env>",
           "",
           `Today's date: ${localDate(timestamp)}`,

packages/core/test/mcp-instructions.test.ts

@@ -12,7 +12,7 @@ import { readInitial, readUpdate } from "./lib/instructions"
 const build = Agent.ID.make("build")
 
 const selection = (permissions: Permission.Ruleset = []) => {
-  const info = Agent.Info.make({ ...Agent.Info.default(build), permissions })
+  const info = Agent.Info.make({ ...Agent.Info.empty(build), permissions })
   return { id: info.id, info }
 }
 

packages/core/test/model-resolver.test.ts

@@ -21,22 +21,6 @@ interface ModelOptions {
   readonly limit?: Info["limit"]
 }
 
-const withEnv =
-  (env: Record<string, string | undefined>) =>
-  <A, E, R>(effect: Effect.Effect<A, E, R>) => {
-    const saved = Object.fromEntries(Object.keys(env).map((key) => [key, process.env[key]]))
-    const apply = (values: Record<string, string | undefined>) => {
-      for (const [key, value] of Object.entries(values)) {
-        if (value === undefined) delete process.env[key]
-        else process.env[key] = value
-      }
-    }
-    return Effect.sync(() => apply(env)).pipe(
-      Effect.andThen(effect),
-      Effect.ensuring(Effect.sync(() => apply(saved))),
-    )
-  }
-
 const model = (packageName: string | undefined, options: ModelOptions = {}) =>
   Info.make({
     id: ID.make("test-model"),
@@ -495,97 +479,6 @@ describe("ModelResolver", () => {
     }),
   )
 
-  it.effect("resolves Bedrock credentials from the AWS default chain when none are configured", () =>
-    Effect.gen(function* () {
-      const native = yield* ModelResolver.fromCatalogModel(
-        model(Provider.aisdk("@ai-sdk/openai"), {
-          settings: { baseURL: "https://openai.example/v1" },
-        }),
-      )
-      const env = {
-        AWS_ACCESS_KEY_ID: "chain-access",
-        AWS_SECRET_ACCESS_KEY: "chain-secret",
-        AWS_SESSION_TOKEN: "chain-session",
-        AWS_REGION: "eu-west-1",
-        AWS_PROFILE: undefined,
-        AWS_BEARER_TOKEN_BEDROCK: undefined,
-      }
-      yield* Effect.gen(function* () {
-        const resolved = yield* ModelResolver.fromCatalogModel(
-          model("@opencode-ai/ai/providers/amazon-bedrock", { settings: {} }),
-          undefined,
-          {
-            loadPackage: () =>
-              Effect.succeed({
-                model: (modelID, settings) => {
-                  expect(settings.credentials).toEqual({
-                    region: "eu-west-1",
-                    accessKeyId: "chain-access",
-                    secretAccessKey: "chain-secret",
-                    sessionToken: "chain-session",
-                  })
-                  expect(settings).not.toHaveProperty("apiKey")
-                  return LanguageModel.make({ id: modelID, provider: "package-provider", route: native.route })
-                },
-              }),
-          },
-        )
-        expect(resolved).toMatchObject({ id: "api-test-model", provider: "test-provider" })
-      }).pipe(withEnv(env))
-    }),
-  )
-
-  it.effect("uses the Bedrock bearer token env before the AWS default chain", () =>
-    Effect.gen(function* () {
-      const native = yield* ModelResolver.fromCatalogModel(
-        model(Provider.aisdk("@ai-sdk/openai"), {
-          settings: { baseURL: "https://openai.example/v1" },
-        }),
-      )
-      yield* Effect.gen(function* () {
-        yield* ModelResolver.fromCatalogModel(
-          model("@opencode-ai/ai/providers/amazon-bedrock", { settings: { region: "us-west-2" } }),
-          undefined,
-          {
-            loadPackage: () =>
-              Effect.succeed({
-                model: (modelID, settings) => {
-                  expect(settings.apiKey).toBe("bearer-token")
-                  expect(settings).not.toHaveProperty("credentials")
-                  return LanguageModel.make({ id: modelID, provider: "package-provider", route: native.route })
-                },
-              }),
-          },
-        )
-      }).pipe(withEnv({ AWS_BEARER_TOKEN_BEDROCK: "bearer-token" }))
-    }),
-  )
-
-  it.effect("keeps explicitly configured Bedrock credentials untouched", () =>
-    Effect.gen(function* () {
-      const native = yield* ModelResolver.fromCatalogModel(
-        model(Provider.aisdk("@ai-sdk/openai"), {
-          settings: { baseURL: "https://openai.example/v1" },
-        }),
-      )
-      const credentials = { region: "us-east-1", accessKeyId: "configured", secretAccessKey: "configured-secret" }
-      yield* ModelResolver.fromCatalogModel(
-        model("@opencode-ai/ai/providers/amazon-bedrock", { settings: { credentials } }),
-        undefined,
-        {
-          loadPackage: () =>
-            Effect.succeed({
-              model: (modelID, settings) => {
-                expect(settings.credentials).toEqual(credentials)
-                expect(settings).not.toHaveProperty("apiKey")
-                return LanguageModel.make({ id: modelID, provider: "package-provider", route: native.route })
-              },
-            }),
-        },
-      )
-    }),
-  )
-
   it.effect("maps OAuth credentials to native provider auth settings", () =>
     Effect.gen(function* () {
       const native = yield* ModelResolver.fromCatalogModel(
@@ -732,14 +625,12 @@ describe("ModelResolver", () => {
           settings: { region: "us-east-1", topP: 0.8, serviceTier: "priority" },
           body: {},
         }),
-        Credential.Key.make({ type: "key", key: "secret" }),
       )
       const mantle = yield* ModelResolver.fromCatalogModel(
         model(Provider.aisdk("@ai-sdk/amazon-bedrock/mantle"), {
           modelID: "openai.gpt-oss-120b",
           settings: { region: "us-east-1" },
         }),
-        Credential.Key.make({ type: "key", key: "secret" }),
       )
 
       expect(google.route.id).toBe("gemini")

packages/core/test/plugin/promise.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect } from "bun:test"
 import { Message, SystemPart } from "@opencode-ai/ai"
-import { DateTime, Deferred, Effect, Fiber, Schema } from "effect"
+import { DateTime, Effect, Schema } from "effect"
 import { Agent } from "@opencode-ai/core/agent"
 import { Catalog } from "@opencode-ai/core/catalog"
 import { Model } from "@opencode-ai/core/model"
@@ -15,7 +15,7 @@ import { SessionPending } from "@opencode-ai/core/session/pending"
 import { Tool } from "@opencode-ai/core/tool"
 import { Provider } from "@opencode-ai/core/provider"
 import { define } from "@opencode-ai/plugin/promise/plugin"
-import type { SessionHooks, SessionHttpHandler } from "@opencode-ai/plugin/effect/session"
+import type { SessionHooks } from "@opencode-ai/plugin/effect/session"
 import { testEffect } from "../lib/effect"
 import { PluginTestLayer } from "./fixture"
 import { host as testHost } from "./host"
@@ -148,9 +148,7 @@ describe("fromPromise", () => {
             expect((await ctx.agent.get({ agentID: Agent.ID.make("reviewer") })).data).toMatchObject({
               description: "Reviews code",
             })
-            await expect(ctx.agent.get({ agentID: Agent.ID.make("missing") })).rejects.toThrow(
-              "Agent not found: missing",
-            )
+            await expect(ctx.agent.get({ agentID: Agent.ID.make("missing") })).rejects.toThrow("Agent not found: missing")
             const models = (await ctx.catalog.model.list()).data
             expect(models.find((model) => model.providerID === "test" && model.id === "alias")).toMatchObject({
               modelID: "gpt-5",
@@ -223,105 +221,6 @@ describe("fromPromise", () => {
     }),
   )
 
-  it.effect("adapts promise session HTTP hooks", () =>
-    Effect.gen(function* () {
-      const plugin = yield* Plugin.Service
-      const hooks = yield* PluginHooks.Service
-      const host = yield* PluginHost.make(plugin)
-      const bodies: string[] = []
-      yield* PluginPromise.fromPromise(
-        define({
-          id: "promise-session-http",
-          setup: async (ctx) => {
-            await ctx.session.hook("http", (event) => {
-              event.use(async (request, next) => {
-                request.headers.set("x-hook", "promise")
-                await next(request)
-                const response = await next(request)
-                return new Response(`${await response.text()}-response`)
-              })
-            })
-            await ctx.session.hook("http", (event) => {
-              event.use(async (request, next) => {
-                const response = await next(request)
-                return new Response(`${await response.text()}-outer`)
-              })
-            })
-          },
-        }),
-      ).effect(host)
-      const middlewares: Parameters<PluginHooks.Domains["session"]["http"]["use"]>[0][] = []
-      const event: PluginHooks.Domains["session"]["http"] = {
-        sessionID: Session.ID.make("ses_promise_session_http"),
-        agent: Agent.ID.make("build"),
-        model: Model.Ref.make({ providerID: Provider.ID.make("test"), id: Model.ID.make("model") }),
-        use: (item) =>
-          Effect.sync(() => {
-            middlewares.push(item)
-          }),
-      }
-
-      yield* hooks.trigger("session", "http", event)
-      const request = middlewares.reduce<SessionHttpHandler>(
-        (next, item) => (input: Request) => item(input, next),
-        (input: Request) =>
-          Effect.promise(() => input.text()).pipe(
-            Effect.tap((body) => Effect.sync(() => bodies.push(body))),
-            Effect.as(new Response(input.headers.get("x-hook") ?? "missing")),
-          ),
-      )
-      const response = yield* request(new Request("https://provider.test", { method: "POST", body: "payload" }))
-
-      expect(bodies).toEqual(["payload", "payload"])
-      expect(yield* Effect.promise(() => response.text())).toBe("promise-response-outer")
-    }),
-  )
-
-  it.effect("interrupts the Effect request through a promise session HTTP hook", () =>
-    Effect.gen(function* () {
-      const plugin = yield* Plugin.Service
-      const hooks = yield* PluginHooks.Service
-      const host = yield* PluginHost.make(plugin)
-      yield* PluginPromise.fromPromise(
-        define({
-          id: "promise-session-http-interrupt",
-          setup: async (ctx) => {
-            await ctx.session.hook("http", (event) => {
-              event.use((request, next) => next(request))
-            })
-          },
-        }),
-      ).effect(host)
-      const started = yield* Deferred.make<void>()
-      const interrupted = yield* Deferred.make<void>()
-      const middlewares: Parameters<PluginHooks.Domains["session"]["http"]["use"]>[0][] = []
-      const event: PluginHooks.Domains["session"]["http"] = {
-        sessionID: Session.ID.make("ses_promise_session_http_interrupt"),
-        agent: Agent.ID.make("build"),
-        model: Model.Ref.make({ providerID: Provider.ID.make("test"), id: Model.ID.make("model") }),
-        use: (item) =>
-          Effect.sync(() => {
-            middlewares.push(item)
-          }),
-      }
-
-      yield* hooks.trigger("session", "http", event)
-      const request = middlewares.reduce<SessionHttpHandler>(
-        (next, item) => (input: Request) => item(input, next),
-        () =>
-          Deferred.succeed(started, undefined).pipe(
-            Effect.andThen(Effect.never),
-            Effect.onInterrupt(() => Deferred.succeed(interrupted, undefined)),
-          ),
-      )
-      const fiber = yield* request(new Request("https://provider.test")).pipe(Effect.forkChild)
-      yield* Deferred.await(started)
-      yield* Fiber.interrupt(fiber)
-
-      expect(yield* Deferred.isDone(interrupted)).toBeTrue()
-    }),
-  )
-
   it.effect("disposes a hook registration on request", () =>
     Effect.gen(function* () {
       const agents = yield* Agent.Service
@@ -416,17 +315,19 @@ describe("fromPromise", () => {
         id: "promise-tool",
         setup: async (ctx) => {
           await ctx.tool.transform((tools) => {
-            tools.add({
-              name: "hello",
-              options: { codemode: false },
-              description: "Hello",
-              input: Schema.Struct({ name: Schema.String }),
-              output: Schema.String,
-              execute: async ({ name }, context) => {
-                await context.progress({ phase: "greeting" })
-                return { output: `Hello, ${name}!` }
+            tools.add(
+              {
+                name: "hello",
+                options: { codemode: false },
+                description: "Hello",
+                input: Schema.Struct({ name: Schema.String }),
+                output: Schema.String,
+                execute: async ({ name }, context) => {
+                  await context.progress({ phase: "greeting" })
+                  return { output: `Hello, ${name}!` }
+                },
               },
-            })
+            )
           })
         },
       })

packages/core/test/plugin/provider-openai.test.ts

@@ -12,7 +12,6 @@ import { PluginHost } from "@opencode-ai/core/plugin/host"
 import { PluginHooks } from "@opencode-ai/core/plugin/hooks"
 import { OpenAIPlugin } from "@opencode-ai/core/plugin/provider/openai"
 import { Provider } from "@opencode-ai/core/provider"
-import type { SessionHttpHandler } from "@opencode-ai/plugin/effect/session"
 import { testEffect } from "../lib/effect"
 import { PluginTestLayer } from "./fixture"
 
@@ -30,29 +29,6 @@ function required<T>(value: T | undefined): T {
   return value
 }
 
-const http = Effect.fn(function* (providerID: Provider.ID, url: string) {
-  const middlewares: Parameters<PluginHooks.Domains["session"]["http"]["use"]>[0][] = []
-  yield* (yield* PluginHooks.Service).trigger("session", "http", {
-    sessionID: Session.ID.make("ses_test"),
-    agent: Agent.ID.make("build"),
-    model: Model.Ref.make({ providerID, id: Model.ID.make("gpt-5.5") }),
-    use: (item) =>
-      Effect.sync(() => {
-        middlewares.push(item)
-      }),
-  })
-  const request = middlewares.reduce<SessionHttpHandler>(
-    (next, item) => (input: Request) => item(input, next),
-    (input: Request) => {
-      const headers = new Headers(input.headers)
-      headers.set("x-seen-url", input.url)
-      return Effect.succeed(new Response(null, { headers }))
-    },
-  )
-  const response = yield* request(new Request(url, { method: "POST", body: "{}" }))
-  return { url: response.headers.get("x-seen-url"), headers: Object.fromEntries(response.headers.entries()) }
-})
-
 describe("OpenAIPlugin", () => {
   it.effect("registers browser and headless ChatGPT OAuth methods", () =>
     Effect.gen(function* () {
@@ -124,9 +100,33 @@ describe("OpenAIPlugin", () => {
       })
       yield* addPlugin()
 
-      const request = yield* http(Provider.ID.openai, "https://api.openai.com/v1/responses")
-      const custom = yield* http(Provider.ID.make("custom-openai"), "https://custom.example/v1/responses")
-      const proxy = yield* http(Provider.ID.openai, "https://proxy.example/v1/responses?region=us")
+      const request = yield* (yield* PluginHooks.Service).trigger("session", "request", {
+        sessionID: Session.ID.make("ses_test"),
+        agent: Agent.ID.make("build"),
+        model: Model.Ref.make({ providerID: Provider.ID.openai, id: Model.ID.make("gpt-5.5") }),
+        url: "https://api.openai.com/v1/responses",
+        method: "POST",
+        headers: {},
+        body: "{}",
+      })
+      const custom = yield* (yield* PluginHooks.Service).trigger("session", "request", {
+        sessionID: Session.ID.make("ses_test"),
+        agent: Agent.ID.make("build"),
+        model: Model.Ref.make({ providerID: Provider.ID.make("custom-openai"), id: Model.ID.make("gpt-5.5") }),
+        url: "https://custom.example/v1/responses",
+        method: "POST",
+        headers: {},
+        body: "{}",
+      })
+      const proxy = yield* (yield* PluginHooks.Service).trigger("session", "request", {
+        sessionID: Session.ID.make("ses_test"),
+        agent: Agent.ID.make("build"),
+        model: Model.Ref.make({ providerID: Provider.ID.openai, id: Model.ID.make("gpt-5.5") }),
+        url: "https://proxy.example/v1/responses?region=us",
+        method: "POST",
+        headers: {},
+        body: "{}",
+      })
 
       const provider = required(yield* catalog.provider.get(Provider.ID.openai))
       expect(provider.package).toBe("@opencode-ai/ai/providers/openai")
@@ -134,7 +134,7 @@ describe("OpenAIPlugin", () => {
       expect(provider.headers).toMatchObject({ "chatgpt-account-id": "acct_123" })
       expect(request.url).toBe("https://chatgpt.com/backend-api/codex/responses")
       expect(request.headers).toMatchObject({ originator: "opencode", "session-id": "ses_test" })
-      expect(custom.headers).not.toHaveProperty("originator")
+      expect(custom.headers).toEqual({})
       expect(proxy.url).toBe("https://proxy.example/v1/responses?region=us")
       expect(proxy.headers).toMatchObject({ originator: "opencode", "session-id": "ses_test" })
       const eligible = required(yield* catalog.model.get(Provider.ID.openai, Model.ID.make("gpt-5.5")))
@@ -184,13 +184,21 @@ describe("OpenAIPlugin", () => {
       })
       yield* addPlugin()
 
-      const request = yield* http(Provider.ID.openai, "https://api.openai.com/v1/responses")
+      const request = yield* (yield* PluginHooks.Service).trigger("session", "request", {
+        sessionID: Session.ID.make("ses_test"),
+        agent: Agent.ID.make("build"),
+        model: Model.Ref.make({ providerID: Provider.ID.openai, id: Model.ID.make("gpt-5.5") }),
+        url: "https://api.openai.com/v1/responses",
+        method: "POST",
+        headers: {},
+        body: "{}",
+      })
 
       const model = required(yield* catalog.model.get(Provider.ID.openai, Model.ID.make("gpt-5.5")))
       expect(model.package).toBe("@opencode-ai/ai/providers/openai")
       expect(model.enabled).toBe(true)
       expect(model.limit).toEqual({ context: 1_050_000, input: 922_000, output: 128_000 })
-      expect(request.headers).not.toHaveProperty("originator")
+      expect(request.headers).toEqual({})
       expect(required(yield* catalog.model.get(Provider.ID.openai, Model.ID.make("gpt-4.1"))).enabled).toBe(true)
     }),
   )

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

@@ -41,7 +41,6 @@ import { SystemPromptPlugin } from "@opencode-ai/core/plugin/system-prompt"
 import { describe, expect } from "bun:test"
 import { eq } from "drizzle-orm"
 import { Effect, Layer, Stream } from "effect"
-import { HttpClient, HttpClientResponse } from "effect/unstable/http"
 import path from "node:path"
 import { testEffect } from "./lib/effect"
 import { agentHost, catalogHost, host } from "./plugin/host"
@@ -105,39 +104,37 @@ const promptCatalog = Layer.mock(Catalog.Service, {
     small: () => Effect.succeed(undefined),
   },
 })
-const runnerLayer = (llmClient: Layer.Layer<typeof LLMClient.Service>) =>
-  AppNodeBuilder.build(SessionRunnerLLM.node, [
-    [Snapshot.node, Snapshot.noopLayer],
-    [LayerNodePlatform.llmClient, llmClient],
-    [SessionRunnerModel.node, models],
-    [InstructionBuiltIns.node, systemContext],
-    [InstructionDiscovery.node, instructionContext],
-    [Location.node, Location.boundNode({ directory: AbsolutePath.make("/project") })],
-    [SkillInstructions.node, skillInstructions],
-    [ReferenceInstructions.node, referenceInstructions],
-    [McpInstructions.node, mcpInstructions],
-    [Config.node, config],
-    [Permission.node, permission],
-    [PluginSupervisor.node, pluginSupervisor],
-  ])
-const execution = (llmClient: Layer.Layer<typeof LLMClient.Service>) =>
-  Layer.effect(
-    SessionExecution.Service,
-    Effect.gen(function* () {
-      const sessionRunner = yield* SessionRunner.Service
-      const coordinator = yield* SessionRunCoordinator.make<Session.ID, SessionRunner.RunError>({
-        drain: (sessionID, force) => sessionRunner.drain({ sessionID, force }),
-      })
-      return SessionExecution.Service.of({
-        active: coordinator.active,
-        resume: coordinator.run,
-        wake: coordinator.wake,
-        interrupt: coordinator.interrupt,
-        awaitIdle: coordinator.awaitIdle,
-      })
-    }),
-  ).pipe(Layer.provide(runnerLayer(llmClient)))
-const testLayer = (llmClient: Layer.Layer<typeof LLMClient.Service>) =>
+const runnerLayer = AppNodeBuilder.build(SessionRunnerLLM.node, [
+  [Snapshot.node, Snapshot.noopLayer],
+  [LayerNodePlatform.llmClient, client],
+  [SessionRunnerModel.node, models],
+  [InstructionBuiltIns.node, systemContext],
+  [InstructionDiscovery.node, instructionContext],
+  [Location.node, Location.boundNode({ directory: AbsolutePath.make("/project") })],
+  [SkillInstructions.node, skillInstructions],
+  [ReferenceInstructions.node, referenceInstructions],
+  [McpInstructions.node, mcpInstructions],
+  [Config.node, config],
+  [Permission.node, permission],
+  [PluginSupervisor.node, pluginSupervisor],
+])
+const execution = Layer.effect(
+  SessionExecution.Service,
+  Effect.gen(function* () {
+    const sessionRunner = yield* SessionRunner.Service
+    const coordinator = yield* SessionRunCoordinator.make<Session.ID, SessionRunner.RunError>({
+      drain: (sessionID, force) => sessionRunner.drain({ sessionID, force }),
+    })
+    return SessionExecution.Service.of({
+      active: coordinator.active,
+      resume: coordinator.run,
+      wake: coordinator.wake,
+      interrupt: coordinator.interrupt,
+      awaitIdle: coordinator.awaitIdle,
+    })
+  }),
+).pipe(Layer.provide(runnerLayer))
+const it = testEffect(
   AppNodeBuilder.build(
     LayerNode.group([
       Database.node,
@@ -159,7 +156,7 @@ const testLayer = (llmClient: Layer.Layer<typeof LLMClient.Service>) =>
       Session.node,
     ]),
     [
-      [LayerNodePlatform.llmClient, llmClient],
+      [LayerNodePlatform.llmClient, client],
       [Permission.node, permission],
       [Catalog.node, promptCatalog],
       [SessionRunnerModel.node, models],
@@ -171,10 +168,10 @@ const testLayer = (llmClient: Layer.Layer<typeof LLMClient.Service>) =>
       [Config.node, config],
       [Snapshot.node, Snapshot.noopLayer],
       [PluginSupervisor.node, pluginSupervisor],
-      [SessionExecution.node, execution(llmClient)],
+      [SessionExecution.node, execution],
     ],
-  )
-const it = testEffect(testLayer(client))
+  ),
+)
 const sessionID = Session.ID.make("ses_runner_recorded")
 
 describe("SessionRunnerLLM recorded", () => {
@@ -250,90 +247,3 @@ describe("SessionRunnerLLM recorded", () => {
     }),
   )
 })
-
-describe("SessionModelRequest HTTP bridge", () => {
-  const bodies: Uint8Array[] = []
-  const methods: string[] = []
-  const response = [
-    'data: {"id":"chatcmpl_test","object":"chat.completion.chunk","created":0,"model":"gpt-4o-mini","choices":[{"index":0,"delta":{"role":"assistant","content":"Hello!"},"finish_reason":null}]}',
-    'data: {"id":"chatcmpl_test","object":"chat.completion.chunk","created":0,"model":"gpt-4o-mini","choices":[{"index":0,"delta":{},"finish_reason":"stop"}]}',
-    "data: [DONE]",
-    "",
-  ].join("\n\n")
-  const transport = Layer.succeed(
-    HttpClient.HttpClient,
-    HttpClient.make((request) =>
-      Effect.sync(() => {
-        if (request.body._tag !== "Uint8Array") throw new Error(`Unexpected request body: ${request.body._tag}`)
-        methods.push(request.method)
-        bodies.push(request.body.body.slice())
-        return HttpClientResponse.fromWeb(
-          request,
-          new Response(response, { headers: { "content-type": "text/event-stream" } }),
-        )
-      }),
-    ),
-  )
-  const retryIt = testEffect(
-    testLayer(LLMClient.layer.pipe(Layer.provide(RequestExecutor.layer.pipe(Layer.provide(transport))))),
-  )
-
-  retryIt.effect("lets an Effect plugin send the same POST Request twice", () =>
-    Effect.gen(function* () {
-      bodies.length = 0
-      methods.length = 0
-      const agents = yield* Agent.Service
-      const catalog = yield* Catalog.Service
-      const hooks = yield* PluginHooks.Service
-      yield* agents.transform((draft) =>
-        draft.update(Agent.ID.make("build"), (agent) => {
-          agent.mode = "primary"
-          agent.permissions.push({ action: "execute", resource: "*", effect: "deny" })
-        }),
-      )
-      const pluginHost = host({
-        agent: agentHost(agents),
-        catalog: catalogHost(catalog),
-        session: { hook: (name, callback) => hooks.register("session", name, callback) },
-      })
-      yield* pluginHost.session.hook("http", (event) =>
-        event.use((request, next) =>
-          Effect.gen(function* () {
-            yield* next(request).pipe(Effect.flatMap((response) => Effect.promise(() => response.text())))
-            return yield* next(request)
-          }),
-        ),
-      )
-      yield* Effect.forEach(SystemPromptPlugin.Plugins, (plugin) => plugin.effect(pluginHost), { discard: true })
-      const { db } = yield* Database.Service
-      yield* db
-        .insert(ProjectTable)
-        .values({ id: Project.ID.global, worktree: AbsolutePath.make("/project"), sandboxes: [] })
-        .onConflictDoNothing()
-        .run()
-        .pipe(Effect.orDie)
-      const retrySessionID = Session.ID.make("ses_model_request_http_retry")
-      yield* db
-        .insert(SessionTable)
-        .values({
-          id: retrySessionID,
-          project_id: Project.ID.global,
-          slug: "test",
-          directory: "/project",
-          title: "test",
-          version: "test",
-        })
-        .run()
-        .pipe(Effect.orDie)
-      const session = yield* Session.Service
-      yield* session.prompt({ sessionID: retrySessionID, text: "Say hello.", resume: false })
-
-      yield* session.resume(retrySessionID)
-
-      expect(methods).toEqual(["POST", "POST"])
-      expect(bodies).toHaveLength(2)
-      expect(bodies[0]?.byteLength).toBeGreaterThan(0)
-      expect(bodies[1]).toEqual(bodies[0])
-    }),
-  )
-})

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

@@ -887,27 +887,6 @@ describe("SessionRunnerLLM", () => {
     }),
   )
 
-  it.effect("executes a tool renamed by a session context hook", () =>
-    Effect.gen(function* () {
-      const session = yield* setup
-      const hooks = yield* PluginHooks.Service
-      yield* hooks.register("session", "context", (event) =>
-        Effect.sync(() => {
-          event.tools.renamed_echo = event.tools.echo!
-          delete event.tools.echo
-        }),
-      )
-      yield* admit(session, "Use the renamed tool")
-      yield* TestLLM.push(TestLLM.tool("call-renamed", "renamed_echo", { text: "renamed" }), [])
-
-      yield* session.resume(sessionID)
-
-      expect(requests[0]?.tools.map((tool) => tool.name)).toContain("renamed_echo")
-      expect(requests[0]?.tools.map((tool) => tool.name)).not.toContain("echo")
-      expect(executions).toEqual(["renamed"])
-    }),
-  )
-
   it.effect("advertises and executes a location registered tool", () =>
     Effect.gen(function* () {
       const session = yield* setup

packages/core/test/shared-schema.test.ts

@@ -166,7 +166,7 @@ test("Core reuses the canonical shared schemas", async () => {
   ]
   for (const [core, shared] of schemas) expect(core).toBe(shared)
 
-  expect(Agent.Info.default(Agent.ID.make("test"))).toEqual(Agent.Info.default(Agent.ID.make("test")))
+  expect(Agent.Info.empty(Agent.ID.make("test"))).toEqual(Agent.Info.empty(Agent.ID.make("test")))
   expect(coreModel.Info.default(coreProvider.ID.make("test"), coreModel.ID.make("model"))).toEqual(
     Model.Info.default(Provider.ID.make("test"), Model.ID.make("model")),
   )

packages/core/test/skill/instructions.test.ts

@@ -47,7 +47,7 @@ const layer = (list: () => Skill.Info[]) =>
 describe("SkillInstructions", () => {
   it.effect("renders described agent skills and updates the complete available list", () => {
     const agent = Agent.Info.make({
-      ...Agent.Info.default(build),
+      ...Agent.Info.empty(build),
       permissions: [{ action: "skill", resource: "denied", effect: "deny" }],
     })
     let skills = [hidden, denied, manual, effect]
@@ -80,7 +80,7 @@ describe("SkillInstructions", () => {
   })
 
   it.effect("announces added and removed skills as deltas without restating the list", () => {
-    const agent = Agent.Info.make(Agent.Info.default(build))
+    const agent = Agent.Info.make(Agent.Info.empty(build))
     const debugging = Skill.Info.make({
       id: Skill.ID.make("debugging"),
       name: Skill.Name.make("Debugging"),
@@ -117,7 +117,7 @@ describe("SkillInstructions", () => {
   })
 
   it.effect("restates the full skill list when a description changes", () => {
-    const agent = Agent.Info.make(Agent.Info.default(build))
+    const agent = Agent.Info.make(Agent.Info.empty(build))
     let skills = [effect]
     return Effect.gen(function* () {
       const instructions = yield* SkillInstructions.Service
@@ -138,7 +138,7 @@ describe("SkillInstructions", () => {
 
   it.effect("omits instructions when the selected agent denies all skills", () => {
     const agent = Agent.Info.make({
-      ...Agent.Info.default(build),
+      ...Agent.Info.empty(build),
       permissions: [{ action: "skill", resource: "*", effect: "deny" }],
     })
     return Effect.gen(function* () {
@@ -149,7 +149,7 @@ describe("SkillInstructions", () => {
 
   it.effect("omits instructions when a resource-specific denial follows the global denial", () => {
     const agent = Agent.Info.make({
-      ...Agent.Info.default(build),
+      ...Agent.Info.empty(build),
       permissions: [
         { action: "skill", resource: "*", effect: "deny" },
         { action: "skill", resource: "hidden", effect: "deny" },
@@ -163,7 +163,7 @@ describe("SkillInstructions", () => {
 
   it.effect("retains specifically allowed skills after a global denial", () => {
     const agent = Agent.Info.make({
-      ...Agent.Info.default(build),
+      ...Agent.Info.empty(build),
       permissions: [
         { action: "skill", resource: "*", effect: "deny" },
         { action: "skill", resource: "effect", effect: "allow" },
@@ -179,7 +179,7 @@ describe("SkillInstructions", () => {
 
   it.effect("omits instructions when a specifically allowed skill is denied again", () => {
     const agent = Agent.Info.make({
-      ...Agent.Info.default(build),
+      ...Agent.Info.empty(build),
       permissions: [
         { action: "skill", resource: "*", effect: "deny" },
         { action: "skill", resource: "effect", effect: "allow" },

packages/core/test/vcs-hg.test.ts

@@ -160,7 +160,6 @@ describeHg("Vcs mercurial", () => {
           await commitAll(directory, "feature change")
         })
         const diff = yield* vcs.diff("branch")
-        expect(yield* vcs.info()).toEqual({ branch: { current: "feature", default: "default" } })
         expect(diff.map((item) => ({ file: item.file, status: item.status }))).toEqual([
           { file: "file.txt", status: "modified" },
         ])

packages/core/test/vcs.test.ts

@@ -53,7 +53,6 @@ describe("Vcs", () => {
     withTmp((directory) =>
       Effect.gen(function* () {
         const vcs = yield* Vcs.Service
-        expect(yield* vcs.info()).toEqual({ branch: {} })
         expect(yield* vcs.status()).toEqual([])
         expect(yield* vcs.diff("working")).toEqual([])
         expect(yield* vcs.diff("branch")).toEqual([])
@@ -164,7 +163,6 @@ describe("Vcs", () => {
           await commitAll(directory, "feature change")
         })
         const diff = yield* vcs.diff("branch")
-        expect(yield* vcs.info()).toEqual({ branch: { current: "feature", default: "main" } })
         expect(diff.map((item) => ({ file: item.file, status: item.status }))).toEqual([
           { file: "file.txt", status: "modified" },
         ])

packages/plugin/src/effect/session.ts

@@ -1,9 +1,10 @@
 import type { SessionApi } from "@opencode-ai/client/effect/api"
 import type { Message, SystemPart } from "@opencode-ai/ai"
+import type { HttpRequest } from "@opencode-ai/ai/route"
 import type { Agent } from "@opencode-ai/schema/agent"
 import type { Model } from "@opencode-ai/schema/model"
 import type { Session } from "@opencode-ai/schema/session"
-import type { Effect, JsonSchema } from "effect"
+import type { JsonSchema } from "effect"
 import type { Hooks } from "./registration.js"
 
 export interface SessionContext {
@@ -15,23 +16,15 @@ export interface SessionContext {
   tools: Record<string, { description: string; input: JsonSchema.JsonSchema }>
 }
 
-export interface SessionHttp {
+export interface SessionRequest extends HttpRequest {
   readonly sessionID: Session.ID
   readonly agent: Agent.ID
   readonly model: Model.Ref
-  readonly use: (middleware: SessionHttpMiddleware) => Effect.Effect<void>
 }
 
-export type SessionHttpHandler = (request: Request) => Effect.Effect<Response, Error>
-
-export type SessionHttpMiddleware = (
-  request: Request,
-  next: SessionHttpHandler,
-) => Effect.Effect<Response, Error>
-
 export interface SessionHooks {
   readonly context: SessionContext
-  readonly http: SessionHttp
+  readonly request: SessionRequest
 }
 
 export type SessionDomain = Pick<

packages/plugin/src/promise/session.ts

@@ -1,5 +1,6 @@
 import type { SessionApi } from "@opencode-ai/client/promise/api"
 import type { Message, SystemPart } from "@opencode-ai/ai"
+import type { HttpRequest } from "@opencode-ai/ai/route"
 import type { Agent } from "@opencode-ai/schema/agent"
 import type { Model } from "@opencode-ai/schema/model"
 import type { Session } from "@opencode-ai/schema/session"
@@ -15,23 +16,15 @@ export interface SessionContext {
   tools: Record<string, { description: string; input: JsonSchema.JsonSchema }>
 }
 
-export interface SessionHttp {
+export interface SessionRequest extends HttpRequest {
   readonly sessionID: Session.ID
   readonly agent: Agent.ID
   readonly model: Model.Ref
-  readonly use: (middleware: SessionHttpMiddleware) => void
 }
 
-export type SessionHttpHandler = (request: Request) => Promise<Response>
-
-export type SessionHttpMiddleware = (
-  request: Request,
-  next: SessionHttpHandler,
-) => Promise<Response> | Response
-
 export interface SessionHooks {
   readonly context: SessionContext
-  readonly http: SessionHttp
+  readonly request: SessionRequest
 }
 
 export type SessionDomain = Pick<

packages/protocol/openapi.json

@@ -851,16 +851,6 @@
                       }
                     ]
                   },
-                  "title": {
-                    "anyOf": [
-                      {
-                        "type": "string"
-                      },
-                      {
-                        "type": "null"
-                      }
-                    ]
-                  },
                   "agent": {
                     "anyOf": [
                       {
@@ -11311,104 +11301,6 @@
         }
       }
     },
-    "/api/vcs": {
-      "get": {
-        "tags": [
-          "vcs"
-        ],
-        "operationId": "v2.vcs.get",
-        "parameters": [
-          {
-            "name": "location",
-            "in": "query",
-            "schema": {
-              "anyOf": [
-                {
-                  "type": "object",
-                  "properties": {
-                    "directory": {
-                      "anyOf": [
-                        {
-                          "type": "string"
-                        },
-                        {
-                          "type": "null"
-                        }
-                      ]
-                    },
-                    "workspace": {
-                      "anyOf": [
-                        {
-                          "type": "string"
-                        },
-                        {
-                          "type": "null"
-                        }
-                      ]
-                    }
-                  },
-                  "additionalProperties": false
-                },
-                {
-                  "type": "null"
-                }
-              ]
-            },
-            "required": false,
-            "style": "deepObject",
-            "explode": true
-          }
-        ],
-        "security": [],
-        "responses": {
-          "200": {
-            "description": "Success",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "type": "object",
-                  "properties": {
-                    "location": {
-                      "$ref": "#/components/schemas/Location.Info"
-                    },
-                    "data": {
-                      "$ref": "#/components/schemas/Vcs.Info"
-                    }
-                  },
-                  "required": [
-                    "location",
-                    "data"
-                  ],
-                  "additionalProperties": false
-                }
-              }
-            }
-          },
-          "400": {
-            "description": "InvalidRequestError",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/InvalidRequestError"
-                }
-              }
-            }
-          },
-          "401": {
-            "description": "UnauthorizedError",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/UnauthorizedError"
-                }
-              }
-            }
-          }
-        },
-        "description": "Get current and default branch information for the requested location.",
-        "summary": "VCS info"
-      }
-    },
     "/api/vcs/status": {
       "get": {
         "tags": [
@@ -12140,15 +12032,11 @@
               },
               "directory": {
                 "type": "string"
-              },
-              "canonical": {
-                "type": "string"
               }
             },
             "required": [
               "id",
-              "directory",
-              "canonical"
+              "directory"
             ],
             "additionalProperties": false
           }
@@ -12610,6 +12498,7 @@
           "cost",
           "tokens",
           "time",
+          "title",
           "location"
         ],
         "additionalProperties": false
@@ -13948,15 +13837,6 @@
           },
           "message": {
             "type": "string"
-          },
-          "status": {
-            "type": "integer",
-            "allOf": [
-              {
-                "minimum": 100,
-                "maximum": 599
-              }
-            ]
           }
         },
         "required": [
@@ -20885,7 +20765,7 @@
           "id": {
             "type": "string"
           },
-          "canonical": {
+          "worktree": {
             "type": "string"
           },
           "vcs": {
@@ -20912,7 +20792,7 @@
         },
         "required": [
           "id",
-          "canonical",
+          "worktree",
           "time",
           "sandboxes"
         ],
@@ -20926,15 +20806,11 @@
           },
           "directory": {
             "type": "string"
-          },
-          "canonical": {
-            "type": "string"
           }
         },
         "required": [
           "id",
-          "directory",
-          "canonical"
+          "directory"
         ],
         "additionalProperties": false
       },
@@ -22569,6 +22445,7 @@
           "slug",
           "projectID",
           "directory",
+          "title",
           "version",
           "time"
         ],
@@ -29250,30 +29127,6 @@
         ],
         "additionalProperties": false
       },
-      "Vcs.Branch": {
-        "type": "object",
-        "properties": {
-          "current": {
-            "type": "string"
-          },
-          "default": {
-            "type": "string"
-          }
-        },
-        "additionalProperties": false
-      },
-      "Vcs.Info": {
-        "type": "object",
-        "properties": {
-          "branch": {
-            "$ref": "#/components/schemas/Vcs.Branch"
-          }
-        },
-        "required": [
-          "branch"
-        ],
-        "additionalProperties": false
-      },
       "Vcs.FileStatus": {
         "type": "object",
         "properties": {

packages/protocol/src/groups/vcs.ts

@@ -13,20 +13,6 @@ const DiffQuery = Schema.Struct({
 })
 
 export const VcsGroup = HttpApiGroup.make("server.vcs")
-  .add(
-    HttpApiEndpoint.get("vcs.get", "/api/vcs", {
-      query: LocationQuery,
-      success: Location.response(Vcs.Info),
-    })
-      .annotateMerge(locationQueryOpenApi)
-      .annotateMerge(
-        OpenApi.annotations({
-          identifier: "v2.vcs.get",
-          summary: "VCS info",
-          description: "Get current and default branch information for the requested location.",
-        }),
-      ),
-  )
   .add(
     HttpApiEndpoint.get("vcs.status", "/api/vcs/status", {
       query: LocationQuery,

packages/schema/src/agent.ts

@@ -36,7 +36,7 @@ export const Info = Schema.Struct({
   .annotate({ identifier: "Agent.Info" })
   .pipe(
     statics(() => ({
-      default: (id: ID) =>
+      empty: (id: ID) =>
         ({
           id,
           name: Name.make(id),
@@ -46,9 +46,6 @@ export const Info = Schema.Struct({
           permissions: [
             { action: "*", resource: "*", effect: "allow" },
             { action: "external_directory", resource: "*", effect: "ask" },
-            { action: "read", resource: "*.env", effect: "ask" },
-            { action: "read", resource: "*.env.*", effect: "ask" },
-            { action: "read", resource: "*.env.example", effect: "allow" },
           ],
         }) satisfies Info,
     })),

packages/schema/src/vcs.ts

@@ -1,18 +1,7 @@
 export * as Vcs from "./vcs.js"
 
 import { Schema } from "effect"
-import { NonNegativeInt, optional } from "./schema.js"
-
-export const Branch = Schema.Struct({
-  current: optional(Schema.String),
-  default: optional(Schema.String),
-}).annotate({ identifier: "Vcs.Branch" })
-export interface Branch extends Schema.Schema.Type<typeof Branch> {}
-
-export const Info = Schema.Struct({
-  branch: Branch,
-}).annotate({ identifier: "Vcs.Info" })
-export interface Info extends Schema.Schema.Type<typeof Info> {}
+import { NonNegativeInt } from "./schema.js"
 
 export const Mode = Schema.Literals(["working", "branch"]).annotate({ identifier: "Vcs.Mode" })
 export type Mode = typeof Mode.Type

packages/schema/test/contract-hygiene.test.ts

@@ -16,7 +16,6 @@ import { FileDiff } from "../src/file-diff.js"
 import { Money } from "../src/money.js"
 import { Skill } from "../src/skill.js"
 import { Shell } from "../src/shell.js"
-import { Vcs } from "../src/vcs.js"
 import { PersistedRevert } from "../src/session-revert.js"
 import { AbsolutePath, optional } from "../src/schema.js"
 
@@ -135,10 +134,6 @@ describe("contract hygiene", () => {
     expect(Pty.ID.create()).toStartWith("pty_")
   })
 
-  test("VCS info omits unavailable branch names", () => {
-    expect(Schema.encodeSync(Vcs.Info)({ branch: { current: undefined, default: undefined } })).toEqual({ branch: {} })
-  })
-
   test("reusable public identifiers are stable and unique", () => {
     const identifiers = [
       Agent.Color,
@@ -171,8 +166,6 @@ describe("contract hygiene", () => {
       SessionPending.SyntheticData,
       SessionPending.User,
       SessionPending.Synthetic,
-      Vcs.Branch,
-      Vcs.Info,
     ].map((schema) => schema.ast.annotations?.identifier)
 
     expect(identifiers.every((identifier) => typeof identifier === "string")).toBe(true)

packages/server/src/handlers/vcs.ts

@@ -7,14 +7,6 @@ import { response } from "../location"
 export const VcsHandler = HttpApiBuilder.group(Api, "server.vcs", (handlers) =>
   Effect.gen(function* () {
     return handlers
-      .handle("vcs.get", () =>
-        response(
-          Effect.gen(function* () {
-            const vcs = yield* Vcs.Service
-            return yield* vcs.info()
-          }),
-        ),
-      )
       .handle("vcs.status", () =>
         response(
           Effect.gen(function* () {

packages/tui/src/context/session-tabs.tsx

@@ -1,4 +1,4 @@
-import { createEffect, createMemo, createSignal, onCleanup } from "solid-js"
+import { createEffect, createMemo, createSignal, on, onCleanup } from "solid-js"
 import { isDeepEqual } from "remeda"
 import { createSimpleContext } from "./helper"
 import { useClient } from "./client"
@@ -126,22 +126,40 @@ export const { use: useSessionTabs, provider: SessionTabsProvider } = createSimp
       })
     }
 
+    createEffect(
+      on(
+        [
+          () => (enabled() && route.data.type === "session" ? route.data.sessionID : undefined),
+          () => config.tabs?.scope,
+          () => paths.cwd,
+        ],
+        ([routed]) => {
+          if (!routed || routed === "dummy") return
+          const sessionID = root(routed)
+          history = recordSessionTabHistory(history, sessionID)
+          const fallback = newTab() ? NEW_SESSION_TAB_TITLE : undefined
+          update((draft) => {
+            draft.tabs = openSessionTab(draft.tabs, {
+              sessionID,
+              title: title(sessionID, draft.tabs.find((tab) => tab.sessionID === sessionID)?.title, fallback),
+            })
+            delete draft.unread[sessionID]
+          })
+        },
+      ),
+    )
+
     createEffect(() => {
-      if (!enabled()) return
-      if (route.data.type !== "session" || route.data.sessionID === "dummy") return
+      if (!enabled() || route.data.type !== "session" || route.data.sessionID === "dummy") return
       const sessionID = root(route.data.sessionID)
-      history = recordSessionTabHistory(history, sessionID)
-      const fallback = newTab() ? NEW_SESSION_TAB_TITLE : undefined
-      const tabs = openSessionTab(state().tabs, {
-        sessionID,
-        title: title(sessionID, state().tabs.find((tab) => tab.sessionID === sessionID)?.title, fallback),
-      })
-      if (tabs === state().tabs && !state().unread[sessionID]) return
+      const tab = state().tabs.find((tab) => tab.sessionID === sessionID)
+      if (!tab) return
+      const nextTitle = title(sessionID, tab.title)
+      if ((!nextTitle || nextTitle === tab.title) && !state().unread[sessionID]) return
       update((draft) => {
-        draft.tabs = openSessionTab(draft.tabs, {
-          sessionID,
-          title: title(sessionID, draft.tabs.find((tab) => tab.sessionID === sessionID)?.title, fallback),
-        })
+        const tab = draft.tabs.find((tab) => tab.sessionID === sessionID)
+        if (!tab) return
+        draft.tabs = openSessionTab(draft.tabs, { sessionID, title: title(sessionID, tab.title) })
         delete draft.unread[sessionID]
       })
     })

packages/tui/src/mini/tool.ts

@@ -125,6 +125,7 @@ type ToolName =
   | "webfetch"
   | "websearch"
   | "skill"
+  | "plan_exit"
 
 type ToolRule = {
   view: ToolView
@@ -515,6 +516,15 @@ function runLsp(p: ToolProps): ToolInline {
   }
 }
 
+function runPlanExit(p: ToolProps): ToolInline {
+  return {
+    icon: "→",
+    title: "Switching to build agent",
+    mode: "block",
+    body: p.frame.status === "completed" ? p.frame.output : undefined,
+  }
+}
+
 function patchTitle(file: PatchFile, directory?: string): string {
   if (file.status === "added") {
     return `# Created ${toolPath(file.file, { directory })}`
@@ -1067,6 +1077,16 @@ const TOOL_RULES = {
       start: scrollSkillStart,
     },
   },
+  plan_exit: {
+    view: {
+      output: true,
+      final: false,
+    },
+    run: runPlanExit,
+    scroll: {
+      start: () => "",
+    },
+  },
 } as const satisfies ToolRegistry
 
 function key(name: string): name is ToolName {

packages/tui/test/context/session-tabs.test.tsx

@@ -170,6 +170,31 @@ test("concurrent TUIs do not alternate shared tab titles from divergent session
   }
 })
 
+test("closing a tab is not undone by another TUI viewing the same session", async () => {
+  const state = stateDir("opencode-session-tabs-shared-close-")
+  const first = await renderSessionTabs("shared", { state })
+  const second = await renderSessionTabs("shared", { state })
+
+  try {
+    await wait(() => first.tabs.tabs().some((tab) => tab.sessionID === "shared"))
+    await wait(() => second.tabs.tabs().some((tab) => tab.sessionID === "shared"))
+    first.tabs.close()
+    await wait(() => first.route.data.type === "home")
+    await wait(() => !second.tabs.tabs().some((tab) => tab.sessionID === "shared"))
+    await Bun.sleep(50)
+
+    expect(first.tabs.tabs().some((tab) => tab.sessionID === "shared")).toBe(false)
+
+    second.route.navigate({ type: "home" })
+    await wait(() => second.route.data.type === "home")
+    second.route.navigate({ type: "session", sessionID: "shared" })
+    await wait(() => first.tabs.tabs().some((tab) => tab.sessionID === "shared"))
+  } finally {
+    first.destroy()
+    second.destroy()
+  }
+})
+
 test("user prompt admissions pulse an already-busy background tab", async () => {
   const setup = await renderSessionTabs("background")
   const admitted = (sessionID: string, inputID: string): OpenCodeEvent => ({

packages/util/src/global.ts

@@ -13,8 +13,6 @@ const config = path.join(xdgConfig!, app)
 const state = path.join(xdgState!, app)
 const tmp = path.join(os.tmpdir(), app)
 
-await fs.mkdir(tmp, { recursive: true })
-
 const paths = {
   get home() {
     return process.env.OPENCODE_TEST_HOME ?? os.homedir()
@@ -26,7 +24,7 @@ const paths = {
   cache,
   config,
   state,
-  tmp: await fs.realpath(tmp),
+  tmp,
 }
 
 export const Path = paths
@@ -37,6 +35,7 @@ await Promise.all([
   fs.mkdir(Path.data, { recursive: true }),
   fs.mkdir(Path.config, { recursive: true }),
   fs.mkdir(Path.state, { recursive: true }),
+  fs.mkdir(Path.tmp, { recursive: true }),
   fs.mkdir(Path.log, { recursive: true }),
   fs.mkdir(Path.bin, { recursive: true }),
   fs.mkdir(Path.repos, { recursive: true }),

packages/www/content/docs/(Configure)/permissions.mdx

@@ -81,7 +81,8 @@ current built-in actions use these resources:
 | `<server>_<tool>` | `*` for an MCP tool; unsupported characters in both names become `_` |
 | `execute` | `*`; controls availability of the Code Mode dispatcher, while each nested tool still enforces its own permission |
 
-`doom_loop` and `lsp` are not current V2 Core permission actions.
+Built-in agent policy also reserves `plan_enter` and `plan_exit` for plan-mode
+transitions. `doom_loop` and `lsp` are not current V2 Core permission actions.
 
 ## External directories
 
@@ -131,9 +132,7 @@ matching, so authorize only trusted directory boundaries.
 
 ## Defaults
 
-Every agent, including custom agents, starts with ordered defaults that allow
-tools, ask for external directories, ask for `.env` reads, and allow
-`.env.example` reads. Shipped agents then add their own policies:
+The evaluator's fallback is `ask`, but shipped agents include ordered defaults:
 
 | Agent | Effective default policy |
 | --- | --- |
@@ -154,12 +153,8 @@ The base read rules are ordered as follows:
 ]
 ```
 
-OpenCode also permits its managed tool-output, shell-output, temporary, and
-global configuration directories. These exceptions apply only to the
-external-directory boundary for every agent; the underlying action still uses
-its own permission rules. The environment instructions identify the temporary
-directory available for work outside the workspace. Later global and
-agent-specific rules can override these defaults.
+OpenCode also permits its managed tool-output and temporary directories where
+needed. These exceptions do not grant general external-directory access.
 
 ## Agent overrides
 

packages/www/content/docs/build/plugins.mdx

@@ -239,29 +239,16 @@ without restarting OpenCode.
 
 ### Runtime hooks
 
-Runtime hooks intercept live operations:
+Runtime hooks intercept live operations. Their event objects expose specific
+mutable fields:
 
 | Hook                                        | Mutable fields                                                                 |
 | ------------------------------------------- | ------------------------------------------------------------------------------ |
 | `ctx.aisdk.hook("sdk", callback)`           | `sdk`, after inspecting `model`, `package`, and `options`                      |
 | `ctx.aisdk.hook("language", callback)`      | `language`, after inspecting `model`, `sdk`, and `options`                     |
-| `ctx.session.hook("context", callback)`     | `system`, `messages`, and the `tools` record immediately before model dispatch |
-| `ctx.session.hook("http", callback)`       | `use`, registering request and response handling                               |
+| `ctx.session.hook("request", callback)`     | `system`, `messages`, and the `tools` record immediately before model dispatch |
 | `ctx.tool.hook("execute.before", callback)` | `input`, before the selected tool executes                                     |
-| `ctx.tool.hook("execute.after", callback)`  | Terminal `result` on success or `error` on failure                             |
-
-HTTP hooks can modify requests, inspect responses, retry, or return a
-response without calling the provider. It applies to native models; AI SDK
-models do not currently pass through this hook.
-
-```ts
-await ctx.session.hook("http", (event) => {
-  event.use((request, next) => {
-    request.headers.set("x-session-id", event.sessionID)
-    return next(request)
-  })
-})
-```
+| `ctx.tool.hook("execute.after", callback)`  | Terminal `result` on success or `error` on failure                            |
 
 For example, remove a tool from selected model requests and normalize another
 tool's input:
@@ -272,7 +259,7 @@ import { Plugin } from "@opencode-ai/plugin"
 export default Plugin.define({
   id: "acme.guards",
   setup: async (ctx) => {
-    await ctx.session.hook("context", (event) => {
+    await ctx.session.hook("request", (event) => {
       delete event.tools.write
     })
 

packages/www/openapi.json

@@ -851,16 +851,6 @@
                       }
                     ]
                   },
-                  "title": {
-                    "anyOf": [
-                      {
-                        "type": "string"
-                      },
-                      {
-                        "type": "null"
-                      }
-                    ]
-                  },
                   "agent": {
                     "anyOf": [
                       {
@@ -11311,104 +11301,6 @@
         }
       }
     },
-    "/api/vcs": {
-      "get": {
-        "tags": [
-          "vcs"
-        ],
-        "operationId": "v2.vcs.get",
-        "parameters": [
-          {
-            "name": "location",
-            "in": "query",
-            "schema": {
-              "anyOf": [
-                {
-                  "type": "object",
-                  "properties": {
-                    "directory": {
-                      "anyOf": [
-                        {
-                          "type": "string"
-                        },
-                        {
-                          "type": "null"
-                        }
-                      ]
-                    },
-                    "workspace": {
-                      "anyOf": [
-                        {
-                          "type": "string"
-                        },
-                        {
-                          "type": "null"
-                        }
-                      ]
-                    }
-                  },
-                  "additionalProperties": false
-                },
-                {
-                  "type": "null"
-                }
-              ]
-            },
-            "required": false,
-            "style": "deepObject",
-            "explode": true
-          }
-        ],
-        "security": [],
-        "responses": {
-          "200": {
-            "description": "Success",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "type": "object",
-                  "properties": {
-                    "location": {
-                      "$ref": "#/components/schemas/Location.Info"
-                    },
-                    "data": {
-                      "$ref": "#/components/schemas/Vcs.Info"
-                    }
-                  },
-                  "required": [
-                    "location",
-                    "data"
-                  ],
-                  "additionalProperties": false
-                }
-              }
-            }
-          },
-          "400": {
-            "description": "InvalidRequestError",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/InvalidRequestError"
-                }
-              }
-            }
-          },
-          "401": {
-            "description": "UnauthorizedError",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/UnauthorizedError"
-                }
-              }
-            }
-          }
-        },
-        "description": "Get current and default branch information for the requested location.",
-        "summary": "VCS info"
-      }
-    },
     "/api/vcs/status": {
       "get": {
         "tags": [
@@ -12140,15 +12032,11 @@
               },
               "directory": {
                 "type": "string"
-              },
-              "canonical": {
-                "type": "string"
               }
             },
             "required": [
               "id",
-              "directory",
-              "canonical"
+              "directory"
             ],
             "additionalProperties": false
           }
@@ -12610,6 +12498,7 @@
           "cost",
           "tokens",
           "time",
+          "title",
           "location"
         ],
         "additionalProperties": false
@@ -13948,15 +13837,6 @@
           },
           "message": {
             "type": "string"
-          },
-          "status": {
-            "type": "integer",
-            "allOf": [
-              {
-                "minimum": 100,
-                "maximum": 599
-              }
-            ]
           }
         },
         "required": [
@@ -20885,7 +20765,7 @@
           "id": {
             "type": "string"
           },
-          "canonical": {
+          "worktree": {
             "type": "string"
           },
           "vcs": {
@@ -20912,7 +20792,7 @@
         },
         "required": [
           "id",
-          "canonical",
+          "worktree",
           "time",
           "sandboxes"
         ],
@@ -20926,15 +20806,11 @@
           },
           "directory": {
             "type": "string"
-          },
-          "canonical": {
-            "type": "string"
           }
         },
         "required": [
           "id",
-          "directory",
-          "canonical"
+          "directory"
         ],
         "additionalProperties": false
       },
@@ -22569,6 +22445,7 @@
           "slug",
           "projectID",
           "directory",
+          "title",
           "version",
           "time"
         ],
@@ -29250,30 +29127,6 @@
         ],
         "additionalProperties": false
       },
-      "Vcs.Branch": {
-        "type": "object",
-        "properties": {
-          "current": {
-            "type": "string"
-          },
-          "default": {
-            "type": "string"
-          }
-        },
-        "additionalProperties": false
-      },
-      "Vcs.Info": {
-        "type": "object",
-        "properties": {
-          "branch": {
-            "$ref": "#/components/schemas/Vcs.Branch"
-          }
-        },
-        "required": [
-          "branch"
-        ],
-        "additionalProperties": false
-      },
       "Vcs.FileStatus": {
         "type": "object",
         "properties": {

packages/www/public/openapi.json

@@ -851,16 +851,6 @@
                       }
                     ]
                   },
-                  "title": {
-                    "anyOf": [
-                      {
-                        "type": "string"
-                      },
-                      {
-                        "type": "null"
-                      }
-                    ]
-                  },
                   "agent": {
                     "anyOf": [
                       {
@@ -11311,104 +11301,6 @@
         }
       }
     },
-    "/api/vcs": {
-      "get": {
-        "tags": [
-          "vcs"
-        ],
-        "operationId": "v2.vcs.get",
-        "parameters": [
-          {
-            "name": "location",
-            "in": "query",
-            "schema": {
-              "anyOf": [
-                {
-                  "type": "object",
-                  "properties": {
-                    "directory": {
-                      "anyOf": [
-                        {
-                          "type": "string"
-                        },
-                        {
-                          "type": "null"
-                        }
-                      ]
-                    },
-                    "workspace": {
-                      "anyOf": [
-                        {
-                          "type": "string"
-                        },
-                        {
-                          "type": "null"
-                        }
-                      ]
-                    }
-                  },
-                  "additionalProperties": false
-                },
-                {
-                  "type": "null"
-                }
-              ]
-            },
-            "required": false,
-            "style": "deepObject",
-            "explode": true
-          }
-        ],
-        "security": [],
-        "responses": {
-          "200": {
-            "description": "Success",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "type": "object",
-                  "properties": {
-                    "location": {
-                      "$ref": "#/components/schemas/Location.Info"
-                    },
-                    "data": {
-                      "$ref": "#/components/schemas/Vcs.Info"
-                    }
-                  },
-                  "required": [
-                    "location",
-                    "data"
-                  ],
-                  "additionalProperties": false
-                }
-              }
-            }
-          },
-          "400": {
-            "description": "InvalidRequestError",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/InvalidRequestError"
-                }
-              }
-            }
-          },
-          "401": {
-            "description": "UnauthorizedError",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/UnauthorizedError"
-                }
-              }
-            }
-          }
-        },
-        "description": "Get current and default branch information for the requested location.",
-        "summary": "VCS info"
-      }
-    },
     "/api/vcs/status": {
       "get": {
         "tags": [
@@ -12140,15 +12032,11 @@
               },
               "directory": {
                 "type": "string"
-              },
-              "canonical": {
-                "type": "string"
               }
             },
             "required": [
               "id",
-              "directory",
-              "canonical"
+              "directory"
             ],
             "additionalProperties": false
           }
@@ -12610,6 +12498,7 @@
           "cost",
           "tokens",
           "time",
+          "title",
           "location"
         ],
         "additionalProperties": false
@@ -13948,15 +13837,6 @@
           },
           "message": {
             "type": "string"
-          },
-          "status": {
-            "type": "integer",
-            "allOf": [
-              {
-                "minimum": 100,
-                "maximum": 599
-              }
-            ]
           }
         },
         "required": [
@@ -20885,7 +20765,7 @@
           "id": {
             "type": "string"
           },
-          "canonical": {
+          "worktree": {
             "type": "string"
           },
           "vcs": {
@@ -20912,7 +20792,7 @@
         },
         "required": [
           "id",
-          "canonical",
+          "worktree",
           "time",
           "sandboxes"
         ],
@@ -20926,15 +20806,11 @@
           },
           "directory": {
             "type": "string"
-          },
-          "canonical": {
-            "type": "string"
           }
         },
         "required": [
           "id",
-          "directory",
-          "canonical"
+          "directory"
         ],
         "additionalProperties": false
       },
@@ -22569,6 +22445,7 @@
           "slug",
           "projectID",
           "directory",
+          "title",
           "version",
           "time"
         ],
@@ -29250,30 +29127,6 @@
         ],
         "additionalProperties": false
       },
-      "Vcs.Branch": {
-        "type": "object",
-        "properties": {
-          "current": {
-            "type": "string"
-          },
-          "default": {
-            "type": "string"
-          }
-        },
-        "additionalProperties": false
-      },
-      "Vcs.Info": {
-        "type": "object",
-        "properties": {
-          "branch": {
-            "$ref": "#/components/schemas/Vcs.Branch"
-          }
-        },
-        "required": [
-          "branch"
-        ],
-        "additionalProperties": false
-      },
       "Vcs.FileStatus": {
         "type": "object",
         "properties": {