fix(tui): clarify saved permission copy

Co-authored-by: exe.dev user <exedev@jlongster-site.exe.xyz>

bun.lock

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

packages/ai/README.md

@@ -368,11 +368,12 @@ Other provider exports listed above remain direct facades until they explicitly
 
 ## Provider options & HTTP overlays
 
-Three escape hatches in order of stability:
+Request options in order of stability:
 
 1. **`generation`** — portable knobs (`maxTokens`, `temperature`, `topP`, `topK`, penalties, seed, stop).
-2. **`providerOptions: { <provider>: {...} }`** — typed-at-the-facade provider-specific knobs (OpenAI `promptCacheKey`, Anthropic `thinking`, Gemini `thinkingConfig`, OpenRouter routing).
-3. **`http: { body, headers, query }`** — last-resort serializable overlays merged into the final HTTP request. Reach for this only when a stable typed path doesn't yet exist.
+2. **`promptCacheKey`** — stable cache affinity lowered by every protocol that supports it.
+3. **`providerOptions: { <provider>: {...} }`** — typed-at-the-facade provider-specific knobs (OpenAI `store`, Anthropic `thinking`, Gemini `thinkingConfig`, OpenRouter routing).
+4. **`http: { body, headers, query }`** — last-resort serializable overlays merged into the final HTTP request. Reach for this only when a stable typed path doesn't yet exist.
 
 Route/provider defaults are overridden by request-level values for each axis.
 

packages/ai/example/tutorial.ts

@@ -33,9 +33,10 @@ const model = OpenAI.configure({
 //
 //   - `generation`: common controls such as max tokens, temperature, topP/topK,
 //     penalties, seed, and stop sequences.
+//   - `promptCacheKey`: stable cache affinity for protocols that support it.
 //   - `providerOptions`: namespaced provider-native behavior. For example,
-//     OpenAI cache keys and store behavior, Anthropic thinking, Gemini thinking
-//     config, or OpenRouter routing/reasoning.
+//     OpenAI store behavior, Anthropic thinking, Gemini thinking config, or
+//     OpenRouter routing/reasoning.
 //   - `http`: last-resort serializable overlays for final request body, headers,
 //     and query params. Prefer typed `providerOptions` when a field is stable.
 //
@@ -45,9 +46,7 @@ const request = LLM.request({
   system: "You are concise and practical.",
   prompt: "Tell me a joke",
   generation: { maxTokens: 80, temperature: 0.7 },
-  providerOptions: {
-    openai: { promptCacheKey: "tutorial-joke" },
-  },
+  promptCacheKey: "tutorial-joke",
 })
 
 // 3. `generate` sends the request and collects the event stream into one

packages/ai/src/protocols/gemini.ts

@@ -25,8 +25,20 @@ import { ToolSchemaProjection } from "./utils/tool-schema"
 
 const ADAPTER = "gemini"
 const MEDIA_MIMES = new Set<string>(ProviderShared.MEDIA_MIMES)
+// Google documents this sentinel for replaying Gemini 3 function calls after their original signature was lost.
+const SKIP_THOUGHT_SIGNATURE_VALIDATOR = "skip_thought_signature_validator"
 export const DEFAULT_BASE_URL = "https://generativelanguage.googleapis.com/v1beta"
 
+// Gemini 3 rejects replayed function calls without a thought signature. Google's SDKs avoid that in normal chats by
+// retaining complete model responses, but OpenCode reconstructs durable history and may encounter an unsigned call
+// from an older or external session. Model IDs are open-ended, so unknown Gemini aliases inherit current behavior.
+const requiresThoughtSignatureFallback = (modelID: string) => {
+  if (!/(^|\/)gemini-/i.test(modelID)) return false
+  if (/(^|\/)gemini-(?:1|2)(?:[.-]|$)/i.test(modelID)) return false
+  if (/(^|\/)gemini-pro(?:-vision)?$/i.test(modelID)) return false
+  return !/(^|\/)gemini-robotics-er-1\.5(?:[.-]|$)/i.test(modelID)
+}
+
 export interface OptionsInput {
   readonly [key: string]: unknown
   readonly cachedContent?: string
@@ -145,6 +157,9 @@ const GeminiGenerationConfig = Schema.Struct({
   temperature: Schema.optional(Schema.Number),
   topP: Schema.optional(Schema.Number),
   topK: Schema.optional(Schema.Number),
+  frequencyPenalty: Schema.optional(Schema.Number),
+  presencePenalty: Schema.optional(Schema.Number),
+  seed: Schema.optional(Schema.Number),
   stopSequences: optionalArray(Schema.String),
   thinkingConfig: Schema.optional(GeminiThinkingConfig),
 })
@@ -202,11 +217,13 @@ interface ParserState {
 //    keys on non-object scalars. Mirrors OpenCode's historical Gemini rules.
 //
 // 2. Project — lossy mapping from JSON Schema to Gemini's schema dialect:
-//    drop empty objects, derive `nullable: true` from `type: [..., "null"]`,
-//    coerce `const` to `[const]` enum, recurse properties/items, propagate
+//    drop empty root parameter schemas while preserving nested empty objects,
+//    expand type arrays into `anyOf`, derive `nullable: true` from null members,
+//    coerce `const` to `[const]` enum, recurse properties/items, and propagate
 //    only an allowlisted set of keys (description, required, format, type,
-//    properties, items, allOf, anyOf, oneOf, minLength). Anything outside the
-//    allowlist (e.g. `additionalProperties`, `$ref`) is silently dropped.
+//    nullable, enum, properties, items, allOf, anyOf, oneOf, minLength).
+//    Anything outside the allowlist (e.g. `additionalProperties`, `$ref`) is
+//    silently dropped.
 //
 // Sanitize runs first, then project. The implementation lives in
 // `utils/gemini-tool-schema` so this protocol keeps the same shape as the other
@@ -282,6 +299,8 @@ const lowerMessages = Effect.fn("Gemini.lowerMessages")(function* (request: LLMR
 
     if (message.role === "assistant") {
       const parts: Array<Schema.Schema.Type<typeof GeminiContentPart>> = []
+      // Parallel Gemini 3 calls may carry one signature on the first call; unsigned sibling calls are valid.
+      let hasSignedToolCall = false
       for (const part of message.content) {
         if (!ProviderShared.supportsContent(part, ["text", "reasoning", "tool-call"]))
           return yield* ProviderShared.unsupportedContent("Gemini", "assistant", ["text", "reasoning", "tool-call"])
@@ -294,7 +313,17 @@ const lowerMessages = Effect.fn("Gemini.lowerMessages")(function* (request: LLMR
           continue
         }
         if (part.type === "tool-call") {
-          parts.push(lowerToolCall(part))
+          const lowered = lowerToolCall(part)
+          const signature = lowered.thoughtSignature
+          parts.push({
+            ...lowered,
+            thoughtSignature:
+              signature ??
+              (requiresThoughtSignatureFallback(request.model.id) && !hasSignedToolCall
+                ? SKIP_THOUGHT_SIGNATURE_VALIDATOR
+                : undefined),
+          })
+          if (signature !== undefined) hasSignedToolCall = true
           continue
         }
       }
@@ -388,6 +417,9 @@ const fromRequest = Effect.fn("Gemini.fromRequest")(function* (request: LLMReque
     temperature: generation?.temperature,
     topP: generation?.topP,
     topK: generation?.topK,
+    frequencyPenalty: generation?.frequencyPenalty,
+    presencePenalty: generation?.presencePenalty,
+    seed: generation?.seed,
     stopSequences: generation?.stop,
     thinkingConfig: options.thinkingConfig,
   }

packages/ai/src/protocols/open-responses.ts

@@ -539,7 +539,7 @@ const lowerOptions = (request: LLMRequest) => {
   return {
     ...(options.instructions ? { instructions: options.instructions } : {}),
     ...(options.store !== undefined ? { store: options.store } : {}),
-    ...(options.promptCacheKey ? { prompt_cache_key: options.promptCacheKey } : {}),
+    ...(request.promptCacheKey ? { prompt_cache_key: request.promptCacheKey } : {}),
     ...(options.include ? { include: options.include } : {}),
     ...(options.reasoningEffort || options.reasoningSummary
       ? { reasoning: { effort: options.reasoningEffort, summary: options.reasoningSummary } }

packages/ai/src/protocols/openai-chat.ts

@@ -132,6 +132,7 @@ export const bodyFields = {
   stream: Schema.Literal(true),
   stream_options: Schema.optional(Schema.Struct({ include_usage: Schema.Boolean })),
   store: Schema.optional(Schema.Boolean),
+  prompt_cache_key: Schema.optional(Schema.String),
   reasoning_effort: Schema.optional(OpenAIOptions.OpenAIReasoningEffort),
   max_completion_tokens: Schema.optional(Schema.Number),
   max_tokens: Schema.optional(Schema.Number),
@@ -509,6 +510,7 @@ const lowerOptions = (request: LLMRequest) => {
   const options = OpenAIOptions.resolve(request)
   return {
     ...(options.store !== undefined ? { store: options.store } : {}),
+    ...(request.promptCacheKey ? { prompt_cache_key: request.promptCacheKey } : {}),
     ...(options.reasoningEffort ? { reasoning_effort: options.reasoningEffort } : {}),
   }
 }

packages/ai/src/protocols/utils/gemini-tool-schema.ts

@@ -61,37 +61,57 @@ const emptyObjectSchema = (schema: Record<string, unknown>) =>
   (!isRecord(schema.properties) || Object.keys(schema.properties).length === 0) &&
   !schema.additionalProperties
 
-const projectNode = (schema: unknown): Record<string, unknown> | undefined => {
+const projectNode = (schema: unknown, nested = false): Record<string, unknown> | undefined => {
   if (!isRecord(schema)) return undefined
-  if (emptyObjectSchema(schema)) return undefined
-  return Object.fromEntries(
+  if (!nested && emptyObjectSchema(schema)) return undefined
+  const types = Array.isArray(schema.type) ? schema.type.filter((type) => type !== "null") : undefined
+  const anyOf = Array.isArray(schema.anyOf) ? schema.anyOf : undefined
+  const hasNullAnyOf = anyOf?.some((item) => isRecord(item) && item.type === "null") ?? false
+  const anyOfTypes = hasNullAnyOf ? anyOf?.filter((item) => !isRecord(item) || item.type !== "null") : anyOf
+  const flattenedAnyOf = hasNullAnyOf && anyOfTypes?.length === 1 ? projectNode(anyOfTypes[0], true) : undefined
+  const result = Object.fromEntries(
     [
       ["description", schema.description],
       ["required", schema.required],
       ["format", schema.format],
-      ["type", Array.isArray(schema.type) ? schema.type.filter((type) => type !== "null")[0] : schema.type],
-      ["nullable", Array.isArray(schema.type) && schema.type.includes("null") ? true : undefined],
+      ["type", types ? (types.length === 0 ? "null" : undefined) : schema.type],
+      [
+        "nullable",
+        (Array.isArray(schema.type) && schema.type.includes("null") && types && types.length > 0) || hasNullAnyOf
+          ? true
+          : undefined,
+      ],
       ["enum", schema.const !== undefined ? [schema.const] : schema.enum],
       [
         "properties",
         isRecord(schema.properties)
-          ? Object.fromEntries(Object.entries(schema.properties).map(([key, value]) => [key, projectNode(value)]))
+          ? Object.fromEntries(Object.entries(schema.properties).map(([key, value]) => [key, projectNode(value, true)]))
           : undefined,
       ],
       [
         "items",
         Array.isArray(schema.items)
-          ? schema.items.map(projectNode)
+          ? schema.items.map((item) => projectNode(item, true))
           : schema.items === undefined
             ? undefined
-            : projectNode(schema.items),
+            : projectNode(schema.items, true),
       ],
-      ["allOf", Array.isArray(schema.allOf) ? schema.allOf.map(projectNode) : undefined],
-      ["anyOf", Array.isArray(schema.anyOf) ? schema.anyOf.map(projectNode) : undefined],
-      ["oneOf", Array.isArray(schema.oneOf) ? schema.oneOf.map(projectNode) : undefined],
+      ["allOf", Array.isArray(schema.allOf) ? schema.allOf.map((item) => projectNode(item, true)) : undefined],
+      [
+        "anyOf",
+        anyOfTypes
+          ? hasNullAnyOf && anyOfTypes.length === 1
+            ? undefined
+            : anyOfTypes.map((item) => projectNode(item, true))
+          : types && types.length > 0
+            ? types.map((type) => ({ type }))
+            : undefined,
+      ],
+      ["oneOf", Array.isArray(schema.oneOf) ? schema.oneOf.map((item) => projectNode(item, true)) : undefined],
       ["minLength", schema.minLength],
     ].filter((entry) => entry[1] !== undefined),
   )
+  return flattenedAnyOf ? { ...result, ...flattenedAnyOf } : result
 }
 
 export const convert = (schema: unknown) => projectNode(sanitizeNode(schema))

packages/ai/src/protocols/utils/open-responses-options.ts

@@ -33,7 +33,6 @@ export const ServiceTierSchema = Schema.Literals(ServiceTiers)
 export interface Resolved {
   readonly instructions?: string
   readonly store?: boolean
-  readonly promptCacheKey?: string
   readonly reasoningEffort?: string
   readonly reasoningSummary?: "auto" | "concise" | "detailed"
   readonly include?: ReadonlyArray<ResponseIncludable>
@@ -50,7 +49,6 @@ export const resolve = (request: LLMRequest): Resolved => {
   return {
     instructions: typeof input?.instructions === "string" ? input.instructions : undefined,
     store: typeof input?.store === "boolean" ? input.store : undefined,
-    promptCacheKey: typeof input?.promptCacheKey === "string" ? input.promptCacheKey : undefined,
     reasoningEffort: typeof input?.reasoningEffort === "string" ? input.reasoningEffort : undefined,
     reasoningSummary:
       reasoningSummary === "auto" || reasoningSummary === "concise" || reasoningSummary === "detailed"

packages/ai/src/providers/open-responses-options.ts

@@ -5,7 +5,6 @@ export interface OpenResponsesOptionsInput {
   readonly [key: string]: unknown
   readonly instructions?: string
   readonly store?: boolean
-  readonly promptCacheKey?: string
   readonly reasoningEffort?: ReasoningEffort
   readonly reasoningSummary?: "auto" | "concise" | "detailed"
   readonly include?: ReadonlyArray<ResponseIncludable>

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

@@ -17,7 +17,6 @@ const openAIProviderOptions = (options: OpenAIOptionsInput | undefined): Provide
   const openai = Object.fromEntries(
     definedEntries({
       store: options?.store,
-      promptCacheKey: options?.promptCacheKey,
       reasoningEffort: options?.reasoningEffort,
       reasoningSummary: options?.reasoningSummary,
       include: options?.include,

packages/ai/src/providers/openrouter.ts

@@ -55,7 +55,6 @@ export interface OpenRouterOptions {
   readonly debug?: Readonly<{ echo_upstream_body?: boolean }>
   readonly models?: ReadonlyArray<string>
   readonly plugins?: ReadonlyArray<OpenRouterPlugin>
-  readonly promptCacheKey?: string
   readonly provider?: OpenRouterProviderRouting
   readonly reasoning?: Readonly<{
     enabled?: boolean
@@ -122,6 +121,7 @@ export const protocol = Protocol.make({
             ...body,
             messages,
             ...bodyOptions(request.providerOptions?.openrouter),
+            ...(request.promptCacheKey ? { prompt_cache_key: request.promptCacheKey } : {}),
           } as OpenRouterBody
         }),
       ),
@@ -161,7 +161,6 @@ const bodyOptions = (input: unknown) => {
     ...(isRecord(debug) ? { debug } : {}),
     ...(typeof user === "string" ? { user } : {}),
     ...(isRecord(reasoning) ? { reasoning } : {}),
-    ...(typeof promptCacheKey === "string" ? { prompt_cache_key: promptCacheKey } : {}),
   }
 }
 

packages/ai/src/providers/xai.ts

@@ -47,6 +47,8 @@ const chatRoute = Route.make({
   protocol: OpenAIChat.protocol,
   endpoint: Endpoint.path("/chat/completions", { baseURL: OpenAICompatibleProfiles.profiles.xai.baseURL }),
   transport: OpenAICompatibleChat.route.transport,
+  headers: ({ request }): Record<string, string> =>
+    request.promptCacheKey ? { "x-grok-conv-id": request.promptCacheKey } : {},
 })
 
 export const routes = [responsesRoute, chatRoute]

packages/ai/src/schema/messages.ts

@@ -272,6 +272,8 @@ export class LLMRequest extends Schema.Class<LLMRequest>("LLM.Request")({
   providerOptions: Schema.optional(ProviderOptions),
   http: Schema.optional(HttpOptions),
   cache: Schema.optional(CachePolicy),
+  // Stable cache affinity for protocols that support provider-managed prompt caching.
+  promptCacheKey: Schema.optional(Schema.String),
   metadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
 }) {}
 
@@ -289,6 +291,7 @@ export namespace LLMRequest {
     providerOptions: request.providerOptions,
     http: request.http,
     cache: request.cache,
+    promptCacheKey: request.promptCacheKey,
     metadata: request.metadata,
   })
 

packages/ai/test/provider-options/cloudflare.types.ts

@@ -3,11 +3,11 @@ import { CloudflareWorkersAI } from "../../src/providers"
 
 const model = CloudflareWorkersAI.configure({ accountId: "account", apiKey: "test" }).model("model")
 
-LLM.request({ model, prompt: "Hello", providerOptions: { openai: { promptCacheKey: "cache" } } })
+LLM.request({ model, prompt: "Hello", promptCacheKey: "cache" })
 
 LLM.request({
   model,
   prompt: "Hello",
-  // @ts-expect-error Cloudflare's OpenAI-compatible prompt cache key must be a string.
-  providerOptions: { openai: { promptCacheKey: 1 } },
+  // @ts-expect-error Prompt cache keys must be strings.
+  promptCacheKey: 1,
 })

packages/ai/test/provider/gemini.test.ts

@@ -16,6 +16,13 @@ const model = Gemini.route
   })
   .model({ id: "gemini-2.5-flash" })
 
+const gemini3 = Gemini.route
+  .with({
+    endpoint: { baseURL: "https://generativelanguage.test/v1beta/" },
+    auth: Auth.header("x-goog-api-key", "test"),
+  })
+  .model({ id: "gemini-3-flash-preview" })
+
 const request = LLM.request({
   id: "req_1",
   model,
@@ -86,6 +93,39 @@ describe("Gemini route", () => {
     }),
   )
 
+  it.effect("forwards standard Gemini generation options", () =>
+    Effect.gen(function* () {
+      const prepared = yield* compileRequest(
+        LLM.request({
+          model,
+          prompt: "Say hello.",
+          generation: {
+            maxTokens: 40,
+            temperature: 0.2,
+            topP: 0.8,
+            topK: 12,
+            frequencyPenalty: 0.3,
+            presencePenalty: 0.4,
+            seed: 42,
+            stop: ["done"],
+          },
+        }),
+      )
+
+      expect(prepared.body.generationConfig).toEqual({
+        maxOutputTokens: 40,
+        temperature: 0.2,
+        topP: 0.8,
+        topK: 12,
+        frequencyPenalty: 0.3,
+        presencePenalty: 0.4,
+        seed: 42,
+        stopSequences: ["done"],
+        thinkingConfig: undefined,
+      })
+    }),
+  )
+
   it.effect("lowers chronological system updates to wrapped user text in order", () =>
     Effect.gen(function* () {
       const prepared = yield* compileRequest(
@@ -350,6 +390,100 @@ describe("Gemini route", () => {
     }),
   )
 
+  it.effect("preserves nested empty object tool schemas", () =>
+    Effect.gen(function* () {
+      const prepared = yield* compileRequest(
+        LLM.request({
+          model,
+          prompt: "Use the tool.",
+          tools: [
+            {
+              name: "configure",
+              description: "Configure the operation",
+              inputSchema: {
+                type: "object",
+                required: ["options"],
+                properties: {
+                  options: { type: "object", description: "Optional provider settings", properties: {} },
+                },
+              },
+            },
+          ],
+        }),
+      )
+
+      expect(prepared.body.tools).toEqual([
+        {
+          functionDeclarations: [
+            {
+              name: "configure",
+              description: "Configure the operation",
+              parameters: {
+                type: "object",
+                required: ["options"],
+                properties: {
+                  options: { type: "object", description: "Optional provider settings", properties: {} },
+                },
+              },
+            },
+          ],
+        },
+      ])
+    }),
+  )
+
+  it.effect("projects Gemini type arrays without narrowing their allowed values", () =>
+    Effect.gen(function* () {
+      const prepared = yield* compileRequest(
+        LLM.request({
+          model,
+          prompt: "Use the tool.",
+          tools: [
+            {
+              name: "filter",
+              description: "Filter values",
+              inputSchema: {
+                type: "object",
+                properties: {
+                  status: { type: ["number", "string"], description: "Status filter" },
+                  maybe: { type: ["string", "null"] },
+                  nothing: { type: ["null"] },
+                  explicit: { anyOf: [{ type: "string" }, { type: "null" }] },
+                  choice: { anyOf: [{ type: "string" }, { type: "number" }, { type: "null" }] },
+                },
+              },
+            },
+          ],
+        }),
+      )
+
+      expect(prepared.body.tools?.[0]?.functionDeclarations[0]?.parameters).toEqual({
+        type: "object",
+        properties: {
+          status: {
+            description: "Status filter",
+            anyOf: [{ type: "number" }, { type: "string" }],
+          },
+          maybe: {
+            nullable: true,
+            anyOf: [{ type: "string" }],
+          },
+          nothing: {
+            type: "null",
+          },
+          explicit: {
+            type: "string",
+            nullable: true,
+          },
+          choice: {
+            anyOf: [{ type: "string" }, { type: "number" }],
+            nullable: true,
+          },
+        },
+      })
+    }),
+  )
+
   it.effect("parses text, reasoning, and usage stream fixtures", () =>
     Effect.gen(function* () {
       const body = sseEvents(
@@ -536,6 +670,44 @@ describe("Gemini route", () => {
     }),
   )
 
+  it.effect("replays unsigned Gemini 3 tool calls with the validator bypass sentinel", () =>
+    Effect.gen(function* () {
+      const prepared = yield* compileRequest(
+        LLM.request({
+          model: gemini3,
+          messages: [
+            Message.assistant([ToolCallPart.make({ id: "tool_0", name: "lookup", input: { query: "weather" } })]),
+            Message.tool({ id: "tool_0", name: "lookup", result: "done", resultType: "text" }),
+          ],
+        }),
+      )
+
+      expect(prepared.body.contents).toEqual([
+        {
+          role: "model",
+          parts: [
+            {
+              functionCall: { id: undefined, name: "lookup", args: { query: "weather" } },
+              thoughtSignature: "skip_thought_signature_validator",
+            },
+          ],
+        },
+        {
+          role: "user",
+          parts: [
+            {
+              functionResponse: {
+                id: undefined,
+                name: "lookup",
+                response: { name: "lookup", content: "done" },
+              },
+            },
+          ],
+        },
+      ])
+    }),
+  )
+
   it.effect("emits streamed tool calls and maps finish reason", () =>
     Effect.gen(function* () {
       const body = sseEvents({

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

@@ -15,6 +15,8 @@ import {
 } from "../../src"
 import * as Azure from "../../src/providers/azure"
 import * as OpenAI from "../../src/providers/openai"
+import * as OpenAICompatible from "../../src/providers/openai-compatible"
+import * as XAI from "../../src/providers/xai"
 import * as OpenAIChat from "../../src/protocols/openai-chat"
 import { ProviderShared } from "../../src/protocols/shared"
 import { Auth, LLMClient } from "../../src/route"
@@ -154,6 +156,47 @@ describe("OpenAI Chat route", () => {
     }),
   )
 
+  it.effect("maps the request prompt cache key", () =>
+    Effect.gen(function* () {
+      const prepared = yield* compileRequest(
+        LLM.request({
+          model: OpenAICompatible.configure({
+            baseURL: "https://api.compatible.test/v1",
+            apiKey: "test",
+          }).model("compatible-model"),
+          prompt: "Hello",
+          promptCacheKey: "session_123",
+        }),
+      )
+
+      expect(prepared.body.prompt_cache_key).toBe("session_123")
+    }),
+  )
+
+  it.effect("maps the xAI Chat prompt cache key to conversation affinity", () =>
+    LLMClient.generate(
+      LLM.request({
+        model: XAI.configure({ apiKey: "test", baseURL: "https://api.x.ai/v1" }).chat("grok-4.5"),
+        prompt: "Hello",
+        promptCacheKey: "session_123",
+      }),
+    ).pipe(
+      Effect.provide(
+        dynamicResponse((input) =>
+          Effect.gen(function* () {
+            const web = yield* HttpClientRequest.toWeb(input.request).pipe(Effect.orDie)
+            expect(web.headers.get("x-grok-conv-id")).toBe("session_123")
+            const body = decodeJson(yield* Effect.promise(() => web.text()))
+            expect(ProviderShared.isRecord(body) ? body.prompt_cache_key : undefined).toBe("session_123")
+            return input.respond(sseEvents(deltaChunk({}, "stop")), {
+              headers: { "content-type": "text/event-stream" },
+            })
+          }),
+        ),
+      ),
+    ),
+  )
+
   it.effect("passes through custom OpenAI-compatible reasoning effort strings", () =>
     Effect.gen(function* () {
       const prepared = yield* compileRequest(

packages/ai/test/provider/openai-responses-cache.recorded.test.ts

@@ -20,7 +20,7 @@ const cacheRequest = LLM.request({
   system: LARGE_CACHEABLE_SYSTEM,
   prompt: "Say hi.",
   generation: { maxTokens: 16, temperature: 0 },
-  providerOptions: { openai: { promptCacheKey: "recorded-cache-test" } },
+  promptCacheKey: "recorded-cache-test",
 })
 
 const recorded = recordedTests({

packages/ai/test/provider/openai-responses.test.ts

@@ -682,9 +682,9 @@ describe("OpenAI Responses route", () => {
         LLM.request({
           model: OpenAI.configure({ baseURL: "https://api.openai.test/v1/", apiKey: "test" }).model("gpt-5.2"),
           prompt: "think",
+          promptCacheKey: "session_123",
           providerOptions: {
             openai: {
-              promptCacheKey: "session_123",
               reasoningEffort: "high",
               reasoningSummary: "auto",
               include: ["reasoning.encrypted_content"],
@@ -803,17 +803,16 @@ describe("OpenAI Responses route", () => {
     }),
   )
 
-  it.effect("request OpenAI provider options override route defaults", () =>
+  it.effect("maps the request prompt cache key", () =>
     Effect.gen(function* () {
       const prepared = yield* compileRequest(
         LLM.request({
           model: OpenAI.configure({
             baseURL: "https://api.openai.test/v1/",
             apiKey: "test",
-            providerOptions: { openai: { promptCacheKey: "model_cache" } },
           }).model("gpt-4.1-mini"),
           prompt: "no cache",
-          providerOptions: { openai: { promptCacheKey: "request_cache" } },
+          promptCacheKey: "request_cache",
         }),
       )
 

packages/ai/test/provider/openrouter.test.ts

@@ -162,7 +162,6 @@ describe("OpenRouter", () => {
               openrouter: {
                 usage: true,
                 reasoning: { effort: "high" },
-                promptCacheKey: "session_123",
                 models: ["anthropic/claude-sonnet-4.6", "google/gemini-3.1-pro"],
                 provider: { order: ["anthropic", "google"], require_parameters: true },
                 plugins: [{ id: "response-healing" }],
@@ -174,6 +173,7 @@ describe("OpenRouter", () => {
             },
           }).model("anthropic/claude-3.7-sonnet:thinking"),
           prompt: "Think briefly.",
+          promptCacheKey: "session_123",
         }),
       )
 

packages/app/src/components/dialog-connect-provider.tsx

@@ -1,4 +1,4 @@
-import type { FormAnswer, IntegrationMethod, IntegrationOauthConnectOutput } from "@opencode-ai/client/promise"
+import type { IntegrationMethod, IntegrationOauthConnectOutput } from "@opencode-ai/client/promise"
 import { Button } from "@opencode-ai/ui/button"
 import { useDialog } from "@opencode-ai/ui/context/dialog"
 import { Dialog } from "@opencode-ai/ui/dialog"
@@ -40,8 +40,6 @@ import { decode64 } from "@/utils/base64"
 
 const CUSTOM_ID = "_custom"
 type ConnectMethod = Extract<IntegrationMethod, { type: "key" | "oauth" }>
-type IntegrationForm = NonNullable<ConnectMethod["forms"]>[number]
-type StringForm = Extract<IntegrationForm, { type: "string" }>
 
 export function useProviderConnectController(options: { onBack?: () => void } = {}) {
   const [store, setStore] = createStore({ selected: undefined as string | undefined })
@@ -436,16 +434,16 @@ function ProviderConnection(props: {
   const [store, setStore] = createStore({
     methodIndex: undefined as undefined | number,
     authorization: undefined as undefined | IntegrationOauthConnectOutput["data"],
-    formAnswers: undefined as FormAnswer | undefined,
-    state: "pending" as undefined | "pending" | "complete" | "error" | "form",
+    promptInputs: undefined as undefined | Record<string, string>,
+    state: "pending" as undefined | "pending" | "complete" | "error" | "prompt",
     error: undefined as string | undefined,
   })
 
   type Action =
     | { type: "method.select"; index: number }
     | { type: "method.reset" }
-    | { type: "auth.form" }
-    | { type: "auth.answers"; answers: FormAnswer }
+    | { type: "auth.prompt" }
+    | { type: "auth.inputs"; inputs: Record<string, string> }
     | { type: "auth.pending" }
     | { type: "auth.complete"; authorization: IntegrationOauthConnectOutput["data"] }
     | { type: "auth.error"; error: string }
@@ -456,7 +454,7 @@ function ProviderConnection(props: {
         if (action.type === "method.select") {
           draft.methodIndex = action.index
           draft.authorization = undefined
-          draft.formAnswers = undefined
+          draft.promptInputs = undefined
           draft.state = undefined
           draft.error = undefined
           return
@@ -464,18 +462,18 @@ function ProviderConnection(props: {
         if (action.type === "method.reset") {
           draft.methodIndex = undefined
           draft.authorization = undefined
-          draft.formAnswers = undefined
+          draft.promptInputs = undefined
           draft.state = undefined
           draft.error = undefined
           return
         }
-        if (action.type === "auth.form") {
-          draft.state = "form"
+        if (action.type === "auth.prompt") {
+          draft.state = "prompt"
           draft.error = undefined
           return
         }
-        if (action.type === "auth.answers") {
-          draft.formAnswers = action.answers
+        if (action.type === "auth.inputs") {
+          draft.promptInputs = action.inputs
           draft.state = undefined
           draft.error = undefined
           return
@@ -533,7 +531,7 @@ function ProviderConnection(props: {
     return fallback
   }
 
-  async function selectMethod(index: number, answers?: FormAnswer) {
+  async function selectMethod(index: number, inputs?: Record<string, string>) {
     if (timer.current !== undefined) {
       clearTimeout(timer.current)
       timer.current = undefined
@@ -542,17 +540,9 @@ function ProviderConnection(props: {
     const method = methods()[index]
     dispatch({ type: "method.select", index })
 
-    if (method.forms?.length && !answers) {
-      dispatch({ type: "auth.form" })
-      return
-    }
-    if (method.type === "key") {
-      dispatch({ type: "auth.answers", answers: answers ?? {} })
-      return
-    }
     if (method.type === "oauth") {
-      if (method.forms?.some((field) => field.type !== "string")) {
-        dispatch({ type: "auth.error", error: "This authentication form contains unsupported fields" })
+      if (method.prompts?.length && !inputs) {
+        dispatch({ type: "auth.prompt" })
         return
       }
       dispatch({ type: "auth.pending" })
@@ -560,7 +550,7 @@ function ProviderConnection(props: {
         .api.integration.oauth.connect({
           integrationID: props.provider,
           methodID: method.id,
-          answers: answers ?? {},
+          inputs: inputs ?? {},
           location: location(),
         })
         .then((x) => {
@@ -574,42 +564,41 @@ function ProviderConnection(props: {
     }
   }
 
-  function AuthFormsView() {
+  function AuthPromptsView() {
     const [formStore, setFormStore] = createStore({
       value: {} as Record<string, string>,
       index: 0,
     })
 
-    const forms = createMemo<StringForm[]>(() => {
+    const prompts = createMemo(() => {
       const value = method()
-      return (value?.forms ?? []).flatMap((field) => (field.type === "string" ? [field] : []))
+      return value?.type === "oauth" ? (value.prompts ?? []) : []
     })
-    const matches = (field: StringForm, value: Record<string, string>) => {
-      return (field.when ?? []).every((condition) => {
-        const actual = value[condition.key]
-        if (actual === undefined) return false
-        return condition.op === "eq" ? actual === condition.value : actual !== condition.value
-      })
+    const matches = (prompt: NonNullable<ReturnType<typeof prompts>[number]>, value: Record<string, string>) => {
+      if (!prompt.when) return true
+      const actual = value[prompt.when.key]
+      if (actual === undefined) return false
+      return prompt.when.op === "eq" ? actual === prompt.when.value : actual !== prompt.when.value
     }
     const current = createMemo(() => {
-      const all = forms()
-      const index = all.findIndex((field, index) => index >= formStore.index && matches(field, formStore.value))
+      const all = prompts()
+      const index = all.findIndex((prompt, index) => index >= formStore.index && matches(prompt, formStore.value))
       if (index === -1) return
       return {
         index,
-        field: all[index],
+        prompt: all[index],
       }
     })
     const valid = createMemo(() => {
       const item = current()
-      if (!item || item.field.options) return false
-      if (!item.field.required) return true
-      return (formStore.value[item.field.key] ?? "").trim().length > 0
+      if (!item || item.prompt.type !== "text") return false
+      const value = formStore.value[item.prompt.key] ?? ""
+      return value.trim().length > 0
     })
 
     async function next(index: number, value: Record<string, string>) {
       if (store.methodIndex === undefined) return
-      const next = forms().findIndex((field, i) => i > index && matches(field, value))
+      const next = prompts().findIndex((prompt, i) => i > index && matches(prompt, value))
       if (next !== -1) {
         setFormStore("index", next)
         return
@@ -620,60 +609,60 @@ function ProviderConnection(props: {
     async function handleSubmit(e: SubmitEvent) {
       e.preventDefault()
       const item = current()
-      if (!item || item.field.options) return
+      if (!item || item.prompt.type !== "text") return
       if (!valid()) return
       await next(item.index, formStore.value)
     }
 
     const item = () => current()
     const text = createMemo(() => {
-      const field = item()?.field
-      if (!field || field.options) return
-      return field
+      const prompt = item()?.prompt
+      if (!prompt || prompt.type !== "text") return
+      return prompt
     })
     const select = createMemo(() => {
-      const field = item()?.field
-      if (!field?.options) return
-      return field
+      const prompt = item()?.prompt
+      if (!prompt || prompt.type !== "select") return
+      return prompt
     })
 
     return (
       <form onSubmit={handleSubmit} class="flex flex-col items-start gap-4">
         <Switch>
-          <Match when={item()?.field.options === undefined}>
+          <Match when={item()?.prompt.type === "text"}>
             <TextField
               type="text"
-              label={text()?.title ?? ""}
+              label={text()?.message ?? ""}
               placeholder={text()?.placeholder}
               value={text() ? (formStore.value[text()!.key] ?? "") : ""}
               onChange={(value) => {
-                const field = text()
-                if (!field) return
-                setFormStore("value", field.key, value)
+                const prompt = text()
+                if (!prompt) return
+                setFormStore("value", prompt.key, value)
               }}
             />
             <Button class="w-auto" type="submit" size="large" variant="primary" disabled={!valid()}>
               {language.t("common.continue")}
             </Button>
           </Match>
-          <Match when={item()?.field.options !== undefined}>
+          <Match when={item()?.prompt.type === "select"}>
             <div class="w-full flex flex-col gap-1.5">
-              <div class="text-14-regular text-text-base">{select()?.title}</div>
+              <div class="text-14-regular text-text-base">{select()?.message}</div>
               <div>
                 <List
                   class="px-3"
                   items={select()?.options ?? []}
                   key={(x) => x.value}
-                  current={select()?.options?.find((x) => x.value === formStore.value[select()!.key])}
+                  current={select()?.options.find((x) => x.value === formStore.value[select()!.key])}
                   onSelect={(value) => {
                     if (!value) return
-                    const field = select()
-                    if (!field) return
+                    const prompt = select()
+                    if (!prompt) return
                     const nextValue = {
                       ...formStore.value,
-                      [field.key]: value.value,
+                      [prompt.key]: value.value,
                     }
-                    setFormStore("value", field.key, value.value)
+                    setFormStore("value", prompt.key, value.value)
                     void next(item()!.index, nextValue)
                   }}
                 >
@@ -683,7 +672,7 @@ function ProviderConnection(props: {
                         <div class="w-2.5 h-0.5 ml-0 bg-icon-strong-base hidden" data-slot="list-item-extra-icon" />
                       </div>
                       <span>{option.label}</span>
-                      <span class="text-14-regular text-text-weak">{option.description}</span>
+                      <span class="text-14-regular text-text-weak">{option.hint}</span>
                     </div>
                   )}
                 </List>
@@ -831,7 +820,6 @@ function ProviderConnection(props: {
         integrationID: props.provider,
         location: location(),
         key: apiKey,
-        answers: store.formAnswers ?? {},
       })
       await complete()
     }
@@ -1155,8 +1143,8 @@ function ProviderConnection(props: {
                 </div>
               </div>
             </Match>
-            <Match when={store.state === "form"}>
-              <AuthFormsView />
+            <Match when={store.state === "prompt"}>
+              <AuthPromptsView />
             </Match>
             <Match when={store.state === "error"}>
               <div class="text-14-regular text-text-base">

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

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

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

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

packages/app/src/context/server-sync.tsx

@@ -671,13 +671,13 @@ export function createServerSyncContextInner(serverSDK: ServerSDK) {
               integrationID: server.integrationID,
               location: { directory: key },
             })
-            const method = integration.data?.methods.find((item) => item.type === "oauth" && !item.forms?.length)
+            const method = integration.data?.methods.find((item) => item.type === "oauth" && !item.prompts?.length)
             if (!method || method.type !== "oauth")
               throw new Error(`MCP server ${name} requires an interactive authentication form`)
             const attempt = await serverSDK.api.integration.oauth.connect({
               integrationID: server.integrationID,
               methodID: method.id,
-              answers: {},
+              inputs: {},
               location: { directory: key },
             })
             platform.openLink(attempt.data.url)

packages/app/src/pages/session.tsx

@@ -688,6 +688,8 @@ export default function Page() {
     return {
       queryKey: [...vcsKey(), mode] as const,
       enabled,
+      refetchOnMount: "always" as const,
+      refetchOnWindowFocus: true,
       queryFn: mode
         ? () =>
             sdk()
@@ -701,6 +703,16 @@ export default function Page() {
     }
   })
   const refreshVcs = debounce(() => void queryClient.invalidateQueries({ queryKey: vcsKey() }), 100)
+  createEffect(
+    on(
+      () => desktopReviewOpen() || mobileChanges(),
+      (open, previous) => {
+        if (!open || previous || !desktopFileTreeOpen() || vcsQuery.isFetching) return
+        refreshVcs()
+      },
+      { defer: true },
+    ),
+  )
   const reviewDiffs = () => {
     if (reviewMode() === "git" || reviewMode() === "branch")
       // avoids suspense
@@ -947,19 +959,6 @@ export default function Page() {
     ),
   )
 
-  const stopVcs = sdk().event.listen((evt) => {
-    const details = evt.details as { type: string; properties?: unknown }
-    if (details.type !== "file.watcher.updated" && details.type !== "filesystem.changed") return
-    const props =
-      typeof details.properties === "object" && details.properties
-        ? (details.properties as Record<string, unknown>)
-        : undefined
-    const file = typeof props?.file === "string" ? props.file : undefined
-    if (!file || file.startsWith(".git/")) return
-    refreshVcs()
-  })
-  onCleanup(stopVcs)
-
   createEffect(
     on(
       () => sdk().directory,

packages/app/tsconfig.json

@@ -22,5 +22,6 @@
     }
   },
   "include": ["src", "package.json"],
-  "exclude": ["dist", "ts-dist"]
+  "exclude": ["dist", "ts-dist"],
+  "references": [{ "path": "../core" }]
 }

packages/cli/src/commands/handlers/console/login.ts

@@ -50,7 +50,7 @@ const login = Effect.fn("cli.console.login.run")(function* (timeline: TimelineHo
       {
         integrationID,
         methodID: method.id,
-        answers: server ? { server } : {},
+        inputs: server ? { server } : {},
         location,
       },
       { signal },

packages/cli/src/commands/handlers/mcp/auth.ts

@@ -32,7 +32,7 @@ export default Runtime.handler(
       return yield* Effect.fail(new Error(`MCP server "${input.name}" is not an OAuth-capable remote server`))
 
     const started = yield* Effect.promise(() =>
-      client.integration.oauth.connect({ integrationID: integration.id, methodID: method.id, answers: {}, location }),
+      client.integration.oauth.connect({ integrationID: integration.id, methodID: method.id, inputs: {}, location }),
     )
     const attempt = started.data
     if (attempt.mode === "code")

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

@@ -23,9 +23,9 @@ import type { Shell } from "@opencode-ai/schema/shell"
 import type { DateTime } from "effect"
 import type { Provider } from "@opencode-ai/schema/provider"
 import type { Integration } from "@opencode-ai/schema/integration"
-import type { Form } from "@opencode-ai/schema/form"
 import type { Mcp } from "@opencode-ai/schema/mcp"
 import type { Credential } from "@opencode-ai/schema/credential"
+import type { Form } from "@opencode-ai/schema/form"
 import type { Permission } from "@opencode-ai/schema/permission"
 import type { PermissionSaved } from "@opencode-ai/schema/permission-saved"
 import type { FileSystem } from "@opencode-ai/schema/filesystem"
@@ -263,38 +263,52 @@ export type Endpoint5_23Input = { readonly sessionID: Session.ID }
 export type Endpoint5_23Output = ReadonlyArray<SessionPending.Info>
 export type SessionPendingListOperation<E = never> = (input: Endpoint5_23Input) => Effect.Effect<Endpoint5_23Output, E>
 
-export type Endpoint5_24Input = { readonly sessionID: Session.ID }
-export type Endpoint5_24Output = ReadonlyArray<InstructionEntry.Info>
-export type SessionInstructionsEntryListOperation<E = never> = (
+export type Endpoint5_24Input = { readonly sessionID: Session.ID; readonly inputID: SessionMessage.ID }
+export type Endpoint5_24Output = void
+export type SessionPendingCancelOperation<E = never> = (
   input: Endpoint5_24Input,
 ) => Effect.Effect<Endpoint5_24Output, E>
 
-export type Endpoint5_25Input = {
+export type Endpoint5_25Input = { readonly sessionID: Session.ID; readonly inputID: SessionMessage.ID }
+export type Endpoint5_25Output = void
+export type SessionPendingSteerOperation<E = never> = (input: Endpoint5_25Input) => Effect.Effect<Endpoint5_25Output, E>
+
+export type Endpoint5_26Input = { readonly sessionID: Session.ID; readonly inputID: SessionMessage.ID }
+export type Endpoint5_26Output = void
+export type SessionPendingQueueOperation<E = never> = (input: Endpoint5_26Input) => Effect.Effect<Endpoint5_26Output, E>
+
+export type Endpoint5_27Input = { readonly sessionID: Session.ID }
+export type Endpoint5_27Output = ReadonlyArray<InstructionEntry.Info>
+export type SessionInstructionsEntryListOperation<E = never> = (
+  input: Endpoint5_27Input,
+) => Effect.Effect<Endpoint5_27Output, E>
+
+export type Endpoint5_28Input = {
   readonly sessionID: Session.ID
   readonly key: InstructionEntry.Key
   readonly value: Schema.Json
 }
-export type Endpoint5_25Output = void
+export type Endpoint5_28Output = void
 export type SessionInstructionsEntryPutOperation<E = never> = (
-  input: Endpoint5_25Input,
-) => Effect.Effect<Endpoint5_25Output, E>
+  input: Endpoint5_28Input,
+) => Effect.Effect<Endpoint5_28Output, E>
 
-export type Endpoint5_26Input = { readonly sessionID: Session.ID; readonly key: InstructionEntry.Key }
-export type Endpoint5_26Output = void
+export type Endpoint5_29Input = { readonly sessionID: Session.ID; readonly key: InstructionEntry.Key }
+export type Endpoint5_29Output = void
 export type SessionInstructionsEntryRemoveOperation<E = never> = (
-  input: Endpoint5_26Input,
-) => Effect.Effect<Endpoint5_26Output, E>
+  input: Endpoint5_29Input,
+) => Effect.Effect<Endpoint5_29Output, E>
 
-export type Endpoint5_27Input = { readonly sessionID: Session.ID; readonly prompt: string }
-export type Endpoint5_27Output = { readonly text: string }
-export type SessionGenerateOperation<E = never> = (input: Endpoint5_27Input) => Effect.Effect<Endpoint5_27Output, E>
+export type Endpoint5_30Input = { readonly sessionID: Session.ID; readonly prompt: string }
+export type Endpoint5_30Output = { readonly text: string }
+export type SessionGenerateOperation<E = never> = (input: Endpoint5_30Input) => Effect.Effect<Endpoint5_30Output, E>
 
-export type Endpoint5_28Input = {
+export type Endpoint5_31Input = {
   readonly sessionID: Session.ID
   readonly after?: Event.Seq | undefined
   readonly follow?: boolean | undefined
 }
-export type Endpoint5_28Output =
+export type Endpoint5_31Output =
   | (
       | {
           readonly id: Event.ID
@@ -404,6 +418,33 @@ export type Endpoint5_28Output =
             readonly input: SessionPending.Message
           }
         }
+      | {
+          readonly id: Event.ID
+          readonly created: DateTime.Utc
+          readonly metadata?: { readonly [x: string]: unknown } | undefined
+          readonly type: "session.input.cancelled"
+          readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
+          readonly location?: Location.Ref | undefined
+          readonly data: { readonly sessionID: Session.ID; readonly inputID: SessionMessage.ID }
+        }
+      | {
+          readonly id: Event.ID
+          readonly created: DateTime.Utc
+          readonly metadata?: { readonly [x: string]: unknown } | undefined
+          readonly type: "session.input.steered"
+          readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
+          readonly location?: Location.Ref | undefined
+          readonly data: { readonly sessionID: Session.ID; readonly inputID: SessionMessage.ID }
+        }
+      | {
+          readonly id: Event.ID
+          readonly created: DateTime.Utc
+          readonly metadata?: { readonly [x: string]: unknown } | undefined
+          readonly type: "session.input.queued"
+          readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
+          readonly location?: Location.Ref | undefined
+          readonly data: { readonly sessionID: Session.ID; readonly inputID: SessionMessage.ID }
+        }
       | {
           readonly id: Event.ID
           readonly created: DateTime.Utc
@@ -862,19 +903,19 @@ export type Endpoint5_28Output =
         }
     )
   | EventLog.Synced
-export type SessionLogOperation<E = never> = (input: Endpoint5_28Input) => Stream.Stream<Endpoint5_28Output, E>
+export type SessionLogOperation<E = never> = (input: Endpoint5_31Input) => Stream.Stream<Endpoint5_31Output, E>
 
-export type Endpoint5_29Input = { readonly sessionID: Session.ID }
-export type Endpoint5_29Output = void
-export type SessionInterruptOperation<E = never> = (input: Endpoint5_29Input) => Effect.Effect<Endpoint5_29Output, E>
+export type Endpoint5_32Input = { readonly sessionID: Session.ID }
+export type Endpoint5_32Output = void
+export type SessionInterruptOperation<E = never> = (input: Endpoint5_32Input) => Effect.Effect<Endpoint5_32Output, E>
 
-export type Endpoint5_30Input = { readonly sessionID: Session.ID }
-export type Endpoint5_30Output = void
-export type SessionBackgroundOperation<E = never> = (input: Endpoint5_30Input) => Effect.Effect<Endpoint5_30Output, E>
+export type Endpoint5_33Input = { readonly sessionID: Session.ID }
+export type Endpoint5_33Output = void
+export type SessionBackgroundOperation<E = never> = (input: Endpoint5_33Input) => Effect.Effect<Endpoint5_33Output, E>
 
-export type Endpoint5_31Input = { readonly sessionID: Session.ID; readonly messageID: SessionMessage.ID }
-export type Endpoint5_31Output = SessionMessage.Info
-export type SessionMessageOperation<E = never> = (input: Endpoint5_31Input) => Effect.Effect<Endpoint5_31Output, E>
+export type Endpoint5_34Input = { readonly sessionID: Session.ID; readonly messageID: SessionMessage.ID }
+export type Endpoint5_34Output = SessionMessage.Info
+export type SessionMessageOperation<E = never> = (input: Endpoint5_34Input) => Effect.Effect<Endpoint5_34Output, E>
 
 export interface SessionApi<E = never> {
   readonly list: SessionListOperation<E>
@@ -902,7 +943,12 @@ export interface SessionApi<E = never> {
     readonly commit: SessionRevertCommitOperation<E>
   }
   readonly context: SessionContextOperation<E>
-  readonly pending: { readonly list: SessionPendingListOperation<E> }
+  readonly pending: {
+    readonly list: SessionPendingListOperation<E>
+    readonly cancel: SessionPendingCancelOperation<E>
+    readonly steer: SessionPendingSteerOperation<E>
+    readonly queue: SessionPendingQueueOperation<E>
+  }
   readonly instructions: {
     readonly entry: {
       readonly list: SessionInstructionsEntryListOperation<E>
@@ -1006,7 +1052,6 @@ export type Endpoint10_3Input = {
   readonly integrationID: Integration.ID
   readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
   readonly key: string
-  readonly answers: Form.Answer
   readonly label?: string | undefined
 }
 export type Endpoint10_3Output = void
@@ -1018,7 +1063,7 @@ export type Endpoint10_4Input = {
   readonly integrationID: Integration.ID
   readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
   readonly methodID: Integration.MethodID
-  readonly answers: Form.Answer
+  readonly inputs: { readonly [x: string]: string }
   readonly label?: string | undefined
 }
 export type Endpoint10_4Output = { readonly location: Location.Info; readonly data: Integration.Attempt }

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

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

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

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

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

@@ -195,18 +195,12 @@ export type ProviderInfo = {
   body?: { [x: string]: any }
 }
 
-export type FormWhen = {
-  key: string
-  op: "eq" | "neq"
-  value: string | number | "Infinity" | "-Infinity" | "NaN" | boolean
-}
-
-export type FormOption = { value: string; label: string; description?: string }
-
-export type FormExternalField = { key: string; type: "external"; url: string; title?: string; description?: string }
+export type IntegrationWhen = { key: string; op: "eq" | "neq"; value: string }
 
 export type IntegrationCommandMethod = { id: string; type: "command"; label: string; command: Array<string> }
 
+export type IntegrationKeyMethod = { type: "key"; label?: string }
+
 export type IntegrationEnvMethod = { type: "env"; names: Array<string> }
 
 export type ConnectionCredentialInfo = { type: "credential"; id: string; label: string }
@@ -291,6 +285,16 @@ export type ProjectDirectory = { directory: string; strategy?: string }
 
 export type FormMetadata = { [x: string]: JsonValue }
 
+export type FormWhen = {
+  key: string
+  op: "eq" | "neq"
+  value: string | number | "Infinity" | "-Infinity" | "NaN" | boolean
+}
+
+export type FormOption = { value: string; label: string; description?: string }
+
+export type FormExternalField = { key: string; type: "external"; url: string; title?: string; description?: string }
+
 export type FormValue = string | number | boolean | Array<string>
 
 export type PermissionSource = { type: "tool"; messageID: string; id: string }
@@ -498,6 +502,36 @@ export type SessionInputPromoted = {
   data: { sessionID: string; inputID: string }
 }
 
+export type SessionInputCancelled = {
+  id: string
+  created: number
+  metadata?: { [x: string]: any }
+  type: "session.input.cancelled"
+  durable: { aggregateID: string; seq: number; version: 1 }
+  location?: LocationRef
+  data: { sessionID: string; inputID: string }
+}
+
+export type SessionInputSteered = {
+  id: string
+  created: number
+  metadata?: { [x: string]: any }
+  type: "session.input.steered"
+  durable: { aggregateID: string; seq: number; version: 1 }
+  location?: LocationRef
+  data: { sessionID: string; inputID: string }
+}
+
+export type SessionInputQueued = {
+  id: string
+  created: number
+  metadata?: { [x: string]: any }
+  type: "session.input.queued"
+  durable: { aggregateID: string; seq: number; version: 1 }
+  location?: LocationRef
+  data: { sessionID: string; inputID: string }
+}
+
 export type SessionExecutionStarted = {
   id: string
   created: number
@@ -1241,6 +1275,45 @@ export type ModelCost = {
   cache: { read: MoneyUSDPerMillionTokens; write: MoneyUSDPerMillionTokens }
 }
 
+export type IntegrationTextPrompt = {
+  type: "text"
+  key: string
+  message: string
+  placeholder?: string
+  when?: IntegrationWhen
+}
+
+export type IntegrationSelectPrompt = {
+  type: "select"
+  key: string
+  message: string
+  options: Array<{ label: string; value: string; hint?: string }>
+  when?: IntegrationWhen
+}
+
+export type ConnectionInfo = ConnectionCredentialInfo | ConnectionEnvInfo
+
+export type McpServer = {
+  name: string
+  status: McpStatusConnected | McpStatusPending | McpStatusDisabled | McpStatusFailed | McpStatusNeedsAuth
+  integrationID?: string
+}
+
+export type McpResourceCatalog = { resources: Array<McpResource>; templates: Array<McpResourceTemplate> }
+
+export type Project = {
+  id: string
+  canonical: string
+  vcs?: ProjectVcs
+  name?: string
+  icon?: ProjectIcon
+  commands?: ProjectCommands
+  time: ProjectTime
+  sandboxes: Array<string>
+}
+
+export type ProjectDirectories = Array<ProjectDirectory>
+
 export type FormNumberField = {
   key: string
   title?: string
@@ -1306,29 +1379,6 @@ export type FormMultiselectField = {
   default?: Array<string>
 }
 
-export type ConnectionInfo = ConnectionCredentialInfo | ConnectionEnvInfo
-
-export type McpServer = {
-  name: string
-  status: McpStatusConnected | McpStatusPending | McpStatusDisabled | McpStatusFailed | McpStatusNeedsAuth
-  integrationID?: string
-}
-
-export type McpResourceCatalog = { resources: Array<McpResource>; templates: Array<McpResourceTemplate> }
-
-export type Project = {
-  id: string
-  canonical: string
-  vcs?: ProjectVcs
-  name?: string
-  icon?: ProjectIcon
-  commands?: ProjectCommands
-  time: ProjectTime
-  sandboxes: Array<string>
-}
-
-export type ProjectDirectories = Array<ProjectDirectory>
-
 export type FormAnswer = { [x: string]: FormValue }
 
 export type PermissionRequest = {
@@ -1609,6 +1659,13 @@ export type ModelInfo = {
   limit: { context: number; input?: number; output: number }
 }
 
+export type IntegrationOAuthMethod = {
+  id: string
+  type: "oauth"
+  label: string
+  prompts?: Array<IntegrationTextPrompt | IntegrationSelectPrompt>
+}
+
 export type FormField =
   | FormStringField
   | FormNumberField
@@ -1862,9 +1919,15 @@ export type SessionMessageAssistantTool = {
   time: { created: number; ran?: number; completed?: number }
 }
 
+export type IntegrationMethod =
+  | IntegrationOAuthMethod
+  | IntegrationCommandMethod
+  | IntegrationKeyMethod
+  | IntegrationEnvMethod
+
 export type FormFields = [FormField, ...Array<FormField>]
 
-export type FormFields3 = [FormField1, ...Array<FormField1>]
+export type FormFields1 = [FormField1, ...Array<FormField1>]
 
 export type SessionPendingInfo = SessionPendingUser | SessionPendingSynthetic | SessionPendingCompaction
 
@@ -1886,13 +1949,16 @@ export type SessionMessageAssistant = {
   retry?: SessionMessageAssistantRetry
 }
 
-export type IntegrationOAuthMethod = { id: string; type: "oauth"; label: string; forms?: FormFields }
-
-export type IntegrationKeyMethod = { type: "key"; label?: string; forms?: FormFields }
+export type IntegrationInfo = {
+  id: string
+  name: string
+  methods: Array<IntegrationMethod>
+  connections: Array<ConnectionInfo>
+}
 
 export type FormInfo = { id: string; sessionID: string; title: string; metadata?: FormMetadata; fields: FormFields }
 
-export type FormInfo1 = { id: string; sessionID: string; title: string; metadata?: FormMetadata1; fields: FormFields3 }
+export type FormInfo1 = { id: string; sessionID: string; title: string; metadata?: FormMetadata1; fields: FormFields1 }
 
 export type SessionInputAdmitted = {
   id: string
@@ -1915,12 +1981,6 @@ export type SessionMessageInfo =
   | SessionMessageAssistant
   | SessionMessageCompaction
 
-export type IntegrationMethod =
-  | IntegrationOAuthMethod
-  | IntegrationCommandMethod
-  | IntegrationKeyMethod
-  | IntegrationEnvMethod
-
 export type FormCreated = {
   id: string
   created: number
@@ -1940,6 +2000,9 @@ export type SessionEventDurable =
   | SessionForked
   | SessionInputPromoted
   | SessionInputAdmitted
+  | SessionInputCancelled
+  | SessionInputSteered
+  | SessionInputQueued
   | SessionExecutionStarted
   | SessionExecutionSucceeded
   | SessionExecutionFailed
@@ -1978,13 +2041,6 @@ export type SessionMessagesResponse = {
   cursor: { previous?: string | null; next?: string | null }
 }
 
-export type IntegrationInfo = {
-  id: string
-  name: string
-  methods: Array<IntegrationMethod>
-  connections: Array<ConnectionInfo>
-}
-
 export type V2Event =
   | ModelsDevRefreshed
   | IntegrationUpdated
@@ -2001,6 +2057,9 @@ export type V2Event =
   | SessionForked
   | SessionInputPromoted
   | SessionInputAdmitted
+  | SessionInputCancelled
+  | SessionInputSteered
+  | SessionInputQueued
   | SessionExecutionStarted
   | SessionExecutionSucceeded
   | SessionExecutionFailed
@@ -3666,6 +3725,27 @@ export type SessionPendingListInput = { readonly sessionID: { readonly sessionID
 
 export type SessionPendingListOutput = { data: Array<SessionPendingInfo> }["data"]
 
+export type SessionPendingCancelInput = {
+  readonly sessionID: { readonly sessionID: string; readonly inputID: string }["sessionID"]
+  readonly inputID: { readonly sessionID: string; readonly inputID: string }["inputID"]
+}
+
+export type SessionPendingCancelOutput = void
+
+export type SessionPendingSteerInput = {
+  readonly sessionID: { readonly sessionID: string; readonly inputID: string }["sessionID"]
+  readonly inputID: { readonly sessionID: string; readonly inputID: string }["inputID"]
+}
+
+export type SessionPendingSteerOutput = void
+
+export type SessionPendingQueueInput = {
+  readonly sessionID: { readonly sessionID: string; readonly inputID: string }["sessionID"]
+  readonly inputID: { readonly sessionID: string; readonly inputID: string }["inputID"]
+}
+
+export type SessionPendingQueueOutput = void
+
 export type SessionInstructionsEntryListInput = { readonly sessionID: { readonly sessionID: string }["sessionID"] }
 
 export type SessionInstructionsEntryListOutput = { data: Array<InstructionEntryInfo> }["data"]
@@ -3834,21 +3914,8 @@ export type IntegrationConnectKeyInput = {
   readonly location?: {
     readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
   }["location"]
-  readonly key: {
-    readonly key: string
-    readonly answers: { readonly [x: string]: string | number | boolean | ReadonlyArray<string> }
-    readonly label?: string | undefined
-  }["key"]
-  readonly answers: {
-    readonly key: string
-    readonly answers: { readonly [x: string]: string | number | boolean | ReadonlyArray<string> }
-    readonly label?: string | undefined
-  }["answers"]
-  readonly label?: {
-    readonly key: string
-    readonly answers: { readonly [x: string]: string | number | boolean | ReadonlyArray<string> }
-    readonly label?: string | undefined
-  }["label"]
+  readonly key: { readonly key: string; readonly label?: string | undefined }["key"]
+  readonly label?: { readonly key: string; readonly label?: string | undefined }["label"]
 }
 
 export type IntegrationConnectKeyOutput = void
@@ -3860,17 +3927,17 @@ export type IntegrationOauthConnectInput = {
   }["location"]
   readonly methodID: {
     readonly methodID: string
-    readonly answers: { readonly [x: string]: string | number | boolean | ReadonlyArray<string> }
+    readonly inputs: { readonly [x: string]: string }
     readonly label?: string | undefined
   }["methodID"]
-  readonly answers: {
+  readonly inputs: {
     readonly methodID: string
-    readonly answers: { readonly [x: string]: string | number | boolean | ReadonlyArray<string> }
+    readonly inputs: { readonly [x: string]: string }
     readonly label?: string | undefined
-  }["answers"]
+  }["inputs"]
   readonly label?: {
     readonly methodID: string
-    readonly answers: { readonly [x: string]: string | number | boolean | ReadonlyArray<string> }
+    readonly inputs: { readonly [x: string]: string }
     readonly label?: string | undefined
   }["label"]
 }

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

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

packages/client/test/promise.test.ts

@@ -32,6 +32,7 @@ test("exposes every standard HTTP API group", () => {
     "projectCopy",
     "vcs",
     "debug",
+    "migration",
     "websearch",
     "config",
   ])
@@ -147,45 +148,6 @@ test("experimental wellknown integration add uses the public HTTP contract", asy
   expect(await request?.json()).toEqual({ url: "https://example.com" })
 })
 
-test("integration connections submit form answers", async () => {
-  const requests: Request[] = []
-  const client = OpenCode.make({
-    baseUrl: "http://localhost:3000",
-    fetch: async (input, init) => {
-      const request = input instanceof Request ? input : new Request(input, init)
-      requests.push(request)
-      if (request.url.endsWith("/connect/key")) return new Response(null, { status: 204 })
-      return Response.json({
-        location: { directory: "/tmp/project", project: { id: "proj_test", directory: "/tmp/project" } },
-        data: {
-          attemptID: "con_test",
-          url: "https://example.com/authorize",
-          instructions: "Authorize",
-          mode: "auto",
-          time: { created: 1, expires: 2 },
-        },
-      })
-    },
-  })
-
-  await client.integration.connect.key({
-    integrationID: "cloudflare-workers-ai",
-    key: "secret",
-    answers: { accountId: "account" },
-  })
-  await client.integration.oauth.connect({
-    integrationID: "github-copilot",
-    methodID: "device",
-    answers: { deploymentType: "enterprise", enabled: true, scopes: ["read:user"] },
-  })
-
-  expect(await requests[0].json()).toEqual({ key: "secret", answers: { accountId: "account" } })
-  expect(await requests[1].json()).toEqual({
-    methodID: "device",
-    answers: { deploymentType: "enterprise", enabled: true, scopes: ["read:user"] },
-  })
-})
-
 test("health.stop sends exact replacement identity", async () => {
   let request: Request | undefined
   const client = OpenCode.make({
@@ -395,6 +357,28 @@ test("session.pending.list uses the public HTTP contract", async () => {
   expect(requests).toEqual([{ method: "GET", url: "http://localhost:3000/api/session/ses_test/pending" }])
 })
 
+test("session.pending mutations use the public HTTP contract", async () => {
+  const requests: Array<{ method: string; url: string }> = []
+  const client = OpenCode.make({
+    baseUrl: "http://localhost:3000",
+    fetch: async (input, init) => {
+      const request = input instanceof Request ? input : new Request(input, init)
+      requests.push({ method: request.method, url: request.url })
+      return new Response(null, { status: 204 })
+    },
+  })
+
+  await client.session.pending.cancel({ sessionID: "ses_test", inputID: "msg_cancel" })
+  await client.session.pending.steer({ sessionID: "ses_test", inputID: "msg_steer" })
+  await client.session.pending.queue({ sessionID: "ses_test", inputID: "msg_queue" })
+
+  expect(requests).toEqual([
+    { method: "DELETE", url: "http://localhost:3000/api/session/ses_test/pending/msg_cancel" },
+    { method: "POST", url: "http://localhost:3000/api/session/ses_test/pending/msg_steer/steer" },
+    { method: "POST", url: "http://localhost:3000/api/session/ses_test/pending/msg_queue/queue" },
+  ])
+})
+
 test("event.subscribe exposes the Promise event stream wire projection", async () => {
   const client = OpenCode.make({
     baseUrl: "http://localhost:3000",

packages/core/package.json

@@ -11,12 +11,13 @@
     "fix-node-pty": "bun run script/fix-node-pty.ts",
     "benchmark:location": "bun run script/benchmark-location.ts",
     "test": "bun test --only-failures",
-    "typecheck": "tsgo --noEmit"
+    "typecheck": "tsgo -b tsconfig.json tsconfig.tests.json"
   },
   "bin": {
     "opencode": "./bin/opencode"
   },
   "exports": {
+    "./environment": "./src/environment/index.ts",
     "./session/runner": "./src/session/runner/index.ts",
     "./instructions": "./src/instructions/index.ts",
     "./*": "./src/*.ts"
@@ -117,6 +118,7 @@
     "immer": "11.1.4",
     "ignore": "7.0.5",
     "jsonc-parser": "3.3.1",
+    "mime-types": "3.0.2",
     "turndown": "7.2.0",
     "tree-sitter-bash": "0.25.0",
     "tree-sitter-powershell": "0.25.10",

packages/core/script/migration.ts

@@ -132,14 +132,16 @@ function renderMigration(name: string, sql: string) {
   return `import { Effect } from "effect"
 import type { DatabaseMigration } from "../migration"
 
-export default {
+const migration: DatabaseMigration.Migration = {
   id: ${JSON.stringify(name)},
   up(tx) {
     return Effect.gen(function* () {
 ${renderStatements(sql)}
     })
   },
-} satisfies DatabaseMigration.Migration
+}
+
+export default migration
 `
 }
 
@@ -147,13 +149,15 @@ function renderSchema(sql: string) {
   return `import { Effect } from "effect"
 import type { DatabaseMigration } from "./migration"
 
-export default {
+const schema: Omit<DatabaseMigration.Migration, "id"> = {
   up(tx) {
     return Effect.gen(function* () {
 ${renderStatements(sql)}
     })
   },
-} satisfies Omit<DatabaseMigration.Migration, "id">
+}
+
+export default schema
 `
 }
 
@@ -191,10 +195,10 @@ async function formatTypescript(input: string) {
 function renderRegistry(names: string[]) {
   return `import type { DatabaseMigration } from "./migration"
 
-export const migrations = (
+export const migrations: DatabaseMigration.Migration[] = (
   await Promise.all([
 ${names.map((name) => `    import("./migration/${name}"),`).join("\n")}
   ])
-).map((module) => module.default) satisfies DatabaseMigration.Migration[]
+).map((module) => module.default)
 `
 }

packages/core/src/aisdk-native.ts

@@ -263,6 +263,7 @@ function mapOpenRouterOptions(settings: Readonly<Record<string, unknown>>) {
           "extraBody",
           "fetch",
           "headers",
+          "promptCacheKey",
           "timeout",
         ].includes(key),
     ),
@@ -279,7 +280,6 @@ function mapXAIOptions(settings: Readonly<Record<string, unknown>>) {
   const options = {
     ...(typeof settings.reasoningEffort === "string" ? { reasoningEffort: settings.reasoningEffort } : {}),
     ...(typeof settings.store === "boolean" ? { store: settings.store } : {}),
-    ...(typeof settings.promptCacheKey === "string" ? { promptCacheKey: settings.promptCacheKey } : {}),
   }
   if (Object.keys(options).length === 0) return {}
   return { providerOptions: { xai: options } }

packages/core/src/codemode/instructions.ts

@@ -126,7 +126,7 @@ ${render(current)}`
 const key = Instructions.Key.make("core/codemode")
 const codec = Schema.toCodecJson(CodeModeCatalog.Summary)
 
-export const make = (entries?: ReadonlyArray<CodeModeCatalog.Entry>): Instructions.Instructions => {
+export const make = (entries?: ReadonlyArray<CodeModeCatalog.Entry>): Instructions.List => {
   const catalog = entries === undefined ? Instructions.removed : CodeModeCatalog.summarize(entries)
   return Instructions.make({
     key,

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

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

packages/core/src/database/migration.gen.ts

@@ -1,6 +1,6 @@
 import type { DatabaseMigration } from "./migration"
 
-export const migrations = (
+export const migrations: DatabaseMigration.Migration[] = (
   await Promise.all([
     import("./migration/20260127222353_familiar_lady_ursula"),
     import("./migration/20260211171708_add_project_commands"),
@@ -43,4 +43,4 @@ export const migrations = (
     import("./migration/20260804233008_loose_psylocke"),
     import("./migration/20260805200742_import_legacy_credentials"),
   ])
-).map((module) => module.default) satisfies DatabaseMigration.Migration[]
+).map((module) => module.default)

packages/core/src/database/migration/20260127222353_familiar_lady_ursula.ts

@@ -1,7 +1,7 @@
 import { Effect } from "effect"
 import type { DatabaseMigration } from "../migration"
 
-export default {
+const migration: DatabaseMigration.Migration = {
   id: "20260127222353_familiar_lady_ursula",
   up(tx) {
     return Effect.gen(function* () {
@@ -104,4 +104,6 @@ export default {
       yield* tx.run(`CREATE INDEX \`todo_session_idx\` ON \`todo\` (\`session_id\`);`)
     })
   },
-} satisfies DatabaseMigration.Migration
+}
+
+export default migration

packages/core/src/database/migration/20260211171708_add_project_commands.ts

@@ -1,11 +1,13 @@
 import { Effect } from "effect"
 import type { DatabaseMigration } from "../migration"
 
-export default {
+const migration: DatabaseMigration.Migration = {
   id: "20260211171708_add_project_commands",
   up(tx) {
     return Effect.gen(function* () {
       yield* tx.run(`ALTER TABLE \`project\` ADD \`commands\` text;`)
     })
   },
-} satisfies DatabaseMigration.Migration
+}
+
+export default migration

packages/core/src/database/migration/20260213144116_wakeful_the_professor.ts

@@ -1,7 +1,7 @@
 import { Effect } from "effect"
 import type { DatabaseMigration } from "../migration"
 
-export default {
+const migration: DatabaseMigration.Migration = {
   id: "20260213144116_wakeful_the_professor",
   up(tx) {
     return Effect.gen(function* () {
@@ -20,4 +20,6 @@ export default {
       `)
     })
   },
-} satisfies DatabaseMigration.Migration
+}
+
+export default migration

packages/core/src/database/migration/20260225215848_workspace.ts

@@ -1,7 +1,7 @@
 import { Effect } from "effect"
 import type { DatabaseMigration } from "../migration"
 
-export default {
+const migration: DatabaseMigration.Migration = {
   id: "20260225215848_workspace",
   up(tx) {
     return Effect.gen(function* () {
@@ -16,4 +16,6 @@ export default {
       `)
     })
   },
-} satisfies DatabaseMigration.Migration
+}
+
+export default migration

packages/core/src/database/migration/20260227213759_add_session_workspace_id.ts

@@ -1,7 +1,7 @@
 import { Effect } from "effect"
 import type { DatabaseMigration } from "../migration"
 
-export default {
+const migration: DatabaseMigration.Migration = {
   id: "20260227213759_add_session_workspace_id",
   up(tx) {
     return Effect.gen(function* () {
@@ -9,4 +9,6 @@ export default {
       yield* tx.run(`CREATE INDEX \`session_workspace_idx\` ON \`session\` (\`workspace_id\`);`)
     })
   },
-} satisfies DatabaseMigration.Migration
+}
+
+export default migration

packages/core/src/database/migration/20260228203230_blue_harpoon.ts

@@ -1,7 +1,7 @@
 import { Effect } from "effect"
 import type { DatabaseMigration } from "../migration"
 
-export default {
+const migration: DatabaseMigration.Migration = {
   id: "20260228203230_blue_harpoon",
   up(tx) {
     return Effect.gen(function* () {
@@ -27,4 +27,6 @@ export default {
       `)
     })
   },
-} satisfies DatabaseMigration.Migration
+}
+
+export default migration

packages/core/src/database/migration/20260303231226_add_workspace_fields.ts

@@ -1,7 +1,7 @@
 import { Effect } from "effect"
 import type { DatabaseMigration } from "../migration"
 
-export default {
+const migration: DatabaseMigration.Migration = {
   id: "20260303231226_add_workspace_fields",
   up(tx) {
     return Effect.gen(function* () {
@@ -12,4 +12,6 @@ export default {
       yield* tx.run(`ALTER TABLE \`workspace\` DROP COLUMN \`config\`;`)
     })
   },
-} satisfies DatabaseMigration.Migration
+}
+
+export default migration

packages/core/src/database/migration/20260309230000_move_org_to_state.ts

@@ -1,7 +1,7 @@
 import { Effect } from "effect"
 import type { DatabaseMigration } from "../migration"
 
-export default {
+const migration: DatabaseMigration.Migration = {
   id: "20260309230000_move_org_to_state",
   up(tx) {
     return Effect.gen(function* () {
@@ -12,4 +12,6 @@ export default {
       yield* tx.run(`ALTER TABLE \`account\` DROP COLUMN \`selected_org_id\`;`)
     })
   },
-} satisfies DatabaseMigration.Migration
+}
+
+export default migration

packages/core/src/database/migration/20260312043431_session_message_cursor.ts

@@ -1,7 +1,7 @@
 import { Effect } from "effect"
 import type { DatabaseMigration } from "../migration"
 
-export default {
+const migration: DatabaseMigration.Migration = {
   id: "20260312043431_session_message_cursor",
   up(tx) {
     return Effect.gen(function* () {
@@ -13,4 +13,6 @@ export default {
       yield* tx.run(`CREATE INDEX \`part_message_id_id_idx\` ON \`part\` (\`message_id\`,\`id\`);`)
     })
   },
-} satisfies DatabaseMigration.Migration
+}
+
+export default migration

packages/core/src/database/migration/20260323234822_events.ts

@@ -1,7 +1,7 @@
 import { Effect } from "effect"
 import type { DatabaseMigration } from "../migration"
 
-export default {
+const migration: DatabaseMigration.Migration = {
   id: "20260323234822_events",
   up(tx) {
     return Effect.gen(function* () {
@@ -23,4 +23,6 @@ export default {
       `)
     })
   },
-} satisfies DatabaseMigration.Migration
+}
+
+export default migration

packages/core/src/database/migration/20260410174513_workspace-name.ts

@@ -1,7 +1,7 @@
 import { Effect } from "effect"
 import type { DatabaseMigration } from "../migration"
 
-export default {
+const migration: DatabaseMigration.Migration = {
   id: "20260410174513_workspace-name",
   up(tx) {
     return Effect.gen(function* () {
@@ -26,4 +26,6 @@ export default {
       yield* tx.run(`PRAGMA foreign_keys=ON;`)
     })
   },
-} satisfies DatabaseMigration.Migration
+}
+
+export default migration

packages/core/src/database/migration/20260413175956_chief_energizer.ts

@@ -1,7 +1,7 @@
 import { Effect } from "effect"
 import type { DatabaseMigration } from "../migration"
 
-export default {
+const migration: DatabaseMigration.Migration = {
   id: "20260413175956_chief_energizer",
   up(tx) {
     return Effect.gen(function* () {
@@ -21,4 +21,6 @@ export default {
       yield* tx.run(`CREATE INDEX \`session_entry_time_created_idx\` ON \`session_entry\` (\`time_created\`);`)
     })
   },
-} satisfies DatabaseMigration.Migration
+}
+
+export default migration

packages/core/src/database/migration/20260423070820_add_icon_url_override.ts

@@ -1,7 +1,7 @@
 import { Effect } from "effect"
 import type { DatabaseMigration } from "../migration"
 
-export default {
+const migration: DatabaseMigration.Migration = {
   id: "20260423070820_add_icon_url_override",
   up(tx) {
     return Effect.gen(function* () {
@@ -11,4 +11,6 @@ export default {
       `)
     })
   },
-} satisfies DatabaseMigration.Migration
+}
+
+export default migration

packages/core/src/database/migration/20260427172553_slow_nightmare.ts

@@ -1,7 +1,7 @@
 import { Effect } from "effect"
 import type { DatabaseMigration } from "../migration"
 
-export default {
+const migration: DatabaseMigration.Migration = {
   id: "20260427172553_slow_nightmare",
   up(tx) {
     return Effect.gen(function* () {
@@ -27,4 +27,6 @@ export default {
       yield* tx.run(`DROP TABLE \`session_entry\`;`)
     })
   },
-} satisfies DatabaseMigration.Migration
+}
+
+export default migration

packages/core/src/database/migration/20260428004200_add_session_path.ts

@@ -1,11 +1,13 @@
 import { Effect } from "effect"
 import type { DatabaseMigration } from "../migration"
 
-export default {
+const migration: DatabaseMigration.Migration = {
   id: "20260428004200_add_session_path",
   up(tx) {
     return Effect.gen(function* () {
       yield* tx.run(`ALTER TABLE \`session\` ADD \`path\` text;`)
     })
   },
-} satisfies DatabaseMigration.Migration
+}
+
+export default migration

packages/core/src/database/migration/20260501142318_next_venus.ts

@@ -1,7 +1,7 @@
 import { Effect } from "effect"
 import type { DatabaseMigration } from "../migration"
 
-export default {
+const migration: DatabaseMigration.Migration = {
   id: "20260501142318_next_venus",
   up(tx) {
     return Effect.gen(function* () {
@@ -9,4 +9,6 @@ export default {
       yield* tx.run(`ALTER TABLE \`session\` ADD \`model\` text;`)
     })
   },
-} satisfies DatabaseMigration.Migration
+}
+
+export default migration

packages/core/src/database/migration/20260504145000_add_sync_owner.ts

@@ -1,11 +1,13 @@
 import { Effect } from "effect"
 import type { DatabaseMigration } from "../migration"
 
-export default {
+const migration: DatabaseMigration.Migration = {
   id: "20260504145000_add_sync_owner",
   up(tx) {
     return Effect.gen(function* () {
       yield* tx.run(`ALTER TABLE \`event_sequence\` ADD \`owner_id\` text;`)
     })
   },
-} satisfies DatabaseMigration.Migration
+}
+
+export default migration

packages/core/src/database/migration/20260507164347_add_workspace_time.ts

@@ -1,11 +1,13 @@
 import { Effect } from "effect"
 import type { DatabaseMigration } from "../migration"
 
-export default {
+const migration: DatabaseMigration.Migration = {
   id: "20260507164347_add_workspace_time",
   up(tx) {
     return Effect.gen(function* () {
       yield* tx.run(`ALTER TABLE \`workspace\` ADD \`time_used\` integer NOT NULL DEFAULT 0;`)
     })
   },
-} satisfies DatabaseMigration.Migration
+}
+
+export default migration

packages/core/src/database/migration/20260510033149_session_usage.ts

@@ -1,7 +1,7 @@
 import { Effect } from "effect"
 import type { DatabaseMigration } from "../migration"
 
-export default {
+const migration: DatabaseMigration.Migration = {
   id: "20260510033149_session_usage",
   up(tx) {
     return Effect.gen(function* () {
@@ -53,4 +53,6 @@ export default {
       `)
     })
   },
-} satisfies DatabaseMigration.Migration
+}
+
+export default migration

packages/core/src/database/migration/20260511000411_data_migration_state.ts

@@ -1,7 +1,7 @@
 import { Effect } from "effect"
 import type { DatabaseMigration } from "../migration"
 
-export default {
+const migration: DatabaseMigration.Migration = {
   id: "20260511000411_data_migration_state",
   up(tx) {
     return Effect.gen(function* () {
@@ -13,4 +13,6 @@ export default {
       `)
     })
   },
-} satisfies DatabaseMigration.Migration
+}
+
+export default migration

packages/core/src/database/migration/20260511173437_session-metadata.ts

@@ -1,7 +1,7 @@
 import { Effect } from "effect"
 import type { DatabaseMigration } from "../migration"
 
-export default {
+const migration: DatabaseMigration.Migration = {
   id: "20260511173437_session-metadata",
   up(tx) {
     return Effect.gen(function* () {
@@ -13,4 +13,6 @@ export default {
       yield* tx.run(`ALTER TABLE \`session\` ADD \`metadata\` text;`)
     })
   },
-} satisfies DatabaseMigration.Migration
+}
+
+export default migration

packages/core/src/database/migration/20260601010001_normalize_storage_paths.ts

@@ -1,7 +1,7 @@
 import { Effect } from "effect"
 import type { DatabaseMigration } from "../migration"
 
-export default {
+const migration: DatabaseMigration.Migration = {
   id: "20260601010001_normalize_storage_paths",
   up(tx) {
     return Effect.gen(function* () {
@@ -19,4 +19,6 @@ export default {
       )
     })
   },
-} satisfies DatabaseMigration.Migration
+}
+
+export default migration

packages/core/src/database/migration/20260601202201_amazing_prowler.ts

@@ -1,11 +1,13 @@
 import { Effect } from "effect"
 import type { DatabaseMigration } from "../migration"
 
-export default {
+const migration: DatabaseMigration.Migration = {
   id: "20260601202201_amazing_prowler",
   up(tx) {
     return Effect.gen(function* () {
       yield* tx.run(`DROP TABLE \`permission\`;`)
     })
   },
-} satisfies DatabaseMigration.Migration
+}
+
+export default migration

packages/core/src/database/migration/20260602002951_lowly_union_jack.ts

@@ -1,7 +1,7 @@
 import { Effect } from "effect"
 import type { DatabaseMigration } from "../migration"
 
-export default {
+const migration: DatabaseMigration.Migration = {
   id: "20260602002951_lowly_union_jack",
   up(tx) {
     return Effect.gen(function* () {
@@ -21,4 +21,6 @@ export default {
       )
     })
   },
-} satisfies DatabaseMigration.Migration
+}
+
+export default migration

packages/core/src/database/migration/20260602182828_add_project_directories.ts

@@ -1,7 +1,7 @@
 import { Effect } from "effect"
 import type { DatabaseMigration } from "../migration"
 
-export default {
+const migration: DatabaseMigration.Migration = {
   id: "20260602182828_add_project_directories",
   up(tx) {
     return Effect.gen(function* () {
@@ -17,4 +17,6 @@ export default {
       `)
     })
   },
-} satisfies DatabaseMigration.Migration
+}
+
+export default migration

packages/core/src/database/migration/20260603001617_session_message_projection_indexes.ts

@@ -1,7 +1,7 @@
 import { Effect } from "effect"
 import type { DatabaseMigration } from "../migration"
 
-export default {
+const migration: DatabaseMigration.Migration = {
   id: "20260603001617_session_message_projection_indexes",
   up(tx) {
     return Effect.gen(function* () {
@@ -16,4 +16,6 @@ export default {
       )
     })
   },
-} satisfies DatabaseMigration.Migration
+}
+
+export default migration

packages/core/src/database/migration/20260603040000_session_message_projection_order.ts

@@ -1,7 +1,7 @@
 import { Effect } from "effect"
 import type { DatabaseMigration } from "../migration"
 
-export default {
+const migration: DatabaseMigration.Migration = {
   id: "20260603040000_session_message_projection_order",
   up(tx) {
     return Effect.gen(function* () {
@@ -16,4 +16,6 @@ export default {
       )
     })
   },
-} satisfies DatabaseMigration.Migration
+}
+
+export default migration

packages/core/src/database/migration/20260603141458_session_input_inbox.ts

@@ -1,7 +1,7 @@
 import { Effect } from "effect"
 import type { DatabaseMigration } from "../migration"
 
-export default {
+const migration: DatabaseMigration.Migration = {
   id: "20260603141458_session_input_inbox",
   up(tx) {
     return Effect.gen(function* () {
@@ -22,4 +22,6 @@ export default {
       )
     })
   },
-} satisfies DatabaseMigration.Migration
+}
+
+export default migration

packages/core/src/database/migration/20260603160727_jittery_ezekiel_stane.ts

@@ -1,7 +1,7 @@
 import { Effect } from "effect"
 import type { DatabaseMigration } from "../migration"
 
-export default {
+const migration: DatabaseMigration.Migration = {
   id: "20260603160727_jittery_ezekiel_stane",
   up(tx) {
     return Effect.gen(function* () {
@@ -17,4 +17,6 @@ export default {
       )
     })
   },
-} satisfies DatabaseMigration.Migration
+}
+
+export default migration

packages/core/src/database/migration/20260604172448_event_sourced_session_input.ts

@@ -1,7 +1,7 @@
 import { Effect } from "effect"
 import type { DatabaseMigration } from "../migration"
 
-export default {
+const migration: DatabaseMigration.Migration = {
   id: "20260604172448_event_sourced_session_input",
   up(tx) {
     return Effect.gen(function* () {
@@ -44,4 +44,6 @@ export default {
       )
     })
   },
-} satisfies DatabaseMigration.Migration
+}
+
+export default migration

packages/core/src/database/migration/20260605003541_add_session_context_snapshot.ts

@@ -1,7 +1,7 @@
 import { Effect } from "effect"
 import type { DatabaseMigration } from "../migration"
 
-export default {
+const migration: DatabaseMigration.Migration = {
   id: "20260605003541_add_session_context_snapshot",
   up(tx) {
     return Effect.gen(function* () {
@@ -18,4 +18,6 @@ export default {
       `)
     })
   },
-} satisfies DatabaseMigration.Migration
+}
+
+export default migration

packages/core/src/database/migration/20260605042240_add_context_epoch_agent.ts

@@ -1,11 +1,13 @@
 import { Effect } from "effect"
 import type { DatabaseMigration } from "../migration"
 
-export default {
+const migration: DatabaseMigration.Migration = {
   id: "20260605042240_add_context_epoch_agent",
   up(tx) {
     return Effect.gen(function* () {
       yield* tx.run(`ALTER TABLE \`session_context_epoch\` ADD \`agent\` text DEFAULT 'build' NOT NULL;`)
     })
   },
-} satisfies DatabaseMigration.Migration
+}
+
+export default migration

packages/core/src/database/migration/20260611035744_credential.ts

@@ -1,7 +1,7 @@
 import { Effect } from "effect"
 import type { DatabaseMigration } from "../migration"
 
-export default {
+const migration: DatabaseMigration.Migration = {
   id: "20260611035744_credential",
   up(tx) {
     return Effect.gen(function* () {
@@ -22,4 +22,6 @@ export default {
       )
     })
   },
-} satisfies DatabaseMigration.Migration
+}
+
+export default migration

packages/core/src/database/migration/20260611192811_lush_chimera.ts

@@ -1,7 +1,7 @@
 import { Effect } from "effect"
 import type { DatabaseMigration } from "../migration"
 
-export default {
+const migration: DatabaseMigration.Migration = {
   id: "20260611192811_lush_chimera",
   up(tx) {
     return Effect.gen(function* () {
@@ -22,4 +22,6 @@ export default {
       `)
     })
   },
-} satisfies DatabaseMigration.Migration
+}
+
+export default migration

packages/core/src/database/migration/20260612174303_project_dir_strategy.ts

@@ -1,7 +1,7 @@
 import { Effect } from "effect"
 import type { DatabaseMigration } from "../migration"
 
-export default {
+const migration: DatabaseMigration.Migration = {
   id: "20260612174303_project_dir_strategy",
   up(tx) {
     return Effect.gen(function* () {
@@ -26,4 +26,6 @@ export default {
       yield* tx.run(`PRAGMA foreign_keys=ON;`)
     })
   },
-} satisfies DatabaseMigration.Migration
+}
+
+export default migration

packages/core/src/database/migration/20260622142730_simplify_session_context_epoch.ts

@@ -1,7 +1,7 @@
 import { Effect } from "effect"
 import type { DatabaseMigration } from "../migration"
 
-export default {
+const migration: DatabaseMigration.Migration = {
   id: "20260622142730_simplify_session_context_epoch",
   up(tx) {
     return Effect.gen(function* () {
@@ -10,4 +10,6 @@ export default {
       yield* tx.run(`ALTER TABLE \`session_context_epoch\` DROP COLUMN \`revision\`;`)
     })
   },
-} satisfies DatabaseMigration.Migration
+}
+
+export default migration

packages/core/src/database/migration/20260622170816_reset_v2_session_state.ts

@@ -1,7 +1,7 @@
 import { Effect } from "effect"
 import type { DatabaseMigration } from "../migration"
 
-export default {
+const migration: DatabaseMigration.Migration = {
   id: "20260622170816_reset_v2_session_state",
   up(tx) {
     return Effect.gen(function* () {
@@ -12,4 +12,6 @@ export default {
       yield* tx.run(`DELETE FROM \`event_sequence\`;`)
     })
   },
-} satisfies DatabaseMigration.Migration
+}
+
+export default migration

packages/core/src/database/migration/20260622202450_simplify_session_input.ts

@@ -1,7 +1,7 @@
 import { Effect } from "effect"
 import type { DatabaseMigration } from "../migration"
 
-export default {
+const migration: DatabaseMigration.Migration = {
   id: "20260622202450_simplify_session_input",
   up(tx) {
     return Effect.gen(function* () {
@@ -14,4 +14,6 @@ export default {
       yield* tx.run(`DELETE FROM \`workspace\`;`)
     })
   },
-} satisfies DatabaseMigration.Migration
+}
+
+export default migration

packages/core/src/database/migration/20260804233008_loose_psylocke.ts

@@ -1,7 +1,7 @@
 import { Effect } from "effect"
 import type { DatabaseMigration } from "../migration"
 
-export default {
+const migration: DatabaseMigration.Migration = {
   id: "20260804233008_loose_psylocke",
   up(tx) {
     return Effect.gen(function* () {
@@ -135,4 +135,6 @@ export default {
       yield* tx.run(`DROP TABLE \`session_input\`;`)
     })
   },
-} satisfies DatabaseMigration.Migration
+}
+
+export default migration

packages/core/src/database/migration/20260805200742_import_legacy_credentials.ts

@@ -30,12 +30,14 @@ const decodeJson = Schema.decodeUnknownOption(Schema.UnknownFromJsonString)
 const decodeValue = Schema.decodeUnknownOption(LegacyValue)
 const wellKnownSourcesKey = "wellknown:sources"
 
-export default {
+const migration: DatabaseMigration.Migration = {
   id: "20260805200742_import_legacy_credentials",
   up(tx) {
     return importLegacyCredentials(tx, path.join(Global.Path.data, "auth.json"))
   },
-} satisfies DatabaseMigration.Migration
+}
+
+export default migration
 
 export function importLegacyCredentials(tx: Parameters<DatabaseMigration.Migration["up"]>[0], filepath: string) {
   return Effect.gen(function* () {

packages/core/src/database/schema.gen.ts

@@ -1,7 +1,7 @@
 import { Effect } from "effect"
 import type { DatabaseMigration } from "./migration"
 
-export default {
+const schema: Omit<DatabaseMigration.Migration, "id"> = {
   up(tx) {
     return Effect.gen(function* () {
       yield* tx.run(`
@@ -248,4 +248,6 @@ export default {
       )
     })
   },
-} satisfies Omit<DatabaseMigration.Migration, "id">
+}
+
+export default schema

packages/core/src/environment/driver.ts

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

packages/core/src/environment/environment.ts

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

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

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

packages/core/src/environment/files.ts

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

packages/core/src/environment/index.ts

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

packages/core/src/environment/local.ts

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

packages/core/src/environment/memory.ts

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

packages/core/src/file-mutation.ts

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

packages/core/src/filesystem/location-watcher.ts

@@ -11,15 +11,6 @@ import { FSUtil } from "@opencode-ai/util/fs-util"
 import { Git } from "../git"
 import { Location } from "../location"
 import { Watcher } from "./watcher"
-import { Ignore } from "./ignore"
-import { Protected } from "./protected"
-
-function protecteds(dir: string) {
-  return Protected.paths().filter((item) => {
-    const relative = path.relative(dir, item)
-    return relative !== "" && !relative.startsWith("..") && !path.isAbsolute(relative)
-  })
-}
 
 export interface Interface {}
 
@@ -44,19 +35,6 @@ const layer = Layer.effect(
       const config = (yield* configService.entries())
         .filter((entry): entry is Document => entry.type === "document")
         .flatMap((item) => item.info.watcher?.ignore ?? [])
-      const home = Protected.isHome(location.directory)
-
-      if (!home && location.vcs) {
-        const updates = yield* watcher.subscribe({
-          path: location.directory,
-          type: "directory",
-          ignore: [...Ignore.PATTERNS, ...config, ...protecteds(location.directory)],
-        })
-        yield* updates.pipe(Stream.runForEach(publish), Effect.forkScoped)
-      }
-      if (home) {
-        yield* Effect.logInfo("location watcher skipped home directory", { directory: location.directory })
-      }
 
       if (location.vcs?.type === "git") {
         const resolved = (yield* git.repo.discover(location.directory))?.gitDirectory
@@ -64,10 +42,7 @@ const layer = Layer.effect(
           ? yield* fs.realPath(resolved).pipe(Effect.catch(() => Effect.succeed(resolved)))
           : undefined
         if (vcs && !config.includes(".git") && !config.includes(vcs) && (!resolved || !config.includes(resolved))) {
-          const ignore = (yield* fs.readDirectoryEntries(vcs).pipe(Effect.catch(() => Effect.succeed([])))).flatMap(
-            (entry) => (entry.name === "HEAD" ? [] : [entry.name]),
-          )
-          const updates = yield* watcher.subscribe({ path: vcs, type: "directory", ignore })
+          const updates = yield* watcher.subscribe({ path: path.join(vcs, "HEAD"), type: "file" })
           yield* updates.pipe(Stream.runForEach(publish), Effect.forkScoped)
         }
       }

packages/core/src/form.ts

@@ -180,14 +180,10 @@ export const layer = Layer.effect(
         Effect.gen(function* () {
           const entry = yield* find(input.id)
           if (entry.state.status !== "pending") return yield* new AlreadySettledError({ id: input.id })
-          const invalid = validateAnswer(entry.form.fields, input.answer)
+          const invalid = validateAnswer(entry.form, input.answer)
           if (invalid) return yield* new InvalidAnswerError({ id: input.id, message: invalid })
           const next: TerminalState = { status: "answered", answer: input.answer }
-          yield* bus.publish(Form.Event.Replied, {
-            id: input.id,
-            sessionID: entry.form.sessionID,
-            answer: input.answer,
-          })
+          yield* bus.publish(Form.Event.Replied, { id: input.id, sessionID: entry.form.sessionID, answer: input.answer })
           yield* Cache.set(forms, input.id, { ...entry, state: next })
           yield* Deferred.succeed(entry.deferred, next)
         }),
@@ -227,12 +223,12 @@ export const locationLayer = layer
 
 export const node = makeLocationNode({ service: Service, layer, deps: [Bus.node] })
 
-export function validateAnswer(forms: ReadonlyArray<Form.Field>, answer: Answer) {
-  const fields = new Map(forms.map((field) => [field.key, field] as const))
+function validateAnswer(form: Info, answer: Answer) {
+  const fields = new Map(form.fields.map((field) => [field.key, field] as const))
   for (const key of Object.keys(answer)) {
     if (!fields.has(key)) return `Unknown form field: ${key}`
   }
-  for (const field of forms) {
+  for (const field of form.fields) {
     const value = answer[field.key]
     if (field.type === "external") {
       if (value !== true) return `External form field must be acknowledged: ${field.key}`
@@ -268,7 +264,7 @@ function matches(when: Form.When, value: Form.Value | undefined) {
 // carry a value matching that field's type, and use a declared option when the field's options
 // are closed. Rejecting these at creation surfaces authoring mistakes to the caller instead of
 // silently never matching.
-export function validateFields(fields: ReadonlyArray<Form.Field>) {
+function validateFields(fields: ReadonlyArray<Form.Field>) {
   if (fields.length === 0) return "Form must have at least one field"
   const earlier = new Map<string, InputField>()
   const keys = new Set<string>()

packages/core/src/instruction-discovery.ts

@@ -18,7 +18,7 @@ const Files = Schema.Array(File)
 const key = Instructions.Key.make("core/instructions")
 
 export interface Interface {
-  readonly load: () => Effect.Effect<Instructions.Instructions>
+  readonly load: () => Effect.Effect<Instructions.List>
 }
 
 export const Options = Schema.Struct({

packages/core/src/instructions/builtins.ts

@@ -8,7 +8,7 @@ import { SessionSchema } from "../session/schema"
 import { Instructions } from "./index"
 
 export interface Interface {
-  readonly load: (sessionID: SessionSchema.ID) => Effect.Effect<Instructions.Instructions>
+  readonly load: (sessionID: SessionSchema.ID) => Effect.Effect<Instructions.List>
 }
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/InstructionBuiltIns") {}

packages/core/src/instructions/index.ts

@@ -53,7 +53,7 @@ export declare namespace Source {
 }
 
 /** Ordered sources; identical values render identical bytes. */
-export type Instructions = ReadonlyArray<Source>
+export type List = ReadonlyArray<Source>
 
 export type ReadResult = ReadonlyArray<{
   readonly key: Key
@@ -82,10 +82,10 @@ export class DuplicateKeyError extends Schema.TaggedErrorClass<DuplicateKeyError
   }
 }
 
-export const empty: Instructions = []
+export const empty: List = []
 
 /** Closes a typed definition into one `Source`, so differently typed sources compose. */
-export function make<A>(source: Source.Definition<A>): Instructions {
+export function make<A>(source: Source.Definition<A>): List {
   const decode = Schema.decodeUnknownOption(source.codec)
   const encode = Schema.encodeSync(source.codec)
   const initial = (value: A) => requireText(source.key, "initial", source.render.initial(value))
@@ -121,7 +121,7 @@ export function make<A>(source: Source.Definition<A>): Instructions {
   ]
 }
 
-export function combine(values: ReadonlyArray<Instructions>): Instructions {
+export function combine(values: ReadonlyArray<List>): List {
   const sources = values.flat()
   const keys = new Set<Key>()
   for (const source of sources) {
@@ -131,7 +131,7 @@ export function combine(values: ReadonlyArray<Instructions>): Instructions {
   return sources
 }
 
-export function read(value: Instructions): Effect.Effect<ReadResult> {
+export function read(value: List): Effect.Effect<ReadResult> {
   return Effect.forEach(
     value,
     (source) => source.read.pipe(Effect.map((observed) => ({ key: source.key, value: observed }))),
@@ -158,7 +158,7 @@ export function diff(observed: ReadResult, previous?: Values): Effect.Effect<Adm
   return Effect.succeed({ delta, blobs })
 }
 
-export function renderInitial(value: Instructions, values: Readonly<Record<string, Schema.Json>>) {
+export function renderInitial(value: List, values: Readonly<Record<string, Schema.Json>>) {
   return render(
     value.flatMap((source) => {
       if (!Object.hasOwn(values, source.key)) return []
@@ -169,7 +169,7 @@ export function renderInitial(value: Instructions, values: Readonly<Record<strin
 }
 
 export function renderUpdate(
-  value: Instructions,
+  value: List,
   previous: Readonly<Record<string, Schema.Json>>,
   delta: Readonly<Record<string, Option.Option<Schema.Json>>>,
 ) {

packages/core/src/integration.ts

@@ -24,7 +24,6 @@ import { Bus } from "./bus"
 import { IntegrationConnection } from "./integration/connection"
 import { AppProcess } from "@opencode-ai/util/process"
 import { ChildProcess } from "effect/unstable/process"
-import { Form } from "./form"
 
 export const ID = Integration.ID
 export type ID = Integration.ID
@@ -35,6 +34,18 @@ export type MethodID = Integration.MethodID
 export const AttemptID = Integration.AttemptID
 export type AttemptID = typeof AttemptID.Type
 
+export const When = Integration.When
+export type When = Integration.When
+
+export const TextPrompt = Integration.TextPrompt
+export type TextPrompt = Integration.TextPrompt
+
+export const SelectPrompt = Integration.SelectPrompt
+export type SelectPrompt = Integration.SelectPrompt
+
+export const Prompt = Integration.Prompt
+export type Prompt = Integration.Prompt
+
 export const OAuthMethod = Integration.OAuthMethod
 export type OAuthMethod = Integration.OAuthMethod
 
@@ -53,6 +64,9 @@ export type Method = Integration.Method
 export const Info = Integration.Info
 export type Info = Integration.Info
 
+export const Inputs = Integration.Inputs
+export type Inputs = Integration.Inputs
+
 export type OAuthAuthorization = {
   readonly url: string
   readonly instructions: string
@@ -71,7 +85,7 @@ export type OAuthAuthorization = {
 export interface OAuthImplementation {
   readonly integrationID: ID
   readonly method: OAuthMethod
-  readonly authorize: (answers: Form.Answer) => Effect.Effect<OAuthAuthorization, unknown, Scope.Scope>
+  readonly authorize: (inputs: Inputs) => Effect.Effect<OAuthAuthorization, unknown, Scope.Scope>
   readonly refresh?: (credential: Credential.OAuth) => Effect.Effect<Credential.OAuth, unknown>
   readonly label?: (credential: Credential.OAuth) => string | undefined
 }
@@ -161,8 +175,6 @@ export interface Interface extends State.Transformable<Draft> {
       readonly integrationID: ID
       /** Secret entered by the user. */
       readonly key: string
-      /** Values collected from the method's form fields. */
-      readonly answers: Form.Answer
       /** User-facing label for the stored credential. */
       readonly label?: string
     }) => Effect.Effect<void, AuthorizationError>
@@ -179,7 +191,7 @@ export interface Interface extends State.Transformable<Draft> {
     readonly connect: (input: {
       readonly integrationID: ID
       readonly methodID: MethodID
-      readonly answers: Form.Answer
+      readonly inputs: Inputs
       readonly label?: string
     }) => Effect.Effect<Attempt, AuthorizationError>
     /** Returns the current state of an OAuth attempt. */
@@ -344,7 +356,7 @@ const layer = Layer.effect(
       return [...credentials, ...env]
     }
 
-    const project = (entry: Entry, connections: IntegrationConnection.Info[]): Info =>
+    const project = (entry: Entry, connections: IntegrationConnection.Info[]) =>
       Info.make({
         id: entry.ref.id,
         name: entry.ref.name,
@@ -535,20 +547,15 @@ const layer = Layer.effect(
     const connectOAuth = Effect.fn("Integration.oauth.connect")(function* (input: {
       readonly integrationID: ID
       readonly methodID: MethodID
-      readonly answers: Form.Answer
+      readonly inputs: Inputs
       readonly label?: string
     }) {
       const method = state.get().integrations.get(input.integrationID)?.implementations.get(input.methodID)
       if (!method) {
         return yield* Effect.die(new Error(`OAuth method not found: ${input.integrationID}/${input.methodID}`))
       }
-      if (method.method.forms) {
-        const invalid =
-          Form.validateFields(method.method.forms) ?? Form.validateAnswer(method.method.forms, input.answers)
-        if (invalid) return yield* new AuthorizationError({ cause: new Error(invalid) })
-      }
       const attemptScope = yield* Scope.fork(scope)
-      const authorization = yield* authorize(method.authorize(input.answers)).pipe(
+      const authorization = yield* authorize(method.authorize(input.inputs)).pipe(
         Scope.provide(attemptScope),
         Effect.onExit((exit) => (Exit.isFailure(exit) ? Scope.close(attemptScope, exit) : Effect.void)),
       )
@@ -692,23 +699,12 @@ const layer = Layer.effect(
           const method = state
             .get()
             .integrations.get(input.integrationID)
-            ?.methods.find((method) => method.type === "key")
+            ?.methods.some((method) => method.type === "key")
           if (!method) return yield* Effect.die(new Error(`Key method not found: ${input.integrationID}`))
-          if (method.type === "key" && method.forms) {
-            const invalid = Form.validateFields(method.forms) ?? Form.validateAnswer(method.forms, input.answers)
-            if (invalid) return yield* new AuthorizationError({ cause: new Error(invalid) })
-          }
-          if (method.type === "key" && !method.forms && Object.keys(input.answers).length > 0) {
-            return yield* new AuthorizationError({ cause: new Error("Key method does not accept form answers") })
-          }
           yield* credentials.create({
             integrationID: input.integrationID,
             label: input.label,
-            value: Credential.Key.make({
-              type: "key",
-              key: input.key,
-              ...(Object.keys(input.answers).length > 0 ? { configuration: input.answers } : {}),
-            }),
+            value: Credential.Key.make({ type: "key", key: input.key }),
           })
           yield* bus.publish(Integration.Event.ConnectionUpdated, { integrationID: input.integrationID })
           yield* bus.publish(Integration.Event.Updated, {})

packages/core/src/location-services.ts

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

packages/core/src/mcp/instructions.ts

@@ -55,7 +55,7 @@ const update = (previous: ReadonlyArray<Summary>, current: ReadonlyArray<Summary
 }
 
 export interface Interface {
-  readonly load: (agent: Agent.Selection) => Effect.Effect<Instructions.Instructions>
+  readonly load: (agent: Agent.Selection) => Effect.Effect<Instructions.List>
 }
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/McpInstructions") {}

packages/core/src/model-resolver.ts

@@ -149,7 +149,6 @@ export const fromCatalogModel = (
   })
   const packageName = Provider.packageName(resolved.package)
   const key = apiKey(resolved, credential)
-  const configuration = credential?.type === "key" ? credential.configuration : undefined
 
   if (Provider.isAISDK(resolved.package) && packageName === "@ai-sdk/openai") {
     return Effect.succeed(
@@ -176,7 +175,7 @@ export const fromCatalogModel = (
         .model({ id: resolved.modelID ?? resolved.id, compatibility: resolved.compatibility }),
     )
   }
-  const configured = { ...resolved.settings, ...credential?.metadata, ...configuration }
+  const configured = { ...resolved.settings, ...credential?.metadata }
   const mapping = Provider.isAISDK(resolved.package)
     ? AISDKNative.map({
         packageName,
@@ -191,7 +190,6 @@ export const fromCatalogModel = (
       draft.settings = Provider.mergeOverlay(draft.settings, {
         ...nativeCredentialSettings(resolved.package ?? "", credential),
         ...credential?.metadata,
-        ...configuration,
       })
     })
     return dependencies.loadAISDK(runtime).pipe(Effect.mapError(() => unsupported(resolved)))

packages/core/src/plugin/host.ts

@@ -47,13 +47,17 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: import("../p
       workspaceID: location.workspaceID,
       project: location.project,
     })
-  const locationRef = (input?: { readonly location?: { readonly directory?: string; readonly workspace?: string } }) =>
+  const locationRef = (input?: {
+    readonly location?: { readonly directory?: string; readonly workspace?: string }
+  }) =>
     input?.location === undefined
       ? undefined
       : Location.Ref.make({
           directory: AbsolutePath.make(input.location.directory ?? location.directory),
           workspaceID:
-            input.location.workspace === undefined ? location.workspaceID : Workspace.ID.make(input.location.workspace),
+            input.location.workspace === undefined
+              ? location.workspaceID
+              : Workspace.ID.make(input.location.workspace),
         })
   const isCurrentLocation = (ref: Location.Ref) =>
     ref.directory === location.directory && ref.workspaceID === location.workspaceID
@@ -70,12 +74,7 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: import("../p
           ref && !isCurrentLocation(ref)
             ? runtime.location.agent
                 .list(ref)
-                .pipe(
-                  Effect.map((result) => ({
-                    ...result,
-                    data: result.data.find((agent) => agent.id === input.agentID),
-                  })),
-                )
+                .pipe(Effect.map((result) => ({ ...result, data: result.data.find((agent) => agent.id === input.agentID) })))
             : response(agents.get(input.agentID))
         return output.pipe(
           Effect.flatMap((result) =>
@@ -163,7 +162,8 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: import("../p
                 mutable(draft.model.get(Provider.ID.make(providerID), Model.ID.make(modelID))),
               update: (providerID, modelID, update) =>
                 draft.model.update(Provider.ID.make(providerID), Model.ID.make(modelID), update),
-              remove: (providerID, modelID) => draft.model.remove(Provider.ID.make(providerID), Model.ID.make(modelID)),
+              remove: (providerID, modelID) =>
+                draft.model.remove(Provider.ID.make(providerID), Model.ID.make(modelID)),
               default: {
                 get: draft.model.default.get,
                 set: (providerID, modelID) =>
@@ -192,7 +192,6 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: import("../p
           integration.connection.key({
             integrationID: Integration.ID.make(input.integrationID),
             key: input.key,
-            answers: input.answers,
             label: input.label,
           }),
       },
@@ -202,7 +201,7 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: import("../p
             integration.oauth.connect({
               integrationID: Integration.ID.make(input.integrationID),
               methodID: Integration.MethodID.make(input.methodID),
-              answers: input.answers,
+              inputs: input.inputs,
               label: input.label,
             }),
           ),
@@ -365,14 +364,9 @@ function methodImplementation(input: IntegrationMethodRegistration): Integration
     const refresh = input.refresh
     return {
       integrationID: Integration.ID.make(input.integrationID),
-      method: Schema.decodeUnknownSync(Integration.OAuthMethod)({
-        id: Integration.MethodID.make(input.method.id),
-        type: "oauth",
-        label: input.method.label,
-        ...(input.method.forms === undefined ? {} : { forms: input.method.forms }),
-      }),
-      authorize: (answers) =>
-        input.authorize(answers).pipe(
+      method: { ...input.method, id: Integration.MethodID.make(input.method.id) },
+      authorize: (inputs) =>
+        input.authorize(inputs).pipe(
           Effect.map((authorization) => {
             if (authorization.mode === "auto") {
               return {
@@ -404,11 +398,7 @@ function methodImplementation(input: IntegrationMethodRegistration): Integration
   }
   return {
     integrationID: Integration.ID.make(input.integrationID),
-    method: Schema.decodeUnknownSync(Integration.KeyMethod)({
-      type: "key",
-      ...(input.method.label === undefined ? {} : { label: input.method.label }),
-      ...(input.method.forms === undefined ? {} : { forms: input.method.forms }),
-    }),
+    method: { type: "key", label: input.method.label },
   }
 }
 

packages/core/src/plugin/internal.ts

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